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