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