This fixes parsing a file containing ELF attributes with very large tag values.
[deliverable/binutils-gdb.git] / bfd / elfxx-mips.c
CommitLineData
b49e97c9 1/* MIPS-specific support for ELF
b90efa5b 2 Copyright (C) 1993-2015 Free Software Foundation, Inc.
b49e97c9
TS
3
4 Most of the information added by Ian Lance Taylor, Cygnus Support,
5 <ian@cygnus.com>.
6 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
7 <mark@codesourcery.com>
8 Traditional MIPS targets support added by Koundinya.K, Dansk Data
9 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
10
ae9a127f 11 This file is part of BFD, the Binary File Descriptor library.
b49e97c9 12
ae9a127f
NC
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
cd123cb7 15 the Free Software Foundation; either version 3 of the License, or
ae9a127f 16 (at your option) any later version.
b49e97c9 17
ae9a127f
NC
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
b49e97c9 22
ae9a127f
NC
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
cd123cb7
NC
25 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
26 MA 02110-1301, USA. */
27
b49e97c9
TS
28
29/* This file handles functionality common to the different MIPS ABI's. */
30
b49e97c9 31#include "sysdep.h"
3db64b00 32#include "bfd.h"
b49e97c9 33#include "libbfd.h"
64543e1a 34#include "libiberty.h"
b49e97c9
TS
35#include "elf-bfd.h"
36#include "elfxx-mips.h"
37#include "elf/mips.h"
0a44bf69 38#include "elf-vxworks.h"
2f0c68f2 39#include "dwarf2.h"
b49e97c9
TS
40
41/* Get the ECOFF swapping routines. */
42#include "coff/sym.h"
43#include "coff/symconst.h"
44#include "coff/ecoff.h"
45#include "coff/mips.h"
46
b15e6682
AO
47#include "hashtab.h"
48
9ab066b4
RS
49/* Types of TLS GOT entry. */
50enum mips_got_tls_type {
51 GOT_TLS_NONE,
52 GOT_TLS_GD,
53 GOT_TLS_LDM,
54 GOT_TLS_IE
55};
56
ead49a57 57/* This structure is used to hold information about one GOT entry.
3dff0dd1
RS
58 There are four types of entry:
59
60 (1) an absolute address
61 requires: abfd == NULL
62 fields: d.address
63
64 (2) a SYMBOL + OFFSET address, where SYMBOL is local to an input bfd
65 requires: abfd != NULL, symndx >= 0, tls_type != GOT_TLS_LDM
66 fields: abfd, symndx, d.addend, tls_type
67
68 (3) a SYMBOL address, where SYMBOL is not local to an input bfd
69 requires: abfd != NULL, symndx == -1
70 fields: d.h, tls_type
71
72 (4) a TLS LDM slot
73 requires: abfd != NULL, symndx == 0, tls_type == GOT_TLS_LDM
74 fields: none; there's only one of these per GOT. */
b15e6682
AO
75struct mips_got_entry
76{
3dff0dd1 77 /* One input bfd that needs the GOT entry. */
b15e6682 78 bfd *abfd;
f4416af6
AO
79 /* The index of the symbol, as stored in the relocation r_info, if
80 we have a local symbol; -1 otherwise. */
81 long symndx;
82 union
83 {
84 /* If abfd == NULL, an address that must be stored in the got. */
85 bfd_vma address;
86 /* If abfd != NULL && symndx != -1, the addend of the relocation
87 that should be added to the symbol value. */
88 bfd_vma addend;
89 /* If abfd != NULL && symndx == -1, the hash table entry
3dff0dd1 90 corresponding to a symbol in the GOT. The symbol's entry
020d7251
RS
91 is in the local area if h->global_got_area is GGA_NONE,
92 otherwise it is in the global area. */
f4416af6
AO
93 struct mips_elf_link_hash_entry *h;
94 } d;
0f20cc35 95
9ab066b4
RS
96 /* The TLS type of this GOT entry. An LDM GOT entry will be a local
97 symbol entry with r_symndx == 0. */
0f20cc35
DJ
98 unsigned char tls_type;
99
9ab066b4
RS
100 /* True if we have filled in the GOT contents for a TLS entry,
101 and created the associated relocations. */
102 unsigned char tls_initialized;
103
b15e6682 104 /* The offset from the beginning of the .got section to the entry
f4416af6
AO
105 corresponding to this symbol+addend. If it's a global symbol
106 whose offset is yet to be decided, it's going to be -1. */
107 long gotidx;
b15e6682
AO
108};
109
13db6b44
RS
110/* This structure represents a GOT page reference from an input bfd.
111 Each instance represents a symbol + ADDEND, where the representation
112 of the symbol depends on whether it is local to the input bfd.
113 If it is, then SYMNDX >= 0, and the symbol has index SYMNDX in U.ABFD.
114 Otherwise, SYMNDX < 0 and U.H points to the symbol's hash table entry.
115
116 Page references with SYMNDX >= 0 always become page references
117 in the output. Page references with SYMNDX < 0 only become page
118 references if the symbol binds locally; in other cases, the page
119 reference decays to a global GOT reference. */
120struct mips_got_page_ref
121{
122 long symndx;
123 union
124 {
125 struct mips_elf_link_hash_entry *h;
126 bfd *abfd;
127 } u;
128 bfd_vma addend;
129};
130
c224138d
RS
131/* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
132 The structures form a non-overlapping list that is sorted by increasing
133 MIN_ADDEND. */
134struct mips_got_page_range
135{
136 struct mips_got_page_range *next;
137 bfd_signed_vma min_addend;
138 bfd_signed_vma max_addend;
139};
140
141/* This structure describes the range of addends that are applied to page
13db6b44 142 relocations against a given section. */
c224138d
RS
143struct mips_got_page_entry
144{
13db6b44
RS
145 /* The section that these entries are based on. */
146 asection *sec;
c224138d
RS
147 /* The ranges for this page entry. */
148 struct mips_got_page_range *ranges;
149 /* The maximum number of page entries needed for RANGES. */
150 bfd_vma num_pages;
151};
152
f0abc2a1 153/* This structure is used to hold .got information when linking. */
b49e97c9
TS
154
155struct mips_got_info
156{
b49e97c9
TS
157 /* The number of global .got entries. */
158 unsigned int global_gotno;
23cc69b6
RS
159 /* The number of global .got entries that are in the GGA_RELOC_ONLY area. */
160 unsigned int reloc_only_gotno;
0f20cc35
DJ
161 /* The number of .got slots used for TLS. */
162 unsigned int tls_gotno;
163 /* The first unused TLS .got entry. Used only during
164 mips_elf_initialize_tls_index. */
165 unsigned int tls_assigned_gotno;
c224138d 166 /* The number of local .got entries, eventually including page entries. */
b49e97c9 167 unsigned int local_gotno;
c224138d
RS
168 /* The maximum number of page entries needed. */
169 unsigned int page_gotno;
ab361d49
RS
170 /* The number of relocations needed for the GOT entries. */
171 unsigned int relocs;
cb22ccf4
KCY
172 /* The first unused local .got entry. */
173 unsigned int assigned_low_gotno;
174 /* The last unused local .got entry. */
175 unsigned int assigned_high_gotno;
b15e6682
AO
176 /* A hash table holding members of the got. */
177 struct htab *got_entries;
13db6b44
RS
178 /* A hash table holding mips_got_page_ref structures. */
179 struct htab *got_page_refs;
c224138d
RS
180 /* A hash table of mips_got_page_entry structures. */
181 struct htab *got_page_entries;
f4416af6
AO
182 /* In multi-got links, a pointer to the next got (err, rather, most
183 of the time, it points to the previous got). */
184 struct mips_got_info *next;
185};
186
d7206569 187/* Structure passed when merging bfds' gots. */
f4416af6
AO
188
189struct mips_elf_got_per_bfd_arg
190{
f4416af6
AO
191 /* The output bfd. */
192 bfd *obfd;
193 /* The link information. */
194 struct bfd_link_info *info;
195 /* A pointer to the primary got, i.e., the one that's going to get
196 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
197 DT_MIPS_GOTSYM. */
198 struct mips_got_info *primary;
199 /* A non-primary got we're trying to merge with other input bfd's
200 gots. */
201 struct mips_got_info *current;
202 /* The maximum number of got entries that can be addressed with a
203 16-bit offset. */
204 unsigned int max_count;
c224138d
RS
205 /* The maximum number of page entries needed by each got. */
206 unsigned int max_pages;
0f20cc35
DJ
207 /* The total number of global entries which will live in the
208 primary got and be automatically relocated. This includes
209 those not referenced by the primary GOT but included in
210 the "master" GOT. */
211 unsigned int global_count;
f4416af6
AO
212};
213
ab361d49
RS
214/* A structure used to pass information to htab_traverse callbacks
215 when laying out the GOT. */
f4416af6 216
ab361d49 217struct mips_elf_traverse_got_arg
f4416af6 218{
ab361d49 219 struct bfd_link_info *info;
f4416af6
AO
220 struct mips_got_info *g;
221 int value;
0f20cc35
DJ
222};
223
f0abc2a1
AM
224struct _mips_elf_section_data
225{
226 struct bfd_elf_section_data elf;
227 union
228 {
f0abc2a1
AM
229 bfd_byte *tdata;
230 } u;
231};
232
233#define mips_elf_section_data(sec) \
68bfbfcc 234 ((struct _mips_elf_section_data *) elf_section_data (sec))
f0abc2a1 235
d5eaccd7
RS
236#define is_mips_elf(bfd) \
237 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
238 && elf_tdata (bfd) != NULL \
4dfe6ac6 239 && elf_object_id (bfd) == MIPS_ELF_DATA)
d5eaccd7 240
634835ae
RS
241/* The ABI says that every symbol used by dynamic relocations must have
242 a global GOT entry. Among other things, this provides the dynamic
243 linker with a free, directly-indexed cache. The GOT can therefore
244 contain symbols that are not referenced by GOT relocations themselves
245 (in other words, it may have symbols that are not referenced by things
246 like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
247
248 GOT relocations are less likely to overflow if we put the associated
249 GOT entries towards the beginning. We therefore divide the global
250 GOT entries into two areas: "normal" and "reloc-only". Entries in
251 the first area can be used for both dynamic relocations and GP-relative
252 accesses, while those in the "reloc-only" area are for dynamic
253 relocations only.
254
255 These GGA_* ("Global GOT Area") values are organised so that lower
256 values are more general than higher values. Also, non-GGA_NONE
257 values are ordered by the position of the area in the GOT. */
258#define GGA_NORMAL 0
259#define GGA_RELOC_ONLY 1
260#define GGA_NONE 2
261
861fb55a
DJ
262/* Information about a non-PIC interface to a PIC function. There are
263 two ways of creating these interfaces. The first is to add:
264
265 lui $25,%hi(func)
266 addiu $25,$25,%lo(func)
267
268 immediately before a PIC function "func". The second is to add:
269
270 lui $25,%hi(func)
271 j func
272 addiu $25,$25,%lo(func)
273
274 to a separate trampoline section.
275
276 Stubs of the first kind go in a new section immediately before the
277 target function. Stubs of the second kind go in a single section
278 pointed to by the hash table's "strampoline" field. */
279struct mips_elf_la25_stub {
280 /* The generated section that contains this stub. */
281 asection *stub_section;
282
283 /* The offset of the stub from the start of STUB_SECTION. */
284 bfd_vma offset;
285
286 /* One symbol for the original function. Its location is available
287 in H->root.root.u.def. */
288 struct mips_elf_link_hash_entry *h;
289};
290
291/* Macros for populating a mips_elf_la25_stub. */
292
293#define LA25_LUI(VAL) (0x3c190000 | (VAL)) /* lui t9,VAL */
294#define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
295#define LA25_ADDIU(VAL) (0x27390000 | (VAL)) /* addiu t9,t9,VAL */
d21911ea
MR
296#define LA25_LUI_MICROMIPS(VAL) \
297 (0x41b90000 | (VAL)) /* lui t9,VAL */
298#define LA25_J_MICROMIPS(VAL) \
299 (0xd4000000 | (((VAL) >> 1) & 0x3ffffff)) /* j VAL */
300#define LA25_ADDIU_MICROMIPS(VAL) \
301 (0x33390000 | (VAL)) /* addiu t9,t9,VAL */
861fb55a 302
b49e97c9
TS
303/* This structure is passed to mips_elf_sort_hash_table_f when sorting
304 the dynamic symbols. */
305
306struct mips_elf_hash_sort_data
307{
308 /* The symbol in the global GOT with the lowest dynamic symbol table
309 index. */
310 struct elf_link_hash_entry *low;
0f20cc35
DJ
311 /* The least dynamic symbol table index corresponding to a non-TLS
312 symbol with a GOT entry. */
b49e97c9 313 long min_got_dynindx;
f4416af6
AO
314 /* The greatest dynamic symbol table index corresponding to a symbol
315 with a GOT entry that is not referenced (e.g., a dynamic symbol
9e4aeb93 316 with dynamic relocations pointing to it from non-primary GOTs). */
f4416af6 317 long max_unref_got_dynindx;
b49e97c9
TS
318 /* The greatest dynamic symbol table index not corresponding to a
319 symbol without a GOT entry. */
320 long max_non_got_dynindx;
321};
322
1bbce132
MR
323/* We make up to two PLT entries if needed, one for standard MIPS code
324 and one for compressed code, either a MIPS16 or microMIPS one. We
325 keep a separate record of traditional lazy-binding stubs, for easier
326 processing. */
327
328struct plt_entry
329{
330 /* Traditional SVR4 stub offset, or -1 if none. */
331 bfd_vma stub_offset;
332
333 /* Standard PLT entry offset, or -1 if none. */
334 bfd_vma mips_offset;
335
336 /* Compressed PLT entry offset, or -1 if none. */
337 bfd_vma comp_offset;
338
339 /* The corresponding .got.plt index, or -1 if none. */
340 bfd_vma gotplt_index;
341
342 /* Whether we need a standard PLT entry. */
343 unsigned int need_mips : 1;
344
345 /* Whether we need a compressed PLT entry. */
346 unsigned int need_comp : 1;
347};
348
b49e97c9
TS
349/* The MIPS ELF linker needs additional information for each symbol in
350 the global hash table. */
351
352struct mips_elf_link_hash_entry
353{
354 struct elf_link_hash_entry root;
355
356 /* External symbol information. */
357 EXTR esym;
358
861fb55a
DJ
359 /* The la25 stub we have created for ths symbol, if any. */
360 struct mips_elf_la25_stub *la25_stub;
361
b49e97c9
TS
362 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
363 this symbol. */
364 unsigned int possibly_dynamic_relocs;
365
b49e97c9
TS
366 /* If there is a stub that 32 bit functions should use to call this
367 16 bit function, this points to the section containing the stub. */
368 asection *fn_stub;
369
b49e97c9
TS
370 /* If there is a stub that 16 bit functions should use to call this
371 32 bit function, this points to the section containing the stub. */
372 asection *call_stub;
373
374 /* This is like the call_stub field, but it is used if the function
375 being called returns a floating point value. */
376 asection *call_fp_stub;
7c5fcef7 377
634835ae
RS
378 /* The highest GGA_* value that satisfies all references to this symbol. */
379 unsigned int global_got_area : 2;
380
6ccf4795
RS
381 /* True if all GOT relocations against this symbol are for calls. This is
382 a looser condition than no_fn_stub below, because there may be other
383 non-call non-GOT relocations against the symbol. */
384 unsigned int got_only_for_calls : 1;
385
71782a75
RS
386 /* True if one of the relocations described by possibly_dynamic_relocs
387 is against a readonly section. */
388 unsigned int readonly_reloc : 1;
389
861fb55a
DJ
390 /* True if there is a relocation against this symbol that must be
391 resolved by the static linker (in other words, if the relocation
392 cannot possibly be made dynamic). */
393 unsigned int has_static_relocs : 1;
394
71782a75
RS
395 /* True if we must not create a .MIPS.stubs entry for this symbol.
396 This is set, for example, if there are relocations related to
397 taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
398 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */
399 unsigned int no_fn_stub : 1;
400
401 /* Whether we need the fn_stub; this is true if this symbol appears
402 in any relocs other than a 16 bit call. */
403 unsigned int need_fn_stub : 1;
404
861fb55a
DJ
405 /* True if this symbol is referenced by branch relocations from
406 any non-PIC input file. This is used to determine whether an
407 la25 stub is required. */
408 unsigned int has_nonpic_branches : 1;
33bb52fb
RS
409
410 /* Does this symbol need a traditional MIPS lazy-binding stub
411 (as opposed to a PLT entry)? */
412 unsigned int needs_lazy_stub : 1;
1bbce132
MR
413
414 /* Does this symbol resolve to a PLT entry? */
415 unsigned int use_plt_entry : 1;
b49e97c9
TS
416};
417
418/* MIPS ELF linker hash table. */
419
420struct mips_elf_link_hash_table
421{
422 struct elf_link_hash_table root;
861fb55a 423
b49e97c9
TS
424 /* The number of .rtproc entries. */
425 bfd_size_type procedure_count;
861fb55a 426
b49e97c9
TS
427 /* The size of the .compact_rel section (if SGI_COMPAT). */
428 bfd_size_type compact_rel_size;
861fb55a 429
e6aea42d
MR
430 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry
431 is set to the address of __rld_obj_head as in IRIX5 and IRIX6. */
b34976b6 432 bfd_boolean use_rld_obj_head;
861fb55a 433
b4082c70
DD
434 /* The __rld_map or __rld_obj_head symbol. */
435 struct elf_link_hash_entry *rld_symbol;
861fb55a 436
b49e97c9 437 /* This is set if we see any mips16 stub sections. */
b34976b6 438 bfd_boolean mips16_stubs_seen;
861fb55a
DJ
439
440 /* True if we can generate copy relocs and PLTs. */
441 bfd_boolean use_plts_and_copy_relocs;
442
833794fc
MR
443 /* True if we can only use 32-bit microMIPS instructions. */
444 bfd_boolean insn32;
445
0a44bf69
RS
446 /* True if we're generating code for VxWorks. */
447 bfd_boolean is_vxworks;
861fb55a 448
0e53d9da
AN
449 /* True if we already reported the small-data section overflow. */
450 bfd_boolean small_data_overflow_reported;
861fb55a 451
0a44bf69
RS
452 /* Shortcuts to some dynamic sections, or NULL if they are not
453 being used. */
454 asection *srelbss;
455 asection *sdynbss;
456 asection *srelplt;
457 asection *srelplt2;
458 asection *sgotplt;
459 asection *splt;
4e41d0d7 460 asection *sstubs;
a8028dd0 461 asection *sgot;
861fb55a 462
a8028dd0
RS
463 /* The master GOT information. */
464 struct mips_got_info *got_info;
861fb55a 465
d222d210
RS
466 /* The global symbol in the GOT with the lowest index in the dynamic
467 symbol table. */
468 struct elf_link_hash_entry *global_gotsym;
469
861fb55a 470 /* The size of the PLT header in bytes. */
0a44bf69 471 bfd_vma plt_header_size;
861fb55a 472
1bbce132
MR
473 /* The size of a standard PLT entry in bytes. */
474 bfd_vma plt_mips_entry_size;
475
476 /* The size of a compressed PLT entry in bytes. */
477 bfd_vma plt_comp_entry_size;
478
479 /* The offset of the next standard PLT entry to create. */
480 bfd_vma plt_mips_offset;
481
482 /* The offset of the next compressed PLT entry to create. */
483 bfd_vma plt_comp_offset;
484
485 /* The index of the next .got.plt entry to create. */
486 bfd_vma plt_got_index;
861fb55a 487
33bb52fb
RS
488 /* The number of functions that need a lazy-binding stub. */
489 bfd_vma lazy_stub_count;
861fb55a 490
5108fc1b
RS
491 /* The size of a function stub entry in bytes. */
492 bfd_vma function_stub_size;
861fb55a
DJ
493
494 /* The number of reserved entries at the beginning of the GOT. */
495 unsigned int reserved_gotno;
496
497 /* The section used for mips_elf_la25_stub trampolines.
498 See the comment above that structure for details. */
499 asection *strampoline;
500
501 /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
502 pairs. */
503 htab_t la25_stubs;
504
505 /* A function FN (NAME, IS, OS) that creates a new input section
506 called NAME and links it to output section OS. If IS is nonnull,
507 the new section should go immediately before it, otherwise it
508 should go at the (current) beginning of OS.
509
510 The function returns the new section on success, otherwise it
511 returns null. */
512 asection *(*add_stub_section) (const char *, asection *, asection *);
13db6b44
RS
513
514 /* Small local sym cache. */
515 struct sym_cache sym_cache;
1bbce132
MR
516
517 /* Is the PLT header compressed? */
518 unsigned int plt_header_is_comp : 1;
861fb55a
DJ
519};
520
4dfe6ac6
NC
521/* Get the MIPS ELF linker hash table from a link_info structure. */
522
523#define mips_elf_hash_table(p) \
524 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
525 == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
526
861fb55a 527/* A structure used to communicate with htab_traverse callbacks. */
4dfe6ac6
NC
528struct mips_htab_traverse_info
529{
861fb55a
DJ
530 /* The usual link-wide information. */
531 struct bfd_link_info *info;
532 bfd *output_bfd;
533
534 /* Starts off FALSE and is set to TRUE if the link should be aborted. */
535 bfd_boolean error;
b49e97c9
TS
536};
537
6ae68ba3
MR
538/* MIPS ELF private object data. */
539
540struct mips_elf_obj_tdata
541{
542 /* Generic ELF private object data. */
543 struct elf_obj_tdata root;
544
545 /* Input BFD providing Tag_GNU_MIPS_ABI_FP attribute for output. */
546 bfd *abi_fp_bfd;
ee227692 547
b60bf9be
CF
548 /* Input BFD providing Tag_GNU_MIPS_ABI_MSA attribute for output. */
549 bfd *abi_msa_bfd;
550
351cdf24
MF
551 /* The abiflags for this object. */
552 Elf_Internal_ABIFlags_v0 abiflags;
553 bfd_boolean abiflags_valid;
554
ee227692
RS
555 /* The GOT requirements of input bfds. */
556 struct mips_got_info *got;
698600e4
AM
557
558 /* Used by _bfd_mips_elf_find_nearest_line. The structure could be
559 included directly in this one, but there's no point to wasting
560 the memory just for the infrequently called find_nearest_line. */
561 struct mips_elf_find_line *find_line_info;
562
563 /* An array of stub sections indexed by symbol number. */
564 asection **local_stubs;
565 asection **local_call_stubs;
566
567 /* The Irix 5 support uses two virtual sections, which represent
568 text/data symbols defined in dynamic objects. */
569 asymbol *elf_data_symbol;
570 asymbol *elf_text_symbol;
571 asection *elf_data_section;
572 asection *elf_text_section;
6ae68ba3
MR
573};
574
575/* Get MIPS ELF private object data from BFD's tdata. */
576
577#define mips_elf_tdata(bfd) \
578 ((struct mips_elf_obj_tdata *) (bfd)->tdata.any)
579
0f20cc35
DJ
580#define TLS_RELOC_P(r_type) \
581 (r_type == R_MIPS_TLS_DTPMOD32 \
582 || r_type == R_MIPS_TLS_DTPMOD64 \
583 || r_type == R_MIPS_TLS_DTPREL32 \
584 || r_type == R_MIPS_TLS_DTPREL64 \
585 || r_type == R_MIPS_TLS_GD \
586 || r_type == R_MIPS_TLS_LDM \
587 || r_type == R_MIPS_TLS_DTPREL_HI16 \
588 || r_type == R_MIPS_TLS_DTPREL_LO16 \
589 || r_type == R_MIPS_TLS_GOTTPREL \
590 || r_type == R_MIPS_TLS_TPREL32 \
591 || r_type == R_MIPS_TLS_TPREL64 \
592 || r_type == R_MIPS_TLS_TPREL_HI16 \
df58fc94 593 || r_type == R_MIPS_TLS_TPREL_LO16 \
d0f13682
CLT
594 || r_type == R_MIPS16_TLS_GD \
595 || r_type == R_MIPS16_TLS_LDM \
596 || r_type == R_MIPS16_TLS_DTPREL_HI16 \
597 || r_type == R_MIPS16_TLS_DTPREL_LO16 \
598 || r_type == R_MIPS16_TLS_GOTTPREL \
599 || r_type == R_MIPS16_TLS_TPREL_HI16 \
600 || r_type == R_MIPS16_TLS_TPREL_LO16 \
df58fc94
RS
601 || r_type == R_MICROMIPS_TLS_GD \
602 || r_type == R_MICROMIPS_TLS_LDM \
603 || r_type == R_MICROMIPS_TLS_DTPREL_HI16 \
604 || r_type == R_MICROMIPS_TLS_DTPREL_LO16 \
605 || r_type == R_MICROMIPS_TLS_GOTTPREL \
606 || r_type == R_MICROMIPS_TLS_TPREL_HI16 \
607 || r_type == R_MICROMIPS_TLS_TPREL_LO16)
0f20cc35 608
b49e97c9
TS
609/* Structure used to pass information to mips_elf_output_extsym. */
610
611struct extsym_info
612{
9e4aeb93
RS
613 bfd *abfd;
614 struct bfd_link_info *info;
b49e97c9
TS
615 struct ecoff_debug_info *debug;
616 const struct ecoff_debug_swap *swap;
b34976b6 617 bfd_boolean failed;
b49e97c9
TS
618};
619
8dc1a139 620/* The names of the runtime procedure table symbols used on IRIX5. */
b49e97c9
TS
621
622static const char * const mips_elf_dynsym_rtproc_names[] =
623{
624 "_procedure_table",
625 "_procedure_string_table",
626 "_procedure_table_size",
627 NULL
628};
629
630/* These structures are used to generate the .compact_rel section on
8dc1a139 631 IRIX5. */
b49e97c9
TS
632
633typedef struct
634{
635 unsigned long id1; /* Always one? */
636 unsigned long num; /* Number of compact relocation entries. */
637 unsigned long id2; /* Always two? */
638 unsigned long offset; /* The file offset of the first relocation. */
639 unsigned long reserved0; /* Zero? */
640 unsigned long reserved1; /* Zero? */
641} Elf32_compact_rel;
642
643typedef struct
644{
645 bfd_byte id1[4];
646 bfd_byte num[4];
647 bfd_byte id2[4];
648 bfd_byte offset[4];
649 bfd_byte reserved0[4];
650 bfd_byte reserved1[4];
651} Elf32_External_compact_rel;
652
653typedef struct
654{
655 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
656 unsigned int rtype : 4; /* Relocation types. See below. */
657 unsigned int dist2to : 8;
658 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
659 unsigned long konst; /* KONST field. See below. */
660 unsigned long vaddr; /* VADDR to be relocated. */
661} Elf32_crinfo;
662
663typedef struct
664{
665 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
666 unsigned int rtype : 4; /* Relocation types. See below. */
667 unsigned int dist2to : 8;
668 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
669 unsigned long konst; /* KONST field. See below. */
670} Elf32_crinfo2;
671
672typedef struct
673{
674 bfd_byte info[4];
675 bfd_byte konst[4];
676 bfd_byte vaddr[4];
677} Elf32_External_crinfo;
678
679typedef struct
680{
681 bfd_byte info[4];
682 bfd_byte konst[4];
683} Elf32_External_crinfo2;
684
685/* These are the constants used to swap the bitfields in a crinfo. */
686
687#define CRINFO_CTYPE (0x1)
688#define CRINFO_CTYPE_SH (31)
689#define CRINFO_RTYPE (0xf)
690#define CRINFO_RTYPE_SH (27)
691#define CRINFO_DIST2TO (0xff)
692#define CRINFO_DIST2TO_SH (19)
693#define CRINFO_RELVADDR (0x7ffff)
694#define CRINFO_RELVADDR_SH (0)
695
696/* A compact relocation info has long (3 words) or short (2 words)
697 formats. A short format doesn't have VADDR field and relvaddr
698 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
699#define CRF_MIPS_LONG 1
700#define CRF_MIPS_SHORT 0
701
702/* There are 4 types of compact relocation at least. The value KONST
703 has different meaning for each type:
704
705 (type) (konst)
706 CT_MIPS_REL32 Address in data
707 CT_MIPS_WORD Address in word (XXX)
708 CT_MIPS_GPHI_LO GP - vaddr
709 CT_MIPS_JMPAD Address to jump
710 */
711
712#define CRT_MIPS_REL32 0xa
713#define CRT_MIPS_WORD 0xb
714#define CRT_MIPS_GPHI_LO 0xc
715#define CRT_MIPS_JMPAD 0xd
716
717#define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
718#define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
719#define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
720#define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
721\f
722/* The structure of the runtime procedure descriptor created by the
723 loader for use by the static exception system. */
724
725typedef struct runtime_pdr {
ae9a127f
NC
726 bfd_vma adr; /* Memory address of start of procedure. */
727 long regmask; /* Save register mask. */
728 long regoffset; /* Save register offset. */
729 long fregmask; /* Save floating point register mask. */
730 long fregoffset; /* Save floating point register offset. */
731 long frameoffset; /* Frame size. */
732 short framereg; /* Frame pointer register. */
733 short pcreg; /* Offset or reg of return pc. */
734 long irpss; /* Index into the runtime string table. */
b49e97c9 735 long reserved;
ae9a127f 736 struct exception_info *exception_info;/* Pointer to exception array. */
b49e97c9
TS
737} RPDR, *pRPDR;
738#define cbRPDR sizeof (RPDR)
739#define rpdNil ((pRPDR) 0)
740\f
b15e6682 741static struct mips_got_entry *mips_elf_create_local_got_entry
a8028dd0
RS
742 (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long,
743 struct mips_elf_link_hash_entry *, int);
b34976b6 744static bfd_boolean mips_elf_sort_hash_table_f
9719ad41 745 (struct mips_elf_link_hash_entry *, void *);
9719ad41
RS
746static bfd_vma mips_elf_high
747 (bfd_vma);
b34976b6 748static bfd_boolean mips_elf_create_dynamic_relocation
9719ad41
RS
749 (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
750 struct mips_elf_link_hash_entry *, asection *, bfd_vma,
751 bfd_vma *, asection *);
f4416af6 752static bfd_vma mips_elf_adjust_gp
9719ad41 753 (bfd *, struct mips_got_info *, bfd *);
f4416af6 754
b49e97c9
TS
755/* This will be used when we sort the dynamic relocation records. */
756static bfd *reldyn_sorting_bfd;
757
6d30f5b2
NC
758/* True if ABFD is for CPUs with load interlocking that include
759 non-MIPS1 CPUs and R3900. */
760#define LOAD_INTERLOCKS_P(abfd) \
761 ( ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
762 || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
763
cd8d5a82
CF
764/* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
765 This should be safe for all architectures. We enable this predicate
766 for RM9000 for now. */
767#define JAL_TO_BAL_P(abfd) \
768 ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
769
770/* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
771 This should be safe for all architectures. We enable this predicate for
772 all CPUs. */
773#define JALR_TO_BAL_P(abfd) 1
774
38a7df63
CF
775/* True if ABFD is for CPUs that are faster if JR is converted to B.
776 This should be safe for all architectures. We enable this predicate for
777 all CPUs. */
778#define JR_TO_B_P(abfd) 1
779
861fb55a
DJ
780/* True if ABFD is a PIC object. */
781#define PIC_OBJECT_P(abfd) \
782 ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
783
351cdf24
MF
784/* Nonzero if ABFD is using the O32 ABI. */
785#define ABI_O32_P(abfd) \
786 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
787
b49e97c9 788/* Nonzero if ABFD is using the N32 ABI. */
b49e97c9
TS
789#define ABI_N32_P(abfd) \
790 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
791
4a14403c 792/* Nonzero if ABFD is using the N64 ABI. */
b49e97c9 793#define ABI_64_P(abfd) \
141ff970 794 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
b49e97c9 795
4a14403c
TS
796/* Nonzero if ABFD is using NewABI conventions. */
797#define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
798
e8faf7d1
MR
799/* Nonzero if ABFD has microMIPS code. */
800#define MICROMIPS_P(abfd) \
801 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0)
802
7361da2c
AB
803/* Nonzero if ABFD is MIPS R6. */
804#define MIPSR6_P(abfd) \
805 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6 \
806 || (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
807
4a14403c 808/* The IRIX compatibility level we are striving for. */
b49e97c9
TS
809#define IRIX_COMPAT(abfd) \
810 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
811
b49e97c9
TS
812/* Whether we are trying to be compatible with IRIX at all. */
813#define SGI_COMPAT(abfd) \
814 (IRIX_COMPAT (abfd) != ict_none)
815
816/* The name of the options section. */
817#define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
d80dcc6a 818 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
b49e97c9 819
cc2e31b9
RS
820/* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
821 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
822#define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
823 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
824
351cdf24
MF
825/* True if NAME is the recognized name of any SHT_MIPS_ABIFLAGS section. */
826#define MIPS_ELF_ABIFLAGS_SECTION_NAME_P(NAME) \
827 (strcmp (NAME, ".MIPS.abiflags") == 0)
828
943284cc
DJ
829/* Whether the section is readonly. */
830#define MIPS_ELF_READONLY_SECTION(sec) \
831 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
832 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
833
b49e97c9 834/* The name of the stub section. */
ca07892d 835#define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
b49e97c9
TS
836
837/* The size of an external REL relocation. */
838#define MIPS_ELF_REL_SIZE(abfd) \
839 (get_elf_backend_data (abfd)->s->sizeof_rel)
840
0a44bf69
RS
841/* The size of an external RELA relocation. */
842#define MIPS_ELF_RELA_SIZE(abfd) \
843 (get_elf_backend_data (abfd)->s->sizeof_rela)
844
b49e97c9
TS
845/* The size of an external dynamic table entry. */
846#define MIPS_ELF_DYN_SIZE(abfd) \
847 (get_elf_backend_data (abfd)->s->sizeof_dyn)
848
849/* The size of a GOT entry. */
850#define MIPS_ELF_GOT_SIZE(abfd) \
851 (get_elf_backend_data (abfd)->s->arch_size / 8)
852
b4082c70
DD
853/* The size of the .rld_map section. */
854#define MIPS_ELF_RLD_MAP_SIZE(abfd) \
855 (get_elf_backend_data (abfd)->s->arch_size / 8)
856
b49e97c9
TS
857/* The size of a symbol-table entry. */
858#define MIPS_ELF_SYM_SIZE(abfd) \
859 (get_elf_backend_data (abfd)->s->sizeof_sym)
860
861/* The default alignment for sections, as a power of two. */
862#define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
45d6a902 863 (get_elf_backend_data (abfd)->s->log_file_align)
b49e97c9
TS
864
865/* Get word-sized data. */
866#define MIPS_ELF_GET_WORD(abfd, ptr) \
867 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
868
869/* Put out word-sized data. */
870#define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
871 (ABI_64_P (abfd) \
872 ? bfd_put_64 (abfd, val, ptr) \
873 : bfd_put_32 (abfd, val, ptr))
874
861fb55a
DJ
875/* The opcode for word-sized loads (LW or LD). */
876#define MIPS_ELF_LOAD_WORD(abfd) \
877 (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
878
b49e97c9 879/* Add a dynamic symbol table-entry. */
9719ad41 880#define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
5a580b3a 881 _bfd_elf_add_dynamic_entry (info, tag, val)
b49e97c9
TS
882
883#define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
884 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
885
0a44bf69
RS
886/* The name of the dynamic relocation section. */
887#define MIPS_ELF_REL_DYN_NAME(INFO) \
888 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
889
b49e97c9
TS
890/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
891 from smaller values. Start with zero, widen, *then* decrement. */
892#define MINUS_ONE (((bfd_vma)0) - 1)
c5ae1840 893#define MINUS_TWO (((bfd_vma)0) - 2)
b49e97c9 894
51e38d68
RS
895/* The value to write into got[1] for SVR4 targets, to identify it is
896 a GNU object. The dynamic linker can then use got[1] to store the
897 module pointer. */
898#define MIPS_ELF_GNU_GOT1_MASK(abfd) \
899 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
900
f4416af6 901/* The offset of $gp from the beginning of the .got section. */
0a44bf69
RS
902#define ELF_MIPS_GP_OFFSET(INFO) \
903 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
f4416af6
AO
904
905/* The maximum size of the GOT for it to be addressable using 16-bit
906 offsets from $gp. */
0a44bf69 907#define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
f4416af6 908
6a691779 909/* Instructions which appear in a stub. */
3d6746ca
DD
910#define STUB_LW(abfd) \
911 ((ABI_64_P (abfd) \
912 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
913 : 0x8f998010)) /* lw t9,0x8010(gp) */
914#define STUB_MOVE(abfd) \
915 ((ABI_64_P (abfd) \
916 ? 0x03e0782d /* daddu t7,ra */ \
917 : 0x03e07821)) /* addu t7,ra */
918#define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
919#define STUB_JALR 0x0320f809 /* jalr t9,ra */
5108fc1b
RS
920#define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
921#define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
3d6746ca
DD
922#define STUB_LI16S(abfd, VAL) \
923 ((ABI_64_P (abfd) \
924 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
925 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
926
1bbce132
MR
927/* Likewise for the microMIPS ASE. */
928#define STUB_LW_MICROMIPS(abfd) \
929 (ABI_64_P (abfd) \
930 ? 0xdf3c8010 /* ld t9,0x8010(gp) */ \
931 : 0xff3c8010) /* lw t9,0x8010(gp) */
932#define STUB_MOVE_MICROMIPS 0x0dff /* move t7,ra */
833794fc
MR
933#define STUB_MOVE32_MICROMIPS(abfd) \
934 (ABI_64_P (abfd) \
935 ? 0x581f7950 /* daddu t7,ra,zero */ \
936 : 0x001f7950) /* addu t7,ra,zero */
1bbce132
MR
937#define STUB_LUI_MICROMIPS(VAL) \
938 (0x41b80000 + (VAL)) /* lui t8,VAL */
939#define STUB_JALR_MICROMIPS 0x45d9 /* jalr t9 */
833794fc 940#define STUB_JALR32_MICROMIPS 0x03f90f3c /* jalr ra,t9 */
1bbce132
MR
941#define STUB_ORI_MICROMIPS(VAL) \
942 (0x53180000 + (VAL)) /* ori t8,t8,VAL */
943#define STUB_LI16U_MICROMIPS(VAL) \
944 (0x53000000 + (VAL)) /* ori t8,zero,VAL unsigned */
945#define STUB_LI16S_MICROMIPS(abfd, VAL) \
946 (ABI_64_P (abfd) \
947 ? 0x5f000000 + (VAL) /* daddiu t8,zero,VAL sign extended */ \
948 : 0x33000000 + (VAL)) /* addiu t8,zero,VAL sign extended */
949
5108fc1b
RS
950#define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
951#define MIPS_FUNCTION_STUB_BIG_SIZE 20
1bbce132
MR
952#define MICROMIPS_FUNCTION_STUB_NORMAL_SIZE 12
953#define MICROMIPS_FUNCTION_STUB_BIG_SIZE 16
833794fc
MR
954#define MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE 16
955#define MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE 20
b49e97c9
TS
956
957/* The name of the dynamic interpreter. This is put in the .interp
958 section. */
959
960#define ELF_DYNAMIC_INTERPRETER(abfd) \
961 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
962 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
963 : "/usr/lib/libc.so.1")
964
965#ifdef BFD64
ee6423ed
AO
966#define MNAME(bfd,pre,pos) \
967 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
b49e97c9
TS
968#define ELF_R_SYM(bfd, i) \
969 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
970#define ELF_R_TYPE(bfd, i) \
971 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
972#define ELF_R_INFO(bfd, s, t) \
973 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
974#else
ee6423ed 975#define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
b49e97c9
TS
976#define ELF_R_SYM(bfd, i) \
977 (ELF32_R_SYM (i))
978#define ELF_R_TYPE(bfd, i) \
979 (ELF32_R_TYPE (i))
980#define ELF_R_INFO(bfd, s, t) \
981 (ELF32_R_INFO (s, t))
982#endif
983\f
984 /* The mips16 compiler uses a couple of special sections to handle
985 floating point arguments.
986
987 Section names that look like .mips16.fn.FNNAME contain stubs that
988 copy floating point arguments from the fp regs to the gp regs and
989 then jump to FNNAME. If any 32 bit function calls FNNAME, the
990 call should be redirected to the stub instead. If no 32 bit
991 function calls FNNAME, the stub should be discarded. We need to
992 consider any reference to the function, not just a call, because
993 if the address of the function is taken we will need the stub,
994 since the address might be passed to a 32 bit function.
995
996 Section names that look like .mips16.call.FNNAME contain stubs
997 that copy floating point arguments from the gp regs to the fp
998 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
999 then any 16 bit function that calls FNNAME should be redirected
1000 to the stub instead. If FNNAME is not a 32 bit function, the
1001 stub should be discarded.
1002
1003 .mips16.call.fp.FNNAME sections are similar, but contain stubs
1004 which call FNNAME and then copy the return value from the fp regs
1005 to the gp regs. These stubs store the return value in $18 while
1006 calling FNNAME; any function which might call one of these stubs
1007 must arrange to save $18 around the call. (This case is not
1008 needed for 32 bit functions that call 16 bit functions, because
1009 16 bit functions always return floating point values in both
1010 $f0/$f1 and $2/$3.)
1011
1012 Note that in all cases FNNAME might be defined statically.
1013 Therefore, FNNAME is not used literally. Instead, the relocation
1014 information will indicate which symbol the section is for.
1015
1016 We record any stubs that we find in the symbol table. */
1017
1018#define FN_STUB ".mips16.fn."
1019#define CALL_STUB ".mips16.call."
1020#define CALL_FP_STUB ".mips16.call.fp."
b9d58d71
TS
1021
1022#define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
1023#define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
1024#define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
b49e97c9 1025\f
861fb55a 1026/* The format of the first PLT entry in an O32 executable. */
6d30f5b2
NC
1027static const bfd_vma mips_o32_exec_plt0_entry[] =
1028{
861fb55a
DJ
1029 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */
1030 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */
1031 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
1032 0x031cc023, /* subu $24, $24, $28 */
81f5d455 1033 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
861fb55a
DJ
1034 0x0018c082, /* srl $24, $24, 2 */
1035 0x0320f809, /* jalr $25 */
1036 0x2718fffe /* subu $24, $24, 2 */
1037};
1038
1039/* The format of the first PLT entry in an N32 executable. Different
1040 because gp ($28) is not available; we use t2 ($14) instead. */
6d30f5b2
NC
1041static const bfd_vma mips_n32_exec_plt0_entry[] =
1042{
861fb55a
DJ
1043 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1044 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */
1045 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1046 0x030ec023, /* subu $24, $24, $14 */
81f5d455 1047 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
861fb55a
DJ
1048 0x0018c082, /* srl $24, $24, 2 */
1049 0x0320f809, /* jalr $25 */
1050 0x2718fffe /* subu $24, $24, 2 */
1051};
1052
1053/* The format of the first PLT entry in an N64 executable. Different
1054 from N32 because of the increased size of GOT entries. */
6d30f5b2
NC
1055static const bfd_vma mips_n64_exec_plt0_entry[] =
1056{
861fb55a
DJ
1057 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1058 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */
1059 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1060 0x030ec023, /* subu $24, $24, $14 */
81f5d455 1061 0x03e0782d, /* move $15, $31 # 64-bit move (daddu) */
861fb55a
DJ
1062 0x0018c0c2, /* srl $24, $24, 3 */
1063 0x0320f809, /* jalr $25 */
1064 0x2718fffe /* subu $24, $24, 2 */
1065};
1066
1bbce132
MR
1067/* The format of the microMIPS first PLT entry in an O32 executable.
1068 We rely on v0 ($2) rather than t8 ($24) to contain the address
1069 of the GOTPLT entry handled, so this stub may only be used when
1070 all the subsequent PLT entries are microMIPS code too.
1071
1072 The trailing NOP is for alignment and correct disassembly only. */
1073static const bfd_vma micromips_o32_exec_plt0_entry[] =
1074{
1075 0x7980, 0x0000, /* addiupc $3, (&GOTPLT[0]) - . */
1076 0xff23, 0x0000, /* lw $25, 0($3) */
1077 0x0535, /* subu $2, $2, $3 */
1078 0x2525, /* srl $2, $2, 2 */
1079 0x3302, 0xfffe, /* subu $24, $2, 2 */
1080 0x0dff, /* move $15, $31 */
1081 0x45f9, /* jalrs $25 */
1082 0x0f83, /* move $28, $3 */
1083 0x0c00 /* nop */
1084};
1085
833794fc
MR
1086/* The format of the microMIPS first PLT entry in an O32 executable
1087 in the insn32 mode. */
1088static const bfd_vma micromips_insn32_o32_exec_plt0_entry[] =
1089{
1090 0x41bc, 0x0000, /* lui $28, %hi(&GOTPLT[0]) */
1091 0xff3c, 0x0000, /* lw $25, %lo(&GOTPLT[0])($28) */
1092 0x339c, 0x0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
1093 0x0398, 0xc1d0, /* subu $24, $24, $28 */
1094 0x001f, 0x7950, /* move $15, $31 */
1095 0x0318, 0x1040, /* srl $24, $24, 2 */
1096 0x03f9, 0x0f3c, /* jalr $25 */
1097 0x3318, 0xfffe /* subu $24, $24, 2 */
1098};
1099
1bbce132 1100/* The format of subsequent standard PLT entries. */
6d30f5b2
NC
1101static const bfd_vma mips_exec_plt_entry[] =
1102{
861fb55a
DJ
1103 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
1104 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
1105 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
1106 0x03200008 /* jr $25 */
1107};
1108
7361da2c
AB
1109/* In the following PLT entry the JR and ADDIU instructions will
1110 be swapped in _bfd_mips_elf_finish_dynamic_symbol because
1111 LOAD_INTERLOCKS_P will be true for MIPS R6. */
1112static const bfd_vma mipsr6_exec_plt_entry[] =
1113{
1114 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
1115 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
1116 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
1117 0x03200009 /* jr $25 */
1118};
1119
1bbce132
MR
1120/* The format of subsequent MIPS16 o32 PLT entries. We use v0 ($2)
1121 and v1 ($3) as temporaries because t8 ($24) and t9 ($25) are not
1122 directly addressable. */
1123static const bfd_vma mips16_o32_exec_plt_entry[] =
1124{
1125 0xb203, /* lw $2, 12($pc) */
1126 0x9a60, /* lw $3, 0($2) */
1127 0x651a, /* move $24, $2 */
1128 0xeb00, /* jr $3 */
1129 0x653b, /* move $25, $3 */
1130 0x6500, /* nop */
1131 0x0000, 0x0000 /* .word (.got.plt entry) */
1132};
1133
1134/* The format of subsequent microMIPS o32 PLT entries. We use v0 ($2)
1135 as a temporary because t8 ($24) is not addressable with ADDIUPC. */
1136static const bfd_vma micromips_o32_exec_plt_entry[] =
1137{
1138 0x7900, 0x0000, /* addiupc $2, (.got.plt entry) - . */
1139 0xff22, 0x0000, /* lw $25, 0($2) */
1140 0x4599, /* jr $25 */
1141 0x0f02 /* move $24, $2 */
1142};
1143
833794fc
MR
1144/* The format of subsequent microMIPS o32 PLT entries in the insn32 mode. */
1145static const bfd_vma micromips_insn32_o32_exec_plt_entry[] =
1146{
1147 0x41af, 0x0000, /* lui $15, %hi(.got.plt entry) */
1148 0xff2f, 0x0000, /* lw $25, %lo(.got.plt entry)($15) */
1149 0x0019, 0x0f3c, /* jr $25 */
1150 0x330f, 0x0000 /* addiu $24, $15, %lo(.got.plt entry) */
1151};
1152
0a44bf69 1153/* The format of the first PLT entry in a VxWorks executable. */
6d30f5b2
NC
1154static const bfd_vma mips_vxworks_exec_plt0_entry[] =
1155{
0a44bf69
RS
1156 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
1157 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
1158 0x8f390008, /* lw t9, 8(t9) */
1159 0x00000000, /* nop */
1160 0x03200008, /* jr t9 */
1161 0x00000000 /* nop */
1162};
1163
1164/* The format of subsequent PLT entries. */
6d30f5b2
NC
1165static const bfd_vma mips_vxworks_exec_plt_entry[] =
1166{
0a44bf69
RS
1167 0x10000000, /* b .PLT_resolver */
1168 0x24180000, /* li t8, <pltindex> */
1169 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
1170 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
1171 0x8f390000, /* lw t9, 0(t9) */
1172 0x00000000, /* nop */
1173 0x03200008, /* jr t9 */
1174 0x00000000 /* nop */
1175};
1176
1177/* The format of the first PLT entry in a VxWorks shared object. */
6d30f5b2
NC
1178static const bfd_vma mips_vxworks_shared_plt0_entry[] =
1179{
0a44bf69
RS
1180 0x8f990008, /* lw t9, 8(gp) */
1181 0x00000000, /* nop */
1182 0x03200008, /* jr t9 */
1183 0x00000000, /* nop */
1184 0x00000000, /* nop */
1185 0x00000000 /* nop */
1186};
1187
1188/* The format of subsequent PLT entries. */
6d30f5b2
NC
1189static const bfd_vma mips_vxworks_shared_plt_entry[] =
1190{
0a44bf69
RS
1191 0x10000000, /* b .PLT_resolver */
1192 0x24180000 /* li t8, <pltindex> */
1193};
1194\f
d21911ea
MR
1195/* microMIPS 32-bit opcode helper installer. */
1196
1197static void
1198bfd_put_micromips_32 (const bfd *abfd, bfd_vma opcode, bfd_byte *ptr)
1199{
1200 bfd_put_16 (abfd, (opcode >> 16) & 0xffff, ptr);
1201 bfd_put_16 (abfd, opcode & 0xffff, ptr + 2);
1202}
1203
1204/* microMIPS 32-bit opcode helper retriever. */
1205
1206static bfd_vma
1207bfd_get_micromips_32 (const bfd *abfd, const bfd_byte *ptr)
1208{
1209 return (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2);
1210}
1211\f
b49e97c9
TS
1212/* Look up an entry in a MIPS ELF linker hash table. */
1213
1214#define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
1215 ((struct mips_elf_link_hash_entry *) \
1216 elf_link_hash_lookup (&(table)->root, (string), (create), \
1217 (copy), (follow)))
1218
1219/* Traverse a MIPS ELF linker hash table. */
1220
1221#define mips_elf_link_hash_traverse(table, func, info) \
1222 (elf_link_hash_traverse \
1223 (&(table)->root, \
9719ad41 1224 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
b49e97c9
TS
1225 (info)))
1226
0f20cc35
DJ
1227/* Find the base offsets for thread-local storage in this object,
1228 for GD/LD and IE/LE respectively. */
1229
1230#define TP_OFFSET 0x7000
1231#define DTP_OFFSET 0x8000
1232
1233static bfd_vma
1234dtprel_base (struct bfd_link_info *info)
1235{
1236 /* If tls_sec is NULL, we should have signalled an error already. */
1237 if (elf_hash_table (info)->tls_sec == NULL)
1238 return 0;
1239 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
1240}
1241
1242static bfd_vma
1243tprel_base (struct bfd_link_info *info)
1244{
1245 /* If tls_sec is NULL, we should have signalled an error already. */
1246 if (elf_hash_table (info)->tls_sec == NULL)
1247 return 0;
1248 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
1249}
1250
b49e97c9
TS
1251/* Create an entry in a MIPS ELF linker hash table. */
1252
1253static struct bfd_hash_entry *
9719ad41
RS
1254mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1255 struct bfd_hash_table *table, const char *string)
b49e97c9
TS
1256{
1257 struct mips_elf_link_hash_entry *ret =
1258 (struct mips_elf_link_hash_entry *) entry;
1259
1260 /* Allocate the structure if it has not already been allocated by a
1261 subclass. */
9719ad41
RS
1262 if (ret == NULL)
1263 ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
1264 if (ret == NULL)
b49e97c9
TS
1265 return (struct bfd_hash_entry *) ret;
1266
1267 /* Call the allocation method of the superclass. */
1268 ret = ((struct mips_elf_link_hash_entry *)
1269 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1270 table, string));
9719ad41 1271 if (ret != NULL)
b49e97c9
TS
1272 {
1273 /* Set local fields. */
1274 memset (&ret->esym, 0, sizeof (EXTR));
1275 /* We use -2 as a marker to indicate that the information has
1276 not been set. -1 means there is no associated ifd. */
1277 ret->esym.ifd = -2;
861fb55a 1278 ret->la25_stub = 0;
b49e97c9 1279 ret->possibly_dynamic_relocs = 0;
b49e97c9 1280 ret->fn_stub = NULL;
b49e97c9
TS
1281 ret->call_stub = NULL;
1282 ret->call_fp_stub = NULL;
634835ae 1283 ret->global_got_area = GGA_NONE;
6ccf4795 1284 ret->got_only_for_calls = TRUE;
71782a75 1285 ret->readonly_reloc = FALSE;
861fb55a 1286 ret->has_static_relocs = FALSE;
71782a75
RS
1287 ret->no_fn_stub = FALSE;
1288 ret->need_fn_stub = FALSE;
861fb55a 1289 ret->has_nonpic_branches = FALSE;
33bb52fb 1290 ret->needs_lazy_stub = FALSE;
1bbce132 1291 ret->use_plt_entry = FALSE;
b49e97c9
TS
1292 }
1293
1294 return (struct bfd_hash_entry *) ret;
1295}
f0abc2a1 1296
6ae68ba3
MR
1297/* Allocate MIPS ELF private object data. */
1298
1299bfd_boolean
1300_bfd_mips_elf_mkobject (bfd *abfd)
1301{
1302 return bfd_elf_allocate_object (abfd, sizeof (struct mips_elf_obj_tdata),
1303 MIPS_ELF_DATA);
1304}
1305
f0abc2a1 1306bfd_boolean
9719ad41 1307_bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
f0abc2a1 1308{
f592407e
AM
1309 if (!sec->used_by_bfd)
1310 {
1311 struct _mips_elf_section_data *sdata;
1312 bfd_size_type amt = sizeof (*sdata);
f0abc2a1 1313
f592407e
AM
1314 sdata = bfd_zalloc (abfd, amt);
1315 if (sdata == NULL)
1316 return FALSE;
1317 sec->used_by_bfd = sdata;
1318 }
f0abc2a1
AM
1319
1320 return _bfd_elf_new_section_hook (abfd, sec);
1321}
b49e97c9
TS
1322\f
1323/* Read ECOFF debugging information from a .mdebug section into a
1324 ecoff_debug_info structure. */
1325
b34976b6 1326bfd_boolean
9719ad41
RS
1327_bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
1328 struct ecoff_debug_info *debug)
b49e97c9
TS
1329{
1330 HDRR *symhdr;
1331 const struct ecoff_debug_swap *swap;
9719ad41 1332 char *ext_hdr;
b49e97c9
TS
1333
1334 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1335 memset (debug, 0, sizeof (*debug));
1336
9719ad41 1337 ext_hdr = bfd_malloc (swap->external_hdr_size);
b49e97c9
TS
1338 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1339 goto error_return;
1340
9719ad41 1341 if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
82e51918 1342 swap->external_hdr_size))
b49e97c9
TS
1343 goto error_return;
1344
1345 symhdr = &debug->symbolic_header;
1346 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1347
1348 /* The symbolic header contains absolute file offsets and sizes to
1349 read. */
1350#define READ(ptr, offset, count, size, type) \
1351 if (symhdr->count == 0) \
1352 debug->ptr = NULL; \
1353 else \
1354 { \
1355 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
9719ad41 1356 debug->ptr = bfd_malloc (amt); \
b49e97c9
TS
1357 if (debug->ptr == NULL) \
1358 goto error_return; \
9719ad41 1359 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
b49e97c9
TS
1360 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1361 goto error_return; \
1362 }
1363
1364 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
9719ad41
RS
1365 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1366 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1367 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1368 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
b49e97c9
TS
1369 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1370 union aux_ext *);
1371 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1372 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
9719ad41
RS
1373 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1374 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1375 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
b49e97c9
TS
1376#undef READ
1377
1378 debug->fdr = NULL;
b49e97c9 1379
b34976b6 1380 return TRUE;
b49e97c9
TS
1381
1382 error_return:
1383 if (ext_hdr != NULL)
1384 free (ext_hdr);
1385 if (debug->line != NULL)
1386 free (debug->line);
1387 if (debug->external_dnr != NULL)
1388 free (debug->external_dnr);
1389 if (debug->external_pdr != NULL)
1390 free (debug->external_pdr);
1391 if (debug->external_sym != NULL)
1392 free (debug->external_sym);
1393 if (debug->external_opt != NULL)
1394 free (debug->external_opt);
1395 if (debug->external_aux != NULL)
1396 free (debug->external_aux);
1397 if (debug->ss != NULL)
1398 free (debug->ss);
1399 if (debug->ssext != NULL)
1400 free (debug->ssext);
1401 if (debug->external_fdr != NULL)
1402 free (debug->external_fdr);
1403 if (debug->external_rfd != NULL)
1404 free (debug->external_rfd);
1405 if (debug->external_ext != NULL)
1406 free (debug->external_ext);
b34976b6 1407 return FALSE;
b49e97c9
TS
1408}
1409\f
1410/* Swap RPDR (runtime procedure table entry) for output. */
1411
1412static void
9719ad41 1413ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
b49e97c9
TS
1414{
1415 H_PUT_S32 (abfd, in->adr, ex->p_adr);
1416 H_PUT_32 (abfd, in->regmask, ex->p_regmask);
1417 H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
1418 H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
1419 H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
1420 H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
1421
1422 H_PUT_16 (abfd, in->framereg, ex->p_framereg);
1423 H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
1424
1425 H_PUT_32 (abfd, in->irpss, ex->p_irpss);
b49e97c9
TS
1426}
1427
1428/* Create a runtime procedure table from the .mdebug section. */
1429
b34976b6 1430static bfd_boolean
9719ad41
RS
1431mips_elf_create_procedure_table (void *handle, bfd *abfd,
1432 struct bfd_link_info *info, asection *s,
1433 struct ecoff_debug_info *debug)
b49e97c9
TS
1434{
1435 const struct ecoff_debug_swap *swap;
1436 HDRR *hdr = &debug->symbolic_header;
1437 RPDR *rpdr, *rp;
1438 struct rpdr_ext *erp;
9719ad41 1439 void *rtproc;
b49e97c9
TS
1440 struct pdr_ext *epdr;
1441 struct sym_ext *esym;
1442 char *ss, **sv;
1443 char *str;
1444 bfd_size_type size;
1445 bfd_size_type count;
1446 unsigned long sindex;
1447 unsigned long i;
1448 PDR pdr;
1449 SYMR sym;
1450 const char *no_name_func = _("static procedure (no name)");
1451
1452 epdr = NULL;
1453 rpdr = NULL;
1454 esym = NULL;
1455 ss = NULL;
1456 sv = NULL;
1457
1458 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1459
1460 sindex = strlen (no_name_func) + 1;
1461 count = hdr->ipdMax;
1462 if (count > 0)
1463 {
1464 size = swap->external_pdr_size;
1465
9719ad41 1466 epdr = bfd_malloc (size * count);
b49e97c9
TS
1467 if (epdr == NULL)
1468 goto error_return;
1469
9719ad41 1470 if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
b49e97c9
TS
1471 goto error_return;
1472
1473 size = sizeof (RPDR);
9719ad41 1474 rp = rpdr = bfd_malloc (size * count);
b49e97c9
TS
1475 if (rpdr == NULL)
1476 goto error_return;
1477
1478 size = sizeof (char *);
9719ad41 1479 sv = bfd_malloc (size * count);
b49e97c9
TS
1480 if (sv == NULL)
1481 goto error_return;
1482
1483 count = hdr->isymMax;
1484 size = swap->external_sym_size;
9719ad41 1485 esym = bfd_malloc (size * count);
b49e97c9
TS
1486 if (esym == NULL)
1487 goto error_return;
1488
9719ad41 1489 if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
b49e97c9
TS
1490 goto error_return;
1491
1492 count = hdr->issMax;
9719ad41 1493 ss = bfd_malloc (count);
b49e97c9
TS
1494 if (ss == NULL)
1495 goto error_return;
f075ee0c 1496 if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
b49e97c9
TS
1497 goto error_return;
1498
1499 count = hdr->ipdMax;
1500 for (i = 0; i < (unsigned long) count; i++, rp++)
1501 {
9719ad41
RS
1502 (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1503 (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
b49e97c9
TS
1504 rp->adr = sym.value;
1505 rp->regmask = pdr.regmask;
1506 rp->regoffset = pdr.regoffset;
1507 rp->fregmask = pdr.fregmask;
1508 rp->fregoffset = pdr.fregoffset;
1509 rp->frameoffset = pdr.frameoffset;
1510 rp->framereg = pdr.framereg;
1511 rp->pcreg = pdr.pcreg;
1512 rp->irpss = sindex;
1513 sv[i] = ss + sym.iss;
1514 sindex += strlen (sv[i]) + 1;
1515 }
1516 }
1517
1518 size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1519 size = BFD_ALIGN (size, 16);
9719ad41 1520 rtproc = bfd_alloc (abfd, size);
b49e97c9
TS
1521 if (rtproc == NULL)
1522 {
1523 mips_elf_hash_table (info)->procedure_count = 0;
1524 goto error_return;
1525 }
1526
1527 mips_elf_hash_table (info)->procedure_count = count + 2;
1528
9719ad41 1529 erp = rtproc;
b49e97c9
TS
1530 memset (erp, 0, sizeof (struct rpdr_ext));
1531 erp++;
1532 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1533 strcpy (str, no_name_func);
1534 str += strlen (no_name_func) + 1;
1535 for (i = 0; i < count; i++)
1536 {
1537 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1538 strcpy (str, sv[i]);
1539 str += strlen (sv[i]) + 1;
1540 }
1541 H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1542
1543 /* Set the size and contents of .rtproc section. */
eea6121a 1544 s->size = size;
9719ad41 1545 s->contents = rtproc;
b49e97c9
TS
1546
1547 /* Skip this section later on (I don't think this currently
1548 matters, but someday it might). */
8423293d 1549 s->map_head.link_order = NULL;
b49e97c9
TS
1550
1551 if (epdr != NULL)
1552 free (epdr);
1553 if (rpdr != NULL)
1554 free (rpdr);
1555 if (esym != NULL)
1556 free (esym);
1557 if (ss != NULL)
1558 free (ss);
1559 if (sv != NULL)
1560 free (sv);
1561
b34976b6 1562 return TRUE;
b49e97c9
TS
1563
1564 error_return:
1565 if (epdr != NULL)
1566 free (epdr);
1567 if (rpdr != NULL)
1568 free (rpdr);
1569 if (esym != NULL)
1570 free (esym);
1571 if (ss != NULL)
1572 free (ss);
1573 if (sv != NULL)
1574 free (sv);
b34976b6 1575 return FALSE;
b49e97c9 1576}
738e5348 1577\f
861fb55a
DJ
1578/* We're going to create a stub for H. Create a symbol for the stub's
1579 value and size, to help make the disassembly easier to read. */
1580
1581static bfd_boolean
1582mips_elf_create_stub_symbol (struct bfd_link_info *info,
1583 struct mips_elf_link_hash_entry *h,
1584 const char *prefix, asection *s, bfd_vma value,
1585 bfd_vma size)
1586{
1587 struct bfd_link_hash_entry *bh;
1588 struct elf_link_hash_entry *elfh;
1589 const char *name;
1590
df58fc94
RS
1591 if (ELF_ST_IS_MICROMIPS (h->root.other))
1592 value |= 1;
1593
861fb55a
DJ
1594 /* Create a new symbol. */
1595 name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1596 bh = NULL;
1597 if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1598 BSF_LOCAL, s, value, NULL,
1599 TRUE, FALSE, &bh))
1600 return FALSE;
1601
1602 /* Make it a local function. */
1603 elfh = (struct elf_link_hash_entry *) bh;
1604 elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
1605 elfh->size = size;
1606 elfh->forced_local = 1;
1607 return TRUE;
1608}
1609
738e5348
RS
1610/* We're about to redefine H. Create a symbol to represent H's
1611 current value and size, to help make the disassembly easier
1612 to read. */
1613
1614static bfd_boolean
1615mips_elf_create_shadow_symbol (struct bfd_link_info *info,
1616 struct mips_elf_link_hash_entry *h,
1617 const char *prefix)
1618{
1619 struct bfd_link_hash_entry *bh;
1620 struct elf_link_hash_entry *elfh;
1621 const char *name;
1622 asection *s;
1623 bfd_vma value;
1624
1625 /* Read the symbol's value. */
1626 BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
1627 || h->root.root.type == bfd_link_hash_defweak);
1628 s = h->root.root.u.def.section;
1629 value = h->root.root.u.def.value;
1630
1631 /* Create a new symbol. */
1632 name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1633 bh = NULL;
1634 if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1635 BSF_LOCAL, s, value, NULL,
1636 TRUE, FALSE, &bh))
1637 return FALSE;
1638
1639 /* Make it local and copy the other attributes from H. */
1640 elfh = (struct elf_link_hash_entry *) bh;
1641 elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type));
1642 elfh->other = h->root.other;
1643 elfh->size = h->root.size;
1644 elfh->forced_local = 1;
1645 return TRUE;
1646}
1647
1648/* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1649 function rather than to a hard-float stub. */
1650
1651static bfd_boolean
1652section_allows_mips16_refs_p (asection *section)
1653{
1654 const char *name;
1655
1656 name = bfd_get_section_name (section->owner, section);
1657 return (FN_STUB_P (name)
1658 || CALL_STUB_P (name)
1659 || CALL_FP_STUB_P (name)
1660 || strcmp (name, ".pdr") == 0);
1661}
1662
1663/* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1664 stub section of some kind. Return the R_SYMNDX of the target
1665 function, or 0 if we can't decide which function that is. */
1666
1667static unsigned long
cb4437b8
MR
1668mips16_stub_symndx (const struct elf_backend_data *bed,
1669 asection *sec ATTRIBUTE_UNUSED,
502e814e 1670 const Elf_Internal_Rela *relocs,
738e5348
RS
1671 const Elf_Internal_Rela *relend)
1672{
cb4437b8 1673 int int_rels_per_ext_rel = bed->s->int_rels_per_ext_rel;
738e5348
RS
1674 const Elf_Internal_Rela *rel;
1675
cb4437b8
MR
1676 /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
1677 one in a compound relocation. */
1678 for (rel = relocs; rel < relend; rel += int_rels_per_ext_rel)
738e5348
RS
1679 if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE)
1680 return ELF_R_SYM (sec->owner, rel->r_info);
1681
1682 /* Otherwise trust the first relocation, whatever its kind. This is
1683 the traditional behavior. */
1684 if (relocs < relend)
1685 return ELF_R_SYM (sec->owner, relocs->r_info);
1686
1687 return 0;
1688}
b49e97c9
TS
1689
1690/* Check the mips16 stubs for a particular symbol, and see if we can
1691 discard them. */
1692
861fb55a
DJ
1693static void
1694mips_elf_check_mips16_stubs (struct bfd_link_info *info,
1695 struct mips_elf_link_hash_entry *h)
b49e97c9 1696{
738e5348
RS
1697 /* Dynamic symbols must use the standard call interface, in case other
1698 objects try to call them. */
1699 if (h->fn_stub != NULL
1700 && h->root.dynindx != -1)
1701 {
1702 mips_elf_create_shadow_symbol (info, h, ".mips16.");
1703 h->need_fn_stub = TRUE;
1704 }
1705
b49e97c9
TS
1706 if (h->fn_stub != NULL
1707 && ! h->need_fn_stub)
1708 {
1709 /* We don't need the fn_stub; the only references to this symbol
1710 are 16 bit calls. Clobber the size to 0 to prevent it from
1711 being included in the link. */
eea6121a 1712 h->fn_stub->size = 0;
b49e97c9
TS
1713 h->fn_stub->flags &= ~SEC_RELOC;
1714 h->fn_stub->reloc_count = 0;
1715 h->fn_stub->flags |= SEC_EXCLUDE;
1716 }
1717
1718 if (h->call_stub != NULL
30c09090 1719 && ELF_ST_IS_MIPS16 (h->root.other))
b49e97c9
TS
1720 {
1721 /* We don't need the call_stub; this is a 16 bit function, so
1722 calls from other 16 bit functions are OK. Clobber the size
1723 to 0 to prevent it from being included in the link. */
eea6121a 1724 h->call_stub->size = 0;
b49e97c9
TS
1725 h->call_stub->flags &= ~SEC_RELOC;
1726 h->call_stub->reloc_count = 0;
1727 h->call_stub->flags |= SEC_EXCLUDE;
1728 }
1729
1730 if (h->call_fp_stub != NULL
30c09090 1731 && ELF_ST_IS_MIPS16 (h->root.other))
b49e97c9
TS
1732 {
1733 /* We don't need the call_stub; this is a 16 bit function, so
1734 calls from other 16 bit functions are OK. Clobber the size
1735 to 0 to prevent it from being included in the link. */
eea6121a 1736 h->call_fp_stub->size = 0;
b49e97c9
TS
1737 h->call_fp_stub->flags &= ~SEC_RELOC;
1738 h->call_fp_stub->reloc_count = 0;
1739 h->call_fp_stub->flags |= SEC_EXCLUDE;
1740 }
861fb55a
DJ
1741}
1742
1743/* Hashtable callbacks for mips_elf_la25_stubs. */
1744
1745static hashval_t
1746mips_elf_la25_stub_hash (const void *entry_)
1747{
1748 const struct mips_elf_la25_stub *entry;
1749
1750 entry = (struct mips_elf_la25_stub *) entry_;
1751 return entry->h->root.root.u.def.section->id
1752 + entry->h->root.root.u.def.value;
1753}
1754
1755static int
1756mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_)
1757{
1758 const struct mips_elf_la25_stub *entry1, *entry2;
1759
1760 entry1 = (struct mips_elf_la25_stub *) entry1_;
1761 entry2 = (struct mips_elf_la25_stub *) entry2_;
1762 return ((entry1->h->root.root.u.def.section
1763 == entry2->h->root.root.u.def.section)
1764 && (entry1->h->root.root.u.def.value
1765 == entry2->h->root.root.u.def.value));
1766}
1767
1768/* Called by the linker to set up the la25 stub-creation code. FN is
1769 the linker's implementation of add_stub_function. Return true on
1770 success. */
1771
1772bfd_boolean
1773_bfd_mips_elf_init_stubs (struct bfd_link_info *info,
1774 asection *(*fn) (const char *, asection *,
1775 asection *))
1776{
1777 struct mips_elf_link_hash_table *htab;
1778
1779 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
1780 if (htab == NULL)
1781 return FALSE;
1782
861fb55a
DJ
1783 htab->add_stub_section = fn;
1784 htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash,
1785 mips_elf_la25_stub_eq, NULL);
1786 if (htab->la25_stubs == NULL)
1787 return FALSE;
1788
1789 return TRUE;
1790}
1791
1792/* Return true if H is a locally-defined PIC function, in the sense
8f0c309a
CLT
1793 that it or its fn_stub might need $25 to be valid on entry.
1794 Note that MIPS16 functions set up $gp using PC-relative instructions,
1795 so they themselves never need $25 to be valid. Only non-MIPS16
1796 entry points are of interest here. */
861fb55a
DJ
1797
1798static bfd_boolean
1799mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h)
1800{
1801 return ((h->root.root.type == bfd_link_hash_defined
1802 || h->root.root.type == bfd_link_hash_defweak)
1803 && h->root.def_regular
1804 && !bfd_is_abs_section (h->root.root.u.def.section)
8f0c309a
CLT
1805 && (!ELF_ST_IS_MIPS16 (h->root.other)
1806 || (h->fn_stub && h->need_fn_stub))
861fb55a
DJ
1807 && (PIC_OBJECT_P (h->root.root.u.def.section->owner)
1808 || ELF_ST_IS_MIPS_PIC (h->root.other)));
1809}
1810
8f0c309a
CLT
1811/* Set *SEC to the input section that contains the target of STUB.
1812 Return the offset of the target from the start of that section. */
1813
1814static bfd_vma
1815mips_elf_get_la25_target (struct mips_elf_la25_stub *stub,
1816 asection **sec)
1817{
1818 if (ELF_ST_IS_MIPS16 (stub->h->root.other))
1819 {
1820 BFD_ASSERT (stub->h->need_fn_stub);
1821 *sec = stub->h->fn_stub;
1822 return 0;
1823 }
1824 else
1825 {
1826 *sec = stub->h->root.root.u.def.section;
1827 return stub->h->root.root.u.def.value;
1828 }
1829}
1830
861fb55a
DJ
1831/* STUB describes an la25 stub that we have decided to implement
1832 by inserting an LUI/ADDIU pair before the target function.
1833 Create the section and redirect the function symbol to it. */
1834
1835static bfd_boolean
1836mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub,
1837 struct bfd_link_info *info)
1838{
1839 struct mips_elf_link_hash_table *htab;
1840 char *name;
1841 asection *s, *input_section;
1842 unsigned int align;
1843
1844 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
1845 if (htab == NULL)
1846 return FALSE;
861fb55a
DJ
1847
1848 /* Create a unique name for the new section. */
1849 name = bfd_malloc (11 + sizeof (".text.stub."));
1850 if (name == NULL)
1851 return FALSE;
1852 sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs));
1853
1854 /* Create the section. */
8f0c309a 1855 mips_elf_get_la25_target (stub, &input_section);
861fb55a
DJ
1856 s = htab->add_stub_section (name, input_section,
1857 input_section->output_section);
1858 if (s == NULL)
1859 return FALSE;
1860
1861 /* Make sure that any padding goes before the stub. */
1862 align = input_section->alignment_power;
1863 if (!bfd_set_section_alignment (s->owner, s, align))
1864 return FALSE;
1865 if (align > 3)
1866 s->size = (1 << align) - 8;
1867
1868 /* Create a symbol for the stub. */
1869 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8);
1870 stub->stub_section = s;
1871 stub->offset = s->size;
1872
1873 /* Allocate room for it. */
1874 s->size += 8;
1875 return TRUE;
1876}
1877
1878/* STUB describes an la25 stub that we have decided to implement
1879 with a separate trampoline. Allocate room for it and redirect
1880 the function symbol to it. */
1881
1882static bfd_boolean
1883mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub,
1884 struct bfd_link_info *info)
1885{
1886 struct mips_elf_link_hash_table *htab;
1887 asection *s;
1888
1889 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
1890 if (htab == NULL)
1891 return FALSE;
861fb55a
DJ
1892
1893 /* Create a trampoline section, if we haven't already. */
1894 s = htab->strampoline;
1895 if (s == NULL)
1896 {
1897 asection *input_section = stub->h->root.root.u.def.section;
1898 s = htab->add_stub_section (".text", NULL,
1899 input_section->output_section);
1900 if (s == NULL || !bfd_set_section_alignment (s->owner, s, 4))
1901 return FALSE;
1902 htab->strampoline = s;
1903 }
1904
1905 /* Create a symbol for the stub. */
1906 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16);
1907 stub->stub_section = s;
1908 stub->offset = s->size;
1909
1910 /* Allocate room for it. */
1911 s->size += 16;
1912 return TRUE;
1913}
1914
1915/* H describes a symbol that needs an la25 stub. Make sure that an
1916 appropriate stub exists and point H at it. */
1917
1918static bfd_boolean
1919mips_elf_add_la25_stub (struct bfd_link_info *info,
1920 struct mips_elf_link_hash_entry *h)
1921{
1922 struct mips_elf_link_hash_table *htab;
1923 struct mips_elf_la25_stub search, *stub;
1924 bfd_boolean use_trampoline_p;
1925 asection *s;
1926 bfd_vma value;
1927 void **slot;
1928
861fb55a
DJ
1929 /* Describe the stub we want. */
1930 search.stub_section = NULL;
1931 search.offset = 0;
1932 search.h = h;
1933
1934 /* See if we've already created an equivalent stub. */
1935 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
1936 if (htab == NULL)
1937 return FALSE;
1938
861fb55a
DJ
1939 slot = htab_find_slot (htab->la25_stubs, &search, INSERT);
1940 if (slot == NULL)
1941 return FALSE;
1942
1943 stub = (struct mips_elf_la25_stub *) *slot;
1944 if (stub != NULL)
1945 {
1946 /* We can reuse the existing stub. */
1947 h->la25_stub = stub;
1948 return TRUE;
1949 }
1950
1951 /* Create a permanent copy of ENTRY and add it to the hash table. */
1952 stub = bfd_malloc (sizeof (search));
1953 if (stub == NULL)
1954 return FALSE;
1955 *stub = search;
1956 *slot = stub;
1957
8f0c309a
CLT
1958 /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1959 of the section and if we would need no more than 2 nops. */
1960 value = mips_elf_get_la25_target (stub, &s);
1961 use_trampoline_p = (value != 0 || s->alignment_power > 4);
1962
861fb55a
DJ
1963 h->la25_stub = stub;
1964 return (use_trampoline_p
1965 ? mips_elf_add_la25_trampoline (stub, info)
1966 : mips_elf_add_la25_intro (stub, info));
1967}
1968
1969/* A mips_elf_link_hash_traverse callback that is called before sizing
1970 sections. DATA points to a mips_htab_traverse_info structure. */
1971
1972static bfd_boolean
1973mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data)
1974{
1975 struct mips_htab_traverse_info *hti;
1976
1977 hti = (struct mips_htab_traverse_info *) data;
861fb55a
DJ
1978 if (!hti->info->relocatable)
1979 mips_elf_check_mips16_stubs (hti->info, h);
b49e97c9 1980
861fb55a
DJ
1981 if (mips_elf_local_pic_function_p (h))
1982 {
ba85c43e
NC
1983 /* PR 12845: If H is in a section that has been garbage
1984 collected it will have its output section set to *ABS*. */
1985 if (bfd_is_abs_section (h->root.root.u.def.section->output_section))
1986 return TRUE;
1987
861fb55a
DJ
1988 /* H is a function that might need $25 to be valid on entry.
1989 If we're creating a non-PIC relocatable object, mark H as
1990 being PIC. If we're creating a non-relocatable object with
1991 non-PIC branches and jumps to H, make sure that H has an la25
1992 stub. */
1993 if (hti->info->relocatable)
1994 {
1995 if (!PIC_OBJECT_P (hti->output_bfd))
1996 h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other);
1997 }
1998 else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h))
1999 {
2000 hti->error = TRUE;
2001 return FALSE;
2002 }
2003 }
b34976b6 2004 return TRUE;
b49e97c9
TS
2005}
2006\f
d6f16593
MR
2007/* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
2008 Most mips16 instructions are 16 bits, but these instructions
2009 are 32 bits.
2010
2011 The format of these instructions is:
2012
2013 +--------------+--------------------------------+
2014 | JALX | X| Imm 20:16 | Imm 25:21 |
2015 +--------------+--------------------------------+
2016 | Immediate 15:0 |
2017 +-----------------------------------------------+
2018
2019 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
2020 Note that the immediate value in the first word is swapped.
2021
2022 When producing a relocatable object file, R_MIPS16_26 is
2023 handled mostly like R_MIPS_26. In particular, the addend is
2024 stored as a straight 26-bit value in a 32-bit instruction.
2025 (gas makes life simpler for itself by never adjusting a
2026 R_MIPS16_26 reloc to be against a section, so the addend is
2027 always zero). However, the 32 bit instruction is stored as 2
2028 16-bit values, rather than a single 32-bit value. In a
2029 big-endian file, the result is the same; in a little-endian
2030 file, the two 16-bit halves of the 32 bit value are swapped.
2031 This is so that a disassembler can recognize the jal
2032 instruction.
2033
2034 When doing a final link, R_MIPS16_26 is treated as a 32 bit
2035 instruction stored as two 16-bit values. The addend A is the
2036 contents of the targ26 field. The calculation is the same as
2037 R_MIPS_26. When storing the calculated value, reorder the
2038 immediate value as shown above, and don't forget to store the
2039 value as two 16-bit values.
2040
2041 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
2042 defined as
2043
2044 big-endian:
2045 +--------+----------------------+
2046 | | |
2047 | | targ26-16 |
2048 |31 26|25 0|
2049 +--------+----------------------+
2050
2051 little-endian:
2052 +----------+------+-------------+
2053 | | | |
2054 | sub1 | | sub2 |
2055 |0 9|10 15|16 31|
2056 +----------+--------------------+
2057 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
2058 ((sub1 << 16) | sub2)).
2059
2060 When producing a relocatable object file, the calculation is
2061 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2062 When producing a fully linked file, the calculation is
2063 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2064 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
2065
738e5348
RS
2066 The table below lists the other MIPS16 instruction relocations.
2067 Each one is calculated in the same way as the non-MIPS16 relocation
2068 given on the right, but using the extended MIPS16 layout of 16-bit
2069 immediate fields:
2070
2071 R_MIPS16_GPREL R_MIPS_GPREL16
2072 R_MIPS16_GOT16 R_MIPS_GOT16
2073 R_MIPS16_CALL16 R_MIPS_CALL16
2074 R_MIPS16_HI16 R_MIPS_HI16
2075 R_MIPS16_LO16 R_MIPS_LO16
2076
2077 A typical instruction will have a format like this:
d6f16593
MR
2078
2079 +--------------+--------------------------------+
2080 | EXTEND | Imm 10:5 | Imm 15:11 |
2081 +--------------+--------------------------------+
2082 | Major | rx | ry | Imm 4:0 |
2083 +--------------+--------------------------------+
2084
2085 EXTEND is the five bit value 11110. Major is the instruction
2086 opcode.
2087
738e5348
RS
2088 All we need to do here is shuffle the bits appropriately.
2089 As above, the two 16-bit halves must be swapped on a
2090 little-endian system. */
2091
2092static inline bfd_boolean
2093mips16_reloc_p (int r_type)
2094{
2095 switch (r_type)
2096 {
2097 case R_MIPS16_26:
2098 case R_MIPS16_GPREL:
2099 case R_MIPS16_GOT16:
2100 case R_MIPS16_CALL16:
2101 case R_MIPS16_HI16:
2102 case R_MIPS16_LO16:
d0f13682
CLT
2103 case R_MIPS16_TLS_GD:
2104 case R_MIPS16_TLS_LDM:
2105 case R_MIPS16_TLS_DTPREL_HI16:
2106 case R_MIPS16_TLS_DTPREL_LO16:
2107 case R_MIPS16_TLS_GOTTPREL:
2108 case R_MIPS16_TLS_TPREL_HI16:
2109 case R_MIPS16_TLS_TPREL_LO16:
738e5348
RS
2110 return TRUE;
2111
2112 default:
2113 return FALSE;
2114 }
2115}
2116
df58fc94
RS
2117/* Check if a microMIPS reloc. */
2118
2119static inline bfd_boolean
2120micromips_reloc_p (unsigned int r_type)
2121{
2122 return r_type >= R_MICROMIPS_min && r_type < R_MICROMIPS_max;
2123}
2124
2125/* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
2126 on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1
2127 and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions. */
2128
2129static inline bfd_boolean
2130micromips_reloc_shuffle_p (unsigned int r_type)
2131{
2132 return (micromips_reloc_p (r_type)
2133 && r_type != R_MICROMIPS_PC7_S1
2134 && r_type != R_MICROMIPS_PC10_S1);
2135}
2136
738e5348
RS
2137static inline bfd_boolean
2138got16_reloc_p (int r_type)
2139{
df58fc94
RS
2140 return (r_type == R_MIPS_GOT16
2141 || r_type == R_MIPS16_GOT16
2142 || r_type == R_MICROMIPS_GOT16);
738e5348
RS
2143}
2144
2145static inline bfd_boolean
2146call16_reloc_p (int r_type)
2147{
df58fc94
RS
2148 return (r_type == R_MIPS_CALL16
2149 || r_type == R_MIPS16_CALL16
2150 || r_type == R_MICROMIPS_CALL16);
2151}
2152
2153static inline bfd_boolean
2154got_disp_reloc_p (unsigned int r_type)
2155{
2156 return r_type == R_MIPS_GOT_DISP || r_type == R_MICROMIPS_GOT_DISP;
2157}
2158
2159static inline bfd_boolean
2160got_page_reloc_p (unsigned int r_type)
2161{
2162 return r_type == R_MIPS_GOT_PAGE || r_type == R_MICROMIPS_GOT_PAGE;
2163}
2164
2165static inline bfd_boolean
2166got_ofst_reloc_p (unsigned int r_type)
2167{
2168 return r_type == R_MIPS_GOT_OFST || r_type == R_MICROMIPS_GOT_OFST;
2169}
2170
2171static inline bfd_boolean
2172got_hi16_reloc_p (unsigned int r_type)
2173{
2174 return r_type == R_MIPS_GOT_HI16 || r_type == R_MICROMIPS_GOT_HI16;
2175}
2176
2177static inline bfd_boolean
2178got_lo16_reloc_p (unsigned int r_type)
2179{
2180 return r_type == R_MIPS_GOT_LO16 || r_type == R_MICROMIPS_GOT_LO16;
2181}
2182
2183static inline bfd_boolean
2184call_hi16_reloc_p (unsigned int r_type)
2185{
2186 return r_type == R_MIPS_CALL_HI16 || r_type == R_MICROMIPS_CALL_HI16;
2187}
2188
2189static inline bfd_boolean
2190call_lo16_reloc_p (unsigned int r_type)
2191{
2192 return r_type == R_MIPS_CALL_LO16 || r_type == R_MICROMIPS_CALL_LO16;
738e5348
RS
2193}
2194
2195static inline bfd_boolean
2196hi16_reloc_p (int r_type)
2197{
df58fc94
RS
2198 return (r_type == R_MIPS_HI16
2199 || r_type == R_MIPS16_HI16
7361da2c
AB
2200 || r_type == R_MICROMIPS_HI16
2201 || r_type == R_MIPS_PCHI16);
738e5348 2202}
d6f16593 2203
738e5348
RS
2204static inline bfd_boolean
2205lo16_reloc_p (int r_type)
2206{
df58fc94
RS
2207 return (r_type == R_MIPS_LO16
2208 || r_type == R_MIPS16_LO16
7361da2c
AB
2209 || r_type == R_MICROMIPS_LO16
2210 || r_type == R_MIPS_PCLO16);
738e5348
RS
2211}
2212
2213static inline bfd_boolean
2214mips16_call_reloc_p (int r_type)
2215{
2216 return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16;
2217}
d6f16593 2218
38a7df63
CF
2219static inline bfd_boolean
2220jal_reloc_p (int r_type)
2221{
df58fc94
RS
2222 return (r_type == R_MIPS_26
2223 || r_type == R_MIPS16_26
2224 || r_type == R_MICROMIPS_26_S1);
2225}
2226
7361da2c
AB
2227static inline bfd_boolean
2228aligned_pcrel_reloc_p (int r_type)
2229{
2230 return (r_type == R_MIPS_PC18_S3
2231 || r_type == R_MIPS_PC19_S2);
2232}
2233
df58fc94
RS
2234static inline bfd_boolean
2235micromips_branch_reloc_p (int r_type)
2236{
2237 return (r_type == R_MICROMIPS_26_S1
2238 || r_type == R_MICROMIPS_PC16_S1
2239 || r_type == R_MICROMIPS_PC10_S1
2240 || r_type == R_MICROMIPS_PC7_S1);
2241}
2242
2243static inline bfd_boolean
2244tls_gd_reloc_p (unsigned int r_type)
2245{
d0f13682
CLT
2246 return (r_type == R_MIPS_TLS_GD
2247 || r_type == R_MIPS16_TLS_GD
2248 || r_type == R_MICROMIPS_TLS_GD);
df58fc94
RS
2249}
2250
2251static inline bfd_boolean
2252tls_ldm_reloc_p (unsigned int r_type)
2253{
d0f13682
CLT
2254 return (r_type == R_MIPS_TLS_LDM
2255 || r_type == R_MIPS16_TLS_LDM
2256 || r_type == R_MICROMIPS_TLS_LDM);
df58fc94
RS
2257}
2258
2259static inline bfd_boolean
2260tls_gottprel_reloc_p (unsigned int r_type)
2261{
d0f13682
CLT
2262 return (r_type == R_MIPS_TLS_GOTTPREL
2263 || r_type == R_MIPS16_TLS_GOTTPREL
2264 || r_type == R_MICROMIPS_TLS_GOTTPREL);
38a7df63
CF
2265}
2266
d6f16593 2267void
df58fc94
RS
2268_bfd_mips_elf_reloc_unshuffle (bfd *abfd, int r_type,
2269 bfd_boolean jal_shuffle, bfd_byte *data)
d6f16593 2270{
df58fc94 2271 bfd_vma first, second, val;
d6f16593 2272
df58fc94 2273 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
d6f16593
MR
2274 return;
2275
df58fc94
RS
2276 /* Pick up the first and second halfwords of the instruction. */
2277 first = bfd_get_16 (abfd, data);
2278 second = bfd_get_16 (abfd, data + 2);
2279 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2280 val = first << 16 | second;
2281 else if (r_type != R_MIPS16_26)
2282 val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
2283 | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
d6f16593 2284 else
df58fc94
RS
2285 val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
2286 | ((first & 0x1f) << 21) | second);
d6f16593
MR
2287 bfd_put_32 (abfd, val, data);
2288}
2289
2290void
df58fc94
RS
2291_bfd_mips_elf_reloc_shuffle (bfd *abfd, int r_type,
2292 bfd_boolean jal_shuffle, bfd_byte *data)
d6f16593 2293{
df58fc94 2294 bfd_vma first, second, val;
d6f16593 2295
df58fc94 2296 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
d6f16593
MR
2297 return;
2298
2299 val = bfd_get_32 (abfd, data);
df58fc94 2300 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
d6f16593 2301 {
df58fc94
RS
2302 second = val & 0xffff;
2303 first = val >> 16;
2304 }
2305 else if (r_type != R_MIPS16_26)
2306 {
2307 second = ((val >> 11) & 0xffe0) | (val & 0x1f);
2308 first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
d6f16593
MR
2309 }
2310 else
2311 {
df58fc94
RS
2312 second = val & 0xffff;
2313 first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
2314 | ((val >> 21) & 0x1f);
d6f16593 2315 }
df58fc94
RS
2316 bfd_put_16 (abfd, second, data + 2);
2317 bfd_put_16 (abfd, first, data);
d6f16593
MR
2318}
2319
b49e97c9 2320bfd_reloc_status_type
9719ad41
RS
2321_bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
2322 arelent *reloc_entry, asection *input_section,
2323 bfd_boolean relocatable, void *data, bfd_vma gp)
b49e97c9
TS
2324{
2325 bfd_vma relocation;
a7ebbfdf 2326 bfd_signed_vma val;
30ac9238 2327 bfd_reloc_status_type status;
b49e97c9
TS
2328
2329 if (bfd_is_com_section (symbol->section))
2330 relocation = 0;
2331 else
2332 relocation = symbol->value;
2333
2334 relocation += symbol->section->output_section->vma;
2335 relocation += symbol->section->output_offset;
2336
07515404 2337 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
b49e97c9
TS
2338 return bfd_reloc_outofrange;
2339
b49e97c9 2340 /* Set val to the offset into the section or symbol. */
a7ebbfdf
TS
2341 val = reloc_entry->addend;
2342
30ac9238 2343 _bfd_mips_elf_sign_extend (val, 16);
a7ebbfdf 2344
b49e97c9 2345 /* Adjust val for the final section location and GP value. If we
1049f94e 2346 are producing relocatable output, we don't want to do this for
b49e97c9 2347 an external symbol. */
1049f94e 2348 if (! relocatable
b49e97c9
TS
2349 || (symbol->flags & BSF_SECTION_SYM) != 0)
2350 val += relocation - gp;
2351
a7ebbfdf
TS
2352 if (reloc_entry->howto->partial_inplace)
2353 {
30ac9238
RS
2354 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2355 (bfd_byte *) data
2356 + reloc_entry->address);
2357 if (status != bfd_reloc_ok)
2358 return status;
a7ebbfdf
TS
2359 }
2360 else
2361 reloc_entry->addend = val;
b49e97c9 2362
1049f94e 2363 if (relocatable)
b49e97c9 2364 reloc_entry->address += input_section->output_offset;
30ac9238
RS
2365
2366 return bfd_reloc_ok;
2367}
2368
2369/* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2370 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
2371 that contains the relocation field and DATA points to the start of
2372 INPUT_SECTION. */
2373
2374struct mips_hi16
2375{
2376 struct mips_hi16 *next;
2377 bfd_byte *data;
2378 asection *input_section;
2379 arelent rel;
2380};
2381
2382/* FIXME: This should not be a static variable. */
2383
2384static struct mips_hi16 *mips_hi16_list;
2385
2386/* A howto special_function for REL *HI16 relocations. We can only
2387 calculate the correct value once we've seen the partnering
2388 *LO16 relocation, so just save the information for later.
2389
2390 The ABI requires that the *LO16 immediately follow the *HI16.
2391 However, as a GNU extension, we permit an arbitrary number of
2392 *HI16s to be associated with a single *LO16. This significantly
2393 simplies the relocation handling in gcc. */
2394
2395bfd_reloc_status_type
2396_bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2397 asymbol *symbol ATTRIBUTE_UNUSED, void *data,
2398 asection *input_section, bfd *output_bfd,
2399 char **error_message ATTRIBUTE_UNUSED)
2400{
2401 struct mips_hi16 *n;
2402
07515404 2403 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
30ac9238
RS
2404 return bfd_reloc_outofrange;
2405
2406 n = bfd_malloc (sizeof *n);
2407 if (n == NULL)
2408 return bfd_reloc_outofrange;
2409
2410 n->next = mips_hi16_list;
2411 n->data = data;
2412 n->input_section = input_section;
2413 n->rel = *reloc_entry;
2414 mips_hi16_list = n;
2415
2416 if (output_bfd != NULL)
2417 reloc_entry->address += input_section->output_offset;
2418
2419 return bfd_reloc_ok;
2420}
2421
738e5348 2422/* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just
30ac9238
RS
2423 like any other 16-bit relocation when applied to global symbols, but is
2424 treated in the same as R_MIPS_HI16 when applied to local symbols. */
2425
2426bfd_reloc_status_type
2427_bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2428 void *data, asection *input_section,
2429 bfd *output_bfd, char **error_message)
2430{
2431 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2432 || bfd_is_und_section (bfd_get_section (symbol))
2433 || bfd_is_com_section (bfd_get_section (symbol)))
2434 /* The relocation is against a global symbol. */
2435 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2436 input_section, output_bfd,
2437 error_message);
2438
2439 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
2440 input_section, output_bfd, error_message);
2441}
2442
2443/* A howto special_function for REL *LO16 relocations. The *LO16 itself
2444 is a straightforward 16 bit inplace relocation, but we must deal with
2445 any partnering high-part relocations as well. */
2446
2447bfd_reloc_status_type
2448_bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2449 void *data, asection *input_section,
2450 bfd *output_bfd, char **error_message)
2451{
2452 bfd_vma vallo;
d6f16593 2453 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
30ac9238 2454
07515404 2455 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
30ac9238
RS
2456 return bfd_reloc_outofrange;
2457
df58fc94 2458 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
d6f16593 2459 location);
df58fc94
RS
2460 vallo = bfd_get_32 (abfd, location);
2461 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2462 location);
d6f16593 2463
30ac9238
RS
2464 while (mips_hi16_list != NULL)
2465 {
2466 bfd_reloc_status_type ret;
2467 struct mips_hi16 *hi;
2468
2469 hi = mips_hi16_list;
2470
738e5348
RS
2471 /* R_MIPS*_GOT16 relocations are something of a special case. We
2472 want to install the addend in the same way as for a R_MIPS*_HI16
30ac9238
RS
2473 relocation (with a rightshift of 16). However, since GOT16
2474 relocations can also be used with global symbols, their howto
2475 has a rightshift of 0. */
2476 if (hi->rel.howto->type == R_MIPS_GOT16)
2477 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
738e5348
RS
2478 else if (hi->rel.howto->type == R_MIPS16_GOT16)
2479 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE);
df58fc94
RS
2480 else if (hi->rel.howto->type == R_MICROMIPS_GOT16)
2481 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MICROMIPS_HI16, FALSE);
30ac9238
RS
2482
2483 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
2484 carry or borrow will induce a change of +1 or -1 in the high part. */
2485 hi->rel.addend += (vallo + 0x8000) & 0xffff;
2486
30ac9238
RS
2487 ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
2488 hi->input_section, output_bfd,
2489 error_message);
2490 if (ret != bfd_reloc_ok)
2491 return ret;
2492
2493 mips_hi16_list = hi->next;
2494 free (hi);
2495 }
2496
2497 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2498 input_section, output_bfd,
2499 error_message);
2500}
2501
2502/* A generic howto special_function. This calculates and installs the
2503 relocation itself, thus avoiding the oft-discussed problems in
2504 bfd_perform_relocation and bfd_install_relocation. */
2505
2506bfd_reloc_status_type
2507_bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2508 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2509 asection *input_section, bfd *output_bfd,
2510 char **error_message ATTRIBUTE_UNUSED)
2511{
2512 bfd_signed_vma val;
2513 bfd_reloc_status_type status;
2514 bfd_boolean relocatable;
2515
2516 relocatable = (output_bfd != NULL);
2517
07515404 2518 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
30ac9238
RS
2519 return bfd_reloc_outofrange;
2520
2521 /* Build up the field adjustment in VAL. */
2522 val = 0;
2523 if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
2524 {
2525 /* Either we're calculating the final field value or we have a
2526 relocation against a section symbol. Add in the section's
2527 offset or address. */
2528 val += symbol->section->output_section->vma;
2529 val += symbol->section->output_offset;
2530 }
2531
2532 if (!relocatable)
2533 {
2534 /* We're calculating the final field value. Add in the symbol's value
2535 and, if pc-relative, subtract the address of the field itself. */
2536 val += symbol->value;
2537 if (reloc_entry->howto->pc_relative)
2538 {
2539 val -= input_section->output_section->vma;
2540 val -= input_section->output_offset;
2541 val -= reloc_entry->address;
2542 }
2543 }
2544
2545 /* VAL is now the final adjustment. If we're keeping this relocation
2546 in the output file, and if the relocation uses a separate addend,
2547 we just need to add VAL to that addend. Otherwise we need to add
2548 VAL to the relocation field itself. */
2549 if (relocatable && !reloc_entry->howto->partial_inplace)
2550 reloc_entry->addend += val;
2551 else
2552 {
d6f16593
MR
2553 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2554
30ac9238
RS
2555 /* Add in the separate addend, if any. */
2556 val += reloc_entry->addend;
2557
2558 /* Add VAL to the relocation field. */
df58fc94
RS
2559 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2560 location);
30ac9238 2561 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
d6f16593 2562 location);
df58fc94
RS
2563 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2564 location);
d6f16593 2565
30ac9238
RS
2566 if (status != bfd_reloc_ok)
2567 return status;
2568 }
2569
2570 if (relocatable)
2571 reloc_entry->address += input_section->output_offset;
b49e97c9
TS
2572
2573 return bfd_reloc_ok;
2574}
2575\f
2576/* Swap an entry in a .gptab section. Note that these routines rely
2577 on the equivalence of the two elements of the union. */
2578
2579static void
9719ad41
RS
2580bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
2581 Elf32_gptab *in)
b49e97c9
TS
2582{
2583 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
2584 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
2585}
2586
2587static void
9719ad41
RS
2588bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
2589 Elf32_External_gptab *ex)
b49e97c9
TS
2590{
2591 H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
2592 H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
2593}
2594
2595static void
9719ad41
RS
2596bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
2597 Elf32_External_compact_rel *ex)
b49e97c9
TS
2598{
2599 H_PUT_32 (abfd, in->id1, ex->id1);
2600 H_PUT_32 (abfd, in->num, ex->num);
2601 H_PUT_32 (abfd, in->id2, ex->id2);
2602 H_PUT_32 (abfd, in->offset, ex->offset);
2603 H_PUT_32 (abfd, in->reserved0, ex->reserved0);
2604 H_PUT_32 (abfd, in->reserved1, ex->reserved1);
2605}
2606
2607static void
9719ad41
RS
2608bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
2609 Elf32_External_crinfo *ex)
b49e97c9
TS
2610{
2611 unsigned long l;
2612
2613 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2614 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2615 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2616 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2617 H_PUT_32 (abfd, l, ex->info);
2618 H_PUT_32 (abfd, in->konst, ex->konst);
2619 H_PUT_32 (abfd, in->vaddr, ex->vaddr);
2620}
b49e97c9
TS
2621\f
2622/* A .reginfo section holds a single Elf32_RegInfo structure. These
2623 routines swap this structure in and out. They are used outside of
2624 BFD, so they are globally visible. */
2625
2626void
9719ad41
RS
2627bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
2628 Elf32_RegInfo *in)
b49e97c9
TS
2629{
2630 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2631 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2632 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2633 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2634 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2635 in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
2636}
2637
2638void
9719ad41
RS
2639bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
2640 Elf32_External_RegInfo *ex)
b49e97c9
TS
2641{
2642 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2643 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2644 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2645 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2646 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2647 H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
2648}
2649
2650/* In the 64 bit ABI, the .MIPS.options section holds register
2651 information in an Elf64_Reginfo structure. These routines swap
2652 them in and out. They are globally visible because they are used
2653 outside of BFD. These routines are here so that gas can call them
2654 without worrying about whether the 64 bit ABI has been included. */
2655
2656void
9719ad41
RS
2657bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
2658 Elf64_Internal_RegInfo *in)
b49e97c9
TS
2659{
2660 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2661 in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
2662 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2663 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2664 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2665 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2666 in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
2667}
2668
2669void
9719ad41
RS
2670bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
2671 Elf64_External_RegInfo *ex)
b49e97c9
TS
2672{
2673 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2674 H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
2675 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2676 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2677 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2678 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2679 H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
2680}
2681
2682/* Swap in an options header. */
2683
2684void
9719ad41
RS
2685bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
2686 Elf_Internal_Options *in)
b49e97c9
TS
2687{
2688 in->kind = H_GET_8 (abfd, ex->kind);
2689 in->size = H_GET_8 (abfd, ex->size);
2690 in->section = H_GET_16 (abfd, ex->section);
2691 in->info = H_GET_32 (abfd, ex->info);
2692}
2693
2694/* Swap out an options header. */
2695
2696void
9719ad41
RS
2697bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
2698 Elf_External_Options *ex)
b49e97c9
TS
2699{
2700 H_PUT_8 (abfd, in->kind, ex->kind);
2701 H_PUT_8 (abfd, in->size, ex->size);
2702 H_PUT_16 (abfd, in->section, ex->section);
2703 H_PUT_32 (abfd, in->info, ex->info);
2704}
351cdf24
MF
2705
2706/* Swap in an abiflags structure. */
2707
2708void
2709bfd_mips_elf_swap_abiflags_v0_in (bfd *abfd,
2710 const Elf_External_ABIFlags_v0 *ex,
2711 Elf_Internal_ABIFlags_v0 *in)
2712{
2713 in->version = H_GET_16 (abfd, ex->version);
2714 in->isa_level = H_GET_8 (abfd, ex->isa_level);
2715 in->isa_rev = H_GET_8 (abfd, ex->isa_rev);
2716 in->gpr_size = H_GET_8 (abfd, ex->gpr_size);
2717 in->cpr1_size = H_GET_8 (abfd, ex->cpr1_size);
2718 in->cpr2_size = H_GET_8 (abfd, ex->cpr2_size);
2719 in->fp_abi = H_GET_8 (abfd, ex->fp_abi);
2720 in->isa_ext = H_GET_32 (abfd, ex->isa_ext);
2721 in->ases = H_GET_32 (abfd, ex->ases);
2722 in->flags1 = H_GET_32 (abfd, ex->flags1);
2723 in->flags2 = H_GET_32 (abfd, ex->flags2);
2724}
2725
2726/* Swap out an abiflags structure. */
2727
2728void
2729bfd_mips_elf_swap_abiflags_v0_out (bfd *abfd,
2730 const Elf_Internal_ABIFlags_v0 *in,
2731 Elf_External_ABIFlags_v0 *ex)
2732{
2733 H_PUT_16 (abfd, in->version, ex->version);
2734 H_PUT_8 (abfd, in->isa_level, ex->isa_level);
2735 H_PUT_8 (abfd, in->isa_rev, ex->isa_rev);
2736 H_PUT_8 (abfd, in->gpr_size, ex->gpr_size);
2737 H_PUT_8 (abfd, in->cpr1_size, ex->cpr1_size);
2738 H_PUT_8 (abfd, in->cpr2_size, ex->cpr2_size);
2739 H_PUT_8 (abfd, in->fp_abi, ex->fp_abi);
2740 H_PUT_32 (abfd, in->isa_ext, ex->isa_ext);
2741 H_PUT_32 (abfd, in->ases, ex->ases);
2742 H_PUT_32 (abfd, in->flags1, ex->flags1);
2743 H_PUT_32 (abfd, in->flags2, ex->flags2);
2744}
b49e97c9
TS
2745\f
2746/* This function is called via qsort() to sort the dynamic relocation
2747 entries by increasing r_symndx value. */
2748
2749static int
9719ad41 2750sort_dynamic_relocs (const void *arg1, const void *arg2)
b49e97c9 2751{
947216bf
AM
2752 Elf_Internal_Rela int_reloc1;
2753 Elf_Internal_Rela int_reloc2;
6870500c 2754 int diff;
b49e97c9 2755
947216bf
AM
2756 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
2757 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
b49e97c9 2758
6870500c
RS
2759 diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
2760 if (diff != 0)
2761 return diff;
2762
2763 if (int_reloc1.r_offset < int_reloc2.r_offset)
2764 return -1;
2765 if (int_reloc1.r_offset > int_reloc2.r_offset)
2766 return 1;
2767 return 0;
b49e97c9
TS
2768}
2769
f4416af6
AO
2770/* Like sort_dynamic_relocs, but used for elf64 relocations. */
2771
2772static int
7e3102a7
AM
2773sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
2774 const void *arg2 ATTRIBUTE_UNUSED)
f4416af6 2775{
7e3102a7 2776#ifdef BFD64
f4416af6
AO
2777 Elf_Internal_Rela int_reloc1[3];
2778 Elf_Internal_Rela int_reloc2[3];
2779
2780 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2781 (reldyn_sorting_bfd, arg1, int_reloc1);
2782 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2783 (reldyn_sorting_bfd, arg2, int_reloc2);
2784
6870500c
RS
2785 if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
2786 return -1;
2787 if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
2788 return 1;
2789
2790 if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
2791 return -1;
2792 if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
2793 return 1;
2794 return 0;
7e3102a7
AM
2795#else
2796 abort ();
2797#endif
f4416af6
AO
2798}
2799
2800
b49e97c9
TS
2801/* This routine is used to write out ECOFF debugging external symbol
2802 information. It is called via mips_elf_link_hash_traverse. The
2803 ECOFF external symbol information must match the ELF external
2804 symbol information. Unfortunately, at this point we don't know
2805 whether a symbol is required by reloc information, so the two
2806 tables may wind up being different. We must sort out the external
2807 symbol information before we can set the final size of the .mdebug
2808 section, and we must set the size of the .mdebug section before we
2809 can relocate any sections, and we can't know which symbols are
2810 required by relocation until we relocate the sections.
2811 Fortunately, it is relatively unlikely that any symbol will be
2812 stripped but required by a reloc. In particular, it can not happen
2813 when generating a final executable. */
2814
b34976b6 2815static bfd_boolean
9719ad41 2816mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
b49e97c9 2817{
9719ad41 2818 struct extsym_info *einfo = data;
b34976b6 2819 bfd_boolean strip;
b49e97c9
TS
2820 asection *sec, *output_section;
2821
b49e97c9 2822 if (h->root.indx == -2)
b34976b6 2823 strip = FALSE;
f5385ebf 2824 else if ((h->root.def_dynamic
77cfaee6
AM
2825 || h->root.ref_dynamic
2826 || h->root.type == bfd_link_hash_new)
f5385ebf
AM
2827 && !h->root.def_regular
2828 && !h->root.ref_regular)
b34976b6 2829 strip = TRUE;
b49e97c9
TS
2830 else if (einfo->info->strip == strip_all
2831 || (einfo->info->strip == strip_some
2832 && bfd_hash_lookup (einfo->info->keep_hash,
2833 h->root.root.root.string,
b34976b6
AM
2834 FALSE, FALSE) == NULL))
2835 strip = TRUE;
b49e97c9 2836 else
b34976b6 2837 strip = FALSE;
b49e97c9
TS
2838
2839 if (strip)
b34976b6 2840 return TRUE;
b49e97c9
TS
2841
2842 if (h->esym.ifd == -2)
2843 {
2844 h->esym.jmptbl = 0;
2845 h->esym.cobol_main = 0;
2846 h->esym.weakext = 0;
2847 h->esym.reserved = 0;
2848 h->esym.ifd = ifdNil;
2849 h->esym.asym.value = 0;
2850 h->esym.asym.st = stGlobal;
2851
2852 if (h->root.root.type == bfd_link_hash_undefined
2853 || h->root.root.type == bfd_link_hash_undefweak)
2854 {
2855 const char *name;
2856
2857 /* Use undefined class. Also, set class and type for some
2858 special symbols. */
2859 name = h->root.root.root.string;
2860 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
2861 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
2862 {
2863 h->esym.asym.sc = scData;
2864 h->esym.asym.st = stLabel;
2865 h->esym.asym.value = 0;
2866 }
2867 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
2868 {
2869 h->esym.asym.sc = scAbs;
2870 h->esym.asym.st = stLabel;
2871 h->esym.asym.value =
2872 mips_elf_hash_table (einfo->info)->procedure_count;
2873 }
4a14403c 2874 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
b49e97c9
TS
2875 {
2876 h->esym.asym.sc = scAbs;
2877 h->esym.asym.st = stLabel;
2878 h->esym.asym.value = elf_gp (einfo->abfd);
2879 }
2880 else
2881 h->esym.asym.sc = scUndefined;
2882 }
2883 else if (h->root.root.type != bfd_link_hash_defined
2884 && h->root.root.type != bfd_link_hash_defweak)
2885 h->esym.asym.sc = scAbs;
2886 else
2887 {
2888 const char *name;
2889
2890 sec = h->root.root.u.def.section;
2891 output_section = sec->output_section;
2892
2893 /* When making a shared library and symbol h is the one from
2894 the another shared library, OUTPUT_SECTION may be null. */
2895 if (output_section == NULL)
2896 h->esym.asym.sc = scUndefined;
2897 else
2898 {
2899 name = bfd_section_name (output_section->owner, output_section);
2900
2901 if (strcmp (name, ".text") == 0)
2902 h->esym.asym.sc = scText;
2903 else if (strcmp (name, ".data") == 0)
2904 h->esym.asym.sc = scData;
2905 else if (strcmp (name, ".sdata") == 0)
2906 h->esym.asym.sc = scSData;
2907 else if (strcmp (name, ".rodata") == 0
2908 || strcmp (name, ".rdata") == 0)
2909 h->esym.asym.sc = scRData;
2910 else if (strcmp (name, ".bss") == 0)
2911 h->esym.asym.sc = scBss;
2912 else if (strcmp (name, ".sbss") == 0)
2913 h->esym.asym.sc = scSBss;
2914 else if (strcmp (name, ".init") == 0)
2915 h->esym.asym.sc = scInit;
2916 else if (strcmp (name, ".fini") == 0)
2917 h->esym.asym.sc = scFini;
2918 else
2919 h->esym.asym.sc = scAbs;
2920 }
2921 }
2922
2923 h->esym.asym.reserved = 0;
2924 h->esym.asym.index = indexNil;
2925 }
2926
2927 if (h->root.root.type == bfd_link_hash_common)
2928 h->esym.asym.value = h->root.root.u.c.size;
2929 else if (h->root.root.type == bfd_link_hash_defined
2930 || h->root.root.type == bfd_link_hash_defweak)
2931 {
2932 if (h->esym.asym.sc == scCommon)
2933 h->esym.asym.sc = scBss;
2934 else if (h->esym.asym.sc == scSCommon)
2935 h->esym.asym.sc = scSBss;
2936
2937 sec = h->root.root.u.def.section;
2938 output_section = sec->output_section;
2939 if (output_section != NULL)
2940 h->esym.asym.value = (h->root.root.u.def.value
2941 + sec->output_offset
2942 + output_section->vma);
2943 else
2944 h->esym.asym.value = 0;
2945 }
33bb52fb 2946 else
b49e97c9
TS
2947 {
2948 struct mips_elf_link_hash_entry *hd = h;
b49e97c9
TS
2949
2950 while (hd->root.root.type == bfd_link_hash_indirect)
33bb52fb 2951 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
b49e97c9 2952
33bb52fb 2953 if (hd->needs_lazy_stub)
b49e97c9 2954 {
1bbce132
MR
2955 BFD_ASSERT (hd->root.plt.plist != NULL);
2956 BFD_ASSERT (hd->root.plt.plist->stub_offset != MINUS_ONE);
b49e97c9
TS
2957 /* Set type and value for a symbol with a function stub. */
2958 h->esym.asym.st = stProc;
2959 sec = hd->root.root.u.def.section;
2960 if (sec == NULL)
2961 h->esym.asym.value = 0;
2962 else
2963 {
2964 output_section = sec->output_section;
2965 if (output_section != NULL)
1bbce132 2966 h->esym.asym.value = (hd->root.plt.plist->stub_offset
b49e97c9
TS
2967 + sec->output_offset
2968 + output_section->vma);
2969 else
2970 h->esym.asym.value = 0;
2971 }
b49e97c9
TS
2972 }
2973 }
2974
2975 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2976 h->root.root.root.string,
2977 &h->esym))
2978 {
b34976b6
AM
2979 einfo->failed = TRUE;
2980 return FALSE;
b49e97c9
TS
2981 }
2982
b34976b6 2983 return TRUE;
b49e97c9
TS
2984}
2985
2986/* A comparison routine used to sort .gptab entries. */
2987
2988static int
9719ad41 2989gptab_compare (const void *p1, const void *p2)
b49e97c9 2990{
9719ad41
RS
2991 const Elf32_gptab *a1 = p1;
2992 const Elf32_gptab *a2 = p2;
b49e97c9
TS
2993
2994 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
2995}
2996\f
b15e6682 2997/* Functions to manage the got entry hash table. */
f4416af6
AO
2998
2999/* Use all 64 bits of a bfd_vma for the computation of a 32-bit
3000 hash number. */
3001
3002static INLINE hashval_t
9719ad41 3003mips_elf_hash_bfd_vma (bfd_vma addr)
f4416af6
AO
3004{
3005#ifdef BFD64
3006 return addr + (addr >> 32);
3007#else
3008 return addr;
3009#endif
3010}
3011
f4416af6 3012static hashval_t
d9bf376d 3013mips_elf_got_entry_hash (const void *entry_)
f4416af6
AO
3014{
3015 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
3016
e641e783 3017 return (entry->symndx
9ab066b4
RS
3018 + ((entry->tls_type == GOT_TLS_LDM) << 18)
3019 + (entry->tls_type == GOT_TLS_LDM ? 0
e641e783
RS
3020 : !entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
3021 : entry->symndx >= 0 ? (entry->abfd->id
3022 + mips_elf_hash_bfd_vma (entry->d.addend))
3023 : entry->d.h->root.root.root.hash));
f4416af6
AO
3024}
3025
3026static int
3dff0dd1 3027mips_elf_got_entry_eq (const void *entry1, const void *entry2)
f4416af6
AO
3028{
3029 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
3030 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
3031
e641e783 3032 return (e1->symndx == e2->symndx
9ab066b4
RS
3033 && e1->tls_type == e2->tls_type
3034 && (e1->tls_type == GOT_TLS_LDM ? TRUE
e641e783
RS
3035 : !e1->abfd ? !e2->abfd && e1->d.address == e2->d.address
3036 : e1->symndx >= 0 ? (e1->abfd == e2->abfd
3037 && e1->d.addend == e2->d.addend)
3038 : e2->abfd && e1->d.h == e2->d.h));
b15e6682 3039}
c224138d 3040
13db6b44
RS
3041static hashval_t
3042mips_got_page_ref_hash (const void *ref_)
3043{
3044 const struct mips_got_page_ref *ref;
3045
3046 ref = (const struct mips_got_page_ref *) ref_;
3047 return ((ref->symndx >= 0
3048 ? (hashval_t) (ref->u.abfd->id + ref->symndx)
3049 : ref->u.h->root.root.root.hash)
3050 + mips_elf_hash_bfd_vma (ref->addend));
3051}
3052
3053static int
3054mips_got_page_ref_eq (const void *ref1_, const void *ref2_)
3055{
3056 const struct mips_got_page_ref *ref1, *ref2;
3057
3058 ref1 = (const struct mips_got_page_ref *) ref1_;
3059 ref2 = (const struct mips_got_page_ref *) ref2_;
3060 return (ref1->symndx == ref2->symndx
3061 && (ref1->symndx < 0
3062 ? ref1->u.h == ref2->u.h
3063 : ref1->u.abfd == ref2->u.abfd)
3064 && ref1->addend == ref2->addend);
3065}
3066
c224138d
RS
3067static hashval_t
3068mips_got_page_entry_hash (const void *entry_)
3069{
3070 const struct mips_got_page_entry *entry;
3071
3072 entry = (const struct mips_got_page_entry *) entry_;
13db6b44 3073 return entry->sec->id;
c224138d
RS
3074}
3075
3076static int
3077mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
3078{
3079 const struct mips_got_page_entry *entry1, *entry2;
3080
3081 entry1 = (const struct mips_got_page_entry *) entry1_;
3082 entry2 = (const struct mips_got_page_entry *) entry2_;
13db6b44 3083 return entry1->sec == entry2->sec;
c224138d 3084}
b15e6682 3085\f
3dff0dd1 3086/* Create and return a new mips_got_info structure. */
5334aa52
RS
3087
3088static struct mips_got_info *
3dff0dd1 3089mips_elf_create_got_info (bfd *abfd)
5334aa52
RS
3090{
3091 struct mips_got_info *g;
3092
3093 g = bfd_zalloc (abfd, sizeof (struct mips_got_info));
3094 if (g == NULL)
3095 return NULL;
3096
3dff0dd1
RS
3097 g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
3098 mips_elf_got_entry_eq, NULL);
5334aa52
RS
3099 if (g->got_entries == NULL)
3100 return NULL;
3101
13db6b44
RS
3102 g->got_page_refs = htab_try_create (1, mips_got_page_ref_hash,
3103 mips_got_page_ref_eq, NULL);
3104 if (g->got_page_refs == NULL)
5334aa52
RS
3105 return NULL;
3106
3107 return g;
3108}
3109
ee227692
RS
3110/* Return the GOT info for input bfd ABFD, trying to create a new one if
3111 CREATE_P and if ABFD doesn't already have a GOT. */
3112
3113static struct mips_got_info *
3114mips_elf_bfd_got (bfd *abfd, bfd_boolean create_p)
3115{
3116 struct mips_elf_obj_tdata *tdata;
3117
3118 if (!is_mips_elf (abfd))
3119 return NULL;
3120
3121 tdata = mips_elf_tdata (abfd);
3122 if (!tdata->got && create_p)
3dff0dd1 3123 tdata->got = mips_elf_create_got_info (abfd);
ee227692
RS
3124 return tdata->got;
3125}
3126
d7206569
RS
3127/* Record that ABFD should use output GOT G. */
3128
3129static void
3130mips_elf_replace_bfd_got (bfd *abfd, struct mips_got_info *g)
3131{
3132 struct mips_elf_obj_tdata *tdata;
3133
3134 BFD_ASSERT (is_mips_elf (abfd));
3135 tdata = mips_elf_tdata (abfd);
3136 if (tdata->got)
3137 {
3138 /* The GOT structure itself and the hash table entries are
3139 allocated to a bfd, but the hash tables aren't. */
3140 htab_delete (tdata->got->got_entries);
13db6b44
RS
3141 htab_delete (tdata->got->got_page_refs);
3142 if (tdata->got->got_page_entries)
3143 htab_delete (tdata->got->got_page_entries);
d7206569
RS
3144 }
3145 tdata->got = g;
3146}
3147
0a44bf69
RS
3148/* Return the dynamic relocation section. If it doesn't exist, try to
3149 create a new it if CREATE_P, otherwise return NULL. Also return NULL
3150 if creation fails. */
f4416af6
AO
3151
3152static asection *
0a44bf69 3153mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
f4416af6 3154{
0a44bf69 3155 const char *dname;
f4416af6 3156 asection *sreloc;
0a44bf69 3157 bfd *dynobj;
f4416af6 3158
0a44bf69
RS
3159 dname = MIPS_ELF_REL_DYN_NAME (info);
3160 dynobj = elf_hash_table (info)->dynobj;
3d4d4302 3161 sreloc = bfd_get_linker_section (dynobj, dname);
f4416af6
AO
3162 if (sreloc == NULL && create_p)
3163 {
3d4d4302
AM
3164 sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
3165 (SEC_ALLOC
3166 | SEC_LOAD
3167 | SEC_HAS_CONTENTS
3168 | SEC_IN_MEMORY
3169 | SEC_LINKER_CREATED
3170 | SEC_READONLY));
f4416af6 3171 if (sreloc == NULL
f4416af6 3172 || ! bfd_set_section_alignment (dynobj, sreloc,
d80dcc6a 3173 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
f4416af6
AO
3174 return NULL;
3175 }
3176 return sreloc;
3177}
3178
e641e783
RS
3179/* Return the GOT_TLS_* type required by relocation type R_TYPE. */
3180
3181static int
3182mips_elf_reloc_tls_type (unsigned int r_type)
3183{
3184 if (tls_gd_reloc_p (r_type))
3185 return GOT_TLS_GD;
3186
3187 if (tls_ldm_reloc_p (r_type))
3188 return GOT_TLS_LDM;
3189
3190 if (tls_gottprel_reloc_p (r_type))
3191 return GOT_TLS_IE;
3192
9ab066b4 3193 return GOT_TLS_NONE;
e641e783
RS
3194}
3195
3196/* Return the number of GOT slots needed for GOT TLS type TYPE. */
3197
3198static int
3199mips_tls_got_entries (unsigned int type)
3200{
3201 switch (type)
3202 {
3203 case GOT_TLS_GD:
3204 case GOT_TLS_LDM:
3205 return 2;
3206
3207 case GOT_TLS_IE:
3208 return 1;
3209
9ab066b4 3210 case GOT_TLS_NONE:
e641e783
RS
3211 return 0;
3212 }
3213 abort ();
3214}
3215
0f20cc35
DJ
3216/* Count the number of relocations needed for a TLS GOT entry, with
3217 access types from TLS_TYPE, and symbol H (or a local symbol if H
3218 is NULL). */
3219
3220static int
3221mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
3222 struct elf_link_hash_entry *h)
3223{
3224 int indx = 0;
0f20cc35
DJ
3225 bfd_boolean need_relocs = FALSE;
3226 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3227
3228 if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3229 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h)))
3230 indx = h->dynindx;
3231
3232 if ((info->shared || indx != 0)
3233 && (h == NULL
3234 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3235 || h->root.type != bfd_link_hash_undefweak))
3236 need_relocs = TRUE;
3237
3238 if (!need_relocs)
e641e783 3239 return 0;
0f20cc35 3240
9ab066b4 3241 switch (tls_type)
0f20cc35 3242 {
e641e783
RS
3243 case GOT_TLS_GD:
3244 return indx != 0 ? 2 : 1;
0f20cc35 3245
e641e783
RS
3246 case GOT_TLS_IE:
3247 return 1;
0f20cc35 3248
e641e783
RS
3249 case GOT_TLS_LDM:
3250 return info->shared ? 1 : 0;
0f20cc35 3251
e641e783
RS
3252 default:
3253 return 0;
3254 }
0f20cc35
DJ
3255}
3256
ab361d49
RS
3257/* Add the number of GOT entries and TLS relocations required by ENTRY
3258 to G. */
0f20cc35 3259
ab361d49
RS
3260static void
3261mips_elf_count_got_entry (struct bfd_link_info *info,
3262 struct mips_got_info *g,
3263 struct mips_got_entry *entry)
0f20cc35 3264{
9ab066b4 3265 if (entry->tls_type)
ab361d49 3266 {
9ab066b4
RS
3267 g->tls_gotno += mips_tls_got_entries (entry->tls_type);
3268 g->relocs += mips_tls_got_relocs (info, entry->tls_type,
ab361d49
RS
3269 entry->symndx < 0
3270 ? &entry->d.h->root : NULL);
3271 }
3272 else if (entry->symndx >= 0 || entry->d.h->global_got_area == GGA_NONE)
3273 g->local_gotno += 1;
3274 else
3275 g->global_gotno += 1;
0f20cc35
DJ
3276}
3277
0f20cc35
DJ
3278/* Output a simple dynamic relocation into SRELOC. */
3279
3280static void
3281mips_elf_output_dynamic_relocation (bfd *output_bfd,
3282 asection *sreloc,
861fb55a 3283 unsigned long reloc_index,
0f20cc35
DJ
3284 unsigned long indx,
3285 int r_type,
3286 bfd_vma offset)
3287{
3288 Elf_Internal_Rela rel[3];
3289
3290 memset (rel, 0, sizeof (rel));
3291
3292 rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
3293 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
3294
3295 if (ABI_64_P (output_bfd))
3296 {
3297 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
3298 (output_bfd, &rel[0],
3299 (sreloc->contents
861fb55a 3300 + reloc_index * sizeof (Elf64_Mips_External_Rel)));
0f20cc35
DJ
3301 }
3302 else
3303 bfd_elf32_swap_reloc_out
3304 (output_bfd, &rel[0],
3305 (sreloc->contents
861fb55a 3306 + reloc_index * sizeof (Elf32_External_Rel)));
0f20cc35
DJ
3307}
3308
3309/* Initialize a set of TLS GOT entries for one symbol. */
3310
3311static void
9ab066b4
RS
3312mips_elf_initialize_tls_slots (bfd *abfd, struct bfd_link_info *info,
3313 struct mips_got_entry *entry,
0f20cc35
DJ
3314 struct mips_elf_link_hash_entry *h,
3315 bfd_vma value)
3316{
23cc69b6 3317 struct mips_elf_link_hash_table *htab;
0f20cc35
DJ
3318 int indx;
3319 asection *sreloc, *sgot;
9ab066b4 3320 bfd_vma got_offset, got_offset2;
0f20cc35
DJ
3321 bfd_boolean need_relocs = FALSE;
3322
23cc69b6 3323 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
3324 if (htab == NULL)
3325 return;
3326
23cc69b6 3327 sgot = htab->sgot;
0f20cc35
DJ
3328
3329 indx = 0;
3330 if (h != NULL)
3331 {
3332 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3333
3334 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root)
3335 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
3336 indx = h->root.dynindx;
3337 }
3338
9ab066b4 3339 if (entry->tls_initialized)
0f20cc35
DJ
3340 return;
3341
3342 if ((info->shared || indx != 0)
3343 && (h == NULL
3344 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
3345 || h->root.type != bfd_link_hash_undefweak))
3346 need_relocs = TRUE;
3347
3348 /* MINUS_ONE means the symbol is not defined in this object. It may not
3349 be defined at all; assume that the value doesn't matter in that
3350 case. Otherwise complain if we would use the value. */
3351 BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
3352 || h->root.root.type == bfd_link_hash_undefweak);
3353
3354 /* Emit necessary relocations. */
0a44bf69 3355 sreloc = mips_elf_rel_dyn_section (info, FALSE);
9ab066b4 3356 got_offset = entry->gotidx;
0f20cc35 3357
9ab066b4 3358 switch (entry->tls_type)
0f20cc35 3359 {
e641e783
RS
3360 case GOT_TLS_GD:
3361 /* General Dynamic. */
3362 got_offset2 = got_offset + MIPS_ELF_GOT_SIZE (abfd);
0f20cc35
DJ
3363
3364 if (need_relocs)
3365 {
3366 mips_elf_output_dynamic_relocation
861fb55a 3367 (abfd, sreloc, sreloc->reloc_count++, indx,
0f20cc35 3368 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
e641e783 3369 sgot->output_offset + sgot->output_section->vma + got_offset);
0f20cc35
DJ
3370
3371 if (indx)
3372 mips_elf_output_dynamic_relocation
861fb55a 3373 (abfd, sreloc, sreloc->reloc_count++, indx,
0f20cc35 3374 ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
e641e783 3375 sgot->output_offset + sgot->output_section->vma + got_offset2);
0f20cc35
DJ
3376 else
3377 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
e641e783 3378 sgot->contents + got_offset2);
0f20cc35
DJ
3379 }
3380 else
3381 {
3382 MIPS_ELF_PUT_WORD (abfd, 1,
e641e783 3383 sgot->contents + got_offset);
0f20cc35 3384 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
e641e783 3385 sgot->contents + got_offset2);
0f20cc35 3386 }
e641e783 3387 break;
0f20cc35 3388
e641e783
RS
3389 case GOT_TLS_IE:
3390 /* Initial Exec model. */
0f20cc35
DJ
3391 if (need_relocs)
3392 {
3393 if (indx == 0)
3394 MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
e641e783 3395 sgot->contents + got_offset);
0f20cc35
DJ
3396 else
3397 MIPS_ELF_PUT_WORD (abfd, 0,
e641e783 3398 sgot->contents + got_offset);
0f20cc35
DJ
3399
3400 mips_elf_output_dynamic_relocation
861fb55a 3401 (abfd, sreloc, sreloc->reloc_count++, indx,
0f20cc35 3402 ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
e641e783 3403 sgot->output_offset + sgot->output_section->vma + got_offset);
0f20cc35
DJ
3404 }
3405 else
3406 MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
e641e783
RS
3407 sgot->contents + got_offset);
3408 break;
0f20cc35 3409
e641e783 3410 case GOT_TLS_LDM:
0f20cc35
DJ
3411 /* The initial offset is zero, and the LD offsets will include the
3412 bias by DTP_OFFSET. */
3413 MIPS_ELF_PUT_WORD (abfd, 0,
3414 sgot->contents + got_offset
3415 + MIPS_ELF_GOT_SIZE (abfd));
3416
3417 if (!info->shared)
3418 MIPS_ELF_PUT_WORD (abfd, 1,
3419 sgot->contents + got_offset);
3420 else
3421 mips_elf_output_dynamic_relocation
861fb55a 3422 (abfd, sreloc, sreloc->reloc_count++, indx,
0f20cc35
DJ
3423 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3424 sgot->output_offset + sgot->output_section->vma + got_offset);
e641e783
RS
3425 break;
3426
3427 default:
3428 abort ();
0f20cc35
DJ
3429 }
3430
9ab066b4 3431 entry->tls_initialized = TRUE;
e641e783 3432}
0f20cc35 3433
0a44bf69
RS
3434/* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3435 for global symbol H. .got.plt comes before the GOT, so the offset
3436 will be negative. */
3437
3438static bfd_vma
3439mips_elf_gotplt_index (struct bfd_link_info *info,
3440 struct elf_link_hash_entry *h)
3441{
1bbce132 3442 bfd_vma got_address, got_value;
0a44bf69
RS
3443 struct mips_elf_link_hash_table *htab;
3444
3445 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
3446 BFD_ASSERT (htab != NULL);
3447
1bbce132
MR
3448 BFD_ASSERT (h->plt.plist != NULL);
3449 BFD_ASSERT (h->plt.plist->gotplt_index != MINUS_ONE);
0a44bf69
RS
3450
3451 /* Calculate the address of the associated .got.plt entry. */
3452 got_address = (htab->sgotplt->output_section->vma
3453 + htab->sgotplt->output_offset
1bbce132
MR
3454 + (h->plt.plist->gotplt_index
3455 * MIPS_ELF_GOT_SIZE (info->output_bfd)));
0a44bf69
RS
3456
3457 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
3458 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
3459 + htab->root.hgot->root.u.def.section->output_offset
3460 + htab->root.hgot->root.u.def.value);
3461
3462 return got_address - got_value;
3463}
3464
5c18022e 3465/* Return the GOT offset for address VALUE. If there is not yet a GOT
0a44bf69
RS
3466 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
3467 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
3468 offset can be found. */
b49e97c9
TS
3469
3470static bfd_vma
9719ad41 3471mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
5c18022e 3472 bfd_vma value, unsigned long r_symndx,
0f20cc35 3473 struct mips_elf_link_hash_entry *h, int r_type)
b49e97c9 3474{
a8028dd0 3475 struct mips_elf_link_hash_table *htab;
b15e6682 3476 struct mips_got_entry *entry;
b49e97c9 3477
a8028dd0 3478 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
3479 BFD_ASSERT (htab != NULL);
3480
a8028dd0
RS
3481 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value,
3482 r_symndx, h, r_type);
0f20cc35 3483 if (!entry)
b15e6682 3484 return MINUS_ONE;
0f20cc35 3485
e641e783 3486 if (entry->tls_type)
9ab066b4
RS
3487 mips_elf_initialize_tls_slots (abfd, info, entry, h, value);
3488 return entry->gotidx;
b49e97c9
TS
3489}
3490
13fbec83 3491/* Return the GOT index of global symbol H in the primary GOT. */
b49e97c9
TS
3492
3493static bfd_vma
13fbec83
RS
3494mips_elf_primary_global_got_index (bfd *obfd, struct bfd_link_info *info,
3495 struct elf_link_hash_entry *h)
3496{
3497 struct mips_elf_link_hash_table *htab;
3498 long global_got_dynindx;
3499 struct mips_got_info *g;
3500 bfd_vma got_index;
3501
3502 htab = mips_elf_hash_table (info);
3503 BFD_ASSERT (htab != NULL);
3504
3505 global_got_dynindx = 0;
3506 if (htab->global_gotsym != NULL)
3507 global_got_dynindx = htab->global_gotsym->dynindx;
3508
3509 /* Once we determine the global GOT entry with the lowest dynamic
3510 symbol table index, we must put all dynamic symbols with greater
3511 indices into the primary GOT. That makes it easy to calculate the
3512 GOT offset. */
3513 BFD_ASSERT (h->dynindx >= global_got_dynindx);
3514 g = mips_elf_bfd_got (obfd, FALSE);
3515 got_index = ((h->dynindx - global_got_dynindx + g->local_gotno)
3516 * MIPS_ELF_GOT_SIZE (obfd));
3517 BFD_ASSERT (got_index < htab->sgot->size);
3518
3519 return got_index;
3520}
3521
3522/* Return the GOT index for the global symbol indicated by H, which is
3523 referenced by a relocation of type R_TYPE in IBFD. */
3524
3525static bfd_vma
3526mips_elf_global_got_index (bfd *obfd, struct bfd_link_info *info, bfd *ibfd,
3527 struct elf_link_hash_entry *h, int r_type)
b49e97c9 3528{
a8028dd0 3529 struct mips_elf_link_hash_table *htab;
6c42ddb9
RS
3530 struct mips_got_info *g;
3531 struct mips_got_entry lookup, *entry;
3532 bfd_vma gotidx;
b49e97c9 3533
a8028dd0 3534 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
3535 BFD_ASSERT (htab != NULL);
3536
6c42ddb9
RS
3537 g = mips_elf_bfd_got (ibfd, FALSE);
3538 BFD_ASSERT (g);
f4416af6 3539
6c42ddb9
RS
3540 lookup.tls_type = mips_elf_reloc_tls_type (r_type);
3541 if (!lookup.tls_type && g == mips_elf_bfd_got (obfd, FALSE))
3542 return mips_elf_primary_global_got_index (obfd, info, h);
f4416af6 3543
6c42ddb9
RS
3544 lookup.abfd = ibfd;
3545 lookup.symndx = -1;
3546 lookup.d.h = (struct mips_elf_link_hash_entry *) h;
3547 entry = htab_find (g->got_entries, &lookup);
3548 BFD_ASSERT (entry);
0f20cc35 3549
6c42ddb9
RS
3550 gotidx = entry->gotidx;
3551 BFD_ASSERT (gotidx > 0 && gotidx < htab->sgot->size);
f4416af6 3552
6c42ddb9 3553 if (lookup.tls_type)
0f20cc35 3554 {
0f20cc35
DJ
3555 bfd_vma value = MINUS_ONE;
3556
3557 if ((h->root.type == bfd_link_hash_defined
3558 || h->root.type == bfd_link_hash_defweak)
3559 && h->root.u.def.section->output_section)
3560 value = (h->root.u.def.value
3561 + h->root.u.def.section->output_offset
3562 + h->root.u.def.section->output_section->vma);
3563
9ab066b4 3564 mips_elf_initialize_tls_slots (obfd, info, entry, lookup.d.h, value);
0f20cc35 3565 }
6c42ddb9 3566 return gotidx;
b49e97c9
TS
3567}
3568
5c18022e
RS
3569/* Find a GOT page entry that points to within 32KB of VALUE. These
3570 entries are supposed to be placed at small offsets in the GOT, i.e.,
3571 within 32KB of GP. Return the index of the GOT entry, or -1 if no
3572 entry could be created. If OFFSETP is nonnull, use it to return the
0a44bf69 3573 offset of the GOT entry from VALUE. */
b49e97c9
TS
3574
3575static bfd_vma
9719ad41 3576mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
5c18022e 3577 bfd_vma value, bfd_vma *offsetp)
b49e97c9 3578{
91d6fa6a 3579 bfd_vma page, got_index;
b15e6682 3580 struct mips_got_entry *entry;
b49e97c9 3581
0a44bf69 3582 page = (value + 0x8000) & ~(bfd_vma) 0xffff;
a8028dd0
RS
3583 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0,
3584 NULL, R_MIPS_GOT_PAGE);
b49e97c9 3585
b15e6682
AO
3586 if (!entry)
3587 return MINUS_ONE;
143d77c5 3588
91d6fa6a 3589 got_index = entry->gotidx;
b49e97c9
TS
3590
3591 if (offsetp)
f4416af6 3592 *offsetp = value - entry->d.address;
b49e97c9 3593
91d6fa6a 3594 return got_index;
b49e97c9
TS
3595}
3596
738e5348 3597/* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
020d7251
RS
3598 EXTERNAL is true if the relocation was originally against a global
3599 symbol that binds locally. */
b49e97c9
TS
3600
3601static bfd_vma
9719ad41 3602mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
5c18022e 3603 bfd_vma value, bfd_boolean external)
b49e97c9 3604{
b15e6682 3605 struct mips_got_entry *entry;
b49e97c9 3606
0a44bf69
RS
3607 /* GOT16 relocations against local symbols are followed by a LO16
3608 relocation; those against global symbols are not. Thus if the
3609 symbol was originally local, the GOT16 relocation should load the
3610 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
b49e97c9 3611 if (! external)
0a44bf69 3612 value = mips_elf_high (value) << 16;
b49e97c9 3613
738e5348
RS
3614 /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3615 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the
3616 same in all cases. */
a8028dd0
RS
3617 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0,
3618 NULL, R_MIPS_GOT16);
b15e6682
AO
3619 if (entry)
3620 return entry->gotidx;
3621 else
3622 return MINUS_ONE;
b49e97c9
TS
3623}
3624
3625/* Returns the offset for the entry at the INDEXth position
3626 in the GOT. */
3627
3628static bfd_vma
a8028dd0 3629mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd,
91d6fa6a 3630 bfd *input_bfd, bfd_vma got_index)
b49e97c9 3631{
a8028dd0 3632 struct mips_elf_link_hash_table *htab;
b49e97c9
TS
3633 asection *sgot;
3634 bfd_vma gp;
3635
a8028dd0 3636 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
3637 BFD_ASSERT (htab != NULL);
3638
a8028dd0 3639 sgot = htab->sgot;
f4416af6 3640 gp = _bfd_get_gp_value (output_bfd)
a8028dd0 3641 + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd);
143d77c5 3642
91d6fa6a 3643 return sgot->output_section->vma + sgot->output_offset + got_index - gp;
b49e97c9
TS
3644}
3645
0a44bf69
RS
3646/* Create and return a local GOT entry for VALUE, which was calculated
3647 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
3648 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
3649 instead. */
b49e97c9 3650
b15e6682 3651static struct mips_got_entry *
0a44bf69 3652mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
a8028dd0 3653 bfd *ibfd, bfd_vma value,
5c18022e 3654 unsigned long r_symndx,
0f20cc35
DJ
3655 struct mips_elf_link_hash_entry *h,
3656 int r_type)
b49e97c9 3657{
ebc53538
RS
3658 struct mips_got_entry lookup, *entry;
3659 void **loc;
f4416af6 3660 struct mips_got_info *g;
0a44bf69 3661 struct mips_elf_link_hash_table *htab;
6c42ddb9 3662 bfd_vma gotidx;
0a44bf69
RS
3663
3664 htab = mips_elf_hash_table (info);
4dfe6ac6 3665 BFD_ASSERT (htab != NULL);
b15e6682 3666
d7206569 3667 g = mips_elf_bfd_got (ibfd, FALSE);
f4416af6
AO
3668 if (g == NULL)
3669 {
d7206569 3670 g = mips_elf_bfd_got (abfd, FALSE);
f4416af6
AO
3671 BFD_ASSERT (g != NULL);
3672 }
b15e6682 3673
020d7251
RS
3674 /* This function shouldn't be called for symbols that live in the global
3675 area of the GOT. */
3676 BFD_ASSERT (h == NULL || h->global_got_area == GGA_NONE);
0f20cc35 3677
ebc53538
RS
3678 lookup.tls_type = mips_elf_reloc_tls_type (r_type);
3679 if (lookup.tls_type)
3680 {
3681 lookup.abfd = ibfd;
df58fc94 3682 if (tls_ldm_reloc_p (r_type))
0f20cc35 3683 {
ebc53538
RS
3684 lookup.symndx = 0;
3685 lookup.d.addend = 0;
0f20cc35
DJ
3686 }
3687 else if (h == NULL)
3688 {
ebc53538
RS
3689 lookup.symndx = r_symndx;
3690 lookup.d.addend = 0;
0f20cc35
DJ
3691 }
3692 else
ebc53538
RS
3693 {
3694 lookup.symndx = -1;
3695 lookup.d.h = h;
3696 }
0f20cc35 3697
ebc53538
RS
3698 entry = (struct mips_got_entry *) htab_find (g->got_entries, &lookup);
3699 BFD_ASSERT (entry);
0f20cc35 3700
6c42ddb9
RS
3701 gotidx = entry->gotidx;
3702 BFD_ASSERT (gotidx > 0 && gotidx < htab->sgot->size);
3703
ebc53538 3704 return entry;
0f20cc35
DJ
3705 }
3706
ebc53538
RS
3707 lookup.abfd = NULL;
3708 lookup.symndx = -1;
3709 lookup.d.address = value;
3710 loc = htab_find_slot (g->got_entries, &lookup, INSERT);
3711 if (!loc)
b15e6682 3712 return NULL;
143d77c5 3713
ebc53538
RS
3714 entry = (struct mips_got_entry *) *loc;
3715 if (entry)
3716 return entry;
b15e6682 3717
cb22ccf4 3718 if (g->assigned_low_gotno > g->assigned_high_gotno)
b49e97c9
TS
3719 {
3720 /* We didn't allocate enough space in the GOT. */
3721 (*_bfd_error_handler)
3722 (_("not enough GOT space for local GOT entries"));
3723 bfd_set_error (bfd_error_bad_value);
b15e6682 3724 return NULL;
b49e97c9
TS
3725 }
3726
ebc53538
RS
3727 entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
3728 if (!entry)
3729 return NULL;
3730
cb22ccf4
KCY
3731 if (got16_reloc_p (r_type)
3732 || call16_reloc_p (r_type)
3733 || got_page_reloc_p (r_type)
3734 || got_disp_reloc_p (r_type))
3735 lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_low_gotno++;
3736 else
3737 lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_high_gotno--;
3738
ebc53538
RS
3739 *entry = lookup;
3740 *loc = entry;
3741
3742 MIPS_ELF_PUT_WORD (abfd, value, htab->sgot->contents + entry->gotidx);
b15e6682 3743
5c18022e 3744 /* These GOT entries need a dynamic relocation on VxWorks. */
0a44bf69
RS
3745 if (htab->is_vxworks)
3746 {
3747 Elf_Internal_Rela outrel;
5c18022e 3748 asection *s;
91d6fa6a 3749 bfd_byte *rloc;
0a44bf69 3750 bfd_vma got_address;
0a44bf69
RS
3751
3752 s = mips_elf_rel_dyn_section (info, FALSE);
a8028dd0
RS
3753 got_address = (htab->sgot->output_section->vma
3754 + htab->sgot->output_offset
ebc53538 3755 + entry->gotidx);
0a44bf69 3756
91d6fa6a 3757 rloc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
0a44bf69 3758 outrel.r_offset = got_address;
5c18022e
RS
3759 outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
3760 outrel.r_addend = value;
91d6fa6a 3761 bfd_elf32_swap_reloca_out (abfd, &outrel, rloc);
0a44bf69
RS
3762 }
3763
ebc53538 3764 return entry;
b49e97c9
TS
3765}
3766
d4596a51
RS
3767/* Return the number of dynamic section symbols required by OUTPUT_BFD.
3768 The number might be exact or a worst-case estimate, depending on how
3769 much information is available to elf_backend_omit_section_dynsym at
3770 the current linking stage. */
3771
3772static bfd_size_type
3773count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
3774{
3775 bfd_size_type count;
3776
3777 count = 0;
3778 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
3779 {
3780 asection *p;
3781 const struct elf_backend_data *bed;
3782
3783 bed = get_elf_backend_data (output_bfd);
3784 for (p = output_bfd->sections; p ; p = p->next)
3785 if ((p->flags & SEC_EXCLUDE) == 0
3786 && (p->flags & SEC_ALLOC) != 0
3787 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
3788 ++count;
3789 }
3790 return count;
3791}
3792
b49e97c9 3793/* Sort the dynamic symbol table so that symbols that need GOT entries
d4596a51 3794 appear towards the end. */
b49e97c9 3795
b34976b6 3796static bfd_boolean
d4596a51 3797mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info)
b49e97c9 3798{
a8028dd0 3799 struct mips_elf_link_hash_table *htab;
b49e97c9
TS
3800 struct mips_elf_hash_sort_data hsd;
3801 struct mips_got_info *g;
b49e97c9 3802
d4596a51
RS
3803 if (elf_hash_table (info)->dynsymcount == 0)
3804 return TRUE;
3805
a8028dd0 3806 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
3807 BFD_ASSERT (htab != NULL);
3808
a8028dd0 3809 g = htab->got_info;
d4596a51
RS
3810 if (g == NULL)
3811 return TRUE;
f4416af6 3812
b49e97c9 3813 hsd.low = NULL;
23cc69b6
RS
3814 hsd.max_unref_got_dynindx
3815 = hsd.min_got_dynindx
3816 = (elf_hash_table (info)->dynsymcount - g->reloc_only_gotno);
d4596a51 3817 hsd.max_non_got_dynindx = count_section_dynsyms (abfd, info) + 1;
b49e97c9
TS
3818 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
3819 elf_hash_table (info)),
3820 mips_elf_sort_hash_table_f,
3821 &hsd);
3822
3823 /* There should have been enough room in the symbol table to
44c410de 3824 accommodate both the GOT and non-GOT symbols. */
b49e97c9 3825 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
d4596a51
RS
3826 BFD_ASSERT ((unsigned long) hsd.max_unref_got_dynindx
3827 == elf_hash_table (info)->dynsymcount);
3828 BFD_ASSERT (elf_hash_table (info)->dynsymcount - hsd.min_got_dynindx
3829 == g->global_gotno);
b49e97c9
TS
3830
3831 /* Now we know which dynamic symbol has the lowest dynamic symbol
3832 table index in the GOT. */
d222d210 3833 htab->global_gotsym = hsd.low;
b49e97c9 3834
b34976b6 3835 return TRUE;
b49e97c9
TS
3836}
3837
3838/* If H needs a GOT entry, assign it the highest available dynamic
3839 index. Otherwise, assign it the lowest available dynamic
3840 index. */
3841
b34976b6 3842static bfd_boolean
9719ad41 3843mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
b49e97c9 3844{
9719ad41 3845 struct mips_elf_hash_sort_data *hsd = data;
b49e97c9 3846
b49e97c9
TS
3847 /* Symbols without dynamic symbol table entries aren't interesting
3848 at all. */
3849 if (h->root.dynindx == -1)
b34976b6 3850 return TRUE;
b49e97c9 3851
634835ae 3852 switch (h->global_got_area)
f4416af6 3853 {
634835ae
RS
3854 case GGA_NONE:
3855 h->root.dynindx = hsd->max_non_got_dynindx++;
3856 break;
0f20cc35 3857
634835ae 3858 case GGA_NORMAL:
b49e97c9
TS
3859 h->root.dynindx = --hsd->min_got_dynindx;
3860 hsd->low = (struct elf_link_hash_entry *) h;
634835ae
RS
3861 break;
3862
3863 case GGA_RELOC_ONLY:
634835ae
RS
3864 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
3865 hsd->low = (struct elf_link_hash_entry *) h;
3866 h->root.dynindx = hsd->max_unref_got_dynindx++;
3867 break;
b49e97c9
TS
3868 }
3869
b34976b6 3870 return TRUE;
b49e97c9
TS
3871}
3872
ee227692
RS
3873/* Record that input bfd ABFD requires a GOT entry like *LOOKUP
3874 (which is owned by the caller and shouldn't be added to the
3875 hash table directly). */
3876
3877static bfd_boolean
3878mips_elf_record_got_entry (struct bfd_link_info *info, bfd *abfd,
3879 struct mips_got_entry *lookup)
3880{
3881 struct mips_elf_link_hash_table *htab;
3882 struct mips_got_entry *entry;
3883 struct mips_got_info *g;
3884 void **loc, **bfd_loc;
3885
3886 /* Make sure there's a slot for this entry in the master GOT. */
3887 htab = mips_elf_hash_table (info);
3888 g = htab->got_info;
3889 loc = htab_find_slot (g->got_entries, lookup, INSERT);
3890 if (!loc)
3891 return FALSE;
3892
3893 /* Populate the entry if it isn't already. */
3894 entry = (struct mips_got_entry *) *loc;
3895 if (!entry)
3896 {
3897 entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
3898 if (!entry)
3899 return FALSE;
3900
9ab066b4 3901 lookup->tls_initialized = FALSE;
ee227692
RS
3902 lookup->gotidx = -1;
3903 *entry = *lookup;
3904 *loc = entry;
3905 }
3906
3907 /* Reuse the same GOT entry for the BFD's GOT. */
3908 g = mips_elf_bfd_got (abfd, TRUE);
3909 if (!g)
3910 return FALSE;
3911
3912 bfd_loc = htab_find_slot (g->got_entries, lookup, INSERT);
3913 if (!bfd_loc)
3914 return FALSE;
3915
3916 if (!*bfd_loc)
3917 *bfd_loc = entry;
3918 return TRUE;
3919}
3920
e641e783
RS
3921/* ABFD has a GOT relocation of type R_TYPE against H. Reserve a GOT
3922 entry for it. FOR_CALL is true if the caller is only interested in
6ccf4795 3923 using the GOT entry for calls. */
b49e97c9 3924
b34976b6 3925static bfd_boolean
9719ad41
RS
3926mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
3927 bfd *abfd, struct bfd_link_info *info,
e641e783 3928 bfd_boolean for_call, int r_type)
b49e97c9 3929{
a8028dd0 3930 struct mips_elf_link_hash_table *htab;
634835ae 3931 struct mips_elf_link_hash_entry *hmips;
ee227692
RS
3932 struct mips_got_entry entry;
3933 unsigned char tls_type;
a8028dd0
RS
3934
3935 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
3936 BFD_ASSERT (htab != NULL);
3937
634835ae 3938 hmips = (struct mips_elf_link_hash_entry *) h;
6ccf4795
RS
3939 if (!for_call)
3940 hmips->got_only_for_calls = FALSE;
f4416af6 3941
b49e97c9
TS
3942 /* A global symbol in the GOT must also be in the dynamic symbol
3943 table. */
7c5fcef7
L
3944 if (h->dynindx == -1)
3945 {
3946 switch (ELF_ST_VISIBILITY (h->other))
3947 {
3948 case STV_INTERNAL:
3949 case STV_HIDDEN:
33bb52fb 3950 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
7c5fcef7
L
3951 break;
3952 }
c152c796 3953 if (!bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 3954 return FALSE;
7c5fcef7 3955 }
b49e97c9 3956
ee227692 3957 tls_type = mips_elf_reloc_tls_type (r_type);
9ab066b4 3958 if (tls_type == GOT_TLS_NONE && hmips->global_got_area > GGA_NORMAL)
ee227692 3959 hmips->global_got_area = GGA_NORMAL;
86324f90 3960
f4416af6
AO
3961 entry.abfd = abfd;
3962 entry.symndx = -1;
3963 entry.d.h = (struct mips_elf_link_hash_entry *) h;
ee227692
RS
3964 entry.tls_type = tls_type;
3965 return mips_elf_record_got_entry (info, abfd, &entry);
b49e97c9 3966}
f4416af6 3967
e641e783
RS
3968/* ABFD has a GOT relocation of type R_TYPE against symbol SYMNDX + ADDEND,
3969 where SYMNDX is a local symbol. Reserve a GOT entry for it. */
f4416af6
AO
3970
3971static bfd_boolean
9719ad41 3972mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
e641e783 3973 struct bfd_link_info *info, int r_type)
f4416af6 3974{
a8028dd0
RS
3975 struct mips_elf_link_hash_table *htab;
3976 struct mips_got_info *g;
ee227692 3977 struct mips_got_entry entry;
f4416af6 3978
a8028dd0 3979 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
3980 BFD_ASSERT (htab != NULL);
3981
a8028dd0
RS
3982 g = htab->got_info;
3983 BFD_ASSERT (g != NULL);
3984
f4416af6
AO
3985 entry.abfd = abfd;
3986 entry.symndx = symndx;
3987 entry.d.addend = addend;
e641e783 3988 entry.tls_type = mips_elf_reloc_tls_type (r_type);
ee227692 3989 return mips_elf_record_got_entry (info, abfd, &entry);
f4416af6 3990}
c224138d 3991
13db6b44
RS
3992/* Record that ABFD has a page relocation against SYMNDX + ADDEND.
3993 H is the symbol's hash table entry, or null if SYMNDX is local
3994 to ABFD. */
c224138d
RS
3995
3996static bfd_boolean
13db6b44
RS
3997mips_elf_record_got_page_ref (struct bfd_link_info *info, bfd *abfd,
3998 long symndx, struct elf_link_hash_entry *h,
3999 bfd_signed_vma addend)
c224138d 4000{
a8028dd0 4001 struct mips_elf_link_hash_table *htab;
ee227692 4002 struct mips_got_info *g1, *g2;
13db6b44 4003 struct mips_got_page_ref lookup, *entry;
ee227692 4004 void **loc, **bfd_loc;
c224138d 4005
a8028dd0 4006 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
4007 BFD_ASSERT (htab != NULL);
4008
ee227692
RS
4009 g1 = htab->got_info;
4010 BFD_ASSERT (g1 != NULL);
a8028dd0 4011
13db6b44
RS
4012 if (h)
4013 {
4014 lookup.symndx = -1;
4015 lookup.u.h = (struct mips_elf_link_hash_entry *) h;
4016 }
4017 else
4018 {
4019 lookup.symndx = symndx;
4020 lookup.u.abfd = abfd;
4021 }
4022 lookup.addend = addend;
4023 loc = htab_find_slot (g1->got_page_refs, &lookup, INSERT);
c224138d
RS
4024 if (loc == NULL)
4025 return FALSE;
4026
13db6b44 4027 entry = (struct mips_got_page_ref *) *loc;
c224138d
RS
4028 if (!entry)
4029 {
4030 entry = bfd_alloc (abfd, sizeof (*entry));
4031 if (!entry)
4032 return FALSE;
4033
13db6b44 4034 *entry = lookup;
c224138d
RS
4035 *loc = entry;
4036 }
4037
ee227692
RS
4038 /* Add the same entry to the BFD's GOT. */
4039 g2 = mips_elf_bfd_got (abfd, TRUE);
4040 if (!g2)
4041 return FALSE;
4042
13db6b44 4043 bfd_loc = htab_find_slot (g2->got_page_refs, &lookup, INSERT);
ee227692
RS
4044 if (!bfd_loc)
4045 return FALSE;
4046
4047 if (!*bfd_loc)
4048 *bfd_loc = entry;
4049
c224138d
RS
4050 return TRUE;
4051}
33bb52fb
RS
4052
4053/* Add room for N relocations to the .rel(a).dyn section in ABFD. */
4054
4055static void
4056mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
4057 unsigned int n)
4058{
4059 asection *s;
4060 struct mips_elf_link_hash_table *htab;
4061
4062 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
4063 BFD_ASSERT (htab != NULL);
4064
33bb52fb
RS
4065 s = mips_elf_rel_dyn_section (info, FALSE);
4066 BFD_ASSERT (s != NULL);
4067
4068 if (htab->is_vxworks)
4069 s->size += n * MIPS_ELF_RELA_SIZE (abfd);
4070 else
4071 {
4072 if (s->size == 0)
4073 {
4074 /* Make room for a null element. */
4075 s->size += MIPS_ELF_REL_SIZE (abfd);
4076 ++s->reloc_count;
4077 }
4078 s->size += n * MIPS_ELF_REL_SIZE (abfd);
4079 }
4080}
4081\f
476366af
RS
4082/* A htab_traverse callback for GOT entries, with DATA pointing to a
4083 mips_elf_traverse_got_arg structure. Count the number of GOT
4084 entries and TLS relocs. Set DATA->value to true if we need
4085 to resolve indirect or warning symbols and then recreate the GOT. */
33bb52fb
RS
4086
4087static int
4088mips_elf_check_recreate_got (void **entryp, void *data)
4089{
4090 struct mips_got_entry *entry;
476366af 4091 struct mips_elf_traverse_got_arg *arg;
33bb52fb
RS
4092
4093 entry = (struct mips_got_entry *) *entryp;
476366af 4094 arg = (struct mips_elf_traverse_got_arg *) data;
33bb52fb
RS
4095 if (entry->abfd != NULL && entry->symndx == -1)
4096 {
4097 struct mips_elf_link_hash_entry *h;
4098
4099 h = entry->d.h;
4100 if (h->root.root.type == bfd_link_hash_indirect
4101 || h->root.root.type == bfd_link_hash_warning)
4102 {
476366af 4103 arg->value = TRUE;
33bb52fb
RS
4104 return 0;
4105 }
4106 }
476366af 4107 mips_elf_count_got_entry (arg->info, arg->g, entry);
33bb52fb
RS
4108 return 1;
4109}
4110
476366af
RS
4111/* A htab_traverse callback for GOT entries, with DATA pointing to a
4112 mips_elf_traverse_got_arg structure. Add all entries to DATA->g,
4113 converting entries for indirect and warning symbols into entries
4114 for the target symbol. Set DATA->g to null on error. */
33bb52fb
RS
4115
4116static int
4117mips_elf_recreate_got (void **entryp, void *data)
4118{
72e7511a 4119 struct mips_got_entry new_entry, *entry;
476366af 4120 struct mips_elf_traverse_got_arg *arg;
33bb52fb
RS
4121 void **slot;
4122
33bb52fb 4123 entry = (struct mips_got_entry *) *entryp;
476366af 4124 arg = (struct mips_elf_traverse_got_arg *) data;
72e7511a
RS
4125 if (entry->abfd != NULL
4126 && entry->symndx == -1
4127 && (entry->d.h->root.root.type == bfd_link_hash_indirect
4128 || entry->d.h->root.root.type == bfd_link_hash_warning))
33bb52fb
RS
4129 {
4130 struct mips_elf_link_hash_entry *h;
4131
72e7511a
RS
4132 new_entry = *entry;
4133 entry = &new_entry;
33bb52fb 4134 h = entry->d.h;
72e7511a 4135 do
634835ae
RS
4136 {
4137 BFD_ASSERT (h->global_got_area == GGA_NONE);
4138 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4139 }
72e7511a
RS
4140 while (h->root.root.type == bfd_link_hash_indirect
4141 || h->root.root.type == bfd_link_hash_warning);
33bb52fb
RS
4142 entry->d.h = h;
4143 }
476366af 4144 slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
33bb52fb
RS
4145 if (slot == NULL)
4146 {
476366af 4147 arg->g = NULL;
33bb52fb
RS
4148 return 0;
4149 }
4150 if (*slot == NULL)
72e7511a
RS
4151 {
4152 if (entry == &new_entry)
4153 {
4154 entry = bfd_alloc (entry->abfd, sizeof (*entry));
4155 if (!entry)
4156 {
476366af 4157 arg->g = NULL;
72e7511a
RS
4158 return 0;
4159 }
4160 *entry = new_entry;
4161 }
4162 *slot = entry;
476366af 4163 mips_elf_count_got_entry (arg->info, arg->g, entry);
72e7511a 4164 }
33bb52fb
RS
4165 return 1;
4166}
4167
13db6b44
RS
4168/* Return the maximum number of GOT page entries required for RANGE. */
4169
4170static bfd_vma
4171mips_elf_pages_for_range (const struct mips_got_page_range *range)
4172{
4173 return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
4174}
4175
4176/* Record that G requires a page entry that can reach SEC + ADDEND. */
4177
4178static bfd_boolean
b75d42bc 4179mips_elf_record_got_page_entry (struct mips_elf_traverse_got_arg *arg,
13db6b44
RS
4180 asection *sec, bfd_signed_vma addend)
4181{
b75d42bc 4182 struct mips_got_info *g = arg->g;
13db6b44
RS
4183 struct mips_got_page_entry lookup, *entry;
4184 struct mips_got_page_range **range_ptr, *range;
4185 bfd_vma old_pages, new_pages;
4186 void **loc;
4187
4188 /* Find the mips_got_page_entry hash table entry for this section. */
4189 lookup.sec = sec;
4190 loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
4191 if (loc == NULL)
4192 return FALSE;
4193
4194 /* Create a mips_got_page_entry if this is the first time we've
4195 seen the section. */
4196 entry = (struct mips_got_page_entry *) *loc;
4197 if (!entry)
4198 {
b75d42bc 4199 entry = bfd_zalloc (arg->info->output_bfd, sizeof (*entry));
13db6b44
RS
4200 if (!entry)
4201 return FALSE;
4202
4203 entry->sec = sec;
4204 *loc = entry;
4205 }
4206
4207 /* Skip over ranges whose maximum extent cannot share a page entry
4208 with ADDEND. */
4209 range_ptr = &entry->ranges;
4210 while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
4211 range_ptr = &(*range_ptr)->next;
4212
4213 /* If we scanned to the end of the list, or found a range whose
4214 minimum extent cannot share a page entry with ADDEND, create
4215 a new singleton range. */
4216 range = *range_ptr;
4217 if (!range || addend < range->min_addend - 0xffff)
4218 {
b75d42bc 4219 range = bfd_zalloc (arg->info->output_bfd, sizeof (*range));
13db6b44
RS
4220 if (!range)
4221 return FALSE;
4222
4223 range->next = *range_ptr;
4224 range->min_addend = addend;
4225 range->max_addend = addend;
4226
4227 *range_ptr = range;
4228 entry->num_pages++;
4229 g->page_gotno++;
4230 return TRUE;
4231 }
4232
4233 /* Remember how many pages the old range contributed. */
4234 old_pages = mips_elf_pages_for_range (range);
4235
4236 /* Update the ranges. */
4237 if (addend < range->min_addend)
4238 range->min_addend = addend;
4239 else if (addend > range->max_addend)
4240 {
4241 if (range->next && addend >= range->next->min_addend - 0xffff)
4242 {
4243 old_pages += mips_elf_pages_for_range (range->next);
4244 range->max_addend = range->next->max_addend;
4245 range->next = range->next->next;
4246 }
4247 else
4248 range->max_addend = addend;
4249 }
4250
4251 /* Record any change in the total estimate. */
4252 new_pages = mips_elf_pages_for_range (range);
4253 if (old_pages != new_pages)
4254 {
4255 entry->num_pages += new_pages - old_pages;
4256 g->page_gotno += new_pages - old_pages;
4257 }
4258
4259 return TRUE;
4260}
4261
4262/* A htab_traverse callback for which *REFP points to a mips_got_page_ref
4263 and for which DATA points to a mips_elf_traverse_got_arg. Work out
4264 whether the page reference described by *REFP needs a GOT page entry,
4265 and record that entry in DATA->g if so. Set DATA->g to null on failure. */
4266
4267static bfd_boolean
4268mips_elf_resolve_got_page_ref (void **refp, void *data)
4269{
4270 struct mips_got_page_ref *ref;
4271 struct mips_elf_traverse_got_arg *arg;
4272 struct mips_elf_link_hash_table *htab;
4273 asection *sec;
4274 bfd_vma addend;
4275
4276 ref = (struct mips_got_page_ref *) *refp;
4277 arg = (struct mips_elf_traverse_got_arg *) data;
4278 htab = mips_elf_hash_table (arg->info);
4279
4280 if (ref->symndx < 0)
4281 {
4282 struct mips_elf_link_hash_entry *h;
4283
4284 /* Global GOT_PAGEs decay to GOT_DISP and so don't need page entries. */
4285 h = ref->u.h;
4286 if (!SYMBOL_REFERENCES_LOCAL (arg->info, &h->root))
4287 return 1;
4288
4289 /* Ignore undefined symbols; we'll issue an error later if
4290 appropriate. */
4291 if (!((h->root.root.type == bfd_link_hash_defined
4292 || h->root.root.type == bfd_link_hash_defweak)
4293 && h->root.root.u.def.section))
4294 return 1;
4295
4296 sec = h->root.root.u.def.section;
4297 addend = h->root.root.u.def.value + ref->addend;
4298 }
4299 else
4300 {
4301 Elf_Internal_Sym *isym;
4302
4303 /* Read in the symbol. */
4304 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ref->u.abfd,
4305 ref->symndx);
4306 if (isym == NULL)
4307 {
4308 arg->g = NULL;
4309 return 0;
4310 }
4311
4312 /* Get the associated input section. */
4313 sec = bfd_section_from_elf_index (ref->u.abfd, isym->st_shndx);
4314 if (sec == NULL)
4315 {
4316 arg->g = NULL;
4317 return 0;
4318 }
4319
4320 /* If this is a mergable section, work out the section and offset
4321 of the merged data. For section symbols, the addend specifies
4322 of the offset _of_ the first byte in the data, otherwise it
4323 specifies the offset _from_ the first byte. */
4324 if (sec->flags & SEC_MERGE)
4325 {
4326 void *secinfo;
4327
4328 secinfo = elf_section_data (sec)->sec_info;
4329 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
4330 addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
4331 isym->st_value + ref->addend);
4332 else
4333 addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
4334 isym->st_value) + ref->addend;
4335 }
4336 else
4337 addend = isym->st_value + ref->addend;
4338 }
b75d42bc 4339 if (!mips_elf_record_got_page_entry (arg, sec, addend))
13db6b44
RS
4340 {
4341 arg->g = NULL;
4342 return 0;
4343 }
4344 return 1;
4345}
4346
33bb52fb 4347/* If any entries in G->got_entries are for indirect or warning symbols,
13db6b44
RS
4348 replace them with entries for the target symbol. Convert g->got_page_refs
4349 into got_page_entry structures and estimate the number of page entries
4350 that they require. */
33bb52fb
RS
4351
4352static bfd_boolean
476366af
RS
4353mips_elf_resolve_final_got_entries (struct bfd_link_info *info,
4354 struct mips_got_info *g)
33bb52fb 4355{
476366af
RS
4356 struct mips_elf_traverse_got_arg tga;
4357 struct mips_got_info oldg;
4358
4359 oldg = *g;
33bb52fb 4360
476366af
RS
4361 tga.info = info;
4362 tga.g = g;
4363 tga.value = FALSE;
4364 htab_traverse (g->got_entries, mips_elf_check_recreate_got, &tga);
4365 if (tga.value)
33bb52fb 4366 {
476366af
RS
4367 *g = oldg;
4368 g->got_entries = htab_create (htab_size (oldg.got_entries),
4369 mips_elf_got_entry_hash,
4370 mips_elf_got_entry_eq, NULL);
4371 if (!g->got_entries)
33bb52fb
RS
4372 return FALSE;
4373
476366af
RS
4374 htab_traverse (oldg.got_entries, mips_elf_recreate_got, &tga);
4375 if (!tga.g)
4376 return FALSE;
4377
4378 htab_delete (oldg.got_entries);
33bb52fb 4379 }
13db6b44
RS
4380
4381 g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4382 mips_got_page_entry_eq, NULL);
4383 if (g->got_page_entries == NULL)
4384 return FALSE;
4385
4386 tga.info = info;
4387 tga.g = g;
4388 htab_traverse (g->got_page_refs, mips_elf_resolve_got_page_ref, &tga);
4389
33bb52fb
RS
4390 return TRUE;
4391}
4392
c5d6fa44
RS
4393/* Return true if a GOT entry for H should live in the local rather than
4394 global GOT area. */
4395
4396static bfd_boolean
4397mips_use_local_got_p (struct bfd_link_info *info,
4398 struct mips_elf_link_hash_entry *h)
4399{
4400 /* Symbols that aren't in the dynamic symbol table must live in the
4401 local GOT. This includes symbols that are completely undefined
4402 and which therefore don't bind locally. We'll report undefined
4403 symbols later if appropriate. */
4404 if (h->root.dynindx == -1)
4405 return TRUE;
4406
4407 /* Symbols that bind locally can (and in the case of forced-local
4408 symbols, must) live in the local GOT. */
4409 if (h->got_only_for_calls
4410 ? SYMBOL_CALLS_LOCAL (info, &h->root)
4411 : SYMBOL_REFERENCES_LOCAL (info, &h->root))
4412 return TRUE;
4413
4414 /* If this is an executable that must provide a definition of the symbol,
4415 either though PLTs or copy relocations, then that address should go in
4416 the local rather than global GOT. */
4417 if (info->executable && h->has_static_relocs)
4418 return TRUE;
4419
4420 return FALSE;
4421}
4422
6c42ddb9
RS
4423/* A mips_elf_link_hash_traverse callback for which DATA points to the
4424 link_info structure. Decide whether the hash entry needs an entry in
4425 the global part of the primary GOT, setting global_got_area accordingly.
4426 Count the number of global symbols that are in the primary GOT only
4427 because they have relocations against them (reloc_only_gotno). */
33bb52fb
RS
4428
4429static int
d4596a51 4430mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
33bb52fb 4431{
020d7251 4432 struct bfd_link_info *info;
6ccf4795 4433 struct mips_elf_link_hash_table *htab;
33bb52fb
RS
4434 struct mips_got_info *g;
4435
020d7251 4436 info = (struct bfd_link_info *) data;
6ccf4795
RS
4437 htab = mips_elf_hash_table (info);
4438 g = htab->got_info;
d4596a51 4439 if (h->global_got_area != GGA_NONE)
33bb52fb 4440 {
020d7251 4441 /* Make a final decision about whether the symbol belongs in the
c5d6fa44
RS
4442 local or global GOT. */
4443 if (mips_use_local_got_p (info, h))
6c42ddb9
RS
4444 /* The symbol belongs in the local GOT. We no longer need this
4445 entry if it was only used for relocations; those relocations
4446 will be against the null or section symbol instead of H. */
4447 h->global_got_area = GGA_NONE;
6ccf4795
RS
4448 else if (htab->is_vxworks
4449 && h->got_only_for_calls
1bbce132 4450 && h->root.plt.plist->mips_offset != MINUS_ONE)
6ccf4795
RS
4451 /* On VxWorks, calls can refer directly to the .got.plt entry;
4452 they don't need entries in the regular GOT. .got.plt entries
4453 will be allocated by _bfd_mips_elf_adjust_dynamic_symbol. */
4454 h->global_got_area = GGA_NONE;
6c42ddb9 4455 else if (h->global_got_area == GGA_RELOC_ONLY)
23cc69b6 4456 {
6c42ddb9 4457 g->reloc_only_gotno++;
23cc69b6 4458 g->global_gotno++;
23cc69b6 4459 }
33bb52fb
RS
4460 }
4461 return 1;
4462}
f4416af6 4463\f
d7206569
RS
4464/* A htab_traverse callback for GOT entries. Add each one to the GOT
4465 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */
f4416af6
AO
4466
4467static int
d7206569 4468mips_elf_add_got_entry (void **entryp, void *data)
f4416af6 4469{
d7206569
RS
4470 struct mips_got_entry *entry;
4471 struct mips_elf_traverse_got_arg *arg;
4472 void **slot;
f4416af6 4473
d7206569
RS
4474 entry = (struct mips_got_entry *) *entryp;
4475 arg = (struct mips_elf_traverse_got_arg *) data;
4476 slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
4477 if (!slot)
f4416af6 4478 {
d7206569
RS
4479 arg->g = NULL;
4480 return 0;
f4416af6 4481 }
d7206569 4482 if (!*slot)
c224138d 4483 {
d7206569
RS
4484 *slot = entry;
4485 mips_elf_count_got_entry (arg->info, arg->g, entry);
c224138d 4486 }
f4416af6
AO
4487 return 1;
4488}
4489
d7206569
RS
4490/* A htab_traverse callback for GOT page entries. Add each one to the GOT
4491 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */
c224138d
RS
4492
4493static int
d7206569 4494mips_elf_add_got_page_entry (void **entryp, void *data)
c224138d 4495{
d7206569
RS
4496 struct mips_got_page_entry *entry;
4497 struct mips_elf_traverse_got_arg *arg;
4498 void **slot;
c224138d 4499
d7206569
RS
4500 entry = (struct mips_got_page_entry *) *entryp;
4501 arg = (struct mips_elf_traverse_got_arg *) data;
4502 slot = htab_find_slot (arg->g->got_page_entries, entry, INSERT);
4503 if (!slot)
c224138d 4504 {
d7206569 4505 arg->g = NULL;
c224138d
RS
4506 return 0;
4507 }
d7206569
RS
4508 if (!*slot)
4509 {
4510 *slot = entry;
4511 arg->g->page_gotno += entry->num_pages;
4512 }
c224138d
RS
4513 return 1;
4514}
4515
d7206569
RS
4516/* Consider merging FROM, which is ABFD's GOT, into TO. Return -1 if
4517 this would lead to overflow, 1 if they were merged successfully,
4518 and 0 if a merge failed due to lack of memory. (These values are chosen
4519 so that nonnegative return values can be returned by a htab_traverse
4520 callback.) */
c224138d
RS
4521
4522static int
d7206569 4523mips_elf_merge_got_with (bfd *abfd, struct mips_got_info *from,
c224138d
RS
4524 struct mips_got_info *to,
4525 struct mips_elf_got_per_bfd_arg *arg)
4526{
d7206569 4527 struct mips_elf_traverse_got_arg tga;
c224138d
RS
4528 unsigned int estimate;
4529
4530 /* Work out how many page entries we would need for the combined GOT. */
4531 estimate = arg->max_pages;
4532 if (estimate >= from->page_gotno + to->page_gotno)
4533 estimate = from->page_gotno + to->page_gotno;
4534
e2ece73c 4535 /* And conservatively estimate how many local and TLS entries
c224138d 4536 would be needed. */
e2ece73c
RS
4537 estimate += from->local_gotno + to->local_gotno;
4538 estimate += from->tls_gotno + to->tls_gotno;
4539
17214937
RS
4540 /* If we're merging with the primary got, any TLS relocations will
4541 come after the full set of global entries. Otherwise estimate those
e2ece73c 4542 conservatively as well. */
17214937 4543 if (to == arg->primary && from->tls_gotno + to->tls_gotno)
e2ece73c
RS
4544 estimate += arg->global_count;
4545 else
4546 estimate += from->global_gotno + to->global_gotno;
c224138d
RS
4547
4548 /* Bail out if the combined GOT might be too big. */
4549 if (estimate > arg->max_count)
4550 return -1;
4551
c224138d 4552 /* Transfer the bfd's got information from FROM to TO. */
d7206569
RS
4553 tga.info = arg->info;
4554 tga.g = to;
4555 htab_traverse (from->got_entries, mips_elf_add_got_entry, &tga);
4556 if (!tga.g)
c224138d
RS
4557 return 0;
4558
d7206569
RS
4559 htab_traverse (from->got_page_entries, mips_elf_add_got_page_entry, &tga);
4560 if (!tga.g)
c224138d
RS
4561 return 0;
4562
d7206569 4563 mips_elf_replace_bfd_got (abfd, to);
c224138d
RS
4564 return 1;
4565}
4566
d7206569 4567/* Attempt to merge GOT G, which belongs to ABFD. Try to use as much
f4416af6
AO
4568 as possible of the primary got, since it doesn't require explicit
4569 dynamic relocations, but don't use bfds that would reference global
4570 symbols out of the addressable range. Failing the primary got,
4571 attempt to merge with the current got, or finish the current got
4572 and then make make the new got current. */
4573
d7206569
RS
4574static bfd_boolean
4575mips_elf_merge_got (bfd *abfd, struct mips_got_info *g,
4576 struct mips_elf_got_per_bfd_arg *arg)
f4416af6 4577{
c224138d
RS
4578 unsigned int estimate;
4579 int result;
4580
476366af 4581 if (!mips_elf_resolve_final_got_entries (arg->info, g))
d7206569
RS
4582 return FALSE;
4583
c224138d
RS
4584 /* Work out the number of page, local and TLS entries. */
4585 estimate = arg->max_pages;
4586 if (estimate > g->page_gotno)
4587 estimate = g->page_gotno;
4588 estimate += g->local_gotno + g->tls_gotno;
0f20cc35
DJ
4589
4590 /* We place TLS GOT entries after both locals and globals. The globals
4591 for the primary GOT may overflow the normal GOT size limit, so be
4592 sure not to merge a GOT which requires TLS with the primary GOT in that
4593 case. This doesn't affect non-primary GOTs. */
c224138d 4594 estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
143d77c5 4595
c224138d 4596 if (estimate <= arg->max_count)
f4416af6 4597 {
c224138d
RS
4598 /* If we don't have a primary GOT, use it as
4599 a starting point for the primary GOT. */
4600 if (!arg->primary)
4601 {
d7206569
RS
4602 arg->primary = g;
4603 return TRUE;
c224138d 4604 }
f4416af6 4605
c224138d 4606 /* Try merging with the primary GOT. */
d7206569 4607 result = mips_elf_merge_got_with (abfd, g, arg->primary, arg);
c224138d
RS
4608 if (result >= 0)
4609 return result;
f4416af6 4610 }
c224138d 4611
f4416af6 4612 /* If we can merge with the last-created got, do it. */
c224138d 4613 if (arg->current)
f4416af6 4614 {
d7206569 4615 result = mips_elf_merge_got_with (abfd, g, arg->current, arg);
c224138d
RS
4616 if (result >= 0)
4617 return result;
f4416af6 4618 }
c224138d 4619
f4416af6
AO
4620 /* Well, we couldn't merge, so create a new GOT. Don't check if it
4621 fits; if it turns out that it doesn't, we'll get relocation
4622 overflows anyway. */
c224138d
RS
4623 g->next = arg->current;
4624 arg->current = g;
0f20cc35 4625
d7206569 4626 return TRUE;
0f20cc35
DJ
4627}
4628
72e7511a
RS
4629/* ENTRYP is a hash table entry for a mips_got_entry. Set its gotidx
4630 to GOTIDX, duplicating the entry if it has already been assigned
4631 an index in a different GOT. */
4632
4633static bfd_boolean
4634mips_elf_set_gotidx (void **entryp, long gotidx)
4635{
4636 struct mips_got_entry *entry;
4637
4638 entry = (struct mips_got_entry *) *entryp;
4639 if (entry->gotidx > 0)
4640 {
4641 struct mips_got_entry *new_entry;
4642
4643 new_entry = bfd_alloc (entry->abfd, sizeof (*entry));
4644 if (!new_entry)
4645 return FALSE;
4646
4647 *new_entry = *entry;
4648 *entryp = new_entry;
4649 entry = new_entry;
4650 }
4651 entry->gotidx = gotidx;
4652 return TRUE;
4653}
4654
4655/* Set the TLS GOT index for the GOT entry in ENTRYP. DATA points to a
4656 mips_elf_traverse_got_arg in which DATA->value is the size of one
4657 GOT entry. Set DATA->g to null on failure. */
0f20cc35
DJ
4658
4659static int
72e7511a 4660mips_elf_initialize_tls_index (void **entryp, void *data)
0f20cc35 4661{
72e7511a
RS
4662 struct mips_got_entry *entry;
4663 struct mips_elf_traverse_got_arg *arg;
0f20cc35
DJ
4664
4665 /* We're only interested in TLS symbols. */
72e7511a 4666 entry = (struct mips_got_entry *) *entryp;
9ab066b4 4667 if (entry->tls_type == GOT_TLS_NONE)
0f20cc35
DJ
4668 return 1;
4669
72e7511a 4670 arg = (struct mips_elf_traverse_got_arg *) data;
6c42ddb9 4671 if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->tls_assigned_gotno))
ead49a57 4672 {
6c42ddb9
RS
4673 arg->g = NULL;
4674 return 0;
f4416af6
AO
4675 }
4676
ead49a57 4677 /* Account for the entries we've just allocated. */
9ab066b4 4678 arg->g->tls_assigned_gotno += mips_tls_got_entries (entry->tls_type);
f4416af6
AO
4679 return 1;
4680}
4681
ab361d49
RS
4682/* A htab_traverse callback for GOT entries, where DATA points to a
4683 mips_elf_traverse_got_arg. Set the global_got_area of each global
4684 symbol to DATA->value. */
f4416af6 4685
f4416af6 4686static int
ab361d49 4687mips_elf_set_global_got_area (void **entryp, void *data)
f4416af6 4688{
ab361d49
RS
4689 struct mips_got_entry *entry;
4690 struct mips_elf_traverse_got_arg *arg;
f4416af6 4691
ab361d49
RS
4692 entry = (struct mips_got_entry *) *entryp;
4693 arg = (struct mips_elf_traverse_got_arg *) data;
4694 if (entry->abfd != NULL
4695 && entry->symndx == -1
4696 && entry->d.h->global_got_area != GGA_NONE)
4697 entry->d.h->global_got_area = arg->value;
4698 return 1;
4699}
4700
4701/* A htab_traverse callback for secondary GOT entries, where DATA points
4702 to a mips_elf_traverse_got_arg. Assign GOT indices to global entries
4703 and record the number of relocations they require. DATA->value is
72e7511a 4704 the size of one GOT entry. Set DATA->g to null on failure. */
ab361d49
RS
4705
4706static int
4707mips_elf_set_global_gotidx (void **entryp, void *data)
4708{
4709 struct mips_got_entry *entry;
4710 struct mips_elf_traverse_got_arg *arg;
0f20cc35 4711
ab361d49
RS
4712 entry = (struct mips_got_entry *) *entryp;
4713 arg = (struct mips_elf_traverse_got_arg *) data;
634835ae
RS
4714 if (entry->abfd != NULL
4715 && entry->symndx == -1
4716 && entry->d.h->global_got_area != GGA_NONE)
f4416af6 4717 {
cb22ccf4 4718 if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->assigned_low_gotno))
72e7511a
RS
4719 {
4720 arg->g = NULL;
4721 return 0;
4722 }
cb22ccf4 4723 arg->g->assigned_low_gotno += 1;
72e7511a 4724
ab361d49
RS
4725 if (arg->info->shared
4726 || (elf_hash_table (arg->info)->dynamic_sections_created
4727 && entry->d.h->root.def_dynamic
4728 && !entry->d.h->root.def_regular))
4729 arg->g->relocs += 1;
f4416af6
AO
4730 }
4731
4732 return 1;
4733}
4734
33bb52fb
RS
4735/* A htab_traverse callback for GOT entries for which DATA is the
4736 bfd_link_info. Forbid any global symbols from having traditional
4737 lazy-binding stubs. */
4738
0626d451 4739static int
33bb52fb 4740mips_elf_forbid_lazy_stubs (void **entryp, void *data)
0626d451 4741{
33bb52fb
RS
4742 struct bfd_link_info *info;
4743 struct mips_elf_link_hash_table *htab;
4744 struct mips_got_entry *entry;
0626d451 4745
33bb52fb
RS
4746 entry = (struct mips_got_entry *) *entryp;
4747 info = (struct bfd_link_info *) data;
4748 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
4749 BFD_ASSERT (htab != NULL);
4750
0626d451
RS
4751 if (entry->abfd != NULL
4752 && entry->symndx == -1
33bb52fb 4753 && entry->d.h->needs_lazy_stub)
f4416af6 4754 {
33bb52fb
RS
4755 entry->d.h->needs_lazy_stub = FALSE;
4756 htab->lazy_stub_count--;
f4416af6 4757 }
143d77c5 4758
f4416af6
AO
4759 return 1;
4760}
4761
f4416af6
AO
4762/* Return the offset of an input bfd IBFD's GOT from the beginning of
4763 the primary GOT. */
4764static bfd_vma
9719ad41 4765mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
f4416af6 4766{
d7206569 4767 if (!g->next)
f4416af6
AO
4768 return 0;
4769
d7206569 4770 g = mips_elf_bfd_got (ibfd, FALSE);
f4416af6
AO
4771 if (! g)
4772 return 0;
4773
4774 BFD_ASSERT (g->next);
4775
4776 g = g->next;
143d77c5 4777
0f20cc35
DJ
4778 return (g->local_gotno + g->global_gotno + g->tls_gotno)
4779 * MIPS_ELF_GOT_SIZE (abfd);
f4416af6
AO
4780}
4781
4782/* Turn a single GOT that is too big for 16-bit addressing into
4783 a sequence of GOTs, each one 16-bit addressable. */
4784
4785static bfd_boolean
9719ad41 4786mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
a8028dd0 4787 asection *got, bfd_size_type pages)
f4416af6 4788{
a8028dd0 4789 struct mips_elf_link_hash_table *htab;
f4416af6 4790 struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
ab361d49 4791 struct mips_elf_traverse_got_arg tga;
a8028dd0 4792 struct mips_got_info *g, *gg;
33bb52fb 4793 unsigned int assign, needed_relocs;
d7206569 4794 bfd *dynobj, *ibfd;
f4416af6 4795
33bb52fb 4796 dynobj = elf_hash_table (info)->dynobj;
a8028dd0 4797 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
4798 BFD_ASSERT (htab != NULL);
4799
a8028dd0 4800 g = htab->got_info;
f4416af6 4801
f4416af6
AO
4802 got_per_bfd_arg.obfd = abfd;
4803 got_per_bfd_arg.info = info;
f4416af6
AO
4804 got_per_bfd_arg.current = NULL;
4805 got_per_bfd_arg.primary = NULL;
0a44bf69 4806 got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
f4416af6 4807 / MIPS_ELF_GOT_SIZE (abfd))
861fb55a 4808 - htab->reserved_gotno);
c224138d 4809 got_per_bfd_arg.max_pages = pages;
0f20cc35 4810 /* The number of globals that will be included in the primary GOT.
ab361d49 4811 See the calls to mips_elf_set_global_got_area below for more
0f20cc35
DJ
4812 information. */
4813 got_per_bfd_arg.global_count = g->global_gotno;
f4416af6
AO
4814
4815 /* Try to merge the GOTs of input bfds together, as long as they
4816 don't seem to exceed the maximum GOT size, choosing one of them
4817 to be the primary GOT. */
c72f2fb2 4818 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
d7206569
RS
4819 {
4820 gg = mips_elf_bfd_got (ibfd, FALSE);
4821 if (gg && !mips_elf_merge_got (ibfd, gg, &got_per_bfd_arg))
4822 return FALSE;
4823 }
f4416af6 4824
0f20cc35 4825 /* If we do not find any suitable primary GOT, create an empty one. */
f4416af6 4826 if (got_per_bfd_arg.primary == NULL)
3dff0dd1 4827 g->next = mips_elf_create_got_info (abfd);
f4416af6
AO
4828 else
4829 g->next = got_per_bfd_arg.primary;
4830 g->next->next = got_per_bfd_arg.current;
4831
4832 /* GG is now the master GOT, and G is the primary GOT. */
4833 gg = g;
4834 g = g->next;
4835
4836 /* Map the output bfd to the primary got. That's what we're going
4837 to use for bfds that use GOT16 or GOT_PAGE relocations that we
4838 didn't mark in check_relocs, and we want a quick way to find it.
4839 We can't just use gg->next because we're going to reverse the
4840 list. */
d7206569 4841 mips_elf_replace_bfd_got (abfd, g);
f4416af6 4842
634835ae
RS
4843 /* Every symbol that is referenced in a dynamic relocation must be
4844 present in the primary GOT, so arrange for them to appear after
4845 those that are actually referenced. */
23cc69b6 4846 gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
634835ae 4847 g->global_gotno = gg->global_gotno;
f4416af6 4848
ab361d49
RS
4849 tga.info = info;
4850 tga.value = GGA_RELOC_ONLY;
4851 htab_traverse (gg->got_entries, mips_elf_set_global_got_area, &tga);
4852 tga.value = GGA_NORMAL;
4853 htab_traverse (g->got_entries, mips_elf_set_global_got_area, &tga);
f4416af6
AO
4854
4855 /* Now go through the GOTs assigning them offset ranges.
cb22ccf4 4856 [assigned_low_gotno, local_gotno[ will be set to the range of local
f4416af6
AO
4857 entries in each GOT. We can then compute the end of a GOT by
4858 adding local_gotno to global_gotno. We reverse the list and make
4859 it circular since then we'll be able to quickly compute the
4860 beginning of a GOT, by computing the end of its predecessor. To
4861 avoid special cases for the primary GOT, while still preserving
4862 assertions that are valid for both single- and multi-got links,
4863 we arrange for the main got struct to have the right number of
4864 global entries, but set its local_gotno such that the initial
4865 offset of the primary GOT is zero. Remember that the primary GOT
4866 will become the last item in the circular linked list, so it
4867 points back to the master GOT. */
4868 gg->local_gotno = -g->global_gotno;
4869 gg->global_gotno = g->global_gotno;
0f20cc35 4870 gg->tls_gotno = 0;
f4416af6
AO
4871 assign = 0;
4872 gg->next = gg;
4873
4874 do
4875 {
4876 struct mips_got_info *gn;
4877
861fb55a 4878 assign += htab->reserved_gotno;
cb22ccf4 4879 g->assigned_low_gotno = assign;
c224138d
RS
4880 g->local_gotno += assign;
4881 g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
cb22ccf4 4882 g->assigned_high_gotno = g->local_gotno - 1;
0f20cc35
DJ
4883 assign = g->local_gotno + g->global_gotno + g->tls_gotno;
4884
ead49a57
RS
4885 /* Take g out of the direct list, and push it onto the reversed
4886 list that gg points to. g->next is guaranteed to be nonnull after
4887 this operation, as required by mips_elf_initialize_tls_index. */
4888 gn = g->next;
4889 g->next = gg->next;
4890 gg->next = g;
4891
0f20cc35
DJ
4892 /* Set up any TLS entries. We always place the TLS entries after
4893 all non-TLS entries. */
4894 g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
72e7511a
RS
4895 tga.g = g;
4896 tga.value = MIPS_ELF_GOT_SIZE (abfd);
4897 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
4898 if (!tga.g)
4899 return FALSE;
1fd20d70 4900 BFD_ASSERT (g->tls_assigned_gotno == assign);
f4416af6 4901
ead49a57 4902 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
f4416af6 4903 g = gn;
0626d451 4904
33bb52fb
RS
4905 /* Forbid global symbols in every non-primary GOT from having
4906 lazy-binding stubs. */
0626d451 4907 if (g)
33bb52fb 4908 htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
f4416af6
AO
4909 }
4910 while (g);
4911
59b08994 4912 got->size = assign * MIPS_ELF_GOT_SIZE (abfd);
33bb52fb
RS
4913
4914 needed_relocs = 0;
33bb52fb
RS
4915 for (g = gg->next; g && g->next != gg; g = g->next)
4916 {
4917 unsigned int save_assign;
4918
ab361d49
RS
4919 /* Assign offsets to global GOT entries and count how many
4920 relocations they need. */
cb22ccf4
KCY
4921 save_assign = g->assigned_low_gotno;
4922 g->assigned_low_gotno = g->local_gotno;
ab361d49
RS
4923 tga.info = info;
4924 tga.value = MIPS_ELF_GOT_SIZE (abfd);
4925 tga.g = g;
4926 htab_traverse (g->got_entries, mips_elf_set_global_gotidx, &tga);
72e7511a
RS
4927 if (!tga.g)
4928 return FALSE;
cb22ccf4
KCY
4929 BFD_ASSERT (g->assigned_low_gotno == g->local_gotno + g->global_gotno);
4930 g->assigned_low_gotno = save_assign;
72e7511a 4931
33bb52fb
RS
4932 if (info->shared)
4933 {
cb22ccf4
KCY
4934 g->relocs += g->local_gotno - g->assigned_low_gotno;
4935 BFD_ASSERT (g->assigned_low_gotno == g->next->local_gotno
33bb52fb
RS
4936 + g->next->global_gotno
4937 + g->next->tls_gotno
861fb55a 4938 + htab->reserved_gotno);
33bb52fb 4939 }
ab361d49 4940 needed_relocs += g->relocs;
33bb52fb 4941 }
ab361d49 4942 needed_relocs += g->relocs;
33bb52fb
RS
4943
4944 if (needed_relocs)
4945 mips_elf_allocate_dynamic_relocations (dynobj, info,
4946 needed_relocs);
143d77c5 4947
f4416af6
AO
4948 return TRUE;
4949}
143d77c5 4950
b49e97c9
TS
4951\f
4952/* Returns the first relocation of type r_type found, beginning with
4953 RELOCATION. RELEND is one-past-the-end of the relocation table. */
4954
4955static const Elf_Internal_Rela *
9719ad41
RS
4956mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
4957 const Elf_Internal_Rela *relocation,
4958 const Elf_Internal_Rela *relend)
b49e97c9 4959{
c000e262
TS
4960 unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
4961
b49e97c9
TS
4962 while (relocation < relend)
4963 {
c000e262
TS
4964 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
4965 && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
b49e97c9
TS
4966 return relocation;
4967
4968 ++relocation;
4969 }
4970
4971 /* We didn't find it. */
b49e97c9
TS
4972 return NULL;
4973}
4974
020d7251 4975/* Return whether an input relocation is against a local symbol. */
b49e97c9 4976
b34976b6 4977static bfd_boolean
9719ad41
RS
4978mips_elf_local_relocation_p (bfd *input_bfd,
4979 const Elf_Internal_Rela *relocation,
020d7251 4980 asection **local_sections)
b49e97c9
TS
4981{
4982 unsigned long r_symndx;
4983 Elf_Internal_Shdr *symtab_hdr;
b49e97c9
TS
4984 size_t extsymoff;
4985
4986 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
4987 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4988 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
4989
4990 if (r_symndx < extsymoff)
b34976b6 4991 return TRUE;
b49e97c9 4992 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
b34976b6 4993 return TRUE;
b49e97c9 4994
b34976b6 4995 return FALSE;
b49e97c9
TS
4996}
4997\f
4998/* Sign-extend VALUE, which has the indicated number of BITS. */
4999
a7ebbfdf 5000bfd_vma
9719ad41 5001_bfd_mips_elf_sign_extend (bfd_vma value, int bits)
b49e97c9
TS
5002{
5003 if (value & ((bfd_vma) 1 << (bits - 1)))
5004 /* VALUE is negative. */
5005 value |= ((bfd_vma) - 1) << bits;
5006
5007 return value;
5008}
5009
5010/* Return non-zero if the indicated VALUE has overflowed the maximum
4cc11e76 5011 range expressible by a signed number with the indicated number of
b49e97c9
TS
5012 BITS. */
5013
b34976b6 5014static bfd_boolean
9719ad41 5015mips_elf_overflow_p (bfd_vma value, int bits)
b49e97c9
TS
5016{
5017 bfd_signed_vma svalue = (bfd_signed_vma) value;
5018
5019 if (svalue > (1 << (bits - 1)) - 1)
5020 /* The value is too big. */
b34976b6 5021 return TRUE;
b49e97c9
TS
5022 else if (svalue < -(1 << (bits - 1)))
5023 /* The value is too small. */
b34976b6 5024 return TRUE;
b49e97c9
TS
5025
5026 /* All is well. */
b34976b6 5027 return FALSE;
b49e97c9
TS
5028}
5029
5030/* Calculate the %high function. */
5031
5032static bfd_vma
9719ad41 5033mips_elf_high (bfd_vma value)
b49e97c9
TS
5034{
5035 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
5036}
5037
5038/* Calculate the %higher function. */
5039
5040static bfd_vma
9719ad41 5041mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
b49e97c9
TS
5042{
5043#ifdef BFD64
5044 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
5045#else
5046 abort ();
c5ae1840 5047 return MINUS_ONE;
b49e97c9
TS
5048#endif
5049}
5050
5051/* Calculate the %highest function. */
5052
5053static bfd_vma
9719ad41 5054mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
b49e97c9
TS
5055{
5056#ifdef BFD64
b15e6682 5057 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
b49e97c9
TS
5058#else
5059 abort ();
c5ae1840 5060 return MINUS_ONE;
b49e97c9
TS
5061#endif
5062}
5063\f
5064/* Create the .compact_rel section. */
5065
b34976b6 5066static bfd_boolean
9719ad41
RS
5067mips_elf_create_compact_rel_section
5068 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
b49e97c9
TS
5069{
5070 flagword flags;
5071 register asection *s;
5072
3d4d4302 5073 if (bfd_get_linker_section (abfd, ".compact_rel") == NULL)
b49e97c9
TS
5074 {
5075 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
5076 | SEC_READONLY);
5077
3d4d4302 5078 s = bfd_make_section_anyway_with_flags (abfd, ".compact_rel", flags);
b49e97c9 5079 if (s == NULL
b49e97c9
TS
5080 || ! bfd_set_section_alignment (abfd, s,
5081 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
b34976b6 5082 return FALSE;
b49e97c9 5083
eea6121a 5084 s->size = sizeof (Elf32_External_compact_rel);
b49e97c9
TS
5085 }
5086
b34976b6 5087 return TRUE;
b49e97c9
TS
5088}
5089
5090/* Create the .got section to hold the global offset table. */
5091
b34976b6 5092static bfd_boolean
23cc69b6 5093mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
b49e97c9
TS
5094{
5095 flagword flags;
5096 register asection *s;
5097 struct elf_link_hash_entry *h;
14a793b2 5098 struct bfd_link_hash_entry *bh;
0a44bf69
RS
5099 struct mips_elf_link_hash_table *htab;
5100
5101 htab = mips_elf_hash_table (info);
4dfe6ac6 5102 BFD_ASSERT (htab != NULL);
b49e97c9
TS
5103
5104 /* This function may be called more than once. */
23cc69b6
RS
5105 if (htab->sgot)
5106 return TRUE;
b49e97c9
TS
5107
5108 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
5109 | SEC_LINKER_CREATED);
5110
72b4917c
TS
5111 /* We have to use an alignment of 2**4 here because this is hardcoded
5112 in the function stub generation and in the linker script. */
87e0a731 5113 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
b49e97c9 5114 if (s == NULL
72b4917c 5115 || ! bfd_set_section_alignment (abfd, s, 4))
b34976b6 5116 return FALSE;
a8028dd0 5117 htab->sgot = s;
b49e97c9
TS
5118
5119 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
5120 linker script because we don't want to define the symbol if we
5121 are not creating a global offset table. */
14a793b2 5122 bh = NULL;
b49e97c9
TS
5123 if (! (_bfd_generic_link_add_one_symbol
5124 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
9719ad41 5125 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
b34976b6 5126 return FALSE;
14a793b2
AM
5127
5128 h = (struct elf_link_hash_entry *) bh;
f5385ebf
AM
5129 h->non_elf = 0;
5130 h->def_regular = 1;
b49e97c9 5131 h->type = STT_OBJECT;
2f9efdfc 5132 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
d329bcd1 5133 elf_hash_table (info)->hgot = h;
b49e97c9
TS
5134
5135 if (info->shared
c152c796 5136 && ! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 5137 return FALSE;
b49e97c9 5138
3dff0dd1 5139 htab->got_info = mips_elf_create_got_info (abfd);
f0abc2a1 5140 mips_elf_section_data (s)->elf.this_hdr.sh_flags
b49e97c9
TS
5141 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5142
861fb55a 5143 /* We also need a .got.plt section when generating PLTs. */
87e0a731
AM
5144 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt",
5145 SEC_ALLOC | SEC_LOAD
5146 | SEC_HAS_CONTENTS
5147 | SEC_IN_MEMORY
5148 | SEC_LINKER_CREATED);
861fb55a
DJ
5149 if (s == NULL)
5150 return FALSE;
5151 htab->sgotplt = s;
0a44bf69 5152
b34976b6 5153 return TRUE;
b49e97c9 5154}
b49e97c9 5155\f
0a44bf69
RS
5156/* Return true if H refers to the special VxWorks __GOTT_BASE__ or
5157 __GOTT_INDEX__ symbols. These symbols are only special for
5158 shared objects; they are not used in executables. */
5159
5160static bfd_boolean
5161is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
5162{
5163 return (mips_elf_hash_table (info)->is_vxworks
5164 && info->shared
5165 && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
5166 || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
5167}
861fb55a
DJ
5168
5169/* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
5170 require an la25 stub. See also mips_elf_local_pic_function_p,
5171 which determines whether the destination function ever requires a
5172 stub. */
5173
5174static bfd_boolean
8f0c309a
CLT
5175mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type,
5176 bfd_boolean target_is_16_bit_code_p)
861fb55a
DJ
5177{
5178 /* We specifically ignore branches and jumps from EF_PIC objects,
5179 where the onus is on the compiler or programmer to perform any
5180 necessary initialization of $25. Sometimes such initialization
5181 is unnecessary; for example, -mno-shared functions do not use
5182 the incoming value of $25, and may therefore be called directly. */
5183 if (PIC_OBJECT_P (input_bfd))
5184 return FALSE;
5185
5186 switch (r_type)
5187 {
5188 case R_MIPS_26:
5189 case R_MIPS_PC16:
7361da2c
AB
5190 case R_MIPS_PC21_S2:
5191 case R_MIPS_PC26_S2:
df58fc94
RS
5192 case R_MICROMIPS_26_S1:
5193 case R_MICROMIPS_PC7_S1:
5194 case R_MICROMIPS_PC10_S1:
5195 case R_MICROMIPS_PC16_S1:
5196 case R_MICROMIPS_PC23_S2:
861fb55a
DJ
5197 return TRUE;
5198
8f0c309a
CLT
5199 case R_MIPS16_26:
5200 return !target_is_16_bit_code_p;
5201
861fb55a
DJ
5202 default:
5203 return FALSE;
5204 }
5205}
0a44bf69 5206\f
b49e97c9
TS
5207/* Calculate the value produced by the RELOCATION (which comes from
5208 the INPUT_BFD). The ADDEND is the addend to use for this
5209 RELOCATION; RELOCATION->R_ADDEND is ignored.
5210
5211 The result of the relocation calculation is stored in VALUEP.
38a7df63 5212 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
df58fc94 5213 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
b49e97c9
TS
5214
5215 This function returns bfd_reloc_continue if the caller need take no
5216 further action regarding this relocation, bfd_reloc_notsupported if
5217 something goes dramatically wrong, bfd_reloc_overflow if an
5218 overflow occurs, and bfd_reloc_ok to indicate success. */
5219
5220static bfd_reloc_status_type
9719ad41
RS
5221mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
5222 asection *input_section,
5223 struct bfd_link_info *info,
5224 const Elf_Internal_Rela *relocation,
5225 bfd_vma addend, reloc_howto_type *howto,
5226 Elf_Internal_Sym *local_syms,
5227 asection **local_sections, bfd_vma *valuep,
38a7df63
CF
5228 const char **namep,
5229 bfd_boolean *cross_mode_jump_p,
9719ad41 5230 bfd_boolean save_addend)
b49e97c9
TS
5231{
5232 /* The eventual value we will return. */
5233 bfd_vma value;
5234 /* The address of the symbol against which the relocation is
5235 occurring. */
5236 bfd_vma symbol = 0;
5237 /* The final GP value to be used for the relocatable, executable, or
5238 shared object file being produced. */
0a61c8c2 5239 bfd_vma gp;
b49e97c9
TS
5240 /* The place (section offset or address) of the storage unit being
5241 relocated. */
5242 bfd_vma p;
5243 /* The value of GP used to create the relocatable object. */
0a61c8c2 5244 bfd_vma gp0;
b49e97c9
TS
5245 /* The offset into the global offset table at which the address of
5246 the relocation entry symbol, adjusted by the addend, resides
5247 during execution. */
5248 bfd_vma g = MINUS_ONE;
5249 /* The section in which the symbol referenced by the relocation is
5250 located. */
5251 asection *sec = NULL;
5252 struct mips_elf_link_hash_entry *h = NULL;
b34976b6 5253 /* TRUE if the symbol referred to by this relocation is a local
b49e97c9 5254 symbol. */
b34976b6
AM
5255 bfd_boolean local_p, was_local_p;
5256 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
5257 bfd_boolean gp_disp_p = FALSE;
bbe506e8
TS
5258 /* TRUE if the symbol referred to by this relocation is
5259 "__gnu_local_gp". */
5260 bfd_boolean gnu_local_gp_p = FALSE;
b49e97c9
TS
5261 Elf_Internal_Shdr *symtab_hdr;
5262 size_t extsymoff;
5263 unsigned long r_symndx;
5264 int r_type;
b34976b6 5265 /* TRUE if overflow occurred during the calculation of the
b49e97c9 5266 relocation value. */
b34976b6
AM
5267 bfd_boolean overflowed_p;
5268 /* TRUE if this relocation refers to a MIPS16 function. */
5269 bfd_boolean target_is_16_bit_code_p = FALSE;
df58fc94 5270 bfd_boolean target_is_micromips_code_p = FALSE;
0a44bf69
RS
5271 struct mips_elf_link_hash_table *htab;
5272 bfd *dynobj;
5273
5274 dynobj = elf_hash_table (info)->dynobj;
5275 htab = mips_elf_hash_table (info);
4dfe6ac6 5276 BFD_ASSERT (htab != NULL);
b49e97c9
TS
5277
5278 /* Parse the relocation. */
5279 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5280 r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5281 p = (input_section->output_section->vma
5282 + input_section->output_offset
5283 + relocation->r_offset);
5284
5285 /* Assume that there will be no overflow. */
b34976b6 5286 overflowed_p = FALSE;
b49e97c9
TS
5287
5288 /* Figure out whether or not the symbol is local, and get the offset
5289 used in the array of hash table entries. */
5290 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5291 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
020d7251 5292 local_sections);
bce03d3d 5293 was_local_p = local_p;
b49e97c9
TS
5294 if (! elf_bad_symtab (input_bfd))
5295 extsymoff = symtab_hdr->sh_info;
5296 else
5297 {
5298 /* The symbol table does not follow the rule that local symbols
5299 must come before globals. */
5300 extsymoff = 0;
5301 }
5302
5303 /* Figure out the value of the symbol. */
5304 if (local_p)
5305 {
5306 Elf_Internal_Sym *sym;
5307
5308 sym = local_syms + r_symndx;
5309 sec = local_sections[r_symndx];
5310
5311 symbol = sec->output_section->vma + sec->output_offset;
d4df96e6
L
5312 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
5313 || (sec->flags & SEC_MERGE))
b49e97c9 5314 symbol += sym->st_value;
d4df96e6
L
5315 if ((sec->flags & SEC_MERGE)
5316 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5317 {
5318 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
5319 addend -= symbol;
5320 addend += sec->output_section->vma + sec->output_offset;
5321 }
b49e97c9 5322
df58fc94
RS
5323 /* MIPS16/microMIPS text labels should be treated as odd. */
5324 if (ELF_ST_IS_COMPRESSED (sym->st_other))
b49e97c9
TS
5325 ++symbol;
5326
5327 /* Record the name of this symbol, for our caller. */
5328 *namep = bfd_elf_string_from_elf_section (input_bfd,
5329 symtab_hdr->sh_link,
5330 sym->st_name);
5331 if (*namep == '\0')
5332 *namep = bfd_section_name (input_bfd, sec);
5333
30c09090 5334 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
df58fc94 5335 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other);
b49e97c9
TS
5336 }
5337 else
5338 {
560e09e9
NC
5339 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
5340
b49e97c9
TS
5341 /* For global symbols we look up the symbol in the hash-table. */
5342 h = ((struct mips_elf_link_hash_entry *)
5343 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5344 /* Find the real hash-table entry for this symbol. */
5345 while (h->root.root.type == bfd_link_hash_indirect
5346 || h->root.root.type == bfd_link_hash_warning)
5347 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5348
5349 /* Record the name of this symbol, for our caller. */
5350 *namep = h->root.root.root.string;
5351
5352 /* See if this is the special _gp_disp symbol. Note that such a
5353 symbol must always be a global symbol. */
560e09e9 5354 if (strcmp (*namep, "_gp_disp") == 0
b49e97c9
TS
5355 && ! NEWABI_P (input_bfd))
5356 {
5357 /* Relocations against _gp_disp are permitted only with
5358 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
738e5348 5359 if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
b49e97c9
TS
5360 return bfd_reloc_notsupported;
5361
b34976b6 5362 gp_disp_p = TRUE;
b49e97c9 5363 }
bbe506e8
TS
5364 /* See if this is the special _gp symbol. Note that such a
5365 symbol must always be a global symbol. */
5366 else if (strcmp (*namep, "__gnu_local_gp") == 0)
5367 gnu_local_gp_p = TRUE;
5368
5369
b49e97c9
TS
5370 /* If this symbol is defined, calculate its address. Note that
5371 _gp_disp is a magic symbol, always implicitly defined by the
5372 linker, so it's inappropriate to check to see whether or not
5373 its defined. */
5374 else if ((h->root.root.type == bfd_link_hash_defined
5375 || h->root.root.type == bfd_link_hash_defweak)
5376 && h->root.root.u.def.section)
5377 {
5378 sec = h->root.root.u.def.section;
5379 if (sec->output_section)
5380 symbol = (h->root.root.u.def.value
5381 + sec->output_section->vma
5382 + sec->output_offset);
5383 else
5384 symbol = h->root.root.u.def.value;
5385 }
5386 else if (h->root.root.type == bfd_link_hash_undefweak)
5387 /* We allow relocations against undefined weak symbols, giving
5388 it the value zero, so that you can undefined weak functions
5389 and check to see if they exist by looking at their
5390 addresses. */
5391 symbol = 0;
59c2e50f 5392 else if (info->unresolved_syms_in_objects == RM_IGNORE
b49e97c9
TS
5393 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5394 symbol = 0;
a4d0f181
TS
5395 else if (strcmp (*namep, SGI_COMPAT (input_bfd)
5396 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
b49e97c9
TS
5397 {
5398 /* If this is a dynamic link, we should have created a
5399 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5400 in in _bfd_mips_elf_create_dynamic_sections.
5401 Otherwise, we should define the symbol with a value of 0.
5402 FIXME: It should probably get into the symbol table
5403 somehow as well. */
5404 BFD_ASSERT (! info->shared);
5405 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5406 symbol = 0;
5407 }
5e2b0d47
NC
5408 else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
5409 {
5410 /* This is an optional symbol - an Irix specific extension to the
5411 ELF spec. Ignore it for now.
5412 XXX - FIXME - there is more to the spec for OPTIONAL symbols
5413 than simply ignoring them, but we do not handle this for now.
5414 For information see the "64-bit ELF Object File Specification"
5415 which is available from here:
5416 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
5417 symbol = 0;
5418 }
e7e2196d
MR
5419 else if ((*info->callbacks->undefined_symbol)
5420 (info, h->root.root.root.string, input_bfd,
5421 input_section, relocation->r_offset,
5422 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
5423 || ELF_ST_VISIBILITY (h->root.other)))
5424 {
5425 return bfd_reloc_undefined;
5426 }
b49e97c9
TS
5427 else
5428 {
e7e2196d 5429 return bfd_reloc_notsupported;
b49e97c9
TS
5430 }
5431
30c09090 5432 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
1bbce132 5433 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (h->root.other);
b49e97c9
TS
5434 }
5435
738e5348
RS
5436 /* If this is a reference to a 16-bit function with a stub, we need
5437 to redirect the relocation to the stub unless:
5438
5439 (a) the relocation is for a MIPS16 JAL;
5440
5441 (b) the relocation is for a MIPS16 PIC call, and there are no
5442 non-MIPS16 uses of the GOT slot; or
5443
5444 (c) the section allows direct references to MIPS16 functions. */
5445 if (r_type != R_MIPS16_26
5446 && !info->relocatable
5447 && ((h != NULL
5448 && h->fn_stub != NULL
5449 && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
b9d58d71 5450 || (local_p
698600e4
AM
5451 && mips_elf_tdata (input_bfd)->local_stubs != NULL
5452 && mips_elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
738e5348 5453 && !section_allows_mips16_refs_p (input_section))
b49e97c9
TS
5454 {
5455 /* This is a 32- or 64-bit call to a 16-bit function. We should
5456 have already noticed that we were going to need the
5457 stub. */
5458 if (local_p)
8f0c309a 5459 {
698600e4 5460 sec = mips_elf_tdata (input_bfd)->local_stubs[r_symndx];
8f0c309a
CLT
5461 value = 0;
5462 }
b49e97c9
TS
5463 else
5464 {
5465 BFD_ASSERT (h->need_fn_stub);
8f0c309a
CLT
5466 if (h->la25_stub)
5467 {
5468 /* If a LA25 header for the stub itself exists, point to the
5469 prepended LUI/ADDIU sequence. */
5470 sec = h->la25_stub->stub_section;
5471 value = h->la25_stub->offset;
5472 }
5473 else
5474 {
5475 sec = h->fn_stub;
5476 value = 0;
5477 }
b49e97c9
TS
5478 }
5479
8f0c309a 5480 symbol = sec->output_section->vma + sec->output_offset + value;
f38c2df5
TS
5481 /* The target is 16-bit, but the stub isn't. */
5482 target_is_16_bit_code_p = FALSE;
b49e97c9 5483 }
1bbce132
MR
5484 /* If this is a MIPS16 call with a stub, that is made through the PLT or
5485 to a standard MIPS function, we need to redirect the call to the stub.
5486 Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
5487 indirect calls should use an indirect stub instead. */
1049f94e 5488 else if (r_type == R_MIPS16_26 && !info->relocatable
b314ec0e 5489 && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
b9d58d71 5490 || (local_p
698600e4
AM
5491 && mips_elf_tdata (input_bfd)->local_call_stubs != NULL
5492 && mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
1bbce132 5493 && ((h != NULL && h->use_plt_entry) || !target_is_16_bit_code_p))
b49e97c9 5494 {
b9d58d71 5495 if (local_p)
698600e4 5496 sec = mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx];
b9d58d71 5497 else
b49e97c9 5498 {
b9d58d71
TS
5499 /* If both call_stub and call_fp_stub are defined, we can figure
5500 out which one to use by checking which one appears in the input
5501 file. */
5502 if (h->call_stub != NULL && h->call_fp_stub != NULL)
b49e97c9 5503 {
b9d58d71 5504 asection *o;
68ffbac6 5505
b9d58d71
TS
5506 sec = NULL;
5507 for (o = input_bfd->sections; o != NULL; o = o->next)
b49e97c9 5508 {
b9d58d71
TS
5509 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
5510 {
5511 sec = h->call_fp_stub;
5512 break;
5513 }
b49e97c9 5514 }
b9d58d71
TS
5515 if (sec == NULL)
5516 sec = h->call_stub;
b49e97c9 5517 }
b9d58d71 5518 else if (h->call_stub != NULL)
b49e97c9 5519 sec = h->call_stub;
b9d58d71
TS
5520 else
5521 sec = h->call_fp_stub;
5522 }
b49e97c9 5523
eea6121a 5524 BFD_ASSERT (sec->size > 0);
b49e97c9
TS
5525 symbol = sec->output_section->vma + sec->output_offset;
5526 }
861fb55a
DJ
5527 /* If this is a direct call to a PIC function, redirect to the
5528 non-PIC stub. */
5529 else if (h != NULL && h->la25_stub
8f0c309a
CLT
5530 && mips_elf_relocation_needs_la25_stub (input_bfd, r_type,
5531 target_is_16_bit_code_p))
861fb55a
DJ
5532 symbol = (h->la25_stub->stub_section->output_section->vma
5533 + h->la25_stub->stub_section->output_offset
5534 + h->la25_stub->offset);
1bbce132
MR
5535 /* For direct MIPS16 and microMIPS calls make sure the compressed PLT
5536 entry is used if a standard PLT entry has also been made. In this
5537 case the symbol will have been set by mips_elf_set_plt_sym_value
5538 to point to the standard PLT entry, so redirect to the compressed
5539 one. */
5540 else if ((r_type == R_MIPS16_26 || r_type == R_MICROMIPS_26_S1)
5541 && !info->relocatable
5542 && h != NULL
5543 && h->use_plt_entry
5544 && h->root.plt.plist->comp_offset != MINUS_ONE
5545 && h->root.plt.plist->mips_offset != MINUS_ONE)
5546 {
5547 bfd_boolean micromips_p = MICROMIPS_P (abfd);
5548
5549 sec = htab->splt;
5550 symbol = (sec->output_section->vma
5551 + sec->output_offset
5552 + htab->plt_header_size
5553 + htab->plt_mips_offset
5554 + h->root.plt.plist->comp_offset
5555 + 1);
5556
5557 target_is_16_bit_code_p = !micromips_p;
5558 target_is_micromips_code_p = micromips_p;
5559 }
b49e97c9 5560
df58fc94
RS
5561 /* Make sure MIPS16 and microMIPS are not used together. */
5562 if ((r_type == R_MIPS16_26 && target_is_micromips_code_p)
5563 || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
5564 {
5565 (*_bfd_error_handler)
5566 (_("MIPS16 and microMIPS functions cannot call each other"));
5567 return bfd_reloc_notsupported;
5568 }
5569
b49e97c9 5570 /* Calls from 16-bit code to 32-bit code and vice versa require the
df58fc94
RS
5571 mode change. However, we can ignore calls to undefined weak symbols,
5572 which should never be executed at runtime. This exception is important
5573 because the assembly writer may have "known" that any definition of the
5574 symbol would be 16-bit code, and that direct jumps were therefore
5575 acceptable. */
5576 *cross_mode_jump_p = (!info->relocatable
5577 && !(h && h->root.root.type == bfd_link_hash_undefweak)
5578 && ((r_type == R_MIPS16_26 && !target_is_16_bit_code_p)
5579 || (r_type == R_MICROMIPS_26_S1
5580 && !target_is_micromips_code_p)
5581 || ((r_type == R_MIPS_26 || r_type == R_MIPS_JALR)
5582 && (target_is_16_bit_code_p
5583 || target_is_micromips_code_p))));
b49e97c9 5584
c5d6fa44 5585 local_p = (h == NULL || mips_use_local_got_p (info, h));
b49e97c9 5586
0a61c8c2
RS
5587 gp0 = _bfd_get_gp_value (input_bfd);
5588 gp = _bfd_get_gp_value (abfd);
23cc69b6 5589 if (htab->got_info)
a8028dd0 5590 gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
0a61c8c2
RS
5591
5592 if (gnu_local_gp_p)
5593 symbol = gp;
5594
df58fc94
RS
5595 /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5596 to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the
5597 corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. */
5598 if (got_page_reloc_p (r_type) && !local_p)
020d7251 5599 {
df58fc94
RS
5600 r_type = (micromips_reloc_p (r_type)
5601 ? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP);
020d7251
RS
5602 addend = 0;
5603 }
5604
e77760d2 5605 /* If we haven't already determined the GOT offset, and we're going
0a61c8c2 5606 to need it, get it now. */
b49e97c9
TS
5607 switch (r_type)
5608 {
738e5348
RS
5609 case R_MIPS16_CALL16:
5610 case R_MIPS16_GOT16:
b49e97c9
TS
5611 case R_MIPS_CALL16:
5612 case R_MIPS_GOT16:
5613 case R_MIPS_GOT_DISP:
5614 case R_MIPS_GOT_HI16:
5615 case R_MIPS_CALL_HI16:
5616 case R_MIPS_GOT_LO16:
5617 case R_MIPS_CALL_LO16:
df58fc94
RS
5618 case R_MICROMIPS_CALL16:
5619 case R_MICROMIPS_GOT16:
5620 case R_MICROMIPS_GOT_DISP:
5621 case R_MICROMIPS_GOT_HI16:
5622 case R_MICROMIPS_CALL_HI16:
5623 case R_MICROMIPS_GOT_LO16:
5624 case R_MICROMIPS_CALL_LO16:
0f20cc35
DJ
5625 case R_MIPS_TLS_GD:
5626 case R_MIPS_TLS_GOTTPREL:
5627 case R_MIPS_TLS_LDM:
d0f13682
CLT
5628 case R_MIPS16_TLS_GD:
5629 case R_MIPS16_TLS_GOTTPREL:
5630 case R_MIPS16_TLS_LDM:
df58fc94
RS
5631 case R_MICROMIPS_TLS_GD:
5632 case R_MICROMIPS_TLS_GOTTPREL:
5633 case R_MICROMIPS_TLS_LDM:
b49e97c9 5634 /* Find the index into the GOT where this value is located. */
df58fc94 5635 if (tls_ldm_reloc_p (r_type))
0f20cc35 5636 {
0a44bf69 5637 g = mips_elf_local_got_index (abfd, input_bfd, info,
5c18022e 5638 0, 0, NULL, r_type);
0f20cc35
DJ
5639 if (g == MINUS_ONE)
5640 return bfd_reloc_outofrange;
5641 }
5642 else if (!local_p)
b49e97c9 5643 {
0a44bf69
RS
5644 /* On VxWorks, CALL relocations should refer to the .got.plt
5645 entry, which is initialized to point at the PLT stub. */
5646 if (htab->is_vxworks
df58fc94
RS
5647 && (call_hi16_reloc_p (r_type)
5648 || call_lo16_reloc_p (r_type)
738e5348 5649 || call16_reloc_p (r_type)))
0a44bf69
RS
5650 {
5651 BFD_ASSERT (addend == 0);
5652 BFD_ASSERT (h->root.needs_plt);
5653 g = mips_elf_gotplt_index (info, &h->root);
5654 }
5655 else
b49e97c9 5656 {
020d7251 5657 BFD_ASSERT (addend == 0);
13fbec83
RS
5658 g = mips_elf_global_got_index (abfd, info, input_bfd,
5659 &h->root, r_type);
e641e783 5660 if (!TLS_RELOC_P (r_type)
020d7251
RS
5661 && !elf_hash_table (info)->dynamic_sections_created)
5662 /* This is a static link. We must initialize the GOT entry. */
a8028dd0 5663 MIPS_ELF_PUT_WORD (dynobj, symbol, htab->sgot->contents + g);
b49e97c9
TS
5664 }
5665 }
0a44bf69 5666 else if (!htab->is_vxworks
738e5348 5667 && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
0a44bf69 5668 /* The calculation below does not involve "g". */
b49e97c9
TS
5669 break;
5670 else
5671 {
5c18022e 5672 g = mips_elf_local_got_index (abfd, input_bfd, info,
0a44bf69 5673 symbol + addend, r_symndx, h, r_type);
b49e97c9
TS
5674 if (g == MINUS_ONE)
5675 return bfd_reloc_outofrange;
5676 }
5677
5678 /* Convert GOT indices to actual offsets. */
a8028dd0 5679 g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
b49e97c9 5680 break;
b49e97c9
TS
5681 }
5682
0a44bf69
RS
5683 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5684 symbols are resolved by the loader. Add them to .rela.dyn. */
5685 if (h != NULL && is_gott_symbol (info, &h->root))
5686 {
5687 Elf_Internal_Rela outrel;
5688 bfd_byte *loc;
5689 asection *s;
5690
5691 s = mips_elf_rel_dyn_section (info, FALSE);
5692 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5693
5694 outrel.r_offset = (input_section->output_section->vma
5695 + input_section->output_offset
5696 + relocation->r_offset);
5697 outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
5698 outrel.r_addend = addend;
5699 bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
9e3313ae
RS
5700
5701 /* If we've written this relocation for a readonly section,
5702 we need to set DF_TEXTREL again, so that we do not delete the
5703 DT_TEXTREL tag. */
5704 if (MIPS_ELF_READONLY_SECTION (input_section))
5705 info->flags |= DF_TEXTREL;
5706
0a44bf69
RS
5707 *valuep = 0;
5708 return bfd_reloc_ok;
5709 }
5710
b49e97c9
TS
5711 /* Figure out what kind of relocation is being performed. */
5712 switch (r_type)
5713 {
5714 case R_MIPS_NONE:
5715 return bfd_reloc_continue;
5716
5717 case R_MIPS_16:
c3eb94b4
MF
5718 if (howto->partial_inplace)
5719 addend = _bfd_mips_elf_sign_extend (addend, 16);
5720 value = symbol + addend;
b49e97c9
TS
5721 overflowed_p = mips_elf_overflow_p (value, 16);
5722 break;
5723
5724 case R_MIPS_32:
5725 case R_MIPS_REL32:
5726 case R_MIPS_64:
5727 if ((info->shared
861fb55a 5728 || (htab->root.dynamic_sections_created
b49e97c9 5729 && h != NULL
f5385ebf 5730 && h->root.def_dynamic
861fb55a
DJ
5731 && !h->root.def_regular
5732 && !h->has_static_relocs))
cf35638d 5733 && r_symndx != STN_UNDEF
9a59ad6b
DJ
5734 && (h == NULL
5735 || h->root.root.type != bfd_link_hash_undefweak
5736 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
b49e97c9
TS
5737 && (input_section->flags & SEC_ALLOC) != 0)
5738 {
861fb55a 5739 /* If we're creating a shared library, then we can't know
b49e97c9
TS
5740 where the symbol will end up. So, we create a relocation
5741 record in the output, and leave the job up to the dynamic
861fb55a
DJ
5742 linker. We must do the same for executable references to
5743 shared library symbols, unless we've decided to use copy
5744 relocs or PLTs instead. */
b49e97c9
TS
5745 value = addend;
5746 if (!mips_elf_create_dynamic_relocation (abfd,
5747 info,
5748 relocation,
5749 h,
5750 sec,
5751 symbol,
5752 &value,
5753 input_section))
5754 return bfd_reloc_undefined;
5755 }
5756 else
5757 {
5758 if (r_type != R_MIPS_REL32)
5759 value = symbol + addend;
5760 else
5761 value = addend;
5762 }
5763 value &= howto->dst_mask;
092dcd75
CD
5764 break;
5765
5766 case R_MIPS_PC32:
5767 value = symbol + addend - p;
5768 value &= howto->dst_mask;
b49e97c9
TS
5769 break;
5770
b49e97c9
TS
5771 case R_MIPS16_26:
5772 /* The calculation for R_MIPS16_26 is just the same as for an
5773 R_MIPS_26. It's only the storage of the relocated field into
5774 the output file that's different. That's handled in
5775 mips_elf_perform_relocation. So, we just fall through to the
5776 R_MIPS_26 case here. */
5777 case R_MIPS_26:
df58fc94
RS
5778 case R_MICROMIPS_26_S1:
5779 {
5780 unsigned int shift;
5781
5782 /* Make sure the target of JALX is word-aligned. Bit 0 must be
5783 the correct ISA mode selector and bit 1 must be 0. */
5784 if (*cross_mode_jump_p && (symbol & 3) != (r_type == R_MIPS_26))
5785 return bfd_reloc_outofrange;
5786
5787 /* Shift is 2, unusually, for microMIPS JALX. */
5788 shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2;
5789
5790 if (was_local_p)
5791 value = addend | ((p + 4) & (0xfc000000 << shift));
c3eb94b4 5792 else if (howto->partial_inplace)
df58fc94 5793 value = _bfd_mips_elf_sign_extend (addend, 26 + shift);
c3eb94b4
MF
5794 else
5795 value = addend;
df58fc94
RS
5796 value = (value + symbol) >> shift;
5797 if (!was_local_p && h->root.root.type != bfd_link_hash_undefweak)
5798 overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift));
5799 value &= howto->dst_mask;
5800 }
b49e97c9
TS
5801 break;
5802
0f20cc35 5803 case R_MIPS_TLS_DTPREL_HI16:
d0f13682 5804 case R_MIPS16_TLS_DTPREL_HI16:
df58fc94 5805 case R_MICROMIPS_TLS_DTPREL_HI16:
0f20cc35
DJ
5806 value = (mips_elf_high (addend + symbol - dtprel_base (info))
5807 & howto->dst_mask);
5808 break;
5809
5810 case R_MIPS_TLS_DTPREL_LO16:
741d6ea8
JM
5811 case R_MIPS_TLS_DTPREL32:
5812 case R_MIPS_TLS_DTPREL64:
d0f13682 5813 case R_MIPS16_TLS_DTPREL_LO16:
df58fc94 5814 case R_MICROMIPS_TLS_DTPREL_LO16:
0f20cc35
DJ
5815 value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
5816 break;
5817
5818 case R_MIPS_TLS_TPREL_HI16:
d0f13682 5819 case R_MIPS16_TLS_TPREL_HI16:
df58fc94 5820 case R_MICROMIPS_TLS_TPREL_HI16:
0f20cc35
DJ
5821 value = (mips_elf_high (addend + symbol - tprel_base (info))
5822 & howto->dst_mask);
5823 break;
5824
5825 case R_MIPS_TLS_TPREL_LO16:
d0f13682
CLT
5826 case R_MIPS_TLS_TPREL32:
5827 case R_MIPS_TLS_TPREL64:
5828 case R_MIPS16_TLS_TPREL_LO16:
df58fc94 5829 case R_MICROMIPS_TLS_TPREL_LO16:
0f20cc35
DJ
5830 value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
5831 break;
5832
b49e97c9 5833 case R_MIPS_HI16:
d6f16593 5834 case R_MIPS16_HI16:
df58fc94 5835 case R_MICROMIPS_HI16:
b49e97c9
TS
5836 if (!gp_disp_p)
5837 {
5838 value = mips_elf_high (addend + symbol);
5839 value &= howto->dst_mask;
5840 }
5841 else
5842 {
d6f16593
MR
5843 /* For MIPS16 ABI code we generate this sequence
5844 0: li $v0,%hi(_gp_disp)
5845 4: addiupc $v1,%lo(_gp_disp)
5846 8: sll $v0,16
5847 12: addu $v0,$v1
5848 14: move $gp,$v0
5849 So the offsets of hi and lo relocs are the same, but the
888b9c01
CLT
5850 base $pc is that used by the ADDIUPC instruction at $t9 + 4.
5851 ADDIUPC clears the low two bits of the instruction address,
5852 so the base is ($t9 + 4) & ~3. */
d6f16593 5853 if (r_type == R_MIPS16_HI16)
888b9c01 5854 value = mips_elf_high (addend + gp - ((p + 4) & ~(bfd_vma) 0x3));
df58fc94
RS
5855 /* The microMIPS .cpload sequence uses the same assembly
5856 instructions as the traditional psABI version, but the
5857 incoming $t9 has the low bit set. */
5858 else if (r_type == R_MICROMIPS_HI16)
5859 value = mips_elf_high (addend + gp - p - 1);
d6f16593
MR
5860 else
5861 value = mips_elf_high (addend + gp - p);
b49e97c9
TS
5862 overflowed_p = mips_elf_overflow_p (value, 16);
5863 }
5864 break;
5865
5866 case R_MIPS_LO16:
d6f16593 5867 case R_MIPS16_LO16:
df58fc94
RS
5868 case R_MICROMIPS_LO16:
5869 case R_MICROMIPS_HI0_LO16:
b49e97c9
TS
5870 if (!gp_disp_p)
5871 value = (symbol + addend) & howto->dst_mask;
5872 else
5873 {
d6f16593
MR
5874 /* See the comment for R_MIPS16_HI16 above for the reason
5875 for this conditional. */
5876 if (r_type == R_MIPS16_LO16)
888b9c01 5877 value = addend + gp - (p & ~(bfd_vma) 0x3);
df58fc94
RS
5878 else if (r_type == R_MICROMIPS_LO16
5879 || r_type == R_MICROMIPS_HI0_LO16)
5880 value = addend + gp - p + 3;
d6f16593
MR
5881 else
5882 value = addend + gp - p + 4;
b49e97c9 5883 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
8dc1a139 5884 for overflow. But, on, say, IRIX5, relocations against
b49e97c9
TS
5885 _gp_disp are normally generated from the .cpload
5886 pseudo-op. It generates code that normally looks like
5887 this:
5888
5889 lui $gp,%hi(_gp_disp)
5890 addiu $gp,$gp,%lo(_gp_disp)
5891 addu $gp,$gp,$t9
5892
5893 Here $t9 holds the address of the function being called,
5894 as required by the MIPS ELF ABI. The R_MIPS_LO16
5895 relocation can easily overflow in this situation, but the
5896 R_MIPS_HI16 relocation will handle the overflow.
5897 Therefore, we consider this a bug in the MIPS ABI, and do
5898 not check for overflow here. */
5899 }
5900 break;
5901
5902 case R_MIPS_LITERAL:
df58fc94 5903 case R_MICROMIPS_LITERAL:
b49e97c9
TS
5904 /* Because we don't merge literal sections, we can handle this
5905 just like R_MIPS_GPREL16. In the long run, we should merge
5906 shared literals, and then we will need to additional work
5907 here. */
5908
5909 /* Fall through. */
5910
5911 case R_MIPS16_GPREL:
5912 /* The R_MIPS16_GPREL performs the same calculation as
5913 R_MIPS_GPREL16, but stores the relocated bits in a different
5914 order. We don't need to do anything special here; the
5915 differences are handled in mips_elf_perform_relocation. */
5916 case R_MIPS_GPREL16:
df58fc94
RS
5917 case R_MICROMIPS_GPREL7_S2:
5918 case R_MICROMIPS_GPREL16:
bce03d3d
AO
5919 /* Only sign-extend the addend if it was extracted from the
5920 instruction. If the addend was separate, leave it alone,
5921 otherwise we may lose significant bits. */
5922 if (howto->partial_inplace)
a7ebbfdf 5923 addend = _bfd_mips_elf_sign_extend (addend, 16);
bce03d3d
AO
5924 value = symbol + addend - gp;
5925 /* If the symbol was local, any earlier relocatable links will
5926 have adjusted its addend with the gp offset, so compensate
5927 for that now. Don't do it for symbols forced local in this
5928 link, though, since they won't have had the gp offset applied
5929 to them before. */
5930 if (was_local_p)
5931 value += gp0;
538baf8b
AB
5932 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5933 overflowed_p = mips_elf_overflow_p (value, 16);
b49e97c9
TS
5934 break;
5935
738e5348
RS
5936 case R_MIPS16_GOT16:
5937 case R_MIPS16_CALL16:
b49e97c9
TS
5938 case R_MIPS_GOT16:
5939 case R_MIPS_CALL16:
df58fc94
RS
5940 case R_MICROMIPS_GOT16:
5941 case R_MICROMIPS_CALL16:
0a44bf69 5942 /* VxWorks does not have separate local and global semantics for
738e5348 5943 R_MIPS*_GOT16; every relocation evaluates to "G". */
0a44bf69 5944 if (!htab->is_vxworks && local_p)
b49e97c9 5945 {
5c18022e 5946 value = mips_elf_got16_entry (abfd, input_bfd, info,
020d7251 5947 symbol + addend, !was_local_p);
b49e97c9
TS
5948 if (value == MINUS_ONE)
5949 return bfd_reloc_outofrange;
5950 value
a8028dd0 5951 = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
b49e97c9
TS
5952 overflowed_p = mips_elf_overflow_p (value, 16);
5953 break;
5954 }
5955
5956 /* Fall through. */
5957
0f20cc35
DJ
5958 case R_MIPS_TLS_GD:
5959 case R_MIPS_TLS_GOTTPREL:
5960 case R_MIPS_TLS_LDM:
b49e97c9 5961 case R_MIPS_GOT_DISP:
d0f13682
CLT
5962 case R_MIPS16_TLS_GD:
5963 case R_MIPS16_TLS_GOTTPREL:
5964 case R_MIPS16_TLS_LDM:
df58fc94
RS
5965 case R_MICROMIPS_TLS_GD:
5966 case R_MICROMIPS_TLS_GOTTPREL:
5967 case R_MICROMIPS_TLS_LDM:
5968 case R_MICROMIPS_GOT_DISP:
b49e97c9
TS
5969 value = g;
5970 overflowed_p = mips_elf_overflow_p (value, 16);
5971 break;
5972
5973 case R_MIPS_GPREL32:
bce03d3d
AO
5974 value = (addend + symbol + gp0 - gp);
5975 if (!save_addend)
5976 value &= howto->dst_mask;
b49e97c9
TS
5977 break;
5978
5979 case R_MIPS_PC16:
bad36eac 5980 case R_MIPS_GNU_REL16_S2:
c3eb94b4
MF
5981 if (howto->partial_inplace)
5982 addend = _bfd_mips_elf_sign_extend (addend, 18);
5983
5984 if ((symbol + addend) & 3)
5985 return bfd_reloc_outofrange;
5986
5987 value = symbol + addend - p;
538baf8b
AB
5988 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5989 overflowed_p = mips_elf_overflow_p (value, 18);
37caec6b
TS
5990 value >>= howto->rightshift;
5991 value &= howto->dst_mask;
b49e97c9
TS
5992 break;
5993
7361da2c
AB
5994 case R_MIPS_PC21_S2:
5995 if (howto->partial_inplace)
5996 addend = _bfd_mips_elf_sign_extend (addend, 23);
5997
5998 if ((symbol + addend) & 3)
5999 return bfd_reloc_outofrange;
6000
6001 value = symbol + addend - p;
538baf8b
AB
6002 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6003 overflowed_p = mips_elf_overflow_p (value, 23);
7361da2c
AB
6004 value >>= howto->rightshift;
6005 value &= howto->dst_mask;
6006 break;
6007
6008 case R_MIPS_PC26_S2:
6009 if (howto->partial_inplace)
6010 addend = _bfd_mips_elf_sign_extend (addend, 28);
6011
6012 if ((symbol + addend) & 3)
6013 return bfd_reloc_outofrange;
6014
6015 value = symbol + addend - p;
538baf8b
AB
6016 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6017 overflowed_p = mips_elf_overflow_p (value, 28);
7361da2c
AB
6018 value >>= howto->rightshift;
6019 value &= howto->dst_mask;
6020 break;
6021
6022 case R_MIPS_PC18_S3:
6023 if (howto->partial_inplace)
6024 addend = _bfd_mips_elf_sign_extend (addend, 21);
6025
6026 if ((symbol + addend) & 7)
6027 return bfd_reloc_outofrange;
6028
6029 value = symbol + addend - ((p | 7) ^ 7);
538baf8b
AB
6030 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6031 overflowed_p = mips_elf_overflow_p (value, 21);
7361da2c
AB
6032 value >>= howto->rightshift;
6033 value &= howto->dst_mask;
6034 break;
6035
6036 case R_MIPS_PC19_S2:
6037 if (howto->partial_inplace)
6038 addend = _bfd_mips_elf_sign_extend (addend, 21);
6039
6040 if ((symbol + addend) & 3)
6041 return bfd_reloc_outofrange;
6042
6043 value = symbol + addend - p;
538baf8b
AB
6044 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6045 overflowed_p = mips_elf_overflow_p (value, 21);
7361da2c
AB
6046 value >>= howto->rightshift;
6047 value &= howto->dst_mask;
6048 break;
6049
6050 case R_MIPS_PCHI16:
6051 value = mips_elf_high (symbol + addend - p);
538baf8b
AB
6052 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6053 overflowed_p = mips_elf_overflow_p (value, 16);
7361da2c
AB
6054 value &= howto->dst_mask;
6055 break;
6056
6057 case R_MIPS_PCLO16:
6058 if (howto->partial_inplace)
6059 addend = _bfd_mips_elf_sign_extend (addend, 16);
6060 value = symbol + addend - p;
6061 value &= howto->dst_mask;
6062 break;
6063
df58fc94 6064 case R_MICROMIPS_PC7_S1:
c3eb94b4
MF
6065 if (howto->partial_inplace)
6066 addend = _bfd_mips_elf_sign_extend (addend, 8);
6067 value = symbol + addend - p;
538baf8b
AB
6068 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6069 overflowed_p = mips_elf_overflow_p (value, 8);
df58fc94
RS
6070 value >>= howto->rightshift;
6071 value &= howto->dst_mask;
6072 break;
6073
6074 case R_MICROMIPS_PC10_S1:
c3eb94b4
MF
6075 if (howto->partial_inplace)
6076 addend = _bfd_mips_elf_sign_extend (addend, 11);
6077 value = symbol + addend - p;
538baf8b
AB
6078 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6079 overflowed_p = mips_elf_overflow_p (value, 11);
df58fc94
RS
6080 value >>= howto->rightshift;
6081 value &= howto->dst_mask;
6082 break;
6083
6084 case R_MICROMIPS_PC16_S1:
c3eb94b4
MF
6085 if (howto->partial_inplace)
6086 addend = _bfd_mips_elf_sign_extend (addend, 17);
6087 value = symbol + addend - p;
538baf8b
AB
6088 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6089 overflowed_p = mips_elf_overflow_p (value, 17);
df58fc94
RS
6090 value >>= howto->rightshift;
6091 value &= howto->dst_mask;
6092 break;
6093
6094 case R_MICROMIPS_PC23_S2:
c3eb94b4
MF
6095 if (howto->partial_inplace)
6096 addend = _bfd_mips_elf_sign_extend (addend, 25);
6097 value = symbol + addend - ((p | 3) ^ 3);
538baf8b
AB
6098 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6099 overflowed_p = mips_elf_overflow_p (value, 25);
df58fc94
RS
6100 value >>= howto->rightshift;
6101 value &= howto->dst_mask;
6102 break;
6103
b49e97c9
TS
6104 case R_MIPS_GOT_HI16:
6105 case R_MIPS_CALL_HI16:
df58fc94
RS
6106 case R_MICROMIPS_GOT_HI16:
6107 case R_MICROMIPS_CALL_HI16:
b49e97c9
TS
6108 /* We're allowed to handle these two relocations identically.
6109 The dynamic linker is allowed to handle the CALL relocations
6110 differently by creating a lazy evaluation stub. */
6111 value = g;
6112 value = mips_elf_high (value);
6113 value &= howto->dst_mask;
6114 break;
6115
6116 case R_MIPS_GOT_LO16:
6117 case R_MIPS_CALL_LO16:
df58fc94
RS
6118 case R_MICROMIPS_GOT_LO16:
6119 case R_MICROMIPS_CALL_LO16:
b49e97c9
TS
6120 value = g & howto->dst_mask;
6121 break;
6122
6123 case R_MIPS_GOT_PAGE:
df58fc94 6124 case R_MICROMIPS_GOT_PAGE:
5c18022e 6125 value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
b49e97c9
TS
6126 if (value == MINUS_ONE)
6127 return bfd_reloc_outofrange;
a8028dd0 6128 value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
b49e97c9
TS
6129 overflowed_p = mips_elf_overflow_p (value, 16);
6130 break;
6131
6132 case R_MIPS_GOT_OFST:
df58fc94 6133 case R_MICROMIPS_GOT_OFST:
93a2b7ae 6134 if (local_p)
5c18022e 6135 mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
0fdc1bf1
AO
6136 else
6137 value = addend;
b49e97c9
TS
6138 overflowed_p = mips_elf_overflow_p (value, 16);
6139 break;
6140
6141 case R_MIPS_SUB:
df58fc94 6142 case R_MICROMIPS_SUB:
b49e97c9
TS
6143 value = symbol - addend;
6144 value &= howto->dst_mask;
6145 break;
6146
6147 case R_MIPS_HIGHER:
df58fc94 6148 case R_MICROMIPS_HIGHER:
b49e97c9
TS
6149 value = mips_elf_higher (addend + symbol);
6150 value &= howto->dst_mask;
6151 break;
6152
6153 case R_MIPS_HIGHEST:
df58fc94 6154 case R_MICROMIPS_HIGHEST:
b49e97c9
TS
6155 value = mips_elf_highest (addend + symbol);
6156 value &= howto->dst_mask;
6157 break;
6158
6159 case R_MIPS_SCN_DISP:
df58fc94 6160 case R_MICROMIPS_SCN_DISP:
b49e97c9
TS
6161 value = symbol + addend - sec->output_offset;
6162 value &= howto->dst_mask;
6163 break;
6164
b49e97c9 6165 case R_MIPS_JALR:
df58fc94 6166 case R_MICROMIPS_JALR:
1367d393
ILT
6167 /* This relocation is only a hint. In some cases, we optimize
6168 it into a bal instruction. But we don't try to optimize
5bbc5ae7
AN
6169 when the symbol does not resolve locally. */
6170 if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
1367d393
ILT
6171 return bfd_reloc_continue;
6172 value = symbol + addend;
6173 break;
b49e97c9 6174
1367d393 6175 case R_MIPS_PJUMP:
b49e97c9
TS
6176 case R_MIPS_GNU_VTINHERIT:
6177 case R_MIPS_GNU_VTENTRY:
6178 /* We don't do anything with these at present. */
6179 return bfd_reloc_continue;
6180
6181 default:
6182 /* An unrecognized relocation type. */
6183 return bfd_reloc_notsupported;
6184 }
6185
6186 /* Store the VALUE for our caller. */
6187 *valuep = value;
6188 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
6189}
6190
6191/* Obtain the field relocated by RELOCATION. */
6192
6193static bfd_vma
9719ad41
RS
6194mips_elf_obtain_contents (reloc_howto_type *howto,
6195 const Elf_Internal_Rela *relocation,
6196 bfd *input_bfd, bfd_byte *contents)
b49e97c9 6197{
6346d5ca 6198 bfd_vma x = 0;
b49e97c9 6199 bfd_byte *location = contents + relocation->r_offset;
6346d5ca 6200 unsigned int size = bfd_get_reloc_size (howto);
b49e97c9
TS
6201
6202 /* Obtain the bytes. */
6346d5ca
AM
6203 if (size != 0)
6204 x = bfd_get (8 * size, input_bfd, location);
b49e97c9 6205
b49e97c9
TS
6206 return x;
6207}
6208
6209/* It has been determined that the result of the RELOCATION is the
6210 VALUE. Use HOWTO to place VALUE into the output file at the
6211 appropriate position. The SECTION is the section to which the
68ffbac6 6212 relocation applies.
38a7df63 6213 CROSS_MODE_JUMP_P is true if the relocation field
df58fc94 6214 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
b49e97c9 6215
b34976b6 6216 Returns FALSE if anything goes wrong. */
b49e97c9 6217
b34976b6 6218static bfd_boolean
9719ad41
RS
6219mips_elf_perform_relocation (struct bfd_link_info *info,
6220 reloc_howto_type *howto,
6221 const Elf_Internal_Rela *relocation,
6222 bfd_vma value, bfd *input_bfd,
6223 asection *input_section, bfd_byte *contents,
38a7df63 6224 bfd_boolean cross_mode_jump_p)
b49e97c9
TS
6225{
6226 bfd_vma x;
6227 bfd_byte *location;
6228 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
6346d5ca 6229 unsigned int size;
b49e97c9
TS
6230
6231 /* Figure out where the relocation is occurring. */
6232 location = contents + relocation->r_offset;
6233
df58fc94 6234 _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
d6f16593 6235
b49e97c9
TS
6236 /* Obtain the current value. */
6237 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
6238
6239 /* Clear the field we are setting. */
6240 x &= ~howto->dst_mask;
6241
b49e97c9
TS
6242 /* Set the field. */
6243 x |= (value & howto->dst_mask);
6244
6245 /* If required, turn JAL into JALX. */
38a7df63 6246 if (cross_mode_jump_p && jal_reloc_p (r_type))
b49e97c9 6247 {
b34976b6 6248 bfd_boolean ok;
b49e97c9
TS
6249 bfd_vma opcode = x >> 26;
6250 bfd_vma jalx_opcode;
6251
6252 /* Check to see if the opcode is already JAL or JALX. */
6253 if (r_type == R_MIPS16_26)
6254 {
6255 ok = ((opcode == 0x6) || (opcode == 0x7));
6256 jalx_opcode = 0x7;
6257 }
df58fc94
RS
6258 else if (r_type == R_MICROMIPS_26_S1)
6259 {
6260 ok = ((opcode == 0x3d) || (opcode == 0x3c));
6261 jalx_opcode = 0x3c;
6262 }
b49e97c9
TS
6263 else
6264 {
6265 ok = ((opcode == 0x3) || (opcode == 0x1d));
6266 jalx_opcode = 0x1d;
6267 }
6268
3bdf9505
MR
6269 /* If the opcode is not JAL or JALX, there's a problem. We cannot
6270 convert J or JALS to JALX. */
b49e97c9
TS
6271 if (!ok)
6272 {
6273 (*_bfd_error_handler)
3bdf9505 6274 (_("%B: %A+0x%lx: Unsupported jump between ISA modes; consider recompiling with interlinking enabled."),
d003868e
AM
6275 input_bfd,
6276 input_section,
b49e97c9
TS
6277 (unsigned long) relocation->r_offset);
6278 bfd_set_error (bfd_error_bad_value);
b34976b6 6279 return FALSE;
b49e97c9
TS
6280 }
6281
6282 /* Make this the JALX opcode. */
6283 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
6284 }
6285
38a7df63
CF
6286 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
6287 range. */
cd8d5a82 6288 if (!info->relocatable
38a7df63 6289 && !cross_mode_jump_p
cd8d5a82
CF
6290 && ((JAL_TO_BAL_P (input_bfd)
6291 && r_type == R_MIPS_26
6292 && (x >> 26) == 0x3) /* jal addr */
6293 || (JALR_TO_BAL_P (input_bfd)
6294 && r_type == R_MIPS_JALR
38a7df63
CF
6295 && x == 0x0320f809) /* jalr t9 */
6296 || (JR_TO_B_P (input_bfd)
6297 && r_type == R_MIPS_JALR
6298 && x == 0x03200008))) /* jr t9 */
1367d393
ILT
6299 {
6300 bfd_vma addr;
6301 bfd_vma dest;
6302 bfd_signed_vma off;
6303
6304 addr = (input_section->output_section->vma
6305 + input_section->output_offset
6306 + relocation->r_offset
6307 + 4);
6308 if (r_type == R_MIPS_26)
6309 dest = (value << 2) | ((addr >> 28) << 28);
6310 else
6311 dest = value;
6312 off = dest - addr;
6313 if (off <= 0x1ffff && off >= -0x20000)
38a7df63
CF
6314 {
6315 if (x == 0x03200008) /* jr t9 */
6316 x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff); /* b addr */
6317 else
6318 x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff); /* bal addr */
6319 }
1367d393
ILT
6320 }
6321
b49e97c9 6322 /* Put the value into the output. */
6346d5ca
AM
6323 size = bfd_get_reloc_size (howto);
6324 if (size != 0)
6325 bfd_put (8 * size, input_bfd, x, location);
d6f16593 6326
df58fc94
RS
6327 _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !info->relocatable,
6328 location);
d6f16593 6329
b34976b6 6330 return TRUE;
b49e97c9 6331}
b49e97c9 6332\f
b49e97c9
TS
6333/* Create a rel.dyn relocation for the dynamic linker to resolve. REL
6334 is the original relocation, which is now being transformed into a
6335 dynamic relocation. The ADDENDP is adjusted if necessary; the
6336 caller should store the result in place of the original addend. */
6337
b34976b6 6338static bfd_boolean
9719ad41
RS
6339mips_elf_create_dynamic_relocation (bfd *output_bfd,
6340 struct bfd_link_info *info,
6341 const Elf_Internal_Rela *rel,
6342 struct mips_elf_link_hash_entry *h,
6343 asection *sec, bfd_vma symbol,
6344 bfd_vma *addendp, asection *input_section)
b49e97c9 6345{
947216bf 6346 Elf_Internal_Rela outrel[3];
b49e97c9
TS
6347 asection *sreloc;
6348 bfd *dynobj;
6349 int r_type;
5d41f0b6
RS
6350 long indx;
6351 bfd_boolean defined_p;
0a44bf69 6352 struct mips_elf_link_hash_table *htab;
b49e97c9 6353
0a44bf69 6354 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
6355 BFD_ASSERT (htab != NULL);
6356
b49e97c9
TS
6357 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6358 dynobj = elf_hash_table (info)->dynobj;
0a44bf69 6359 sreloc = mips_elf_rel_dyn_section (info, FALSE);
b49e97c9
TS
6360 BFD_ASSERT (sreloc != NULL);
6361 BFD_ASSERT (sreloc->contents != NULL);
6362 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
eea6121a 6363 < sreloc->size);
b49e97c9 6364
b49e97c9
TS
6365 outrel[0].r_offset =
6366 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
9ddf8309
TS
6367 if (ABI_64_P (output_bfd))
6368 {
6369 outrel[1].r_offset =
6370 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
6371 outrel[2].r_offset =
6372 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
6373 }
b49e97c9 6374
c5ae1840 6375 if (outrel[0].r_offset == MINUS_ONE)
0d591ff7 6376 /* The relocation field has been deleted. */
5d41f0b6
RS
6377 return TRUE;
6378
6379 if (outrel[0].r_offset == MINUS_TWO)
0d591ff7
RS
6380 {
6381 /* The relocation field has been converted into a relative value of
6382 some sort. Functions like _bfd_elf_write_section_eh_frame expect
6383 the field to be fully relocated, so add in the symbol's value. */
0d591ff7 6384 *addendp += symbol;
5d41f0b6 6385 return TRUE;
0d591ff7 6386 }
b49e97c9 6387
5d41f0b6
RS
6388 /* We must now calculate the dynamic symbol table index to use
6389 in the relocation. */
d4a77f3f 6390 if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root))
5d41f0b6 6391 {
020d7251 6392 BFD_ASSERT (htab->is_vxworks || h->global_got_area != GGA_NONE);
5d41f0b6
RS
6393 indx = h->root.dynindx;
6394 if (SGI_COMPAT (output_bfd))
6395 defined_p = h->root.def_regular;
6396 else
6397 /* ??? glibc's ld.so just adds the final GOT entry to the
6398 relocation field. It therefore treats relocs against
6399 defined symbols in the same way as relocs against
6400 undefined symbols. */
6401 defined_p = FALSE;
6402 }
b49e97c9
TS
6403 else
6404 {
5d41f0b6
RS
6405 if (sec != NULL && bfd_is_abs_section (sec))
6406 indx = 0;
6407 else if (sec == NULL || sec->owner == NULL)
fdd07405 6408 {
5d41f0b6
RS
6409 bfd_set_error (bfd_error_bad_value);
6410 return FALSE;
b49e97c9
TS
6411 }
6412 else
6413 {
5d41f0b6 6414 indx = elf_section_data (sec->output_section)->dynindx;
74541ad4
AM
6415 if (indx == 0)
6416 {
6417 asection *osec = htab->root.text_index_section;
6418 indx = elf_section_data (osec)->dynindx;
6419 }
5d41f0b6
RS
6420 if (indx == 0)
6421 abort ();
b49e97c9
TS
6422 }
6423
5d41f0b6
RS
6424 /* Instead of generating a relocation using the section
6425 symbol, we may as well make it a fully relative
6426 relocation. We want to avoid generating relocations to
6427 local symbols because we used to generate them
6428 incorrectly, without adding the original symbol value,
6429 which is mandated by the ABI for section symbols. In
6430 order to give dynamic loaders and applications time to
6431 phase out the incorrect use, we refrain from emitting
6432 section-relative relocations. It's not like they're
6433 useful, after all. This should be a bit more efficient
6434 as well. */
6435 /* ??? Although this behavior is compatible with glibc's ld.so,
6436 the ABI says that relocations against STN_UNDEF should have
6437 a symbol value of 0. Irix rld honors this, so relocations
6438 against STN_UNDEF have no effect. */
6439 if (!SGI_COMPAT (output_bfd))
6440 indx = 0;
6441 defined_p = TRUE;
b49e97c9
TS
6442 }
6443
5d41f0b6
RS
6444 /* If the relocation was previously an absolute relocation and
6445 this symbol will not be referred to by the relocation, we must
6446 adjust it by the value we give it in the dynamic symbol table.
6447 Otherwise leave the job up to the dynamic linker. */
6448 if (defined_p && r_type != R_MIPS_REL32)
6449 *addendp += symbol;
6450
0a44bf69
RS
6451 if (htab->is_vxworks)
6452 /* VxWorks uses non-relative relocations for this. */
6453 outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
6454 else
6455 /* The relocation is always an REL32 relocation because we don't
6456 know where the shared library will wind up at load-time. */
6457 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
6458 R_MIPS_REL32);
6459
5d41f0b6
RS
6460 /* For strict adherence to the ABI specification, we should
6461 generate a R_MIPS_64 relocation record by itself before the
6462 _REL32/_64 record as well, such that the addend is read in as
6463 a 64-bit value (REL32 is a 32-bit relocation, after all).
6464 However, since none of the existing ELF64 MIPS dynamic
6465 loaders seems to care, we don't waste space with these
6466 artificial relocations. If this turns out to not be true,
6467 mips_elf_allocate_dynamic_relocation() should be tweaked so
6468 as to make room for a pair of dynamic relocations per
6469 invocation if ABI_64_P, and here we should generate an
6470 additional relocation record with R_MIPS_64 by itself for a
6471 NULL symbol before this relocation record. */
6472 outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
6473 ABI_64_P (output_bfd)
6474 ? R_MIPS_64
6475 : R_MIPS_NONE);
6476 outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
6477
6478 /* Adjust the output offset of the relocation to reference the
6479 correct location in the output file. */
6480 outrel[0].r_offset += (input_section->output_section->vma
6481 + input_section->output_offset);
6482 outrel[1].r_offset += (input_section->output_section->vma
6483 + input_section->output_offset);
6484 outrel[2].r_offset += (input_section->output_section->vma
6485 + input_section->output_offset);
6486
b49e97c9
TS
6487 /* Put the relocation back out. We have to use the special
6488 relocation outputter in the 64-bit case since the 64-bit
6489 relocation format is non-standard. */
6490 if (ABI_64_P (output_bfd))
6491 {
6492 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
6493 (output_bfd, &outrel[0],
6494 (sreloc->contents
6495 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
6496 }
0a44bf69
RS
6497 else if (htab->is_vxworks)
6498 {
6499 /* VxWorks uses RELA rather than REL dynamic relocations. */
6500 outrel[0].r_addend = *addendp;
6501 bfd_elf32_swap_reloca_out
6502 (output_bfd, &outrel[0],
6503 (sreloc->contents
6504 + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
6505 }
b49e97c9 6506 else
947216bf
AM
6507 bfd_elf32_swap_reloc_out
6508 (output_bfd, &outrel[0],
6509 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
b49e97c9 6510
b49e97c9
TS
6511 /* We've now added another relocation. */
6512 ++sreloc->reloc_count;
6513
6514 /* Make sure the output section is writable. The dynamic linker
6515 will be writing to it. */
6516 elf_section_data (input_section->output_section)->this_hdr.sh_flags
6517 |= SHF_WRITE;
6518
6519 /* On IRIX5, make an entry of compact relocation info. */
5d41f0b6 6520 if (IRIX_COMPAT (output_bfd) == ict_irix5)
b49e97c9 6521 {
3d4d4302 6522 asection *scpt = bfd_get_linker_section (dynobj, ".compact_rel");
b49e97c9
TS
6523 bfd_byte *cr;
6524
6525 if (scpt)
6526 {
6527 Elf32_crinfo cptrel;
6528
6529 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
6530 cptrel.vaddr = (rel->r_offset
6531 + input_section->output_section->vma
6532 + input_section->output_offset);
6533 if (r_type == R_MIPS_REL32)
6534 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
6535 else
6536 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
6537 mips_elf_set_cr_dist2to (cptrel, 0);
6538 cptrel.konst = *addendp;
6539
6540 cr = (scpt->contents
6541 + sizeof (Elf32_External_compact_rel));
abc0f8d0 6542 mips_elf_set_cr_relvaddr (cptrel, 0);
b49e97c9
TS
6543 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
6544 ((Elf32_External_crinfo *) cr
6545 + scpt->reloc_count));
6546 ++scpt->reloc_count;
6547 }
6548 }
6549
943284cc
DJ
6550 /* If we've written this relocation for a readonly section,
6551 we need to set DF_TEXTREL again, so that we do not delete the
6552 DT_TEXTREL tag. */
6553 if (MIPS_ELF_READONLY_SECTION (input_section))
6554 info->flags |= DF_TEXTREL;
6555
b34976b6 6556 return TRUE;
b49e97c9
TS
6557}
6558\f
b49e97c9
TS
6559/* Return the MACH for a MIPS e_flags value. */
6560
6561unsigned long
9719ad41 6562_bfd_elf_mips_mach (flagword flags)
b49e97c9
TS
6563{
6564 switch (flags & EF_MIPS_MACH)
6565 {
6566 case E_MIPS_MACH_3900:
6567 return bfd_mach_mips3900;
6568
6569 case E_MIPS_MACH_4010:
6570 return bfd_mach_mips4010;
6571
6572 case E_MIPS_MACH_4100:
6573 return bfd_mach_mips4100;
6574
6575 case E_MIPS_MACH_4111:
6576 return bfd_mach_mips4111;
6577
00707a0e
RS
6578 case E_MIPS_MACH_4120:
6579 return bfd_mach_mips4120;
6580
b49e97c9
TS
6581 case E_MIPS_MACH_4650:
6582 return bfd_mach_mips4650;
6583
00707a0e
RS
6584 case E_MIPS_MACH_5400:
6585 return bfd_mach_mips5400;
6586
6587 case E_MIPS_MACH_5500:
6588 return bfd_mach_mips5500;
6589
e407c74b
NC
6590 case E_MIPS_MACH_5900:
6591 return bfd_mach_mips5900;
6592
0d2e43ed
ILT
6593 case E_MIPS_MACH_9000:
6594 return bfd_mach_mips9000;
6595
b49e97c9
TS
6596 case E_MIPS_MACH_SB1:
6597 return bfd_mach_mips_sb1;
6598
350cc38d
MS
6599 case E_MIPS_MACH_LS2E:
6600 return bfd_mach_mips_loongson_2e;
6601
6602 case E_MIPS_MACH_LS2F:
6603 return bfd_mach_mips_loongson_2f;
6604
fd503541
NC
6605 case E_MIPS_MACH_LS3A:
6606 return bfd_mach_mips_loongson_3a;
6607
2c629856
N
6608 case E_MIPS_MACH_OCTEON3:
6609 return bfd_mach_mips_octeon3;
6610
432233b3
AP
6611 case E_MIPS_MACH_OCTEON2:
6612 return bfd_mach_mips_octeon2;
6613
6f179bd0
AN
6614 case E_MIPS_MACH_OCTEON:
6615 return bfd_mach_mips_octeon;
6616
52b6b6b9
JM
6617 case E_MIPS_MACH_XLR:
6618 return bfd_mach_mips_xlr;
6619
b49e97c9
TS
6620 default:
6621 switch (flags & EF_MIPS_ARCH)
6622 {
6623 default:
6624 case E_MIPS_ARCH_1:
6625 return bfd_mach_mips3000;
b49e97c9
TS
6626
6627 case E_MIPS_ARCH_2:
6628 return bfd_mach_mips6000;
b49e97c9
TS
6629
6630 case E_MIPS_ARCH_3:
6631 return bfd_mach_mips4000;
b49e97c9
TS
6632
6633 case E_MIPS_ARCH_4:
6634 return bfd_mach_mips8000;
b49e97c9
TS
6635
6636 case E_MIPS_ARCH_5:
6637 return bfd_mach_mips5;
b49e97c9
TS
6638
6639 case E_MIPS_ARCH_32:
6640 return bfd_mach_mipsisa32;
b49e97c9
TS
6641
6642 case E_MIPS_ARCH_64:
6643 return bfd_mach_mipsisa64;
af7ee8bf
CD
6644
6645 case E_MIPS_ARCH_32R2:
6646 return bfd_mach_mipsisa32r2;
5f74bc13
CD
6647
6648 case E_MIPS_ARCH_64R2:
6649 return bfd_mach_mipsisa64r2;
7361da2c
AB
6650
6651 case E_MIPS_ARCH_32R6:
6652 return bfd_mach_mipsisa32r6;
6653
6654 case E_MIPS_ARCH_64R6:
6655 return bfd_mach_mipsisa64r6;
b49e97c9
TS
6656 }
6657 }
6658
6659 return 0;
6660}
6661
6662/* Return printable name for ABI. */
6663
6664static INLINE char *
9719ad41 6665elf_mips_abi_name (bfd *abfd)
b49e97c9
TS
6666{
6667 flagword flags;
6668
6669 flags = elf_elfheader (abfd)->e_flags;
6670 switch (flags & EF_MIPS_ABI)
6671 {
6672 case 0:
6673 if (ABI_N32_P (abfd))
6674 return "N32";
6675 else if (ABI_64_P (abfd))
6676 return "64";
6677 else
6678 return "none";
6679 case E_MIPS_ABI_O32:
6680 return "O32";
6681 case E_MIPS_ABI_O64:
6682 return "O64";
6683 case E_MIPS_ABI_EABI32:
6684 return "EABI32";
6685 case E_MIPS_ABI_EABI64:
6686 return "EABI64";
6687 default:
6688 return "unknown abi";
6689 }
6690}
6691\f
6692/* MIPS ELF uses two common sections. One is the usual one, and the
6693 other is for small objects. All the small objects are kept
6694 together, and then referenced via the gp pointer, which yields
6695 faster assembler code. This is what we use for the small common
6696 section. This approach is copied from ecoff.c. */
6697static asection mips_elf_scom_section;
6698static asymbol mips_elf_scom_symbol;
6699static asymbol *mips_elf_scom_symbol_ptr;
6700
6701/* MIPS ELF also uses an acommon section, which represents an
6702 allocated common symbol which may be overridden by a
6703 definition in a shared library. */
6704static asection mips_elf_acom_section;
6705static asymbol mips_elf_acom_symbol;
6706static asymbol *mips_elf_acom_symbol_ptr;
6707
738e5348 6708/* This is used for both the 32-bit and the 64-bit ABI. */
b49e97c9
TS
6709
6710void
9719ad41 6711_bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
b49e97c9
TS
6712{
6713 elf_symbol_type *elfsym;
6714
738e5348 6715 /* Handle the special MIPS section numbers that a symbol may use. */
b49e97c9
TS
6716 elfsym = (elf_symbol_type *) asym;
6717 switch (elfsym->internal_elf_sym.st_shndx)
6718 {
6719 case SHN_MIPS_ACOMMON:
6720 /* This section is used in a dynamically linked executable file.
6721 It is an allocated common section. The dynamic linker can
6722 either resolve these symbols to something in a shared
6723 library, or it can just leave them here. For our purposes,
6724 we can consider these symbols to be in a new section. */
6725 if (mips_elf_acom_section.name == NULL)
6726 {
6727 /* Initialize the acommon section. */
6728 mips_elf_acom_section.name = ".acommon";
6729 mips_elf_acom_section.flags = SEC_ALLOC;
6730 mips_elf_acom_section.output_section = &mips_elf_acom_section;
6731 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
6732 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
6733 mips_elf_acom_symbol.name = ".acommon";
6734 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
6735 mips_elf_acom_symbol.section = &mips_elf_acom_section;
6736 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
6737 }
6738 asym->section = &mips_elf_acom_section;
6739 break;
6740
6741 case SHN_COMMON:
6742 /* Common symbols less than the GP size are automatically
6743 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
6744 if (asym->value > elf_gp_size (abfd)
b59eed79 6745 || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
b49e97c9
TS
6746 || IRIX_COMPAT (abfd) == ict_irix6)
6747 break;
6748 /* Fall through. */
6749 case SHN_MIPS_SCOMMON:
6750 if (mips_elf_scom_section.name == NULL)
6751 {
6752 /* Initialize the small common section. */
6753 mips_elf_scom_section.name = ".scommon";
6754 mips_elf_scom_section.flags = SEC_IS_COMMON;
6755 mips_elf_scom_section.output_section = &mips_elf_scom_section;
6756 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
6757 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
6758 mips_elf_scom_symbol.name = ".scommon";
6759 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
6760 mips_elf_scom_symbol.section = &mips_elf_scom_section;
6761 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
6762 }
6763 asym->section = &mips_elf_scom_section;
6764 asym->value = elfsym->internal_elf_sym.st_size;
6765 break;
6766
6767 case SHN_MIPS_SUNDEFINED:
6768 asym->section = bfd_und_section_ptr;
6769 break;
6770
b49e97c9 6771 case SHN_MIPS_TEXT:
00b4930b
TS
6772 {
6773 asection *section = bfd_get_section_by_name (abfd, ".text");
6774
00b4930b
TS
6775 if (section != NULL)
6776 {
6777 asym->section = section;
6778 /* MIPS_TEXT is a bit special, the address is not an offset
6779 to the base of the .text section. So substract the section
6780 base address to make it an offset. */
6781 asym->value -= section->vma;
6782 }
6783 }
b49e97c9
TS
6784 break;
6785
6786 case SHN_MIPS_DATA:
00b4930b
TS
6787 {
6788 asection *section = bfd_get_section_by_name (abfd, ".data");
6789
00b4930b
TS
6790 if (section != NULL)
6791 {
6792 asym->section = section;
6793 /* MIPS_DATA is a bit special, the address is not an offset
6794 to the base of the .data section. So substract the section
6795 base address to make it an offset. */
6796 asym->value -= section->vma;
6797 }
6798 }
b49e97c9 6799 break;
b49e97c9 6800 }
738e5348 6801
df58fc94
RS
6802 /* If this is an odd-valued function symbol, assume it's a MIPS16
6803 or microMIPS one. */
738e5348
RS
6804 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
6805 && (asym->value & 1) != 0)
6806 {
6807 asym->value--;
e8faf7d1 6808 if (MICROMIPS_P (abfd))
df58fc94
RS
6809 elfsym->internal_elf_sym.st_other
6810 = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other);
6811 else
6812 elfsym->internal_elf_sym.st_other
6813 = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
738e5348 6814 }
b49e97c9
TS
6815}
6816\f
8c946ed5
RS
6817/* Implement elf_backend_eh_frame_address_size. This differs from
6818 the default in the way it handles EABI64.
6819
6820 EABI64 was originally specified as an LP64 ABI, and that is what
6821 -mabi=eabi normally gives on a 64-bit target. However, gcc has
6822 historically accepted the combination of -mabi=eabi and -mlong32,
6823 and this ILP32 variation has become semi-official over time.
6824 Both forms use elf32 and have pointer-sized FDE addresses.
6825
6826 If an EABI object was generated by GCC 4.0 or above, it will have
6827 an empty .gcc_compiled_longXX section, where XX is the size of longs
6828 in bits. Unfortunately, ILP32 objects generated by earlier compilers
6829 have no special marking to distinguish them from LP64 objects.
6830
6831 We don't want users of the official LP64 ABI to be punished for the
6832 existence of the ILP32 variant, but at the same time, we don't want
6833 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6834 We therefore take the following approach:
6835
6836 - If ABFD contains a .gcc_compiled_longXX section, use it to
6837 determine the pointer size.
6838
6839 - Otherwise check the type of the first relocation. Assume that
6840 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
6841
6842 - Otherwise punt.
6843
6844 The second check is enough to detect LP64 objects generated by pre-4.0
6845 compilers because, in the kind of output generated by those compilers,
6846 the first relocation will be associated with either a CIE personality
6847 routine or an FDE start address. Furthermore, the compilers never
6848 used a special (non-pointer) encoding for this ABI.
6849
6850 Checking the relocation type should also be safe because there is no
6851 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
6852 did so. */
6853
6854unsigned int
6855_bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
6856{
6857 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
6858 return 8;
6859 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
6860 {
6861 bfd_boolean long32_p, long64_p;
6862
6863 long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
6864 long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
6865 if (long32_p && long64_p)
6866 return 0;
6867 if (long32_p)
6868 return 4;
6869 if (long64_p)
6870 return 8;
6871
6872 if (sec->reloc_count > 0
6873 && elf_section_data (sec)->relocs != NULL
6874 && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
6875 == R_MIPS_64))
6876 return 8;
6877
6878 return 0;
6879 }
6880 return 4;
6881}
6882\f
174fd7f9
RS
6883/* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
6884 relocations against two unnamed section symbols to resolve to the
6885 same address. For example, if we have code like:
6886
6887 lw $4,%got_disp(.data)($gp)
6888 lw $25,%got_disp(.text)($gp)
6889 jalr $25
6890
6891 then the linker will resolve both relocations to .data and the program
6892 will jump there rather than to .text.
6893
6894 We can work around this problem by giving names to local section symbols.
6895 This is also what the MIPSpro tools do. */
6896
6897bfd_boolean
6898_bfd_mips_elf_name_local_section_symbols (bfd *abfd)
6899{
6900 return SGI_COMPAT (abfd);
6901}
6902\f
b49e97c9
TS
6903/* Work over a section just before writing it out. This routine is
6904 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
6905 sections that need the SHF_MIPS_GPREL flag by name; there has to be
6906 a better way. */
6907
b34976b6 6908bfd_boolean
9719ad41 6909_bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
b49e97c9
TS
6910{
6911 if (hdr->sh_type == SHT_MIPS_REGINFO
6912 && hdr->sh_size > 0)
6913 {
6914 bfd_byte buf[4];
6915
6916 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
6917 BFD_ASSERT (hdr->contents == NULL);
6918
6919 if (bfd_seek (abfd,
6920 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
6921 SEEK_SET) != 0)
b34976b6 6922 return FALSE;
b49e97c9 6923 H_PUT_32 (abfd, elf_gp (abfd), buf);
9719ad41 6924 if (bfd_bwrite (buf, 4, abfd) != 4)
b34976b6 6925 return FALSE;
b49e97c9
TS
6926 }
6927
6928 if (hdr->sh_type == SHT_MIPS_OPTIONS
6929 && hdr->bfd_section != NULL
f0abc2a1
AM
6930 && mips_elf_section_data (hdr->bfd_section) != NULL
6931 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
b49e97c9
TS
6932 {
6933 bfd_byte *contents, *l, *lend;
6934
f0abc2a1
AM
6935 /* We stored the section contents in the tdata field in the
6936 set_section_contents routine. We save the section contents
6937 so that we don't have to read them again.
b49e97c9
TS
6938 At this point we know that elf_gp is set, so we can look
6939 through the section contents to see if there is an
6940 ODK_REGINFO structure. */
6941
f0abc2a1 6942 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
b49e97c9
TS
6943 l = contents;
6944 lend = contents + hdr->sh_size;
6945 while (l + sizeof (Elf_External_Options) <= lend)
6946 {
6947 Elf_Internal_Options intopt;
6948
6949 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6950 &intopt);
1bc8074d
MR
6951 if (intopt.size < sizeof (Elf_External_Options))
6952 {
6953 (*_bfd_error_handler)
6954 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6955 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6956 break;
6957 }
b49e97c9
TS
6958 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6959 {
6960 bfd_byte buf[8];
6961
6962 if (bfd_seek (abfd,
6963 (hdr->sh_offset
6964 + (l - contents)
6965 + sizeof (Elf_External_Options)
6966 + (sizeof (Elf64_External_RegInfo) - 8)),
6967 SEEK_SET) != 0)
b34976b6 6968 return FALSE;
b49e97c9 6969 H_PUT_64 (abfd, elf_gp (abfd), buf);
9719ad41 6970 if (bfd_bwrite (buf, 8, abfd) != 8)
b34976b6 6971 return FALSE;
b49e97c9
TS
6972 }
6973 else if (intopt.kind == ODK_REGINFO)
6974 {
6975 bfd_byte buf[4];
6976
6977 if (bfd_seek (abfd,
6978 (hdr->sh_offset
6979 + (l - contents)
6980 + sizeof (Elf_External_Options)
6981 + (sizeof (Elf32_External_RegInfo) - 4)),
6982 SEEK_SET) != 0)
b34976b6 6983 return FALSE;
b49e97c9 6984 H_PUT_32 (abfd, elf_gp (abfd), buf);
9719ad41 6985 if (bfd_bwrite (buf, 4, abfd) != 4)
b34976b6 6986 return FALSE;
b49e97c9
TS
6987 }
6988 l += intopt.size;
6989 }
6990 }
6991
6992 if (hdr->bfd_section != NULL)
6993 {
6994 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
6995
2d0f9ad9
JM
6996 /* .sbss is not handled specially here because the GNU/Linux
6997 prelinker can convert .sbss from NOBITS to PROGBITS and
6998 changing it back to NOBITS breaks the binary. The entry in
6999 _bfd_mips_elf_special_sections will ensure the correct flags
7000 are set on .sbss if BFD creates it without reading it from an
7001 input file, and without special handling here the flags set
7002 on it in an input file will be followed. */
b49e97c9
TS
7003 if (strcmp (name, ".sdata") == 0
7004 || strcmp (name, ".lit8") == 0
7005 || strcmp (name, ".lit4") == 0)
fd6f9d17 7006 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
b49e97c9 7007 else if (strcmp (name, ".srdata") == 0)
fd6f9d17 7008 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
b49e97c9 7009 else if (strcmp (name, ".compact_rel") == 0)
fd6f9d17 7010 hdr->sh_flags = 0;
b49e97c9
TS
7011 else if (strcmp (name, ".rtproc") == 0)
7012 {
7013 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
7014 {
7015 unsigned int adjust;
7016
7017 adjust = hdr->sh_size % hdr->sh_addralign;
7018 if (adjust != 0)
7019 hdr->sh_size += hdr->sh_addralign - adjust;
7020 }
7021 }
7022 }
7023
b34976b6 7024 return TRUE;
b49e97c9
TS
7025}
7026
7027/* Handle a MIPS specific section when reading an object file. This
7028 is called when elfcode.h finds a section with an unknown type.
7029 This routine supports both the 32-bit and 64-bit ELF ABI.
7030
7031 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
7032 how to. */
7033
b34976b6 7034bfd_boolean
6dc132d9
L
7035_bfd_mips_elf_section_from_shdr (bfd *abfd,
7036 Elf_Internal_Shdr *hdr,
7037 const char *name,
7038 int shindex)
b49e97c9
TS
7039{
7040 flagword flags = 0;
7041
7042 /* There ought to be a place to keep ELF backend specific flags, but
7043 at the moment there isn't one. We just keep track of the
7044 sections by their name, instead. Fortunately, the ABI gives
7045 suggested names for all the MIPS specific sections, so we will
7046 probably get away with this. */
7047 switch (hdr->sh_type)
7048 {
7049 case SHT_MIPS_LIBLIST:
7050 if (strcmp (name, ".liblist") != 0)
b34976b6 7051 return FALSE;
b49e97c9
TS
7052 break;
7053 case SHT_MIPS_MSYM:
7054 if (strcmp (name, ".msym") != 0)
b34976b6 7055 return FALSE;
b49e97c9
TS
7056 break;
7057 case SHT_MIPS_CONFLICT:
7058 if (strcmp (name, ".conflict") != 0)
b34976b6 7059 return FALSE;
b49e97c9
TS
7060 break;
7061 case SHT_MIPS_GPTAB:
0112cd26 7062 if (! CONST_STRNEQ (name, ".gptab."))
b34976b6 7063 return FALSE;
b49e97c9
TS
7064 break;
7065 case SHT_MIPS_UCODE:
7066 if (strcmp (name, ".ucode") != 0)
b34976b6 7067 return FALSE;
b49e97c9
TS
7068 break;
7069 case SHT_MIPS_DEBUG:
7070 if (strcmp (name, ".mdebug") != 0)
b34976b6 7071 return FALSE;
b49e97c9
TS
7072 flags = SEC_DEBUGGING;
7073 break;
7074 case SHT_MIPS_REGINFO:
7075 if (strcmp (name, ".reginfo") != 0
7076 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
b34976b6 7077 return FALSE;
b49e97c9
TS
7078 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
7079 break;
7080 case SHT_MIPS_IFACE:
7081 if (strcmp (name, ".MIPS.interfaces") != 0)
b34976b6 7082 return FALSE;
b49e97c9
TS
7083 break;
7084 case SHT_MIPS_CONTENT:
0112cd26 7085 if (! CONST_STRNEQ (name, ".MIPS.content"))
b34976b6 7086 return FALSE;
b49e97c9
TS
7087 break;
7088 case SHT_MIPS_OPTIONS:
cc2e31b9 7089 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
b34976b6 7090 return FALSE;
b49e97c9 7091 break;
351cdf24
MF
7092 case SHT_MIPS_ABIFLAGS:
7093 if (!MIPS_ELF_ABIFLAGS_SECTION_NAME_P (name))
7094 return FALSE;
7095 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
7096 break;
b49e97c9 7097 case SHT_MIPS_DWARF:
1b315056 7098 if (! CONST_STRNEQ (name, ".debug_")
355d10dc 7099 && ! CONST_STRNEQ (name, ".zdebug_"))
b34976b6 7100 return FALSE;
b49e97c9
TS
7101 break;
7102 case SHT_MIPS_SYMBOL_LIB:
7103 if (strcmp (name, ".MIPS.symlib") != 0)
b34976b6 7104 return FALSE;
b49e97c9
TS
7105 break;
7106 case SHT_MIPS_EVENTS:
0112cd26
NC
7107 if (! CONST_STRNEQ (name, ".MIPS.events")
7108 && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
b34976b6 7109 return FALSE;
b49e97c9
TS
7110 break;
7111 default:
cc2e31b9 7112 break;
b49e97c9
TS
7113 }
7114
6dc132d9 7115 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
b34976b6 7116 return FALSE;
b49e97c9
TS
7117
7118 if (flags)
7119 {
7120 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
7121 (bfd_get_section_flags (abfd,
7122 hdr->bfd_section)
7123 | flags)))
b34976b6 7124 return FALSE;
b49e97c9
TS
7125 }
7126
351cdf24
MF
7127 if (hdr->sh_type == SHT_MIPS_ABIFLAGS)
7128 {
7129 Elf_External_ABIFlags_v0 ext;
7130
7131 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
7132 &ext, 0, sizeof ext))
7133 return FALSE;
7134 bfd_mips_elf_swap_abiflags_v0_in (abfd, &ext,
7135 &mips_elf_tdata (abfd)->abiflags);
7136 if (mips_elf_tdata (abfd)->abiflags.version != 0)
7137 return FALSE;
7138 mips_elf_tdata (abfd)->abiflags_valid = TRUE;
7139 }
7140
b49e97c9
TS
7141 /* FIXME: We should record sh_info for a .gptab section. */
7142
7143 /* For a .reginfo section, set the gp value in the tdata information
7144 from the contents of this section. We need the gp value while
7145 processing relocs, so we just get it now. The .reginfo section
7146 is not used in the 64-bit MIPS ELF ABI. */
7147 if (hdr->sh_type == SHT_MIPS_REGINFO)
7148 {
7149 Elf32_External_RegInfo ext;
7150 Elf32_RegInfo s;
7151
9719ad41
RS
7152 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
7153 &ext, 0, sizeof ext))
b34976b6 7154 return FALSE;
b49e97c9
TS
7155 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
7156 elf_gp (abfd) = s.ri_gp_value;
7157 }
7158
7159 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
7160 set the gp value based on what we find. We may see both
7161 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
7162 they should agree. */
7163 if (hdr->sh_type == SHT_MIPS_OPTIONS)
7164 {
7165 bfd_byte *contents, *l, *lend;
7166
9719ad41 7167 contents = bfd_malloc (hdr->sh_size);
b49e97c9 7168 if (contents == NULL)
b34976b6 7169 return FALSE;
b49e97c9 7170 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
9719ad41 7171 0, hdr->sh_size))
b49e97c9
TS
7172 {
7173 free (contents);
b34976b6 7174 return FALSE;
b49e97c9
TS
7175 }
7176 l = contents;
7177 lend = contents + hdr->sh_size;
7178 while (l + sizeof (Elf_External_Options) <= lend)
7179 {
7180 Elf_Internal_Options intopt;
7181
7182 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
7183 &intopt);
1bc8074d
MR
7184 if (intopt.size < sizeof (Elf_External_Options))
7185 {
7186 (*_bfd_error_handler)
7187 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
7188 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
7189 break;
7190 }
b49e97c9
TS
7191 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
7192 {
7193 Elf64_Internal_RegInfo intreg;
7194
7195 bfd_mips_elf64_swap_reginfo_in
7196 (abfd,
7197 ((Elf64_External_RegInfo *)
7198 (l + sizeof (Elf_External_Options))),
7199 &intreg);
7200 elf_gp (abfd) = intreg.ri_gp_value;
7201 }
7202 else if (intopt.kind == ODK_REGINFO)
7203 {
7204 Elf32_RegInfo intreg;
7205
7206 bfd_mips_elf32_swap_reginfo_in
7207 (abfd,
7208 ((Elf32_External_RegInfo *)
7209 (l + sizeof (Elf_External_Options))),
7210 &intreg);
7211 elf_gp (abfd) = intreg.ri_gp_value;
7212 }
7213 l += intopt.size;
7214 }
7215 free (contents);
7216 }
7217
b34976b6 7218 return TRUE;
b49e97c9
TS
7219}
7220
7221/* Set the correct type for a MIPS ELF section. We do this by the
7222 section name, which is a hack, but ought to work. This routine is
7223 used by both the 32-bit and the 64-bit ABI. */
7224
b34976b6 7225bfd_boolean
9719ad41 7226_bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
b49e97c9 7227{
0414f35b 7228 const char *name = bfd_get_section_name (abfd, sec);
b49e97c9
TS
7229
7230 if (strcmp (name, ".liblist") == 0)
7231 {
7232 hdr->sh_type = SHT_MIPS_LIBLIST;
eea6121a 7233 hdr->sh_info = sec->size / sizeof (Elf32_Lib);
b49e97c9
TS
7234 /* The sh_link field is set in final_write_processing. */
7235 }
7236 else if (strcmp (name, ".conflict") == 0)
7237 hdr->sh_type = SHT_MIPS_CONFLICT;
0112cd26 7238 else if (CONST_STRNEQ (name, ".gptab."))
b49e97c9
TS
7239 {
7240 hdr->sh_type = SHT_MIPS_GPTAB;
7241 hdr->sh_entsize = sizeof (Elf32_External_gptab);
7242 /* The sh_info field is set in final_write_processing. */
7243 }
7244 else if (strcmp (name, ".ucode") == 0)
7245 hdr->sh_type = SHT_MIPS_UCODE;
7246 else if (strcmp (name, ".mdebug") == 0)
7247 {
7248 hdr->sh_type = SHT_MIPS_DEBUG;
8dc1a139 7249 /* In a shared object on IRIX 5.3, the .mdebug section has an
b49e97c9
TS
7250 entsize of 0. FIXME: Does this matter? */
7251 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
7252 hdr->sh_entsize = 0;
7253 else
7254 hdr->sh_entsize = 1;
7255 }
7256 else if (strcmp (name, ".reginfo") == 0)
7257 {
7258 hdr->sh_type = SHT_MIPS_REGINFO;
8dc1a139 7259 /* In a shared object on IRIX 5.3, the .reginfo section has an
b49e97c9
TS
7260 entsize of 0x18. FIXME: Does this matter? */
7261 if (SGI_COMPAT (abfd))
7262 {
7263 if ((abfd->flags & DYNAMIC) != 0)
7264 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
7265 else
7266 hdr->sh_entsize = 1;
7267 }
7268 else
7269 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
7270 }
7271 else if (SGI_COMPAT (abfd)
7272 && (strcmp (name, ".hash") == 0
7273 || strcmp (name, ".dynamic") == 0
7274 || strcmp (name, ".dynstr") == 0))
7275 {
7276 if (SGI_COMPAT (abfd))
7277 hdr->sh_entsize = 0;
7278#if 0
8dc1a139 7279 /* This isn't how the IRIX6 linker behaves. */
b49e97c9
TS
7280 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
7281#endif
7282 }
7283 else if (strcmp (name, ".got") == 0
7284 || strcmp (name, ".srdata") == 0
7285 || strcmp (name, ".sdata") == 0
7286 || strcmp (name, ".sbss") == 0
7287 || strcmp (name, ".lit4") == 0
7288 || strcmp (name, ".lit8") == 0)
7289 hdr->sh_flags |= SHF_MIPS_GPREL;
7290 else if (strcmp (name, ".MIPS.interfaces") == 0)
7291 {
7292 hdr->sh_type = SHT_MIPS_IFACE;
7293 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7294 }
0112cd26 7295 else if (CONST_STRNEQ (name, ".MIPS.content"))
b49e97c9
TS
7296 {
7297 hdr->sh_type = SHT_MIPS_CONTENT;
7298 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7299 /* The sh_info field is set in final_write_processing. */
7300 }
cc2e31b9 7301 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
b49e97c9
TS
7302 {
7303 hdr->sh_type = SHT_MIPS_OPTIONS;
7304 hdr->sh_entsize = 1;
7305 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7306 }
351cdf24
MF
7307 else if (CONST_STRNEQ (name, ".MIPS.abiflags"))
7308 {
7309 hdr->sh_type = SHT_MIPS_ABIFLAGS;
7310 hdr->sh_entsize = sizeof (Elf_External_ABIFlags_v0);
7311 }
1b315056
CS
7312 else if (CONST_STRNEQ (name, ".debug_")
7313 || CONST_STRNEQ (name, ".zdebug_"))
b5482f21
NC
7314 {
7315 hdr->sh_type = SHT_MIPS_DWARF;
7316
7317 /* Irix facilities such as libexc expect a single .debug_frame
7318 per executable, the system ones have NOSTRIP set and the linker
7319 doesn't merge sections with different flags so ... */
7320 if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
7321 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7322 }
b49e97c9
TS
7323 else if (strcmp (name, ".MIPS.symlib") == 0)
7324 {
7325 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
7326 /* The sh_link and sh_info fields are set in
7327 final_write_processing. */
7328 }
0112cd26
NC
7329 else if (CONST_STRNEQ (name, ".MIPS.events")
7330 || CONST_STRNEQ (name, ".MIPS.post_rel"))
b49e97c9
TS
7331 {
7332 hdr->sh_type = SHT_MIPS_EVENTS;
7333 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7334 /* The sh_link field is set in final_write_processing. */
7335 }
7336 else if (strcmp (name, ".msym") == 0)
7337 {
7338 hdr->sh_type = SHT_MIPS_MSYM;
7339 hdr->sh_flags |= SHF_ALLOC;
7340 hdr->sh_entsize = 8;
7341 }
7342
7a79a000
TS
7343 /* The generic elf_fake_sections will set up REL_HDR using the default
7344 kind of relocations. We used to set up a second header for the
7345 non-default kind of relocations here, but only NewABI would use
7346 these, and the IRIX ld doesn't like resulting empty RELA sections.
7347 Thus we create those header only on demand now. */
b49e97c9 7348
b34976b6 7349 return TRUE;
b49e97c9
TS
7350}
7351
7352/* Given a BFD section, try to locate the corresponding ELF section
7353 index. This is used by both the 32-bit and the 64-bit ABI.
7354 Actually, it's not clear to me that the 64-bit ABI supports these,
7355 but for non-PIC objects we will certainly want support for at least
7356 the .scommon section. */
7357
b34976b6 7358bfd_boolean
9719ad41
RS
7359_bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
7360 asection *sec, int *retval)
b49e97c9
TS
7361{
7362 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
7363 {
7364 *retval = SHN_MIPS_SCOMMON;
b34976b6 7365 return TRUE;
b49e97c9
TS
7366 }
7367 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
7368 {
7369 *retval = SHN_MIPS_ACOMMON;
b34976b6 7370 return TRUE;
b49e97c9 7371 }
b34976b6 7372 return FALSE;
b49e97c9
TS
7373}
7374\f
7375/* Hook called by the linker routine which adds symbols from an object
7376 file. We must handle the special MIPS section numbers here. */
7377
b34976b6 7378bfd_boolean
9719ad41 7379_bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
555cd476 7380 Elf_Internal_Sym *sym, const char **namep,
9719ad41
RS
7381 flagword *flagsp ATTRIBUTE_UNUSED,
7382 asection **secp, bfd_vma *valp)
b49e97c9
TS
7383{
7384 if (SGI_COMPAT (abfd)
7385 && (abfd->flags & DYNAMIC) != 0
7386 && strcmp (*namep, "_rld_new_interface") == 0)
7387 {
8dc1a139 7388 /* Skip IRIX5 rld entry name. */
b49e97c9 7389 *namep = NULL;
b34976b6 7390 return TRUE;
b49e97c9
TS
7391 }
7392
eedecc07
DD
7393 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
7394 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
7395 by setting a DT_NEEDED for the shared object. Since _gp_disp is
7396 a magic symbol resolved by the linker, we ignore this bogus definition
7397 of _gp_disp. New ABI objects do not suffer from this problem so this
7398 is not done for them. */
7399 if (!NEWABI_P(abfd)
7400 && (sym->st_shndx == SHN_ABS)
7401 && (strcmp (*namep, "_gp_disp") == 0))
7402 {
7403 *namep = NULL;
7404 return TRUE;
7405 }
7406
b49e97c9
TS
7407 switch (sym->st_shndx)
7408 {
7409 case SHN_COMMON:
7410 /* Common symbols less than the GP size are automatically
7411 treated as SHN_MIPS_SCOMMON symbols. */
7412 if (sym->st_size > elf_gp_size (abfd)
b59eed79 7413 || ELF_ST_TYPE (sym->st_info) == STT_TLS
b49e97c9
TS
7414 || IRIX_COMPAT (abfd) == ict_irix6)
7415 break;
7416 /* Fall through. */
7417 case SHN_MIPS_SCOMMON:
7418 *secp = bfd_make_section_old_way (abfd, ".scommon");
7419 (*secp)->flags |= SEC_IS_COMMON;
7420 *valp = sym->st_size;
7421 break;
7422
7423 case SHN_MIPS_TEXT:
7424 /* This section is used in a shared object. */
698600e4 7425 if (mips_elf_tdata (abfd)->elf_text_section == NULL)
b49e97c9
TS
7426 {
7427 asymbol *elf_text_symbol;
7428 asection *elf_text_section;
7429 bfd_size_type amt = sizeof (asection);
7430
7431 elf_text_section = bfd_zalloc (abfd, amt);
7432 if (elf_text_section == NULL)
b34976b6 7433 return FALSE;
b49e97c9
TS
7434
7435 amt = sizeof (asymbol);
7436 elf_text_symbol = bfd_zalloc (abfd, amt);
7437 if (elf_text_symbol == NULL)
b34976b6 7438 return FALSE;
b49e97c9
TS
7439
7440 /* Initialize the section. */
7441
698600e4
AM
7442 mips_elf_tdata (abfd)->elf_text_section = elf_text_section;
7443 mips_elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
b49e97c9
TS
7444
7445 elf_text_section->symbol = elf_text_symbol;
698600e4 7446 elf_text_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_text_symbol;
b49e97c9
TS
7447
7448 elf_text_section->name = ".text";
7449 elf_text_section->flags = SEC_NO_FLAGS;
7450 elf_text_section->output_section = NULL;
7451 elf_text_section->owner = abfd;
7452 elf_text_symbol->name = ".text";
7453 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7454 elf_text_symbol->section = elf_text_section;
7455 }
7456 /* This code used to do *secp = bfd_und_section_ptr if
7457 info->shared. I don't know why, and that doesn't make sense,
7458 so I took it out. */
698600e4 7459 *secp = mips_elf_tdata (abfd)->elf_text_section;
b49e97c9
TS
7460 break;
7461
7462 case SHN_MIPS_ACOMMON:
7463 /* Fall through. XXX Can we treat this as allocated data? */
7464 case SHN_MIPS_DATA:
7465 /* This section is used in a shared object. */
698600e4 7466 if (mips_elf_tdata (abfd)->elf_data_section == NULL)
b49e97c9
TS
7467 {
7468 asymbol *elf_data_symbol;
7469 asection *elf_data_section;
7470 bfd_size_type amt = sizeof (asection);
7471
7472 elf_data_section = bfd_zalloc (abfd, amt);
7473 if (elf_data_section == NULL)
b34976b6 7474 return FALSE;
b49e97c9
TS
7475
7476 amt = sizeof (asymbol);
7477 elf_data_symbol = bfd_zalloc (abfd, amt);
7478 if (elf_data_symbol == NULL)
b34976b6 7479 return FALSE;
b49e97c9
TS
7480
7481 /* Initialize the section. */
7482
698600e4
AM
7483 mips_elf_tdata (abfd)->elf_data_section = elf_data_section;
7484 mips_elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
b49e97c9
TS
7485
7486 elf_data_section->symbol = elf_data_symbol;
698600e4 7487 elf_data_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_data_symbol;
b49e97c9
TS
7488
7489 elf_data_section->name = ".data";
7490 elf_data_section->flags = SEC_NO_FLAGS;
7491 elf_data_section->output_section = NULL;
7492 elf_data_section->owner = abfd;
7493 elf_data_symbol->name = ".data";
7494 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7495 elf_data_symbol->section = elf_data_section;
7496 }
7497 /* This code used to do *secp = bfd_und_section_ptr if
7498 info->shared. I don't know why, and that doesn't make sense,
7499 so I took it out. */
698600e4 7500 *secp = mips_elf_tdata (abfd)->elf_data_section;
b49e97c9
TS
7501 break;
7502
7503 case SHN_MIPS_SUNDEFINED:
7504 *secp = bfd_und_section_ptr;
7505 break;
7506 }
7507
7508 if (SGI_COMPAT (abfd)
7509 && ! info->shared
f13a99db 7510 && info->output_bfd->xvec == abfd->xvec
b49e97c9
TS
7511 && strcmp (*namep, "__rld_obj_head") == 0)
7512 {
7513 struct elf_link_hash_entry *h;
14a793b2 7514 struct bfd_link_hash_entry *bh;
b49e97c9
TS
7515
7516 /* Mark __rld_obj_head as dynamic. */
14a793b2 7517 bh = NULL;
b49e97c9 7518 if (! (_bfd_generic_link_add_one_symbol
9719ad41 7519 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
14a793b2 7520 get_elf_backend_data (abfd)->collect, &bh)))
b34976b6 7521 return FALSE;
14a793b2
AM
7522
7523 h = (struct elf_link_hash_entry *) bh;
f5385ebf
AM
7524 h->non_elf = 0;
7525 h->def_regular = 1;
b49e97c9
TS
7526 h->type = STT_OBJECT;
7527
c152c796 7528 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 7529 return FALSE;
b49e97c9 7530
b34976b6 7531 mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
b4082c70 7532 mips_elf_hash_table (info)->rld_symbol = h;
b49e97c9
TS
7533 }
7534
7535 /* If this is a mips16 text symbol, add 1 to the value to make it
7536 odd. This will cause something like .word SYM to come up with
7537 the right value when it is loaded into the PC. */
df58fc94 7538 if (ELF_ST_IS_COMPRESSED (sym->st_other))
b49e97c9
TS
7539 ++*valp;
7540
b34976b6 7541 return TRUE;
b49e97c9
TS
7542}
7543
7544/* This hook function is called before the linker writes out a global
7545 symbol. We mark symbols as small common if appropriate. This is
7546 also where we undo the increment of the value for a mips16 symbol. */
7547
6e0b88f1 7548int
9719ad41
RS
7549_bfd_mips_elf_link_output_symbol_hook
7550 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7551 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
7552 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
b49e97c9
TS
7553{
7554 /* If we see a common symbol, which implies a relocatable link, then
7555 if a symbol was small common in an input file, mark it as small
7556 common in the output file. */
7557 if (sym->st_shndx == SHN_COMMON
7558 && strcmp (input_sec->name, ".scommon") == 0)
7559 sym->st_shndx = SHN_MIPS_SCOMMON;
7560
df58fc94 7561 if (ELF_ST_IS_COMPRESSED (sym->st_other))
79cda7cf 7562 sym->st_value &= ~1;
b49e97c9 7563
6e0b88f1 7564 return 1;
b49e97c9
TS
7565}
7566\f
7567/* Functions for the dynamic linker. */
7568
7569/* Create dynamic sections when linking against a dynamic object. */
7570
b34976b6 7571bfd_boolean
9719ad41 7572_bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
b49e97c9
TS
7573{
7574 struct elf_link_hash_entry *h;
14a793b2 7575 struct bfd_link_hash_entry *bh;
b49e97c9
TS
7576 flagword flags;
7577 register asection *s;
7578 const char * const *namep;
0a44bf69 7579 struct mips_elf_link_hash_table *htab;
b49e97c9 7580
0a44bf69 7581 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
7582 BFD_ASSERT (htab != NULL);
7583
b49e97c9
TS
7584 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7585 | SEC_LINKER_CREATED | SEC_READONLY);
7586
0a44bf69
RS
7587 /* The psABI requires a read-only .dynamic section, but the VxWorks
7588 EABI doesn't. */
7589 if (!htab->is_vxworks)
b49e97c9 7590 {
3d4d4302 7591 s = bfd_get_linker_section (abfd, ".dynamic");
0a44bf69
RS
7592 if (s != NULL)
7593 {
7594 if (! bfd_set_section_flags (abfd, s, flags))
7595 return FALSE;
7596 }
b49e97c9
TS
7597 }
7598
7599 /* We need to create .got section. */
23cc69b6 7600 if (!mips_elf_create_got_section (abfd, info))
f4416af6
AO
7601 return FALSE;
7602
0a44bf69 7603 if (! mips_elf_rel_dyn_section (info, TRUE))
b34976b6 7604 return FALSE;
b49e97c9 7605
b49e97c9 7606 /* Create .stub section. */
3d4d4302
AM
7607 s = bfd_make_section_anyway_with_flags (abfd,
7608 MIPS_ELF_STUB_SECTION_NAME (abfd),
7609 flags | SEC_CODE);
4e41d0d7
RS
7610 if (s == NULL
7611 || ! bfd_set_section_alignment (abfd, s,
7612 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7613 return FALSE;
7614 htab->sstubs = s;
b49e97c9 7615
e6aea42d 7616 if (!mips_elf_hash_table (info)->use_rld_obj_head
a5499fa4 7617 && info->executable
3d4d4302 7618 && bfd_get_linker_section (abfd, ".rld_map") == NULL)
b49e97c9 7619 {
3d4d4302
AM
7620 s = bfd_make_section_anyway_with_flags (abfd, ".rld_map",
7621 flags &~ (flagword) SEC_READONLY);
b49e97c9 7622 if (s == NULL
b49e97c9
TS
7623 || ! bfd_set_section_alignment (abfd, s,
7624 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
b34976b6 7625 return FALSE;
b49e97c9
TS
7626 }
7627
7628 /* On IRIX5, we adjust add some additional symbols and change the
7629 alignments of several sections. There is no ABI documentation
7630 indicating that this is necessary on IRIX6, nor any evidence that
7631 the linker takes such action. */
7632 if (IRIX_COMPAT (abfd) == ict_irix5)
7633 {
7634 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7635 {
14a793b2 7636 bh = NULL;
b49e97c9 7637 if (! (_bfd_generic_link_add_one_symbol
9719ad41
RS
7638 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
7639 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
b34976b6 7640 return FALSE;
14a793b2
AM
7641
7642 h = (struct elf_link_hash_entry *) bh;
f5385ebf
AM
7643 h->non_elf = 0;
7644 h->def_regular = 1;
b49e97c9
TS
7645 h->type = STT_SECTION;
7646
c152c796 7647 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 7648 return FALSE;
b49e97c9
TS
7649 }
7650
7651 /* We need to create a .compact_rel section. */
7652 if (SGI_COMPAT (abfd))
7653 {
7654 if (!mips_elf_create_compact_rel_section (abfd, info))
b34976b6 7655 return FALSE;
b49e97c9
TS
7656 }
7657
44c410de 7658 /* Change alignments of some sections. */
3d4d4302 7659 s = bfd_get_linker_section (abfd, ".hash");
b49e97c9 7660 if (s != NULL)
a253d456
NC
7661 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7662
3d4d4302 7663 s = bfd_get_linker_section (abfd, ".dynsym");
b49e97c9 7664 if (s != NULL)
a253d456
NC
7665 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7666
3d4d4302 7667 s = bfd_get_linker_section (abfd, ".dynstr");
b49e97c9 7668 if (s != NULL)
a253d456
NC
7669 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7670
3d4d4302 7671 /* ??? */
b49e97c9
TS
7672 s = bfd_get_section_by_name (abfd, ".reginfo");
7673 if (s != NULL)
a253d456
NC
7674 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7675
3d4d4302 7676 s = bfd_get_linker_section (abfd, ".dynamic");
b49e97c9 7677 if (s != NULL)
a253d456 7678 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
b49e97c9
TS
7679 }
7680
a5499fa4 7681 if (info->executable)
b49e97c9 7682 {
14a793b2
AM
7683 const char *name;
7684
7685 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7686 bh = NULL;
7687 if (!(_bfd_generic_link_add_one_symbol
9719ad41
RS
7688 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
7689 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
b34976b6 7690 return FALSE;
14a793b2
AM
7691
7692 h = (struct elf_link_hash_entry *) bh;
f5385ebf
AM
7693 h->non_elf = 0;
7694 h->def_regular = 1;
b49e97c9
TS
7695 h->type = STT_SECTION;
7696
c152c796 7697 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 7698 return FALSE;
b49e97c9
TS
7699
7700 if (! mips_elf_hash_table (info)->use_rld_obj_head)
7701 {
7702 /* __rld_map is a four byte word located in the .data section
7703 and is filled in by the rtld to contain a pointer to
7704 the _r_debug structure. Its symbol value will be set in
7705 _bfd_mips_elf_finish_dynamic_symbol. */
3d4d4302 7706 s = bfd_get_linker_section (abfd, ".rld_map");
0abfb97a 7707 BFD_ASSERT (s != NULL);
14a793b2 7708
0abfb97a
L
7709 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
7710 bh = NULL;
7711 if (!(_bfd_generic_link_add_one_symbol
7712 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
7713 get_elf_backend_data (abfd)->collect, &bh)))
7714 return FALSE;
b49e97c9 7715
0abfb97a
L
7716 h = (struct elf_link_hash_entry *) bh;
7717 h->non_elf = 0;
7718 h->def_regular = 1;
7719 h->type = STT_OBJECT;
7720
7721 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7722 return FALSE;
b4082c70 7723 mips_elf_hash_table (info)->rld_symbol = h;
b49e97c9
TS
7724 }
7725 }
7726
861fb55a 7727 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
c164a95d 7728 Also, on VxWorks, create the _PROCEDURE_LINKAGE_TABLE_ symbol. */
861fb55a
DJ
7729 if (!_bfd_elf_create_dynamic_sections (abfd, info))
7730 return FALSE;
7731
7732 /* Cache the sections created above. */
3d4d4302
AM
7733 htab->splt = bfd_get_linker_section (abfd, ".plt");
7734 htab->sdynbss = bfd_get_linker_section (abfd, ".dynbss");
0a44bf69
RS
7735 if (htab->is_vxworks)
7736 {
3d4d4302
AM
7737 htab->srelbss = bfd_get_linker_section (abfd, ".rela.bss");
7738 htab->srelplt = bfd_get_linker_section (abfd, ".rela.plt");
861fb55a
DJ
7739 }
7740 else
3d4d4302 7741 htab->srelplt = bfd_get_linker_section (abfd, ".rel.plt");
861fb55a
DJ
7742 if (!htab->sdynbss
7743 || (htab->is_vxworks && !htab->srelbss && !info->shared)
7744 || !htab->srelplt
7745 || !htab->splt)
7746 abort ();
0a44bf69 7747
1bbce132
MR
7748 /* Do the usual VxWorks handling. */
7749 if (htab->is_vxworks
7750 && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
7751 return FALSE;
0a44bf69 7752
b34976b6 7753 return TRUE;
b49e97c9
TS
7754}
7755\f
c224138d
RS
7756/* Return true if relocation REL against section SEC is a REL rather than
7757 RELA relocation. RELOCS is the first relocation in the section and
7758 ABFD is the bfd that contains SEC. */
7759
7760static bfd_boolean
7761mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
7762 const Elf_Internal_Rela *relocs,
7763 const Elf_Internal_Rela *rel)
7764{
7765 Elf_Internal_Shdr *rel_hdr;
7766 const struct elf_backend_data *bed;
7767
d4730f92
BS
7768 /* To determine which flavor of relocation this is, we depend on the
7769 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
7770 rel_hdr = elf_section_data (sec)->rel.hdr;
7771 if (rel_hdr == NULL)
7772 return FALSE;
c224138d 7773 bed = get_elf_backend_data (abfd);
d4730f92
BS
7774 return ((size_t) (rel - relocs)
7775 < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
c224138d
RS
7776}
7777
7778/* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7779 HOWTO is the relocation's howto and CONTENTS points to the contents
7780 of the section that REL is against. */
7781
7782static bfd_vma
7783mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
7784 reloc_howto_type *howto, bfd_byte *contents)
7785{
7786 bfd_byte *location;
7787 unsigned int r_type;
7788 bfd_vma addend;
7789
7790 r_type = ELF_R_TYPE (abfd, rel->r_info);
7791 location = contents + rel->r_offset;
7792
7793 /* Get the addend, which is stored in the input file. */
df58fc94 7794 _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
c224138d 7795 addend = mips_elf_obtain_contents (howto, rel, abfd, contents);
df58fc94 7796 _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location);
c224138d
RS
7797
7798 return addend & howto->src_mask;
7799}
7800
7801/* REL is a relocation in ABFD that needs a partnering LO16 relocation
7802 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
7803 and update *ADDEND with the final addend. Return true on success
7804 or false if the LO16 could not be found. RELEND is the exclusive
7805 upper bound on the relocations for REL's section. */
7806
7807static bfd_boolean
7808mips_elf_add_lo16_rel_addend (bfd *abfd,
7809 const Elf_Internal_Rela *rel,
7810 const Elf_Internal_Rela *relend,
7811 bfd_byte *contents, bfd_vma *addend)
7812{
7813 unsigned int r_type, lo16_type;
7814 const Elf_Internal_Rela *lo16_relocation;
7815 reloc_howto_type *lo16_howto;
7816 bfd_vma l;
7817
7818 r_type = ELF_R_TYPE (abfd, rel->r_info);
738e5348 7819 if (mips16_reloc_p (r_type))
c224138d 7820 lo16_type = R_MIPS16_LO16;
df58fc94
RS
7821 else if (micromips_reloc_p (r_type))
7822 lo16_type = R_MICROMIPS_LO16;
7361da2c
AB
7823 else if (r_type == R_MIPS_PCHI16)
7824 lo16_type = R_MIPS_PCLO16;
c224138d
RS
7825 else
7826 lo16_type = R_MIPS_LO16;
7827
7828 /* The combined value is the sum of the HI16 addend, left-shifted by
7829 sixteen bits, and the LO16 addend, sign extended. (Usually, the
7830 code does a `lui' of the HI16 value, and then an `addiu' of the
7831 LO16 value.)
7832
7833 Scan ahead to find a matching LO16 relocation.
7834
7835 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
7836 be immediately following. However, for the IRIX6 ABI, the next
7837 relocation may be a composed relocation consisting of several
7838 relocations for the same address. In that case, the R_MIPS_LO16
7839 relocation may occur as one of these. We permit a similar
7840 extension in general, as that is useful for GCC.
7841
7842 In some cases GCC dead code elimination removes the LO16 but keeps
7843 the corresponding HI16. This is strictly speaking a violation of
7844 the ABI but not immediately harmful. */
7845 lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
7846 if (lo16_relocation == NULL)
7847 return FALSE;
7848
7849 /* Obtain the addend kept there. */
7850 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
7851 l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
7852
7853 l <<= lo16_howto->rightshift;
7854 l = _bfd_mips_elf_sign_extend (l, 16);
7855
7856 *addend <<= 16;
7857 *addend += l;
7858 return TRUE;
7859}
7860
7861/* Try to read the contents of section SEC in bfd ABFD. Return true and
7862 store the contents in *CONTENTS on success. Assume that *CONTENTS
7863 already holds the contents if it is nonull on entry. */
7864
7865static bfd_boolean
7866mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
7867{
7868 if (*contents)
7869 return TRUE;
7870
7871 /* Get cached copy if it exists. */
7872 if (elf_section_data (sec)->this_hdr.contents != NULL)
7873 {
7874 *contents = elf_section_data (sec)->this_hdr.contents;
7875 return TRUE;
7876 }
7877
7878 return bfd_malloc_and_get_section (abfd, sec, contents);
7879}
7880
1bbce132
MR
7881/* Make a new PLT record to keep internal data. */
7882
7883static struct plt_entry *
7884mips_elf_make_plt_record (bfd *abfd)
7885{
7886 struct plt_entry *entry;
7887
7888 entry = bfd_zalloc (abfd, sizeof (*entry));
7889 if (entry == NULL)
7890 return NULL;
7891
7892 entry->stub_offset = MINUS_ONE;
7893 entry->mips_offset = MINUS_ONE;
7894 entry->comp_offset = MINUS_ONE;
7895 entry->gotplt_index = MINUS_ONE;
7896 return entry;
7897}
7898
b49e97c9 7899/* Look through the relocs for a section during the first phase, and
1bbce132
MR
7900 allocate space in the global offset table and record the need for
7901 standard MIPS and compressed procedure linkage table entries. */
b49e97c9 7902
b34976b6 7903bfd_boolean
9719ad41
RS
7904_bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7905 asection *sec, const Elf_Internal_Rela *relocs)
b49e97c9
TS
7906{
7907 const char *name;
7908 bfd *dynobj;
7909 Elf_Internal_Shdr *symtab_hdr;
7910 struct elf_link_hash_entry **sym_hashes;
b49e97c9
TS
7911 size_t extsymoff;
7912 const Elf_Internal_Rela *rel;
7913 const Elf_Internal_Rela *rel_end;
b49e97c9 7914 asection *sreloc;
9c5bfbb7 7915 const struct elf_backend_data *bed;
0a44bf69 7916 struct mips_elf_link_hash_table *htab;
c224138d
RS
7917 bfd_byte *contents;
7918 bfd_vma addend;
7919 reloc_howto_type *howto;
b49e97c9 7920
1049f94e 7921 if (info->relocatable)
b34976b6 7922 return TRUE;
b49e97c9 7923
0a44bf69 7924 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
7925 BFD_ASSERT (htab != NULL);
7926
b49e97c9
TS
7927 dynobj = elf_hash_table (info)->dynobj;
7928 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7929 sym_hashes = elf_sym_hashes (abfd);
7930 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7931
738e5348
RS
7932 bed = get_elf_backend_data (abfd);
7933 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7934
b49e97c9
TS
7935 /* Check for the mips16 stub sections. */
7936
7937 name = bfd_get_section_name (abfd, sec);
b9d58d71 7938 if (FN_STUB_P (name))
b49e97c9
TS
7939 {
7940 unsigned long r_symndx;
7941
7942 /* Look at the relocation information to figure out which symbol
7943 this is for. */
7944
cb4437b8 7945 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
738e5348
RS
7946 if (r_symndx == 0)
7947 {
7948 (*_bfd_error_handler)
7949 (_("%B: Warning: cannot determine the target function for"
7950 " stub section `%s'"),
7951 abfd, name);
7952 bfd_set_error (bfd_error_bad_value);
7953 return FALSE;
7954 }
b49e97c9
TS
7955
7956 if (r_symndx < extsymoff
7957 || sym_hashes[r_symndx - extsymoff] == NULL)
7958 {
7959 asection *o;
7960
7961 /* This stub is for a local symbol. This stub will only be
7962 needed if there is some relocation in this BFD, other
7963 than a 16 bit function call, which refers to this symbol. */
7964 for (o = abfd->sections; o != NULL; o = o->next)
7965 {
7966 Elf_Internal_Rela *sec_relocs;
7967 const Elf_Internal_Rela *r, *rend;
7968
7969 /* We can ignore stub sections when looking for relocs. */
7970 if ((o->flags & SEC_RELOC) == 0
7971 || o->reloc_count == 0
738e5348 7972 || section_allows_mips16_refs_p (o))
b49e97c9
TS
7973 continue;
7974
45d6a902 7975 sec_relocs
9719ad41 7976 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
45d6a902 7977 info->keep_memory);
b49e97c9 7978 if (sec_relocs == NULL)
b34976b6 7979 return FALSE;
b49e97c9
TS
7980
7981 rend = sec_relocs + o->reloc_count;
7982 for (r = sec_relocs; r < rend; r++)
7983 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
738e5348 7984 && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
b49e97c9
TS
7985 break;
7986
6cdc0ccc 7987 if (elf_section_data (o)->relocs != sec_relocs)
b49e97c9
TS
7988 free (sec_relocs);
7989
7990 if (r < rend)
7991 break;
7992 }
7993
7994 if (o == NULL)
7995 {
7996 /* There is no non-call reloc for this stub, so we do
7997 not need it. Since this function is called before
7998 the linker maps input sections to output sections, we
7999 can easily discard it by setting the SEC_EXCLUDE
8000 flag. */
8001 sec->flags |= SEC_EXCLUDE;
b34976b6 8002 return TRUE;
b49e97c9
TS
8003 }
8004
8005 /* Record this stub in an array of local symbol stubs for
8006 this BFD. */
698600e4 8007 if (mips_elf_tdata (abfd)->local_stubs == NULL)
b49e97c9
TS
8008 {
8009 unsigned long symcount;
8010 asection **n;
8011 bfd_size_type amt;
8012
8013 if (elf_bad_symtab (abfd))
8014 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
8015 else
8016 symcount = symtab_hdr->sh_info;
8017 amt = symcount * sizeof (asection *);
9719ad41 8018 n = bfd_zalloc (abfd, amt);
b49e97c9 8019 if (n == NULL)
b34976b6 8020 return FALSE;
698600e4 8021 mips_elf_tdata (abfd)->local_stubs = n;
b49e97c9
TS
8022 }
8023
b9d58d71 8024 sec->flags |= SEC_KEEP;
698600e4 8025 mips_elf_tdata (abfd)->local_stubs[r_symndx] = sec;
b49e97c9
TS
8026
8027 /* We don't need to set mips16_stubs_seen in this case.
8028 That flag is used to see whether we need to look through
8029 the global symbol table for stubs. We don't need to set
8030 it here, because we just have a local stub. */
8031 }
8032 else
8033 {
8034 struct mips_elf_link_hash_entry *h;
8035
8036 h = ((struct mips_elf_link_hash_entry *)
8037 sym_hashes[r_symndx - extsymoff]);
8038
973a3492
L
8039 while (h->root.root.type == bfd_link_hash_indirect
8040 || h->root.root.type == bfd_link_hash_warning)
8041 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8042
b49e97c9
TS
8043 /* H is the symbol this stub is for. */
8044
b9d58d71
TS
8045 /* If we already have an appropriate stub for this function, we
8046 don't need another one, so we can discard this one. Since
8047 this function is called before the linker maps input sections
8048 to output sections, we can easily discard it by setting the
8049 SEC_EXCLUDE flag. */
8050 if (h->fn_stub != NULL)
8051 {
8052 sec->flags |= SEC_EXCLUDE;
8053 return TRUE;
8054 }
8055
8056 sec->flags |= SEC_KEEP;
b49e97c9 8057 h->fn_stub = sec;
b34976b6 8058 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
b49e97c9
TS
8059 }
8060 }
b9d58d71 8061 else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
b49e97c9
TS
8062 {
8063 unsigned long r_symndx;
8064 struct mips_elf_link_hash_entry *h;
8065 asection **loc;
8066
8067 /* Look at the relocation information to figure out which symbol
8068 this is for. */
8069
cb4437b8 8070 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
738e5348
RS
8071 if (r_symndx == 0)
8072 {
8073 (*_bfd_error_handler)
8074 (_("%B: Warning: cannot determine the target function for"
8075 " stub section `%s'"),
8076 abfd, name);
8077 bfd_set_error (bfd_error_bad_value);
8078 return FALSE;
8079 }
b49e97c9
TS
8080
8081 if (r_symndx < extsymoff
8082 || sym_hashes[r_symndx - extsymoff] == NULL)
8083 {
b9d58d71 8084 asection *o;
b49e97c9 8085
b9d58d71
TS
8086 /* This stub is for a local symbol. This stub will only be
8087 needed if there is some relocation (R_MIPS16_26) in this BFD
8088 that refers to this symbol. */
8089 for (o = abfd->sections; o != NULL; o = o->next)
8090 {
8091 Elf_Internal_Rela *sec_relocs;
8092 const Elf_Internal_Rela *r, *rend;
8093
8094 /* We can ignore stub sections when looking for relocs. */
8095 if ((o->flags & SEC_RELOC) == 0
8096 || o->reloc_count == 0
738e5348 8097 || section_allows_mips16_refs_p (o))
b9d58d71
TS
8098 continue;
8099
8100 sec_relocs
8101 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
8102 info->keep_memory);
8103 if (sec_relocs == NULL)
8104 return FALSE;
8105
8106 rend = sec_relocs + o->reloc_count;
8107 for (r = sec_relocs; r < rend; r++)
8108 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
8109 && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
8110 break;
8111
8112 if (elf_section_data (o)->relocs != sec_relocs)
8113 free (sec_relocs);
8114
8115 if (r < rend)
8116 break;
8117 }
8118
8119 if (o == NULL)
8120 {
8121 /* There is no non-call reloc for this stub, so we do
8122 not need it. Since this function is called before
8123 the linker maps input sections to output sections, we
8124 can easily discard it by setting the SEC_EXCLUDE
8125 flag. */
8126 sec->flags |= SEC_EXCLUDE;
8127 return TRUE;
8128 }
8129
8130 /* Record this stub in an array of local symbol call_stubs for
8131 this BFD. */
698600e4 8132 if (mips_elf_tdata (abfd)->local_call_stubs == NULL)
b9d58d71
TS
8133 {
8134 unsigned long symcount;
8135 asection **n;
8136 bfd_size_type amt;
8137
8138 if (elf_bad_symtab (abfd))
8139 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
8140 else
8141 symcount = symtab_hdr->sh_info;
8142 amt = symcount * sizeof (asection *);
8143 n = bfd_zalloc (abfd, amt);
8144 if (n == NULL)
8145 return FALSE;
698600e4 8146 mips_elf_tdata (abfd)->local_call_stubs = n;
b9d58d71 8147 }
b49e97c9 8148
b9d58d71 8149 sec->flags |= SEC_KEEP;
698600e4 8150 mips_elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
b49e97c9 8151
b9d58d71
TS
8152 /* We don't need to set mips16_stubs_seen in this case.
8153 That flag is used to see whether we need to look through
8154 the global symbol table for stubs. We don't need to set
8155 it here, because we just have a local stub. */
8156 }
b49e97c9 8157 else
b49e97c9 8158 {
b9d58d71
TS
8159 h = ((struct mips_elf_link_hash_entry *)
8160 sym_hashes[r_symndx - extsymoff]);
68ffbac6 8161
b9d58d71 8162 /* H is the symbol this stub is for. */
68ffbac6 8163
b9d58d71
TS
8164 if (CALL_FP_STUB_P (name))
8165 loc = &h->call_fp_stub;
8166 else
8167 loc = &h->call_stub;
68ffbac6 8168
b9d58d71
TS
8169 /* If we already have an appropriate stub for this function, we
8170 don't need another one, so we can discard this one. Since
8171 this function is called before the linker maps input sections
8172 to output sections, we can easily discard it by setting the
8173 SEC_EXCLUDE flag. */
8174 if (*loc != NULL)
8175 {
8176 sec->flags |= SEC_EXCLUDE;
8177 return TRUE;
8178 }
b49e97c9 8179
b9d58d71
TS
8180 sec->flags |= SEC_KEEP;
8181 *loc = sec;
8182 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
8183 }
b49e97c9
TS
8184 }
8185
b49e97c9 8186 sreloc = NULL;
c224138d 8187 contents = NULL;
b49e97c9
TS
8188 for (rel = relocs; rel < rel_end; ++rel)
8189 {
8190 unsigned long r_symndx;
8191 unsigned int r_type;
8192 struct elf_link_hash_entry *h;
861fb55a 8193 bfd_boolean can_make_dynamic_p;
c5d6fa44
RS
8194 bfd_boolean call_reloc_p;
8195 bfd_boolean constrain_symbol_p;
b49e97c9
TS
8196
8197 r_symndx = ELF_R_SYM (abfd, rel->r_info);
8198 r_type = ELF_R_TYPE (abfd, rel->r_info);
8199
8200 if (r_symndx < extsymoff)
8201 h = NULL;
8202 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
8203 {
8204 (*_bfd_error_handler)
d003868e
AM
8205 (_("%B: Malformed reloc detected for section %s"),
8206 abfd, name);
b49e97c9 8207 bfd_set_error (bfd_error_bad_value);
b34976b6 8208 return FALSE;
b49e97c9
TS
8209 }
8210 else
8211 {
8212 h = sym_hashes[r_symndx - extsymoff];
81fbe831
AM
8213 if (h != NULL)
8214 {
8215 while (h->root.type == bfd_link_hash_indirect
8216 || h->root.type == bfd_link_hash_warning)
8217 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8218
8219 /* PR15323, ref flags aren't set for references in the
8220 same object. */
8221 h->root.non_ir_ref = 1;
8222 }
861fb55a 8223 }
b49e97c9 8224
861fb55a
DJ
8225 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
8226 relocation into a dynamic one. */
8227 can_make_dynamic_p = FALSE;
c5d6fa44
RS
8228
8229 /* Set CALL_RELOC_P to true if the relocation is for a call,
8230 and if pointer equality therefore doesn't matter. */
8231 call_reloc_p = FALSE;
8232
8233 /* Set CONSTRAIN_SYMBOL_P if we need to take the relocation
8234 into account when deciding how to define the symbol.
8235 Relocations in nonallocatable sections such as .pdr and
8236 .debug* should have no effect. */
8237 constrain_symbol_p = ((sec->flags & SEC_ALLOC) != 0);
8238
861fb55a
DJ
8239 switch (r_type)
8240 {
861fb55a
DJ
8241 case R_MIPS_CALL16:
8242 case R_MIPS_CALL_HI16:
8243 case R_MIPS_CALL_LO16:
c5d6fa44
RS
8244 case R_MIPS16_CALL16:
8245 case R_MICROMIPS_CALL16:
8246 case R_MICROMIPS_CALL_HI16:
8247 case R_MICROMIPS_CALL_LO16:
8248 call_reloc_p = TRUE;
8249 /* Fall through. */
8250
8251 case R_MIPS_GOT16:
861fb55a
DJ
8252 case R_MIPS_GOT_HI16:
8253 case R_MIPS_GOT_LO16:
8254 case R_MIPS_GOT_PAGE:
8255 case R_MIPS_GOT_OFST:
8256 case R_MIPS_GOT_DISP:
8257 case R_MIPS_TLS_GOTTPREL:
8258 case R_MIPS_TLS_GD:
8259 case R_MIPS_TLS_LDM:
d0f13682 8260 case R_MIPS16_GOT16:
d0f13682
CLT
8261 case R_MIPS16_TLS_GOTTPREL:
8262 case R_MIPS16_TLS_GD:
8263 case R_MIPS16_TLS_LDM:
df58fc94 8264 case R_MICROMIPS_GOT16:
df58fc94
RS
8265 case R_MICROMIPS_GOT_HI16:
8266 case R_MICROMIPS_GOT_LO16:
8267 case R_MICROMIPS_GOT_PAGE:
8268 case R_MICROMIPS_GOT_OFST:
8269 case R_MICROMIPS_GOT_DISP:
8270 case R_MICROMIPS_TLS_GOTTPREL:
8271 case R_MICROMIPS_TLS_GD:
8272 case R_MICROMIPS_TLS_LDM:
861fb55a
DJ
8273 if (dynobj == NULL)
8274 elf_hash_table (info)->dynobj = dynobj = abfd;
8275 if (!mips_elf_create_got_section (dynobj, info))
8276 return FALSE;
8277 if (htab->is_vxworks && !info->shared)
b49e97c9 8278 {
861fb55a
DJ
8279 (*_bfd_error_handler)
8280 (_("%B: GOT reloc at 0x%lx not expected in executables"),
8281 abfd, (unsigned long) rel->r_offset);
8282 bfd_set_error (bfd_error_bad_value);
8283 return FALSE;
b49e97c9 8284 }
c5d6fa44 8285 can_make_dynamic_p = TRUE;
861fb55a 8286 break;
b49e97c9 8287
c5d6fa44 8288 case R_MIPS_NONE:
99da6b5f 8289 case R_MIPS_JALR:
df58fc94 8290 case R_MICROMIPS_JALR:
c5d6fa44
RS
8291 /* These relocations have empty fields and are purely there to
8292 provide link information. The symbol value doesn't matter. */
8293 constrain_symbol_p = FALSE;
8294 break;
8295
8296 case R_MIPS_GPREL16:
8297 case R_MIPS_GPREL32:
8298 case R_MIPS16_GPREL:
8299 case R_MICROMIPS_GPREL16:
8300 /* GP-relative relocations always resolve to a definition in a
8301 regular input file, ignoring the one-definition rule. This is
8302 important for the GP setup sequence in NewABI code, which
8303 always resolves to a local function even if other relocations
8304 against the symbol wouldn't. */
8305 constrain_symbol_p = FALSE;
99da6b5f
AN
8306 break;
8307
861fb55a
DJ
8308 case R_MIPS_32:
8309 case R_MIPS_REL32:
8310 case R_MIPS_64:
8311 /* In VxWorks executables, references to external symbols
8312 must be handled using copy relocs or PLT entries; it is not
8313 possible to convert this relocation into a dynamic one.
8314
8315 For executables that use PLTs and copy-relocs, we have a
8316 choice between converting the relocation into a dynamic
8317 one or using copy relocations or PLT entries. It is
8318 usually better to do the former, unless the relocation is
8319 against a read-only section. */
8320 if ((info->shared
8321 || (h != NULL
8322 && !htab->is_vxworks
8323 && strcmp (h->root.root.string, "__gnu_local_gp") != 0
8324 && !(!info->nocopyreloc
8325 && !PIC_OBJECT_P (abfd)
8326 && MIPS_ELF_READONLY_SECTION (sec))))
8327 && (sec->flags & SEC_ALLOC) != 0)
b49e97c9 8328 {
861fb55a 8329 can_make_dynamic_p = TRUE;
b49e97c9
TS
8330 if (dynobj == NULL)
8331 elf_hash_table (info)->dynobj = dynobj = abfd;
861fb55a 8332 }
c5d6fa44 8333 break;
b49e97c9 8334
861fb55a
DJ
8335 case R_MIPS_26:
8336 case R_MIPS_PC16:
7361da2c
AB
8337 case R_MIPS_PC21_S2:
8338 case R_MIPS_PC26_S2:
861fb55a 8339 case R_MIPS16_26:
df58fc94
RS
8340 case R_MICROMIPS_26_S1:
8341 case R_MICROMIPS_PC7_S1:
8342 case R_MICROMIPS_PC10_S1:
8343 case R_MICROMIPS_PC16_S1:
8344 case R_MICROMIPS_PC23_S2:
c5d6fa44 8345 call_reloc_p = TRUE;
861fb55a 8346 break;
b49e97c9
TS
8347 }
8348
0a44bf69
RS
8349 if (h)
8350 {
c5d6fa44
RS
8351 if (constrain_symbol_p)
8352 {
8353 if (!can_make_dynamic_p)
8354 ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = 1;
8355
8356 if (!call_reloc_p)
8357 h->pointer_equality_needed = 1;
8358
8359 /* We must not create a stub for a symbol that has
8360 relocations related to taking the function's address.
8361 This doesn't apply to VxWorks, where CALL relocs refer
8362 to a .got.plt entry instead of a normal .got entry. */
8363 if (!htab->is_vxworks && (!can_make_dynamic_p || !call_reloc_p))
8364 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
8365 }
8366
0a44bf69
RS
8367 /* Relocations against the special VxWorks __GOTT_BASE__ and
8368 __GOTT_INDEX__ symbols must be left to the loader. Allocate
8369 room for them in .rela.dyn. */
8370 if (is_gott_symbol (info, h))
8371 {
8372 if (sreloc == NULL)
8373 {
8374 sreloc = mips_elf_rel_dyn_section (info, TRUE);
8375 if (sreloc == NULL)
8376 return FALSE;
8377 }
8378 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
9e3313ae
RS
8379 if (MIPS_ELF_READONLY_SECTION (sec))
8380 /* We tell the dynamic linker that there are
8381 relocations against the text segment. */
8382 info->flags |= DF_TEXTREL;
0a44bf69
RS
8383 }
8384 }
df58fc94
RS
8385 else if (call_lo16_reloc_p (r_type)
8386 || got_lo16_reloc_p (r_type)
8387 || got_disp_reloc_p (r_type)
738e5348 8388 || (got16_reloc_p (r_type) && htab->is_vxworks))
b49e97c9
TS
8389 {
8390 /* We may need a local GOT entry for this relocation. We
8391 don't count R_MIPS_GOT_PAGE because we can estimate the
8392 maximum number of pages needed by looking at the size of
738e5348
RS
8393 the segment. Similar comments apply to R_MIPS*_GOT16 and
8394 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
0a44bf69 8395 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
b49e97c9 8396 R_MIPS_CALL_HI16 because these are always followed by an
b15e6682 8397 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
a8028dd0 8398 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
e641e783 8399 rel->r_addend, info, r_type))
f4416af6 8400 return FALSE;
b49e97c9
TS
8401 }
8402
8f0c309a
CLT
8403 if (h != NULL
8404 && mips_elf_relocation_needs_la25_stub (abfd, r_type,
8405 ELF_ST_IS_MIPS16 (h->other)))
861fb55a
DJ
8406 ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
8407
b49e97c9
TS
8408 switch (r_type)
8409 {
8410 case R_MIPS_CALL16:
738e5348 8411 case R_MIPS16_CALL16:
df58fc94 8412 case R_MICROMIPS_CALL16:
b49e97c9
TS
8413 if (h == NULL)
8414 {
8415 (*_bfd_error_handler)
d003868e
AM
8416 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
8417 abfd, (unsigned long) rel->r_offset);
b49e97c9 8418 bfd_set_error (bfd_error_bad_value);
b34976b6 8419 return FALSE;
b49e97c9
TS
8420 }
8421 /* Fall through. */
8422
8423 case R_MIPS_CALL_HI16:
8424 case R_MIPS_CALL_LO16:
df58fc94
RS
8425 case R_MICROMIPS_CALL_HI16:
8426 case R_MICROMIPS_CALL_LO16:
b49e97c9
TS
8427 if (h != NULL)
8428 {
6ccf4795
RS
8429 /* Make sure there is room in the regular GOT to hold the
8430 function's address. We may eliminate it in favour of
8431 a .got.plt entry later; see mips_elf_count_got_symbols. */
e641e783
RS
8432 if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE,
8433 r_type))
b34976b6 8434 return FALSE;
b49e97c9
TS
8435
8436 /* We need a stub, not a plt entry for the undefined
8437 function. But we record it as if it needs plt. See
c152c796 8438 _bfd_elf_adjust_dynamic_symbol. */
f5385ebf 8439 h->needs_plt = 1;
b49e97c9
TS
8440 h->type = STT_FUNC;
8441 }
8442 break;
8443
0fdc1bf1 8444 case R_MIPS_GOT_PAGE:
df58fc94 8445 case R_MICROMIPS_GOT_PAGE:
738e5348 8446 case R_MIPS16_GOT16:
b49e97c9
TS
8447 case R_MIPS_GOT16:
8448 case R_MIPS_GOT_HI16:
8449 case R_MIPS_GOT_LO16:
df58fc94
RS
8450 case R_MICROMIPS_GOT16:
8451 case R_MICROMIPS_GOT_HI16:
8452 case R_MICROMIPS_GOT_LO16:
8453 if (!h || got_page_reloc_p (r_type))
c224138d 8454 {
3a3b6725
DJ
8455 /* This relocation needs (or may need, if h != NULL) a
8456 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
8457 know for sure until we know whether the symbol is
8458 preemptible. */
c224138d
RS
8459 if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
8460 {
8461 if (!mips_elf_get_section_contents (abfd, sec, &contents))
8462 return FALSE;
8463 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8464 addend = mips_elf_read_rel_addend (abfd, rel,
8465 howto, contents);
9684f078 8466 if (got16_reloc_p (r_type))
c224138d
RS
8467 mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
8468 contents, &addend);
8469 else
8470 addend <<= howto->rightshift;
8471 }
8472 else
8473 addend = rel->r_addend;
13db6b44
RS
8474 if (!mips_elf_record_got_page_ref (info, abfd, r_symndx,
8475 h, addend))
c224138d 8476 return FALSE;
13db6b44
RS
8477
8478 if (h)
8479 {
8480 struct mips_elf_link_hash_entry *hmips =
8481 (struct mips_elf_link_hash_entry *) h;
8482
8483 /* This symbol is definitely not overridable. */
8484 if (hmips->root.def_regular
8485 && ! (info->shared && ! info->symbolic
8486 && ! hmips->root.forced_local))
8487 h = NULL;
8488 }
c224138d 8489 }
13db6b44
RS
8490 /* If this is a global, overridable symbol, GOT_PAGE will
8491 decay to GOT_DISP, so we'll need a GOT entry for it. */
c224138d
RS
8492 /* Fall through. */
8493
b49e97c9 8494 case R_MIPS_GOT_DISP:
df58fc94 8495 case R_MICROMIPS_GOT_DISP:
6ccf4795 8496 if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
e641e783 8497 FALSE, r_type))
b34976b6 8498 return FALSE;
b49e97c9
TS
8499 break;
8500
0f20cc35 8501 case R_MIPS_TLS_GOTTPREL:
d0f13682 8502 case R_MIPS16_TLS_GOTTPREL:
df58fc94 8503 case R_MICROMIPS_TLS_GOTTPREL:
0f20cc35
DJ
8504 if (info->shared)
8505 info->flags |= DF_STATIC_TLS;
8506 /* Fall through */
8507
8508 case R_MIPS_TLS_LDM:
d0f13682 8509 case R_MIPS16_TLS_LDM:
df58fc94
RS
8510 case R_MICROMIPS_TLS_LDM:
8511 if (tls_ldm_reloc_p (r_type))
0f20cc35 8512 {
cf35638d 8513 r_symndx = STN_UNDEF;
0f20cc35
DJ
8514 h = NULL;
8515 }
8516 /* Fall through */
8517
8518 case R_MIPS_TLS_GD:
d0f13682 8519 case R_MIPS16_TLS_GD:
df58fc94 8520 case R_MICROMIPS_TLS_GD:
0f20cc35
DJ
8521 /* This symbol requires a global offset table entry, or two
8522 for TLS GD relocations. */
e641e783
RS
8523 if (h != NULL)
8524 {
8525 if (!mips_elf_record_global_got_symbol (h, abfd, info,
8526 FALSE, r_type))
8527 return FALSE;
8528 }
8529 else
8530 {
8531 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8532 rel->r_addend,
8533 info, r_type))
8534 return FALSE;
8535 }
0f20cc35
DJ
8536 break;
8537
b49e97c9
TS
8538 case R_MIPS_32:
8539 case R_MIPS_REL32:
8540 case R_MIPS_64:
0a44bf69
RS
8541 /* In VxWorks executables, references to external symbols
8542 are handled using copy relocs or PLT stubs, so there's
8543 no need to add a .rela.dyn entry for this relocation. */
861fb55a 8544 if (can_make_dynamic_p)
b49e97c9
TS
8545 {
8546 if (sreloc == NULL)
8547 {
0a44bf69 8548 sreloc = mips_elf_rel_dyn_section (info, TRUE);
b49e97c9 8549 if (sreloc == NULL)
f4416af6 8550 return FALSE;
b49e97c9 8551 }
9a59ad6b 8552 if (info->shared && h == NULL)
82f0cfbd
EC
8553 {
8554 /* When creating a shared object, we must copy these
8555 reloc types into the output file as R_MIPS_REL32
0a44bf69
RS
8556 relocs. Make room for this reloc in .rel(a).dyn. */
8557 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
943284cc 8558 if (MIPS_ELF_READONLY_SECTION (sec))
82f0cfbd
EC
8559 /* We tell the dynamic linker that there are
8560 relocations against the text segment. */
8561 info->flags |= DF_TEXTREL;
8562 }
b49e97c9
TS
8563 else
8564 {
8565 struct mips_elf_link_hash_entry *hmips;
82f0cfbd 8566
9a59ad6b
DJ
8567 /* For a shared object, we must copy this relocation
8568 unless the symbol turns out to be undefined and
8569 weak with non-default visibility, in which case
8570 it will be left as zero.
8571
8572 We could elide R_MIPS_REL32 for locally binding symbols
8573 in shared libraries, but do not yet do so.
8574
8575 For an executable, we only need to copy this
8576 reloc if the symbol is defined in a dynamic
8577 object. */
b49e97c9
TS
8578 hmips = (struct mips_elf_link_hash_entry *) h;
8579 ++hmips->possibly_dynamic_relocs;
943284cc 8580 if (MIPS_ELF_READONLY_SECTION (sec))
82f0cfbd
EC
8581 /* We need it to tell the dynamic linker if there
8582 are relocations against the text segment. */
8583 hmips->readonly_reloc = TRUE;
b49e97c9 8584 }
b49e97c9
TS
8585 }
8586
8587 if (SGI_COMPAT (abfd))
8588 mips_elf_hash_table (info)->compact_rel_size +=
8589 sizeof (Elf32_External_crinfo);
8590 break;
8591
8592 case R_MIPS_26:
8593 case R_MIPS_GPREL16:
8594 case R_MIPS_LITERAL:
8595 case R_MIPS_GPREL32:
df58fc94
RS
8596 case R_MICROMIPS_26_S1:
8597 case R_MICROMIPS_GPREL16:
8598 case R_MICROMIPS_LITERAL:
8599 case R_MICROMIPS_GPREL7_S2:
b49e97c9
TS
8600 if (SGI_COMPAT (abfd))
8601 mips_elf_hash_table (info)->compact_rel_size +=
8602 sizeof (Elf32_External_crinfo);
8603 break;
8604
8605 /* This relocation describes the C++ object vtable hierarchy.
8606 Reconstruct it for later use during GC. */
8607 case R_MIPS_GNU_VTINHERIT:
c152c796 8608 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 8609 return FALSE;
b49e97c9
TS
8610 break;
8611
8612 /* This relocation describes which C++ vtable entries are actually
8613 used. Record for later use during GC. */
8614 case R_MIPS_GNU_VTENTRY:
d17e0c6e
JB
8615 BFD_ASSERT (h != NULL);
8616 if (h != NULL
8617 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
b34976b6 8618 return FALSE;
b49e97c9
TS
8619 break;
8620
8621 default:
8622 break;
8623 }
8624
1bbce132
MR
8625 /* Record the need for a PLT entry. At this point we don't know
8626 yet if we are going to create a PLT in the first place, but
8627 we only record whether the relocation requires a standard MIPS
8628 or a compressed code entry anyway. If we don't make a PLT after
8629 all, then we'll just ignore these arrangements. Likewise if
8630 a PLT entry is not created because the symbol is satisfied
8631 locally. */
8632 if (h != NULL
8633 && jal_reloc_p (r_type)
8634 && !SYMBOL_CALLS_LOCAL (info, h))
8635 {
8636 if (h->plt.plist == NULL)
8637 h->plt.plist = mips_elf_make_plt_record (abfd);
8638 if (h->plt.plist == NULL)
8639 return FALSE;
8640
8641 if (r_type == R_MIPS_26)
8642 h->plt.plist->need_mips = TRUE;
8643 else
8644 h->plt.plist->need_comp = TRUE;
8645 }
8646
738e5348
RS
8647 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
8648 if there is one. We only need to handle global symbols here;
8649 we decide whether to keep or delete stubs for local symbols
8650 when processing the stub's relocations. */
b49e97c9 8651 if (h != NULL
738e5348
RS
8652 && !mips16_call_reloc_p (r_type)
8653 && !section_allows_mips16_refs_p (sec))
b49e97c9
TS
8654 {
8655 struct mips_elf_link_hash_entry *mh;
8656
8657 mh = (struct mips_elf_link_hash_entry *) h;
b34976b6 8658 mh->need_fn_stub = TRUE;
b49e97c9 8659 }
861fb55a
DJ
8660
8661 /* Refuse some position-dependent relocations when creating a
8662 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
8663 not PIC, but we can create dynamic relocations and the result
8664 will be fine. Also do not refuse R_MIPS_LO16, which can be
8665 combined with R_MIPS_GOT16. */
8666 if (info->shared)
8667 {
8668 switch (r_type)
8669 {
8670 case R_MIPS16_HI16:
8671 case R_MIPS_HI16:
8672 case R_MIPS_HIGHER:
8673 case R_MIPS_HIGHEST:
df58fc94
RS
8674 case R_MICROMIPS_HI16:
8675 case R_MICROMIPS_HIGHER:
8676 case R_MICROMIPS_HIGHEST:
861fb55a
DJ
8677 /* Don't refuse a high part relocation if it's against
8678 no symbol (e.g. part of a compound relocation). */
cf35638d 8679 if (r_symndx == STN_UNDEF)
861fb55a
DJ
8680 break;
8681
8682 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
8683 and has a special meaning. */
8684 if (!NEWABI_P (abfd) && h != NULL
8685 && strcmp (h->root.root.string, "_gp_disp") == 0)
8686 break;
8687
0fc1eb3c
RS
8688 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */
8689 if (is_gott_symbol (info, h))
8690 break;
8691
861fb55a
DJ
8692 /* FALLTHROUGH */
8693
8694 case R_MIPS16_26:
8695 case R_MIPS_26:
df58fc94 8696 case R_MICROMIPS_26_S1:
861fb55a
DJ
8697 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8698 (*_bfd_error_handler)
8699 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
8700 abfd, howto->name,
8701 (h) ? h->root.root.string : "a local symbol");
8702 bfd_set_error (bfd_error_bad_value);
8703 return FALSE;
8704 default:
8705 break;
8706 }
8707 }
b49e97c9
TS
8708 }
8709
b34976b6 8710 return TRUE;
b49e97c9
TS
8711}
8712\f
d0647110 8713bfd_boolean
9719ad41
RS
8714_bfd_mips_relax_section (bfd *abfd, asection *sec,
8715 struct bfd_link_info *link_info,
8716 bfd_boolean *again)
d0647110
AO
8717{
8718 Elf_Internal_Rela *internal_relocs;
8719 Elf_Internal_Rela *irel, *irelend;
8720 Elf_Internal_Shdr *symtab_hdr;
8721 bfd_byte *contents = NULL;
d0647110
AO
8722 size_t extsymoff;
8723 bfd_boolean changed_contents = FALSE;
8724 bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
8725 Elf_Internal_Sym *isymbuf = NULL;
8726
8727 /* We are not currently changing any sizes, so only one pass. */
8728 *again = FALSE;
8729
1049f94e 8730 if (link_info->relocatable)
d0647110
AO
8731 return TRUE;
8732
9719ad41 8733 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
45d6a902 8734 link_info->keep_memory);
d0647110
AO
8735 if (internal_relocs == NULL)
8736 return TRUE;
8737
8738 irelend = internal_relocs + sec->reloc_count
8739 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
8740 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8741 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8742
8743 for (irel = internal_relocs; irel < irelend; irel++)
8744 {
8745 bfd_vma symval;
8746 bfd_signed_vma sym_offset;
8747 unsigned int r_type;
8748 unsigned long r_symndx;
8749 asection *sym_sec;
8750 unsigned long instruction;
8751
8752 /* Turn jalr into bgezal, and jr into beq, if they're marked
8753 with a JALR relocation, that indicate where they jump to.
8754 This saves some pipeline bubbles. */
8755 r_type = ELF_R_TYPE (abfd, irel->r_info);
8756 if (r_type != R_MIPS_JALR)
8757 continue;
8758
8759 r_symndx = ELF_R_SYM (abfd, irel->r_info);
8760 /* Compute the address of the jump target. */
8761 if (r_symndx >= extsymoff)
8762 {
8763 struct mips_elf_link_hash_entry *h
8764 = ((struct mips_elf_link_hash_entry *)
8765 elf_sym_hashes (abfd) [r_symndx - extsymoff]);
8766
8767 while (h->root.root.type == bfd_link_hash_indirect
8768 || h->root.root.type == bfd_link_hash_warning)
8769 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
143d77c5 8770
d0647110
AO
8771 /* If a symbol is undefined, or if it may be overridden,
8772 skip it. */
8773 if (! ((h->root.root.type == bfd_link_hash_defined
8774 || h->root.root.type == bfd_link_hash_defweak)
8775 && h->root.root.u.def.section)
8776 || (link_info->shared && ! link_info->symbolic
f5385ebf 8777 && !h->root.forced_local))
d0647110
AO
8778 continue;
8779
8780 sym_sec = h->root.root.u.def.section;
8781 if (sym_sec->output_section)
8782 symval = (h->root.root.u.def.value
8783 + sym_sec->output_section->vma
8784 + sym_sec->output_offset);
8785 else
8786 symval = h->root.root.u.def.value;
8787 }
8788 else
8789 {
8790 Elf_Internal_Sym *isym;
8791
8792 /* Read this BFD's symbols if we haven't done so already. */
8793 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
8794 {
8795 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
8796 if (isymbuf == NULL)
8797 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8798 symtab_hdr->sh_info, 0,
8799 NULL, NULL, NULL);
8800 if (isymbuf == NULL)
8801 goto relax_return;
8802 }
8803
8804 isym = isymbuf + r_symndx;
8805 if (isym->st_shndx == SHN_UNDEF)
8806 continue;
8807 else if (isym->st_shndx == SHN_ABS)
8808 sym_sec = bfd_abs_section_ptr;
8809 else if (isym->st_shndx == SHN_COMMON)
8810 sym_sec = bfd_com_section_ptr;
8811 else
8812 sym_sec
8813 = bfd_section_from_elf_index (abfd, isym->st_shndx);
8814 symval = isym->st_value
8815 + sym_sec->output_section->vma
8816 + sym_sec->output_offset;
8817 }
8818
8819 /* Compute branch offset, from delay slot of the jump to the
8820 branch target. */
8821 sym_offset = (symval + irel->r_addend)
8822 - (sec_start + irel->r_offset + 4);
8823
8824 /* Branch offset must be properly aligned. */
8825 if ((sym_offset & 3) != 0)
8826 continue;
8827
8828 sym_offset >>= 2;
8829
8830 /* Check that it's in range. */
8831 if (sym_offset < -0x8000 || sym_offset >= 0x8000)
8832 continue;
143d77c5 8833
d0647110 8834 /* Get the section contents if we haven't done so already. */
c224138d
RS
8835 if (!mips_elf_get_section_contents (abfd, sec, &contents))
8836 goto relax_return;
d0647110
AO
8837
8838 instruction = bfd_get_32 (abfd, contents + irel->r_offset);
8839
8840 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
8841 if ((instruction & 0xfc1fffff) == 0x0000f809)
8842 instruction = 0x04110000;
8843 /* If it was jr <reg>, turn it into b <target>. */
8844 else if ((instruction & 0xfc1fffff) == 0x00000008)
8845 instruction = 0x10000000;
8846 else
8847 continue;
8848
8849 instruction |= (sym_offset & 0xffff);
8850 bfd_put_32 (abfd, instruction, contents + irel->r_offset);
8851 changed_contents = TRUE;
8852 }
8853
8854 if (contents != NULL
8855 && elf_section_data (sec)->this_hdr.contents != contents)
8856 {
8857 if (!changed_contents && !link_info->keep_memory)
8858 free (contents);
8859 else
8860 {
8861 /* Cache the section contents for elf_link_input_bfd. */
8862 elf_section_data (sec)->this_hdr.contents = contents;
8863 }
8864 }
8865 return TRUE;
8866
143d77c5 8867 relax_return:
eea6121a
AM
8868 if (contents != NULL
8869 && elf_section_data (sec)->this_hdr.contents != contents)
8870 free (contents);
d0647110
AO
8871 return FALSE;
8872}
8873\f
9a59ad6b
DJ
8874/* Allocate space for global sym dynamic relocs. */
8875
8876static bfd_boolean
8877allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8878{
8879 struct bfd_link_info *info = inf;
8880 bfd *dynobj;
8881 struct mips_elf_link_hash_entry *hmips;
8882 struct mips_elf_link_hash_table *htab;
8883
8884 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
8885 BFD_ASSERT (htab != NULL);
8886
9a59ad6b
DJ
8887 dynobj = elf_hash_table (info)->dynobj;
8888 hmips = (struct mips_elf_link_hash_entry *) h;
8889
8890 /* VxWorks executables are handled elsewhere; we only need to
8891 allocate relocations in shared objects. */
8892 if (htab->is_vxworks && !info->shared)
8893 return TRUE;
8894
7686d77d
AM
8895 /* Ignore indirect symbols. All relocations against such symbols
8896 will be redirected to the target symbol. */
8897 if (h->root.type == bfd_link_hash_indirect)
63897e2c
RS
8898 return TRUE;
8899
9a59ad6b
DJ
8900 /* If this symbol is defined in a dynamic object, or we are creating
8901 a shared library, we will need to copy any R_MIPS_32 or
8902 R_MIPS_REL32 relocs against it into the output file. */
8903 if (! info->relocatable
8904 && hmips->possibly_dynamic_relocs != 0
8905 && (h->root.type == bfd_link_hash_defweak
625ef6dc 8906 || (!h->def_regular && !ELF_COMMON_DEF_P (h))
9a59ad6b
DJ
8907 || info->shared))
8908 {
8909 bfd_boolean do_copy = TRUE;
8910
8911 if (h->root.type == bfd_link_hash_undefweak)
8912 {
8913 /* Do not copy relocations for undefined weak symbols with
8914 non-default visibility. */
8915 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8916 do_copy = FALSE;
8917
8918 /* Make sure undefined weak symbols are output as a dynamic
8919 symbol in PIEs. */
8920 else if (h->dynindx == -1 && !h->forced_local)
8921 {
8922 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8923 return FALSE;
8924 }
8925 }
8926
8927 if (do_copy)
8928 {
aff469fa 8929 /* Even though we don't directly need a GOT entry for this symbol,
f7ff1106
RS
8930 the SVR4 psABI requires it to have a dynamic symbol table
8931 index greater that DT_MIPS_GOTSYM if there are dynamic
8932 relocations against it.
8933
8934 VxWorks does not enforce the same mapping between the GOT
8935 and the symbol table, so the same requirement does not
8936 apply there. */
6ccf4795
RS
8937 if (!htab->is_vxworks)
8938 {
8939 if (hmips->global_got_area > GGA_RELOC_ONLY)
8940 hmips->global_got_area = GGA_RELOC_ONLY;
8941 hmips->got_only_for_calls = FALSE;
8942 }
aff469fa 8943
9a59ad6b
DJ
8944 mips_elf_allocate_dynamic_relocations
8945 (dynobj, info, hmips->possibly_dynamic_relocs);
8946 if (hmips->readonly_reloc)
8947 /* We tell the dynamic linker that there are relocations
8948 against the text segment. */
8949 info->flags |= DF_TEXTREL;
8950 }
8951 }
8952
8953 return TRUE;
8954}
8955
b49e97c9
TS
8956/* Adjust a symbol defined by a dynamic object and referenced by a
8957 regular object. The current definition is in some section of the
8958 dynamic object, but we're not including those sections. We have to
8959 change the definition to something the rest of the link can
8960 understand. */
8961
b34976b6 8962bfd_boolean
9719ad41
RS
8963_bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
8964 struct elf_link_hash_entry *h)
b49e97c9
TS
8965{
8966 bfd *dynobj;
8967 struct mips_elf_link_hash_entry *hmips;
5108fc1b 8968 struct mips_elf_link_hash_table *htab;
b49e97c9 8969
5108fc1b 8970 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
8971 BFD_ASSERT (htab != NULL);
8972
b49e97c9 8973 dynobj = elf_hash_table (info)->dynobj;
861fb55a 8974 hmips = (struct mips_elf_link_hash_entry *) h;
b49e97c9
TS
8975
8976 /* Make sure we know what is going on here. */
8977 BFD_ASSERT (dynobj != NULL
f5385ebf 8978 && (h->needs_plt
f6e332e6 8979 || h->u.weakdef != NULL
f5385ebf
AM
8980 || (h->def_dynamic
8981 && h->ref_regular
8982 && !h->def_regular)));
b49e97c9 8983
b49e97c9 8984 hmips = (struct mips_elf_link_hash_entry *) h;
b49e97c9 8985
861fb55a
DJ
8986 /* If there are call relocations against an externally-defined symbol,
8987 see whether we can create a MIPS lazy-binding stub for it. We can
8988 only do this if all references to the function are through call
8989 relocations, and in that case, the traditional lazy-binding stubs
8990 are much more efficient than PLT entries.
8991
8992 Traditional stubs are only available on SVR4 psABI-based systems;
8993 VxWorks always uses PLTs instead. */
8994 if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
b49e97c9
TS
8995 {
8996 if (! elf_hash_table (info)->dynamic_sections_created)
b34976b6 8997 return TRUE;
b49e97c9
TS
8998
8999 /* If this symbol is not defined in a regular file, then set
9000 the symbol to the stub location. This is required to make
9001 function pointers compare as equal between the normal
9002 executable and the shared library. */
f5385ebf 9003 if (!h->def_regular)
b49e97c9 9004 {
33bb52fb
RS
9005 hmips->needs_lazy_stub = TRUE;
9006 htab->lazy_stub_count++;
b34976b6 9007 return TRUE;
b49e97c9
TS
9008 }
9009 }
861fb55a
DJ
9010 /* As above, VxWorks requires PLT entries for externally-defined
9011 functions that are only accessed through call relocations.
b49e97c9 9012
861fb55a
DJ
9013 Both VxWorks and non-VxWorks targets also need PLT entries if there
9014 are static-only relocations against an externally-defined function.
9015 This can technically occur for shared libraries if there are
9016 branches to the symbol, although it is unlikely that this will be
9017 used in practice due to the short ranges involved. It can occur
9018 for any relative or absolute relocation in executables; in that
9019 case, the PLT entry becomes the function's canonical address. */
9020 else if (((h->needs_plt && !hmips->no_fn_stub)
9021 || (h->type == STT_FUNC && hmips->has_static_relocs))
9022 && htab->use_plts_and_copy_relocs
9023 && !SYMBOL_CALLS_LOCAL (info, h)
9024 && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
9025 && h->root.type == bfd_link_hash_undefweak))
b49e97c9 9026 {
1bbce132
MR
9027 bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
9028 bfd_boolean newabi_p = NEWABI_P (info->output_bfd);
9029
9030 /* If this is the first symbol to need a PLT entry, then make some
9031 basic setup. Also work out PLT entry sizes. We'll need them
9032 for PLT offset calculations. */
9033 if (htab->plt_mips_offset + htab->plt_comp_offset == 0)
861fb55a
DJ
9034 {
9035 BFD_ASSERT (htab->sgotplt->size == 0);
1bbce132 9036 BFD_ASSERT (htab->plt_got_index == 0);
0a44bf69 9037
861fb55a
DJ
9038 /* If we're using the PLT additions to the psABI, each PLT
9039 entry is 16 bytes and the PLT0 entry is 32 bytes.
9040 Encourage better cache usage by aligning. We do this
9041 lazily to avoid pessimizing traditional objects. */
9042 if (!htab->is_vxworks
9043 && !bfd_set_section_alignment (dynobj, htab->splt, 5))
9044 return FALSE;
0a44bf69 9045
861fb55a
DJ
9046 /* Make sure that .got.plt is word-aligned. We do this lazily
9047 for the same reason as above. */
9048 if (!bfd_set_section_alignment (dynobj, htab->sgotplt,
9049 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
9050 return FALSE;
0a44bf69 9051
861fb55a
DJ
9052 /* On non-VxWorks targets, the first two entries in .got.plt
9053 are reserved. */
9054 if (!htab->is_vxworks)
1bbce132
MR
9055 htab->plt_got_index
9056 += (get_elf_backend_data (dynobj)->got_header_size
9057 / MIPS_ELF_GOT_SIZE (dynobj));
0a44bf69 9058
861fb55a
DJ
9059 /* On VxWorks, also allocate room for the header's
9060 .rela.plt.unloaded entries. */
9061 if (htab->is_vxworks && !info->shared)
0a44bf69 9062 htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
1bbce132
MR
9063
9064 /* Now work out the sizes of individual PLT entries. */
9065 if (htab->is_vxworks && info->shared)
9066 htab->plt_mips_entry_size
9067 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
9068 else if (htab->is_vxworks)
9069 htab->plt_mips_entry_size
9070 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
9071 else if (newabi_p)
9072 htab->plt_mips_entry_size
9073 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
833794fc 9074 else if (!micromips_p)
1bbce132
MR
9075 {
9076 htab->plt_mips_entry_size
9077 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9078 htab->plt_comp_entry_size
833794fc
MR
9079 = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
9080 }
9081 else if (htab->insn32)
9082 {
9083 htab->plt_mips_entry_size
9084 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9085 htab->plt_comp_entry_size
9086 = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
1bbce132
MR
9087 }
9088 else
9089 {
9090 htab->plt_mips_entry_size
9091 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9092 htab->plt_comp_entry_size
833794fc 9093 = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
1bbce132 9094 }
0a44bf69
RS
9095 }
9096
1bbce132
MR
9097 if (h->plt.plist == NULL)
9098 h->plt.plist = mips_elf_make_plt_record (dynobj);
9099 if (h->plt.plist == NULL)
9100 return FALSE;
9101
9102 /* There are no defined MIPS16 or microMIPS PLT entries for VxWorks,
9103 n32 or n64, so always use a standard entry there.
9104
9105 If the symbol has a MIPS16 call stub and gets a PLT entry, then
9106 all MIPS16 calls will go via that stub, and there is no benefit
9107 to having a MIPS16 entry. And in the case of call_stub a
9108 standard entry actually has to be used as the stub ends with a J
9109 instruction. */
9110 if (newabi_p
9111 || htab->is_vxworks
9112 || hmips->call_stub
9113 || hmips->call_fp_stub)
9114 {
9115 h->plt.plist->need_mips = TRUE;
9116 h->plt.plist->need_comp = FALSE;
9117 }
9118
9119 /* Otherwise, if there are no direct calls to the function, we
9120 have a free choice of whether to use standard or compressed
9121 entries. Prefer microMIPS entries if the object is known to
9122 contain microMIPS code, so that it becomes possible to create
9123 pure microMIPS binaries. Prefer standard entries otherwise,
9124 because MIPS16 ones are no smaller and are usually slower. */
9125 if (!h->plt.plist->need_mips && !h->plt.plist->need_comp)
9126 {
9127 if (micromips_p)
9128 h->plt.plist->need_comp = TRUE;
9129 else
9130 h->plt.plist->need_mips = TRUE;
9131 }
9132
9133 if (h->plt.plist->need_mips)
9134 {
9135 h->plt.plist->mips_offset = htab->plt_mips_offset;
9136 htab->plt_mips_offset += htab->plt_mips_entry_size;
9137 }
9138 if (h->plt.plist->need_comp)
9139 {
9140 h->plt.plist->comp_offset = htab->plt_comp_offset;
9141 htab->plt_comp_offset += htab->plt_comp_entry_size;
9142 }
9143
9144 /* Reserve the corresponding .got.plt entry now too. */
9145 h->plt.plist->gotplt_index = htab->plt_got_index++;
0a44bf69
RS
9146
9147 /* If the output file has no definition of the symbol, set the
861fb55a 9148 symbol's value to the address of the stub. */
131eb6b7 9149 if (!info->shared && !h->def_regular)
1bbce132 9150 hmips->use_plt_entry = TRUE;
0a44bf69 9151
1bbce132 9152 /* Make room for the R_MIPS_JUMP_SLOT relocation. */
861fb55a
DJ
9153 htab->srelplt->size += (htab->is_vxworks
9154 ? MIPS_ELF_RELA_SIZE (dynobj)
9155 : MIPS_ELF_REL_SIZE (dynobj));
0a44bf69
RS
9156
9157 /* Make room for the .rela.plt.unloaded relocations. */
861fb55a 9158 if (htab->is_vxworks && !info->shared)
0a44bf69
RS
9159 htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
9160
861fb55a
DJ
9161 /* All relocations against this symbol that could have been made
9162 dynamic will now refer to the PLT entry instead. */
9163 hmips->possibly_dynamic_relocs = 0;
0a44bf69 9164
0a44bf69
RS
9165 return TRUE;
9166 }
9167
9168 /* If this is a weak symbol, and there is a real definition, the
9169 processor independent code will have arranged for us to see the
9170 real definition first, and we can just use the same value. */
9171 if (h->u.weakdef != NULL)
9172 {
9173 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
9174 || h->u.weakdef->root.type == bfd_link_hash_defweak);
9175 h->root.u.def.section = h->u.weakdef->root.u.def.section;
9176 h->root.u.def.value = h->u.weakdef->root.u.def.value;
9177 return TRUE;
9178 }
9179
861fb55a
DJ
9180 /* Otherwise, there is nothing further to do for symbols defined
9181 in regular objects. */
9182 if (h->def_regular)
0a44bf69
RS
9183 return TRUE;
9184
861fb55a
DJ
9185 /* There's also nothing more to do if we'll convert all relocations
9186 against this symbol into dynamic relocations. */
9187 if (!hmips->has_static_relocs)
9188 return TRUE;
9189
9190 /* We're now relying on copy relocations. Complain if we have
9191 some that we can't convert. */
9192 if (!htab->use_plts_and_copy_relocs || info->shared)
9193 {
9194 (*_bfd_error_handler) (_("non-dynamic relocations refer to "
9195 "dynamic symbol %s"),
9196 h->root.root.string);
9197 bfd_set_error (bfd_error_bad_value);
9198 return FALSE;
9199 }
9200
0a44bf69
RS
9201 /* We must allocate the symbol in our .dynbss section, which will
9202 become part of the .bss section of the executable. There will be
9203 an entry for this symbol in the .dynsym section. The dynamic
9204 object will contain position independent code, so all references
9205 from the dynamic object to this symbol will go through the global
9206 offset table. The dynamic linker will use the .dynsym entry to
9207 determine the address it must put in the global offset table, so
9208 both the dynamic object and the regular object will refer to the
9209 same memory location for the variable. */
9210
9211 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
9212 {
861fb55a
DJ
9213 if (htab->is_vxworks)
9214 htab->srelbss->size += sizeof (Elf32_External_Rela);
9215 else
9216 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
0a44bf69
RS
9217 h->needs_copy = 1;
9218 }
9219
861fb55a
DJ
9220 /* All relocations against this symbol that could have been made
9221 dynamic will now refer to the local copy instead. */
9222 hmips->possibly_dynamic_relocs = 0;
9223
6cabe1ea 9224 return _bfd_elf_adjust_dynamic_copy (info, h, htab->sdynbss);
0a44bf69 9225}
b49e97c9
TS
9226\f
9227/* This function is called after all the input files have been read,
9228 and the input sections have been assigned to output sections. We
9229 check for any mips16 stub sections that we can discard. */
9230
b34976b6 9231bfd_boolean
9719ad41
RS
9232_bfd_mips_elf_always_size_sections (bfd *output_bfd,
9233 struct bfd_link_info *info)
b49e97c9 9234{
351cdf24 9235 asection *sect;
0a44bf69 9236 struct mips_elf_link_hash_table *htab;
861fb55a 9237 struct mips_htab_traverse_info hti;
0a44bf69
RS
9238
9239 htab = mips_elf_hash_table (info);
4dfe6ac6 9240 BFD_ASSERT (htab != NULL);
f4416af6 9241
b49e97c9 9242 /* The .reginfo section has a fixed size. */
351cdf24
MF
9243 sect = bfd_get_section_by_name (output_bfd, ".reginfo");
9244 if (sect != NULL)
9245 bfd_set_section_size (output_bfd, sect, sizeof (Elf32_External_RegInfo));
9246
9247 /* The .MIPS.abiflags section has a fixed size. */
9248 sect = bfd_get_section_by_name (output_bfd, ".MIPS.abiflags");
9249 if (sect != NULL)
9250 bfd_set_section_size (output_bfd, sect, sizeof (Elf_External_ABIFlags_v0));
b49e97c9 9251
861fb55a
DJ
9252 hti.info = info;
9253 hti.output_bfd = output_bfd;
9254 hti.error = FALSE;
9255 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
9256 mips_elf_check_symbols, &hti);
9257 if (hti.error)
9258 return FALSE;
f4416af6 9259
33bb52fb
RS
9260 return TRUE;
9261}
9262
9263/* If the link uses a GOT, lay it out and work out its size. */
9264
9265static bfd_boolean
9266mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
9267{
9268 bfd *dynobj;
9269 asection *s;
9270 struct mips_got_info *g;
33bb52fb
RS
9271 bfd_size_type loadable_size = 0;
9272 bfd_size_type page_gotno;
d7206569 9273 bfd *ibfd;
ab361d49 9274 struct mips_elf_traverse_got_arg tga;
33bb52fb
RS
9275 struct mips_elf_link_hash_table *htab;
9276
9277 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
9278 BFD_ASSERT (htab != NULL);
9279
a8028dd0 9280 s = htab->sgot;
f4416af6 9281 if (s == NULL)
b34976b6 9282 return TRUE;
b49e97c9 9283
33bb52fb 9284 dynobj = elf_hash_table (info)->dynobj;
a8028dd0
RS
9285 g = htab->got_info;
9286
861fb55a
DJ
9287 /* Allocate room for the reserved entries. VxWorks always reserves
9288 3 entries; other objects only reserve 2 entries. */
cb22ccf4 9289 BFD_ASSERT (g->assigned_low_gotno == 0);
861fb55a
DJ
9290 if (htab->is_vxworks)
9291 htab->reserved_gotno = 3;
9292 else
9293 htab->reserved_gotno = 2;
9294 g->local_gotno += htab->reserved_gotno;
cb22ccf4 9295 g->assigned_low_gotno = htab->reserved_gotno;
861fb55a 9296
6c42ddb9
RS
9297 /* Decide which symbols need to go in the global part of the GOT and
9298 count the number of reloc-only GOT symbols. */
020d7251 9299 mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info);
f4416af6 9300
13db6b44
RS
9301 if (!mips_elf_resolve_final_got_entries (info, g))
9302 return FALSE;
9303
33bb52fb
RS
9304 /* Calculate the total loadable size of the output. That
9305 will give us the maximum number of GOT_PAGE entries
9306 required. */
c72f2fb2 9307 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
33bb52fb
RS
9308 {
9309 asection *subsection;
5108fc1b 9310
d7206569 9311 for (subsection = ibfd->sections;
33bb52fb
RS
9312 subsection;
9313 subsection = subsection->next)
9314 {
9315 if ((subsection->flags & SEC_ALLOC) == 0)
9316 continue;
9317 loadable_size += ((subsection->size + 0xf)
9318 &~ (bfd_size_type) 0xf);
9319 }
9320 }
f4416af6 9321
0a44bf69 9322 if (htab->is_vxworks)
738e5348 9323 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
0a44bf69
RS
9324 relocations against local symbols evaluate to "G", and the EABI does
9325 not include R_MIPS_GOT_PAGE. */
c224138d 9326 page_gotno = 0;
0a44bf69
RS
9327 else
9328 /* Assume there are two loadable segments consisting of contiguous
9329 sections. Is 5 enough? */
c224138d
RS
9330 page_gotno = (loadable_size >> 16) + 5;
9331
13db6b44 9332 /* Choose the smaller of the two page estimates; both are intended to be
c224138d
RS
9333 conservative. */
9334 if (page_gotno > g->page_gotno)
9335 page_gotno = g->page_gotno;
f4416af6 9336
c224138d 9337 g->local_gotno += page_gotno;
cb22ccf4 9338 g->assigned_high_gotno = g->local_gotno - 1;
ab361d49 9339
ab361d49
RS
9340 s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9341 s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
0f20cc35
DJ
9342 s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9343
0a44bf69
RS
9344 /* VxWorks does not support multiple GOTs. It initializes $gp to
9345 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
9346 dynamic loader. */
57093f5e 9347 if (!htab->is_vxworks && s->size > MIPS_ELF_GOT_MAX_SIZE (info))
0f20cc35 9348 {
a8028dd0 9349 if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
0f20cc35
DJ
9350 return FALSE;
9351 }
9352 else
9353 {
d7206569
RS
9354 /* Record that all bfds use G. This also has the effect of freeing
9355 the per-bfd GOTs, which we no longer need. */
c72f2fb2 9356 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
d7206569
RS
9357 if (mips_elf_bfd_got (ibfd, FALSE))
9358 mips_elf_replace_bfd_got (ibfd, g);
9359 mips_elf_replace_bfd_got (output_bfd, g);
9360
33bb52fb 9361 /* Set up TLS entries. */
0f20cc35 9362 g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
72e7511a
RS
9363 tga.info = info;
9364 tga.g = g;
9365 tga.value = MIPS_ELF_GOT_SIZE (output_bfd);
9366 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
9367 if (!tga.g)
9368 return FALSE;
1fd20d70
RS
9369 BFD_ASSERT (g->tls_assigned_gotno
9370 == g->global_gotno + g->local_gotno + g->tls_gotno);
33bb52fb 9371
57093f5e
RS
9372 /* Each VxWorks GOT entry needs an explicit relocation. */
9373 if (htab->is_vxworks && info->shared)
9374 g->relocs += g->global_gotno + g->local_gotno - htab->reserved_gotno;
9375
33bb52fb 9376 /* Allocate room for the TLS relocations. */
ab361d49
RS
9377 if (g->relocs)
9378 mips_elf_allocate_dynamic_relocations (dynobj, info, g->relocs);
0f20cc35 9379 }
b49e97c9 9380
b34976b6 9381 return TRUE;
b49e97c9
TS
9382}
9383
33bb52fb
RS
9384/* Estimate the size of the .MIPS.stubs section. */
9385
9386static void
9387mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
9388{
9389 struct mips_elf_link_hash_table *htab;
9390 bfd_size_type dynsymcount;
9391
9392 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
9393 BFD_ASSERT (htab != NULL);
9394
33bb52fb
RS
9395 if (htab->lazy_stub_count == 0)
9396 return;
9397
9398 /* IRIX rld assumes that a function stub isn't at the end of the .text
9399 section, so add a dummy entry to the end. */
9400 htab->lazy_stub_count++;
9401
9402 /* Get a worst-case estimate of the number of dynamic symbols needed.
9403 At this point, dynsymcount does not account for section symbols
9404 and count_section_dynsyms may overestimate the number that will
9405 be needed. */
9406 dynsymcount = (elf_hash_table (info)->dynsymcount
9407 + count_section_dynsyms (output_bfd, info));
9408
1bbce132
MR
9409 /* Determine the size of one stub entry. There's no disadvantage
9410 from using microMIPS code here, so for the sake of pure-microMIPS
9411 binaries we prefer it whenever there's any microMIPS code in
9412 output produced at all. This has a benefit of stubs being
833794fc
MR
9413 shorter by 4 bytes each too, unless in the insn32 mode. */
9414 if (!MICROMIPS_P (output_bfd))
1bbce132
MR
9415 htab->function_stub_size = (dynsymcount > 0x10000
9416 ? MIPS_FUNCTION_STUB_BIG_SIZE
9417 : MIPS_FUNCTION_STUB_NORMAL_SIZE);
833794fc
MR
9418 else if (htab->insn32)
9419 htab->function_stub_size = (dynsymcount > 0x10000
9420 ? MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
9421 : MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE);
9422 else
9423 htab->function_stub_size = (dynsymcount > 0x10000
9424 ? MICROMIPS_FUNCTION_STUB_BIG_SIZE
9425 : MICROMIPS_FUNCTION_STUB_NORMAL_SIZE);
33bb52fb
RS
9426
9427 htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
9428}
9429
1bbce132
MR
9430/* A mips_elf_link_hash_traverse callback for which DATA points to a
9431 mips_htab_traverse_info. If H needs a traditional MIPS lazy-binding
9432 stub, allocate an entry in the stubs section. */
33bb52fb
RS
9433
9434static bfd_boolean
af924177 9435mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void *data)
33bb52fb 9436{
1bbce132 9437 struct mips_htab_traverse_info *hti = data;
33bb52fb 9438 struct mips_elf_link_hash_table *htab;
1bbce132
MR
9439 struct bfd_link_info *info;
9440 bfd *output_bfd;
9441
9442 info = hti->info;
9443 output_bfd = hti->output_bfd;
9444 htab = mips_elf_hash_table (info);
9445 BFD_ASSERT (htab != NULL);
33bb52fb 9446
33bb52fb
RS
9447 if (h->needs_lazy_stub)
9448 {
1bbce132
MR
9449 bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
9450 unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9451 bfd_vma isa_bit = micromips_p;
9452
9453 BFD_ASSERT (htab->root.dynobj != NULL);
9454 if (h->root.plt.plist == NULL)
9455 h->root.plt.plist = mips_elf_make_plt_record (htab->sstubs->owner);
9456 if (h->root.plt.plist == NULL)
9457 {
9458 hti->error = TRUE;
9459 return FALSE;
9460 }
33bb52fb 9461 h->root.root.u.def.section = htab->sstubs;
1bbce132
MR
9462 h->root.root.u.def.value = htab->sstubs->size + isa_bit;
9463 h->root.plt.plist->stub_offset = htab->sstubs->size;
9464 h->root.other = other;
33bb52fb
RS
9465 htab->sstubs->size += htab->function_stub_size;
9466 }
9467 return TRUE;
9468}
9469
9470/* Allocate offsets in the stubs section to each symbol that needs one.
9471 Set the final size of the .MIPS.stub section. */
9472
1bbce132 9473static bfd_boolean
33bb52fb
RS
9474mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
9475{
1bbce132
MR
9476 bfd *output_bfd = info->output_bfd;
9477 bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
9478 unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9479 bfd_vma isa_bit = micromips_p;
33bb52fb 9480 struct mips_elf_link_hash_table *htab;
1bbce132
MR
9481 struct mips_htab_traverse_info hti;
9482 struct elf_link_hash_entry *h;
9483 bfd *dynobj;
33bb52fb
RS
9484
9485 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
9486 BFD_ASSERT (htab != NULL);
9487
33bb52fb 9488 if (htab->lazy_stub_count == 0)
1bbce132 9489 return TRUE;
33bb52fb
RS
9490
9491 htab->sstubs->size = 0;
1bbce132
MR
9492 hti.info = info;
9493 hti.output_bfd = output_bfd;
9494 hti.error = FALSE;
9495 mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, &hti);
9496 if (hti.error)
9497 return FALSE;
33bb52fb
RS
9498 htab->sstubs->size += htab->function_stub_size;
9499 BFD_ASSERT (htab->sstubs->size
9500 == htab->lazy_stub_count * htab->function_stub_size);
1bbce132
MR
9501
9502 dynobj = elf_hash_table (info)->dynobj;
9503 BFD_ASSERT (dynobj != NULL);
9504 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->sstubs, "_MIPS_STUBS_");
9505 if (h == NULL)
9506 return FALSE;
9507 h->root.u.def.value = isa_bit;
9508 h->other = other;
9509 h->type = STT_FUNC;
9510
9511 return TRUE;
9512}
9513
9514/* A mips_elf_link_hash_traverse callback for which DATA points to a
9515 bfd_link_info. If H uses the address of a PLT entry as the value
9516 of the symbol, then set the entry in the symbol table now. Prefer
9517 a standard MIPS PLT entry. */
9518
9519static bfd_boolean
9520mips_elf_set_plt_sym_value (struct mips_elf_link_hash_entry *h, void *data)
9521{
9522 struct bfd_link_info *info = data;
9523 bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
9524 struct mips_elf_link_hash_table *htab;
9525 unsigned int other;
9526 bfd_vma isa_bit;
9527 bfd_vma val;
9528
9529 htab = mips_elf_hash_table (info);
9530 BFD_ASSERT (htab != NULL);
9531
9532 if (h->use_plt_entry)
9533 {
9534 BFD_ASSERT (h->root.plt.plist != NULL);
9535 BFD_ASSERT (h->root.plt.plist->mips_offset != MINUS_ONE
9536 || h->root.plt.plist->comp_offset != MINUS_ONE);
9537
9538 val = htab->plt_header_size;
9539 if (h->root.plt.plist->mips_offset != MINUS_ONE)
9540 {
9541 isa_bit = 0;
9542 val += h->root.plt.plist->mips_offset;
9543 other = 0;
9544 }
9545 else
9546 {
9547 isa_bit = 1;
9548 val += htab->plt_mips_offset + h->root.plt.plist->comp_offset;
9549 other = micromips_p ? STO_MICROMIPS : STO_MIPS16;
9550 }
9551 val += isa_bit;
9552 /* For VxWorks, point at the PLT load stub rather than the lazy
9553 resolution stub; this stub will become the canonical function
9554 address. */
9555 if (htab->is_vxworks)
9556 val += 8;
9557
9558 h->root.root.u.def.section = htab->splt;
9559 h->root.root.u.def.value = val;
9560 h->root.other = other;
9561 }
9562
9563 return TRUE;
33bb52fb
RS
9564}
9565
b49e97c9
TS
9566/* Set the sizes of the dynamic sections. */
9567
b34976b6 9568bfd_boolean
9719ad41
RS
9569_bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
9570 struct bfd_link_info *info)
b49e97c9
TS
9571{
9572 bfd *dynobj;
861fb55a 9573 asection *s, *sreldyn;
b34976b6 9574 bfd_boolean reltext;
0a44bf69 9575 struct mips_elf_link_hash_table *htab;
b49e97c9 9576
0a44bf69 9577 htab = mips_elf_hash_table (info);
4dfe6ac6 9578 BFD_ASSERT (htab != NULL);
b49e97c9
TS
9579 dynobj = elf_hash_table (info)->dynobj;
9580 BFD_ASSERT (dynobj != NULL);
9581
9582 if (elf_hash_table (info)->dynamic_sections_created)
9583 {
9584 /* Set the contents of the .interp section to the interpreter. */
893c4fe2 9585 if (info->executable)
b49e97c9 9586 {
3d4d4302 9587 s = bfd_get_linker_section (dynobj, ".interp");
b49e97c9 9588 BFD_ASSERT (s != NULL);
eea6121a 9589 s->size
b49e97c9
TS
9590 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
9591 s->contents
9592 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
9593 }
861fb55a 9594
1bbce132
MR
9595 /* Figure out the size of the PLT header if we know that we
9596 are using it. For the sake of cache alignment always use
9597 a standard header whenever any standard entries are present
9598 even if microMIPS entries are present as well. This also
9599 lets the microMIPS header rely on the value of $v0 only set
9600 by microMIPS entries, for a small size reduction.
9601
9602 Set symbol table entry values for symbols that use the
9603 address of their PLT entry now that we can calculate it.
9604
9605 Also create the _PROCEDURE_LINKAGE_TABLE_ symbol if we
9606 haven't already in _bfd_elf_create_dynamic_sections. */
9607 if (htab->splt && htab->plt_mips_offset + htab->plt_comp_offset != 0)
861fb55a 9608 {
1bbce132
MR
9609 bfd_boolean micromips_p = (MICROMIPS_P (output_bfd)
9610 && !htab->plt_mips_offset);
9611 unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9612 bfd_vma isa_bit = micromips_p;
861fb55a 9613 struct elf_link_hash_entry *h;
1bbce132 9614 bfd_vma size;
861fb55a
DJ
9615
9616 BFD_ASSERT (htab->use_plts_and_copy_relocs);
1bbce132
MR
9617 BFD_ASSERT (htab->sgotplt->size == 0);
9618 BFD_ASSERT (htab->splt->size == 0);
9619
9620 if (htab->is_vxworks && info->shared)
9621 size = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
9622 else if (htab->is_vxworks)
9623 size = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
9624 else if (ABI_64_P (output_bfd))
9625 size = 4 * ARRAY_SIZE (mips_n64_exec_plt0_entry);
9626 else if (ABI_N32_P (output_bfd))
9627 size = 4 * ARRAY_SIZE (mips_n32_exec_plt0_entry);
9628 else if (!micromips_p)
9629 size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
833794fc
MR
9630 else if (htab->insn32)
9631 size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
1bbce132
MR
9632 else
9633 size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
861fb55a 9634
1bbce132
MR
9635 htab->plt_header_is_comp = micromips_p;
9636 htab->plt_header_size = size;
9637 htab->splt->size = (size
9638 + htab->plt_mips_offset
9639 + htab->plt_comp_offset);
9640 htab->sgotplt->size = (htab->plt_got_index
9641 * MIPS_ELF_GOT_SIZE (dynobj));
9642
9643 mips_elf_link_hash_traverse (htab, mips_elf_set_plt_sym_value, info);
9644
9645 if (htab->root.hplt == NULL)
9646 {
9647 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->splt,
9648 "_PROCEDURE_LINKAGE_TABLE_");
9649 htab->root.hplt = h;
9650 if (h == NULL)
9651 return FALSE;
9652 }
9653
9654 h = htab->root.hplt;
9655 h->root.u.def.value = isa_bit;
9656 h->other = other;
861fb55a
DJ
9657 h->type = STT_FUNC;
9658 }
9659 }
4e41d0d7 9660
9a59ad6b 9661 /* Allocate space for global sym dynamic relocs. */
2c3fc389 9662 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
9a59ad6b 9663
33bb52fb
RS
9664 mips_elf_estimate_stub_size (output_bfd, info);
9665
9666 if (!mips_elf_lay_out_got (output_bfd, info))
9667 return FALSE;
9668
9669 mips_elf_lay_out_lazy_stubs (info);
9670
b49e97c9
TS
9671 /* The check_relocs and adjust_dynamic_symbol entry points have
9672 determined the sizes of the various dynamic sections. Allocate
9673 memory for them. */
b34976b6 9674 reltext = FALSE;
b49e97c9
TS
9675 for (s = dynobj->sections; s != NULL; s = s->next)
9676 {
9677 const char *name;
b49e97c9
TS
9678
9679 /* It's OK to base decisions on the section name, because none
9680 of the dynobj section names depend upon the input files. */
9681 name = bfd_get_section_name (dynobj, s);
9682
9683 if ((s->flags & SEC_LINKER_CREATED) == 0)
9684 continue;
9685
0112cd26 9686 if (CONST_STRNEQ (name, ".rel"))
b49e97c9 9687 {
c456f082 9688 if (s->size != 0)
b49e97c9
TS
9689 {
9690 const char *outname;
9691 asection *target;
9692
9693 /* If this relocation section applies to a read only
9694 section, then we probably need a DT_TEXTREL entry.
0a44bf69 9695 If the relocation section is .rel(a).dyn, we always
b49e97c9
TS
9696 assert a DT_TEXTREL entry rather than testing whether
9697 there exists a relocation to a read only section or
9698 not. */
9699 outname = bfd_get_section_name (output_bfd,
9700 s->output_section);
9701 target = bfd_get_section_by_name (output_bfd, outname + 4);
9702 if ((target != NULL
9703 && (target->flags & SEC_READONLY) != 0
9704 && (target->flags & SEC_ALLOC) != 0)
0a44bf69 9705 || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
b34976b6 9706 reltext = TRUE;
b49e97c9
TS
9707
9708 /* We use the reloc_count field as a counter if we need
9709 to copy relocs into the output file. */
0a44bf69 9710 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
b49e97c9 9711 s->reloc_count = 0;
f4416af6
AO
9712
9713 /* If combreloc is enabled, elf_link_sort_relocs() will
9714 sort relocations, but in a different way than we do,
9715 and before we're done creating relocations. Also, it
9716 will move them around between input sections'
9717 relocation's contents, so our sorting would be
9718 broken, so don't let it run. */
9719 info->combreloc = 0;
b49e97c9
TS
9720 }
9721 }
a5499fa4 9722 else if (info->executable
b49e97c9 9723 && ! mips_elf_hash_table (info)->use_rld_obj_head
0112cd26 9724 && CONST_STRNEQ (name, ".rld_map"))
b49e97c9 9725 {
5108fc1b 9726 /* We add a room for __rld_map. It will be filled in by the
b49e97c9 9727 rtld to contain a pointer to the _r_debug structure. */
b4082c70 9728 s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd);
b49e97c9
TS
9729 }
9730 else if (SGI_COMPAT (output_bfd)
0112cd26 9731 && CONST_STRNEQ (name, ".compact_rel"))
eea6121a 9732 s->size += mips_elf_hash_table (info)->compact_rel_size;
861fb55a
DJ
9733 else if (s == htab->splt)
9734 {
9735 /* If the last PLT entry has a branch delay slot, allocate
6d30f5b2
NC
9736 room for an extra nop to fill the delay slot. This is
9737 for CPUs without load interlocking. */
9738 if (! LOAD_INTERLOCKS_P (output_bfd)
9739 && ! htab->is_vxworks && s->size > 0)
861fb55a
DJ
9740 s->size += 4;
9741 }
0112cd26 9742 else if (! CONST_STRNEQ (name, ".init")
33bb52fb 9743 && s != htab->sgot
0a44bf69 9744 && s != htab->sgotplt
861fb55a
DJ
9745 && s != htab->sstubs
9746 && s != htab->sdynbss)
b49e97c9
TS
9747 {
9748 /* It's not one of our sections, so don't allocate space. */
9749 continue;
9750 }
9751
c456f082 9752 if (s->size == 0)
b49e97c9 9753 {
8423293d 9754 s->flags |= SEC_EXCLUDE;
b49e97c9
TS
9755 continue;
9756 }
9757
c456f082
AM
9758 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9759 continue;
9760
b49e97c9 9761 /* Allocate memory for the section contents. */
eea6121a 9762 s->contents = bfd_zalloc (dynobj, s->size);
c456f082 9763 if (s->contents == NULL)
b49e97c9
TS
9764 {
9765 bfd_set_error (bfd_error_no_memory);
b34976b6 9766 return FALSE;
b49e97c9
TS
9767 }
9768 }
9769
9770 if (elf_hash_table (info)->dynamic_sections_created)
9771 {
9772 /* Add some entries to the .dynamic section. We fill in the
9773 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
9774 must add the entries now so that we get the correct size for
5750dcec 9775 the .dynamic section. */
af5978fb
RS
9776
9777 /* SGI object has the equivalence of DT_DEBUG in the
5750dcec 9778 DT_MIPS_RLD_MAP entry. This must come first because glibc
6e6be592
MR
9779 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
9780 may only look at the first one they see. */
af5978fb
RS
9781 if (!info->shared
9782 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
9783 return FALSE;
b49e97c9 9784
a5499fa4
MF
9785 if (info->executable
9786 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP_REL, 0))
9787 return FALSE;
9788
5750dcec
DJ
9789 /* The DT_DEBUG entry may be filled in by the dynamic linker and
9790 used by the debugger. */
9791 if (info->executable
9792 && !SGI_COMPAT (output_bfd)
9793 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
9794 return FALSE;
9795
0a44bf69 9796 if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
b49e97c9
TS
9797 info->flags |= DF_TEXTREL;
9798
9799 if ((info->flags & DF_TEXTREL) != 0)
9800 {
9801 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
b34976b6 9802 return FALSE;
943284cc
DJ
9803
9804 /* Clear the DF_TEXTREL flag. It will be set again if we
9805 write out an actual text relocation; we may not, because
9806 at this point we do not know whether e.g. any .eh_frame
9807 absolute relocations have been converted to PC-relative. */
9808 info->flags &= ~DF_TEXTREL;
b49e97c9
TS
9809 }
9810
9811 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
b34976b6 9812 return FALSE;
b49e97c9 9813
861fb55a 9814 sreldyn = mips_elf_rel_dyn_section (info, FALSE);
0a44bf69 9815 if (htab->is_vxworks)
b49e97c9 9816 {
0a44bf69
RS
9817 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
9818 use any of the DT_MIPS_* tags. */
861fb55a 9819 if (sreldyn && sreldyn->size > 0)
0a44bf69
RS
9820 {
9821 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
9822 return FALSE;
b49e97c9 9823
0a44bf69
RS
9824 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
9825 return FALSE;
b49e97c9 9826
0a44bf69
RS
9827 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
9828 return FALSE;
9829 }
b49e97c9 9830 }
0a44bf69
RS
9831 else
9832 {
861fb55a 9833 if (sreldyn && sreldyn->size > 0)
0a44bf69
RS
9834 {
9835 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
9836 return FALSE;
b49e97c9 9837
0a44bf69
RS
9838 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
9839 return FALSE;
b49e97c9 9840
0a44bf69
RS
9841 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
9842 return FALSE;
9843 }
b49e97c9 9844
0a44bf69
RS
9845 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
9846 return FALSE;
b49e97c9 9847
0a44bf69
RS
9848 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
9849 return FALSE;
b49e97c9 9850
0a44bf69
RS
9851 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
9852 return FALSE;
b49e97c9 9853
0a44bf69
RS
9854 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
9855 return FALSE;
b49e97c9 9856
0a44bf69
RS
9857 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
9858 return FALSE;
b49e97c9 9859
0a44bf69
RS
9860 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
9861 return FALSE;
b49e97c9 9862
0a44bf69
RS
9863 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
9864 return FALSE;
9865
9866 if (IRIX_COMPAT (dynobj) == ict_irix5
9867 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
9868 return FALSE;
9869
9870 if (IRIX_COMPAT (dynobj) == ict_irix6
9871 && (bfd_get_section_by_name
af0edeb8 9872 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
0a44bf69
RS
9873 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
9874 return FALSE;
9875 }
861fb55a
DJ
9876 if (htab->splt->size > 0)
9877 {
9878 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
9879 return FALSE;
9880
9881 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
9882 return FALSE;
9883
9884 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
9885 return FALSE;
9886
9887 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
9888 return FALSE;
9889 }
7a2b07ff
NS
9890 if (htab->is_vxworks
9891 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
9892 return FALSE;
b49e97c9
TS
9893 }
9894
b34976b6 9895 return TRUE;
b49e97c9
TS
9896}
9897\f
81d43bff
RS
9898/* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
9899 Adjust its R_ADDEND field so that it is correct for the output file.
9900 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
9901 and sections respectively; both use symbol indexes. */
9902
9903static void
9904mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
9905 bfd *input_bfd, Elf_Internal_Sym *local_syms,
9906 asection **local_sections, Elf_Internal_Rela *rel)
9907{
9908 unsigned int r_type, r_symndx;
9909 Elf_Internal_Sym *sym;
9910 asection *sec;
9911
020d7251 9912 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
81d43bff
RS
9913 {
9914 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
df58fc94 9915 if (gprel16_reloc_p (r_type)
81d43bff 9916 || r_type == R_MIPS_GPREL32
df58fc94 9917 || literal_reloc_p (r_type))
81d43bff
RS
9918 {
9919 rel->r_addend += _bfd_get_gp_value (input_bfd);
9920 rel->r_addend -= _bfd_get_gp_value (output_bfd);
9921 }
9922
9923 r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
9924 sym = local_syms + r_symndx;
9925
9926 /* Adjust REL's addend to account for section merging. */
9927 if (!info->relocatable)
9928 {
9929 sec = local_sections[r_symndx];
9930 _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9931 }
9932
9933 /* This would normally be done by the rela_normal code in elflink.c. */
9934 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9935 rel->r_addend += local_sections[r_symndx]->output_offset;
9936 }
9937}
9938
545fd46b
MR
9939/* Handle relocations against symbols from removed linkonce sections,
9940 or sections discarded by a linker script. We use this wrapper around
9941 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
9942 on 64-bit ELF targets. In this case for any relocation handled, which
9943 always be the first in a triplet, the remaining two have to be processed
9944 together with the first, even if they are R_MIPS_NONE. It is the symbol
9945 index referred by the first reloc that applies to all the three and the
9946 remaining two never refer to an object symbol. And it is the final
9947 relocation (the last non-null one) that determines the output field of
9948 the whole relocation so retrieve the corresponding howto structure for
9949 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
9950
9951 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
9952 and therefore requires to be pasted in a loop. It also defines a block
9953 and does not protect any of its arguments, hence the extra brackets. */
9954
9955static void
9956mips_reloc_against_discarded_section (bfd *output_bfd,
9957 struct bfd_link_info *info,
9958 bfd *input_bfd, asection *input_section,
9959 Elf_Internal_Rela **rel,
9960 const Elf_Internal_Rela **relend,
9961 bfd_boolean rel_reloc,
9962 reloc_howto_type *howto,
9963 bfd_byte *contents)
9964{
9965 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
9966 int count = bed->s->int_rels_per_ext_rel;
9967 unsigned int r_type;
9968 int i;
9969
9970 for (i = count - 1; i > 0; i--)
9971 {
9972 r_type = ELF_R_TYPE (output_bfd, (*rel)[i].r_info);
9973 if (r_type != R_MIPS_NONE)
9974 {
9975 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
9976 break;
9977 }
9978 }
9979 do
9980 {
9981 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
9982 (*rel), count, (*relend),
9983 howto, i, contents);
9984 }
9985 while (0);
9986}
9987
b49e97c9
TS
9988/* Relocate a MIPS ELF section. */
9989
b34976b6 9990bfd_boolean
9719ad41
RS
9991_bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
9992 bfd *input_bfd, asection *input_section,
9993 bfd_byte *contents, Elf_Internal_Rela *relocs,
9994 Elf_Internal_Sym *local_syms,
9995 asection **local_sections)
b49e97c9
TS
9996{
9997 Elf_Internal_Rela *rel;
9998 const Elf_Internal_Rela *relend;
9999 bfd_vma addend = 0;
b34976b6 10000 bfd_boolean use_saved_addend_p = FALSE;
9c5bfbb7 10001 const struct elf_backend_data *bed;
b49e97c9
TS
10002
10003 bed = get_elf_backend_data (output_bfd);
10004 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
10005 for (rel = relocs; rel < relend; ++rel)
10006 {
10007 const char *name;
c9adbffe 10008 bfd_vma value = 0;
b49e97c9 10009 reloc_howto_type *howto;
ad3d9127 10010 bfd_boolean cross_mode_jump_p = FALSE;
b34976b6 10011 /* TRUE if the relocation is a RELA relocation, rather than a
b49e97c9 10012 REL relocation. */
b34976b6 10013 bfd_boolean rela_relocation_p = TRUE;
b49e97c9 10014 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
9719ad41 10015 const char *msg;
ab96bf03
AM
10016 unsigned long r_symndx;
10017 asection *sec;
749b8d9d
L
10018 Elf_Internal_Shdr *symtab_hdr;
10019 struct elf_link_hash_entry *h;
d4730f92 10020 bfd_boolean rel_reloc;
b49e97c9 10021
d4730f92
BS
10022 rel_reloc = (NEWABI_P (input_bfd)
10023 && mips_elf_rel_relocation_p (input_bfd, input_section,
10024 relocs, rel));
b49e97c9 10025 /* Find the relocation howto for this relocation. */
d4730f92 10026 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
ab96bf03
AM
10027
10028 r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
749b8d9d 10029 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
020d7251 10030 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
749b8d9d
L
10031 {
10032 sec = local_sections[r_symndx];
10033 h = NULL;
10034 }
ab96bf03
AM
10035 else
10036 {
ab96bf03 10037 unsigned long extsymoff;
ab96bf03 10038
ab96bf03
AM
10039 extsymoff = 0;
10040 if (!elf_bad_symtab (input_bfd))
10041 extsymoff = symtab_hdr->sh_info;
10042 h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
10043 while (h->root.type == bfd_link_hash_indirect
10044 || h->root.type == bfd_link_hash_warning)
10045 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10046
10047 sec = NULL;
10048 if (h->root.type == bfd_link_hash_defined
10049 || h->root.type == bfd_link_hash_defweak)
10050 sec = h->root.u.def.section;
10051 }
10052
dbaa2011 10053 if (sec != NULL && discarded_section (sec))
545fd46b
MR
10054 {
10055 mips_reloc_against_discarded_section (output_bfd, info, input_bfd,
10056 input_section, &rel, &relend,
10057 rel_reloc, howto, contents);
10058 continue;
10059 }
ab96bf03 10060
4a14403c 10061 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
b49e97c9
TS
10062 {
10063 /* Some 32-bit code uses R_MIPS_64. In particular, people use
10064 64-bit code, but make sure all their addresses are in the
10065 lowermost or uppermost 32-bit section of the 64-bit address
10066 space. Thus, when they use an R_MIPS_64 they mean what is
10067 usually meant by R_MIPS_32, with the exception that the
10068 stored value is sign-extended to 64 bits. */
b34976b6 10069 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
b49e97c9
TS
10070
10071 /* On big-endian systems, we need to lie about the position
10072 of the reloc. */
10073 if (bfd_big_endian (input_bfd))
10074 rel->r_offset += 4;
10075 }
b49e97c9
TS
10076
10077 if (!use_saved_addend_p)
10078 {
b49e97c9
TS
10079 /* If these relocations were originally of the REL variety,
10080 we must pull the addend out of the field that will be
10081 relocated. Otherwise, we simply use the contents of the
c224138d
RS
10082 RELA relocation. */
10083 if (mips_elf_rel_relocation_p (input_bfd, input_section,
10084 relocs, rel))
b49e97c9 10085 {
b34976b6 10086 rela_relocation_p = FALSE;
c224138d
RS
10087 addend = mips_elf_read_rel_addend (input_bfd, rel,
10088 howto, contents);
738e5348
RS
10089 if (hi16_reloc_p (r_type)
10090 || (got16_reloc_p (r_type)
b49e97c9 10091 && mips_elf_local_relocation_p (input_bfd, rel,
020d7251 10092 local_sections)))
b49e97c9 10093 {
c224138d
RS
10094 if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
10095 contents, &addend))
749b8d9d 10096 {
749b8d9d
L
10097 if (h)
10098 name = h->root.root.string;
10099 else
10100 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
10101 local_syms + r_symndx,
10102 sec);
10103 (*_bfd_error_handler)
10104 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
10105 input_bfd, input_section, name, howto->name,
10106 rel->r_offset);
749b8d9d 10107 }
b49e97c9 10108 }
30ac9238
RS
10109 else
10110 addend <<= howto->rightshift;
b49e97c9
TS
10111 }
10112 else
10113 addend = rel->r_addend;
81d43bff
RS
10114 mips_elf_adjust_addend (output_bfd, info, input_bfd,
10115 local_syms, local_sections, rel);
b49e97c9
TS
10116 }
10117
1049f94e 10118 if (info->relocatable)
b49e97c9 10119 {
4a14403c 10120 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
b49e97c9
TS
10121 && bfd_big_endian (input_bfd))
10122 rel->r_offset -= 4;
10123
81d43bff 10124 if (!rela_relocation_p && rel->r_addend)
5a659663 10125 {
81d43bff 10126 addend += rel->r_addend;
738e5348 10127 if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
5a659663
TS
10128 addend = mips_elf_high (addend);
10129 else if (r_type == R_MIPS_HIGHER)
10130 addend = mips_elf_higher (addend);
10131 else if (r_type == R_MIPS_HIGHEST)
10132 addend = mips_elf_highest (addend);
30ac9238
RS
10133 else
10134 addend >>= howto->rightshift;
b49e97c9 10135
30ac9238
RS
10136 /* We use the source mask, rather than the destination
10137 mask because the place to which we are writing will be
10138 source of the addend in the final link. */
b49e97c9
TS
10139 addend &= howto->src_mask;
10140
5a659663 10141 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
b49e97c9
TS
10142 /* See the comment above about using R_MIPS_64 in the 32-bit
10143 ABI. Here, we need to update the addend. It would be
10144 possible to get away with just using the R_MIPS_32 reloc
10145 but for endianness. */
10146 {
10147 bfd_vma sign_bits;
10148 bfd_vma low_bits;
10149 bfd_vma high_bits;
10150
10151 if (addend & ((bfd_vma) 1 << 31))
10152#ifdef BFD64
10153 sign_bits = ((bfd_vma) 1 << 32) - 1;
10154#else
10155 sign_bits = -1;
10156#endif
10157 else
10158 sign_bits = 0;
10159
10160 /* If we don't know that we have a 64-bit type,
10161 do two separate stores. */
10162 if (bfd_big_endian (input_bfd))
10163 {
10164 /* Store the sign-bits (which are most significant)
10165 first. */
10166 low_bits = sign_bits;
10167 high_bits = addend;
10168 }
10169 else
10170 {
10171 low_bits = addend;
10172 high_bits = sign_bits;
10173 }
10174 bfd_put_32 (input_bfd, low_bits,
10175 contents + rel->r_offset);
10176 bfd_put_32 (input_bfd, high_bits,
10177 contents + rel->r_offset + 4);
10178 continue;
10179 }
10180
10181 if (! mips_elf_perform_relocation (info, howto, rel, addend,
10182 input_bfd, input_section,
b34976b6
AM
10183 contents, FALSE))
10184 return FALSE;
b49e97c9
TS
10185 }
10186
10187 /* Go on to the next relocation. */
10188 continue;
10189 }
10190
10191 /* In the N32 and 64-bit ABIs there may be multiple consecutive
10192 relocations for the same offset. In that case we are
10193 supposed to treat the output of each relocation as the addend
10194 for the next. */
10195 if (rel + 1 < relend
10196 && rel->r_offset == rel[1].r_offset
10197 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
b34976b6 10198 use_saved_addend_p = TRUE;
b49e97c9 10199 else
b34976b6 10200 use_saved_addend_p = FALSE;
b49e97c9
TS
10201
10202 /* Figure out what value we are supposed to relocate. */
10203 switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
10204 input_section, info, rel,
10205 addend, howto, local_syms,
10206 local_sections, &value,
38a7df63 10207 &name, &cross_mode_jump_p,
bce03d3d 10208 use_saved_addend_p))
b49e97c9
TS
10209 {
10210 case bfd_reloc_continue:
10211 /* There's nothing to do. */
10212 continue;
10213
10214 case bfd_reloc_undefined:
10215 /* mips_elf_calculate_relocation already called the
10216 undefined_symbol callback. There's no real point in
10217 trying to perform the relocation at this point, so we
10218 just skip ahead to the next relocation. */
10219 continue;
10220
10221 case bfd_reloc_notsupported:
10222 msg = _("internal error: unsupported relocation error");
10223 info->callbacks->warning
10224 (info, msg, name, input_bfd, input_section, rel->r_offset);
b34976b6 10225 return FALSE;
b49e97c9
TS
10226
10227 case bfd_reloc_overflow:
10228 if (use_saved_addend_p)
10229 /* Ignore overflow until we reach the last relocation for
10230 a given location. */
10231 ;
10232 else
10233 {
0e53d9da
AN
10234 struct mips_elf_link_hash_table *htab;
10235
10236 htab = mips_elf_hash_table (info);
4dfe6ac6 10237 BFD_ASSERT (htab != NULL);
b49e97c9 10238 BFD_ASSERT (name != NULL);
0e53d9da 10239 if (!htab->small_data_overflow_reported
9684f078 10240 && (gprel16_reloc_p (howto->type)
df58fc94 10241 || literal_reloc_p (howto->type)))
0e53d9da 10242 {
91d6fa6a
NC
10243 msg = _("small-data section exceeds 64KB;"
10244 " lower small-data size limit (see option -G)");
0e53d9da
AN
10245
10246 htab->small_data_overflow_reported = TRUE;
10247 (*info->callbacks->einfo) ("%P: %s\n", msg);
10248 }
b49e97c9 10249 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f 10250 (info, NULL, name, howto->name, (bfd_vma) 0,
b49e97c9 10251 input_bfd, input_section, rel->r_offset)))
b34976b6 10252 return FALSE;
b49e97c9
TS
10253 }
10254 break;
10255
10256 case bfd_reloc_ok:
10257 break;
10258
df58fc94
RS
10259 case bfd_reloc_outofrange:
10260 if (jal_reloc_p (howto->type))
10261 {
10262 msg = _("JALX to a non-word-aligned address");
10263 info->callbacks->warning
10264 (info, msg, name, input_bfd, input_section, rel->r_offset);
10265 return FALSE;
10266 }
7361da2c
AB
10267 if (aligned_pcrel_reloc_p (howto->type))
10268 {
10269 msg = _("PC-relative load from unaligned address");
10270 info->callbacks->warning
10271 (info, msg, name, input_bfd, input_section, rel->r_offset);
10272 return FALSE;
10273 }
df58fc94
RS
10274 /* Fall through. */
10275
b49e97c9
TS
10276 default:
10277 abort ();
10278 break;
10279 }
10280
10281 /* If we've got another relocation for the address, keep going
10282 until we reach the last one. */
10283 if (use_saved_addend_p)
10284 {
10285 addend = value;
10286 continue;
10287 }
10288
4a14403c 10289 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
b49e97c9
TS
10290 /* See the comment above about using R_MIPS_64 in the 32-bit
10291 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
10292 that calculated the right value. Now, however, we
10293 sign-extend the 32-bit result to 64-bits, and store it as a
10294 64-bit value. We are especially generous here in that we
10295 go to extreme lengths to support this usage on systems with
10296 only a 32-bit VMA. */
10297 {
10298 bfd_vma sign_bits;
10299 bfd_vma low_bits;
10300 bfd_vma high_bits;
10301
10302 if (value & ((bfd_vma) 1 << 31))
10303#ifdef BFD64
10304 sign_bits = ((bfd_vma) 1 << 32) - 1;
10305#else
10306 sign_bits = -1;
10307#endif
10308 else
10309 sign_bits = 0;
10310
10311 /* If we don't know that we have a 64-bit type,
10312 do two separate stores. */
10313 if (bfd_big_endian (input_bfd))
10314 {
10315 /* Undo what we did above. */
10316 rel->r_offset -= 4;
10317 /* Store the sign-bits (which are most significant)
10318 first. */
10319 low_bits = sign_bits;
10320 high_bits = value;
10321 }
10322 else
10323 {
10324 low_bits = value;
10325 high_bits = sign_bits;
10326 }
10327 bfd_put_32 (input_bfd, low_bits,
10328 contents + rel->r_offset);
10329 bfd_put_32 (input_bfd, high_bits,
10330 contents + rel->r_offset + 4);
10331 continue;
10332 }
10333
10334 /* Actually perform the relocation. */
10335 if (! mips_elf_perform_relocation (info, howto, rel, value,
10336 input_bfd, input_section,
38a7df63 10337 contents, cross_mode_jump_p))
b34976b6 10338 return FALSE;
b49e97c9
TS
10339 }
10340
b34976b6 10341 return TRUE;
b49e97c9
TS
10342}
10343\f
861fb55a
DJ
10344/* A function that iterates over each entry in la25_stubs and fills
10345 in the code for each one. DATA points to a mips_htab_traverse_info. */
10346
10347static int
10348mips_elf_create_la25_stub (void **slot, void *data)
10349{
10350 struct mips_htab_traverse_info *hti;
10351 struct mips_elf_link_hash_table *htab;
10352 struct mips_elf_la25_stub *stub;
10353 asection *s;
10354 bfd_byte *loc;
10355 bfd_vma offset, target, target_high, target_low;
10356
10357 stub = (struct mips_elf_la25_stub *) *slot;
10358 hti = (struct mips_htab_traverse_info *) data;
10359 htab = mips_elf_hash_table (hti->info);
4dfe6ac6 10360 BFD_ASSERT (htab != NULL);
861fb55a
DJ
10361
10362 /* Create the section contents, if we haven't already. */
10363 s = stub->stub_section;
10364 loc = s->contents;
10365 if (loc == NULL)
10366 {
10367 loc = bfd_malloc (s->size);
10368 if (loc == NULL)
10369 {
10370 hti->error = TRUE;
10371 return FALSE;
10372 }
10373 s->contents = loc;
10374 }
10375
10376 /* Work out where in the section this stub should go. */
10377 offset = stub->offset;
10378
10379 /* Work out the target address. */
8f0c309a
CLT
10380 target = mips_elf_get_la25_target (stub, &s);
10381 target += s->output_section->vma + s->output_offset;
10382
861fb55a
DJ
10383 target_high = ((target + 0x8000) >> 16) & 0xffff;
10384 target_low = (target & 0xffff);
10385
10386 if (stub->stub_section != htab->strampoline)
10387 {
df58fc94 10388 /* This is a simple LUI/ADDIU stub. Zero out the beginning
861fb55a
DJ
10389 of the section and write the two instructions at the end. */
10390 memset (loc, 0, offset);
10391 loc += offset;
df58fc94
RS
10392 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
10393 {
d21911ea
MR
10394 bfd_put_micromips_32 (hti->output_bfd,
10395 LA25_LUI_MICROMIPS (target_high),
10396 loc);
10397 bfd_put_micromips_32 (hti->output_bfd,
10398 LA25_ADDIU_MICROMIPS (target_low),
10399 loc + 4);
df58fc94
RS
10400 }
10401 else
10402 {
10403 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
10404 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
10405 }
861fb55a
DJ
10406 }
10407 else
10408 {
10409 /* This is trampoline. */
10410 loc += offset;
df58fc94
RS
10411 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
10412 {
d21911ea
MR
10413 bfd_put_micromips_32 (hti->output_bfd,
10414 LA25_LUI_MICROMIPS (target_high), loc);
10415 bfd_put_micromips_32 (hti->output_bfd,
10416 LA25_J_MICROMIPS (target), loc + 4);
10417 bfd_put_micromips_32 (hti->output_bfd,
10418 LA25_ADDIU_MICROMIPS (target_low), loc + 8);
df58fc94
RS
10419 bfd_put_32 (hti->output_bfd, 0, loc + 12);
10420 }
10421 else
10422 {
10423 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
10424 bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
10425 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
10426 bfd_put_32 (hti->output_bfd, 0, loc + 12);
10427 }
861fb55a
DJ
10428 }
10429 return TRUE;
10430}
10431
b49e97c9
TS
10432/* If NAME is one of the special IRIX6 symbols defined by the linker,
10433 adjust it appropriately now. */
10434
10435static void
9719ad41
RS
10436mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
10437 const char *name, Elf_Internal_Sym *sym)
b49e97c9
TS
10438{
10439 /* The linker script takes care of providing names and values for
10440 these, but we must place them into the right sections. */
10441 static const char* const text_section_symbols[] = {
10442 "_ftext",
10443 "_etext",
10444 "__dso_displacement",
10445 "__elf_header",
10446 "__program_header_table",
10447 NULL
10448 };
10449
10450 static const char* const data_section_symbols[] = {
10451 "_fdata",
10452 "_edata",
10453 "_end",
10454 "_fbss",
10455 NULL
10456 };
10457
10458 const char* const *p;
10459 int i;
10460
10461 for (i = 0; i < 2; ++i)
10462 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
10463 *p;
10464 ++p)
10465 if (strcmp (*p, name) == 0)
10466 {
10467 /* All of these symbols are given type STT_SECTION by the
10468 IRIX6 linker. */
10469 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
e10609d3 10470 sym->st_other = STO_PROTECTED;
b49e97c9
TS
10471
10472 /* The IRIX linker puts these symbols in special sections. */
10473 if (i == 0)
10474 sym->st_shndx = SHN_MIPS_TEXT;
10475 else
10476 sym->st_shndx = SHN_MIPS_DATA;
10477
10478 break;
10479 }
10480}
10481
10482/* Finish up dynamic symbol handling. We set the contents of various
10483 dynamic sections here. */
10484
b34976b6 10485bfd_boolean
9719ad41
RS
10486_bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
10487 struct bfd_link_info *info,
10488 struct elf_link_hash_entry *h,
10489 Elf_Internal_Sym *sym)
b49e97c9
TS
10490{
10491 bfd *dynobj;
b49e97c9 10492 asection *sgot;
f4416af6 10493 struct mips_got_info *g, *gg;
b49e97c9 10494 const char *name;
3d6746ca 10495 int idx;
5108fc1b 10496 struct mips_elf_link_hash_table *htab;
738e5348 10497 struct mips_elf_link_hash_entry *hmips;
b49e97c9 10498
5108fc1b 10499 htab = mips_elf_hash_table (info);
4dfe6ac6 10500 BFD_ASSERT (htab != NULL);
b49e97c9 10501 dynobj = elf_hash_table (info)->dynobj;
738e5348 10502 hmips = (struct mips_elf_link_hash_entry *) h;
b49e97c9 10503
861fb55a
DJ
10504 BFD_ASSERT (!htab->is_vxworks);
10505
1bbce132
MR
10506 if (h->plt.plist != NULL
10507 && (h->plt.plist->mips_offset != MINUS_ONE
10508 || h->plt.plist->comp_offset != MINUS_ONE))
861fb55a
DJ
10509 {
10510 /* We've decided to create a PLT entry for this symbol. */
10511 bfd_byte *loc;
1bbce132 10512 bfd_vma header_address, got_address;
861fb55a 10513 bfd_vma got_address_high, got_address_low, load;
1bbce132
MR
10514 bfd_vma got_index;
10515 bfd_vma isa_bit;
10516
10517 got_index = h->plt.plist->gotplt_index;
861fb55a
DJ
10518
10519 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10520 BFD_ASSERT (h->dynindx != -1);
10521 BFD_ASSERT (htab->splt != NULL);
1bbce132 10522 BFD_ASSERT (got_index != MINUS_ONE);
861fb55a
DJ
10523 BFD_ASSERT (!h->def_regular);
10524
10525 /* Calculate the address of the PLT header. */
1bbce132 10526 isa_bit = htab->plt_header_is_comp;
861fb55a 10527 header_address = (htab->splt->output_section->vma
1bbce132 10528 + htab->splt->output_offset + isa_bit);
861fb55a
DJ
10529
10530 /* Calculate the address of the .got.plt entry. */
10531 got_address = (htab->sgotplt->output_section->vma
10532 + htab->sgotplt->output_offset
1bbce132
MR
10533 + got_index * MIPS_ELF_GOT_SIZE (dynobj));
10534
861fb55a
DJ
10535 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
10536 got_address_low = got_address & 0xffff;
10537
10538 /* Initially point the .got.plt entry at the PLT header. */
1bbce132 10539 loc = (htab->sgotplt->contents + got_index * MIPS_ELF_GOT_SIZE (dynobj));
861fb55a
DJ
10540 if (ABI_64_P (output_bfd))
10541 bfd_put_64 (output_bfd, header_address, loc);
10542 else
10543 bfd_put_32 (output_bfd, header_address, loc);
10544
1bbce132
MR
10545 /* Now handle the PLT itself. First the standard entry (the order
10546 does not matter, we just have to pick one). */
10547 if (h->plt.plist->mips_offset != MINUS_ONE)
10548 {
10549 const bfd_vma *plt_entry;
10550 bfd_vma plt_offset;
861fb55a 10551
1bbce132 10552 plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
861fb55a 10553
1bbce132 10554 BFD_ASSERT (plt_offset <= htab->splt->size);
6d30f5b2 10555
1bbce132
MR
10556 /* Find out where the .plt entry should go. */
10557 loc = htab->splt->contents + plt_offset;
10558
10559 /* Pick the load opcode. */
10560 load = MIPS_ELF_LOAD_WORD (output_bfd);
10561
10562 /* Fill in the PLT entry itself. */
7361da2c
AB
10563
10564 if (MIPSR6_P (output_bfd))
10565 plt_entry = mipsr6_exec_plt_entry;
10566 else
10567 plt_entry = mips_exec_plt_entry;
1bbce132
MR
10568 bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
10569 bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load,
10570 loc + 4);
10571
10572 if (! LOAD_INTERLOCKS_P (output_bfd))
10573 {
10574 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
10575 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10576 }
10577 else
10578 {
10579 bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
10580 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low,
10581 loc + 12);
10582 }
6d30f5b2 10583 }
1bbce132
MR
10584
10585 /* Now the compressed entry. They come after any standard ones. */
10586 if (h->plt.plist->comp_offset != MINUS_ONE)
6d30f5b2 10587 {
1bbce132
MR
10588 bfd_vma plt_offset;
10589
10590 plt_offset = (htab->plt_header_size + htab->plt_mips_offset
10591 + h->plt.plist->comp_offset);
10592
10593 BFD_ASSERT (plt_offset <= htab->splt->size);
10594
10595 /* Find out where the .plt entry should go. */
10596 loc = htab->splt->contents + plt_offset;
10597
10598 /* Fill in the PLT entry itself. */
833794fc
MR
10599 if (!MICROMIPS_P (output_bfd))
10600 {
10601 const bfd_vma *plt_entry = mips16_o32_exec_plt_entry;
10602
10603 bfd_put_16 (output_bfd, plt_entry[0], loc);
10604 bfd_put_16 (output_bfd, plt_entry[1], loc + 2);
10605 bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10606 bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
10607 bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10608 bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10609 bfd_put_32 (output_bfd, got_address, loc + 12);
10610 }
10611 else if (htab->insn32)
10612 {
10613 const bfd_vma *plt_entry = micromips_insn32_o32_exec_plt_entry;
10614
10615 bfd_put_16 (output_bfd, plt_entry[0], loc);
10616 bfd_put_16 (output_bfd, got_address_high, loc + 2);
10617 bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10618 bfd_put_16 (output_bfd, got_address_low, loc + 6);
10619 bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10620 bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10621 bfd_put_16 (output_bfd, plt_entry[6], loc + 12);
10622 bfd_put_16 (output_bfd, got_address_low, loc + 14);
10623 }
10624 else
1bbce132
MR
10625 {
10626 const bfd_vma *plt_entry = micromips_o32_exec_plt_entry;
10627 bfd_signed_vma gotpc_offset;
10628 bfd_vma loc_address;
10629
10630 BFD_ASSERT (got_address % 4 == 0);
10631
10632 loc_address = (htab->splt->output_section->vma
10633 + htab->splt->output_offset + plt_offset);
10634 gotpc_offset = got_address - ((loc_address | 3) ^ 3);
10635
10636 /* ADDIUPC has a span of +/-16MB, check we're in range. */
10637 if (gotpc_offset + 0x1000000 >= 0x2000000)
10638 {
10639 (*_bfd_error_handler)
10640 (_("%B: `%A' offset of %ld from `%A' "
10641 "beyond the range of ADDIUPC"),
10642 output_bfd,
10643 htab->sgotplt->output_section,
10644 htab->splt->output_section,
10645 (long) gotpc_offset);
10646 bfd_set_error (bfd_error_no_error);
10647 return FALSE;
10648 }
10649 bfd_put_16 (output_bfd,
10650 plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
10651 bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
10652 bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10653 bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
10654 bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10655 bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10656 }
6d30f5b2 10657 }
861fb55a
DJ
10658
10659 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
10660 mips_elf_output_dynamic_relocation (output_bfd, htab->srelplt,
1bbce132 10661 got_index - 2, h->dynindx,
861fb55a
DJ
10662 R_MIPS_JUMP_SLOT, got_address);
10663
10664 /* We distinguish between PLT entries and lazy-binding stubs by
10665 giving the former an st_other value of STO_MIPS_PLT. Set the
10666 flag and leave the value if there are any relocations in the
10667 binary where pointer equality matters. */
10668 sym->st_shndx = SHN_UNDEF;
10669 if (h->pointer_equality_needed)
1bbce132 10670 sym->st_other = ELF_ST_SET_MIPS_PLT (sym->st_other);
861fb55a 10671 else
1bbce132
MR
10672 {
10673 sym->st_value = 0;
10674 sym->st_other = 0;
10675 }
861fb55a 10676 }
1bbce132
MR
10677
10678 if (h->plt.plist != NULL && h->plt.plist->stub_offset != MINUS_ONE)
b49e97c9 10679 {
861fb55a 10680 /* We've decided to create a lazy-binding stub. */
1bbce132
MR
10681 bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
10682 unsigned int other = micromips_p ? STO_MICROMIPS : 0;
10683 bfd_vma stub_size = htab->function_stub_size;
5108fc1b 10684 bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
1bbce132
MR
10685 bfd_vma isa_bit = micromips_p;
10686 bfd_vma stub_big_size;
10687
833794fc 10688 if (!micromips_p)
1bbce132 10689 stub_big_size = MIPS_FUNCTION_STUB_BIG_SIZE;
833794fc
MR
10690 else if (htab->insn32)
10691 stub_big_size = MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE;
10692 else
10693 stub_big_size = MICROMIPS_FUNCTION_STUB_BIG_SIZE;
b49e97c9
TS
10694
10695 /* This symbol has a stub. Set it up. */
10696
10697 BFD_ASSERT (h->dynindx != -1);
10698
1bbce132 10699 BFD_ASSERT (stub_size == stub_big_size || h->dynindx <= 0xffff);
3d6746ca
DD
10700
10701 /* Values up to 2^31 - 1 are allowed. Larger values would cause
5108fc1b
RS
10702 sign extension at runtime in the stub, resulting in a negative
10703 index value. */
10704 if (h->dynindx & ~0x7fffffff)
b34976b6 10705 return FALSE;
b49e97c9
TS
10706
10707 /* Fill the stub. */
1bbce132
MR
10708 if (micromips_p)
10709 {
10710 idx = 0;
10711 bfd_put_micromips_32 (output_bfd, STUB_LW_MICROMIPS (output_bfd),
10712 stub + idx);
10713 idx += 4;
833794fc
MR
10714 if (htab->insn32)
10715 {
10716 bfd_put_micromips_32 (output_bfd,
10717 STUB_MOVE32_MICROMIPS (output_bfd),
10718 stub + idx);
10719 idx += 4;
10720 }
10721 else
10722 {
10723 bfd_put_16 (output_bfd, STUB_MOVE_MICROMIPS, stub + idx);
10724 idx += 2;
10725 }
1bbce132
MR
10726 if (stub_size == stub_big_size)
10727 {
10728 long dynindx_hi = (h->dynindx >> 16) & 0x7fff;
10729
10730 bfd_put_micromips_32 (output_bfd,
10731 STUB_LUI_MICROMIPS (dynindx_hi),
10732 stub + idx);
10733 idx += 4;
10734 }
833794fc
MR
10735 if (htab->insn32)
10736 {
10737 bfd_put_micromips_32 (output_bfd, STUB_JALR32_MICROMIPS,
10738 stub + idx);
10739 idx += 4;
10740 }
10741 else
10742 {
10743 bfd_put_16 (output_bfd, STUB_JALR_MICROMIPS, stub + idx);
10744 idx += 2;
10745 }
1bbce132
MR
10746
10747 /* If a large stub is not required and sign extension is not a
10748 problem, then use legacy code in the stub. */
10749 if (stub_size == stub_big_size)
10750 bfd_put_micromips_32 (output_bfd,
10751 STUB_ORI_MICROMIPS (h->dynindx & 0xffff),
10752 stub + idx);
10753 else if (h->dynindx & ~0x7fff)
10754 bfd_put_micromips_32 (output_bfd,
10755 STUB_LI16U_MICROMIPS (h->dynindx & 0xffff),
10756 stub + idx);
10757 else
10758 bfd_put_micromips_32 (output_bfd,
10759 STUB_LI16S_MICROMIPS (output_bfd,
10760 h->dynindx),
10761 stub + idx);
10762 }
3d6746ca 10763 else
1bbce132
MR
10764 {
10765 idx = 0;
10766 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
10767 idx += 4;
10768 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx);
10769 idx += 4;
10770 if (stub_size == stub_big_size)
10771 {
10772 bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
10773 stub + idx);
10774 idx += 4;
10775 }
10776 bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
10777 idx += 4;
10778
10779 /* If a large stub is not required and sign extension is not a
10780 problem, then use legacy code in the stub. */
10781 if (stub_size == stub_big_size)
10782 bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff),
10783 stub + idx);
10784 else if (h->dynindx & ~0x7fff)
10785 bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff),
10786 stub + idx);
10787 else
10788 bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
10789 stub + idx);
10790 }
5108fc1b 10791
1bbce132
MR
10792 BFD_ASSERT (h->plt.plist->stub_offset <= htab->sstubs->size);
10793 memcpy (htab->sstubs->contents + h->plt.plist->stub_offset,
10794 stub, stub_size);
b49e97c9 10795
1bbce132 10796 /* Mark the symbol as undefined. stub_offset != -1 occurs
b49e97c9
TS
10797 only for the referenced symbol. */
10798 sym->st_shndx = SHN_UNDEF;
10799
10800 /* The run-time linker uses the st_value field of the symbol
10801 to reset the global offset table entry for this external
10802 to its stub address when unlinking a shared object. */
4e41d0d7
RS
10803 sym->st_value = (htab->sstubs->output_section->vma
10804 + htab->sstubs->output_offset
1bbce132
MR
10805 + h->plt.plist->stub_offset
10806 + isa_bit);
10807 sym->st_other = other;
b49e97c9
TS
10808 }
10809
738e5348
RS
10810 /* If we have a MIPS16 function with a stub, the dynamic symbol must
10811 refer to the stub, since only the stub uses the standard calling
10812 conventions. */
10813 if (h->dynindx != -1 && hmips->fn_stub != NULL)
10814 {
10815 BFD_ASSERT (hmips->need_fn_stub);
10816 sym->st_value = (hmips->fn_stub->output_section->vma
10817 + hmips->fn_stub->output_offset);
10818 sym->st_size = hmips->fn_stub->size;
10819 sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
10820 }
10821
b49e97c9 10822 BFD_ASSERT (h->dynindx != -1
f5385ebf 10823 || h->forced_local);
b49e97c9 10824
23cc69b6 10825 sgot = htab->sgot;
a8028dd0 10826 g = htab->got_info;
b49e97c9
TS
10827 BFD_ASSERT (g != NULL);
10828
10829 /* Run through the global symbol table, creating GOT entries for all
10830 the symbols that need them. */
020d7251 10831 if (hmips->global_got_area != GGA_NONE)
b49e97c9
TS
10832 {
10833 bfd_vma offset;
10834 bfd_vma value;
10835
6eaa6adc 10836 value = sym->st_value;
13fbec83 10837 offset = mips_elf_primary_global_got_index (output_bfd, info, h);
b49e97c9
TS
10838 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
10839 }
10840
e641e783 10841 if (hmips->global_got_area != GGA_NONE && g->next)
f4416af6
AO
10842 {
10843 struct mips_got_entry e, *p;
0626d451 10844 bfd_vma entry;
f4416af6 10845 bfd_vma offset;
f4416af6
AO
10846
10847 gg = g;
10848
10849 e.abfd = output_bfd;
10850 e.symndx = -1;
738e5348 10851 e.d.h = hmips;
9ab066b4 10852 e.tls_type = GOT_TLS_NONE;
143d77c5 10853
f4416af6
AO
10854 for (g = g->next; g->next != gg; g = g->next)
10855 {
10856 if (g->got_entries
10857 && (p = (struct mips_got_entry *) htab_find (g->got_entries,
10858 &e)))
10859 {
10860 offset = p->gotidx;
6c42ddb9 10861 BFD_ASSERT (offset > 0 && offset < htab->sgot->size);
0626d451
RS
10862 if (info->shared
10863 || (elf_hash_table (info)->dynamic_sections_created
10864 && p->d.h != NULL
f5385ebf
AM
10865 && p->d.h->root.def_dynamic
10866 && !p->d.h->root.def_regular))
0626d451
RS
10867 {
10868 /* Create an R_MIPS_REL32 relocation for this entry. Due to
10869 the various compatibility problems, it's easier to mock
10870 up an R_MIPS_32 or R_MIPS_64 relocation and leave
10871 mips_elf_create_dynamic_relocation to calculate the
10872 appropriate addend. */
10873 Elf_Internal_Rela rel[3];
10874
10875 memset (rel, 0, sizeof (rel));
10876 if (ABI_64_P (output_bfd))
10877 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
10878 else
10879 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
10880 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
10881
10882 entry = 0;
10883 if (! (mips_elf_create_dynamic_relocation
10884 (output_bfd, info, rel,
10885 e.d.h, NULL, sym->st_value, &entry, sgot)))
10886 return FALSE;
10887 }
10888 else
10889 entry = sym->st_value;
10890 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
f4416af6
AO
10891 }
10892 }
10893 }
10894
b49e97c9
TS
10895 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
10896 name = h->root.root.string;
9637f6ef 10897 if (h == elf_hash_table (info)->hdynamic
22edb2f1 10898 || h == elf_hash_table (info)->hgot)
b49e97c9
TS
10899 sym->st_shndx = SHN_ABS;
10900 else if (strcmp (name, "_DYNAMIC_LINK") == 0
10901 || strcmp (name, "_DYNAMIC_LINKING") == 0)
10902 {
10903 sym->st_shndx = SHN_ABS;
10904 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10905 sym->st_value = 1;
10906 }
4a14403c 10907 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
b49e97c9
TS
10908 {
10909 sym->st_shndx = SHN_ABS;
10910 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10911 sym->st_value = elf_gp (output_bfd);
10912 }
10913 else if (SGI_COMPAT (output_bfd))
10914 {
10915 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
10916 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
10917 {
10918 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10919 sym->st_other = STO_PROTECTED;
10920 sym->st_value = 0;
10921 sym->st_shndx = SHN_MIPS_DATA;
10922 }
10923 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
10924 {
10925 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10926 sym->st_other = STO_PROTECTED;
10927 sym->st_value = mips_elf_hash_table (info)->procedure_count;
10928 sym->st_shndx = SHN_ABS;
10929 }
10930 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
10931 {
10932 if (h->type == STT_FUNC)
10933 sym->st_shndx = SHN_MIPS_TEXT;
10934 else if (h->type == STT_OBJECT)
10935 sym->st_shndx = SHN_MIPS_DATA;
10936 }
10937 }
10938
861fb55a
DJ
10939 /* Emit a copy reloc, if needed. */
10940 if (h->needs_copy)
10941 {
10942 asection *s;
10943 bfd_vma symval;
10944
10945 BFD_ASSERT (h->dynindx != -1);
10946 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10947
10948 s = mips_elf_rel_dyn_section (info, FALSE);
10949 symval = (h->root.u.def.section->output_section->vma
10950 + h->root.u.def.section->output_offset
10951 + h->root.u.def.value);
10952 mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
10953 h->dynindx, R_MIPS_COPY, symval);
10954 }
10955
b49e97c9
TS
10956 /* Handle the IRIX6-specific symbols. */
10957 if (IRIX_COMPAT (output_bfd) == ict_irix6)
10958 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
10959
cbf8d970
MR
10960 /* Keep dynamic compressed symbols odd. This allows the dynamic linker
10961 to treat compressed symbols like any other. */
30c09090 10962 if (ELF_ST_IS_MIPS16 (sym->st_other))
738e5348
RS
10963 {
10964 BFD_ASSERT (sym->st_value & 1);
10965 sym->st_other -= STO_MIPS16;
10966 }
cbf8d970
MR
10967 else if (ELF_ST_IS_MICROMIPS (sym->st_other))
10968 {
10969 BFD_ASSERT (sym->st_value & 1);
10970 sym->st_other -= STO_MICROMIPS;
10971 }
b49e97c9 10972
b34976b6 10973 return TRUE;
b49e97c9
TS
10974}
10975
0a44bf69
RS
10976/* Likewise, for VxWorks. */
10977
10978bfd_boolean
10979_bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
10980 struct bfd_link_info *info,
10981 struct elf_link_hash_entry *h,
10982 Elf_Internal_Sym *sym)
10983{
10984 bfd *dynobj;
10985 asection *sgot;
10986 struct mips_got_info *g;
10987 struct mips_elf_link_hash_table *htab;
020d7251 10988 struct mips_elf_link_hash_entry *hmips;
0a44bf69
RS
10989
10990 htab = mips_elf_hash_table (info);
4dfe6ac6 10991 BFD_ASSERT (htab != NULL);
0a44bf69 10992 dynobj = elf_hash_table (info)->dynobj;
020d7251 10993 hmips = (struct mips_elf_link_hash_entry *) h;
0a44bf69 10994
1bbce132 10995 if (h->plt.plist != NULL && h->plt.plist->mips_offset != MINUS_ONE)
0a44bf69 10996 {
6d79d2ed 10997 bfd_byte *loc;
1bbce132 10998 bfd_vma plt_address, got_address, got_offset, branch_offset;
0a44bf69
RS
10999 Elf_Internal_Rela rel;
11000 static const bfd_vma *plt_entry;
1bbce132
MR
11001 bfd_vma gotplt_index;
11002 bfd_vma plt_offset;
11003
11004 plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
11005 gotplt_index = h->plt.plist->gotplt_index;
0a44bf69
RS
11006
11007 BFD_ASSERT (h->dynindx != -1);
11008 BFD_ASSERT (htab->splt != NULL);
1bbce132
MR
11009 BFD_ASSERT (gotplt_index != MINUS_ONE);
11010 BFD_ASSERT (plt_offset <= htab->splt->size);
0a44bf69
RS
11011
11012 /* Calculate the address of the .plt entry. */
11013 plt_address = (htab->splt->output_section->vma
11014 + htab->splt->output_offset
1bbce132 11015 + plt_offset);
0a44bf69
RS
11016
11017 /* Calculate the address of the .got.plt entry. */
11018 got_address = (htab->sgotplt->output_section->vma
11019 + htab->sgotplt->output_offset
1bbce132 11020 + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd));
0a44bf69
RS
11021
11022 /* Calculate the offset of the .got.plt entry from
11023 _GLOBAL_OFFSET_TABLE_. */
11024 got_offset = mips_elf_gotplt_index (info, h);
11025
11026 /* Calculate the offset for the branch at the start of the PLT
11027 entry. The branch jumps to the beginning of .plt. */
1bbce132 11028 branch_offset = -(plt_offset / 4 + 1) & 0xffff;
0a44bf69
RS
11029
11030 /* Fill in the initial value of the .got.plt entry. */
11031 bfd_put_32 (output_bfd, plt_address,
1bbce132
MR
11032 (htab->sgotplt->contents
11033 + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd)));
0a44bf69
RS
11034
11035 /* Find out where the .plt entry should go. */
1bbce132 11036 loc = htab->splt->contents + plt_offset;
0a44bf69
RS
11037
11038 if (info->shared)
11039 {
11040 plt_entry = mips_vxworks_shared_plt_entry;
11041 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
1bbce132 11042 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
0a44bf69
RS
11043 }
11044 else
11045 {
11046 bfd_vma got_address_high, got_address_low;
11047
11048 plt_entry = mips_vxworks_exec_plt_entry;
11049 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
11050 got_address_low = got_address & 0xffff;
11051
11052 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
1bbce132 11053 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
0a44bf69
RS
11054 bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
11055 bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
11056 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11057 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11058 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
11059 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
11060
11061 loc = (htab->srelplt2->contents
1bbce132 11062 + (gotplt_index * 3 + 2) * sizeof (Elf32_External_Rela));
0a44bf69
RS
11063
11064 /* Emit a relocation for the .got.plt entry. */
11065 rel.r_offset = got_address;
11066 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
1bbce132 11067 rel.r_addend = plt_offset;
0a44bf69
RS
11068 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11069
11070 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
11071 loc += sizeof (Elf32_External_Rela);
11072 rel.r_offset = plt_address + 8;
11073 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11074 rel.r_addend = got_offset;
11075 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11076
11077 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
11078 loc += sizeof (Elf32_External_Rela);
11079 rel.r_offset += 4;
11080 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11081 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11082 }
11083
11084 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
1bbce132
MR
11085 loc = (htab->srelplt->contents
11086 + gotplt_index * sizeof (Elf32_External_Rela));
0a44bf69
RS
11087 rel.r_offset = got_address;
11088 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
11089 rel.r_addend = 0;
11090 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11091
11092 if (!h->def_regular)
11093 sym->st_shndx = SHN_UNDEF;
11094 }
11095
11096 BFD_ASSERT (h->dynindx != -1 || h->forced_local);
11097
23cc69b6 11098 sgot = htab->sgot;
a8028dd0 11099 g = htab->got_info;
0a44bf69
RS
11100 BFD_ASSERT (g != NULL);
11101
11102 /* See if this symbol has an entry in the GOT. */
020d7251 11103 if (hmips->global_got_area != GGA_NONE)
0a44bf69
RS
11104 {
11105 bfd_vma offset;
11106 Elf_Internal_Rela outrel;
11107 bfd_byte *loc;
11108 asection *s;
11109
11110 /* Install the symbol value in the GOT. */
13fbec83 11111 offset = mips_elf_primary_global_got_index (output_bfd, info, h);
0a44bf69
RS
11112 MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
11113
11114 /* Add a dynamic relocation for it. */
11115 s = mips_elf_rel_dyn_section (info, FALSE);
11116 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
11117 outrel.r_offset = (sgot->output_section->vma
11118 + sgot->output_offset
11119 + offset);
11120 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
11121 outrel.r_addend = 0;
11122 bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
11123 }
11124
11125 /* Emit a copy reloc, if needed. */
11126 if (h->needs_copy)
11127 {
11128 Elf_Internal_Rela rel;
11129
11130 BFD_ASSERT (h->dynindx != -1);
11131
11132 rel.r_offset = (h->root.u.def.section->output_section->vma
11133 + h->root.u.def.section->output_offset
11134 + h->root.u.def.value);
11135 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
11136 rel.r_addend = 0;
11137 bfd_elf32_swap_reloca_out (output_bfd, &rel,
11138 htab->srelbss->contents
11139 + (htab->srelbss->reloc_count
11140 * sizeof (Elf32_External_Rela)));
11141 ++htab->srelbss->reloc_count;
11142 }
11143
df58fc94
RS
11144 /* If this is a mips16/microMIPS symbol, force the value to be even. */
11145 if (ELF_ST_IS_COMPRESSED (sym->st_other))
0a44bf69
RS
11146 sym->st_value &= ~1;
11147
11148 return TRUE;
11149}
11150
861fb55a
DJ
11151/* Write out a plt0 entry to the beginning of .plt. */
11152
1bbce132 11153static bfd_boolean
861fb55a
DJ
11154mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
11155{
11156 bfd_byte *loc;
11157 bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
11158 static const bfd_vma *plt_entry;
11159 struct mips_elf_link_hash_table *htab;
11160
11161 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
11162 BFD_ASSERT (htab != NULL);
11163
861fb55a
DJ
11164 if (ABI_64_P (output_bfd))
11165 plt_entry = mips_n64_exec_plt0_entry;
11166 else if (ABI_N32_P (output_bfd))
11167 plt_entry = mips_n32_exec_plt0_entry;
833794fc 11168 else if (!htab->plt_header_is_comp)
861fb55a 11169 plt_entry = mips_o32_exec_plt0_entry;
833794fc
MR
11170 else if (htab->insn32)
11171 plt_entry = micromips_insn32_o32_exec_plt0_entry;
11172 else
11173 plt_entry = micromips_o32_exec_plt0_entry;
861fb55a
DJ
11174
11175 /* Calculate the value of .got.plt. */
11176 gotplt_value = (htab->sgotplt->output_section->vma
11177 + htab->sgotplt->output_offset);
11178 gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
11179 gotplt_value_low = gotplt_value & 0xffff;
11180
11181 /* The PLT sequence is not safe for N64 if .got.plt's address can
11182 not be loaded in two instructions. */
11183 BFD_ASSERT ((gotplt_value & ~(bfd_vma) 0x7fffffff) == 0
11184 || ~(gotplt_value | 0x7fffffff) == 0);
11185
11186 /* Install the PLT header. */
11187 loc = htab->splt->contents;
1bbce132
MR
11188 if (plt_entry == micromips_o32_exec_plt0_entry)
11189 {
11190 bfd_vma gotpc_offset;
11191 bfd_vma loc_address;
11192 size_t i;
11193
11194 BFD_ASSERT (gotplt_value % 4 == 0);
11195
11196 loc_address = (htab->splt->output_section->vma
11197 + htab->splt->output_offset);
11198 gotpc_offset = gotplt_value - ((loc_address | 3) ^ 3);
11199
11200 /* ADDIUPC has a span of +/-16MB, check we're in range. */
11201 if (gotpc_offset + 0x1000000 >= 0x2000000)
11202 {
11203 (*_bfd_error_handler)
11204 (_("%B: `%A' offset of %ld from `%A' beyond the range of ADDIUPC"),
11205 output_bfd,
11206 htab->sgotplt->output_section,
11207 htab->splt->output_section,
11208 (long) gotpc_offset);
11209 bfd_set_error (bfd_error_no_error);
11210 return FALSE;
11211 }
11212 bfd_put_16 (output_bfd,
11213 plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
11214 bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
11215 for (i = 2; i < ARRAY_SIZE (micromips_o32_exec_plt0_entry); i++)
11216 bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
11217 }
833794fc
MR
11218 else if (plt_entry == micromips_insn32_o32_exec_plt0_entry)
11219 {
11220 size_t i;
11221
11222 bfd_put_16 (output_bfd, plt_entry[0], loc);
11223 bfd_put_16 (output_bfd, gotplt_value_high, loc + 2);
11224 bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
11225 bfd_put_16 (output_bfd, gotplt_value_low, loc + 6);
11226 bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
11227 bfd_put_16 (output_bfd, gotplt_value_low, loc + 10);
11228 for (i = 6; i < ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry); i++)
11229 bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
11230 }
1bbce132
MR
11231 else
11232 {
11233 bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
11234 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
11235 bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
11236 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
11237 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11238 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11239 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
11240 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
11241 }
11242
11243 return TRUE;
861fb55a
DJ
11244}
11245
0a44bf69
RS
11246/* Install the PLT header for a VxWorks executable and finalize the
11247 contents of .rela.plt.unloaded. */
11248
11249static void
11250mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
11251{
11252 Elf_Internal_Rela rela;
11253 bfd_byte *loc;
11254 bfd_vma got_value, got_value_high, got_value_low, plt_address;
11255 static const bfd_vma *plt_entry;
11256 struct mips_elf_link_hash_table *htab;
11257
11258 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
11259 BFD_ASSERT (htab != NULL);
11260
0a44bf69
RS
11261 plt_entry = mips_vxworks_exec_plt0_entry;
11262
11263 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
11264 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
11265 + htab->root.hgot->root.u.def.section->output_offset
11266 + htab->root.hgot->root.u.def.value);
11267
11268 got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
11269 got_value_low = got_value & 0xffff;
11270
11271 /* Calculate the address of the PLT header. */
11272 plt_address = htab->splt->output_section->vma + htab->splt->output_offset;
11273
11274 /* Install the PLT header. */
11275 loc = htab->splt->contents;
11276 bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
11277 bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
11278 bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
11279 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
11280 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11281 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11282
11283 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
11284 loc = htab->srelplt2->contents;
11285 rela.r_offset = plt_address;
11286 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11287 rela.r_addend = 0;
11288 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
11289 loc += sizeof (Elf32_External_Rela);
11290
11291 /* Output the relocation for the following addiu of
11292 %lo(_GLOBAL_OFFSET_TABLE_). */
11293 rela.r_offset += 4;
11294 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11295 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
11296 loc += sizeof (Elf32_External_Rela);
11297
11298 /* Fix up the remaining relocations. They may have the wrong
11299 symbol index for _G_O_T_ or _P_L_T_ depending on the order
11300 in which symbols were output. */
11301 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
11302 {
11303 Elf_Internal_Rela rel;
11304
11305 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11306 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
11307 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11308 loc += sizeof (Elf32_External_Rela);
11309
11310 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11311 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11312 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11313 loc += sizeof (Elf32_External_Rela);
11314
11315 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11316 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11317 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11318 loc += sizeof (Elf32_External_Rela);
11319 }
11320}
11321
11322/* Install the PLT header for a VxWorks shared library. */
11323
11324static void
11325mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
11326{
11327 unsigned int i;
11328 struct mips_elf_link_hash_table *htab;
11329
11330 htab = mips_elf_hash_table (info);
4dfe6ac6 11331 BFD_ASSERT (htab != NULL);
0a44bf69
RS
11332
11333 /* We just need to copy the entry byte-by-byte. */
11334 for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
11335 bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
11336 htab->splt->contents + i * 4);
11337}
11338
b49e97c9
TS
11339/* Finish up the dynamic sections. */
11340
b34976b6 11341bfd_boolean
9719ad41
RS
11342_bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
11343 struct bfd_link_info *info)
b49e97c9
TS
11344{
11345 bfd *dynobj;
11346 asection *sdyn;
11347 asection *sgot;
f4416af6 11348 struct mips_got_info *gg, *g;
0a44bf69 11349 struct mips_elf_link_hash_table *htab;
b49e97c9 11350
0a44bf69 11351 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
11352 BFD_ASSERT (htab != NULL);
11353
b49e97c9
TS
11354 dynobj = elf_hash_table (info)->dynobj;
11355
3d4d4302 11356 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
b49e97c9 11357
23cc69b6
RS
11358 sgot = htab->sgot;
11359 gg = htab->got_info;
b49e97c9
TS
11360
11361 if (elf_hash_table (info)->dynamic_sections_created)
11362 {
11363 bfd_byte *b;
943284cc 11364 int dyn_to_skip = 0, dyn_skipped = 0;
b49e97c9
TS
11365
11366 BFD_ASSERT (sdyn != NULL);
23cc69b6
RS
11367 BFD_ASSERT (gg != NULL);
11368
d7206569 11369 g = mips_elf_bfd_got (output_bfd, FALSE);
b49e97c9
TS
11370 BFD_ASSERT (g != NULL);
11371
11372 for (b = sdyn->contents;
eea6121a 11373 b < sdyn->contents + sdyn->size;
b49e97c9
TS
11374 b += MIPS_ELF_DYN_SIZE (dynobj))
11375 {
11376 Elf_Internal_Dyn dyn;
11377 const char *name;
11378 size_t elemsize;
11379 asection *s;
b34976b6 11380 bfd_boolean swap_out_p;
b49e97c9
TS
11381
11382 /* Read in the current dynamic entry. */
11383 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
11384
11385 /* Assume that we're going to modify it and write it out. */
b34976b6 11386 swap_out_p = TRUE;
b49e97c9
TS
11387
11388 switch (dyn.d_tag)
11389 {
11390 case DT_RELENT:
b49e97c9
TS
11391 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
11392 break;
11393
0a44bf69
RS
11394 case DT_RELAENT:
11395 BFD_ASSERT (htab->is_vxworks);
11396 dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
11397 break;
11398
b49e97c9
TS
11399 case DT_STRSZ:
11400 /* Rewrite DT_STRSZ. */
11401 dyn.d_un.d_val =
11402 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
11403 break;
11404
11405 case DT_PLTGOT:
861fb55a
DJ
11406 s = htab->sgot;
11407 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11408 break;
11409
11410 case DT_MIPS_PLTGOT:
11411 s = htab->sgotplt;
11412 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
b49e97c9
TS
11413 break;
11414
11415 case DT_MIPS_RLD_VERSION:
11416 dyn.d_un.d_val = 1; /* XXX */
11417 break;
11418
11419 case DT_MIPS_FLAGS:
11420 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
11421 break;
11422
b49e97c9 11423 case DT_MIPS_TIME_STAMP:
6edfbbad
DJ
11424 {
11425 time_t t;
11426 time (&t);
11427 dyn.d_un.d_val = t;
11428 }
b49e97c9
TS
11429 break;
11430
11431 case DT_MIPS_ICHECKSUM:
11432 /* XXX FIXME: */
b34976b6 11433 swap_out_p = FALSE;
b49e97c9
TS
11434 break;
11435
11436 case DT_MIPS_IVERSION:
11437 /* XXX FIXME: */
b34976b6 11438 swap_out_p = FALSE;
b49e97c9
TS
11439 break;
11440
11441 case DT_MIPS_BASE_ADDRESS:
11442 s = output_bfd->sections;
11443 BFD_ASSERT (s != NULL);
11444 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
11445 break;
11446
11447 case DT_MIPS_LOCAL_GOTNO:
11448 dyn.d_un.d_val = g->local_gotno;
11449 break;
11450
11451 case DT_MIPS_UNREFEXTNO:
11452 /* The index into the dynamic symbol table which is the
11453 entry of the first external symbol that is not
11454 referenced within the same object. */
11455 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
11456 break;
11457
11458 case DT_MIPS_GOTSYM:
d222d210 11459 if (htab->global_gotsym)
b49e97c9 11460 {
d222d210 11461 dyn.d_un.d_val = htab->global_gotsym->dynindx;
b49e97c9
TS
11462 break;
11463 }
11464 /* In case if we don't have global got symbols we default
11465 to setting DT_MIPS_GOTSYM to the same value as
11466 DT_MIPS_SYMTABNO, so we just fall through. */
11467
11468 case DT_MIPS_SYMTABNO:
11469 name = ".dynsym";
11470 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
11471 s = bfd_get_section_by_name (output_bfd, name);
b49e97c9 11472
131e2f8e
MF
11473 if (s != NULL)
11474 dyn.d_un.d_val = s->size / elemsize;
11475 else
11476 dyn.d_un.d_val = 0;
b49e97c9
TS
11477 break;
11478
11479 case DT_MIPS_HIPAGENO:
861fb55a 11480 dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
b49e97c9
TS
11481 break;
11482
11483 case DT_MIPS_RLD_MAP:
b4082c70
DD
11484 {
11485 struct elf_link_hash_entry *h;
11486 h = mips_elf_hash_table (info)->rld_symbol;
11487 if (!h)
11488 {
11489 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11490 swap_out_p = FALSE;
11491 break;
11492 }
11493 s = h->root.u.def.section;
a5499fa4
MF
11494
11495 /* The MIPS_RLD_MAP tag stores the absolute address of the
11496 debug pointer. */
b4082c70
DD
11497 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
11498 + h->root.u.def.value);
11499 }
b49e97c9
TS
11500 break;
11501
a5499fa4
MF
11502 case DT_MIPS_RLD_MAP_REL:
11503 {
11504 struct elf_link_hash_entry *h;
11505 bfd_vma dt_addr, rld_addr;
11506 h = mips_elf_hash_table (info)->rld_symbol;
11507 if (!h)
11508 {
11509 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11510 swap_out_p = FALSE;
11511 break;
11512 }
11513 s = h->root.u.def.section;
11514
11515 /* The MIPS_RLD_MAP_REL tag stores the offset to the debug
11516 pointer, relative to the address of the tag. */
11517 dt_addr = (sdyn->output_section->vma + sdyn->output_offset
11518 + b - sdyn->contents);
11519 rld_addr = (s->output_section->vma + s->output_offset
11520 + h->root.u.def.value);
11521 dyn.d_un.d_ptr = rld_addr - dt_addr;
11522 }
11523 break;
11524
b49e97c9
TS
11525 case DT_MIPS_OPTIONS:
11526 s = (bfd_get_section_by_name
11527 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
11528 dyn.d_un.d_ptr = s->vma;
11529 break;
11530
0a44bf69
RS
11531 case DT_RELASZ:
11532 BFD_ASSERT (htab->is_vxworks);
11533 /* The count does not include the JUMP_SLOT relocations. */
11534 if (htab->srelplt)
11535 dyn.d_un.d_val -= htab->srelplt->size;
11536 break;
11537
11538 case DT_PLTREL:
861fb55a
DJ
11539 BFD_ASSERT (htab->use_plts_and_copy_relocs);
11540 if (htab->is_vxworks)
11541 dyn.d_un.d_val = DT_RELA;
11542 else
11543 dyn.d_un.d_val = DT_REL;
0a44bf69
RS
11544 break;
11545
11546 case DT_PLTRELSZ:
861fb55a 11547 BFD_ASSERT (htab->use_plts_and_copy_relocs);
0a44bf69
RS
11548 dyn.d_un.d_val = htab->srelplt->size;
11549 break;
11550
11551 case DT_JMPREL:
861fb55a
DJ
11552 BFD_ASSERT (htab->use_plts_and_copy_relocs);
11553 dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
0a44bf69
RS
11554 + htab->srelplt->output_offset);
11555 break;
11556
943284cc
DJ
11557 case DT_TEXTREL:
11558 /* If we didn't need any text relocations after all, delete
11559 the dynamic tag. */
11560 if (!(info->flags & DF_TEXTREL))
11561 {
11562 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11563 swap_out_p = FALSE;
11564 }
11565 break;
11566
11567 case DT_FLAGS:
11568 /* If we didn't need any text relocations after all, clear
11569 DF_TEXTREL from DT_FLAGS. */
11570 if (!(info->flags & DF_TEXTREL))
11571 dyn.d_un.d_val &= ~DF_TEXTREL;
11572 else
11573 swap_out_p = FALSE;
11574 break;
11575
b49e97c9 11576 default:
b34976b6 11577 swap_out_p = FALSE;
7a2b07ff
NS
11578 if (htab->is_vxworks
11579 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
11580 swap_out_p = TRUE;
b49e97c9
TS
11581 break;
11582 }
11583
943284cc 11584 if (swap_out_p || dyn_skipped)
b49e97c9 11585 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
943284cc
DJ
11586 (dynobj, &dyn, b - dyn_skipped);
11587
11588 if (dyn_to_skip)
11589 {
11590 dyn_skipped += dyn_to_skip;
11591 dyn_to_skip = 0;
11592 }
b49e97c9 11593 }
943284cc
DJ
11594
11595 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
11596 if (dyn_skipped > 0)
11597 memset (b - dyn_skipped, 0, dyn_skipped);
b49e97c9
TS
11598 }
11599
b55fd4d4
DJ
11600 if (sgot != NULL && sgot->size > 0
11601 && !bfd_is_abs_section (sgot->output_section))
b49e97c9 11602 {
0a44bf69
RS
11603 if (htab->is_vxworks)
11604 {
11605 /* The first entry of the global offset table points to the
11606 ".dynamic" section. The second is initialized by the
11607 loader and contains the shared library identifier.
11608 The third is also initialized by the loader and points
11609 to the lazy resolution stub. */
11610 MIPS_ELF_PUT_WORD (output_bfd,
11611 sdyn->output_offset + sdyn->output_section->vma,
11612 sgot->contents);
11613 MIPS_ELF_PUT_WORD (output_bfd, 0,
11614 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
11615 MIPS_ELF_PUT_WORD (output_bfd, 0,
11616 sgot->contents
11617 + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
11618 }
11619 else
11620 {
11621 /* The first entry of the global offset table will be filled at
11622 runtime. The second entry will be used by some runtime loaders.
11623 This isn't the case of IRIX rld. */
11624 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
51e38d68 11625 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
0a44bf69
RS
11626 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
11627 }
b49e97c9 11628
54938e2a
TS
11629 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
11630 = MIPS_ELF_GOT_SIZE (output_bfd);
11631 }
b49e97c9 11632
f4416af6
AO
11633 /* Generate dynamic relocations for the non-primary gots. */
11634 if (gg != NULL && gg->next)
11635 {
11636 Elf_Internal_Rela rel[3];
11637 bfd_vma addend = 0;
11638
11639 memset (rel, 0, sizeof (rel));
11640 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
11641
11642 for (g = gg->next; g->next != gg; g = g->next)
11643 {
91d6fa6a 11644 bfd_vma got_index = g->next->local_gotno + g->next->global_gotno
0f20cc35 11645 + g->next->tls_gotno;
f4416af6 11646
9719ad41 11647 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
91d6fa6a 11648 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
51e38d68
RS
11649 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
11650 sgot->contents
91d6fa6a 11651 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
f4416af6
AO
11652
11653 if (! info->shared)
11654 continue;
11655
cb22ccf4 11656 for (; got_index < g->local_gotno; got_index++)
f4416af6 11657 {
cb22ccf4
KCY
11658 if (got_index >= g->assigned_low_gotno
11659 && got_index <= g->assigned_high_gotno)
11660 continue;
11661
f4416af6 11662 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
cb22ccf4 11663 = got_index * MIPS_ELF_GOT_SIZE (output_bfd);
f4416af6
AO
11664 if (!(mips_elf_create_dynamic_relocation
11665 (output_bfd, info, rel, NULL,
11666 bfd_abs_section_ptr,
11667 0, &addend, sgot)))
11668 return FALSE;
11669 BFD_ASSERT (addend == 0);
11670 }
11671 }
11672 }
11673
3133ddbf
DJ
11674 /* The generation of dynamic relocations for the non-primary gots
11675 adds more dynamic relocations. We cannot count them until
11676 here. */
11677
11678 if (elf_hash_table (info)->dynamic_sections_created)
11679 {
11680 bfd_byte *b;
11681 bfd_boolean swap_out_p;
11682
11683 BFD_ASSERT (sdyn != NULL);
11684
11685 for (b = sdyn->contents;
11686 b < sdyn->contents + sdyn->size;
11687 b += MIPS_ELF_DYN_SIZE (dynobj))
11688 {
11689 Elf_Internal_Dyn dyn;
11690 asection *s;
11691
11692 /* Read in the current dynamic entry. */
11693 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
11694
11695 /* Assume that we're going to modify it and write it out. */
11696 swap_out_p = TRUE;
11697
11698 switch (dyn.d_tag)
11699 {
11700 case DT_RELSZ:
11701 /* Reduce DT_RELSZ to account for any relocations we
11702 decided not to make. This is for the n64 irix rld,
11703 which doesn't seem to apply any relocations if there
11704 are trailing null entries. */
0a44bf69 11705 s = mips_elf_rel_dyn_section (info, FALSE);
3133ddbf
DJ
11706 dyn.d_un.d_val = (s->reloc_count
11707 * (ABI_64_P (output_bfd)
11708 ? sizeof (Elf64_Mips_External_Rel)
11709 : sizeof (Elf32_External_Rel)));
bcfdf036
RS
11710 /* Adjust the section size too. Tools like the prelinker
11711 can reasonably expect the values to the same. */
11712 elf_section_data (s->output_section)->this_hdr.sh_size
11713 = dyn.d_un.d_val;
3133ddbf
DJ
11714 break;
11715
11716 default:
11717 swap_out_p = FALSE;
11718 break;
11719 }
11720
11721 if (swap_out_p)
11722 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
11723 (dynobj, &dyn, b);
11724 }
11725 }
11726
b49e97c9 11727 {
b49e97c9
TS
11728 asection *s;
11729 Elf32_compact_rel cpt;
11730
b49e97c9
TS
11731 if (SGI_COMPAT (output_bfd))
11732 {
11733 /* Write .compact_rel section out. */
3d4d4302 11734 s = bfd_get_linker_section (dynobj, ".compact_rel");
b49e97c9
TS
11735 if (s != NULL)
11736 {
11737 cpt.id1 = 1;
11738 cpt.num = s->reloc_count;
11739 cpt.id2 = 2;
11740 cpt.offset = (s->output_section->filepos
11741 + sizeof (Elf32_External_compact_rel));
11742 cpt.reserved0 = 0;
11743 cpt.reserved1 = 0;
11744 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
11745 ((Elf32_External_compact_rel *)
11746 s->contents));
11747
11748 /* Clean up a dummy stub function entry in .text. */
4e41d0d7 11749 if (htab->sstubs != NULL)
b49e97c9
TS
11750 {
11751 file_ptr dummy_offset;
11752
4e41d0d7
RS
11753 BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
11754 dummy_offset = htab->sstubs->size - htab->function_stub_size;
11755 memset (htab->sstubs->contents + dummy_offset, 0,
5108fc1b 11756 htab->function_stub_size);
b49e97c9
TS
11757 }
11758 }
11759 }
11760
0a44bf69
RS
11761 /* The psABI says that the dynamic relocations must be sorted in
11762 increasing order of r_symndx. The VxWorks EABI doesn't require
11763 this, and because the code below handles REL rather than RELA
11764 relocations, using it for VxWorks would be outright harmful. */
11765 if (!htab->is_vxworks)
b49e97c9 11766 {
0a44bf69
RS
11767 s = mips_elf_rel_dyn_section (info, FALSE);
11768 if (s != NULL
11769 && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
11770 {
11771 reldyn_sorting_bfd = output_bfd;
b49e97c9 11772
0a44bf69
RS
11773 if (ABI_64_P (output_bfd))
11774 qsort ((Elf64_External_Rel *) s->contents + 1,
11775 s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
11776 sort_dynamic_relocs_64);
11777 else
11778 qsort ((Elf32_External_Rel *) s->contents + 1,
11779 s->reloc_count - 1, sizeof (Elf32_External_Rel),
11780 sort_dynamic_relocs);
11781 }
b49e97c9 11782 }
b49e97c9
TS
11783 }
11784
861fb55a 11785 if (htab->splt && htab->splt->size > 0)
0a44bf69 11786 {
861fb55a
DJ
11787 if (htab->is_vxworks)
11788 {
11789 if (info->shared)
11790 mips_vxworks_finish_shared_plt (output_bfd, info);
11791 else
11792 mips_vxworks_finish_exec_plt (output_bfd, info);
11793 }
0a44bf69 11794 else
861fb55a
DJ
11795 {
11796 BFD_ASSERT (!info->shared);
1bbce132
MR
11797 if (!mips_finish_exec_plt (output_bfd, info))
11798 return FALSE;
861fb55a 11799 }
0a44bf69 11800 }
b34976b6 11801 return TRUE;
b49e97c9
TS
11802}
11803
b49e97c9 11804
64543e1a
RS
11805/* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
11806
11807static void
9719ad41 11808mips_set_isa_flags (bfd *abfd)
b49e97c9 11809{
64543e1a 11810 flagword val;
b49e97c9
TS
11811
11812 switch (bfd_get_mach (abfd))
11813 {
11814 default:
11815 case bfd_mach_mips3000:
11816 val = E_MIPS_ARCH_1;
11817 break;
11818
11819 case bfd_mach_mips3900:
11820 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
11821 break;
11822
11823 case bfd_mach_mips6000:
11824 val = E_MIPS_ARCH_2;
11825 break;
11826
11827 case bfd_mach_mips4000:
11828 case bfd_mach_mips4300:
11829 case bfd_mach_mips4400:
11830 case bfd_mach_mips4600:
11831 val = E_MIPS_ARCH_3;
11832 break;
11833
11834 case bfd_mach_mips4010:
11835 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
11836 break;
11837
11838 case bfd_mach_mips4100:
11839 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
11840 break;
11841
11842 case bfd_mach_mips4111:
11843 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
11844 break;
11845
00707a0e
RS
11846 case bfd_mach_mips4120:
11847 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
11848 break;
11849
b49e97c9
TS
11850 case bfd_mach_mips4650:
11851 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
11852 break;
11853
00707a0e
RS
11854 case bfd_mach_mips5400:
11855 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
11856 break;
11857
11858 case bfd_mach_mips5500:
11859 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
11860 break;
11861
e407c74b
NC
11862 case bfd_mach_mips5900:
11863 val = E_MIPS_ARCH_3 | E_MIPS_MACH_5900;
11864 break;
11865
0d2e43ed
ILT
11866 case bfd_mach_mips9000:
11867 val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
11868 break;
11869
b49e97c9 11870 case bfd_mach_mips5000:
5a7ea749 11871 case bfd_mach_mips7000:
b49e97c9
TS
11872 case bfd_mach_mips8000:
11873 case bfd_mach_mips10000:
11874 case bfd_mach_mips12000:
3aa3176b
TS
11875 case bfd_mach_mips14000:
11876 case bfd_mach_mips16000:
b49e97c9
TS
11877 val = E_MIPS_ARCH_4;
11878 break;
11879
11880 case bfd_mach_mips5:
11881 val = E_MIPS_ARCH_5;
11882 break;
11883
350cc38d
MS
11884 case bfd_mach_mips_loongson_2e:
11885 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
11886 break;
11887
11888 case bfd_mach_mips_loongson_2f:
11889 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
11890 break;
11891
b49e97c9
TS
11892 case bfd_mach_mips_sb1:
11893 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
11894 break;
11895
d051516a 11896 case bfd_mach_mips_loongson_3a:
4ba154f5 11897 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_LS3A;
d051516a
NC
11898 break;
11899
6f179bd0 11900 case bfd_mach_mips_octeon:
dd6a37e7 11901 case bfd_mach_mips_octeonp:
6f179bd0
AN
11902 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
11903 break;
11904
2c629856
N
11905 case bfd_mach_mips_octeon3:
11906 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON3;
11907 break;
11908
52b6b6b9
JM
11909 case bfd_mach_mips_xlr:
11910 val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
11911 break;
11912
432233b3
AP
11913 case bfd_mach_mips_octeon2:
11914 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON2;
11915 break;
11916
b49e97c9
TS
11917 case bfd_mach_mipsisa32:
11918 val = E_MIPS_ARCH_32;
11919 break;
11920
11921 case bfd_mach_mipsisa64:
11922 val = E_MIPS_ARCH_64;
af7ee8bf
CD
11923 break;
11924
11925 case bfd_mach_mipsisa32r2:
ae52f483
AB
11926 case bfd_mach_mipsisa32r3:
11927 case bfd_mach_mipsisa32r5:
af7ee8bf
CD
11928 val = E_MIPS_ARCH_32R2;
11929 break;
5f74bc13
CD
11930
11931 case bfd_mach_mipsisa64r2:
ae52f483
AB
11932 case bfd_mach_mipsisa64r3:
11933 case bfd_mach_mipsisa64r5:
5f74bc13
CD
11934 val = E_MIPS_ARCH_64R2;
11935 break;
7361da2c
AB
11936
11937 case bfd_mach_mipsisa32r6:
11938 val = E_MIPS_ARCH_32R6;
11939 break;
11940
11941 case bfd_mach_mipsisa64r6:
11942 val = E_MIPS_ARCH_64R6;
11943 break;
b49e97c9 11944 }
b49e97c9
TS
11945 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
11946 elf_elfheader (abfd)->e_flags |= val;
11947
64543e1a
RS
11948}
11949
11950
28dbcedc
AM
11951/* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
11952 Don't do so for code sections. We want to keep ordering of HI16/LO16
11953 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame
11954 relocs to be sorted. */
11955
11956bfd_boolean
11957_bfd_mips_elf_sort_relocs_p (asection *sec)
11958{
11959 return (sec->flags & SEC_CODE) == 0;
11960}
11961
11962
64543e1a
RS
11963/* The final processing done just before writing out a MIPS ELF object
11964 file. This gets the MIPS architecture right based on the machine
11965 number. This is used by both the 32-bit and the 64-bit ABI. */
11966
11967void
9719ad41
RS
11968_bfd_mips_elf_final_write_processing (bfd *abfd,
11969 bfd_boolean linker ATTRIBUTE_UNUSED)
64543e1a
RS
11970{
11971 unsigned int i;
11972 Elf_Internal_Shdr **hdrpp;
11973 const char *name;
11974 asection *sec;
11975
11976 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
11977 is nonzero. This is for compatibility with old objects, which used
11978 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
11979 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
11980 mips_set_isa_flags (abfd);
11981
b49e97c9
TS
11982 /* Set the sh_info field for .gptab sections and other appropriate
11983 info for each special section. */
11984 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
11985 i < elf_numsections (abfd);
11986 i++, hdrpp++)
11987 {
11988 switch ((*hdrpp)->sh_type)
11989 {
11990 case SHT_MIPS_MSYM:
11991 case SHT_MIPS_LIBLIST:
11992 sec = bfd_get_section_by_name (abfd, ".dynstr");
11993 if (sec != NULL)
11994 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11995 break;
11996
11997 case SHT_MIPS_GPTAB:
11998 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11999 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12000 BFD_ASSERT (name != NULL
0112cd26 12001 && CONST_STRNEQ (name, ".gptab."));
b49e97c9
TS
12002 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
12003 BFD_ASSERT (sec != NULL);
12004 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
12005 break;
12006
12007 case SHT_MIPS_CONTENT:
12008 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12009 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12010 BFD_ASSERT (name != NULL
0112cd26 12011 && CONST_STRNEQ (name, ".MIPS.content"));
b49e97c9
TS
12012 sec = bfd_get_section_by_name (abfd,
12013 name + sizeof ".MIPS.content" - 1);
12014 BFD_ASSERT (sec != NULL);
12015 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12016 break;
12017
12018 case SHT_MIPS_SYMBOL_LIB:
12019 sec = bfd_get_section_by_name (abfd, ".dynsym");
12020 if (sec != NULL)
12021 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12022 sec = bfd_get_section_by_name (abfd, ".liblist");
12023 if (sec != NULL)
12024 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
12025 break;
12026
12027 case SHT_MIPS_EVENTS:
12028 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12029 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12030 BFD_ASSERT (name != NULL);
0112cd26 12031 if (CONST_STRNEQ (name, ".MIPS.events"))
b49e97c9
TS
12032 sec = bfd_get_section_by_name (abfd,
12033 name + sizeof ".MIPS.events" - 1);
12034 else
12035 {
0112cd26 12036 BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
b49e97c9
TS
12037 sec = bfd_get_section_by_name (abfd,
12038 (name
12039 + sizeof ".MIPS.post_rel" - 1));
12040 }
12041 BFD_ASSERT (sec != NULL);
12042 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12043 break;
12044
12045 }
12046 }
12047}
12048\f
8dc1a139 12049/* When creating an IRIX5 executable, we need REGINFO and RTPROC
b49e97c9
TS
12050 segments. */
12051
12052int
a6b96beb
AM
12053_bfd_mips_elf_additional_program_headers (bfd *abfd,
12054 struct bfd_link_info *info ATTRIBUTE_UNUSED)
b49e97c9
TS
12055{
12056 asection *s;
12057 int ret = 0;
12058
12059 /* See if we need a PT_MIPS_REGINFO segment. */
12060 s = bfd_get_section_by_name (abfd, ".reginfo");
12061 if (s && (s->flags & SEC_LOAD))
12062 ++ret;
12063
351cdf24
MF
12064 /* See if we need a PT_MIPS_ABIFLAGS segment. */
12065 if (bfd_get_section_by_name (abfd, ".MIPS.abiflags"))
12066 ++ret;
12067
b49e97c9
TS
12068 /* See if we need a PT_MIPS_OPTIONS segment. */
12069 if (IRIX_COMPAT (abfd) == ict_irix6
12070 && bfd_get_section_by_name (abfd,
12071 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
12072 ++ret;
12073
12074 /* See if we need a PT_MIPS_RTPROC segment. */
12075 if (IRIX_COMPAT (abfd) == ict_irix5
12076 && bfd_get_section_by_name (abfd, ".dynamic")
12077 && bfd_get_section_by_name (abfd, ".mdebug"))
12078 ++ret;
12079
98c904a8
RS
12080 /* Allocate a PT_NULL header in dynamic objects. See
12081 _bfd_mips_elf_modify_segment_map for details. */
12082 if (!SGI_COMPAT (abfd)
12083 && bfd_get_section_by_name (abfd, ".dynamic"))
12084 ++ret;
12085
b49e97c9
TS
12086 return ret;
12087}
12088
8dc1a139 12089/* Modify the segment map for an IRIX5 executable. */
b49e97c9 12090
b34976b6 12091bfd_boolean
9719ad41 12092_bfd_mips_elf_modify_segment_map (bfd *abfd,
7c8b76cc 12093 struct bfd_link_info *info)
b49e97c9
TS
12094{
12095 asection *s;
12096 struct elf_segment_map *m, **pm;
12097 bfd_size_type amt;
12098
12099 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
12100 segment. */
12101 s = bfd_get_section_by_name (abfd, ".reginfo");
12102 if (s != NULL && (s->flags & SEC_LOAD) != 0)
12103 {
12bd6957 12104 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
b49e97c9
TS
12105 if (m->p_type == PT_MIPS_REGINFO)
12106 break;
12107 if (m == NULL)
12108 {
12109 amt = sizeof *m;
9719ad41 12110 m = bfd_zalloc (abfd, amt);
b49e97c9 12111 if (m == NULL)
b34976b6 12112 return FALSE;
b49e97c9
TS
12113
12114 m->p_type = PT_MIPS_REGINFO;
12115 m->count = 1;
12116 m->sections[0] = s;
12117
12118 /* We want to put it after the PHDR and INTERP segments. */
12bd6957 12119 pm = &elf_seg_map (abfd);
b49e97c9
TS
12120 while (*pm != NULL
12121 && ((*pm)->p_type == PT_PHDR
12122 || (*pm)->p_type == PT_INTERP))
12123 pm = &(*pm)->next;
12124
12125 m->next = *pm;
12126 *pm = m;
12127 }
12128 }
12129
351cdf24
MF
12130 /* If there is a .MIPS.abiflags section, we need a PT_MIPS_ABIFLAGS
12131 segment. */
12132 s = bfd_get_section_by_name (abfd, ".MIPS.abiflags");
12133 if (s != NULL && (s->flags & SEC_LOAD) != 0)
12134 {
12135 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12136 if (m->p_type == PT_MIPS_ABIFLAGS)
12137 break;
12138 if (m == NULL)
12139 {
12140 amt = sizeof *m;
12141 m = bfd_zalloc (abfd, amt);
12142 if (m == NULL)
12143 return FALSE;
12144
12145 m->p_type = PT_MIPS_ABIFLAGS;
12146 m->count = 1;
12147 m->sections[0] = s;
12148
12149 /* We want to put it after the PHDR and INTERP segments. */
12150 pm = &elf_seg_map (abfd);
12151 while (*pm != NULL
12152 && ((*pm)->p_type == PT_PHDR
12153 || (*pm)->p_type == PT_INTERP))
12154 pm = &(*pm)->next;
12155
12156 m->next = *pm;
12157 *pm = m;
12158 }
12159 }
12160
b49e97c9
TS
12161 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
12162 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
98a8deaf 12163 PT_MIPS_OPTIONS segment immediately following the program header
b49e97c9 12164 table. */
c1fd6598
AO
12165 if (NEWABI_P (abfd)
12166 /* On non-IRIX6 new abi, we'll have already created a segment
12167 for this section, so don't create another. I'm not sure this
12168 is not also the case for IRIX 6, but I can't test it right
12169 now. */
12170 && IRIX_COMPAT (abfd) == ict_irix6)
b49e97c9
TS
12171 {
12172 for (s = abfd->sections; s; s = s->next)
12173 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
12174 break;
12175
12176 if (s)
12177 {
12178 struct elf_segment_map *options_segment;
12179
12bd6957 12180 pm = &elf_seg_map (abfd);
98a8deaf
RS
12181 while (*pm != NULL
12182 && ((*pm)->p_type == PT_PHDR
12183 || (*pm)->p_type == PT_INTERP))
12184 pm = &(*pm)->next;
b49e97c9 12185
8ded5a0f
AM
12186 if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
12187 {
12188 amt = sizeof (struct elf_segment_map);
12189 options_segment = bfd_zalloc (abfd, amt);
12190 options_segment->next = *pm;
12191 options_segment->p_type = PT_MIPS_OPTIONS;
12192 options_segment->p_flags = PF_R;
12193 options_segment->p_flags_valid = TRUE;
12194 options_segment->count = 1;
12195 options_segment->sections[0] = s;
12196 *pm = options_segment;
12197 }
b49e97c9
TS
12198 }
12199 }
12200 else
12201 {
12202 if (IRIX_COMPAT (abfd) == ict_irix5)
12203 {
12204 /* If there are .dynamic and .mdebug sections, we make a room
12205 for the RTPROC header. FIXME: Rewrite without section names. */
12206 if (bfd_get_section_by_name (abfd, ".interp") == NULL
12207 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
12208 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
12209 {
12bd6957 12210 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
b49e97c9
TS
12211 if (m->p_type == PT_MIPS_RTPROC)
12212 break;
12213 if (m == NULL)
12214 {
12215 amt = sizeof *m;
9719ad41 12216 m = bfd_zalloc (abfd, amt);
b49e97c9 12217 if (m == NULL)
b34976b6 12218 return FALSE;
b49e97c9
TS
12219
12220 m->p_type = PT_MIPS_RTPROC;
12221
12222 s = bfd_get_section_by_name (abfd, ".rtproc");
12223 if (s == NULL)
12224 {
12225 m->count = 0;
12226 m->p_flags = 0;
12227 m->p_flags_valid = 1;
12228 }
12229 else
12230 {
12231 m->count = 1;
12232 m->sections[0] = s;
12233 }
12234
12235 /* We want to put it after the DYNAMIC segment. */
12bd6957 12236 pm = &elf_seg_map (abfd);
b49e97c9
TS
12237 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
12238 pm = &(*pm)->next;
12239 if (*pm != NULL)
12240 pm = &(*pm)->next;
12241
12242 m->next = *pm;
12243 *pm = m;
12244 }
12245 }
12246 }
8dc1a139 12247 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
b49e97c9
TS
12248 .dynstr, .dynsym, and .hash sections, and everything in
12249 between. */
12bd6957 12250 for (pm = &elf_seg_map (abfd); *pm != NULL;
b49e97c9
TS
12251 pm = &(*pm)->next)
12252 if ((*pm)->p_type == PT_DYNAMIC)
12253 break;
12254 m = *pm;
f6f62d6f
RS
12255 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
12256 glibc's dynamic linker has traditionally derived the number of
12257 tags from the p_filesz field, and sometimes allocates stack
12258 arrays of that size. An overly-big PT_DYNAMIC segment can
12259 be actively harmful in such cases. Making PT_DYNAMIC contain
12260 other sections can also make life hard for the prelinker,
12261 which might move one of the other sections to a different
12262 PT_LOAD segment. */
12263 if (SGI_COMPAT (abfd)
12264 && m != NULL
12265 && m->count == 1
12266 && strcmp (m->sections[0]->name, ".dynamic") == 0)
b49e97c9
TS
12267 {
12268 static const char *sec_names[] =
12269 {
12270 ".dynamic", ".dynstr", ".dynsym", ".hash"
12271 };
12272 bfd_vma low, high;
12273 unsigned int i, c;
12274 struct elf_segment_map *n;
12275
792b4a53 12276 low = ~(bfd_vma) 0;
b49e97c9
TS
12277 high = 0;
12278 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
12279 {
12280 s = bfd_get_section_by_name (abfd, sec_names[i]);
12281 if (s != NULL && (s->flags & SEC_LOAD) != 0)
12282 {
12283 bfd_size_type sz;
12284
12285 if (low > s->vma)
12286 low = s->vma;
eea6121a 12287 sz = s->size;
b49e97c9
TS
12288 if (high < s->vma + sz)
12289 high = s->vma + sz;
12290 }
12291 }
12292
12293 c = 0;
12294 for (s = abfd->sections; s != NULL; s = s->next)
12295 if ((s->flags & SEC_LOAD) != 0
12296 && s->vma >= low
eea6121a 12297 && s->vma + s->size <= high)
b49e97c9
TS
12298 ++c;
12299
12300 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
9719ad41 12301 n = bfd_zalloc (abfd, amt);
b49e97c9 12302 if (n == NULL)
b34976b6 12303 return FALSE;
b49e97c9
TS
12304 *n = *m;
12305 n->count = c;
12306
12307 i = 0;
12308 for (s = abfd->sections; s != NULL; s = s->next)
12309 {
12310 if ((s->flags & SEC_LOAD) != 0
12311 && s->vma >= low
eea6121a 12312 && s->vma + s->size <= high)
b49e97c9
TS
12313 {
12314 n->sections[i] = s;
12315 ++i;
12316 }
12317 }
12318
12319 *pm = n;
12320 }
12321 }
12322
98c904a8
RS
12323 /* Allocate a spare program header in dynamic objects so that tools
12324 like the prelinker can add an extra PT_LOAD entry.
12325
12326 If the prelinker needs to make room for a new PT_LOAD entry, its
12327 standard procedure is to move the first (read-only) sections into
12328 the new (writable) segment. However, the MIPS ABI requires
12329 .dynamic to be in a read-only segment, and the section will often
12330 start within sizeof (ElfNN_Phdr) bytes of the last program header.
12331
12332 Although the prelinker could in principle move .dynamic to a
12333 writable segment, it seems better to allocate a spare program
12334 header instead, and avoid the need to move any sections.
12335 There is a long tradition of allocating spare dynamic tags,
12336 so allocating a spare program header seems like a natural
7c8b76cc
JM
12337 extension.
12338
12339 If INFO is NULL, we may be copying an already prelinked binary
12340 with objcopy or strip, so do not add this header. */
12341 if (info != NULL
12342 && !SGI_COMPAT (abfd)
98c904a8
RS
12343 && bfd_get_section_by_name (abfd, ".dynamic"))
12344 {
12bd6957 12345 for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
98c904a8
RS
12346 if ((*pm)->p_type == PT_NULL)
12347 break;
12348 if (*pm == NULL)
12349 {
12350 m = bfd_zalloc (abfd, sizeof (*m));
12351 if (m == NULL)
12352 return FALSE;
12353
12354 m->p_type = PT_NULL;
12355 *pm = m;
12356 }
12357 }
12358
b34976b6 12359 return TRUE;
b49e97c9
TS
12360}
12361\f
12362/* Return the section that should be marked against GC for a given
12363 relocation. */
12364
12365asection *
9719ad41 12366_bfd_mips_elf_gc_mark_hook (asection *sec,
07adf181 12367 struct bfd_link_info *info,
9719ad41
RS
12368 Elf_Internal_Rela *rel,
12369 struct elf_link_hash_entry *h,
12370 Elf_Internal_Sym *sym)
b49e97c9
TS
12371{
12372 /* ??? Do mips16 stub sections need to be handled special? */
12373
12374 if (h != NULL)
07adf181
AM
12375 switch (ELF_R_TYPE (sec->owner, rel->r_info))
12376 {
12377 case R_MIPS_GNU_VTINHERIT:
12378 case R_MIPS_GNU_VTENTRY:
12379 return NULL;
12380 }
b49e97c9 12381
07adf181 12382 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
b49e97c9
TS
12383}
12384
12385/* Update the got entry reference counts for the section being removed. */
12386
b34976b6 12387bfd_boolean
9719ad41
RS
12388_bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
12389 struct bfd_link_info *info ATTRIBUTE_UNUSED,
12390 asection *sec ATTRIBUTE_UNUSED,
12391 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
b49e97c9
TS
12392{
12393#if 0
12394 Elf_Internal_Shdr *symtab_hdr;
12395 struct elf_link_hash_entry **sym_hashes;
12396 bfd_signed_vma *local_got_refcounts;
12397 const Elf_Internal_Rela *rel, *relend;
12398 unsigned long r_symndx;
12399 struct elf_link_hash_entry *h;
12400
7dda2462
TG
12401 if (info->relocatable)
12402 return TRUE;
12403
b49e97c9
TS
12404 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12405 sym_hashes = elf_sym_hashes (abfd);
12406 local_got_refcounts = elf_local_got_refcounts (abfd);
12407
12408 relend = relocs + sec->reloc_count;
12409 for (rel = relocs; rel < relend; rel++)
12410 switch (ELF_R_TYPE (abfd, rel->r_info))
12411 {
738e5348
RS
12412 case R_MIPS16_GOT16:
12413 case R_MIPS16_CALL16:
b49e97c9
TS
12414 case R_MIPS_GOT16:
12415 case R_MIPS_CALL16:
12416 case R_MIPS_CALL_HI16:
12417 case R_MIPS_CALL_LO16:
12418 case R_MIPS_GOT_HI16:
12419 case R_MIPS_GOT_LO16:
4a14403c
TS
12420 case R_MIPS_GOT_DISP:
12421 case R_MIPS_GOT_PAGE:
12422 case R_MIPS_GOT_OFST:
df58fc94
RS
12423 case R_MICROMIPS_GOT16:
12424 case R_MICROMIPS_CALL16:
12425 case R_MICROMIPS_CALL_HI16:
12426 case R_MICROMIPS_CALL_LO16:
12427 case R_MICROMIPS_GOT_HI16:
12428 case R_MICROMIPS_GOT_LO16:
12429 case R_MICROMIPS_GOT_DISP:
12430 case R_MICROMIPS_GOT_PAGE:
12431 case R_MICROMIPS_GOT_OFST:
b49e97c9
TS
12432 /* ??? It would seem that the existing MIPS code does no sort
12433 of reference counting or whatnot on its GOT and PLT entries,
12434 so it is not possible to garbage collect them at this time. */
12435 break;
12436
12437 default:
12438 break;
12439 }
12440#endif
12441
b34976b6 12442 return TRUE;
b49e97c9 12443}
351cdf24
MF
12444
12445/* Prevent .MIPS.abiflags from being discarded with --gc-sections. */
12446
12447bfd_boolean
12448_bfd_mips_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12449 elf_gc_mark_hook_fn gc_mark_hook)
12450{
12451 bfd *sub;
12452
12453 _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
12454
12455 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12456 {
12457 asection *o;
12458
12459 if (! is_mips_elf (sub))
12460 continue;
12461
12462 for (o = sub->sections; o != NULL; o = o->next)
12463 if (!o->gc_mark
12464 && MIPS_ELF_ABIFLAGS_SECTION_NAME_P
12465 (bfd_get_section_name (sub, o)))
12466 {
12467 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12468 return FALSE;
12469 }
12470 }
12471
12472 return TRUE;
12473}
b49e97c9
TS
12474\f
12475/* Copy data from a MIPS ELF indirect symbol to its direct symbol,
12476 hiding the old indirect symbol. Process additional relocation
12477 information. Also called for weakdefs, in which case we just let
12478 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
12479
12480void
fcfa13d2 12481_bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
9719ad41
RS
12482 struct elf_link_hash_entry *dir,
12483 struct elf_link_hash_entry *ind)
b49e97c9
TS
12484{
12485 struct mips_elf_link_hash_entry *dirmips, *indmips;
12486
fcfa13d2 12487 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
b49e97c9 12488
861fb55a
DJ
12489 dirmips = (struct mips_elf_link_hash_entry *) dir;
12490 indmips = (struct mips_elf_link_hash_entry *) ind;
12491 /* Any absolute non-dynamic relocations against an indirect or weak
12492 definition will be against the target symbol. */
12493 if (indmips->has_static_relocs)
12494 dirmips->has_static_relocs = TRUE;
12495
b49e97c9
TS
12496 if (ind->root.type != bfd_link_hash_indirect)
12497 return;
12498
b49e97c9
TS
12499 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
12500 if (indmips->readonly_reloc)
b34976b6 12501 dirmips->readonly_reloc = TRUE;
b49e97c9 12502 if (indmips->no_fn_stub)
b34976b6 12503 dirmips->no_fn_stub = TRUE;
61b0a4af
RS
12504 if (indmips->fn_stub)
12505 {
12506 dirmips->fn_stub = indmips->fn_stub;
12507 indmips->fn_stub = NULL;
12508 }
12509 if (indmips->need_fn_stub)
12510 {
12511 dirmips->need_fn_stub = TRUE;
12512 indmips->need_fn_stub = FALSE;
12513 }
12514 if (indmips->call_stub)
12515 {
12516 dirmips->call_stub = indmips->call_stub;
12517 indmips->call_stub = NULL;
12518 }
12519 if (indmips->call_fp_stub)
12520 {
12521 dirmips->call_fp_stub = indmips->call_fp_stub;
12522 indmips->call_fp_stub = NULL;
12523 }
634835ae
RS
12524 if (indmips->global_got_area < dirmips->global_got_area)
12525 dirmips->global_got_area = indmips->global_got_area;
12526 if (indmips->global_got_area < GGA_NONE)
12527 indmips->global_got_area = GGA_NONE;
861fb55a
DJ
12528 if (indmips->has_nonpic_branches)
12529 dirmips->has_nonpic_branches = TRUE;
b49e97c9 12530}
b49e97c9 12531\f
d01414a5
TS
12532#define PDR_SIZE 32
12533
b34976b6 12534bfd_boolean
9719ad41
RS
12535_bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
12536 struct bfd_link_info *info)
d01414a5
TS
12537{
12538 asection *o;
b34976b6 12539 bfd_boolean ret = FALSE;
d01414a5
TS
12540 unsigned char *tdata;
12541 size_t i, skip;
12542
12543 o = bfd_get_section_by_name (abfd, ".pdr");
12544 if (! o)
b34976b6 12545 return FALSE;
eea6121a 12546 if (o->size == 0)
b34976b6 12547 return FALSE;
eea6121a 12548 if (o->size % PDR_SIZE != 0)
b34976b6 12549 return FALSE;
d01414a5
TS
12550 if (o->output_section != NULL
12551 && bfd_is_abs_section (o->output_section))
b34976b6 12552 return FALSE;
d01414a5 12553
eea6121a 12554 tdata = bfd_zmalloc (o->size / PDR_SIZE);
d01414a5 12555 if (! tdata)
b34976b6 12556 return FALSE;
d01414a5 12557
9719ad41 12558 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
45d6a902 12559 info->keep_memory);
d01414a5
TS
12560 if (!cookie->rels)
12561 {
12562 free (tdata);
b34976b6 12563 return FALSE;
d01414a5
TS
12564 }
12565
12566 cookie->rel = cookie->rels;
12567 cookie->relend = cookie->rels + o->reloc_count;
12568
eea6121a 12569 for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
d01414a5 12570 {
c152c796 12571 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
d01414a5
TS
12572 {
12573 tdata[i] = 1;
12574 skip ++;
12575 }
12576 }
12577
12578 if (skip != 0)
12579 {
f0abc2a1 12580 mips_elf_section_data (o)->u.tdata = tdata;
e034b2cc
MR
12581 if (o->rawsize == 0)
12582 o->rawsize = o->size;
eea6121a 12583 o->size -= skip * PDR_SIZE;
b34976b6 12584 ret = TRUE;
d01414a5
TS
12585 }
12586 else
12587 free (tdata);
12588
12589 if (! info->keep_memory)
12590 free (cookie->rels);
12591
12592 return ret;
12593}
12594
b34976b6 12595bfd_boolean
9719ad41 12596_bfd_mips_elf_ignore_discarded_relocs (asection *sec)
53bfd6b4
MR
12597{
12598 if (strcmp (sec->name, ".pdr") == 0)
b34976b6
AM
12599 return TRUE;
12600 return FALSE;
53bfd6b4 12601}
d01414a5 12602
b34976b6 12603bfd_boolean
c7b8f16e
JB
12604_bfd_mips_elf_write_section (bfd *output_bfd,
12605 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
12606 asection *sec, bfd_byte *contents)
d01414a5
TS
12607{
12608 bfd_byte *to, *from, *end;
12609 int i;
12610
12611 if (strcmp (sec->name, ".pdr") != 0)
b34976b6 12612 return FALSE;
d01414a5 12613
f0abc2a1 12614 if (mips_elf_section_data (sec)->u.tdata == NULL)
b34976b6 12615 return FALSE;
d01414a5
TS
12616
12617 to = contents;
eea6121a 12618 end = contents + sec->size;
d01414a5
TS
12619 for (from = contents, i = 0;
12620 from < end;
12621 from += PDR_SIZE, i++)
12622 {
f0abc2a1 12623 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
d01414a5
TS
12624 continue;
12625 if (to != from)
12626 memcpy (to, from, PDR_SIZE);
12627 to += PDR_SIZE;
12628 }
12629 bfd_set_section_contents (output_bfd, sec->output_section, contents,
eea6121a 12630 sec->output_offset, sec->size);
b34976b6 12631 return TRUE;
d01414a5 12632}
53bfd6b4 12633\f
df58fc94
RS
12634/* microMIPS code retains local labels for linker relaxation. Omit them
12635 from output by default for clarity. */
12636
12637bfd_boolean
12638_bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
12639{
12640 return _bfd_elf_is_local_label_name (abfd, sym->name);
12641}
12642
b49e97c9
TS
12643/* MIPS ELF uses a special find_nearest_line routine in order the
12644 handle the ECOFF debugging information. */
12645
12646struct mips_elf_find_line
12647{
12648 struct ecoff_debug_info d;
12649 struct ecoff_find_line i;
12650};
12651
b34976b6 12652bfd_boolean
fb167eb2
AM
12653_bfd_mips_elf_find_nearest_line (bfd *abfd, asymbol **symbols,
12654 asection *section, bfd_vma offset,
9719ad41
RS
12655 const char **filename_ptr,
12656 const char **functionname_ptr,
fb167eb2
AM
12657 unsigned int *line_ptr,
12658 unsigned int *discriminator_ptr)
b49e97c9
TS
12659{
12660 asection *msec;
12661
fb167eb2 12662 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
b49e97c9 12663 filename_ptr, functionname_ptr,
fb167eb2
AM
12664 line_ptr, discriminator_ptr,
12665 dwarf_debug_sections,
12666 ABI_64_P (abfd) ? 8 : 0,
12667 &elf_tdata (abfd)->dwarf2_find_line_info))
b34976b6 12668 return TRUE;
b49e97c9 12669
fb167eb2 12670 if (_bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
b49e97c9 12671 filename_ptr, functionname_ptr,
fb167eb2 12672 line_ptr))
b34976b6 12673 return TRUE;
b49e97c9
TS
12674
12675 msec = bfd_get_section_by_name (abfd, ".mdebug");
12676 if (msec != NULL)
12677 {
12678 flagword origflags;
12679 struct mips_elf_find_line *fi;
12680 const struct ecoff_debug_swap * const swap =
12681 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
12682
12683 /* If we are called during a link, mips_elf_final_link may have
12684 cleared the SEC_HAS_CONTENTS field. We force it back on here
12685 if appropriate (which it normally will be). */
12686 origflags = msec->flags;
12687 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
12688 msec->flags |= SEC_HAS_CONTENTS;
12689
698600e4 12690 fi = mips_elf_tdata (abfd)->find_line_info;
b49e97c9
TS
12691 if (fi == NULL)
12692 {
12693 bfd_size_type external_fdr_size;
12694 char *fraw_src;
12695 char *fraw_end;
12696 struct fdr *fdr_ptr;
12697 bfd_size_type amt = sizeof (struct mips_elf_find_line);
12698
9719ad41 12699 fi = bfd_zalloc (abfd, amt);
b49e97c9
TS
12700 if (fi == NULL)
12701 {
12702 msec->flags = origflags;
b34976b6 12703 return FALSE;
b49e97c9
TS
12704 }
12705
12706 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
12707 {
12708 msec->flags = origflags;
b34976b6 12709 return FALSE;
b49e97c9
TS
12710 }
12711
12712 /* Swap in the FDR information. */
12713 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
9719ad41 12714 fi->d.fdr = bfd_alloc (abfd, amt);
b49e97c9
TS
12715 if (fi->d.fdr == NULL)
12716 {
12717 msec->flags = origflags;
b34976b6 12718 return FALSE;
b49e97c9
TS
12719 }
12720 external_fdr_size = swap->external_fdr_size;
12721 fdr_ptr = fi->d.fdr;
12722 fraw_src = (char *) fi->d.external_fdr;
12723 fraw_end = (fraw_src
12724 + fi->d.symbolic_header.ifdMax * external_fdr_size);
12725 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
9719ad41 12726 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
b49e97c9 12727
698600e4 12728 mips_elf_tdata (abfd)->find_line_info = fi;
b49e97c9
TS
12729
12730 /* Note that we don't bother to ever free this information.
12731 find_nearest_line is either called all the time, as in
12732 objdump -l, so the information should be saved, or it is
12733 rarely called, as in ld error messages, so the memory
12734 wasted is unimportant. Still, it would probably be a
12735 good idea for free_cached_info to throw it away. */
12736 }
12737
12738 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
12739 &fi->i, filename_ptr, functionname_ptr,
12740 line_ptr))
12741 {
12742 msec->flags = origflags;
b34976b6 12743 return TRUE;
b49e97c9
TS
12744 }
12745
12746 msec->flags = origflags;
12747 }
12748
12749 /* Fall back on the generic ELF find_nearest_line routine. */
12750
fb167eb2 12751 return _bfd_elf_find_nearest_line (abfd, symbols, section, offset,
b49e97c9 12752 filename_ptr, functionname_ptr,
fb167eb2 12753 line_ptr, discriminator_ptr);
b49e97c9 12754}
4ab527b0
FF
12755
12756bfd_boolean
12757_bfd_mips_elf_find_inliner_info (bfd *abfd,
12758 const char **filename_ptr,
12759 const char **functionname_ptr,
12760 unsigned int *line_ptr)
12761{
12762 bfd_boolean found;
12763 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
12764 functionname_ptr, line_ptr,
12765 & elf_tdata (abfd)->dwarf2_find_line_info);
12766 return found;
12767}
12768
b49e97c9
TS
12769\f
12770/* When are writing out the .options or .MIPS.options section,
12771 remember the bytes we are writing out, so that we can install the
12772 GP value in the section_processing routine. */
12773
b34976b6 12774bfd_boolean
9719ad41
RS
12775_bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
12776 const void *location,
12777 file_ptr offset, bfd_size_type count)
b49e97c9 12778{
cc2e31b9 12779 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
b49e97c9
TS
12780 {
12781 bfd_byte *c;
12782
12783 if (elf_section_data (section) == NULL)
12784 {
12785 bfd_size_type amt = sizeof (struct bfd_elf_section_data);
9719ad41 12786 section->used_by_bfd = bfd_zalloc (abfd, amt);
b49e97c9 12787 if (elf_section_data (section) == NULL)
b34976b6 12788 return FALSE;
b49e97c9 12789 }
f0abc2a1 12790 c = mips_elf_section_data (section)->u.tdata;
b49e97c9
TS
12791 if (c == NULL)
12792 {
eea6121a 12793 c = bfd_zalloc (abfd, section->size);
b49e97c9 12794 if (c == NULL)
b34976b6 12795 return FALSE;
f0abc2a1 12796 mips_elf_section_data (section)->u.tdata = c;
b49e97c9
TS
12797 }
12798
9719ad41 12799 memcpy (c + offset, location, count);
b49e97c9
TS
12800 }
12801
12802 return _bfd_elf_set_section_contents (abfd, section, location, offset,
12803 count);
12804}
12805
12806/* This is almost identical to bfd_generic_get_... except that some
12807 MIPS relocations need to be handled specially. Sigh. */
12808
12809bfd_byte *
9719ad41
RS
12810_bfd_elf_mips_get_relocated_section_contents
12811 (bfd *abfd,
12812 struct bfd_link_info *link_info,
12813 struct bfd_link_order *link_order,
12814 bfd_byte *data,
12815 bfd_boolean relocatable,
12816 asymbol **symbols)
b49e97c9
TS
12817{
12818 /* Get enough memory to hold the stuff */
12819 bfd *input_bfd = link_order->u.indirect.section->owner;
12820 asection *input_section = link_order->u.indirect.section;
eea6121a 12821 bfd_size_type sz;
b49e97c9
TS
12822
12823 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
12824 arelent **reloc_vector = NULL;
12825 long reloc_count;
12826
12827 if (reloc_size < 0)
12828 goto error_return;
12829
9719ad41 12830 reloc_vector = bfd_malloc (reloc_size);
b49e97c9
TS
12831 if (reloc_vector == NULL && reloc_size != 0)
12832 goto error_return;
12833
12834 /* read in the section */
eea6121a
AM
12835 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
12836 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
b49e97c9
TS
12837 goto error_return;
12838
b49e97c9
TS
12839 reloc_count = bfd_canonicalize_reloc (input_bfd,
12840 input_section,
12841 reloc_vector,
12842 symbols);
12843 if (reloc_count < 0)
12844 goto error_return;
12845
12846 if (reloc_count > 0)
12847 {
12848 arelent **parent;
12849 /* for mips */
12850 int gp_found;
12851 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
12852
12853 {
12854 struct bfd_hash_entry *h;
12855 struct bfd_link_hash_entry *lh;
12856 /* Skip all this stuff if we aren't mixing formats. */
12857 if (abfd && input_bfd
12858 && abfd->xvec == input_bfd->xvec)
12859 lh = 0;
12860 else
12861 {
b34976b6 12862 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
b49e97c9
TS
12863 lh = (struct bfd_link_hash_entry *) h;
12864 }
12865 lookup:
12866 if (lh)
12867 {
12868 switch (lh->type)
12869 {
12870 case bfd_link_hash_undefined:
12871 case bfd_link_hash_undefweak:
12872 case bfd_link_hash_common:
12873 gp_found = 0;
12874 break;
12875 case bfd_link_hash_defined:
12876 case bfd_link_hash_defweak:
12877 gp_found = 1;
12878 gp = lh->u.def.value;
12879 break;
12880 case bfd_link_hash_indirect:
12881 case bfd_link_hash_warning:
12882 lh = lh->u.i.link;
12883 /* @@FIXME ignoring warning for now */
12884 goto lookup;
12885 case bfd_link_hash_new:
12886 default:
12887 abort ();
12888 }
12889 }
12890 else
12891 gp_found = 0;
12892 }
12893 /* end mips */
9719ad41 12894 for (parent = reloc_vector; *parent != NULL; parent++)
b49e97c9 12895 {
9719ad41 12896 char *error_message = NULL;
b49e97c9
TS
12897 bfd_reloc_status_type r;
12898
12899 /* Specific to MIPS: Deal with relocation types that require
12900 knowing the gp of the output bfd. */
12901 asymbol *sym = *(*parent)->sym_ptr_ptr;
b49e97c9 12902
8236346f
EC
12903 /* If we've managed to find the gp and have a special
12904 function for the relocation then go ahead, else default
12905 to the generic handling. */
12906 if (gp_found
12907 && (*parent)->howto->special_function
12908 == _bfd_mips_elf32_gprel16_reloc)
12909 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
12910 input_section, relocatable,
12911 data, gp);
12912 else
86324f90 12913 r = bfd_perform_relocation (input_bfd, *parent, data,
8236346f
EC
12914 input_section,
12915 relocatable ? abfd : NULL,
12916 &error_message);
b49e97c9 12917
1049f94e 12918 if (relocatable)
b49e97c9
TS
12919 {
12920 asection *os = input_section->output_section;
12921
12922 /* A partial link, so keep the relocs */
12923 os->orelocation[os->reloc_count] = *parent;
12924 os->reloc_count++;
12925 }
12926
12927 if (r != bfd_reloc_ok)
12928 {
12929 switch (r)
12930 {
12931 case bfd_reloc_undefined:
12932 if (!((*link_info->callbacks->undefined_symbol)
12933 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
5e2b0d47 12934 input_bfd, input_section, (*parent)->address, TRUE)))
b49e97c9
TS
12935 goto error_return;
12936 break;
12937 case bfd_reloc_dangerous:
9719ad41 12938 BFD_ASSERT (error_message != NULL);
b49e97c9
TS
12939 if (!((*link_info->callbacks->reloc_dangerous)
12940 (link_info, error_message, input_bfd, input_section,
12941 (*parent)->address)))
12942 goto error_return;
12943 break;
12944 case bfd_reloc_overflow:
12945 if (!((*link_info->callbacks->reloc_overflow)
dfeffb9f
L
12946 (link_info, NULL,
12947 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
b49e97c9
TS
12948 (*parent)->howto->name, (*parent)->addend,
12949 input_bfd, input_section, (*parent)->address)))
12950 goto error_return;
12951 break;
12952 case bfd_reloc_outofrange:
12953 default:
12954 abort ();
12955 break;
12956 }
12957
12958 }
12959 }
12960 }
12961 if (reloc_vector != NULL)
12962 free (reloc_vector);
12963 return data;
12964
12965error_return:
12966 if (reloc_vector != NULL)
12967 free (reloc_vector);
12968 return NULL;
12969}
12970\f
df58fc94
RS
12971static bfd_boolean
12972mips_elf_relax_delete_bytes (bfd *abfd,
12973 asection *sec, bfd_vma addr, int count)
12974{
12975 Elf_Internal_Shdr *symtab_hdr;
12976 unsigned int sec_shndx;
12977 bfd_byte *contents;
12978 Elf_Internal_Rela *irel, *irelend;
12979 Elf_Internal_Sym *isym;
12980 Elf_Internal_Sym *isymend;
12981 struct elf_link_hash_entry **sym_hashes;
12982 struct elf_link_hash_entry **end_hashes;
12983 struct elf_link_hash_entry **start_hashes;
12984 unsigned int symcount;
12985
12986 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
12987 contents = elf_section_data (sec)->this_hdr.contents;
12988
12989 irel = elf_section_data (sec)->relocs;
12990 irelend = irel + sec->reloc_count;
12991
12992 /* Actually delete the bytes. */
12993 memmove (contents + addr, contents + addr + count,
12994 (size_t) (sec->size - addr - count));
12995 sec->size -= count;
12996
12997 /* Adjust all the relocs. */
12998 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
12999 {
13000 /* Get the new reloc address. */
13001 if (irel->r_offset > addr)
13002 irel->r_offset -= count;
13003 }
13004
13005 BFD_ASSERT (addr % 2 == 0);
13006 BFD_ASSERT (count % 2 == 0);
13007
13008 /* Adjust the local symbols defined in this section. */
13009 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13010 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
13011 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
2309ddf2 13012 if (isym->st_shndx == sec_shndx && isym->st_value > addr)
df58fc94
RS
13013 isym->st_value -= count;
13014
13015 /* Now adjust the global symbols defined in this section. */
13016 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
13017 - symtab_hdr->sh_info);
13018 sym_hashes = start_hashes = elf_sym_hashes (abfd);
13019 end_hashes = sym_hashes + symcount;
13020
13021 for (; sym_hashes < end_hashes; sym_hashes++)
13022 {
13023 struct elf_link_hash_entry *sym_hash = *sym_hashes;
13024
13025 if ((sym_hash->root.type == bfd_link_hash_defined
13026 || sym_hash->root.type == bfd_link_hash_defweak)
13027 && sym_hash->root.u.def.section == sec)
13028 {
2309ddf2 13029 bfd_vma value = sym_hash->root.u.def.value;
df58fc94 13030
df58fc94
RS
13031 if (ELF_ST_IS_MICROMIPS (sym_hash->other))
13032 value &= MINUS_TWO;
13033 if (value > addr)
13034 sym_hash->root.u.def.value -= count;
13035 }
13036 }
13037
13038 return TRUE;
13039}
13040
13041
13042/* Opcodes needed for microMIPS relaxation as found in
13043 opcodes/micromips-opc.c. */
13044
13045struct opcode_descriptor {
13046 unsigned long match;
13047 unsigned long mask;
13048};
13049
13050/* The $ra register aka $31. */
13051
13052#define RA 31
13053
13054/* 32-bit instruction format register fields. */
13055
13056#define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
13057#define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
13058
13059/* Check if a 5-bit register index can be abbreviated to 3 bits. */
13060
13061#define OP16_VALID_REG(r) \
13062 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
13063
13064
13065/* 32-bit and 16-bit branches. */
13066
13067static const struct opcode_descriptor b_insns_32[] = {
13068 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */
13069 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
13070 { 0, 0 } /* End marker for find_match(). */
13071};
13072
13073static const struct opcode_descriptor bc_insn_32 =
13074 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 };
13075
13076static const struct opcode_descriptor bz_insn_32 =
13077 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 };
13078
13079static const struct opcode_descriptor bzal_insn_32 =
13080 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 };
13081
13082static const struct opcode_descriptor beq_insn_32 =
13083 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 };
13084
13085static const struct opcode_descriptor b_insn_16 =
13086 { /* "b", "mD", */ 0xcc00, 0xfc00 };
13087
13088static const struct opcode_descriptor bz_insn_16 =
c088dedf 13089 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 };
df58fc94
RS
13090
13091
13092/* 32-bit and 16-bit branch EQ and NE zero. */
13093
13094/* NOTE: All opcode tables have BEQ/BNE in the same order: first the
13095 eq and second the ne. This convention is used when replacing a
13096 32-bit BEQ/BNE with the 16-bit version. */
13097
13098#define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
13099
13100static const struct opcode_descriptor bz_rs_insns_32[] = {
13101 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 },
13102 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 },
13103 { 0, 0 } /* End marker for find_match(). */
13104};
13105
13106static const struct opcode_descriptor bz_rt_insns_32[] = {
13107 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 },
13108 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 },
13109 { 0, 0 } /* End marker for find_match(). */
13110};
13111
13112static const struct opcode_descriptor bzc_insns_32[] = {
13113 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 },
13114 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 },
13115 { 0, 0 } /* End marker for find_match(). */
13116};
13117
13118static const struct opcode_descriptor bz_insns_16[] = {
13119 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 },
13120 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 },
13121 { 0, 0 } /* End marker for find_match(). */
13122};
13123
13124/* Switch between a 5-bit register index and its 3-bit shorthand. */
13125
13126#define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0x17) + 2)
13127#define BZ16_REG_FIELD(r) \
13128 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 7)
13129
13130
13131/* 32-bit instructions with a delay slot. */
13132
13133static const struct opcode_descriptor jal_insn_32_bd16 =
13134 { /* "jals", "a", */ 0x74000000, 0xfc000000 };
13135
13136static const struct opcode_descriptor jal_insn_32_bd32 =
13137 { /* "jal", "a", */ 0xf4000000, 0xfc000000 };
13138
13139static const struct opcode_descriptor jal_x_insn_32_bd32 =
13140 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 };
13141
13142static const struct opcode_descriptor j_insn_32 =
13143 { /* "j", "a", */ 0xd4000000, 0xfc000000 };
13144
13145static const struct opcode_descriptor jalr_insn_32 =
13146 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff };
13147
13148/* This table can be compacted, because no opcode replacement is made. */
13149
13150static const struct opcode_descriptor ds_insns_32_bd16[] = {
13151 { /* "jals", "a", */ 0x74000000, 0xfc000000 },
13152
13153 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff },
13154 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 },
13155
13156 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 },
13157 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 },
13158 { /* "j", "a", */ 0xd4000000, 0xfc000000 },
13159 { 0, 0 } /* End marker for find_match(). */
13160};
13161
13162/* This table can be compacted, because no opcode replacement is made. */
13163
13164static const struct opcode_descriptor ds_insns_32_bd32[] = {
13165 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 },
13166
13167 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff },
13168 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 },
13169 { 0, 0 } /* End marker for find_match(). */
13170};
13171
13172
13173/* 16-bit instructions with a delay slot. */
13174
13175static const struct opcode_descriptor jalr_insn_16_bd16 =
13176 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 };
13177
13178static const struct opcode_descriptor jalr_insn_16_bd32 =
13179 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 };
13180
13181static const struct opcode_descriptor jr_insn_16 =
13182 { /* "jr", "mj", */ 0x4580, 0xffe0 };
13183
13184#define JR16_REG(opcode) ((opcode) & 0x1f)
13185
13186/* This table can be compacted, because no opcode replacement is made. */
13187
13188static const struct opcode_descriptor ds_insns_16_bd16[] = {
13189 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 },
13190
13191 { /* "b", "mD", */ 0xcc00, 0xfc00 },
13192 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 },
13193 { /* "jr", "mj", */ 0x4580, 0xffe0 },
13194 { 0, 0 } /* End marker for find_match(). */
13195};
13196
13197
13198/* LUI instruction. */
13199
13200static const struct opcode_descriptor lui_insn =
13201 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 };
13202
13203
13204/* ADDIU instruction. */
13205
13206static const struct opcode_descriptor addiu_insn =
13207 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 };
13208
13209static const struct opcode_descriptor addiupc_insn =
13210 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 };
13211
13212#define ADDIUPC_REG_FIELD(r) \
13213 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
13214
13215
13216/* Relaxable instructions in a JAL delay slot: MOVE. */
13217
13218/* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves
13219 (ADDU, OR) have rd in 15:11 and rs in 10:16. */
13220#define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
13221#define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
13222
13223#define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
13224#define MOVE16_RS_FIELD(r) (((r) & 0x1f) )
13225
13226static const struct opcode_descriptor move_insns_32[] = {
13227 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
13228 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */
13229 { 0, 0 } /* End marker for find_match(). */
13230};
13231
13232static const struct opcode_descriptor move_insn_16 =
13233 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 };
13234
13235
13236/* NOP instructions. */
13237
13238static const struct opcode_descriptor nop_insn_32 =
13239 { /* "nop", "", */ 0x00000000, 0xffffffff };
13240
13241static const struct opcode_descriptor nop_insn_16 =
13242 { /* "nop", "", */ 0x0c00, 0xffff };
13243
13244
13245/* Instruction match support. */
13246
13247#define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
13248
13249static int
13250find_match (unsigned long opcode, const struct opcode_descriptor insn[])
13251{
13252 unsigned long indx;
13253
13254 for (indx = 0; insn[indx].mask != 0; indx++)
13255 if (MATCH (opcode, insn[indx]))
13256 return indx;
13257
13258 return -1;
13259}
13260
13261
13262/* Branch and delay slot decoding support. */
13263
13264/* If PTR points to what *might* be a 16-bit branch or jump, then
13265 return the minimum length of its delay slot, otherwise return 0.
13266 Non-zero results are not definitive as we might be checking against
13267 the second half of another instruction. */
13268
13269static int
13270check_br16_dslot (bfd *abfd, bfd_byte *ptr)
13271{
13272 unsigned long opcode;
13273 int bdsize;
13274
13275 opcode = bfd_get_16 (abfd, ptr);
13276 if (MATCH (opcode, jalr_insn_16_bd32) != 0)
13277 /* 16-bit branch/jump with a 32-bit delay slot. */
13278 bdsize = 4;
13279 else if (MATCH (opcode, jalr_insn_16_bd16) != 0
13280 || find_match (opcode, ds_insns_16_bd16) >= 0)
13281 /* 16-bit branch/jump with a 16-bit delay slot. */
13282 bdsize = 2;
13283 else
13284 /* No delay slot. */
13285 bdsize = 0;
13286
13287 return bdsize;
13288}
13289
13290/* If PTR points to what *might* be a 32-bit branch or jump, then
13291 return the minimum length of its delay slot, otherwise return 0.
13292 Non-zero results are not definitive as we might be checking against
13293 the second half of another instruction. */
13294
13295static int
13296check_br32_dslot (bfd *abfd, bfd_byte *ptr)
13297{
13298 unsigned long opcode;
13299 int bdsize;
13300
d21911ea 13301 opcode = bfd_get_micromips_32 (abfd, ptr);
df58fc94
RS
13302 if (find_match (opcode, ds_insns_32_bd32) >= 0)
13303 /* 32-bit branch/jump with a 32-bit delay slot. */
13304 bdsize = 4;
13305 else if (find_match (opcode, ds_insns_32_bd16) >= 0)
13306 /* 32-bit branch/jump with a 16-bit delay slot. */
13307 bdsize = 2;
13308 else
13309 /* No delay slot. */
13310 bdsize = 0;
13311
13312 return bdsize;
13313}
13314
13315/* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
13316 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */
13317
13318static bfd_boolean
13319check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
13320{
13321 unsigned long opcode;
13322
13323 opcode = bfd_get_16 (abfd, ptr);
13324 if (MATCH (opcode, b_insn_16)
13325 /* B16 */
13326 || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode))
13327 /* JR16 */
13328 || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode))
13329 /* BEQZ16, BNEZ16 */
13330 || (MATCH (opcode, jalr_insn_16_bd32)
13331 /* JALR16 */
13332 && reg != JR16_REG (opcode) && reg != RA))
13333 return TRUE;
13334
13335 return FALSE;
13336}
13337
13338/* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
13339 then return TRUE, otherwise FALSE. */
13340
f41e5fcc 13341static bfd_boolean
df58fc94
RS
13342check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
13343{
13344 unsigned long opcode;
13345
d21911ea 13346 opcode = bfd_get_micromips_32 (abfd, ptr);
df58fc94
RS
13347 if (MATCH (opcode, j_insn_32)
13348 /* J */
13349 || MATCH (opcode, bc_insn_32)
13350 /* BC1F, BC1T, BC2F, BC2T */
13351 || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA)
13352 /* JAL, JALX */
13353 || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode))
13354 /* BGEZ, BGTZ, BLEZ, BLTZ */
13355 || (MATCH (opcode, bzal_insn_32)
13356 /* BGEZAL, BLTZAL */
13357 && reg != OP32_SREG (opcode) && reg != RA)
13358 || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32))
13359 /* JALR, JALR.HB, BEQ, BNE */
13360 && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode)))
13361 return TRUE;
13362
13363 return FALSE;
13364}
13365
80cab405
MR
13366/* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
13367 IRELEND) at OFFSET indicate that there must be a compact branch there,
13368 then return TRUE, otherwise FALSE. */
df58fc94
RS
13369
13370static bfd_boolean
80cab405
MR
13371check_relocated_bzc (bfd *abfd, const bfd_byte *ptr, bfd_vma offset,
13372 const Elf_Internal_Rela *internal_relocs,
13373 const Elf_Internal_Rela *irelend)
df58fc94 13374{
80cab405
MR
13375 const Elf_Internal_Rela *irel;
13376 unsigned long opcode;
13377
d21911ea 13378 opcode = bfd_get_micromips_32 (abfd, ptr);
80cab405
MR
13379 if (find_match (opcode, bzc_insns_32) < 0)
13380 return FALSE;
df58fc94
RS
13381
13382 for (irel = internal_relocs; irel < irelend; irel++)
80cab405
MR
13383 if (irel->r_offset == offset
13384 && ELF32_R_TYPE (irel->r_info) == R_MICROMIPS_PC16_S1)
13385 return TRUE;
13386
df58fc94
RS
13387 return FALSE;
13388}
80cab405
MR
13389
13390/* Bitsize checking. */
13391#define IS_BITSIZE(val, N) \
13392 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \
13393 - (1ULL << ((N) - 1))) == (val))
13394
df58fc94
RS
13395\f
13396bfd_boolean
13397_bfd_mips_elf_relax_section (bfd *abfd, asection *sec,
13398 struct bfd_link_info *link_info,
13399 bfd_boolean *again)
13400{
833794fc 13401 bfd_boolean insn32 = mips_elf_hash_table (link_info)->insn32;
df58fc94
RS
13402 Elf_Internal_Shdr *symtab_hdr;
13403 Elf_Internal_Rela *internal_relocs;
13404 Elf_Internal_Rela *irel, *irelend;
13405 bfd_byte *contents = NULL;
13406 Elf_Internal_Sym *isymbuf = NULL;
13407
13408 /* Assume nothing changes. */
13409 *again = FALSE;
13410
13411 /* We don't have to do anything for a relocatable link, if
13412 this section does not have relocs, or if this is not a
13413 code section. */
13414
13415 if (link_info->relocatable
13416 || (sec->flags & SEC_RELOC) == 0
13417 || sec->reloc_count == 0
13418 || (sec->flags & SEC_CODE) == 0)
13419 return TRUE;
13420
13421 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13422
13423 /* Get a copy of the native relocations. */
13424 internal_relocs = (_bfd_elf_link_read_relocs
2c3fc389 13425 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
df58fc94
RS
13426 link_info->keep_memory));
13427 if (internal_relocs == NULL)
13428 goto error_return;
13429
13430 /* Walk through them looking for relaxing opportunities. */
13431 irelend = internal_relocs + sec->reloc_count;
13432 for (irel = internal_relocs; irel < irelend; irel++)
13433 {
13434 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
13435 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
13436 bfd_boolean target_is_micromips_code_p;
13437 unsigned long opcode;
13438 bfd_vma symval;
13439 bfd_vma pcrval;
2309ddf2 13440 bfd_byte *ptr;
df58fc94
RS
13441 int fndopc;
13442
13443 /* The number of bytes to delete for relaxation and from where
13444 to delete these bytes starting at irel->r_offset. */
13445 int delcnt = 0;
13446 int deloff = 0;
13447
13448 /* If this isn't something that can be relaxed, then ignore
13449 this reloc. */
13450 if (r_type != R_MICROMIPS_HI16
13451 && r_type != R_MICROMIPS_PC16_S1
2309ddf2 13452 && r_type != R_MICROMIPS_26_S1)
df58fc94
RS
13453 continue;
13454
13455 /* Get the section contents if we haven't done so already. */
13456 if (contents == NULL)
13457 {
13458 /* Get cached copy if it exists. */
13459 if (elf_section_data (sec)->this_hdr.contents != NULL)
13460 contents = elf_section_data (sec)->this_hdr.contents;
13461 /* Go get them off disk. */
13462 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
13463 goto error_return;
13464 }
2309ddf2 13465 ptr = contents + irel->r_offset;
df58fc94
RS
13466
13467 /* Read this BFD's local symbols if we haven't done so already. */
13468 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
13469 {
13470 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
13471 if (isymbuf == NULL)
13472 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
13473 symtab_hdr->sh_info, 0,
13474 NULL, NULL, NULL);
13475 if (isymbuf == NULL)
13476 goto error_return;
13477 }
13478
13479 /* Get the value of the symbol referred to by the reloc. */
13480 if (r_symndx < symtab_hdr->sh_info)
13481 {
13482 /* A local symbol. */
13483 Elf_Internal_Sym *isym;
13484 asection *sym_sec;
13485
13486 isym = isymbuf + r_symndx;
13487 if (isym->st_shndx == SHN_UNDEF)
13488 sym_sec = bfd_und_section_ptr;
13489 else if (isym->st_shndx == SHN_ABS)
13490 sym_sec = bfd_abs_section_ptr;
13491 else if (isym->st_shndx == SHN_COMMON)
13492 sym_sec = bfd_com_section_ptr;
13493 else
13494 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
13495 symval = (isym->st_value
13496 + sym_sec->output_section->vma
13497 + sym_sec->output_offset);
13498 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other);
13499 }
13500 else
13501 {
13502 unsigned long indx;
13503 struct elf_link_hash_entry *h;
13504
13505 /* An external symbol. */
13506 indx = r_symndx - symtab_hdr->sh_info;
13507 h = elf_sym_hashes (abfd)[indx];
13508 BFD_ASSERT (h != NULL);
13509
13510 if (h->root.type != bfd_link_hash_defined
13511 && h->root.type != bfd_link_hash_defweak)
13512 /* This appears to be a reference to an undefined
13513 symbol. Just ignore it -- it will be caught by the
13514 regular reloc processing. */
13515 continue;
13516
13517 symval = (h->root.u.def.value
13518 + h->root.u.def.section->output_section->vma
13519 + h->root.u.def.section->output_offset);
13520 target_is_micromips_code_p = (!h->needs_plt
13521 && ELF_ST_IS_MICROMIPS (h->other));
13522 }
13523
13524
13525 /* For simplicity of coding, we are going to modify the
13526 section contents, the section relocs, and the BFD symbol
13527 table. We must tell the rest of the code not to free up this
13528 information. It would be possible to instead create a table
13529 of changes which have to be made, as is done in coff-mips.c;
13530 that would be more work, but would require less memory when
13531 the linker is run. */
13532
13533 /* Only 32-bit instructions relaxed. */
13534 if (irel->r_offset + 4 > sec->size)
13535 continue;
13536
d21911ea 13537 opcode = bfd_get_micromips_32 (abfd, ptr);
df58fc94
RS
13538
13539 /* This is the pc-relative distance from the instruction the
13540 relocation is applied to, to the symbol referred. */
13541 pcrval = (symval
13542 - (sec->output_section->vma + sec->output_offset)
13543 - irel->r_offset);
13544
13545 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
13546 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
13547 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is
13548
13549 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
13550
13551 where pcrval has first to be adjusted to apply against the LO16
13552 location (we make the adjustment later on, when we have figured
13553 out the offset). */
13554 if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn))
13555 {
80cab405 13556 bfd_boolean bzc = FALSE;
df58fc94
RS
13557 unsigned long nextopc;
13558 unsigned long reg;
13559 bfd_vma offset;
13560
13561 /* Give up if the previous reloc was a HI16 against this symbol
13562 too. */
13563 if (irel > internal_relocs
13564 && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16
13565 && ELF32_R_SYM (irel[-1].r_info) == r_symndx)
13566 continue;
13567
13568 /* Or if the next reloc is not a LO16 against this symbol. */
13569 if (irel + 1 >= irelend
13570 || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16
13571 || ELF32_R_SYM (irel[1].r_info) != r_symndx)
13572 continue;
13573
13574 /* Or if the second next reloc is a LO16 against this symbol too. */
13575 if (irel + 2 >= irelend
13576 && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16
13577 && ELF32_R_SYM (irel[2].r_info) == r_symndx)
13578 continue;
13579
80cab405
MR
13580 /* See if the LUI instruction *might* be in a branch delay slot.
13581 We check whether what looks like a 16-bit branch or jump is
13582 actually an immediate argument to a compact branch, and let
13583 it through if so. */
df58fc94 13584 if (irel->r_offset >= 2
2309ddf2 13585 && check_br16_dslot (abfd, ptr - 2)
df58fc94 13586 && !(irel->r_offset >= 4
80cab405
MR
13587 && (bzc = check_relocated_bzc (abfd,
13588 ptr - 4, irel->r_offset - 4,
13589 internal_relocs, irelend))))
df58fc94
RS
13590 continue;
13591 if (irel->r_offset >= 4
80cab405 13592 && !bzc
2309ddf2 13593 && check_br32_dslot (abfd, ptr - 4))
df58fc94
RS
13594 continue;
13595
13596 reg = OP32_SREG (opcode);
13597
13598 /* We only relax adjacent instructions or ones separated with
13599 a branch or jump that has a delay slot. The branch or jump
13600 must not fiddle with the register used to hold the address.
13601 Subtract 4 for the LUI itself. */
13602 offset = irel[1].r_offset - irel[0].r_offset;
13603 switch (offset - 4)
13604 {
13605 case 0:
13606 break;
13607 case 2:
2309ddf2 13608 if (check_br16 (abfd, ptr + 4, reg))
df58fc94
RS
13609 break;
13610 continue;
13611 case 4:
2309ddf2 13612 if (check_br32 (abfd, ptr + 4, reg))
df58fc94
RS
13613 break;
13614 continue;
13615 default:
13616 continue;
13617 }
13618
d21911ea 13619 nextopc = bfd_get_micromips_32 (abfd, contents + irel[1].r_offset);
df58fc94
RS
13620
13621 /* Give up unless the same register is used with both
13622 relocations. */
13623 if (OP32_SREG (nextopc) != reg)
13624 continue;
13625
13626 /* Now adjust pcrval, subtracting the offset to the LO16 reloc
13627 and rounding up to take masking of the two LSBs into account. */
13628 pcrval = ((pcrval - offset + 3) | 3) ^ 3;
13629
13630 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */
13631 if (IS_BITSIZE (symval, 16))
13632 {
13633 /* Fix the relocation's type. */
13634 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16);
13635
13636 /* Instructions using R_MICROMIPS_LO16 have the base or
13637 source register in bits 20:16. This register becomes $0
13638 (zero) as the result of the R_MICROMIPS_HI16 being 0. */
13639 nextopc &= ~0x001f0000;
13640 bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
13641 contents + irel[1].r_offset);
13642 }
13643
13644 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
13645 We add 4 to take LUI deletion into account while checking
13646 the PC-relative distance. */
13647 else if (symval % 4 == 0
13648 && IS_BITSIZE (pcrval + 4, 25)
13649 && MATCH (nextopc, addiu_insn)
13650 && OP32_TREG (nextopc) == OP32_SREG (nextopc)
13651 && OP16_VALID_REG (OP32_TREG (nextopc)))
13652 {
13653 /* Fix the relocation's type. */
13654 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2);
13655
13656 /* Replace ADDIU with the ADDIUPC version. */
13657 nextopc = (addiupc_insn.match
13658 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc)));
13659
d21911ea
MR
13660 bfd_put_micromips_32 (abfd, nextopc,
13661 contents + irel[1].r_offset);
df58fc94
RS
13662 }
13663
13664 /* Can't do anything, give up, sigh... */
13665 else
13666 continue;
13667
13668 /* Fix the relocation's type. */
13669 irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE);
13670
13671 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */
13672 delcnt = 4;
13673 deloff = 0;
13674 }
13675
13676 /* Compact branch relaxation -- due to the multitude of macros
13677 employed by the compiler/assembler, compact branches are not
13678 always generated. Obviously, this can/will be fixed elsewhere,
13679 but there is no drawback in double checking it here. */
13680 else if (r_type == R_MICROMIPS_PC16_S1
13681 && irel->r_offset + 5 < sec->size
13682 && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
13683 || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0)
833794fc
MR
13684 && ((!insn32
13685 && (delcnt = MATCH (bfd_get_16 (abfd, ptr + 4),
13686 nop_insn_16) ? 2 : 0))
13687 || (irel->r_offset + 7 < sec->size
13688 && (delcnt = MATCH (bfd_get_micromips_32 (abfd,
13689 ptr + 4),
13690 nop_insn_32) ? 4 : 0))))
df58fc94
RS
13691 {
13692 unsigned long reg;
13693
13694 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
13695
13696 /* Replace BEQZ/BNEZ with the compact version. */
13697 opcode = (bzc_insns_32[fndopc].match
13698 | BZC32_REG_FIELD (reg)
13699 | (opcode & 0xffff)); /* Addend value. */
13700
d21911ea 13701 bfd_put_micromips_32 (abfd, opcode, ptr);
df58fc94 13702
833794fc
MR
13703 /* Delete the delay slot NOP: two or four bytes from
13704 irel->offset + 4; delcnt has already been set above. */
df58fc94
RS
13705 deloff = 4;
13706 }
13707
13708 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need
13709 to check the distance from the next instruction, so subtract 2. */
833794fc
MR
13710 else if (!insn32
13711 && r_type == R_MICROMIPS_PC16_S1
df58fc94
RS
13712 && IS_BITSIZE (pcrval - 2, 11)
13713 && find_match (opcode, b_insns_32) >= 0)
13714 {
13715 /* Fix the relocation's type. */
13716 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1);
13717
a8685210 13718 /* Replace the 32-bit opcode with a 16-bit opcode. */
df58fc94
RS
13719 bfd_put_16 (abfd,
13720 (b_insn_16.match
13721 | (opcode & 0x3ff)), /* Addend value. */
2309ddf2 13722 ptr);
df58fc94
RS
13723
13724 /* Delete 2 bytes from irel->r_offset + 2. */
13725 delcnt = 2;
13726 deloff = 2;
13727 }
13728
13729 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need
13730 to check the distance from the next instruction, so subtract 2. */
833794fc
MR
13731 else if (!insn32
13732 && r_type == R_MICROMIPS_PC16_S1
df58fc94
RS
13733 && IS_BITSIZE (pcrval - 2, 8)
13734 && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
13735 && OP16_VALID_REG (OP32_SREG (opcode)))
13736 || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0
13737 && OP16_VALID_REG (OP32_TREG (opcode)))))
13738 {
13739 unsigned long reg;
13740
13741 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
13742
13743 /* Fix the relocation's type. */
13744 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1);
13745
a8685210 13746 /* Replace the 32-bit opcode with a 16-bit opcode. */
df58fc94
RS
13747 bfd_put_16 (abfd,
13748 (bz_insns_16[fndopc].match
13749 | BZ16_REG_FIELD (reg)
13750 | (opcode & 0x7f)), /* Addend value. */
2309ddf2 13751 ptr);
df58fc94
RS
13752
13753 /* Delete 2 bytes from irel->r_offset + 2. */
13754 delcnt = 2;
13755 deloff = 2;
13756 }
13757
13758 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */
833794fc
MR
13759 else if (!insn32
13760 && r_type == R_MICROMIPS_26_S1
df58fc94
RS
13761 && target_is_micromips_code_p
13762 && irel->r_offset + 7 < sec->size
13763 && MATCH (opcode, jal_insn_32_bd32))
13764 {
13765 unsigned long n32opc;
13766 bfd_boolean relaxed = FALSE;
13767
d21911ea 13768 n32opc = bfd_get_micromips_32 (abfd, ptr + 4);
df58fc94
RS
13769
13770 if (MATCH (n32opc, nop_insn_32))
13771 {
13772 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */
2309ddf2 13773 bfd_put_16 (abfd, nop_insn_16.match, ptr + 4);
df58fc94
RS
13774
13775 relaxed = TRUE;
13776 }
13777 else if (find_match (n32opc, move_insns_32) >= 0)
13778 {
13779 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */
13780 bfd_put_16 (abfd,
13781 (move_insn_16.match
13782 | MOVE16_RD_FIELD (MOVE32_RD (n32opc))
13783 | MOVE16_RS_FIELD (MOVE32_RS (n32opc))),
2309ddf2 13784 ptr + 4);
df58fc94
RS
13785
13786 relaxed = TRUE;
13787 }
13788 /* Other 32-bit instructions relaxable to 16-bit
13789 instructions will be handled here later. */
13790
13791 if (relaxed)
13792 {
13793 /* JAL with 32-bit delay slot that is changed to a JALS
13794 with 16-bit delay slot. */
d21911ea 13795 bfd_put_micromips_32 (abfd, jal_insn_32_bd16.match, ptr);
df58fc94
RS
13796
13797 /* Delete 2 bytes from irel->r_offset + 6. */
13798 delcnt = 2;
13799 deloff = 6;
13800 }
13801 }
13802
13803 if (delcnt != 0)
13804 {
13805 /* Note that we've changed the relocs, section contents, etc. */
13806 elf_section_data (sec)->relocs = internal_relocs;
13807 elf_section_data (sec)->this_hdr.contents = contents;
13808 symtab_hdr->contents = (unsigned char *) isymbuf;
13809
13810 /* Delete bytes depending on the delcnt and deloff. */
13811 if (!mips_elf_relax_delete_bytes (abfd, sec,
13812 irel->r_offset + deloff, delcnt))
13813 goto error_return;
13814
13815 /* That will change things, so we should relax again.
13816 Note that this is not required, and it may be slow. */
13817 *again = TRUE;
13818 }
13819 }
13820
13821 if (isymbuf != NULL
13822 && symtab_hdr->contents != (unsigned char *) isymbuf)
13823 {
13824 if (! link_info->keep_memory)
13825 free (isymbuf);
13826 else
13827 {
13828 /* Cache the symbols for elf_link_input_bfd. */
13829 symtab_hdr->contents = (unsigned char *) isymbuf;
13830 }
13831 }
13832
13833 if (contents != NULL
13834 && elf_section_data (sec)->this_hdr.contents != contents)
13835 {
13836 if (! link_info->keep_memory)
13837 free (contents);
13838 else
13839 {
13840 /* Cache the section contents for elf_link_input_bfd. */
13841 elf_section_data (sec)->this_hdr.contents = contents;
13842 }
13843 }
13844
13845 if (internal_relocs != NULL
13846 && elf_section_data (sec)->relocs != internal_relocs)
13847 free (internal_relocs);
13848
13849 return TRUE;
13850
13851 error_return:
13852 if (isymbuf != NULL
13853 && symtab_hdr->contents != (unsigned char *) isymbuf)
13854 free (isymbuf);
13855 if (contents != NULL
13856 && elf_section_data (sec)->this_hdr.contents != contents)
13857 free (contents);
13858 if (internal_relocs != NULL
13859 && elf_section_data (sec)->relocs != internal_relocs)
13860 free (internal_relocs);
13861
13862 return FALSE;
13863}
13864\f
b49e97c9
TS
13865/* Create a MIPS ELF linker hash table. */
13866
13867struct bfd_link_hash_table *
9719ad41 13868_bfd_mips_elf_link_hash_table_create (bfd *abfd)
b49e97c9
TS
13869{
13870 struct mips_elf_link_hash_table *ret;
13871 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
13872
7bf52ea2 13873 ret = bfd_zmalloc (amt);
9719ad41 13874 if (ret == NULL)
b49e97c9
TS
13875 return NULL;
13876
66eb6687
AM
13877 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
13878 mips_elf_link_hash_newfunc,
4dfe6ac6
NC
13879 sizeof (struct mips_elf_link_hash_entry),
13880 MIPS_ELF_DATA))
b49e97c9 13881 {
e2d34d7d 13882 free (ret);
b49e97c9
TS
13883 return NULL;
13884 }
1bbce132
MR
13885 ret->root.init_plt_refcount.plist = NULL;
13886 ret->root.init_plt_offset.plist = NULL;
b49e97c9 13887
b49e97c9
TS
13888 return &ret->root.root;
13889}
0a44bf69
RS
13890
13891/* Likewise, but indicate that the target is VxWorks. */
13892
13893struct bfd_link_hash_table *
13894_bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
13895{
13896 struct bfd_link_hash_table *ret;
13897
13898 ret = _bfd_mips_elf_link_hash_table_create (abfd);
13899 if (ret)
13900 {
13901 struct mips_elf_link_hash_table *htab;
13902
13903 htab = (struct mips_elf_link_hash_table *) ret;
861fb55a
DJ
13904 htab->use_plts_and_copy_relocs = TRUE;
13905 htab->is_vxworks = TRUE;
0a44bf69
RS
13906 }
13907 return ret;
13908}
861fb55a
DJ
13909
13910/* A function that the linker calls if we are allowed to use PLTs
13911 and copy relocs. */
13912
13913void
13914_bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
13915{
13916 mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
13917}
833794fc
MR
13918
13919/* A function that the linker calls to select between all or only
13920 32-bit microMIPS instructions. */
13921
13922void
13923_bfd_mips_elf_insn32 (struct bfd_link_info *info, bfd_boolean on)
13924{
13925 mips_elf_hash_table (info)->insn32 = on;
13926}
b49e97c9 13927\f
351cdf24
MF
13928/* Return the .MIPS.abiflags value representing each ISA Extension. */
13929
13930unsigned int
13931bfd_mips_isa_ext (bfd *abfd)
13932{
13933 switch (bfd_get_mach (abfd))
13934 {
13935 case bfd_mach_mips3900:
13936 return AFL_EXT_3900;
13937 case bfd_mach_mips4010:
13938 return AFL_EXT_4010;
13939 case bfd_mach_mips4100:
13940 return AFL_EXT_4100;
13941 case bfd_mach_mips4111:
13942 return AFL_EXT_4111;
13943 case bfd_mach_mips4120:
13944 return AFL_EXT_4120;
13945 case bfd_mach_mips4650:
13946 return AFL_EXT_4650;
13947 case bfd_mach_mips5400:
13948 return AFL_EXT_5400;
13949 case bfd_mach_mips5500:
13950 return AFL_EXT_5500;
13951 case bfd_mach_mips5900:
13952 return AFL_EXT_5900;
13953 case bfd_mach_mips10000:
13954 return AFL_EXT_10000;
13955 case bfd_mach_mips_loongson_2e:
13956 return AFL_EXT_LOONGSON_2E;
13957 case bfd_mach_mips_loongson_2f:
13958 return AFL_EXT_LOONGSON_2F;
13959 case bfd_mach_mips_loongson_3a:
13960 return AFL_EXT_LOONGSON_3A;
13961 case bfd_mach_mips_sb1:
13962 return AFL_EXT_SB1;
13963 case bfd_mach_mips_octeon:
13964 return AFL_EXT_OCTEON;
13965 case bfd_mach_mips_octeonp:
13966 return AFL_EXT_OCTEONP;
2c629856
N
13967 case bfd_mach_mips_octeon3:
13968 return AFL_EXT_OCTEON3;
351cdf24
MF
13969 case bfd_mach_mips_octeon2:
13970 return AFL_EXT_OCTEON2;
13971 case bfd_mach_mips_xlr:
13972 return AFL_EXT_XLR;
13973 }
13974 return 0;
13975}
13976
13977/* Update the isa_level, isa_rev, isa_ext fields of abiflags. */
13978
13979static void
13980update_mips_abiflags_isa (bfd *abfd, Elf_Internal_ABIFlags_v0 *abiflags)
13981{
13982 switch (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH)
13983 {
13984 case E_MIPS_ARCH_1:
13985 abiflags->isa_level = 1;
13986 abiflags->isa_rev = 0;
13987 break;
13988 case E_MIPS_ARCH_2:
13989 abiflags->isa_level = 2;
13990 abiflags->isa_rev = 0;
13991 break;
13992 case E_MIPS_ARCH_3:
13993 abiflags->isa_level = 3;
13994 abiflags->isa_rev = 0;
13995 break;
13996 case E_MIPS_ARCH_4:
13997 abiflags->isa_level = 4;
13998 abiflags->isa_rev = 0;
13999 break;
14000 case E_MIPS_ARCH_5:
14001 abiflags->isa_level = 5;
14002 abiflags->isa_rev = 0;
14003 break;
14004 case E_MIPS_ARCH_32:
14005 abiflags->isa_level = 32;
14006 abiflags->isa_rev = 1;
14007 break;
14008 case E_MIPS_ARCH_32R2:
14009 abiflags->isa_level = 32;
14010 /* Handle MIPS32r3 and MIPS32r5 which do not have a header flag. */
14011 if (abiflags->isa_rev < 2)
14012 abiflags->isa_rev = 2;
14013 break;
09c14161
MF
14014 case E_MIPS_ARCH_32R6:
14015 abiflags->isa_level = 32;
14016 abiflags->isa_rev = 6;
14017 break;
351cdf24
MF
14018 case E_MIPS_ARCH_64:
14019 abiflags->isa_level = 64;
14020 abiflags->isa_rev = 1;
14021 break;
14022 case E_MIPS_ARCH_64R2:
14023 /* Handle MIPS64r3 and MIPS64r5 which do not have a header flag. */
14024 abiflags->isa_level = 64;
14025 if (abiflags->isa_rev < 2)
14026 abiflags->isa_rev = 2;
14027 break;
09c14161
MF
14028 case E_MIPS_ARCH_64R6:
14029 abiflags->isa_level = 64;
14030 abiflags->isa_rev = 6;
14031 break;
351cdf24
MF
14032 default:
14033 (*_bfd_error_handler)
14034 (_("%B: Unknown architecture %s"),
14035 abfd, bfd_printable_name (abfd));
14036 }
14037
14038 abiflags->isa_ext = bfd_mips_isa_ext (abfd);
14039}
14040
14041/* Return true if the given ELF header flags describe a 32-bit binary. */
14042
14043static bfd_boolean
14044mips_32bit_flags_p (flagword flags)
14045{
14046 return ((flags & EF_MIPS_32BITMODE) != 0
14047 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
14048 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
14049 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
14050 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
14051 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
7361da2c
AB
14052 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2
14053 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6);
351cdf24
MF
14054}
14055
14056/* Infer the content of the ABI flags based on the elf header. */
14057
14058static void
14059infer_mips_abiflags (bfd *abfd, Elf_Internal_ABIFlags_v0* abiflags)
14060{
14061 obj_attribute *in_attr;
14062
14063 memset (abiflags, 0, sizeof (Elf_Internal_ABIFlags_v0));
14064 update_mips_abiflags_isa (abfd, abiflags);
14065
14066 if (mips_32bit_flags_p (elf_elfheader (abfd)->e_flags))
14067 abiflags->gpr_size = AFL_REG_32;
14068 else
14069 abiflags->gpr_size = AFL_REG_64;
14070
14071 abiflags->cpr1_size = AFL_REG_NONE;
14072
14073 in_attr = elf_known_obj_attributes (abfd)[OBJ_ATTR_GNU];
14074 abiflags->fp_abi = in_attr[Tag_GNU_MIPS_ABI_FP].i;
14075
14076 if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_SINGLE
14077 || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_XX
14078 || (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
14079 && abiflags->gpr_size == AFL_REG_32))
14080 abiflags->cpr1_size = AFL_REG_32;
14081 else if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
14082 || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64
14083 || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64A)
14084 abiflags->cpr1_size = AFL_REG_64;
14085
14086 abiflags->cpr2_size = AFL_REG_NONE;
14087
14088 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
14089 abiflags->ases |= AFL_ASE_MDMX;
14090 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
14091 abiflags->ases |= AFL_ASE_MIPS16;
14092 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
14093 abiflags->ases |= AFL_ASE_MICROMIPS;
14094
14095 if (abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_ANY
14096 && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_SOFT
14097 && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_64A
14098 && abiflags->isa_level >= 32
14099 && abiflags->isa_ext != AFL_EXT_LOONGSON_3A)
14100 abiflags->flags1 |= AFL_FLAGS1_ODDSPREG;
14101}
14102
b49e97c9
TS
14103/* We need to use a special link routine to handle the .reginfo and
14104 the .mdebug sections. We need to merge all instances of these
14105 sections together, not write them all out sequentially. */
14106
b34976b6 14107bfd_boolean
9719ad41 14108_bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
b49e97c9 14109{
b49e97c9
TS
14110 asection *o;
14111 struct bfd_link_order *p;
14112 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
351cdf24 14113 asection *rtproc_sec, *abiflags_sec;
b49e97c9
TS
14114 Elf32_RegInfo reginfo;
14115 struct ecoff_debug_info debug;
861fb55a 14116 struct mips_htab_traverse_info hti;
7a2a6943
NC
14117 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
14118 const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
b49e97c9 14119 HDRR *symhdr = &debug.symbolic_header;
9719ad41 14120 void *mdebug_handle = NULL;
b49e97c9
TS
14121 asection *s;
14122 EXTR esym;
14123 unsigned int i;
14124 bfd_size_type amt;
0a44bf69 14125 struct mips_elf_link_hash_table *htab;
b49e97c9
TS
14126
14127 static const char * const secname[] =
14128 {
14129 ".text", ".init", ".fini", ".data",
14130 ".rodata", ".sdata", ".sbss", ".bss"
14131 };
14132 static const int sc[] =
14133 {
14134 scText, scInit, scFini, scData,
14135 scRData, scSData, scSBss, scBss
14136 };
14137
d4596a51
RS
14138 /* Sort the dynamic symbols so that those with GOT entries come after
14139 those without. */
0a44bf69 14140 htab = mips_elf_hash_table (info);
4dfe6ac6
NC
14141 BFD_ASSERT (htab != NULL);
14142
d4596a51
RS
14143 if (!mips_elf_sort_hash_table (abfd, info))
14144 return FALSE;
b49e97c9 14145
861fb55a
DJ
14146 /* Create any scheduled LA25 stubs. */
14147 hti.info = info;
14148 hti.output_bfd = abfd;
14149 hti.error = FALSE;
14150 htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
14151 if (hti.error)
14152 return FALSE;
14153
b49e97c9
TS
14154 /* Get a value for the GP register. */
14155 if (elf_gp (abfd) == 0)
14156 {
14157 struct bfd_link_hash_entry *h;
14158
b34976b6 14159 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
9719ad41 14160 if (h != NULL && h->type == bfd_link_hash_defined)
b49e97c9
TS
14161 elf_gp (abfd) = (h->u.def.value
14162 + h->u.def.section->output_section->vma
14163 + h->u.def.section->output_offset);
0a44bf69
RS
14164 else if (htab->is_vxworks
14165 && (h = bfd_link_hash_lookup (info->hash,
14166 "_GLOBAL_OFFSET_TABLE_",
14167 FALSE, FALSE, TRUE))
14168 && h->type == bfd_link_hash_defined)
14169 elf_gp (abfd) = (h->u.def.section->output_section->vma
14170 + h->u.def.section->output_offset
14171 + h->u.def.value);
1049f94e 14172 else if (info->relocatable)
b49e97c9
TS
14173 {
14174 bfd_vma lo = MINUS_ONE;
14175
14176 /* Find the GP-relative section with the lowest offset. */
9719ad41 14177 for (o = abfd->sections; o != NULL; o = o->next)
b49e97c9
TS
14178 if (o->vma < lo
14179 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
14180 lo = o->vma;
14181
14182 /* And calculate GP relative to that. */
0a44bf69 14183 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
b49e97c9
TS
14184 }
14185 else
14186 {
14187 /* If the relocate_section function needs to do a reloc
14188 involving the GP value, it should make a reloc_dangerous
14189 callback to warn that GP is not defined. */
14190 }
14191 }
14192
14193 /* Go through the sections and collect the .reginfo and .mdebug
14194 information. */
351cdf24 14195 abiflags_sec = NULL;
b49e97c9
TS
14196 reginfo_sec = NULL;
14197 mdebug_sec = NULL;
14198 gptab_data_sec = NULL;
14199 gptab_bss_sec = NULL;
9719ad41 14200 for (o = abfd->sections; o != NULL; o = o->next)
b49e97c9 14201 {
351cdf24
MF
14202 if (strcmp (o->name, ".MIPS.abiflags") == 0)
14203 {
14204 /* We have found the .MIPS.abiflags section in the output file.
14205 Look through all the link_orders comprising it and remove them.
14206 The data is merged in _bfd_mips_elf_merge_private_bfd_data. */
14207 for (p = o->map_head.link_order; p != NULL; p = p->next)
14208 {
14209 asection *input_section;
14210
14211 if (p->type != bfd_indirect_link_order)
14212 {
14213 if (p->type == bfd_data_link_order)
14214 continue;
14215 abort ();
14216 }
14217
14218 input_section = p->u.indirect.section;
14219
14220 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14221 elf_link_input_bfd ignores this section. */
14222 input_section->flags &= ~SEC_HAS_CONTENTS;
14223 }
14224
14225 /* Size has been set in _bfd_mips_elf_always_size_sections. */
14226 BFD_ASSERT(o->size == sizeof (Elf_External_ABIFlags_v0));
14227
14228 /* Skip this section later on (I don't think this currently
14229 matters, but someday it might). */
14230 o->map_head.link_order = NULL;
14231
14232 abiflags_sec = o;
14233 }
14234
b49e97c9
TS
14235 if (strcmp (o->name, ".reginfo") == 0)
14236 {
14237 memset (&reginfo, 0, sizeof reginfo);
14238
14239 /* We have found the .reginfo section in the output file.
14240 Look through all the link_orders comprising it and merge
14241 the information together. */
8423293d 14242 for (p = o->map_head.link_order; p != NULL; p = p->next)
b49e97c9
TS
14243 {
14244 asection *input_section;
14245 bfd *input_bfd;
14246 Elf32_External_RegInfo ext;
14247 Elf32_RegInfo sub;
14248
14249 if (p->type != bfd_indirect_link_order)
14250 {
14251 if (p->type == bfd_data_link_order)
14252 continue;
14253 abort ();
14254 }
14255
14256 input_section = p->u.indirect.section;
14257 input_bfd = input_section->owner;
14258
b49e97c9 14259 if (! bfd_get_section_contents (input_bfd, input_section,
9719ad41 14260 &ext, 0, sizeof ext))
b34976b6 14261 return FALSE;
b49e97c9
TS
14262
14263 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
14264
14265 reginfo.ri_gprmask |= sub.ri_gprmask;
14266 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
14267 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
14268 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
14269 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
14270
14271 /* ri_gp_value is set by the function
14272 mips_elf32_section_processing when the section is
14273 finally written out. */
14274
14275 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14276 elf_link_input_bfd ignores this section. */
14277 input_section->flags &= ~SEC_HAS_CONTENTS;
14278 }
14279
14280 /* Size has been set in _bfd_mips_elf_always_size_sections. */
eea6121a 14281 BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
b49e97c9
TS
14282
14283 /* Skip this section later on (I don't think this currently
14284 matters, but someday it might). */
8423293d 14285 o->map_head.link_order = NULL;
b49e97c9
TS
14286
14287 reginfo_sec = o;
14288 }
14289
14290 if (strcmp (o->name, ".mdebug") == 0)
14291 {
14292 struct extsym_info einfo;
14293 bfd_vma last;
14294
14295 /* We have found the .mdebug section in the output file.
14296 Look through all the link_orders comprising it and merge
14297 the information together. */
14298 symhdr->magic = swap->sym_magic;
14299 /* FIXME: What should the version stamp be? */
14300 symhdr->vstamp = 0;
14301 symhdr->ilineMax = 0;
14302 symhdr->cbLine = 0;
14303 symhdr->idnMax = 0;
14304 symhdr->ipdMax = 0;
14305 symhdr->isymMax = 0;
14306 symhdr->ioptMax = 0;
14307 symhdr->iauxMax = 0;
14308 symhdr->issMax = 0;
14309 symhdr->issExtMax = 0;
14310 symhdr->ifdMax = 0;
14311 symhdr->crfd = 0;
14312 symhdr->iextMax = 0;
14313
14314 /* We accumulate the debugging information itself in the
14315 debug_info structure. */
14316 debug.line = NULL;
14317 debug.external_dnr = NULL;
14318 debug.external_pdr = NULL;
14319 debug.external_sym = NULL;
14320 debug.external_opt = NULL;
14321 debug.external_aux = NULL;
14322 debug.ss = NULL;
14323 debug.ssext = debug.ssext_end = NULL;
14324 debug.external_fdr = NULL;
14325 debug.external_rfd = NULL;
14326 debug.external_ext = debug.external_ext_end = NULL;
14327
14328 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
9719ad41 14329 if (mdebug_handle == NULL)
b34976b6 14330 return FALSE;
b49e97c9
TS
14331
14332 esym.jmptbl = 0;
14333 esym.cobol_main = 0;
14334 esym.weakext = 0;
14335 esym.reserved = 0;
14336 esym.ifd = ifdNil;
14337 esym.asym.iss = issNil;
14338 esym.asym.st = stLocal;
14339 esym.asym.reserved = 0;
14340 esym.asym.index = indexNil;
14341 last = 0;
14342 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
14343 {
14344 esym.asym.sc = sc[i];
14345 s = bfd_get_section_by_name (abfd, secname[i]);
14346 if (s != NULL)
14347 {
14348 esym.asym.value = s->vma;
eea6121a 14349 last = s->vma + s->size;
b49e97c9
TS
14350 }
14351 else
14352 esym.asym.value = last;
14353 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
14354 secname[i], &esym))
b34976b6 14355 return FALSE;
b49e97c9
TS
14356 }
14357
8423293d 14358 for (p = o->map_head.link_order; p != NULL; p = p->next)
b49e97c9
TS
14359 {
14360 asection *input_section;
14361 bfd *input_bfd;
14362 const struct ecoff_debug_swap *input_swap;
14363 struct ecoff_debug_info input_debug;
14364 char *eraw_src;
14365 char *eraw_end;
14366
14367 if (p->type != bfd_indirect_link_order)
14368 {
14369 if (p->type == bfd_data_link_order)
14370 continue;
14371 abort ();
14372 }
14373
14374 input_section = p->u.indirect.section;
14375 input_bfd = input_section->owner;
14376
d5eaccd7 14377 if (!is_mips_elf (input_bfd))
b49e97c9
TS
14378 {
14379 /* I don't know what a non MIPS ELF bfd would be
14380 doing with a .mdebug section, but I don't really
14381 want to deal with it. */
14382 continue;
14383 }
14384
14385 input_swap = (get_elf_backend_data (input_bfd)
14386 ->elf_backend_ecoff_debug_swap);
14387
eea6121a 14388 BFD_ASSERT (p->size == input_section->size);
b49e97c9
TS
14389
14390 /* The ECOFF linking code expects that we have already
14391 read in the debugging information and set up an
14392 ecoff_debug_info structure, so we do that now. */
14393 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
14394 &input_debug))
b34976b6 14395 return FALSE;
b49e97c9
TS
14396
14397 if (! (bfd_ecoff_debug_accumulate
14398 (mdebug_handle, abfd, &debug, swap, input_bfd,
14399 &input_debug, input_swap, info)))
b34976b6 14400 return FALSE;
b49e97c9
TS
14401
14402 /* Loop through the external symbols. For each one with
14403 interesting information, try to find the symbol in
14404 the linker global hash table and save the information
14405 for the output external symbols. */
14406 eraw_src = input_debug.external_ext;
14407 eraw_end = (eraw_src
14408 + (input_debug.symbolic_header.iextMax
14409 * input_swap->external_ext_size));
14410 for (;
14411 eraw_src < eraw_end;
14412 eraw_src += input_swap->external_ext_size)
14413 {
14414 EXTR ext;
14415 const char *name;
14416 struct mips_elf_link_hash_entry *h;
14417
9719ad41 14418 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
b49e97c9
TS
14419 if (ext.asym.sc == scNil
14420 || ext.asym.sc == scUndefined
14421 || ext.asym.sc == scSUndefined)
14422 continue;
14423
14424 name = input_debug.ssext + ext.asym.iss;
14425 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
b34976b6 14426 name, FALSE, FALSE, TRUE);
b49e97c9
TS
14427 if (h == NULL || h->esym.ifd != -2)
14428 continue;
14429
14430 if (ext.ifd != -1)
14431 {
14432 BFD_ASSERT (ext.ifd
14433 < input_debug.symbolic_header.ifdMax);
14434 ext.ifd = input_debug.ifdmap[ext.ifd];
14435 }
14436
14437 h->esym = ext;
14438 }
14439
14440 /* Free up the information we just read. */
14441 free (input_debug.line);
14442 free (input_debug.external_dnr);
14443 free (input_debug.external_pdr);
14444 free (input_debug.external_sym);
14445 free (input_debug.external_opt);
14446 free (input_debug.external_aux);
14447 free (input_debug.ss);
14448 free (input_debug.ssext);
14449 free (input_debug.external_fdr);
14450 free (input_debug.external_rfd);
14451 free (input_debug.external_ext);
14452
14453 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14454 elf_link_input_bfd ignores this section. */
14455 input_section->flags &= ~SEC_HAS_CONTENTS;
14456 }
14457
14458 if (SGI_COMPAT (abfd) && info->shared)
14459 {
14460 /* Create .rtproc section. */
87e0a731 14461 rtproc_sec = bfd_get_linker_section (abfd, ".rtproc");
b49e97c9
TS
14462 if (rtproc_sec == NULL)
14463 {
14464 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
14465 | SEC_LINKER_CREATED | SEC_READONLY);
14466
87e0a731
AM
14467 rtproc_sec = bfd_make_section_anyway_with_flags (abfd,
14468 ".rtproc",
14469 flags);
b49e97c9 14470 if (rtproc_sec == NULL
b49e97c9 14471 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
b34976b6 14472 return FALSE;
b49e97c9
TS
14473 }
14474
14475 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
14476 info, rtproc_sec,
14477 &debug))
b34976b6 14478 return FALSE;
b49e97c9
TS
14479 }
14480
14481 /* Build the external symbol information. */
14482 einfo.abfd = abfd;
14483 einfo.info = info;
14484 einfo.debug = &debug;
14485 einfo.swap = swap;
b34976b6 14486 einfo.failed = FALSE;
b49e97c9 14487 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
9719ad41 14488 mips_elf_output_extsym, &einfo);
b49e97c9 14489 if (einfo.failed)
b34976b6 14490 return FALSE;
b49e97c9
TS
14491
14492 /* Set the size of the .mdebug section. */
eea6121a 14493 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
b49e97c9
TS
14494
14495 /* Skip this section later on (I don't think this currently
14496 matters, but someday it might). */
8423293d 14497 o->map_head.link_order = NULL;
b49e97c9
TS
14498
14499 mdebug_sec = o;
14500 }
14501
0112cd26 14502 if (CONST_STRNEQ (o->name, ".gptab."))
b49e97c9
TS
14503 {
14504 const char *subname;
14505 unsigned int c;
14506 Elf32_gptab *tab;
14507 Elf32_External_gptab *ext_tab;
14508 unsigned int j;
14509
14510 /* The .gptab.sdata and .gptab.sbss sections hold
14511 information describing how the small data area would
14512 change depending upon the -G switch. These sections
14513 not used in executables files. */
1049f94e 14514 if (! info->relocatable)
b49e97c9 14515 {
8423293d 14516 for (p = o->map_head.link_order; p != NULL; p = p->next)
b49e97c9
TS
14517 {
14518 asection *input_section;
14519
14520 if (p->type != bfd_indirect_link_order)
14521 {
14522 if (p->type == bfd_data_link_order)
14523 continue;
14524 abort ();
14525 }
14526
14527 input_section = p->u.indirect.section;
14528
14529 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14530 elf_link_input_bfd ignores this section. */
14531 input_section->flags &= ~SEC_HAS_CONTENTS;
14532 }
14533
14534 /* Skip this section later on (I don't think this
14535 currently matters, but someday it might). */
8423293d 14536 o->map_head.link_order = NULL;
b49e97c9
TS
14537
14538 /* Really remove the section. */
5daa8fe7 14539 bfd_section_list_remove (abfd, o);
b49e97c9
TS
14540 --abfd->section_count;
14541
14542 continue;
14543 }
14544
14545 /* There is one gptab for initialized data, and one for
14546 uninitialized data. */
14547 if (strcmp (o->name, ".gptab.sdata") == 0)
14548 gptab_data_sec = o;
14549 else if (strcmp (o->name, ".gptab.sbss") == 0)
14550 gptab_bss_sec = o;
14551 else
14552 {
14553 (*_bfd_error_handler)
14554 (_("%s: illegal section name `%s'"),
14555 bfd_get_filename (abfd), o->name);
14556 bfd_set_error (bfd_error_nonrepresentable_section);
b34976b6 14557 return FALSE;
b49e97c9
TS
14558 }
14559
14560 /* The linker script always combines .gptab.data and
14561 .gptab.sdata into .gptab.sdata, and likewise for
14562 .gptab.bss and .gptab.sbss. It is possible that there is
14563 no .sdata or .sbss section in the output file, in which
14564 case we must change the name of the output section. */
14565 subname = o->name + sizeof ".gptab" - 1;
14566 if (bfd_get_section_by_name (abfd, subname) == NULL)
14567 {
14568 if (o == gptab_data_sec)
14569 o->name = ".gptab.data";
14570 else
14571 o->name = ".gptab.bss";
14572 subname = o->name + sizeof ".gptab" - 1;
14573 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
14574 }
14575
14576 /* Set up the first entry. */
14577 c = 1;
14578 amt = c * sizeof (Elf32_gptab);
9719ad41 14579 tab = bfd_malloc (amt);
b49e97c9 14580 if (tab == NULL)
b34976b6 14581 return FALSE;
b49e97c9
TS
14582 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
14583 tab[0].gt_header.gt_unused = 0;
14584
14585 /* Combine the input sections. */
8423293d 14586 for (p = o->map_head.link_order; p != NULL; p = p->next)
b49e97c9
TS
14587 {
14588 asection *input_section;
14589 bfd *input_bfd;
14590 bfd_size_type size;
14591 unsigned long last;
14592 bfd_size_type gpentry;
14593
14594 if (p->type != bfd_indirect_link_order)
14595 {
14596 if (p->type == bfd_data_link_order)
14597 continue;
14598 abort ();
14599 }
14600
14601 input_section = p->u.indirect.section;
14602 input_bfd = input_section->owner;
14603
14604 /* Combine the gptab entries for this input section one
14605 by one. We know that the input gptab entries are
14606 sorted by ascending -G value. */
eea6121a 14607 size = input_section->size;
b49e97c9
TS
14608 last = 0;
14609 for (gpentry = sizeof (Elf32_External_gptab);
14610 gpentry < size;
14611 gpentry += sizeof (Elf32_External_gptab))
14612 {
14613 Elf32_External_gptab ext_gptab;
14614 Elf32_gptab int_gptab;
14615 unsigned long val;
14616 unsigned long add;
b34976b6 14617 bfd_boolean exact;
b49e97c9
TS
14618 unsigned int look;
14619
14620 if (! (bfd_get_section_contents
9719ad41
RS
14621 (input_bfd, input_section, &ext_gptab, gpentry,
14622 sizeof (Elf32_External_gptab))))
b49e97c9
TS
14623 {
14624 free (tab);
b34976b6 14625 return FALSE;
b49e97c9
TS
14626 }
14627
14628 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
14629 &int_gptab);
14630 val = int_gptab.gt_entry.gt_g_value;
14631 add = int_gptab.gt_entry.gt_bytes - last;
14632
b34976b6 14633 exact = FALSE;
b49e97c9
TS
14634 for (look = 1; look < c; look++)
14635 {
14636 if (tab[look].gt_entry.gt_g_value >= val)
14637 tab[look].gt_entry.gt_bytes += add;
14638
14639 if (tab[look].gt_entry.gt_g_value == val)
b34976b6 14640 exact = TRUE;
b49e97c9
TS
14641 }
14642
14643 if (! exact)
14644 {
14645 Elf32_gptab *new_tab;
14646 unsigned int max;
14647
14648 /* We need a new table entry. */
14649 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
9719ad41 14650 new_tab = bfd_realloc (tab, amt);
b49e97c9
TS
14651 if (new_tab == NULL)
14652 {
14653 free (tab);
b34976b6 14654 return FALSE;
b49e97c9
TS
14655 }
14656 tab = new_tab;
14657 tab[c].gt_entry.gt_g_value = val;
14658 tab[c].gt_entry.gt_bytes = add;
14659
14660 /* Merge in the size for the next smallest -G
14661 value, since that will be implied by this new
14662 value. */
14663 max = 0;
14664 for (look = 1; look < c; look++)
14665 {
14666 if (tab[look].gt_entry.gt_g_value < val
14667 && (max == 0
14668 || (tab[look].gt_entry.gt_g_value
14669 > tab[max].gt_entry.gt_g_value)))
14670 max = look;
14671 }
14672 if (max != 0)
14673 tab[c].gt_entry.gt_bytes +=
14674 tab[max].gt_entry.gt_bytes;
14675
14676 ++c;
14677 }
14678
14679 last = int_gptab.gt_entry.gt_bytes;
14680 }
14681
14682 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14683 elf_link_input_bfd ignores this section. */
14684 input_section->flags &= ~SEC_HAS_CONTENTS;
14685 }
14686
14687 /* The table must be sorted by -G value. */
14688 if (c > 2)
14689 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
14690
14691 /* Swap out the table. */
14692 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
9719ad41 14693 ext_tab = bfd_alloc (abfd, amt);
b49e97c9
TS
14694 if (ext_tab == NULL)
14695 {
14696 free (tab);
b34976b6 14697 return FALSE;
b49e97c9
TS
14698 }
14699
14700 for (j = 0; j < c; j++)
14701 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
14702 free (tab);
14703
eea6121a 14704 o->size = c * sizeof (Elf32_External_gptab);
b49e97c9
TS
14705 o->contents = (bfd_byte *) ext_tab;
14706
14707 /* Skip this section later on (I don't think this currently
14708 matters, but someday it might). */
8423293d 14709 o->map_head.link_order = NULL;
b49e97c9
TS
14710 }
14711 }
14712
14713 /* Invoke the regular ELF backend linker to do all the work. */
c152c796 14714 if (!bfd_elf_final_link (abfd, info))
b34976b6 14715 return FALSE;
b49e97c9
TS
14716
14717 /* Now write out the computed sections. */
14718
351cdf24
MF
14719 if (abiflags_sec != NULL)
14720 {
14721 Elf_External_ABIFlags_v0 ext;
14722 Elf_Internal_ABIFlags_v0 *abiflags;
14723
14724 abiflags = &mips_elf_tdata (abfd)->abiflags;
14725
14726 /* Set up the abiflags if no valid input sections were found. */
14727 if (!mips_elf_tdata (abfd)->abiflags_valid)
14728 {
14729 infer_mips_abiflags (abfd, abiflags);
14730 mips_elf_tdata (abfd)->abiflags_valid = TRUE;
14731 }
14732 bfd_mips_elf_swap_abiflags_v0_out (abfd, abiflags, &ext);
14733 if (! bfd_set_section_contents (abfd, abiflags_sec, &ext, 0, sizeof ext))
14734 return FALSE;
14735 }
14736
9719ad41 14737 if (reginfo_sec != NULL)
b49e97c9
TS
14738 {
14739 Elf32_External_RegInfo ext;
14740
14741 bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
9719ad41 14742 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
b34976b6 14743 return FALSE;
b49e97c9
TS
14744 }
14745
9719ad41 14746 if (mdebug_sec != NULL)
b49e97c9
TS
14747 {
14748 BFD_ASSERT (abfd->output_has_begun);
14749 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
14750 swap, info,
14751 mdebug_sec->filepos))
b34976b6 14752 return FALSE;
b49e97c9
TS
14753
14754 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
14755 }
14756
9719ad41 14757 if (gptab_data_sec != NULL)
b49e97c9
TS
14758 {
14759 if (! bfd_set_section_contents (abfd, gptab_data_sec,
14760 gptab_data_sec->contents,
eea6121a 14761 0, gptab_data_sec->size))
b34976b6 14762 return FALSE;
b49e97c9
TS
14763 }
14764
9719ad41 14765 if (gptab_bss_sec != NULL)
b49e97c9
TS
14766 {
14767 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
14768 gptab_bss_sec->contents,
eea6121a 14769 0, gptab_bss_sec->size))
b34976b6 14770 return FALSE;
b49e97c9
TS
14771 }
14772
14773 if (SGI_COMPAT (abfd))
14774 {
14775 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
14776 if (rtproc_sec != NULL)
14777 {
14778 if (! bfd_set_section_contents (abfd, rtproc_sec,
14779 rtproc_sec->contents,
eea6121a 14780 0, rtproc_sec->size))
b34976b6 14781 return FALSE;
b49e97c9
TS
14782 }
14783 }
14784
b34976b6 14785 return TRUE;
b49e97c9
TS
14786}
14787\f
64543e1a
RS
14788/* Structure for saying that BFD machine EXTENSION extends BASE. */
14789
a253d456
NC
14790struct mips_mach_extension
14791{
64543e1a
RS
14792 unsigned long extension, base;
14793};
14794
14795
14796/* An array describing how BFD machines relate to one another. The entries
14797 are ordered topologically with MIPS I extensions listed last. */
14798
a253d456
NC
14799static const struct mips_mach_extension mips_mach_extensions[] =
14800{
6f179bd0 14801 /* MIPS64r2 extensions. */
2c629856 14802 { bfd_mach_mips_octeon3, bfd_mach_mips_octeon2 },
432233b3 14803 { bfd_mach_mips_octeon2, bfd_mach_mips_octeonp },
dd6a37e7 14804 { bfd_mach_mips_octeonp, bfd_mach_mips_octeon },
6f179bd0 14805 { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
4ba154f5 14806 { bfd_mach_mips_loongson_3a, bfd_mach_mipsisa64r2 },
6f179bd0 14807
64543e1a 14808 /* MIPS64 extensions. */
5f74bc13 14809 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
64543e1a 14810 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
52b6b6b9 14811 { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
64543e1a
RS
14812
14813 /* MIPS V extensions. */
14814 { bfd_mach_mipsisa64, bfd_mach_mips5 },
14815
14816 /* R10000 extensions. */
14817 { bfd_mach_mips12000, bfd_mach_mips10000 },
3aa3176b
TS
14818 { bfd_mach_mips14000, bfd_mach_mips10000 },
14819 { bfd_mach_mips16000, bfd_mach_mips10000 },
64543e1a
RS
14820
14821 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
14822 vr5400 ISA, but doesn't include the multimedia stuff. It seems
14823 better to allow vr5400 and vr5500 code to be merged anyway, since
14824 many libraries will just use the core ISA. Perhaps we could add
14825 some sort of ASE flag if this ever proves a problem. */
14826 { bfd_mach_mips5500, bfd_mach_mips5400 },
14827 { bfd_mach_mips5400, bfd_mach_mips5000 },
14828
14829 /* MIPS IV extensions. */
14830 { bfd_mach_mips5, bfd_mach_mips8000 },
14831 { bfd_mach_mips10000, bfd_mach_mips8000 },
14832 { bfd_mach_mips5000, bfd_mach_mips8000 },
5a7ea749 14833 { bfd_mach_mips7000, bfd_mach_mips8000 },
0d2e43ed 14834 { bfd_mach_mips9000, bfd_mach_mips8000 },
64543e1a
RS
14835
14836 /* VR4100 extensions. */
14837 { bfd_mach_mips4120, bfd_mach_mips4100 },
14838 { bfd_mach_mips4111, bfd_mach_mips4100 },
14839
14840 /* MIPS III extensions. */
350cc38d
MS
14841 { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
14842 { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
64543e1a
RS
14843 { bfd_mach_mips8000, bfd_mach_mips4000 },
14844 { bfd_mach_mips4650, bfd_mach_mips4000 },
14845 { bfd_mach_mips4600, bfd_mach_mips4000 },
14846 { bfd_mach_mips4400, bfd_mach_mips4000 },
14847 { bfd_mach_mips4300, bfd_mach_mips4000 },
14848 { bfd_mach_mips4100, bfd_mach_mips4000 },
14849 { bfd_mach_mips4010, bfd_mach_mips4000 },
e407c74b 14850 { bfd_mach_mips5900, bfd_mach_mips4000 },
64543e1a
RS
14851
14852 /* MIPS32 extensions. */
14853 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
14854
14855 /* MIPS II extensions. */
14856 { bfd_mach_mips4000, bfd_mach_mips6000 },
14857 { bfd_mach_mipsisa32, bfd_mach_mips6000 },
14858
14859 /* MIPS I extensions. */
14860 { bfd_mach_mips6000, bfd_mach_mips3000 },
14861 { bfd_mach_mips3900, bfd_mach_mips3000 }
14862};
14863
14864
14865/* Return true if bfd machine EXTENSION is an extension of machine BASE. */
14866
14867static bfd_boolean
9719ad41 14868mips_mach_extends_p (unsigned long base, unsigned long extension)
64543e1a
RS
14869{
14870 size_t i;
14871
c5211a54
RS
14872 if (extension == base)
14873 return TRUE;
14874
14875 if (base == bfd_mach_mipsisa32
14876 && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
14877 return TRUE;
14878
14879 if (base == bfd_mach_mipsisa32r2
14880 && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
14881 return TRUE;
14882
14883 for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
64543e1a 14884 if (extension == mips_mach_extensions[i].extension)
c5211a54
RS
14885 {
14886 extension = mips_mach_extensions[i].base;
14887 if (extension == base)
14888 return TRUE;
14889 }
64543e1a 14890
c5211a54 14891 return FALSE;
64543e1a
RS
14892}
14893
14894
2cf19d5c
JM
14895/* Merge object attributes from IBFD into OBFD. Raise an error if
14896 there are conflicting attributes. */
14897static bfd_boolean
14898mips_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
14899{
14900 obj_attribute *in_attr;
14901 obj_attribute *out_attr;
6ae68ba3 14902 bfd *abi_fp_bfd;
b60bf9be 14903 bfd *abi_msa_bfd;
6ae68ba3
MR
14904
14905 abi_fp_bfd = mips_elf_tdata (obfd)->abi_fp_bfd;
14906 in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
d929bc19 14907 if (!abi_fp_bfd && in_attr[Tag_GNU_MIPS_ABI_FP].i != Val_GNU_MIPS_ABI_FP_ANY)
6ae68ba3 14908 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
2cf19d5c 14909
b60bf9be
CF
14910 abi_msa_bfd = mips_elf_tdata (obfd)->abi_msa_bfd;
14911 if (!abi_msa_bfd
14912 && in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
14913 mips_elf_tdata (obfd)->abi_msa_bfd = ibfd;
14914
2cf19d5c
JM
14915 if (!elf_known_obj_attributes_proc (obfd)[0].i)
14916 {
14917 /* This is the first object. Copy the attributes. */
14918 _bfd_elf_copy_obj_attributes (ibfd, obfd);
14919
14920 /* Use the Tag_null value to indicate the attributes have been
14921 initialized. */
14922 elf_known_obj_attributes_proc (obfd)[0].i = 1;
14923
14924 return TRUE;
14925 }
14926
14927 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
14928 non-conflicting ones. */
2cf19d5c
JM
14929 out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
14930 if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
14931 {
757a636f 14932 int out_fp, in_fp;
6ae68ba3 14933
757a636f
RS
14934 out_fp = out_attr[Tag_GNU_MIPS_ABI_FP].i;
14935 in_fp = in_attr[Tag_GNU_MIPS_ABI_FP].i;
14936 out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
14937 if (out_fp == Val_GNU_MIPS_ABI_FP_ANY)
14938 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_fp;
351cdf24
MF
14939 else if (out_fp == Val_GNU_MIPS_ABI_FP_XX
14940 && (in_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
14941 || in_fp == Val_GNU_MIPS_ABI_FP_64
14942 || in_fp == Val_GNU_MIPS_ABI_FP_64A))
14943 {
14944 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
14945 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
14946 }
14947 else if (in_fp == Val_GNU_MIPS_ABI_FP_XX
14948 && (out_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
14949 || out_fp == Val_GNU_MIPS_ABI_FP_64
14950 || out_fp == Val_GNU_MIPS_ABI_FP_64A))
14951 /* Keep the current setting. */;
14952 else if (out_fp == Val_GNU_MIPS_ABI_FP_64A
14953 && in_fp == Val_GNU_MIPS_ABI_FP_64)
14954 {
14955 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
14956 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
14957 }
14958 else if (in_fp == Val_GNU_MIPS_ABI_FP_64A
14959 && out_fp == Val_GNU_MIPS_ABI_FP_64)
14960 /* Keep the current setting. */;
757a636f
RS
14961 else if (in_fp != Val_GNU_MIPS_ABI_FP_ANY)
14962 {
14963 const char *out_string, *in_string;
6ae68ba3 14964
757a636f
RS
14965 out_string = _bfd_mips_fp_abi_string (out_fp);
14966 in_string = _bfd_mips_fp_abi_string (in_fp);
14967 /* First warn about cases involving unrecognised ABIs. */
14968 if (!out_string && !in_string)
14969 _bfd_error_handler
14970 (_("Warning: %B uses unknown floating point ABI %d "
14971 "(set by %B), %B uses unknown floating point ABI %d"),
14972 obfd, abi_fp_bfd, ibfd, out_fp, in_fp);
14973 else if (!out_string)
14974 _bfd_error_handler
14975 (_("Warning: %B uses unknown floating point ABI %d "
14976 "(set by %B), %B uses %s"),
14977 obfd, abi_fp_bfd, ibfd, out_fp, in_string);
14978 else if (!in_string)
14979 _bfd_error_handler
14980 (_("Warning: %B uses %s (set by %B), "
14981 "%B uses unknown floating point ABI %d"),
14982 obfd, abi_fp_bfd, ibfd, out_string, in_fp);
14983 else
14984 {
14985 /* If one of the bfds is soft-float, the other must be
14986 hard-float. The exact choice of hard-float ABI isn't
14987 really relevant to the error message. */
14988 if (in_fp == Val_GNU_MIPS_ABI_FP_SOFT)
14989 out_string = "-mhard-float";
14990 else if (out_fp == Val_GNU_MIPS_ABI_FP_SOFT)
14991 in_string = "-mhard-float";
14992 _bfd_error_handler
14993 (_("Warning: %B uses %s (set by %B), %B uses %s"),
14994 obfd, abi_fp_bfd, ibfd, out_string, in_string);
14995 }
14996 }
2cf19d5c
JM
14997 }
14998
b60bf9be
CF
14999 /* Check for conflicting Tag_GNU_MIPS_ABI_MSA attributes and merge
15000 non-conflicting ones. */
15001 if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != out_attr[Tag_GNU_MIPS_ABI_MSA].i)
15002 {
15003 out_attr[Tag_GNU_MIPS_ABI_MSA].type = 1;
15004 if (out_attr[Tag_GNU_MIPS_ABI_MSA].i == Val_GNU_MIPS_ABI_MSA_ANY)
15005 out_attr[Tag_GNU_MIPS_ABI_MSA].i = in_attr[Tag_GNU_MIPS_ABI_MSA].i;
15006 else if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
15007 switch (out_attr[Tag_GNU_MIPS_ABI_MSA].i)
15008 {
15009 case Val_GNU_MIPS_ABI_MSA_128:
15010 _bfd_error_handler
15011 (_("Warning: %B uses %s (set by %B), "
15012 "%B uses unknown MSA ABI %d"),
15013 obfd, abi_msa_bfd, ibfd,
15014 "-mmsa", in_attr[Tag_GNU_MIPS_ABI_MSA].i);
15015 break;
15016
15017 default:
15018 switch (in_attr[Tag_GNU_MIPS_ABI_MSA].i)
15019 {
15020 case Val_GNU_MIPS_ABI_MSA_128:
15021 _bfd_error_handler
15022 (_("Warning: %B uses unknown MSA ABI %d "
15023 "(set by %B), %B uses %s"),
15024 obfd, abi_msa_bfd, ibfd,
15025 out_attr[Tag_GNU_MIPS_ABI_MSA].i, "-mmsa");
15026 break;
15027
15028 default:
15029 _bfd_error_handler
15030 (_("Warning: %B uses unknown MSA ABI %d "
15031 "(set by %B), %B uses unknown MSA ABI %d"),
15032 obfd, abi_msa_bfd, ibfd,
15033 out_attr[Tag_GNU_MIPS_ABI_MSA].i,
15034 in_attr[Tag_GNU_MIPS_ABI_MSA].i);
15035 break;
15036 }
15037 }
15038 }
15039
2cf19d5c
JM
15040 /* Merge Tag_compatibility attributes and any common GNU ones. */
15041 _bfd_elf_merge_object_attributes (ibfd, obfd);
15042
15043 return TRUE;
15044}
15045
b49e97c9
TS
15046/* Merge backend specific data from an object file to the output
15047 object file when linking. */
15048
b34976b6 15049bfd_boolean
9719ad41 15050_bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
b49e97c9
TS
15051{
15052 flagword old_flags;
15053 flagword new_flags;
b34976b6
AM
15054 bfd_boolean ok;
15055 bfd_boolean null_input_bfd = TRUE;
b49e97c9 15056 asection *sec;
351cdf24 15057 obj_attribute *out_attr;
b49e97c9 15058
58238693 15059 /* Check if we have the same endianness. */
82e51918 15060 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
aa701218
AO
15061 {
15062 (*_bfd_error_handler)
d003868e
AM
15063 (_("%B: endianness incompatible with that of the selected emulation"),
15064 ibfd);
aa701218
AO
15065 return FALSE;
15066 }
b49e97c9 15067
d5eaccd7 15068 if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
b34976b6 15069 return TRUE;
b49e97c9 15070
aa701218
AO
15071 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
15072 {
15073 (*_bfd_error_handler)
d003868e
AM
15074 (_("%B: ABI is incompatible with that of the selected emulation"),
15075 ibfd);
aa701218
AO
15076 return FALSE;
15077 }
15078
351cdf24
MF
15079 /* Set up the FP ABI attribute from the abiflags if it is not already
15080 set. */
15081 if (mips_elf_tdata (ibfd)->abiflags_valid)
15082 {
15083 obj_attribute *in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
15084 if (in_attr[Tag_GNU_MIPS_ABI_FP].i == Val_GNU_MIPS_ABI_FP_ANY)
15085 in_attr[Tag_GNU_MIPS_ABI_FP].i =
15086 mips_elf_tdata (ibfd)->abiflags.fp_abi;
15087 }
15088
2cf19d5c
JM
15089 if (!mips_elf_merge_obj_attributes (ibfd, obfd))
15090 return FALSE;
15091
351cdf24
MF
15092 /* Check to see if the input BFD actually contains any sections.
15093 If not, its flags may not have been initialised either, but it cannot
15094 actually cause any incompatibility. */
15095 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
15096 {
15097 /* Ignore synthetic sections and empty .text, .data and .bss sections
15098 which are automatically generated by gas. Also ignore fake
15099 (s)common sections, since merely defining a common symbol does
15100 not affect compatibility. */
15101 if ((sec->flags & SEC_IS_COMMON) == 0
15102 && strcmp (sec->name, ".reginfo")
15103 && strcmp (sec->name, ".mdebug")
15104 && (sec->size != 0
15105 || (strcmp (sec->name, ".text")
15106 && strcmp (sec->name, ".data")
15107 && strcmp (sec->name, ".bss"))))
15108 {
15109 null_input_bfd = FALSE;
15110 break;
15111 }
15112 }
15113 if (null_input_bfd)
15114 return TRUE;
15115
15116 /* Populate abiflags using existing information. */
15117 if (!mips_elf_tdata (ibfd)->abiflags_valid)
15118 {
15119 infer_mips_abiflags (ibfd, &mips_elf_tdata (ibfd)->abiflags);
15120 mips_elf_tdata (ibfd)->abiflags_valid = TRUE;
15121 }
15122 else
15123 {
15124 Elf_Internal_ABIFlags_v0 abiflags;
15125 Elf_Internal_ABIFlags_v0 in_abiflags;
15126 infer_mips_abiflags (ibfd, &abiflags);
15127 in_abiflags = mips_elf_tdata (ibfd)->abiflags;
15128
15129 /* It is not possible to infer the correct ISA revision
15130 for R3 or R5 so drop down to R2 for the checks. */
15131 if (in_abiflags.isa_rev == 3 || in_abiflags.isa_rev == 5)
15132 in_abiflags.isa_rev = 2;
15133
15134 if (in_abiflags.isa_level != abiflags.isa_level
15135 || in_abiflags.isa_rev != abiflags.isa_rev
15136 || in_abiflags.isa_ext != abiflags.isa_ext)
15137 (*_bfd_error_handler)
15138 (_("%B: warning: Inconsistent ISA between e_flags and "
15139 ".MIPS.abiflags"), ibfd);
15140 if (abiflags.fp_abi != Val_GNU_MIPS_ABI_FP_ANY
15141 && in_abiflags.fp_abi != abiflags.fp_abi)
15142 (*_bfd_error_handler)
15143 (_("%B: warning: Inconsistent FP ABI between e_flags and "
15144 ".MIPS.abiflags"), ibfd);
15145 if ((in_abiflags.ases & abiflags.ases) != abiflags.ases)
15146 (*_bfd_error_handler)
15147 (_("%B: warning: Inconsistent ASEs between e_flags and "
15148 ".MIPS.abiflags"), ibfd);
15149 if (in_abiflags.isa_ext != abiflags.isa_ext)
15150 (*_bfd_error_handler)
15151 (_("%B: warning: Inconsistent ISA extensions between e_flags and "
15152 ".MIPS.abiflags"), ibfd);
15153 if (in_abiflags.flags2 != 0)
15154 (*_bfd_error_handler)
15155 (_("%B: warning: Unexpected flag in the flags2 field of "
15156 ".MIPS.abiflags (0x%lx)"), ibfd,
15157 (unsigned long) in_abiflags.flags2);
15158 }
15159
15160 if (!mips_elf_tdata (obfd)->abiflags_valid)
15161 {
15162 /* Copy input abiflags if output abiflags are not already valid. */
15163 mips_elf_tdata (obfd)->abiflags = mips_elf_tdata (ibfd)->abiflags;
15164 mips_elf_tdata (obfd)->abiflags_valid = TRUE;
15165 }
b49e97c9
TS
15166
15167 if (! elf_flags_init (obfd))
15168 {
b34976b6 15169 elf_flags_init (obfd) = TRUE;
351cdf24 15170 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
b49e97c9
TS
15171 elf_elfheader (obfd)->e_ident[EI_CLASS]
15172 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
15173
15174 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2907b861 15175 && (bfd_get_arch_info (obfd)->the_default
68ffbac6 15176 || mips_mach_extends_p (bfd_get_mach (obfd),
2907b861 15177 bfd_get_mach (ibfd))))
b49e97c9
TS
15178 {
15179 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
15180 bfd_get_mach (ibfd)))
b34976b6 15181 return FALSE;
351cdf24
MF
15182
15183 /* Update the ABI flags isa_level, isa_rev and isa_ext fields. */
15184 update_mips_abiflags_isa (obfd, &mips_elf_tdata (obfd)->abiflags);
b49e97c9
TS
15185 }
15186
b34976b6 15187 return TRUE;
b49e97c9
TS
15188 }
15189
351cdf24
MF
15190 /* Update the output abiflags fp_abi using the computed fp_abi. */
15191 out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
15192 mips_elf_tdata (obfd)->abiflags.fp_abi = out_attr[Tag_GNU_MIPS_ABI_FP].i;
15193
15194#define max(a,b) ((a) > (b) ? (a) : (b))
15195 /* Merge abiflags. */
15196 mips_elf_tdata (obfd)->abiflags.isa_rev
15197 = max (mips_elf_tdata (obfd)->abiflags.isa_rev,
15198 mips_elf_tdata (ibfd)->abiflags.isa_rev);
15199 mips_elf_tdata (obfd)->abiflags.gpr_size
15200 = max (mips_elf_tdata (obfd)->abiflags.gpr_size,
15201 mips_elf_tdata (ibfd)->abiflags.gpr_size);
15202 mips_elf_tdata (obfd)->abiflags.cpr1_size
15203 = max (mips_elf_tdata (obfd)->abiflags.cpr1_size,
15204 mips_elf_tdata (ibfd)->abiflags.cpr1_size);
15205 mips_elf_tdata (obfd)->abiflags.cpr2_size
15206 = max (mips_elf_tdata (obfd)->abiflags.cpr2_size,
15207 mips_elf_tdata (ibfd)->abiflags.cpr2_size);
15208#undef max
15209 mips_elf_tdata (obfd)->abiflags.ases
15210 |= mips_elf_tdata (ibfd)->abiflags.ases;
15211 mips_elf_tdata (obfd)->abiflags.flags1
15212 |= mips_elf_tdata (ibfd)->abiflags.flags1;
15213
15214 new_flags = elf_elfheader (ibfd)->e_flags;
15215 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
15216 old_flags = elf_elfheader (obfd)->e_flags;
15217
b49e97c9
TS
15218 /* Check flag compatibility. */
15219
15220 new_flags &= ~EF_MIPS_NOREORDER;
15221 old_flags &= ~EF_MIPS_NOREORDER;
15222
f4416af6
AO
15223 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
15224 doesn't seem to matter. */
15225 new_flags &= ~EF_MIPS_XGOT;
15226 old_flags &= ~EF_MIPS_XGOT;
15227
98a8deaf
RS
15228 /* MIPSpro generates ucode info in n64 objects. Again, we should
15229 just be able to ignore this. */
15230 new_flags &= ~EF_MIPS_UCODE;
15231 old_flags &= ~EF_MIPS_UCODE;
15232
861fb55a
DJ
15233 /* DSOs should only be linked with CPIC code. */
15234 if ((ibfd->flags & DYNAMIC) != 0)
15235 new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
0a44bf69 15236
b49e97c9 15237 if (new_flags == old_flags)
b34976b6 15238 return TRUE;
b49e97c9 15239
b34976b6 15240 ok = TRUE;
b49e97c9 15241
143d77c5
EC
15242 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
15243 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
b49e97c9 15244 {
b49e97c9 15245 (*_bfd_error_handler)
861fb55a 15246 (_("%B: warning: linking abicalls files with non-abicalls files"),
d003868e 15247 ibfd);
143d77c5 15248 ok = TRUE;
b49e97c9
TS
15249 }
15250
143d77c5
EC
15251 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
15252 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
15253 if (! (new_flags & EF_MIPS_PIC))
15254 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
15255
15256 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
15257 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
b49e97c9 15258
64543e1a
RS
15259 /* Compare the ISAs. */
15260 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
b49e97c9 15261 {
64543e1a 15262 (*_bfd_error_handler)
d003868e
AM
15263 (_("%B: linking 32-bit code with 64-bit code"),
15264 ibfd);
64543e1a
RS
15265 ok = FALSE;
15266 }
15267 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
15268 {
15269 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
15270 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
b49e97c9 15271 {
64543e1a
RS
15272 /* Copy the architecture info from IBFD to OBFD. Also copy
15273 the 32-bit flag (if set) so that we continue to recognise
15274 OBFD as a 32-bit binary. */
15275 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
15276 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
15277 elf_elfheader (obfd)->e_flags
15278 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15279
351cdf24
MF
15280 /* Update the ABI flags isa_level, isa_rev, isa_ext fields. */
15281 update_mips_abiflags_isa (obfd, &mips_elf_tdata (obfd)->abiflags);
15282
64543e1a
RS
15283 /* Copy across the ABI flags if OBFD doesn't use them
15284 and if that was what caused us to treat IBFD as 32-bit. */
15285 if ((old_flags & EF_MIPS_ABI) == 0
15286 && mips_32bit_flags_p (new_flags)
15287 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
15288 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
b49e97c9
TS
15289 }
15290 else
15291 {
64543e1a 15292 /* The ISAs aren't compatible. */
b49e97c9 15293 (*_bfd_error_handler)
d003868e
AM
15294 (_("%B: linking %s module with previous %s modules"),
15295 ibfd,
64543e1a
RS
15296 bfd_printable_name (ibfd),
15297 bfd_printable_name (obfd));
b34976b6 15298 ok = FALSE;
b49e97c9 15299 }
b49e97c9
TS
15300 }
15301
64543e1a
RS
15302 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15303 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15304
15305 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
b49e97c9
TS
15306 does set EI_CLASS differently from any 32-bit ABI. */
15307 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
15308 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
15309 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
15310 {
15311 /* Only error if both are set (to different values). */
15312 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
15313 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
15314 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
15315 {
15316 (*_bfd_error_handler)
d003868e
AM
15317 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
15318 ibfd,
b49e97c9
TS
15319 elf_mips_abi_name (ibfd),
15320 elf_mips_abi_name (obfd));
b34976b6 15321 ok = FALSE;
b49e97c9
TS
15322 }
15323 new_flags &= ~EF_MIPS_ABI;
15324 old_flags &= ~EF_MIPS_ABI;
15325 }
15326
df58fc94
RS
15327 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
15328 and allow arbitrary mixing of the remaining ASEs (retain the union). */
fb39dac1
RS
15329 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
15330 {
df58fc94
RS
15331 int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
15332 int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
15333 int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16;
15334 int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16;
15335 int micro_mis = old_m16 && new_micro;
15336 int m16_mis = old_micro && new_m16;
15337
15338 if (m16_mis || micro_mis)
15339 {
15340 (*_bfd_error_handler)
15341 (_("%B: ASE mismatch: linking %s module with previous %s modules"),
15342 ibfd,
15343 m16_mis ? "MIPS16" : "microMIPS",
15344 m16_mis ? "microMIPS" : "MIPS16");
15345 ok = FALSE;
15346 }
15347
fb39dac1
RS
15348 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
15349
15350 new_flags &= ~ EF_MIPS_ARCH_ASE;
15351 old_flags &= ~ EF_MIPS_ARCH_ASE;
15352 }
15353
ba92f887
MR
15354 /* Compare NaN encodings. */
15355 if ((new_flags & EF_MIPS_NAN2008) != (old_flags & EF_MIPS_NAN2008))
15356 {
15357 _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
15358 ibfd,
15359 (new_flags & EF_MIPS_NAN2008
15360 ? "-mnan=2008" : "-mnan=legacy"),
15361 (old_flags & EF_MIPS_NAN2008
15362 ? "-mnan=2008" : "-mnan=legacy"));
15363 ok = FALSE;
15364 new_flags &= ~EF_MIPS_NAN2008;
15365 old_flags &= ~EF_MIPS_NAN2008;
15366 }
15367
351cdf24
MF
15368 /* Compare FP64 state. */
15369 if ((new_flags & EF_MIPS_FP64) != (old_flags & EF_MIPS_FP64))
15370 {
15371 _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
15372 ibfd,
15373 (new_flags & EF_MIPS_FP64
15374 ? "-mfp64" : "-mfp32"),
15375 (old_flags & EF_MIPS_FP64
15376 ? "-mfp64" : "-mfp32"));
15377 ok = FALSE;
15378 new_flags &= ~EF_MIPS_FP64;
15379 old_flags &= ~EF_MIPS_FP64;
15380 }
15381
b49e97c9
TS
15382 /* Warn about any other mismatches */
15383 if (new_flags != old_flags)
15384 {
15385 (*_bfd_error_handler)
d003868e
AM
15386 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
15387 ibfd, (unsigned long) new_flags,
b49e97c9 15388 (unsigned long) old_flags);
b34976b6 15389 ok = FALSE;
b49e97c9
TS
15390 }
15391
15392 if (! ok)
15393 {
15394 bfd_set_error (bfd_error_bad_value);
b34976b6 15395 return FALSE;
b49e97c9
TS
15396 }
15397
b34976b6 15398 return TRUE;
b49e97c9
TS
15399}
15400
15401/* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
15402
b34976b6 15403bfd_boolean
9719ad41 15404_bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
b49e97c9
TS
15405{
15406 BFD_ASSERT (!elf_flags_init (abfd)
15407 || elf_elfheader (abfd)->e_flags == flags);
15408
15409 elf_elfheader (abfd)->e_flags = flags;
b34976b6
AM
15410 elf_flags_init (abfd) = TRUE;
15411 return TRUE;
b49e97c9
TS
15412}
15413
ad9563d6
CM
15414char *
15415_bfd_mips_elf_get_target_dtag (bfd_vma dtag)
15416{
15417 switch (dtag)
15418 {
15419 default: return "";
15420 case DT_MIPS_RLD_VERSION:
15421 return "MIPS_RLD_VERSION";
15422 case DT_MIPS_TIME_STAMP:
15423 return "MIPS_TIME_STAMP";
15424 case DT_MIPS_ICHECKSUM:
15425 return "MIPS_ICHECKSUM";
15426 case DT_MIPS_IVERSION:
15427 return "MIPS_IVERSION";
15428 case DT_MIPS_FLAGS:
15429 return "MIPS_FLAGS";
15430 case DT_MIPS_BASE_ADDRESS:
15431 return "MIPS_BASE_ADDRESS";
15432 case DT_MIPS_MSYM:
15433 return "MIPS_MSYM";
15434 case DT_MIPS_CONFLICT:
15435 return "MIPS_CONFLICT";
15436 case DT_MIPS_LIBLIST:
15437 return "MIPS_LIBLIST";
15438 case DT_MIPS_LOCAL_GOTNO:
15439 return "MIPS_LOCAL_GOTNO";
15440 case DT_MIPS_CONFLICTNO:
15441 return "MIPS_CONFLICTNO";
15442 case DT_MIPS_LIBLISTNO:
15443 return "MIPS_LIBLISTNO";
15444 case DT_MIPS_SYMTABNO:
15445 return "MIPS_SYMTABNO";
15446 case DT_MIPS_UNREFEXTNO:
15447 return "MIPS_UNREFEXTNO";
15448 case DT_MIPS_GOTSYM:
15449 return "MIPS_GOTSYM";
15450 case DT_MIPS_HIPAGENO:
15451 return "MIPS_HIPAGENO";
15452 case DT_MIPS_RLD_MAP:
15453 return "MIPS_RLD_MAP";
a5499fa4
MF
15454 case DT_MIPS_RLD_MAP_REL:
15455 return "MIPS_RLD_MAP_REL";
ad9563d6
CM
15456 case DT_MIPS_DELTA_CLASS:
15457 return "MIPS_DELTA_CLASS";
15458 case DT_MIPS_DELTA_CLASS_NO:
15459 return "MIPS_DELTA_CLASS_NO";
15460 case DT_MIPS_DELTA_INSTANCE:
15461 return "MIPS_DELTA_INSTANCE";
15462 case DT_MIPS_DELTA_INSTANCE_NO:
15463 return "MIPS_DELTA_INSTANCE_NO";
15464 case DT_MIPS_DELTA_RELOC:
15465 return "MIPS_DELTA_RELOC";
15466 case DT_MIPS_DELTA_RELOC_NO:
15467 return "MIPS_DELTA_RELOC_NO";
15468 case DT_MIPS_DELTA_SYM:
15469 return "MIPS_DELTA_SYM";
15470 case DT_MIPS_DELTA_SYM_NO:
15471 return "MIPS_DELTA_SYM_NO";
15472 case DT_MIPS_DELTA_CLASSSYM:
15473 return "MIPS_DELTA_CLASSSYM";
15474 case DT_MIPS_DELTA_CLASSSYM_NO:
15475 return "MIPS_DELTA_CLASSSYM_NO";
15476 case DT_MIPS_CXX_FLAGS:
15477 return "MIPS_CXX_FLAGS";
15478 case DT_MIPS_PIXIE_INIT:
15479 return "MIPS_PIXIE_INIT";
15480 case DT_MIPS_SYMBOL_LIB:
15481 return "MIPS_SYMBOL_LIB";
15482 case DT_MIPS_LOCALPAGE_GOTIDX:
15483 return "MIPS_LOCALPAGE_GOTIDX";
15484 case DT_MIPS_LOCAL_GOTIDX:
15485 return "MIPS_LOCAL_GOTIDX";
15486 case DT_MIPS_HIDDEN_GOTIDX:
15487 return "MIPS_HIDDEN_GOTIDX";
15488 case DT_MIPS_PROTECTED_GOTIDX:
15489 return "MIPS_PROTECTED_GOT_IDX";
15490 case DT_MIPS_OPTIONS:
15491 return "MIPS_OPTIONS";
15492 case DT_MIPS_INTERFACE:
15493 return "MIPS_INTERFACE";
15494 case DT_MIPS_DYNSTR_ALIGN:
15495 return "DT_MIPS_DYNSTR_ALIGN";
15496 case DT_MIPS_INTERFACE_SIZE:
15497 return "DT_MIPS_INTERFACE_SIZE";
15498 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
15499 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
15500 case DT_MIPS_PERF_SUFFIX:
15501 return "DT_MIPS_PERF_SUFFIX";
15502 case DT_MIPS_COMPACT_SIZE:
15503 return "DT_MIPS_COMPACT_SIZE";
15504 case DT_MIPS_GP_VALUE:
15505 return "DT_MIPS_GP_VALUE";
15506 case DT_MIPS_AUX_DYNAMIC:
15507 return "DT_MIPS_AUX_DYNAMIC";
861fb55a
DJ
15508 case DT_MIPS_PLTGOT:
15509 return "DT_MIPS_PLTGOT";
15510 case DT_MIPS_RWPLT:
15511 return "DT_MIPS_RWPLT";
ad9563d6
CM
15512 }
15513}
15514
757a636f
RS
15515/* Return the meaning of Tag_GNU_MIPS_ABI_FP value FP, or null if
15516 not known. */
15517
15518const char *
15519_bfd_mips_fp_abi_string (int fp)
15520{
15521 switch (fp)
15522 {
15523 /* These strings aren't translated because they're simply
15524 option lists. */
15525 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15526 return "-mdouble-float";
15527
15528 case Val_GNU_MIPS_ABI_FP_SINGLE:
15529 return "-msingle-float";
15530
15531 case Val_GNU_MIPS_ABI_FP_SOFT:
15532 return "-msoft-float";
15533
351cdf24
MF
15534 case Val_GNU_MIPS_ABI_FP_OLD_64:
15535 return _("-mips32r2 -mfp64 (12 callee-saved)");
15536
15537 case Val_GNU_MIPS_ABI_FP_XX:
15538 return "-mfpxx";
15539
757a636f 15540 case Val_GNU_MIPS_ABI_FP_64:
351cdf24
MF
15541 return "-mgp32 -mfp64";
15542
15543 case Val_GNU_MIPS_ABI_FP_64A:
15544 return "-mgp32 -mfp64 -mno-odd-spreg";
757a636f
RS
15545
15546 default:
15547 return 0;
15548 }
15549}
15550
351cdf24
MF
15551static void
15552print_mips_ases (FILE *file, unsigned int mask)
15553{
15554 if (mask & AFL_ASE_DSP)
15555 fputs ("\n\tDSP ASE", file);
15556 if (mask & AFL_ASE_DSPR2)
15557 fputs ("\n\tDSP R2 ASE", file);
15558 if (mask & AFL_ASE_EVA)
15559 fputs ("\n\tEnhanced VA Scheme", file);
15560 if (mask & AFL_ASE_MCU)
15561 fputs ("\n\tMCU (MicroController) ASE", file);
15562 if (mask & AFL_ASE_MDMX)
15563 fputs ("\n\tMDMX ASE", file);
15564 if (mask & AFL_ASE_MIPS3D)
15565 fputs ("\n\tMIPS-3D ASE", file);
15566 if (mask & AFL_ASE_MT)
15567 fputs ("\n\tMT ASE", file);
15568 if (mask & AFL_ASE_SMARTMIPS)
15569 fputs ("\n\tSmartMIPS ASE", file);
15570 if (mask & AFL_ASE_VIRT)
15571 fputs ("\n\tVZ ASE", file);
15572 if (mask & AFL_ASE_MSA)
15573 fputs ("\n\tMSA ASE", file);
15574 if (mask & AFL_ASE_MIPS16)
15575 fputs ("\n\tMIPS16 ASE", file);
15576 if (mask & AFL_ASE_MICROMIPS)
15577 fputs ("\n\tMICROMIPS ASE", file);
15578 if (mask & AFL_ASE_XPA)
15579 fputs ("\n\tXPA ASE", file);
15580 if (mask == 0)
15581 fprintf (file, "\n\t%s", _("None"));
00ac7aa0
MF
15582 else if ((mask & ~AFL_ASE_MASK) != 0)
15583 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
351cdf24
MF
15584}
15585
15586static void
15587print_mips_isa_ext (FILE *file, unsigned int isa_ext)
15588{
15589 switch (isa_ext)
15590 {
15591 case 0:
15592 fputs (_("None"), file);
15593 break;
15594 case AFL_EXT_XLR:
15595 fputs ("RMI XLR", file);
15596 break;
2c629856
N
15597 case AFL_EXT_OCTEON3:
15598 fputs ("Cavium Networks Octeon3", file);
15599 break;
351cdf24
MF
15600 case AFL_EXT_OCTEON2:
15601 fputs ("Cavium Networks Octeon2", file);
15602 break;
15603 case AFL_EXT_OCTEONP:
15604 fputs ("Cavium Networks OcteonP", file);
15605 break;
15606 case AFL_EXT_LOONGSON_3A:
15607 fputs ("Loongson 3A", file);
15608 break;
15609 case AFL_EXT_OCTEON:
15610 fputs ("Cavium Networks Octeon", file);
15611 break;
15612 case AFL_EXT_5900:
15613 fputs ("Toshiba R5900", file);
15614 break;
15615 case AFL_EXT_4650:
15616 fputs ("MIPS R4650", file);
15617 break;
15618 case AFL_EXT_4010:
15619 fputs ("LSI R4010", file);
15620 break;
15621 case AFL_EXT_4100:
15622 fputs ("NEC VR4100", file);
15623 break;
15624 case AFL_EXT_3900:
15625 fputs ("Toshiba R3900", file);
15626 break;
15627 case AFL_EXT_10000:
15628 fputs ("MIPS R10000", file);
15629 break;
15630 case AFL_EXT_SB1:
15631 fputs ("Broadcom SB-1", file);
15632 break;
15633 case AFL_EXT_4111:
15634 fputs ("NEC VR4111/VR4181", file);
15635 break;
15636 case AFL_EXT_4120:
15637 fputs ("NEC VR4120", file);
15638 break;
15639 case AFL_EXT_5400:
15640 fputs ("NEC VR5400", file);
15641 break;
15642 case AFL_EXT_5500:
15643 fputs ("NEC VR5500", file);
15644 break;
15645 case AFL_EXT_LOONGSON_2E:
15646 fputs ("ST Microelectronics Loongson 2E", file);
15647 break;
15648 case AFL_EXT_LOONGSON_2F:
15649 fputs ("ST Microelectronics Loongson 2F", file);
15650 break;
15651 default:
00ac7aa0 15652 fprintf (file, "%s (%d)", _("Unknown"), isa_ext);
351cdf24
MF
15653 break;
15654 }
15655}
15656
15657static void
15658print_mips_fp_abi_value (FILE *file, int val)
15659{
15660 switch (val)
15661 {
15662 case Val_GNU_MIPS_ABI_FP_ANY:
15663 fprintf (file, _("Hard or soft float\n"));
15664 break;
15665 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15666 fprintf (file, _("Hard float (double precision)\n"));
15667 break;
15668 case Val_GNU_MIPS_ABI_FP_SINGLE:
15669 fprintf (file, _("Hard float (single precision)\n"));
15670 break;
15671 case Val_GNU_MIPS_ABI_FP_SOFT:
15672 fprintf (file, _("Soft float\n"));
15673 break;
15674 case Val_GNU_MIPS_ABI_FP_OLD_64:
15675 fprintf (file, _("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15676 break;
15677 case Val_GNU_MIPS_ABI_FP_XX:
15678 fprintf (file, _("Hard float (32-bit CPU, Any FPU)\n"));
15679 break;
15680 case Val_GNU_MIPS_ABI_FP_64:
15681 fprintf (file, _("Hard float (32-bit CPU, 64-bit FPU)\n"));
15682 break;
15683 case Val_GNU_MIPS_ABI_FP_64A:
15684 fprintf (file, _("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15685 break;
15686 default:
15687 fprintf (file, "??? (%d)\n", val);
15688 break;
15689 }
15690}
15691
15692static int
15693get_mips_reg_size (int reg_size)
15694{
15695 return (reg_size == AFL_REG_NONE) ? 0
15696 : (reg_size == AFL_REG_32) ? 32
15697 : (reg_size == AFL_REG_64) ? 64
15698 : (reg_size == AFL_REG_128) ? 128
15699 : -1;
15700}
15701
b34976b6 15702bfd_boolean
9719ad41 15703_bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
b49e97c9 15704{
9719ad41 15705 FILE *file = ptr;
b49e97c9
TS
15706
15707 BFD_ASSERT (abfd != NULL && ptr != NULL);
15708
15709 /* Print normal ELF private data. */
15710 _bfd_elf_print_private_bfd_data (abfd, ptr);
15711
15712 /* xgettext:c-format */
15713 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
15714
15715 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
15716 fprintf (file, _(" [abi=O32]"));
15717 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
15718 fprintf (file, _(" [abi=O64]"));
15719 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
15720 fprintf (file, _(" [abi=EABI32]"));
15721 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
15722 fprintf (file, _(" [abi=EABI64]"));
15723 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
15724 fprintf (file, _(" [abi unknown]"));
15725 else if (ABI_N32_P (abfd))
15726 fprintf (file, _(" [abi=N32]"));
15727 else if (ABI_64_P (abfd))
15728 fprintf (file, _(" [abi=64]"));
15729 else
15730 fprintf (file, _(" [no abi set]"));
15731
15732 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
ae0d2616 15733 fprintf (file, " [mips1]");
b49e97c9 15734 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
ae0d2616 15735 fprintf (file, " [mips2]");
b49e97c9 15736 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
ae0d2616 15737 fprintf (file, " [mips3]");
b49e97c9 15738 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
ae0d2616 15739 fprintf (file, " [mips4]");
b49e97c9 15740 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
ae0d2616 15741 fprintf (file, " [mips5]");
b49e97c9 15742 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
ae0d2616 15743 fprintf (file, " [mips32]");
b49e97c9 15744 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
ae0d2616 15745 fprintf (file, " [mips64]");
af7ee8bf 15746 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
ae0d2616 15747 fprintf (file, " [mips32r2]");
5f74bc13 15748 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
ae0d2616 15749 fprintf (file, " [mips64r2]");
7361da2c
AB
15750 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6)
15751 fprintf (file, " [mips32r6]");
15752 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
15753 fprintf (file, " [mips64r6]");
b49e97c9
TS
15754 else
15755 fprintf (file, _(" [unknown ISA]"));
15756
40d32fc6 15757 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
ae0d2616 15758 fprintf (file, " [mdmx]");
40d32fc6
CD
15759
15760 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
ae0d2616 15761 fprintf (file, " [mips16]");
40d32fc6 15762
df58fc94
RS
15763 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
15764 fprintf (file, " [micromips]");
15765
ba92f887
MR
15766 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NAN2008)
15767 fprintf (file, " [nan2008]");
15768
5baf5e34 15769 if (elf_elfheader (abfd)->e_flags & EF_MIPS_FP64)
351cdf24 15770 fprintf (file, " [old fp64]");
5baf5e34 15771
b49e97c9 15772 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
ae0d2616 15773 fprintf (file, " [32bitmode]");
b49e97c9
TS
15774 else
15775 fprintf (file, _(" [not 32bitmode]"));
15776
c0e3f241 15777 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
ae0d2616 15778 fprintf (file, " [noreorder]");
c0e3f241
CD
15779
15780 if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
ae0d2616 15781 fprintf (file, " [PIC]");
c0e3f241
CD
15782
15783 if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
ae0d2616 15784 fprintf (file, " [CPIC]");
c0e3f241
CD
15785
15786 if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
ae0d2616 15787 fprintf (file, " [XGOT]");
c0e3f241
CD
15788
15789 if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
ae0d2616 15790 fprintf (file, " [UCODE]");
c0e3f241 15791
b49e97c9
TS
15792 fputc ('\n', file);
15793
351cdf24
MF
15794 if (mips_elf_tdata (abfd)->abiflags_valid)
15795 {
15796 Elf_Internal_ABIFlags_v0 *abiflags = &mips_elf_tdata (abfd)->abiflags;
15797 fprintf (file, "\nMIPS ABI Flags Version: %d\n", abiflags->version);
15798 fprintf (file, "\nISA: MIPS%d", abiflags->isa_level);
15799 if (abiflags->isa_rev > 1)
15800 fprintf (file, "r%d", abiflags->isa_rev);
15801 fprintf (file, "\nGPR size: %d",
15802 get_mips_reg_size (abiflags->gpr_size));
15803 fprintf (file, "\nCPR1 size: %d",
15804 get_mips_reg_size (abiflags->cpr1_size));
15805 fprintf (file, "\nCPR2 size: %d",
15806 get_mips_reg_size (abiflags->cpr2_size));
15807 fputs ("\nFP ABI: ", file);
15808 print_mips_fp_abi_value (file, abiflags->fp_abi);
15809 fputs ("ISA Extension: ", file);
15810 print_mips_isa_ext (file, abiflags->isa_ext);
15811 fputs ("\nASEs:", file);
15812 print_mips_ases (file, abiflags->ases);
15813 fprintf (file, "\nFLAGS 1: %8.8lx", abiflags->flags1);
15814 fprintf (file, "\nFLAGS 2: %8.8lx", abiflags->flags2);
15815 fputc ('\n', file);
15816 }
15817
b34976b6 15818 return TRUE;
b49e97c9 15819}
2f89ff8d 15820
b35d266b 15821const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
2f89ff8d 15822{
0112cd26
NC
15823 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
15824 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
15825 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
15826 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
15827 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
15828 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE, 0 },
15829 { NULL, 0, 0, 0, 0 }
2f89ff8d 15830};
5e2b0d47 15831
8992f0d7
TS
15832/* Merge non visibility st_other attributes. Ensure that the
15833 STO_OPTIONAL flag is copied into h->other, even if this is not a
15834 definiton of the symbol. */
5e2b0d47
NC
15835void
15836_bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
15837 const Elf_Internal_Sym *isym,
15838 bfd_boolean definition,
15839 bfd_boolean dynamic ATTRIBUTE_UNUSED)
15840{
8992f0d7
TS
15841 if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
15842 {
15843 unsigned char other;
15844
15845 other = (definition ? isym->st_other : h->other);
15846 other &= ~ELF_ST_VISIBILITY (-1);
15847 h->other = other | ELF_ST_VISIBILITY (h->other);
15848 }
15849
15850 if (!definition
5e2b0d47
NC
15851 && ELF_MIPS_IS_OPTIONAL (isym->st_other))
15852 h->other |= STO_OPTIONAL;
15853}
12ac1cf5
NC
15854
15855/* Decide whether an undefined symbol is special and can be ignored.
15856 This is the case for OPTIONAL symbols on IRIX. */
15857bfd_boolean
15858_bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
15859{
15860 return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
15861}
e0764319
NC
15862
15863bfd_boolean
15864_bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
15865{
15866 return (sym->st_shndx == SHN_COMMON
15867 || sym->st_shndx == SHN_MIPS_ACOMMON
15868 || sym->st_shndx == SHN_MIPS_SCOMMON);
15869}
861fb55a
DJ
15870
15871/* Return address for Ith PLT stub in section PLT, for relocation REL
15872 or (bfd_vma) -1 if it should not be included. */
15873
15874bfd_vma
15875_bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
15876 const arelent *rel ATTRIBUTE_UNUSED)
15877{
15878 return (plt->vma
15879 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
15880 + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
15881}
15882
1bbce132
MR
15883/* Build a table of synthetic symbols to represent the PLT. As with MIPS16
15884 and microMIPS PLT slots we may have a many-to-one mapping between .plt
15885 and .got.plt and also the slots may be of a different size each we walk
15886 the PLT manually fetching instructions and matching them against known
15887 patterns. To make things easier standard MIPS slots, if any, always come
15888 first. As we don't create proper ELF symbols we use the UDATA.I member
15889 of ASYMBOL to carry ISA annotation. The encoding used is the same as
15890 with the ST_OTHER member of the ELF symbol. */
15891
15892long
15893_bfd_mips_elf_get_synthetic_symtab (bfd *abfd,
15894 long symcount ATTRIBUTE_UNUSED,
15895 asymbol **syms ATTRIBUTE_UNUSED,
15896 long dynsymcount, asymbol **dynsyms,
15897 asymbol **ret)
15898{
15899 static const char pltname[] = "_PROCEDURE_LINKAGE_TABLE_";
15900 static const char microsuffix[] = "@micromipsplt";
15901 static const char m16suffix[] = "@mips16plt";
15902 static const char mipssuffix[] = "@plt";
15903
15904 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
15905 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
15906 bfd_boolean micromips_p = MICROMIPS_P (abfd);
15907 Elf_Internal_Shdr *hdr;
15908 bfd_byte *plt_data;
15909 bfd_vma plt_offset;
15910 unsigned int other;
15911 bfd_vma entry_size;
15912 bfd_vma plt0_size;
15913 asection *relplt;
15914 bfd_vma opcode;
15915 asection *plt;
15916 asymbol *send;
15917 size_t size;
15918 char *names;
15919 long counti;
15920 arelent *p;
15921 asymbol *s;
15922 char *nend;
15923 long count;
15924 long pi;
15925 long i;
15926 long n;
15927
15928 *ret = NULL;
15929
15930 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0 || dynsymcount <= 0)
15931 return 0;
15932
15933 relplt = bfd_get_section_by_name (abfd, ".rel.plt");
15934 if (relplt == NULL)
15935 return 0;
15936
15937 hdr = &elf_section_data (relplt)->this_hdr;
15938 if (hdr->sh_link != elf_dynsymtab (abfd) || hdr->sh_type != SHT_REL)
15939 return 0;
15940
15941 plt = bfd_get_section_by_name (abfd, ".plt");
15942 if (plt == NULL)
15943 return 0;
15944
15945 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
15946 if (!(*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
15947 return -1;
15948 p = relplt->relocation;
15949
15950 /* Calculating the exact amount of space required for symbols would
15951 require two passes over the PLT, so just pessimise assuming two
15952 PLT slots per relocation. */
15953 count = relplt->size / hdr->sh_entsize;
15954 counti = count * bed->s->int_rels_per_ext_rel;
15955 size = 2 * count * sizeof (asymbol);
15956 size += count * (sizeof (mipssuffix) +
15957 (micromips_p ? sizeof (microsuffix) : sizeof (m16suffix)));
15958 for (pi = 0; pi < counti; pi += bed->s->int_rels_per_ext_rel)
15959 size += 2 * strlen ((*p[pi].sym_ptr_ptr)->name);
15960
15961 /* Add the size of "_PROCEDURE_LINKAGE_TABLE_" too. */
15962 size += sizeof (asymbol) + sizeof (pltname);
15963
15964 if (!bfd_malloc_and_get_section (abfd, plt, &plt_data))
15965 return -1;
15966
15967 if (plt->size < 16)
15968 return -1;
15969
15970 s = *ret = bfd_malloc (size);
15971 if (s == NULL)
15972 return -1;
15973 send = s + 2 * count + 1;
15974
15975 names = (char *) send;
15976 nend = (char *) s + size;
15977 n = 0;
15978
15979 opcode = bfd_get_micromips_32 (abfd, plt_data + 12);
15980 if (opcode == 0x3302fffe)
15981 {
15982 if (!micromips_p)
15983 return -1;
15984 plt0_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
15985 other = STO_MICROMIPS;
15986 }
833794fc
MR
15987 else if (opcode == 0x0398c1d0)
15988 {
15989 if (!micromips_p)
15990 return -1;
15991 plt0_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
15992 other = STO_MICROMIPS;
15993 }
1bbce132
MR
15994 else
15995 {
15996 plt0_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
15997 other = 0;
15998 }
15999
16000 s->the_bfd = abfd;
16001 s->flags = BSF_SYNTHETIC | BSF_FUNCTION | BSF_LOCAL;
16002 s->section = plt;
16003 s->value = 0;
16004 s->name = names;
16005 s->udata.i = other;
16006 memcpy (names, pltname, sizeof (pltname));
16007 names += sizeof (pltname);
16008 ++s, ++n;
16009
16010 pi = 0;
16011 for (plt_offset = plt0_size;
16012 plt_offset + 8 <= plt->size && s < send;
16013 plt_offset += entry_size)
16014 {
16015 bfd_vma gotplt_addr;
16016 const char *suffix;
16017 bfd_vma gotplt_hi;
16018 bfd_vma gotplt_lo;
16019 size_t suffixlen;
16020
16021 opcode = bfd_get_micromips_32 (abfd, plt_data + plt_offset + 4);
16022
16023 /* Check if the second word matches the expected MIPS16 instruction. */
16024 if (opcode == 0x651aeb00)
16025 {
16026 if (micromips_p)
16027 return -1;
16028 /* Truncated table??? */
16029 if (plt_offset + 16 > plt->size)
16030 break;
16031 gotplt_addr = bfd_get_32 (abfd, plt_data + plt_offset + 12);
16032 entry_size = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
16033 suffixlen = sizeof (m16suffix);
16034 suffix = m16suffix;
16035 other = STO_MIPS16;
16036 }
833794fc 16037 /* Likewise the expected microMIPS instruction (no insn32 mode). */
1bbce132
MR
16038 else if (opcode == 0xff220000)
16039 {
16040 if (!micromips_p)
16041 return -1;
16042 gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset) & 0x7f;
16043 gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
16044 gotplt_hi = ((gotplt_hi ^ 0x40) - 0x40) << 18;
16045 gotplt_lo <<= 2;
16046 gotplt_addr = gotplt_hi + gotplt_lo;
16047 gotplt_addr += ((plt->vma + plt_offset) | 3) ^ 3;
16048 entry_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
16049 suffixlen = sizeof (microsuffix);
16050 suffix = microsuffix;
16051 other = STO_MICROMIPS;
16052 }
833794fc
MR
16053 /* Likewise the expected microMIPS instruction (insn32 mode). */
16054 else if ((opcode & 0xffff0000) == 0xff2f0000)
16055 {
16056 gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
16057 gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 6) & 0xffff;
16058 gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
16059 gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
16060 gotplt_addr = gotplt_hi + gotplt_lo;
16061 entry_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
16062 suffixlen = sizeof (microsuffix);
16063 suffix = microsuffix;
16064 other = STO_MICROMIPS;
16065 }
1bbce132
MR
16066 /* Otherwise assume standard MIPS code. */
16067 else
16068 {
16069 gotplt_hi = bfd_get_32 (abfd, plt_data + plt_offset) & 0xffff;
16070 gotplt_lo = bfd_get_32 (abfd, plt_data + plt_offset + 4) & 0xffff;
16071 gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
16072 gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
16073 gotplt_addr = gotplt_hi + gotplt_lo;
16074 entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
16075 suffixlen = sizeof (mipssuffix);
16076 suffix = mipssuffix;
16077 other = 0;
16078 }
16079 /* Truncated table??? */
16080 if (plt_offset + entry_size > plt->size)
16081 break;
16082
16083 for (i = 0;
16084 i < count && p[pi].address != gotplt_addr;
16085 i++, pi = (pi + bed->s->int_rels_per_ext_rel) % counti);
16086
16087 if (i < count)
16088 {
16089 size_t namelen;
16090 size_t len;
16091
16092 *s = **p[pi].sym_ptr_ptr;
16093 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
16094 we are defining a symbol, ensure one of them is set. */
16095 if ((s->flags & BSF_LOCAL) == 0)
16096 s->flags |= BSF_GLOBAL;
16097 s->flags |= BSF_SYNTHETIC;
16098 s->section = plt;
16099 s->value = plt_offset;
16100 s->name = names;
16101 s->udata.i = other;
16102
16103 len = strlen ((*p[pi].sym_ptr_ptr)->name);
16104 namelen = len + suffixlen;
16105 if (names + namelen > nend)
16106 break;
16107
16108 memcpy (names, (*p[pi].sym_ptr_ptr)->name, len);
16109 names += len;
16110 memcpy (names, suffix, suffixlen);
16111 names += suffixlen;
16112
16113 ++s, ++n;
16114 pi = (pi + bed->s->int_rels_per_ext_rel) % counti;
16115 }
16116 }
16117
16118 free (plt_data);
16119
16120 return n;
16121}
16122
861fb55a
DJ
16123void
16124_bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
16125{
16126 struct mips_elf_link_hash_table *htab;
16127 Elf_Internal_Ehdr *i_ehdrp;
16128
16129 i_ehdrp = elf_elfheader (abfd);
16130 if (link_info)
16131 {
16132 htab = mips_elf_hash_table (link_info);
4dfe6ac6
NC
16133 BFD_ASSERT (htab != NULL);
16134
861fb55a
DJ
16135 if (htab->use_plts_and_copy_relocs && !htab->is_vxworks)
16136 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
16137 }
0af03126
L
16138
16139 _bfd_elf_post_process_headers (abfd, link_info);
351cdf24
MF
16140
16141 if (mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64
16142 || mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64A)
16143 i_ehdrp->e_ident[EI_ABIVERSION] = 3;
861fb55a 16144}
2f0c68f2
CM
16145
16146int
16147_bfd_mips_elf_compact_eh_encoding (struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
16148{
16149 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
16150}
16151
16152/* Return the opcode for can't unwind. */
16153
16154int
16155_bfd_mips_elf_cant_unwind_opcode (struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
16156{
16157 return COMPACT_EH_CANT_UNWIND_OPCODE;
16158}
This page took 1.96766 seconds and 4 git commands to generate.