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