MIPS/BFD: Discard ineligible JALR relocations right away
[binutils-gdb.git] / bfd / elfxx-mips.c
1 /* MIPS-specific support for ELF
2 Copyright (C) 1993-2017 Free Software Foundation, Inc.
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
11 This file is part of BFD, the Binary File Descriptor library.
12
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
15 the Free Software Foundation; either version 3 of the License, or
16 (at your option) any later version.
17
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.
22
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
25 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
26 MA 02110-1301, USA. */
27
28
29 /* This file handles functionality common to the different MIPS ABI's. */
30
31 #include "sysdep.h"
32 #include "bfd.h"
33 #include "libbfd.h"
34 #include "libiberty.h"
35 #include "elf-bfd.h"
36 #include "elfxx-mips.h"
37 #include "elf/mips.h"
38 #include "elf-vxworks.h"
39 #include "dwarf2.h"
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
47 #include "hashtab.h"
48
49 /* Types of TLS GOT entry. */
50 enum mips_got_tls_type {
51 GOT_TLS_NONE,
52 GOT_TLS_GD,
53 GOT_TLS_LDM,
54 GOT_TLS_IE
55 };
56
57 /* This structure is used to hold information about one GOT entry.
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. */
75 struct mips_got_entry
76 {
77 /* One input bfd that needs the GOT entry. */
78 bfd *abfd;
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
90 corresponding to a symbol in the GOT. The symbol's entry
91 is in the local area if h->global_got_area is GGA_NONE,
92 otherwise it is in the global area. */
93 struct mips_elf_link_hash_entry *h;
94 } d;
95
96 /* The TLS type of this GOT entry. An LDM GOT entry will be a local
97 symbol entry with r_symndx == 0. */
98 unsigned char tls_type;
99
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
104 /* The offset from the beginning of the .got section to the entry
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;
108 };
109
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. */
120 struct 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
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. */
134 struct 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
142 relocations against a given section. */
143 struct mips_got_page_entry
144 {
145 /* The section that these entries are based on. */
146 asection *sec;
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
153 /* This structure is used to hold .got information when linking. */
154
155 struct mips_got_info
156 {
157 /* The number of global .got entries. */
158 unsigned int global_gotno;
159 /* The number of global .got entries that are in the GGA_RELOC_ONLY area. */
160 unsigned int reloc_only_gotno;
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;
166 /* The number of local .got entries, eventually including page entries. */
167 unsigned int local_gotno;
168 /* The maximum number of page entries needed. */
169 unsigned int page_gotno;
170 /* The number of relocations needed for the GOT entries. */
171 unsigned int relocs;
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;
176 /* A hash table holding members of the got. */
177 struct htab *got_entries;
178 /* A hash table holding mips_got_page_ref structures. */
179 struct htab *got_page_refs;
180 /* A hash table of mips_got_page_entry structures. */
181 struct htab *got_page_entries;
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
187 /* Structure passed when merging bfds' gots. */
188
189 struct mips_elf_got_per_bfd_arg
190 {
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;
205 /* The maximum number of page entries needed by each got. */
206 unsigned int max_pages;
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;
212 };
213
214 /* A structure used to pass information to htab_traverse callbacks
215 when laying out the GOT. */
216
217 struct mips_elf_traverse_got_arg
218 {
219 struct bfd_link_info *info;
220 struct mips_got_info *g;
221 int value;
222 };
223
224 struct _mips_elf_section_data
225 {
226 struct bfd_elf_section_data elf;
227 union
228 {
229 bfd_byte *tdata;
230 } u;
231 };
232
233 #define mips_elf_section_data(sec) \
234 ((struct _mips_elf_section_data *) elf_section_data (sec))
235
236 #define is_mips_elf(bfd) \
237 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
238 && elf_tdata (bfd) != NULL \
239 && elf_object_id (bfd) == MIPS_ELF_DATA)
240
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
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. */
279 struct 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 */
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 */
302
303 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
304 the dynamic symbols. */
305
306 struct 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;
311 /* The least dynamic symbol table index corresponding to a non-TLS
312 symbol with a GOT entry. */
313 bfd_size_type min_got_dynindx;
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
316 with dynamic relocations pointing to it from non-primary GOTs). */
317 bfd_size_type max_unref_got_dynindx;
318 /* The greatest dynamic symbol table index corresponding to a local
319 symbol. */
320 bfd_size_type max_local_dynindx;
321 /* The greatest dynamic symbol table index corresponding to an external
322 symbol without a GOT entry. */
323 bfd_size_type max_non_got_dynindx;
324 };
325
326 /* We make up to two PLT entries if needed, one for standard MIPS code
327 and one for compressed code, either a MIPS16 or microMIPS one. We
328 keep a separate record of traditional lazy-binding stubs, for easier
329 processing. */
330
331 struct plt_entry
332 {
333 /* Traditional SVR4 stub offset, or -1 if none. */
334 bfd_vma stub_offset;
335
336 /* Standard PLT entry offset, or -1 if none. */
337 bfd_vma mips_offset;
338
339 /* Compressed PLT entry offset, or -1 if none. */
340 bfd_vma comp_offset;
341
342 /* The corresponding .got.plt index, or -1 if none. */
343 bfd_vma gotplt_index;
344
345 /* Whether we need a standard PLT entry. */
346 unsigned int need_mips : 1;
347
348 /* Whether we need a compressed PLT entry. */
349 unsigned int need_comp : 1;
350 };
351
352 /* The MIPS ELF linker needs additional information for each symbol in
353 the global hash table. */
354
355 struct mips_elf_link_hash_entry
356 {
357 struct elf_link_hash_entry root;
358
359 /* External symbol information. */
360 EXTR esym;
361
362 /* The la25 stub we have created for ths symbol, if any. */
363 struct mips_elf_la25_stub *la25_stub;
364
365 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
366 this symbol. */
367 unsigned int possibly_dynamic_relocs;
368
369 /* If there is a stub that 32 bit functions should use to call this
370 16 bit function, this points to the section containing the stub. */
371 asection *fn_stub;
372
373 /* If there is a stub that 16 bit functions should use to call this
374 32 bit function, this points to the section containing the stub. */
375 asection *call_stub;
376
377 /* This is like the call_stub field, but it is used if the function
378 being called returns a floating point value. */
379 asection *call_fp_stub;
380
381 /* The highest GGA_* value that satisfies all references to this symbol. */
382 unsigned int global_got_area : 2;
383
384 /* True if all GOT relocations against this symbol are for calls. This is
385 a looser condition than no_fn_stub below, because there may be other
386 non-call non-GOT relocations against the symbol. */
387 unsigned int got_only_for_calls : 1;
388
389 /* True if one of the relocations described by possibly_dynamic_relocs
390 is against a readonly section. */
391 unsigned int readonly_reloc : 1;
392
393 /* True if there is a relocation against this symbol that must be
394 resolved by the static linker (in other words, if the relocation
395 cannot possibly be made dynamic). */
396 unsigned int has_static_relocs : 1;
397
398 /* True if we must not create a .MIPS.stubs entry for this symbol.
399 This is set, for example, if there are relocations related to
400 taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
401 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */
402 unsigned int no_fn_stub : 1;
403
404 /* Whether we need the fn_stub; this is true if this symbol appears
405 in any relocs other than a 16 bit call. */
406 unsigned int need_fn_stub : 1;
407
408 /* True if this symbol is referenced by branch relocations from
409 any non-PIC input file. This is used to determine whether an
410 la25 stub is required. */
411 unsigned int has_nonpic_branches : 1;
412
413 /* Does this symbol need a traditional MIPS lazy-binding stub
414 (as opposed to a PLT entry)? */
415 unsigned int needs_lazy_stub : 1;
416
417 /* Does this symbol resolve to a PLT entry? */
418 unsigned int use_plt_entry : 1;
419 };
420
421 /* MIPS ELF linker hash table. */
422
423 struct mips_elf_link_hash_table
424 {
425 struct elf_link_hash_table root;
426
427 /* The number of .rtproc entries. */
428 bfd_size_type procedure_count;
429
430 /* The size of the .compact_rel section (if SGI_COMPAT). */
431 bfd_size_type compact_rel_size;
432
433 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry
434 is set to the address of __rld_obj_head as in IRIX5 and IRIX6. */
435 bfd_boolean use_rld_obj_head;
436
437 /* The __rld_map or __rld_obj_head symbol. */
438 struct elf_link_hash_entry *rld_symbol;
439
440 /* This is set if we see any mips16 stub sections. */
441 bfd_boolean mips16_stubs_seen;
442
443 /* True if we can generate copy relocs and PLTs. */
444 bfd_boolean use_plts_and_copy_relocs;
445
446 /* True if we can only use 32-bit microMIPS instructions. */
447 bfd_boolean insn32;
448
449 /* True if we suppress checks for invalid branches between ISA modes. */
450 bfd_boolean ignore_branch_isa;
451
452 /* True if we're generating code for VxWorks. */
453 bfd_boolean is_vxworks;
454
455 /* True if we already reported the small-data section overflow. */
456 bfd_boolean small_data_overflow_reported;
457
458 /* Shortcuts to some dynamic sections, or NULL if they are not
459 being used. */
460 asection *srelplt2;
461 asection *sstubs;
462
463 /* The master GOT information. */
464 struct mips_got_info *got_info;
465
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
470 /* The size of the PLT header in bytes. */
471 bfd_vma plt_header_size;
472
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;
487
488 /* The number of functions that need a lazy-binding stub. */
489 bfd_vma lazy_stub_count;
490
491 /* The size of a function stub entry in bytes. */
492 bfd_vma function_stub_size;
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 *);
513
514 /* Small local sym cache. */
515 struct sym_cache sym_cache;
516
517 /* Is the PLT header compressed? */
518 unsigned int plt_header_is_comp : 1;
519 };
520
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
527 /* A structure used to communicate with htab_traverse callbacks. */
528 struct mips_htab_traverse_info
529 {
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;
536 };
537
538 /* MIPS ELF private object data. */
539
540 struct 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;
547
548 /* Input BFD providing Tag_GNU_MIPS_ABI_MSA attribute for output. */
549 bfd *abi_msa_bfd;
550
551 /* The abiflags for this object. */
552 Elf_Internal_ABIFlags_v0 abiflags;
553 bfd_boolean abiflags_valid;
554
555 /* The GOT requirements of input bfds. */
556 struct mips_got_info *got;
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;
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
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 \
593 || r_type == R_MIPS_TLS_TPREL_LO16 \
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 \
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)
608
609 /* Structure used to pass information to mips_elf_output_extsym. */
610
611 struct extsym_info
612 {
613 bfd *abfd;
614 struct bfd_link_info *info;
615 struct ecoff_debug_info *debug;
616 const struct ecoff_debug_swap *swap;
617 bfd_boolean failed;
618 };
619
620 /* The names of the runtime procedure table symbols used on IRIX5. */
621
622 static 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
631 IRIX5. */
632
633 typedef 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
643 typedef 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
653 typedef 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
663 typedef 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
672 typedef struct
673 {
674 bfd_byte info[4];
675 bfd_byte konst[4];
676 bfd_byte vaddr[4];
677 } Elf32_External_crinfo;
678
679 typedef 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
725 typedef struct runtime_pdr {
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. */
735 long reserved;
736 struct exception_info *exception_info;/* Pointer to exception array. */
737 } RPDR, *pRPDR;
738 #define cbRPDR sizeof (RPDR)
739 #define rpdNil ((pRPDR) 0)
740 \f
741 static struct mips_got_entry *mips_elf_create_local_got_entry
742 (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long,
743 struct mips_elf_link_hash_entry *, int);
744 static bfd_boolean mips_elf_sort_hash_table_f
745 (struct mips_elf_link_hash_entry *, void *);
746 static bfd_vma mips_elf_high
747 (bfd_vma);
748 static bfd_boolean mips_elf_create_dynamic_relocation
749 (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
750 struct mips_elf_link_hash_entry *, asection *, bfd_vma,
751 bfd_vma *, asection *);
752 static bfd_vma mips_elf_adjust_gp
753 (bfd *, struct mips_got_info *, bfd *);
754
755 /* This will be used when we sort the dynamic relocation records. */
756 static bfd *reldyn_sorting_bfd;
757
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
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
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
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
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
788 /* Nonzero if ABFD is using the N32 ABI. */
789 #define ABI_N32_P(abfd) \
790 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
791
792 /* Nonzero if ABFD is using the N64 ABI. */
793 #define ABI_64_P(abfd) \
794 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
795
796 /* Nonzero if ABFD is using NewABI conventions. */
797 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
798
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
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
808 /* The IRIX compatibility level we are striving for. */
809 #define IRIX_COMPAT(abfd) \
810 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
811
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) \
818 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
819
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
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
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
834 /* The name of the stub section. */
835 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
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
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
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
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
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) \
863 (get_elf_backend_data (abfd)->s->log_file_align)
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
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
879 /* Add a dynamic symbol table-entry. */
880 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
881 _bfd_elf_add_dynamic_entry (info, tag, val)
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
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
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)
893 #define MINUS_TWO (((bfd_vma)0) - 2)
894
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
901 /* The offset of $gp from the beginning of the .got section. */
902 #define ELF_MIPS_GP_OFFSET(INFO) \
903 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
904
905 /* The maximum size of the GOT for it to be addressable using 16-bit
906 offsets from $gp. */
907 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
908
909 /* Instructions which appear in a stub. */
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 0x03e07825 /* or t7,ra,zero */
915 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
916 #define STUB_JALR 0x0320f809 /* jalr ra,t9 */
917 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
918 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
919 #define STUB_LI16S(abfd, VAL) \
920 ((ABI_64_P (abfd) \
921 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
922 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
923
924 /* Likewise for the microMIPS ASE. */
925 #define STUB_LW_MICROMIPS(abfd) \
926 (ABI_64_P (abfd) \
927 ? 0xdf3c8010 /* ld t9,0x8010(gp) */ \
928 : 0xff3c8010) /* lw t9,0x8010(gp) */
929 #define STUB_MOVE_MICROMIPS 0x0dff /* move t7,ra */
930 #define STUB_MOVE32_MICROMIPS 0x001f7a90 /* or t7,ra,zero */
931 #define STUB_LUI_MICROMIPS(VAL) \
932 (0x41b80000 + (VAL)) /* lui t8,VAL */
933 #define STUB_JALR_MICROMIPS 0x45d9 /* jalr t9 */
934 #define STUB_JALR32_MICROMIPS 0x03f90f3c /* jalr ra,t9 */
935 #define STUB_ORI_MICROMIPS(VAL) \
936 (0x53180000 + (VAL)) /* ori t8,t8,VAL */
937 #define STUB_LI16U_MICROMIPS(VAL) \
938 (0x53000000 + (VAL)) /* ori t8,zero,VAL unsigned */
939 #define STUB_LI16S_MICROMIPS(abfd, VAL) \
940 (ABI_64_P (abfd) \
941 ? 0x5f000000 + (VAL) /* daddiu t8,zero,VAL sign extended */ \
942 : 0x33000000 + (VAL)) /* addiu t8,zero,VAL sign extended */
943
944 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
945 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
946 #define MICROMIPS_FUNCTION_STUB_NORMAL_SIZE 12
947 #define MICROMIPS_FUNCTION_STUB_BIG_SIZE 16
948 #define MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE 16
949 #define MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE 20
950
951 /* The name of the dynamic interpreter. This is put in the .interp
952 section. */
953
954 #define ELF_DYNAMIC_INTERPRETER(abfd) \
955 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
956 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
957 : "/usr/lib/libc.so.1")
958
959 #ifdef BFD64
960 #define MNAME(bfd,pre,pos) \
961 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
962 #define ELF_R_SYM(bfd, i) \
963 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
964 #define ELF_R_TYPE(bfd, i) \
965 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
966 #define ELF_R_INFO(bfd, s, t) \
967 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
968 #else
969 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
970 #define ELF_R_SYM(bfd, i) \
971 (ELF32_R_SYM (i))
972 #define ELF_R_TYPE(bfd, i) \
973 (ELF32_R_TYPE (i))
974 #define ELF_R_INFO(bfd, s, t) \
975 (ELF32_R_INFO (s, t))
976 #endif
977 \f
978 /* The mips16 compiler uses a couple of special sections to handle
979 floating point arguments.
980
981 Section names that look like .mips16.fn.FNNAME contain stubs that
982 copy floating point arguments from the fp regs to the gp regs and
983 then jump to FNNAME. If any 32 bit function calls FNNAME, the
984 call should be redirected to the stub instead. If no 32 bit
985 function calls FNNAME, the stub should be discarded. We need to
986 consider any reference to the function, not just a call, because
987 if the address of the function is taken we will need the stub,
988 since the address might be passed to a 32 bit function.
989
990 Section names that look like .mips16.call.FNNAME contain stubs
991 that copy floating point arguments from the gp regs to the fp
992 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
993 then any 16 bit function that calls FNNAME should be redirected
994 to the stub instead. If FNNAME is not a 32 bit function, the
995 stub should be discarded.
996
997 .mips16.call.fp.FNNAME sections are similar, but contain stubs
998 which call FNNAME and then copy the return value from the fp regs
999 to the gp regs. These stubs store the return value in $18 while
1000 calling FNNAME; any function which might call one of these stubs
1001 must arrange to save $18 around the call. (This case is not
1002 needed for 32 bit functions that call 16 bit functions, because
1003 16 bit functions always return floating point values in both
1004 $f0/$f1 and $2/$3.)
1005
1006 Note that in all cases FNNAME might be defined statically.
1007 Therefore, FNNAME is not used literally. Instead, the relocation
1008 information will indicate which symbol the section is for.
1009
1010 We record any stubs that we find in the symbol table. */
1011
1012 #define FN_STUB ".mips16.fn."
1013 #define CALL_STUB ".mips16.call."
1014 #define CALL_FP_STUB ".mips16.call.fp."
1015
1016 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
1017 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
1018 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
1019 \f
1020 /* The format of the first PLT entry in an O32 executable. */
1021 static const bfd_vma mips_o32_exec_plt0_entry[] =
1022 {
1023 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */
1024 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */
1025 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
1026 0x031cc023, /* subu $24, $24, $28 */
1027 0x03e07825, /* or t7, ra, zero */
1028 0x0018c082, /* srl $24, $24, 2 */
1029 0x0320f809, /* jalr $25 */
1030 0x2718fffe /* subu $24, $24, 2 */
1031 };
1032
1033 /* The format of the first PLT entry in an N32 executable. Different
1034 because gp ($28) is not available; we use t2 ($14) instead. */
1035 static const bfd_vma mips_n32_exec_plt0_entry[] =
1036 {
1037 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1038 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */
1039 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1040 0x030ec023, /* subu $24, $24, $14 */
1041 0x03e07825, /* or t7, ra, zero */
1042 0x0018c082, /* srl $24, $24, 2 */
1043 0x0320f809, /* jalr $25 */
1044 0x2718fffe /* subu $24, $24, 2 */
1045 };
1046
1047 /* The format of the first PLT entry in an N64 executable. Different
1048 from N32 because of the increased size of GOT entries. */
1049 static const bfd_vma mips_n64_exec_plt0_entry[] =
1050 {
1051 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1052 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */
1053 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1054 0x030ec023, /* subu $24, $24, $14 */
1055 0x03e07825, /* or t7, ra, zero */
1056 0x0018c0c2, /* srl $24, $24, 3 */
1057 0x0320f809, /* jalr $25 */
1058 0x2718fffe /* subu $24, $24, 2 */
1059 };
1060
1061 /* The format of the microMIPS first PLT entry in an O32 executable.
1062 We rely on v0 ($2) rather than t8 ($24) to contain the address
1063 of the GOTPLT entry handled, so this stub may only be used when
1064 all the subsequent PLT entries are microMIPS code too.
1065
1066 The trailing NOP is for alignment and correct disassembly only. */
1067 static const bfd_vma micromips_o32_exec_plt0_entry[] =
1068 {
1069 0x7980, 0x0000, /* addiupc $3, (&GOTPLT[0]) - . */
1070 0xff23, 0x0000, /* lw $25, 0($3) */
1071 0x0535, /* subu $2, $2, $3 */
1072 0x2525, /* srl $2, $2, 2 */
1073 0x3302, 0xfffe, /* subu $24, $2, 2 */
1074 0x0dff, /* move $15, $31 */
1075 0x45f9, /* jalrs $25 */
1076 0x0f83, /* move $28, $3 */
1077 0x0c00 /* nop */
1078 };
1079
1080 /* The format of the microMIPS first PLT entry in an O32 executable
1081 in the insn32 mode. */
1082 static const bfd_vma micromips_insn32_o32_exec_plt0_entry[] =
1083 {
1084 0x41bc, 0x0000, /* lui $28, %hi(&GOTPLT[0]) */
1085 0xff3c, 0x0000, /* lw $25, %lo(&GOTPLT[0])($28) */
1086 0x339c, 0x0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
1087 0x0398, 0xc1d0, /* subu $24, $24, $28 */
1088 0x001f, 0x7a90, /* or $15, $31, zero */
1089 0x0318, 0x1040, /* srl $24, $24, 2 */
1090 0x03f9, 0x0f3c, /* jalr $25 */
1091 0x3318, 0xfffe /* subu $24, $24, 2 */
1092 };
1093
1094 /* The format of subsequent standard PLT entries. */
1095 static const bfd_vma mips_exec_plt_entry[] =
1096 {
1097 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
1098 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
1099 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
1100 0x03200008 /* jr $25 */
1101 };
1102
1103 /* In the following PLT entry the JR and ADDIU instructions will
1104 be swapped in _bfd_mips_elf_finish_dynamic_symbol because
1105 LOAD_INTERLOCKS_P will be true for MIPS R6. */
1106 static const bfd_vma mipsr6_exec_plt_entry[] =
1107 {
1108 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
1109 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
1110 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
1111 0x03200009 /* jr $25 */
1112 };
1113
1114 /* The format of subsequent MIPS16 o32 PLT entries. We use v0 ($2)
1115 and v1 ($3) as temporaries because t8 ($24) and t9 ($25) are not
1116 directly addressable. */
1117 static const bfd_vma mips16_o32_exec_plt_entry[] =
1118 {
1119 0xb203, /* lw $2, 12($pc) */
1120 0x9a60, /* lw $3, 0($2) */
1121 0x651a, /* move $24, $2 */
1122 0xeb00, /* jr $3 */
1123 0x653b, /* move $25, $3 */
1124 0x6500, /* nop */
1125 0x0000, 0x0000 /* .word (.got.plt entry) */
1126 };
1127
1128 /* The format of subsequent microMIPS o32 PLT entries. We use v0 ($2)
1129 as a temporary because t8 ($24) is not addressable with ADDIUPC. */
1130 static const bfd_vma micromips_o32_exec_plt_entry[] =
1131 {
1132 0x7900, 0x0000, /* addiupc $2, (.got.plt entry) - . */
1133 0xff22, 0x0000, /* lw $25, 0($2) */
1134 0x4599, /* jr $25 */
1135 0x0f02 /* move $24, $2 */
1136 };
1137
1138 /* The format of subsequent microMIPS o32 PLT entries in the insn32 mode. */
1139 static const bfd_vma micromips_insn32_o32_exec_plt_entry[] =
1140 {
1141 0x41af, 0x0000, /* lui $15, %hi(.got.plt entry) */
1142 0xff2f, 0x0000, /* lw $25, %lo(.got.plt entry)($15) */
1143 0x0019, 0x0f3c, /* jr $25 */
1144 0x330f, 0x0000 /* addiu $24, $15, %lo(.got.plt entry) */
1145 };
1146
1147 /* The format of the first PLT entry in a VxWorks executable. */
1148 static const bfd_vma mips_vxworks_exec_plt0_entry[] =
1149 {
1150 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
1151 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
1152 0x8f390008, /* lw t9, 8(t9) */
1153 0x00000000, /* nop */
1154 0x03200008, /* jr t9 */
1155 0x00000000 /* nop */
1156 };
1157
1158 /* The format of subsequent PLT entries. */
1159 static const bfd_vma mips_vxworks_exec_plt_entry[] =
1160 {
1161 0x10000000, /* b .PLT_resolver */
1162 0x24180000, /* li t8, <pltindex> */
1163 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
1164 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
1165 0x8f390000, /* lw t9, 0(t9) */
1166 0x00000000, /* nop */
1167 0x03200008, /* jr t9 */
1168 0x00000000 /* nop */
1169 };
1170
1171 /* The format of the first PLT entry in a VxWorks shared object. */
1172 static const bfd_vma mips_vxworks_shared_plt0_entry[] =
1173 {
1174 0x8f990008, /* lw t9, 8(gp) */
1175 0x00000000, /* nop */
1176 0x03200008, /* jr t9 */
1177 0x00000000, /* nop */
1178 0x00000000, /* nop */
1179 0x00000000 /* nop */
1180 };
1181
1182 /* The format of subsequent PLT entries. */
1183 static const bfd_vma mips_vxworks_shared_plt_entry[] =
1184 {
1185 0x10000000, /* b .PLT_resolver */
1186 0x24180000 /* li t8, <pltindex> */
1187 };
1188 \f
1189 /* microMIPS 32-bit opcode helper installer. */
1190
1191 static void
1192 bfd_put_micromips_32 (const bfd *abfd, bfd_vma opcode, bfd_byte *ptr)
1193 {
1194 bfd_put_16 (abfd, (opcode >> 16) & 0xffff, ptr);
1195 bfd_put_16 (abfd, opcode & 0xffff, ptr + 2);
1196 }
1197
1198 /* microMIPS 32-bit opcode helper retriever. */
1199
1200 static bfd_vma
1201 bfd_get_micromips_32 (const bfd *abfd, const bfd_byte *ptr)
1202 {
1203 return (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2);
1204 }
1205 \f
1206 /* Look up an entry in a MIPS ELF linker hash table. */
1207
1208 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
1209 ((struct mips_elf_link_hash_entry *) \
1210 elf_link_hash_lookup (&(table)->root, (string), (create), \
1211 (copy), (follow)))
1212
1213 /* Traverse a MIPS ELF linker hash table. */
1214
1215 #define mips_elf_link_hash_traverse(table, func, info) \
1216 (elf_link_hash_traverse \
1217 (&(table)->root, \
1218 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1219 (info)))
1220
1221 /* Find the base offsets for thread-local storage in this object,
1222 for GD/LD and IE/LE respectively. */
1223
1224 #define TP_OFFSET 0x7000
1225 #define DTP_OFFSET 0x8000
1226
1227 static bfd_vma
1228 dtprel_base (struct bfd_link_info *info)
1229 {
1230 /* If tls_sec is NULL, we should have signalled an error already. */
1231 if (elf_hash_table (info)->tls_sec == NULL)
1232 return 0;
1233 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
1234 }
1235
1236 static bfd_vma
1237 tprel_base (struct bfd_link_info *info)
1238 {
1239 /* If tls_sec is NULL, we should have signalled an error already. */
1240 if (elf_hash_table (info)->tls_sec == NULL)
1241 return 0;
1242 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
1243 }
1244
1245 /* Create an entry in a MIPS ELF linker hash table. */
1246
1247 static struct bfd_hash_entry *
1248 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1249 struct bfd_hash_table *table, const char *string)
1250 {
1251 struct mips_elf_link_hash_entry *ret =
1252 (struct mips_elf_link_hash_entry *) entry;
1253
1254 /* Allocate the structure if it has not already been allocated by a
1255 subclass. */
1256 if (ret == NULL)
1257 ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
1258 if (ret == NULL)
1259 return (struct bfd_hash_entry *) ret;
1260
1261 /* Call the allocation method of the superclass. */
1262 ret = ((struct mips_elf_link_hash_entry *)
1263 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1264 table, string));
1265 if (ret != NULL)
1266 {
1267 /* Set local fields. */
1268 memset (&ret->esym, 0, sizeof (EXTR));
1269 /* We use -2 as a marker to indicate that the information has
1270 not been set. -1 means there is no associated ifd. */
1271 ret->esym.ifd = -2;
1272 ret->la25_stub = 0;
1273 ret->possibly_dynamic_relocs = 0;
1274 ret->fn_stub = NULL;
1275 ret->call_stub = NULL;
1276 ret->call_fp_stub = NULL;
1277 ret->global_got_area = GGA_NONE;
1278 ret->got_only_for_calls = TRUE;
1279 ret->readonly_reloc = FALSE;
1280 ret->has_static_relocs = FALSE;
1281 ret->no_fn_stub = FALSE;
1282 ret->need_fn_stub = FALSE;
1283 ret->has_nonpic_branches = FALSE;
1284 ret->needs_lazy_stub = FALSE;
1285 ret->use_plt_entry = FALSE;
1286 }
1287
1288 return (struct bfd_hash_entry *) ret;
1289 }
1290
1291 /* Allocate MIPS ELF private object data. */
1292
1293 bfd_boolean
1294 _bfd_mips_elf_mkobject (bfd *abfd)
1295 {
1296 return bfd_elf_allocate_object (abfd, sizeof (struct mips_elf_obj_tdata),
1297 MIPS_ELF_DATA);
1298 }
1299
1300 bfd_boolean
1301 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
1302 {
1303 if (!sec->used_by_bfd)
1304 {
1305 struct _mips_elf_section_data *sdata;
1306 bfd_size_type amt = sizeof (*sdata);
1307
1308 sdata = bfd_zalloc (abfd, amt);
1309 if (sdata == NULL)
1310 return FALSE;
1311 sec->used_by_bfd = sdata;
1312 }
1313
1314 return _bfd_elf_new_section_hook (abfd, sec);
1315 }
1316 \f
1317 /* Read ECOFF debugging information from a .mdebug section into a
1318 ecoff_debug_info structure. */
1319
1320 bfd_boolean
1321 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
1322 struct ecoff_debug_info *debug)
1323 {
1324 HDRR *symhdr;
1325 const struct ecoff_debug_swap *swap;
1326 char *ext_hdr;
1327
1328 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1329 memset (debug, 0, sizeof (*debug));
1330
1331 ext_hdr = bfd_malloc (swap->external_hdr_size);
1332 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1333 goto error_return;
1334
1335 if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
1336 swap->external_hdr_size))
1337 goto error_return;
1338
1339 symhdr = &debug->symbolic_header;
1340 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1341
1342 /* The symbolic header contains absolute file offsets and sizes to
1343 read. */
1344 #define READ(ptr, offset, count, size, type) \
1345 if (symhdr->count == 0) \
1346 debug->ptr = NULL; \
1347 else \
1348 { \
1349 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1350 debug->ptr = bfd_malloc (amt); \
1351 if (debug->ptr == NULL) \
1352 goto error_return; \
1353 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
1354 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1355 goto error_return; \
1356 }
1357
1358 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1359 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1360 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1361 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1362 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1363 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1364 union aux_ext *);
1365 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1366 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1367 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1368 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1369 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1370 #undef READ
1371
1372 debug->fdr = NULL;
1373
1374 return TRUE;
1375
1376 error_return:
1377 if (ext_hdr != NULL)
1378 free (ext_hdr);
1379 if (debug->line != NULL)
1380 free (debug->line);
1381 if (debug->external_dnr != NULL)
1382 free (debug->external_dnr);
1383 if (debug->external_pdr != NULL)
1384 free (debug->external_pdr);
1385 if (debug->external_sym != NULL)
1386 free (debug->external_sym);
1387 if (debug->external_opt != NULL)
1388 free (debug->external_opt);
1389 if (debug->external_aux != NULL)
1390 free (debug->external_aux);
1391 if (debug->ss != NULL)
1392 free (debug->ss);
1393 if (debug->ssext != NULL)
1394 free (debug->ssext);
1395 if (debug->external_fdr != NULL)
1396 free (debug->external_fdr);
1397 if (debug->external_rfd != NULL)
1398 free (debug->external_rfd);
1399 if (debug->external_ext != NULL)
1400 free (debug->external_ext);
1401 return FALSE;
1402 }
1403 \f
1404 /* Swap RPDR (runtime procedure table entry) for output. */
1405
1406 static void
1407 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
1408 {
1409 H_PUT_S32 (abfd, in->adr, ex->p_adr);
1410 H_PUT_32 (abfd, in->regmask, ex->p_regmask);
1411 H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
1412 H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
1413 H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
1414 H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
1415
1416 H_PUT_16 (abfd, in->framereg, ex->p_framereg);
1417 H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
1418
1419 H_PUT_32 (abfd, in->irpss, ex->p_irpss);
1420 }
1421
1422 /* Create a runtime procedure table from the .mdebug section. */
1423
1424 static bfd_boolean
1425 mips_elf_create_procedure_table (void *handle, bfd *abfd,
1426 struct bfd_link_info *info, asection *s,
1427 struct ecoff_debug_info *debug)
1428 {
1429 const struct ecoff_debug_swap *swap;
1430 HDRR *hdr = &debug->symbolic_header;
1431 RPDR *rpdr, *rp;
1432 struct rpdr_ext *erp;
1433 void *rtproc;
1434 struct pdr_ext *epdr;
1435 struct sym_ext *esym;
1436 char *ss, **sv;
1437 char *str;
1438 bfd_size_type size;
1439 bfd_size_type count;
1440 unsigned long sindex;
1441 unsigned long i;
1442 PDR pdr;
1443 SYMR sym;
1444 const char *no_name_func = _("static procedure (no name)");
1445
1446 epdr = NULL;
1447 rpdr = NULL;
1448 esym = NULL;
1449 ss = NULL;
1450 sv = NULL;
1451
1452 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1453
1454 sindex = strlen (no_name_func) + 1;
1455 count = hdr->ipdMax;
1456 if (count > 0)
1457 {
1458 size = swap->external_pdr_size;
1459
1460 epdr = bfd_malloc (size * count);
1461 if (epdr == NULL)
1462 goto error_return;
1463
1464 if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
1465 goto error_return;
1466
1467 size = sizeof (RPDR);
1468 rp = rpdr = bfd_malloc (size * count);
1469 if (rpdr == NULL)
1470 goto error_return;
1471
1472 size = sizeof (char *);
1473 sv = bfd_malloc (size * count);
1474 if (sv == NULL)
1475 goto error_return;
1476
1477 count = hdr->isymMax;
1478 size = swap->external_sym_size;
1479 esym = bfd_malloc (size * count);
1480 if (esym == NULL)
1481 goto error_return;
1482
1483 if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
1484 goto error_return;
1485
1486 count = hdr->issMax;
1487 ss = bfd_malloc (count);
1488 if (ss == NULL)
1489 goto error_return;
1490 if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
1491 goto error_return;
1492
1493 count = hdr->ipdMax;
1494 for (i = 0; i < (unsigned long) count; i++, rp++)
1495 {
1496 (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1497 (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
1498 rp->adr = sym.value;
1499 rp->regmask = pdr.regmask;
1500 rp->regoffset = pdr.regoffset;
1501 rp->fregmask = pdr.fregmask;
1502 rp->fregoffset = pdr.fregoffset;
1503 rp->frameoffset = pdr.frameoffset;
1504 rp->framereg = pdr.framereg;
1505 rp->pcreg = pdr.pcreg;
1506 rp->irpss = sindex;
1507 sv[i] = ss + sym.iss;
1508 sindex += strlen (sv[i]) + 1;
1509 }
1510 }
1511
1512 size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1513 size = BFD_ALIGN (size, 16);
1514 rtproc = bfd_alloc (abfd, size);
1515 if (rtproc == NULL)
1516 {
1517 mips_elf_hash_table (info)->procedure_count = 0;
1518 goto error_return;
1519 }
1520
1521 mips_elf_hash_table (info)->procedure_count = count + 2;
1522
1523 erp = rtproc;
1524 memset (erp, 0, sizeof (struct rpdr_ext));
1525 erp++;
1526 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1527 strcpy (str, no_name_func);
1528 str += strlen (no_name_func) + 1;
1529 for (i = 0; i < count; i++)
1530 {
1531 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1532 strcpy (str, sv[i]);
1533 str += strlen (sv[i]) + 1;
1534 }
1535 H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1536
1537 /* Set the size and contents of .rtproc section. */
1538 s->size = size;
1539 s->contents = rtproc;
1540
1541 /* Skip this section later on (I don't think this currently
1542 matters, but someday it might). */
1543 s->map_head.link_order = NULL;
1544
1545 if (epdr != NULL)
1546 free (epdr);
1547 if (rpdr != NULL)
1548 free (rpdr);
1549 if (esym != NULL)
1550 free (esym);
1551 if (ss != NULL)
1552 free (ss);
1553 if (sv != NULL)
1554 free (sv);
1555
1556 return TRUE;
1557
1558 error_return:
1559 if (epdr != NULL)
1560 free (epdr);
1561 if (rpdr != NULL)
1562 free (rpdr);
1563 if (esym != NULL)
1564 free (esym);
1565 if (ss != NULL)
1566 free (ss);
1567 if (sv != NULL)
1568 free (sv);
1569 return FALSE;
1570 }
1571 \f
1572 /* We're going to create a stub for H. Create a symbol for the stub's
1573 value and size, to help make the disassembly easier to read. */
1574
1575 static bfd_boolean
1576 mips_elf_create_stub_symbol (struct bfd_link_info *info,
1577 struct mips_elf_link_hash_entry *h,
1578 const char *prefix, asection *s, bfd_vma value,
1579 bfd_vma size)
1580 {
1581 bfd_boolean micromips_p = ELF_ST_IS_MICROMIPS (h->root.other);
1582 struct bfd_link_hash_entry *bh;
1583 struct elf_link_hash_entry *elfh;
1584 char *name;
1585 bfd_boolean res;
1586
1587 if (micromips_p)
1588 value |= 1;
1589
1590 /* Create a new symbol. */
1591 name = concat (prefix, h->root.root.root.string, NULL);
1592 bh = NULL;
1593 res = _bfd_generic_link_add_one_symbol (info, s->owner, name,
1594 BSF_LOCAL, s, value, NULL,
1595 TRUE, FALSE, &bh);
1596 free (name);
1597 if (! res)
1598 return FALSE;
1599
1600 /* Make it a local function. */
1601 elfh = (struct elf_link_hash_entry *) bh;
1602 elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
1603 elfh->size = size;
1604 elfh->forced_local = 1;
1605 if (micromips_p)
1606 elfh->other = ELF_ST_SET_MICROMIPS (elfh->other);
1607 return TRUE;
1608 }
1609
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
1614 static bfd_boolean
1615 mips_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 char *name;
1622 asection *s;
1623 bfd_vma value;
1624 bfd_boolean res;
1625
1626 /* Read the symbol's value. */
1627 BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
1628 || h->root.root.type == bfd_link_hash_defweak);
1629 s = h->root.root.u.def.section;
1630 value = h->root.root.u.def.value;
1631
1632 /* Create a new symbol. */
1633 name = concat (prefix, h->root.root.root.string, NULL);
1634 bh = NULL;
1635 res = _bfd_generic_link_add_one_symbol (info, s->owner, name,
1636 BSF_LOCAL, s, value, NULL,
1637 TRUE, FALSE, &bh);
1638 free (name);
1639 if (! res)
1640 return FALSE;
1641
1642 /* Make it local and copy the other attributes from H. */
1643 elfh = (struct elf_link_hash_entry *) bh;
1644 elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type));
1645 elfh->other = h->root.other;
1646 elfh->size = h->root.size;
1647 elfh->forced_local = 1;
1648 return TRUE;
1649 }
1650
1651 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1652 function rather than to a hard-float stub. */
1653
1654 static bfd_boolean
1655 section_allows_mips16_refs_p (asection *section)
1656 {
1657 const char *name;
1658
1659 name = bfd_get_section_name (section->owner, section);
1660 return (FN_STUB_P (name)
1661 || CALL_STUB_P (name)
1662 || CALL_FP_STUB_P (name)
1663 || strcmp (name, ".pdr") == 0);
1664 }
1665
1666 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1667 stub section of some kind. Return the R_SYMNDX of the target
1668 function, or 0 if we can't decide which function that is. */
1669
1670 static unsigned long
1671 mips16_stub_symndx (const struct elf_backend_data *bed,
1672 asection *sec ATTRIBUTE_UNUSED,
1673 const Elf_Internal_Rela *relocs,
1674 const Elf_Internal_Rela *relend)
1675 {
1676 int int_rels_per_ext_rel = bed->s->int_rels_per_ext_rel;
1677 const Elf_Internal_Rela *rel;
1678
1679 /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
1680 one in a compound relocation. */
1681 for (rel = relocs; rel < relend; rel += int_rels_per_ext_rel)
1682 if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE)
1683 return ELF_R_SYM (sec->owner, rel->r_info);
1684
1685 /* Otherwise trust the first relocation, whatever its kind. This is
1686 the traditional behavior. */
1687 if (relocs < relend)
1688 return ELF_R_SYM (sec->owner, relocs->r_info);
1689
1690 return 0;
1691 }
1692
1693 /* Check the mips16 stubs for a particular symbol, and see if we can
1694 discard them. */
1695
1696 static void
1697 mips_elf_check_mips16_stubs (struct bfd_link_info *info,
1698 struct mips_elf_link_hash_entry *h)
1699 {
1700 /* Dynamic symbols must use the standard call interface, in case other
1701 objects try to call them. */
1702 if (h->fn_stub != NULL
1703 && h->root.dynindx != -1)
1704 {
1705 mips_elf_create_shadow_symbol (info, h, ".mips16.");
1706 h->need_fn_stub = TRUE;
1707 }
1708
1709 if (h->fn_stub != NULL
1710 && ! h->need_fn_stub)
1711 {
1712 /* We don't need the fn_stub; the only references to this symbol
1713 are 16 bit calls. Clobber the size to 0 to prevent it from
1714 being included in the link. */
1715 h->fn_stub->size = 0;
1716 h->fn_stub->flags &= ~SEC_RELOC;
1717 h->fn_stub->reloc_count = 0;
1718 h->fn_stub->flags |= SEC_EXCLUDE;
1719 h->fn_stub->output_section = bfd_abs_section_ptr;
1720 }
1721
1722 if (h->call_stub != NULL
1723 && ELF_ST_IS_MIPS16 (h->root.other))
1724 {
1725 /* We don't need the call_stub; this is a 16 bit function, so
1726 calls from other 16 bit functions are OK. Clobber the size
1727 to 0 to prevent it from being included in the link. */
1728 h->call_stub->size = 0;
1729 h->call_stub->flags &= ~SEC_RELOC;
1730 h->call_stub->reloc_count = 0;
1731 h->call_stub->flags |= SEC_EXCLUDE;
1732 h->call_stub->output_section = bfd_abs_section_ptr;
1733 }
1734
1735 if (h->call_fp_stub != NULL
1736 && ELF_ST_IS_MIPS16 (h->root.other))
1737 {
1738 /* We don't need the call_stub; this is a 16 bit function, so
1739 calls from other 16 bit functions are OK. Clobber the size
1740 to 0 to prevent it from being included in the link. */
1741 h->call_fp_stub->size = 0;
1742 h->call_fp_stub->flags &= ~SEC_RELOC;
1743 h->call_fp_stub->reloc_count = 0;
1744 h->call_fp_stub->flags |= SEC_EXCLUDE;
1745 h->call_fp_stub->output_section = bfd_abs_section_ptr;
1746 }
1747 }
1748
1749 /* Hashtable callbacks for mips_elf_la25_stubs. */
1750
1751 static hashval_t
1752 mips_elf_la25_stub_hash (const void *entry_)
1753 {
1754 const struct mips_elf_la25_stub *entry;
1755
1756 entry = (struct mips_elf_la25_stub *) entry_;
1757 return entry->h->root.root.u.def.section->id
1758 + entry->h->root.root.u.def.value;
1759 }
1760
1761 static int
1762 mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_)
1763 {
1764 const struct mips_elf_la25_stub *entry1, *entry2;
1765
1766 entry1 = (struct mips_elf_la25_stub *) entry1_;
1767 entry2 = (struct mips_elf_la25_stub *) entry2_;
1768 return ((entry1->h->root.root.u.def.section
1769 == entry2->h->root.root.u.def.section)
1770 && (entry1->h->root.root.u.def.value
1771 == entry2->h->root.root.u.def.value));
1772 }
1773
1774 /* Called by the linker to set up the la25 stub-creation code. FN is
1775 the linker's implementation of add_stub_function. Return true on
1776 success. */
1777
1778 bfd_boolean
1779 _bfd_mips_elf_init_stubs (struct bfd_link_info *info,
1780 asection *(*fn) (const char *, asection *,
1781 asection *))
1782 {
1783 struct mips_elf_link_hash_table *htab;
1784
1785 htab = mips_elf_hash_table (info);
1786 if (htab == NULL)
1787 return FALSE;
1788
1789 htab->add_stub_section = fn;
1790 htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash,
1791 mips_elf_la25_stub_eq, NULL);
1792 if (htab->la25_stubs == NULL)
1793 return FALSE;
1794
1795 return TRUE;
1796 }
1797
1798 /* Return true if H is a locally-defined PIC function, in the sense
1799 that it or its fn_stub might need $25 to be valid on entry.
1800 Note that MIPS16 functions set up $gp using PC-relative instructions,
1801 so they themselves never need $25 to be valid. Only non-MIPS16
1802 entry points are of interest here. */
1803
1804 static bfd_boolean
1805 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h)
1806 {
1807 return ((h->root.root.type == bfd_link_hash_defined
1808 || h->root.root.type == bfd_link_hash_defweak)
1809 && h->root.def_regular
1810 && !bfd_is_abs_section (h->root.root.u.def.section)
1811 && !bfd_is_und_section (h->root.root.u.def.section)
1812 && (!ELF_ST_IS_MIPS16 (h->root.other)
1813 || (h->fn_stub && h->need_fn_stub))
1814 && (PIC_OBJECT_P (h->root.root.u.def.section->owner)
1815 || ELF_ST_IS_MIPS_PIC (h->root.other)));
1816 }
1817
1818 /* Set *SEC to the input section that contains the target of STUB.
1819 Return the offset of the target from the start of that section. */
1820
1821 static bfd_vma
1822 mips_elf_get_la25_target (struct mips_elf_la25_stub *stub,
1823 asection **sec)
1824 {
1825 if (ELF_ST_IS_MIPS16 (stub->h->root.other))
1826 {
1827 BFD_ASSERT (stub->h->need_fn_stub);
1828 *sec = stub->h->fn_stub;
1829 return 0;
1830 }
1831 else
1832 {
1833 *sec = stub->h->root.root.u.def.section;
1834 return stub->h->root.root.u.def.value;
1835 }
1836 }
1837
1838 /* STUB describes an la25 stub that we have decided to implement
1839 by inserting an LUI/ADDIU pair before the target function.
1840 Create the section and redirect the function symbol to it. */
1841
1842 static bfd_boolean
1843 mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub,
1844 struct bfd_link_info *info)
1845 {
1846 struct mips_elf_link_hash_table *htab;
1847 char *name;
1848 asection *s, *input_section;
1849 unsigned int align;
1850
1851 htab = mips_elf_hash_table (info);
1852 if (htab == NULL)
1853 return FALSE;
1854
1855 /* Create a unique name for the new section. */
1856 name = bfd_malloc (11 + sizeof (".text.stub."));
1857 if (name == NULL)
1858 return FALSE;
1859 sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs));
1860
1861 /* Create the section. */
1862 mips_elf_get_la25_target (stub, &input_section);
1863 s = htab->add_stub_section (name, input_section,
1864 input_section->output_section);
1865 if (s == NULL)
1866 return FALSE;
1867
1868 /* Make sure that any padding goes before the stub. */
1869 align = input_section->alignment_power;
1870 if (!bfd_set_section_alignment (s->owner, s, align))
1871 return FALSE;
1872 if (align > 3)
1873 s->size = (1 << align) - 8;
1874
1875 /* Create a symbol for the stub. */
1876 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8);
1877 stub->stub_section = s;
1878 stub->offset = s->size;
1879
1880 /* Allocate room for it. */
1881 s->size += 8;
1882 return TRUE;
1883 }
1884
1885 /* STUB describes an la25 stub that we have decided to implement
1886 with a separate trampoline. Allocate room for it and redirect
1887 the function symbol to it. */
1888
1889 static bfd_boolean
1890 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub,
1891 struct bfd_link_info *info)
1892 {
1893 struct mips_elf_link_hash_table *htab;
1894 asection *s;
1895
1896 htab = mips_elf_hash_table (info);
1897 if (htab == NULL)
1898 return FALSE;
1899
1900 /* Create a trampoline section, if we haven't already. */
1901 s = htab->strampoline;
1902 if (s == NULL)
1903 {
1904 asection *input_section = stub->h->root.root.u.def.section;
1905 s = htab->add_stub_section (".text", NULL,
1906 input_section->output_section);
1907 if (s == NULL || !bfd_set_section_alignment (s->owner, s, 4))
1908 return FALSE;
1909 htab->strampoline = s;
1910 }
1911
1912 /* Create a symbol for the stub. */
1913 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16);
1914 stub->stub_section = s;
1915 stub->offset = s->size;
1916
1917 /* Allocate room for it. */
1918 s->size += 16;
1919 return TRUE;
1920 }
1921
1922 /* H describes a symbol that needs an la25 stub. Make sure that an
1923 appropriate stub exists and point H at it. */
1924
1925 static bfd_boolean
1926 mips_elf_add_la25_stub (struct bfd_link_info *info,
1927 struct mips_elf_link_hash_entry *h)
1928 {
1929 struct mips_elf_link_hash_table *htab;
1930 struct mips_elf_la25_stub search, *stub;
1931 bfd_boolean use_trampoline_p;
1932 asection *s;
1933 bfd_vma value;
1934 void **slot;
1935
1936 /* Describe the stub we want. */
1937 search.stub_section = NULL;
1938 search.offset = 0;
1939 search.h = h;
1940
1941 /* See if we've already created an equivalent stub. */
1942 htab = mips_elf_hash_table (info);
1943 if (htab == NULL)
1944 return FALSE;
1945
1946 slot = htab_find_slot (htab->la25_stubs, &search, INSERT);
1947 if (slot == NULL)
1948 return FALSE;
1949
1950 stub = (struct mips_elf_la25_stub *) *slot;
1951 if (stub != NULL)
1952 {
1953 /* We can reuse the existing stub. */
1954 h->la25_stub = stub;
1955 return TRUE;
1956 }
1957
1958 /* Create a permanent copy of ENTRY and add it to the hash table. */
1959 stub = bfd_malloc (sizeof (search));
1960 if (stub == NULL)
1961 return FALSE;
1962 *stub = search;
1963 *slot = stub;
1964
1965 /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1966 of the section and if we would need no more than 2 nops. */
1967 value = mips_elf_get_la25_target (stub, &s);
1968 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
1969 value &= ~1;
1970 use_trampoline_p = (value != 0 || s->alignment_power > 4);
1971
1972 h->la25_stub = stub;
1973 return (use_trampoline_p
1974 ? mips_elf_add_la25_trampoline (stub, info)
1975 : mips_elf_add_la25_intro (stub, info));
1976 }
1977
1978 /* A mips_elf_link_hash_traverse callback that is called before sizing
1979 sections. DATA points to a mips_htab_traverse_info structure. */
1980
1981 static bfd_boolean
1982 mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data)
1983 {
1984 struct mips_htab_traverse_info *hti;
1985
1986 hti = (struct mips_htab_traverse_info *) data;
1987 if (!bfd_link_relocatable (hti->info))
1988 mips_elf_check_mips16_stubs (hti->info, h);
1989
1990 if (mips_elf_local_pic_function_p (h))
1991 {
1992 /* PR 12845: If H is in a section that has been garbage
1993 collected it will have its output section set to *ABS*. */
1994 if (bfd_is_abs_section (h->root.root.u.def.section->output_section))
1995 return TRUE;
1996
1997 /* H is a function that might need $25 to be valid on entry.
1998 If we're creating a non-PIC relocatable object, mark H as
1999 being PIC. If we're creating a non-relocatable object with
2000 non-PIC branches and jumps to H, make sure that H has an la25
2001 stub. */
2002 if (bfd_link_relocatable (hti->info))
2003 {
2004 if (!PIC_OBJECT_P (hti->output_bfd))
2005 h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other);
2006 }
2007 else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h))
2008 {
2009 hti->error = TRUE;
2010 return FALSE;
2011 }
2012 }
2013 return TRUE;
2014 }
2015 \f
2016 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
2017 Most mips16 instructions are 16 bits, but these instructions
2018 are 32 bits.
2019
2020 The format of these instructions is:
2021
2022 +--------------+--------------------------------+
2023 | JALX | X| Imm 20:16 | Imm 25:21 |
2024 +--------------+--------------------------------+
2025 | Immediate 15:0 |
2026 +-----------------------------------------------+
2027
2028 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
2029 Note that the immediate value in the first word is swapped.
2030
2031 When producing a relocatable object file, R_MIPS16_26 is
2032 handled mostly like R_MIPS_26. In particular, the addend is
2033 stored as a straight 26-bit value in a 32-bit instruction.
2034 (gas makes life simpler for itself by never adjusting a
2035 R_MIPS16_26 reloc to be against a section, so the addend is
2036 always zero). However, the 32 bit instruction is stored as 2
2037 16-bit values, rather than a single 32-bit value. In a
2038 big-endian file, the result is the same; in a little-endian
2039 file, the two 16-bit halves of the 32 bit value are swapped.
2040 This is so that a disassembler can recognize the jal
2041 instruction.
2042
2043 When doing a final link, R_MIPS16_26 is treated as a 32 bit
2044 instruction stored as two 16-bit values. The addend A is the
2045 contents of the targ26 field. The calculation is the same as
2046 R_MIPS_26. When storing the calculated value, reorder the
2047 immediate value as shown above, and don't forget to store the
2048 value as two 16-bit values.
2049
2050 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
2051 defined as
2052
2053 big-endian:
2054 +--------+----------------------+
2055 | | |
2056 | | targ26-16 |
2057 |31 26|25 0|
2058 +--------+----------------------+
2059
2060 little-endian:
2061 +----------+------+-------------+
2062 | | | |
2063 | sub1 | | sub2 |
2064 |0 9|10 15|16 31|
2065 +----------+--------------------+
2066 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
2067 ((sub1 << 16) | sub2)).
2068
2069 When producing a relocatable object file, the calculation is
2070 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2071 When producing a fully linked file, the calculation is
2072 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2073 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
2074
2075 The table below lists the other MIPS16 instruction relocations.
2076 Each one is calculated in the same way as the non-MIPS16 relocation
2077 given on the right, but using the extended MIPS16 layout of 16-bit
2078 immediate fields:
2079
2080 R_MIPS16_GPREL R_MIPS_GPREL16
2081 R_MIPS16_GOT16 R_MIPS_GOT16
2082 R_MIPS16_CALL16 R_MIPS_CALL16
2083 R_MIPS16_HI16 R_MIPS_HI16
2084 R_MIPS16_LO16 R_MIPS_LO16
2085
2086 A typical instruction will have a format like this:
2087
2088 +--------------+--------------------------------+
2089 | EXTEND | Imm 10:5 | Imm 15:11 |
2090 +--------------+--------------------------------+
2091 | Major | rx | ry | Imm 4:0 |
2092 +--------------+--------------------------------+
2093
2094 EXTEND is the five bit value 11110. Major is the instruction
2095 opcode.
2096
2097 All we need to do here is shuffle the bits appropriately.
2098 As above, the two 16-bit halves must be swapped on a
2099 little-endian system.
2100
2101 Finally R_MIPS16_PC16_S1 corresponds to R_MIPS_PC16, however the
2102 relocatable field is shifted by 1 rather than 2 and the same bit
2103 shuffling is done as with the relocations above. */
2104
2105 static inline bfd_boolean
2106 mips16_reloc_p (int r_type)
2107 {
2108 switch (r_type)
2109 {
2110 case R_MIPS16_26:
2111 case R_MIPS16_GPREL:
2112 case R_MIPS16_GOT16:
2113 case R_MIPS16_CALL16:
2114 case R_MIPS16_HI16:
2115 case R_MIPS16_LO16:
2116 case R_MIPS16_TLS_GD:
2117 case R_MIPS16_TLS_LDM:
2118 case R_MIPS16_TLS_DTPREL_HI16:
2119 case R_MIPS16_TLS_DTPREL_LO16:
2120 case R_MIPS16_TLS_GOTTPREL:
2121 case R_MIPS16_TLS_TPREL_HI16:
2122 case R_MIPS16_TLS_TPREL_LO16:
2123 case R_MIPS16_PC16_S1:
2124 return TRUE;
2125
2126 default:
2127 return FALSE;
2128 }
2129 }
2130
2131 /* Check if a microMIPS reloc. */
2132
2133 static inline bfd_boolean
2134 micromips_reloc_p (unsigned int r_type)
2135 {
2136 return r_type >= R_MICROMIPS_min && r_type < R_MICROMIPS_max;
2137 }
2138
2139 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
2140 on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1
2141 and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions. */
2142
2143 static inline bfd_boolean
2144 micromips_reloc_shuffle_p (unsigned int r_type)
2145 {
2146 return (micromips_reloc_p (r_type)
2147 && r_type != R_MICROMIPS_PC7_S1
2148 && r_type != R_MICROMIPS_PC10_S1);
2149 }
2150
2151 static inline bfd_boolean
2152 got16_reloc_p (int r_type)
2153 {
2154 return (r_type == R_MIPS_GOT16
2155 || r_type == R_MIPS16_GOT16
2156 || r_type == R_MICROMIPS_GOT16);
2157 }
2158
2159 static inline bfd_boolean
2160 call16_reloc_p (int r_type)
2161 {
2162 return (r_type == R_MIPS_CALL16
2163 || r_type == R_MIPS16_CALL16
2164 || r_type == R_MICROMIPS_CALL16);
2165 }
2166
2167 static inline bfd_boolean
2168 got_disp_reloc_p (unsigned int r_type)
2169 {
2170 return r_type == R_MIPS_GOT_DISP || r_type == R_MICROMIPS_GOT_DISP;
2171 }
2172
2173 static inline bfd_boolean
2174 got_page_reloc_p (unsigned int r_type)
2175 {
2176 return r_type == R_MIPS_GOT_PAGE || r_type == R_MICROMIPS_GOT_PAGE;
2177 }
2178
2179 static inline bfd_boolean
2180 got_lo16_reloc_p (unsigned int r_type)
2181 {
2182 return r_type == R_MIPS_GOT_LO16 || r_type == R_MICROMIPS_GOT_LO16;
2183 }
2184
2185 static inline bfd_boolean
2186 call_hi16_reloc_p (unsigned int r_type)
2187 {
2188 return r_type == R_MIPS_CALL_HI16 || r_type == R_MICROMIPS_CALL_HI16;
2189 }
2190
2191 static inline bfd_boolean
2192 call_lo16_reloc_p (unsigned int r_type)
2193 {
2194 return r_type == R_MIPS_CALL_LO16 || r_type == R_MICROMIPS_CALL_LO16;
2195 }
2196
2197 static inline bfd_boolean
2198 hi16_reloc_p (int r_type)
2199 {
2200 return (r_type == R_MIPS_HI16
2201 || r_type == R_MIPS16_HI16
2202 || r_type == R_MICROMIPS_HI16
2203 || r_type == R_MIPS_PCHI16);
2204 }
2205
2206 static inline bfd_boolean
2207 lo16_reloc_p (int r_type)
2208 {
2209 return (r_type == R_MIPS_LO16
2210 || r_type == R_MIPS16_LO16
2211 || r_type == R_MICROMIPS_LO16
2212 || r_type == R_MIPS_PCLO16);
2213 }
2214
2215 static inline bfd_boolean
2216 mips16_call_reloc_p (int r_type)
2217 {
2218 return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16;
2219 }
2220
2221 static inline bfd_boolean
2222 jal_reloc_p (int r_type)
2223 {
2224 return (r_type == R_MIPS_26
2225 || r_type == R_MIPS16_26
2226 || r_type == R_MICROMIPS_26_S1);
2227 }
2228
2229 static inline bfd_boolean
2230 b_reloc_p (int r_type)
2231 {
2232 return (r_type == R_MIPS_PC26_S2
2233 || r_type == R_MIPS_PC21_S2
2234 || r_type == R_MIPS_PC16
2235 || r_type == R_MIPS_GNU_REL16_S2
2236 || r_type == R_MIPS16_PC16_S1
2237 || r_type == R_MICROMIPS_PC16_S1
2238 || r_type == R_MICROMIPS_PC10_S1
2239 || r_type == R_MICROMIPS_PC7_S1);
2240 }
2241
2242 static inline bfd_boolean
2243 aligned_pcrel_reloc_p (int r_type)
2244 {
2245 return (r_type == R_MIPS_PC18_S3
2246 || r_type == R_MIPS_PC19_S2);
2247 }
2248
2249 static inline bfd_boolean
2250 branch_reloc_p (int r_type)
2251 {
2252 return (r_type == R_MIPS_26
2253 || r_type == R_MIPS_PC26_S2
2254 || r_type == R_MIPS_PC21_S2
2255 || r_type == R_MIPS_PC16
2256 || r_type == R_MIPS_GNU_REL16_S2);
2257 }
2258
2259 static inline bfd_boolean
2260 mips16_branch_reloc_p (int r_type)
2261 {
2262 return (r_type == R_MIPS16_26
2263 || r_type == R_MIPS16_PC16_S1);
2264 }
2265
2266 static inline bfd_boolean
2267 micromips_branch_reloc_p (int r_type)
2268 {
2269 return (r_type == R_MICROMIPS_26_S1
2270 || r_type == R_MICROMIPS_PC16_S1
2271 || r_type == R_MICROMIPS_PC10_S1
2272 || r_type == R_MICROMIPS_PC7_S1);
2273 }
2274
2275 static inline bfd_boolean
2276 tls_gd_reloc_p (unsigned int r_type)
2277 {
2278 return (r_type == R_MIPS_TLS_GD
2279 || r_type == R_MIPS16_TLS_GD
2280 || r_type == R_MICROMIPS_TLS_GD);
2281 }
2282
2283 static inline bfd_boolean
2284 tls_ldm_reloc_p (unsigned int r_type)
2285 {
2286 return (r_type == R_MIPS_TLS_LDM
2287 || r_type == R_MIPS16_TLS_LDM
2288 || r_type == R_MICROMIPS_TLS_LDM);
2289 }
2290
2291 static inline bfd_boolean
2292 tls_gottprel_reloc_p (unsigned int r_type)
2293 {
2294 return (r_type == R_MIPS_TLS_GOTTPREL
2295 || r_type == R_MIPS16_TLS_GOTTPREL
2296 || r_type == R_MICROMIPS_TLS_GOTTPREL);
2297 }
2298
2299 void
2300 _bfd_mips_elf_reloc_unshuffle (bfd *abfd, int r_type,
2301 bfd_boolean jal_shuffle, bfd_byte *data)
2302 {
2303 bfd_vma first, second, val;
2304
2305 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2306 return;
2307
2308 /* Pick up the first and second halfwords of the instruction. */
2309 first = bfd_get_16 (abfd, data);
2310 second = bfd_get_16 (abfd, data + 2);
2311 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2312 val = first << 16 | second;
2313 else if (r_type != R_MIPS16_26)
2314 val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
2315 | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
2316 else
2317 val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
2318 | ((first & 0x1f) << 21) | second);
2319 bfd_put_32 (abfd, val, data);
2320 }
2321
2322 void
2323 _bfd_mips_elf_reloc_shuffle (bfd *abfd, int r_type,
2324 bfd_boolean jal_shuffle, bfd_byte *data)
2325 {
2326 bfd_vma first, second, val;
2327
2328 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2329 return;
2330
2331 val = bfd_get_32 (abfd, data);
2332 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2333 {
2334 second = val & 0xffff;
2335 first = val >> 16;
2336 }
2337 else if (r_type != R_MIPS16_26)
2338 {
2339 second = ((val >> 11) & 0xffe0) | (val & 0x1f);
2340 first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
2341 }
2342 else
2343 {
2344 second = val & 0xffff;
2345 first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
2346 | ((val >> 21) & 0x1f);
2347 }
2348 bfd_put_16 (abfd, second, data + 2);
2349 bfd_put_16 (abfd, first, data);
2350 }
2351
2352 bfd_reloc_status_type
2353 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
2354 arelent *reloc_entry, asection *input_section,
2355 bfd_boolean relocatable, void *data, bfd_vma gp)
2356 {
2357 bfd_vma relocation;
2358 bfd_signed_vma val;
2359 bfd_reloc_status_type status;
2360
2361 if (bfd_is_com_section (symbol->section))
2362 relocation = 0;
2363 else
2364 relocation = symbol->value;
2365
2366 relocation += symbol->section->output_section->vma;
2367 relocation += symbol->section->output_offset;
2368
2369 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2370 return bfd_reloc_outofrange;
2371
2372 /* Set val to the offset into the section or symbol. */
2373 val = reloc_entry->addend;
2374
2375 _bfd_mips_elf_sign_extend (val, 16);
2376
2377 /* Adjust val for the final section location and GP value. If we
2378 are producing relocatable output, we don't want to do this for
2379 an external symbol. */
2380 if (! relocatable
2381 || (symbol->flags & BSF_SECTION_SYM) != 0)
2382 val += relocation - gp;
2383
2384 if (reloc_entry->howto->partial_inplace)
2385 {
2386 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2387 (bfd_byte *) data
2388 + reloc_entry->address);
2389 if (status != bfd_reloc_ok)
2390 return status;
2391 }
2392 else
2393 reloc_entry->addend = val;
2394
2395 if (relocatable)
2396 reloc_entry->address += input_section->output_offset;
2397
2398 return bfd_reloc_ok;
2399 }
2400
2401 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2402 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
2403 that contains the relocation field and DATA points to the start of
2404 INPUT_SECTION. */
2405
2406 struct mips_hi16
2407 {
2408 struct mips_hi16 *next;
2409 bfd_byte *data;
2410 asection *input_section;
2411 arelent rel;
2412 };
2413
2414 /* FIXME: This should not be a static variable. */
2415
2416 static struct mips_hi16 *mips_hi16_list;
2417
2418 /* A howto special_function for REL *HI16 relocations. We can only
2419 calculate the correct value once we've seen the partnering
2420 *LO16 relocation, so just save the information for later.
2421
2422 The ABI requires that the *LO16 immediately follow the *HI16.
2423 However, as a GNU extension, we permit an arbitrary number of
2424 *HI16s to be associated with a single *LO16. This significantly
2425 simplies the relocation handling in gcc. */
2426
2427 bfd_reloc_status_type
2428 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2429 asymbol *symbol ATTRIBUTE_UNUSED, void *data,
2430 asection *input_section, bfd *output_bfd,
2431 char **error_message ATTRIBUTE_UNUSED)
2432 {
2433 struct mips_hi16 *n;
2434
2435 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2436 return bfd_reloc_outofrange;
2437
2438 n = bfd_malloc (sizeof *n);
2439 if (n == NULL)
2440 return bfd_reloc_outofrange;
2441
2442 n->next = mips_hi16_list;
2443 n->data = data;
2444 n->input_section = input_section;
2445 n->rel = *reloc_entry;
2446 mips_hi16_list = n;
2447
2448 if (output_bfd != NULL)
2449 reloc_entry->address += input_section->output_offset;
2450
2451 return bfd_reloc_ok;
2452 }
2453
2454 /* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just
2455 like any other 16-bit relocation when applied to global symbols, but is
2456 treated in the same as R_MIPS_HI16 when applied to local symbols. */
2457
2458 bfd_reloc_status_type
2459 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2460 void *data, asection *input_section,
2461 bfd *output_bfd, char **error_message)
2462 {
2463 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2464 || bfd_is_und_section (bfd_get_section (symbol))
2465 || bfd_is_com_section (bfd_get_section (symbol)))
2466 /* The relocation is against a global symbol. */
2467 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2468 input_section, output_bfd,
2469 error_message);
2470
2471 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
2472 input_section, output_bfd, error_message);
2473 }
2474
2475 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
2476 is a straightforward 16 bit inplace relocation, but we must deal with
2477 any partnering high-part relocations as well. */
2478
2479 bfd_reloc_status_type
2480 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2481 void *data, asection *input_section,
2482 bfd *output_bfd, char **error_message)
2483 {
2484 bfd_vma vallo;
2485 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2486
2487 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2488 return bfd_reloc_outofrange;
2489
2490 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2491 location);
2492 vallo = bfd_get_32 (abfd, location);
2493 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2494 location);
2495
2496 while (mips_hi16_list != NULL)
2497 {
2498 bfd_reloc_status_type ret;
2499 struct mips_hi16 *hi;
2500
2501 hi = mips_hi16_list;
2502
2503 /* R_MIPS*_GOT16 relocations are something of a special case. We
2504 want to install the addend in the same way as for a R_MIPS*_HI16
2505 relocation (with a rightshift of 16). However, since GOT16
2506 relocations can also be used with global symbols, their howto
2507 has a rightshift of 0. */
2508 if (hi->rel.howto->type == R_MIPS_GOT16)
2509 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
2510 else if (hi->rel.howto->type == R_MIPS16_GOT16)
2511 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE);
2512 else if (hi->rel.howto->type == R_MICROMIPS_GOT16)
2513 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MICROMIPS_HI16, FALSE);
2514
2515 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
2516 carry or borrow will induce a change of +1 or -1 in the high part. */
2517 hi->rel.addend += (vallo + 0x8000) & 0xffff;
2518
2519 ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
2520 hi->input_section, output_bfd,
2521 error_message);
2522 if (ret != bfd_reloc_ok)
2523 return ret;
2524
2525 mips_hi16_list = hi->next;
2526 free (hi);
2527 }
2528
2529 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2530 input_section, output_bfd,
2531 error_message);
2532 }
2533
2534 /* A generic howto special_function. This calculates and installs the
2535 relocation itself, thus avoiding the oft-discussed problems in
2536 bfd_perform_relocation and bfd_install_relocation. */
2537
2538 bfd_reloc_status_type
2539 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2540 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2541 asection *input_section, bfd *output_bfd,
2542 char **error_message ATTRIBUTE_UNUSED)
2543 {
2544 bfd_signed_vma val;
2545 bfd_reloc_status_type status;
2546 bfd_boolean relocatable;
2547
2548 relocatable = (output_bfd != NULL);
2549
2550 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2551 return bfd_reloc_outofrange;
2552
2553 /* Build up the field adjustment in VAL. */
2554 val = 0;
2555 if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
2556 {
2557 /* Either we're calculating the final field value or we have a
2558 relocation against a section symbol. Add in the section's
2559 offset or address. */
2560 val += symbol->section->output_section->vma;
2561 val += symbol->section->output_offset;
2562 }
2563
2564 if (!relocatable)
2565 {
2566 /* We're calculating the final field value. Add in the symbol's value
2567 and, if pc-relative, subtract the address of the field itself. */
2568 val += symbol->value;
2569 if (reloc_entry->howto->pc_relative)
2570 {
2571 val -= input_section->output_section->vma;
2572 val -= input_section->output_offset;
2573 val -= reloc_entry->address;
2574 }
2575 }
2576
2577 /* VAL is now the final adjustment. If we're keeping this relocation
2578 in the output file, and if the relocation uses a separate addend,
2579 we just need to add VAL to that addend. Otherwise we need to add
2580 VAL to the relocation field itself. */
2581 if (relocatable && !reloc_entry->howto->partial_inplace)
2582 reloc_entry->addend += val;
2583 else
2584 {
2585 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2586
2587 /* Add in the separate addend, if any. */
2588 val += reloc_entry->addend;
2589
2590 /* Add VAL to the relocation field. */
2591 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2592 location);
2593 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2594 location);
2595 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2596 location);
2597
2598 if (status != bfd_reloc_ok)
2599 return status;
2600 }
2601
2602 if (relocatable)
2603 reloc_entry->address += input_section->output_offset;
2604
2605 return bfd_reloc_ok;
2606 }
2607 \f
2608 /* Swap an entry in a .gptab section. Note that these routines rely
2609 on the equivalence of the two elements of the union. */
2610
2611 static void
2612 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
2613 Elf32_gptab *in)
2614 {
2615 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
2616 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
2617 }
2618
2619 static void
2620 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
2621 Elf32_External_gptab *ex)
2622 {
2623 H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
2624 H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
2625 }
2626
2627 static void
2628 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
2629 Elf32_External_compact_rel *ex)
2630 {
2631 H_PUT_32 (abfd, in->id1, ex->id1);
2632 H_PUT_32 (abfd, in->num, ex->num);
2633 H_PUT_32 (abfd, in->id2, ex->id2);
2634 H_PUT_32 (abfd, in->offset, ex->offset);
2635 H_PUT_32 (abfd, in->reserved0, ex->reserved0);
2636 H_PUT_32 (abfd, in->reserved1, ex->reserved1);
2637 }
2638
2639 static void
2640 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
2641 Elf32_External_crinfo *ex)
2642 {
2643 unsigned long l;
2644
2645 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2646 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2647 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2648 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2649 H_PUT_32 (abfd, l, ex->info);
2650 H_PUT_32 (abfd, in->konst, ex->konst);
2651 H_PUT_32 (abfd, in->vaddr, ex->vaddr);
2652 }
2653 \f
2654 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2655 routines swap this structure in and out. They are used outside of
2656 BFD, so they are globally visible. */
2657
2658 void
2659 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
2660 Elf32_RegInfo *in)
2661 {
2662 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2663 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2664 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2665 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2666 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2667 in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
2668 }
2669
2670 void
2671 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
2672 Elf32_External_RegInfo *ex)
2673 {
2674 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
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_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
2680 }
2681
2682 /* In the 64 bit ABI, the .MIPS.options section holds register
2683 information in an Elf64_Reginfo structure. These routines swap
2684 them in and out. They are globally visible because they are used
2685 outside of BFD. These routines are here so that gas can call them
2686 without worrying about whether the 64 bit ABI has been included. */
2687
2688 void
2689 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
2690 Elf64_Internal_RegInfo *in)
2691 {
2692 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2693 in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
2694 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2695 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2696 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2697 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2698 in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
2699 }
2700
2701 void
2702 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
2703 Elf64_External_RegInfo *ex)
2704 {
2705 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2706 H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
2707 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2708 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2709 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2710 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2711 H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
2712 }
2713
2714 /* Swap in an options header. */
2715
2716 void
2717 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
2718 Elf_Internal_Options *in)
2719 {
2720 in->kind = H_GET_8 (abfd, ex->kind);
2721 in->size = H_GET_8 (abfd, ex->size);
2722 in->section = H_GET_16 (abfd, ex->section);
2723 in->info = H_GET_32 (abfd, ex->info);
2724 }
2725
2726 /* Swap out an options header. */
2727
2728 void
2729 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
2730 Elf_External_Options *ex)
2731 {
2732 H_PUT_8 (abfd, in->kind, ex->kind);
2733 H_PUT_8 (abfd, in->size, ex->size);
2734 H_PUT_16 (abfd, in->section, ex->section);
2735 H_PUT_32 (abfd, in->info, ex->info);
2736 }
2737
2738 /* Swap in an abiflags structure. */
2739
2740 void
2741 bfd_mips_elf_swap_abiflags_v0_in (bfd *abfd,
2742 const Elf_External_ABIFlags_v0 *ex,
2743 Elf_Internal_ABIFlags_v0 *in)
2744 {
2745 in->version = H_GET_16 (abfd, ex->version);
2746 in->isa_level = H_GET_8 (abfd, ex->isa_level);
2747 in->isa_rev = H_GET_8 (abfd, ex->isa_rev);
2748 in->gpr_size = H_GET_8 (abfd, ex->gpr_size);
2749 in->cpr1_size = H_GET_8 (abfd, ex->cpr1_size);
2750 in->cpr2_size = H_GET_8 (abfd, ex->cpr2_size);
2751 in->fp_abi = H_GET_8 (abfd, ex->fp_abi);
2752 in->isa_ext = H_GET_32 (abfd, ex->isa_ext);
2753 in->ases = H_GET_32 (abfd, ex->ases);
2754 in->flags1 = H_GET_32 (abfd, ex->flags1);
2755 in->flags2 = H_GET_32 (abfd, ex->flags2);
2756 }
2757
2758 /* Swap out an abiflags structure. */
2759
2760 void
2761 bfd_mips_elf_swap_abiflags_v0_out (bfd *abfd,
2762 const Elf_Internal_ABIFlags_v0 *in,
2763 Elf_External_ABIFlags_v0 *ex)
2764 {
2765 H_PUT_16 (abfd, in->version, ex->version);
2766 H_PUT_8 (abfd, in->isa_level, ex->isa_level);
2767 H_PUT_8 (abfd, in->isa_rev, ex->isa_rev);
2768 H_PUT_8 (abfd, in->gpr_size, ex->gpr_size);
2769 H_PUT_8 (abfd, in->cpr1_size, ex->cpr1_size);
2770 H_PUT_8 (abfd, in->cpr2_size, ex->cpr2_size);
2771 H_PUT_8 (abfd, in->fp_abi, ex->fp_abi);
2772 H_PUT_32 (abfd, in->isa_ext, ex->isa_ext);
2773 H_PUT_32 (abfd, in->ases, ex->ases);
2774 H_PUT_32 (abfd, in->flags1, ex->flags1);
2775 H_PUT_32 (abfd, in->flags2, ex->flags2);
2776 }
2777 \f
2778 /* This function is called via qsort() to sort the dynamic relocation
2779 entries by increasing r_symndx value. */
2780
2781 static int
2782 sort_dynamic_relocs (const void *arg1, const void *arg2)
2783 {
2784 Elf_Internal_Rela int_reloc1;
2785 Elf_Internal_Rela int_reloc2;
2786 int diff;
2787
2788 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
2789 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
2790
2791 diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
2792 if (diff != 0)
2793 return diff;
2794
2795 if (int_reloc1.r_offset < int_reloc2.r_offset)
2796 return -1;
2797 if (int_reloc1.r_offset > int_reloc2.r_offset)
2798 return 1;
2799 return 0;
2800 }
2801
2802 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
2803
2804 static int
2805 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
2806 const void *arg2 ATTRIBUTE_UNUSED)
2807 {
2808 #ifdef BFD64
2809 Elf_Internal_Rela int_reloc1[3];
2810 Elf_Internal_Rela int_reloc2[3];
2811
2812 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2813 (reldyn_sorting_bfd, arg1, int_reloc1);
2814 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2815 (reldyn_sorting_bfd, arg2, int_reloc2);
2816
2817 if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
2818 return -1;
2819 if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
2820 return 1;
2821
2822 if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
2823 return -1;
2824 if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
2825 return 1;
2826 return 0;
2827 #else
2828 abort ();
2829 #endif
2830 }
2831
2832
2833 /* This routine is used to write out ECOFF debugging external symbol
2834 information. It is called via mips_elf_link_hash_traverse. The
2835 ECOFF external symbol information must match the ELF external
2836 symbol information. Unfortunately, at this point we don't know
2837 whether a symbol is required by reloc information, so the two
2838 tables may wind up being different. We must sort out the external
2839 symbol information before we can set the final size of the .mdebug
2840 section, and we must set the size of the .mdebug section before we
2841 can relocate any sections, and we can't know which symbols are
2842 required by relocation until we relocate the sections.
2843 Fortunately, it is relatively unlikely that any symbol will be
2844 stripped but required by a reloc. In particular, it can not happen
2845 when generating a final executable. */
2846
2847 static bfd_boolean
2848 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
2849 {
2850 struct extsym_info *einfo = data;
2851 bfd_boolean strip;
2852 asection *sec, *output_section;
2853
2854 if (h->root.indx == -2)
2855 strip = FALSE;
2856 else if ((h->root.def_dynamic
2857 || h->root.ref_dynamic
2858 || h->root.type == bfd_link_hash_new)
2859 && !h->root.def_regular
2860 && !h->root.ref_regular)
2861 strip = TRUE;
2862 else if (einfo->info->strip == strip_all
2863 || (einfo->info->strip == strip_some
2864 && bfd_hash_lookup (einfo->info->keep_hash,
2865 h->root.root.root.string,
2866 FALSE, FALSE) == NULL))
2867 strip = TRUE;
2868 else
2869 strip = FALSE;
2870
2871 if (strip)
2872 return TRUE;
2873
2874 if (h->esym.ifd == -2)
2875 {
2876 h->esym.jmptbl = 0;
2877 h->esym.cobol_main = 0;
2878 h->esym.weakext = 0;
2879 h->esym.reserved = 0;
2880 h->esym.ifd = ifdNil;
2881 h->esym.asym.value = 0;
2882 h->esym.asym.st = stGlobal;
2883
2884 if (h->root.root.type == bfd_link_hash_undefined
2885 || h->root.root.type == bfd_link_hash_undefweak)
2886 {
2887 const char *name;
2888
2889 /* Use undefined class. Also, set class and type for some
2890 special symbols. */
2891 name = h->root.root.root.string;
2892 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
2893 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
2894 {
2895 h->esym.asym.sc = scData;
2896 h->esym.asym.st = stLabel;
2897 h->esym.asym.value = 0;
2898 }
2899 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
2900 {
2901 h->esym.asym.sc = scAbs;
2902 h->esym.asym.st = stLabel;
2903 h->esym.asym.value =
2904 mips_elf_hash_table (einfo->info)->procedure_count;
2905 }
2906 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
2907 {
2908 h->esym.asym.sc = scAbs;
2909 h->esym.asym.st = stLabel;
2910 h->esym.asym.value = elf_gp (einfo->abfd);
2911 }
2912 else
2913 h->esym.asym.sc = scUndefined;
2914 }
2915 else if (h->root.root.type != bfd_link_hash_defined
2916 && h->root.root.type != bfd_link_hash_defweak)
2917 h->esym.asym.sc = scAbs;
2918 else
2919 {
2920 const char *name;
2921
2922 sec = h->root.root.u.def.section;
2923 output_section = sec->output_section;
2924
2925 /* When making a shared library and symbol h is the one from
2926 the another shared library, OUTPUT_SECTION may be null. */
2927 if (output_section == NULL)
2928 h->esym.asym.sc = scUndefined;
2929 else
2930 {
2931 name = bfd_section_name (output_section->owner, output_section);
2932
2933 if (strcmp (name, ".text") == 0)
2934 h->esym.asym.sc = scText;
2935 else if (strcmp (name, ".data") == 0)
2936 h->esym.asym.sc = scData;
2937 else if (strcmp (name, ".sdata") == 0)
2938 h->esym.asym.sc = scSData;
2939 else if (strcmp (name, ".rodata") == 0
2940 || strcmp (name, ".rdata") == 0)
2941 h->esym.asym.sc = scRData;
2942 else if (strcmp (name, ".bss") == 0)
2943 h->esym.asym.sc = scBss;
2944 else if (strcmp (name, ".sbss") == 0)
2945 h->esym.asym.sc = scSBss;
2946 else if (strcmp (name, ".init") == 0)
2947 h->esym.asym.sc = scInit;
2948 else if (strcmp (name, ".fini") == 0)
2949 h->esym.asym.sc = scFini;
2950 else
2951 h->esym.asym.sc = scAbs;
2952 }
2953 }
2954
2955 h->esym.asym.reserved = 0;
2956 h->esym.asym.index = indexNil;
2957 }
2958
2959 if (h->root.root.type == bfd_link_hash_common)
2960 h->esym.asym.value = h->root.root.u.c.size;
2961 else if (h->root.root.type == bfd_link_hash_defined
2962 || h->root.root.type == bfd_link_hash_defweak)
2963 {
2964 if (h->esym.asym.sc == scCommon)
2965 h->esym.asym.sc = scBss;
2966 else if (h->esym.asym.sc == scSCommon)
2967 h->esym.asym.sc = scSBss;
2968
2969 sec = h->root.root.u.def.section;
2970 output_section = sec->output_section;
2971 if (output_section != NULL)
2972 h->esym.asym.value = (h->root.root.u.def.value
2973 + sec->output_offset
2974 + output_section->vma);
2975 else
2976 h->esym.asym.value = 0;
2977 }
2978 else
2979 {
2980 struct mips_elf_link_hash_entry *hd = h;
2981
2982 while (hd->root.root.type == bfd_link_hash_indirect)
2983 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
2984
2985 if (hd->needs_lazy_stub)
2986 {
2987 BFD_ASSERT (hd->root.plt.plist != NULL);
2988 BFD_ASSERT (hd->root.plt.plist->stub_offset != MINUS_ONE);
2989 /* Set type and value for a symbol with a function stub. */
2990 h->esym.asym.st = stProc;
2991 sec = hd->root.root.u.def.section;
2992 if (sec == NULL)
2993 h->esym.asym.value = 0;
2994 else
2995 {
2996 output_section = sec->output_section;
2997 if (output_section != NULL)
2998 h->esym.asym.value = (hd->root.plt.plist->stub_offset
2999 + sec->output_offset
3000 + output_section->vma);
3001 else
3002 h->esym.asym.value = 0;
3003 }
3004 }
3005 }
3006
3007 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
3008 h->root.root.root.string,
3009 &h->esym))
3010 {
3011 einfo->failed = TRUE;
3012 return FALSE;
3013 }
3014
3015 return TRUE;
3016 }
3017
3018 /* A comparison routine used to sort .gptab entries. */
3019
3020 static int
3021 gptab_compare (const void *p1, const void *p2)
3022 {
3023 const Elf32_gptab *a1 = p1;
3024 const Elf32_gptab *a2 = p2;
3025
3026 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
3027 }
3028 \f
3029 /* Functions to manage the got entry hash table. */
3030
3031 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
3032 hash number. */
3033
3034 static INLINE hashval_t
3035 mips_elf_hash_bfd_vma (bfd_vma addr)
3036 {
3037 #ifdef BFD64
3038 return addr + (addr >> 32);
3039 #else
3040 return addr;
3041 #endif
3042 }
3043
3044 static hashval_t
3045 mips_elf_got_entry_hash (const void *entry_)
3046 {
3047 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
3048
3049 return (entry->symndx
3050 + ((entry->tls_type == GOT_TLS_LDM) << 18)
3051 + (entry->tls_type == GOT_TLS_LDM ? 0
3052 : !entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
3053 : entry->symndx >= 0 ? (entry->abfd->id
3054 + mips_elf_hash_bfd_vma (entry->d.addend))
3055 : entry->d.h->root.root.root.hash));
3056 }
3057
3058 static int
3059 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
3060 {
3061 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
3062 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
3063
3064 return (e1->symndx == e2->symndx
3065 && e1->tls_type == e2->tls_type
3066 && (e1->tls_type == GOT_TLS_LDM ? TRUE
3067 : !e1->abfd ? !e2->abfd && e1->d.address == e2->d.address
3068 : e1->symndx >= 0 ? (e1->abfd == e2->abfd
3069 && e1->d.addend == e2->d.addend)
3070 : e2->abfd && e1->d.h == e2->d.h));
3071 }
3072
3073 static hashval_t
3074 mips_got_page_ref_hash (const void *ref_)
3075 {
3076 const struct mips_got_page_ref *ref;
3077
3078 ref = (const struct mips_got_page_ref *) ref_;
3079 return ((ref->symndx >= 0
3080 ? (hashval_t) (ref->u.abfd->id + ref->symndx)
3081 : ref->u.h->root.root.root.hash)
3082 + mips_elf_hash_bfd_vma (ref->addend));
3083 }
3084
3085 static int
3086 mips_got_page_ref_eq (const void *ref1_, const void *ref2_)
3087 {
3088 const struct mips_got_page_ref *ref1, *ref2;
3089
3090 ref1 = (const struct mips_got_page_ref *) ref1_;
3091 ref2 = (const struct mips_got_page_ref *) ref2_;
3092 return (ref1->symndx == ref2->symndx
3093 && (ref1->symndx < 0
3094 ? ref1->u.h == ref2->u.h
3095 : ref1->u.abfd == ref2->u.abfd)
3096 && ref1->addend == ref2->addend);
3097 }
3098
3099 static hashval_t
3100 mips_got_page_entry_hash (const void *entry_)
3101 {
3102 const struct mips_got_page_entry *entry;
3103
3104 entry = (const struct mips_got_page_entry *) entry_;
3105 return entry->sec->id;
3106 }
3107
3108 static int
3109 mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
3110 {
3111 const struct mips_got_page_entry *entry1, *entry2;
3112
3113 entry1 = (const struct mips_got_page_entry *) entry1_;
3114 entry2 = (const struct mips_got_page_entry *) entry2_;
3115 return entry1->sec == entry2->sec;
3116 }
3117 \f
3118 /* Create and return a new mips_got_info structure. */
3119
3120 static struct mips_got_info *
3121 mips_elf_create_got_info (bfd *abfd)
3122 {
3123 struct mips_got_info *g;
3124
3125 g = bfd_zalloc (abfd, sizeof (struct mips_got_info));
3126 if (g == NULL)
3127 return NULL;
3128
3129 g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
3130 mips_elf_got_entry_eq, NULL);
3131 if (g->got_entries == NULL)
3132 return NULL;
3133
3134 g->got_page_refs = htab_try_create (1, mips_got_page_ref_hash,
3135 mips_got_page_ref_eq, NULL);
3136 if (g->got_page_refs == NULL)
3137 return NULL;
3138
3139 return g;
3140 }
3141
3142 /* Return the GOT info for input bfd ABFD, trying to create a new one if
3143 CREATE_P and if ABFD doesn't already have a GOT. */
3144
3145 static struct mips_got_info *
3146 mips_elf_bfd_got (bfd *abfd, bfd_boolean create_p)
3147 {
3148 struct mips_elf_obj_tdata *tdata;
3149
3150 if (!is_mips_elf (abfd))
3151 return NULL;
3152
3153 tdata = mips_elf_tdata (abfd);
3154 if (!tdata->got && create_p)
3155 tdata->got = mips_elf_create_got_info (abfd);
3156 return tdata->got;
3157 }
3158
3159 /* Record that ABFD should use output GOT G. */
3160
3161 static void
3162 mips_elf_replace_bfd_got (bfd *abfd, struct mips_got_info *g)
3163 {
3164 struct mips_elf_obj_tdata *tdata;
3165
3166 BFD_ASSERT (is_mips_elf (abfd));
3167 tdata = mips_elf_tdata (abfd);
3168 if (tdata->got)
3169 {
3170 /* The GOT structure itself and the hash table entries are
3171 allocated to a bfd, but the hash tables aren't. */
3172 htab_delete (tdata->got->got_entries);
3173 htab_delete (tdata->got->got_page_refs);
3174 if (tdata->got->got_page_entries)
3175 htab_delete (tdata->got->got_page_entries);
3176 }
3177 tdata->got = g;
3178 }
3179
3180 /* Return the dynamic relocation section. If it doesn't exist, try to
3181 create a new it if CREATE_P, otherwise return NULL. Also return NULL
3182 if creation fails. */
3183
3184 static asection *
3185 mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
3186 {
3187 const char *dname;
3188 asection *sreloc;
3189 bfd *dynobj;
3190
3191 dname = MIPS_ELF_REL_DYN_NAME (info);
3192 dynobj = elf_hash_table (info)->dynobj;
3193 sreloc = bfd_get_linker_section (dynobj, dname);
3194 if (sreloc == NULL && create_p)
3195 {
3196 sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
3197 (SEC_ALLOC
3198 | SEC_LOAD
3199 | SEC_HAS_CONTENTS
3200 | SEC_IN_MEMORY
3201 | SEC_LINKER_CREATED
3202 | SEC_READONLY));
3203 if (sreloc == NULL
3204 || ! bfd_set_section_alignment (dynobj, sreloc,
3205 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
3206 return NULL;
3207 }
3208 return sreloc;
3209 }
3210
3211 /* Return the GOT_TLS_* type required by relocation type R_TYPE. */
3212
3213 static int
3214 mips_elf_reloc_tls_type (unsigned int r_type)
3215 {
3216 if (tls_gd_reloc_p (r_type))
3217 return GOT_TLS_GD;
3218
3219 if (tls_ldm_reloc_p (r_type))
3220 return GOT_TLS_LDM;
3221
3222 if (tls_gottprel_reloc_p (r_type))
3223 return GOT_TLS_IE;
3224
3225 return GOT_TLS_NONE;
3226 }
3227
3228 /* Return the number of GOT slots needed for GOT TLS type TYPE. */
3229
3230 static int
3231 mips_tls_got_entries (unsigned int type)
3232 {
3233 switch (type)
3234 {
3235 case GOT_TLS_GD:
3236 case GOT_TLS_LDM:
3237 return 2;
3238
3239 case GOT_TLS_IE:
3240 return 1;
3241
3242 case GOT_TLS_NONE:
3243 return 0;
3244 }
3245 abort ();
3246 }
3247
3248 /* Count the number of relocations needed for a TLS GOT entry, with
3249 access types from TLS_TYPE, and symbol H (or a local symbol if H
3250 is NULL). */
3251
3252 static int
3253 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
3254 struct elf_link_hash_entry *h)
3255 {
3256 int indx = 0;
3257 bfd_boolean need_relocs = FALSE;
3258 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3259
3260 if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
3261 && (!bfd_link_pic (info) || !SYMBOL_REFERENCES_LOCAL (info, h)))
3262 indx = h->dynindx;
3263
3264 if ((bfd_link_pic (info) || indx != 0)
3265 && (h == NULL
3266 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3267 || h->root.type != bfd_link_hash_undefweak))
3268 need_relocs = TRUE;
3269
3270 if (!need_relocs)
3271 return 0;
3272
3273 switch (tls_type)
3274 {
3275 case GOT_TLS_GD:
3276 return indx != 0 ? 2 : 1;
3277
3278 case GOT_TLS_IE:
3279 return 1;
3280
3281 case GOT_TLS_LDM:
3282 return bfd_link_pic (info) ? 1 : 0;
3283
3284 default:
3285 return 0;
3286 }
3287 }
3288
3289 /* Add the number of GOT entries and TLS relocations required by ENTRY
3290 to G. */
3291
3292 static void
3293 mips_elf_count_got_entry (struct bfd_link_info *info,
3294 struct mips_got_info *g,
3295 struct mips_got_entry *entry)
3296 {
3297 if (entry->tls_type)
3298 {
3299 g->tls_gotno += mips_tls_got_entries (entry->tls_type);
3300 g->relocs += mips_tls_got_relocs (info, entry->tls_type,
3301 entry->symndx < 0
3302 ? &entry->d.h->root : NULL);
3303 }
3304 else if (entry->symndx >= 0 || entry->d.h->global_got_area == GGA_NONE)
3305 g->local_gotno += 1;
3306 else
3307 g->global_gotno += 1;
3308 }
3309
3310 /* Output a simple dynamic relocation into SRELOC. */
3311
3312 static void
3313 mips_elf_output_dynamic_relocation (bfd *output_bfd,
3314 asection *sreloc,
3315 unsigned long reloc_index,
3316 unsigned long indx,
3317 int r_type,
3318 bfd_vma offset)
3319 {
3320 Elf_Internal_Rela rel[3];
3321
3322 memset (rel, 0, sizeof (rel));
3323
3324 rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
3325 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
3326
3327 if (ABI_64_P (output_bfd))
3328 {
3329 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
3330 (output_bfd, &rel[0],
3331 (sreloc->contents
3332 + reloc_index * sizeof (Elf64_Mips_External_Rel)));
3333 }
3334 else
3335 bfd_elf32_swap_reloc_out
3336 (output_bfd, &rel[0],
3337 (sreloc->contents
3338 + reloc_index * sizeof (Elf32_External_Rel)));
3339 }
3340
3341 /* Initialize a set of TLS GOT entries for one symbol. */
3342
3343 static void
3344 mips_elf_initialize_tls_slots (bfd *abfd, struct bfd_link_info *info,
3345 struct mips_got_entry *entry,
3346 struct mips_elf_link_hash_entry *h,
3347 bfd_vma value)
3348 {
3349 struct mips_elf_link_hash_table *htab;
3350 int indx;
3351 asection *sreloc, *sgot;
3352 bfd_vma got_offset, got_offset2;
3353 bfd_boolean need_relocs = FALSE;
3354
3355 htab = mips_elf_hash_table (info);
3356 if (htab == NULL)
3357 return;
3358
3359 sgot = htab->root.sgot;
3360
3361 indx = 0;
3362 if (h != NULL)
3363 {
3364 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3365
3366 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
3367 &h->root)
3368 && (!bfd_link_pic (info)
3369 || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
3370 indx = h->root.dynindx;
3371 }
3372
3373 if (entry->tls_initialized)
3374 return;
3375
3376 if ((bfd_link_pic (info) || indx != 0)
3377 && (h == NULL
3378 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
3379 || h->root.type != bfd_link_hash_undefweak))
3380 need_relocs = TRUE;
3381
3382 /* MINUS_ONE means the symbol is not defined in this object. It may not
3383 be defined at all; assume that the value doesn't matter in that
3384 case. Otherwise complain if we would use the value. */
3385 BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
3386 || h->root.root.type == bfd_link_hash_undefweak);
3387
3388 /* Emit necessary relocations. */
3389 sreloc = mips_elf_rel_dyn_section (info, FALSE);
3390 got_offset = entry->gotidx;
3391
3392 switch (entry->tls_type)
3393 {
3394 case GOT_TLS_GD:
3395 /* General Dynamic. */
3396 got_offset2 = got_offset + MIPS_ELF_GOT_SIZE (abfd);
3397
3398 if (need_relocs)
3399 {
3400 mips_elf_output_dynamic_relocation
3401 (abfd, sreloc, sreloc->reloc_count++, indx,
3402 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3403 sgot->output_offset + sgot->output_section->vma + got_offset);
3404
3405 if (indx)
3406 mips_elf_output_dynamic_relocation
3407 (abfd, sreloc, sreloc->reloc_count++, indx,
3408 ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
3409 sgot->output_offset + sgot->output_section->vma + got_offset2);
3410 else
3411 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3412 sgot->contents + got_offset2);
3413 }
3414 else
3415 {
3416 MIPS_ELF_PUT_WORD (abfd, 1,
3417 sgot->contents + got_offset);
3418 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3419 sgot->contents + got_offset2);
3420 }
3421 break;
3422
3423 case GOT_TLS_IE:
3424 /* Initial Exec model. */
3425 if (need_relocs)
3426 {
3427 if (indx == 0)
3428 MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
3429 sgot->contents + got_offset);
3430 else
3431 MIPS_ELF_PUT_WORD (abfd, 0,
3432 sgot->contents + got_offset);
3433
3434 mips_elf_output_dynamic_relocation
3435 (abfd, sreloc, sreloc->reloc_count++, indx,
3436 ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
3437 sgot->output_offset + sgot->output_section->vma + got_offset);
3438 }
3439 else
3440 MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
3441 sgot->contents + got_offset);
3442 break;
3443
3444 case GOT_TLS_LDM:
3445 /* The initial offset is zero, and the LD offsets will include the
3446 bias by DTP_OFFSET. */
3447 MIPS_ELF_PUT_WORD (abfd, 0,
3448 sgot->contents + got_offset
3449 + MIPS_ELF_GOT_SIZE (abfd));
3450
3451 if (!bfd_link_pic (info))
3452 MIPS_ELF_PUT_WORD (abfd, 1,
3453 sgot->contents + got_offset);
3454 else
3455 mips_elf_output_dynamic_relocation
3456 (abfd, sreloc, sreloc->reloc_count++, indx,
3457 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3458 sgot->output_offset + sgot->output_section->vma + got_offset);
3459 break;
3460
3461 default:
3462 abort ();
3463 }
3464
3465 entry->tls_initialized = TRUE;
3466 }
3467
3468 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3469 for global symbol H. .got.plt comes before the GOT, so the offset
3470 will be negative. */
3471
3472 static bfd_vma
3473 mips_elf_gotplt_index (struct bfd_link_info *info,
3474 struct elf_link_hash_entry *h)
3475 {
3476 bfd_vma got_address, got_value;
3477 struct mips_elf_link_hash_table *htab;
3478
3479 htab = mips_elf_hash_table (info);
3480 BFD_ASSERT (htab != NULL);
3481
3482 BFD_ASSERT (h->plt.plist != NULL);
3483 BFD_ASSERT (h->plt.plist->gotplt_index != MINUS_ONE);
3484
3485 /* Calculate the address of the associated .got.plt entry. */
3486 got_address = (htab->root.sgotplt->output_section->vma
3487 + htab->root.sgotplt->output_offset
3488 + (h->plt.plist->gotplt_index
3489 * MIPS_ELF_GOT_SIZE (info->output_bfd)));
3490
3491 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
3492 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
3493 + htab->root.hgot->root.u.def.section->output_offset
3494 + htab->root.hgot->root.u.def.value);
3495
3496 return got_address - got_value;
3497 }
3498
3499 /* Return the GOT offset for address VALUE. If there is not yet a GOT
3500 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
3501 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
3502 offset can be found. */
3503
3504 static bfd_vma
3505 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3506 bfd_vma value, unsigned long r_symndx,
3507 struct mips_elf_link_hash_entry *h, int r_type)
3508 {
3509 struct mips_elf_link_hash_table *htab;
3510 struct mips_got_entry *entry;
3511
3512 htab = mips_elf_hash_table (info);
3513 BFD_ASSERT (htab != NULL);
3514
3515 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value,
3516 r_symndx, h, r_type);
3517 if (!entry)
3518 return MINUS_ONE;
3519
3520 if (entry->tls_type)
3521 mips_elf_initialize_tls_slots (abfd, info, entry, h, value);
3522 return entry->gotidx;
3523 }
3524
3525 /* Return the GOT index of global symbol H in the primary GOT. */
3526
3527 static bfd_vma
3528 mips_elf_primary_global_got_index (bfd *obfd, struct bfd_link_info *info,
3529 struct elf_link_hash_entry *h)
3530 {
3531 struct mips_elf_link_hash_table *htab;
3532 long global_got_dynindx;
3533 struct mips_got_info *g;
3534 bfd_vma got_index;
3535
3536 htab = mips_elf_hash_table (info);
3537 BFD_ASSERT (htab != NULL);
3538
3539 global_got_dynindx = 0;
3540 if (htab->global_gotsym != NULL)
3541 global_got_dynindx = htab->global_gotsym->dynindx;
3542
3543 /* Once we determine the global GOT entry with the lowest dynamic
3544 symbol table index, we must put all dynamic symbols with greater
3545 indices into the primary GOT. That makes it easy to calculate the
3546 GOT offset. */
3547 BFD_ASSERT (h->dynindx >= global_got_dynindx);
3548 g = mips_elf_bfd_got (obfd, FALSE);
3549 got_index = ((h->dynindx - global_got_dynindx + g->local_gotno)
3550 * MIPS_ELF_GOT_SIZE (obfd));
3551 BFD_ASSERT (got_index < htab->root.sgot->size);
3552
3553 return got_index;
3554 }
3555
3556 /* Return the GOT index for the global symbol indicated by H, which is
3557 referenced by a relocation of type R_TYPE in IBFD. */
3558
3559 static bfd_vma
3560 mips_elf_global_got_index (bfd *obfd, struct bfd_link_info *info, bfd *ibfd,
3561 struct elf_link_hash_entry *h, int r_type)
3562 {
3563 struct mips_elf_link_hash_table *htab;
3564 struct mips_got_info *g;
3565 struct mips_got_entry lookup, *entry;
3566 bfd_vma gotidx;
3567
3568 htab = mips_elf_hash_table (info);
3569 BFD_ASSERT (htab != NULL);
3570
3571 g = mips_elf_bfd_got (ibfd, FALSE);
3572 BFD_ASSERT (g);
3573
3574 lookup.tls_type = mips_elf_reloc_tls_type (r_type);
3575 if (!lookup.tls_type && g == mips_elf_bfd_got (obfd, FALSE))
3576 return mips_elf_primary_global_got_index (obfd, info, h);
3577
3578 lookup.abfd = ibfd;
3579 lookup.symndx = -1;
3580 lookup.d.h = (struct mips_elf_link_hash_entry *) h;
3581 entry = htab_find (g->got_entries, &lookup);
3582 BFD_ASSERT (entry);
3583
3584 gotidx = entry->gotidx;
3585 BFD_ASSERT (gotidx > 0 && gotidx < htab->root.sgot->size);
3586
3587 if (lookup.tls_type)
3588 {
3589 bfd_vma value = MINUS_ONE;
3590
3591 if ((h->root.type == bfd_link_hash_defined
3592 || h->root.type == bfd_link_hash_defweak)
3593 && h->root.u.def.section->output_section)
3594 value = (h->root.u.def.value
3595 + h->root.u.def.section->output_offset
3596 + h->root.u.def.section->output_section->vma);
3597
3598 mips_elf_initialize_tls_slots (obfd, info, entry, lookup.d.h, value);
3599 }
3600 return gotidx;
3601 }
3602
3603 /* Find a GOT page entry that points to within 32KB of VALUE. These
3604 entries are supposed to be placed at small offsets in the GOT, i.e.,
3605 within 32KB of GP. Return the index of the GOT entry, or -1 if no
3606 entry could be created. If OFFSETP is nonnull, use it to return the
3607 offset of the GOT entry from VALUE. */
3608
3609 static bfd_vma
3610 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3611 bfd_vma value, bfd_vma *offsetp)
3612 {
3613 bfd_vma page, got_index;
3614 struct mips_got_entry *entry;
3615
3616 page = (value + 0x8000) & ~(bfd_vma) 0xffff;
3617 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0,
3618 NULL, R_MIPS_GOT_PAGE);
3619
3620 if (!entry)
3621 return MINUS_ONE;
3622
3623 got_index = entry->gotidx;
3624
3625 if (offsetp)
3626 *offsetp = value - entry->d.address;
3627
3628 return got_index;
3629 }
3630
3631 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3632 EXTERNAL is true if the relocation was originally against a global
3633 symbol that binds locally. */
3634
3635 static bfd_vma
3636 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3637 bfd_vma value, bfd_boolean external)
3638 {
3639 struct mips_got_entry *entry;
3640
3641 /* GOT16 relocations against local symbols are followed by a LO16
3642 relocation; those against global symbols are not. Thus if the
3643 symbol was originally local, the GOT16 relocation should load the
3644 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
3645 if (! external)
3646 value = mips_elf_high (value) << 16;
3647
3648 /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3649 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the
3650 same in all cases. */
3651 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0,
3652 NULL, R_MIPS_GOT16);
3653 if (entry)
3654 return entry->gotidx;
3655 else
3656 return MINUS_ONE;
3657 }
3658
3659 /* Returns the offset for the entry at the INDEXth position
3660 in the GOT. */
3661
3662 static bfd_vma
3663 mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd,
3664 bfd *input_bfd, bfd_vma got_index)
3665 {
3666 struct mips_elf_link_hash_table *htab;
3667 asection *sgot;
3668 bfd_vma gp;
3669
3670 htab = mips_elf_hash_table (info);
3671 BFD_ASSERT (htab != NULL);
3672
3673 sgot = htab->root.sgot;
3674 gp = _bfd_get_gp_value (output_bfd)
3675 + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd);
3676
3677 return sgot->output_section->vma + sgot->output_offset + got_index - gp;
3678 }
3679
3680 /* Create and return a local GOT entry for VALUE, which was calculated
3681 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
3682 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
3683 instead. */
3684
3685 static struct mips_got_entry *
3686 mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
3687 bfd *ibfd, bfd_vma value,
3688 unsigned long r_symndx,
3689 struct mips_elf_link_hash_entry *h,
3690 int r_type)
3691 {
3692 struct mips_got_entry lookup, *entry;
3693 void **loc;
3694 struct mips_got_info *g;
3695 struct mips_elf_link_hash_table *htab;
3696 bfd_vma gotidx;
3697
3698 htab = mips_elf_hash_table (info);
3699 BFD_ASSERT (htab != NULL);
3700
3701 g = mips_elf_bfd_got (ibfd, FALSE);
3702 if (g == NULL)
3703 {
3704 g = mips_elf_bfd_got (abfd, FALSE);
3705 BFD_ASSERT (g != NULL);
3706 }
3707
3708 /* This function shouldn't be called for symbols that live in the global
3709 area of the GOT. */
3710 BFD_ASSERT (h == NULL || h->global_got_area == GGA_NONE);
3711
3712 lookup.tls_type = mips_elf_reloc_tls_type (r_type);
3713 if (lookup.tls_type)
3714 {
3715 lookup.abfd = ibfd;
3716 if (tls_ldm_reloc_p (r_type))
3717 {
3718 lookup.symndx = 0;
3719 lookup.d.addend = 0;
3720 }
3721 else if (h == NULL)
3722 {
3723 lookup.symndx = r_symndx;
3724 lookup.d.addend = 0;
3725 }
3726 else
3727 {
3728 lookup.symndx = -1;
3729 lookup.d.h = h;
3730 }
3731
3732 entry = (struct mips_got_entry *) htab_find (g->got_entries, &lookup);
3733 BFD_ASSERT (entry);
3734
3735 gotidx = entry->gotidx;
3736 BFD_ASSERT (gotidx > 0 && gotidx < htab->root.sgot->size);
3737
3738 return entry;
3739 }
3740
3741 lookup.abfd = NULL;
3742 lookup.symndx = -1;
3743 lookup.d.address = value;
3744 loc = htab_find_slot (g->got_entries, &lookup, INSERT);
3745 if (!loc)
3746 return NULL;
3747
3748 entry = (struct mips_got_entry *) *loc;
3749 if (entry)
3750 return entry;
3751
3752 if (g->assigned_low_gotno > g->assigned_high_gotno)
3753 {
3754 /* We didn't allocate enough space in the GOT. */
3755 _bfd_error_handler
3756 (_("not enough GOT space for local GOT entries"));
3757 bfd_set_error (bfd_error_bad_value);
3758 return NULL;
3759 }
3760
3761 entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
3762 if (!entry)
3763 return NULL;
3764
3765 if (got16_reloc_p (r_type)
3766 || call16_reloc_p (r_type)
3767 || got_page_reloc_p (r_type)
3768 || got_disp_reloc_p (r_type))
3769 lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_low_gotno++;
3770 else
3771 lookup.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_high_gotno--;
3772
3773 *entry = lookup;
3774 *loc = entry;
3775
3776 MIPS_ELF_PUT_WORD (abfd, value, htab->root.sgot->contents + entry->gotidx);
3777
3778 /* These GOT entries need a dynamic relocation on VxWorks. */
3779 if (htab->is_vxworks)
3780 {
3781 Elf_Internal_Rela outrel;
3782 asection *s;
3783 bfd_byte *rloc;
3784 bfd_vma got_address;
3785
3786 s = mips_elf_rel_dyn_section (info, FALSE);
3787 got_address = (htab->root.sgot->output_section->vma
3788 + htab->root.sgot->output_offset
3789 + entry->gotidx);
3790
3791 rloc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
3792 outrel.r_offset = got_address;
3793 outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
3794 outrel.r_addend = value;
3795 bfd_elf32_swap_reloca_out (abfd, &outrel, rloc);
3796 }
3797
3798 return entry;
3799 }
3800
3801 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3802 The number might be exact or a worst-case estimate, depending on how
3803 much information is available to elf_backend_omit_section_dynsym at
3804 the current linking stage. */
3805
3806 static bfd_size_type
3807 count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
3808 {
3809 bfd_size_type count;
3810
3811 count = 0;
3812 if (bfd_link_pic (info)
3813 || elf_hash_table (info)->is_relocatable_executable)
3814 {
3815 asection *p;
3816 const struct elf_backend_data *bed;
3817
3818 bed = get_elf_backend_data (output_bfd);
3819 for (p = output_bfd->sections; p ; p = p->next)
3820 if ((p->flags & SEC_EXCLUDE) == 0
3821 && (p->flags & SEC_ALLOC) != 0
3822 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
3823 ++count;
3824 }
3825 return count;
3826 }
3827
3828 /* Sort the dynamic symbol table so that symbols that need GOT entries
3829 appear towards the end. */
3830
3831 static bfd_boolean
3832 mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info)
3833 {
3834 struct mips_elf_link_hash_table *htab;
3835 struct mips_elf_hash_sort_data hsd;
3836 struct mips_got_info *g;
3837
3838 htab = mips_elf_hash_table (info);
3839 BFD_ASSERT (htab != NULL);
3840
3841 if (htab->root.dynsymcount == 0)
3842 return TRUE;
3843
3844 g = htab->got_info;
3845 if (g == NULL)
3846 return TRUE;
3847
3848 hsd.low = NULL;
3849 hsd.max_unref_got_dynindx
3850 = hsd.min_got_dynindx
3851 = (htab->root.dynsymcount - g->reloc_only_gotno);
3852 /* Add 1 to local symbol indices to account for the mandatory NULL entry
3853 at the head of the table; see `_bfd_elf_link_renumber_dynsyms'. */
3854 hsd.max_local_dynindx = count_section_dynsyms (abfd, info) + 1;
3855 hsd.max_non_got_dynindx = htab->root.local_dynsymcount + 1;
3856 mips_elf_link_hash_traverse (htab, mips_elf_sort_hash_table_f, &hsd);
3857
3858 /* There should have been enough room in the symbol table to
3859 accommodate both the GOT and non-GOT symbols. */
3860 BFD_ASSERT (hsd.max_local_dynindx <= htab->root.local_dynsymcount + 1);
3861 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
3862 BFD_ASSERT (hsd.max_unref_got_dynindx == htab->root.dynsymcount);
3863 BFD_ASSERT (htab->root.dynsymcount - hsd.min_got_dynindx == g->global_gotno);
3864
3865 /* Now we know which dynamic symbol has the lowest dynamic symbol
3866 table index in the GOT. */
3867 htab->global_gotsym = hsd.low;
3868
3869 return TRUE;
3870 }
3871
3872 /* If H needs a GOT entry, assign it the highest available dynamic
3873 index. Otherwise, assign it the lowest available dynamic
3874 index. */
3875
3876 static bfd_boolean
3877 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
3878 {
3879 struct mips_elf_hash_sort_data *hsd = data;
3880
3881 /* Symbols without dynamic symbol table entries aren't interesting
3882 at all. */
3883 if (h->root.dynindx == -1)
3884 return TRUE;
3885
3886 switch (h->global_got_area)
3887 {
3888 case GGA_NONE:
3889 if (h->root.forced_local)
3890 h->root.dynindx = hsd->max_local_dynindx++;
3891 else
3892 h->root.dynindx = hsd->max_non_got_dynindx++;
3893 break;
3894
3895 case GGA_NORMAL:
3896 h->root.dynindx = --hsd->min_got_dynindx;
3897 hsd->low = (struct elf_link_hash_entry *) h;
3898 break;
3899
3900 case GGA_RELOC_ONLY:
3901 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
3902 hsd->low = (struct elf_link_hash_entry *) h;
3903 h->root.dynindx = hsd->max_unref_got_dynindx++;
3904 break;
3905 }
3906
3907 return TRUE;
3908 }
3909
3910 /* Record that input bfd ABFD requires a GOT entry like *LOOKUP
3911 (which is owned by the caller and shouldn't be added to the
3912 hash table directly). */
3913
3914 static bfd_boolean
3915 mips_elf_record_got_entry (struct bfd_link_info *info, bfd *abfd,
3916 struct mips_got_entry *lookup)
3917 {
3918 struct mips_elf_link_hash_table *htab;
3919 struct mips_got_entry *entry;
3920 struct mips_got_info *g;
3921 void **loc, **bfd_loc;
3922
3923 /* Make sure there's a slot for this entry in the master GOT. */
3924 htab = mips_elf_hash_table (info);
3925 g = htab->got_info;
3926 loc = htab_find_slot (g->got_entries, lookup, INSERT);
3927 if (!loc)
3928 return FALSE;
3929
3930 /* Populate the entry if it isn't already. */
3931 entry = (struct mips_got_entry *) *loc;
3932 if (!entry)
3933 {
3934 entry = (struct mips_got_entry *) bfd_alloc (abfd, sizeof (*entry));
3935 if (!entry)
3936 return FALSE;
3937
3938 lookup->tls_initialized = FALSE;
3939 lookup->gotidx = -1;
3940 *entry = *lookup;
3941 *loc = entry;
3942 }
3943
3944 /* Reuse the same GOT entry for the BFD's GOT. */
3945 g = mips_elf_bfd_got (abfd, TRUE);
3946 if (!g)
3947 return FALSE;
3948
3949 bfd_loc = htab_find_slot (g->got_entries, lookup, INSERT);
3950 if (!bfd_loc)
3951 return FALSE;
3952
3953 if (!*bfd_loc)
3954 *bfd_loc = entry;
3955 return TRUE;
3956 }
3957
3958 /* ABFD has a GOT relocation of type R_TYPE against H. Reserve a GOT
3959 entry for it. FOR_CALL is true if the caller is only interested in
3960 using the GOT entry for calls. */
3961
3962 static bfd_boolean
3963 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
3964 bfd *abfd, struct bfd_link_info *info,
3965 bfd_boolean for_call, int r_type)
3966 {
3967 struct mips_elf_link_hash_table *htab;
3968 struct mips_elf_link_hash_entry *hmips;
3969 struct mips_got_entry entry;
3970 unsigned char tls_type;
3971
3972 htab = mips_elf_hash_table (info);
3973 BFD_ASSERT (htab != NULL);
3974
3975 hmips = (struct mips_elf_link_hash_entry *) h;
3976 if (!for_call)
3977 hmips->got_only_for_calls = FALSE;
3978
3979 /* A global symbol in the GOT must also be in the dynamic symbol
3980 table. */
3981 if (h->dynindx == -1)
3982 {
3983 switch (ELF_ST_VISIBILITY (h->other))
3984 {
3985 case STV_INTERNAL:
3986 case STV_HIDDEN:
3987 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
3988 break;
3989 }
3990 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3991 return FALSE;
3992 }
3993
3994 tls_type = mips_elf_reloc_tls_type (r_type);
3995 if (tls_type == GOT_TLS_NONE && hmips->global_got_area > GGA_NORMAL)
3996 hmips->global_got_area = GGA_NORMAL;
3997
3998 entry.abfd = abfd;
3999 entry.symndx = -1;
4000 entry.d.h = (struct mips_elf_link_hash_entry *) h;
4001 entry.tls_type = tls_type;
4002 return mips_elf_record_got_entry (info, abfd, &entry);
4003 }
4004
4005 /* ABFD has a GOT relocation of type R_TYPE against symbol SYMNDX + ADDEND,
4006 where SYMNDX is a local symbol. Reserve a GOT entry for it. */
4007
4008 static bfd_boolean
4009 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
4010 struct bfd_link_info *info, int r_type)
4011 {
4012 struct mips_elf_link_hash_table *htab;
4013 struct mips_got_info *g;
4014 struct mips_got_entry entry;
4015
4016 htab = mips_elf_hash_table (info);
4017 BFD_ASSERT (htab != NULL);
4018
4019 g = htab->got_info;
4020 BFD_ASSERT (g != NULL);
4021
4022 entry.abfd = abfd;
4023 entry.symndx = symndx;
4024 entry.d.addend = addend;
4025 entry.tls_type = mips_elf_reloc_tls_type (r_type);
4026 return mips_elf_record_got_entry (info, abfd, &entry);
4027 }
4028
4029 /* Record that ABFD has a page relocation against SYMNDX + ADDEND.
4030 H is the symbol's hash table entry, or null if SYMNDX is local
4031 to ABFD. */
4032
4033 static bfd_boolean
4034 mips_elf_record_got_page_ref (struct bfd_link_info *info, bfd *abfd,
4035 long symndx, struct elf_link_hash_entry *h,
4036 bfd_signed_vma addend)
4037 {
4038 struct mips_elf_link_hash_table *htab;
4039 struct mips_got_info *g1, *g2;
4040 struct mips_got_page_ref lookup, *entry;
4041 void **loc, **bfd_loc;
4042
4043 htab = mips_elf_hash_table (info);
4044 BFD_ASSERT (htab != NULL);
4045
4046 g1 = htab->got_info;
4047 BFD_ASSERT (g1 != NULL);
4048
4049 if (h)
4050 {
4051 lookup.symndx = -1;
4052 lookup.u.h = (struct mips_elf_link_hash_entry *) h;
4053 }
4054 else
4055 {
4056 lookup.symndx = symndx;
4057 lookup.u.abfd = abfd;
4058 }
4059 lookup.addend = addend;
4060 loc = htab_find_slot (g1->got_page_refs, &lookup, INSERT);
4061 if (loc == NULL)
4062 return FALSE;
4063
4064 entry = (struct mips_got_page_ref *) *loc;
4065 if (!entry)
4066 {
4067 entry = bfd_alloc (abfd, sizeof (*entry));
4068 if (!entry)
4069 return FALSE;
4070
4071 *entry = lookup;
4072 *loc = entry;
4073 }
4074
4075 /* Add the same entry to the BFD's GOT. */
4076 g2 = mips_elf_bfd_got (abfd, TRUE);
4077 if (!g2)
4078 return FALSE;
4079
4080 bfd_loc = htab_find_slot (g2->got_page_refs, &lookup, INSERT);
4081 if (!bfd_loc)
4082 return FALSE;
4083
4084 if (!*bfd_loc)
4085 *bfd_loc = entry;
4086
4087 return TRUE;
4088 }
4089
4090 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
4091
4092 static void
4093 mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
4094 unsigned int n)
4095 {
4096 asection *s;
4097 struct mips_elf_link_hash_table *htab;
4098
4099 htab = mips_elf_hash_table (info);
4100 BFD_ASSERT (htab != NULL);
4101
4102 s = mips_elf_rel_dyn_section (info, FALSE);
4103 BFD_ASSERT (s != NULL);
4104
4105 if (htab->is_vxworks)
4106 s->size += n * MIPS_ELF_RELA_SIZE (abfd);
4107 else
4108 {
4109 if (s->size == 0)
4110 {
4111 /* Make room for a null element. */
4112 s->size += MIPS_ELF_REL_SIZE (abfd);
4113 ++s->reloc_count;
4114 }
4115 s->size += n * MIPS_ELF_REL_SIZE (abfd);
4116 }
4117 }
4118 \f
4119 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4120 mips_elf_traverse_got_arg structure. Count the number of GOT
4121 entries and TLS relocs. Set DATA->value to true if we need
4122 to resolve indirect or warning symbols and then recreate the GOT. */
4123
4124 static int
4125 mips_elf_check_recreate_got (void **entryp, void *data)
4126 {
4127 struct mips_got_entry *entry;
4128 struct mips_elf_traverse_got_arg *arg;
4129
4130 entry = (struct mips_got_entry *) *entryp;
4131 arg = (struct mips_elf_traverse_got_arg *) data;
4132 if (entry->abfd != NULL && entry->symndx == -1)
4133 {
4134 struct mips_elf_link_hash_entry *h;
4135
4136 h = entry->d.h;
4137 if (h->root.root.type == bfd_link_hash_indirect
4138 || h->root.root.type == bfd_link_hash_warning)
4139 {
4140 arg->value = TRUE;
4141 return 0;
4142 }
4143 }
4144 mips_elf_count_got_entry (arg->info, arg->g, entry);
4145 return 1;
4146 }
4147
4148 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4149 mips_elf_traverse_got_arg structure. Add all entries to DATA->g,
4150 converting entries for indirect and warning symbols into entries
4151 for the target symbol. Set DATA->g to null on error. */
4152
4153 static int
4154 mips_elf_recreate_got (void **entryp, void *data)
4155 {
4156 struct mips_got_entry new_entry, *entry;
4157 struct mips_elf_traverse_got_arg *arg;
4158 void **slot;
4159
4160 entry = (struct mips_got_entry *) *entryp;
4161 arg = (struct mips_elf_traverse_got_arg *) data;
4162 if (entry->abfd != NULL
4163 && entry->symndx == -1
4164 && (entry->d.h->root.root.type == bfd_link_hash_indirect
4165 || entry->d.h->root.root.type == bfd_link_hash_warning))
4166 {
4167 struct mips_elf_link_hash_entry *h;
4168
4169 new_entry = *entry;
4170 entry = &new_entry;
4171 h = entry->d.h;
4172 do
4173 {
4174 BFD_ASSERT (h->global_got_area == GGA_NONE);
4175 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4176 }
4177 while (h->root.root.type == bfd_link_hash_indirect
4178 || h->root.root.type == bfd_link_hash_warning);
4179 entry->d.h = h;
4180 }
4181 slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
4182 if (slot == NULL)
4183 {
4184 arg->g = NULL;
4185 return 0;
4186 }
4187 if (*slot == NULL)
4188 {
4189 if (entry == &new_entry)
4190 {
4191 entry = bfd_alloc (entry->abfd, sizeof (*entry));
4192 if (!entry)
4193 {
4194 arg->g = NULL;
4195 return 0;
4196 }
4197 *entry = new_entry;
4198 }
4199 *slot = entry;
4200 mips_elf_count_got_entry (arg->info, arg->g, entry);
4201 }
4202 return 1;
4203 }
4204
4205 /* Return the maximum number of GOT page entries required for RANGE. */
4206
4207 static bfd_vma
4208 mips_elf_pages_for_range (const struct mips_got_page_range *range)
4209 {
4210 return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
4211 }
4212
4213 /* Record that G requires a page entry that can reach SEC + ADDEND. */
4214
4215 static bfd_boolean
4216 mips_elf_record_got_page_entry (struct mips_elf_traverse_got_arg *arg,
4217 asection *sec, bfd_signed_vma addend)
4218 {
4219 struct mips_got_info *g = arg->g;
4220 struct mips_got_page_entry lookup, *entry;
4221 struct mips_got_page_range **range_ptr, *range;
4222 bfd_vma old_pages, new_pages;
4223 void **loc;
4224
4225 /* Find the mips_got_page_entry hash table entry for this section. */
4226 lookup.sec = sec;
4227 loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
4228 if (loc == NULL)
4229 return FALSE;
4230
4231 /* Create a mips_got_page_entry if this is the first time we've
4232 seen the section. */
4233 entry = (struct mips_got_page_entry *) *loc;
4234 if (!entry)
4235 {
4236 entry = bfd_zalloc (arg->info->output_bfd, sizeof (*entry));
4237 if (!entry)
4238 return FALSE;
4239
4240 entry->sec = sec;
4241 *loc = entry;
4242 }
4243
4244 /* Skip over ranges whose maximum extent cannot share a page entry
4245 with ADDEND. */
4246 range_ptr = &entry->ranges;
4247 while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
4248 range_ptr = &(*range_ptr)->next;
4249
4250 /* If we scanned to the end of the list, or found a range whose
4251 minimum extent cannot share a page entry with ADDEND, create
4252 a new singleton range. */
4253 range = *range_ptr;
4254 if (!range || addend < range->min_addend - 0xffff)
4255 {
4256 range = bfd_zalloc (arg->info->output_bfd, sizeof (*range));
4257 if (!range)
4258 return FALSE;
4259
4260 range->next = *range_ptr;
4261 range->min_addend = addend;
4262 range->max_addend = addend;
4263
4264 *range_ptr = range;
4265 entry->num_pages++;
4266 g->page_gotno++;
4267 return TRUE;
4268 }
4269
4270 /* Remember how many pages the old range contributed. */
4271 old_pages = mips_elf_pages_for_range (range);
4272
4273 /* Update the ranges. */
4274 if (addend < range->min_addend)
4275 range->min_addend = addend;
4276 else if (addend > range->max_addend)
4277 {
4278 if (range->next && addend >= range->next->min_addend - 0xffff)
4279 {
4280 old_pages += mips_elf_pages_for_range (range->next);
4281 range->max_addend = range->next->max_addend;
4282 range->next = range->next->next;
4283 }
4284 else
4285 range->max_addend = addend;
4286 }
4287
4288 /* Record any change in the total estimate. */
4289 new_pages = mips_elf_pages_for_range (range);
4290 if (old_pages != new_pages)
4291 {
4292 entry->num_pages += new_pages - old_pages;
4293 g->page_gotno += new_pages - old_pages;
4294 }
4295
4296 return TRUE;
4297 }
4298
4299 /* A htab_traverse callback for which *REFP points to a mips_got_page_ref
4300 and for which DATA points to a mips_elf_traverse_got_arg. Work out
4301 whether the page reference described by *REFP needs a GOT page entry,
4302 and record that entry in DATA->g if so. Set DATA->g to null on failure. */
4303
4304 static bfd_boolean
4305 mips_elf_resolve_got_page_ref (void **refp, void *data)
4306 {
4307 struct mips_got_page_ref *ref;
4308 struct mips_elf_traverse_got_arg *arg;
4309 struct mips_elf_link_hash_table *htab;
4310 asection *sec;
4311 bfd_vma addend;
4312
4313 ref = (struct mips_got_page_ref *) *refp;
4314 arg = (struct mips_elf_traverse_got_arg *) data;
4315 htab = mips_elf_hash_table (arg->info);
4316
4317 if (ref->symndx < 0)
4318 {
4319 struct mips_elf_link_hash_entry *h;
4320
4321 /* Global GOT_PAGEs decay to GOT_DISP and so don't need page entries. */
4322 h = ref->u.h;
4323 if (!SYMBOL_REFERENCES_LOCAL (arg->info, &h->root))
4324 return 1;
4325
4326 /* Ignore undefined symbols; we'll issue an error later if
4327 appropriate. */
4328 if (!((h->root.root.type == bfd_link_hash_defined
4329 || h->root.root.type == bfd_link_hash_defweak)
4330 && h->root.root.u.def.section))
4331 return 1;
4332
4333 sec = h->root.root.u.def.section;
4334 addend = h->root.root.u.def.value + ref->addend;
4335 }
4336 else
4337 {
4338 Elf_Internal_Sym *isym;
4339
4340 /* Read in the symbol. */
4341 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ref->u.abfd,
4342 ref->symndx);
4343 if (isym == NULL)
4344 {
4345 arg->g = NULL;
4346 return 0;
4347 }
4348
4349 /* Get the associated input section. */
4350 sec = bfd_section_from_elf_index (ref->u.abfd, isym->st_shndx);
4351 if (sec == NULL)
4352 {
4353 arg->g = NULL;
4354 return 0;
4355 }
4356
4357 /* If this is a mergable section, work out the section and offset
4358 of the merged data. For section symbols, the addend specifies
4359 of the offset _of_ the first byte in the data, otherwise it
4360 specifies the offset _from_ the first byte. */
4361 if (sec->flags & SEC_MERGE)
4362 {
4363 void *secinfo;
4364
4365 secinfo = elf_section_data (sec)->sec_info;
4366 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
4367 addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
4368 isym->st_value + ref->addend);
4369 else
4370 addend = _bfd_merged_section_offset (ref->u.abfd, &sec, secinfo,
4371 isym->st_value) + ref->addend;
4372 }
4373 else
4374 addend = isym->st_value + ref->addend;
4375 }
4376 if (!mips_elf_record_got_page_entry (arg, sec, addend))
4377 {
4378 arg->g = NULL;
4379 return 0;
4380 }
4381 return 1;
4382 }
4383
4384 /* If any entries in G->got_entries are for indirect or warning symbols,
4385 replace them with entries for the target symbol. Convert g->got_page_refs
4386 into got_page_entry structures and estimate the number of page entries
4387 that they require. */
4388
4389 static bfd_boolean
4390 mips_elf_resolve_final_got_entries (struct bfd_link_info *info,
4391 struct mips_got_info *g)
4392 {
4393 struct mips_elf_traverse_got_arg tga;
4394 struct mips_got_info oldg;
4395
4396 oldg = *g;
4397
4398 tga.info = info;
4399 tga.g = g;
4400 tga.value = FALSE;
4401 htab_traverse (g->got_entries, mips_elf_check_recreate_got, &tga);
4402 if (tga.value)
4403 {
4404 *g = oldg;
4405 g->got_entries = htab_create (htab_size (oldg.got_entries),
4406 mips_elf_got_entry_hash,
4407 mips_elf_got_entry_eq, NULL);
4408 if (!g->got_entries)
4409 return FALSE;
4410
4411 htab_traverse (oldg.got_entries, mips_elf_recreate_got, &tga);
4412 if (!tga.g)
4413 return FALSE;
4414
4415 htab_delete (oldg.got_entries);
4416 }
4417
4418 g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4419 mips_got_page_entry_eq, NULL);
4420 if (g->got_page_entries == NULL)
4421 return FALSE;
4422
4423 tga.info = info;
4424 tga.g = g;
4425 htab_traverse (g->got_page_refs, mips_elf_resolve_got_page_ref, &tga);
4426
4427 return TRUE;
4428 }
4429
4430 /* Return true if a GOT entry for H should live in the local rather than
4431 global GOT area. */
4432
4433 static bfd_boolean
4434 mips_use_local_got_p (struct bfd_link_info *info,
4435 struct mips_elf_link_hash_entry *h)
4436 {
4437 /* Symbols that aren't in the dynamic symbol table must live in the
4438 local GOT. This includes symbols that are completely undefined
4439 and which therefore don't bind locally. We'll report undefined
4440 symbols later if appropriate. */
4441 if (h->root.dynindx == -1)
4442 return TRUE;
4443
4444 /* Symbols that bind locally can (and in the case of forced-local
4445 symbols, must) live in the local GOT. */
4446 if (h->got_only_for_calls
4447 ? SYMBOL_CALLS_LOCAL (info, &h->root)
4448 : SYMBOL_REFERENCES_LOCAL (info, &h->root))
4449 return TRUE;
4450
4451 /* If this is an executable that must provide a definition of the symbol,
4452 either though PLTs or copy relocations, then that address should go in
4453 the local rather than global GOT. */
4454 if (bfd_link_executable (info) && h->has_static_relocs)
4455 return TRUE;
4456
4457 return FALSE;
4458 }
4459
4460 /* A mips_elf_link_hash_traverse callback for which DATA points to the
4461 link_info structure. Decide whether the hash entry needs an entry in
4462 the global part of the primary GOT, setting global_got_area accordingly.
4463 Count the number of global symbols that are in the primary GOT only
4464 because they have relocations against them (reloc_only_gotno). */
4465
4466 static int
4467 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
4468 {
4469 struct bfd_link_info *info;
4470 struct mips_elf_link_hash_table *htab;
4471 struct mips_got_info *g;
4472
4473 info = (struct bfd_link_info *) data;
4474 htab = mips_elf_hash_table (info);
4475 g = htab->got_info;
4476 if (h->global_got_area != GGA_NONE)
4477 {
4478 /* Make a final decision about whether the symbol belongs in the
4479 local or global GOT. */
4480 if (mips_use_local_got_p (info, h))
4481 /* The symbol belongs in the local GOT. We no longer need this
4482 entry if it was only used for relocations; those relocations
4483 will be against the null or section symbol instead of H. */
4484 h->global_got_area = GGA_NONE;
4485 else if (htab->is_vxworks
4486 && h->got_only_for_calls
4487 && h->root.plt.plist->mips_offset != MINUS_ONE)
4488 /* On VxWorks, calls can refer directly to the .got.plt entry;
4489 they don't need entries in the regular GOT. .got.plt entries
4490 will be allocated by _bfd_mips_elf_adjust_dynamic_symbol. */
4491 h->global_got_area = GGA_NONE;
4492 else if (h->global_got_area == GGA_RELOC_ONLY)
4493 {
4494 g->reloc_only_gotno++;
4495 g->global_gotno++;
4496 }
4497 }
4498 return 1;
4499 }
4500 \f
4501 /* A htab_traverse callback for GOT entries. Add each one to the GOT
4502 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */
4503
4504 static int
4505 mips_elf_add_got_entry (void **entryp, void *data)
4506 {
4507 struct mips_got_entry *entry;
4508 struct mips_elf_traverse_got_arg *arg;
4509 void **slot;
4510
4511 entry = (struct mips_got_entry *) *entryp;
4512 arg = (struct mips_elf_traverse_got_arg *) data;
4513 slot = htab_find_slot (arg->g->got_entries, entry, INSERT);
4514 if (!slot)
4515 {
4516 arg->g = NULL;
4517 return 0;
4518 }
4519 if (!*slot)
4520 {
4521 *slot = entry;
4522 mips_elf_count_got_entry (arg->info, arg->g, entry);
4523 }
4524 return 1;
4525 }
4526
4527 /* A htab_traverse callback for GOT page entries. Add each one to the GOT
4528 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */
4529
4530 static int
4531 mips_elf_add_got_page_entry (void **entryp, void *data)
4532 {
4533 struct mips_got_page_entry *entry;
4534 struct mips_elf_traverse_got_arg *arg;
4535 void **slot;
4536
4537 entry = (struct mips_got_page_entry *) *entryp;
4538 arg = (struct mips_elf_traverse_got_arg *) data;
4539 slot = htab_find_slot (arg->g->got_page_entries, entry, INSERT);
4540 if (!slot)
4541 {
4542 arg->g = NULL;
4543 return 0;
4544 }
4545 if (!*slot)
4546 {
4547 *slot = entry;
4548 arg->g->page_gotno += entry->num_pages;
4549 }
4550 return 1;
4551 }
4552
4553 /* Consider merging FROM, which is ABFD's GOT, into TO. Return -1 if
4554 this would lead to overflow, 1 if they were merged successfully,
4555 and 0 if a merge failed due to lack of memory. (These values are chosen
4556 so that nonnegative return values can be returned by a htab_traverse
4557 callback.) */
4558
4559 static int
4560 mips_elf_merge_got_with (bfd *abfd, struct mips_got_info *from,
4561 struct mips_got_info *to,
4562 struct mips_elf_got_per_bfd_arg *arg)
4563 {
4564 struct mips_elf_traverse_got_arg tga;
4565 unsigned int estimate;
4566
4567 /* Work out how many page entries we would need for the combined GOT. */
4568 estimate = arg->max_pages;
4569 if (estimate >= from->page_gotno + to->page_gotno)
4570 estimate = from->page_gotno + to->page_gotno;
4571
4572 /* And conservatively estimate how many local and TLS entries
4573 would be needed. */
4574 estimate += from->local_gotno + to->local_gotno;
4575 estimate += from->tls_gotno + to->tls_gotno;
4576
4577 /* If we're merging with the primary got, any TLS relocations will
4578 come after the full set of global entries. Otherwise estimate those
4579 conservatively as well. */
4580 if (to == arg->primary && from->tls_gotno + to->tls_gotno)
4581 estimate += arg->global_count;
4582 else
4583 estimate += from->global_gotno + to->global_gotno;
4584
4585 /* Bail out if the combined GOT might be too big. */
4586 if (estimate > arg->max_count)
4587 return -1;
4588
4589 /* Transfer the bfd's got information from FROM to TO. */
4590 tga.info = arg->info;
4591 tga.g = to;
4592 htab_traverse (from->got_entries, mips_elf_add_got_entry, &tga);
4593 if (!tga.g)
4594 return 0;
4595
4596 htab_traverse (from->got_page_entries, mips_elf_add_got_page_entry, &tga);
4597 if (!tga.g)
4598 return 0;
4599
4600 mips_elf_replace_bfd_got (abfd, to);
4601 return 1;
4602 }
4603
4604 /* Attempt to merge GOT G, which belongs to ABFD. Try to use as much
4605 as possible of the primary got, since it doesn't require explicit
4606 dynamic relocations, but don't use bfds that would reference global
4607 symbols out of the addressable range. Failing the primary got,
4608 attempt to merge with the current got, or finish the current got
4609 and then make make the new got current. */
4610
4611 static bfd_boolean
4612 mips_elf_merge_got (bfd *abfd, struct mips_got_info *g,
4613 struct mips_elf_got_per_bfd_arg *arg)
4614 {
4615 unsigned int estimate;
4616 int result;
4617
4618 if (!mips_elf_resolve_final_got_entries (arg->info, g))
4619 return FALSE;
4620
4621 /* Work out the number of page, local and TLS entries. */
4622 estimate = arg->max_pages;
4623 if (estimate > g->page_gotno)
4624 estimate = g->page_gotno;
4625 estimate += g->local_gotno + g->tls_gotno;
4626
4627 /* We place TLS GOT entries after both locals and globals. The globals
4628 for the primary GOT may overflow the normal GOT size limit, so be
4629 sure not to merge a GOT which requires TLS with the primary GOT in that
4630 case. This doesn't affect non-primary GOTs. */
4631 estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
4632
4633 if (estimate <= arg->max_count)
4634 {
4635 /* If we don't have a primary GOT, use it as
4636 a starting point for the primary GOT. */
4637 if (!arg->primary)
4638 {
4639 arg->primary = g;
4640 return TRUE;
4641 }
4642
4643 /* Try merging with the primary GOT. */
4644 result = mips_elf_merge_got_with (abfd, g, arg->primary, arg);
4645 if (result >= 0)
4646 return result;
4647 }
4648
4649 /* If we can merge with the last-created got, do it. */
4650 if (arg->current)
4651 {
4652 result = mips_elf_merge_got_with (abfd, g, arg->current, arg);
4653 if (result >= 0)
4654 return result;
4655 }
4656
4657 /* Well, we couldn't merge, so create a new GOT. Don't check if it
4658 fits; if it turns out that it doesn't, we'll get relocation
4659 overflows anyway. */
4660 g->next = arg->current;
4661 arg->current = g;
4662
4663 return TRUE;
4664 }
4665
4666 /* ENTRYP is a hash table entry for a mips_got_entry. Set its gotidx
4667 to GOTIDX, duplicating the entry if it has already been assigned
4668 an index in a different GOT. */
4669
4670 static bfd_boolean
4671 mips_elf_set_gotidx (void **entryp, long gotidx)
4672 {
4673 struct mips_got_entry *entry;
4674
4675 entry = (struct mips_got_entry *) *entryp;
4676 if (entry->gotidx > 0)
4677 {
4678 struct mips_got_entry *new_entry;
4679
4680 new_entry = bfd_alloc (entry->abfd, sizeof (*entry));
4681 if (!new_entry)
4682 return FALSE;
4683
4684 *new_entry = *entry;
4685 *entryp = new_entry;
4686 entry = new_entry;
4687 }
4688 entry->gotidx = gotidx;
4689 return TRUE;
4690 }
4691
4692 /* Set the TLS GOT index for the GOT entry in ENTRYP. DATA points to a
4693 mips_elf_traverse_got_arg in which DATA->value is the size of one
4694 GOT entry. Set DATA->g to null on failure. */
4695
4696 static int
4697 mips_elf_initialize_tls_index (void **entryp, void *data)
4698 {
4699 struct mips_got_entry *entry;
4700 struct mips_elf_traverse_got_arg *arg;
4701
4702 /* We're only interested in TLS symbols. */
4703 entry = (struct mips_got_entry *) *entryp;
4704 if (entry->tls_type == GOT_TLS_NONE)
4705 return 1;
4706
4707 arg = (struct mips_elf_traverse_got_arg *) data;
4708 if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->tls_assigned_gotno))
4709 {
4710 arg->g = NULL;
4711 return 0;
4712 }
4713
4714 /* Account for the entries we've just allocated. */
4715 arg->g->tls_assigned_gotno += mips_tls_got_entries (entry->tls_type);
4716 return 1;
4717 }
4718
4719 /* A htab_traverse callback for GOT entries, where DATA points to a
4720 mips_elf_traverse_got_arg. Set the global_got_area of each global
4721 symbol to DATA->value. */
4722
4723 static int
4724 mips_elf_set_global_got_area (void **entryp, void *data)
4725 {
4726 struct mips_got_entry *entry;
4727 struct mips_elf_traverse_got_arg *arg;
4728
4729 entry = (struct mips_got_entry *) *entryp;
4730 arg = (struct mips_elf_traverse_got_arg *) data;
4731 if (entry->abfd != NULL
4732 && entry->symndx == -1
4733 && entry->d.h->global_got_area != GGA_NONE)
4734 entry->d.h->global_got_area = arg->value;
4735 return 1;
4736 }
4737
4738 /* A htab_traverse callback for secondary GOT entries, where DATA points
4739 to a mips_elf_traverse_got_arg. Assign GOT indices to global entries
4740 and record the number of relocations they require. DATA->value is
4741 the size of one GOT entry. Set DATA->g to null on failure. */
4742
4743 static int
4744 mips_elf_set_global_gotidx (void **entryp, void *data)
4745 {
4746 struct mips_got_entry *entry;
4747 struct mips_elf_traverse_got_arg *arg;
4748
4749 entry = (struct mips_got_entry *) *entryp;
4750 arg = (struct mips_elf_traverse_got_arg *) data;
4751 if (entry->abfd != NULL
4752 && entry->symndx == -1
4753 && entry->d.h->global_got_area != GGA_NONE)
4754 {
4755 if (!mips_elf_set_gotidx (entryp, arg->value * arg->g->assigned_low_gotno))
4756 {
4757 arg->g = NULL;
4758 return 0;
4759 }
4760 arg->g->assigned_low_gotno += 1;
4761
4762 if (bfd_link_pic (arg->info)
4763 || (elf_hash_table (arg->info)->dynamic_sections_created
4764 && entry->d.h->root.def_dynamic
4765 && !entry->d.h->root.def_regular))
4766 arg->g->relocs += 1;
4767 }
4768
4769 return 1;
4770 }
4771
4772 /* A htab_traverse callback for GOT entries for which DATA is the
4773 bfd_link_info. Forbid any global symbols from having traditional
4774 lazy-binding stubs. */
4775
4776 static int
4777 mips_elf_forbid_lazy_stubs (void **entryp, void *data)
4778 {
4779 struct bfd_link_info *info;
4780 struct mips_elf_link_hash_table *htab;
4781 struct mips_got_entry *entry;
4782
4783 entry = (struct mips_got_entry *) *entryp;
4784 info = (struct bfd_link_info *) data;
4785 htab = mips_elf_hash_table (info);
4786 BFD_ASSERT (htab != NULL);
4787
4788 if (entry->abfd != NULL
4789 && entry->symndx == -1
4790 && entry->d.h->needs_lazy_stub)
4791 {
4792 entry->d.h->needs_lazy_stub = FALSE;
4793 htab->lazy_stub_count--;
4794 }
4795
4796 return 1;
4797 }
4798
4799 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4800 the primary GOT. */
4801 static bfd_vma
4802 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
4803 {
4804 if (!g->next)
4805 return 0;
4806
4807 g = mips_elf_bfd_got (ibfd, FALSE);
4808 if (! g)
4809 return 0;
4810
4811 BFD_ASSERT (g->next);
4812
4813 g = g->next;
4814
4815 return (g->local_gotno + g->global_gotno + g->tls_gotno)
4816 * MIPS_ELF_GOT_SIZE (abfd);
4817 }
4818
4819 /* Turn a single GOT that is too big for 16-bit addressing into
4820 a sequence of GOTs, each one 16-bit addressable. */
4821
4822 static bfd_boolean
4823 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
4824 asection *got, bfd_size_type pages)
4825 {
4826 struct mips_elf_link_hash_table *htab;
4827 struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
4828 struct mips_elf_traverse_got_arg tga;
4829 struct mips_got_info *g, *gg;
4830 unsigned int assign, needed_relocs;
4831 bfd *dynobj, *ibfd;
4832
4833 dynobj = elf_hash_table (info)->dynobj;
4834 htab = mips_elf_hash_table (info);
4835 BFD_ASSERT (htab != NULL);
4836
4837 g = htab->got_info;
4838
4839 got_per_bfd_arg.obfd = abfd;
4840 got_per_bfd_arg.info = info;
4841 got_per_bfd_arg.current = NULL;
4842 got_per_bfd_arg.primary = NULL;
4843 got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
4844 / MIPS_ELF_GOT_SIZE (abfd))
4845 - htab->reserved_gotno);
4846 got_per_bfd_arg.max_pages = pages;
4847 /* The number of globals that will be included in the primary GOT.
4848 See the calls to mips_elf_set_global_got_area below for more
4849 information. */
4850 got_per_bfd_arg.global_count = g->global_gotno;
4851
4852 /* Try to merge the GOTs of input bfds together, as long as they
4853 don't seem to exceed the maximum GOT size, choosing one of them
4854 to be the primary GOT. */
4855 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
4856 {
4857 gg = mips_elf_bfd_got (ibfd, FALSE);
4858 if (gg && !mips_elf_merge_got (ibfd, gg, &got_per_bfd_arg))
4859 return FALSE;
4860 }
4861
4862 /* If we do not find any suitable primary GOT, create an empty one. */
4863 if (got_per_bfd_arg.primary == NULL)
4864 g->next = mips_elf_create_got_info (abfd);
4865 else
4866 g->next = got_per_bfd_arg.primary;
4867 g->next->next = got_per_bfd_arg.current;
4868
4869 /* GG is now the master GOT, and G is the primary GOT. */
4870 gg = g;
4871 g = g->next;
4872
4873 /* Map the output bfd to the primary got. That's what we're going
4874 to use for bfds that use GOT16 or GOT_PAGE relocations that we
4875 didn't mark in check_relocs, and we want a quick way to find it.
4876 We can't just use gg->next because we're going to reverse the
4877 list. */
4878 mips_elf_replace_bfd_got (abfd, g);
4879
4880 /* Every symbol that is referenced in a dynamic relocation must be
4881 present in the primary GOT, so arrange for them to appear after
4882 those that are actually referenced. */
4883 gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
4884 g->global_gotno = gg->global_gotno;
4885
4886 tga.info = info;
4887 tga.value = GGA_RELOC_ONLY;
4888 htab_traverse (gg->got_entries, mips_elf_set_global_got_area, &tga);
4889 tga.value = GGA_NORMAL;
4890 htab_traverse (g->got_entries, mips_elf_set_global_got_area, &tga);
4891
4892 /* Now go through the GOTs assigning them offset ranges.
4893 [assigned_low_gotno, local_gotno[ will be set to the range of local
4894 entries in each GOT. We can then compute the end of a GOT by
4895 adding local_gotno to global_gotno. We reverse the list and make
4896 it circular since then we'll be able to quickly compute the
4897 beginning of a GOT, by computing the end of its predecessor. To
4898 avoid special cases for the primary GOT, while still preserving
4899 assertions that are valid for both single- and multi-got links,
4900 we arrange for the main got struct to have the right number of
4901 global entries, but set its local_gotno such that the initial
4902 offset of the primary GOT is zero. Remember that the primary GOT
4903 will become the last item in the circular linked list, so it
4904 points back to the master GOT. */
4905 gg->local_gotno = -g->global_gotno;
4906 gg->global_gotno = g->global_gotno;
4907 gg->tls_gotno = 0;
4908 assign = 0;
4909 gg->next = gg;
4910
4911 do
4912 {
4913 struct mips_got_info *gn;
4914
4915 assign += htab->reserved_gotno;
4916 g->assigned_low_gotno = assign;
4917 g->local_gotno += assign;
4918 g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
4919 g->assigned_high_gotno = g->local_gotno - 1;
4920 assign = g->local_gotno + g->global_gotno + g->tls_gotno;
4921
4922 /* Take g out of the direct list, and push it onto the reversed
4923 list that gg points to. g->next is guaranteed to be nonnull after
4924 this operation, as required by mips_elf_initialize_tls_index. */
4925 gn = g->next;
4926 g->next = gg->next;
4927 gg->next = g;
4928
4929 /* Set up any TLS entries. We always place the TLS entries after
4930 all non-TLS entries. */
4931 g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
4932 tga.g = g;
4933 tga.value = MIPS_ELF_GOT_SIZE (abfd);
4934 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
4935 if (!tga.g)
4936 return FALSE;
4937 BFD_ASSERT (g->tls_assigned_gotno == assign);
4938
4939 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
4940 g = gn;
4941
4942 /* Forbid global symbols in every non-primary GOT from having
4943 lazy-binding stubs. */
4944 if (g)
4945 htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
4946 }
4947 while (g);
4948
4949 got->size = assign * MIPS_ELF_GOT_SIZE (abfd);
4950
4951 needed_relocs = 0;
4952 for (g = gg->next; g && g->next != gg; g = g->next)
4953 {
4954 unsigned int save_assign;
4955
4956 /* Assign offsets to global GOT entries and count how many
4957 relocations they need. */
4958 save_assign = g->assigned_low_gotno;
4959 g->assigned_low_gotno = g->local_gotno;
4960 tga.info = info;
4961 tga.value = MIPS_ELF_GOT_SIZE (abfd);
4962 tga.g = g;
4963 htab_traverse (g->got_entries, mips_elf_set_global_gotidx, &tga);
4964 if (!tga.g)
4965 return FALSE;
4966 BFD_ASSERT (g->assigned_low_gotno == g->local_gotno + g->global_gotno);
4967 g->assigned_low_gotno = save_assign;
4968
4969 if (bfd_link_pic (info))
4970 {
4971 g->relocs += g->local_gotno - g->assigned_low_gotno;
4972 BFD_ASSERT (g->assigned_low_gotno == g->next->local_gotno
4973 + g->next->global_gotno
4974 + g->next->tls_gotno
4975 + htab->reserved_gotno);
4976 }
4977 needed_relocs += g->relocs;
4978 }
4979 needed_relocs += g->relocs;
4980
4981 if (needed_relocs)
4982 mips_elf_allocate_dynamic_relocations (dynobj, info,
4983 needed_relocs);
4984
4985 return TRUE;
4986 }
4987
4988 \f
4989 /* Returns the first relocation of type r_type found, beginning with
4990 RELOCATION. RELEND is one-past-the-end of the relocation table. */
4991
4992 static const Elf_Internal_Rela *
4993 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
4994 const Elf_Internal_Rela *relocation,
4995 const Elf_Internal_Rela *relend)
4996 {
4997 unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
4998
4999 while (relocation < relend)
5000 {
5001 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
5002 && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
5003 return relocation;
5004
5005 ++relocation;
5006 }
5007
5008 /* We didn't find it. */
5009 return NULL;
5010 }
5011
5012 /* Return whether an input relocation is against a local symbol. */
5013
5014 static bfd_boolean
5015 mips_elf_local_relocation_p (bfd *input_bfd,
5016 const Elf_Internal_Rela *relocation,
5017 asection **local_sections)
5018 {
5019 unsigned long r_symndx;
5020 Elf_Internal_Shdr *symtab_hdr;
5021 size_t extsymoff;
5022
5023 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5024 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5025 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
5026
5027 if (r_symndx < extsymoff)
5028 return TRUE;
5029 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
5030 return TRUE;
5031
5032 return FALSE;
5033 }
5034 \f
5035 /* Sign-extend VALUE, which has the indicated number of BITS. */
5036
5037 bfd_vma
5038 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
5039 {
5040 if (value & ((bfd_vma) 1 << (bits - 1)))
5041 /* VALUE is negative. */
5042 value |= ((bfd_vma) - 1) << bits;
5043
5044 return value;
5045 }
5046
5047 /* Return non-zero if the indicated VALUE has overflowed the maximum
5048 range expressible by a signed number with the indicated number of
5049 BITS. */
5050
5051 static bfd_boolean
5052 mips_elf_overflow_p (bfd_vma value, int bits)
5053 {
5054 bfd_signed_vma svalue = (bfd_signed_vma) value;
5055
5056 if (svalue > (1 << (bits - 1)) - 1)
5057 /* The value is too big. */
5058 return TRUE;
5059 else if (svalue < -(1 << (bits - 1)))
5060 /* The value is too small. */
5061 return TRUE;
5062
5063 /* All is well. */
5064 return FALSE;
5065 }
5066
5067 /* Calculate the %high function. */
5068
5069 static bfd_vma
5070 mips_elf_high (bfd_vma value)
5071 {
5072 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
5073 }
5074
5075 /* Calculate the %higher function. */
5076
5077 static bfd_vma
5078 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
5079 {
5080 #ifdef BFD64
5081 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
5082 #else
5083 abort ();
5084 return MINUS_ONE;
5085 #endif
5086 }
5087
5088 /* Calculate the %highest function. */
5089
5090 static bfd_vma
5091 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
5092 {
5093 #ifdef BFD64
5094 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
5095 #else
5096 abort ();
5097 return MINUS_ONE;
5098 #endif
5099 }
5100 \f
5101 /* Create the .compact_rel section. */
5102
5103 static bfd_boolean
5104 mips_elf_create_compact_rel_section
5105 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
5106 {
5107 flagword flags;
5108 register asection *s;
5109
5110 if (bfd_get_linker_section (abfd, ".compact_rel") == NULL)
5111 {
5112 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
5113 | SEC_READONLY);
5114
5115 s = bfd_make_section_anyway_with_flags (abfd, ".compact_rel", flags);
5116 if (s == NULL
5117 || ! bfd_set_section_alignment (abfd, s,
5118 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
5119 return FALSE;
5120
5121 s->size = sizeof (Elf32_External_compact_rel);
5122 }
5123
5124 return TRUE;
5125 }
5126
5127 /* Create the .got section to hold the global offset table. */
5128
5129 static bfd_boolean
5130 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
5131 {
5132 flagword flags;
5133 register asection *s;
5134 struct elf_link_hash_entry *h;
5135 struct bfd_link_hash_entry *bh;
5136 struct mips_elf_link_hash_table *htab;
5137
5138 htab = mips_elf_hash_table (info);
5139 BFD_ASSERT (htab != NULL);
5140
5141 /* This function may be called more than once. */
5142 if (htab->root.sgot)
5143 return TRUE;
5144
5145 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
5146 | SEC_LINKER_CREATED);
5147
5148 /* We have to use an alignment of 2**4 here because this is hardcoded
5149 in the function stub generation and in the linker script. */
5150 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
5151 if (s == NULL
5152 || ! bfd_set_section_alignment (abfd, s, 4))
5153 return FALSE;
5154 htab->root.sgot = s;
5155
5156 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
5157 linker script because we don't want to define the symbol if we
5158 are not creating a global offset table. */
5159 bh = NULL;
5160 if (! (_bfd_generic_link_add_one_symbol
5161 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
5162 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
5163 return FALSE;
5164
5165 h = (struct elf_link_hash_entry *) bh;
5166 h->non_elf = 0;
5167 h->def_regular = 1;
5168 h->type = STT_OBJECT;
5169 h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
5170 elf_hash_table (info)->hgot = h;
5171
5172 if (bfd_link_pic (info)
5173 && ! bfd_elf_link_record_dynamic_symbol (info, h))
5174 return FALSE;
5175
5176 htab->got_info = mips_elf_create_got_info (abfd);
5177 mips_elf_section_data (s)->elf.this_hdr.sh_flags
5178 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5179
5180 /* We also need a .got.plt section when generating PLTs. */
5181 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt",
5182 SEC_ALLOC | SEC_LOAD
5183 | SEC_HAS_CONTENTS
5184 | SEC_IN_MEMORY
5185 | SEC_LINKER_CREATED);
5186 if (s == NULL)
5187 return FALSE;
5188 htab->root.sgotplt = s;
5189
5190 return TRUE;
5191 }
5192 \f
5193 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
5194 __GOTT_INDEX__ symbols. These symbols are only special for
5195 shared objects; they are not used in executables. */
5196
5197 static bfd_boolean
5198 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
5199 {
5200 return (mips_elf_hash_table (info)->is_vxworks
5201 && bfd_link_pic (info)
5202 && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
5203 || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
5204 }
5205
5206 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
5207 require an la25 stub. See also mips_elf_local_pic_function_p,
5208 which determines whether the destination function ever requires a
5209 stub. */
5210
5211 static bfd_boolean
5212 mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type,
5213 bfd_boolean target_is_16_bit_code_p)
5214 {
5215 /* We specifically ignore branches and jumps from EF_PIC objects,
5216 where the onus is on the compiler or programmer to perform any
5217 necessary initialization of $25. Sometimes such initialization
5218 is unnecessary; for example, -mno-shared functions do not use
5219 the incoming value of $25, and may therefore be called directly. */
5220 if (PIC_OBJECT_P (input_bfd))
5221 return FALSE;
5222
5223 switch (r_type)
5224 {
5225 case R_MIPS_26:
5226 case R_MIPS_PC16:
5227 case R_MIPS_PC21_S2:
5228 case R_MIPS_PC26_S2:
5229 case R_MICROMIPS_26_S1:
5230 case R_MICROMIPS_PC7_S1:
5231 case R_MICROMIPS_PC10_S1:
5232 case R_MICROMIPS_PC16_S1:
5233 case R_MICROMIPS_PC23_S2:
5234 return TRUE;
5235
5236 case R_MIPS16_26:
5237 return !target_is_16_bit_code_p;
5238
5239 default:
5240 return FALSE;
5241 }
5242 }
5243 \f
5244 /* Calculate the value produced by the RELOCATION (which comes from
5245 the INPUT_BFD). The ADDEND is the addend to use for this
5246 RELOCATION; RELOCATION->R_ADDEND is ignored.
5247
5248 The result of the relocation calculation is stored in VALUEP.
5249 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
5250 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5251
5252 This function returns bfd_reloc_continue if the caller need take no
5253 further action regarding this relocation, bfd_reloc_notsupported if
5254 something goes dramatically wrong, bfd_reloc_overflow if an
5255 overflow occurs, and bfd_reloc_ok to indicate success. */
5256
5257 static bfd_reloc_status_type
5258 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
5259 asection *input_section,
5260 struct bfd_link_info *info,
5261 const Elf_Internal_Rela *relocation,
5262 bfd_vma addend, reloc_howto_type *howto,
5263 Elf_Internal_Sym *local_syms,
5264 asection **local_sections, bfd_vma *valuep,
5265 const char **namep,
5266 bfd_boolean *cross_mode_jump_p,
5267 bfd_boolean save_addend)
5268 {
5269 /* The eventual value we will return. */
5270 bfd_vma value;
5271 /* The address of the symbol against which the relocation is
5272 occurring. */
5273 bfd_vma symbol = 0;
5274 /* The final GP value to be used for the relocatable, executable, or
5275 shared object file being produced. */
5276 bfd_vma gp;
5277 /* The place (section offset or address) of the storage unit being
5278 relocated. */
5279 bfd_vma p;
5280 /* The value of GP used to create the relocatable object. */
5281 bfd_vma gp0;
5282 /* The offset into the global offset table at which the address of
5283 the relocation entry symbol, adjusted by the addend, resides
5284 during execution. */
5285 bfd_vma g = MINUS_ONE;
5286 /* The section in which the symbol referenced by the relocation is
5287 located. */
5288 asection *sec = NULL;
5289 struct mips_elf_link_hash_entry *h = NULL;
5290 /* TRUE if the symbol referred to by this relocation is a local
5291 symbol. */
5292 bfd_boolean local_p, was_local_p;
5293 /* TRUE if the symbol referred to by this relocation is a section
5294 symbol. */
5295 bfd_boolean section_p = FALSE;
5296 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
5297 bfd_boolean gp_disp_p = FALSE;
5298 /* TRUE if the symbol referred to by this relocation is
5299 "__gnu_local_gp". */
5300 bfd_boolean gnu_local_gp_p = FALSE;
5301 Elf_Internal_Shdr *symtab_hdr;
5302 size_t extsymoff;
5303 unsigned long r_symndx;
5304 int r_type;
5305 /* TRUE if overflow occurred during the calculation of the
5306 relocation value. */
5307 bfd_boolean overflowed_p;
5308 /* TRUE if this relocation refers to a MIPS16 function. */
5309 bfd_boolean target_is_16_bit_code_p = FALSE;
5310 bfd_boolean target_is_micromips_code_p = FALSE;
5311 struct mips_elf_link_hash_table *htab;
5312 bfd *dynobj;
5313
5314 dynobj = elf_hash_table (info)->dynobj;
5315 htab = mips_elf_hash_table (info);
5316 BFD_ASSERT (htab != NULL);
5317
5318 /* Parse the relocation. */
5319 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5320 r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5321 p = (input_section->output_section->vma
5322 + input_section->output_offset
5323 + relocation->r_offset);
5324
5325 /* Assume that there will be no overflow. */
5326 overflowed_p = FALSE;
5327
5328 /* Figure out whether or not the symbol is local, and get the offset
5329 used in the array of hash table entries. */
5330 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5331 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5332 local_sections);
5333 was_local_p = local_p;
5334 if (! elf_bad_symtab (input_bfd))
5335 extsymoff = symtab_hdr->sh_info;
5336 else
5337 {
5338 /* The symbol table does not follow the rule that local symbols
5339 must come before globals. */
5340 extsymoff = 0;
5341 }
5342
5343 /* Figure out the value of the symbol. */
5344 if (local_p)
5345 {
5346 bfd_boolean micromips_p = MICROMIPS_P (abfd);
5347 Elf_Internal_Sym *sym;
5348
5349 sym = local_syms + r_symndx;
5350 sec = local_sections[r_symndx];
5351
5352 section_p = ELF_ST_TYPE (sym->st_info) == STT_SECTION;
5353
5354 symbol = sec->output_section->vma + sec->output_offset;
5355 if (!section_p || (sec->flags & SEC_MERGE))
5356 symbol += sym->st_value;
5357 if ((sec->flags & SEC_MERGE) && section_p)
5358 {
5359 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
5360 addend -= symbol;
5361 addend += sec->output_section->vma + sec->output_offset;
5362 }
5363
5364 /* MIPS16/microMIPS text labels should be treated as odd. */
5365 if (ELF_ST_IS_COMPRESSED (sym->st_other))
5366 ++symbol;
5367
5368 /* Record the name of this symbol, for our caller. */
5369 *namep = bfd_elf_string_from_elf_section (input_bfd,
5370 symtab_hdr->sh_link,
5371 sym->st_name);
5372 if (*namep == NULL || **namep == '\0')
5373 *namep = bfd_section_name (input_bfd, sec);
5374
5375 /* For relocations against a section symbol and ones against no
5376 symbol (absolute relocations) infer the ISA mode from the addend. */
5377 if (section_p || r_symndx == STN_UNDEF)
5378 {
5379 target_is_16_bit_code_p = (addend & 1) && !micromips_p;
5380 target_is_micromips_code_p = (addend & 1) && micromips_p;
5381 }
5382 /* For relocations against an absolute symbol infer the ISA mode
5383 from the value of the symbol plus addend. */
5384 else if (bfd_is_abs_section (sec))
5385 {
5386 target_is_16_bit_code_p = ((symbol + addend) & 1) && !micromips_p;
5387 target_is_micromips_code_p = ((symbol + addend) & 1) && micromips_p;
5388 }
5389 /* Otherwise just use the regular symbol annotation available. */
5390 else
5391 {
5392 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
5393 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other);
5394 }
5395 }
5396 else
5397 {
5398 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
5399
5400 /* For global symbols we look up the symbol in the hash-table. */
5401 h = ((struct mips_elf_link_hash_entry *)
5402 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5403 /* Find the real hash-table entry for this symbol. */
5404 while (h->root.root.type == bfd_link_hash_indirect
5405 || h->root.root.type == bfd_link_hash_warning)
5406 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5407
5408 /* Record the name of this symbol, for our caller. */
5409 *namep = h->root.root.root.string;
5410
5411 /* See if this is the special _gp_disp symbol. Note that such a
5412 symbol must always be a global symbol. */
5413 if (strcmp (*namep, "_gp_disp") == 0
5414 && ! NEWABI_P (input_bfd))
5415 {
5416 /* Relocations against _gp_disp are permitted only with
5417 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5418 if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
5419 return bfd_reloc_notsupported;
5420
5421 gp_disp_p = TRUE;
5422 }
5423 /* See if this is the special _gp symbol. Note that such a
5424 symbol must always be a global symbol. */
5425 else if (strcmp (*namep, "__gnu_local_gp") == 0)
5426 gnu_local_gp_p = TRUE;
5427
5428
5429 /* If this symbol is defined, calculate its address. Note that
5430 _gp_disp is a magic symbol, always implicitly defined by the
5431 linker, so it's inappropriate to check to see whether or not
5432 its defined. */
5433 else if ((h->root.root.type == bfd_link_hash_defined
5434 || h->root.root.type == bfd_link_hash_defweak)
5435 && h->root.root.u.def.section)
5436 {
5437 sec = h->root.root.u.def.section;
5438 if (sec->output_section)
5439 symbol = (h->root.root.u.def.value
5440 + sec->output_section->vma
5441 + sec->output_offset);
5442 else
5443 symbol = h->root.root.u.def.value;
5444 }
5445 else if (h->root.root.type == bfd_link_hash_undefweak)
5446 /* We allow relocations against undefined weak symbols, giving
5447 it the value zero, so that you can undefined weak functions
5448 and check to see if they exist by looking at their
5449 addresses. */
5450 symbol = 0;
5451 else if (info->unresolved_syms_in_objects == RM_IGNORE
5452 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5453 symbol = 0;
5454 else if (strcmp (*namep, SGI_COMPAT (input_bfd)
5455 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5456 {
5457 /* If this is a dynamic link, we should have created a
5458 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5459 in in _bfd_mips_elf_create_dynamic_sections.
5460 Otherwise, we should define the symbol with a value of 0.
5461 FIXME: It should probably get into the symbol table
5462 somehow as well. */
5463 BFD_ASSERT (! bfd_link_pic (info));
5464 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5465 symbol = 0;
5466 }
5467 else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
5468 {
5469 /* This is an optional symbol - an Irix specific extension to the
5470 ELF spec. Ignore it for now.
5471 XXX - FIXME - there is more to the spec for OPTIONAL symbols
5472 than simply ignoring them, but we do not handle this for now.
5473 For information see the "64-bit ELF Object File Specification"
5474 which is available from here:
5475 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
5476 symbol = 0;
5477 }
5478 else
5479 {
5480 (*info->callbacks->undefined_symbol)
5481 (info, h->root.root.root.string, input_bfd,
5482 input_section, relocation->r_offset,
5483 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
5484 || ELF_ST_VISIBILITY (h->root.other));
5485 return bfd_reloc_undefined;
5486 }
5487
5488 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
5489 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (h->root.other);
5490 }
5491
5492 /* If this is a reference to a 16-bit function with a stub, we need
5493 to redirect the relocation to the stub unless:
5494
5495 (a) the relocation is for a MIPS16 JAL;
5496
5497 (b) the relocation is for a MIPS16 PIC call, and there are no
5498 non-MIPS16 uses of the GOT slot; or
5499
5500 (c) the section allows direct references to MIPS16 functions. */
5501 if (r_type != R_MIPS16_26
5502 && !bfd_link_relocatable (info)
5503 && ((h != NULL
5504 && h->fn_stub != NULL
5505 && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
5506 || (local_p
5507 && mips_elf_tdata (input_bfd)->local_stubs != NULL
5508 && mips_elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5509 && !section_allows_mips16_refs_p (input_section))
5510 {
5511 /* This is a 32- or 64-bit call to a 16-bit function. We should
5512 have already noticed that we were going to need the
5513 stub. */
5514 if (local_p)
5515 {
5516 sec = mips_elf_tdata (input_bfd)->local_stubs[r_symndx];
5517 value = 0;
5518 }
5519 else
5520 {
5521 BFD_ASSERT (h->need_fn_stub);
5522 if (h->la25_stub)
5523 {
5524 /* If a LA25 header for the stub itself exists, point to the
5525 prepended LUI/ADDIU sequence. */
5526 sec = h->la25_stub->stub_section;
5527 value = h->la25_stub->offset;
5528 }
5529 else
5530 {
5531 sec = h->fn_stub;
5532 value = 0;
5533 }
5534 }
5535
5536 symbol = sec->output_section->vma + sec->output_offset + value;
5537 /* The target is 16-bit, but the stub isn't. */
5538 target_is_16_bit_code_p = FALSE;
5539 }
5540 /* If this is a MIPS16 call with a stub, that is made through the PLT or
5541 to a standard MIPS function, we need to redirect the call to the stub.
5542 Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
5543 indirect calls should use an indirect stub instead. */
5544 else if (r_type == R_MIPS16_26 && !bfd_link_relocatable (info)
5545 && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
5546 || (local_p
5547 && mips_elf_tdata (input_bfd)->local_call_stubs != NULL
5548 && mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
5549 && ((h != NULL && h->use_plt_entry) || !target_is_16_bit_code_p))
5550 {
5551 if (local_p)
5552 sec = mips_elf_tdata (input_bfd)->local_call_stubs[r_symndx];
5553 else
5554 {
5555 /* If both call_stub and call_fp_stub are defined, we can figure
5556 out which one to use by checking which one appears in the input
5557 file. */
5558 if (h->call_stub != NULL && h->call_fp_stub != NULL)
5559 {
5560 asection *o;
5561
5562 sec = NULL;
5563 for (o = input_bfd->sections; o != NULL; o = o->next)
5564 {
5565 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
5566 {
5567 sec = h->call_fp_stub;
5568 break;
5569 }
5570 }
5571 if (sec == NULL)
5572 sec = h->call_stub;
5573 }
5574 else if (h->call_stub != NULL)
5575 sec = h->call_stub;
5576 else
5577 sec = h->call_fp_stub;
5578 }
5579
5580 BFD_ASSERT (sec->size > 0);
5581 symbol = sec->output_section->vma + sec->output_offset;
5582 }
5583 /* If this is a direct call to a PIC function, redirect to the
5584 non-PIC stub. */
5585 else if (h != NULL && h->la25_stub
5586 && mips_elf_relocation_needs_la25_stub (input_bfd, r_type,
5587 target_is_16_bit_code_p))
5588 {
5589 symbol = (h->la25_stub->stub_section->output_section->vma
5590 + h->la25_stub->stub_section->output_offset
5591 + h->la25_stub->offset);
5592 if (ELF_ST_IS_MICROMIPS (h->root.other))
5593 symbol |= 1;
5594 }
5595 /* For direct MIPS16 and microMIPS calls make sure the compressed PLT
5596 entry is used if a standard PLT entry has also been made. In this
5597 case the symbol will have been set by mips_elf_set_plt_sym_value
5598 to point to the standard PLT entry, so redirect to the compressed
5599 one. */
5600 else if ((mips16_branch_reloc_p (r_type)
5601 || micromips_branch_reloc_p (r_type))
5602 && !bfd_link_relocatable (info)
5603 && h != NULL
5604 && h->use_plt_entry
5605 && h->root.plt.plist->comp_offset != MINUS_ONE
5606 && h->root.plt.plist->mips_offset != MINUS_ONE)
5607 {
5608 bfd_boolean micromips_p = MICROMIPS_P (abfd);
5609
5610 sec = htab->root.splt;
5611 symbol = (sec->output_section->vma
5612 + sec->output_offset
5613 + htab->plt_header_size
5614 + htab->plt_mips_offset
5615 + h->root.plt.plist->comp_offset
5616 + 1);
5617
5618 target_is_16_bit_code_p = !micromips_p;
5619 target_is_micromips_code_p = micromips_p;
5620 }
5621
5622 /* Make sure MIPS16 and microMIPS are not used together. */
5623 if ((mips16_branch_reloc_p (r_type) && target_is_micromips_code_p)
5624 || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
5625 {
5626 _bfd_error_handler
5627 (_("MIPS16 and microMIPS functions cannot call each other"));
5628 return bfd_reloc_notsupported;
5629 }
5630
5631 /* Calls from 16-bit code to 32-bit code and vice versa require the
5632 mode change. However, we can ignore calls to undefined weak symbols,
5633 which should never be executed at runtime. This exception is important
5634 because the assembly writer may have "known" that any definition of the
5635 symbol would be 16-bit code, and that direct jumps were therefore
5636 acceptable. */
5637 *cross_mode_jump_p = (!bfd_link_relocatable (info)
5638 && !(h && h->root.root.type == bfd_link_hash_undefweak)
5639 && ((mips16_branch_reloc_p (r_type)
5640 && !target_is_16_bit_code_p)
5641 || (micromips_branch_reloc_p (r_type)
5642 && !target_is_micromips_code_p)
5643 || ((branch_reloc_p (r_type)
5644 || r_type == R_MIPS_JALR)
5645 && (target_is_16_bit_code_p
5646 || target_is_micromips_code_p))));
5647
5648 local_p = (h == NULL || mips_use_local_got_p (info, h));
5649
5650 gp0 = _bfd_get_gp_value (input_bfd);
5651 gp = _bfd_get_gp_value (abfd);
5652 if (htab->got_info)
5653 gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
5654
5655 if (gnu_local_gp_p)
5656 symbol = gp;
5657
5658 /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5659 to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the
5660 corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. */
5661 if (got_page_reloc_p (r_type) && !local_p)
5662 {
5663 r_type = (micromips_reloc_p (r_type)
5664 ? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP);
5665 addend = 0;
5666 }
5667
5668 /* If we haven't already determined the GOT offset, and we're going
5669 to need it, get it now. */
5670 switch (r_type)
5671 {
5672 case R_MIPS16_CALL16:
5673 case R_MIPS16_GOT16:
5674 case R_MIPS_CALL16:
5675 case R_MIPS_GOT16:
5676 case R_MIPS_GOT_DISP:
5677 case R_MIPS_GOT_HI16:
5678 case R_MIPS_CALL_HI16:
5679 case R_MIPS_GOT_LO16:
5680 case R_MIPS_CALL_LO16:
5681 case R_MICROMIPS_CALL16:
5682 case R_MICROMIPS_GOT16:
5683 case R_MICROMIPS_GOT_DISP:
5684 case R_MICROMIPS_GOT_HI16:
5685 case R_MICROMIPS_CALL_HI16:
5686 case R_MICROMIPS_GOT_LO16:
5687 case R_MICROMIPS_CALL_LO16:
5688 case R_MIPS_TLS_GD:
5689 case R_MIPS_TLS_GOTTPREL:
5690 case R_MIPS_TLS_LDM:
5691 case R_MIPS16_TLS_GD:
5692 case R_MIPS16_TLS_GOTTPREL:
5693 case R_MIPS16_TLS_LDM:
5694 case R_MICROMIPS_TLS_GD:
5695 case R_MICROMIPS_TLS_GOTTPREL:
5696 case R_MICROMIPS_TLS_LDM:
5697 /* Find the index into the GOT where this value is located. */
5698 if (tls_ldm_reloc_p (r_type))
5699 {
5700 g = mips_elf_local_got_index (abfd, input_bfd, info,
5701 0, 0, NULL, r_type);
5702 if (g == MINUS_ONE)
5703 return bfd_reloc_outofrange;
5704 }
5705 else if (!local_p)
5706 {
5707 /* On VxWorks, CALL relocations should refer to the .got.plt
5708 entry, which is initialized to point at the PLT stub. */
5709 if (htab->is_vxworks
5710 && (call_hi16_reloc_p (r_type)
5711 || call_lo16_reloc_p (r_type)
5712 || call16_reloc_p (r_type)))
5713 {
5714 BFD_ASSERT (addend == 0);
5715 BFD_ASSERT (h->root.needs_plt);
5716 g = mips_elf_gotplt_index (info, &h->root);
5717 }
5718 else
5719 {
5720 BFD_ASSERT (addend == 0);
5721 g = mips_elf_global_got_index (abfd, info, input_bfd,
5722 &h->root, r_type);
5723 if (!TLS_RELOC_P (r_type)
5724 && !elf_hash_table (info)->dynamic_sections_created)
5725 /* This is a static link. We must initialize the GOT entry. */
5726 MIPS_ELF_PUT_WORD (dynobj, symbol, htab->root.sgot->contents + g);
5727 }
5728 }
5729 else if (!htab->is_vxworks
5730 && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
5731 /* The calculation below does not involve "g". */
5732 break;
5733 else
5734 {
5735 g = mips_elf_local_got_index (abfd, input_bfd, info,
5736 symbol + addend, r_symndx, h, r_type);
5737 if (g == MINUS_ONE)
5738 return bfd_reloc_outofrange;
5739 }
5740
5741 /* Convert GOT indices to actual offsets. */
5742 g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
5743 break;
5744 }
5745
5746 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5747 symbols are resolved by the loader. Add them to .rela.dyn. */
5748 if (h != NULL && is_gott_symbol (info, &h->root))
5749 {
5750 Elf_Internal_Rela outrel;
5751 bfd_byte *loc;
5752 asection *s;
5753
5754 s = mips_elf_rel_dyn_section (info, FALSE);
5755 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5756
5757 outrel.r_offset = (input_section->output_section->vma
5758 + input_section->output_offset
5759 + relocation->r_offset);
5760 outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
5761 outrel.r_addend = addend;
5762 bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
5763
5764 /* If we've written this relocation for a readonly section,
5765 we need to set DF_TEXTREL again, so that we do not delete the
5766 DT_TEXTREL tag. */
5767 if (MIPS_ELF_READONLY_SECTION (input_section))
5768 info->flags |= DF_TEXTREL;
5769
5770 *valuep = 0;
5771 return bfd_reloc_ok;
5772 }
5773
5774 /* Figure out what kind of relocation is being performed. */
5775 switch (r_type)
5776 {
5777 case R_MIPS_NONE:
5778 return bfd_reloc_continue;
5779
5780 case R_MIPS_16:
5781 if (howto->partial_inplace)
5782 addend = _bfd_mips_elf_sign_extend (addend, 16);
5783 value = symbol + addend;
5784 overflowed_p = mips_elf_overflow_p (value, 16);
5785 break;
5786
5787 case R_MIPS_32:
5788 case R_MIPS_REL32:
5789 case R_MIPS_64:
5790 if ((bfd_link_pic (info)
5791 || (htab->root.dynamic_sections_created
5792 && h != NULL
5793 && h->root.def_dynamic
5794 && !h->root.def_regular
5795 && !h->has_static_relocs))
5796 && r_symndx != STN_UNDEF
5797 && (h == NULL
5798 || h->root.root.type != bfd_link_hash_undefweak
5799 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5800 && (input_section->flags & SEC_ALLOC) != 0)
5801 {
5802 /* If we're creating a shared library, then we can't know
5803 where the symbol will end up. So, we create a relocation
5804 record in the output, and leave the job up to the dynamic
5805 linker. We must do the same for executable references to
5806 shared library symbols, unless we've decided to use copy
5807 relocs or PLTs instead. */
5808 value = addend;
5809 if (!mips_elf_create_dynamic_relocation (abfd,
5810 info,
5811 relocation,
5812 h,
5813 sec,
5814 symbol,
5815 &value,
5816 input_section))
5817 return bfd_reloc_undefined;
5818 }
5819 else
5820 {
5821 if (r_type != R_MIPS_REL32)
5822 value = symbol + addend;
5823 else
5824 value = addend;
5825 }
5826 value &= howto->dst_mask;
5827 break;
5828
5829 case R_MIPS_PC32:
5830 value = symbol + addend - p;
5831 value &= howto->dst_mask;
5832 break;
5833
5834 case R_MIPS16_26:
5835 /* The calculation for R_MIPS16_26 is just the same as for an
5836 R_MIPS_26. It's only the storage of the relocated field into
5837 the output file that's different. That's handled in
5838 mips_elf_perform_relocation. So, we just fall through to the
5839 R_MIPS_26 case here. */
5840 case R_MIPS_26:
5841 case R_MICROMIPS_26_S1:
5842 {
5843 unsigned int shift;
5844
5845 /* Shift is 2, unusually, for microMIPS JALX. */
5846 shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2;
5847
5848 if (howto->partial_inplace && !section_p)
5849 value = _bfd_mips_elf_sign_extend (addend, 26 + shift);
5850 else
5851 value = addend;
5852 value += symbol;
5853
5854 /* Make sure the target of a jump is suitably aligned. Bit 0 must
5855 be the correct ISA mode selector except for weak undefined
5856 symbols. */
5857 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5858 && (*cross_mode_jump_p
5859 ? (value & 3) != (r_type == R_MIPS_26)
5860 : (value & ((1 << shift) - 1)) != (r_type != R_MIPS_26)))
5861 return bfd_reloc_outofrange;
5862
5863 value >>= shift;
5864 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5865 overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift));
5866 value &= howto->dst_mask;
5867 }
5868 break;
5869
5870 case R_MIPS_TLS_DTPREL_HI16:
5871 case R_MIPS16_TLS_DTPREL_HI16:
5872 case R_MICROMIPS_TLS_DTPREL_HI16:
5873 value = (mips_elf_high (addend + symbol - dtprel_base (info))
5874 & howto->dst_mask);
5875 break;
5876
5877 case R_MIPS_TLS_DTPREL_LO16:
5878 case R_MIPS_TLS_DTPREL32:
5879 case R_MIPS_TLS_DTPREL64:
5880 case R_MIPS16_TLS_DTPREL_LO16:
5881 case R_MICROMIPS_TLS_DTPREL_LO16:
5882 value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
5883 break;
5884
5885 case R_MIPS_TLS_TPREL_HI16:
5886 case R_MIPS16_TLS_TPREL_HI16:
5887 case R_MICROMIPS_TLS_TPREL_HI16:
5888 value = (mips_elf_high (addend + symbol - tprel_base (info))
5889 & howto->dst_mask);
5890 break;
5891
5892 case R_MIPS_TLS_TPREL_LO16:
5893 case R_MIPS_TLS_TPREL32:
5894 case R_MIPS_TLS_TPREL64:
5895 case R_MIPS16_TLS_TPREL_LO16:
5896 case R_MICROMIPS_TLS_TPREL_LO16:
5897 value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
5898 break;
5899
5900 case R_MIPS_HI16:
5901 case R_MIPS16_HI16:
5902 case R_MICROMIPS_HI16:
5903 if (!gp_disp_p)
5904 {
5905 value = mips_elf_high (addend + symbol);
5906 value &= howto->dst_mask;
5907 }
5908 else
5909 {
5910 /* For MIPS16 ABI code we generate this sequence
5911 0: li $v0,%hi(_gp_disp)
5912 4: addiupc $v1,%lo(_gp_disp)
5913 8: sll $v0,16
5914 12: addu $v0,$v1
5915 14: move $gp,$v0
5916 So the offsets of hi and lo relocs are the same, but the
5917 base $pc is that used by the ADDIUPC instruction at $t9 + 4.
5918 ADDIUPC clears the low two bits of the instruction address,
5919 so the base is ($t9 + 4) & ~3. */
5920 if (r_type == R_MIPS16_HI16)
5921 value = mips_elf_high (addend + gp - ((p + 4) & ~(bfd_vma) 0x3));
5922 /* The microMIPS .cpload sequence uses the same assembly
5923 instructions as the traditional psABI version, but the
5924 incoming $t9 has the low bit set. */
5925 else if (r_type == R_MICROMIPS_HI16)
5926 value = mips_elf_high (addend + gp - p - 1);
5927 else
5928 value = mips_elf_high (addend + gp - p);
5929 }
5930 break;
5931
5932 case R_MIPS_LO16:
5933 case R_MIPS16_LO16:
5934 case R_MICROMIPS_LO16:
5935 case R_MICROMIPS_HI0_LO16:
5936 if (!gp_disp_p)
5937 value = (symbol + addend) & howto->dst_mask;
5938 else
5939 {
5940 /* See the comment for R_MIPS16_HI16 above for the reason
5941 for this conditional. */
5942 if (r_type == R_MIPS16_LO16)
5943 value = addend + gp - (p & ~(bfd_vma) 0x3);
5944 else if (r_type == R_MICROMIPS_LO16
5945 || r_type == R_MICROMIPS_HI0_LO16)
5946 value = addend + gp - p + 3;
5947 else
5948 value = addend + gp - p + 4;
5949 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5950 for overflow. But, on, say, IRIX5, relocations against
5951 _gp_disp are normally generated from the .cpload
5952 pseudo-op. It generates code that normally looks like
5953 this:
5954
5955 lui $gp,%hi(_gp_disp)
5956 addiu $gp,$gp,%lo(_gp_disp)
5957 addu $gp,$gp,$t9
5958
5959 Here $t9 holds the address of the function being called,
5960 as required by the MIPS ELF ABI. The R_MIPS_LO16
5961 relocation can easily overflow in this situation, but the
5962 R_MIPS_HI16 relocation will handle the overflow.
5963 Therefore, we consider this a bug in the MIPS ABI, and do
5964 not check for overflow here. */
5965 }
5966 break;
5967
5968 case R_MIPS_LITERAL:
5969 case R_MICROMIPS_LITERAL:
5970 /* Because we don't merge literal sections, we can handle this
5971 just like R_MIPS_GPREL16. In the long run, we should merge
5972 shared literals, and then we will need to additional work
5973 here. */
5974
5975 /* Fall through. */
5976
5977 case R_MIPS16_GPREL:
5978 /* The R_MIPS16_GPREL performs the same calculation as
5979 R_MIPS_GPREL16, but stores the relocated bits in a different
5980 order. We don't need to do anything special here; the
5981 differences are handled in mips_elf_perform_relocation. */
5982 case R_MIPS_GPREL16:
5983 case R_MICROMIPS_GPREL7_S2:
5984 case R_MICROMIPS_GPREL16:
5985 /* Only sign-extend the addend if it was extracted from the
5986 instruction. If the addend was separate, leave it alone,
5987 otherwise we may lose significant bits. */
5988 if (howto->partial_inplace)
5989 addend = _bfd_mips_elf_sign_extend (addend, 16);
5990 value = symbol + addend - gp;
5991 /* If the symbol was local, any earlier relocatable links will
5992 have adjusted its addend with the gp offset, so compensate
5993 for that now. Don't do it for symbols forced local in this
5994 link, though, since they won't have had the gp offset applied
5995 to them before. */
5996 if (was_local_p)
5997 value += gp0;
5998 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
5999 overflowed_p = mips_elf_overflow_p (value, 16);
6000 break;
6001
6002 case R_MIPS16_GOT16:
6003 case R_MIPS16_CALL16:
6004 case R_MIPS_GOT16:
6005 case R_MIPS_CALL16:
6006 case R_MICROMIPS_GOT16:
6007 case R_MICROMIPS_CALL16:
6008 /* VxWorks does not have separate local and global semantics for
6009 R_MIPS*_GOT16; every relocation evaluates to "G". */
6010 if (!htab->is_vxworks && local_p)
6011 {
6012 value = mips_elf_got16_entry (abfd, input_bfd, info,
6013 symbol + addend, !was_local_p);
6014 if (value == MINUS_ONE)
6015 return bfd_reloc_outofrange;
6016 value
6017 = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
6018 overflowed_p = mips_elf_overflow_p (value, 16);
6019 break;
6020 }
6021
6022 /* Fall through. */
6023
6024 case R_MIPS_TLS_GD:
6025 case R_MIPS_TLS_GOTTPREL:
6026 case R_MIPS_TLS_LDM:
6027 case R_MIPS_GOT_DISP:
6028 case R_MIPS16_TLS_GD:
6029 case R_MIPS16_TLS_GOTTPREL:
6030 case R_MIPS16_TLS_LDM:
6031 case R_MICROMIPS_TLS_GD:
6032 case R_MICROMIPS_TLS_GOTTPREL:
6033 case R_MICROMIPS_TLS_LDM:
6034 case R_MICROMIPS_GOT_DISP:
6035 value = g;
6036 overflowed_p = mips_elf_overflow_p (value, 16);
6037 break;
6038
6039 case R_MIPS_GPREL32:
6040 value = (addend + symbol + gp0 - gp);
6041 if (!save_addend)
6042 value &= howto->dst_mask;
6043 break;
6044
6045 case R_MIPS_PC16:
6046 case R_MIPS_GNU_REL16_S2:
6047 if (howto->partial_inplace)
6048 addend = _bfd_mips_elf_sign_extend (addend, 18);
6049
6050 /* No need to exclude weak undefined symbols here as they resolve
6051 to 0 and never set `*cross_mode_jump_p', so this alignment check
6052 will never trigger for them. */
6053 if (*cross_mode_jump_p
6054 ? ((symbol + addend) & 3) != 1
6055 : ((symbol + addend) & 3) != 0)
6056 return bfd_reloc_outofrange;
6057
6058 value = symbol + addend - p;
6059 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6060 overflowed_p = mips_elf_overflow_p (value, 18);
6061 value >>= howto->rightshift;
6062 value &= howto->dst_mask;
6063 break;
6064
6065 case R_MIPS16_PC16_S1:
6066 if (howto->partial_inplace)
6067 addend = _bfd_mips_elf_sign_extend (addend, 17);
6068
6069 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6070 && (*cross_mode_jump_p
6071 ? ((symbol + addend) & 3) != 0
6072 : ((symbol + addend) & 1) == 0))
6073 return bfd_reloc_outofrange;
6074
6075 value = symbol + addend - p;
6076 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6077 overflowed_p = mips_elf_overflow_p (value, 17);
6078 value >>= howto->rightshift;
6079 value &= howto->dst_mask;
6080 break;
6081
6082 case R_MIPS_PC21_S2:
6083 if (howto->partial_inplace)
6084 addend = _bfd_mips_elf_sign_extend (addend, 23);
6085
6086 if ((symbol + addend) & 3)
6087 return bfd_reloc_outofrange;
6088
6089 value = symbol + addend - p;
6090 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6091 overflowed_p = mips_elf_overflow_p (value, 23);
6092 value >>= howto->rightshift;
6093 value &= howto->dst_mask;
6094 break;
6095
6096 case R_MIPS_PC26_S2:
6097 if (howto->partial_inplace)
6098 addend = _bfd_mips_elf_sign_extend (addend, 28);
6099
6100 if ((symbol + addend) & 3)
6101 return bfd_reloc_outofrange;
6102
6103 value = symbol + addend - p;
6104 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6105 overflowed_p = mips_elf_overflow_p (value, 28);
6106 value >>= howto->rightshift;
6107 value &= howto->dst_mask;
6108 break;
6109
6110 case R_MIPS_PC18_S3:
6111 if (howto->partial_inplace)
6112 addend = _bfd_mips_elf_sign_extend (addend, 21);
6113
6114 if ((symbol + addend) & 7)
6115 return bfd_reloc_outofrange;
6116
6117 value = symbol + addend - ((p | 7) ^ 7);
6118 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6119 overflowed_p = mips_elf_overflow_p (value, 21);
6120 value >>= howto->rightshift;
6121 value &= howto->dst_mask;
6122 break;
6123
6124 case R_MIPS_PC19_S2:
6125 if (howto->partial_inplace)
6126 addend = _bfd_mips_elf_sign_extend (addend, 21);
6127
6128 if ((symbol + addend) & 3)
6129 return bfd_reloc_outofrange;
6130
6131 value = symbol + addend - p;
6132 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6133 overflowed_p = mips_elf_overflow_p (value, 21);
6134 value >>= howto->rightshift;
6135 value &= howto->dst_mask;
6136 break;
6137
6138 case R_MIPS_PCHI16:
6139 value = mips_elf_high (symbol + addend - p);
6140 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6141 overflowed_p = mips_elf_overflow_p (value, 16);
6142 value &= howto->dst_mask;
6143 break;
6144
6145 case R_MIPS_PCLO16:
6146 if (howto->partial_inplace)
6147 addend = _bfd_mips_elf_sign_extend (addend, 16);
6148 value = symbol + addend - p;
6149 value &= howto->dst_mask;
6150 break;
6151
6152 case R_MICROMIPS_PC7_S1:
6153 if (howto->partial_inplace)
6154 addend = _bfd_mips_elf_sign_extend (addend, 8);
6155
6156 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6157 && (*cross_mode_jump_p
6158 ? ((symbol + addend + 2) & 3) != 0
6159 : ((symbol + addend + 2) & 1) == 0))
6160 return bfd_reloc_outofrange;
6161
6162 value = symbol + addend - p;
6163 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6164 overflowed_p = mips_elf_overflow_p (value, 8);
6165 value >>= howto->rightshift;
6166 value &= howto->dst_mask;
6167 break;
6168
6169 case R_MICROMIPS_PC10_S1:
6170 if (howto->partial_inplace)
6171 addend = _bfd_mips_elf_sign_extend (addend, 11);
6172
6173 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6174 && (*cross_mode_jump_p
6175 ? ((symbol + addend + 2) & 3) != 0
6176 : ((symbol + addend + 2) & 1) == 0))
6177 return bfd_reloc_outofrange;
6178
6179 value = symbol + addend - p;
6180 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6181 overflowed_p = mips_elf_overflow_p (value, 11);
6182 value >>= howto->rightshift;
6183 value &= howto->dst_mask;
6184 break;
6185
6186 case R_MICROMIPS_PC16_S1:
6187 if (howto->partial_inplace)
6188 addend = _bfd_mips_elf_sign_extend (addend, 17);
6189
6190 if ((was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6191 && (*cross_mode_jump_p
6192 ? ((symbol + addend) & 3) != 0
6193 : ((symbol + addend) & 1) == 0))
6194 return bfd_reloc_outofrange;
6195
6196 value = symbol + addend - p;
6197 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6198 overflowed_p = mips_elf_overflow_p (value, 17);
6199 value >>= howto->rightshift;
6200 value &= howto->dst_mask;
6201 break;
6202
6203 case R_MICROMIPS_PC23_S2:
6204 if (howto->partial_inplace)
6205 addend = _bfd_mips_elf_sign_extend (addend, 25);
6206 value = symbol + addend - ((p | 3) ^ 3);
6207 if (was_local_p || h->root.root.type != bfd_link_hash_undefweak)
6208 overflowed_p = mips_elf_overflow_p (value, 25);
6209 value >>= howto->rightshift;
6210 value &= howto->dst_mask;
6211 break;
6212
6213 case R_MIPS_GOT_HI16:
6214 case R_MIPS_CALL_HI16:
6215 case R_MICROMIPS_GOT_HI16:
6216 case R_MICROMIPS_CALL_HI16:
6217 /* We're allowed to handle these two relocations identically.
6218 The dynamic linker is allowed to handle the CALL relocations
6219 differently by creating a lazy evaluation stub. */
6220 value = g;
6221 value = mips_elf_high (value);
6222 value &= howto->dst_mask;
6223 break;
6224
6225 case R_MIPS_GOT_LO16:
6226 case R_MIPS_CALL_LO16:
6227 case R_MICROMIPS_GOT_LO16:
6228 case R_MICROMIPS_CALL_LO16:
6229 value = g & howto->dst_mask;
6230 break;
6231
6232 case R_MIPS_GOT_PAGE:
6233 case R_MICROMIPS_GOT_PAGE:
6234 value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
6235 if (value == MINUS_ONE)
6236 return bfd_reloc_outofrange;
6237 value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
6238 overflowed_p = mips_elf_overflow_p (value, 16);
6239 break;
6240
6241 case R_MIPS_GOT_OFST:
6242 case R_MICROMIPS_GOT_OFST:
6243 if (local_p)
6244 mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
6245 else
6246 value = addend;
6247 overflowed_p = mips_elf_overflow_p (value, 16);
6248 break;
6249
6250 case R_MIPS_SUB:
6251 case R_MICROMIPS_SUB:
6252 value = symbol - addend;
6253 value &= howto->dst_mask;
6254 break;
6255
6256 case R_MIPS_HIGHER:
6257 case R_MICROMIPS_HIGHER:
6258 value = mips_elf_higher (addend + symbol);
6259 value &= howto->dst_mask;
6260 break;
6261
6262 case R_MIPS_HIGHEST:
6263 case R_MICROMIPS_HIGHEST:
6264 value = mips_elf_highest (addend + symbol);
6265 value &= howto->dst_mask;
6266 break;
6267
6268 case R_MIPS_SCN_DISP:
6269 case R_MICROMIPS_SCN_DISP:
6270 value = symbol + addend - sec->output_offset;
6271 value &= howto->dst_mask;
6272 break;
6273
6274 case R_MIPS_JALR:
6275 case R_MICROMIPS_JALR:
6276 /* This relocation is only a hint. In some cases, we optimize
6277 it into a bal instruction. But we don't try to optimize
6278 when the symbol does not resolve locally. */
6279 if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
6280 return bfd_reloc_continue;
6281 /* We can't optimize cross-mode jumps either. */
6282 if (*cross_mode_jump_p)
6283 return bfd_reloc_continue;
6284 value = symbol + addend;
6285 /* Neither we can non-instruction-aligned targets. */
6286 if (r_type == R_MIPS_JALR ? (value & 3) != 0 : (value & 1) == 0)
6287 return bfd_reloc_continue;
6288 break;
6289
6290 case R_MIPS_PJUMP:
6291 case R_MIPS_GNU_VTINHERIT:
6292 case R_MIPS_GNU_VTENTRY:
6293 /* We don't do anything with these at present. */
6294 return bfd_reloc_continue;
6295
6296 default:
6297 /* An unrecognized relocation type. */
6298 return bfd_reloc_notsupported;
6299 }
6300
6301 /* Store the VALUE for our caller. */
6302 *valuep = value;
6303 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
6304 }
6305
6306 /* Obtain the field relocated by RELOCATION. */
6307
6308 static bfd_vma
6309 mips_elf_obtain_contents (reloc_howto_type *howto,
6310 const Elf_Internal_Rela *relocation,
6311 bfd *input_bfd, bfd_byte *contents)
6312 {
6313 bfd_vma x = 0;
6314 bfd_byte *location = contents + relocation->r_offset;
6315 unsigned int size = bfd_get_reloc_size (howto);
6316
6317 /* Obtain the bytes. */
6318 if (size != 0)
6319 x = bfd_get (8 * size, input_bfd, location);
6320
6321 return x;
6322 }
6323
6324 /* It has been determined that the result of the RELOCATION is the
6325 VALUE. Use HOWTO to place VALUE into the output file at the
6326 appropriate position. The SECTION is the section to which the
6327 relocation applies.
6328 CROSS_MODE_JUMP_P is true if the relocation field
6329 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
6330
6331 Returns FALSE if anything goes wrong. */
6332
6333 static bfd_boolean
6334 mips_elf_perform_relocation (struct bfd_link_info *info,
6335 reloc_howto_type *howto,
6336 const Elf_Internal_Rela *relocation,
6337 bfd_vma value, bfd *input_bfd,
6338 asection *input_section, bfd_byte *contents,
6339 bfd_boolean cross_mode_jump_p)
6340 {
6341 bfd_vma x;
6342 bfd_byte *location;
6343 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
6344 unsigned int size;
6345
6346 /* Figure out where the relocation is occurring. */
6347 location = contents + relocation->r_offset;
6348
6349 _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
6350
6351 /* Obtain the current value. */
6352 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
6353
6354 /* Clear the field we are setting. */
6355 x &= ~howto->dst_mask;
6356
6357 /* Set the field. */
6358 x |= (value & howto->dst_mask);
6359
6360 /* Detect incorrect JALX usage. If required, turn JAL or BAL into JALX. */
6361 if (!cross_mode_jump_p && jal_reloc_p (r_type))
6362 {
6363 bfd_vma opcode = x >> 26;
6364
6365 if (r_type == R_MIPS16_26 ? opcode == 0x7
6366 : r_type == R_MICROMIPS_26_S1 ? opcode == 0x3c
6367 : opcode == 0x1d)
6368 {
6369 info->callbacks->einfo
6370 (_("%X%H: Unsupported JALX to the same ISA mode\n"),
6371 input_bfd, input_section, relocation->r_offset);
6372 return TRUE;
6373 }
6374 }
6375 if (cross_mode_jump_p && jal_reloc_p (r_type))
6376 {
6377 bfd_boolean ok;
6378 bfd_vma opcode = x >> 26;
6379 bfd_vma jalx_opcode;
6380
6381 /* Check to see if the opcode is already JAL or JALX. */
6382 if (r_type == R_MIPS16_26)
6383 {
6384 ok = ((opcode == 0x6) || (opcode == 0x7));
6385 jalx_opcode = 0x7;
6386 }
6387 else if (r_type == R_MICROMIPS_26_S1)
6388 {
6389 ok = ((opcode == 0x3d) || (opcode == 0x3c));
6390 jalx_opcode = 0x3c;
6391 }
6392 else
6393 {
6394 ok = ((opcode == 0x3) || (opcode == 0x1d));
6395 jalx_opcode = 0x1d;
6396 }
6397
6398 /* If the opcode is not JAL or JALX, there's a problem. We cannot
6399 convert J or JALS to JALX. */
6400 if (!ok)
6401 {
6402 info->callbacks->einfo
6403 (_("%X%H: Unsupported jump between ISA modes; "
6404 "consider recompiling with interlinking enabled\n"),
6405 input_bfd, input_section, relocation->r_offset);
6406 return TRUE;
6407 }
6408
6409 /* Make this the JALX opcode. */
6410 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
6411 }
6412 else if (cross_mode_jump_p && b_reloc_p (r_type))
6413 {
6414 bfd_boolean ok = FALSE;
6415 bfd_vma opcode = x >> 16;
6416 bfd_vma jalx_opcode = 0;
6417 bfd_vma addr;
6418 bfd_vma dest;
6419
6420 if (r_type == R_MICROMIPS_PC16_S1)
6421 {
6422 ok = opcode == 0x4060;
6423 jalx_opcode = 0x3c;
6424 value <<= 1;
6425 }
6426 else if (r_type == R_MIPS_PC16 || r_type == R_MIPS_GNU_REL16_S2)
6427 {
6428 ok = opcode == 0x411;
6429 jalx_opcode = 0x1d;
6430 value <<= 2;
6431 }
6432
6433 if (ok && !bfd_link_pic (info))
6434 {
6435 addr = (input_section->output_section->vma
6436 + input_section->output_offset
6437 + relocation->r_offset
6438 + 4);
6439 dest = addr + (((value & 0x3ffff) ^ 0x20000) - 0x20000);
6440
6441 if ((addr >> 28) << 28 != (dest >> 28) << 28)
6442 {
6443 info->callbacks->einfo
6444 (_("%X%H: Cannot convert branch between ISA modes "
6445 "to JALX: relocation out of range\n"),
6446 input_bfd, input_section, relocation->r_offset);
6447 return TRUE;
6448 }
6449
6450 /* Make this the JALX opcode. */
6451 x = ((dest >> 2) & 0x3ffffff) | jalx_opcode << 26;
6452 }
6453 else if (!mips_elf_hash_table (info)->ignore_branch_isa)
6454 {
6455 info->callbacks->einfo
6456 (_("%X%H: Unsupported branch between ISA modes\n"),
6457 input_bfd, input_section, relocation->r_offset);
6458 return TRUE;
6459 }
6460 }
6461
6462 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
6463 range. */
6464 if (!bfd_link_relocatable (info)
6465 && !cross_mode_jump_p
6466 && ((JAL_TO_BAL_P (input_bfd)
6467 && r_type == R_MIPS_26
6468 && (x >> 26) == 0x3) /* jal addr */
6469 || (JALR_TO_BAL_P (input_bfd)
6470 && r_type == R_MIPS_JALR
6471 && x == 0x0320f809) /* jalr t9 */
6472 || (JR_TO_B_P (input_bfd)
6473 && r_type == R_MIPS_JALR
6474 && x == 0x03200008))) /* jr t9 */
6475 {
6476 bfd_vma addr;
6477 bfd_vma dest;
6478 bfd_signed_vma off;
6479
6480 addr = (input_section->output_section->vma
6481 + input_section->output_offset
6482 + relocation->r_offset
6483 + 4);
6484 if (r_type == R_MIPS_26)
6485 dest = (value << 2) | ((addr >> 28) << 28);
6486 else
6487 dest = value;
6488 off = dest - addr;
6489 if (off <= 0x1ffff && off >= -0x20000)
6490 {
6491 if (x == 0x03200008) /* jr t9 */
6492 x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff); /* b addr */
6493 else
6494 x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff); /* bal addr */
6495 }
6496 }
6497
6498 /* Put the value into the output. */
6499 size = bfd_get_reloc_size (howto);
6500 if (size != 0)
6501 bfd_put (8 * size, input_bfd, x, location);
6502
6503 _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !bfd_link_relocatable (info),
6504 location);
6505
6506 return TRUE;
6507 }
6508 \f
6509 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
6510 is the original relocation, which is now being transformed into a
6511 dynamic relocation. The ADDENDP is adjusted if necessary; the
6512 caller should store the result in place of the original addend. */
6513
6514 static bfd_boolean
6515 mips_elf_create_dynamic_relocation (bfd *output_bfd,
6516 struct bfd_link_info *info,
6517 const Elf_Internal_Rela *rel,
6518 struct mips_elf_link_hash_entry *h,
6519 asection *sec, bfd_vma symbol,
6520 bfd_vma *addendp, asection *input_section)
6521 {
6522 Elf_Internal_Rela outrel[3];
6523 asection *sreloc;
6524 bfd *dynobj;
6525 int r_type;
6526 long indx;
6527 bfd_boolean defined_p;
6528 struct mips_elf_link_hash_table *htab;
6529
6530 htab = mips_elf_hash_table (info);
6531 BFD_ASSERT (htab != NULL);
6532
6533 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6534 dynobj = elf_hash_table (info)->dynobj;
6535 sreloc = mips_elf_rel_dyn_section (info, FALSE);
6536 BFD_ASSERT (sreloc != NULL);
6537 BFD_ASSERT (sreloc->contents != NULL);
6538 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
6539 < sreloc->size);
6540
6541 outrel[0].r_offset =
6542 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
6543 if (ABI_64_P (output_bfd))
6544 {
6545 outrel[1].r_offset =
6546 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
6547 outrel[2].r_offset =
6548 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
6549 }
6550
6551 if (outrel[0].r_offset == MINUS_ONE)
6552 /* The relocation field has been deleted. */
6553 return TRUE;
6554
6555 if (outrel[0].r_offset == MINUS_TWO)
6556 {
6557 /* The relocation field has been converted into a relative value of
6558 some sort. Functions like _bfd_elf_write_section_eh_frame expect
6559 the field to be fully relocated, so add in the symbol's value. */
6560 *addendp += symbol;
6561 return TRUE;
6562 }
6563
6564 /* We must now calculate the dynamic symbol table index to use
6565 in the relocation. */
6566 if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root))
6567 {
6568 BFD_ASSERT (htab->is_vxworks || h->global_got_area != GGA_NONE);
6569 indx = h->root.dynindx;
6570 if (SGI_COMPAT (output_bfd))
6571 defined_p = h->root.def_regular;
6572 else
6573 /* ??? glibc's ld.so just adds the final GOT entry to the
6574 relocation field. It therefore treats relocs against
6575 defined symbols in the same way as relocs against
6576 undefined symbols. */
6577 defined_p = FALSE;
6578 }
6579 else
6580 {
6581 if (sec != NULL && bfd_is_abs_section (sec))
6582 indx = 0;
6583 else if (sec == NULL || sec->owner == NULL)
6584 {
6585 bfd_set_error (bfd_error_bad_value);
6586 return FALSE;
6587 }
6588 else
6589 {
6590 indx = elf_section_data (sec->output_section)->dynindx;
6591 if (indx == 0)
6592 {
6593 asection *osec = htab->root.text_index_section;
6594 indx = elf_section_data (osec)->dynindx;
6595 }
6596 if (indx == 0)
6597 abort ();
6598 }
6599
6600 /* Instead of generating a relocation using the section
6601 symbol, we may as well make it a fully relative
6602 relocation. We want to avoid generating relocations to
6603 local symbols because we used to generate them
6604 incorrectly, without adding the original symbol value,
6605 which is mandated by the ABI for section symbols. In
6606 order to give dynamic loaders and applications time to
6607 phase out the incorrect use, we refrain from emitting
6608 section-relative relocations. It's not like they're
6609 useful, after all. This should be a bit more efficient
6610 as well. */
6611 /* ??? Although this behavior is compatible with glibc's ld.so,
6612 the ABI says that relocations against STN_UNDEF should have
6613 a symbol value of 0. Irix rld honors this, so relocations
6614 against STN_UNDEF have no effect. */
6615 if (!SGI_COMPAT (output_bfd))
6616 indx = 0;
6617 defined_p = TRUE;
6618 }
6619
6620 /* If the relocation was previously an absolute relocation and
6621 this symbol will not be referred to by the relocation, we must
6622 adjust it by the value we give it in the dynamic symbol table.
6623 Otherwise leave the job up to the dynamic linker. */
6624 if (defined_p && r_type != R_MIPS_REL32)
6625 *addendp += symbol;
6626
6627 if (htab->is_vxworks)
6628 /* VxWorks uses non-relative relocations for this. */
6629 outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
6630 else
6631 /* The relocation is always an REL32 relocation because we don't
6632 know where the shared library will wind up at load-time. */
6633 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
6634 R_MIPS_REL32);
6635
6636 /* For strict adherence to the ABI specification, we should
6637 generate a R_MIPS_64 relocation record by itself before the
6638 _REL32/_64 record as well, such that the addend is read in as
6639 a 64-bit value (REL32 is a 32-bit relocation, after all).
6640 However, since none of the existing ELF64 MIPS dynamic
6641 loaders seems to care, we don't waste space with these
6642 artificial relocations. If this turns out to not be true,
6643 mips_elf_allocate_dynamic_relocation() should be tweaked so
6644 as to make room for a pair of dynamic relocations per
6645 invocation if ABI_64_P, and here we should generate an
6646 additional relocation record with R_MIPS_64 by itself for a
6647 NULL symbol before this relocation record. */
6648 outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
6649 ABI_64_P (output_bfd)
6650 ? R_MIPS_64
6651 : R_MIPS_NONE);
6652 outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
6653
6654 /* Adjust the output offset of the relocation to reference the
6655 correct location in the output file. */
6656 outrel[0].r_offset += (input_section->output_section->vma
6657 + input_section->output_offset);
6658 outrel[1].r_offset += (input_section->output_section->vma
6659 + input_section->output_offset);
6660 outrel[2].r_offset += (input_section->output_section->vma
6661 + input_section->output_offset);
6662
6663 /* Put the relocation back out. We have to use the special
6664 relocation outputter in the 64-bit case since the 64-bit
6665 relocation format is non-standard. */
6666 if (ABI_64_P (output_bfd))
6667 {
6668 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
6669 (output_bfd, &outrel[0],
6670 (sreloc->contents
6671 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
6672 }
6673 else if (htab->is_vxworks)
6674 {
6675 /* VxWorks uses RELA rather than REL dynamic relocations. */
6676 outrel[0].r_addend = *addendp;
6677 bfd_elf32_swap_reloca_out
6678 (output_bfd, &outrel[0],
6679 (sreloc->contents
6680 + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
6681 }
6682 else
6683 bfd_elf32_swap_reloc_out
6684 (output_bfd, &outrel[0],
6685 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
6686
6687 /* We've now added another relocation. */
6688 ++sreloc->reloc_count;
6689
6690 /* Make sure the output section is writable. The dynamic linker
6691 will be writing to it. */
6692 elf_section_data (input_section->output_section)->this_hdr.sh_flags
6693 |= SHF_WRITE;
6694
6695 /* On IRIX5, make an entry of compact relocation info. */
6696 if (IRIX_COMPAT (output_bfd) == ict_irix5)
6697 {
6698 asection *scpt = bfd_get_linker_section (dynobj, ".compact_rel");
6699 bfd_byte *cr;
6700
6701 if (scpt)
6702 {
6703 Elf32_crinfo cptrel;
6704
6705 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
6706 cptrel.vaddr = (rel->r_offset
6707 + input_section->output_section->vma
6708 + input_section->output_offset);
6709 if (r_type == R_MIPS_REL32)
6710 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
6711 else
6712 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
6713 mips_elf_set_cr_dist2to (cptrel, 0);
6714 cptrel.konst = *addendp;
6715
6716 cr = (scpt->contents
6717 + sizeof (Elf32_External_compact_rel));
6718 mips_elf_set_cr_relvaddr (cptrel, 0);
6719 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
6720 ((Elf32_External_crinfo *) cr
6721 + scpt->reloc_count));
6722 ++scpt->reloc_count;
6723 }
6724 }
6725
6726 /* If we've written this relocation for a readonly section,
6727 we need to set DF_TEXTREL again, so that we do not delete the
6728 DT_TEXTREL tag. */
6729 if (MIPS_ELF_READONLY_SECTION (input_section))
6730 info->flags |= DF_TEXTREL;
6731
6732 return TRUE;
6733 }
6734 \f
6735 /* Return the MACH for a MIPS e_flags value. */
6736
6737 unsigned long
6738 _bfd_elf_mips_mach (flagword flags)
6739 {
6740 switch (flags & EF_MIPS_MACH)
6741 {
6742 case E_MIPS_MACH_3900:
6743 return bfd_mach_mips3900;
6744
6745 case E_MIPS_MACH_4010:
6746 return bfd_mach_mips4010;
6747
6748 case E_MIPS_MACH_4100:
6749 return bfd_mach_mips4100;
6750
6751 case E_MIPS_MACH_4111:
6752 return bfd_mach_mips4111;
6753
6754 case E_MIPS_MACH_4120:
6755 return bfd_mach_mips4120;
6756
6757 case E_MIPS_MACH_4650:
6758 return bfd_mach_mips4650;
6759
6760 case E_MIPS_MACH_5400:
6761 return bfd_mach_mips5400;
6762
6763 case E_MIPS_MACH_5500:
6764 return bfd_mach_mips5500;
6765
6766 case E_MIPS_MACH_5900:
6767 return bfd_mach_mips5900;
6768
6769 case E_MIPS_MACH_9000:
6770 return bfd_mach_mips9000;
6771
6772 case E_MIPS_MACH_SB1:
6773 return bfd_mach_mips_sb1;
6774
6775 case E_MIPS_MACH_LS2E:
6776 return bfd_mach_mips_loongson_2e;
6777
6778 case E_MIPS_MACH_LS2F:
6779 return bfd_mach_mips_loongson_2f;
6780
6781 case E_MIPS_MACH_LS3A:
6782 return bfd_mach_mips_loongson_3a;
6783
6784 case E_MIPS_MACH_OCTEON3:
6785 return bfd_mach_mips_octeon3;
6786
6787 case E_MIPS_MACH_OCTEON2:
6788 return bfd_mach_mips_octeon2;
6789
6790 case E_MIPS_MACH_OCTEON:
6791 return bfd_mach_mips_octeon;
6792
6793 case E_MIPS_MACH_XLR:
6794 return bfd_mach_mips_xlr;
6795
6796 default:
6797 switch (flags & EF_MIPS_ARCH)
6798 {
6799 default:
6800 case E_MIPS_ARCH_1:
6801 return bfd_mach_mips3000;
6802
6803 case E_MIPS_ARCH_2:
6804 return bfd_mach_mips6000;
6805
6806 case E_MIPS_ARCH_3:
6807 return bfd_mach_mips4000;
6808
6809 case E_MIPS_ARCH_4:
6810 return bfd_mach_mips8000;
6811
6812 case E_MIPS_ARCH_5:
6813 return bfd_mach_mips5;
6814
6815 case E_MIPS_ARCH_32:
6816 return bfd_mach_mipsisa32;
6817
6818 case E_MIPS_ARCH_64:
6819 return bfd_mach_mipsisa64;
6820
6821 case E_MIPS_ARCH_32R2:
6822 return bfd_mach_mipsisa32r2;
6823
6824 case E_MIPS_ARCH_64R2:
6825 return bfd_mach_mipsisa64r2;
6826
6827 case E_MIPS_ARCH_32R6:
6828 return bfd_mach_mipsisa32r6;
6829
6830 case E_MIPS_ARCH_64R6:
6831 return bfd_mach_mipsisa64r6;
6832 }
6833 }
6834
6835 return 0;
6836 }
6837
6838 /* Return printable name for ABI. */
6839
6840 static INLINE char *
6841 elf_mips_abi_name (bfd *abfd)
6842 {
6843 flagword flags;
6844
6845 flags = elf_elfheader (abfd)->e_flags;
6846 switch (flags & EF_MIPS_ABI)
6847 {
6848 case 0:
6849 if (ABI_N32_P (abfd))
6850 return "N32";
6851 else if (ABI_64_P (abfd))
6852 return "64";
6853 else
6854 return "none";
6855 case E_MIPS_ABI_O32:
6856 return "O32";
6857 case E_MIPS_ABI_O64:
6858 return "O64";
6859 case E_MIPS_ABI_EABI32:
6860 return "EABI32";
6861 case E_MIPS_ABI_EABI64:
6862 return "EABI64";
6863 default:
6864 return "unknown abi";
6865 }
6866 }
6867 \f
6868 /* MIPS ELF uses two common sections. One is the usual one, and the
6869 other is for small objects. All the small objects are kept
6870 together, and then referenced via the gp pointer, which yields
6871 faster assembler code. This is what we use for the small common
6872 section. This approach is copied from ecoff.c. */
6873 static asection mips_elf_scom_section;
6874 static asymbol mips_elf_scom_symbol;
6875 static asymbol *mips_elf_scom_symbol_ptr;
6876
6877 /* MIPS ELF also uses an acommon section, which represents an
6878 allocated common symbol which may be overridden by a
6879 definition in a shared library. */
6880 static asection mips_elf_acom_section;
6881 static asymbol mips_elf_acom_symbol;
6882 static asymbol *mips_elf_acom_symbol_ptr;
6883
6884 /* This is used for both the 32-bit and the 64-bit ABI. */
6885
6886 void
6887 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
6888 {
6889 elf_symbol_type *elfsym;
6890
6891 /* Handle the special MIPS section numbers that a symbol may use. */
6892 elfsym = (elf_symbol_type *) asym;
6893 switch (elfsym->internal_elf_sym.st_shndx)
6894 {
6895 case SHN_MIPS_ACOMMON:
6896 /* This section is used in a dynamically linked executable file.
6897 It is an allocated common section. The dynamic linker can
6898 either resolve these symbols to something in a shared
6899 library, or it can just leave them here. For our purposes,
6900 we can consider these symbols to be in a new section. */
6901 if (mips_elf_acom_section.name == NULL)
6902 {
6903 /* Initialize the acommon section. */
6904 mips_elf_acom_section.name = ".acommon";
6905 mips_elf_acom_section.flags = SEC_ALLOC;
6906 mips_elf_acom_section.output_section = &mips_elf_acom_section;
6907 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
6908 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
6909 mips_elf_acom_symbol.name = ".acommon";
6910 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
6911 mips_elf_acom_symbol.section = &mips_elf_acom_section;
6912 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
6913 }
6914 asym->section = &mips_elf_acom_section;
6915 break;
6916
6917 case SHN_COMMON:
6918 /* Common symbols less than the GP size are automatically
6919 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
6920 if (asym->value > elf_gp_size (abfd)
6921 || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
6922 || IRIX_COMPAT (abfd) == ict_irix6)
6923 break;
6924 /* Fall through. */
6925 case SHN_MIPS_SCOMMON:
6926 if (mips_elf_scom_section.name == NULL)
6927 {
6928 /* Initialize the small common section. */
6929 mips_elf_scom_section.name = ".scommon";
6930 mips_elf_scom_section.flags = SEC_IS_COMMON;
6931 mips_elf_scom_section.output_section = &mips_elf_scom_section;
6932 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
6933 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
6934 mips_elf_scom_symbol.name = ".scommon";
6935 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
6936 mips_elf_scom_symbol.section = &mips_elf_scom_section;
6937 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
6938 }
6939 asym->section = &mips_elf_scom_section;
6940 asym->value = elfsym->internal_elf_sym.st_size;
6941 break;
6942
6943 case SHN_MIPS_SUNDEFINED:
6944 asym->section = bfd_und_section_ptr;
6945 break;
6946
6947 case SHN_MIPS_TEXT:
6948 {
6949 asection *section = bfd_get_section_by_name (abfd, ".text");
6950
6951 if (section != NULL)
6952 {
6953 asym->section = section;
6954 /* MIPS_TEXT is a bit special, the address is not an offset
6955 to the base of the .text section. So substract the section
6956 base address to make it an offset. */
6957 asym->value -= section->vma;
6958 }
6959 }
6960 break;
6961
6962 case SHN_MIPS_DATA:
6963 {
6964 asection *section = bfd_get_section_by_name (abfd, ".data");
6965
6966 if (section != NULL)
6967 {
6968 asym->section = section;
6969 /* MIPS_DATA is a bit special, the address is not an offset
6970 to the base of the .data section. So substract the section
6971 base address to make it an offset. */
6972 asym->value -= section->vma;
6973 }
6974 }
6975 break;
6976 }
6977
6978 /* If this is an odd-valued function symbol, assume it's a MIPS16
6979 or microMIPS one. */
6980 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
6981 && (asym->value & 1) != 0)
6982 {
6983 asym->value--;
6984 if (MICROMIPS_P (abfd))
6985 elfsym->internal_elf_sym.st_other
6986 = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other);
6987 else
6988 elfsym->internal_elf_sym.st_other
6989 = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
6990 }
6991 }
6992 \f
6993 /* Implement elf_backend_eh_frame_address_size. This differs from
6994 the default in the way it handles EABI64.
6995
6996 EABI64 was originally specified as an LP64 ABI, and that is what
6997 -mabi=eabi normally gives on a 64-bit target. However, gcc has
6998 historically accepted the combination of -mabi=eabi and -mlong32,
6999 and this ILP32 variation has become semi-official over time.
7000 Both forms use elf32 and have pointer-sized FDE addresses.
7001
7002 If an EABI object was generated by GCC 4.0 or above, it will have
7003 an empty .gcc_compiled_longXX section, where XX is the size of longs
7004 in bits. Unfortunately, ILP32 objects generated by earlier compilers
7005 have no special marking to distinguish them from LP64 objects.
7006
7007 We don't want users of the official LP64 ABI to be punished for the
7008 existence of the ILP32 variant, but at the same time, we don't want
7009 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
7010 We therefore take the following approach:
7011
7012 - If ABFD contains a .gcc_compiled_longXX section, use it to
7013 determine the pointer size.
7014
7015 - Otherwise check the type of the first relocation. Assume that
7016 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
7017
7018 - Otherwise punt.
7019
7020 The second check is enough to detect LP64 objects generated by pre-4.0
7021 compilers because, in the kind of output generated by those compilers,
7022 the first relocation will be associated with either a CIE personality
7023 routine or an FDE start address. Furthermore, the compilers never
7024 used a special (non-pointer) encoding for this ABI.
7025
7026 Checking the relocation type should also be safe because there is no
7027 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
7028 did so. */
7029
7030 unsigned int
7031 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
7032 {
7033 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
7034 return 8;
7035 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
7036 {
7037 bfd_boolean long32_p, long64_p;
7038
7039 long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
7040 long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
7041 if (long32_p && long64_p)
7042 return 0;
7043 if (long32_p)
7044 return 4;
7045 if (long64_p)
7046 return 8;
7047
7048 if (sec->reloc_count > 0
7049 && elf_section_data (sec)->relocs != NULL
7050 && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
7051 == R_MIPS_64))
7052 return 8;
7053
7054 return 0;
7055 }
7056 return 4;
7057 }
7058 \f
7059 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
7060 relocations against two unnamed section symbols to resolve to the
7061 same address. For example, if we have code like:
7062
7063 lw $4,%got_disp(.data)($gp)
7064 lw $25,%got_disp(.text)($gp)
7065 jalr $25
7066
7067 then the linker will resolve both relocations to .data and the program
7068 will jump there rather than to .text.
7069
7070 We can work around this problem by giving names to local section symbols.
7071 This is also what the MIPSpro tools do. */
7072
7073 bfd_boolean
7074 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
7075 {
7076 return SGI_COMPAT (abfd);
7077 }
7078 \f
7079 /* Work over a section just before writing it out. This routine is
7080 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
7081 sections that need the SHF_MIPS_GPREL flag by name; there has to be
7082 a better way. */
7083
7084 bfd_boolean
7085 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
7086 {
7087 if (hdr->sh_type == SHT_MIPS_REGINFO
7088 && hdr->sh_size > 0)
7089 {
7090 bfd_byte buf[4];
7091
7092 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
7093 BFD_ASSERT (hdr->contents == NULL);
7094
7095 if (bfd_seek (abfd,
7096 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
7097 SEEK_SET) != 0)
7098 return FALSE;
7099 H_PUT_32 (abfd, elf_gp (abfd), buf);
7100 if (bfd_bwrite (buf, 4, abfd) != 4)
7101 return FALSE;
7102 }
7103
7104 if (hdr->sh_type == SHT_MIPS_OPTIONS
7105 && hdr->bfd_section != NULL
7106 && mips_elf_section_data (hdr->bfd_section) != NULL
7107 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
7108 {
7109 bfd_byte *contents, *l, *lend;
7110
7111 /* We stored the section contents in the tdata field in the
7112 set_section_contents routine. We save the section contents
7113 so that we don't have to read them again.
7114 At this point we know that elf_gp is set, so we can look
7115 through the section contents to see if there is an
7116 ODK_REGINFO structure. */
7117
7118 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
7119 l = contents;
7120 lend = contents + hdr->sh_size;
7121 while (l + sizeof (Elf_External_Options) <= lend)
7122 {
7123 Elf_Internal_Options intopt;
7124
7125 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
7126 &intopt);
7127 if (intopt.size < sizeof (Elf_External_Options))
7128 {
7129 _bfd_error_handler
7130 /* xgettext:c-format */
7131 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
7132 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
7133 break;
7134 }
7135 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
7136 {
7137 bfd_byte buf[8];
7138
7139 if (bfd_seek (abfd,
7140 (hdr->sh_offset
7141 + (l - contents)
7142 + sizeof (Elf_External_Options)
7143 + (sizeof (Elf64_External_RegInfo) - 8)),
7144 SEEK_SET) != 0)
7145 return FALSE;
7146 H_PUT_64 (abfd, elf_gp (abfd), buf);
7147 if (bfd_bwrite (buf, 8, abfd) != 8)
7148 return FALSE;
7149 }
7150 else if (intopt.kind == ODK_REGINFO)
7151 {
7152 bfd_byte buf[4];
7153
7154 if (bfd_seek (abfd,
7155 (hdr->sh_offset
7156 + (l - contents)
7157 + sizeof (Elf_External_Options)
7158 + (sizeof (Elf32_External_RegInfo) - 4)),
7159 SEEK_SET) != 0)
7160 return FALSE;
7161 H_PUT_32 (abfd, elf_gp (abfd), buf);
7162 if (bfd_bwrite (buf, 4, abfd) != 4)
7163 return FALSE;
7164 }
7165 l += intopt.size;
7166 }
7167 }
7168
7169 if (hdr->bfd_section != NULL)
7170 {
7171 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
7172
7173 /* .sbss is not handled specially here because the GNU/Linux
7174 prelinker can convert .sbss from NOBITS to PROGBITS and
7175 changing it back to NOBITS breaks the binary. The entry in
7176 _bfd_mips_elf_special_sections will ensure the correct flags
7177 are set on .sbss if BFD creates it without reading it from an
7178 input file, and without special handling here the flags set
7179 on it in an input file will be followed. */
7180 if (strcmp (name, ".sdata") == 0
7181 || strcmp (name, ".lit8") == 0
7182 || strcmp (name, ".lit4") == 0)
7183 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
7184 else if (strcmp (name, ".srdata") == 0)
7185 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
7186 else if (strcmp (name, ".compact_rel") == 0)
7187 hdr->sh_flags = 0;
7188 else if (strcmp (name, ".rtproc") == 0)
7189 {
7190 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
7191 {
7192 unsigned int adjust;
7193
7194 adjust = hdr->sh_size % hdr->sh_addralign;
7195 if (adjust != 0)
7196 hdr->sh_size += hdr->sh_addralign - adjust;
7197 }
7198 }
7199 }
7200
7201 return TRUE;
7202 }
7203
7204 /* Handle a MIPS specific section when reading an object file. This
7205 is called when elfcode.h finds a section with an unknown type.
7206 This routine supports both the 32-bit and 64-bit ELF ABI.
7207
7208 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
7209 how to. */
7210
7211 bfd_boolean
7212 _bfd_mips_elf_section_from_shdr (bfd *abfd,
7213 Elf_Internal_Shdr *hdr,
7214 const char *name,
7215 int shindex)
7216 {
7217 flagword flags = 0;
7218
7219 /* There ought to be a place to keep ELF backend specific flags, but
7220 at the moment there isn't one. We just keep track of the
7221 sections by their name, instead. Fortunately, the ABI gives
7222 suggested names for all the MIPS specific sections, so we will
7223 probably get away with this. */
7224 switch (hdr->sh_type)
7225 {
7226 case SHT_MIPS_LIBLIST:
7227 if (strcmp (name, ".liblist") != 0)
7228 return FALSE;
7229 break;
7230 case SHT_MIPS_MSYM:
7231 if (strcmp (name, ".msym") != 0)
7232 return FALSE;
7233 break;
7234 case SHT_MIPS_CONFLICT:
7235 if (strcmp (name, ".conflict") != 0)
7236 return FALSE;
7237 break;
7238 case SHT_MIPS_GPTAB:
7239 if (! CONST_STRNEQ (name, ".gptab."))
7240 return FALSE;
7241 break;
7242 case SHT_MIPS_UCODE:
7243 if (strcmp (name, ".ucode") != 0)
7244 return FALSE;
7245 break;
7246 case SHT_MIPS_DEBUG:
7247 if (strcmp (name, ".mdebug") != 0)
7248 return FALSE;
7249 flags = SEC_DEBUGGING;
7250 break;
7251 case SHT_MIPS_REGINFO:
7252 if (strcmp (name, ".reginfo") != 0
7253 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
7254 return FALSE;
7255 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
7256 break;
7257 case SHT_MIPS_IFACE:
7258 if (strcmp (name, ".MIPS.interfaces") != 0)
7259 return FALSE;
7260 break;
7261 case SHT_MIPS_CONTENT:
7262 if (! CONST_STRNEQ (name, ".MIPS.content"))
7263 return FALSE;
7264 break;
7265 case SHT_MIPS_OPTIONS:
7266 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
7267 return FALSE;
7268 break;
7269 case SHT_MIPS_ABIFLAGS:
7270 if (!MIPS_ELF_ABIFLAGS_SECTION_NAME_P (name))
7271 return FALSE;
7272 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
7273 break;
7274 case SHT_MIPS_DWARF:
7275 if (! CONST_STRNEQ (name, ".debug_")
7276 && ! CONST_STRNEQ (name, ".zdebug_"))
7277 return FALSE;
7278 break;
7279 case SHT_MIPS_SYMBOL_LIB:
7280 if (strcmp (name, ".MIPS.symlib") != 0)
7281 return FALSE;
7282 break;
7283 case SHT_MIPS_EVENTS:
7284 if (! CONST_STRNEQ (name, ".MIPS.events")
7285 && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
7286 return FALSE;
7287 break;
7288 default:
7289 break;
7290 }
7291
7292 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7293 return FALSE;
7294
7295 if (flags)
7296 {
7297 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
7298 (bfd_get_section_flags (abfd,
7299 hdr->bfd_section)
7300 | flags)))
7301 return FALSE;
7302 }
7303
7304 if (hdr->sh_type == SHT_MIPS_ABIFLAGS)
7305 {
7306 Elf_External_ABIFlags_v0 ext;
7307
7308 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
7309 &ext, 0, sizeof ext))
7310 return FALSE;
7311 bfd_mips_elf_swap_abiflags_v0_in (abfd, &ext,
7312 &mips_elf_tdata (abfd)->abiflags);
7313 if (mips_elf_tdata (abfd)->abiflags.version != 0)
7314 return FALSE;
7315 mips_elf_tdata (abfd)->abiflags_valid = TRUE;
7316 }
7317
7318 /* FIXME: We should record sh_info for a .gptab section. */
7319
7320 /* For a .reginfo section, set the gp value in the tdata information
7321 from the contents of this section. We need the gp value while
7322 processing relocs, so we just get it now. The .reginfo section
7323 is not used in the 64-bit MIPS ELF ABI. */
7324 if (hdr->sh_type == SHT_MIPS_REGINFO)
7325 {
7326 Elf32_External_RegInfo ext;
7327 Elf32_RegInfo s;
7328
7329 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
7330 &ext, 0, sizeof ext))
7331 return FALSE;
7332 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
7333 elf_gp (abfd) = s.ri_gp_value;
7334 }
7335
7336 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
7337 set the gp value based on what we find. We may see both
7338 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
7339 they should agree. */
7340 if (hdr->sh_type == SHT_MIPS_OPTIONS)
7341 {
7342 bfd_byte *contents, *l, *lend;
7343
7344 contents = bfd_malloc (hdr->sh_size);
7345 if (contents == NULL)
7346 return FALSE;
7347 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
7348 0, hdr->sh_size))
7349 {
7350 free (contents);
7351 return FALSE;
7352 }
7353 l = contents;
7354 lend = contents + hdr->sh_size;
7355 while (l + sizeof (Elf_External_Options) <= lend)
7356 {
7357 Elf_Internal_Options intopt;
7358
7359 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
7360 &intopt);
7361 if (intopt.size < sizeof (Elf_External_Options))
7362 {
7363 _bfd_error_handler
7364 /* xgettext:c-format */
7365 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
7366 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
7367 break;
7368 }
7369 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
7370 {
7371 Elf64_Internal_RegInfo intreg;
7372
7373 bfd_mips_elf64_swap_reginfo_in
7374 (abfd,
7375 ((Elf64_External_RegInfo *)
7376 (l + sizeof (Elf_External_Options))),
7377 &intreg);
7378 elf_gp (abfd) = intreg.ri_gp_value;
7379 }
7380 else if (intopt.kind == ODK_REGINFO)
7381 {
7382 Elf32_RegInfo intreg;
7383
7384 bfd_mips_elf32_swap_reginfo_in
7385 (abfd,
7386 ((Elf32_External_RegInfo *)
7387 (l + sizeof (Elf_External_Options))),
7388 &intreg);
7389 elf_gp (abfd) = intreg.ri_gp_value;
7390 }
7391 l += intopt.size;
7392 }
7393 free (contents);
7394 }
7395
7396 return TRUE;
7397 }
7398
7399 /* Set the correct type for a MIPS ELF section. We do this by the
7400 section name, which is a hack, but ought to work. This routine is
7401 used by both the 32-bit and the 64-bit ABI. */
7402
7403 bfd_boolean
7404 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
7405 {
7406 const char *name = bfd_get_section_name (abfd, sec);
7407
7408 if (strcmp (name, ".liblist") == 0)
7409 {
7410 hdr->sh_type = SHT_MIPS_LIBLIST;
7411 hdr->sh_info = sec->size / sizeof (Elf32_Lib);
7412 /* The sh_link field is set in final_write_processing. */
7413 }
7414 else if (strcmp (name, ".conflict") == 0)
7415 hdr->sh_type = SHT_MIPS_CONFLICT;
7416 else if (CONST_STRNEQ (name, ".gptab."))
7417 {
7418 hdr->sh_type = SHT_MIPS_GPTAB;
7419 hdr->sh_entsize = sizeof (Elf32_External_gptab);
7420 /* The sh_info field is set in final_write_processing. */
7421 }
7422 else if (strcmp (name, ".ucode") == 0)
7423 hdr->sh_type = SHT_MIPS_UCODE;
7424 else if (strcmp (name, ".mdebug") == 0)
7425 {
7426 hdr->sh_type = SHT_MIPS_DEBUG;
7427 /* In a shared object on IRIX 5.3, the .mdebug section has an
7428 entsize of 0. FIXME: Does this matter? */
7429 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
7430 hdr->sh_entsize = 0;
7431 else
7432 hdr->sh_entsize = 1;
7433 }
7434 else if (strcmp (name, ".reginfo") == 0)
7435 {
7436 hdr->sh_type = SHT_MIPS_REGINFO;
7437 /* In a shared object on IRIX 5.3, the .reginfo section has an
7438 entsize of 0x18. FIXME: Does this matter? */
7439 if (SGI_COMPAT (abfd))
7440 {
7441 if ((abfd->flags & DYNAMIC) != 0)
7442 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
7443 else
7444 hdr->sh_entsize = 1;
7445 }
7446 else
7447 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
7448 }
7449 else if (SGI_COMPAT (abfd)
7450 && (strcmp (name, ".hash") == 0
7451 || strcmp (name, ".dynamic") == 0
7452 || strcmp (name, ".dynstr") == 0))
7453 {
7454 if (SGI_COMPAT (abfd))
7455 hdr->sh_entsize = 0;
7456 #if 0
7457 /* This isn't how the IRIX6 linker behaves. */
7458 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
7459 #endif
7460 }
7461 else if (strcmp (name, ".got") == 0
7462 || strcmp (name, ".srdata") == 0
7463 || strcmp (name, ".sdata") == 0
7464 || strcmp (name, ".sbss") == 0
7465 || strcmp (name, ".lit4") == 0
7466 || strcmp (name, ".lit8") == 0)
7467 hdr->sh_flags |= SHF_MIPS_GPREL;
7468 else if (strcmp (name, ".MIPS.interfaces") == 0)
7469 {
7470 hdr->sh_type = SHT_MIPS_IFACE;
7471 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7472 }
7473 else if (CONST_STRNEQ (name, ".MIPS.content"))
7474 {
7475 hdr->sh_type = SHT_MIPS_CONTENT;
7476 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7477 /* The sh_info field is set in final_write_processing. */
7478 }
7479 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
7480 {
7481 hdr->sh_type = SHT_MIPS_OPTIONS;
7482 hdr->sh_entsize = 1;
7483 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7484 }
7485 else if (CONST_STRNEQ (name, ".MIPS.abiflags"))
7486 {
7487 hdr->sh_type = SHT_MIPS_ABIFLAGS;
7488 hdr->sh_entsize = sizeof (Elf_External_ABIFlags_v0);
7489 }
7490 else if (CONST_STRNEQ (name, ".debug_")
7491 || CONST_STRNEQ (name, ".zdebug_"))
7492 {
7493 hdr->sh_type = SHT_MIPS_DWARF;
7494
7495 /* Irix facilities such as libexc expect a single .debug_frame
7496 per executable, the system ones have NOSTRIP set and the linker
7497 doesn't merge sections with different flags so ... */
7498 if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
7499 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7500 }
7501 else if (strcmp (name, ".MIPS.symlib") == 0)
7502 {
7503 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
7504 /* The sh_link and sh_info fields are set in
7505 final_write_processing. */
7506 }
7507 else if (CONST_STRNEQ (name, ".MIPS.events")
7508 || CONST_STRNEQ (name, ".MIPS.post_rel"))
7509 {
7510 hdr->sh_type = SHT_MIPS_EVENTS;
7511 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
7512 /* The sh_link field is set in final_write_processing. */
7513 }
7514 else if (strcmp (name, ".msym") == 0)
7515 {
7516 hdr->sh_type = SHT_MIPS_MSYM;
7517 hdr->sh_flags |= SHF_ALLOC;
7518 hdr->sh_entsize = 8;
7519 }
7520
7521 /* The generic elf_fake_sections will set up REL_HDR using the default
7522 kind of relocations. We used to set up a second header for the
7523 non-default kind of relocations here, but only NewABI would use
7524 these, and the IRIX ld doesn't like resulting empty RELA sections.
7525 Thus we create those header only on demand now. */
7526
7527 return TRUE;
7528 }
7529
7530 /* Given a BFD section, try to locate the corresponding ELF section
7531 index. This is used by both the 32-bit and the 64-bit ABI.
7532 Actually, it's not clear to me that the 64-bit ABI supports these,
7533 but for non-PIC objects we will certainly want support for at least
7534 the .scommon section. */
7535
7536 bfd_boolean
7537 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
7538 asection *sec, int *retval)
7539 {
7540 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
7541 {
7542 *retval = SHN_MIPS_SCOMMON;
7543 return TRUE;
7544 }
7545 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
7546 {
7547 *retval = SHN_MIPS_ACOMMON;
7548 return TRUE;
7549 }
7550 return FALSE;
7551 }
7552 \f
7553 /* Hook called by the linker routine which adds symbols from an object
7554 file. We must handle the special MIPS section numbers here. */
7555
7556 bfd_boolean
7557 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
7558 Elf_Internal_Sym *sym, const char **namep,
7559 flagword *flagsp ATTRIBUTE_UNUSED,
7560 asection **secp, bfd_vma *valp)
7561 {
7562 if (SGI_COMPAT (abfd)
7563 && (abfd->flags & DYNAMIC) != 0
7564 && strcmp (*namep, "_rld_new_interface") == 0)
7565 {
7566 /* Skip IRIX5 rld entry name. */
7567 *namep = NULL;
7568 return TRUE;
7569 }
7570
7571 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
7572 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
7573 by setting a DT_NEEDED for the shared object. Since _gp_disp is
7574 a magic symbol resolved by the linker, we ignore this bogus definition
7575 of _gp_disp. New ABI objects do not suffer from this problem so this
7576 is not done for them. */
7577 if (!NEWABI_P(abfd)
7578 && (sym->st_shndx == SHN_ABS)
7579 && (strcmp (*namep, "_gp_disp") == 0))
7580 {
7581 *namep = NULL;
7582 return TRUE;
7583 }
7584
7585 switch (sym->st_shndx)
7586 {
7587 case SHN_COMMON:
7588 /* Common symbols less than the GP size are automatically
7589 treated as SHN_MIPS_SCOMMON symbols. */
7590 if (sym->st_size > elf_gp_size (abfd)
7591 || ELF_ST_TYPE (sym->st_info) == STT_TLS
7592 || IRIX_COMPAT (abfd) == ict_irix6)
7593 break;
7594 /* Fall through. */
7595 case SHN_MIPS_SCOMMON:
7596 *secp = bfd_make_section_old_way (abfd, ".scommon");
7597 (*secp)->flags |= SEC_IS_COMMON;
7598 *valp = sym->st_size;
7599 break;
7600
7601 case SHN_MIPS_TEXT:
7602 /* This section is used in a shared object. */
7603 if (mips_elf_tdata (abfd)->elf_text_section == NULL)
7604 {
7605 asymbol *elf_text_symbol;
7606 asection *elf_text_section;
7607 bfd_size_type amt = sizeof (asection);
7608
7609 elf_text_section = bfd_zalloc (abfd, amt);
7610 if (elf_text_section == NULL)
7611 return FALSE;
7612
7613 amt = sizeof (asymbol);
7614 elf_text_symbol = bfd_zalloc (abfd, amt);
7615 if (elf_text_symbol == NULL)
7616 return FALSE;
7617
7618 /* Initialize the section. */
7619
7620 mips_elf_tdata (abfd)->elf_text_section = elf_text_section;
7621 mips_elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
7622
7623 elf_text_section->symbol = elf_text_symbol;
7624 elf_text_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_text_symbol;
7625
7626 elf_text_section->name = ".text";
7627 elf_text_section->flags = SEC_NO_FLAGS;
7628 elf_text_section->output_section = NULL;
7629 elf_text_section->owner = abfd;
7630 elf_text_symbol->name = ".text";
7631 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7632 elf_text_symbol->section = elf_text_section;
7633 }
7634 /* This code used to do *secp = bfd_und_section_ptr if
7635 bfd_link_pic (info). I don't know why, and that doesn't make sense,
7636 so I took it out. */
7637 *secp = mips_elf_tdata (abfd)->elf_text_section;
7638 break;
7639
7640 case SHN_MIPS_ACOMMON:
7641 /* Fall through. XXX Can we treat this as allocated data? */
7642 case SHN_MIPS_DATA:
7643 /* This section is used in a shared object. */
7644 if (mips_elf_tdata (abfd)->elf_data_section == NULL)
7645 {
7646 asymbol *elf_data_symbol;
7647 asection *elf_data_section;
7648 bfd_size_type amt = sizeof (asection);
7649
7650 elf_data_section = bfd_zalloc (abfd, amt);
7651 if (elf_data_section == NULL)
7652 return FALSE;
7653
7654 amt = sizeof (asymbol);
7655 elf_data_symbol = bfd_zalloc (abfd, amt);
7656 if (elf_data_symbol == NULL)
7657 return FALSE;
7658
7659 /* Initialize the section. */
7660
7661 mips_elf_tdata (abfd)->elf_data_section = elf_data_section;
7662 mips_elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
7663
7664 elf_data_section->symbol = elf_data_symbol;
7665 elf_data_section->symbol_ptr_ptr = &mips_elf_tdata (abfd)->elf_data_symbol;
7666
7667 elf_data_section->name = ".data";
7668 elf_data_section->flags = SEC_NO_FLAGS;
7669 elf_data_section->output_section = NULL;
7670 elf_data_section->owner = abfd;
7671 elf_data_symbol->name = ".data";
7672 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7673 elf_data_symbol->section = elf_data_section;
7674 }
7675 /* This code used to do *secp = bfd_und_section_ptr if
7676 bfd_link_pic (info). I don't know why, and that doesn't make sense,
7677 so I took it out. */
7678 *secp = mips_elf_tdata (abfd)->elf_data_section;
7679 break;
7680
7681 case SHN_MIPS_SUNDEFINED:
7682 *secp = bfd_und_section_ptr;
7683 break;
7684 }
7685
7686 if (SGI_COMPAT (abfd)
7687 && ! bfd_link_pic (info)
7688 && info->output_bfd->xvec == abfd->xvec
7689 && strcmp (*namep, "__rld_obj_head") == 0)
7690 {
7691 struct elf_link_hash_entry *h;
7692 struct bfd_link_hash_entry *bh;
7693
7694 /* Mark __rld_obj_head as dynamic. */
7695 bh = NULL;
7696 if (! (_bfd_generic_link_add_one_symbol
7697 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
7698 get_elf_backend_data (abfd)->collect, &bh)))
7699 return FALSE;
7700
7701 h = (struct elf_link_hash_entry *) bh;
7702 h->non_elf = 0;
7703 h->def_regular = 1;
7704 h->type = STT_OBJECT;
7705
7706 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7707 return FALSE;
7708
7709 mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
7710 mips_elf_hash_table (info)->rld_symbol = h;
7711 }
7712
7713 /* If this is a mips16 text symbol, add 1 to the value to make it
7714 odd. This will cause something like .word SYM to come up with
7715 the right value when it is loaded into the PC. */
7716 if (ELF_ST_IS_COMPRESSED (sym->st_other))
7717 ++*valp;
7718
7719 return TRUE;
7720 }
7721
7722 /* This hook function is called before the linker writes out a global
7723 symbol. We mark symbols as small common if appropriate. This is
7724 also where we undo the increment of the value for a mips16 symbol. */
7725
7726 int
7727 _bfd_mips_elf_link_output_symbol_hook
7728 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7729 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
7730 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7731 {
7732 /* If we see a common symbol, which implies a relocatable link, then
7733 if a symbol was small common in an input file, mark it as small
7734 common in the output file. */
7735 if (sym->st_shndx == SHN_COMMON
7736 && strcmp (input_sec->name, ".scommon") == 0)
7737 sym->st_shndx = SHN_MIPS_SCOMMON;
7738
7739 if (ELF_ST_IS_COMPRESSED (sym->st_other))
7740 sym->st_value &= ~1;
7741
7742 return 1;
7743 }
7744 \f
7745 /* Functions for the dynamic linker. */
7746
7747 /* Create dynamic sections when linking against a dynamic object. */
7748
7749 bfd_boolean
7750 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
7751 {
7752 struct elf_link_hash_entry *h;
7753 struct bfd_link_hash_entry *bh;
7754 flagword flags;
7755 register asection *s;
7756 const char * const *namep;
7757 struct mips_elf_link_hash_table *htab;
7758
7759 htab = mips_elf_hash_table (info);
7760 BFD_ASSERT (htab != NULL);
7761
7762 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7763 | SEC_LINKER_CREATED | SEC_READONLY);
7764
7765 /* The psABI requires a read-only .dynamic section, but the VxWorks
7766 EABI doesn't. */
7767 if (!htab->is_vxworks)
7768 {
7769 s = bfd_get_linker_section (abfd, ".dynamic");
7770 if (s != NULL)
7771 {
7772 if (! bfd_set_section_flags (abfd, s, flags))
7773 return FALSE;
7774 }
7775 }
7776
7777 /* We need to create .got section. */
7778 if (!mips_elf_create_got_section (abfd, info))
7779 return FALSE;
7780
7781 if (! mips_elf_rel_dyn_section (info, TRUE))
7782 return FALSE;
7783
7784 /* Create .stub section. */
7785 s = bfd_make_section_anyway_with_flags (abfd,
7786 MIPS_ELF_STUB_SECTION_NAME (abfd),
7787 flags | SEC_CODE);
7788 if (s == NULL
7789 || ! bfd_set_section_alignment (abfd, s,
7790 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7791 return FALSE;
7792 htab->sstubs = s;
7793
7794 if (!mips_elf_hash_table (info)->use_rld_obj_head
7795 && bfd_link_executable (info)
7796 && bfd_get_linker_section (abfd, ".rld_map") == NULL)
7797 {
7798 s = bfd_make_section_anyway_with_flags (abfd, ".rld_map",
7799 flags &~ (flagword) SEC_READONLY);
7800 if (s == NULL
7801 || ! bfd_set_section_alignment (abfd, s,
7802 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7803 return FALSE;
7804 }
7805
7806 /* On IRIX5, we adjust add some additional symbols and change the
7807 alignments of several sections. There is no ABI documentation
7808 indicating that this is necessary on IRIX6, nor any evidence that
7809 the linker takes such action. */
7810 if (IRIX_COMPAT (abfd) == ict_irix5)
7811 {
7812 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7813 {
7814 bh = NULL;
7815 if (! (_bfd_generic_link_add_one_symbol
7816 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
7817 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7818 return FALSE;
7819
7820 h = (struct elf_link_hash_entry *) bh;
7821 h->non_elf = 0;
7822 h->def_regular = 1;
7823 h->type = STT_SECTION;
7824
7825 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7826 return FALSE;
7827 }
7828
7829 /* We need to create a .compact_rel section. */
7830 if (SGI_COMPAT (abfd))
7831 {
7832 if (!mips_elf_create_compact_rel_section (abfd, info))
7833 return FALSE;
7834 }
7835
7836 /* Change alignments of some sections. */
7837 s = bfd_get_linker_section (abfd, ".hash");
7838 if (s != NULL)
7839 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7840
7841 s = bfd_get_linker_section (abfd, ".dynsym");
7842 if (s != NULL)
7843 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7844
7845 s = bfd_get_linker_section (abfd, ".dynstr");
7846 if (s != NULL)
7847 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7848
7849 /* ??? */
7850 s = bfd_get_section_by_name (abfd, ".reginfo");
7851 if (s != NULL)
7852 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7853
7854 s = bfd_get_linker_section (abfd, ".dynamic");
7855 if (s != NULL)
7856 (void) bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7857 }
7858
7859 if (bfd_link_executable (info))
7860 {
7861 const char *name;
7862
7863 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7864 bh = NULL;
7865 if (!(_bfd_generic_link_add_one_symbol
7866 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
7867 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7868 return FALSE;
7869
7870 h = (struct elf_link_hash_entry *) bh;
7871 h->non_elf = 0;
7872 h->def_regular = 1;
7873 h->type = STT_SECTION;
7874
7875 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7876 return FALSE;
7877
7878 if (! mips_elf_hash_table (info)->use_rld_obj_head)
7879 {
7880 /* __rld_map is a four byte word located in the .data section
7881 and is filled in by the rtld to contain a pointer to
7882 the _r_debug structure. Its symbol value will be set in
7883 _bfd_mips_elf_finish_dynamic_symbol. */
7884 s = bfd_get_linker_section (abfd, ".rld_map");
7885 BFD_ASSERT (s != NULL);
7886
7887 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
7888 bh = NULL;
7889 if (!(_bfd_generic_link_add_one_symbol
7890 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
7891 get_elf_backend_data (abfd)->collect, &bh)))
7892 return FALSE;
7893
7894 h = (struct elf_link_hash_entry *) bh;
7895 h->non_elf = 0;
7896 h->def_regular = 1;
7897 h->type = STT_OBJECT;
7898
7899 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7900 return FALSE;
7901 mips_elf_hash_table (info)->rld_symbol = h;
7902 }
7903 }
7904
7905 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
7906 Also, on VxWorks, create the _PROCEDURE_LINKAGE_TABLE_ symbol. */
7907 if (!_bfd_elf_create_dynamic_sections (abfd, info))
7908 return FALSE;
7909
7910 /* Do the usual VxWorks handling. */
7911 if (htab->is_vxworks
7912 && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
7913 return FALSE;
7914
7915 return TRUE;
7916 }
7917 \f
7918 /* Return true if relocation REL against section SEC is a REL rather than
7919 RELA relocation. RELOCS is the first relocation in the section and
7920 ABFD is the bfd that contains SEC. */
7921
7922 static bfd_boolean
7923 mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
7924 const Elf_Internal_Rela *relocs,
7925 const Elf_Internal_Rela *rel)
7926 {
7927 Elf_Internal_Shdr *rel_hdr;
7928 const struct elf_backend_data *bed;
7929
7930 /* To determine which flavor of relocation this is, we depend on the
7931 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
7932 rel_hdr = elf_section_data (sec)->rel.hdr;
7933 if (rel_hdr == NULL)
7934 return FALSE;
7935 bed = get_elf_backend_data (abfd);
7936 return ((size_t) (rel - relocs)
7937 < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
7938 }
7939
7940 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7941 HOWTO is the relocation's howto and CONTENTS points to the contents
7942 of the section that REL is against. */
7943
7944 static bfd_vma
7945 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
7946 reloc_howto_type *howto, bfd_byte *contents)
7947 {
7948 bfd_byte *location;
7949 unsigned int r_type;
7950 bfd_vma addend;
7951 bfd_vma bytes;
7952
7953 r_type = ELF_R_TYPE (abfd, rel->r_info);
7954 location = contents + rel->r_offset;
7955
7956 /* Get the addend, which is stored in the input file. */
7957 _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
7958 bytes = mips_elf_obtain_contents (howto, rel, abfd, contents);
7959 _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location);
7960
7961 addend = bytes & howto->src_mask;
7962
7963 /* Shift is 2, unusually, for microMIPS JALX. Adjust the addend
7964 accordingly. */
7965 if (r_type == R_MICROMIPS_26_S1 && (bytes >> 26) == 0x3c)
7966 addend <<= 1;
7967
7968 return addend;
7969 }
7970
7971 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
7972 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
7973 and update *ADDEND with the final addend. Return true on success
7974 or false if the LO16 could not be found. RELEND is the exclusive
7975 upper bound on the relocations for REL's section. */
7976
7977 static bfd_boolean
7978 mips_elf_add_lo16_rel_addend (bfd *abfd,
7979 const Elf_Internal_Rela *rel,
7980 const Elf_Internal_Rela *relend,
7981 bfd_byte *contents, bfd_vma *addend)
7982 {
7983 unsigned int r_type, lo16_type;
7984 const Elf_Internal_Rela *lo16_relocation;
7985 reloc_howto_type *lo16_howto;
7986 bfd_vma l;
7987
7988 r_type = ELF_R_TYPE (abfd, rel->r_info);
7989 if (mips16_reloc_p (r_type))
7990 lo16_type = R_MIPS16_LO16;
7991 else if (micromips_reloc_p (r_type))
7992 lo16_type = R_MICROMIPS_LO16;
7993 else if (r_type == R_MIPS_PCHI16)
7994 lo16_type = R_MIPS_PCLO16;
7995 else
7996 lo16_type = R_MIPS_LO16;
7997
7998 /* The combined value is the sum of the HI16 addend, left-shifted by
7999 sixteen bits, and the LO16 addend, sign extended. (Usually, the
8000 code does a `lui' of the HI16 value, and then an `addiu' of the
8001 LO16 value.)
8002
8003 Scan ahead to find a matching LO16 relocation.
8004
8005 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
8006 be immediately following. However, for the IRIX6 ABI, the next
8007 relocation may be a composed relocation consisting of several
8008 relocations for the same address. In that case, the R_MIPS_LO16
8009 relocation may occur as one of these. We permit a similar
8010 extension in general, as that is useful for GCC.
8011
8012 In some cases GCC dead code elimination removes the LO16 but keeps
8013 the corresponding HI16. This is strictly speaking a violation of
8014 the ABI but not immediately harmful. */
8015 lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
8016 if (lo16_relocation == NULL)
8017 return FALSE;
8018
8019 /* Obtain the addend kept there. */
8020 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
8021 l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
8022
8023 l <<= lo16_howto->rightshift;
8024 l = _bfd_mips_elf_sign_extend (l, 16);
8025
8026 *addend <<= 16;
8027 *addend += l;
8028 return TRUE;
8029 }
8030
8031 /* Try to read the contents of section SEC in bfd ABFD. Return true and
8032 store the contents in *CONTENTS on success. Assume that *CONTENTS
8033 already holds the contents if it is nonull on entry. */
8034
8035 static bfd_boolean
8036 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
8037 {
8038 if (*contents)
8039 return TRUE;
8040
8041 /* Get cached copy if it exists. */
8042 if (elf_section_data (sec)->this_hdr.contents != NULL)
8043 {
8044 *contents = elf_section_data (sec)->this_hdr.contents;
8045 return TRUE;
8046 }
8047
8048 return bfd_malloc_and_get_section (abfd, sec, contents);
8049 }
8050
8051 /* Make a new PLT record to keep internal data. */
8052
8053 static struct plt_entry *
8054 mips_elf_make_plt_record (bfd *abfd)
8055 {
8056 struct plt_entry *entry;
8057
8058 entry = bfd_zalloc (abfd, sizeof (*entry));
8059 if (entry == NULL)
8060 return NULL;
8061
8062 entry->stub_offset = MINUS_ONE;
8063 entry->mips_offset = MINUS_ONE;
8064 entry->comp_offset = MINUS_ONE;
8065 entry->gotplt_index = MINUS_ONE;
8066 return entry;
8067 }
8068
8069 /* Look through the relocs for a section during the first phase, and
8070 allocate space in the global offset table and record the need for
8071 standard MIPS and compressed procedure linkage table entries. */
8072
8073 bfd_boolean
8074 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
8075 asection *sec, const Elf_Internal_Rela *relocs)
8076 {
8077 const char *name;
8078 bfd *dynobj;
8079 Elf_Internal_Shdr *symtab_hdr;
8080 struct elf_link_hash_entry **sym_hashes;
8081 size_t extsymoff;
8082 const Elf_Internal_Rela *rel;
8083 const Elf_Internal_Rela *rel_end;
8084 asection *sreloc;
8085 const struct elf_backend_data *bed;
8086 struct mips_elf_link_hash_table *htab;
8087 bfd_byte *contents;
8088 bfd_vma addend;
8089 reloc_howto_type *howto;
8090
8091 if (bfd_link_relocatable (info))
8092 return TRUE;
8093
8094 htab = mips_elf_hash_table (info);
8095 BFD_ASSERT (htab != NULL);
8096
8097 dynobj = elf_hash_table (info)->dynobj;
8098 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8099 sym_hashes = elf_sym_hashes (abfd);
8100 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8101
8102 bed = get_elf_backend_data (abfd);
8103 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
8104
8105 /* Check for the mips16 stub sections. */
8106
8107 name = bfd_get_section_name (abfd, sec);
8108 if (FN_STUB_P (name))
8109 {
8110 unsigned long r_symndx;
8111
8112 /* Look at the relocation information to figure out which symbol
8113 this is for. */
8114
8115 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
8116 if (r_symndx == 0)
8117 {
8118 _bfd_error_handler
8119 /* xgettext:c-format */
8120 (_("%B: Warning: cannot determine the target function for"
8121 " stub section `%s'"),
8122 abfd, name);
8123 bfd_set_error (bfd_error_bad_value);
8124 return FALSE;
8125 }
8126
8127 if (r_symndx < extsymoff
8128 || sym_hashes[r_symndx - extsymoff] == NULL)
8129 {
8130 asection *o;
8131
8132 /* This stub is for a local symbol. This stub will only be
8133 needed if there is some relocation in this BFD, other
8134 than a 16 bit function call, which refers to this symbol. */
8135 for (o = abfd->sections; o != NULL; o = o->next)
8136 {
8137 Elf_Internal_Rela *sec_relocs;
8138 const Elf_Internal_Rela *r, *rend;
8139
8140 /* We can ignore stub sections when looking for relocs. */
8141 if ((o->flags & SEC_RELOC) == 0
8142 || o->reloc_count == 0
8143 || section_allows_mips16_refs_p (o))
8144 continue;
8145
8146 sec_relocs
8147 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
8148 info->keep_memory);
8149 if (sec_relocs == NULL)
8150 return FALSE;
8151
8152 rend = sec_relocs + o->reloc_count;
8153 for (r = sec_relocs; r < rend; r++)
8154 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
8155 && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
8156 break;
8157
8158 if (elf_section_data (o)->relocs != sec_relocs)
8159 free (sec_relocs);
8160
8161 if (r < rend)
8162 break;
8163 }
8164
8165 if (o == NULL)
8166 {
8167 /* There is no non-call reloc for this stub, so we do
8168 not need it. Since this function is called before
8169 the linker maps input sections to output sections, we
8170 can easily discard it by setting the SEC_EXCLUDE
8171 flag. */
8172 sec->flags |= SEC_EXCLUDE;
8173 return TRUE;
8174 }
8175
8176 /* Record this stub in an array of local symbol stubs for
8177 this BFD. */
8178 if (mips_elf_tdata (abfd)->local_stubs == NULL)
8179 {
8180 unsigned long symcount;
8181 asection **n;
8182 bfd_size_type amt;
8183
8184 if (elf_bad_symtab (abfd))
8185 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
8186 else
8187 symcount = symtab_hdr->sh_info;
8188 amt = symcount * sizeof (asection *);
8189 n = bfd_zalloc (abfd, amt);
8190 if (n == NULL)
8191 return FALSE;
8192 mips_elf_tdata (abfd)->local_stubs = n;
8193 }
8194
8195 sec->flags |= SEC_KEEP;
8196 mips_elf_tdata (abfd)->local_stubs[r_symndx] = sec;
8197
8198 /* We don't need to set mips16_stubs_seen in this case.
8199 That flag is used to see whether we need to look through
8200 the global symbol table for stubs. We don't need to set
8201 it here, because we just have a local stub. */
8202 }
8203 else
8204 {
8205 struct mips_elf_link_hash_entry *h;
8206
8207 h = ((struct mips_elf_link_hash_entry *)
8208 sym_hashes[r_symndx - extsymoff]);
8209
8210 while (h->root.root.type == bfd_link_hash_indirect
8211 || h->root.root.type == bfd_link_hash_warning)
8212 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8213
8214 /* H is the symbol this stub is for. */
8215
8216 /* If we already have an appropriate stub for this function, we
8217 don't need another one, so we can discard this one. Since
8218 this function is called before the linker maps input sections
8219 to output sections, we can easily discard it by setting the
8220 SEC_EXCLUDE flag. */
8221 if (h->fn_stub != NULL)
8222 {
8223 sec->flags |= SEC_EXCLUDE;
8224 return TRUE;
8225 }
8226
8227 sec->flags |= SEC_KEEP;
8228 h->fn_stub = sec;
8229 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
8230 }
8231 }
8232 else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
8233 {
8234 unsigned long r_symndx;
8235 struct mips_elf_link_hash_entry *h;
8236 asection **loc;
8237
8238 /* Look at the relocation information to figure out which symbol
8239 this is for. */
8240
8241 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
8242 if (r_symndx == 0)
8243 {
8244 _bfd_error_handler
8245 /* xgettext:c-format */
8246 (_("%B: Warning: cannot determine the target function for"
8247 " stub section `%s'"),
8248 abfd, name);
8249 bfd_set_error (bfd_error_bad_value);
8250 return FALSE;
8251 }
8252
8253 if (r_symndx < extsymoff
8254 || sym_hashes[r_symndx - extsymoff] == NULL)
8255 {
8256 asection *o;
8257
8258 /* This stub is for a local symbol. This stub will only be
8259 needed if there is some relocation (R_MIPS16_26) in this BFD
8260 that refers to this symbol. */
8261 for (o = abfd->sections; o != NULL; o = o->next)
8262 {
8263 Elf_Internal_Rela *sec_relocs;
8264 const Elf_Internal_Rela *r, *rend;
8265
8266 /* We can ignore stub sections when looking for relocs. */
8267 if ((o->flags & SEC_RELOC) == 0
8268 || o->reloc_count == 0
8269 || section_allows_mips16_refs_p (o))
8270 continue;
8271
8272 sec_relocs
8273 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
8274 info->keep_memory);
8275 if (sec_relocs == NULL)
8276 return FALSE;
8277
8278 rend = sec_relocs + o->reloc_count;
8279 for (r = sec_relocs; r < rend; r++)
8280 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
8281 && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
8282 break;
8283
8284 if (elf_section_data (o)->relocs != sec_relocs)
8285 free (sec_relocs);
8286
8287 if (r < rend)
8288 break;
8289 }
8290
8291 if (o == NULL)
8292 {
8293 /* There is no non-call reloc for this stub, so we do
8294 not need it. Since this function is called before
8295 the linker maps input sections to output sections, we
8296 can easily discard it by setting the SEC_EXCLUDE
8297 flag. */
8298 sec->flags |= SEC_EXCLUDE;
8299 return TRUE;
8300 }
8301
8302 /* Record this stub in an array of local symbol call_stubs for
8303 this BFD. */
8304 if (mips_elf_tdata (abfd)->local_call_stubs == NULL)
8305 {
8306 unsigned long symcount;
8307 asection **n;
8308 bfd_size_type amt;
8309
8310 if (elf_bad_symtab (abfd))
8311 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
8312 else
8313 symcount = symtab_hdr->sh_info;
8314 amt = symcount * sizeof (asection *);
8315 n = bfd_zalloc (abfd, amt);
8316 if (n == NULL)
8317 return FALSE;
8318 mips_elf_tdata (abfd)->local_call_stubs = n;
8319 }
8320
8321 sec->flags |= SEC_KEEP;
8322 mips_elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
8323
8324 /* We don't need to set mips16_stubs_seen in this case.
8325 That flag is used to see whether we need to look through
8326 the global symbol table for stubs. We don't need to set
8327 it here, because we just have a local stub. */
8328 }
8329 else
8330 {
8331 h = ((struct mips_elf_link_hash_entry *)
8332 sym_hashes[r_symndx - extsymoff]);
8333
8334 /* H is the symbol this stub is for. */
8335
8336 if (CALL_FP_STUB_P (name))
8337 loc = &h->call_fp_stub;
8338 else
8339 loc = &h->call_stub;
8340
8341 /* If we already have an appropriate stub for this function, we
8342 don't need another one, so we can discard this one. Since
8343 this function is called before the linker maps input sections
8344 to output sections, we can easily discard it by setting the
8345 SEC_EXCLUDE flag. */
8346 if (*loc != NULL)
8347 {
8348 sec->flags |= SEC_EXCLUDE;
8349 return TRUE;
8350 }
8351
8352 sec->flags |= SEC_KEEP;
8353 *loc = sec;
8354 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
8355 }
8356 }
8357
8358 sreloc = NULL;
8359 contents = NULL;
8360 for (rel = relocs; rel < rel_end; ++rel)
8361 {
8362 unsigned long r_symndx;
8363 unsigned int r_type;
8364 struct elf_link_hash_entry *h;
8365 bfd_boolean can_make_dynamic_p;
8366 bfd_boolean call_reloc_p;
8367 bfd_boolean constrain_symbol_p;
8368
8369 r_symndx = ELF_R_SYM (abfd, rel->r_info);
8370 r_type = ELF_R_TYPE (abfd, rel->r_info);
8371
8372 if (r_symndx < extsymoff)
8373 h = NULL;
8374 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
8375 {
8376 _bfd_error_handler
8377 /* xgettext:c-format */
8378 (_("%B: Malformed reloc detected for section %s"),
8379 abfd, name);
8380 bfd_set_error (bfd_error_bad_value);
8381 return FALSE;
8382 }
8383 else
8384 {
8385 h = sym_hashes[r_symndx - extsymoff];
8386 if (h != NULL)
8387 {
8388 while (h->root.type == bfd_link_hash_indirect
8389 || h->root.type == bfd_link_hash_warning)
8390 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8391
8392 /* PR15323, ref flags aren't set for references in the
8393 same object. */
8394 h->root.non_ir_ref = 1;
8395 }
8396 }
8397
8398 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
8399 relocation into a dynamic one. */
8400 can_make_dynamic_p = FALSE;
8401
8402 /* Set CALL_RELOC_P to true if the relocation is for a call,
8403 and if pointer equality therefore doesn't matter. */
8404 call_reloc_p = FALSE;
8405
8406 /* Set CONSTRAIN_SYMBOL_P if we need to take the relocation
8407 into account when deciding how to define the symbol.
8408 Relocations in nonallocatable sections such as .pdr and
8409 .debug* should have no effect. */
8410 constrain_symbol_p = ((sec->flags & SEC_ALLOC) != 0);
8411
8412 switch (r_type)
8413 {
8414 case R_MIPS_CALL16:
8415 case R_MIPS_CALL_HI16:
8416 case R_MIPS_CALL_LO16:
8417 case R_MIPS16_CALL16:
8418 case R_MICROMIPS_CALL16:
8419 case R_MICROMIPS_CALL_HI16:
8420 case R_MICROMIPS_CALL_LO16:
8421 call_reloc_p = TRUE;
8422 /* Fall through. */
8423
8424 case R_MIPS_GOT16:
8425 case R_MIPS_GOT_HI16:
8426 case R_MIPS_GOT_LO16:
8427 case R_MIPS_GOT_PAGE:
8428 case R_MIPS_GOT_OFST:
8429 case R_MIPS_GOT_DISP:
8430 case R_MIPS_TLS_GOTTPREL:
8431 case R_MIPS_TLS_GD:
8432 case R_MIPS_TLS_LDM:
8433 case R_MIPS16_GOT16:
8434 case R_MIPS16_TLS_GOTTPREL:
8435 case R_MIPS16_TLS_GD:
8436 case R_MIPS16_TLS_LDM:
8437 case R_MICROMIPS_GOT16:
8438 case R_MICROMIPS_GOT_HI16:
8439 case R_MICROMIPS_GOT_LO16:
8440 case R_MICROMIPS_GOT_PAGE:
8441 case R_MICROMIPS_GOT_OFST:
8442 case R_MICROMIPS_GOT_DISP:
8443 case R_MICROMIPS_TLS_GOTTPREL:
8444 case R_MICROMIPS_TLS_GD:
8445 case R_MICROMIPS_TLS_LDM:
8446 if (dynobj == NULL)
8447 elf_hash_table (info)->dynobj = dynobj = abfd;
8448 if (!mips_elf_create_got_section (dynobj, info))
8449 return FALSE;
8450 if (htab->is_vxworks && !bfd_link_pic (info))
8451 {
8452 _bfd_error_handler
8453 /* xgettext:c-format */
8454 (_("%B: GOT reloc at 0x%lx not expected in executables"),
8455 abfd, (unsigned long) rel->r_offset);
8456 bfd_set_error (bfd_error_bad_value);
8457 return FALSE;
8458 }
8459 can_make_dynamic_p = TRUE;
8460 break;
8461
8462 case R_MIPS_NONE:
8463 case R_MIPS_JALR:
8464 case R_MICROMIPS_JALR:
8465 /* These relocations have empty fields and are purely there to
8466 provide link information. The symbol value doesn't matter. */
8467 constrain_symbol_p = FALSE;
8468 break;
8469
8470 case R_MIPS_GPREL16:
8471 case R_MIPS_GPREL32:
8472 case R_MIPS16_GPREL:
8473 case R_MICROMIPS_GPREL16:
8474 /* GP-relative relocations always resolve to a definition in a
8475 regular input file, ignoring the one-definition rule. This is
8476 important for the GP setup sequence in NewABI code, which
8477 always resolves to a local function even if other relocations
8478 against the symbol wouldn't. */
8479 constrain_symbol_p = FALSE;
8480 break;
8481
8482 case R_MIPS_32:
8483 case R_MIPS_REL32:
8484 case R_MIPS_64:
8485 /* In VxWorks executables, references to external symbols
8486 must be handled using copy relocs or PLT entries; it is not
8487 possible to convert this relocation into a dynamic one.
8488
8489 For executables that use PLTs and copy-relocs, we have a
8490 choice between converting the relocation into a dynamic
8491 one or using copy relocations or PLT entries. It is
8492 usually better to do the former, unless the relocation is
8493 against a read-only section. */
8494 if ((bfd_link_pic (info)
8495 || (h != NULL
8496 && !htab->is_vxworks
8497 && strcmp (h->root.root.string, "__gnu_local_gp") != 0
8498 && !(!info->nocopyreloc
8499 && !PIC_OBJECT_P (abfd)
8500 && MIPS_ELF_READONLY_SECTION (sec))))
8501 && (sec->flags & SEC_ALLOC) != 0)
8502 {
8503 can_make_dynamic_p = TRUE;
8504 if (dynobj == NULL)
8505 elf_hash_table (info)->dynobj = dynobj = abfd;
8506 }
8507 break;
8508
8509 case R_MIPS_26:
8510 case R_MIPS_PC16:
8511 case R_MIPS_PC21_S2:
8512 case R_MIPS_PC26_S2:
8513 case R_MIPS16_26:
8514 case R_MIPS16_PC16_S1:
8515 case R_MICROMIPS_26_S1:
8516 case R_MICROMIPS_PC7_S1:
8517 case R_MICROMIPS_PC10_S1:
8518 case R_MICROMIPS_PC16_S1:
8519 case R_MICROMIPS_PC23_S2:
8520 call_reloc_p = TRUE;
8521 break;
8522 }
8523
8524 if (h)
8525 {
8526 if (constrain_symbol_p)
8527 {
8528 if (!can_make_dynamic_p)
8529 ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = 1;
8530
8531 if (!call_reloc_p)
8532 h->pointer_equality_needed = 1;
8533
8534 /* We must not create a stub for a symbol that has
8535 relocations related to taking the function's address.
8536 This doesn't apply to VxWorks, where CALL relocs refer
8537 to a .got.plt entry instead of a normal .got entry. */
8538 if (!htab->is_vxworks && (!can_make_dynamic_p || !call_reloc_p))
8539 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
8540 }
8541
8542 /* Relocations against the special VxWorks __GOTT_BASE__ and
8543 __GOTT_INDEX__ symbols must be left to the loader. Allocate
8544 room for them in .rela.dyn. */
8545 if (is_gott_symbol (info, h))
8546 {
8547 if (sreloc == NULL)
8548 {
8549 sreloc = mips_elf_rel_dyn_section (info, TRUE);
8550 if (sreloc == NULL)
8551 return FALSE;
8552 }
8553 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8554 if (MIPS_ELF_READONLY_SECTION (sec))
8555 /* We tell the dynamic linker that there are
8556 relocations against the text segment. */
8557 info->flags |= DF_TEXTREL;
8558 }
8559 }
8560 else if (call_lo16_reloc_p (r_type)
8561 || got_lo16_reloc_p (r_type)
8562 || got_disp_reloc_p (r_type)
8563 || (got16_reloc_p (r_type) && htab->is_vxworks))
8564 {
8565 /* We may need a local GOT entry for this relocation. We
8566 don't count R_MIPS_GOT_PAGE because we can estimate the
8567 maximum number of pages needed by looking at the size of
8568 the segment. Similar comments apply to R_MIPS*_GOT16 and
8569 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
8570 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
8571 R_MIPS_CALL_HI16 because these are always followed by an
8572 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
8573 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8574 rel->r_addend, info, r_type))
8575 return FALSE;
8576 }
8577
8578 if (h != NULL
8579 && mips_elf_relocation_needs_la25_stub (abfd, r_type,
8580 ELF_ST_IS_MIPS16 (h->other)))
8581 ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
8582
8583 switch (r_type)
8584 {
8585 case R_MIPS_CALL16:
8586 case R_MIPS16_CALL16:
8587 case R_MICROMIPS_CALL16:
8588 if (h == NULL)
8589 {
8590 _bfd_error_handler
8591 /* xgettext:c-format */
8592 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
8593 abfd, (unsigned long) rel->r_offset);
8594 bfd_set_error (bfd_error_bad_value);
8595 return FALSE;
8596 }
8597 /* Fall through. */
8598
8599 case R_MIPS_CALL_HI16:
8600 case R_MIPS_CALL_LO16:
8601 case R_MICROMIPS_CALL_HI16:
8602 case R_MICROMIPS_CALL_LO16:
8603 if (h != NULL)
8604 {
8605 /* Make sure there is room in the regular GOT to hold the
8606 function's address. We may eliminate it in favour of
8607 a .got.plt entry later; see mips_elf_count_got_symbols. */
8608 if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE,
8609 r_type))
8610 return FALSE;
8611
8612 /* We need a stub, not a plt entry for the undefined
8613 function. But we record it as if it needs plt. See
8614 _bfd_elf_adjust_dynamic_symbol. */
8615 h->needs_plt = 1;
8616 h->type = STT_FUNC;
8617 }
8618 break;
8619
8620 case R_MIPS_GOT_PAGE:
8621 case R_MICROMIPS_GOT_PAGE:
8622 case R_MIPS16_GOT16:
8623 case R_MIPS_GOT16:
8624 case R_MIPS_GOT_HI16:
8625 case R_MIPS_GOT_LO16:
8626 case R_MICROMIPS_GOT16:
8627 case R_MICROMIPS_GOT_HI16:
8628 case R_MICROMIPS_GOT_LO16:
8629 if (!h || got_page_reloc_p (r_type))
8630 {
8631 /* This relocation needs (or may need, if h != NULL) a
8632 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
8633 know for sure until we know whether the symbol is
8634 preemptible. */
8635 if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
8636 {
8637 if (!mips_elf_get_section_contents (abfd, sec, &contents))
8638 return FALSE;
8639 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8640 addend = mips_elf_read_rel_addend (abfd, rel,
8641 howto, contents);
8642 if (got16_reloc_p (r_type))
8643 mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
8644 contents, &addend);
8645 else
8646 addend <<= howto->rightshift;
8647 }
8648 else
8649 addend = rel->r_addend;
8650 if (!mips_elf_record_got_page_ref (info, abfd, r_symndx,
8651 h, addend))
8652 return FALSE;
8653
8654 if (h)
8655 {
8656 struct mips_elf_link_hash_entry *hmips =
8657 (struct mips_elf_link_hash_entry *) h;
8658
8659 /* This symbol is definitely not overridable. */
8660 if (hmips->root.def_regular
8661 && ! (bfd_link_pic (info) && ! info->symbolic
8662 && ! hmips->root.forced_local))
8663 h = NULL;
8664 }
8665 }
8666 /* If this is a global, overridable symbol, GOT_PAGE will
8667 decay to GOT_DISP, so we'll need a GOT entry for it. */
8668 /* Fall through. */
8669
8670 case R_MIPS_GOT_DISP:
8671 case R_MICROMIPS_GOT_DISP:
8672 if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8673 FALSE, r_type))
8674 return FALSE;
8675 break;
8676
8677 case R_MIPS_TLS_GOTTPREL:
8678 case R_MIPS16_TLS_GOTTPREL:
8679 case R_MICROMIPS_TLS_GOTTPREL:
8680 if (bfd_link_pic (info))
8681 info->flags |= DF_STATIC_TLS;
8682 /* Fall through */
8683
8684 case R_MIPS_TLS_LDM:
8685 case R_MIPS16_TLS_LDM:
8686 case R_MICROMIPS_TLS_LDM:
8687 if (tls_ldm_reloc_p (r_type))
8688 {
8689 r_symndx = STN_UNDEF;
8690 h = NULL;
8691 }
8692 /* Fall through */
8693
8694 case R_MIPS_TLS_GD:
8695 case R_MIPS16_TLS_GD:
8696 case R_MICROMIPS_TLS_GD:
8697 /* This symbol requires a global offset table entry, or two
8698 for TLS GD relocations. */
8699 if (h != NULL)
8700 {
8701 if (!mips_elf_record_global_got_symbol (h, abfd, info,
8702 FALSE, r_type))
8703 return FALSE;
8704 }
8705 else
8706 {
8707 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8708 rel->r_addend,
8709 info, r_type))
8710 return FALSE;
8711 }
8712 break;
8713
8714 case R_MIPS_32:
8715 case R_MIPS_REL32:
8716 case R_MIPS_64:
8717 /* In VxWorks executables, references to external symbols
8718 are handled using copy relocs or PLT stubs, so there's
8719 no need to add a .rela.dyn entry for this relocation. */
8720 if (can_make_dynamic_p)
8721 {
8722 if (sreloc == NULL)
8723 {
8724 sreloc = mips_elf_rel_dyn_section (info, TRUE);
8725 if (sreloc == NULL)
8726 return FALSE;
8727 }
8728 if (bfd_link_pic (info) && h == NULL)
8729 {
8730 /* When creating a shared object, we must copy these
8731 reloc types into the output file as R_MIPS_REL32
8732 relocs. Make room for this reloc in .rel(a).dyn. */
8733 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8734 if (MIPS_ELF_READONLY_SECTION (sec))
8735 /* We tell the dynamic linker that there are
8736 relocations against the text segment. */
8737 info->flags |= DF_TEXTREL;
8738 }
8739 else
8740 {
8741 struct mips_elf_link_hash_entry *hmips;
8742
8743 /* For a shared object, we must copy this relocation
8744 unless the symbol turns out to be undefined and
8745 weak with non-default visibility, in which case
8746 it will be left as zero.
8747
8748 We could elide R_MIPS_REL32 for locally binding symbols
8749 in shared libraries, but do not yet do so.
8750
8751 For an executable, we only need to copy this
8752 reloc if the symbol is defined in a dynamic
8753 object. */
8754 hmips = (struct mips_elf_link_hash_entry *) h;
8755 ++hmips->possibly_dynamic_relocs;
8756 if (MIPS_ELF_READONLY_SECTION (sec))
8757 /* We need it to tell the dynamic linker if there
8758 are relocations against the text segment. */
8759 hmips->readonly_reloc = TRUE;
8760 }
8761 }
8762
8763 if (SGI_COMPAT (abfd))
8764 mips_elf_hash_table (info)->compact_rel_size +=
8765 sizeof (Elf32_External_crinfo);
8766 break;
8767
8768 case R_MIPS_26:
8769 case R_MIPS_GPREL16:
8770 case R_MIPS_LITERAL:
8771 case R_MIPS_GPREL32:
8772 case R_MICROMIPS_26_S1:
8773 case R_MICROMIPS_GPREL16:
8774 case R_MICROMIPS_LITERAL:
8775 case R_MICROMIPS_GPREL7_S2:
8776 if (SGI_COMPAT (abfd))
8777 mips_elf_hash_table (info)->compact_rel_size +=
8778 sizeof (Elf32_External_crinfo);
8779 break;
8780
8781 /* This relocation describes the C++ object vtable hierarchy.
8782 Reconstruct it for later use during GC. */
8783 case R_MIPS_GNU_VTINHERIT:
8784 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
8785 return FALSE;
8786 break;
8787
8788 /* This relocation describes which C++ vtable entries are actually
8789 used. Record for later use during GC. */
8790 case R_MIPS_GNU_VTENTRY:
8791 BFD_ASSERT (h != NULL);
8792 if (h != NULL
8793 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
8794 return FALSE;
8795 break;
8796
8797 default:
8798 break;
8799 }
8800
8801 /* Record the need for a PLT entry. At this point we don't know
8802 yet if we are going to create a PLT in the first place, but
8803 we only record whether the relocation requires a standard MIPS
8804 or a compressed code entry anyway. If we don't make a PLT after
8805 all, then we'll just ignore these arrangements. Likewise if
8806 a PLT entry is not created because the symbol is satisfied
8807 locally. */
8808 if (h != NULL
8809 && (branch_reloc_p (r_type)
8810 || mips16_branch_reloc_p (r_type)
8811 || micromips_branch_reloc_p (r_type))
8812 && !SYMBOL_CALLS_LOCAL (info, h))
8813 {
8814 if (h->plt.plist == NULL)
8815 h->plt.plist = mips_elf_make_plt_record (abfd);
8816 if (h->plt.plist == NULL)
8817 return FALSE;
8818
8819 if (branch_reloc_p (r_type))
8820 h->plt.plist->need_mips = TRUE;
8821 else
8822 h->plt.plist->need_comp = TRUE;
8823 }
8824
8825 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
8826 if there is one. We only need to handle global symbols here;
8827 we decide whether to keep or delete stubs for local symbols
8828 when processing the stub's relocations. */
8829 if (h != NULL
8830 && !mips16_call_reloc_p (r_type)
8831 && !section_allows_mips16_refs_p (sec))
8832 {
8833 struct mips_elf_link_hash_entry *mh;
8834
8835 mh = (struct mips_elf_link_hash_entry *) h;
8836 mh->need_fn_stub = TRUE;
8837 }
8838
8839 /* Refuse some position-dependent relocations when creating a
8840 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
8841 not PIC, but we can create dynamic relocations and the result
8842 will be fine. Also do not refuse R_MIPS_LO16, which can be
8843 combined with R_MIPS_GOT16. */
8844 if (bfd_link_pic (info))
8845 {
8846 switch (r_type)
8847 {
8848 case R_MIPS16_HI16:
8849 case R_MIPS_HI16:
8850 case R_MIPS_HIGHER:
8851 case R_MIPS_HIGHEST:
8852 case R_MICROMIPS_HI16:
8853 case R_MICROMIPS_HIGHER:
8854 case R_MICROMIPS_HIGHEST:
8855 /* Don't refuse a high part relocation if it's against
8856 no symbol (e.g. part of a compound relocation). */
8857 if (r_symndx == STN_UNDEF)
8858 break;
8859
8860 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
8861 and has a special meaning. */
8862 if (!NEWABI_P (abfd) && h != NULL
8863 && strcmp (h->root.root.string, "_gp_disp") == 0)
8864 break;
8865
8866 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */
8867 if (is_gott_symbol (info, h))
8868 break;
8869
8870 /* FALLTHROUGH */
8871
8872 case R_MIPS16_26:
8873 case R_MIPS_26:
8874 case R_MICROMIPS_26_S1:
8875 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8876 _bfd_error_handler
8877 /* xgettext:c-format */
8878 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
8879 abfd, howto->name,
8880 (h) ? h->root.root.string : "a local symbol");
8881 bfd_set_error (bfd_error_bad_value);
8882 return FALSE;
8883 default:
8884 break;
8885 }
8886 }
8887 }
8888
8889 return TRUE;
8890 }
8891 \f
8892 bfd_boolean
8893 _bfd_mips_relax_section (bfd *abfd, asection *sec,
8894 struct bfd_link_info *link_info,
8895 bfd_boolean *again)
8896 {
8897 Elf_Internal_Rela *internal_relocs;
8898 Elf_Internal_Rela *irel, *irelend;
8899 Elf_Internal_Shdr *symtab_hdr;
8900 bfd_byte *contents = NULL;
8901 size_t extsymoff;
8902 bfd_boolean changed_contents = FALSE;
8903 bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
8904 Elf_Internal_Sym *isymbuf = NULL;
8905
8906 /* We are not currently changing any sizes, so only one pass. */
8907 *again = FALSE;
8908
8909 if (bfd_link_relocatable (link_info))
8910 return TRUE;
8911
8912 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
8913 link_info->keep_memory);
8914 if (internal_relocs == NULL)
8915 return TRUE;
8916
8917 irelend = internal_relocs + sec->reloc_count
8918 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
8919 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8920 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8921
8922 for (irel = internal_relocs; irel < irelend; irel++)
8923 {
8924 bfd_vma symval;
8925 bfd_signed_vma sym_offset;
8926 unsigned int r_type;
8927 unsigned long r_symndx;
8928 asection *sym_sec;
8929 unsigned long instruction;
8930
8931 /* Turn jalr into bgezal, and jr into beq, if they're marked
8932 with a JALR relocation, that indicate where they jump to.
8933 This saves some pipeline bubbles. */
8934 r_type = ELF_R_TYPE (abfd, irel->r_info);
8935 if (r_type != R_MIPS_JALR)
8936 continue;
8937
8938 r_symndx = ELF_R_SYM (abfd, irel->r_info);
8939 /* Compute the address of the jump target. */
8940 if (r_symndx >= extsymoff)
8941 {
8942 struct mips_elf_link_hash_entry *h
8943 = ((struct mips_elf_link_hash_entry *)
8944 elf_sym_hashes (abfd) [r_symndx - extsymoff]);
8945
8946 while (h->root.root.type == bfd_link_hash_indirect
8947 || h->root.root.type == bfd_link_hash_warning)
8948 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8949
8950 /* If a symbol is undefined, or if it may be overridden,
8951 skip it. */
8952 if (! ((h->root.root.type == bfd_link_hash_defined
8953 || h->root.root.type == bfd_link_hash_defweak)
8954 && h->root.root.u.def.section)
8955 || (bfd_link_pic (link_info) && ! link_info->symbolic
8956 && !h->root.forced_local))
8957 continue;
8958
8959 sym_sec = h->root.root.u.def.section;
8960 if (sym_sec->output_section)
8961 symval = (h->root.root.u.def.value
8962 + sym_sec->output_section->vma
8963 + sym_sec->output_offset);
8964 else
8965 symval = h->root.root.u.def.value;
8966 }
8967 else
8968 {
8969 Elf_Internal_Sym *isym;
8970
8971 /* Read this BFD's symbols if we haven't done so already. */
8972 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
8973 {
8974 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
8975 if (isymbuf == NULL)
8976 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8977 symtab_hdr->sh_info, 0,
8978 NULL, NULL, NULL);
8979 if (isymbuf == NULL)
8980 goto relax_return;
8981 }
8982
8983 isym = isymbuf + r_symndx;
8984 if (isym->st_shndx == SHN_UNDEF)
8985 continue;
8986 else if (isym->st_shndx == SHN_ABS)
8987 sym_sec = bfd_abs_section_ptr;
8988 else if (isym->st_shndx == SHN_COMMON)
8989 sym_sec = bfd_com_section_ptr;
8990 else
8991 sym_sec
8992 = bfd_section_from_elf_index (abfd, isym->st_shndx);
8993 symval = isym->st_value
8994 + sym_sec->output_section->vma
8995 + sym_sec->output_offset;
8996 }
8997
8998 /* Compute branch offset, from delay slot of the jump to the
8999 branch target. */
9000 sym_offset = (symval + irel->r_addend)
9001 - (sec_start + irel->r_offset + 4);
9002
9003 /* Branch offset must be properly aligned. */
9004 if ((sym_offset & 3) != 0)
9005 continue;
9006
9007 sym_offset >>= 2;
9008
9009 /* Check that it's in range. */
9010 if (sym_offset < -0x8000 || sym_offset >= 0x8000)
9011 continue;
9012
9013 /* Get the section contents if we haven't done so already. */
9014 if (!mips_elf_get_section_contents (abfd, sec, &contents))
9015 goto relax_return;
9016
9017 instruction = bfd_get_32 (abfd, contents + irel->r_offset);
9018
9019 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
9020 if ((instruction & 0xfc1fffff) == 0x0000f809)
9021 instruction = 0x04110000;
9022 /* If it was jr <reg>, turn it into b <target>. */
9023 else if ((instruction & 0xfc1fffff) == 0x00000008)
9024 instruction = 0x10000000;
9025 else
9026 continue;
9027
9028 instruction |= (sym_offset & 0xffff);
9029 bfd_put_32 (abfd, instruction, contents + irel->r_offset);
9030 changed_contents = TRUE;
9031 }
9032
9033 if (contents != NULL
9034 && elf_section_data (sec)->this_hdr.contents != contents)
9035 {
9036 if (!changed_contents && !link_info->keep_memory)
9037 free (contents);
9038 else
9039 {
9040 /* Cache the section contents for elf_link_input_bfd. */
9041 elf_section_data (sec)->this_hdr.contents = contents;
9042 }
9043 }
9044 return TRUE;
9045
9046 relax_return:
9047 if (contents != NULL
9048 && elf_section_data (sec)->this_hdr.contents != contents)
9049 free (contents);
9050 return FALSE;
9051 }
9052 \f
9053 /* Allocate space for global sym dynamic relocs. */
9054
9055 static bfd_boolean
9056 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9057 {
9058 struct bfd_link_info *info = inf;
9059 bfd *dynobj;
9060 struct mips_elf_link_hash_entry *hmips;
9061 struct mips_elf_link_hash_table *htab;
9062
9063 htab = mips_elf_hash_table (info);
9064 BFD_ASSERT (htab != NULL);
9065
9066 dynobj = elf_hash_table (info)->dynobj;
9067 hmips = (struct mips_elf_link_hash_entry *) h;
9068
9069 /* VxWorks executables are handled elsewhere; we only need to
9070 allocate relocations in shared objects. */
9071 if (htab->is_vxworks && !bfd_link_pic (info))
9072 return TRUE;
9073
9074 /* Ignore indirect symbols. All relocations against such symbols
9075 will be redirected to the target symbol. */
9076 if (h->root.type == bfd_link_hash_indirect)
9077 return TRUE;
9078
9079 /* If this symbol is defined in a dynamic object, or we are creating
9080 a shared library, we will need to copy any R_MIPS_32 or
9081 R_MIPS_REL32 relocs against it into the output file. */
9082 if (! bfd_link_relocatable (info)
9083 && hmips->possibly_dynamic_relocs != 0
9084 && (h->root.type == bfd_link_hash_defweak
9085 || (!h->def_regular && !ELF_COMMON_DEF_P (h))
9086 || bfd_link_pic (info)))
9087 {
9088 bfd_boolean do_copy = TRUE;
9089
9090 if (h->root.type == bfd_link_hash_undefweak)
9091 {
9092 /* Do not copy relocations for undefined weak symbols with
9093 non-default visibility. */
9094 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9095 do_copy = FALSE;
9096
9097 /* Make sure undefined weak symbols are output as a dynamic
9098 symbol in PIEs. */
9099 else if (h->dynindx == -1 && !h->forced_local)
9100 {
9101 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9102 return FALSE;
9103 }
9104 }
9105
9106 if (do_copy)
9107 {
9108 /* Even though we don't directly need a GOT entry for this symbol,
9109 the SVR4 psABI requires it to have a dynamic symbol table
9110 index greater that DT_MIPS_GOTSYM if there are dynamic
9111 relocations against it.
9112
9113 VxWorks does not enforce the same mapping between the GOT
9114 and the symbol table, so the same requirement does not
9115 apply there. */
9116 if (!htab->is_vxworks)
9117 {
9118 if (hmips->global_got_area > GGA_RELOC_ONLY)
9119 hmips->global_got_area = GGA_RELOC_ONLY;
9120 hmips->got_only_for_calls = FALSE;
9121 }
9122
9123 mips_elf_allocate_dynamic_relocations
9124 (dynobj, info, hmips->possibly_dynamic_relocs);
9125 if (hmips->readonly_reloc)
9126 /* We tell the dynamic linker that there are relocations
9127 against the text segment. */
9128 info->flags |= DF_TEXTREL;
9129 }
9130 }
9131
9132 return TRUE;
9133 }
9134
9135 /* Adjust a symbol defined by a dynamic object and referenced by a
9136 regular object. The current definition is in some section of the
9137 dynamic object, but we're not including those sections. We have to
9138 change the definition to something the rest of the link can
9139 understand. */
9140
9141 bfd_boolean
9142 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
9143 struct elf_link_hash_entry *h)
9144 {
9145 bfd *dynobj;
9146 struct mips_elf_link_hash_entry *hmips;
9147 struct mips_elf_link_hash_table *htab;
9148 asection *s, *srel;
9149
9150 htab = mips_elf_hash_table (info);
9151 BFD_ASSERT (htab != NULL);
9152
9153 dynobj = elf_hash_table (info)->dynobj;
9154 hmips = (struct mips_elf_link_hash_entry *) h;
9155
9156 /* Make sure we know what is going on here. */
9157 BFD_ASSERT (dynobj != NULL
9158 && (h->needs_plt
9159 || h->u.weakdef != NULL
9160 || (h->def_dynamic
9161 && h->ref_regular
9162 && !h->def_regular)));
9163
9164 hmips = (struct mips_elf_link_hash_entry *) h;
9165
9166 /* If there are call relocations against an externally-defined symbol,
9167 see whether we can create a MIPS lazy-binding stub for it. We can
9168 only do this if all references to the function are through call
9169 relocations, and in that case, the traditional lazy-binding stubs
9170 are much more efficient than PLT entries.
9171
9172 Traditional stubs are only available on SVR4 psABI-based systems;
9173 VxWorks always uses PLTs instead. */
9174 if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
9175 {
9176 if (! elf_hash_table (info)->dynamic_sections_created)
9177 return TRUE;
9178
9179 /* If this symbol is not defined in a regular file, then set
9180 the symbol to the stub location. This is required to make
9181 function pointers compare as equal between the normal
9182 executable and the shared library. */
9183 if (!h->def_regular)
9184 {
9185 hmips->needs_lazy_stub = TRUE;
9186 htab->lazy_stub_count++;
9187 return TRUE;
9188 }
9189 }
9190 /* As above, VxWorks requires PLT entries for externally-defined
9191 functions that are only accessed through call relocations.
9192
9193 Both VxWorks and non-VxWorks targets also need PLT entries if there
9194 are static-only relocations against an externally-defined function.
9195 This can technically occur for shared libraries if there are
9196 branches to the symbol, although it is unlikely that this will be
9197 used in practice due to the short ranges involved. It can occur
9198 for any relative or absolute relocation in executables; in that
9199 case, the PLT entry becomes the function's canonical address. */
9200 else if (((h->needs_plt && !hmips->no_fn_stub)
9201 || (h->type == STT_FUNC && hmips->has_static_relocs))
9202 && htab->use_plts_and_copy_relocs
9203 && !SYMBOL_CALLS_LOCAL (info, h)
9204 && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
9205 && h->root.type == bfd_link_hash_undefweak))
9206 {
9207 bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
9208 bfd_boolean newabi_p = NEWABI_P (info->output_bfd);
9209
9210 /* If this is the first symbol to need a PLT entry, then make some
9211 basic setup. Also work out PLT entry sizes. We'll need them
9212 for PLT offset calculations. */
9213 if (htab->plt_mips_offset + htab->plt_comp_offset == 0)
9214 {
9215 BFD_ASSERT (htab->root.sgotplt->size == 0);
9216 BFD_ASSERT (htab->plt_got_index == 0);
9217
9218 /* If we're using the PLT additions to the psABI, each PLT
9219 entry is 16 bytes and the PLT0 entry is 32 bytes.
9220 Encourage better cache usage by aligning. We do this
9221 lazily to avoid pessimizing traditional objects. */
9222 if (!htab->is_vxworks
9223 && !bfd_set_section_alignment (dynobj, htab->root.splt, 5))
9224 return FALSE;
9225
9226 /* Make sure that .got.plt is word-aligned. We do this lazily
9227 for the same reason as above. */
9228 if (!bfd_set_section_alignment (dynobj, htab->root.sgotplt,
9229 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
9230 return FALSE;
9231
9232 /* On non-VxWorks targets, the first two entries in .got.plt
9233 are reserved. */
9234 if (!htab->is_vxworks)
9235 htab->plt_got_index
9236 += (get_elf_backend_data (dynobj)->got_header_size
9237 / MIPS_ELF_GOT_SIZE (dynobj));
9238
9239 /* On VxWorks, also allocate room for the header's
9240 .rela.plt.unloaded entries. */
9241 if (htab->is_vxworks && !bfd_link_pic (info))
9242 htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
9243
9244 /* Now work out the sizes of individual PLT entries. */
9245 if (htab->is_vxworks && bfd_link_pic (info))
9246 htab->plt_mips_entry_size
9247 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
9248 else if (htab->is_vxworks)
9249 htab->plt_mips_entry_size
9250 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
9251 else if (newabi_p)
9252 htab->plt_mips_entry_size
9253 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9254 else if (!micromips_p)
9255 {
9256 htab->plt_mips_entry_size
9257 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9258 htab->plt_comp_entry_size
9259 = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
9260 }
9261 else if (htab->insn32)
9262 {
9263 htab->plt_mips_entry_size
9264 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9265 htab->plt_comp_entry_size
9266 = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
9267 }
9268 else
9269 {
9270 htab->plt_mips_entry_size
9271 = 4 * ARRAY_SIZE (mips_exec_plt_entry);
9272 htab->plt_comp_entry_size
9273 = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
9274 }
9275 }
9276
9277 if (h->plt.plist == NULL)
9278 h->plt.plist = mips_elf_make_plt_record (dynobj);
9279 if (h->plt.plist == NULL)
9280 return FALSE;
9281
9282 /* There are no defined MIPS16 or microMIPS PLT entries for VxWorks,
9283 n32 or n64, so always use a standard entry there.
9284
9285 If the symbol has a MIPS16 call stub and gets a PLT entry, then
9286 all MIPS16 calls will go via that stub, and there is no benefit
9287 to having a MIPS16 entry. And in the case of call_stub a
9288 standard entry actually has to be used as the stub ends with a J
9289 instruction. */
9290 if (newabi_p
9291 || htab->is_vxworks
9292 || hmips->call_stub
9293 || hmips->call_fp_stub)
9294 {
9295 h->plt.plist->need_mips = TRUE;
9296 h->plt.plist->need_comp = FALSE;
9297 }
9298
9299 /* Otherwise, if there are no direct calls to the function, we
9300 have a free choice of whether to use standard or compressed
9301 entries. Prefer microMIPS entries if the object is known to
9302 contain microMIPS code, so that it becomes possible to create
9303 pure microMIPS binaries. Prefer standard entries otherwise,
9304 because MIPS16 ones are no smaller and are usually slower. */
9305 if (!h->plt.plist->need_mips && !h->plt.plist->need_comp)
9306 {
9307 if (micromips_p)
9308 h->plt.plist->need_comp = TRUE;
9309 else
9310 h->plt.plist->need_mips = TRUE;
9311 }
9312
9313 if (h->plt.plist->need_mips)
9314 {
9315 h->plt.plist->mips_offset = htab->plt_mips_offset;
9316 htab->plt_mips_offset += htab->plt_mips_entry_size;
9317 }
9318 if (h->plt.plist->need_comp)
9319 {
9320 h->plt.plist->comp_offset = htab->plt_comp_offset;
9321 htab->plt_comp_offset += htab->plt_comp_entry_size;
9322 }
9323
9324 /* Reserve the corresponding .got.plt entry now too. */
9325 h->plt.plist->gotplt_index = htab->plt_got_index++;
9326
9327 /* If the output file has no definition of the symbol, set the
9328 symbol's value to the address of the stub. */
9329 if (!bfd_link_pic (info) && !h->def_regular)
9330 hmips->use_plt_entry = TRUE;
9331
9332 /* Make room for the R_MIPS_JUMP_SLOT relocation. */
9333 htab->root.srelplt->size += (htab->is_vxworks
9334 ? MIPS_ELF_RELA_SIZE (dynobj)
9335 : MIPS_ELF_REL_SIZE (dynobj));
9336
9337 /* Make room for the .rela.plt.unloaded relocations. */
9338 if (htab->is_vxworks && !bfd_link_pic (info))
9339 htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
9340
9341 /* All relocations against this symbol that could have been made
9342 dynamic will now refer to the PLT entry instead. */
9343 hmips->possibly_dynamic_relocs = 0;
9344
9345 return TRUE;
9346 }
9347
9348 /* If this is a weak symbol, and there is a real definition, the
9349 processor independent code will have arranged for us to see the
9350 real definition first, and we can just use the same value. */
9351 if (h->u.weakdef != NULL)
9352 {
9353 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
9354 || h->u.weakdef->root.type == bfd_link_hash_defweak);
9355 h->root.u.def.section = h->u.weakdef->root.u.def.section;
9356 h->root.u.def.value = h->u.weakdef->root.u.def.value;
9357 return TRUE;
9358 }
9359
9360 /* Otherwise, there is nothing further to do for symbols defined
9361 in regular objects. */
9362 if (h->def_regular)
9363 return TRUE;
9364
9365 /* There's also nothing more to do if we'll convert all relocations
9366 against this symbol into dynamic relocations. */
9367 if (!hmips->has_static_relocs)
9368 return TRUE;
9369
9370 /* We're now relying on copy relocations. Complain if we have
9371 some that we can't convert. */
9372 if (!htab->use_plts_and_copy_relocs || bfd_link_pic (info))
9373 {
9374 _bfd_error_handler (_("non-dynamic relocations refer to "
9375 "dynamic symbol %s"),
9376 h->root.root.string);
9377 bfd_set_error (bfd_error_bad_value);
9378 return FALSE;
9379 }
9380
9381 /* We must allocate the symbol in our .dynbss section, which will
9382 become part of the .bss section of the executable. There will be
9383 an entry for this symbol in the .dynsym section. The dynamic
9384 object will contain position independent code, so all references
9385 from the dynamic object to this symbol will go through the global
9386 offset table. The dynamic linker will use the .dynsym entry to
9387 determine the address it must put in the global offset table, so
9388 both the dynamic object and the regular object will refer to the
9389 same memory location for the variable. */
9390
9391 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
9392 {
9393 s = htab->root.sdynrelro;
9394 srel = htab->root.sreldynrelro;
9395 }
9396 else
9397 {
9398 s = htab->root.sdynbss;
9399 srel = htab->root.srelbss;
9400 }
9401 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
9402 {
9403 if (htab->is_vxworks)
9404 srel->size += sizeof (Elf32_External_Rela);
9405 else
9406 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
9407 h->needs_copy = 1;
9408 }
9409
9410 /* All relocations against this symbol that could have been made
9411 dynamic will now refer to the local copy instead. */
9412 hmips->possibly_dynamic_relocs = 0;
9413
9414 return _bfd_elf_adjust_dynamic_copy (info, h, s);
9415 }
9416 \f
9417 /* This function is called after all the input files have been read,
9418 and the input sections have been assigned to output sections. We
9419 check for any mips16 stub sections that we can discard. */
9420
9421 bfd_boolean
9422 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
9423 struct bfd_link_info *info)
9424 {
9425 asection *sect;
9426 struct mips_elf_link_hash_table *htab;
9427 struct mips_htab_traverse_info hti;
9428
9429 htab = mips_elf_hash_table (info);
9430 BFD_ASSERT (htab != NULL);
9431
9432 /* The .reginfo section has a fixed size. */
9433 sect = bfd_get_section_by_name (output_bfd, ".reginfo");
9434 if (sect != NULL)
9435 bfd_set_section_size (output_bfd, sect, sizeof (Elf32_External_RegInfo));
9436
9437 /* The .MIPS.abiflags section has a fixed size. */
9438 sect = bfd_get_section_by_name (output_bfd, ".MIPS.abiflags");
9439 if (sect != NULL)
9440 bfd_set_section_size (output_bfd, sect, sizeof (Elf_External_ABIFlags_v0));
9441
9442 hti.info = info;
9443 hti.output_bfd = output_bfd;
9444 hti.error = FALSE;
9445 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
9446 mips_elf_check_symbols, &hti);
9447 if (hti.error)
9448 return FALSE;
9449
9450 return TRUE;
9451 }
9452
9453 /* If the link uses a GOT, lay it out and work out its size. */
9454
9455 static bfd_boolean
9456 mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
9457 {
9458 bfd *dynobj;
9459 asection *s;
9460 struct mips_got_info *g;
9461 bfd_size_type loadable_size = 0;
9462 bfd_size_type page_gotno;
9463 bfd *ibfd;
9464 struct mips_elf_traverse_got_arg tga;
9465 struct mips_elf_link_hash_table *htab;
9466
9467 htab = mips_elf_hash_table (info);
9468 BFD_ASSERT (htab != NULL);
9469
9470 s = htab->root.sgot;
9471 if (s == NULL)
9472 return TRUE;
9473
9474 dynobj = elf_hash_table (info)->dynobj;
9475 g = htab->got_info;
9476
9477 /* Allocate room for the reserved entries. VxWorks always reserves
9478 3 entries; other objects only reserve 2 entries. */
9479 BFD_ASSERT (g->assigned_low_gotno == 0);
9480 if (htab->is_vxworks)
9481 htab->reserved_gotno = 3;
9482 else
9483 htab->reserved_gotno = 2;
9484 g->local_gotno += htab->reserved_gotno;
9485 g->assigned_low_gotno = htab->reserved_gotno;
9486
9487 /* Decide which symbols need to go in the global part of the GOT and
9488 count the number of reloc-only GOT symbols. */
9489 mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info);
9490
9491 if (!mips_elf_resolve_final_got_entries (info, g))
9492 return FALSE;
9493
9494 /* Calculate the total loadable size of the output. That
9495 will give us the maximum number of GOT_PAGE entries
9496 required. */
9497 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
9498 {
9499 asection *subsection;
9500
9501 for (subsection = ibfd->sections;
9502 subsection;
9503 subsection = subsection->next)
9504 {
9505 if ((subsection->flags & SEC_ALLOC) == 0)
9506 continue;
9507 loadable_size += ((subsection->size + 0xf)
9508 &~ (bfd_size_type) 0xf);
9509 }
9510 }
9511
9512 if (htab->is_vxworks)
9513 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
9514 relocations against local symbols evaluate to "G", and the EABI does
9515 not include R_MIPS_GOT_PAGE. */
9516 page_gotno = 0;
9517 else
9518 /* Assume there are two loadable segments consisting of contiguous
9519 sections. Is 5 enough? */
9520 page_gotno = (loadable_size >> 16) + 5;
9521
9522 /* Choose the smaller of the two page estimates; both are intended to be
9523 conservative. */
9524 if (page_gotno > g->page_gotno)
9525 page_gotno = g->page_gotno;
9526
9527 g->local_gotno += page_gotno;
9528 g->assigned_high_gotno = g->local_gotno - 1;
9529
9530 s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9531 s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9532 s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
9533
9534 /* VxWorks does not support multiple GOTs. It initializes $gp to
9535 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
9536 dynamic loader. */
9537 if (!htab->is_vxworks && s->size > MIPS_ELF_GOT_MAX_SIZE (info))
9538 {
9539 if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
9540 return FALSE;
9541 }
9542 else
9543 {
9544 /* Record that all bfds use G. This also has the effect of freeing
9545 the per-bfd GOTs, which we no longer need. */
9546 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
9547 if (mips_elf_bfd_got (ibfd, FALSE))
9548 mips_elf_replace_bfd_got (ibfd, g);
9549 mips_elf_replace_bfd_got (output_bfd, g);
9550
9551 /* Set up TLS entries. */
9552 g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
9553 tga.info = info;
9554 tga.g = g;
9555 tga.value = MIPS_ELF_GOT_SIZE (output_bfd);
9556 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, &tga);
9557 if (!tga.g)
9558 return FALSE;
9559 BFD_ASSERT (g->tls_assigned_gotno
9560 == g->global_gotno + g->local_gotno + g->tls_gotno);
9561
9562 /* Each VxWorks GOT entry needs an explicit relocation. */
9563 if (htab->is_vxworks && bfd_link_pic (info))
9564 g->relocs += g->global_gotno + g->local_gotno - htab->reserved_gotno;
9565
9566 /* Allocate room for the TLS relocations. */
9567 if (g->relocs)
9568 mips_elf_allocate_dynamic_relocations (dynobj, info, g->relocs);
9569 }
9570
9571 return TRUE;
9572 }
9573
9574 /* Estimate the size of the .MIPS.stubs section. */
9575
9576 static void
9577 mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
9578 {
9579 struct mips_elf_link_hash_table *htab;
9580 bfd_size_type dynsymcount;
9581
9582 htab = mips_elf_hash_table (info);
9583 BFD_ASSERT (htab != NULL);
9584
9585 if (htab->lazy_stub_count == 0)
9586 return;
9587
9588 /* IRIX rld assumes that a function stub isn't at the end of the .text
9589 section, so add a dummy entry to the end. */
9590 htab->lazy_stub_count++;
9591
9592 /* Get a worst-case estimate of the number of dynamic symbols needed.
9593 At this point, dynsymcount does not account for section symbols
9594 and count_section_dynsyms may overestimate the number that will
9595 be needed. */
9596 dynsymcount = (elf_hash_table (info)->dynsymcount
9597 + count_section_dynsyms (output_bfd, info));
9598
9599 /* Determine the size of one stub entry. There's no disadvantage
9600 from using microMIPS code here, so for the sake of pure-microMIPS
9601 binaries we prefer it whenever there's any microMIPS code in
9602 output produced at all. This has a benefit of stubs being
9603 shorter by 4 bytes each too, unless in the insn32 mode. */
9604 if (!MICROMIPS_P (output_bfd))
9605 htab->function_stub_size = (dynsymcount > 0x10000
9606 ? MIPS_FUNCTION_STUB_BIG_SIZE
9607 : MIPS_FUNCTION_STUB_NORMAL_SIZE);
9608 else if (htab->insn32)
9609 htab->function_stub_size = (dynsymcount > 0x10000
9610 ? MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
9611 : MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE);
9612 else
9613 htab->function_stub_size = (dynsymcount > 0x10000
9614 ? MICROMIPS_FUNCTION_STUB_BIG_SIZE
9615 : MICROMIPS_FUNCTION_STUB_NORMAL_SIZE);
9616
9617 htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
9618 }
9619
9620 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9621 mips_htab_traverse_info. If H needs a traditional MIPS lazy-binding
9622 stub, allocate an entry in the stubs section. */
9623
9624 static bfd_boolean
9625 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void *data)
9626 {
9627 struct mips_htab_traverse_info *hti = data;
9628 struct mips_elf_link_hash_table *htab;
9629 struct bfd_link_info *info;
9630 bfd *output_bfd;
9631
9632 info = hti->info;
9633 output_bfd = hti->output_bfd;
9634 htab = mips_elf_hash_table (info);
9635 BFD_ASSERT (htab != NULL);
9636
9637 if (h->needs_lazy_stub)
9638 {
9639 bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
9640 unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9641 bfd_vma isa_bit = micromips_p;
9642
9643 BFD_ASSERT (htab->root.dynobj != NULL);
9644 if (h->root.plt.plist == NULL)
9645 h->root.plt.plist = mips_elf_make_plt_record (htab->sstubs->owner);
9646 if (h->root.plt.plist == NULL)
9647 {
9648 hti->error = TRUE;
9649 return FALSE;
9650 }
9651 h->root.root.u.def.section = htab->sstubs;
9652 h->root.root.u.def.value = htab->sstubs->size + isa_bit;
9653 h->root.plt.plist->stub_offset = htab->sstubs->size;
9654 h->root.other = other;
9655 htab->sstubs->size += htab->function_stub_size;
9656 }
9657 return TRUE;
9658 }
9659
9660 /* Allocate offsets in the stubs section to each symbol that needs one.
9661 Set the final size of the .MIPS.stub section. */
9662
9663 static bfd_boolean
9664 mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
9665 {
9666 bfd *output_bfd = info->output_bfd;
9667 bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
9668 unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9669 bfd_vma isa_bit = micromips_p;
9670 struct mips_elf_link_hash_table *htab;
9671 struct mips_htab_traverse_info hti;
9672 struct elf_link_hash_entry *h;
9673 bfd *dynobj;
9674
9675 htab = mips_elf_hash_table (info);
9676 BFD_ASSERT (htab != NULL);
9677
9678 if (htab->lazy_stub_count == 0)
9679 return TRUE;
9680
9681 htab->sstubs->size = 0;
9682 hti.info = info;
9683 hti.output_bfd = output_bfd;
9684 hti.error = FALSE;
9685 mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, &hti);
9686 if (hti.error)
9687 return FALSE;
9688 htab->sstubs->size += htab->function_stub_size;
9689 BFD_ASSERT (htab->sstubs->size
9690 == htab->lazy_stub_count * htab->function_stub_size);
9691
9692 dynobj = elf_hash_table (info)->dynobj;
9693 BFD_ASSERT (dynobj != NULL);
9694 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->sstubs, "_MIPS_STUBS_");
9695 if (h == NULL)
9696 return FALSE;
9697 h->root.u.def.value = isa_bit;
9698 h->other = other;
9699 h->type = STT_FUNC;
9700
9701 return TRUE;
9702 }
9703
9704 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9705 bfd_link_info. If H uses the address of a PLT entry as the value
9706 of the symbol, then set the entry in the symbol table now. Prefer
9707 a standard MIPS PLT entry. */
9708
9709 static bfd_boolean
9710 mips_elf_set_plt_sym_value (struct mips_elf_link_hash_entry *h, void *data)
9711 {
9712 struct bfd_link_info *info = data;
9713 bfd_boolean micromips_p = MICROMIPS_P (info->output_bfd);
9714 struct mips_elf_link_hash_table *htab;
9715 unsigned int other;
9716 bfd_vma isa_bit;
9717 bfd_vma val;
9718
9719 htab = mips_elf_hash_table (info);
9720 BFD_ASSERT (htab != NULL);
9721
9722 if (h->use_plt_entry)
9723 {
9724 BFD_ASSERT (h->root.plt.plist != NULL);
9725 BFD_ASSERT (h->root.plt.plist->mips_offset != MINUS_ONE
9726 || h->root.plt.plist->comp_offset != MINUS_ONE);
9727
9728 val = htab->plt_header_size;
9729 if (h->root.plt.plist->mips_offset != MINUS_ONE)
9730 {
9731 isa_bit = 0;
9732 val += h->root.plt.plist->mips_offset;
9733 other = 0;
9734 }
9735 else
9736 {
9737 isa_bit = 1;
9738 val += htab->plt_mips_offset + h->root.plt.plist->comp_offset;
9739 other = micromips_p ? STO_MICROMIPS : STO_MIPS16;
9740 }
9741 val += isa_bit;
9742 /* For VxWorks, point at the PLT load stub rather than the lazy
9743 resolution stub; this stub will become the canonical function
9744 address. */
9745 if (htab->is_vxworks)
9746 val += 8;
9747
9748 h->root.root.u.def.section = htab->root.splt;
9749 h->root.root.u.def.value = val;
9750 h->root.other = other;
9751 }
9752
9753 return TRUE;
9754 }
9755
9756 /* Set the sizes of the dynamic sections. */
9757
9758 bfd_boolean
9759 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
9760 struct bfd_link_info *info)
9761 {
9762 bfd *dynobj;
9763 asection *s, *sreldyn;
9764 bfd_boolean reltext;
9765 struct mips_elf_link_hash_table *htab;
9766
9767 htab = mips_elf_hash_table (info);
9768 BFD_ASSERT (htab != NULL);
9769 dynobj = elf_hash_table (info)->dynobj;
9770 BFD_ASSERT (dynobj != NULL);
9771
9772 if (elf_hash_table (info)->dynamic_sections_created)
9773 {
9774 /* Set the contents of the .interp section to the interpreter. */
9775 if (bfd_link_executable (info) && !info->nointerp)
9776 {
9777 s = bfd_get_linker_section (dynobj, ".interp");
9778 BFD_ASSERT (s != NULL);
9779 s->size
9780 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
9781 s->contents
9782 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
9783 }
9784
9785 /* Figure out the size of the PLT header if we know that we
9786 are using it. For the sake of cache alignment always use
9787 a standard header whenever any standard entries are present
9788 even if microMIPS entries are present as well. This also
9789 lets the microMIPS header rely on the value of $v0 only set
9790 by microMIPS entries, for a small size reduction.
9791
9792 Set symbol table entry values for symbols that use the
9793 address of their PLT entry now that we can calculate it.
9794
9795 Also create the _PROCEDURE_LINKAGE_TABLE_ symbol if we
9796 haven't already in _bfd_elf_create_dynamic_sections. */
9797 if (htab->root.splt && htab->plt_mips_offset + htab->plt_comp_offset != 0)
9798 {
9799 bfd_boolean micromips_p = (MICROMIPS_P (output_bfd)
9800 && !htab->plt_mips_offset);
9801 unsigned int other = micromips_p ? STO_MICROMIPS : 0;
9802 bfd_vma isa_bit = micromips_p;
9803 struct elf_link_hash_entry *h;
9804 bfd_vma size;
9805
9806 BFD_ASSERT (htab->use_plts_and_copy_relocs);
9807 BFD_ASSERT (htab->root.sgotplt->size == 0);
9808 BFD_ASSERT (htab->root.splt->size == 0);
9809
9810 if (htab->is_vxworks && bfd_link_pic (info))
9811 size = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
9812 else if (htab->is_vxworks)
9813 size = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
9814 else if (ABI_64_P (output_bfd))
9815 size = 4 * ARRAY_SIZE (mips_n64_exec_plt0_entry);
9816 else if (ABI_N32_P (output_bfd))
9817 size = 4 * ARRAY_SIZE (mips_n32_exec_plt0_entry);
9818 else if (!micromips_p)
9819 size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
9820 else if (htab->insn32)
9821 size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
9822 else
9823 size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
9824
9825 htab->plt_header_is_comp = micromips_p;
9826 htab->plt_header_size = size;
9827 htab->root.splt->size = (size
9828 + htab->plt_mips_offset
9829 + htab->plt_comp_offset);
9830 htab->root.sgotplt->size = (htab->plt_got_index
9831 * MIPS_ELF_GOT_SIZE (dynobj));
9832
9833 mips_elf_link_hash_traverse (htab, mips_elf_set_plt_sym_value, info);
9834
9835 if (htab->root.hplt == NULL)
9836 {
9837 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->root.splt,
9838 "_PROCEDURE_LINKAGE_TABLE_");
9839 htab->root.hplt = h;
9840 if (h == NULL)
9841 return FALSE;
9842 }
9843
9844 h = htab->root.hplt;
9845 h->root.u.def.value = isa_bit;
9846 h->other = other;
9847 h->type = STT_FUNC;
9848 }
9849 }
9850
9851 /* Allocate space for global sym dynamic relocs. */
9852 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
9853
9854 mips_elf_estimate_stub_size (output_bfd, info);
9855
9856 if (!mips_elf_lay_out_got (output_bfd, info))
9857 return FALSE;
9858
9859 mips_elf_lay_out_lazy_stubs (info);
9860
9861 /* The check_relocs and adjust_dynamic_symbol entry points have
9862 determined the sizes of the various dynamic sections. Allocate
9863 memory for them. */
9864 reltext = FALSE;
9865 for (s = dynobj->sections; s != NULL; s = s->next)
9866 {
9867 const char *name;
9868
9869 /* It's OK to base decisions on the section name, because none
9870 of the dynobj section names depend upon the input files. */
9871 name = bfd_get_section_name (dynobj, s);
9872
9873 if ((s->flags & SEC_LINKER_CREATED) == 0)
9874 continue;
9875
9876 if (CONST_STRNEQ (name, ".rel"))
9877 {
9878 if (s->size != 0)
9879 {
9880 const char *outname;
9881 asection *target;
9882
9883 /* If this relocation section applies to a read only
9884 section, then we probably need a DT_TEXTREL entry.
9885 If the relocation section is .rel(a).dyn, we always
9886 assert a DT_TEXTREL entry rather than testing whether
9887 there exists a relocation to a read only section or
9888 not. */
9889 outname = bfd_get_section_name (output_bfd,
9890 s->output_section);
9891 target = bfd_get_section_by_name (output_bfd, outname + 4);
9892 if ((target != NULL
9893 && (target->flags & SEC_READONLY) != 0
9894 && (target->flags & SEC_ALLOC) != 0)
9895 || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
9896 reltext = TRUE;
9897
9898 /* We use the reloc_count field as a counter if we need
9899 to copy relocs into the output file. */
9900 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
9901 s->reloc_count = 0;
9902
9903 /* If combreloc is enabled, elf_link_sort_relocs() will
9904 sort relocations, but in a different way than we do,
9905 and before we're done creating relocations. Also, it
9906 will move them around between input sections'
9907 relocation's contents, so our sorting would be
9908 broken, so don't let it run. */
9909 info->combreloc = 0;
9910 }
9911 }
9912 else if (bfd_link_executable (info)
9913 && ! mips_elf_hash_table (info)->use_rld_obj_head
9914 && CONST_STRNEQ (name, ".rld_map"))
9915 {
9916 /* We add a room for __rld_map. It will be filled in by the
9917 rtld to contain a pointer to the _r_debug structure. */
9918 s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd);
9919 }
9920 else if (SGI_COMPAT (output_bfd)
9921 && CONST_STRNEQ (name, ".compact_rel"))
9922 s->size += mips_elf_hash_table (info)->compact_rel_size;
9923 else if (s == htab->root.splt)
9924 {
9925 /* If the last PLT entry has a branch delay slot, allocate
9926 room for an extra nop to fill the delay slot. This is
9927 for CPUs without load interlocking. */
9928 if (! LOAD_INTERLOCKS_P (output_bfd)
9929 && ! htab->is_vxworks && s->size > 0)
9930 s->size += 4;
9931 }
9932 else if (! CONST_STRNEQ (name, ".init")
9933 && s != htab->root.sgot
9934 && s != htab->root.sgotplt
9935 && s != htab->sstubs
9936 && s != htab->root.sdynbss
9937 && s != htab->root.sdynrelro)
9938 {
9939 /* It's not one of our sections, so don't allocate space. */
9940 continue;
9941 }
9942
9943 if (s->size == 0)
9944 {
9945 s->flags |= SEC_EXCLUDE;
9946 continue;
9947 }
9948
9949 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9950 continue;
9951
9952 /* Allocate memory for the section contents. */
9953 s->contents = bfd_zalloc (dynobj, s->size);
9954 if (s->contents == NULL)
9955 {
9956 bfd_set_error (bfd_error_no_memory);
9957 return FALSE;
9958 }
9959 }
9960
9961 if (elf_hash_table (info)->dynamic_sections_created)
9962 {
9963 /* Add some entries to the .dynamic section. We fill in the
9964 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
9965 must add the entries now so that we get the correct size for
9966 the .dynamic section. */
9967
9968 /* SGI object has the equivalence of DT_DEBUG in the
9969 DT_MIPS_RLD_MAP entry. This must come first because glibc
9970 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
9971 may only look at the first one they see. */
9972 if (!bfd_link_pic (info)
9973 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
9974 return FALSE;
9975
9976 if (bfd_link_executable (info)
9977 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP_REL, 0))
9978 return FALSE;
9979
9980 /* The DT_DEBUG entry may be filled in by the dynamic linker and
9981 used by the debugger. */
9982 if (bfd_link_executable (info)
9983 && !SGI_COMPAT (output_bfd)
9984 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
9985 return FALSE;
9986
9987 if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
9988 info->flags |= DF_TEXTREL;
9989
9990 if ((info->flags & DF_TEXTREL) != 0)
9991 {
9992 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
9993 return FALSE;
9994
9995 /* Clear the DF_TEXTREL flag. It will be set again if we
9996 write out an actual text relocation; we may not, because
9997 at this point we do not know whether e.g. any .eh_frame
9998 absolute relocations have been converted to PC-relative. */
9999 info->flags &= ~DF_TEXTREL;
10000 }
10001
10002 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
10003 return FALSE;
10004
10005 sreldyn = mips_elf_rel_dyn_section (info, FALSE);
10006 if (htab->is_vxworks)
10007 {
10008 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
10009 use any of the DT_MIPS_* tags. */
10010 if (sreldyn && sreldyn->size > 0)
10011 {
10012 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
10013 return FALSE;
10014
10015 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
10016 return FALSE;
10017
10018 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
10019 return FALSE;
10020 }
10021 }
10022 else
10023 {
10024 if (sreldyn && sreldyn->size > 0)
10025 {
10026 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
10027 return FALSE;
10028
10029 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
10030 return FALSE;
10031
10032 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
10033 return FALSE;
10034 }
10035
10036 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
10037 return FALSE;
10038
10039 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
10040 return FALSE;
10041
10042 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
10043 return FALSE;
10044
10045 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
10046 return FALSE;
10047
10048 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
10049 return FALSE;
10050
10051 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
10052 return FALSE;
10053
10054 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
10055 return FALSE;
10056
10057 if (IRIX_COMPAT (dynobj) == ict_irix5
10058 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
10059 return FALSE;
10060
10061 if (IRIX_COMPAT (dynobj) == ict_irix6
10062 && (bfd_get_section_by_name
10063 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
10064 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
10065 return FALSE;
10066 }
10067 if (htab->root.splt->size > 0)
10068 {
10069 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
10070 return FALSE;
10071
10072 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
10073 return FALSE;
10074
10075 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
10076 return FALSE;
10077
10078 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
10079 return FALSE;
10080 }
10081 if (htab->is_vxworks
10082 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
10083 return FALSE;
10084 }
10085
10086 return TRUE;
10087 }
10088 \f
10089 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
10090 Adjust its R_ADDEND field so that it is correct for the output file.
10091 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
10092 and sections respectively; both use symbol indexes. */
10093
10094 static void
10095 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
10096 bfd *input_bfd, Elf_Internal_Sym *local_syms,
10097 asection **local_sections, Elf_Internal_Rela *rel)
10098 {
10099 unsigned int r_type, r_symndx;
10100 Elf_Internal_Sym *sym;
10101 asection *sec;
10102
10103 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
10104 {
10105 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
10106 if (gprel16_reloc_p (r_type)
10107 || r_type == R_MIPS_GPREL32
10108 || literal_reloc_p (r_type))
10109 {
10110 rel->r_addend += _bfd_get_gp_value (input_bfd);
10111 rel->r_addend -= _bfd_get_gp_value (output_bfd);
10112 }
10113
10114 r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
10115 sym = local_syms + r_symndx;
10116
10117 /* Adjust REL's addend to account for section merging. */
10118 if (!bfd_link_relocatable (info))
10119 {
10120 sec = local_sections[r_symndx];
10121 _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
10122 }
10123
10124 /* This would normally be done by the rela_normal code in elflink.c. */
10125 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10126 rel->r_addend += local_sections[r_symndx]->output_offset;
10127 }
10128 }
10129
10130 /* Handle relocations against symbols from removed linkonce sections,
10131 or sections discarded by a linker script. We use this wrapper around
10132 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
10133 on 64-bit ELF targets. In this case for any relocation handled, which
10134 always be the first in a triplet, the remaining two have to be processed
10135 together with the first, even if they are R_MIPS_NONE. It is the symbol
10136 index referred by the first reloc that applies to all the three and the
10137 remaining two never refer to an object symbol. And it is the final
10138 relocation (the last non-null one) that determines the output field of
10139 the whole relocation so retrieve the corresponding howto structure for
10140 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
10141
10142 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
10143 and therefore requires to be pasted in a loop. It also defines a block
10144 and does not protect any of its arguments, hence the extra brackets. */
10145
10146 static void
10147 mips_reloc_against_discarded_section (bfd *output_bfd,
10148 struct bfd_link_info *info,
10149 bfd *input_bfd, asection *input_section,
10150 Elf_Internal_Rela **rel,
10151 const Elf_Internal_Rela **relend,
10152 bfd_boolean rel_reloc,
10153 reloc_howto_type *howto,
10154 bfd_byte *contents)
10155 {
10156 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
10157 int count = bed->s->int_rels_per_ext_rel;
10158 unsigned int r_type;
10159 int i;
10160
10161 for (i = count - 1; i > 0; i--)
10162 {
10163 r_type = ELF_R_TYPE (output_bfd, (*rel)[i].r_info);
10164 if (r_type != R_MIPS_NONE)
10165 {
10166 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
10167 break;
10168 }
10169 }
10170 do
10171 {
10172 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
10173 (*rel), count, (*relend),
10174 howto, i, contents);
10175 }
10176 while (0);
10177 }
10178
10179 /* Relocate a MIPS ELF section. */
10180
10181 bfd_boolean
10182 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
10183 bfd *input_bfd, asection *input_section,
10184 bfd_byte *contents, Elf_Internal_Rela *relocs,
10185 Elf_Internal_Sym *local_syms,
10186 asection **local_sections)
10187 {
10188 Elf_Internal_Rela *rel;
10189 const Elf_Internal_Rela *relend;
10190 bfd_vma addend = 0;
10191 bfd_boolean use_saved_addend_p = FALSE;
10192 const struct elf_backend_data *bed;
10193
10194 bed = get_elf_backend_data (output_bfd);
10195 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
10196 for (rel = relocs; rel < relend; ++rel)
10197 {
10198 const char *name;
10199 bfd_vma value = 0;
10200 reloc_howto_type *howto;
10201 bfd_boolean cross_mode_jump_p = FALSE;
10202 /* TRUE if the relocation is a RELA relocation, rather than a
10203 REL relocation. */
10204 bfd_boolean rela_relocation_p = TRUE;
10205 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
10206 const char *msg;
10207 unsigned long r_symndx;
10208 asection *sec;
10209 Elf_Internal_Shdr *symtab_hdr;
10210 struct elf_link_hash_entry *h;
10211 bfd_boolean rel_reloc;
10212
10213 rel_reloc = (NEWABI_P (input_bfd)
10214 && mips_elf_rel_relocation_p (input_bfd, input_section,
10215 relocs, rel));
10216 /* Find the relocation howto for this relocation. */
10217 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
10218
10219 r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
10220 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
10221 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
10222 {
10223 sec = local_sections[r_symndx];
10224 h = NULL;
10225 }
10226 else
10227 {
10228 unsigned long extsymoff;
10229
10230 extsymoff = 0;
10231 if (!elf_bad_symtab (input_bfd))
10232 extsymoff = symtab_hdr->sh_info;
10233 h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
10234 while (h->root.type == bfd_link_hash_indirect
10235 || h->root.type == bfd_link_hash_warning)
10236 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10237
10238 sec = NULL;
10239 if (h->root.type == bfd_link_hash_defined
10240 || h->root.type == bfd_link_hash_defweak)
10241 sec = h->root.u.def.section;
10242 }
10243
10244 if (sec != NULL && discarded_section (sec))
10245 {
10246 mips_reloc_against_discarded_section (output_bfd, info, input_bfd,
10247 input_section, &rel, &relend,
10248 rel_reloc, howto, contents);
10249 continue;
10250 }
10251
10252 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
10253 {
10254 /* Some 32-bit code uses R_MIPS_64. In particular, people use
10255 64-bit code, but make sure all their addresses are in the
10256 lowermost or uppermost 32-bit section of the 64-bit address
10257 space. Thus, when they use an R_MIPS_64 they mean what is
10258 usually meant by R_MIPS_32, with the exception that the
10259 stored value is sign-extended to 64 bits. */
10260 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
10261
10262 /* On big-endian systems, we need to lie about the position
10263 of the reloc. */
10264 if (bfd_big_endian (input_bfd))
10265 rel->r_offset += 4;
10266 }
10267
10268 if (!use_saved_addend_p)
10269 {
10270 /* If these relocations were originally of the REL variety,
10271 we must pull the addend out of the field that will be
10272 relocated. Otherwise, we simply use the contents of the
10273 RELA relocation. */
10274 if (mips_elf_rel_relocation_p (input_bfd, input_section,
10275 relocs, rel))
10276 {
10277 rela_relocation_p = FALSE;
10278 addend = mips_elf_read_rel_addend (input_bfd, rel,
10279 howto, contents);
10280 if (hi16_reloc_p (r_type)
10281 || (got16_reloc_p (r_type)
10282 && mips_elf_local_relocation_p (input_bfd, rel,
10283 local_sections)))
10284 {
10285 if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
10286 contents, &addend))
10287 {
10288 if (h)
10289 name = h->root.root.string;
10290 else
10291 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
10292 local_syms + r_symndx,
10293 sec);
10294 _bfd_error_handler
10295 /* xgettext:c-format */
10296 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
10297 input_bfd, input_section, name, howto->name,
10298 rel->r_offset);
10299 }
10300 }
10301 else
10302 addend <<= howto->rightshift;
10303 }
10304 else
10305 addend = rel->r_addend;
10306 mips_elf_adjust_addend (output_bfd, info, input_bfd,
10307 local_syms, local_sections, rel);
10308 }
10309
10310 if (bfd_link_relocatable (info))
10311 {
10312 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
10313 && bfd_big_endian (input_bfd))
10314 rel->r_offset -= 4;
10315
10316 if (!rela_relocation_p && rel->r_addend)
10317 {
10318 addend += rel->r_addend;
10319 if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
10320 addend = mips_elf_high (addend);
10321 else if (r_type == R_MIPS_HIGHER)
10322 addend = mips_elf_higher (addend);
10323 else if (r_type == R_MIPS_HIGHEST)
10324 addend = mips_elf_highest (addend);
10325 else
10326 addend >>= howto->rightshift;
10327
10328 /* We use the source mask, rather than the destination
10329 mask because the place to which we are writing will be
10330 source of the addend in the final link. */
10331 addend &= howto->src_mask;
10332
10333 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
10334 /* See the comment above about using R_MIPS_64 in the 32-bit
10335 ABI. Here, we need to update the addend. It would be
10336 possible to get away with just using the R_MIPS_32 reloc
10337 but for endianness. */
10338 {
10339 bfd_vma sign_bits;
10340 bfd_vma low_bits;
10341 bfd_vma high_bits;
10342
10343 if (addend & ((bfd_vma) 1 << 31))
10344 #ifdef BFD64
10345 sign_bits = ((bfd_vma) 1 << 32) - 1;
10346 #else
10347 sign_bits = -1;
10348 #endif
10349 else
10350 sign_bits = 0;
10351
10352 /* If we don't know that we have a 64-bit type,
10353 do two separate stores. */
10354 if (bfd_big_endian (input_bfd))
10355 {
10356 /* Store the sign-bits (which are most significant)
10357 first. */
10358 low_bits = sign_bits;
10359 high_bits = addend;
10360 }
10361 else
10362 {
10363 low_bits = addend;
10364 high_bits = sign_bits;
10365 }
10366 bfd_put_32 (input_bfd, low_bits,
10367 contents + rel->r_offset);
10368 bfd_put_32 (input_bfd, high_bits,
10369 contents + rel->r_offset + 4);
10370 continue;
10371 }
10372
10373 if (! mips_elf_perform_relocation (info, howto, rel, addend,
10374 input_bfd, input_section,
10375 contents, FALSE))
10376 return FALSE;
10377 }
10378
10379 /* Go on to the next relocation. */
10380 continue;
10381 }
10382
10383 /* In the N32 and 64-bit ABIs there may be multiple consecutive
10384 relocations for the same offset. In that case we are
10385 supposed to treat the output of each relocation as the addend
10386 for the next. */
10387 if (rel + 1 < relend
10388 && rel->r_offset == rel[1].r_offset
10389 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
10390 use_saved_addend_p = TRUE;
10391 else
10392 use_saved_addend_p = FALSE;
10393
10394 /* Figure out what value we are supposed to relocate. */
10395 switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
10396 input_section, info, rel,
10397 addend, howto, local_syms,
10398 local_sections, &value,
10399 &name, &cross_mode_jump_p,
10400 use_saved_addend_p))
10401 {
10402 case bfd_reloc_continue:
10403 /* There's nothing to do. */
10404 continue;
10405
10406 case bfd_reloc_undefined:
10407 /* mips_elf_calculate_relocation already called the
10408 undefined_symbol callback. There's no real point in
10409 trying to perform the relocation at this point, so we
10410 just skip ahead to the next relocation. */
10411 continue;
10412
10413 case bfd_reloc_notsupported:
10414 msg = _("internal error: unsupported relocation error");
10415 info->callbacks->warning
10416 (info, msg, name, input_bfd, input_section, rel->r_offset);
10417 return FALSE;
10418
10419 case bfd_reloc_overflow:
10420 if (use_saved_addend_p)
10421 /* Ignore overflow until we reach the last relocation for
10422 a given location. */
10423 ;
10424 else
10425 {
10426 struct mips_elf_link_hash_table *htab;
10427
10428 htab = mips_elf_hash_table (info);
10429 BFD_ASSERT (htab != NULL);
10430 BFD_ASSERT (name != NULL);
10431 if (!htab->small_data_overflow_reported
10432 && (gprel16_reloc_p (howto->type)
10433 || literal_reloc_p (howto->type)))
10434 {
10435 msg = _("small-data section exceeds 64KB;"
10436 " lower small-data size limit (see option -G)");
10437
10438 htab->small_data_overflow_reported = TRUE;
10439 (*info->callbacks->einfo) ("%P: %s\n", msg);
10440 }
10441 (*info->callbacks->reloc_overflow)
10442 (info, NULL, name, howto->name, (bfd_vma) 0,
10443 input_bfd, input_section, rel->r_offset);
10444 }
10445 break;
10446
10447 case bfd_reloc_ok:
10448 break;
10449
10450 case bfd_reloc_outofrange:
10451 msg = NULL;
10452 if (jal_reloc_p (howto->type))
10453 msg = (cross_mode_jump_p
10454 ? _("Cannot convert a jump to JALX "
10455 "for a non-word-aligned address")
10456 : (howto->type == R_MIPS16_26
10457 ? _("Jump to a non-word-aligned address")
10458 : _("Jump to a non-instruction-aligned address")));
10459 else if (b_reloc_p (howto->type))
10460 msg = (cross_mode_jump_p
10461 ? _("Cannot convert a branch to JALX "
10462 "for a non-word-aligned address")
10463 : _("Branch to a non-instruction-aligned address"));
10464 else if (aligned_pcrel_reloc_p (howto->type))
10465 msg = _("PC-relative load from unaligned address");
10466 if (msg)
10467 {
10468 info->callbacks->einfo
10469 ("%X%H: %s\n", input_bfd, input_section, rel->r_offset, msg);
10470 break;
10471 }
10472 /* Fall through. */
10473
10474 default:
10475 abort ();
10476 break;
10477 }
10478
10479 /* If we've got another relocation for the address, keep going
10480 until we reach the last one. */
10481 if (use_saved_addend_p)
10482 {
10483 addend = value;
10484 continue;
10485 }
10486
10487 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
10488 /* See the comment above about using R_MIPS_64 in the 32-bit
10489 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
10490 that calculated the right value. Now, however, we
10491 sign-extend the 32-bit result to 64-bits, and store it as a
10492 64-bit value. We are especially generous here in that we
10493 go to extreme lengths to support this usage on systems with
10494 only a 32-bit VMA. */
10495 {
10496 bfd_vma sign_bits;
10497 bfd_vma low_bits;
10498 bfd_vma high_bits;
10499
10500 if (value & ((bfd_vma) 1 << 31))
10501 #ifdef BFD64
10502 sign_bits = ((bfd_vma) 1 << 32) - 1;
10503 #else
10504 sign_bits = -1;
10505 #endif
10506 else
10507 sign_bits = 0;
10508
10509 /* If we don't know that we have a 64-bit type,
10510 do two separate stores. */
10511 if (bfd_big_endian (input_bfd))
10512 {
10513 /* Undo what we did above. */
10514 rel->r_offset -= 4;
10515 /* Store the sign-bits (which are most significant)
10516 first. */
10517 low_bits = sign_bits;
10518 high_bits = value;
10519 }
10520 else
10521 {
10522 low_bits = value;
10523 high_bits = sign_bits;
10524 }
10525 bfd_put_32 (input_bfd, low_bits,
10526 contents + rel->r_offset);
10527 bfd_put_32 (input_bfd, high_bits,
10528 contents + rel->r_offset + 4);
10529 continue;
10530 }
10531
10532 /* Actually perform the relocation. */
10533 if (! mips_elf_perform_relocation (info, howto, rel, value,
10534 input_bfd, input_section,
10535 contents, cross_mode_jump_p))
10536 return FALSE;
10537 }
10538
10539 return TRUE;
10540 }
10541 \f
10542 /* A function that iterates over each entry in la25_stubs and fills
10543 in the code for each one. DATA points to a mips_htab_traverse_info. */
10544
10545 static int
10546 mips_elf_create_la25_stub (void **slot, void *data)
10547 {
10548 struct mips_htab_traverse_info *hti;
10549 struct mips_elf_link_hash_table *htab;
10550 struct mips_elf_la25_stub *stub;
10551 asection *s;
10552 bfd_byte *loc;
10553 bfd_vma offset, target, target_high, target_low;
10554
10555 stub = (struct mips_elf_la25_stub *) *slot;
10556 hti = (struct mips_htab_traverse_info *) data;
10557 htab = mips_elf_hash_table (hti->info);
10558 BFD_ASSERT (htab != NULL);
10559
10560 /* Create the section contents, if we haven't already. */
10561 s = stub->stub_section;
10562 loc = s->contents;
10563 if (loc == NULL)
10564 {
10565 loc = bfd_malloc (s->size);
10566 if (loc == NULL)
10567 {
10568 hti->error = TRUE;
10569 return FALSE;
10570 }
10571 s->contents = loc;
10572 }
10573
10574 /* Work out where in the section this stub should go. */
10575 offset = stub->offset;
10576
10577 /* Work out the target address. */
10578 target = mips_elf_get_la25_target (stub, &s);
10579 target += s->output_section->vma + s->output_offset;
10580
10581 target_high = ((target + 0x8000) >> 16) & 0xffff;
10582 target_low = (target & 0xffff);
10583
10584 if (stub->stub_section != htab->strampoline)
10585 {
10586 /* This is a simple LUI/ADDIU stub. Zero out the beginning
10587 of the section and write the two instructions at the end. */
10588 memset (loc, 0, offset);
10589 loc += offset;
10590 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
10591 {
10592 bfd_put_micromips_32 (hti->output_bfd,
10593 LA25_LUI_MICROMIPS (target_high),
10594 loc);
10595 bfd_put_micromips_32 (hti->output_bfd,
10596 LA25_ADDIU_MICROMIPS (target_low),
10597 loc + 4);
10598 }
10599 else
10600 {
10601 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
10602 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
10603 }
10604 }
10605 else
10606 {
10607 /* This is trampoline. */
10608 loc += offset;
10609 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
10610 {
10611 bfd_put_micromips_32 (hti->output_bfd,
10612 LA25_LUI_MICROMIPS (target_high), loc);
10613 bfd_put_micromips_32 (hti->output_bfd,
10614 LA25_J_MICROMIPS (target), loc + 4);
10615 bfd_put_micromips_32 (hti->output_bfd,
10616 LA25_ADDIU_MICROMIPS (target_low), loc + 8);
10617 bfd_put_32 (hti->output_bfd, 0, loc + 12);
10618 }
10619 else
10620 {
10621 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
10622 bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
10623 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
10624 bfd_put_32 (hti->output_bfd, 0, loc + 12);
10625 }
10626 }
10627 return TRUE;
10628 }
10629
10630 /* If NAME is one of the special IRIX6 symbols defined by the linker,
10631 adjust it appropriately now. */
10632
10633 static void
10634 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
10635 const char *name, Elf_Internal_Sym *sym)
10636 {
10637 /* The linker script takes care of providing names and values for
10638 these, but we must place them into the right sections. */
10639 static const char* const text_section_symbols[] = {
10640 "_ftext",
10641 "_etext",
10642 "__dso_displacement",
10643 "__elf_header",
10644 "__program_header_table",
10645 NULL
10646 };
10647
10648 static const char* const data_section_symbols[] = {
10649 "_fdata",
10650 "_edata",
10651 "_end",
10652 "_fbss",
10653 NULL
10654 };
10655
10656 const char* const *p;
10657 int i;
10658
10659 for (i = 0; i < 2; ++i)
10660 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
10661 *p;
10662 ++p)
10663 if (strcmp (*p, name) == 0)
10664 {
10665 /* All of these symbols are given type STT_SECTION by the
10666 IRIX6 linker. */
10667 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10668 sym->st_other = STO_PROTECTED;
10669
10670 /* The IRIX linker puts these symbols in special sections. */
10671 if (i == 0)
10672 sym->st_shndx = SHN_MIPS_TEXT;
10673 else
10674 sym->st_shndx = SHN_MIPS_DATA;
10675
10676 break;
10677 }
10678 }
10679
10680 /* Finish up dynamic symbol handling. We set the contents of various
10681 dynamic sections here. */
10682
10683 bfd_boolean
10684 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
10685 struct bfd_link_info *info,
10686 struct elf_link_hash_entry *h,
10687 Elf_Internal_Sym *sym)
10688 {
10689 bfd *dynobj;
10690 asection *sgot;
10691 struct mips_got_info *g, *gg;
10692 const char *name;
10693 int idx;
10694 struct mips_elf_link_hash_table *htab;
10695 struct mips_elf_link_hash_entry *hmips;
10696
10697 htab = mips_elf_hash_table (info);
10698 BFD_ASSERT (htab != NULL);
10699 dynobj = elf_hash_table (info)->dynobj;
10700 hmips = (struct mips_elf_link_hash_entry *) h;
10701
10702 BFD_ASSERT (!htab->is_vxworks);
10703
10704 if (h->plt.plist != NULL
10705 && (h->plt.plist->mips_offset != MINUS_ONE
10706 || h->plt.plist->comp_offset != MINUS_ONE))
10707 {
10708 /* We've decided to create a PLT entry for this symbol. */
10709 bfd_byte *loc;
10710 bfd_vma header_address, got_address;
10711 bfd_vma got_address_high, got_address_low, load;
10712 bfd_vma got_index;
10713 bfd_vma isa_bit;
10714
10715 got_index = h->plt.plist->gotplt_index;
10716
10717 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10718 BFD_ASSERT (h->dynindx != -1);
10719 BFD_ASSERT (htab->root.splt != NULL);
10720 BFD_ASSERT (got_index != MINUS_ONE);
10721 BFD_ASSERT (!h->def_regular);
10722
10723 /* Calculate the address of the PLT header. */
10724 isa_bit = htab->plt_header_is_comp;
10725 header_address = (htab->root.splt->output_section->vma
10726 + htab->root.splt->output_offset + isa_bit);
10727
10728 /* Calculate the address of the .got.plt entry. */
10729 got_address = (htab->root.sgotplt->output_section->vma
10730 + htab->root.sgotplt->output_offset
10731 + got_index * MIPS_ELF_GOT_SIZE (dynobj));
10732
10733 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
10734 got_address_low = got_address & 0xffff;
10735
10736 /* Initially point the .got.plt entry at the PLT header. */
10737 loc = (htab->root.sgotplt->contents + got_index * MIPS_ELF_GOT_SIZE (dynobj));
10738 if (ABI_64_P (output_bfd))
10739 bfd_put_64 (output_bfd, header_address, loc);
10740 else
10741 bfd_put_32 (output_bfd, header_address, loc);
10742
10743 /* Now handle the PLT itself. First the standard entry (the order
10744 does not matter, we just have to pick one). */
10745 if (h->plt.plist->mips_offset != MINUS_ONE)
10746 {
10747 const bfd_vma *plt_entry;
10748 bfd_vma plt_offset;
10749
10750 plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
10751
10752 BFD_ASSERT (plt_offset <= htab->root.splt->size);
10753
10754 /* Find out where the .plt entry should go. */
10755 loc = htab->root.splt->contents + plt_offset;
10756
10757 /* Pick the load opcode. */
10758 load = MIPS_ELF_LOAD_WORD (output_bfd);
10759
10760 /* Fill in the PLT entry itself. */
10761
10762 if (MIPSR6_P (output_bfd))
10763 plt_entry = mipsr6_exec_plt_entry;
10764 else
10765 plt_entry = mips_exec_plt_entry;
10766 bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
10767 bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load,
10768 loc + 4);
10769
10770 if (! LOAD_INTERLOCKS_P (output_bfd))
10771 {
10772 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
10773 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10774 }
10775 else
10776 {
10777 bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
10778 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low,
10779 loc + 12);
10780 }
10781 }
10782
10783 /* Now the compressed entry. They come after any standard ones. */
10784 if (h->plt.plist->comp_offset != MINUS_ONE)
10785 {
10786 bfd_vma plt_offset;
10787
10788 plt_offset = (htab->plt_header_size + htab->plt_mips_offset
10789 + h->plt.plist->comp_offset);
10790
10791 BFD_ASSERT (plt_offset <= htab->root.splt->size);
10792
10793 /* Find out where the .plt entry should go. */
10794 loc = htab->root.splt->contents + plt_offset;
10795
10796 /* Fill in the PLT entry itself. */
10797 if (!MICROMIPS_P (output_bfd))
10798 {
10799 const bfd_vma *plt_entry = mips16_o32_exec_plt_entry;
10800
10801 bfd_put_16 (output_bfd, plt_entry[0], loc);
10802 bfd_put_16 (output_bfd, plt_entry[1], loc + 2);
10803 bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10804 bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
10805 bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10806 bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10807 bfd_put_32 (output_bfd, got_address, loc + 12);
10808 }
10809 else if (htab->insn32)
10810 {
10811 const bfd_vma *plt_entry = micromips_insn32_o32_exec_plt_entry;
10812
10813 bfd_put_16 (output_bfd, plt_entry[0], loc);
10814 bfd_put_16 (output_bfd, got_address_high, loc + 2);
10815 bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10816 bfd_put_16 (output_bfd, got_address_low, loc + 6);
10817 bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10818 bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10819 bfd_put_16 (output_bfd, plt_entry[6], loc + 12);
10820 bfd_put_16 (output_bfd, got_address_low, loc + 14);
10821 }
10822 else
10823 {
10824 const bfd_vma *plt_entry = micromips_o32_exec_plt_entry;
10825 bfd_signed_vma gotpc_offset;
10826 bfd_vma loc_address;
10827
10828 BFD_ASSERT (got_address % 4 == 0);
10829
10830 loc_address = (htab->root.splt->output_section->vma
10831 + htab->root.splt->output_offset + plt_offset);
10832 gotpc_offset = got_address - ((loc_address | 3) ^ 3);
10833
10834 /* ADDIUPC has a span of +/-16MB, check we're in range. */
10835 if (gotpc_offset + 0x1000000 >= 0x2000000)
10836 {
10837 _bfd_error_handler
10838 /* xgettext:c-format */
10839 (_("%B: `%A' offset of %ld from `%A' "
10840 "beyond the range of ADDIUPC"),
10841 output_bfd,
10842 htab->root.sgotplt->output_section,
10843 htab->root.splt->output_section,
10844 (long) gotpc_offset);
10845 bfd_set_error (bfd_error_no_error);
10846 return FALSE;
10847 }
10848 bfd_put_16 (output_bfd,
10849 plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
10850 bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
10851 bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
10852 bfd_put_16 (output_bfd, plt_entry[3], loc + 6);
10853 bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
10854 bfd_put_16 (output_bfd, plt_entry[5], loc + 10);
10855 }
10856 }
10857
10858 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
10859 mips_elf_output_dynamic_relocation (output_bfd, htab->root.srelplt,
10860 got_index - 2, h->dynindx,
10861 R_MIPS_JUMP_SLOT, got_address);
10862
10863 /* We distinguish between PLT entries and lazy-binding stubs by
10864 giving the former an st_other value of STO_MIPS_PLT. Set the
10865 flag and leave the value if there are any relocations in the
10866 binary where pointer equality matters. */
10867 sym->st_shndx = SHN_UNDEF;
10868 if (h->pointer_equality_needed)
10869 sym->st_other = ELF_ST_SET_MIPS_PLT (sym->st_other);
10870 else
10871 {
10872 sym->st_value = 0;
10873 sym->st_other = 0;
10874 }
10875 }
10876
10877 if (h->plt.plist != NULL && h->plt.plist->stub_offset != MINUS_ONE)
10878 {
10879 /* We've decided to create a lazy-binding stub. */
10880 bfd_boolean micromips_p = MICROMIPS_P (output_bfd);
10881 unsigned int other = micromips_p ? STO_MICROMIPS : 0;
10882 bfd_vma stub_size = htab->function_stub_size;
10883 bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
10884 bfd_vma isa_bit = micromips_p;
10885 bfd_vma stub_big_size;
10886
10887 if (!micromips_p)
10888 stub_big_size = MIPS_FUNCTION_STUB_BIG_SIZE;
10889 else if (htab->insn32)
10890 stub_big_size = MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE;
10891 else
10892 stub_big_size = MICROMIPS_FUNCTION_STUB_BIG_SIZE;
10893
10894 /* This symbol has a stub. Set it up. */
10895
10896 BFD_ASSERT (h->dynindx != -1);
10897
10898 BFD_ASSERT (stub_size == stub_big_size || h->dynindx <= 0xffff);
10899
10900 /* Values up to 2^31 - 1 are allowed. Larger values would cause
10901 sign extension at runtime in the stub, resulting in a negative
10902 index value. */
10903 if (h->dynindx & ~0x7fffffff)
10904 return FALSE;
10905
10906 /* Fill the stub. */
10907 if (micromips_p)
10908 {
10909 idx = 0;
10910 bfd_put_micromips_32 (output_bfd, STUB_LW_MICROMIPS (output_bfd),
10911 stub + idx);
10912 idx += 4;
10913 if (htab->insn32)
10914 {
10915 bfd_put_micromips_32 (output_bfd,
10916 STUB_MOVE32_MICROMIPS, stub + idx);
10917 idx += 4;
10918 }
10919 else
10920 {
10921 bfd_put_16 (output_bfd, STUB_MOVE_MICROMIPS, stub + idx);
10922 idx += 2;
10923 }
10924 if (stub_size == stub_big_size)
10925 {
10926 long dynindx_hi = (h->dynindx >> 16) & 0x7fff;
10927
10928 bfd_put_micromips_32 (output_bfd,
10929 STUB_LUI_MICROMIPS (dynindx_hi),
10930 stub + idx);
10931 idx += 4;
10932 }
10933 if (htab->insn32)
10934 {
10935 bfd_put_micromips_32 (output_bfd, STUB_JALR32_MICROMIPS,
10936 stub + idx);
10937 idx += 4;
10938 }
10939 else
10940 {
10941 bfd_put_16 (output_bfd, STUB_JALR_MICROMIPS, stub + idx);
10942 idx += 2;
10943 }
10944
10945 /* If a large stub is not required and sign extension is not a
10946 problem, then use legacy code in the stub. */
10947 if (stub_size == stub_big_size)
10948 bfd_put_micromips_32 (output_bfd,
10949 STUB_ORI_MICROMIPS (h->dynindx & 0xffff),
10950 stub + idx);
10951 else if (h->dynindx & ~0x7fff)
10952 bfd_put_micromips_32 (output_bfd,
10953 STUB_LI16U_MICROMIPS (h->dynindx & 0xffff),
10954 stub + idx);
10955 else
10956 bfd_put_micromips_32 (output_bfd,
10957 STUB_LI16S_MICROMIPS (output_bfd,
10958 h->dynindx),
10959 stub + idx);
10960 }
10961 else
10962 {
10963 idx = 0;
10964 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
10965 idx += 4;
10966 bfd_put_32 (output_bfd, STUB_MOVE, stub + idx);
10967 idx += 4;
10968 if (stub_size == stub_big_size)
10969 {
10970 bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
10971 stub + idx);
10972 idx += 4;
10973 }
10974 bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
10975 idx += 4;
10976
10977 /* If a large stub is not required and sign extension is not a
10978 problem, then use legacy code in the stub. */
10979 if (stub_size == stub_big_size)
10980 bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff),
10981 stub + idx);
10982 else if (h->dynindx & ~0x7fff)
10983 bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff),
10984 stub + idx);
10985 else
10986 bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
10987 stub + idx);
10988 }
10989
10990 BFD_ASSERT (h->plt.plist->stub_offset <= htab->sstubs->size);
10991 memcpy (htab->sstubs->contents + h->plt.plist->stub_offset,
10992 stub, stub_size);
10993
10994 /* Mark the symbol as undefined. stub_offset != -1 occurs
10995 only for the referenced symbol. */
10996 sym->st_shndx = SHN_UNDEF;
10997
10998 /* The run-time linker uses the st_value field of the symbol
10999 to reset the global offset table entry for this external
11000 to its stub address when unlinking a shared object. */
11001 sym->st_value = (htab->sstubs->output_section->vma
11002 + htab->sstubs->output_offset
11003 + h->plt.plist->stub_offset
11004 + isa_bit);
11005 sym->st_other = other;
11006 }
11007
11008 /* If we have a MIPS16 function with a stub, the dynamic symbol must
11009 refer to the stub, since only the stub uses the standard calling
11010 conventions. */
11011 if (h->dynindx != -1 && hmips->fn_stub != NULL)
11012 {
11013 BFD_ASSERT (hmips->need_fn_stub);
11014 sym->st_value = (hmips->fn_stub->output_section->vma
11015 + hmips->fn_stub->output_offset);
11016 sym->st_size = hmips->fn_stub->size;
11017 sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
11018 }
11019
11020 BFD_ASSERT (h->dynindx != -1
11021 || h->forced_local);
11022
11023 sgot = htab->root.sgot;
11024 g = htab->got_info;
11025 BFD_ASSERT (g != NULL);
11026
11027 /* Run through the global symbol table, creating GOT entries for all
11028 the symbols that need them. */
11029 if (hmips->global_got_area != GGA_NONE)
11030 {
11031 bfd_vma offset;
11032 bfd_vma value;
11033
11034 value = sym->st_value;
11035 offset = mips_elf_primary_global_got_index (output_bfd, info, h);
11036 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
11037 }
11038
11039 if (hmips->global_got_area != GGA_NONE && g->next)
11040 {
11041 struct mips_got_entry e, *p;
11042 bfd_vma entry;
11043 bfd_vma offset;
11044
11045 gg = g;
11046
11047 e.abfd = output_bfd;
11048 e.symndx = -1;
11049 e.d.h = hmips;
11050 e.tls_type = GOT_TLS_NONE;
11051
11052 for (g = g->next; g->next != gg; g = g->next)
11053 {
11054 if (g->got_entries
11055 && (p = (struct mips_got_entry *) htab_find (g->got_entries,
11056 &e)))
11057 {
11058 offset = p->gotidx;
11059 BFD_ASSERT (offset > 0 && offset < htab->root.sgot->size);
11060 if (bfd_link_pic (info)
11061 || (elf_hash_table (info)->dynamic_sections_created
11062 && p->d.h != NULL
11063 && p->d.h->root.def_dynamic
11064 && !p->d.h->root.def_regular))
11065 {
11066 /* Create an R_MIPS_REL32 relocation for this entry. Due to
11067 the various compatibility problems, it's easier to mock
11068 up an R_MIPS_32 or R_MIPS_64 relocation and leave
11069 mips_elf_create_dynamic_relocation to calculate the
11070 appropriate addend. */
11071 Elf_Internal_Rela rel[3];
11072
11073 memset (rel, 0, sizeof (rel));
11074 if (ABI_64_P (output_bfd))
11075 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
11076 else
11077 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
11078 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
11079
11080 entry = 0;
11081 if (! (mips_elf_create_dynamic_relocation
11082 (output_bfd, info, rel,
11083 e.d.h, NULL, sym->st_value, &entry, sgot)))
11084 return FALSE;
11085 }
11086 else
11087 entry = sym->st_value;
11088 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
11089 }
11090 }
11091 }
11092
11093 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
11094 name = h->root.root.string;
11095 if (h == elf_hash_table (info)->hdynamic
11096 || h == elf_hash_table (info)->hgot)
11097 sym->st_shndx = SHN_ABS;
11098 else if (strcmp (name, "_DYNAMIC_LINK") == 0
11099 || strcmp (name, "_DYNAMIC_LINKING") == 0)
11100 {
11101 sym->st_shndx = SHN_ABS;
11102 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11103 sym->st_value = 1;
11104 }
11105 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
11106 {
11107 sym->st_shndx = SHN_ABS;
11108 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11109 sym->st_value = elf_gp (output_bfd);
11110 }
11111 else if (SGI_COMPAT (output_bfd))
11112 {
11113 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
11114 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
11115 {
11116 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11117 sym->st_other = STO_PROTECTED;
11118 sym->st_value = 0;
11119 sym->st_shndx = SHN_MIPS_DATA;
11120 }
11121 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
11122 {
11123 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
11124 sym->st_other = STO_PROTECTED;
11125 sym->st_value = mips_elf_hash_table (info)->procedure_count;
11126 sym->st_shndx = SHN_ABS;
11127 }
11128 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
11129 {
11130 if (h->type == STT_FUNC)
11131 sym->st_shndx = SHN_MIPS_TEXT;
11132 else if (h->type == STT_OBJECT)
11133 sym->st_shndx = SHN_MIPS_DATA;
11134 }
11135 }
11136
11137 /* Emit a copy reloc, if needed. */
11138 if (h->needs_copy)
11139 {
11140 asection *s;
11141 bfd_vma symval;
11142
11143 BFD_ASSERT (h->dynindx != -1);
11144 BFD_ASSERT (htab->use_plts_and_copy_relocs);
11145
11146 s = mips_elf_rel_dyn_section (info, FALSE);
11147 symval = (h->root.u.def.section->output_section->vma
11148 + h->root.u.def.section->output_offset
11149 + h->root.u.def.value);
11150 mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
11151 h->dynindx, R_MIPS_COPY, symval);
11152 }
11153
11154 /* Handle the IRIX6-specific symbols. */
11155 if (IRIX_COMPAT (output_bfd) == ict_irix6)
11156 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
11157
11158 /* Keep dynamic compressed symbols odd. This allows the dynamic linker
11159 to treat compressed symbols like any other. */
11160 if (ELF_ST_IS_MIPS16 (sym->st_other))
11161 {
11162 BFD_ASSERT (sym->st_value & 1);
11163 sym->st_other -= STO_MIPS16;
11164 }
11165 else if (ELF_ST_IS_MICROMIPS (sym->st_other))
11166 {
11167 BFD_ASSERT (sym->st_value & 1);
11168 sym->st_other -= STO_MICROMIPS;
11169 }
11170
11171 return TRUE;
11172 }
11173
11174 /* Likewise, for VxWorks. */
11175
11176 bfd_boolean
11177 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
11178 struct bfd_link_info *info,
11179 struct elf_link_hash_entry *h,
11180 Elf_Internal_Sym *sym)
11181 {
11182 bfd *dynobj;
11183 asection *sgot;
11184 struct mips_got_info *g;
11185 struct mips_elf_link_hash_table *htab;
11186 struct mips_elf_link_hash_entry *hmips;
11187
11188 htab = mips_elf_hash_table (info);
11189 BFD_ASSERT (htab != NULL);
11190 dynobj = elf_hash_table (info)->dynobj;
11191 hmips = (struct mips_elf_link_hash_entry *) h;
11192
11193 if (h->plt.plist != NULL && h->plt.plist->mips_offset != MINUS_ONE)
11194 {
11195 bfd_byte *loc;
11196 bfd_vma plt_address, got_address, got_offset, branch_offset;
11197 Elf_Internal_Rela rel;
11198 static const bfd_vma *plt_entry;
11199 bfd_vma gotplt_index;
11200 bfd_vma plt_offset;
11201
11202 plt_offset = htab->plt_header_size + h->plt.plist->mips_offset;
11203 gotplt_index = h->plt.plist->gotplt_index;
11204
11205 BFD_ASSERT (h->dynindx != -1);
11206 BFD_ASSERT (htab->root.splt != NULL);
11207 BFD_ASSERT (gotplt_index != MINUS_ONE);
11208 BFD_ASSERT (plt_offset <= htab->root.splt->size);
11209
11210 /* Calculate the address of the .plt entry. */
11211 plt_address = (htab->root.splt->output_section->vma
11212 + htab->root.splt->output_offset
11213 + plt_offset);
11214
11215 /* Calculate the address of the .got.plt entry. */
11216 got_address = (htab->root.sgotplt->output_section->vma
11217 + htab->root.sgotplt->output_offset
11218 + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd));
11219
11220 /* Calculate the offset of the .got.plt entry from
11221 _GLOBAL_OFFSET_TABLE_. */
11222 got_offset = mips_elf_gotplt_index (info, h);
11223
11224 /* Calculate the offset for the branch at the start of the PLT
11225 entry. The branch jumps to the beginning of .plt. */
11226 branch_offset = -(plt_offset / 4 + 1) & 0xffff;
11227
11228 /* Fill in the initial value of the .got.plt entry. */
11229 bfd_put_32 (output_bfd, plt_address,
11230 (htab->root.sgotplt->contents
11231 + gotplt_index * MIPS_ELF_GOT_SIZE (output_bfd)));
11232
11233 /* Find out where the .plt entry should go. */
11234 loc = htab->root.splt->contents + plt_offset;
11235
11236 if (bfd_link_pic (info))
11237 {
11238 plt_entry = mips_vxworks_shared_plt_entry;
11239 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
11240 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
11241 }
11242 else
11243 {
11244 bfd_vma got_address_high, got_address_low;
11245
11246 plt_entry = mips_vxworks_exec_plt_entry;
11247 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
11248 got_address_low = got_address & 0xffff;
11249
11250 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
11251 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_index, loc + 4);
11252 bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
11253 bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
11254 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11255 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11256 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
11257 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
11258
11259 loc = (htab->srelplt2->contents
11260 + (gotplt_index * 3 + 2) * sizeof (Elf32_External_Rela));
11261
11262 /* Emit a relocation for the .got.plt entry. */
11263 rel.r_offset = got_address;
11264 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
11265 rel.r_addend = plt_offset;
11266 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11267
11268 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
11269 loc += sizeof (Elf32_External_Rela);
11270 rel.r_offset = plt_address + 8;
11271 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11272 rel.r_addend = got_offset;
11273 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11274
11275 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
11276 loc += sizeof (Elf32_External_Rela);
11277 rel.r_offset += 4;
11278 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11279 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11280 }
11281
11282 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
11283 loc = (htab->root.srelplt->contents
11284 + gotplt_index * sizeof (Elf32_External_Rela));
11285 rel.r_offset = got_address;
11286 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
11287 rel.r_addend = 0;
11288 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11289
11290 if (!h->def_regular)
11291 sym->st_shndx = SHN_UNDEF;
11292 }
11293
11294 BFD_ASSERT (h->dynindx != -1 || h->forced_local);
11295
11296 sgot = htab->root.sgot;
11297 g = htab->got_info;
11298 BFD_ASSERT (g != NULL);
11299
11300 /* See if this symbol has an entry in the GOT. */
11301 if (hmips->global_got_area != GGA_NONE)
11302 {
11303 bfd_vma offset;
11304 Elf_Internal_Rela outrel;
11305 bfd_byte *loc;
11306 asection *s;
11307
11308 /* Install the symbol value in the GOT. */
11309 offset = mips_elf_primary_global_got_index (output_bfd, info, h);
11310 MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
11311
11312 /* Add a dynamic relocation for it. */
11313 s = mips_elf_rel_dyn_section (info, FALSE);
11314 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
11315 outrel.r_offset = (sgot->output_section->vma
11316 + sgot->output_offset
11317 + offset);
11318 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
11319 outrel.r_addend = 0;
11320 bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
11321 }
11322
11323 /* Emit a copy reloc, if needed. */
11324 if (h->needs_copy)
11325 {
11326 Elf_Internal_Rela rel;
11327 asection *srel;
11328 bfd_byte *loc;
11329
11330 BFD_ASSERT (h->dynindx != -1);
11331
11332 rel.r_offset = (h->root.u.def.section->output_section->vma
11333 + h->root.u.def.section->output_offset
11334 + h->root.u.def.value);
11335 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
11336 rel.r_addend = 0;
11337 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
11338 srel = htab->root.sreldynrelro;
11339 else
11340 srel = htab->root.srelbss;
11341 loc = srel->contents + srel->reloc_count * sizeof (Elf32_External_Rela);
11342 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11343 ++srel->reloc_count;
11344 }
11345
11346 /* If this is a mips16/microMIPS symbol, force the value to be even. */
11347 if (ELF_ST_IS_COMPRESSED (sym->st_other))
11348 sym->st_value &= ~1;
11349
11350 return TRUE;
11351 }
11352
11353 /* Write out a plt0 entry to the beginning of .plt. */
11354
11355 static bfd_boolean
11356 mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
11357 {
11358 bfd_byte *loc;
11359 bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
11360 static const bfd_vma *plt_entry;
11361 struct mips_elf_link_hash_table *htab;
11362
11363 htab = mips_elf_hash_table (info);
11364 BFD_ASSERT (htab != NULL);
11365
11366 if (ABI_64_P (output_bfd))
11367 plt_entry = mips_n64_exec_plt0_entry;
11368 else if (ABI_N32_P (output_bfd))
11369 plt_entry = mips_n32_exec_plt0_entry;
11370 else if (!htab->plt_header_is_comp)
11371 plt_entry = mips_o32_exec_plt0_entry;
11372 else if (htab->insn32)
11373 plt_entry = micromips_insn32_o32_exec_plt0_entry;
11374 else
11375 plt_entry = micromips_o32_exec_plt0_entry;
11376
11377 /* Calculate the value of .got.plt. */
11378 gotplt_value = (htab->root.sgotplt->output_section->vma
11379 + htab->root.sgotplt->output_offset);
11380 gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
11381 gotplt_value_low = gotplt_value & 0xffff;
11382
11383 /* The PLT sequence is not safe for N64 if .got.plt's address can
11384 not be loaded in two instructions. */
11385 BFD_ASSERT ((gotplt_value & ~(bfd_vma) 0x7fffffff) == 0
11386 || ~(gotplt_value | 0x7fffffff) == 0);
11387
11388 /* Install the PLT header. */
11389 loc = htab->root.splt->contents;
11390 if (plt_entry == micromips_o32_exec_plt0_entry)
11391 {
11392 bfd_vma gotpc_offset;
11393 bfd_vma loc_address;
11394 size_t i;
11395
11396 BFD_ASSERT (gotplt_value % 4 == 0);
11397
11398 loc_address = (htab->root.splt->output_section->vma
11399 + htab->root.splt->output_offset);
11400 gotpc_offset = gotplt_value - ((loc_address | 3) ^ 3);
11401
11402 /* ADDIUPC has a span of +/-16MB, check we're in range. */
11403 if (gotpc_offset + 0x1000000 >= 0x2000000)
11404 {
11405 _bfd_error_handler
11406 /* xgettext:c-format */
11407 (_("%B: `%A' offset of %ld from `%A' beyond the range of ADDIUPC"),
11408 output_bfd,
11409 htab->root.sgotplt->output_section,
11410 htab->root.splt->output_section,
11411 (long) gotpc_offset);
11412 bfd_set_error (bfd_error_no_error);
11413 return FALSE;
11414 }
11415 bfd_put_16 (output_bfd,
11416 plt_entry[0] | ((gotpc_offset >> 18) & 0x7f), loc);
11417 bfd_put_16 (output_bfd, (gotpc_offset >> 2) & 0xffff, loc + 2);
11418 for (i = 2; i < ARRAY_SIZE (micromips_o32_exec_plt0_entry); i++)
11419 bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
11420 }
11421 else if (plt_entry == micromips_insn32_o32_exec_plt0_entry)
11422 {
11423 size_t i;
11424
11425 bfd_put_16 (output_bfd, plt_entry[0], loc);
11426 bfd_put_16 (output_bfd, gotplt_value_high, loc + 2);
11427 bfd_put_16 (output_bfd, plt_entry[2], loc + 4);
11428 bfd_put_16 (output_bfd, gotplt_value_low, loc + 6);
11429 bfd_put_16 (output_bfd, plt_entry[4], loc + 8);
11430 bfd_put_16 (output_bfd, gotplt_value_low, loc + 10);
11431 for (i = 6; i < ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry); i++)
11432 bfd_put_16 (output_bfd, plt_entry[i], loc + (i * 2));
11433 }
11434 else
11435 {
11436 bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
11437 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
11438 bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
11439 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
11440 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11441 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11442 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
11443 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
11444 }
11445
11446 return TRUE;
11447 }
11448
11449 /* Install the PLT header for a VxWorks executable and finalize the
11450 contents of .rela.plt.unloaded. */
11451
11452 static void
11453 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
11454 {
11455 Elf_Internal_Rela rela;
11456 bfd_byte *loc;
11457 bfd_vma got_value, got_value_high, got_value_low, plt_address;
11458 static const bfd_vma *plt_entry;
11459 struct mips_elf_link_hash_table *htab;
11460
11461 htab = mips_elf_hash_table (info);
11462 BFD_ASSERT (htab != NULL);
11463
11464 plt_entry = mips_vxworks_exec_plt0_entry;
11465
11466 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
11467 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
11468 + htab->root.hgot->root.u.def.section->output_offset
11469 + htab->root.hgot->root.u.def.value);
11470
11471 got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
11472 got_value_low = got_value & 0xffff;
11473
11474 /* Calculate the address of the PLT header. */
11475 plt_address = (htab->root.splt->output_section->vma
11476 + htab->root.splt->output_offset);
11477
11478 /* Install the PLT header. */
11479 loc = htab->root.splt->contents;
11480 bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
11481 bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
11482 bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
11483 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
11484 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
11485 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
11486
11487 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
11488 loc = htab->srelplt2->contents;
11489 rela.r_offset = plt_address;
11490 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11491 rela.r_addend = 0;
11492 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
11493 loc += sizeof (Elf32_External_Rela);
11494
11495 /* Output the relocation for the following addiu of
11496 %lo(_GLOBAL_OFFSET_TABLE_). */
11497 rela.r_offset += 4;
11498 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11499 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
11500 loc += sizeof (Elf32_External_Rela);
11501
11502 /* Fix up the remaining relocations. They may have the wrong
11503 symbol index for _G_O_T_ or _P_L_T_ depending on the order
11504 in which symbols were output. */
11505 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
11506 {
11507 Elf_Internal_Rela rel;
11508
11509 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11510 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
11511 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11512 loc += sizeof (Elf32_External_Rela);
11513
11514 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11515 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
11516 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11517 loc += sizeof (Elf32_External_Rela);
11518
11519 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
11520 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
11521 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
11522 loc += sizeof (Elf32_External_Rela);
11523 }
11524 }
11525
11526 /* Install the PLT header for a VxWorks shared library. */
11527
11528 static void
11529 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
11530 {
11531 unsigned int i;
11532 struct mips_elf_link_hash_table *htab;
11533
11534 htab = mips_elf_hash_table (info);
11535 BFD_ASSERT (htab != NULL);
11536
11537 /* We just need to copy the entry byte-by-byte. */
11538 for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
11539 bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
11540 htab->root.splt->contents + i * 4);
11541 }
11542
11543 /* Finish up the dynamic sections. */
11544
11545 bfd_boolean
11546 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
11547 struct bfd_link_info *info)
11548 {
11549 bfd *dynobj;
11550 asection *sdyn;
11551 asection *sgot;
11552 struct mips_got_info *gg, *g;
11553 struct mips_elf_link_hash_table *htab;
11554
11555 htab = mips_elf_hash_table (info);
11556 BFD_ASSERT (htab != NULL);
11557
11558 dynobj = elf_hash_table (info)->dynobj;
11559
11560 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
11561
11562 sgot = htab->root.sgot;
11563 gg = htab->got_info;
11564
11565 if (elf_hash_table (info)->dynamic_sections_created)
11566 {
11567 bfd_byte *b;
11568 int dyn_to_skip = 0, dyn_skipped = 0;
11569
11570 BFD_ASSERT (sdyn != NULL);
11571 BFD_ASSERT (gg != NULL);
11572
11573 g = mips_elf_bfd_got (output_bfd, FALSE);
11574 BFD_ASSERT (g != NULL);
11575
11576 for (b = sdyn->contents;
11577 b < sdyn->contents + sdyn->size;
11578 b += MIPS_ELF_DYN_SIZE (dynobj))
11579 {
11580 Elf_Internal_Dyn dyn;
11581 const char *name;
11582 size_t elemsize;
11583 asection *s;
11584 bfd_boolean swap_out_p;
11585
11586 /* Read in the current dynamic entry. */
11587 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
11588
11589 /* Assume that we're going to modify it and write it out. */
11590 swap_out_p = TRUE;
11591
11592 switch (dyn.d_tag)
11593 {
11594 case DT_RELENT:
11595 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
11596 break;
11597
11598 case DT_RELAENT:
11599 BFD_ASSERT (htab->is_vxworks);
11600 dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
11601 break;
11602
11603 case DT_STRSZ:
11604 /* Rewrite DT_STRSZ. */
11605 dyn.d_un.d_val =
11606 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
11607 break;
11608
11609 case DT_PLTGOT:
11610 s = htab->root.sgot;
11611 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11612 break;
11613
11614 case DT_MIPS_PLTGOT:
11615 s = htab->root.sgotplt;
11616 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11617 break;
11618
11619 case DT_MIPS_RLD_VERSION:
11620 dyn.d_un.d_val = 1; /* XXX */
11621 break;
11622
11623 case DT_MIPS_FLAGS:
11624 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
11625 break;
11626
11627 case DT_MIPS_TIME_STAMP:
11628 {
11629 time_t t;
11630 time (&t);
11631 dyn.d_un.d_val = t;
11632 }
11633 break;
11634
11635 case DT_MIPS_ICHECKSUM:
11636 /* XXX FIXME: */
11637 swap_out_p = FALSE;
11638 break;
11639
11640 case DT_MIPS_IVERSION:
11641 /* XXX FIXME: */
11642 swap_out_p = FALSE;
11643 break;
11644
11645 case DT_MIPS_BASE_ADDRESS:
11646 s = output_bfd->sections;
11647 BFD_ASSERT (s != NULL);
11648 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
11649 break;
11650
11651 case DT_MIPS_LOCAL_GOTNO:
11652 dyn.d_un.d_val = g->local_gotno;
11653 break;
11654
11655 case DT_MIPS_UNREFEXTNO:
11656 /* The index into the dynamic symbol table which is the
11657 entry of the first external symbol that is not
11658 referenced within the same object. */
11659 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
11660 break;
11661
11662 case DT_MIPS_GOTSYM:
11663 if (htab->global_gotsym)
11664 {
11665 dyn.d_un.d_val = htab->global_gotsym->dynindx;
11666 break;
11667 }
11668 /* In case if we don't have global got symbols we default
11669 to setting DT_MIPS_GOTSYM to the same value as
11670 DT_MIPS_SYMTABNO. */
11671 /* Fall through. */
11672
11673 case DT_MIPS_SYMTABNO:
11674 name = ".dynsym";
11675 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
11676 s = bfd_get_linker_section (dynobj, name);
11677
11678 if (s != NULL)
11679 dyn.d_un.d_val = s->size / elemsize;
11680 else
11681 dyn.d_un.d_val = 0;
11682 break;
11683
11684 case DT_MIPS_HIPAGENO:
11685 dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
11686 break;
11687
11688 case DT_MIPS_RLD_MAP:
11689 {
11690 struct elf_link_hash_entry *h;
11691 h = mips_elf_hash_table (info)->rld_symbol;
11692 if (!h)
11693 {
11694 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11695 swap_out_p = FALSE;
11696 break;
11697 }
11698 s = h->root.u.def.section;
11699
11700 /* The MIPS_RLD_MAP tag stores the absolute address of the
11701 debug pointer. */
11702 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
11703 + h->root.u.def.value);
11704 }
11705 break;
11706
11707 case DT_MIPS_RLD_MAP_REL:
11708 {
11709 struct elf_link_hash_entry *h;
11710 bfd_vma dt_addr, rld_addr;
11711 h = mips_elf_hash_table (info)->rld_symbol;
11712 if (!h)
11713 {
11714 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11715 swap_out_p = FALSE;
11716 break;
11717 }
11718 s = h->root.u.def.section;
11719
11720 /* The MIPS_RLD_MAP_REL tag stores the offset to the debug
11721 pointer, relative to the address of the tag. */
11722 dt_addr = (sdyn->output_section->vma + sdyn->output_offset
11723 + (b - sdyn->contents));
11724 rld_addr = (s->output_section->vma + s->output_offset
11725 + h->root.u.def.value);
11726 dyn.d_un.d_ptr = rld_addr - dt_addr;
11727 }
11728 break;
11729
11730 case DT_MIPS_OPTIONS:
11731 s = (bfd_get_section_by_name
11732 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
11733 dyn.d_un.d_ptr = s->vma;
11734 break;
11735
11736 case DT_PLTREL:
11737 BFD_ASSERT (htab->use_plts_and_copy_relocs);
11738 if (htab->is_vxworks)
11739 dyn.d_un.d_val = DT_RELA;
11740 else
11741 dyn.d_un.d_val = DT_REL;
11742 break;
11743
11744 case DT_PLTRELSZ:
11745 BFD_ASSERT (htab->use_plts_and_copy_relocs);
11746 dyn.d_un.d_val = htab->root.srelplt->size;
11747 break;
11748
11749 case DT_JMPREL:
11750 BFD_ASSERT (htab->use_plts_and_copy_relocs);
11751 dyn.d_un.d_ptr = (htab->root.srelplt->output_section->vma
11752 + htab->root.srelplt->output_offset);
11753 break;
11754
11755 case DT_TEXTREL:
11756 /* If we didn't need any text relocations after all, delete
11757 the dynamic tag. */
11758 if (!(info->flags & DF_TEXTREL))
11759 {
11760 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
11761 swap_out_p = FALSE;
11762 }
11763 break;
11764
11765 case DT_FLAGS:
11766 /* If we didn't need any text relocations after all, clear
11767 DF_TEXTREL from DT_FLAGS. */
11768 if (!(info->flags & DF_TEXTREL))
11769 dyn.d_un.d_val &= ~DF_TEXTREL;
11770 else
11771 swap_out_p = FALSE;
11772 break;
11773
11774 default:
11775 swap_out_p = FALSE;
11776 if (htab->is_vxworks
11777 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
11778 swap_out_p = TRUE;
11779 break;
11780 }
11781
11782 if (swap_out_p || dyn_skipped)
11783 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
11784 (dynobj, &dyn, b - dyn_skipped);
11785
11786 if (dyn_to_skip)
11787 {
11788 dyn_skipped += dyn_to_skip;
11789 dyn_to_skip = 0;
11790 }
11791 }
11792
11793 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
11794 if (dyn_skipped > 0)
11795 memset (b - dyn_skipped, 0, dyn_skipped);
11796 }
11797
11798 if (sgot != NULL && sgot->size > 0
11799 && !bfd_is_abs_section (sgot->output_section))
11800 {
11801 if (htab->is_vxworks)
11802 {
11803 /* The first entry of the global offset table points to the
11804 ".dynamic" section. The second is initialized by the
11805 loader and contains the shared library identifier.
11806 The third is also initialized by the loader and points
11807 to the lazy resolution stub. */
11808 MIPS_ELF_PUT_WORD (output_bfd,
11809 sdyn->output_offset + sdyn->output_section->vma,
11810 sgot->contents);
11811 MIPS_ELF_PUT_WORD (output_bfd, 0,
11812 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
11813 MIPS_ELF_PUT_WORD (output_bfd, 0,
11814 sgot->contents
11815 + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
11816 }
11817 else
11818 {
11819 /* The first entry of the global offset table will be filled at
11820 runtime. The second entry will be used by some runtime loaders.
11821 This isn't the case of IRIX rld. */
11822 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
11823 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
11824 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
11825 }
11826
11827 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
11828 = MIPS_ELF_GOT_SIZE (output_bfd);
11829 }
11830
11831 /* Generate dynamic relocations for the non-primary gots. */
11832 if (gg != NULL && gg->next)
11833 {
11834 Elf_Internal_Rela rel[3];
11835 bfd_vma addend = 0;
11836
11837 memset (rel, 0, sizeof (rel));
11838 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
11839
11840 for (g = gg->next; g->next != gg; g = g->next)
11841 {
11842 bfd_vma got_index = g->next->local_gotno + g->next->global_gotno
11843 + g->next->tls_gotno;
11844
11845 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
11846 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
11847 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
11848 sgot->contents
11849 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
11850
11851 if (! bfd_link_pic (info))
11852 continue;
11853
11854 for (; got_index < g->local_gotno; got_index++)
11855 {
11856 if (got_index >= g->assigned_low_gotno
11857 && got_index <= g->assigned_high_gotno)
11858 continue;
11859
11860 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
11861 = got_index * MIPS_ELF_GOT_SIZE (output_bfd);
11862 if (!(mips_elf_create_dynamic_relocation
11863 (output_bfd, info, rel, NULL,
11864 bfd_abs_section_ptr,
11865 0, &addend, sgot)))
11866 return FALSE;
11867 BFD_ASSERT (addend == 0);
11868 }
11869 }
11870 }
11871
11872 /* The generation of dynamic relocations for the non-primary gots
11873 adds more dynamic relocations. We cannot count them until
11874 here. */
11875
11876 if (elf_hash_table (info)->dynamic_sections_created)
11877 {
11878 bfd_byte *b;
11879 bfd_boolean swap_out_p;
11880
11881 BFD_ASSERT (sdyn != NULL);
11882
11883 for (b = sdyn->contents;
11884 b < sdyn->contents + sdyn->size;
11885 b += MIPS_ELF_DYN_SIZE (dynobj))
11886 {
11887 Elf_Internal_Dyn dyn;
11888 asection *s;
11889
11890 /* Read in the current dynamic entry. */
11891 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
11892
11893 /* Assume that we're going to modify it and write it out. */
11894 swap_out_p = TRUE;
11895
11896 switch (dyn.d_tag)
11897 {
11898 case DT_RELSZ:
11899 /* Reduce DT_RELSZ to account for any relocations we
11900 decided not to make. This is for the n64 irix rld,
11901 which doesn't seem to apply any relocations if there
11902 are trailing null entries. */
11903 s = mips_elf_rel_dyn_section (info, FALSE);
11904 dyn.d_un.d_val = (s->reloc_count
11905 * (ABI_64_P (output_bfd)
11906 ? sizeof (Elf64_Mips_External_Rel)
11907 : sizeof (Elf32_External_Rel)));
11908 /* Adjust the section size too. Tools like the prelinker
11909 can reasonably expect the values to the same. */
11910 elf_section_data (s->output_section)->this_hdr.sh_size
11911 = dyn.d_un.d_val;
11912 break;
11913
11914 default:
11915 swap_out_p = FALSE;
11916 break;
11917 }
11918
11919 if (swap_out_p)
11920 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
11921 (dynobj, &dyn, b);
11922 }
11923 }
11924
11925 {
11926 asection *s;
11927 Elf32_compact_rel cpt;
11928
11929 if (SGI_COMPAT (output_bfd))
11930 {
11931 /* Write .compact_rel section out. */
11932 s = bfd_get_linker_section (dynobj, ".compact_rel");
11933 if (s != NULL)
11934 {
11935 cpt.id1 = 1;
11936 cpt.num = s->reloc_count;
11937 cpt.id2 = 2;
11938 cpt.offset = (s->output_section->filepos
11939 + sizeof (Elf32_External_compact_rel));
11940 cpt.reserved0 = 0;
11941 cpt.reserved1 = 0;
11942 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
11943 ((Elf32_External_compact_rel *)
11944 s->contents));
11945
11946 /* Clean up a dummy stub function entry in .text. */
11947 if (htab->sstubs != NULL)
11948 {
11949 file_ptr dummy_offset;
11950
11951 BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
11952 dummy_offset = htab->sstubs->size - htab->function_stub_size;
11953 memset (htab->sstubs->contents + dummy_offset, 0,
11954 htab->function_stub_size);
11955 }
11956 }
11957 }
11958
11959 /* The psABI says that the dynamic relocations must be sorted in
11960 increasing order of r_symndx. The VxWorks EABI doesn't require
11961 this, and because the code below handles REL rather than RELA
11962 relocations, using it for VxWorks would be outright harmful. */
11963 if (!htab->is_vxworks)
11964 {
11965 s = mips_elf_rel_dyn_section (info, FALSE);
11966 if (s != NULL
11967 && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
11968 {
11969 reldyn_sorting_bfd = output_bfd;
11970
11971 if (ABI_64_P (output_bfd))
11972 qsort ((Elf64_External_Rel *) s->contents + 1,
11973 s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
11974 sort_dynamic_relocs_64);
11975 else
11976 qsort ((Elf32_External_Rel *) s->contents + 1,
11977 s->reloc_count - 1, sizeof (Elf32_External_Rel),
11978 sort_dynamic_relocs);
11979 }
11980 }
11981 }
11982
11983 if (htab->root.splt && htab->root.splt->size > 0)
11984 {
11985 if (htab->is_vxworks)
11986 {
11987 if (bfd_link_pic (info))
11988 mips_vxworks_finish_shared_plt (output_bfd, info);
11989 else
11990 mips_vxworks_finish_exec_plt (output_bfd, info);
11991 }
11992 else
11993 {
11994 BFD_ASSERT (!bfd_link_pic (info));
11995 if (!mips_finish_exec_plt (output_bfd, info))
11996 return FALSE;
11997 }
11998 }
11999 return TRUE;
12000 }
12001
12002
12003 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
12004
12005 static void
12006 mips_set_isa_flags (bfd *abfd)
12007 {
12008 flagword val;
12009
12010 switch (bfd_get_mach (abfd))
12011 {
12012 default:
12013 case bfd_mach_mips3000:
12014 val = E_MIPS_ARCH_1;
12015 break;
12016
12017 case bfd_mach_mips3900:
12018 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
12019 break;
12020
12021 case bfd_mach_mips6000:
12022 val = E_MIPS_ARCH_2;
12023 break;
12024
12025 case bfd_mach_mips4000:
12026 case bfd_mach_mips4300:
12027 case bfd_mach_mips4400:
12028 case bfd_mach_mips4600:
12029 val = E_MIPS_ARCH_3;
12030 break;
12031
12032 case bfd_mach_mips4010:
12033 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
12034 break;
12035
12036 case bfd_mach_mips4100:
12037 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
12038 break;
12039
12040 case bfd_mach_mips4111:
12041 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
12042 break;
12043
12044 case bfd_mach_mips4120:
12045 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
12046 break;
12047
12048 case bfd_mach_mips4650:
12049 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
12050 break;
12051
12052 case bfd_mach_mips5400:
12053 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
12054 break;
12055
12056 case bfd_mach_mips5500:
12057 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
12058 break;
12059
12060 case bfd_mach_mips5900:
12061 val = E_MIPS_ARCH_3 | E_MIPS_MACH_5900;
12062 break;
12063
12064 case bfd_mach_mips9000:
12065 val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
12066 break;
12067
12068 case bfd_mach_mips5000:
12069 case bfd_mach_mips7000:
12070 case bfd_mach_mips8000:
12071 case bfd_mach_mips10000:
12072 case bfd_mach_mips12000:
12073 case bfd_mach_mips14000:
12074 case bfd_mach_mips16000:
12075 val = E_MIPS_ARCH_4;
12076 break;
12077
12078 case bfd_mach_mips5:
12079 val = E_MIPS_ARCH_5;
12080 break;
12081
12082 case bfd_mach_mips_loongson_2e:
12083 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
12084 break;
12085
12086 case bfd_mach_mips_loongson_2f:
12087 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
12088 break;
12089
12090 case bfd_mach_mips_sb1:
12091 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
12092 break;
12093
12094 case bfd_mach_mips_loongson_3a:
12095 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_LS3A;
12096 break;
12097
12098 case bfd_mach_mips_octeon:
12099 case bfd_mach_mips_octeonp:
12100 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
12101 break;
12102
12103 case bfd_mach_mips_octeon3:
12104 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON3;
12105 break;
12106
12107 case bfd_mach_mips_xlr:
12108 val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
12109 break;
12110
12111 case bfd_mach_mips_octeon2:
12112 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON2;
12113 break;
12114
12115 case bfd_mach_mipsisa32:
12116 val = E_MIPS_ARCH_32;
12117 break;
12118
12119 case bfd_mach_mipsisa64:
12120 val = E_MIPS_ARCH_64;
12121 break;
12122
12123 case bfd_mach_mipsisa32r2:
12124 case bfd_mach_mipsisa32r3:
12125 case bfd_mach_mipsisa32r5:
12126 val = E_MIPS_ARCH_32R2;
12127 break;
12128
12129 case bfd_mach_mipsisa64r2:
12130 case bfd_mach_mipsisa64r3:
12131 case bfd_mach_mipsisa64r5:
12132 val = E_MIPS_ARCH_64R2;
12133 break;
12134
12135 case bfd_mach_mipsisa32r6:
12136 val = E_MIPS_ARCH_32R6;
12137 break;
12138
12139 case bfd_mach_mipsisa64r6:
12140 val = E_MIPS_ARCH_64R6;
12141 break;
12142 }
12143 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
12144 elf_elfheader (abfd)->e_flags |= val;
12145
12146 }
12147
12148
12149 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
12150 Don't do so for code sections. We want to keep ordering of HI16/LO16
12151 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame
12152 relocs to be sorted. */
12153
12154 bfd_boolean
12155 _bfd_mips_elf_sort_relocs_p (asection *sec)
12156 {
12157 return (sec->flags & SEC_CODE) == 0;
12158 }
12159
12160
12161 /* The final processing done just before writing out a MIPS ELF object
12162 file. This gets the MIPS architecture right based on the machine
12163 number. This is used by both the 32-bit and the 64-bit ABI. */
12164
12165 void
12166 _bfd_mips_elf_final_write_processing (bfd *abfd,
12167 bfd_boolean linker ATTRIBUTE_UNUSED)
12168 {
12169 unsigned int i;
12170 Elf_Internal_Shdr **hdrpp;
12171 const char *name;
12172 asection *sec;
12173
12174 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
12175 is nonzero. This is for compatibility with old objects, which used
12176 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
12177 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
12178 mips_set_isa_flags (abfd);
12179
12180 /* Set the sh_info field for .gptab sections and other appropriate
12181 info for each special section. */
12182 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
12183 i < elf_numsections (abfd);
12184 i++, hdrpp++)
12185 {
12186 switch ((*hdrpp)->sh_type)
12187 {
12188 case SHT_MIPS_MSYM:
12189 case SHT_MIPS_LIBLIST:
12190 sec = bfd_get_section_by_name (abfd, ".dynstr");
12191 if (sec != NULL)
12192 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12193 break;
12194
12195 case SHT_MIPS_GPTAB:
12196 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12197 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12198 BFD_ASSERT (name != NULL
12199 && CONST_STRNEQ (name, ".gptab."));
12200 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
12201 BFD_ASSERT (sec != NULL);
12202 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
12203 break;
12204
12205 case SHT_MIPS_CONTENT:
12206 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12207 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12208 BFD_ASSERT (name != NULL
12209 && CONST_STRNEQ (name, ".MIPS.content"));
12210 sec = bfd_get_section_by_name (abfd,
12211 name + sizeof ".MIPS.content" - 1);
12212 BFD_ASSERT (sec != NULL);
12213 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12214 break;
12215
12216 case SHT_MIPS_SYMBOL_LIB:
12217 sec = bfd_get_section_by_name (abfd, ".dynsym");
12218 if (sec != NULL)
12219 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12220 sec = bfd_get_section_by_name (abfd, ".liblist");
12221 if (sec != NULL)
12222 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
12223 break;
12224
12225 case SHT_MIPS_EVENTS:
12226 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
12227 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
12228 BFD_ASSERT (name != NULL);
12229 if (CONST_STRNEQ (name, ".MIPS.events"))
12230 sec = bfd_get_section_by_name (abfd,
12231 name + sizeof ".MIPS.events" - 1);
12232 else
12233 {
12234 BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
12235 sec = bfd_get_section_by_name (abfd,
12236 (name
12237 + sizeof ".MIPS.post_rel" - 1));
12238 }
12239 BFD_ASSERT (sec != NULL);
12240 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
12241 break;
12242
12243 }
12244 }
12245 }
12246 \f
12247 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
12248 segments. */
12249
12250 int
12251 _bfd_mips_elf_additional_program_headers (bfd *abfd,
12252 struct bfd_link_info *info ATTRIBUTE_UNUSED)
12253 {
12254 asection *s;
12255 int ret = 0;
12256
12257 /* See if we need a PT_MIPS_REGINFO segment. */
12258 s = bfd_get_section_by_name (abfd, ".reginfo");
12259 if (s && (s->flags & SEC_LOAD))
12260 ++ret;
12261
12262 /* See if we need a PT_MIPS_ABIFLAGS segment. */
12263 if (bfd_get_section_by_name (abfd, ".MIPS.abiflags"))
12264 ++ret;
12265
12266 /* See if we need a PT_MIPS_OPTIONS segment. */
12267 if (IRIX_COMPAT (abfd) == ict_irix6
12268 && bfd_get_section_by_name (abfd,
12269 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
12270 ++ret;
12271
12272 /* See if we need a PT_MIPS_RTPROC segment. */
12273 if (IRIX_COMPAT (abfd) == ict_irix5
12274 && bfd_get_section_by_name (abfd, ".dynamic")
12275 && bfd_get_section_by_name (abfd, ".mdebug"))
12276 ++ret;
12277
12278 /* Allocate a PT_NULL header in dynamic objects. See
12279 _bfd_mips_elf_modify_segment_map for details. */
12280 if (!SGI_COMPAT (abfd)
12281 && bfd_get_section_by_name (abfd, ".dynamic"))
12282 ++ret;
12283
12284 return ret;
12285 }
12286
12287 /* Modify the segment map for an IRIX5 executable. */
12288
12289 bfd_boolean
12290 _bfd_mips_elf_modify_segment_map (bfd *abfd,
12291 struct bfd_link_info *info)
12292 {
12293 asection *s;
12294 struct elf_segment_map *m, **pm;
12295 bfd_size_type amt;
12296
12297 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
12298 segment. */
12299 s = bfd_get_section_by_name (abfd, ".reginfo");
12300 if (s != NULL && (s->flags & SEC_LOAD) != 0)
12301 {
12302 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12303 if (m->p_type == PT_MIPS_REGINFO)
12304 break;
12305 if (m == NULL)
12306 {
12307 amt = sizeof *m;
12308 m = bfd_zalloc (abfd, amt);
12309 if (m == NULL)
12310 return FALSE;
12311
12312 m->p_type = PT_MIPS_REGINFO;
12313 m->count = 1;
12314 m->sections[0] = s;
12315
12316 /* We want to put it after the PHDR and INTERP segments. */
12317 pm = &elf_seg_map (abfd);
12318 while (*pm != NULL
12319 && ((*pm)->p_type == PT_PHDR
12320 || (*pm)->p_type == PT_INTERP))
12321 pm = &(*pm)->next;
12322
12323 m->next = *pm;
12324 *pm = m;
12325 }
12326 }
12327
12328 /* If there is a .MIPS.abiflags section, we need a PT_MIPS_ABIFLAGS
12329 segment. */
12330 s = bfd_get_section_by_name (abfd, ".MIPS.abiflags");
12331 if (s != NULL && (s->flags & SEC_LOAD) != 0)
12332 {
12333 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12334 if (m->p_type == PT_MIPS_ABIFLAGS)
12335 break;
12336 if (m == NULL)
12337 {
12338 amt = sizeof *m;
12339 m = bfd_zalloc (abfd, amt);
12340 if (m == NULL)
12341 return FALSE;
12342
12343 m->p_type = PT_MIPS_ABIFLAGS;
12344 m->count = 1;
12345 m->sections[0] = s;
12346
12347 /* We want to put it after the PHDR and INTERP segments. */
12348 pm = &elf_seg_map (abfd);
12349 while (*pm != NULL
12350 && ((*pm)->p_type == PT_PHDR
12351 || (*pm)->p_type == PT_INTERP))
12352 pm = &(*pm)->next;
12353
12354 m->next = *pm;
12355 *pm = m;
12356 }
12357 }
12358
12359 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
12360 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
12361 PT_MIPS_OPTIONS segment immediately following the program header
12362 table. */
12363 if (NEWABI_P (abfd)
12364 /* On non-IRIX6 new abi, we'll have already created a segment
12365 for this section, so don't create another. I'm not sure this
12366 is not also the case for IRIX 6, but I can't test it right
12367 now. */
12368 && IRIX_COMPAT (abfd) == ict_irix6)
12369 {
12370 for (s = abfd->sections; s; s = s->next)
12371 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
12372 break;
12373
12374 if (s)
12375 {
12376 struct elf_segment_map *options_segment;
12377
12378 pm = &elf_seg_map (abfd);
12379 while (*pm != NULL
12380 && ((*pm)->p_type == PT_PHDR
12381 || (*pm)->p_type == PT_INTERP))
12382 pm = &(*pm)->next;
12383
12384 if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
12385 {
12386 amt = sizeof (struct elf_segment_map);
12387 options_segment = bfd_zalloc (abfd, amt);
12388 options_segment->next = *pm;
12389 options_segment->p_type = PT_MIPS_OPTIONS;
12390 options_segment->p_flags = PF_R;
12391 options_segment->p_flags_valid = TRUE;
12392 options_segment->count = 1;
12393 options_segment->sections[0] = s;
12394 *pm = options_segment;
12395 }
12396 }
12397 }
12398 else
12399 {
12400 if (IRIX_COMPAT (abfd) == ict_irix5)
12401 {
12402 /* If there are .dynamic and .mdebug sections, we make a room
12403 for the RTPROC header. FIXME: Rewrite without section names. */
12404 if (bfd_get_section_by_name (abfd, ".interp") == NULL
12405 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
12406 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
12407 {
12408 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
12409 if (m->p_type == PT_MIPS_RTPROC)
12410 break;
12411 if (m == NULL)
12412 {
12413 amt = sizeof *m;
12414 m = bfd_zalloc (abfd, amt);
12415 if (m == NULL)
12416 return FALSE;
12417
12418 m->p_type = PT_MIPS_RTPROC;
12419
12420 s = bfd_get_section_by_name (abfd, ".rtproc");
12421 if (s == NULL)
12422 {
12423 m->count = 0;
12424 m->p_flags = 0;
12425 m->p_flags_valid = 1;
12426 }
12427 else
12428 {
12429 m->count = 1;
12430 m->sections[0] = s;
12431 }
12432
12433 /* We want to put it after the DYNAMIC segment. */
12434 pm = &elf_seg_map (abfd);
12435 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
12436 pm = &(*pm)->next;
12437 if (*pm != NULL)
12438 pm = &(*pm)->next;
12439
12440 m->next = *pm;
12441 *pm = m;
12442 }
12443 }
12444 }
12445 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
12446 .dynstr, .dynsym, and .hash sections, and everything in
12447 between. */
12448 for (pm = &elf_seg_map (abfd); *pm != NULL;
12449 pm = &(*pm)->next)
12450 if ((*pm)->p_type == PT_DYNAMIC)
12451 break;
12452 m = *pm;
12453 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
12454 glibc's dynamic linker has traditionally derived the number of
12455 tags from the p_filesz field, and sometimes allocates stack
12456 arrays of that size. An overly-big PT_DYNAMIC segment can
12457 be actively harmful in such cases. Making PT_DYNAMIC contain
12458 other sections can also make life hard for the prelinker,
12459 which might move one of the other sections to a different
12460 PT_LOAD segment. */
12461 if (SGI_COMPAT (abfd)
12462 && m != NULL
12463 && m->count == 1
12464 && strcmp (m->sections[0]->name, ".dynamic") == 0)
12465 {
12466 static const char *sec_names[] =
12467 {
12468 ".dynamic", ".dynstr", ".dynsym", ".hash"
12469 };
12470 bfd_vma low, high;
12471 unsigned int i, c;
12472 struct elf_segment_map *n;
12473
12474 low = ~(bfd_vma) 0;
12475 high = 0;
12476 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
12477 {
12478 s = bfd_get_section_by_name (abfd, sec_names[i]);
12479 if (s != NULL && (s->flags & SEC_LOAD) != 0)
12480 {
12481 bfd_size_type sz;
12482
12483 if (low > s->vma)
12484 low = s->vma;
12485 sz = s->size;
12486 if (high < s->vma + sz)
12487 high = s->vma + sz;
12488 }
12489 }
12490
12491 c = 0;
12492 for (s = abfd->sections; s != NULL; s = s->next)
12493 if ((s->flags & SEC_LOAD) != 0
12494 && s->vma >= low
12495 && s->vma + s->size <= high)
12496 ++c;
12497
12498 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
12499 n = bfd_zalloc (abfd, amt);
12500 if (n == NULL)
12501 return FALSE;
12502 *n = *m;
12503 n->count = c;
12504
12505 i = 0;
12506 for (s = abfd->sections; s != NULL; s = s->next)
12507 {
12508 if ((s->flags & SEC_LOAD) != 0
12509 && s->vma >= low
12510 && s->vma + s->size <= high)
12511 {
12512 n->sections[i] = s;
12513 ++i;
12514 }
12515 }
12516
12517 *pm = n;
12518 }
12519 }
12520
12521 /* Allocate a spare program header in dynamic objects so that tools
12522 like the prelinker can add an extra PT_LOAD entry.
12523
12524 If the prelinker needs to make room for a new PT_LOAD entry, its
12525 standard procedure is to move the first (read-only) sections into
12526 the new (writable) segment. However, the MIPS ABI requires
12527 .dynamic to be in a read-only segment, and the section will often
12528 start within sizeof (ElfNN_Phdr) bytes of the last program header.
12529
12530 Although the prelinker could in principle move .dynamic to a
12531 writable segment, it seems better to allocate a spare program
12532 header instead, and avoid the need to move any sections.
12533 There is a long tradition of allocating spare dynamic tags,
12534 so allocating a spare program header seems like a natural
12535 extension.
12536
12537 If INFO is NULL, we may be copying an already prelinked binary
12538 with objcopy or strip, so do not add this header. */
12539 if (info != NULL
12540 && !SGI_COMPAT (abfd)
12541 && bfd_get_section_by_name (abfd, ".dynamic"))
12542 {
12543 for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
12544 if ((*pm)->p_type == PT_NULL)
12545 break;
12546 if (*pm == NULL)
12547 {
12548 m = bfd_zalloc (abfd, sizeof (*m));
12549 if (m == NULL)
12550 return FALSE;
12551
12552 m->p_type = PT_NULL;
12553 *pm = m;
12554 }
12555 }
12556
12557 return TRUE;
12558 }
12559 \f
12560 /* Return the section that should be marked against GC for a given
12561 relocation. */
12562
12563 asection *
12564 _bfd_mips_elf_gc_mark_hook (asection *sec,
12565 struct bfd_link_info *info,
12566 Elf_Internal_Rela *rel,
12567 struct elf_link_hash_entry *h,
12568 Elf_Internal_Sym *sym)
12569 {
12570 /* ??? Do mips16 stub sections need to be handled special? */
12571
12572 if (h != NULL)
12573 switch (ELF_R_TYPE (sec->owner, rel->r_info))
12574 {
12575 case R_MIPS_GNU_VTINHERIT:
12576 case R_MIPS_GNU_VTENTRY:
12577 return NULL;
12578 }
12579
12580 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
12581 }
12582
12583 /* Update the got entry reference counts for the section being removed. */
12584
12585 bfd_boolean
12586 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
12587 struct bfd_link_info *info ATTRIBUTE_UNUSED,
12588 asection *sec ATTRIBUTE_UNUSED,
12589 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
12590 {
12591 #if 0
12592 Elf_Internal_Shdr *symtab_hdr;
12593 struct elf_link_hash_entry **sym_hashes;
12594 bfd_signed_vma *local_got_refcounts;
12595 const Elf_Internal_Rela *rel, *relend;
12596 unsigned long r_symndx;
12597 struct elf_link_hash_entry *h;
12598
12599 if (bfd_link_relocatable (info))
12600 return TRUE;
12601
12602 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12603 sym_hashes = elf_sym_hashes (abfd);
12604 local_got_refcounts = elf_local_got_refcounts (abfd);
12605
12606 relend = relocs + sec->reloc_count;
12607 for (rel = relocs; rel < relend; rel++)
12608 switch (ELF_R_TYPE (abfd, rel->r_info))
12609 {
12610 case R_MIPS16_GOT16:
12611 case R_MIPS16_CALL16:
12612 case R_MIPS_GOT16:
12613 case R_MIPS_CALL16:
12614 case R_MIPS_CALL_HI16:
12615 case R_MIPS_CALL_LO16:
12616 case R_MIPS_GOT_HI16:
12617 case R_MIPS_GOT_LO16:
12618 case R_MIPS_GOT_DISP:
12619 case R_MIPS_GOT_PAGE:
12620 case R_MIPS_GOT_OFST:
12621 case R_MICROMIPS_GOT16:
12622 case R_MICROMIPS_CALL16:
12623 case R_MICROMIPS_CALL_HI16:
12624 case R_MICROMIPS_CALL_LO16:
12625 case R_MICROMIPS_GOT_HI16:
12626 case R_MICROMIPS_GOT_LO16:
12627 case R_MICROMIPS_GOT_DISP:
12628 case R_MICROMIPS_GOT_PAGE:
12629 case R_MICROMIPS_GOT_OFST:
12630 /* ??? It would seem that the existing MIPS code does no sort
12631 of reference counting or whatnot on its GOT and PLT entries,
12632 so it is not possible to garbage collect them at this time. */
12633 break;
12634
12635 default:
12636 break;
12637 }
12638 #endif
12639
12640 return TRUE;
12641 }
12642
12643 /* Prevent .MIPS.abiflags from being discarded with --gc-sections. */
12644
12645 bfd_boolean
12646 _bfd_mips_elf_gc_mark_extra_sections (struct bfd_link_info *info,
12647 elf_gc_mark_hook_fn gc_mark_hook)
12648 {
12649 bfd *sub;
12650
12651 _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
12652
12653 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
12654 {
12655 asection *o;
12656
12657 if (! is_mips_elf (sub))
12658 continue;
12659
12660 for (o = sub->sections; o != NULL; o = o->next)
12661 if (!o->gc_mark
12662 && MIPS_ELF_ABIFLAGS_SECTION_NAME_P
12663 (bfd_get_section_name (sub, o)))
12664 {
12665 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12666 return FALSE;
12667 }
12668 }
12669
12670 return TRUE;
12671 }
12672 \f
12673 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
12674 hiding the old indirect symbol. Process additional relocation
12675 information. Also called for weakdefs, in which case we just let
12676 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
12677
12678 void
12679 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
12680 struct elf_link_hash_entry *dir,
12681 struct elf_link_hash_entry *ind)
12682 {
12683 struct mips_elf_link_hash_entry *dirmips, *indmips;
12684
12685 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
12686
12687 dirmips = (struct mips_elf_link_hash_entry *) dir;
12688 indmips = (struct mips_elf_link_hash_entry *) ind;
12689 /* Any absolute non-dynamic relocations against an indirect or weak
12690 definition will be against the target symbol. */
12691 if (indmips->has_static_relocs)
12692 dirmips->has_static_relocs = TRUE;
12693
12694 if (ind->root.type != bfd_link_hash_indirect)
12695 return;
12696
12697 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
12698 if (indmips->readonly_reloc)
12699 dirmips->readonly_reloc = TRUE;
12700 if (indmips->no_fn_stub)
12701 dirmips->no_fn_stub = TRUE;
12702 if (indmips->fn_stub)
12703 {
12704 dirmips->fn_stub = indmips->fn_stub;
12705 indmips->fn_stub = NULL;
12706 }
12707 if (indmips->need_fn_stub)
12708 {
12709 dirmips->need_fn_stub = TRUE;
12710 indmips->need_fn_stub = FALSE;
12711 }
12712 if (indmips->call_stub)
12713 {
12714 dirmips->call_stub = indmips->call_stub;
12715 indmips->call_stub = NULL;
12716 }
12717 if (indmips->call_fp_stub)
12718 {
12719 dirmips->call_fp_stub = indmips->call_fp_stub;
12720 indmips->call_fp_stub = NULL;
12721 }
12722 if (indmips->global_got_area < dirmips->global_got_area)
12723 dirmips->global_got_area = indmips->global_got_area;
12724 if (indmips->global_got_area < GGA_NONE)
12725 indmips->global_got_area = GGA_NONE;
12726 if (indmips->has_nonpic_branches)
12727 dirmips->has_nonpic_branches = TRUE;
12728 }
12729 \f
12730 #define PDR_SIZE 32
12731
12732 bfd_boolean
12733 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
12734 struct bfd_link_info *info)
12735 {
12736 asection *o;
12737 bfd_boolean ret = FALSE;
12738 unsigned char *tdata;
12739 size_t i, skip;
12740
12741 o = bfd_get_section_by_name (abfd, ".pdr");
12742 if (! o)
12743 return FALSE;
12744 if (o->size == 0)
12745 return FALSE;
12746 if (o->size % PDR_SIZE != 0)
12747 return FALSE;
12748 if (o->output_section != NULL
12749 && bfd_is_abs_section (o->output_section))
12750 return FALSE;
12751
12752 tdata = bfd_zmalloc (o->size / PDR_SIZE);
12753 if (! tdata)
12754 return FALSE;
12755
12756 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
12757 info->keep_memory);
12758 if (!cookie->rels)
12759 {
12760 free (tdata);
12761 return FALSE;
12762 }
12763
12764 cookie->rel = cookie->rels;
12765 cookie->relend = cookie->rels + o->reloc_count;
12766
12767 for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
12768 {
12769 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
12770 {
12771 tdata[i] = 1;
12772 skip ++;
12773 }
12774 }
12775
12776 if (skip != 0)
12777 {
12778 mips_elf_section_data (o)->u.tdata = tdata;
12779 if (o->rawsize == 0)
12780 o->rawsize = o->size;
12781 o->size -= skip * PDR_SIZE;
12782 ret = TRUE;
12783 }
12784 else
12785 free (tdata);
12786
12787 if (! info->keep_memory)
12788 free (cookie->rels);
12789
12790 return ret;
12791 }
12792
12793 bfd_boolean
12794 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
12795 {
12796 if (strcmp (sec->name, ".pdr") == 0)
12797 return TRUE;
12798 return FALSE;
12799 }
12800
12801 bfd_boolean
12802 _bfd_mips_elf_write_section (bfd *output_bfd,
12803 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
12804 asection *sec, bfd_byte *contents)
12805 {
12806 bfd_byte *to, *from, *end;
12807 int i;
12808
12809 if (strcmp (sec->name, ".pdr") != 0)
12810 return FALSE;
12811
12812 if (mips_elf_section_data (sec)->u.tdata == NULL)
12813 return FALSE;
12814
12815 to = contents;
12816 end = contents + sec->size;
12817 for (from = contents, i = 0;
12818 from < end;
12819 from += PDR_SIZE, i++)
12820 {
12821 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
12822 continue;
12823 if (to != from)
12824 memcpy (to, from, PDR_SIZE);
12825 to += PDR_SIZE;
12826 }
12827 bfd_set_section_contents (output_bfd, sec->output_section, contents,
12828 sec->output_offset, sec->size);
12829 return TRUE;
12830 }
12831 \f
12832 /* microMIPS code retains local labels for linker relaxation. Omit them
12833 from output by default for clarity. */
12834
12835 bfd_boolean
12836 _bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
12837 {
12838 return _bfd_elf_is_local_label_name (abfd, sym->name);
12839 }
12840
12841 /* MIPS ELF uses a special find_nearest_line routine in order the
12842 handle the ECOFF debugging information. */
12843
12844 struct mips_elf_find_line
12845 {
12846 struct ecoff_debug_info d;
12847 struct ecoff_find_line i;
12848 };
12849
12850 bfd_boolean
12851 _bfd_mips_elf_find_nearest_line (bfd *abfd, asymbol **symbols,
12852 asection *section, bfd_vma offset,
12853 const char **filename_ptr,
12854 const char **functionname_ptr,
12855 unsigned int *line_ptr,
12856 unsigned int *discriminator_ptr)
12857 {
12858 asection *msec;
12859
12860 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
12861 filename_ptr, functionname_ptr,
12862 line_ptr, discriminator_ptr,
12863 dwarf_debug_sections,
12864 ABI_64_P (abfd) ? 8 : 0,
12865 &elf_tdata (abfd)->dwarf2_find_line_info))
12866 return TRUE;
12867
12868 if (_bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
12869 filename_ptr, functionname_ptr,
12870 line_ptr))
12871 return TRUE;
12872
12873 msec = bfd_get_section_by_name (abfd, ".mdebug");
12874 if (msec != NULL)
12875 {
12876 flagword origflags;
12877 struct mips_elf_find_line *fi;
12878 const struct ecoff_debug_swap * const swap =
12879 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
12880
12881 /* If we are called during a link, mips_elf_final_link may have
12882 cleared the SEC_HAS_CONTENTS field. We force it back on here
12883 if appropriate (which it normally will be). */
12884 origflags = msec->flags;
12885 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
12886 msec->flags |= SEC_HAS_CONTENTS;
12887
12888 fi = mips_elf_tdata (abfd)->find_line_info;
12889 if (fi == NULL)
12890 {
12891 bfd_size_type external_fdr_size;
12892 char *fraw_src;
12893 char *fraw_end;
12894 struct fdr *fdr_ptr;
12895 bfd_size_type amt = sizeof (struct mips_elf_find_line);
12896
12897 fi = bfd_zalloc (abfd, amt);
12898 if (fi == NULL)
12899 {
12900 msec->flags = origflags;
12901 return FALSE;
12902 }
12903
12904 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
12905 {
12906 msec->flags = origflags;
12907 return FALSE;
12908 }
12909
12910 /* Swap in the FDR information. */
12911 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
12912 fi->d.fdr = bfd_alloc (abfd, amt);
12913 if (fi->d.fdr == NULL)
12914 {
12915 msec->flags = origflags;
12916 return FALSE;
12917 }
12918 external_fdr_size = swap->external_fdr_size;
12919 fdr_ptr = fi->d.fdr;
12920 fraw_src = (char *) fi->d.external_fdr;
12921 fraw_end = (fraw_src
12922 + fi->d.symbolic_header.ifdMax * external_fdr_size);
12923 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
12924 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
12925
12926 mips_elf_tdata (abfd)->find_line_info = fi;
12927
12928 /* Note that we don't bother to ever free this information.
12929 find_nearest_line is either called all the time, as in
12930 objdump -l, so the information should be saved, or it is
12931 rarely called, as in ld error messages, so the memory
12932 wasted is unimportant. Still, it would probably be a
12933 good idea for free_cached_info to throw it away. */
12934 }
12935
12936 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
12937 &fi->i, filename_ptr, functionname_ptr,
12938 line_ptr))
12939 {
12940 msec->flags = origflags;
12941 return TRUE;
12942 }
12943
12944 msec->flags = origflags;
12945 }
12946
12947 /* Fall back on the generic ELF find_nearest_line routine. */
12948
12949 return _bfd_elf_find_nearest_line (abfd, symbols, section, offset,
12950 filename_ptr, functionname_ptr,
12951 line_ptr, discriminator_ptr);
12952 }
12953
12954 bfd_boolean
12955 _bfd_mips_elf_find_inliner_info (bfd *abfd,
12956 const char **filename_ptr,
12957 const char **functionname_ptr,
12958 unsigned int *line_ptr)
12959 {
12960 bfd_boolean found;
12961 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
12962 functionname_ptr, line_ptr,
12963 & elf_tdata (abfd)->dwarf2_find_line_info);
12964 return found;
12965 }
12966
12967 \f
12968 /* When are writing out the .options or .MIPS.options section,
12969 remember the bytes we are writing out, so that we can install the
12970 GP value in the section_processing routine. */
12971
12972 bfd_boolean
12973 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
12974 const void *location,
12975 file_ptr offset, bfd_size_type count)
12976 {
12977 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
12978 {
12979 bfd_byte *c;
12980
12981 if (elf_section_data (section) == NULL)
12982 {
12983 bfd_size_type amt = sizeof (struct bfd_elf_section_data);
12984 section->used_by_bfd = bfd_zalloc (abfd, amt);
12985 if (elf_section_data (section) == NULL)
12986 return FALSE;
12987 }
12988 c = mips_elf_section_data (section)->u.tdata;
12989 if (c == NULL)
12990 {
12991 c = bfd_zalloc (abfd, section->size);
12992 if (c == NULL)
12993 return FALSE;
12994 mips_elf_section_data (section)->u.tdata = c;
12995 }
12996
12997 memcpy (c + offset, location, count);
12998 }
12999
13000 return _bfd_elf_set_section_contents (abfd, section, location, offset,
13001 count);
13002 }
13003
13004 /* This is almost identical to bfd_generic_get_... except that some
13005 MIPS relocations need to be handled specially. Sigh. */
13006
13007 bfd_byte *
13008 _bfd_elf_mips_get_relocated_section_contents
13009 (bfd *abfd,
13010 struct bfd_link_info *link_info,
13011 struct bfd_link_order *link_order,
13012 bfd_byte *data,
13013 bfd_boolean relocatable,
13014 asymbol **symbols)
13015 {
13016 /* Get enough memory to hold the stuff */
13017 bfd *input_bfd = link_order->u.indirect.section->owner;
13018 asection *input_section = link_order->u.indirect.section;
13019 bfd_size_type sz;
13020
13021 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
13022 arelent **reloc_vector = NULL;
13023 long reloc_count;
13024
13025 if (reloc_size < 0)
13026 goto error_return;
13027
13028 reloc_vector = bfd_malloc (reloc_size);
13029 if (reloc_vector == NULL && reloc_size != 0)
13030 goto error_return;
13031
13032 /* read in the section */
13033 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
13034 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
13035 goto error_return;
13036
13037 reloc_count = bfd_canonicalize_reloc (input_bfd,
13038 input_section,
13039 reloc_vector,
13040 symbols);
13041 if (reloc_count < 0)
13042 goto error_return;
13043
13044 if (reloc_count > 0)
13045 {
13046 arelent **parent;
13047 /* for mips */
13048 int gp_found;
13049 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
13050
13051 {
13052 struct bfd_hash_entry *h;
13053 struct bfd_link_hash_entry *lh;
13054 /* Skip all this stuff if we aren't mixing formats. */
13055 if (abfd && input_bfd
13056 && abfd->xvec == input_bfd->xvec)
13057 lh = 0;
13058 else
13059 {
13060 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
13061 lh = (struct bfd_link_hash_entry *) h;
13062 }
13063 lookup:
13064 if (lh)
13065 {
13066 switch (lh->type)
13067 {
13068 case bfd_link_hash_undefined:
13069 case bfd_link_hash_undefweak:
13070 case bfd_link_hash_common:
13071 gp_found = 0;
13072 break;
13073 case bfd_link_hash_defined:
13074 case bfd_link_hash_defweak:
13075 gp_found = 1;
13076 gp = lh->u.def.value;
13077 break;
13078 case bfd_link_hash_indirect:
13079 case bfd_link_hash_warning:
13080 lh = lh->u.i.link;
13081 /* @@FIXME ignoring warning for now */
13082 goto lookup;
13083 case bfd_link_hash_new:
13084 default:
13085 abort ();
13086 }
13087 }
13088 else
13089 gp_found = 0;
13090 }
13091 /* end mips */
13092 for (parent = reloc_vector; *parent != NULL; parent++)
13093 {
13094 char *error_message = NULL;
13095 bfd_reloc_status_type r;
13096
13097 /* Specific to MIPS: Deal with relocation types that require
13098 knowing the gp of the output bfd. */
13099 asymbol *sym = *(*parent)->sym_ptr_ptr;
13100
13101 /* If we've managed to find the gp and have a special
13102 function for the relocation then go ahead, else default
13103 to the generic handling. */
13104 if (gp_found
13105 && (*parent)->howto->special_function
13106 == _bfd_mips_elf32_gprel16_reloc)
13107 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
13108 input_section, relocatable,
13109 data, gp);
13110 else
13111 r = bfd_perform_relocation (input_bfd, *parent, data,
13112 input_section,
13113 relocatable ? abfd : NULL,
13114 &error_message);
13115
13116 if (relocatable)
13117 {
13118 asection *os = input_section->output_section;
13119
13120 /* A partial link, so keep the relocs */
13121 os->orelocation[os->reloc_count] = *parent;
13122 os->reloc_count++;
13123 }
13124
13125 if (r != bfd_reloc_ok)
13126 {
13127 switch (r)
13128 {
13129 case bfd_reloc_undefined:
13130 (*link_info->callbacks->undefined_symbol)
13131 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13132 input_bfd, input_section, (*parent)->address, TRUE);
13133 break;
13134 case bfd_reloc_dangerous:
13135 BFD_ASSERT (error_message != NULL);
13136 (*link_info->callbacks->reloc_dangerous)
13137 (link_info, error_message,
13138 input_bfd, input_section, (*parent)->address);
13139 break;
13140 case bfd_reloc_overflow:
13141 (*link_info->callbacks->reloc_overflow)
13142 (link_info, NULL,
13143 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13144 (*parent)->howto->name, (*parent)->addend,
13145 input_bfd, input_section, (*parent)->address);
13146 break;
13147 case bfd_reloc_outofrange:
13148 default:
13149 abort ();
13150 break;
13151 }
13152
13153 }
13154 }
13155 }
13156 if (reloc_vector != NULL)
13157 free (reloc_vector);
13158 return data;
13159
13160 error_return:
13161 if (reloc_vector != NULL)
13162 free (reloc_vector);
13163 return NULL;
13164 }
13165 \f
13166 static bfd_boolean
13167 mips_elf_relax_delete_bytes (bfd *abfd,
13168 asection *sec, bfd_vma addr, int count)
13169 {
13170 Elf_Internal_Shdr *symtab_hdr;
13171 unsigned int sec_shndx;
13172 bfd_byte *contents;
13173 Elf_Internal_Rela *irel, *irelend;
13174 Elf_Internal_Sym *isym;
13175 Elf_Internal_Sym *isymend;
13176 struct elf_link_hash_entry **sym_hashes;
13177 struct elf_link_hash_entry **end_hashes;
13178 struct elf_link_hash_entry **start_hashes;
13179 unsigned int symcount;
13180
13181 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
13182 contents = elf_section_data (sec)->this_hdr.contents;
13183
13184 irel = elf_section_data (sec)->relocs;
13185 irelend = irel + sec->reloc_count;
13186
13187 /* Actually delete the bytes. */
13188 memmove (contents + addr, contents + addr + count,
13189 (size_t) (sec->size - addr - count));
13190 sec->size -= count;
13191
13192 /* Adjust all the relocs. */
13193 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
13194 {
13195 /* Get the new reloc address. */
13196 if (irel->r_offset > addr)
13197 irel->r_offset -= count;
13198 }
13199
13200 BFD_ASSERT (addr % 2 == 0);
13201 BFD_ASSERT (count % 2 == 0);
13202
13203 /* Adjust the local symbols defined in this section. */
13204 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13205 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
13206 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
13207 if (isym->st_shndx == sec_shndx && isym->st_value > addr)
13208 isym->st_value -= count;
13209
13210 /* Now adjust the global symbols defined in this section. */
13211 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
13212 - symtab_hdr->sh_info);
13213 sym_hashes = start_hashes = elf_sym_hashes (abfd);
13214 end_hashes = sym_hashes + symcount;
13215
13216 for (; sym_hashes < end_hashes; sym_hashes++)
13217 {
13218 struct elf_link_hash_entry *sym_hash = *sym_hashes;
13219
13220 if ((sym_hash->root.type == bfd_link_hash_defined
13221 || sym_hash->root.type == bfd_link_hash_defweak)
13222 && sym_hash->root.u.def.section == sec)
13223 {
13224 bfd_vma value = sym_hash->root.u.def.value;
13225
13226 if (ELF_ST_IS_MICROMIPS (sym_hash->other))
13227 value &= MINUS_TWO;
13228 if (value > addr)
13229 sym_hash->root.u.def.value -= count;
13230 }
13231 }
13232
13233 return TRUE;
13234 }
13235
13236
13237 /* Opcodes needed for microMIPS relaxation as found in
13238 opcodes/micromips-opc.c. */
13239
13240 struct opcode_descriptor {
13241 unsigned long match;
13242 unsigned long mask;
13243 };
13244
13245 /* The $ra register aka $31. */
13246
13247 #define RA 31
13248
13249 /* 32-bit instruction format register fields. */
13250
13251 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
13252 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
13253
13254 /* Check if a 5-bit register index can be abbreviated to 3 bits. */
13255
13256 #define OP16_VALID_REG(r) \
13257 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
13258
13259
13260 /* 32-bit and 16-bit branches. */
13261
13262 static const struct opcode_descriptor b_insns_32[] = {
13263 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */
13264 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
13265 { 0, 0 } /* End marker for find_match(). */
13266 };
13267
13268 static const struct opcode_descriptor bc_insn_32 =
13269 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 };
13270
13271 static const struct opcode_descriptor bz_insn_32 =
13272 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 };
13273
13274 static const struct opcode_descriptor bzal_insn_32 =
13275 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 };
13276
13277 static const struct opcode_descriptor beq_insn_32 =
13278 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 };
13279
13280 static const struct opcode_descriptor b_insn_16 =
13281 { /* "b", "mD", */ 0xcc00, 0xfc00 };
13282
13283 static const struct opcode_descriptor bz_insn_16 =
13284 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 };
13285
13286
13287 /* 32-bit and 16-bit branch EQ and NE zero. */
13288
13289 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
13290 eq and second the ne. This convention is used when replacing a
13291 32-bit BEQ/BNE with the 16-bit version. */
13292
13293 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
13294
13295 static const struct opcode_descriptor bz_rs_insns_32[] = {
13296 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 },
13297 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 },
13298 { 0, 0 } /* End marker for find_match(). */
13299 };
13300
13301 static const struct opcode_descriptor bz_rt_insns_32[] = {
13302 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 },
13303 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 },
13304 { 0, 0 } /* End marker for find_match(). */
13305 };
13306
13307 static const struct opcode_descriptor bzc_insns_32[] = {
13308 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 },
13309 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 },
13310 { 0, 0 } /* End marker for find_match(). */
13311 };
13312
13313 static const struct opcode_descriptor bz_insns_16[] = {
13314 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 },
13315 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 },
13316 { 0, 0 } /* End marker for find_match(). */
13317 };
13318
13319 /* Switch between a 5-bit register index and its 3-bit shorthand. */
13320
13321 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0xf) + 2)
13322 #define BZ16_REG_FIELD(r) (((r) & 7) << 7)
13323
13324
13325 /* 32-bit instructions with a delay slot. */
13326
13327 static const struct opcode_descriptor jal_insn_32_bd16 =
13328 { /* "jals", "a", */ 0x74000000, 0xfc000000 };
13329
13330 static const struct opcode_descriptor jal_insn_32_bd32 =
13331 { /* "jal", "a", */ 0xf4000000, 0xfc000000 };
13332
13333 static const struct opcode_descriptor jal_x_insn_32_bd32 =
13334 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 };
13335
13336 static const struct opcode_descriptor j_insn_32 =
13337 { /* "j", "a", */ 0xd4000000, 0xfc000000 };
13338
13339 static const struct opcode_descriptor jalr_insn_32 =
13340 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff };
13341
13342 /* This table can be compacted, because no opcode replacement is made. */
13343
13344 static const struct opcode_descriptor ds_insns_32_bd16[] = {
13345 { /* "jals", "a", */ 0x74000000, 0xfc000000 },
13346
13347 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff },
13348 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 },
13349
13350 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 },
13351 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 },
13352 { /* "j", "a", */ 0xd4000000, 0xfc000000 },
13353 { 0, 0 } /* End marker for find_match(). */
13354 };
13355
13356 /* This table can be compacted, because no opcode replacement is made. */
13357
13358 static const struct opcode_descriptor ds_insns_32_bd32[] = {
13359 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 },
13360
13361 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff },
13362 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 },
13363 { 0, 0 } /* End marker for find_match(). */
13364 };
13365
13366
13367 /* 16-bit instructions with a delay slot. */
13368
13369 static const struct opcode_descriptor jalr_insn_16_bd16 =
13370 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 };
13371
13372 static const struct opcode_descriptor jalr_insn_16_bd32 =
13373 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 };
13374
13375 static const struct opcode_descriptor jr_insn_16 =
13376 { /* "jr", "mj", */ 0x4580, 0xffe0 };
13377
13378 #define JR16_REG(opcode) ((opcode) & 0x1f)
13379
13380 /* This table can be compacted, because no opcode replacement is made. */
13381
13382 static const struct opcode_descriptor ds_insns_16_bd16[] = {
13383 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 },
13384
13385 { /* "b", "mD", */ 0xcc00, 0xfc00 },
13386 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 },
13387 { /* "jr", "mj", */ 0x4580, 0xffe0 },
13388 { 0, 0 } /* End marker for find_match(). */
13389 };
13390
13391
13392 /* LUI instruction. */
13393
13394 static const struct opcode_descriptor lui_insn =
13395 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 };
13396
13397
13398 /* ADDIU instruction. */
13399
13400 static const struct opcode_descriptor addiu_insn =
13401 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 };
13402
13403 static const struct opcode_descriptor addiupc_insn =
13404 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 };
13405
13406 #define ADDIUPC_REG_FIELD(r) \
13407 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
13408
13409
13410 /* Relaxable instructions in a JAL delay slot: MOVE. */
13411
13412 /* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves
13413 (ADDU, OR) have rd in 15:11 and rs in 10:16. */
13414 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
13415 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
13416
13417 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
13418 #define MOVE16_RS_FIELD(r) (((r) & 0x1f) )
13419
13420 static const struct opcode_descriptor move_insns_32[] = {
13421 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */
13422 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
13423 { 0, 0 } /* End marker for find_match(). */
13424 };
13425
13426 static const struct opcode_descriptor move_insn_16 =
13427 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 };
13428
13429
13430 /* NOP instructions. */
13431
13432 static const struct opcode_descriptor nop_insn_32 =
13433 { /* "nop", "", */ 0x00000000, 0xffffffff };
13434
13435 static const struct opcode_descriptor nop_insn_16 =
13436 { /* "nop", "", */ 0x0c00, 0xffff };
13437
13438
13439 /* Instruction match support. */
13440
13441 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
13442
13443 static int
13444 find_match (unsigned long opcode, const struct opcode_descriptor insn[])
13445 {
13446 unsigned long indx;
13447
13448 for (indx = 0; insn[indx].mask != 0; indx++)
13449 if (MATCH (opcode, insn[indx]))
13450 return indx;
13451
13452 return -1;
13453 }
13454
13455
13456 /* Branch and delay slot decoding support. */
13457
13458 /* If PTR points to what *might* be a 16-bit branch or jump, then
13459 return the minimum length of its delay slot, otherwise return 0.
13460 Non-zero results are not definitive as we might be checking against
13461 the second half of another instruction. */
13462
13463 static int
13464 check_br16_dslot (bfd *abfd, bfd_byte *ptr)
13465 {
13466 unsigned long opcode;
13467 int bdsize;
13468
13469 opcode = bfd_get_16 (abfd, ptr);
13470 if (MATCH (opcode, jalr_insn_16_bd32) != 0)
13471 /* 16-bit branch/jump with a 32-bit delay slot. */
13472 bdsize = 4;
13473 else if (MATCH (opcode, jalr_insn_16_bd16) != 0
13474 || find_match (opcode, ds_insns_16_bd16) >= 0)
13475 /* 16-bit branch/jump with a 16-bit delay slot. */
13476 bdsize = 2;
13477 else
13478 /* No delay slot. */
13479 bdsize = 0;
13480
13481 return bdsize;
13482 }
13483
13484 /* If PTR points to what *might* be a 32-bit branch or jump, then
13485 return the minimum length of its delay slot, otherwise return 0.
13486 Non-zero results are not definitive as we might be checking against
13487 the second half of another instruction. */
13488
13489 static int
13490 check_br32_dslot (bfd *abfd, bfd_byte *ptr)
13491 {
13492 unsigned long opcode;
13493 int bdsize;
13494
13495 opcode = bfd_get_micromips_32 (abfd, ptr);
13496 if (find_match (opcode, ds_insns_32_bd32) >= 0)
13497 /* 32-bit branch/jump with a 32-bit delay slot. */
13498 bdsize = 4;
13499 else if (find_match (opcode, ds_insns_32_bd16) >= 0)
13500 /* 32-bit branch/jump with a 16-bit delay slot. */
13501 bdsize = 2;
13502 else
13503 /* No delay slot. */
13504 bdsize = 0;
13505
13506 return bdsize;
13507 }
13508
13509 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
13510 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */
13511
13512 static bfd_boolean
13513 check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
13514 {
13515 unsigned long opcode;
13516
13517 opcode = bfd_get_16 (abfd, ptr);
13518 if (MATCH (opcode, b_insn_16)
13519 /* B16 */
13520 || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode))
13521 /* JR16 */
13522 || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode))
13523 /* BEQZ16, BNEZ16 */
13524 || (MATCH (opcode, jalr_insn_16_bd32)
13525 /* JALR16 */
13526 && reg != JR16_REG (opcode) && reg != RA))
13527 return TRUE;
13528
13529 return FALSE;
13530 }
13531
13532 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
13533 then return TRUE, otherwise FALSE. */
13534
13535 static bfd_boolean
13536 check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
13537 {
13538 unsigned long opcode;
13539
13540 opcode = bfd_get_micromips_32 (abfd, ptr);
13541 if (MATCH (opcode, j_insn_32)
13542 /* J */
13543 || MATCH (opcode, bc_insn_32)
13544 /* BC1F, BC1T, BC2F, BC2T */
13545 || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA)
13546 /* JAL, JALX */
13547 || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode))
13548 /* BGEZ, BGTZ, BLEZ, BLTZ */
13549 || (MATCH (opcode, bzal_insn_32)
13550 /* BGEZAL, BLTZAL */
13551 && reg != OP32_SREG (opcode) && reg != RA)
13552 || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32))
13553 /* JALR, JALR.HB, BEQ, BNE */
13554 && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode)))
13555 return TRUE;
13556
13557 return FALSE;
13558 }
13559
13560 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
13561 IRELEND) at OFFSET indicate that there must be a compact branch there,
13562 then return TRUE, otherwise FALSE. */
13563
13564 static bfd_boolean
13565 check_relocated_bzc (bfd *abfd, const bfd_byte *ptr, bfd_vma offset,
13566 const Elf_Internal_Rela *internal_relocs,
13567 const Elf_Internal_Rela *irelend)
13568 {
13569 const Elf_Internal_Rela *irel;
13570 unsigned long opcode;
13571
13572 opcode = bfd_get_micromips_32 (abfd, ptr);
13573 if (find_match (opcode, bzc_insns_32) < 0)
13574 return FALSE;
13575
13576 for (irel = internal_relocs; irel < irelend; irel++)
13577 if (irel->r_offset == offset
13578 && ELF32_R_TYPE (irel->r_info) == R_MICROMIPS_PC16_S1)
13579 return TRUE;
13580
13581 return FALSE;
13582 }
13583
13584 /* Bitsize checking. */
13585 #define IS_BITSIZE(val, N) \
13586 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \
13587 - (1ULL << ((N) - 1))) == (val))
13588
13589 \f
13590 bfd_boolean
13591 _bfd_mips_elf_relax_section (bfd *abfd, asection *sec,
13592 struct bfd_link_info *link_info,
13593 bfd_boolean *again)
13594 {
13595 bfd_boolean insn32 = mips_elf_hash_table (link_info)->insn32;
13596 Elf_Internal_Shdr *symtab_hdr;
13597 Elf_Internal_Rela *internal_relocs;
13598 Elf_Internal_Rela *irel, *irelend;
13599 bfd_byte *contents = NULL;
13600 Elf_Internal_Sym *isymbuf = NULL;
13601
13602 /* Assume nothing changes. */
13603 *again = FALSE;
13604
13605 /* We don't have to do anything for a relocatable link, if
13606 this section does not have relocs, or if this is not a
13607 code section. */
13608
13609 if (bfd_link_relocatable (link_info)
13610 || (sec->flags & SEC_RELOC) == 0
13611 || sec->reloc_count == 0
13612 || (sec->flags & SEC_CODE) == 0)
13613 return TRUE;
13614
13615 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13616
13617 /* Get a copy of the native relocations. */
13618 internal_relocs = (_bfd_elf_link_read_relocs
13619 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
13620 link_info->keep_memory));
13621 if (internal_relocs == NULL)
13622 goto error_return;
13623
13624 /* Walk through them looking for relaxing opportunities. */
13625 irelend = internal_relocs + sec->reloc_count;
13626 for (irel = internal_relocs; irel < irelend; irel++)
13627 {
13628 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
13629 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
13630 bfd_boolean target_is_micromips_code_p;
13631 unsigned long opcode;
13632 bfd_vma symval;
13633 bfd_vma pcrval;
13634 bfd_byte *ptr;
13635 int fndopc;
13636
13637 /* The number of bytes to delete for relaxation and from where
13638 to delete these bytes starting at irel->r_offset. */
13639 int delcnt = 0;
13640 int deloff = 0;
13641
13642 /* If this isn't something that can be relaxed, then ignore
13643 this reloc. */
13644 if (r_type != R_MICROMIPS_HI16
13645 && r_type != R_MICROMIPS_PC16_S1
13646 && r_type != R_MICROMIPS_26_S1)
13647 continue;
13648
13649 /* Get the section contents if we haven't done so already. */
13650 if (contents == NULL)
13651 {
13652 /* Get cached copy if it exists. */
13653 if (elf_section_data (sec)->this_hdr.contents != NULL)
13654 contents = elf_section_data (sec)->this_hdr.contents;
13655 /* Go get them off disk. */
13656 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
13657 goto error_return;
13658 }
13659 ptr = contents + irel->r_offset;
13660
13661 /* Read this BFD's local symbols if we haven't done so already. */
13662 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
13663 {
13664 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
13665 if (isymbuf == NULL)
13666 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
13667 symtab_hdr->sh_info, 0,
13668 NULL, NULL, NULL);
13669 if (isymbuf == NULL)
13670 goto error_return;
13671 }
13672
13673 /* Get the value of the symbol referred to by the reloc. */
13674 if (r_symndx < symtab_hdr->sh_info)
13675 {
13676 /* A local symbol. */
13677 Elf_Internal_Sym *isym;
13678 asection *sym_sec;
13679
13680 isym = isymbuf + r_symndx;
13681 if (isym->st_shndx == SHN_UNDEF)
13682 sym_sec = bfd_und_section_ptr;
13683 else if (isym->st_shndx == SHN_ABS)
13684 sym_sec = bfd_abs_section_ptr;
13685 else if (isym->st_shndx == SHN_COMMON)
13686 sym_sec = bfd_com_section_ptr;
13687 else
13688 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
13689 symval = (isym->st_value
13690 + sym_sec->output_section->vma
13691 + sym_sec->output_offset);
13692 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other);
13693 }
13694 else
13695 {
13696 unsigned long indx;
13697 struct elf_link_hash_entry *h;
13698
13699 /* An external symbol. */
13700 indx = r_symndx - symtab_hdr->sh_info;
13701 h = elf_sym_hashes (abfd)[indx];
13702 BFD_ASSERT (h != NULL);
13703
13704 if (h->root.type != bfd_link_hash_defined
13705 && h->root.type != bfd_link_hash_defweak)
13706 /* This appears to be a reference to an undefined
13707 symbol. Just ignore it -- it will be caught by the
13708 regular reloc processing. */
13709 continue;
13710
13711 symval = (h->root.u.def.value
13712 + h->root.u.def.section->output_section->vma
13713 + h->root.u.def.section->output_offset);
13714 target_is_micromips_code_p = (!h->needs_plt
13715 && ELF_ST_IS_MICROMIPS (h->other));
13716 }
13717
13718
13719 /* For simplicity of coding, we are going to modify the
13720 section contents, the section relocs, and the BFD symbol
13721 table. We must tell the rest of the code not to free up this
13722 information. It would be possible to instead create a table
13723 of changes which have to be made, as is done in coff-mips.c;
13724 that would be more work, but would require less memory when
13725 the linker is run. */
13726
13727 /* Only 32-bit instructions relaxed. */
13728 if (irel->r_offset + 4 > sec->size)
13729 continue;
13730
13731 opcode = bfd_get_micromips_32 (abfd, ptr);
13732
13733 /* This is the pc-relative distance from the instruction the
13734 relocation is applied to, to the symbol referred. */
13735 pcrval = (symval
13736 - (sec->output_section->vma + sec->output_offset)
13737 - irel->r_offset);
13738
13739 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
13740 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
13741 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is
13742
13743 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
13744
13745 where pcrval has first to be adjusted to apply against the LO16
13746 location (we make the adjustment later on, when we have figured
13747 out the offset). */
13748 if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn))
13749 {
13750 bfd_boolean bzc = FALSE;
13751 unsigned long nextopc;
13752 unsigned long reg;
13753 bfd_vma offset;
13754
13755 /* Give up if the previous reloc was a HI16 against this symbol
13756 too. */
13757 if (irel > internal_relocs
13758 && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16
13759 && ELF32_R_SYM (irel[-1].r_info) == r_symndx)
13760 continue;
13761
13762 /* Or if the next reloc is not a LO16 against this symbol. */
13763 if (irel + 1 >= irelend
13764 || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16
13765 || ELF32_R_SYM (irel[1].r_info) != r_symndx)
13766 continue;
13767
13768 /* Or if the second next reloc is a LO16 against this symbol too. */
13769 if (irel + 2 >= irelend
13770 && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16
13771 && ELF32_R_SYM (irel[2].r_info) == r_symndx)
13772 continue;
13773
13774 /* See if the LUI instruction *might* be in a branch delay slot.
13775 We check whether what looks like a 16-bit branch or jump is
13776 actually an immediate argument to a compact branch, and let
13777 it through if so. */
13778 if (irel->r_offset >= 2
13779 && check_br16_dslot (abfd, ptr - 2)
13780 && !(irel->r_offset >= 4
13781 && (bzc = check_relocated_bzc (abfd,
13782 ptr - 4, irel->r_offset - 4,
13783 internal_relocs, irelend))))
13784 continue;
13785 if (irel->r_offset >= 4
13786 && !bzc
13787 && check_br32_dslot (abfd, ptr - 4))
13788 continue;
13789
13790 reg = OP32_SREG (opcode);
13791
13792 /* We only relax adjacent instructions or ones separated with
13793 a branch or jump that has a delay slot. The branch or jump
13794 must not fiddle with the register used to hold the address.
13795 Subtract 4 for the LUI itself. */
13796 offset = irel[1].r_offset - irel[0].r_offset;
13797 switch (offset - 4)
13798 {
13799 case 0:
13800 break;
13801 case 2:
13802 if (check_br16 (abfd, ptr + 4, reg))
13803 break;
13804 continue;
13805 case 4:
13806 if (check_br32 (abfd, ptr + 4, reg))
13807 break;
13808 continue;
13809 default:
13810 continue;
13811 }
13812
13813 nextopc = bfd_get_micromips_32 (abfd, contents + irel[1].r_offset);
13814
13815 /* Give up unless the same register is used with both
13816 relocations. */
13817 if (OP32_SREG (nextopc) != reg)
13818 continue;
13819
13820 /* Now adjust pcrval, subtracting the offset to the LO16 reloc
13821 and rounding up to take masking of the two LSBs into account. */
13822 pcrval = ((pcrval - offset + 3) | 3) ^ 3;
13823
13824 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */
13825 if (IS_BITSIZE (symval, 16))
13826 {
13827 /* Fix the relocation's type. */
13828 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16);
13829
13830 /* Instructions using R_MICROMIPS_LO16 have the base or
13831 source register in bits 20:16. This register becomes $0
13832 (zero) as the result of the R_MICROMIPS_HI16 being 0. */
13833 nextopc &= ~0x001f0000;
13834 bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
13835 contents + irel[1].r_offset);
13836 }
13837
13838 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
13839 We add 4 to take LUI deletion into account while checking
13840 the PC-relative distance. */
13841 else if (symval % 4 == 0
13842 && IS_BITSIZE (pcrval + 4, 25)
13843 && MATCH (nextopc, addiu_insn)
13844 && OP32_TREG (nextopc) == OP32_SREG (nextopc)
13845 && OP16_VALID_REG (OP32_TREG (nextopc)))
13846 {
13847 /* Fix the relocation's type. */
13848 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2);
13849
13850 /* Replace ADDIU with the ADDIUPC version. */
13851 nextopc = (addiupc_insn.match
13852 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc)));
13853
13854 bfd_put_micromips_32 (abfd, nextopc,
13855 contents + irel[1].r_offset);
13856 }
13857
13858 /* Can't do anything, give up, sigh... */
13859 else
13860 continue;
13861
13862 /* Fix the relocation's type. */
13863 irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE);
13864
13865 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */
13866 delcnt = 4;
13867 deloff = 0;
13868 }
13869
13870 /* Compact branch relaxation -- due to the multitude of macros
13871 employed by the compiler/assembler, compact branches are not
13872 always generated. Obviously, this can/will be fixed elsewhere,
13873 but there is no drawback in double checking it here. */
13874 else if (r_type == R_MICROMIPS_PC16_S1
13875 && irel->r_offset + 5 < sec->size
13876 && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
13877 || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0)
13878 && ((!insn32
13879 && (delcnt = MATCH (bfd_get_16 (abfd, ptr + 4),
13880 nop_insn_16) ? 2 : 0))
13881 || (irel->r_offset + 7 < sec->size
13882 && (delcnt = MATCH (bfd_get_micromips_32 (abfd,
13883 ptr + 4),
13884 nop_insn_32) ? 4 : 0))))
13885 {
13886 unsigned long reg;
13887
13888 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
13889
13890 /* Replace BEQZ/BNEZ with the compact version. */
13891 opcode = (bzc_insns_32[fndopc].match
13892 | BZC32_REG_FIELD (reg)
13893 | (opcode & 0xffff)); /* Addend value. */
13894
13895 bfd_put_micromips_32 (abfd, opcode, ptr);
13896
13897 /* Delete the delay slot NOP: two or four bytes from
13898 irel->offset + 4; delcnt has already been set above. */
13899 deloff = 4;
13900 }
13901
13902 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need
13903 to check the distance from the next instruction, so subtract 2. */
13904 else if (!insn32
13905 && r_type == R_MICROMIPS_PC16_S1
13906 && IS_BITSIZE (pcrval - 2, 11)
13907 && find_match (opcode, b_insns_32) >= 0)
13908 {
13909 /* Fix the relocation's type. */
13910 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1);
13911
13912 /* Replace the 32-bit opcode with a 16-bit opcode. */
13913 bfd_put_16 (abfd,
13914 (b_insn_16.match
13915 | (opcode & 0x3ff)), /* Addend value. */
13916 ptr);
13917
13918 /* Delete 2 bytes from irel->r_offset + 2. */
13919 delcnt = 2;
13920 deloff = 2;
13921 }
13922
13923 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need
13924 to check the distance from the next instruction, so subtract 2. */
13925 else if (!insn32
13926 && r_type == R_MICROMIPS_PC16_S1
13927 && IS_BITSIZE (pcrval - 2, 8)
13928 && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
13929 && OP16_VALID_REG (OP32_SREG (opcode)))
13930 || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0
13931 && OP16_VALID_REG (OP32_TREG (opcode)))))
13932 {
13933 unsigned long reg;
13934
13935 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
13936
13937 /* Fix the relocation's type. */
13938 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1);
13939
13940 /* Replace the 32-bit opcode with a 16-bit opcode. */
13941 bfd_put_16 (abfd,
13942 (bz_insns_16[fndopc].match
13943 | BZ16_REG_FIELD (reg)
13944 | (opcode & 0x7f)), /* Addend value. */
13945 ptr);
13946
13947 /* Delete 2 bytes from irel->r_offset + 2. */
13948 delcnt = 2;
13949 deloff = 2;
13950 }
13951
13952 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */
13953 else if (!insn32
13954 && r_type == R_MICROMIPS_26_S1
13955 && target_is_micromips_code_p
13956 && irel->r_offset + 7 < sec->size
13957 && MATCH (opcode, jal_insn_32_bd32))
13958 {
13959 unsigned long n32opc;
13960 bfd_boolean relaxed = FALSE;
13961
13962 n32opc = bfd_get_micromips_32 (abfd, ptr + 4);
13963
13964 if (MATCH (n32opc, nop_insn_32))
13965 {
13966 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */
13967 bfd_put_16 (abfd, nop_insn_16.match, ptr + 4);
13968
13969 relaxed = TRUE;
13970 }
13971 else if (find_match (n32opc, move_insns_32) >= 0)
13972 {
13973 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */
13974 bfd_put_16 (abfd,
13975 (move_insn_16.match
13976 | MOVE16_RD_FIELD (MOVE32_RD (n32opc))
13977 | MOVE16_RS_FIELD (MOVE32_RS (n32opc))),
13978 ptr + 4);
13979
13980 relaxed = TRUE;
13981 }
13982 /* Other 32-bit instructions relaxable to 16-bit
13983 instructions will be handled here later. */
13984
13985 if (relaxed)
13986 {
13987 /* JAL with 32-bit delay slot that is changed to a JALS
13988 with 16-bit delay slot. */
13989 bfd_put_micromips_32 (abfd, jal_insn_32_bd16.match, ptr);
13990
13991 /* Delete 2 bytes from irel->r_offset + 6. */
13992 delcnt = 2;
13993 deloff = 6;
13994 }
13995 }
13996
13997 if (delcnt != 0)
13998 {
13999 /* Note that we've changed the relocs, section contents, etc. */
14000 elf_section_data (sec)->relocs = internal_relocs;
14001 elf_section_data (sec)->this_hdr.contents = contents;
14002 symtab_hdr->contents = (unsigned char *) isymbuf;
14003
14004 /* Delete bytes depending on the delcnt and deloff. */
14005 if (!mips_elf_relax_delete_bytes (abfd, sec,
14006 irel->r_offset + deloff, delcnt))
14007 goto error_return;
14008
14009 /* That will change things, so we should relax again.
14010 Note that this is not required, and it may be slow. */
14011 *again = TRUE;
14012 }
14013 }
14014
14015 if (isymbuf != NULL
14016 && symtab_hdr->contents != (unsigned char *) isymbuf)
14017 {
14018 if (! link_info->keep_memory)
14019 free (isymbuf);
14020 else
14021 {
14022 /* Cache the symbols for elf_link_input_bfd. */
14023 symtab_hdr->contents = (unsigned char *) isymbuf;
14024 }
14025 }
14026
14027 if (contents != NULL
14028 && elf_section_data (sec)->this_hdr.contents != contents)
14029 {
14030 if (! link_info->keep_memory)
14031 free (contents);
14032 else
14033 {
14034 /* Cache the section contents for elf_link_input_bfd. */
14035 elf_section_data (sec)->this_hdr.contents = contents;
14036 }
14037 }
14038
14039 if (internal_relocs != NULL
14040 && elf_section_data (sec)->relocs != internal_relocs)
14041 free (internal_relocs);
14042
14043 return TRUE;
14044
14045 error_return:
14046 if (isymbuf != NULL
14047 && symtab_hdr->contents != (unsigned char *) isymbuf)
14048 free (isymbuf);
14049 if (contents != NULL
14050 && elf_section_data (sec)->this_hdr.contents != contents)
14051 free (contents);
14052 if (internal_relocs != NULL
14053 && elf_section_data (sec)->relocs != internal_relocs)
14054 free (internal_relocs);
14055
14056 return FALSE;
14057 }
14058 \f
14059 /* Create a MIPS ELF linker hash table. */
14060
14061 struct bfd_link_hash_table *
14062 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
14063 {
14064 struct mips_elf_link_hash_table *ret;
14065 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
14066
14067 ret = bfd_zmalloc (amt);
14068 if (ret == NULL)
14069 return NULL;
14070
14071 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
14072 mips_elf_link_hash_newfunc,
14073 sizeof (struct mips_elf_link_hash_entry),
14074 MIPS_ELF_DATA))
14075 {
14076 free (ret);
14077 return NULL;
14078 }
14079 ret->root.init_plt_refcount.plist = NULL;
14080 ret->root.init_plt_offset.plist = NULL;
14081
14082 return &ret->root.root;
14083 }
14084
14085 /* Likewise, but indicate that the target is VxWorks. */
14086
14087 struct bfd_link_hash_table *
14088 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
14089 {
14090 struct bfd_link_hash_table *ret;
14091
14092 ret = _bfd_mips_elf_link_hash_table_create (abfd);
14093 if (ret)
14094 {
14095 struct mips_elf_link_hash_table *htab;
14096
14097 htab = (struct mips_elf_link_hash_table *) ret;
14098 htab->use_plts_and_copy_relocs = TRUE;
14099 htab->is_vxworks = TRUE;
14100 }
14101 return ret;
14102 }
14103
14104 /* A function that the linker calls if we are allowed to use PLTs
14105 and copy relocs. */
14106
14107 void
14108 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
14109 {
14110 mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
14111 }
14112
14113 /* A function that the linker calls to select between all or only
14114 32-bit microMIPS instructions, and between making or ignoring
14115 branch relocation checks for invalid transitions between ISA modes. */
14116
14117 void
14118 _bfd_mips_elf_linker_flags (struct bfd_link_info *info, bfd_boolean insn32,
14119 bfd_boolean ignore_branch_isa)
14120 {
14121 mips_elf_hash_table (info)->insn32 = insn32;
14122 mips_elf_hash_table (info)->ignore_branch_isa = ignore_branch_isa;
14123 }
14124 \f
14125 /* Structure for saying that BFD machine EXTENSION extends BASE. */
14126
14127 struct mips_mach_extension
14128 {
14129 unsigned long extension, base;
14130 };
14131
14132
14133 /* An array describing how BFD machines relate to one another. The entries
14134 are ordered topologically with MIPS I extensions listed last. */
14135
14136 static const struct mips_mach_extension mips_mach_extensions[] =
14137 {
14138 /* MIPS64r2 extensions. */
14139 { bfd_mach_mips_octeon3, bfd_mach_mips_octeon2 },
14140 { bfd_mach_mips_octeon2, bfd_mach_mips_octeonp },
14141 { bfd_mach_mips_octeonp, bfd_mach_mips_octeon },
14142 { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
14143 { bfd_mach_mips_loongson_3a, bfd_mach_mipsisa64r2 },
14144
14145 /* MIPS64 extensions. */
14146 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
14147 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
14148 { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
14149
14150 /* MIPS V extensions. */
14151 { bfd_mach_mipsisa64, bfd_mach_mips5 },
14152
14153 /* R10000 extensions. */
14154 { bfd_mach_mips12000, bfd_mach_mips10000 },
14155 { bfd_mach_mips14000, bfd_mach_mips10000 },
14156 { bfd_mach_mips16000, bfd_mach_mips10000 },
14157
14158 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
14159 vr5400 ISA, but doesn't include the multimedia stuff. It seems
14160 better to allow vr5400 and vr5500 code to be merged anyway, since
14161 many libraries will just use the core ISA. Perhaps we could add
14162 some sort of ASE flag if this ever proves a problem. */
14163 { bfd_mach_mips5500, bfd_mach_mips5400 },
14164 { bfd_mach_mips5400, bfd_mach_mips5000 },
14165
14166 /* MIPS IV extensions. */
14167 { bfd_mach_mips5, bfd_mach_mips8000 },
14168 { bfd_mach_mips10000, bfd_mach_mips8000 },
14169 { bfd_mach_mips5000, bfd_mach_mips8000 },
14170 { bfd_mach_mips7000, bfd_mach_mips8000 },
14171 { bfd_mach_mips9000, bfd_mach_mips8000 },
14172
14173 /* VR4100 extensions. */
14174 { bfd_mach_mips4120, bfd_mach_mips4100 },
14175 { bfd_mach_mips4111, bfd_mach_mips4100 },
14176
14177 /* MIPS III extensions. */
14178 { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
14179 { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
14180 { bfd_mach_mips8000, bfd_mach_mips4000 },
14181 { bfd_mach_mips4650, bfd_mach_mips4000 },
14182 { bfd_mach_mips4600, bfd_mach_mips4000 },
14183 { bfd_mach_mips4400, bfd_mach_mips4000 },
14184 { bfd_mach_mips4300, bfd_mach_mips4000 },
14185 { bfd_mach_mips4100, bfd_mach_mips4000 },
14186 { bfd_mach_mips4010, bfd_mach_mips4000 },
14187 { bfd_mach_mips5900, bfd_mach_mips4000 },
14188
14189 /* MIPS32 extensions. */
14190 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
14191
14192 /* MIPS II extensions. */
14193 { bfd_mach_mips4000, bfd_mach_mips6000 },
14194 { bfd_mach_mipsisa32, bfd_mach_mips6000 },
14195
14196 /* MIPS I extensions. */
14197 { bfd_mach_mips6000, bfd_mach_mips3000 },
14198 { bfd_mach_mips3900, bfd_mach_mips3000 }
14199 };
14200
14201 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
14202
14203 static bfd_boolean
14204 mips_mach_extends_p (unsigned long base, unsigned long extension)
14205 {
14206 size_t i;
14207
14208 if (extension == base)
14209 return TRUE;
14210
14211 if (base == bfd_mach_mipsisa32
14212 && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
14213 return TRUE;
14214
14215 if (base == bfd_mach_mipsisa32r2
14216 && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
14217 return TRUE;
14218
14219 for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
14220 if (extension == mips_mach_extensions[i].extension)
14221 {
14222 extension = mips_mach_extensions[i].base;
14223 if (extension == base)
14224 return TRUE;
14225 }
14226
14227 return FALSE;
14228 }
14229
14230 /* Return the BFD mach for each .MIPS.abiflags ISA Extension. */
14231
14232 static unsigned long
14233 bfd_mips_isa_ext_mach (unsigned int isa_ext)
14234 {
14235 switch (isa_ext)
14236 {
14237 case AFL_EXT_3900: return bfd_mach_mips3900;
14238 case AFL_EXT_4010: return bfd_mach_mips4010;
14239 case AFL_EXT_4100: return bfd_mach_mips4100;
14240 case AFL_EXT_4111: return bfd_mach_mips4111;
14241 case AFL_EXT_4120: return bfd_mach_mips4120;
14242 case AFL_EXT_4650: return bfd_mach_mips4650;
14243 case AFL_EXT_5400: return bfd_mach_mips5400;
14244 case AFL_EXT_5500: return bfd_mach_mips5500;
14245 case AFL_EXT_5900: return bfd_mach_mips5900;
14246 case AFL_EXT_10000: return bfd_mach_mips10000;
14247 case AFL_EXT_LOONGSON_2E: return bfd_mach_mips_loongson_2e;
14248 case AFL_EXT_LOONGSON_2F: return bfd_mach_mips_loongson_2f;
14249 case AFL_EXT_LOONGSON_3A: return bfd_mach_mips_loongson_3a;
14250 case AFL_EXT_SB1: return bfd_mach_mips_sb1;
14251 case AFL_EXT_OCTEON: return bfd_mach_mips_octeon;
14252 case AFL_EXT_OCTEONP: return bfd_mach_mips_octeonp;
14253 case AFL_EXT_OCTEON2: return bfd_mach_mips_octeon2;
14254 case AFL_EXT_XLR: return bfd_mach_mips_xlr;
14255 default: return bfd_mach_mips3000;
14256 }
14257 }
14258
14259 /* Return the .MIPS.abiflags value representing each ISA Extension. */
14260
14261 unsigned int
14262 bfd_mips_isa_ext (bfd *abfd)
14263 {
14264 switch (bfd_get_mach (abfd))
14265 {
14266 case bfd_mach_mips3900: return AFL_EXT_3900;
14267 case bfd_mach_mips4010: return AFL_EXT_4010;
14268 case bfd_mach_mips4100: return AFL_EXT_4100;
14269 case bfd_mach_mips4111: return AFL_EXT_4111;
14270 case bfd_mach_mips4120: return AFL_EXT_4120;
14271 case bfd_mach_mips4650: return AFL_EXT_4650;
14272 case bfd_mach_mips5400: return AFL_EXT_5400;
14273 case bfd_mach_mips5500: return AFL_EXT_5500;
14274 case bfd_mach_mips5900: return AFL_EXT_5900;
14275 case bfd_mach_mips10000: return AFL_EXT_10000;
14276 case bfd_mach_mips_loongson_2e: return AFL_EXT_LOONGSON_2E;
14277 case bfd_mach_mips_loongson_2f: return AFL_EXT_LOONGSON_2F;
14278 case bfd_mach_mips_loongson_3a: return AFL_EXT_LOONGSON_3A;
14279 case bfd_mach_mips_sb1: return AFL_EXT_SB1;
14280 case bfd_mach_mips_octeon: return AFL_EXT_OCTEON;
14281 case bfd_mach_mips_octeonp: return AFL_EXT_OCTEONP;
14282 case bfd_mach_mips_octeon3: return AFL_EXT_OCTEON3;
14283 case bfd_mach_mips_octeon2: return AFL_EXT_OCTEON2;
14284 case bfd_mach_mips_xlr: return AFL_EXT_XLR;
14285 default: return 0;
14286 }
14287 }
14288
14289 /* Encode ISA level and revision as a single value. */
14290 #define LEVEL_REV(LEV,REV) ((LEV) << 3 | (REV))
14291
14292 /* Decode a single value into level and revision. */
14293 #define ISA_LEVEL(LEVREV) ((LEVREV) >> 3)
14294 #define ISA_REV(LEVREV) ((LEVREV) & 0x7)
14295
14296 /* Update the isa_level, isa_rev, isa_ext fields of abiflags. */
14297
14298 static void
14299 update_mips_abiflags_isa (bfd *abfd, Elf_Internal_ABIFlags_v0 *abiflags)
14300 {
14301 int new_isa = 0;
14302 switch (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH)
14303 {
14304 case E_MIPS_ARCH_1: new_isa = LEVEL_REV (1, 0); break;
14305 case E_MIPS_ARCH_2: new_isa = LEVEL_REV (2, 0); break;
14306 case E_MIPS_ARCH_3: new_isa = LEVEL_REV (3, 0); break;
14307 case E_MIPS_ARCH_4: new_isa = LEVEL_REV (4, 0); break;
14308 case E_MIPS_ARCH_5: new_isa = LEVEL_REV (5, 0); break;
14309 case E_MIPS_ARCH_32: new_isa = LEVEL_REV (32, 1); break;
14310 case E_MIPS_ARCH_32R2: new_isa = LEVEL_REV (32, 2); break;
14311 case E_MIPS_ARCH_32R6: new_isa = LEVEL_REV (32, 6); break;
14312 case E_MIPS_ARCH_64: new_isa = LEVEL_REV (64, 1); break;
14313 case E_MIPS_ARCH_64R2: new_isa = LEVEL_REV (64, 2); break;
14314 case E_MIPS_ARCH_64R6: new_isa = LEVEL_REV (64, 6); break;
14315 default:
14316 _bfd_error_handler
14317 /* xgettext:c-format */
14318 (_("%B: Unknown architecture %s"),
14319 abfd, bfd_printable_name (abfd));
14320 }
14321
14322 if (new_isa > LEVEL_REV (abiflags->isa_level, abiflags->isa_rev))
14323 {
14324 abiflags->isa_level = ISA_LEVEL (new_isa);
14325 abiflags->isa_rev = ISA_REV (new_isa);
14326 }
14327
14328 /* Update the isa_ext if ABFD describes a further extension. */
14329 if (mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags->isa_ext),
14330 bfd_get_mach (abfd)))
14331 abiflags->isa_ext = bfd_mips_isa_ext (abfd);
14332 }
14333
14334 /* Return true if the given ELF header flags describe a 32-bit binary. */
14335
14336 static bfd_boolean
14337 mips_32bit_flags_p (flagword flags)
14338 {
14339 return ((flags & EF_MIPS_32BITMODE) != 0
14340 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
14341 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
14342 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
14343 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
14344 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
14345 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2
14346 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6);
14347 }
14348
14349 /* Infer the content of the ABI flags based on the elf header. */
14350
14351 static void
14352 infer_mips_abiflags (bfd *abfd, Elf_Internal_ABIFlags_v0* abiflags)
14353 {
14354 obj_attribute *in_attr;
14355
14356 memset (abiflags, 0, sizeof (Elf_Internal_ABIFlags_v0));
14357 update_mips_abiflags_isa (abfd, abiflags);
14358
14359 if (mips_32bit_flags_p (elf_elfheader (abfd)->e_flags))
14360 abiflags->gpr_size = AFL_REG_32;
14361 else
14362 abiflags->gpr_size = AFL_REG_64;
14363
14364 abiflags->cpr1_size = AFL_REG_NONE;
14365
14366 in_attr = elf_known_obj_attributes (abfd)[OBJ_ATTR_GNU];
14367 abiflags->fp_abi = in_attr[Tag_GNU_MIPS_ABI_FP].i;
14368
14369 if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_SINGLE
14370 || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_XX
14371 || (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
14372 && abiflags->gpr_size == AFL_REG_32))
14373 abiflags->cpr1_size = AFL_REG_32;
14374 else if (abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_DOUBLE
14375 || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64
14376 || abiflags->fp_abi == Val_GNU_MIPS_ABI_FP_64A)
14377 abiflags->cpr1_size = AFL_REG_64;
14378
14379 abiflags->cpr2_size = AFL_REG_NONE;
14380
14381 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
14382 abiflags->ases |= AFL_ASE_MDMX;
14383 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
14384 abiflags->ases |= AFL_ASE_MIPS16;
14385 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
14386 abiflags->ases |= AFL_ASE_MICROMIPS;
14387
14388 if (abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_ANY
14389 && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_SOFT
14390 && abiflags->fp_abi != Val_GNU_MIPS_ABI_FP_64A
14391 && abiflags->isa_level >= 32
14392 && abiflags->isa_ext != AFL_EXT_LOONGSON_3A)
14393 abiflags->flags1 |= AFL_FLAGS1_ODDSPREG;
14394 }
14395
14396 /* We need to use a special link routine to handle the .reginfo and
14397 the .mdebug sections. We need to merge all instances of these
14398 sections together, not write them all out sequentially. */
14399
14400 bfd_boolean
14401 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
14402 {
14403 asection *o;
14404 struct bfd_link_order *p;
14405 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
14406 asection *rtproc_sec, *abiflags_sec;
14407 Elf32_RegInfo reginfo;
14408 struct ecoff_debug_info debug;
14409 struct mips_htab_traverse_info hti;
14410 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
14411 const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
14412 HDRR *symhdr = &debug.symbolic_header;
14413 void *mdebug_handle = NULL;
14414 asection *s;
14415 EXTR esym;
14416 unsigned int i;
14417 bfd_size_type amt;
14418 struct mips_elf_link_hash_table *htab;
14419
14420 static const char * const secname[] =
14421 {
14422 ".text", ".init", ".fini", ".data",
14423 ".rodata", ".sdata", ".sbss", ".bss"
14424 };
14425 static const int sc[] =
14426 {
14427 scText, scInit, scFini, scData,
14428 scRData, scSData, scSBss, scBss
14429 };
14430
14431 /* Sort the dynamic symbols so that those with GOT entries come after
14432 those without. */
14433 htab = mips_elf_hash_table (info);
14434 BFD_ASSERT (htab != NULL);
14435
14436 if (!mips_elf_sort_hash_table (abfd, info))
14437 return FALSE;
14438
14439 /* Create any scheduled LA25 stubs. */
14440 hti.info = info;
14441 hti.output_bfd = abfd;
14442 hti.error = FALSE;
14443 htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
14444 if (hti.error)
14445 return FALSE;
14446
14447 /* Get a value for the GP register. */
14448 if (elf_gp (abfd) == 0)
14449 {
14450 struct bfd_link_hash_entry *h;
14451
14452 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
14453 if (h != NULL && h->type == bfd_link_hash_defined)
14454 elf_gp (abfd) = (h->u.def.value
14455 + h->u.def.section->output_section->vma
14456 + h->u.def.section->output_offset);
14457 else if (htab->is_vxworks
14458 && (h = bfd_link_hash_lookup (info->hash,
14459 "_GLOBAL_OFFSET_TABLE_",
14460 FALSE, FALSE, TRUE))
14461 && h->type == bfd_link_hash_defined)
14462 elf_gp (abfd) = (h->u.def.section->output_section->vma
14463 + h->u.def.section->output_offset
14464 + h->u.def.value);
14465 else if (bfd_link_relocatable (info))
14466 {
14467 bfd_vma lo = MINUS_ONE;
14468
14469 /* Find the GP-relative section with the lowest offset. */
14470 for (o = abfd->sections; o != NULL; o = o->next)
14471 if (o->vma < lo
14472 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
14473 lo = o->vma;
14474
14475 /* And calculate GP relative to that. */
14476 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
14477 }
14478 else
14479 {
14480 /* If the relocate_section function needs to do a reloc
14481 involving the GP value, it should make a reloc_dangerous
14482 callback to warn that GP is not defined. */
14483 }
14484 }
14485
14486 /* Go through the sections and collect the .reginfo and .mdebug
14487 information. */
14488 abiflags_sec = NULL;
14489 reginfo_sec = NULL;
14490 mdebug_sec = NULL;
14491 gptab_data_sec = NULL;
14492 gptab_bss_sec = NULL;
14493 for (o = abfd->sections; o != NULL; o = o->next)
14494 {
14495 if (strcmp (o->name, ".MIPS.abiflags") == 0)
14496 {
14497 /* We have found the .MIPS.abiflags section in the output file.
14498 Look through all the link_orders comprising it and remove them.
14499 The data is merged in _bfd_mips_elf_merge_private_bfd_data. */
14500 for (p = o->map_head.link_order; p != NULL; p = p->next)
14501 {
14502 asection *input_section;
14503
14504 if (p->type != bfd_indirect_link_order)
14505 {
14506 if (p->type == bfd_data_link_order)
14507 continue;
14508 abort ();
14509 }
14510
14511 input_section = p->u.indirect.section;
14512
14513 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14514 elf_link_input_bfd ignores this section. */
14515 input_section->flags &= ~SEC_HAS_CONTENTS;
14516 }
14517
14518 /* Size has been set in _bfd_mips_elf_always_size_sections. */
14519 BFD_ASSERT(o->size == sizeof (Elf_External_ABIFlags_v0));
14520
14521 /* Skip this section later on (I don't think this currently
14522 matters, but someday it might). */
14523 o->map_head.link_order = NULL;
14524
14525 abiflags_sec = o;
14526 }
14527
14528 if (strcmp (o->name, ".reginfo") == 0)
14529 {
14530 memset (&reginfo, 0, sizeof reginfo);
14531
14532 /* We have found the .reginfo section in the output file.
14533 Look through all the link_orders comprising it and merge
14534 the information together. */
14535 for (p = o->map_head.link_order; p != NULL; p = p->next)
14536 {
14537 asection *input_section;
14538 bfd *input_bfd;
14539 Elf32_External_RegInfo ext;
14540 Elf32_RegInfo sub;
14541
14542 if (p->type != bfd_indirect_link_order)
14543 {
14544 if (p->type == bfd_data_link_order)
14545 continue;
14546 abort ();
14547 }
14548
14549 input_section = p->u.indirect.section;
14550 input_bfd = input_section->owner;
14551
14552 if (! bfd_get_section_contents (input_bfd, input_section,
14553 &ext, 0, sizeof ext))
14554 return FALSE;
14555
14556 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
14557
14558 reginfo.ri_gprmask |= sub.ri_gprmask;
14559 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
14560 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
14561 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
14562 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
14563
14564 /* ri_gp_value is set by the function
14565 mips_elf32_section_processing when the section is
14566 finally written out. */
14567
14568 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14569 elf_link_input_bfd ignores this section. */
14570 input_section->flags &= ~SEC_HAS_CONTENTS;
14571 }
14572
14573 /* Size has been set in _bfd_mips_elf_always_size_sections. */
14574 BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
14575
14576 /* Skip this section later on (I don't think this currently
14577 matters, but someday it might). */
14578 o->map_head.link_order = NULL;
14579
14580 reginfo_sec = o;
14581 }
14582
14583 if (strcmp (o->name, ".mdebug") == 0)
14584 {
14585 struct extsym_info einfo;
14586 bfd_vma last;
14587
14588 /* We have found the .mdebug section in the output file.
14589 Look through all the link_orders comprising it and merge
14590 the information together. */
14591 symhdr->magic = swap->sym_magic;
14592 /* FIXME: What should the version stamp be? */
14593 symhdr->vstamp = 0;
14594 symhdr->ilineMax = 0;
14595 symhdr->cbLine = 0;
14596 symhdr->idnMax = 0;
14597 symhdr->ipdMax = 0;
14598 symhdr->isymMax = 0;
14599 symhdr->ioptMax = 0;
14600 symhdr->iauxMax = 0;
14601 symhdr->issMax = 0;
14602 symhdr->issExtMax = 0;
14603 symhdr->ifdMax = 0;
14604 symhdr->crfd = 0;
14605 symhdr->iextMax = 0;
14606
14607 /* We accumulate the debugging information itself in the
14608 debug_info structure. */
14609 debug.line = NULL;
14610 debug.external_dnr = NULL;
14611 debug.external_pdr = NULL;
14612 debug.external_sym = NULL;
14613 debug.external_opt = NULL;
14614 debug.external_aux = NULL;
14615 debug.ss = NULL;
14616 debug.ssext = debug.ssext_end = NULL;
14617 debug.external_fdr = NULL;
14618 debug.external_rfd = NULL;
14619 debug.external_ext = debug.external_ext_end = NULL;
14620
14621 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
14622 if (mdebug_handle == NULL)
14623 return FALSE;
14624
14625 esym.jmptbl = 0;
14626 esym.cobol_main = 0;
14627 esym.weakext = 0;
14628 esym.reserved = 0;
14629 esym.ifd = ifdNil;
14630 esym.asym.iss = issNil;
14631 esym.asym.st = stLocal;
14632 esym.asym.reserved = 0;
14633 esym.asym.index = indexNil;
14634 last = 0;
14635 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
14636 {
14637 esym.asym.sc = sc[i];
14638 s = bfd_get_section_by_name (abfd, secname[i]);
14639 if (s != NULL)
14640 {
14641 esym.asym.value = s->vma;
14642 last = s->vma + s->size;
14643 }
14644 else
14645 esym.asym.value = last;
14646 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
14647 secname[i], &esym))
14648 return FALSE;
14649 }
14650
14651 for (p = o->map_head.link_order; p != NULL; p = p->next)
14652 {
14653 asection *input_section;
14654 bfd *input_bfd;
14655 const struct ecoff_debug_swap *input_swap;
14656 struct ecoff_debug_info input_debug;
14657 char *eraw_src;
14658 char *eraw_end;
14659
14660 if (p->type != bfd_indirect_link_order)
14661 {
14662 if (p->type == bfd_data_link_order)
14663 continue;
14664 abort ();
14665 }
14666
14667 input_section = p->u.indirect.section;
14668 input_bfd = input_section->owner;
14669
14670 if (!is_mips_elf (input_bfd))
14671 {
14672 /* I don't know what a non MIPS ELF bfd would be
14673 doing with a .mdebug section, but I don't really
14674 want to deal with it. */
14675 continue;
14676 }
14677
14678 input_swap = (get_elf_backend_data (input_bfd)
14679 ->elf_backend_ecoff_debug_swap);
14680
14681 BFD_ASSERT (p->size == input_section->size);
14682
14683 /* The ECOFF linking code expects that we have already
14684 read in the debugging information and set up an
14685 ecoff_debug_info structure, so we do that now. */
14686 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
14687 &input_debug))
14688 return FALSE;
14689
14690 if (! (bfd_ecoff_debug_accumulate
14691 (mdebug_handle, abfd, &debug, swap, input_bfd,
14692 &input_debug, input_swap, info)))
14693 return FALSE;
14694
14695 /* Loop through the external symbols. For each one with
14696 interesting information, try to find the symbol in
14697 the linker global hash table and save the information
14698 for the output external symbols. */
14699 eraw_src = input_debug.external_ext;
14700 eraw_end = (eraw_src
14701 + (input_debug.symbolic_header.iextMax
14702 * input_swap->external_ext_size));
14703 for (;
14704 eraw_src < eraw_end;
14705 eraw_src += input_swap->external_ext_size)
14706 {
14707 EXTR ext;
14708 const char *name;
14709 struct mips_elf_link_hash_entry *h;
14710
14711 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
14712 if (ext.asym.sc == scNil
14713 || ext.asym.sc == scUndefined
14714 || ext.asym.sc == scSUndefined)
14715 continue;
14716
14717 name = input_debug.ssext + ext.asym.iss;
14718 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
14719 name, FALSE, FALSE, TRUE);
14720 if (h == NULL || h->esym.ifd != -2)
14721 continue;
14722
14723 if (ext.ifd != -1)
14724 {
14725 BFD_ASSERT (ext.ifd
14726 < input_debug.symbolic_header.ifdMax);
14727 ext.ifd = input_debug.ifdmap[ext.ifd];
14728 }
14729
14730 h->esym = ext;
14731 }
14732
14733 /* Free up the information we just read. */
14734 free (input_debug.line);
14735 free (input_debug.external_dnr);
14736 free (input_debug.external_pdr);
14737 free (input_debug.external_sym);
14738 free (input_debug.external_opt);
14739 free (input_debug.external_aux);
14740 free (input_debug.ss);
14741 free (input_debug.ssext);
14742 free (input_debug.external_fdr);
14743 free (input_debug.external_rfd);
14744 free (input_debug.external_ext);
14745
14746 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14747 elf_link_input_bfd ignores this section. */
14748 input_section->flags &= ~SEC_HAS_CONTENTS;
14749 }
14750
14751 if (SGI_COMPAT (abfd) && bfd_link_pic (info))
14752 {
14753 /* Create .rtproc section. */
14754 rtproc_sec = bfd_get_linker_section (abfd, ".rtproc");
14755 if (rtproc_sec == NULL)
14756 {
14757 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
14758 | SEC_LINKER_CREATED | SEC_READONLY);
14759
14760 rtproc_sec = bfd_make_section_anyway_with_flags (abfd,
14761 ".rtproc",
14762 flags);
14763 if (rtproc_sec == NULL
14764 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
14765 return FALSE;
14766 }
14767
14768 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
14769 info, rtproc_sec,
14770 &debug))
14771 return FALSE;
14772 }
14773
14774 /* Build the external symbol information. */
14775 einfo.abfd = abfd;
14776 einfo.info = info;
14777 einfo.debug = &debug;
14778 einfo.swap = swap;
14779 einfo.failed = FALSE;
14780 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
14781 mips_elf_output_extsym, &einfo);
14782 if (einfo.failed)
14783 return FALSE;
14784
14785 /* Set the size of the .mdebug section. */
14786 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
14787
14788 /* Skip this section later on (I don't think this currently
14789 matters, but someday it might). */
14790 o->map_head.link_order = NULL;
14791
14792 mdebug_sec = o;
14793 }
14794
14795 if (CONST_STRNEQ (o->name, ".gptab."))
14796 {
14797 const char *subname;
14798 unsigned int c;
14799 Elf32_gptab *tab;
14800 Elf32_External_gptab *ext_tab;
14801 unsigned int j;
14802
14803 /* The .gptab.sdata and .gptab.sbss sections hold
14804 information describing how the small data area would
14805 change depending upon the -G switch. These sections
14806 not used in executables files. */
14807 if (! bfd_link_relocatable (info))
14808 {
14809 for (p = o->map_head.link_order; p != NULL; p = p->next)
14810 {
14811 asection *input_section;
14812
14813 if (p->type != bfd_indirect_link_order)
14814 {
14815 if (p->type == bfd_data_link_order)
14816 continue;
14817 abort ();
14818 }
14819
14820 input_section = p->u.indirect.section;
14821
14822 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14823 elf_link_input_bfd ignores this section. */
14824 input_section->flags &= ~SEC_HAS_CONTENTS;
14825 }
14826
14827 /* Skip this section later on (I don't think this
14828 currently matters, but someday it might). */
14829 o->map_head.link_order = NULL;
14830
14831 /* Really remove the section. */
14832 bfd_section_list_remove (abfd, o);
14833 --abfd->section_count;
14834
14835 continue;
14836 }
14837
14838 /* There is one gptab for initialized data, and one for
14839 uninitialized data. */
14840 if (strcmp (o->name, ".gptab.sdata") == 0)
14841 gptab_data_sec = o;
14842 else if (strcmp (o->name, ".gptab.sbss") == 0)
14843 gptab_bss_sec = o;
14844 else
14845 {
14846 _bfd_error_handler
14847 /* xgettext:c-format */
14848 (_("%s: illegal section name `%s'"),
14849 bfd_get_filename (abfd), o->name);
14850 bfd_set_error (bfd_error_nonrepresentable_section);
14851 return FALSE;
14852 }
14853
14854 /* The linker script always combines .gptab.data and
14855 .gptab.sdata into .gptab.sdata, and likewise for
14856 .gptab.bss and .gptab.sbss. It is possible that there is
14857 no .sdata or .sbss section in the output file, in which
14858 case we must change the name of the output section. */
14859 subname = o->name + sizeof ".gptab" - 1;
14860 if (bfd_get_section_by_name (abfd, subname) == NULL)
14861 {
14862 if (o == gptab_data_sec)
14863 o->name = ".gptab.data";
14864 else
14865 o->name = ".gptab.bss";
14866 subname = o->name + sizeof ".gptab" - 1;
14867 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
14868 }
14869
14870 /* Set up the first entry. */
14871 c = 1;
14872 amt = c * sizeof (Elf32_gptab);
14873 tab = bfd_malloc (amt);
14874 if (tab == NULL)
14875 return FALSE;
14876 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
14877 tab[0].gt_header.gt_unused = 0;
14878
14879 /* Combine the input sections. */
14880 for (p = o->map_head.link_order; p != NULL; p = p->next)
14881 {
14882 asection *input_section;
14883 bfd *input_bfd;
14884 bfd_size_type size;
14885 unsigned long last;
14886 bfd_size_type gpentry;
14887
14888 if (p->type != bfd_indirect_link_order)
14889 {
14890 if (p->type == bfd_data_link_order)
14891 continue;
14892 abort ();
14893 }
14894
14895 input_section = p->u.indirect.section;
14896 input_bfd = input_section->owner;
14897
14898 /* Combine the gptab entries for this input section one
14899 by one. We know that the input gptab entries are
14900 sorted by ascending -G value. */
14901 size = input_section->size;
14902 last = 0;
14903 for (gpentry = sizeof (Elf32_External_gptab);
14904 gpentry < size;
14905 gpentry += sizeof (Elf32_External_gptab))
14906 {
14907 Elf32_External_gptab ext_gptab;
14908 Elf32_gptab int_gptab;
14909 unsigned long val;
14910 unsigned long add;
14911 bfd_boolean exact;
14912 unsigned int look;
14913
14914 if (! (bfd_get_section_contents
14915 (input_bfd, input_section, &ext_gptab, gpentry,
14916 sizeof (Elf32_External_gptab))))
14917 {
14918 free (tab);
14919 return FALSE;
14920 }
14921
14922 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
14923 &int_gptab);
14924 val = int_gptab.gt_entry.gt_g_value;
14925 add = int_gptab.gt_entry.gt_bytes - last;
14926
14927 exact = FALSE;
14928 for (look = 1; look < c; look++)
14929 {
14930 if (tab[look].gt_entry.gt_g_value >= val)
14931 tab[look].gt_entry.gt_bytes += add;
14932
14933 if (tab[look].gt_entry.gt_g_value == val)
14934 exact = TRUE;
14935 }
14936
14937 if (! exact)
14938 {
14939 Elf32_gptab *new_tab;
14940 unsigned int max;
14941
14942 /* We need a new table entry. */
14943 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
14944 new_tab = bfd_realloc (tab, amt);
14945 if (new_tab == NULL)
14946 {
14947 free (tab);
14948 return FALSE;
14949 }
14950 tab = new_tab;
14951 tab[c].gt_entry.gt_g_value = val;
14952 tab[c].gt_entry.gt_bytes = add;
14953
14954 /* Merge in the size for the next smallest -G
14955 value, since that will be implied by this new
14956 value. */
14957 max = 0;
14958 for (look = 1; look < c; look++)
14959 {
14960 if (tab[look].gt_entry.gt_g_value < val
14961 && (max == 0
14962 || (tab[look].gt_entry.gt_g_value
14963 > tab[max].gt_entry.gt_g_value)))
14964 max = look;
14965 }
14966 if (max != 0)
14967 tab[c].gt_entry.gt_bytes +=
14968 tab[max].gt_entry.gt_bytes;
14969
14970 ++c;
14971 }
14972
14973 last = int_gptab.gt_entry.gt_bytes;
14974 }
14975
14976 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14977 elf_link_input_bfd ignores this section. */
14978 input_section->flags &= ~SEC_HAS_CONTENTS;
14979 }
14980
14981 /* The table must be sorted by -G value. */
14982 if (c > 2)
14983 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
14984
14985 /* Swap out the table. */
14986 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
14987 ext_tab = bfd_alloc (abfd, amt);
14988 if (ext_tab == NULL)
14989 {
14990 free (tab);
14991 return FALSE;
14992 }
14993
14994 for (j = 0; j < c; j++)
14995 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
14996 free (tab);
14997
14998 o->size = c * sizeof (Elf32_External_gptab);
14999 o->contents = (bfd_byte *) ext_tab;
15000
15001 /* Skip this section later on (I don't think this currently
15002 matters, but someday it might). */
15003 o->map_head.link_order = NULL;
15004 }
15005 }
15006
15007 /* Invoke the regular ELF backend linker to do all the work. */
15008 if (!bfd_elf_final_link (abfd, info))
15009 return FALSE;
15010
15011 /* Now write out the computed sections. */
15012
15013 if (abiflags_sec != NULL)
15014 {
15015 Elf_External_ABIFlags_v0 ext;
15016 Elf_Internal_ABIFlags_v0 *abiflags;
15017
15018 abiflags = &mips_elf_tdata (abfd)->abiflags;
15019
15020 /* Set up the abiflags if no valid input sections were found. */
15021 if (!mips_elf_tdata (abfd)->abiflags_valid)
15022 {
15023 infer_mips_abiflags (abfd, abiflags);
15024 mips_elf_tdata (abfd)->abiflags_valid = TRUE;
15025 }
15026 bfd_mips_elf_swap_abiflags_v0_out (abfd, abiflags, &ext);
15027 if (! bfd_set_section_contents (abfd, abiflags_sec, &ext, 0, sizeof ext))
15028 return FALSE;
15029 }
15030
15031 if (reginfo_sec != NULL)
15032 {
15033 Elf32_External_RegInfo ext;
15034
15035 bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
15036 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
15037 return FALSE;
15038 }
15039
15040 if (mdebug_sec != NULL)
15041 {
15042 BFD_ASSERT (abfd->output_has_begun);
15043 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
15044 swap, info,
15045 mdebug_sec->filepos))
15046 return FALSE;
15047
15048 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
15049 }
15050
15051 if (gptab_data_sec != NULL)
15052 {
15053 if (! bfd_set_section_contents (abfd, gptab_data_sec,
15054 gptab_data_sec->contents,
15055 0, gptab_data_sec->size))
15056 return FALSE;
15057 }
15058
15059 if (gptab_bss_sec != NULL)
15060 {
15061 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
15062 gptab_bss_sec->contents,
15063 0, gptab_bss_sec->size))
15064 return FALSE;
15065 }
15066
15067 if (SGI_COMPAT (abfd))
15068 {
15069 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
15070 if (rtproc_sec != NULL)
15071 {
15072 if (! bfd_set_section_contents (abfd, rtproc_sec,
15073 rtproc_sec->contents,
15074 0, rtproc_sec->size))
15075 return FALSE;
15076 }
15077 }
15078
15079 return TRUE;
15080 }
15081 \f
15082 /* Merge object file header flags from IBFD into OBFD. Raise an error
15083 if there are conflicting settings. */
15084
15085 static bfd_boolean
15086 mips_elf_merge_obj_e_flags (bfd *ibfd, struct bfd_link_info *info)
15087 {
15088 bfd *obfd = info->output_bfd;
15089 struct mips_elf_obj_tdata *out_tdata = mips_elf_tdata (obfd);
15090 flagword old_flags;
15091 flagword new_flags;
15092 bfd_boolean ok;
15093
15094 new_flags = elf_elfheader (ibfd)->e_flags;
15095 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
15096 old_flags = elf_elfheader (obfd)->e_flags;
15097
15098 /* Check flag compatibility. */
15099
15100 new_flags &= ~EF_MIPS_NOREORDER;
15101 old_flags &= ~EF_MIPS_NOREORDER;
15102
15103 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
15104 doesn't seem to matter. */
15105 new_flags &= ~EF_MIPS_XGOT;
15106 old_flags &= ~EF_MIPS_XGOT;
15107
15108 /* MIPSpro generates ucode info in n64 objects. Again, we should
15109 just be able to ignore this. */
15110 new_flags &= ~EF_MIPS_UCODE;
15111 old_flags &= ~EF_MIPS_UCODE;
15112
15113 /* DSOs should only be linked with CPIC code. */
15114 if ((ibfd->flags & DYNAMIC) != 0)
15115 new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
15116
15117 if (new_flags == old_flags)
15118 return TRUE;
15119
15120 ok = TRUE;
15121
15122 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
15123 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
15124 {
15125 _bfd_error_handler
15126 (_("%B: warning: linking abicalls files with non-abicalls files"),
15127 ibfd);
15128 ok = TRUE;
15129 }
15130
15131 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
15132 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
15133 if (! (new_flags & EF_MIPS_PIC))
15134 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
15135
15136 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
15137 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
15138
15139 /* Compare the ISAs. */
15140 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
15141 {
15142 _bfd_error_handler
15143 (_("%B: linking 32-bit code with 64-bit code"),
15144 ibfd);
15145 ok = FALSE;
15146 }
15147 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
15148 {
15149 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
15150 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
15151 {
15152 /* Copy the architecture info from IBFD to OBFD. Also copy
15153 the 32-bit flag (if set) so that we continue to recognise
15154 OBFD as a 32-bit binary. */
15155 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
15156 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
15157 elf_elfheader (obfd)->e_flags
15158 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15159
15160 /* Update the ABI flags isa_level, isa_rev, isa_ext fields. */
15161 update_mips_abiflags_isa (obfd, &out_tdata->abiflags);
15162
15163 /* Copy across the ABI flags if OBFD doesn't use them
15164 and if that was what caused us to treat IBFD as 32-bit. */
15165 if ((old_flags & EF_MIPS_ABI) == 0
15166 && mips_32bit_flags_p (new_flags)
15167 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
15168 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
15169 }
15170 else
15171 {
15172 /* The ISAs aren't compatible. */
15173 _bfd_error_handler
15174 /* xgettext:c-format */
15175 (_("%B: linking %s module with previous %s modules"),
15176 ibfd,
15177 bfd_printable_name (ibfd),
15178 bfd_printable_name (obfd));
15179 ok = FALSE;
15180 }
15181 }
15182
15183 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15184 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
15185
15186 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
15187 does set EI_CLASS differently from any 32-bit ABI. */
15188 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
15189 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
15190 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
15191 {
15192 /* Only error if both are set (to different values). */
15193 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
15194 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
15195 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
15196 {
15197 _bfd_error_handler
15198 /* xgettext:c-format */
15199 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
15200 ibfd,
15201 elf_mips_abi_name (ibfd),
15202 elf_mips_abi_name (obfd));
15203 ok = FALSE;
15204 }
15205 new_flags &= ~EF_MIPS_ABI;
15206 old_flags &= ~EF_MIPS_ABI;
15207 }
15208
15209 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
15210 and allow arbitrary mixing of the remaining ASEs (retain the union). */
15211 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
15212 {
15213 int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
15214 int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
15215 int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16;
15216 int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16;
15217 int micro_mis = old_m16 && new_micro;
15218 int m16_mis = old_micro && new_m16;
15219
15220 if (m16_mis || micro_mis)
15221 {
15222 _bfd_error_handler
15223 /* xgettext:c-format */
15224 (_("%B: ASE mismatch: linking %s module with previous %s modules"),
15225 ibfd,
15226 m16_mis ? "MIPS16" : "microMIPS",
15227 m16_mis ? "microMIPS" : "MIPS16");
15228 ok = FALSE;
15229 }
15230
15231 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
15232
15233 new_flags &= ~ EF_MIPS_ARCH_ASE;
15234 old_flags &= ~ EF_MIPS_ARCH_ASE;
15235 }
15236
15237 /* Compare NaN encodings. */
15238 if ((new_flags & EF_MIPS_NAN2008) != (old_flags & EF_MIPS_NAN2008))
15239 {
15240 /* xgettext:c-format */
15241 _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
15242 ibfd,
15243 (new_flags & EF_MIPS_NAN2008
15244 ? "-mnan=2008" : "-mnan=legacy"),
15245 (old_flags & EF_MIPS_NAN2008
15246 ? "-mnan=2008" : "-mnan=legacy"));
15247 ok = FALSE;
15248 new_flags &= ~EF_MIPS_NAN2008;
15249 old_flags &= ~EF_MIPS_NAN2008;
15250 }
15251
15252 /* Compare FP64 state. */
15253 if ((new_flags & EF_MIPS_FP64) != (old_flags & EF_MIPS_FP64))
15254 {
15255 /* xgettext:c-format */
15256 _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
15257 ibfd,
15258 (new_flags & EF_MIPS_FP64
15259 ? "-mfp64" : "-mfp32"),
15260 (old_flags & EF_MIPS_FP64
15261 ? "-mfp64" : "-mfp32"));
15262 ok = FALSE;
15263 new_flags &= ~EF_MIPS_FP64;
15264 old_flags &= ~EF_MIPS_FP64;
15265 }
15266
15267 /* Warn about any other mismatches */
15268 if (new_flags != old_flags)
15269 {
15270 /* xgettext:c-format */
15271 _bfd_error_handler
15272 (_("%B: uses different e_flags (0x%lx) fields than previous modules "
15273 "(0x%lx)"),
15274 ibfd, (unsigned long) new_flags,
15275 (unsigned long) old_flags);
15276 ok = FALSE;
15277 }
15278
15279 return ok;
15280 }
15281
15282 /* Merge object attributes from IBFD into OBFD. Raise an error if
15283 there are conflicting attributes. */
15284 static bfd_boolean
15285 mips_elf_merge_obj_attributes (bfd *ibfd, struct bfd_link_info *info)
15286 {
15287 bfd *obfd = info->output_bfd;
15288 obj_attribute *in_attr;
15289 obj_attribute *out_attr;
15290 bfd *abi_fp_bfd;
15291 bfd *abi_msa_bfd;
15292
15293 abi_fp_bfd = mips_elf_tdata (obfd)->abi_fp_bfd;
15294 in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
15295 if (!abi_fp_bfd && in_attr[Tag_GNU_MIPS_ABI_FP].i != Val_GNU_MIPS_ABI_FP_ANY)
15296 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
15297
15298 abi_msa_bfd = mips_elf_tdata (obfd)->abi_msa_bfd;
15299 if (!abi_msa_bfd
15300 && in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
15301 mips_elf_tdata (obfd)->abi_msa_bfd = ibfd;
15302
15303 if (!elf_known_obj_attributes_proc (obfd)[0].i)
15304 {
15305 /* This is the first object. Copy the attributes. */
15306 _bfd_elf_copy_obj_attributes (ibfd, obfd);
15307
15308 /* Use the Tag_null value to indicate the attributes have been
15309 initialized. */
15310 elf_known_obj_attributes_proc (obfd)[0].i = 1;
15311
15312 return TRUE;
15313 }
15314
15315 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
15316 non-conflicting ones. */
15317 out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
15318 if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
15319 {
15320 int out_fp, in_fp;
15321
15322 out_fp = out_attr[Tag_GNU_MIPS_ABI_FP].i;
15323 in_fp = in_attr[Tag_GNU_MIPS_ABI_FP].i;
15324 out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
15325 if (out_fp == Val_GNU_MIPS_ABI_FP_ANY)
15326 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_fp;
15327 else if (out_fp == Val_GNU_MIPS_ABI_FP_XX
15328 && (in_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
15329 || in_fp == Val_GNU_MIPS_ABI_FP_64
15330 || in_fp == Val_GNU_MIPS_ABI_FP_64A))
15331 {
15332 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
15333 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
15334 }
15335 else if (in_fp == Val_GNU_MIPS_ABI_FP_XX
15336 && (out_fp == Val_GNU_MIPS_ABI_FP_DOUBLE
15337 || out_fp == Val_GNU_MIPS_ABI_FP_64
15338 || out_fp == Val_GNU_MIPS_ABI_FP_64A))
15339 /* Keep the current setting. */;
15340 else if (out_fp == Val_GNU_MIPS_ABI_FP_64A
15341 && in_fp == Val_GNU_MIPS_ABI_FP_64)
15342 {
15343 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
15344 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
15345 }
15346 else if (in_fp == Val_GNU_MIPS_ABI_FP_64A
15347 && out_fp == Val_GNU_MIPS_ABI_FP_64)
15348 /* Keep the current setting. */;
15349 else if (in_fp != Val_GNU_MIPS_ABI_FP_ANY)
15350 {
15351 const char *out_string, *in_string;
15352
15353 out_string = _bfd_mips_fp_abi_string (out_fp);
15354 in_string = _bfd_mips_fp_abi_string (in_fp);
15355 /* First warn about cases involving unrecognised ABIs. */
15356 if (!out_string && !in_string)
15357 /* xgettext:c-format */
15358 _bfd_error_handler
15359 (_("Warning: %B uses unknown floating point ABI %d "
15360 "(set by %B), %B uses unknown floating point ABI %d"),
15361 obfd, abi_fp_bfd, ibfd, out_fp, in_fp);
15362 else if (!out_string)
15363 _bfd_error_handler
15364 /* xgettext:c-format */
15365 (_("Warning: %B uses unknown floating point ABI %d "
15366 "(set by %B), %B uses %s"),
15367 obfd, abi_fp_bfd, ibfd, out_fp, in_string);
15368 else if (!in_string)
15369 _bfd_error_handler
15370 /* xgettext:c-format */
15371 (_("Warning: %B uses %s (set by %B), "
15372 "%B uses unknown floating point ABI %d"),
15373 obfd, abi_fp_bfd, ibfd, out_string, in_fp);
15374 else
15375 {
15376 /* If one of the bfds is soft-float, the other must be
15377 hard-float. The exact choice of hard-float ABI isn't
15378 really relevant to the error message. */
15379 if (in_fp == Val_GNU_MIPS_ABI_FP_SOFT)
15380 out_string = "-mhard-float";
15381 else if (out_fp == Val_GNU_MIPS_ABI_FP_SOFT)
15382 in_string = "-mhard-float";
15383 _bfd_error_handler
15384 /* xgettext:c-format */
15385 (_("Warning: %B uses %s (set by %B), %B uses %s"),
15386 obfd, abi_fp_bfd, ibfd, out_string, in_string);
15387 }
15388 }
15389 }
15390
15391 /* Check for conflicting Tag_GNU_MIPS_ABI_MSA attributes and merge
15392 non-conflicting ones. */
15393 if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != out_attr[Tag_GNU_MIPS_ABI_MSA].i)
15394 {
15395 out_attr[Tag_GNU_MIPS_ABI_MSA].type = 1;
15396 if (out_attr[Tag_GNU_MIPS_ABI_MSA].i == Val_GNU_MIPS_ABI_MSA_ANY)
15397 out_attr[Tag_GNU_MIPS_ABI_MSA].i = in_attr[Tag_GNU_MIPS_ABI_MSA].i;
15398 else if (in_attr[Tag_GNU_MIPS_ABI_MSA].i != Val_GNU_MIPS_ABI_MSA_ANY)
15399 switch (out_attr[Tag_GNU_MIPS_ABI_MSA].i)
15400 {
15401 case Val_GNU_MIPS_ABI_MSA_128:
15402 _bfd_error_handler
15403 /* xgettext:c-format */
15404 (_("Warning: %B uses %s (set by %B), "
15405 "%B uses unknown MSA ABI %d"),
15406 obfd, abi_msa_bfd, ibfd,
15407 "-mmsa", in_attr[Tag_GNU_MIPS_ABI_MSA].i);
15408 break;
15409
15410 default:
15411 switch (in_attr[Tag_GNU_MIPS_ABI_MSA].i)
15412 {
15413 case Val_GNU_MIPS_ABI_MSA_128:
15414 _bfd_error_handler
15415 /* xgettext:c-format */
15416 (_("Warning: %B uses unknown MSA ABI %d "
15417 "(set by %B), %B uses %s"),
15418 obfd, abi_msa_bfd, ibfd,
15419 out_attr[Tag_GNU_MIPS_ABI_MSA].i, "-mmsa");
15420 break;
15421
15422 default:
15423 _bfd_error_handler
15424 /* xgettext:c-format */
15425 (_("Warning: %B uses unknown MSA ABI %d "
15426 "(set by %B), %B uses unknown MSA ABI %d"),
15427 obfd, abi_msa_bfd, ibfd,
15428 out_attr[Tag_GNU_MIPS_ABI_MSA].i,
15429 in_attr[Tag_GNU_MIPS_ABI_MSA].i);
15430 break;
15431 }
15432 }
15433 }
15434
15435 /* Merge Tag_compatibility attributes and any common GNU ones. */
15436 return _bfd_elf_merge_object_attributes (ibfd, info);
15437 }
15438
15439 /* Merge object ABI flags from IBFD into OBFD. Raise an error if
15440 there are conflicting settings. */
15441
15442 static bfd_boolean
15443 mips_elf_merge_obj_abiflags (bfd *ibfd, bfd *obfd)
15444 {
15445 obj_attribute *out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
15446 struct mips_elf_obj_tdata *out_tdata = mips_elf_tdata (obfd);
15447 struct mips_elf_obj_tdata *in_tdata = mips_elf_tdata (ibfd);
15448
15449 /* Update the output abiflags fp_abi using the computed fp_abi. */
15450 out_tdata->abiflags.fp_abi = out_attr[Tag_GNU_MIPS_ABI_FP].i;
15451
15452 #define max(a, b) ((a) > (b) ? (a) : (b))
15453 /* Merge abiflags. */
15454 out_tdata->abiflags.isa_level = max (out_tdata->abiflags.isa_level,
15455 in_tdata->abiflags.isa_level);
15456 out_tdata->abiflags.isa_rev = max (out_tdata->abiflags.isa_rev,
15457 in_tdata->abiflags.isa_rev);
15458 out_tdata->abiflags.gpr_size = max (out_tdata->abiflags.gpr_size,
15459 in_tdata->abiflags.gpr_size);
15460 out_tdata->abiflags.cpr1_size = max (out_tdata->abiflags.cpr1_size,
15461 in_tdata->abiflags.cpr1_size);
15462 out_tdata->abiflags.cpr2_size = max (out_tdata->abiflags.cpr2_size,
15463 in_tdata->abiflags.cpr2_size);
15464 #undef max
15465 out_tdata->abiflags.ases |= in_tdata->abiflags.ases;
15466 out_tdata->abiflags.flags1 |= in_tdata->abiflags.flags1;
15467
15468 return TRUE;
15469 }
15470
15471 /* Merge backend specific data from an object file to the output
15472 object file when linking. */
15473
15474 bfd_boolean
15475 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
15476 {
15477 bfd *obfd = info->output_bfd;
15478 struct mips_elf_obj_tdata *out_tdata;
15479 struct mips_elf_obj_tdata *in_tdata;
15480 bfd_boolean null_input_bfd = TRUE;
15481 asection *sec;
15482 bfd_boolean ok;
15483
15484 /* Check if we have the same endianness. */
15485 if (! _bfd_generic_verify_endian_match (ibfd, info))
15486 {
15487 _bfd_error_handler
15488 (_("%B: endianness incompatible with that of the selected emulation"),
15489 ibfd);
15490 return FALSE;
15491 }
15492
15493 if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
15494 return TRUE;
15495
15496 in_tdata = mips_elf_tdata (ibfd);
15497 out_tdata = mips_elf_tdata (obfd);
15498
15499 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
15500 {
15501 _bfd_error_handler
15502 (_("%B: ABI is incompatible with that of the selected emulation"),
15503 ibfd);
15504 return FALSE;
15505 }
15506
15507 /* Check to see if the input BFD actually contains any sections. If not,
15508 then it has no attributes, and its flags may not have been initialized
15509 either, but it cannot actually cause any incompatibility. */
15510 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
15511 {
15512 /* Ignore synthetic sections and empty .text, .data and .bss sections
15513 which are automatically generated by gas. Also ignore fake
15514 (s)common sections, since merely defining a common symbol does
15515 not affect compatibility. */
15516 if ((sec->flags & SEC_IS_COMMON) == 0
15517 && strcmp (sec->name, ".reginfo")
15518 && strcmp (sec->name, ".mdebug")
15519 && (sec->size != 0
15520 || (strcmp (sec->name, ".text")
15521 && strcmp (sec->name, ".data")
15522 && strcmp (sec->name, ".bss"))))
15523 {
15524 null_input_bfd = FALSE;
15525 break;
15526 }
15527 }
15528 if (null_input_bfd)
15529 return TRUE;
15530
15531 /* Populate abiflags using existing information. */
15532 if (in_tdata->abiflags_valid)
15533 {
15534 obj_attribute *in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
15535 Elf_Internal_ABIFlags_v0 in_abiflags;
15536 Elf_Internal_ABIFlags_v0 abiflags;
15537
15538 /* Set up the FP ABI attribute from the abiflags if it is not already
15539 set. */
15540 if (in_attr[Tag_GNU_MIPS_ABI_FP].i == Val_GNU_MIPS_ABI_FP_ANY)
15541 in_attr[Tag_GNU_MIPS_ABI_FP].i = in_tdata->abiflags.fp_abi;
15542
15543 infer_mips_abiflags (ibfd, &abiflags);
15544 in_abiflags = in_tdata->abiflags;
15545
15546 /* It is not possible to infer the correct ISA revision
15547 for R3 or R5 so drop down to R2 for the checks. */
15548 if (in_abiflags.isa_rev == 3 || in_abiflags.isa_rev == 5)
15549 in_abiflags.isa_rev = 2;
15550
15551 if (LEVEL_REV (in_abiflags.isa_level, in_abiflags.isa_rev)
15552 < LEVEL_REV (abiflags.isa_level, abiflags.isa_rev))
15553 _bfd_error_handler
15554 (_("%B: warning: Inconsistent ISA between e_flags and "
15555 ".MIPS.abiflags"), ibfd);
15556 if (abiflags.fp_abi != Val_GNU_MIPS_ABI_FP_ANY
15557 && in_abiflags.fp_abi != abiflags.fp_abi)
15558 _bfd_error_handler
15559 (_("%B: warning: Inconsistent FP ABI between .gnu.attributes and "
15560 ".MIPS.abiflags"), ibfd);
15561 if ((in_abiflags.ases & abiflags.ases) != abiflags.ases)
15562 _bfd_error_handler
15563 (_("%B: warning: Inconsistent ASEs between e_flags and "
15564 ".MIPS.abiflags"), ibfd);
15565 /* The isa_ext is allowed to be an extension of what can be inferred
15566 from e_flags. */
15567 if (!mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags.isa_ext),
15568 bfd_mips_isa_ext_mach (in_abiflags.isa_ext)))
15569 _bfd_error_handler
15570 (_("%B: warning: Inconsistent ISA extensions between e_flags and "
15571 ".MIPS.abiflags"), ibfd);
15572 if (in_abiflags.flags2 != 0)
15573 _bfd_error_handler
15574 (_("%B: warning: Unexpected flag in the flags2 field of "
15575 ".MIPS.abiflags (0x%lx)"), ibfd,
15576 (unsigned long) in_abiflags.flags2);
15577 }
15578 else
15579 {
15580 infer_mips_abiflags (ibfd, &in_tdata->abiflags);
15581 in_tdata->abiflags_valid = TRUE;
15582 }
15583
15584 if (!out_tdata->abiflags_valid)
15585 {
15586 /* Copy input abiflags if output abiflags are not already valid. */
15587 out_tdata->abiflags = in_tdata->abiflags;
15588 out_tdata->abiflags_valid = TRUE;
15589 }
15590
15591 if (! elf_flags_init (obfd))
15592 {
15593 elf_flags_init (obfd) = TRUE;
15594 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
15595 elf_elfheader (obfd)->e_ident[EI_CLASS]
15596 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
15597
15598 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
15599 && (bfd_get_arch_info (obfd)->the_default
15600 || mips_mach_extends_p (bfd_get_mach (obfd),
15601 bfd_get_mach (ibfd))))
15602 {
15603 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
15604 bfd_get_mach (ibfd)))
15605 return FALSE;
15606
15607 /* Update the ABI flags isa_level, isa_rev and isa_ext fields. */
15608 update_mips_abiflags_isa (obfd, &out_tdata->abiflags);
15609 }
15610
15611 ok = TRUE;
15612 }
15613 else
15614 ok = mips_elf_merge_obj_e_flags (ibfd, info);
15615
15616 ok = mips_elf_merge_obj_attributes (ibfd, info) && ok;
15617
15618 ok = mips_elf_merge_obj_abiflags (ibfd, obfd) && ok;
15619
15620 if (!ok)
15621 {
15622 bfd_set_error (bfd_error_bad_value);
15623 return FALSE;
15624 }
15625
15626 return TRUE;
15627 }
15628
15629 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
15630
15631 bfd_boolean
15632 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
15633 {
15634 BFD_ASSERT (!elf_flags_init (abfd)
15635 || elf_elfheader (abfd)->e_flags == flags);
15636
15637 elf_elfheader (abfd)->e_flags = flags;
15638 elf_flags_init (abfd) = TRUE;
15639 return TRUE;
15640 }
15641
15642 char *
15643 _bfd_mips_elf_get_target_dtag (bfd_vma dtag)
15644 {
15645 switch (dtag)
15646 {
15647 default: return "";
15648 case DT_MIPS_RLD_VERSION:
15649 return "MIPS_RLD_VERSION";
15650 case DT_MIPS_TIME_STAMP:
15651 return "MIPS_TIME_STAMP";
15652 case DT_MIPS_ICHECKSUM:
15653 return "MIPS_ICHECKSUM";
15654 case DT_MIPS_IVERSION:
15655 return "MIPS_IVERSION";
15656 case DT_MIPS_FLAGS:
15657 return "MIPS_FLAGS";
15658 case DT_MIPS_BASE_ADDRESS:
15659 return "MIPS_BASE_ADDRESS";
15660 case DT_MIPS_MSYM:
15661 return "MIPS_MSYM";
15662 case DT_MIPS_CONFLICT:
15663 return "MIPS_CONFLICT";
15664 case DT_MIPS_LIBLIST:
15665 return "MIPS_LIBLIST";
15666 case DT_MIPS_LOCAL_GOTNO:
15667 return "MIPS_LOCAL_GOTNO";
15668 case DT_MIPS_CONFLICTNO:
15669 return "MIPS_CONFLICTNO";
15670 case DT_MIPS_LIBLISTNO:
15671 return "MIPS_LIBLISTNO";
15672 case DT_MIPS_SYMTABNO:
15673 return "MIPS_SYMTABNO";
15674 case DT_MIPS_UNREFEXTNO:
15675 return "MIPS_UNREFEXTNO";
15676 case DT_MIPS_GOTSYM:
15677 return "MIPS_GOTSYM";
15678 case DT_MIPS_HIPAGENO:
15679 return "MIPS_HIPAGENO";
15680 case DT_MIPS_RLD_MAP:
15681 return "MIPS_RLD_MAP";
15682 case DT_MIPS_RLD_MAP_REL:
15683 return "MIPS_RLD_MAP_REL";
15684 case DT_MIPS_DELTA_CLASS:
15685 return "MIPS_DELTA_CLASS";
15686 case DT_MIPS_DELTA_CLASS_NO:
15687 return "MIPS_DELTA_CLASS_NO";
15688 case DT_MIPS_DELTA_INSTANCE:
15689 return "MIPS_DELTA_INSTANCE";
15690 case DT_MIPS_DELTA_INSTANCE_NO:
15691 return "MIPS_DELTA_INSTANCE_NO";
15692 case DT_MIPS_DELTA_RELOC:
15693 return "MIPS_DELTA_RELOC";
15694 case DT_MIPS_DELTA_RELOC_NO:
15695 return "MIPS_DELTA_RELOC_NO";
15696 case DT_MIPS_DELTA_SYM:
15697 return "MIPS_DELTA_SYM";
15698 case DT_MIPS_DELTA_SYM_NO:
15699 return "MIPS_DELTA_SYM_NO";
15700 case DT_MIPS_DELTA_CLASSSYM:
15701 return "MIPS_DELTA_CLASSSYM";
15702 case DT_MIPS_DELTA_CLASSSYM_NO:
15703 return "MIPS_DELTA_CLASSSYM_NO";
15704 case DT_MIPS_CXX_FLAGS:
15705 return "MIPS_CXX_FLAGS";
15706 case DT_MIPS_PIXIE_INIT:
15707 return "MIPS_PIXIE_INIT";
15708 case DT_MIPS_SYMBOL_LIB:
15709 return "MIPS_SYMBOL_LIB";
15710 case DT_MIPS_LOCALPAGE_GOTIDX:
15711 return "MIPS_LOCALPAGE_GOTIDX";
15712 case DT_MIPS_LOCAL_GOTIDX:
15713 return "MIPS_LOCAL_GOTIDX";
15714 case DT_MIPS_HIDDEN_GOTIDX:
15715 return "MIPS_HIDDEN_GOTIDX";
15716 case DT_MIPS_PROTECTED_GOTIDX:
15717 return "MIPS_PROTECTED_GOT_IDX";
15718 case DT_MIPS_OPTIONS:
15719 return "MIPS_OPTIONS";
15720 case DT_MIPS_INTERFACE:
15721 return "MIPS_INTERFACE";
15722 case DT_MIPS_DYNSTR_ALIGN:
15723 return "DT_MIPS_DYNSTR_ALIGN";
15724 case DT_MIPS_INTERFACE_SIZE:
15725 return "DT_MIPS_INTERFACE_SIZE";
15726 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
15727 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
15728 case DT_MIPS_PERF_SUFFIX:
15729 return "DT_MIPS_PERF_SUFFIX";
15730 case DT_MIPS_COMPACT_SIZE:
15731 return "DT_MIPS_COMPACT_SIZE";
15732 case DT_MIPS_GP_VALUE:
15733 return "DT_MIPS_GP_VALUE";
15734 case DT_MIPS_AUX_DYNAMIC:
15735 return "DT_MIPS_AUX_DYNAMIC";
15736 case DT_MIPS_PLTGOT:
15737 return "DT_MIPS_PLTGOT";
15738 case DT_MIPS_RWPLT:
15739 return "DT_MIPS_RWPLT";
15740 }
15741 }
15742
15743 /* Return the meaning of Tag_GNU_MIPS_ABI_FP value FP, or null if
15744 not known. */
15745
15746 const char *
15747 _bfd_mips_fp_abi_string (int fp)
15748 {
15749 switch (fp)
15750 {
15751 /* These strings aren't translated because they're simply
15752 option lists. */
15753 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15754 return "-mdouble-float";
15755
15756 case Val_GNU_MIPS_ABI_FP_SINGLE:
15757 return "-msingle-float";
15758
15759 case Val_GNU_MIPS_ABI_FP_SOFT:
15760 return "-msoft-float";
15761
15762 case Val_GNU_MIPS_ABI_FP_OLD_64:
15763 return _("-mips32r2 -mfp64 (12 callee-saved)");
15764
15765 case Val_GNU_MIPS_ABI_FP_XX:
15766 return "-mfpxx";
15767
15768 case Val_GNU_MIPS_ABI_FP_64:
15769 return "-mgp32 -mfp64";
15770
15771 case Val_GNU_MIPS_ABI_FP_64A:
15772 return "-mgp32 -mfp64 -mno-odd-spreg";
15773
15774 default:
15775 return 0;
15776 }
15777 }
15778
15779 static void
15780 print_mips_ases (FILE *file, unsigned int mask)
15781 {
15782 if (mask & AFL_ASE_DSP)
15783 fputs ("\n\tDSP ASE", file);
15784 if (mask & AFL_ASE_DSPR2)
15785 fputs ("\n\tDSP R2 ASE", file);
15786 if (mask & AFL_ASE_DSPR3)
15787 fputs ("\n\tDSP R3 ASE", file);
15788 if (mask & AFL_ASE_EVA)
15789 fputs ("\n\tEnhanced VA Scheme", file);
15790 if (mask & AFL_ASE_MCU)
15791 fputs ("\n\tMCU (MicroController) ASE", file);
15792 if (mask & AFL_ASE_MDMX)
15793 fputs ("\n\tMDMX ASE", file);
15794 if (mask & AFL_ASE_MIPS3D)
15795 fputs ("\n\tMIPS-3D ASE", file);
15796 if (mask & AFL_ASE_MT)
15797 fputs ("\n\tMT ASE", file);
15798 if (mask & AFL_ASE_SMARTMIPS)
15799 fputs ("\n\tSmartMIPS ASE", file);
15800 if (mask & AFL_ASE_VIRT)
15801 fputs ("\n\tVZ ASE", file);
15802 if (mask & AFL_ASE_MSA)
15803 fputs ("\n\tMSA ASE", file);
15804 if (mask & AFL_ASE_MIPS16)
15805 fputs ("\n\tMIPS16 ASE", file);
15806 if (mask & AFL_ASE_MICROMIPS)
15807 fputs ("\n\tMICROMIPS ASE", file);
15808 if (mask & AFL_ASE_XPA)
15809 fputs ("\n\tXPA ASE", file);
15810 if (mask == 0)
15811 fprintf (file, "\n\t%s", _("None"));
15812 else if ((mask & ~AFL_ASE_MASK) != 0)
15813 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15814 }
15815
15816 static void
15817 print_mips_isa_ext (FILE *file, unsigned int isa_ext)
15818 {
15819 switch (isa_ext)
15820 {
15821 case 0:
15822 fputs (_("None"), file);
15823 break;
15824 case AFL_EXT_XLR:
15825 fputs ("RMI XLR", file);
15826 break;
15827 case AFL_EXT_OCTEON3:
15828 fputs ("Cavium Networks Octeon3", file);
15829 break;
15830 case AFL_EXT_OCTEON2:
15831 fputs ("Cavium Networks Octeon2", file);
15832 break;
15833 case AFL_EXT_OCTEONP:
15834 fputs ("Cavium Networks OcteonP", file);
15835 break;
15836 case AFL_EXT_LOONGSON_3A:
15837 fputs ("Loongson 3A", file);
15838 break;
15839 case AFL_EXT_OCTEON:
15840 fputs ("Cavium Networks Octeon", file);
15841 break;
15842 case AFL_EXT_5900:
15843 fputs ("Toshiba R5900", file);
15844 break;
15845 case AFL_EXT_4650:
15846 fputs ("MIPS R4650", file);
15847 break;
15848 case AFL_EXT_4010:
15849 fputs ("LSI R4010", file);
15850 break;
15851 case AFL_EXT_4100:
15852 fputs ("NEC VR4100", file);
15853 break;
15854 case AFL_EXT_3900:
15855 fputs ("Toshiba R3900", file);
15856 break;
15857 case AFL_EXT_10000:
15858 fputs ("MIPS R10000", file);
15859 break;
15860 case AFL_EXT_SB1:
15861 fputs ("Broadcom SB-1", file);
15862 break;
15863 case AFL_EXT_4111:
15864 fputs ("NEC VR4111/VR4181", file);
15865 break;
15866 case AFL_EXT_4120:
15867 fputs ("NEC VR4120", file);
15868 break;
15869 case AFL_EXT_5400:
15870 fputs ("NEC VR5400", file);
15871 break;
15872 case AFL_EXT_5500:
15873 fputs ("NEC VR5500", file);
15874 break;
15875 case AFL_EXT_LOONGSON_2E:
15876 fputs ("ST Microelectronics Loongson 2E", file);
15877 break;
15878 case AFL_EXT_LOONGSON_2F:
15879 fputs ("ST Microelectronics Loongson 2F", file);
15880 break;
15881 default:
15882 fprintf (file, "%s (%d)", _("Unknown"), isa_ext);
15883 break;
15884 }
15885 }
15886
15887 static void
15888 print_mips_fp_abi_value (FILE *file, int val)
15889 {
15890 switch (val)
15891 {
15892 case Val_GNU_MIPS_ABI_FP_ANY:
15893 fprintf (file, _("Hard or soft float\n"));
15894 break;
15895 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15896 fprintf (file, _("Hard float (double precision)\n"));
15897 break;
15898 case Val_GNU_MIPS_ABI_FP_SINGLE:
15899 fprintf (file, _("Hard float (single precision)\n"));
15900 break;
15901 case Val_GNU_MIPS_ABI_FP_SOFT:
15902 fprintf (file, _("Soft float\n"));
15903 break;
15904 case Val_GNU_MIPS_ABI_FP_OLD_64:
15905 fprintf (file, _("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15906 break;
15907 case Val_GNU_MIPS_ABI_FP_XX:
15908 fprintf (file, _("Hard float (32-bit CPU, Any FPU)\n"));
15909 break;
15910 case Val_GNU_MIPS_ABI_FP_64:
15911 fprintf (file, _("Hard float (32-bit CPU, 64-bit FPU)\n"));
15912 break;
15913 case Val_GNU_MIPS_ABI_FP_64A:
15914 fprintf (file, _("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15915 break;
15916 default:
15917 fprintf (file, "??? (%d)\n", val);
15918 break;
15919 }
15920 }
15921
15922 static int
15923 get_mips_reg_size (int reg_size)
15924 {
15925 return (reg_size == AFL_REG_NONE) ? 0
15926 : (reg_size == AFL_REG_32) ? 32
15927 : (reg_size == AFL_REG_64) ? 64
15928 : (reg_size == AFL_REG_128) ? 128
15929 : -1;
15930 }
15931
15932 bfd_boolean
15933 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
15934 {
15935 FILE *file = ptr;
15936
15937 BFD_ASSERT (abfd != NULL && ptr != NULL);
15938
15939 /* Print normal ELF private data. */
15940 _bfd_elf_print_private_bfd_data (abfd, ptr);
15941
15942 /* xgettext:c-format */
15943 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
15944
15945 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
15946 fprintf (file, _(" [abi=O32]"));
15947 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
15948 fprintf (file, _(" [abi=O64]"));
15949 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
15950 fprintf (file, _(" [abi=EABI32]"));
15951 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
15952 fprintf (file, _(" [abi=EABI64]"));
15953 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
15954 fprintf (file, _(" [abi unknown]"));
15955 else if (ABI_N32_P (abfd))
15956 fprintf (file, _(" [abi=N32]"));
15957 else if (ABI_64_P (abfd))
15958 fprintf (file, _(" [abi=64]"));
15959 else
15960 fprintf (file, _(" [no abi set]"));
15961
15962 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
15963 fprintf (file, " [mips1]");
15964 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
15965 fprintf (file, " [mips2]");
15966 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
15967 fprintf (file, " [mips3]");
15968 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
15969 fprintf (file, " [mips4]");
15970 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
15971 fprintf (file, " [mips5]");
15972 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
15973 fprintf (file, " [mips32]");
15974 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
15975 fprintf (file, " [mips64]");
15976 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
15977 fprintf (file, " [mips32r2]");
15978 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
15979 fprintf (file, " [mips64r2]");
15980 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6)
15981 fprintf (file, " [mips32r6]");
15982 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
15983 fprintf (file, " [mips64r6]");
15984 else
15985 fprintf (file, _(" [unknown ISA]"));
15986
15987 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
15988 fprintf (file, " [mdmx]");
15989
15990 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
15991 fprintf (file, " [mips16]");
15992
15993 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
15994 fprintf (file, " [micromips]");
15995
15996 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NAN2008)
15997 fprintf (file, " [nan2008]");
15998
15999 if (elf_elfheader (abfd)->e_flags & EF_MIPS_FP64)
16000 fprintf (file, " [old fp64]");
16001
16002 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
16003 fprintf (file, " [32bitmode]");
16004 else
16005 fprintf (file, _(" [not 32bitmode]"));
16006
16007 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
16008 fprintf (file, " [noreorder]");
16009
16010 if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
16011 fprintf (file, " [PIC]");
16012
16013 if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
16014 fprintf (file, " [CPIC]");
16015
16016 if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
16017 fprintf (file, " [XGOT]");
16018
16019 if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
16020 fprintf (file, " [UCODE]");
16021
16022 fputc ('\n', file);
16023
16024 if (mips_elf_tdata (abfd)->abiflags_valid)
16025 {
16026 Elf_Internal_ABIFlags_v0 *abiflags = &mips_elf_tdata (abfd)->abiflags;
16027 fprintf (file, "\nMIPS ABI Flags Version: %d\n", abiflags->version);
16028 fprintf (file, "\nISA: MIPS%d", abiflags->isa_level);
16029 if (abiflags->isa_rev > 1)
16030 fprintf (file, "r%d", abiflags->isa_rev);
16031 fprintf (file, "\nGPR size: %d",
16032 get_mips_reg_size (abiflags->gpr_size));
16033 fprintf (file, "\nCPR1 size: %d",
16034 get_mips_reg_size (abiflags->cpr1_size));
16035 fprintf (file, "\nCPR2 size: %d",
16036 get_mips_reg_size (abiflags->cpr2_size));
16037 fputs ("\nFP ABI: ", file);
16038 print_mips_fp_abi_value (file, abiflags->fp_abi);
16039 fputs ("ISA Extension: ", file);
16040 print_mips_isa_ext (file, abiflags->isa_ext);
16041 fputs ("\nASEs:", file);
16042 print_mips_ases (file, abiflags->ases);
16043 fprintf (file, "\nFLAGS 1: %8.8lx", abiflags->flags1);
16044 fprintf (file, "\nFLAGS 2: %8.8lx", abiflags->flags2);
16045 fputc ('\n', file);
16046 }
16047
16048 return TRUE;
16049 }
16050
16051 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
16052 {
16053 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16054 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16055 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
16056 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16057 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
16058 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE, 0 },
16059 { NULL, 0, 0, 0, 0 }
16060 };
16061
16062 /* Merge non visibility st_other attributes. Ensure that the
16063 STO_OPTIONAL flag is copied into h->other, even if this is not a
16064 definiton of the symbol. */
16065 void
16066 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
16067 const Elf_Internal_Sym *isym,
16068 bfd_boolean definition,
16069 bfd_boolean dynamic ATTRIBUTE_UNUSED)
16070 {
16071 if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
16072 {
16073 unsigned char other;
16074
16075 other = (definition ? isym->st_other : h->other);
16076 other &= ~ELF_ST_VISIBILITY (-1);
16077 h->other = other | ELF_ST_VISIBILITY (h->other);
16078 }
16079
16080 if (!definition
16081 && ELF_MIPS_IS_OPTIONAL (isym->st_other))
16082 h->other |= STO_OPTIONAL;
16083 }
16084
16085 /* Decide whether an undefined symbol is special and can be ignored.
16086 This is the case for OPTIONAL symbols on IRIX. */
16087 bfd_boolean
16088 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
16089 {
16090 return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
16091 }
16092
16093 bfd_boolean
16094 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
16095 {
16096 return (sym->st_shndx == SHN_COMMON
16097 || sym->st_shndx == SHN_MIPS_ACOMMON
16098 || sym->st_shndx == SHN_MIPS_SCOMMON);
16099 }
16100
16101 /* Return address for Ith PLT stub in section PLT, for relocation REL
16102 or (bfd_vma) -1 if it should not be included. */
16103
16104 bfd_vma
16105 _bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
16106 const arelent *rel ATTRIBUTE_UNUSED)
16107 {
16108 return (plt->vma
16109 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
16110 + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
16111 }
16112
16113 /* Build a table of synthetic symbols to represent the PLT. As with MIPS16
16114 and microMIPS PLT slots we may have a many-to-one mapping between .plt
16115 and .got.plt and also the slots may be of a different size each we walk
16116 the PLT manually fetching instructions and matching them against known
16117 patterns. To make things easier standard MIPS slots, if any, always come
16118 first. As we don't create proper ELF symbols we use the UDATA.I member
16119 of ASYMBOL to carry ISA annotation. The encoding used is the same as
16120 with the ST_OTHER member of the ELF symbol. */
16121
16122 long
16123 _bfd_mips_elf_get_synthetic_symtab (bfd *abfd,
16124 long symcount ATTRIBUTE_UNUSED,
16125 asymbol **syms ATTRIBUTE_UNUSED,
16126 long dynsymcount, asymbol **dynsyms,
16127 asymbol **ret)
16128 {
16129 static const char pltname[] = "_PROCEDURE_LINKAGE_TABLE_";
16130 static const char microsuffix[] = "@micromipsplt";
16131 static const char m16suffix[] = "@mips16plt";
16132 static const char mipssuffix[] = "@plt";
16133
16134 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
16135 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
16136 bfd_boolean micromips_p = MICROMIPS_P (abfd);
16137 Elf_Internal_Shdr *hdr;
16138 bfd_byte *plt_data;
16139 bfd_vma plt_offset;
16140 unsigned int other;
16141 bfd_vma entry_size;
16142 bfd_vma plt0_size;
16143 asection *relplt;
16144 bfd_vma opcode;
16145 asection *plt;
16146 asymbol *send;
16147 size_t size;
16148 char *names;
16149 long counti;
16150 arelent *p;
16151 asymbol *s;
16152 char *nend;
16153 long count;
16154 long pi;
16155 long i;
16156 long n;
16157
16158 *ret = NULL;
16159
16160 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0 || dynsymcount <= 0)
16161 return 0;
16162
16163 relplt = bfd_get_section_by_name (abfd, ".rel.plt");
16164 if (relplt == NULL)
16165 return 0;
16166
16167 hdr = &elf_section_data (relplt)->this_hdr;
16168 if (hdr->sh_link != elf_dynsymtab (abfd) || hdr->sh_type != SHT_REL)
16169 return 0;
16170
16171 plt = bfd_get_section_by_name (abfd, ".plt");
16172 if (plt == NULL)
16173 return 0;
16174
16175 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
16176 if (!(*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
16177 return -1;
16178 p = relplt->relocation;
16179
16180 /* Calculating the exact amount of space required for symbols would
16181 require two passes over the PLT, so just pessimise assuming two
16182 PLT slots per relocation. */
16183 count = relplt->size / hdr->sh_entsize;
16184 counti = count * bed->s->int_rels_per_ext_rel;
16185 size = 2 * count * sizeof (asymbol);
16186 size += count * (sizeof (mipssuffix) +
16187 (micromips_p ? sizeof (microsuffix) : sizeof (m16suffix)));
16188 for (pi = 0; pi < counti; pi += bed->s->int_rels_per_ext_rel)
16189 size += 2 * strlen ((*p[pi].sym_ptr_ptr)->name);
16190
16191 /* Add the size of "_PROCEDURE_LINKAGE_TABLE_" too. */
16192 size += sizeof (asymbol) + sizeof (pltname);
16193
16194 if (!bfd_malloc_and_get_section (abfd, plt, &plt_data))
16195 return -1;
16196
16197 if (plt->size < 16)
16198 return -1;
16199
16200 s = *ret = bfd_malloc (size);
16201 if (s == NULL)
16202 return -1;
16203 send = s + 2 * count + 1;
16204
16205 names = (char *) send;
16206 nend = (char *) s + size;
16207 n = 0;
16208
16209 opcode = bfd_get_micromips_32 (abfd, plt_data + 12);
16210 if (opcode == 0x3302fffe)
16211 {
16212 if (!micromips_p)
16213 return -1;
16214 plt0_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry);
16215 other = STO_MICROMIPS;
16216 }
16217 else if (opcode == 0x0398c1d0)
16218 {
16219 if (!micromips_p)
16220 return -1;
16221 plt0_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry);
16222 other = STO_MICROMIPS;
16223 }
16224 else
16225 {
16226 plt0_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
16227 other = 0;
16228 }
16229
16230 s->the_bfd = abfd;
16231 s->flags = BSF_SYNTHETIC | BSF_FUNCTION | BSF_LOCAL;
16232 s->section = plt;
16233 s->value = 0;
16234 s->name = names;
16235 s->udata.i = other;
16236 memcpy (names, pltname, sizeof (pltname));
16237 names += sizeof (pltname);
16238 ++s, ++n;
16239
16240 pi = 0;
16241 for (plt_offset = plt0_size;
16242 plt_offset + 8 <= plt->size && s < send;
16243 plt_offset += entry_size)
16244 {
16245 bfd_vma gotplt_addr;
16246 const char *suffix;
16247 bfd_vma gotplt_hi;
16248 bfd_vma gotplt_lo;
16249 size_t suffixlen;
16250
16251 opcode = bfd_get_micromips_32 (abfd, plt_data + plt_offset + 4);
16252
16253 /* Check if the second word matches the expected MIPS16 instruction. */
16254 if (opcode == 0x651aeb00)
16255 {
16256 if (micromips_p)
16257 return -1;
16258 /* Truncated table??? */
16259 if (plt_offset + 16 > plt->size)
16260 break;
16261 gotplt_addr = bfd_get_32 (abfd, plt_data + plt_offset + 12);
16262 entry_size = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry);
16263 suffixlen = sizeof (m16suffix);
16264 suffix = m16suffix;
16265 other = STO_MIPS16;
16266 }
16267 /* Likewise the expected microMIPS instruction (no insn32 mode). */
16268 else if (opcode == 0xff220000)
16269 {
16270 if (!micromips_p)
16271 return -1;
16272 gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset) & 0x7f;
16273 gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
16274 gotplt_hi = ((gotplt_hi ^ 0x40) - 0x40) << 18;
16275 gotplt_lo <<= 2;
16276 gotplt_addr = gotplt_hi + gotplt_lo;
16277 gotplt_addr += ((plt->vma + plt_offset) | 3) ^ 3;
16278 entry_size = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry);
16279 suffixlen = sizeof (microsuffix);
16280 suffix = microsuffix;
16281 other = STO_MICROMIPS;
16282 }
16283 /* Likewise the expected microMIPS instruction (insn32 mode). */
16284 else if ((opcode & 0xffff0000) == 0xff2f0000)
16285 {
16286 gotplt_hi = bfd_get_16 (abfd, plt_data + plt_offset + 2) & 0xffff;
16287 gotplt_lo = bfd_get_16 (abfd, plt_data + plt_offset + 6) & 0xffff;
16288 gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
16289 gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
16290 gotplt_addr = gotplt_hi + gotplt_lo;
16291 entry_size = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry);
16292 suffixlen = sizeof (microsuffix);
16293 suffix = microsuffix;
16294 other = STO_MICROMIPS;
16295 }
16296 /* Otherwise assume standard MIPS code. */
16297 else
16298 {
16299 gotplt_hi = bfd_get_32 (abfd, plt_data + plt_offset) & 0xffff;
16300 gotplt_lo = bfd_get_32 (abfd, plt_data + plt_offset + 4) & 0xffff;
16301 gotplt_hi = ((gotplt_hi ^ 0x8000) - 0x8000) << 16;
16302 gotplt_lo = (gotplt_lo ^ 0x8000) - 0x8000;
16303 gotplt_addr = gotplt_hi + gotplt_lo;
16304 entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
16305 suffixlen = sizeof (mipssuffix);
16306 suffix = mipssuffix;
16307 other = 0;
16308 }
16309 /* Truncated table??? */
16310 if (plt_offset + entry_size > plt->size)
16311 break;
16312
16313 for (i = 0;
16314 i < count && p[pi].address != gotplt_addr;
16315 i++, pi = (pi + bed->s->int_rels_per_ext_rel) % counti);
16316
16317 if (i < count)
16318 {
16319 size_t namelen;
16320 size_t len;
16321
16322 *s = **p[pi].sym_ptr_ptr;
16323 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
16324 we are defining a symbol, ensure one of them is set. */
16325 if ((s->flags & BSF_LOCAL) == 0)
16326 s->flags |= BSF_GLOBAL;
16327 s->flags |= BSF_SYNTHETIC;
16328 s->section = plt;
16329 s->value = plt_offset;
16330 s->name = names;
16331 s->udata.i = other;
16332
16333 len = strlen ((*p[pi].sym_ptr_ptr)->name);
16334 namelen = len + suffixlen;
16335 if (names + namelen > nend)
16336 break;
16337
16338 memcpy (names, (*p[pi].sym_ptr_ptr)->name, len);
16339 names += len;
16340 memcpy (names, suffix, suffixlen);
16341 names += suffixlen;
16342
16343 ++s, ++n;
16344 pi = (pi + bed->s->int_rels_per_ext_rel) % counti;
16345 }
16346 }
16347
16348 free (plt_data);
16349
16350 return n;
16351 }
16352
16353 /* Return the ABI flags associated with ABFD if available. */
16354
16355 Elf_Internal_ABIFlags_v0 *
16356 bfd_mips_elf_get_abiflags (bfd *abfd)
16357 {
16358 struct mips_elf_obj_tdata *tdata = mips_elf_tdata (abfd);
16359
16360 return tdata->abiflags_valid ? &tdata->abiflags : NULL;
16361 }
16362
16363 void
16364 _bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
16365 {
16366 struct mips_elf_link_hash_table *htab;
16367 Elf_Internal_Ehdr *i_ehdrp;
16368
16369 i_ehdrp = elf_elfheader (abfd);
16370 if (link_info)
16371 {
16372 htab = mips_elf_hash_table (link_info);
16373 BFD_ASSERT (htab != NULL);
16374
16375 if (htab->use_plts_and_copy_relocs && !htab->is_vxworks)
16376 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
16377 }
16378
16379 _bfd_elf_post_process_headers (abfd, link_info);
16380
16381 if (mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64
16382 || mips_elf_tdata (abfd)->abiflags.fp_abi == Val_GNU_MIPS_ABI_FP_64A)
16383 i_ehdrp->e_ident[EI_ABIVERSION] = 3;
16384 }
16385
16386 int
16387 _bfd_mips_elf_compact_eh_encoding (struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
16388 {
16389 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
16390 }
16391
16392 /* Return the opcode for can't unwind. */
16393
16394 int
16395 _bfd_mips_elf_cant_unwind_opcode (struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
16396 {
16397 return COMPACT_EH_CANT_UNWIND_OPCODE;
16398 }