projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elflink.c (_bfd_elf_link_create_dynamic_sections): Move from
[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) \
45d6a902 545 (get_elf_backend_data (abfd)->s->log_file_align)
b49e97c9
TS		 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:
93a2b7ae 3224 case R_MIPS_GOT_OFST:
0176c794
AO		 3225 /* If this symbol got a global GOT entry, we have to decay
3226 GOT_PAGE/GOT_OFST to GOT_DISP/addend. */
93a2b7ae
AO		 3227 local_p = local_p || ! h
3228 || (h->root.dynindx
3229 < mips_elf_get_global_gotsym_index (elf_hash_table (info)
3230 ->dynobj));
3231 if (local_p || r_type == R_MIPS_GOT_OFST)
0fdc1bf1
AO		 3232 break;
3233 /* Fall through. */
3234
b49e97c9
TS		 3235 case R_MIPS_CALL16:
3236 case R_MIPS_GOT16:
3237 case R_MIPS_GOT_DISP:
3238 case R_MIPS_GOT_HI16:
3239 case R_MIPS_CALL_HI16:
3240 case R_MIPS_GOT_LO16:
3241 case R_MIPS_CALL_LO16:
3242 /* Find the index into the GOT where this value is located. */
3243 if (!local_p)
3244 {
0fdc1bf1
AO		 3245 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3246 GOT_PAGE relocation that decays to GOT_DISP because the
3247 symbol turns out to be global. The addend is then added
3248 as GOT_OFST. */
3249 BFD_ASSERT (addend == 0 || r_type == R_MIPS_GOT_PAGE);
b49e97c9 3250 g = mips_elf_global_got_index (elf_hash_table (info)->dynobj,
f4416af6 3251 input_bfd,
b49e97c9
TS		 3252 (struct elf_link_hash_entry *) h);
3253 if (! elf_hash_table(info)->dynamic_sections_created
3254 || (info->shared
3255 && (info->symbolic || h->root.dynindx == -1)
3256 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
3257 {
3258 /* This is a static link or a -Bsymbolic link. The
3259 symbol is defined locally, or was forced to be local.
3260 We must initialize this entry in the GOT. */
3261 bfd *tmpbfd = elf_hash_table (info)->dynobj;
f4416af6 3262 asection *sgot = mips_elf_got_section (tmpbfd, FALSE);
0fdc1bf1 3263 MIPS_ELF_PUT_WORD (tmpbfd, symbol, sgot->contents + g);
b49e97c9
TS		 3264 }
3265 }
3266 else if (r_type == R_MIPS_GOT16 || r_type == R_MIPS_CALL16)
3267 /* There's no need to create a local GOT entry here; the
3268 calculation for a local GOT16 entry does not involve G. */
3269 break;
3270 else
3271 {
f4416af6
AO		 3272 g = mips_elf_local_got_index (abfd, input_bfd,
3273 info, symbol + addend);
b49e97c9
TS		 3274 if (g == MINUS_ONE)
3275 return bfd_reloc_outofrange;
3276 }
3277
3278 /* Convert GOT indices to actual offsets. */
3279 g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
f4416af6 3280 abfd, input_bfd, g);
b49e97c9
TS		 3281 break;
3282
3283 case R_MIPS_HI16:
3284 case R_MIPS_LO16:
3285 case R_MIPS16_GPREL:
3286 case R_MIPS_GPREL16:
3287 case R_MIPS_GPREL32:
3288 case R_MIPS_LITERAL:
3289 gp0 = _bfd_get_gp_value (input_bfd);
3290 gp = _bfd_get_gp_value (abfd);
f4416af6
AO		 3291 if (elf_hash_table (info)->dynobj)
3292 gp += mips_elf_adjust_gp (abfd,
3293 mips_elf_got_info
3294 (elf_hash_table (info)->dynobj, NULL),
3295 input_bfd);
b49e97c9
TS		 3296 break;
3297
3298 default:
3299 break;
3300 }
3301
3302 /* Figure out what kind of relocation is being performed. */
3303 switch (r_type)
3304 {
3305 case R_MIPS_NONE:
3306 return bfd_reloc_continue;
3307
3308 case R_MIPS_16:
3309 value = symbol + mips_elf_sign_extend (addend, 16);
3310 overflowed_p = mips_elf_overflow_p (value, 16);
3311 break;
3312
3313 case R_MIPS_32:
3314 case R_MIPS_REL32:
3315 case R_MIPS_64:
3316 if ((info->shared
3317 || (elf_hash_table (info)->dynamic_sections_created
3318 && h != NULL
3319 && ((h->root.elf_link_hash_flags
3320 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
3321 && ((h->root.elf_link_hash_flags
3322 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
3323 && r_symndx != 0
3324 && (input_section->flags & SEC_ALLOC) != 0)
3325 {
3326 /* If we're creating a shared library, or this relocation is
3327 against a symbol in a shared library, then we can't know
3328 where the symbol will end up. So, we create a relocation
3329 record in the output, and leave the job up to the dynamic
3330 linker. */
3331 value = addend;
3332 if (!mips_elf_create_dynamic_relocation (abfd,
3333 info,
3334 relocation,
3335 h,
3336 sec,
3337 symbol,
3338 &value,
3339 input_section))
3340 return bfd_reloc_undefined;
3341 }
3342 else
3343 {
3344 if (r_type != R_MIPS_REL32)
3345 value = symbol + addend;
3346 else
3347 value = addend;
3348 }
3349 value &= howto->dst_mask;
3350 break;
3351
3352 case R_MIPS_PC32:
3353 case R_MIPS_PC64:
3354 case R_MIPS_GNU_REL_LO16:
3355 value = symbol + addend - p;
3356 value &= howto->dst_mask;
3357 break;
3358
0b25d3e6
AO		 3359 case R_MIPS_GNU_REL16_S2:
3360 value = symbol + mips_elf_sign_extend (addend << 2, 18) - p;
3361 overflowed_p = mips_elf_overflow_p (value, 18);
3362 value = (value >> 2) & howto->dst_mask;
3363 break;
3364
b49e97c9
TS		 3365 case R_MIPS_GNU_REL_HI16:
3366 /* Instead of subtracting 'p' here, we should be subtracting the
3367 equivalent value for the LO part of the reloc, since the value
3368 here is relative to that address. Because that's not easy to do,
3369 we adjust 'addend' in _bfd_mips_elf_relocate_section(). See also
3370 the comment there for more information. */
3371 value = mips_elf_high (addend + symbol - p);
3372 value &= howto->dst_mask;
3373 break;
3374
3375 case R_MIPS16_26:
3376 /* The calculation for R_MIPS16_26 is just the same as for an
3377 R_MIPS_26. It's only the storage of the relocated field into
3378 the output file that's different. That's handled in
3379 mips_elf_perform_relocation. So, we just fall through to the
3380 R_MIPS_26 case here. */
3381 case R_MIPS_26:
3382 if (local_p)
3383 value = (((addend << 2) | ((p + 4) & 0xf0000000)) + symbol) >> 2;
3384 else
3385 value = (mips_elf_sign_extend (addend << 2, 28) + symbol) >> 2;
3386 value &= howto->dst_mask;
3387 break;
3388
3389 case R_MIPS_HI16:
3390 if (!gp_disp_p)
3391 {
3392 value = mips_elf_high (addend + symbol);
3393 value &= howto->dst_mask;
3394 }
3395 else
3396 {
3397 value = mips_elf_high (addend + gp - p);
3398 overflowed_p = mips_elf_overflow_p (value, 16);
3399 }
3400 break;
3401
3402 case R_MIPS_LO16:
3403 if (!gp_disp_p)
3404 value = (symbol + addend) & howto->dst_mask;
3405 else
3406 {
3407 value = addend + gp - p + 4;
3408 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
8dc1a139 3409 for overflow. But, on, say, IRIX5, relocations against
b49e97c9
TS		 3410 _gp_disp are normally generated from the .cpload
3411 pseudo-op. It generates code that normally looks like
3412 this:
3413
3414 lui $gp,%hi(_gp_disp)
3415 addiu $gp,$gp,%lo(_gp_disp)
3416 addu $gp,$gp,$t9
3417
3418 Here $t9 holds the address of the function being called,
3419 as required by the MIPS ELF ABI. The R_MIPS_LO16
3420 relocation can easily overflow in this situation, but the
3421 R_MIPS_HI16 relocation will handle the overflow.
3422 Therefore, we consider this a bug in the MIPS ABI, and do
3423 not check for overflow here. */
3424 }
3425 break;
3426
3427 case R_MIPS_LITERAL:
3428 /* Because we don't merge literal sections, we can handle this
3429 just like R_MIPS_GPREL16. In the long run, we should merge
3430 shared literals, and then we will need to additional work
3431 here. */
3432
3433 /* Fall through. */
3434
3435 case R_MIPS16_GPREL:
3436 /* The R_MIPS16_GPREL performs the same calculation as
3437 R_MIPS_GPREL16, but stores the relocated bits in a different
3438 order. We don't need to do anything special here; the
3439 differences are handled in mips_elf_perform_relocation. */
3440 case R_MIPS_GPREL16:
bce03d3d
AO		 3441 /* Only sign-extend the addend if it was extracted from the
3442 instruction. If the addend was separate, leave it alone,
3443 otherwise we may lose significant bits. */
3444 if (howto->partial_inplace)
3445 addend = mips_elf_sign_extend (addend, 16);
3446 value = symbol + addend - gp;
3447 /* If the symbol was local, any earlier relocatable links will
3448 have adjusted its addend with the gp offset, so compensate
3449 for that now. Don't do it for symbols forced local in this
3450 link, though, since they won't have had the gp offset applied
3451 to them before. */
3452 if (was_local_p)
3453 value += gp0;
b49e97c9
TS		 3454 overflowed_p = mips_elf_overflow_p (value, 16);
3455 break;
3456
3457 case R_MIPS_GOT16:
3458 case R_MIPS_CALL16:
3459 if (local_p)
3460 {
b34976b6 3461 bfd_boolean forced;
b49e97c9
TS		 3462
3463 /* The special case is when the symbol is forced to be local. We
3464 need the full address in the GOT since no R_MIPS_LO16 relocation
3465 follows. */
3466 forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
b34976b6 3467 local_sections, FALSE);
f4416af6
AO		 3468 value = mips_elf_got16_entry (abfd, input_bfd, info,
3469 symbol + addend, forced);
b49e97c9
TS		 3470 if (value == MINUS_ONE)
3471 return bfd_reloc_outofrange;
3472 value
3473 = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
f4416af6 3474 abfd, input_bfd, value);
b49e97c9
TS		 3475 overflowed_p = mips_elf_overflow_p (value, 16);
3476 break;
3477 }
3478
3479 /* Fall through. */
3480
3481 case R_MIPS_GOT_DISP:
0fdc1bf1 3482 got_disp:
b49e97c9
TS		 3483 value = g;
3484 overflowed_p = mips_elf_overflow_p (value, 16);
3485 break;
3486
3487 case R_MIPS_GPREL32:
bce03d3d
AO		 3488 value = (addend + symbol + gp0 - gp);
3489 if (!save_addend)
3490 value &= howto->dst_mask;
b49e97c9
TS		 3491 break;
3492
3493 case R_MIPS_PC16:
0b25d3e6
AO		 3494 value = mips_elf_sign_extend (addend, 16) + symbol - p;
3495 overflowed_p = mips_elf_overflow_p (value, 16);
b49e97c9
TS		 3496 break;
3497
3498 case R_MIPS_GOT_HI16:
3499 case R_MIPS_CALL_HI16:
3500 /* We're allowed to handle these two relocations identically.
3501 The dynamic linker is allowed to handle the CALL relocations
3502 differently by creating a lazy evaluation stub. */
3503 value = g;
3504 value = mips_elf_high (value);
3505 value &= howto->dst_mask;
3506 break;
3507
3508 case R_MIPS_GOT_LO16:
3509 case R_MIPS_CALL_LO16:
3510 value = g & howto->dst_mask;
3511 break;
3512
3513 case R_MIPS_GOT_PAGE:
0fdc1bf1
AO		 3514 /* GOT_PAGE relocations that reference non-local symbols decay
3515 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3516 0. */
93a2b7ae 3517 if (! local_p)
0fdc1bf1 3518 goto got_disp;
f4416af6 3519 value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
b49e97c9
TS		 3520 if (value == MINUS_ONE)
3521 return bfd_reloc_outofrange;
3522 value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
f4416af6 3523 abfd, input_bfd, value);
b49e97c9
TS		 3524 overflowed_p = mips_elf_overflow_p (value, 16);
3525 break;
3526
3527 case R_MIPS_GOT_OFST:
93a2b7ae 3528 if (local_p)
0fdc1bf1
AO		 3529 mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
3530 else
3531 value = addend;
b49e97c9
TS		 3532 overflowed_p = mips_elf_overflow_p (value, 16);
3533 break;
3534
3535 case R_MIPS_SUB:
3536 value = symbol - addend;
3537 value &= howto->dst_mask;
3538 break;
3539
3540 case R_MIPS_HIGHER:
3541 value = mips_elf_higher (addend + symbol);
3542 value &= howto->dst_mask;
3543 break;
3544
3545 case R_MIPS_HIGHEST:
3546 value = mips_elf_highest (addend + symbol);
3547 value &= howto->dst_mask;
3548 break;
3549
3550 case R_MIPS_SCN_DISP:
3551 value = symbol + addend - sec->output_offset;
3552 value &= howto->dst_mask;
3553 break;
3554
3555 case R_MIPS_PJUMP:
3556 case R_MIPS_JALR:
3557 /* Both of these may be ignored. R_MIPS_JALR is an optimization
3558 hint; we could improve performance by honoring that hint. */
3559 return bfd_reloc_continue;
3560
3561 case R_MIPS_GNU_VTINHERIT:
3562 case R_MIPS_GNU_VTENTRY:
3563 /* We don't do anything with these at present. */
3564 return bfd_reloc_continue;
3565
3566 default:
3567 /* An unrecognized relocation type. */
3568 return bfd_reloc_notsupported;
3569 }
3570
3571 /* Store the VALUE for our caller. */
3572 *valuep = value;
3573 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
3574}
3575
3576/* Obtain the field relocated by RELOCATION. */
3577
3578static bfd_vma
3579mips_elf_obtain_contents (howto, relocation, input_bfd, contents)
3580 reloc_howto_type *howto;
3581 const Elf_Internal_Rela *relocation;
3582 bfd *input_bfd;
3583 bfd_byte *contents;
3584{
3585 bfd_vma x;
3586 bfd_byte *location = contents + relocation->r_offset;
3587
3588 /* Obtain the bytes. */
3589 x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
3590
3591 if ((ELF_R_TYPE (input_bfd, relocation->r_info) == R_MIPS16_26
3592 || ELF_R_TYPE (input_bfd, relocation->r_info) == R_MIPS16_GPREL)
3593 && bfd_little_endian (input_bfd))
3594 /* The two 16-bit words will be reversed on a little-endian system.
3595 See mips_elf_perform_relocation for more details. */
3596 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
3597
3598 return x;
3599}
3600
3601/* It has been determined that the result of the RELOCATION is the
3602 VALUE. Use HOWTO to place VALUE into the output file at the
3603 appropriate position. The SECTION is the section to which the
b34976b6 3604 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
b49e97c9
TS		 3605 for the relocation must be either JAL or JALX, and it is
3606 unconditionally converted to JALX.
3607
b34976b6 3608 Returns FALSE if anything goes wrong. */
b49e97c9 3609
b34976b6 3610static bfd_boolean
b49e97c9
TS		 3611mips_elf_perform_relocation (info, howto, relocation, value, input_bfd,
3612 input_section, contents, require_jalx)
3613 struct bfd_link_info *info;
3614 reloc_howto_type *howto;
3615 const Elf_Internal_Rela *relocation;
3616 bfd_vma value;
3617 bfd *input_bfd;
3618 asection *input_section;
3619 bfd_byte *contents;
b34976b6 3620 bfd_boolean require_jalx;
b49e97c9
TS		 3621{
3622 bfd_vma x;
3623 bfd_byte *location;
3624 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
3625
3626 /* Figure out where the relocation is occurring. */
3627 location = contents + relocation->r_offset;
3628
3629 /* Obtain the current value. */
3630 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
3631
3632 /* Clear the field we are setting. */
3633 x &= ~howto->dst_mask;
3634
3635 /* If this is the R_MIPS16_26 relocation, we must store the
3636 value in a funny way. */
3637 if (r_type == R_MIPS16_26)
3638 {
3639 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3640 Most mips16 instructions are 16 bits, but these instructions
3641 are 32 bits.
3642
3643 The format of these instructions is:
3644
3645 +--------------+--------------------------------+
3646 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
3647 +--------------+--------------------------------+
3648 ! Immediate 15:0 !
3649 +-----------------------------------------------+
3650
3651 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
3652 Note that the immediate value in the first word is swapped.
3653
3654 When producing a relocateable object file, R_MIPS16_26 is
3655 handled mostly like R_MIPS_26. In particular, the addend is
3656 stored as a straight 26-bit value in a 32-bit instruction.
3657 (gas makes life simpler for itself by never adjusting a
3658 R_MIPS16_26 reloc to be against a section, so the addend is
3659 always zero). However, the 32 bit instruction is stored as 2
3660 16-bit values, rather than a single 32-bit value. In a
3661 big-endian file, the result is the same; in a little-endian
3662 file, the two 16-bit halves of the 32 bit value are swapped.
3663 This is so that a disassembler can recognize the jal
3664 instruction.
3665
3666 When doing a final link, R_MIPS16_26 is treated as a 32 bit
3667 instruction stored as two 16-bit values. The addend A is the
3668 contents of the targ26 field. The calculation is the same as
3669 R_MIPS_26. When storing the calculated value, reorder the
3670 immediate value as shown above, and don't forget to store the
3671 value as two 16-bit values.
3672
3673 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3674 defined as
3675
3676 big-endian:
3677 +--------+----------------------+
3678 | | |
3679 | | targ26-16 |
3680 |31 26|25 0|
3681 +--------+----------------------+
3682
3683 little-endian:
3684 +----------+------+-------------+
3685 | | | |
3686 | sub1 | | sub2 |
3687 |0 9|10 15|16 31|
3688 +----------+--------------------+
3689 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3690 ((sub1 << 16) | sub2)).
3691
3692 When producing a relocateable object file, the calculation is
3693 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3694 When producing a fully linked file, the calculation is
3695 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3696 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
3697
3698 if (!info->relocateable)
3699 /* Shuffle the bits according to the formula above. */
3700 value = (((value & 0x1f0000) << 5)
3701 | ((value & 0x3e00000) >> 5)
3702 | (value & 0xffff));
3703 }
3704 else if (r_type == R_MIPS16_GPREL)
3705 {
3706 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3707 mode. A typical instruction will have a format like this:
3708
3709 +--------------+--------------------------------+
3710 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
3711 +--------------+--------------------------------+
3712 ! Major ! rx ! ry ! Imm 4:0 !
3713 +--------------+--------------------------------+
3714
3715 EXTEND is the five bit value 11110. Major is the instruction
3716 opcode.
3717
3718 This is handled exactly like R_MIPS_GPREL16, except that the
3719 addend is retrieved and stored as shown in this diagram; that
3720 is, the Imm fields above replace the V-rel16 field.
3721
3722 All we need to do here is shuffle the bits appropriately. As
3723 above, the two 16-bit halves must be swapped on a
3724 little-endian system. */
3725 value = (((value & 0x7e0) << 16)
3726 | ((value & 0xf800) << 5)
3727 | (value & 0x1f));
3728 }
3729
3730 /* Set the field. */
3731 x |= (value & howto->dst_mask);
3732
3733 /* If required, turn JAL into JALX. */
3734 if (require_jalx)
3735 {
b34976b6 3736 bfd_boolean ok;
b49e97c9
TS		 3737 bfd_vma opcode = x >> 26;
3738 bfd_vma jalx_opcode;
3739
3740 /* Check to see if the opcode is already JAL or JALX. */
3741 if (r_type == R_MIPS16_26)
3742 {
3743 ok = ((opcode == 0x6) || (opcode == 0x7));
3744 jalx_opcode = 0x7;
3745 }
3746 else
3747 {
3748 ok = ((opcode == 0x3) || (opcode == 0x1d));
3749 jalx_opcode = 0x1d;
3750 }
3751
3752 /* If the opcode is not JAL or JALX, there's a problem. */
3753 if (!ok)
3754 {
3755 (*_bfd_error_handler)
3756 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3757 bfd_archive_filename (input_bfd),
3758 input_section->name,
3759 (unsigned long) relocation->r_offset);
3760 bfd_set_error (bfd_error_bad_value);
b34976b6 3761 return FALSE;
b49e97c9
TS		 3762 }
3763
3764 /* Make this the JALX opcode. */
3765 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
3766 }
3767
3768 /* Swap the high- and low-order 16 bits on little-endian systems
3769 when doing a MIPS16 relocation. */
3770 if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
3771 && bfd_little_endian (input_bfd))
3772 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
3773
3774 /* Put the value into the output. */
3775 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
b34976b6 3776 return TRUE;
b49e97c9
TS		 3777}
3778
b34976b6 3779/* Returns TRUE if SECTION is a MIPS16 stub section. */
b49e97c9 3780
b34976b6 3781static bfd_boolean
b49e97c9
TS		 3782mips_elf_stub_section_p (abfd, section)
3783 bfd *abfd ATTRIBUTE_UNUSED;
3784 asection *section;
3785{
3786 const char *name = bfd_get_section_name (abfd, section);
3787
3788 return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
3789 || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
3790 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
3791}
3792\f
3793/* Add room for N relocations to the .rel.dyn section in ABFD. */
3794
3795static void
3796mips_elf_allocate_dynamic_relocations (abfd, n)
3797 bfd *abfd;
3798 unsigned int n;
3799{
3800 asection *s;
3801
f4416af6 3802 s = mips_elf_rel_dyn_section (abfd, FALSE);
b49e97c9
TS		 3803 BFD_ASSERT (s != NULL);
3804
3805 if (s->_raw_size == 0)
3806 {
3807 /* Make room for a null element. */
3808 s->_raw_size += MIPS_ELF_REL_SIZE (abfd);
3809 ++s->reloc_count;
3810 }
3811 s->_raw_size += n * MIPS_ELF_REL_SIZE (abfd);
3812}
3813
3814/* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3815 is the original relocation, which is now being transformed into a
3816 dynamic relocation. The ADDENDP is adjusted if necessary; the
3817 caller should store the result in place of the original addend. */
3818
b34976b6 3819static bfd_boolean
b49e97c9
TS		 3820mips_elf_create_dynamic_relocation (output_bfd, info, rel, h, sec,
3821 symbol, addendp, input_section)
3822 bfd *output_bfd;
3823 struct bfd_link_info *info;
3824 const Elf_Internal_Rela *rel;
3825 struct mips_elf_link_hash_entry *h;
3826 asection *sec;
3827 bfd_vma symbol;
3828 bfd_vma *addendp;
3829 asection *input_section;
3830{
947216bf 3831 Elf_Internal_Rela outrel[3];
b34976b6 3832 bfd_boolean skip;
b49e97c9
TS		 3833 asection *sreloc;
3834 bfd *dynobj;
3835 int r_type;
3836
3837 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
3838 dynobj = elf_hash_table (info)->dynobj;
f4416af6 3839 sreloc = mips_elf_rel_dyn_section (dynobj, FALSE);
b49e97c9
TS		 3840 BFD_ASSERT (sreloc != NULL);
3841 BFD_ASSERT (sreloc->contents != NULL);
3842 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
3843 < sreloc->_raw_size);
3844
b34976b6 3845 skip = FALSE;
b49e97c9
TS		 3846 outrel[0].r_offset =
3847 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
3848 outrel[1].r_offset =
3849 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
3850 outrel[2].r_offset =
3851 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
3852
3853#if 0
3854 /* We begin by assuming that the offset for the dynamic relocation
3855 is the same as for the original relocation. We'll adjust this
3856 later to reflect the correct output offsets. */
3857 if (elf_section_data (input_section)->sec_info_type != ELF_INFO_TYPE_STABS)
3858 {
3859 outrel[1].r_offset = rel[1].r_offset;
3860 outrel[2].r_offset = rel[2].r_offset;
3861 }
3862 else
3863 {
3864 /* Except that in a stab section things are more complex.
3865 Because we compress stab information, the offset given in the
3866 relocation may not be the one we want; we must let the stabs
3867 machinery tell us the offset. */
3868 outrel[1].r_offset = outrel[0].r_offset;
3869 outrel[2].r_offset = outrel[0].r_offset;
3870 /* If we didn't need the relocation at all, this value will be
3871 -1. */
3872 if (outrel[0].r_offset == (bfd_vma) -1)
b34976b6 3873 skip = TRUE;
b49e97c9
TS		 3874 }
3875#endif
3876
4bb9a95f
AO		 3877 if (outrel[0].r_offset == (bfd_vma) -1
3878 || outrel[0].r_offset == (bfd_vma) -2)
b34976b6 3879 skip = TRUE;
b49e97c9
TS		 3880
3881 /* If we've decided to skip this relocation, just output an empty
3882 record. Note that R_MIPS_NONE == 0, so that this call to memset
3883 is a way of setting R_TYPE to R_MIPS_NONE. */
3884 if (skip)
947216bf 3885 memset (outrel, 0, sizeof (Elf_Internal_Rela) * 3);
b49e97c9
TS		 3886 else
3887 {
3888 long indx;
b49e97c9
TS		 3889
3890 /* We must now calculate the dynamic symbol table index to use
3891 in the relocation. */
3892 if (h != NULL
3893 && (! info->symbolic || (h->root.elf_link_hash_flags
3894 & ELF_LINK_HASH_DEF_REGULAR) == 0))
3895 {
3896 indx = h->root.dynindx;
3897 /* h->root.dynindx may be -1 if this symbol was marked to
3898 become local. */
3899 if (indx == -1)
3900 indx = 0;
3901 }
3902 else
3903 {
3904 if (sec != NULL && bfd_is_abs_section (sec))
3905 indx = 0;
3906 else if (sec == NULL || sec->owner == NULL)
3907 {
3908 bfd_set_error (bfd_error_bad_value);
b34976b6 3909 return FALSE;
b49e97c9
TS		 3910 }
3911 else
3912 {
3913 indx = elf_section_data (sec->output_section)->dynindx;
3914 if (indx == 0)
3915 abort ();
3916 }
3917
908488f1
AO		 3918 /* Instead of generating a relocation using the section
3919 symbol, we may as well make it a fully relative
3920 relocation. We want to avoid generating relocations to
3921 local symbols because we used to generate them
3922 incorrectly, without adding the original symbol value,
3923 which is mandated by the ABI for section symbols. In
3924 order to give dynamic loaders and applications time to
3925 phase out the incorrect use, we refrain from emitting
3926 section-relative relocations. It's not like they're
3927 useful, after all. This should be a bit more efficient
3928 as well. */
3929 indx = 0;
b49e97c9
TS		 3930 }
3931
3932 /* If the relocation was previously an absolute relocation and
3933 this symbol will not be referred to by the relocation, we must
3934 adjust it by the value we give it in the dynamic symbol table.
3935 Otherwise leave the job up to the dynamic linker. */
3936 if (!indx && r_type != R_MIPS_REL32)
3937 *addendp += symbol;
3938
3939 /* The relocation is always an REL32 relocation because we don't
3940 know where the shared library will wind up at load-time. */
34ea4a36
TS		 3941 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
3942 R_MIPS_REL32);
908488f1
AO		 3943 /* For strict adherence to the ABI specification, we should
3944 generate a R_MIPS_64 relocation record by itself before the
3945 _REL32/_64 record as well, such that the addend is read in as
3946 a 64-bit value (REL32 is a 32-bit relocation, after all).
3947 However, since none of the existing ELF64 MIPS dynamic
3948 loaders seems to care, we don't waste space with these
3949 artificial relocations. If this turns out to not be true,
3950 mips_elf_allocate_dynamic_relocation() should be tweaked so
3951 as to make room for a pair of dynamic relocations per
3952 invocation if ABI_64_P, and here we should generate an
3953 additional relocation record with R_MIPS_64 by itself for a
3954 NULL symbol before this relocation record. */
7c4ca42d 3955 outrel[1].r_info = ELF_R_INFO (output_bfd, (unsigned long) 0,
033fd5f9
AO		 3956 ABI_64_P (output_bfd)
3957 ? R_MIPS_64
3958 : R_MIPS_NONE);
7c4ca42d
AO		 3959 outrel[2].r_info = ELF_R_INFO (output_bfd, (unsigned long) 0,
3960 R_MIPS_NONE);
b49e97c9
TS		 3961
3962 /* Adjust the output offset of the relocation to reference the
3963 correct location in the output file. */
3964 outrel[0].r_offset += (input_section->output_section->vma
3965 + input_section->output_offset);
3966 outrel[1].r_offset += (input_section->output_section->vma
3967 + input_section->output_offset);
3968 outrel[2].r_offset += (input_section->output_section->vma
3969 + input_section->output_offset);
3970 }
3971
3972 /* Put the relocation back out. We have to use the special
3973 relocation outputter in the 64-bit case since the 64-bit
3974 relocation format is non-standard. */
3975 if (ABI_64_P (output_bfd))
3976 {
3977 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
3978 (output_bfd, &outrel[0],
3979 (sreloc->contents
3980 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
3981 }
3982 else
947216bf
AM		 3983 bfd_elf32_swap_reloc_out
3984 (output_bfd, &outrel[0],
3985 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
b49e97c9
TS		 3986
3987 /* Record the index of the first relocation referencing H. This
3988 information is later emitted in the .msym section. */
3989 if (h != NULL
3990 && (h->min_dyn_reloc_index == 0
3991 || sreloc->reloc_count < h->min_dyn_reloc_index))
3992 h->min_dyn_reloc_index = sreloc->reloc_count;
3993
3994 /* We've now added another relocation. */
3995 ++sreloc->reloc_count;
3996
3997 /* Make sure the output section is writable. The dynamic linker
3998 will be writing to it. */
3999 elf_section_data (input_section->output_section)->this_hdr.sh_flags
4000 |= SHF_WRITE;
4001
4002 /* On IRIX5, make an entry of compact relocation info. */
4003 if (! skip && IRIX_COMPAT (output_bfd) == ict_irix5)
4004 {
4005 asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
4006 bfd_byte *cr;
4007
4008 if (scpt)
4009 {
4010 Elf32_crinfo cptrel;
4011
4012 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
4013 cptrel.vaddr = (rel->r_offset
4014 + input_section->output_section->vma
4015 + input_section->output_offset);
4016 if (r_type == R_MIPS_REL32)
4017 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
4018 else
4019 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
4020 mips_elf_set_cr_dist2to (cptrel, 0);
4021 cptrel.konst = *addendp;
4022
4023 cr = (scpt->contents
4024 + sizeof (Elf32_External_compact_rel));
4025 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
4026 ((Elf32_External_crinfo *) cr
4027 + scpt->reloc_count));
4028 ++scpt->reloc_count;
4029 }
4030 }
4031
b34976b6 4032 return TRUE;
b49e97c9
TS		 4033}
4034\f
b49e97c9
TS		 4035/* Return the MACH for a MIPS e_flags value. */
4036
4037unsigned long
4038_bfd_elf_mips_mach (flags)
4039 flagword flags;
4040{
4041 switch (flags & EF_MIPS_MACH)
4042 {
4043 case E_MIPS_MACH_3900:
4044 return bfd_mach_mips3900;
4045
4046 case E_MIPS_MACH_4010:
4047 return bfd_mach_mips4010;
4048
4049 case E_MIPS_MACH_4100:
4050 return bfd_mach_mips4100;
4051
4052 case E_MIPS_MACH_4111:
4053 return bfd_mach_mips4111;
4054
00707a0e
RS		 4055 case E_MIPS_MACH_4120:
4056 return bfd_mach_mips4120;
4057
b49e97c9
TS		 4058 case E_MIPS_MACH_4650:
4059 return bfd_mach_mips4650;
4060
00707a0e
RS		 4061 case E_MIPS_MACH_5400:
4062 return bfd_mach_mips5400;
4063
4064 case E_MIPS_MACH_5500:
4065 return bfd_mach_mips5500;
4066
b49e97c9
TS		 4067 case E_MIPS_MACH_SB1:
4068 return bfd_mach_mips_sb1;
4069
4070 default:
4071 switch (flags & EF_MIPS_ARCH)
4072 {
4073 default:
4074 case E_MIPS_ARCH_1:
4075 return bfd_mach_mips3000;
4076 break;
4077
4078 case E_MIPS_ARCH_2:
4079 return bfd_mach_mips6000;
4080 break;
4081
4082 case E_MIPS_ARCH_3:
4083 return bfd_mach_mips4000;
4084 break;
4085
4086 case E_MIPS_ARCH_4:
4087 return bfd_mach_mips8000;
4088 break;
4089
4090 case E_MIPS_ARCH_5:
4091 return bfd_mach_mips5;
4092 break;
4093
4094 case E_MIPS_ARCH_32:
4095 return bfd_mach_mipsisa32;
4096 break;
4097
4098 case E_MIPS_ARCH_64:
4099 return bfd_mach_mipsisa64;
4100 break;
af7ee8bf
CD		 4101
4102 case E_MIPS_ARCH_32R2:
4103 return bfd_mach_mipsisa32r2;
4104 break;
b49e97c9
TS		 4105 }
4106 }
4107
4108 return 0;
4109}
4110
4111/* Return printable name for ABI. */
4112
4113static INLINE char *
4114elf_mips_abi_name (abfd)
4115 bfd *abfd;
4116{
4117 flagword flags;
4118
4119 flags = elf_elfheader (abfd)->e_flags;
4120 switch (flags & EF_MIPS_ABI)
4121 {
4122 case 0:
4123 if (ABI_N32_P (abfd))
4124 return "N32";
4125 else if (ABI_64_P (abfd))
4126 return "64";
4127 else
4128 return "none";
4129 case E_MIPS_ABI_O32:
4130 return "O32";
4131 case E_MIPS_ABI_O64:
4132 return "O64";
4133 case E_MIPS_ABI_EABI32:
4134 return "EABI32";
4135 case E_MIPS_ABI_EABI64:
4136 return "EABI64";
4137 default:
4138 return "unknown abi";
4139 }
4140}
4141\f
4142/* MIPS ELF uses two common sections. One is the usual one, and the
4143 other is for small objects. All the small objects are kept
4144 together, and then referenced via the gp pointer, which yields
4145 faster assembler code. This is what we use for the small common
4146 section. This approach is copied from ecoff.c. */
4147static asection mips_elf_scom_section;
4148static asymbol mips_elf_scom_symbol;
4149static asymbol *mips_elf_scom_symbol_ptr;
4150
4151/* MIPS ELF also uses an acommon section, which represents an
4152 allocated common symbol which may be overridden by a
4153 definition in a shared library. */
4154static asection mips_elf_acom_section;
4155static asymbol mips_elf_acom_symbol;
4156static asymbol *mips_elf_acom_symbol_ptr;
4157
4158/* Handle the special MIPS section numbers that a symbol may use.
4159 This is used for both the 32-bit and the 64-bit ABI. */
4160
4161void
4162_bfd_mips_elf_symbol_processing (abfd, asym)
4163 bfd *abfd;
4164 asymbol *asym;
4165{
4166 elf_symbol_type *elfsym;
4167
4168 elfsym = (elf_symbol_type *) asym;
4169 switch (elfsym->internal_elf_sym.st_shndx)
4170 {
4171 case SHN_MIPS_ACOMMON:
4172 /* This section is used in a dynamically linked executable file.
4173 It is an allocated common section. The dynamic linker can
4174 either resolve these symbols to something in a shared
4175 library, or it can just leave them here. For our purposes,
4176 we can consider these symbols to be in a new section. */
4177 if (mips_elf_acom_section.name == NULL)
4178 {
4179 /* Initialize the acommon section. */
4180 mips_elf_acom_section.name = ".acommon";
4181 mips_elf_acom_section.flags = SEC_ALLOC;
4182 mips_elf_acom_section.output_section = &mips_elf_acom_section;
4183 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
4184 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
4185 mips_elf_acom_symbol.name = ".acommon";
4186 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
4187 mips_elf_acom_symbol.section = &mips_elf_acom_section;
4188 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
4189 }
4190 asym->section = &mips_elf_acom_section;
4191 break;
4192
4193 case SHN_COMMON:
4194 /* Common symbols less than the GP size are automatically
4195 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4196 if (asym->value > elf_gp_size (abfd)
4197 || IRIX_COMPAT (abfd) == ict_irix6)
4198 break;
4199 /* Fall through. */
4200 case SHN_MIPS_SCOMMON:
4201 if (mips_elf_scom_section.name == NULL)
4202 {
4203 /* Initialize the small common section. */
4204 mips_elf_scom_section.name = ".scommon";
4205 mips_elf_scom_section.flags = SEC_IS_COMMON;
4206 mips_elf_scom_section.output_section = &mips_elf_scom_section;
4207 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
4208 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
4209 mips_elf_scom_symbol.name = ".scommon";
4210 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
4211 mips_elf_scom_symbol.section = &mips_elf_scom_section;
4212 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
4213 }
4214 asym->section = &mips_elf_scom_section;
4215 asym->value = elfsym->internal_elf_sym.st_size;
4216 break;
4217
4218 case SHN_MIPS_SUNDEFINED:
4219 asym->section = bfd_und_section_ptr;
4220 break;
4221
4222#if 0 /* for SGI_COMPAT */
4223 case SHN_MIPS_TEXT:
4224 asym->section = mips_elf_text_section_ptr;
4225 break;
4226
4227 case SHN_MIPS_DATA:
4228 asym->section = mips_elf_data_section_ptr;
4229 break;
4230#endif
4231 }
4232}
4233\f
4234/* Work over a section just before writing it out. This routine is
4235 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4236 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4237 a better way. */
4238
b34976b6 4239bfd_boolean
b49e97c9
TS		 4240_bfd_mips_elf_section_processing (abfd, hdr)
4241 bfd *abfd;
4242 Elf_Internal_Shdr *hdr;
4243{
4244 if (hdr->sh_type == SHT_MIPS_REGINFO
4245 && hdr->sh_size > 0)
4246 {
4247 bfd_byte buf[4];
4248
4249 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
4250 BFD_ASSERT (hdr->contents == NULL);
4251
4252 if (bfd_seek (abfd,
4253 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
4254 SEEK_SET) != 0)
b34976b6 4255 return FALSE;
b49e97c9
TS		 4256 H_PUT_32 (abfd, elf_gp (abfd), buf);
4257 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
b34976b6 4258 return FALSE;
b49e97c9
TS		 4259 }
4260
4261 if (hdr->sh_type == SHT_MIPS_OPTIONS
4262 && hdr->bfd_section != NULL
f0abc2a1
AM		 4263 && mips_elf_section_data (hdr->bfd_section) != NULL
4264 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
b49e97c9
TS		 4265 {
4266 bfd_byte *contents, *l, *lend;
4267
f0abc2a1
AM		 4268 /* We stored the section contents in the tdata field in the
4269 set_section_contents routine. We save the section contents
4270 so that we don't have to read them again.
b49e97c9
TS		 4271 At this point we know that elf_gp is set, so we can look
4272 through the section contents to see if there is an
4273 ODK_REGINFO structure. */
4274
f0abc2a1 4275 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
b49e97c9
TS		 4276 l = contents;
4277 lend = contents + hdr->sh_size;
4278 while (l + sizeof (Elf_External_Options) <= lend)
4279 {
4280 Elf_Internal_Options intopt;
4281
4282 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
4283 &intopt);
4284 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
4285 {
4286 bfd_byte buf[8];
4287
4288 if (bfd_seek (abfd,
4289 (hdr->sh_offset
4290 + (l - contents)
4291 + sizeof (Elf_External_Options)
4292 + (sizeof (Elf64_External_RegInfo) - 8)),
4293 SEEK_SET) != 0)
b34976b6 4294 return FALSE;
b49e97c9
TS		 4295 H_PUT_64 (abfd, elf_gp (abfd), buf);
4296 if (bfd_bwrite (buf, (bfd_size_type) 8, abfd) != 8)
b34976b6 4297 return FALSE;
b49e97c9
TS		 4298 }
4299 else if (intopt.kind == ODK_REGINFO)
4300 {
4301 bfd_byte buf[4];
4302
4303 if (bfd_seek (abfd,
4304 (hdr->sh_offset
4305 + (l - contents)
4306 + sizeof (Elf_External_Options)
4307 + (sizeof (Elf32_External_RegInfo) - 4)),
4308 SEEK_SET) != 0)
b34976b6 4309 return FALSE;
b49e97c9
TS		 4310 H_PUT_32 (abfd, elf_gp (abfd), buf);
4311 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
b34976b6 4312 return FALSE;
b49e97c9
TS		 4313 }
4314 l += intopt.size;
4315 }
4316 }
4317
4318 if (hdr->bfd_section != NULL)
4319 {
4320 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
4321
4322 if (strcmp (name, ".sdata") == 0
4323 || strcmp (name, ".lit8") == 0
4324 || strcmp (name, ".lit4") == 0)
4325 {
4326 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4327 hdr->sh_type = SHT_PROGBITS;
4328 }
4329 else if (strcmp (name, ".sbss") == 0)
4330 {
4331 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4332 hdr->sh_type = SHT_NOBITS;
4333 }
4334 else if (strcmp (name, ".srdata") == 0)
4335 {
4336 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
4337 hdr->sh_type = SHT_PROGBITS;
4338 }
4339 else if (strcmp (name, ".compact_rel") == 0)
4340 {
4341 hdr->sh_flags = 0;
4342 hdr->sh_type = SHT_PROGBITS;
4343 }
4344 else if (strcmp (name, ".rtproc") == 0)
4345 {
4346 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
4347 {
4348 unsigned int adjust;
4349
4350 adjust = hdr->sh_size % hdr->sh_addralign;
4351 if (adjust != 0)
4352 hdr->sh_size += hdr->sh_addralign - adjust;
4353 }
4354 }
4355 }
4356
b34976b6 4357 return TRUE;
b49e97c9
TS		 4358}
4359
4360/* Handle a MIPS specific section when reading an object file. This
4361 is called when elfcode.h finds a section with an unknown type.
4362 This routine supports both the 32-bit and 64-bit ELF ABI.
4363
4364 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4365 how to. */
4366
b34976b6 4367bfd_boolean
b49e97c9
TS		 4368_bfd_mips_elf_section_from_shdr (abfd, hdr, name)
4369 bfd *abfd;
4370 Elf_Internal_Shdr *hdr;
90937f86 4371 const char *name;
b49e97c9
TS		 4372{
4373 flagword flags = 0;
4374
4375 /* There ought to be a place to keep ELF backend specific flags, but
4376 at the moment there isn't one. We just keep track of the
4377 sections by their name, instead. Fortunately, the ABI gives
4378 suggested names for all the MIPS specific sections, so we will
4379 probably get away with this. */
4380 switch (hdr->sh_type)
4381 {
4382 case SHT_MIPS_LIBLIST:
4383 if (strcmp (name, ".liblist") != 0)
b34976b6 4384 return FALSE;
b49e97c9
TS		 4385 break;
4386 case SHT_MIPS_MSYM:
4387 if (strcmp (name, ".msym") != 0)
b34976b6 4388 return FALSE;
b49e97c9
TS		 4389 break;
4390 case SHT_MIPS_CONFLICT:
4391 if (strcmp (name, ".conflict") != 0)
b34976b6 4392 return FALSE;
b49e97c9
TS		 4393 break;
4394 case SHT_MIPS_GPTAB:
4395 if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0)
b34976b6 4396 return FALSE;
b49e97c9
TS		 4397 break;
4398 case SHT_MIPS_UCODE:
4399 if (strcmp (name, ".ucode") != 0)
b34976b6 4400 return FALSE;
b49e97c9
TS		 4401 break;
4402 case SHT_MIPS_DEBUG:
4403 if (strcmp (name, ".mdebug") != 0)
b34976b6 4404 return FALSE;
b49e97c9
TS		 4405 flags = SEC_DEBUGGING;
4406 break;
4407 case SHT_MIPS_REGINFO:
4408 if (strcmp (name, ".reginfo") != 0
4409 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
b34976b6 4410 return FALSE;
b49e97c9
TS		 4411 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
4412 break;
4413 case SHT_MIPS_IFACE:
4414 if (strcmp (name, ".MIPS.interfaces") != 0)
b34976b6 4415 return FALSE;
b49e97c9
TS		 4416 break;
4417 case SHT_MIPS_CONTENT:
4418 if (strncmp (name, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
b34976b6 4419 return FALSE;
b49e97c9
TS		 4420 break;
4421 case SHT_MIPS_OPTIONS:
4422 if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) != 0)
b34976b6 4423 return FALSE;
b49e97c9
TS		 4424 break;
4425 case SHT_MIPS_DWARF:
4426 if (strncmp (name, ".debug_", sizeof ".debug_" - 1) != 0)
b34976b6 4427 return FALSE;
b49e97c9
TS		 4428 break;
4429 case SHT_MIPS_SYMBOL_LIB:
4430 if (strcmp (name, ".MIPS.symlib") != 0)
b34976b6 4431 return FALSE;
b49e97c9
TS		 4432 break;
4433 case SHT_MIPS_EVENTS:
4434 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4435 && strncmp (name, ".MIPS.post_rel",
4436 sizeof ".MIPS.post_rel" - 1) != 0)
b34976b6 4437 return FALSE;
b49e97c9
TS		 4438 break;
4439 default:
b34976b6 4440 return FALSE;
b49e97c9
TS		 4441 }
4442
4443 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
b34976b6 4444 return FALSE;
b49e97c9
TS		 4445
4446 if (flags)
4447 {
4448 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
4449 (bfd_get_section_flags (abfd,
4450 hdr->bfd_section)
4451 | flags)))
b34976b6 4452 return FALSE;
b49e97c9
TS		 4453 }
4454
4455 /* FIXME: We should record sh_info for a .gptab section. */
4456
4457 /* For a .reginfo section, set the gp value in the tdata information
4458 from the contents of this section. We need the gp value while
4459 processing relocs, so we just get it now. The .reginfo section
4460 is not used in the 64-bit MIPS ELF ABI. */
4461 if (hdr->sh_type == SHT_MIPS_REGINFO)
4462 {
4463 Elf32_External_RegInfo ext;
4464 Elf32_RegInfo s;
4465
4466 if (! bfd_get_section_contents (abfd, hdr->bfd_section, (PTR) &ext,
4467 (file_ptr) 0,
4468 (bfd_size_type) sizeof ext))
b34976b6 4469 return FALSE;
b49e97c9
TS		 4470 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
4471 elf_gp (abfd) = s.ri_gp_value;
4472 }
4473
4474 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4475 set the gp value based on what we find. We may see both
4476 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4477 they should agree. */
4478 if (hdr->sh_type == SHT_MIPS_OPTIONS)
4479 {
4480 bfd_byte *contents, *l, *lend;
4481
4482 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4483 if (contents == NULL)
b34976b6 4484 return FALSE;
b49e97c9
TS		 4485 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
4486 (file_ptr) 0, hdr->sh_size))
4487 {
4488 free (contents);
b34976b6 4489 return FALSE;
b49e97c9
TS		 4490 }
4491 l = contents;
4492 lend = contents + hdr->sh_size;
4493 while (l + sizeof (Elf_External_Options) <= lend)
4494 {
4495 Elf_Internal_Options intopt;
4496
4497 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
4498 &intopt);
4499 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
4500 {
4501 Elf64_Internal_RegInfo intreg;
4502
4503 bfd_mips_elf64_swap_reginfo_in
4504 (abfd,
4505 ((Elf64_External_RegInfo *)
4506 (l + sizeof (Elf_External_Options))),
4507 &intreg);
4508 elf_gp (abfd) = intreg.ri_gp_value;
4509 }
4510 else if (intopt.kind == ODK_REGINFO)
4511 {
4512 Elf32_RegInfo intreg;
4513
4514 bfd_mips_elf32_swap_reginfo_in
4515 (abfd,
4516 ((Elf32_External_RegInfo *)
4517 (l + sizeof (Elf_External_Options))),
4518 &intreg);
4519 elf_gp (abfd) = intreg.ri_gp_value;
4520 }
4521 l += intopt.size;
4522 }
4523 free (contents);
4524 }
4525
b34976b6 4526 return TRUE;
b49e97c9
TS		 4527}
4528
4529/* Set the correct type for a MIPS ELF section. We do this by the
4530 section name, which is a hack, but ought to work. This routine is
4531 used by both the 32-bit and the 64-bit ABI. */
4532
b34976b6 4533bfd_boolean
b49e97c9
TS		 4534_bfd_mips_elf_fake_sections (abfd, hdr, sec)
4535 bfd *abfd;
947216bf 4536 Elf_Internal_Shdr *hdr;
b49e97c9
TS		 4537 asection *sec;
4538{
4539 register const char *name;
4540
4541 name = bfd_get_section_name (abfd, sec);
4542
4543 if (strcmp (name, ".liblist") == 0)
4544 {
4545 hdr->sh_type = SHT_MIPS_LIBLIST;
4546 hdr->sh_info = sec->_raw_size / sizeof (Elf32_Lib);
4547 /* The sh_link field is set in final_write_processing. */
4548 }
4549 else if (strcmp (name, ".conflict") == 0)
4550 hdr->sh_type = SHT_MIPS_CONFLICT;
4551 else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0)
4552 {
4553 hdr->sh_type = SHT_MIPS_GPTAB;
4554 hdr->sh_entsize = sizeof (Elf32_External_gptab);
4555 /* The sh_info field is set in final_write_processing. */
4556 }
4557 else if (strcmp (name, ".ucode") == 0)
4558 hdr->sh_type = SHT_MIPS_UCODE;
4559 else if (strcmp (name, ".mdebug") == 0)
4560 {
4561 hdr->sh_type = SHT_MIPS_DEBUG;
8dc1a139 4562 /* In a shared object on IRIX 5.3, the .mdebug section has an
b49e97c9
TS		 4563 entsize of 0. FIXME: Does this matter? */
4564 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
4565 hdr->sh_entsize = 0;
4566 else
4567 hdr->sh_entsize = 1;
4568 }
4569 else if (strcmp (name, ".reginfo") == 0)
4570 {
4571 hdr->sh_type = SHT_MIPS_REGINFO;
8dc1a139 4572 /* In a shared object on IRIX 5.3, the .reginfo section has an
b49e97c9
TS		 4573 entsize of 0x18. FIXME: Does this matter? */
4574 if (SGI_COMPAT (abfd))
4575 {
4576 if ((abfd->flags & DYNAMIC) != 0)
4577 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
4578 else
4579 hdr->sh_entsize = 1;
4580 }
4581 else
4582 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
4583 }
4584 else if (SGI_COMPAT (abfd)
4585 && (strcmp (name, ".hash") == 0
4586 || strcmp (name, ".dynamic") == 0
4587 || strcmp (name, ".dynstr") == 0))
4588 {
4589 if (SGI_COMPAT (abfd))
4590 hdr->sh_entsize = 0;
4591#if 0
8dc1a139 4592 /* This isn't how the IRIX6 linker behaves. */
b49e97c9
TS		 4593 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
4594#endif
4595 }
4596 else if (strcmp (name, ".got") == 0
4597 || strcmp (name, ".srdata") == 0
4598 || strcmp (name, ".sdata") == 0
4599 || strcmp (name, ".sbss") == 0
4600 || strcmp (name, ".lit4") == 0
4601 || strcmp (name, ".lit8") == 0)
4602 hdr->sh_flags |= SHF_MIPS_GPREL;
4603 else if (strcmp (name, ".MIPS.interfaces") == 0)
4604 {
4605 hdr->sh_type = SHT_MIPS_IFACE;
4606 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4607 }
4608 else if (strncmp (name, ".MIPS.content", strlen (".MIPS.content")) == 0)
4609 {
4610 hdr->sh_type = SHT_MIPS_CONTENT;
4611 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4612 /* The sh_info field is set in final_write_processing. */
4613 }
4614 else if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
4615 {
4616 hdr->sh_type = SHT_MIPS_OPTIONS;
4617 hdr->sh_entsize = 1;
4618 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4619 }
4620 else if (strncmp (name, ".debug_", sizeof ".debug_" - 1) == 0)
4621 hdr->sh_type = SHT_MIPS_DWARF;
4622 else if (strcmp (name, ".MIPS.symlib") == 0)
4623 {
4624 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
4625 /* The sh_link and sh_info fields are set in
4626 final_write_processing. */
4627 }
4628 else if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4629 || strncmp (name, ".MIPS.post_rel",
4630 sizeof ".MIPS.post_rel" - 1) == 0)
4631 {
4632 hdr->sh_type = SHT_MIPS_EVENTS;
4633 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4634 /* The sh_link field is set in final_write_processing. */
4635 }
4636 else if (strcmp (name, ".msym") == 0)
4637 {
4638 hdr->sh_type = SHT_MIPS_MSYM;
4639 hdr->sh_flags |= SHF_ALLOC;
4640 hdr->sh_entsize = 8;
4641 }
4642
4643 /* The generic elf_fake_sections will set up REL_HDR using the
4644 default kind of relocations. But, we may actually need both
4645 kinds of relocations, so we set up the second header here.
4646
4647 This is not necessary for the O32 ABI since that only uses Elf32_Rel
4648 relocations (cf. System V ABI, MIPS RISC Processor Supplement,
4649 3rd Edition, p. 4-17). It breaks the IRIX 5/6 32-bit ld, since one
4650 of the resulting empty .rela.<section> sections starts with
4651 sh_offset == object size, and ld doesn't allow that. While the check
4652 is arguably bogus for empty or SHT_NOBITS sections, it can easily be
4653 avoided by not emitting those useless sections in the first place. */
14366460 4654 if (! SGI_COMPAT (abfd) && ! NEWABI_P(abfd)
4a14403c 4655 && (sec->flags & SEC_RELOC) != 0)
b49e97c9
TS		 4656 {
4657 struct bfd_elf_section_data *esd;
4658 bfd_size_type amt = sizeof (Elf_Internal_Shdr);
4659
4660 esd = elf_section_data (sec);
4661 BFD_ASSERT (esd->rel_hdr2 == NULL);
4662 esd->rel_hdr2 = (Elf_Internal_Shdr *) bfd_zalloc (abfd, amt);
4663 if (!esd->rel_hdr2)
b34976b6 4664 return FALSE;
68bfbfcc 4665 _bfd_elf_init_reloc_shdr (abfd, esd->rel_hdr2, sec, !sec->use_rela_p);
b49e97c9
TS		 4666 }
4667
b34976b6 4668 return TRUE;
b49e97c9
TS		 4669}
4670
4671/* Given a BFD section, try to locate the corresponding ELF section
4672 index. This is used by both the 32-bit and the 64-bit ABI.
4673 Actually, it's not clear to me that the 64-bit ABI supports these,
4674 but for non-PIC objects we will certainly want support for at least
4675 the .scommon section. */
4676
b34976b6 4677bfd_boolean
b49e97c9
TS		 4678_bfd_mips_elf_section_from_bfd_section (abfd, sec, retval)
4679 bfd *abfd ATTRIBUTE_UNUSED;
4680 asection *sec;
4681 int *retval;
4682{
4683 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
4684 {
4685 *retval = SHN_MIPS_SCOMMON;
b34976b6 4686 return TRUE;
b49e97c9
TS		 4687 }
4688 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
4689 {
4690 *retval = SHN_MIPS_ACOMMON;
b34976b6 4691 return TRUE;
b49e97c9 4692 }
b34976b6 4693 return FALSE;
b49e97c9
TS		 4694}
4695\f
4696/* Hook called by the linker routine which adds symbols from an object
4697 file. We must handle the special MIPS section numbers here. */
4698
b34976b6 4699bfd_boolean
b49e97c9
TS		 4700_bfd_mips_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4701 bfd *abfd;
4702 struct bfd_link_info *info;
4703 const Elf_Internal_Sym *sym;
4704 const char **namep;
4705 flagword *flagsp ATTRIBUTE_UNUSED;
4706 asection **secp;
4707 bfd_vma *valp;
4708{
4709 if (SGI_COMPAT (abfd)
4710 && (abfd->flags & DYNAMIC) != 0
4711 && strcmp (*namep, "_rld_new_interface") == 0)
4712 {
8dc1a139 4713 /* Skip IRIX5 rld entry name. */
b49e97c9 4714 *namep = NULL;
b34976b6 4715 return TRUE;
b49e97c9
TS		 4716 }
4717
4718 switch (sym->st_shndx)
4719 {
4720 case SHN_COMMON:
4721 /* Common symbols less than the GP size are automatically
4722 treated as SHN_MIPS_SCOMMON symbols. */
4723 if (sym->st_size > elf_gp_size (abfd)
4724 || IRIX_COMPAT (abfd) == ict_irix6)
4725 break;
4726 /* Fall through. */
4727 case SHN_MIPS_SCOMMON:
4728 *secp = bfd_make_section_old_way (abfd, ".scommon");
4729 (*secp)->flags |= SEC_IS_COMMON;
4730 *valp = sym->st_size;
4731 break;
4732
4733 case SHN_MIPS_TEXT:
4734 /* This section is used in a shared object. */
4735 if (elf_tdata (abfd)->elf_text_section == NULL)
4736 {
4737 asymbol *elf_text_symbol;
4738 asection *elf_text_section;
4739 bfd_size_type amt = sizeof (asection);
4740
4741 elf_text_section = bfd_zalloc (abfd, amt);
4742 if (elf_text_section == NULL)
b34976b6 4743 return FALSE;
b49e97c9
TS		 4744
4745 amt = sizeof (asymbol);
4746 elf_text_symbol = bfd_zalloc (abfd, amt);
4747 if (elf_text_symbol == NULL)
b34976b6 4748 return FALSE;
b49e97c9
TS		 4749
4750 /* Initialize the section. */
4751
4752 elf_tdata (abfd)->elf_text_section = elf_text_section;
4753 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
4754
4755 elf_text_section->symbol = elf_text_symbol;
4756 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
4757
4758 elf_text_section->name = ".text";
4759 elf_text_section->flags = SEC_NO_FLAGS;
4760 elf_text_section->output_section = NULL;
4761 elf_text_section->owner = abfd;
4762 elf_text_symbol->name = ".text";
4763 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4764 elf_text_symbol->section = elf_text_section;
4765 }
4766 /* This code used to do *secp = bfd_und_section_ptr if
4767 info->shared. I don't know why, and that doesn't make sense,
4768 so I took it out. */
4769 *secp = elf_tdata (abfd)->elf_text_section;
4770 break;
4771
4772 case SHN_MIPS_ACOMMON:
4773 /* Fall through. XXX Can we treat this as allocated data? */
4774 case SHN_MIPS_DATA:
4775 /* This section is used in a shared object. */
4776 if (elf_tdata (abfd)->elf_data_section == NULL)
4777 {
4778 asymbol *elf_data_symbol;
4779 asection *elf_data_section;
4780 bfd_size_type amt = sizeof (asection);
4781
4782 elf_data_section = bfd_zalloc (abfd, amt);
4783 if (elf_data_section == NULL)
b34976b6 4784 return FALSE;
b49e97c9
TS		 4785
4786 amt = sizeof (asymbol);
4787 elf_data_symbol = bfd_zalloc (abfd, amt);
4788 if (elf_data_symbol == NULL)
b34976b6 4789 return FALSE;
b49e97c9
TS		 4790
4791 /* Initialize the section. */
4792
4793 elf_tdata (abfd)->elf_data_section = elf_data_section;
4794 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
4795
4796 elf_data_section->symbol = elf_data_symbol;
4797 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
4798
4799 elf_data_section->name = ".data";
4800 elf_data_section->flags = SEC_NO_FLAGS;
4801 elf_data_section->output_section = NULL;
4802 elf_data_section->owner = abfd;
4803 elf_data_symbol->name = ".data";
4804 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4805 elf_data_symbol->section = elf_data_section;
4806 }
4807 /* This code used to do *secp = bfd_und_section_ptr if
4808 info->shared. I don't know why, and that doesn't make sense,
4809 so I took it out. */
4810 *secp = elf_tdata (abfd)->elf_data_section;
4811 break;
4812
4813 case SHN_MIPS_SUNDEFINED:
4814 *secp = bfd_und_section_ptr;
4815 break;
4816 }
4817
4818 if (SGI_COMPAT (abfd)
4819 && ! info->shared
4820 && info->hash->creator == abfd->xvec
4821 && strcmp (*namep, "__rld_obj_head") == 0)
4822 {
4823 struct elf_link_hash_entry *h;
14a793b2 4824 struct bfd_link_hash_entry *bh;
b49e97c9
TS		 4825
4826 /* Mark __rld_obj_head as dynamic. */
14a793b2 4827 bh = NULL;
b49e97c9
TS		 4828 if (! (_bfd_generic_link_add_one_symbol
4829 (info, abfd, *namep, BSF_GLOBAL, *secp,
b34976b6 4830 (bfd_vma) *valp, (const char *) NULL, FALSE,
14a793b2 4831 get_elf_backend_data (abfd)->collect, &bh)))
b34976b6 4832 return FALSE;
14a793b2
AM		 4833
4834 h = (struct elf_link_hash_entry *) bh;
b49e97c9
TS		 4835 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4836 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4837 h->type = STT_OBJECT;
4838
4839 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 4840 return FALSE;
b49e97c9 4841
b34976b6 4842 mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
b49e97c9
TS		 4843 }
4844
4845 /* If this is a mips16 text symbol, add 1 to the value to make it
4846 odd. This will cause something like .word SYM to come up with
4847 the right value when it is loaded into the PC. */
4848 if (sym->st_other == STO_MIPS16)
4849 ++*valp;
4850
b34976b6 4851 return TRUE;
b49e97c9
TS		 4852}
4853
4854/* This hook function is called before the linker writes out a global
4855 symbol. We mark symbols as small common if appropriate. This is
4856 also where we undo the increment of the value for a mips16 symbol. */
4857
b34976b6 4858bfd_boolean
b49e97c9
TS		 4859_bfd_mips_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
4860 bfd *abfd ATTRIBUTE_UNUSED;
4861 struct bfd_link_info *info ATTRIBUTE_UNUSED;
4862 const char *name ATTRIBUTE_UNUSED;
4863 Elf_Internal_Sym *sym;
4864 asection *input_sec;
4865{
4866 /* If we see a common symbol, which implies a relocatable link, then
4867 if a symbol was small common in an input file, mark it as small
4868 common in the output file. */
4869 if (sym->st_shndx == SHN_COMMON
4870 && strcmp (input_sec->name, ".scommon") == 0)
4871 sym->st_shndx = SHN_MIPS_SCOMMON;
4872
4873 if (sym->st_other == STO_MIPS16
4874 && (sym->st_value & 1) != 0)
4875 --sym->st_value;
4876
b34976b6 4877 return TRUE;
b49e97c9
TS		 4878}
4879\f
4880/* Functions for the dynamic linker. */
4881
4882/* Create dynamic sections when linking against a dynamic object. */
4883
b34976b6 4884bfd_boolean
b49e97c9
TS		 4885_bfd_mips_elf_create_dynamic_sections (abfd, info)
4886 bfd *abfd;
4887 struct bfd_link_info *info;
4888{
4889 struct elf_link_hash_entry *h;
14a793b2 4890 struct bfd_link_hash_entry *bh;
b49e97c9
TS		 4891 flagword flags;
4892 register asection *s;
4893 const char * const *namep;
4894
4895 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4896 | SEC_LINKER_CREATED | SEC_READONLY);
4897
4898 /* Mips ABI requests the .dynamic section to be read only. */
4899 s = bfd_get_section_by_name (abfd, ".dynamic");
4900 if (s != NULL)
4901 {
4902 if (! bfd_set_section_flags (abfd, s, flags))
b34976b6 4903 return FALSE;
b49e97c9
TS		 4904 }
4905
4906 /* We need to create .got section. */
f4416af6
AO		 4907 if (! mips_elf_create_got_section (abfd, info, FALSE))
4908 return FALSE;
4909
4910 if (! mips_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
b34976b6 4911 return FALSE;
b49e97c9
TS		 4912
4913 /* Create the .msym section on IRIX6. It is used by the dynamic
4914 linker to speed up dynamic relocations, and to avoid computing
4915 the ELF hash for symbols. */
4916 if (IRIX_COMPAT (abfd) == ict_irix6
4917 && !mips_elf_create_msym_section (abfd))
b34976b6 4918 return FALSE;
b49e97c9
TS		 4919
4920 /* Create .stub section. */
4921 if (bfd_get_section_by_name (abfd,
4922 MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
4923 {
4924 s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
4925 if (s == NULL
4926 || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
4927 || ! bfd_set_section_alignment (abfd, s,
4928 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
b34976b6 4929 return FALSE;
b49e97c9
TS		 4930 }
4931
4932 if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
4933 && !info->shared
4934 && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
4935 {
4936 s = bfd_make_section (abfd, ".rld_map");
4937 if (s == NULL
4938 || ! bfd_set_section_flags (abfd, s, flags &~ (flagword) SEC_READONLY)
4939 || ! bfd_set_section_alignment (abfd, s,
4940 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
b34976b6 4941 return FALSE;
b49e97c9
TS		 4942 }
4943
4944 /* On IRIX5, we adjust add some additional symbols and change the
4945 alignments of several sections. There is no ABI documentation
4946 indicating that this is necessary on IRIX6, nor any evidence that
4947 the linker takes such action. */
4948 if (IRIX_COMPAT (abfd) == ict_irix5)
4949 {
4950 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
4951 {
14a793b2 4952 bh = NULL;
b49e97c9
TS		 4953 if (! (_bfd_generic_link_add_one_symbol
4954 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr,
b34976b6 4955 (bfd_vma) 0, (const char *) NULL, FALSE,
14a793b2 4956 get_elf_backend_data (abfd)->collect, &bh)))
b34976b6 4957 return FALSE;
14a793b2
AM		 4958
4959 h = (struct elf_link_hash_entry *) bh;
b49e97c9
TS		 4960 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4961 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4962 h->type = STT_SECTION;
4963
4964 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 4965 return FALSE;
b49e97c9
TS		 4966 }
4967
4968 /* We need to create a .compact_rel section. */
4969 if (SGI_COMPAT (abfd))
4970 {
4971 if (!mips_elf_create_compact_rel_section (abfd, info))
b34976b6 4972 return FALSE;
b49e97c9
TS		 4973 }
4974
44c410de 4975 /* Change alignments of some sections. */
b49e97c9
TS		 4976 s = bfd_get_section_by_name (abfd, ".hash");
4977 if (s != NULL)
4978 bfd_set_section_alignment (abfd, s, 4);
4979 s = bfd_get_section_by_name (abfd, ".dynsym");
4980 if (s != NULL)
4981 bfd_set_section_alignment (abfd, s, 4);
4982 s = bfd_get_section_by_name (abfd, ".dynstr");
4983 if (s != NULL)
4984 bfd_set_section_alignment (abfd, s, 4);
4985 s = bfd_get_section_by_name (abfd, ".reginfo");
4986 if (s != NULL)
4987 bfd_set_section_alignment (abfd, s, 4);
4988 s = bfd_get_section_by_name (abfd, ".dynamic");
4989 if (s != NULL)
4990 bfd_set_section_alignment (abfd, s, 4);
4991 }
4992
4993 if (!info->shared)
4994 {
14a793b2
AM		 4995 const char *name;
4996
4997 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4998 bh = NULL;
4999 if (!(_bfd_generic_link_add_one_symbol
5000 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr,
b34976b6 5001 (bfd_vma) 0, (const char *) NULL, FALSE,
14a793b2 5002 get_elf_backend_data (abfd)->collect, &bh)))
b34976b6 5003 return FALSE;
14a793b2
AM		 5004
5005 h = (struct elf_link_hash_entry *) bh;
b49e97c9
TS		 5006 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
5007 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5008 h->type = STT_SECTION;
5009
5010 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 5011 return FALSE;
b49e97c9
TS		 5012
5013 if (! mips_elf_hash_table (info)->use_rld_obj_head)
5014 {
5015 /* __rld_map is a four byte word located in the .data section
5016 and is filled in by the rtld to contain a pointer to
5017 the _r_debug structure. Its symbol value will be set in
5018 _bfd_mips_elf_finish_dynamic_symbol. */
5019 s = bfd_get_section_by_name (abfd, ".rld_map");
5020 BFD_ASSERT (s != NULL);
5021
14a793b2
AM		 5022 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
5023 bh = NULL;
5024 if (!(_bfd_generic_link_add_one_symbol
5025 (info, abfd, name, BSF_GLOBAL, s,
b34976b6 5026 (bfd_vma) 0, (const char *) NULL, FALSE,
14a793b2 5027 get_elf_backend_data (abfd)->collect, &bh)))
b34976b6 5028 return FALSE;
14a793b2
AM		 5029
5030 h = (struct elf_link_hash_entry *) bh;
b49e97c9
TS		 5031 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
5032 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
5033 h->type = STT_OBJECT;
5034
5035 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 5036 return FALSE;
b49e97c9
TS		 5037 }
5038 }
5039
b34976b6 5040 return TRUE;
b49e97c9
TS		 5041}
5042\f
5043/* Look through the relocs for a section during the first phase, and
5044 allocate space in the global offset table. */
5045
b34976b6 5046bfd_boolean
b49e97c9
TS		 5047_bfd_mips_elf_check_relocs (abfd, info, sec, relocs)
5048 bfd *abfd;
5049 struct bfd_link_info *info;
5050 asection *sec;
5051 const Elf_Internal_Rela *relocs;
5052{
5053 const char *name;
5054 bfd *dynobj;
5055 Elf_Internal_Shdr *symtab_hdr;
5056 struct elf_link_hash_entry **sym_hashes;
5057 struct mips_got_info *g;
5058 size_t extsymoff;
5059 const Elf_Internal_Rela *rel;
5060 const Elf_Internal_Rela *rel_end;
5061 asection *sgot;
5062 asection *sreloc;
5063 struct elf_backend_data *bed;
5064
5065 if (info->relocateable)
b34976b6 5066 return TRUE;
b49e97c9
TS		 5067
5068 dynobj = elf_hash_table (info)->dynobj;
5069 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5070 sym_hashes = elf_sym_hashes (abfd);
5071 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5072
5073 /* Check for the mips16 stub sections. */
5074
5075 name = bfd_get_section_name (abfd, sec);
5076 if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5077 {
5078 unsigned long r_symndx;
5079
5080 /* Look at the relocation information to figure out which symbol
5081 this is for. */
5082
5083 r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5084
5085 if (r_symndx < extsymoff
5086 || sym_hashes[r_symndx - extsymoff] == NULL)
5087 {
5088 asection *o;
5089
5090 /* This stub is for a local symbol. This stub will only be
5091 needed if there is some relocation in this BFD, other
5092 than a 16 bit function call, which refers to this symbol. */
5093 for (o = abfd->sections; o != NULL; o = o->next)
5094 {
5095 Elf_Internal_Rela *sec_relocs;
5096 const Elf_Internal_Rela *r, *rend;
5097
5098 /* We can ignore stub sections when looking for relocs. */
5099 if ((o->flags & SEC_RELOC) == 0
5100 || o->reloc_count == 0
5101 || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5102 sizeof FN_STUB - 1) == 0
5103 || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5104 sizeof CALL_STUB - 1) == 0
5105 || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5106 sizeof CALL_FP_STUB - 1) == 0)
5107 continue;
5108
45d6a902
AM		 5109 sec_relocs
5110 = _bfd_elf_link_read_relocs (abfd, o, (PTR) NULL,
5111 (Elf_Internal_Rela *) NULL,
5112 info->keep_memory);
b49e97c9 5113 if (sec_relocs == NULL)
b34976b6 5114 return FALSE;
b49e97c9
TS		 5115
5116 rend = sec_relocs + o->reloc_count;
5117 for (r = sec_relocs; r < rend; r++)
5118 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
5119 && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26)
5120 break;
5121
6cdc0ccc 5122 if (elf_section_data (o)->relocs != sec_relocs)
b49e97c9
TS		 5123 free (sec_relocs);
5124
5125 if (r < rend)
5126 break;
5127 }
5128
5129 if (o == NULL)
5130 {
5131 /* There is no non-call reloc for this stub, so we do
5132 not need it. Since this function is called before
5133 the linker maps input sections to output sections, we
5134 can easily discard it by setting the SEC_EXCLUDE
5135 flag. */
5136 sec->flags |= SEC_EXCLUDE;
b34976b6 5137 return TRUE;
b49e97c9
TS		 5138 }
5139
5140 /* Record this stub in an array of local symbol stubs for
5141 this BFD. */
5142 if (elf_tdata (abfd)->local_stubs == NULL)
5143 {
5144 unsigned long symcount;
5145 asection **n;
5146 bfd_size_type amt;
5147
5148 if (elf_bad_symtab (abfd))
5149 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5150 else
5151 symcount = symtab_hdr->sh_info;
5152 amt = symcount * sizeof (asection *);
5153 n = (asection **) bfd_zalloc (abfd, amt);
5154 if (n == NULL)
b34976b6 5155 return FALSE;
b49e97c9
TS		 5156 elf_tdata (abfd)->local_stubs = n;
5157 }
5158
5159 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5160
5161 /* We don't need to set mips16_stubs_seen in this case.
5162 That flag is used to see whether we need to look through
5163 the global symbol table for stubs. We don't need to set
5164 it here, because we just have a local stub. */
5165 }
5166 else
5167 {
5168 struct mips_elf_link_hash_entry *h;
5169
5170 h = ((struct mips_elf_link_hash_entry *)
5171 sym_hashes[r_symndx - extsymoff]);
5172
5173 /* H is the symbol this stub is for. */
5174
5175 h->fn_stub = sec;
b34976b6 5176 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
b49e97c9
TS		 5177 }
5178 }
5179 else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5180 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5181 {
5182 unsigned long r_symndx;
5183 struct mips_elf_link_hash_entry *h;
5184 asection **loc;
5185
5186 /* Look at the relocation information to figure out which symbol
5187 this is for. */
5188
5189 r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5190
5191 if (r_symndx < extsymoff
5192 || sym_hashes[r_symndx - extsymoff] == NULL)
5193 {
5194 /* This stub was actually built for a static symbol defined
5195 in the same file. We assume that all static symbols in
5196 mips16 code are themselves mips16, so we can simply
5197 discard this stub. Since this function is called before
5198 the linker maps input sections to output sections, we can
5199 easily discard it by setting the SEC_EXCLUDE flag. */
5200 sec->flags |= SEC_EXCLUDE;
b34976b6 5201 return TRUE;
b49e97c9
TS		 5202 }
5203
5204 h = ((struct mips_elf_link_hash_entry *)
5205 sym_hashes[r_symndx - extsymoff]);
5206
5207 /* H is the symbol this stub is for. */
5208
5209 if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5210 loc = &h->call_fp_stub;
5211 else
5212 loc = &h->call_stub;
5213
5214 /* If we already have an appropriate stub for this function, we
5215 don't need another one, so we can discard this one. Since
5216 this function is called before the linker maps input sections
5217 to output sections, we can easily discard it by setting the
5218 SEC_EXCLUDE flag. We can also discard this section if we
5219 happen to already know that this is a mips16 function; it is
5220 not necessary to check this here, as it is checked later, but
5221 it is slightly faster to check now. */
5222 if (*loc != NULL || h->root.other == STO_MIPS16)
5223 {
5224 sec->flags |= SEC_EXCLUDE;
b34976b6 5225 return TRUE;
b49e97c9
TS		 5226 }
5227
5228 *loc = sec;
b34976b6 5229 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
b49e97c9
TS		 5230 }
5231
5232 if (dynobj == NULL)
5233 {
5234 sgot = NULL;
5235 g = NULL;
5236 }
5237 else
5238 {
f4416af6 5239 sgot = mips_elf_got_section (dynobj, FALSE);
b49e97c9
TS		 5240 if (sgot == NULL)
5241 g = NULL;
5242 else
5243 {
f0abc2a1
AM		 5244 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
5245 g = mips_elf_section_data (sgot)->u.got_info;
b49e97c9
TS		 5246 BFD_ASSERT (g != NULL);
5247 }
5248 }
5249
5250 sreloc = NULL;
5251 bed = get_elf_backend_data (abfd);
5252 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5253 for (rel = relocs; rel < rel_end; ++rel)
5254 {
5255 unsigned long r_symndx;
5256 unsigned int r_type;
5257 struct elf_link_hash_entry *h;
5258
5259 r_symndx = ELF_R_SYM (abfd, rel->r_info);
5260 r_type = ELF_R_TYPE (abfd, rel->r_info);
5261
5262 if (r_symndx < extsymoff)
5263 h = NULL;
5264 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5265 {
5266 (*_bfd_error_handler)
5267 (_("%s: Malformed reloc detected for section %s"),
5268 bfd_archive_filename (abfd), name);
5269 bfd_set_error (bfd_error_bad_value);
b34976b6 5270 return FALSE;
b49e97c9
TS		 5271 }
5272 else
5273 {
5274 h = sym_hashes[r_symndx - extsymoff];
5275
5276 /* This may be an indirect symbol created because of a version. */
5277 if (h != NULL)
5278 {
5279 while (h->root.type == bfd_link_hash_indirect)
5280 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5281 }
5282 }
5283
5284 /* Some relocs require a global offset table. */
5285 if (dynobj == NULL || sgot == NULL)
5286 {
5287 switch (r_type)
5288 {
5289 case R_MIPS_GOT16:
5290 case R_MIPS_CALL16:
5291 case R_MIPS_CALL_HI16:
5292 case R_MIPS_CALL_LO16:
5293 case R_MIPS_GOT_HI16:
5294 case R_MIPS_GOT_LO16:
5295 case R_MIPS_GOT_PAGE:
5296 case R_MIPS_GOT_OFST:
5297 case R_MIPS_GOT_DISP:
5298 if (dynobj == NULL)
5299 elf_hash_table (info)->dynobj = dynobj = abfd;
f4416af6 5300 if (! mips_elf_create_got_section (dynobj, info, FALSE))
b34976b6 5301 return FALSE;
b49e97c9
TS		 5302 g = mips_elf_got_info (dynobj, &sgot);
5303 break;
5304
5305 case R_MIPS_32:
5306 case R_MIPS_REL32:
5307 case R_MIPS_64:
5308 if (dynobj == NULL
5309 && (info->shared || h != NULL)
5310 && (sec->flags & SEC_ALLOC) != 0)
5311 elf_hash_table (info)->dynobj = dynobj = abfd;
5312 break;
5313
5314 default:
5315 break;
5316 }
5317 }
5318
5319 if (!h && (r_type == R_MIPS_CALL_LO16
5320 || r_type == R_MIPS_GOT_LO16
5321 || r_type == R_MIPS_GOT_DISP))
5322 {
5323 /* We may need a local GOT entry for this relocation. We
5324 don't count R_MIPS_GOT_PAGE because we can estimate the
5325 maximum number of pages needed by looking at the size of
5326 the segment. Similar comments apply to R_MIPS_GOT16 and
5327 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5328 R_MIPS_CALL_HI16 because these are always followed by an
b15e6682 5329 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
f4416af6
AO		 5330 if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
5331 rel->r_addend, g))
5332 return FALSE;
b49e97c9
TS		 5333 }
5334
5335 switch (r_type)
5336 {
5337 case R_MIPS_CALL16:
5338 if (h == NULL)
5339 {
5340 (*_bfd_error_handler)
5341 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5342 bfd_archive_filename (abfd), (unsigned long) rel->r_offset);
5343 bfd_set_error (bfd_error_bad_value);
b34976b6 5344 return FALSE;
b49e97c9
TS		 5345 }
5346 /* Fall through. */
5347
5348 case R_MIPS_CALL_HI16:
5349 case R_MIPS_CALL_LO16:
5350 if (h != NULL)
5351 {
5352 /* This symbol requires a global offset table entry. */
f4416af6 5353 if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
b34976b6 5354 return FALSE;
b49e97c9
TS		 5355
5356 /* We need a stub, not a plt entry for the undefined
5357 function. But we record it as if it needs plt. See
5358 elf_adjust_dynamic_symbol in elflink.h. */
5359 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
5360 h->type = STT_FUNC;
5361 }
5362 break;
5363
0fdc1bf1
AO		 5364 case R_MIPS_GOT_PAGE:
5365 /* If this is a global, overridable symbol, GOT_PAGE will
5366 decay to GOT_DISP, so we'll need a GOT entry for it. */
5367 if (h == NULL)
5368 break;
5369 else
5370 {
5371 struct mips_elf_link_hash_entry *hmips =
5372 (struct mips_elf_link_hash_entry *) h;
5373
5374 while (hmips->root.root.type == bfd_link_hash_indirect
5375 || hmips->root.root.type == bfd_link_hash_warning)
5376 hmips = (struct mips_elf_link_hash_entry *)
5377 hmips->root.root.u.i.link;
5378
5379 if ((hmips->root.root.type == bfd_link_hash_defined
5380 || hmips->root.root.type == bfd_link_hash_defweak)
5381 && hmips->root.root.u.def.section
5382 && ! (info->shared && ! info->symbolic
5383 && ! (hmips->root.elf_link_hash_flags
5384 & ELF_LINK_FORCED_LOCAL))
5385 /* If we've encountered any other relocation
5386 referencing the symbol, we'll have marked it as
5387 dynamic, and, even though we might be able to get
5388 rid of the GOT entry should we know for sure all
5389 previous relocations were GOT_PAGE ones, at this
5390 point we can't tell, so just keep using the
5391 symbol as dynamic. This is very important in the
5392 multi-got case, since we don't decide whether to
5393 decay GOT_PAGE to GOT_DISP on a per-GOT basis: if
5394 the symbol is dynamic, we'll need a GOT entry for
5395 every GOT in which the symbol is referenced with
5396 a GOT_PAGE relocation. */
5397 && hmips->root.dynindx == -1)
5398 break;
5399 }
5400 /* Fall through. */
5401
b49e97c9
TS		 5402 case R_MIPS_GOT16:
5403 case R_MIPS_GOT_HI16:
5404 case R_MIPS_GOT_LO16:
5405 case R_MIPS_GOT_DISP:
5406 /* This symbol requires a global offset table entry. */
f4416af6 5407 if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g))
b34976b6 5408 return FALSE;
b49e97c9
TS		 5409 break;
5410
5411 case R_MIPS_32:
5412 case R_MIPS_REL32:
5413 case R_MIPS_64:
5414 if ((info->shared || h != NULL)
5415 && (sec->flags & SEC_ALLOC) != 0)
5416 {
5417 if (sreloc == NULL)
5418 {
f4416af6 5419 sreloc = mips_elf_rel_dyn_section (dynobj, TRUE);
b49e97c9 5420 if (sreloc == NULL)
f4416af6 5421 return FALSE;
b49e97c9
TS		 5422 }
5423#define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5424 if (info->shared)
5425 {
5426 /* When creating a shared object, we must copy these
5427 reloc types into the output file as R_MIPS_REL32
5428 relocs. We make room for this reloc in the
5429 .rel.dyn reloc section. */
5430 mips_elf_allocate_dynamic_relocations (dynobj, 1);
5431 if ((sec->flags & MIPS_READONLY_SECTION)
5432 == MIPS_READONLY_SECTION)
5433 /* We tell the dynamic linker that there are
5434 relocations against the text segment. */
5435 info->flags |= DF_TEXTREL;
5436 }
5437 else
5438 {
5439 struct mips_elf_link_hash_entry *hmips;
5440
5441 /* We only need to copy this reloc if the symbol is
5442 defined in a dynamic object. */
5443 hmips = (struct mips_elf_link_hash_entry *) h;
5444 ++hmips->possibly_dynamic_relocs;
5445 if ((sec->flags & MIPS_READONLY_SECTION)
5446 == MIPS_READONLY_SECTION)
5447 /* We need it to tell the dynamic linker if there
5448 are relocations against the text segment. */
b34976b6 5449 hmips->readonly_reloc = TRUE;
b49e97c9
TS		 5450 }
5451
5452 /* Even though we don't directly need a GOT entry for
5453 this symbol, a symbol must have a dynamic symbol
5454 table index greater that DT_MIPS_GOTSYM if there are
5455 dynamic relocations against it. */
f4416af6
AO		 5456 if (h != NULL)
5457 {
5458 if (dynobj == NULL)
5459 elf_hash_table (info)->dynobj = dynobj = abfd;
5460 if (! mips_elf_create_got_section (dynobj, info, TRUE))
5461 return FALSE;
5462 g = mips_elf_got_info (dynobj, &sgot);
5463 if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5464 return FALSE;
5465 }
b49e97c9
TS		 5466 }
5467
5468 if (SGI_COMPAT (abfd))
5469 mips_elf_hash_table (info)->compact_rel_size +=
5470 sizeof (Elf32_External_crinfo);
5471 break;
5472
5473 case R_MIPS_26:
5474 case R_MIPS_GPREL16:
5475 case R_MIPS_LITERAL:
5476 case R_MIPS_GPREL32:
5477 if (SGI_COMPAT (abfd))
5478 mips_elf_hash_table (info)->compact_rel_size +=
5479 sizeof (Elf32_External_crinfo);
5480 break;
5481
5482 /* This relocation describes the C++ object vtable hierarchy.
5483 Reconstruct it for later use during GC. */
5484 case R_MIPS_GNU_VTINHERIT:
5485 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 5486 return FALSE;
b49e97c9
TS		 5487 break;
5488
5489 /* This relocation describes which C++ vtable entries are actually
5490 used. Record for later use during GC. */
5491 case R_MIPS_GNU_VTENTRY:
5492 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
b34976b6 5493 return FALSE;
b49e97c9
TS		 5494 break;
5495
5496 default:
5497 break;
5498 }
5499
5500 /* We must not create a stub for a symbol that has relocations
5501 related to taking the function's address. */
5502 switch (r_type)
5503 {
5504 default:
5505 if (h != NULL)
5506 {
5507 struct mips_elf_link_hash_entry *mh;
5508
5509 mh = (struct mips_elf_link_hash_entry *) h;
b34976b6 5510 mh->no_fn_stub = TRUE;
b49e97c9
TS		 5511 }
5512 break;
5513 case R_MIPS_CALL16:
5514 case R_MIPS_CALL_HI16:
5515 case R_MIPS_CALL_LO16:
5516 break;
5517 }
5518
5519 /* If this reloc is not a 16 bit call, and it has a global
5520 symbol, then we will need the fn_stub if there is one.
5521 References from a stub section do not count. */
5522 if (h != NULL
5523 && r_type != R_MIPS16_26
5524 && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
5525 sizeof FN_STUB - 1) != 0
5526 && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
5527 sizeof CALL_STUB - 1) != 0
5528 && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
5529 sizeof CALL_FP_STUB - 1) != 0)
5530 {
5531 struct mips_elf_link_hash_entry *mh;
5532
5533 mh = (struct mips_elf_link_hash_entry *) h;
b34976b6 5534 mh->need_fn_stub = TRUE;
b49e97c9
TS		 5535 }
5536 }
5537
b34976b6 5538 return TRUE;
b49e97c9
TS		 5539}
5540\f
d0647110
AO		 5541bfd_boolean
5542_bfd_mips_relax_section (abfd, sec, link_info, again)
5543 bfd *abfd;
5544 asection *sec;
5545 struct bfd_link_info *link_info;
5546 bfd_boolean *again;
5547{
5548 Elf_Internal_Rela *internal_relocs;
5549 Elf_Internal_Rela *irel, *irelend;
5550 Elf_Internal_Shdr *symtab_hdr;
5551 bfd_byte *contents = NULL;
5552 bfd_byte *free_contents = NULL;
5553 size_t extsymoff;
5554 bfd_boolean changed_contents = FALSE;
5555 bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
5556 Elf_Internal_Sym *isymbuf = NULL;
5557
5558 /* We are not currently changing any sizes, so only one pass. */
5559 *again = FALSE;
5560
5561 if (link_info->relocateable)
5562 return TRUE;
5563
45d6a902
AM		 5564 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, (PTR) NULL,
5565 (Elf_Internal_Rela *) NULL,
5566 link_info->keep_memory);
d0647110
AO		 5567 if (internal_relocs == NULL)
5568 return TRUE;
5569
5570 irelend = internal_relocs + sec->reloc_count
5571 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
5572 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5573 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5574
5575 for (irel = internal_relocs; irel < irelend; irel++)
5576 {
5577 bfd_vma symval;
5578 bfd_signed_vma sym_offset;
5579 unsigned int r_type;
5580 unsigned long r_symndx;
5581 asection *sym_sec;
5582 unsigned long instruction;
5583
5584 /* Turn jalr into bgezal, and jr into beq, if they're marked
5585 with a JALR relocation, that indicate where they jump to.
5586 This saves some pipeline bubbles. */
5587 r_type = ELF_R_TYPE (abfd, irel->r_info);
5588 if (r_type != R_MIPS_JALR)
5589 continue;
5590
5591 r_symndx = ELF_R_SYM (abfd, irel->r_info);
5592 /* Compute the address of the jump target. */
5593 if (r_symndx >= extsymoff)
5594 {
5595 struct mips_elf_link_hash_entry *h
5596 = ((struct mips_elf_link_hash_entry *)
5597 elf_sym_hashes (abfd) [r_symndx - extsymoff]);
5598
5599 while (h->root.root.type == bfd_link_hash_indirect
5600 || h->root.root.type == bfd_link_hash_warning)
5601 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5602
5603 /* If a symbol is undefined, or if it may be overridden,
5604 skip it. */
5605 if (! ((h->root.root.type == bfd_link_hash_defined
5606 || h->root.root.type == bfd_link_hash_defweak)
5607 && h->root.root.u.def.section)
5608 || (link_info->shared && ! link_info->symbolic
5609 && ! (h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)))
5610 continue;
5611
5612 sym_sec = h->root.root.u.def.section;
5613 if (sym_sec->output_section)
5614 symval = (h->root.root.u.def.value
5615 + sym_sec->output_section->vma
5616 + sym_sec->output_offset);
5617 else
5618 symval = h->root.root.u.def.value;
5619 }
5620 else
5621 {
5622 Elf_Internal_Sym *isym;
5623
5624 /* Read this BFD's symbols if we haven't done so already. */
5625 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
5626 {
5627 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5628 if (isymbuf == NULL)
5629 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5630 symtab_hdr->sh_info, 0,
5631 NULL, NULL, NULL);
5632 if (isymbuf == NULL)
5633 goto relax_return;
5634 }
5635
5636 isym = isymbuf + r_symndx;
5637 if (isym->st_shndx == SHN_UNDEF)
5638 continue;
5639 else if (isym->st_shndx == SHN_ABS)
5640 sym_sec = bfd_abs_section_ptr;
5641 else if (isym->st_shndx == SHN_COMMON)
5642 sym_sec = bfd_com_section_ptr;
5643 else
5644 sym_sec
5645 = bfd_section_from_elf_index (abfd, isym->st_shndx);
5646 symval = isym->st_value
5647 + sym_sec->output_section->vma
5648 + sym_sec->output_offset;
5649 }
5650
5651 /* Compute branch offset, from delay slot of the jump to the
5652 branch target. */
5653 sym_offset = (symval + irel->r_addend)
5654 - (sec_start + irel->r_offset + 4);
5655
5656 /* Branch offset must be properly aligned. */
5657 if ((sym_offset & 3) != 0)
5658 continue;
5659
5660 sym_offset >>= 2;
5661
5662 /* Check that it's in range. */
5663 if (sym_offset < -0x8000 || sym_offset >= 0x8000)
5664 continue;
5665
5666 /* Get the section contents if we haven't done so already. */
5667 if (contents == NULL)
5668 {
5669 /* Get cached copy if it exists. */
5670 if (elf_section_data (sec)->this_hdr.contents != NULL)
5671 contents = elf_section_data (sec)->this_hdr.contents;
5672 else
5673 {
5674 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
5675 if (contents == NULL)
5676 goto relax_return;
5677
5678 free_contents = contents;
5679 if (! bfd_get_section_contents (abfd, sec, contents,
5680 (file_ptr) 0, sec->_raw_size))
5681 goto relax_return;
5682 }
5683 }
5684
5685 instruction = bfd_get_32 (abfd, contents + irel->r_offset);
5686
5687 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5688 if ((instruction & 0xfc1fffff) == 0x0000f809)
5689 instruction = 0x04110000;
5690 /* If it was jr <reg>, turn it into b <target>. */
5691 else if ((instruction & 0xfc1fffff) == 0x00000008)
5692 instruction = 0x10000000;
5693 else
5694 continue;
5695
5696 instruction |= (sym_offset & 0xffff);
5697 bfd_put_32 (abfd, instruction, contents + irel->r_offset);
5698 changed_contents = TRUE;
5699 }
5700
5701 if (contents != NULL
5702 && elf_section_data (sec)->this_hdr.contents != contents)
5703 {
5704 if (!changed_contents && !link_info->keep_memory)
5705 free (contents);
5706 else
5707 {
5708 /* Cache the section contents for elf_link_input_bfd. */
5709 elf_section_data (sec)->this_hdr.contents = contents;
5710 }
5711 }
5712 return TRUE;
5713
5714 relax_return:
5715 if (free_contents != NULL)
5716 free (free_contents);
5717 return FALSE;
5718}
5719\f
b49e97c9
TS		 5720/* Adjust a symbol defined by a dynamic object and referenced by a
5721 regular object. The current definition is in some section of the
5722 dynamic object, but we're not including those sections. We have to
5723 change the definition to something the rest of the link can
5724 understand. */
5725
b34976b6 5726bfd_boolean
b49e97c9
TS		 5727_bfd_mips_elf_adjust_dynamic_symbol (info, h)
5728 struct bfd_link_info *info;
5729 struct elf_link_hash_entry *h;
5730{
5731 bfd *dynobj;
5732 struct mips_elf_link_hash_entry *hmips;
5733 asection *s;
5734
5735 dynobj = elf_hash_table (info)->dynobj;
5736
5737 /* Make sure we know what is going on here. */
5738 BFD_ASSERT (dynobj != NULL
5739 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
5740 || h->weakdef != NULL
5741 || ((h->elf_link_hash_flags
5742 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5743 && (h->elf_link_hash_flags
5744 & ELF_LINK_HASH_REF_REGULAR) != 0
5745 && (h->elf_link_hash_flags
5746 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
5747
5748 /* If this symbol is defined in a dynamic object, we need to copy
5749 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5750 file. */
5751 hmips = (struct mips_elf_link_hash_entry *) h;
5752 if (! info->relocateable
5753 && hmips->possibly_dynamic_relocs != 0
5754 && (h->root.type == bfd_link_hash_defweak
5755 || (h->elf_link_hash_flags
5756 & ELF_LINK_HASH_DEF_REGULAR) == 0))
5757 {
5758 mips_elf_allocate_dynamic_relocations (dynobj,
5759 hmips->possibly_dynamic_relocs);
5760 if (hmips->readonly_reloc)
5761 /* We tell the dynamic linker that there are relocations
5762 against the text segment. */
5763 info->flags |= DF_TEXTREL;
5764 }
5765
5766 /* For a function, create a stub, if allowed. */
5767 if (! hmips->no_fn_stub
5768 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
5769 {
5770 if (! elf_hash_table (info)->dynamic_sections_created)
b34976b6 5771 return TRUE;
b49e97c9
TS		 5772
5773 /* If this symbol is not defined in a regular file, then set
5774 the symbol to the stub location. This is required to make
5775 function pointers compare as equal between the normal
5776 executable and the shared library. */
5777 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
5778 {
5779 /* We need .stub section. */
5780 s = bfd_get_section_by_name (dynobj,
5781 MIPS_ELF_STUB_SECTION_NAME (dynobj));
5782 BFD_ASSERT (s != NULL);
5783
5784 h->root.u.def.section = s;
5785 h->root.u.def.value = s->_raw_size;
5786
5787 /* XXX Write this stub address somewhere. */
5788 h->plt.offset = s->_raw_size;
5789
5790 /* Make room for this stub code. */
5791 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
5792
5793 /* The last half word of the stub will be filled with the index
5794 of this symbol in .dynsym section. */
b34976b6 5795 return TRUE;
b49e97c9
TS		 5796 }
5797 }
5798 else if ((h->type == STT_FUNC)
5799 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
5800 {
5801 /* This will set the entry for this symbol in the GOT to 0, and
5802 the dynamic linker will take care of this. */
5803 h->root.u.def.value = 0;
b34976b6 5804 return TRUE;
b49e97c9
TS		 5805 }
5806
5807 /* If this is a weak symbol, and there is a real definition, the
5808 processor independent code will have arranged for us to see the
5809 real definition first, and we can just use the same value. */
5810 if (h->weakdef != NULL)
5811 {
5812 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
5813 || h->weakdef->root.type == bfd_link_hash_defweak);
5814 h->root.u.def.section = h->weakdef->root.u.def.section;
5815 h->root.u.def.value = h->weakdef->root.u.def.value;
b34976b6 5816 return TRUE;
b49e97c9
TS		 5817 }
5818
5819 /* This is a reference to a symbol defined by a dynamic object which
5820 is not a function. */
5821
b34976b6 5822 return TRUE;
b49e97c9
TS		 5823}
5824\f
5825/* This function is called after all the input files have been read,
5826 and the input sections have been assigned to output sections. We
5827 check for any mips16 stub sections that we can discard. */
5828
b34976b6 5829bfd_boolean
b49e97c9
TS		 5830_bfd_mips_elf_always_size_sections (output_bfd, info)
5831 bfd *output_bfd;
5832 struct bfd_link_info *info;
5833{
5834 asection *ri;
5835
f4416af6
AO		 5836 bfd *dynobj;
5837 asection *s;
5838 struct mips_got_info *g;
5839 int i;
5840 bfd_size_type loadable_size = 0;
5841 bfd_size_type local_gotno;
5842 bfd *sub;
5843
b49e97c9
TS		 5844 /* The .reginfo section has a fixed size. */
5845 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
5846 if (ri != NULL)
5847 bfd_set_section_size (output_bfd, ri,
5848 (bfd_size_type) sizeof (Elf32_External_RegInfo));
5849
f4416af6
AO		 5850 if (! (info->relocateable
5851 || ! mips_elf_hash_table (info)->mips16_stubs_seen))
5852 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
5853 mips_elf_check_mips16_stubs,
5854 (PTR) NULL);
5855
5856 dynobj = elf_hash_table (info)->dynobj;
5857 if (dynobj == NULL)
5858 /* Relocatable links don't have it. */
5859 return TRUE;
5860
5861 g = mips_elf_got_info (dynobj, &s);
5862 if (s == NULL)
b34976b6 5863 return TRUE;
b49e97c9 5864
f4416af6
AO		 5865 /* Calculate the total loadable size of the output. That
5866 will give us the maximum number of GOT_PAGE entries
5867 required. */
5868 for (sub = info->input_bfds; sub; sub = sub->link_next)
5869 {
5870 asection *subsection;
5871
5872 for (subsection = sub->sections;
5873 subsection;
5874 subsection = subsection->next)
5875 {
5876 if ((subsection->flags & SEC_ALLOC) == 0)
5877 continue;
5878 loadable_size += ((subsection->_raw_size + 0xf)
5879 &~ (bfd_size_type) 0xf);
5880 }
5881 }
5882
5883 /* There has to be a global GOT entry for every symbol with
5884 a dynamic symbol table index of DT_MIPS_GOTSYM or
5885 higher. Therefore, it make sense to put those symbols
5886 that need GOT entries at the end of the symbol table. We
5887 do that here. */
5888 if (! mips_elf_sort_hash_table (info, 1))
5889 return FALSE;
5890
5891 if (g->global_gotsym != NULL)
5892 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
5893 else
5894 /* If there are no global symbols, or none requiring
5895 relocations, then GLOBAL_GOTSYM will be NULL. */
5896 i = 0;
5897
5898 /* In the worst case, we'll get one stub per dynamic symbol, plus
5899 one to account for the dummy entry at the end required by IRIX
5900 rld. */
5901 loadable_size += MIPS_FUNCTION_STUB_SIZE * (i + 1);
5902
5903 /* Assume there are two loadable segments consisting of
5904 contiguous sections. Is 5 enough? */
5905 local_gotno = (loadable_size >> 16) + 5;
5906
5907 g->local_gotno += local_gotno;
5908 s->_raw_size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
5909
5910 g->global_gotno = i;
5911 s->_raw_size += i * MIPS_ELF_GOT_SIZE (output_bfd);
5912
5913 if (s->_raw_size > MIPS_ELF_GOT_MAX_SIZE (output_bfd)
5914 && ! mips_elf_multi_got (output_bfd, info, g, s, local_gotno))
5915 return FALSE;
b49e97c9 5916
b34976b6 5917 return TRUE;
b49e97c9
TS		 5918}
5919
5920/* Set the sizes of the dynamic sections. */
5921
b34976b6 5922bfd_boolean
b49e97c9
TS		 5923_bfd_mips_elf_size_dynamic_sections (output_bfd, info)
5924 bfd *output_bfd;
5925 struct bfd_link_info *info;
5926{
5927 bfd *dynobj;
5928 asection *s;
b34976b6 5929 bfd_boolean reltext;
b49e97c9
TS		 5930
5931 dynobj = elf_hash_table (info)->dynobj;
5932 BFD_ASSERT (dynobj != NULL);
5933
5934 if (elf_hash_table (info)->dynamic_sections_created)
5935 {
5936 /* Set the contents of the .interp section to the interpreter. */
5937 if (! info->shared)
5938 {
5939 s = bfd_get_section_by_name (dynobj, ".interp");
5940 BFD_ASSERT (s != NULL);
5941 s->_raw_size
5942 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
5943 s->contents
5944 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
5945 }
5946 }
5947
5948 /* The check_relocs and adjust_dynamic_symbol entry points have
5949 determined the sizes of the various dynamic sections. Allocate
5950 memory for them. */
b34976b6 5951 reltext = FALSE;
b49e97c9
TS		 5952 for (s = dynobj->sections; s != NULL; s = s->next)
5953 {
5954 const char *name;
b34976b6 5955 bfd_boolean strip;
b49e97c9
TS		 5956
5957 /* It's OK to base decisions on the section name, because none
5958 of the dynobj section names depend upon the input files. */
5959 name = bfd_get_section_name (dynobj, s);
5960
5961 if ((s->flags & SEC_LINKER_CREATED) == 0)
5962 continue;
5963
b34976b6 5964 strip = FALSE;
b49e97c9
TS		 5965
5966 if (strncmp (name, ".rel", 4) == 0)
5967 {
5968 if (s->_raw_size == 0)
5969 {
5970 /* We only strip the section if the output section name
5971 has the same name. Otherwise, there might be several
5972 input sections for this output section. FIXME: This
5973 code is probably not needed these days anyhow, since
5974 the linker now does not create empty output sections. */
5975 if (s->output_section != NULL
5976 && strcmp (name,
5977 bfd_get_section_name (s->output_section->owner,
5978 s->output_section)) == 0)
b34976b6 5979 strip = TRUE;
b49e97c9
TS		 5980 }
5981 else
5982 {
5983 const char *outname;
5984 asection *target;
5985
5986 /* If this relocation section applies to a read only
5987 section, then we probably need a DT_TEXTREL entry.
5988 If the relocation section is .rel.dyn, we always
5989 assert a DT_TEXTREL entry rather than testing whether
5990 there exists a relocation to a read only section or
5991 not. */
5992 outname = bfd_get_section_name (output_bfd,
5993 s->output_section);
5994 target = bfd_get_section_by_name (output_bfd, outname + 4);
5995 if ((target != NULL
5996 && (target->flags & SEC_READONLY) != 0
5997 && (target->flags & SEC_ALLOC) != 0)
5998 || strcmp (outname, ".rel.dyn") == 0)
b34976b6 5999 reltext = TRUE;
b49e97c9
TS		 6000
6001 /* We use the reloc_count field as a counter if we need
6002 to copy relocs into the output file. */
6003 if (strcmp (name, ".rel.dyn") != 0)
6004 s->reloc_count = 0;
f4416af6
AO		 6005
6006 /* If combreloc is enabled, elf_link_sort_relocs() will
6007 sort relocations, but in a different way than we do,
6008 and before we're done creating relocations. Also, it
6009 will move them around between input sections'
6010 relocation's contents, so our sorting would be
6011 broken, so don't let it run. */
6012 info->combreloc = 0;
b49e97c9
TS		 6013 }
6014 }
6015 else if (strncmp (name, ".got", 4) == 0)
6016 {
f4416af6
AO		 6017 /* _bfd_mips_elf_always_size_sections() has already done
6018 most of the work, but some symbols may have been mapped
6019 to versions that we must now resolve in the got_entries
6020 hash tables. */
6021 struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL);
6022 struct mips_got_info *g = gg;
6023 struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
6024 unsigned int needed_relocs = 0;
6025
6026 if (gg->next)
b49e97c9 6027 {
f4416af6
AO		 6028 set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd);
6029 set_got_offset_arg.info = info;
b49e97c9 6030
f4416af6
AO		 6031 mips_elf_resolve_final_got_entries (gg);
6032 for (g = gg->next; g && g->next != gg; g = g->next)
b49e97c9 6033 {
f4416af6
AO		 6034 unsigned int save_assign;
6035
6036 mips_elf_resolve_final_got_entries (g);
6037
6038 /* Assign offsets to global GOT entries. */
6039 save_assign = g->assigned_gotno;
6040 g->assigned_gotno = g->local_gotno;
6041 set_got_offset_arg.g = g;
6042 set_got_offset_arg.needed_relocs = 0;
6043 htab_traverse (g->got_entries,
6044 mips_elf_set_global_got_offset,
6045 &set_got_offset_arg);
6046 needed_relocs += set_got_offset_arg.needed_relocs;
6047 BFD_ASSERT (g->assigned_gotno - g->local_gotno
6048 <= g->global_gotno);
6049
6050 g->assigned_gotno = save_assign;
6051 if (info->shared)
6052 {
6053 needed_relocs += g->local_gotno - g->assigned_gotno;
6054 BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
6055 + g->next->global_gotno
6056 + MIPS_RESERVED_GOTNO);
6057 }
b49e97c9 6058 }
b49e97c9 6059
f4416af6
AO		 6060 if (needed_relocs)
6061 mips_elf_allocate_dynamic_relocations (dynobj, needed_relocs);
6062 }
b49e97c9
TS		 6063 }
6064 else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
6065 {
8dc1a139 6066 /* IRIX rld assumes that the function stub isn't at the end
b49e97c9
TS		 6067 of .text section. So put a dummy. XXX */
6068 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
6069 }
6070 else if (! info->shared
6071 && ! mips_elf_hash_table (info)->use_rld_obj_head
6072 && strncmp (name, ".rld_map", 8) == 0)
6073 {
6074 /* We add a room for __rld_map. It will be filled in by the
6075 rtld to contain a pointer to the _r_debug structure. */
6076 s->_raw_size += 4;
6077 }
6078 else if (SGI_COMPAT (output_bfd)
6079 && strncmp (name, ".compact_rel", 12) == 0)
6080 s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
6081 else if (strcmp (name, ".msym") == 0)
6082 s->_raw_size = (sizeof (Elf32_External_Msym)
6083 * (elf_hash_table (info)->dynsymcount
6084 + bfd_count_sections (output_bfd)));
6085 else if (strncmp (name, ".init", 5) != 0)
6086 {
6087 /* It's not one of our sections, so don't allocate space. */
6088 continue;
6089 }
6090
6091 if (strip)
6092 {
6093 _bfd_strip_section_from_output (info, s);
6094 continue;
6095 }
6096
6097 /* Allocate memory for the section contents. */
6098 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
6099 if (s->contents == NULL && s->_raw_size != 0)
6100 {
6101 bfd_set_error (bfd_error_no_memory);
b34976b6 6102 return FALSE;
b49e97c9
TS		 6103 }
6104 }
6105
6106 if (elf_hash_table (info)->dynamic_sections_created)
6107 {
6108 /* Add some entries to the .dynamic section. We fill in the
6109 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6110 must add the entries now so that we get the correct size for
6111 the .dynamic section. The DT_DEBUG entry is filled in by the
6112 dynamic linker and used by the debugger. */
6113 if (! info->shared)
6114 {
6115 /* SGI object has the equivalence of DT_DEBUG in the
6116 DT_MIPS_RLD_MAP entry. */
6117 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
b34976b6 6118 return FALSE;
b49e97c9
TS		 6119 if (!SGI_COMPAT (output_bfd))
6120 {
6121 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
b34976b6 6122 return FALSE;
b49e97c9
TS		 6123 }
6124 }
6125 else
6126 {
6127 /* Shared libraries on traditional mips have DT_DEBUG. */
6128 if (!SGI_COMPAT (output_bfd))
6129 {
6130 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
b34976b6 6131 return FALSE;
b49e97c9
TS		 6132 }
6133 }
6134
6135 if (reltext && SGI_COMPAT (output_bfd))
6136 info->flags |= DF_TEXTREL;
6137
6138 if ((info->flags & DF_TEXTREL) != 0)
6139 {
6140 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
b34976b6 6141 return FALSE;
b49e97c9
TS		 6142 }
6143
6144 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
b34976b6 6145 return FALSE;
b49e97c9 6146
f4416af6 6147 if (mips_elf_rel_dyn_section (dynobj, FALSE))
b49e97c9
TS		 6148 {
6149 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
b34976b6 6150 return FALSE;
b49e97c9
TS		 6151
6152 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
b34976b6 6153 return FALSE;
b49e97c9
TS		 6154
6155 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
b34976b6 6156 return FALSE;
b49e97c9
TS		 6157 }
6158
6159 if (SGI_COMPAT (output_bfd))
6160 {
6161 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICTNO, 0))
b34976b6 6162 return FALSE;
b49e97c9
TS		 6163 }
6164
6165 if (SGI_COMPAT (output_bfd))
6166 {
6167 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLISTNO, 0))
b34976b6 6168 return FALSE;
b49e97c9
TS		 6169 }
6170
6171 if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
6172 {
6173 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICT, 0))
b34976b6 6174 return FALSE;
b49e97c9
TS		 6175
6176 s = bfd_get_section_by_name (dynobj, ".liblist");
6177 BFD_ASSERT (s != NULL);
6178
6179 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLIST, 0))
b34976b6 6180 return FALSE;
b49e97c9
TS		 6181 }
6182
6183 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
b34976b6 6184 return FALSE;
b49e97c9
TS		 6185
6186 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
b34976b6 6187 return FALSE;
b49e97c9
TS		 6188
6189#if 0
6190 /* Time stamps in executable files are a bad idea. */
6191 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
b34976b6 6192 return FALSE;
b49e97c9
TS		 6193#endif
6194
6195#if 0 /* FIXME */
6196 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
b34976b6 6197 return FALSE;
b49e97c9
TS		 6198#endif
6199
6200#if 0 /* FIXME */
6201 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
b34976b6 6202 return FALSE;
b49e97c9
TS		 6203#endif
6204
6205 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
b34976b6 6206 return FALSE;
b49e97c9
TS		 6207
6208 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
b34976b6 6209 return FALSE;
b49e97c9
TS		 6210
6211 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
b34976b6 6212 return FALSE;
b49e97c9
TS		 6213
6214 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
b34976b6 6215 return FALSE;
b49e97c9
TS		 6216
6217 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
b34976b6 6218 return FALSE;
b49e97c9
TS		 6219
6220 if (IRIX_COMPAT (dynobj) == ict_irix5
6221 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
b34976b6 6222 return FALSE;
b49e97c9
TS		 6223
6224 if (IRIX_COMPAT (dynobj) == ict_irix6
6225 && (bfd_get_section_by_name
6226 (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
6227 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
b34976b6 6228 return FALSE;
b49e97c9
TS		 6229
6230 if (bfd_get_section_by_name (dynobj, ".msym")
6231 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_MSYM, 0))
b34976b6 6232 return FALSE;
b49e97c9
TS		 6233 }
6234
b34976b6 6235 return TRUE;
b49e97c9
TS		 6236}
6237\f
6238/* Relocate a MIPS ELF section. */
6239
b34976b6 6240bfd_boolean
b49e97c9
TS		 6241_bfd_mips_elf_relocate_section (output_bfd, info, input_bfd, input_section,
6242 contents, relocs, local_syms, local_sections)
6243 bfd *output_bfd;
6244 struct bfd_link_info *info;
6245 bfd *input_bfd;
6246 asection *input_section;
6247 bfd_byte *contents;
6248 Elf_Internal_Rela *relocs;
6249 Elf_Internal_Sym *local_syms;
6250 asection **local_sections;
6251{
6252 Elf_Internal_Rela *rel;
6253 const Elf_Internal_Rela *relend;
6254 bfd_vma addend = 0;
b34976b6 6255 bfd_boolean use_saved_addend_p = FALSE;
b49e97c9
TS		 6256 struct elf_backend_data *bed;
6257
6258 bed = get_elf_backend_data (output_bfd);
6259 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6260 for (rel = relocs; rel < relend; ++rel)
6261 {
6262 const char *name;
6263 bfd_vma value;
6264 reloc_howto_type *howto;
b34976b6
AM		 6265 bfd_boolean require_jalx;
6266 /* TRUE if the relocation is a RELA relocation, rather than a
b49e97c9 6267 REL relocation. */
b34976b6 6268 bfd_boolean rela_relocation_p = TRUE;
b49e97c9
TS		 6269 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6270 const char * msg = (const char *) NULL;
6271
6272 /* Find the relocation howto for this relocation. */
4a14403c 6273 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
b49e97c9
TS		 6274 {
6275 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6276 64-bit code, but make sure all their addresses are in the
6277 lowermost or uppermost 32-bit section of the 64-bit address
6278 space. Thus, when they use an R_MIPS_64 they mean what is
6279 usually meant by R_MIPS_32, with the exception that the
6280 stored value is sign-extended to 64 bits. */
b34976b6 6281 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
b49e97c9
TS		 6282
6283 /* On big-endian systems, we need to lie about the position
6284 of the reloc. */
6285 if (bfd_big_endian (input_bfd))
6286 rel->r_offset += 4;
6287 }
6288 else
6289 /* NewABI defaults to RELA relocations. */
6290 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
4ffba85c
AO		 6291 NEWABI_P (input_bfd)
6292 && (MIPS_RELOC_RELA_P
6293 (input_bfd, input_section,
6294 rel - relocs)));
b49e97c9
TS		 6295
6296 if (!use_saved_addend_p)
6297 {
6298 Elf_Internal_Shdr *rel_hdr;
6299
6300 /* If these relocations were originally of the REL variety,
6301 we must pull the addend out of the field that will be
6302 relocated. Otherwise, we simply use the contents of the
6303 RELA relocation. To determine which flavor or relocation
6304 this is, we depend on the fact that the INPUT_SECTION's
6305 REL_HDR is read before its REL_HDR2. */
6306 rel_hdr = &elf_section_data (input_section)->rel_hdr;
6307 if ((size_t) (rel - relocs)
6308 >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6309 rel_hdr = elf_section_data (input_section)->rel_hdr2;
6310 if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6311 {
6312 /* Note that this is a REL relocation. */
b34976b6 6313 rela_relocation_p = FALSE;
b49e97c9
TS		 6314
6315 /* Get the addend, which is stored in the input file. */
6316 addend = mips_elf_obtain_contents (howto, rel, input_bfd,
6317 contents);
6318 addend &= howto->src_mask;
5a659663 6319 addend <<= howto->rightshift;
b49e97c9
TS		 6320
6321 /* For some kinds of relocations, the ADDEND is a
6322 combination of the addend stored in two different
6323 relocations. */
6324 if (r_type == R_MIPS_HI16
6325 || r_type == R_MIPS_GNU_REL_HI16
6326 || (r_type == R_MIPS_GOT16
6327 && mips_elf_local_relocation_p (input_bfd, rel,
b34976b6 6328 local_sections, FALSE)))
b49e97c9
TS		 6329 {
6330 bfd_vma l;
6331 const Elf_Internal_Rela *lo16_relocation;
6332 reloc_howto_type *lo16_howto;
6333 unsigned int lo;
6334
6335 /* The combined value is the sum of the HI16 addend,
6336 left-shifted by sixteen bits, and the LO16
6337 addend, sign extended. (Usually, the code does
6338 a `lui' of the HI16 value, and then an `addiu' of
6339 the LO16 value.)
6340
6341 Scan ahead to find a matching LO16 relocation. */
6342 if (r_type == R_MIPS_GNU_REL_HI16)
6343 lo = R_MIPS_GNU_REL_LO16;
6344 else
6345 lo = R_MIPS_LO16;
6346 lo16_relocation = mips_elf_next_relocation (input_bfd, lo,
6347 rel, relend);
6348 if (lo16_relocation == NULL)
b34976b6 6349 return FALSE;
b49e97c9
TS		 6350
6351 /* Obtain the addend kept there. */
b34976b6 6352 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, lo, FALSE);
b49e97c9
TS		 6353 l = mips_elf_obtain_contents (lo16_howto, lo16_relocation,
6354 input_bfd, contents);
6355 l &= lo16_howto->src_mask;
5a659663 6356 l <<= lo16_howto->rightshift;
b49e97c9
TS		 6357 l = mips_elf_sign_extend (l, 16);
6358
6359 addend <<= 16;
6360
6361 /* Compute the combined addend. */
6362 addend += l;
6363
6364 /* If PC-relative, subtract the difference between the
6365 address of the LO part of the reloc and the address of
6366 the HI part. The relocation is relative to the LO
6367 part, but mips_elf_calculate_relocation() doesn't
6368 know its address or the difference from the HI part, so
6369 we subtract that difference here. See also the
6370 comment in mips_elf_calculate_relocation(). */
6371 if (r_type == R_MIPS_GNU_REL_HI16)
6372 addend -= (lo16_relocation->r_offset - rel->r_offset);
6373 }
6374 else if (r_type == R_MIPS16_GPREL)
6375 {
6376 /* The addend is scrambled in the object file. See
6377 mips_elf_perform_relocation for details on the
6378 format. */
6379 addend = (((addend & 0x1f0000) >> 5)
6380 | ((addend & 0x7e00000) >> 16)
6381 | (addend & 0x1f));
6382 }
6383 }
6384 else
6385 addend = rel->r_addend;
6386 }
6387
6388 if (info->relocateable)
6389 {
6390 Elf_Internal_Sym *sym;
6391 unsigned long r_symndx;
6392
4a14403c 6393 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
b49e97c9
TS		 6394 && bfd_big_endian (input_bfd))
6395 rel->r_offset -= 4;
6396
6397 /* Since we're just relocating, all we need to do is copy
6398 the relocations back out to the object file, unless
6399 they're against a section symbol, in which case we need
6400 to adjust by the section offset, or unless they're GP
6401 relative in which case we need to adjust by the amount
6402 that we're adjusting GP in this relocateable object. */
6403
6404 if (! mips_elf_local_relocation_p (input_bfd, rel, local_sections,
b34976b6 6405 FALSE))
b49e97c9
TS		 6406 /* There's nothing to do for non-local relocations. */
6407 continue;
6408
6409 if (r_type == R_MIPS16_GPREL
6410 || r_type == R_MIPS_GPREL16
6411 || r_type == R_MIPS_GPREL32
6412 || r_type == R_MIPS_LITERAL)
6413 addend -= (_bfd_get_gp_value (output_bfd)
6414 - _bfd_get_gp_value (input_bfd));
b49e97c9
TS		 6415
6416 r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
6417 sym = local_syms + r_symndx;
6418 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6419 /* Adjust the addend appropriately. */
6420 addend += local_sections[r_symndx]->output_offset;
6421
5a659663
TS		 6422 if (howto->partial_inplace)
6423 {
6424 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6425 then we only want to write out the high-order 16 bits.
6426 The subsequent R_MIPS_LO16 will handle the low-order bits.
6427 */
6428 if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16
6429 || r_type == R_MIPS_GNU_REL_HI16)
6430 addend = mips_elf_high (addend);
6431 else if (r_type == R_MIPS_HIGHER)
6432 addend = mips_elf_higher (addend);
6433 else if (r_type == R_MIPS_HIGHEST)
6434 addend = mips_elf_highest (addend);
6435 }
b49e97c9
TS		 6436
6437 if (rela_relocation_p)
6438 /* If this is a RELA relocation, just update the addend.
6439 We have to cast away constness for REL. */
6440 rel->r_addend = addend;
6441 else
6442 {
6443 /* Otherwise, we have to write the value back out. Note
6444 that we use the source mask, rather than the
6445 destination mask because the place to which we are
6446 writing will be source of the addend in the final
6447 link. */
5a659663 6448 addend >>= howto->rightshift;
b49e97c9
TS		 6449 addend &= howto->src_mask;
6450
5a659663 6451 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
b49e97c9
TS		 6452 /* See the comment above about using R_MIPS_64 in the 32-bit
6453 ABI. Here, we need to update the addend. It would be
6454 possible to get away with just using the R_MIPS_32 reloc
6455 but for endianness. */
6456 {
6457 bfd_vma sign_bits;
6458 bfd_vma low_bits;
6459 bfd_vma high_bits;
6460
6461 if (addend & ((bfd_vma) 1 << 31))
6462#ifdef BFD64
6463 sign_bits = ((bfd_vma) 1 << 32) - 1;
6464#else
6465 sign_bits = -1;
6466#endif
6467 else
6468 sign_bits = 0;
6469
6470 /* If we don't know that we have a 64-bit type,
6471 do two separate stores. */
6472 if (bfd_big_endian (input_bfd))
6473 {
6474 /* Store the sign-bits (which are most significant)
6475 first. */
6476 low_bits = sign_bits;
6477 high_bits = addend;
6478 }
6479 else
6480 {
6481 low_bits = addend;
6482 high_bits = sign_bits;
6483 }
6484 bfd_put_32 (input_bfd, low_bits,
6485 contents + rel->r_offset);
6486 bfd_put_32 (input_bfd, high_bits,
6487 contents + rel->r_offset + 4);
6488 continue;
6489 }
6490
6491 if (! mips_elf_perform_relocation (info, howto, rel, addend,
6492 input_bfd, input_section,
b34976b6
AM		 6493 contents, FALSE))
6494 return FALSE;
b49e97c9
TS		 6495 }
6496
6497 /* Go on to the next relocation. */
6498 continue;
6499 }
6500
6501 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6502 relocations for the same offset. In that case we are
6503 supposed to treat the output of each relocation as the addend
6504 for the next. */
6505 if (rel + 1 < relend
6506 && rel->r_offset == rel[1].r_offset
6507 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
b34976b6 6508 use_saved_addend_p = TRUE;
b49e97c9 6509 else
b34976b6 6510 use_saved_addend_p = FALSE;
b49e97c9 6511
5a659663
TS		 6512 addend >>= howto->rightshift;
6513
b49e97c9
TS		 6514 /* Figure out what value we are supposed to relocate. */
6515 switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
6516 input_section, info, rel,
6517 addend, howto, local_syms,
6518 local_sections, &value,
bce03d3d
AO		 6519 &name, &require_jalx,
6520 use_saved_addend_p))
b49e97c9
TS		 6521 {
6522 case bfd_reloc_continue:
6523 /* There's nothing to do. */
6524 continue;
6525
6526 case bfd_reloc_undefined:
6527 /* mips_elf_calculate_relocation already called the
6528 undefined_symbol callback. There's no real point in
6529 trying to perform the relocation at this point, so we
6530 just skip ahead to the next relocation. */
6531 continue;
6532
6533 case bfd_reloc_notsupported:
6534 msg = _("internal error: unsupported relocation error");
6535 info->callbacks->warning
6536 (info, msg, name, input_bfd, input_section, rel->r_offset);
b34976b6 6537 return FALSE;
b49e97c9
TS		 6538
6539 case bfd_reloc_overflow:
6540 if (use_saved_addend_p)
6541 /* Ignore overflow until we reach the last relocation for
6542 a given location. */
6543 ;
6544 else
6545 {
6546 BFD_ASSERT (name != NULL);
6547 if (! ((*info->callbacks->reloc_overflow)
6548 (info, name, howto->name, (bfd_vma) 0,
6549 input_bfd, input_section, rel->r_offset)))
b34976b6 6550 return FALSE;
b49e97c9
TS		 6551 }
6552 break;
6553
6554 case bfd_reloc_ok:
6555 break;
6556
6557 default:
6558 abort ();
6559 break;
6560 }
6561
6562 /* If we've got another relocation for the address, keep going
6563 until we reach the last one. */
6564 if (use_saved_addend_p)
6565 {
6566 addend = value;
6567 continue;
6568 }
6569
4a14403c 6570 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
b49e97c9
TS		 6571 /* See the comment above about using R_MIPS_64 in the 32-bit
6572 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6573 that calculated the right value. Now, however, we
6574 sign-extend the 32-bit result to 64-bits, and store it as a
6575 64-bit value. We are especially generous here in that we
6576 go to extreme lengths to support this usage on systems with
6577 only a 32-bit VMA. */
6578 {
6579 bfd_vma sign_bits;
6580 bfd_vma low_bits;
6581 bfd_vma high_bits;
6582
6583 if (value & ((bfd_vma) 1 << 31))
6584#ifdef BFD64
6585 sign_bits = ((bfd_vma) 1 << 32) - 1;
6586#else
6587 sign_bits = -1;
6588#endif
6589 else
6590 sign_bits = 0;
6591
6592 /* If we don't know that we have a 64-bit type,
6593 do two separate stores. */
6594 if (bfd_big_endian (input_bfd))
6595 {
6596 /* Undo what we did above. */
6597 rel->r_offset -= 4;
6598 /* Store the sign-bits (which are most significant)
6599 first. */
6600 low_bits = sign_bits;
6601 high_bits = value;
6602 }
6603 else
6604 {
6605 low_bits = value;
6606 high_bits = sign_bits;
6607 }
6608 bfd_put_32 (input_bfd, low_bits,
6609 contents + rel->r_offset);
6610 bfd_put_32 (input_bfd, high_bits,
6611 contents + rel->r_offset + 4);
6612 continue;
6613 }
6614
6615 /* Actually perform the relocation. */
6616 if (! mips_elf_perform_relocation (info, howto, rel, value,
6617 input_bfd, input_section,
6618 contents, require_jalx))
b34976b6 6619 return FALSE;
b49e97c9
TS		 6620 }
6621
b34976b6 6622 return TRUE;
b49e97c9
TS		 6623}
6624\f
6625/* If NAME is one of the special IRIX6 symbols defined by the linker,
6626 adjust it appropriately now. */
6627
6628static void
6629mips_elf_irix6_finish_dynamic_symbol (abfd, name, sym)
6630 bfd *abfd ATTRIBUTE_UNUSED;
6631 const char *name;
6632 Elf_Internal_Sym *sym;
6633{
6634 /* The linker script takes care of providing names and values for
6635 these, but we must place them into the right sections. */
6636 static const char* const text_section_symbols[] = {
6637 "_ftext",
6638 "_etext",
6639 "__dso_displacement",
6640 "__elf_header",
6641 "__program_header_table",
6642 NULL
6643 };
6644
6645 static const char* const data_section_symbols[] = {
6646 "_fdata",
6647 "_edata",
6648 "_end",
6649 "_fbss",
6650 NULL
6651 };
6652
6653 const char* const *p;
6654 int i;
6655
6656 for (i = 0; i < 2; ++i)
6657 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
6658 *p;
6659 ++p)
6660 if (strcmp (*p, name) == 0)
6661 {
6662 /* All of these symbols are given type STT_SECTION by the
6663 IRIX6 linker. */
6664 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6665
6666 /* The IRIX linker puts these symbols in special sections. */
6667 if (i == 0)
6668 sym->st_shndx = SHN_MIPS_TEXT;
6669 else
6670 sym->st_shndx = SHN_MIPS_DATA;
6671
6672 break;
6673 }
6674}
6675
6676/* Finish up dynamic symbol handling. We set the contents of various
6677 dynamic sections here. */
6678
b34976b6 6679bfd_boolean
b49e97c9
TS		 6680_bfd_mips_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
6681 bfd *output_bfd;
6682 struct bfd_link_info *info;
6683 struct elf_link_hash_entry *h;
6684 Elf_Internal_Sym *sym;
6685{
6686 bfd *dynobj;
6687 bfd_vma gval;
6688 asection *sgot;
6689 asection *smsym;
f4416af6 6690 struct mips_got_info *g, *gg;
b49e97c9
TS		 6691 const char *name;
6692 struct mips_elf_link_hash_entry *mh;
6693
6694 dynobj = elf_hash_table (info)->dynobj;
6695 gval = sym->st_value;
6696 mh = (struct mips_elf_link_hash_entry *) h;
6697
6698 if (h->plt.offset != (bfd_vma) -1)
6699 {
6700 asection *s;
6701 bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
6702
6703 /* This symbol has a stub. Set it up. */
6704
6705 BFD_ASSERT (h->dynindx != -1);
6706
6707 s = bfd_get_section_by_name (dynobj,
6708 MIPS_ELF_STUB_SECTION_NAME (dynobj));
6709 BFD_ASSERT (s != NULL);
6710
6711 /* FIXME: Can h->dynindex be more than 64K? */
6712 if (h->dynindx & 0xffff0000)
b34976b6 6713 return FALSE;
b49e97c9
TS		 6714
6715 /* Fill the stub. */
6716 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub);
6717 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + 4);
6718 bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
6719 bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, stub + 12);
6720
6721 BFD_ASSERT (h->plt.offset <= s->_raw_size);
6722 memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
6723
6724 /* Mark the symbol as undefined. plt.offset != -1 occurs
6725 only for the referenced symbol. */
6726 sym->st_shndx = SHN_UNDEF;
6727
6728 /* The run-time linker uses the st_value field of the symbol
6729 to reset the global offset table entry for this external
6730 to its stub address when unlinking a shared object. */
6731 gval = s->output_section->vma + s->output_offset + h->plt.offset;
6732 sym->st_value = gval;
6733 }
6734
6735 BFD_ASSERT (h->dynindx != -1
6736 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
6737
f4416af6 6738 sgot = mips_elf_got_section (dynobj, FALSE);
b49e97c9 6739 BFD_ASSERT (sgot != NULL);
f4416af6 6740 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
f0abc2a1 6741 g = mips_elf_section_data (sgot)->u.got_info;
b49e97c9
TS		 6742 BFD_ASSERT (g != NULL);
6743
6744 /* Run through the global symbol table, creating GOT entries for all
6745 the symbols that need them. */
6746 if (g->global_gotsym != NULL
6747 && h->dynindx >= g->global_gotsym->dynindx)
6748 {
6749 bfd_vma offset;
6750 bfd_vma value;
6751
6752 if (sym->st_value)
6753 value = sym->st_value;
6754 else
6755 {
6756 /* For an entity defined in a shared object, this will be
6757 NULL. (For functions in shared objects for
6758 which we have created stubs, ST_VALUE will be non-NULL.
6759 That's because such the functions are now no longer defined
6760 in a shared object.) */
6761
f4416af6
AO		 6762 if ((info->shared && h->root.type == bfd_link_hash_undefined)
6763 || h->root.type == bfd_link_hash_undefweak)
b49e97c9
TS		 6764 value = 0;
6765 else
6766 value = h->root.u.def.value;
6767 }
f4416af6 6768 offset = mips_elf_global_got_index (dynobj, output_bfd, h);
b49e97c9
TS		 6769 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
6770 }
6771
f4416af6
AO		 6772 if (g->next && h->dynindx != -1)
6773 {
6774 struct mips_got_entry e, *p;
6775 bfd_vma offset;
6776 bfd_vma value;
6777 Elf_Internal_Rela rel[3];
6778 bfd_vma addend = 0;
6779
6780 gg = g;
6781
6782 e.abfd = output_bfd;
6783 e.symndx = -1;
6784 e.d.h = (struct mips_elf_link_hash_entry *)h;
6785
6786 if (info->shared
6787 || h->root.type == bfd_link_hash_undefined
6788 || h->root.type == bfd_link_hash_undefweak)
6789 value = 0;
6790 else if (sym->st_value)
6791 value = sym->st_value;
6792 else
6793 value = h->root.u.def.value;
6794
6795 memset (rel, 0, sizeof (rel));
6796 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
6797
6798 for (g = g->next; g->next != gg; g = g->next)
6799 {
6800 if (g->got_entries
6801 && (p = (struct mips_got_entry *) htab_find (g->got_entries,
6802 &e)))
6803 {
6804 offset = p->gotidx;
6805 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
6806
6807 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
6808
6809 if ((info->shared
6810 || (elf_hash_table (info)->dynamic_sections_created
6811 && p->d.h != NULL
6812 && ((p->d.h->root.elf_link_hash_flags
6813 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)
6814 && ((p->d.h->root.elf_link_hash_flags
6815 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
6816 && ! (mips_elf_create_dynamic_relocation
6817 (output_bfd, info, rel,
6818 e.d.h, NULL, value, &addend, sgot)))
6819 return FALSE;
6820 BFD_ASSERT (addend == 0);
6821 }
6822 }
6823 }
6824
b49e97c9
TS		 6825 /* Create a .msym entry, if appropriate. */
6826 smsym = bfd_get_section_by_name (dynobj, ".msym");
6827 if (smsym)
6828 {
6829 Elf32_Internal_Msym msym;
6830
6831 msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
6832 /* It is undocumented what the `1' indicates, but IRIX6 uses
6833 this value. */
6834 msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
6835 bfd_mips_elf_swap_msym_out
6836 (dynobj, &msym,
6837 ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
6838 }
6839
6840 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6841 name = h->root.root.string;
6842 if (strcmp (name, "_DYNAMIC") == 0
6843 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
6844 sym->st_shndx = SHN_ABS;
6845 else if (strcmp (name, "_DYNAMIC_LINK") == 0
6846 || strcmp (name, "_DYNAMIC_LINKING") == 0)
6847 {
6848 sym->st_shndx = SHN_ABS;
6849 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6850 sym->st_value = 1;
6851 }
4a14403c 6852 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
b49e97c9
TS		 6853 {
6854 sym->st_shndx = SHN_ABS;
6855 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6856 sym->st_value = elf_gp (output_bfd);
6857 }
6858 else if (SGI_COMPAT (output_bfd))
6859 {
6860 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
6861 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
6862 {
6863 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6864 sym->st_other = STO_PROTECTED;
6865 sym->st_value = 0;
6866 sym->st_shndx = SHN_MIPS_DATA;
6867 }
6868 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
6869 {
6870 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6871 sym->st_other = STO_PROTECTED;
6872 sym->st_value = mips_elf_hash_table (info)->procedure_count;
6873 sym->st_shndx = SHN_ABS;
6874 }
6875 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
6876 {
6877 if (h->type == STT_FUNC)
6878 sym->st_shndx = SHN_MIPS_TEXT;
6879 else if (h->type == STT_OBJECT)
6880 sym->st_shndx = SHN_MIPS_DATA;
6881 }
6882 }
6883
6884 /* Handle the IRIX6-specific symbols. */
6885 if (IRIX_COMPAT (output_bfd) == ict_irix6)
6886 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
6887
6888 if (! info->shared)
6889 {
6890 if (! mips_elf_hash_table (info)->use_rld_obj_head
6891 && (strcmp (name, "__rld_map") == 0
6892 || strcmp (name, "__RLD_MAP") == 0))
6893 {
6894 asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
6895 BFD_ASSERT (s != NULL);
6896 sym->st_value = s->output_section->vma + s->output_offset;
6897 bfd_put_32 (output_bfd, (bfd_vma) 0, s->contents);
6898 if (mips_elf_hash_table (info)->rld_value == 0)
6899 mips_elf_hash_table (info)->rld_value = sym->st_value;
6900 }
6901 else if (mips_elf_hash_table (info)->use_rld_obj_head
6902 && strcmp (name, "__rld_obj_head") == 0)
6903 {
6904 /* IRIX6 does not use a .rld_map section. */
6905 if (IRIX_COMPAT (output_bfd) == ict_irix5
6906 || IRIX_COMPAT (output_bfd) == ict_none)
6907 BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
6908 != NULL);
6909 mips_elf_hash_table (info)->rld_value = sym->st_value;
6910 }
6911 }
6912
6913 /* If this is a mips16 symbol, force the value to be even. */
6914 if (sym->st_other == STO_MIPS16
6915 && (sym->st_value & 1) != 0)
6916 --sym->st_value;
6917
b34976b6 6918 return TRUE;
b49e97c9
TS		 6919}
6920
6921/* Finish up the dynamic sections. */
6922
b34976b6 6923bfd_boolean
b49e97c9
TS		 6924_bfd_mips_elf_finish_dynamic_sections (output_bfd, info)
6925 bfd *output_bfd;
6926 struct bfd_link_info *info;
6927{
6928 bfd *dynobj;
6929 asection *sdyn;
6930 asection *sgot;
f4416af6 6931 struct mips_got_info *gg, *g;
b49e97c9
TS		 6932
6933 dynobj = elf_hash_table (info)->dynobj;
6934
6935 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6936
f4416af6 6937 sgot = mips_elf_got_section (dynobj, FALSE);
b49e97c9 6938 if (sgot == NULL)
f4416af6 6939 gg = g = NULL;
b49e97c9
TS		 6940 else
6941 {
f4416af6
AO		 6942 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6943 gg = mips_elf_section_data (sgot)->u.got_info;
6944 BFD_ASSERT (gg != NULL);
6945 g = mips_elf_got_for_ibfd (gg, output_bfd);
b49e97c9
TS		 6946 BFD_ASSERT (g != NULL);
6947 }
6948
6949 if (elf_hash_table (info)->dynamic_sections_created)
6950 {
6951 bfd_byte *b;
6952
6953 BFD_ASSERT (sdyn != NULL);
6954 BFD_ASSERT (g != NULL);
6955
6956 for (b = sdyn->contents;
6957 b < sdyn->contents + sdyn->_raw_size;
6958 b += MIPS_ELF_DYN_SIZE (dynobj))
6959 {
6960 Elf_Internal_Dyn dyn;
6961 const char *name;
6962 size_t elemsize;
6963 asection *s;
b34976b6 6964 bfd_boolean swap_out_p;
b49e97c9
TS		 6965
6966 /* Read in the current dynamic entry. */
6967 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
6968
6969 /* Assume that we're going to modify it and write it out. */
b34976b6 6970 swap_out_p = TRUE;
b49e97c9
TS		 6971
6972 switch (dyn.d_tag)
6973 {
6974 case DT_RELENT:
f4416af6 6975 s = mips_elf_rel_dyn_section (dynobj, FALSE);
b49e97c9
TS		 6976 BFD_ASSERT (s != NULL);
6977 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
6978 break;
6979
6980 case DT_STRSZ:
6981 /* Rewrite DT_STRSZ. */
6982 dyn.d_un.d_val =
6983 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6984 break;
6985
6986 case DT_PLTGOT:
6987 name = ".got";
6988 goto get_vma;
6989 case DT_MIPS_CONFLICT:
6990 name = ".conflict";
6991 goto get_vma;
6992 case DT_MIPS_LIBLIST:
6993 name = ".liblist";
6994 get_vma:
6995 s = bfd_get_section_by_name (output_bfd, name);
6996 BFD_ASSERT (s != NULL);
6997 dyn.d_un.d_ptr = s->vma;
6998 break;
6999
7000 case DT_MIPS_RLD_VERSION:
7001 dyn.d_un.d_val = 1; /* XXX */
7002 break;
7003
7004 case DT_MIPS_FLAGS:
7005 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
7006 break;
7007
7008 case DT_MIPS_CONFLICTNO:
7009 name = ".conflict";
7010 elemsize = sizeof (Elf32_Conflict);
7011 goto set_elemno;
7012
7013 case DT_MIPS_LIBLISTNO:
7014 name = ".liblist";
7015 elemsize = sizeof (Elf32_Lib);
7016 set_elemno:
7017 s = bfd_get_section_by_name (output_bfd, name);
7018 if (s != NULL)
7019 {
7020 if (s->_cooked_size != 0)
7021 dyn.d_un.d_val = s->_cooked_size / elemsize;
7022 else
7023 dyn.d_un.d_val = s->_raw_size / elemsize;
7024 }
7025 else
7026 dyn.d_un.d_val = 0;
7027 break;
7028
7029 case DT_MIPS_TIME_STAMP:
7030 time ((time_t *) &dyn.d_un.d_val);
7031 break;
7032
7033 case DT_MIPS_ICHECKSUM:
7034 /* XXX FIXME: */
b34976b6 7035 swap_out_p = FALSE;
b49e97c9
TS		 7036 break;
7037
7038 case DT_MIPS_IVERSION:
7039 /* XXX FIXME: */
b34976b6 7040 swap_out_p = FALSE;
b49e97c9
TS		 7041 break;
7042
7043 case DT_MIPS_BASE_ADDRESS:
7044 s = output_bfd->sections;
7045 BFD_ASSERT (s != NULL);
7046 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
7047 break;
7048
7049 case DT_MIPS_LOCAL_GOTNO:
7050 dyn.d_un.d_val = g->local_gotno;
7051 break;
7052
7053 case DT_MIPS_UNREFEXTNO:
7054 /* The index into the dynamic symbol table which is the
7055 entry of the first external symbol that is not
7056 referenced within the same object. */
7057 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
7058 break;
7059
7060 case DT_MIPS_GOTSYM:
f4416af6 7061 if (gg->global_gotsym)
b49e97c9 7062 {
f4416af6 7063 dyn.d_un.d_val = gg->global_gotsym->dynindx;
b49e97c9
TS		 7064 break;
7065 }
7066 /* In case if we don't have global got symbols we default
7067 to setting DT_MIPS_GOTSYM to the same value as
7068 DT_MIPS_SYMTABNO, so we just fall through. */
7069
7070 case DT_MIPS_SYMTABNO:
7071 name = ".dynsym";
7072 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
7073 s = bfd_get_section_by_name (output_bfd, name);
7074 BFD_ASSERT (s != NULL);
7075
7076 if (s->_cooked_size != 0)
7077 dyn.d_un.d_val = s->_cooked_size / elemsize;
7078 else
7079 dyn.d_un.d_val = s->_raw_size / elemsize;
7080 break;
7081
7082 case DT_MIPS_HIPAGENO:
7083 dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
7084 break;
7085
7086 case DT_MIPS_RLD_MAP:
7087 dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
7088 break;
7089
7090 case DT_MIPS_OPTIONS:
7091 s = (bfd_get_section_by_name
7092 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
7093 dyn.d_un.d_ptr = s->vma;
7094 break;
7095
7096 case DT_MIPS_MSYM:
7097 s = (bfd_get_section_by_name (output_bfd, ".msym"));
7098 dyn.d_un.d_ptr = s->vma;
7099 break;
7100
7101 default:
b34976b6 7102 swap_out_p = FALSE;
b49e97c9
TS		 7103 break;
7104 }
7105
7106 if (swap_out_p)
7107 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
7108 (dynobj, &dyn, b);
7109 }
7110 }
7111
7112 /* The first entry of the global offset table will be filled at
7113 runtime. The second entry will be used by some runtime loaders.
8dc1a139 7114 This isn't the case of IRIX rld. */
b49e97c9
TS		 7115 if (sgot != NULL && sgot->_raw_size > 0)
7116 {
7117 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
7118 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000,
7119 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
7120 }
7121
7122 if (sgot != NULL)
7123 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
7124 = MIPS_ELF_GOT_SIZE (output_bfd);
7125
f4416af6
AO		 7126 /* Generate dynamic relocations for the non-primary gots. */
7127 if (gg != NULL && gg->next)
7128 {
7129 Elf_Internal_Rela rel[3];
7130 bfd_vma addend = 0;
7131
7132 memset (rel, 0, sizeof (rel));
7133 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
7134
7135 for (g = gg->next; g->next != gg; g = g->next)
7136 {
7137 bfd_vma index = g->next->local_gotno + g->next->global_gotno;
7138
7139 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents
7140 + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7141 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000, sgot->contents
7142 + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
7143
7144 if (! info->shared)
7145 continue;
7146
7147 while (index < g->assigned_gotno)
7148 {
7149 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
7150 = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
7151 if (!(mips_elf_create_dynamic_relocation
7152 (output_bfd, info, rel, NULL,
7153 bfd_abs_section_ptr,
7154 0, &addend, sgot)))
7155 return FALSE;
7156 BFD_ASSERT (addend == 0);
7157 }
7158 }
7159 }
7160
b49e97c9
TS		 7161 {
7162 asection *smsym;
7163 asection *s;
7164 Elf32_compact_rel cpt;
7165
7166 /* ??? The section symbols for the output sections were set up in
7167 _bfd_elf_final_link. SGI sets the STT_NOTYPE attribute for these
7168 symbols. Should we do so? */
7169
7170 smsym = bfd_get_section_by_name (dynobj, ".msym");
7171 if (smsym != NULL)
7172 {
7173 Elf32_Internal_Msym msym;
7174
7175 msym.ms_hash_value = 0;
7176 msym.ms_info = ELF32_MS_INFO (0, 1);
7177
7178 for (s = output_bfd->sections; s != NULL; s = s->next)
7179 {
7180 long dynindx = elf_section_data (s)->dynindx;
7181
7182 bfd_mips_elf_swap_msym_out
7183 (output_bfd, &msym,
7184 (((Elf32_External_Msym *) smsym->contents)
7185 + dynindx));
7186 }
7187 }
7188
7189 if (SGI_COMPAT (output_bfd))
7190 {
7191 /* Write .compact_rel section out. */
7192 s = bfd_get_section_by_name (dynobj, ".compact_rel");
7193 if (s != NULL)
7194 {
7195 cpt.id1 = 1;
7196 cpt.num = s->reloc_count;
7197 cpt.id2 = 2;
7198 cpt.offset = (s->output_section->filepos
7199 + sizeof (Elf32_External_compact_rel));
7200 cpt.reserved0 = 0;
7201 cpt.reserved1 = 0;
7202 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
7203 ((Elf32_External_compact_rel *)
7204 s->contents));
7205
7206 /* Clean up a dummy stub function entry in .text. */
7207 s = bfd_get_section_by_name (dynobj,
7208 MIPS_ELF_STUB_SECTION_NAME (dynobj));
7209 if (s != NULL)
7210 {
7211 file_ptr dummy_offset;
7212
7213 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
7214 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
7215 memset (s->contents + dummy_offset, 0,
7216 MIPS_FUNCTION_STUB_SIZE);
7217 }
7218 }
7219 }
7220
7221 /* We need to sort the entries of the dynamic relocation section. */
7222
f4416af6
AO		 7223 s = mips_elf_rel_dyn_section (dynobj, FALSE);
7224
7225 if (s != NULL
7226 && s->_raw_size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
b49e97c9 7227 {
f4416af6 7228 reldyn_sorting_bfd = output_bfd;
b49e97c9 7229
f4416af6
AO		 7230 if (ABI_64_P (output_bfd))
7231 qsort ((Elf64_External_Rel *) s->contents + 1,
7232 (size_t) s->reloc_count - 1,
7233 sizeof (Elf64_Mips_External_Rel), sort_dynamic_relocs_64);
7234 else
7235 qsort ((Elf32_External_Rel *) s->contents + 1,
7236 (size_t) s->reloc_count - 1,
7237 sizeof (Elf32_External_Rel), sort_dynamic_relocs);
b49e97c9 7238 }
b49e97c9
TS		 7239 }
7240
b34976b6 7241 return TRUE;
b49e97c9
TS		 7242}
7243
b49e97c9 7244
64543e1a
RS		 7245/* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7246
7247static void
7248mips_set_isa_flags (abfd)
b49e97c9 7249 bfd *abfd;
b49e97c9 7250{
64543e1a 7251 flagword val;
b49e97c9
TS		 7252
7253 switch (bfd_get_mach (abfd))
7254 {
7255 default:
7256 case bfd_mach_mips3000:
7257 val = E_MIPS_ARCH_1;
7258 break;
7259
7260 case bfd_mach_mips3900:
7261 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
7262 break;
7263
7264 case bfd_mach_mips6000:
7265 val = E_MIPS_ARCH_2;
7266 break;
7267
7268 case bfd_mach_mips4000:
7269 case bfd_mach_mips4300:
7270 case bfd_mach_mips4400:
7271 case bfd_mach_mips4600:
7272 val = E_MIPS_ARCH_3;
7273 break;
7274
7275 case bfd_mach_mips4010:
7276 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
7277 break;
7278
7279 case bfd_mach_mips4100:
7280 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
7281 break;
7282
7283 case bfd_mach_mips4111:
7284 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
7285 break;
7286
00707a0e
RS		 7287 case bfd_mach_mips4120:
7288 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
7289 break;
7290
b49e97c9
TS		 7291 case bfd_mach_mips4650:
7292 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
7293 break;
7294
00707a0e
RS		 7295 case bfd_mach_mips5400:
7296 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
7297 break;
7298
7299 case bfd_mach_mips5500:
7300 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
7301 break;
7302
b49e97c9
TS		 7303 case bfd_mach_mips5000:
7304 case bfd_mach_mips8000:
7305 case bfd_mach_mips10000:
7306 case bfd_mach_mips12000:
7307 val = E_MIPS_ARCH_4;
7308 break;
7309
7310 case bfd_mach_mips5:
7311 val = E_MIPS_ARCH_5;
7312 break;
7313
7314 case bfd_mach_mips_sb1:
7315 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
7316 break;
7317
7318 case bfd_mach_mipsisa32:
7319 val = E_MIPS_ARCH_32;
7320 break;
7321
7322 case bfd_mach_mipsisa64:
7323 val = E_MIPS_ARCH_64;
af7ee8bf
CD		 7324 break;
7325
7326 case bfd_mach_mipsisa32r2:
7327 val = E_MIPS_ARCH_32R2;
7328 break;
b49e97c9 7329 }
b49e97c9
TS		 7330 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
7331 elf_elfheader (abfd)->e_flags |= val;
7332
64543e1a
RS		 7333}
7334
7335
7336/* The final processing done just before writing out a MIPS ELF object
7337 file. This gets the MIPS architecture right based on the machine
7338 number. This is used by both the 32-bit and the 64-bit ABI. */
7339
7340void
7341_bfd_mips_elf_final_write_processing (abfd, linker)
7342 bfd *abfd;
7343 bfd_boolean linker ATTRIBUTE_UNUSED;
7344{
7345 unsigned int i;
7346 Elf_Internal_Shdr **hdrpp;
7347 const char *name;
7348 asection *sec;
7349
7350 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7351 is nonzero. This is for compatibility with old objects, which used
7352 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7353 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
7354 mips_set_isa_flags (abfd);
7355
b49e97c9
TS		 7356 /* Set the sh_info field for .gptab sections and other appropriate
7357 info for each special section. */
7358 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
7359 i < elf_numsections (abfd);
7360 i++, hdrpp++)
7361 {
7362 switch ((*hdrpp)->sh_type)
7363 {
7364 case SHT_MIPS_MSYM:
7365 case SHT_MIPS_LIBLIST:
7366 sec = bfd_get_section_by_name (abfd, ".dynstr");
7367 if (sec != NULL)
7368 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7369 break;
7370
7371 case SHT_MIPS_GPTAB:
7372 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7373 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7374 BFD_ASSERT (name != NULL
7375 && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
7376 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
7377 BFD_ASSERT (sec != NULL);
7378 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7379 break;
7380
7381 case SHT_MIPS_CONTENT:
7382 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7383 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7384 BFD_ASSERT (name != NULL
7385 && strncmp (name, ".MIPS.content",
7386 sizeof ".MIPS.content" - 1) == 0);
7387 sec = bfd_get_section_by_name (abfd,
7388 name + sizeof ".MIPS.content" - 1);
7389 BFD_ASSERT (sec != NULL);
7390 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7391 break;
7392
7393 case SHT_MIPS_SYMBOL_LIB:
7394 sec = bfd_get_section_by_name (abfd, ".dynsym");
7395 if (sec != NULL)
7396 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7397 sec = bfd_get_section_by_name (abfd, ".liblist");
7398 if (sec != NULL)
7399 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7400 break;
7401
7402 case SHT_MIPS_EVENTS:
7403 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7404 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7405 BFD_ASSERT (name != NULL);
7406 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7407 sec = bfd_get_section_by_name (abfd,
7408 name + sizeof ".MIPS.events" - 1);
7409 else
7410 {
7411 BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
7412 sizeof ".MIPS.post_rel" - 1) == 0);
7413 sec = bfd_get_section_by_name (abfd,
7414 (name
7415 + sizeof ".MIPS.post_rel" - 1));
7416 }
7417 BFD_ASSERT (sec != NULL);
7418 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7419 break;
7420
7421 }
7422 }
7423}
7424\f
8dc1a139 7425/* When creating an IRIX5 executable, we need REGINFO and RTPROC
b49e97c9
TS		 7426 segments. */
7427
7428int
7429_bfd_mips_elf_additional_program_headers (abfd)
7430 bfd *abfd;
7431{
7432 asection *s;
7433 int ret = 0;
7434
7435 /* See if we need a PT_MIPS_REGINFO segment. */
7436 s = bfd_get_section_by_name (abfd, ".reginfo");
7437 if (s && (s->flags & SEC_LOAD))
7438 ++ret;
7439
7440 /* See if we need a PT_MIPS_OPTIONS segment. */
7441 if (IRIX_COMPAT (abfd) == ict_irix6
7442 && bfd_get_section_by_name (abfd,
7443 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
7444 ++ret;
7445
7446 /* See if we need a PT_MIPS_RTPROC segment. */
7447 if (IRIX_COMPAT (abfd) == ict_irix5
7448 && bfd_get_section_by_name (abfd, ".dynamic")
7449 && bfd_get_section_by_name (abfd, ".mdebug"))
7450 ++ret;
7451
7452 return ret;
7453}
7454
8dc1a139 7455/* Modify the segment map for an IRIX5 executable. */
b49e97c9 7456
b34976b6 7457bfd_boolean
b49e97c9
TS		 7458_bfd_mips_elf_modify_segment_map (abfd)
7459 bfd *abfd;
7460{
7461 asection *s;
7462 struct elf_segment_map *m, **pm;
7463 bfd_size_type amt;
7464
7465 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7466 segment. */
7467 s = bfd_get_section_by_name (abfd, ".reginfo");
7468 if (s != NULL && (s->flags & SEC_LOAD) != 0)
7469 {
7470 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7471 if (m->p_type == PT_MIPS_REGINFO)
7472 break;
7473 if (m == NULL)
7474 {
7475 amt = sizeof *m;
7476 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
7477 if (m == NULL)
b34976b6 7478 return FALSE;
b49e97c9
TS		 7479
7480 m->p_type = PT_MIPS_REGINFO;
7481 m->count = 1;
7482 m->sections[0] = s;
7483
7484 /* We want to put it after the PHDR and INTERP segments. */
7485 pm = &elf_tdata (abfd)->segment_map;
7486 while (*pm != NULL
7487 && ((*pm)->p_type == PT_PHDR
7488 || (*pm)->p_type == PT_INTERP))
7489 pm = &(*pm)->next;
7490
7491 m->next = *pm;
7492 *pm = m;
7493 }
7494 }
7495
7496 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7497 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
44c410de 7498 PT_OPTIONS segment immediately following the program header
b49e97c9 7499 table. */
c1fd6598
AO		 7500 if (NEWABI_P (abfd)
7501 /* On non-IRIX6 new abi, we'll have already created a segment
7502 for this section, so don't create another. I'm not sure this
7503 is not also the case for IRIX 6, but I can't test it right
7504 now. */
7505 && IRIX_COMPAT (abfd) == ict_irix6)
b49e97c9
TS		 7506 {
7507 for (s = abfd->sections; s; s = s->next)
7508 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
7509 break;
7510
7511 if (s)
7512 {
7513 struct elf_segment_map *options_segment;
7514
7515 /* Usually, there's a program header table. But, sometimes
7516 there's not (like when running the `ld' testsuite). So,
7517 if there's no program header table, we just put the
44c410de 7518 options segment at the end. */
b49e97c9
TS		 7519 for (pm = &elf_tdata (abfd)->segment_map;
7520 *pm != NULL;
7521 pm = &(*pm)->next)
7522 if ((*pm)->p_type == PT_PHDR)
7523 break;
7524
7525 amt = sizeof (struct elf_segment_map);
7526 options_segment = bfd_zalloc (abfd, amt);
7527 options_segment->next = *pm;
7528 options_segment->p_type = PT_MIPS_OPTIONS;
7529 options_segment->p_flags = PF_R;
b34976b6 7530 options_segment->p_flags_valid = TRUE;
b49e97c9
TS		 7531 options_segment->count = 1;
7532 options_segment->sections[0] = s;
7533 *pm = options_segment;
7534 }
7535 }
7536 else
7537 {
7538 if (IRIX_COMPAT (abfd) == ict_irix5)
7539 {
7540 /* If there are .dynamic and .mdebug sections, we make a room
7541 for the RTPROC header. FIXME: Rewrite without section names. */
7542 if (bfd_get_section_by_name (abfd, ".interp") == NULL
7543 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
7544 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
7545 {
7546 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7547 if (m->p_type == PT_MIPS_RTPROC)
7548 break;
7549 if (m == NULL)
7550 {
7551 amt = sizeof *m;
7552 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
7553 if (m == NULL)
b34976b6 7554 return FALSE;
b49e97c9
TS		 7555
7556 m->p_type = PT_MIPS_RTPROC;
7557
7558 s = bfd_get_section_by_name (abfd, ".rtproc");
7559 if (s == NULL)
7560 {
7561 m->count = 0;
7562 m->p_flags = 0;
7563 m->p_flags_valid = 1;
7564 }
7565 else
7566 {
7567 m->count = 1;
7568 m->sections[0] = s;
7569 }
7570
7571 /* We want to put it after the DYNAMIC segment. */
7572 pm = &elf_tdata (abfd)->segment_map;
7573 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
7574 pm = &(*pm)->next;
7575 if (*pm != NULL)
7576 pm = &(*pm)->next;
7577
7578 m->next = *pm;
7579 *pm = m;
7580 }
7581 }
7582 }
8dc1a139 7583 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
b49e97c9
TS		 7584 .dynstr, .dynsym, and .hash sections, and everything in
7585 between. */
7586 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
7587 pm = &(*pm)->next)
7588 if ((*pm)->p_type == PT_DYNAMIC)
7589 break;
7590 m = *pm;
7591 if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
7592 {
7593 /* For a normal mips executable the permissions for the PT_DYNAMIC
7594 segment are read, write and execute. We do that here since
7595 the code in elf.c sets only the read permission. This matters
7596 sometimes for the dynamic linker. */
7597 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
7598 {
7599 m->p_flags = PF_R | PF_W | PF_X;
7600 m->p_flags_valid = 1;
7601 }
7602 }
7603 if (m != NULL
7604 && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
7605 {
7606 static const char *sec_names[] =
7607 {
7608 ".dynamic", ".dynstr", ".dynsym", ".hash"
7609 };
7610 bfd_vma low, high;
7611 unsigned int i, c;
7612 struct elf_segment_map *n;
7613
7614 low = 0xffffffff;
7615 high = 0;
7616 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
7617 {
7618 s = bfd_get_section_by_name (abfd, sec_names[i]);
7619 if (s != NULL && (s->flags & SEC_LOAD) != 0)
7620 {
7621 bfd_size_type sz;
7622
7623 if (low > s->vma)
7624 low = s->vma;
7625 sz = s->_cooked_size;
7626 if (sz == 0)
7627 sz = s->_raw_size;
7628 if (high < s->vma + sz)
7629 high = s->vma + sz;
7630 }
7631 }
7632
7633 c = 0;
7634 for (s = abfd->sections; s != NULL; s = s->next)
7635 if ((s->flags & SEC_LOAD) != 0
7636 && s->vma >= low
7637 && ((s->vma
7638 + (s->_cooked_size !=
7639 0 ? s->_cooked_size : s->_raw_size)) <= high))
7640 ++c;
7641
7642 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
7643 n = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
7644 if (n == NULL)
b34976b6 7645 return FALSE;
b49e97c9
TS		 7646 *n = *m;
7647 n->count = c;
7648
7649 i = 0;
7650 for (s = abfd->sections; s != NULL; s = s->next)
7651 {
7652 if ((s->flags & SEC_LOAD) != 0
7653 && s->vma >= low
7654 && ((s->vma
7655 + (s->_cooked_size != 0 ?
7656 s->_cooked_size : s->_raw_size)) <= high))
7657 {
7658 n->sections[i] = s;
7659 ++i;
7660 }
7661 }
7662
7663 *pm = n;
7664 }
7665 }
7666
b34976b6 7667 return TRUE;
b49e97c9
TS		 7668}
7669\f
7670/* Return the section that should be marked against GC for a given
7671 relocation. */
7672
7673asection *
1e2f5b6e
AM		 7674_bfd_mips_elf_gc_mark_hook (sec, info, rel, h, sym)
7675 asection *sec;
b49e97c9
TS		 7676 struct bfd_link_info *info ATTRIBUTE_UNUSED;
7677 Elf_Internal_Rela *rel;
7678 struct elf_link_hash_entry *h;
7679 Elf_Internal_Sym *sym;
7680{
7681 /* ??? Do mips16 stub sections need to be handled special? */
7682
7683 if (h != NULL)
7684 {
1e2f5b6e 7685 switch (ELF_R_TYPE (sec->owner, rel->r_info))
b49e97c9
TS		 7686 {
7687 case R_MIPS_GNU_VTINHERIT:
7688 case R_MIPS_GNU_VTENTRY:
7689 break;
7690
7691 default:
7692 switch (h->root.type)
7693 {
7694 case bfd_link_hash_defined:
7695 case bfd_link_hash_defweak:
7696 return h->root.u.def.section;
7697
7698 case bfd_link_hash_common:
7699 return h->root.u.c.p->section;
7700
7701 default:
7702 break;
7703 }
7704 }
7705 }
7706 else
1e2f5b6e 7707 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
b49e97c9
TS		 7708
7709 return NULL;
7710}
7711
7712/* Update the got entry reference counts for the section being removed. */
7713
b34976b6 7714bfd_boolean
b49e97c9
TS		 7715_bfd_mips_elf_gc_sweep_hook (abfd, info, sec, relocs)
7716 bfd *abfd ATTRIBUTE_UNUSED;
7717 struct bfd_link_info *info ATTRIBUTE_UNUSED;
7718 asection *sec ATTRIBUTE_UNUSED;
7719 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
7720{
7721#if 0
7722 Elf_Internal_Shdr *symtab_hdr;
7723 struct elf_link_hash_entry **sym_hashes;
7724 bfd_signed_vma *local_got_refcounts;
7725 const Elf_Internal_Rela *rel, *relend;
7726 unsigned long r_symndx;
7727 struct elf_link_hash_entry *h;
7728
7729 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7730 sym_hashes = elf_sym_hashes (abfd);
7731 local_got_refcounts = elf_local_got_refcounts (abfd);
7732
7733 relend = relocs + sec->reloc_count;
7734 for (rel = relocs; rel < relend; rel++)
7735 switch (ELF_R_TYPE (abfd, rel->r_info))
7736 {
7737 case R_MIPS_GOT16:
7738 case R_MIPS_CALL16:
7739 case R_MIPS_CALL_HI16:
7740 case R_MIPS_CALL_LO16:
7741 case R_MIPS_GOT_HI16:
7742 case R_MIPS_GOT_LO16:
4a14403c
TS		 7743 case R_MIPS_GOT_DISP:
7744 case R_MIPS_GOT_PAGE:
7745 case R_MIPS_GOT_OFST:
b49e97c9
TS		 7746 /* ??? It would seem that the existing MIPS code does no sort
7747 of reference counting or whatnot on its GOT and PLT entries,
7748 so it is not possible to garbage collect them at this time. */
7749 break;
7750
7751 default:
7752 break;
7753 }
7754#endif
7755
b34976b6 7756 return TRUE;
b49e97c9
TS		 7757}
7758\f
7759/* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7760 hiding the old indirect symbol. Process additional relocation
7761 information. Also called for weakdefs, in which case we just let
7762 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7763
7764void
b48fa14c
AM		 7765_bfd_mips_elf_copy_indirect_symbol (bed, dir, ind)
7766 struct elf_backend_data *bed;
b49e97c9
TS		 7767 struct elf_link_hash_entry *dir, *ind;
7768{
7769 struct mips_elf_link_hash_entry *dirmips, *indmips;
7770
b48fa14c 7771 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
b49e97c9
TS		 7772
7773 if (ind->root.type != bfd_link_hash_indirect)
7774 return;
7775
7776 dirmips = (struct mips_elf_link_hash_entry *) dir;
7777 indmips = (struct mips_elf_link_hash_entry *) ind;
7778 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
7779 if (indmips->readonly_reloc)
b34976b6 7780 dirmips->readonly_reloc = TRUE;
b49e97c9
TS		 7781 if (dirmips->min_dyn_reloc_index == 0
7782 || (indmips->min_dyn_reloc_index != 0
7783 && indmips->min_dyn_reloc_index < dirmips->min_dyn_reloc_index))
7784 dirmips->min_dyn_reloc_index = indmips->min_dyn_reloc_index;
7785 if (indmips->no_fn_stub)
b34976b6 7786 dirmips->no_fn_stub = TRUE;
b49e97c9
TS		 7787}
7788
7789void
7790_bfd_mips_elf_hide_symbol (info, entry, force_local)
7791 struct bfd_link_info *info;
7792 struct elf_link_hash_entry *entry;
b34976b6 7793 bfd_boolean force_local;
b49e97c9
TS		 7794{
7795 bfd *dynobj;
7796 asection *got;
7797 struct mips_got_info *g;
7798 struct mips_elf_link_hash_entry *h;
7c5fcef7 7799
b49e97c9 7800 h = (struct mips_elf_link_hash_entry *) entry;
7c5fcef7
L		 7801 if (h->forced_local)
7802 return;
b34976b6 7803 h->forced_local = TRUE;
7c5fcef7 7804
b49e97c9 7805 dynobj = elf_hash_table (info)->dynobj;
c45a316a 7806 if (dynobj != NULL)
f4416af6 7807 {
c45a316a
AM		 7808 got = mips_elf_got_section (dynobj, FALSE);
7809 g = mips_elf_section_data (got)->u.got_info;
f4416af6 7810
c45a316a
AM		 7811 if (g->next)
7812 {
7813 struct mips_got_entry e;
7814 struct mips_got_info *gg = g;
7815
7816 /* Since we're turning what used to be a global symbol into a
7817 local one, bump up the number of local entries of each GOT
7818 that had an entry for it. This will automatically decrease
7819 the number of global entries, since global_gotno is actually
7820 the upper limit of global entries. */
7821 e.abfd = dynobj;
7822 e.symndx = -1;
7823 e.d.h = h;
7824
7825 for (g = g->next; g != gg; g = g->next)
7826 if (htab_find (g->got_entries, &e))
7827 {
7828 BFD_ASSERT (g->global_gotno > 0);
7829 g->local_gotno++;
7830 g->global_gotno--;
7831 }
b49e97c9 7832
c45a316a
AM		 7833 /* If this was a global symbol forced into the primary GOT, we
7834 no longer need an entry for it. We can't release the entry
7835 at this point, but we must at least stop counting it as one
7836 of the symbols that required a forced got entry. */
7837 if (h->root.got.offset == 2)
7838 {
7839 BFD_ASSERT (gg->assigned_gotno > 0);
7840 gg->assigned_gotno--;
7841 }
7842 }
7843 else if (g->global_gotno == 0 && g->global_gotsym == NULL)
7844 /* If we haven't got through GOT allocation yet, just bump up the
7845 number of local entries, as this symbol won't be counted as
7846 global. */
7847 g->local_gotno++;
7848 else if (h->root.got.offset == 1)
f4416af6 7849 {
c45a316a
AM		 7850 /* If we're past non-multi-GOT allocation and this symbol had
7851 been marked for a global got entry, give it a local entry
7852 instead. */
7853 BFD_ASSERT (g->global_gotno > 0);
7854 g->local_gotno++;
7855 g->global_gotno--;
f4416af6
AO		 7856 }
7857 }
f4416af6
AO		 7858
7859 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
b49e97c9
TS		 7860}
7861\f
d01414a5
TS		 7862#define PDR_SIZE 32
7863
b34976b6 7864bfd_boolean
d01414a5
TS		 7865_bfd_mips_elf_discard_info (abfd, cookie, info)
7866 bfd *abfd;
7867 struct elf_reloc_cookie *cookie;
7868 struct bfd_link_info *info;
7869{
7870 asection *o;
b34976b6 7871 bfd_boolean ret = FALSE;
d01414a5
TS		 7872 unsigned char *tdata;
7873 size_t i, skip;
7874
7875 o = bfd_get_section_by_name (abfd, ".pdr");
7876 if (! o)
b34976b6 7877 return FALSE;
d01414a5 7878 if (o->_raw_size == 0)
b34976b6 7879 return FALSE;
d01414a5 7880 if (o->_raw_size % PDR_SIZE != 0)
b34976b6 7881 return FALSE;
d01414a5
TS		 7882 if (o->output_section != NULL
7883 && bfd_is_abs_section (o->output_section))
b34976b6 7884 return FALSE;
d01414a5
TS		 7885
7886 tdata = bfd_zmalloc (o->_raw_size / PDR_SIZE);
7887 if (! tdata)
b34976b6 7888 return FALSE;
d01414a5 7889
45d6a902
AM		 7890 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, (PTR) NULL,
7891 (Elf_Internal_Rela *) NULL,
7892 info->keep_memory);
d01414a5
TS		 7893 if (!cookie->rels)
7894 {
7895 free (tdata);
b34976b6 7896 return FALSE;
d01414a5
TS		 7897 }
7898
7899 cookie->rel = cookie->rels;
7900 cookie->relend = cookie->rels + o->reloc_count;
7901
7902 for (i = 0, skip = 0; i < o->_raw_size; i ++)
7903 {
ee6423ed 7904 if (MNAME(abfd,_bfd_elf,reloc_symbol_deleted_p) (i * PDR_SIZE, cookie))
d01414a5
TS		 7905 {
7906 tdata[i] = 1;
7907 skip ++;
7908 }
7909 }
7910
7911 if (skip != 0)
7912 {
f0abc2a1 7913 mips_elf_section_data (o)->u.tdata = tdata;
d01414a5 7914 o->_cooked_size = o->_raw_size - skip * PDR_SIZE;
b34976b6 7915 ret = TRUE;
d01414a5
TS		 7916 }
7917 else
7918 free (tdata);
7919
7920 if (! info->keep_memory)
7921 free (cookie->rels);
7922
7923 return ret;
7924}
7925
b34976b6 7926bfd_boolean
53bfd6b4
MR		 7927_bfd_mips_elf_ignore_discarded_relocs (sec)
7928 asection *sec;
7929{
7930 if (strcmp (sec->name, ".pdr") == 0)
b34976b6
AM		 7931 return TRUE;
7932 return FALSE;
53bfd6b4 7933}
d01414a5 7934
b34976b6 7935bfd_boolean
d01414a5
TS		 7936_bfd_mips_elf_write_section (output_bfd, sec, contents)
7937 bfd *output_bfd;
7938 asection *sec;
7939 bfd_byte *contents;
7940{
7941 bfd_byte *to, *from, *end;
7942 int i;
7943
7944 if (strcmp (sec->name, ".pdr") != 0)
b34976b6 7945 return FALSE;
d01414a5 7946
f0abc2a1 7947 if (mips_elf_section_data (sec)->u.tdata == NULL)
b34976b6 7948 return FALSE;
d01414a5
TS		 7949
7950 to = contents;
7951 end = contents + sec->_raw_size;
7952 for (from = contents, i = 0;
7953 from < end;
7954 from += PDR_SIZE, i++)
7955 {
f0abc2a1 7956 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
d01414a5
TS		 7957 continue;
7958 if (to != from)
7959 memcpy (to, from, PDR_SIZE);
7960 to += PDR_SIZE;
7961 }
7962 bfd_set_section_contents (output_bfd, sec->output_section, contents,
7963 (file_ptr) sec->output_offset,
7964 sec->_cooked_size);
b34976b6 7965 return TRUE;
d01414a5 7966}
53bfd6b4 7967\f
b49e97c9
TS		 7968/* MIPS ELF uses a special find_nearest_line routine in order the
7969 handle the ECOFF debugging information. */
7970
7971struct mips_elf_find_line
7972{
7973 struct ecoff_debug_info d;
7974 struct ecoff_find_line i;
7975};
7976
b34976b6 7977bfd_boolean
b49e97c9
TS		 7978_bfd_mips_elf_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
7979 functionname_ptr, line_ptr)
7980 bfd *abfd;
7981 asection *section;
7982 asymbol **symbols;
7983 bfd_vma offset;
7984 const char **filename_ptr;
7985 const char **functionname_ptr;
7986 unsigned int *line_ptr;
7987{
7988 asection *msec;
7989
7990 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7991 filename_ptr, functionname_ptr,
7992 line_ptr))
b34976b6 7993 return TRUE;
b49e97c9
TS		 7994
7995 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7996 filename_ptr, functionname_ptr,
7997 line_ptr,
7998 (unsigned) (ABI_64_P (abfd) ? 8 : 0),
7999 &elf_tdata (abfd)->dwarf2_find_line_info))
b34976b6 8000 return TRUE;
b49e97c9
TS		 8001
8002 msec = bfd_get_section_by_name (abfd, ".mdebug");
8003 if (msec != NULL)
8004 {
8005 flagword origflags;
8006 struct mips_elf_find_line *fi;
8007 const struct ecoff_debug_swap * const swap =
8008 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
8009
8010 /* If we are called during a link, mips_elf_final_link may have
8011 cleared the SEC_HAS_CONTENTS field. We force it back on here
8012 if appropriate (which it normally will be). */
8013 origflags = msec->flags;
8014 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
8015 msec->flags |= SEC_HAS_CONTENTS;
8016
8017 fi = elf_tdata (abfd)->find_line_info;
8018 if (fi == NULL)
8019 {
8020 bfd_size_type external_fdr_size;
8021 char *fraw_src;
8022 char *fraw_end;
8023 struct fdr *fdr_ptr;
8024 bfd_size_type amt = sizeof (struct mips_elf_find_line);
8025
8026 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
8027 if (fi == NULL)
8028 {
8029 msec->flags = origflags;
b34976b6 8030 return FALSE;
b49e97c9
TS		 8031 }
8032
8033 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
8034 {
8035 msec->flags = origflags;
b34976b6 8036 return FALSE;
b49e97c9
TS		 8037 }
8038
8039 /* Swap in the FDR information. */
8040 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
8041 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
8042 if (fi->d.fdr == NULL)
8043 {
8044 msec->flags = origflags;
b34976b6 8045 return FALSE;
b49e97c9
TS		 8046 }
8047 external_fdr_size = swap->external_fdr_size;
8048 fdr_ptr = fi->d.fdr;
8049 fraw_src = (char *) fi->d.external_fdr;
8050 fraw_end = (fraw_src
8051 + fi->d.symbolic_header.ifdMax * external_fdr_size);
8052 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
8053 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
8054
8055 elf_tdata (abfd)->find_line_info = fi;
8056
8057 /* Note that we don't bother to ever free this information.
8058 find_nearest_line is either called all the time, as in
8059 objdump -l, so the information should be saved, or it is
8060 rarely called, as in ld error messages, so the memory
8061 wasted is unimportant. Still, it would probably be a
8062 good idea for free_cached_info to throw it away. */
8063 }
8064
8065 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
8066 &fi->i, filename_ptr, functionname_ptr,
8067 line_ptr))
8068 {
8069 msec->flags = origflags;
b34976b6 8070 return TRUE;
b49e97c9
TS		 8071 }
8072
8073 msec->flags = origflags;
8074 }
8075
8076 /* Fall back on the generic ELF find_nearest_line routine. */
8077
8078 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
8079 filename_ptr, functionname_ptr,
8080 line_ptr);
8081}
8082\f
8083/* When are writing out the .options or .MIPS.options section,
8084 remember the bytes we are writing out, so that we can install the
8085 GP value in the section_processing routine. */
8086
b34976b6 8087bfd_boolean
b49e97c9
TS		 8088_bfd_mips_elf_set_section_contents (abfd, section, location, offset, count)
8089 bfd *abfd;
8090 sec_ptr section;
8091 PTR location;
8092 file_ptr offset;
8093 bfd_size_type count;
8094{
8095 if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8096 {
8097 bfd_byte *c;
8098
8099 if (elf_section_data (section) == NULL)
8100 {
8101 bfd_size_type amt = sizeof (struct bfd_elf_section_data);
8102 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
8103 if (elf_section_data (section) == NULL)
b34976b6 8104 return FALSE;
b49e97c9 8105 }
f0abc2a1 8106 c = mips_elf_section_data (section)->u.tdata;
b49e97c9
TS		 8107 if (c == NULL)
8108 {
8109 bfd_size_type size;
8110
8111 if (section->_cooked_size != 0)
8112 size = section->_cooked_size;
8113 else
8114 size = section->_raw_size;
8115 c = (bfd_byte *) bfd_zalloc (abfd, size);
8116 if (c == NULL)
b34976b6 8117 return FALSE;
f0abc2a1 8118 mips_elf_section_data (section)->u.tdata = c;
b49e97c9
TS		 8119 }
8120
8121 memcpy (c + offset, location, (size_t) count);
8122 }
8123
8124 return _bfd_elf_set_section_contents (abfd, section, location, offset,
8125 count);
8126}
8127
8128/* This is almost identical to bfd_generic_get_... except that some
8129 MIPS relocations need to be handled specially. Sigh. */
8130
8131bfd_byte *
8132_bfd_elf_mips_get_relocated_section_contents (abfd, link_info, link_order,
8133 data, relocateable, symbols)
8134 bfd *abfd;
8135 struct bfd_link_info *link_info;
8136 struct bfd_link_order *link_order;
8137 bfd_byte *data;
b34976b6 8138 bfd_boolean relocateable;
b49e97c9
TS		 8139 asymbol **symbols;
8140{
8141 /* Get enough memory to hold the stuff */
8142 bfd *input_bfd = link_order->u.indirect.section->owner;
8143 asection *input_section = link_order->u.indirect.section;
8144
8145 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
8146 arelent **reloc_vector = NULL;
8147 long reloc_count;
8148
8149 if (reloc_size < 0)
8150 goto error_return;
8151
8152 reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
8153 if (reloc_vector == NULL && reloc_size != 0)
8154 goto error_return;
8155
8156 /* read in the section */
8157 if (!bfd_get_section_contents (input_bfd,
8158 input_section,
8159 (PTR) data,
8160 (file_ptr) 0,
8161 input_section->_raw_size))
8162 goto error_return;
8163
8164 /* We're not relaxing the section, so just copy the size info */
8165 input_section->_cooked_size = input_section->_raw_size;
b34976b6 8166 input_section->reloc_done = TRUE;
b49e97c9
TS		 8167
8168 reloc_count = bfd_canonicalize_reloc (input_bfd,
8169 input_section,
8170 reloc_vector,
8171 symbols);
8172 if (reloc_count < 0)
8173 goto error_return;
8174
8175 if (reloc_count > 0)
8176 {
8177 arelent **parent;
8178 /* for mips */
8179 int gp_found;
8180 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
8181
8182 {
8183 struct bfd_hash_entry *h;
8184 struct bfd_link_hash_entry *lh;
8185 /* Skip all this stuff if we aren't mixing formats. */
8186 if (abfd && input_bfd
8187 && abfd->xvec == input_bfd->xvec)
8188 lh = 0;
8189 else
8190 {
b34976b6 8191 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
b49e97c9
TS		 8192 lh = (struct bfd_link_hash_entry *) h;
8193 }
8194 lookup:
8195 if (lh)
8196 {
8197 switch (lh->type)
8198 {
8199 case bfd_link_hash_undefined:
8200 case bfd_link_hash_undefweak:
8201 case bfd_link_hash_common:
8202 gp_found = 0;
8203 break;
8204 case bfd_link_hash_defined:
8205 case bfd_link_hash_defweak:
8206 gp_found = 1;
8207 gp = lh->u.def.value;
8208 break;
8209 case bfd_link_hash_indirect:
8210 case bfd_link_hash_warning:
8211 lh = lh->u.i.link;
8212 /* @@FIXME ignoring warning for now */
8213 goto lookup;
8214 case bfd_link_hash_new:
8215 default:
8216 abort ();
8217 }
8218 }
8219 else
8220 gp_found = 0;
8221 }
8222 /* end mips */
8223 for (parent = reloc_vector; *parent != (arelent *) NULL;
8224 parent++)
8225 {
8226 char *error_message = (char *) NULL;
8227 bfd_reloc_status_type r;
8228
8229 /* Specific to MIPS: Deal with relocation types that require
8230 knowing the gp of the output bfd. */
8231 asymbol *sym = *(*parent)->sym_ptr_ptr;
8232 if (bfd_is_abs_section (sym->section) && abfd)
8233 {
44c410de 8234 /* The special_function wouldn't get called anyway. */
b49e97c9
TS		 8235 }
8236 else if (!gp_found)
8237 {
8238 /* The gp isn't there; let the special function code
8239 fall over on its own. */
8240 }
8241 else if ((*parent)->howto->special_function
8242 == _bfd_mips_elf32_gprel16_reloc)
8243 {
8244 /* bypass special_function call */
8245 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
8246 input_section, relocateable,
8247 (PTR) data, gp);
8248 goto skip_bfd_perform_relocation;
8249 }
8250 /* end mips specific stuff */
8251
8252 r = bfd_perform_relocation (input_bfd,
8253 *parent,
8254 (PTR) data,
8255 input_section,
8256 relocateable ? abfd : (bfd *) NULL,
8257 &error_message);
8258 skip_bfd_perform_relocation:
8259
8260 if (relocateable)
8261 {
8262 asection *os = input_section->output_section;
8263
8264 /* A partial link, so keep the relocs */
8265 os->orelocation[os->reloc_count] = *parent;
8266 os->reloc_count++;
8267 }
8268
8269 if (r != bfd_reloc_ok)
8270 {
8271 switch (r)
8272 {
8273 case bfd_reloc_undefined:
8274 if (!((*link_info->callbacks->undefined_symbol)
8275 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8276 input_bfd, input_section, (*parent)->address,
b34976b6 8277 TRUE)))
b49e97c9
TS		 8278 goto error_return;
8279 break;
8280 case bfd_reloc_dangerous:
8281 BFD_ASSERT (error_message != (char *) NULL);
8282 if (!((*link_info->callbacks->reloc_dangerous)
8283 (link_info, error_message, input_bfd, input_section,
8284 (*parent)->address)))
8285 goto error_return;
8286 break;
8287 case bfd_reloc_overflow:
8288 if (!((*link_info->callbacks->reloc_overflow)
8289 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8290 (*parent)->howto->name, (*parent)->addend,
8291 input_bfd, input_section, (*parent)->address)))
8292 goto error_return;
8293 break;
8294 case bfd_reloc_outofrange:
8295 default:
8296 abort ();
8297 break;
8298 }
8299
8300 }
8301 }
8302 }
8303 if (reloc_vector != NULL)
8304 free (reloc_vector);
8305 return data;
8306
8307error_return:
8308 if (reloc_vector != NULL)
8309 free (reloc_vector);
8310 return NULL;
8311}
8312\f
8313/* Create a MIPS ELF linker hash table. */
8314
8315struct bfd_link_hash_table *
8316_bfd_mips_elf_link_hash_table_create (abfd)
8317 bfd *abfd;
8318{
8319 struct mips_elf_link_hash_table *ret;
8320 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
8321
e2d34d7d 8322 ret = (struct mips_elf_link_hash_table *) bfd_malloc (amt);
b49e97c9
TS		 8323 if (ret == (struct mips_elf_link_hash_table *) NULL)
8324 return NULL;
8325
8326 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
8327 mips_elf_link_hash_newfunc))
8328 {
e2d34d7d 8329 free (ret);
b49e97c9
TS		 8330 return NULL;
8331 }
8332
8333#if 0
8334 /* We no longer use this. */
8335 for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
8336 ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
8337#endif
8338 ret->procedure_count = 0;
8339 ret->compact_rel_size = 0;
b34976b6 8340 ret->use_rld_obj_head = FALSE;
b49e97c9 8341 ret->rld_value = 0;
b34976b6 8342 ret->mips16_stubs_seen = FALSE;
b49e97c9
TS		 8343
8344 return &ret->root.root;
8345}
8346\f
8347/* We need to use a special link routine to handle the .reginfo and
8348 the .mdebug sections. We need to merge all instances of these
8349 sections together, not write them all out sequentially. */
8350
b34976b6 8351bfd_boolean
b49e97c9
TS		 8352_bfd_mips_elf_final_link (abfd, info)
8353 bfd *abfd;
8354 struct bfd_link_info *info;
8355{
8356 asection **secpp;
8357 asection *o;
8358 struct bfd_link_order *p;
8359 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
8360 asection *rtproc_sec;
8361 Elf32_RegInfo reginfo;
8362 struct ecoff_debug_info debug;
8363 const struct ecoff_debug_swap *swap
8364 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
8365 HDRR *symhdr = &debug.symbolic_header;
8366 PTR mdebug_handle = NULL;
8367 asection *s;
8368 EXTR esym;
8369 unsigned int i;
8370 bfd_size_type amt;
8371
8372 static const char * const secname[] =
8373 {
8374 ".text", ".init", ".fini", ".data",
8375 ".rodata", ".sdata", ".sbss", ".bss"
8376 };
8377 static const int sc[] =
8378 {
8379 scText, scInit, scFini, scData,
8380 scRData, scSData, scSBss, scBss
8381 };
8382
8383 /* If all the things we linked together were PIC, but we're
8384 producing an executable (rather than a shared object), then the
8385 resulting file is CPIC (i.e., it calls PIC code.) */
8386 if (!info->shared
8387 && !info->relocateable
8388 && elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
8389 {
8390 elf_elfheader (abfd)->e_flags &= ~EF_MIPS_PIC;
8391 elf_elfheader (abfd)->e_flags |= EF_MIPS_CPIC;
8392 }
8393
8394 /* We'd carefully arranged the dynamic symbol indices, and then the
8395 generic size_dynamic_sections renumbered them out from under us.
8396 Rather than trying somehow to prevent the renumbering, just do
8397 the sort again. */
8398 if (elf_hash_table (info)->dynamic_sections_created)
8399 {
8400 bfd *dynobj;
8401 asection *got;
8402 struct mips_got_info *g;
8403
8404 /* When we resort, we must tell mips_elf_sort_hash_table what
8405 the lowest index it may use is. That's the number of section
8406 symbols we're going to add. The generic ELF linker only
8407 adds these symbols when building a shared object. Note that
8408 we count the sections after (possibly) removing the .options
8409 section above. */
8410 if (! mips_elf_sort_hash_table (info, (info->shared
8411 ? bfd_count_sections (abfd) + 1
8412 : 1)))
b34976b6 8413 return FALSE;
b49e97c9
TS		 8414
8415 /* Make sure we didn't grow the global .got region. */
8416 dynobj = elf_hash_table (info)->dynobj;
f4416af6 8417 got = mips_elf_got_section (dynobj, FALSE);
f0abc2a1 8418 g = mips_elf_section_data (got)->u.got_info;
b49e97c9
TS		 8419
8420 if (g->global_gotsym != NULL)
8421 BFD_ASSERT ((elf_hash_table (info)->dynsymcount
8422 - g->global_gotsym->dynindx)
8423 <= g->global_gotno);
8424 }
8425
a902ee94
SC		 8426#if 0
8427 /* We want to set the GP value for ld -r. */
b49e97c9
TS		 8428 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8429 include it, even though we don't process it quite right. (Some
8430 entries are supposed to be merged.) Empirically, we seem to be
8431 better off including it then not. */
8432 if (IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
8433 for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8434 {
8435 if (strcmp ((*secpp)->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8436 {
8437 for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8438 if (p->type == bfd_indirect_link_order)
8439 p->u.indirect.section->flags &= ~SEC_HAS_CONTENTS;
8440 (*secpp)->link_order_head = NULL;
8441 bfd_section_list_remove (abfd, secpp);
8442 --abfd->section_count;
8443
8444 break;
8445 }
8446 }
8447
8448 /* We include .MIPS.options, even though we don't process it quite right.
8449 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8450 to be better off including it than not. */
8451 for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8452 {
8453 if (strcmp ((*secpp)->name, ".MIPS.options") == 0)
8454 {
8455 for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8456 if (p->type == bfd_indirect_link_order)
8457 p->u.indirect.section->flags &=~ SEC_HAS_CONTENTS;
8458 (*secpp)->link_order_head = NULL;
8459 bfd_section_list_remove (abfd, secpp);
8460 --abfd->section_count;
b34976b6 8461
b49e97c9
TS		 8462 break;
8463 }
8464 }
a902ee94 8465#endif
b49e97c9
TS		 8466
8467 /* Get a value for the GP register. */
8468 if (elf_gp (abfd) == 0)
8469 {
8470 struct bfd_link_hash_entry *h;
8471
b34976b6 8472 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
b49e97c9
TS		 8473 if (h != (struct bfd_link_hash_entry *) NULL
8474 && h->type == bfd_link_hash_defined)
8475 elf_gp (abfd) = (h->u.def.value
8476 + h->u.def.section->output_section->vma
8477 + h->u.def.section->output_offset);
8478 else if (info->relocateable)
8479 {
8480 bfd_vma lo = MINUS_ONE;
8481
8482 /* Find the GP-relative section with the lowest offset. */
8483 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
8484 if (o->vma < lo
8485 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
8486 lo = o->vma;
8487
8488 /* And calculate GP relative to that. */
8489 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
8490 }
8491 else
8492 {
8493 /* If the relocate_section function needs to do a reloc
8494 involving the GP value, it should make a reloc_dangerous
8495 callback to warn that GP is not defined. */
8496 }
8497 }
8498
8499 /* Go through the sections and collect the .reginfo and .mdebug
8500 information. */
8501 reginfo_sec = NULL;
8502 mdebug_sec = NULL;
8503 gptab_data_sec = NULL;
8504 gptab_bss_sec = NULL;
8505 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
8506 {
8507 if (strcmp (o->name, ".reginfo") == 0)
8508 {
8509 memset (&reginfo, 0, sizeof reginfo);
8510
8511 /* We have found the .reginfo section in the output file.
8512 Look through all the link_orders comprising it and merge
8513 the information together. */
8514 for (p = o->link_order_head;
8515 p != (struct bfd_link_order *) NULL;
8516 p = p->next)
8517 {
8518 asection *input_section;
8519 bfd *input_bfd;
8520 Elf32_External_RegInfo ext;
8521 Elf32_RegInfo sub;
8522
8523 if (p->type != bfd_indirect_link_order)
8524 {
8525 if (p->type == bfd_data_link_order)
8526 continue;
8527 abort ();
8528 }
8529
8530 input_section = p->u.indirect.section;
8531 input_bfd = input_section->owner;
8532
8533 /* The linker emulation code has probably clobbered the
8534 size to be zero bytes. */
8535 if (input_section->_raw_size == 0)
8536 input_section->_raw_size = sizeof (Elf32_External_RegInfo);
8537
8538 if (! bfd_get_section_contents (input_bfd, input_section,
8539 (PTR) &ext,
8540 (file_ptr) 0,
8541 (bfd_size_type) sizeof ext))
b34976b6 8542 return FALSE;
b49e97c9
TS		 8543
8544 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
8545
8546 reginfo.ri_gprmask |= sub.ri_gprmask;
8547 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
8548 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
8549 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
8550 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
8551
8552 /* ri_gp_value is set by the function
8553 mips_elf32_section_processing when the section is
8554 finally written out. */
8555
8556 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8557 elf_link_input_bfd ignores this section. */
8558 input_section->flags &= ~SEC_HAS_CONTENTS;
8559 }
8560
8561 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8562 BFD_ASSERT(o->_raw_size == sizeof (Elf32_External_RegInfo));
8563
8564 /* Skip this section later on (I don't think this currently
8565 matters, but someday it might). */
8566 o->link_order_head = (struct bfd_link_order *) NULL;
8567
8568 reginfo_sec = o;
8569 }
8570
8571 if (strcmp (o->name, ".mdebug") == 0)
8572 {
8573 struct extsym_info einfo;
8574 bfd_vma last;
8575
8576 /* We have found the .mdebug section in the output file.
8577 Look through all the link_orders comprising it and merge
8578 the information together. */
8579 symhdr->magic = swap->sym_magic;
8580 /* FIXME: What should the version stamp be? */
8581 symhdr->vstamp = 0;
8582 symhdr->ilineMax = 0;
8583 symhdr->cbLine = 0;
8584 symhdr->idnMax = 0;
8585 symhdr->ipdMax = 0;
8586 symhdr->isymMax = 0;
8587 symhdr->ioptMax = 0;
8588 symhdr->iauxMax = 0;
8589 symhdr->issMax = 0;
8590 symhdr->issExtMax = 0;
8591 symhdr->ifdMax = 0;
8592 symhdr->crfd = 0;
8593 symhdr->iextMax = 0;
8594
8595 /* We accumulate the debugging information itself in the
8596 debug_info structure. */
8597 debug.line = NULL;
8598 debug.external_dnr = NULL;
8599 debug.external_pdr = NULL;
8600 debug.external_sym = NULL;
8601 debug.external_opt = NULL;
8602 debug.external_aux = NULL;
8603 debug.ss = NULL;
8604 debug.ssext = debug.ssext_end = NULL;
8605 debug.external_fdr = NULL;
8606 debug.external_rfd = NULL;
8607 debug.external_ext = debug.external_ext_end = NULL;
8608
8609 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
8610 if (mdebug_handle == (PTR) NULL)
b34976b6 8611 return FALSE;
b49e97c9
TS		 8612
8613 esym.jmptbl = 0;
8614 esym.cobol_main = 0;
8615 esym.weakext = 0;
8616 esym.reserved = 0;
8617 esym.ifd = ifdNil;
8618 esym.asym.iss = issNil;
8619 esym.asym.st = stLocal;
8620 esym.asym.reserved = 0;
8621 esym.asym.index = indexNil;
8622 last = 0;
8623 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
8624 {
8625 esym.asym.sc = sc[i];
8626 s = bfd_get_section_by_name (abfd, secname[i]);
8627 if (s != NULL)
8628 {
8629 esym.asym.value = s->vma;
8630 last = s->vma + s->_raw_size;
8631 }
8632 else
8633 esym.asym.value = last;
8634 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
8635 secname[i], &esym))
b34976b6 8636 return FALSE;
b49e97c9
TS		 8637 }
8638
8639 for (p = o->link_order_head;
8640 p != (struct bfd_link_order *) NULL;
8641 p = p->next)
8642 {
8643 asection *input_section;
8644 bfd *input_bfd;
8645 const struct ecoff_debug_swap *input_swap;
8646 struct ecoff_debug_info input_debug;
8647 char *eraw_src;
8648 char *eraw_end;
8649
8650 if (p->type != bfd_indirect_link_order)
8651 {
8652 if (p->type == bfd_data_link_order)
8653 continue;
8654 abort ();
8655 }
8656
8657 input_section = p->u.indirect.section;
8658 input_bfd = input_section->owner;
8659
8660 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
8661 || (get_elf_backend_data (input_bfd)
8662 ->elf_backend_ecoff_debug_swap) == NULL)
8663 {
8664 /* I don't know what a non MIPS ELF bfd would be
8665 doing with a .mdebug section, but I don't really
8666 want to deal with it. */
8667 continue;
8668 }
8669
8670 input_swap = (get_elf_backend_data (input_bfd)
8671 ->elf_backend_ecoff_debug_swap);
8672
8673 BFD_ASSERT (p->size == input_section->_raw_size);
8674
8675 /* The ECOFF linking code expects that we have already
8676 read in the debugging information and set up an
8677 ecoff_debug_info structure, so we do that now. */
8678 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
8679 &input_debug))
b34976b6 8680 return FALSE;
b49e97c9
TS		 8681
8682 if (! (bfd_ecoff_debug_accumulate
8683 (mdebug_handle, abfd, &debug, swap, input_bfd,
8684 &input_debug, input_swap, info)))
b34976b6 8685 return FALSE;
b49e97c9
TS		 8686
8687 /* Loop through the external symbols. For each one with
8688 interesting information, try to find the symbol in
8689 the linker global hash table and save the information
8690 for the output external symbols. */
8691 eraw_src = input_debug.external_ext;
8692 eraw_end = (eraw_src
8693 + (input_debug.symbolic_header.iextMax
8694 * input_swap->external_ext_size));
8695 for (;
8696 eraw_src < eraw_end;
8697 eraw_src += input_swap->external_ext_size)
8698 {
8699 EXTR ext;
8700 const char *name;
8701 struct mips_elf_link_hash_entry *h;
8702
8703 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
8704 if (ext.asym.sc == scNil
8705 || ext.asym.sc == scUndefined
8706 || ext.asym.sc == scSUndefined)
8707 continue;
8708
8709 name = input_debug.ssext + ext.asym.iss;
8710 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
b34976b6 8711 name, FALSE, FALSE, TRUE);
b49e97c9
TS		 8712 if (h == NULL || h->esym.ifd != -2)
8713 continue;
8714
8715 if (ext.ifd != -1)
8716 {
8717 BFD_ASSERT (ext.ifd
8718 < input_debug.symbolic_header.ifdMax);
8719 ext.ifd = input_debug.ifdmap[ext.ifd];
8720 }
8721
8722 h->esym = ext;
8723 }
8724
8725 /* Free up the information we just read. */
8726 free (input_debug.line);
8727 free (input_debug.external_dnr);
8728 free (input_debug.external_pdr);
8729 free (input_debug.external_sym);
8730 free (input_debug.external_opt);
8731 free (input_debug.external_aux);
8732 free (input_debug.ss);
8733 free (input_debug.ssext);
8734 free (input_debug.external_fdr);
8735 free (input_debug.external_rfd);
8736 free (input_debug.external_ext);
8737
8738 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8739 elf_link_input_bfd ignores this section. */
8740 input_section->flags &= ~SEC_HAS_CONTENTS;
8741 }
8742
8743 if (SGI_COMPAT (abfd) && info->shared)
8744 {
8745 /* Create .rtproc section. */
8746 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
8747 if (rtproc_sec == NULL)
8748 {
8749 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
8750 | SEC_LINKER_CREATED | SEC_READONLY);
8751
8752 rtproc_sec = bfd_make_section (abfd, ".rtproc");
8753 if (rtproc_sec == NULL
8754 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
8755 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
b34976b6 8756 return FALSE;
b49e97c9
TS		 8757 }
8758
8759 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
8760 info, rtproc_sec,
8761 &debug))
b34976b6 8762 return FALSE;
b49e97c9
TS		 8763 }
8764
8765 /* Build the external symbol information. */
8766 einfo.abfd = abfd;
8767 einfo.info = info;
8768 einfo.debug = &debug;
8769 einfo.swap = swap;
b34976b6 8770 einfo.failed = FALSE;
b49e97c9
TS		 8771 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8772 mips_elf_output_extsym,
8773 (PTR) &einfo);
8774 if (einfo.failed)
b34976b6 8775 return FALSE;
b49e97c9
TS		 8776
8777 /* Set the size of the .mdebug section. */
8778 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
8779
8780 /* Skip this section later on (I don't think this currently
8781 matters, but someday it might). */
8782 o->link_order_head = (struct bfd_link_order *) NULL;
8783
8784 mdebug_sec = o;
8785 }
8786
8787 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
8788 {
8789 const char *subname;
8790 unsigned int c;
8791 Elf32_gptab *tab;
8792 Elf32_External_gptab *ext_tab;
8793 unsigned int j;
8794
8795 /* The .gptab.sdata and .gptab.sbss sections hold
8796 information describing how the small data area would
8797 change depending upon the -G switch. These sections
8798 not used in executables files. */
8799 if (! info->relocateable)
8800 {
8801 for (p = o->link_order_head;
8802 p != (struct bfd_link_order *) NULL;
8803 p = p->next)
8804 {
8805 asection *input_section;
8806
8807 if (p->type != bfd_indirect_link_order)
8808 {
8809 if (p->type == bfd_data_link_order)
8810 continue;
8811 abort ();
8812 }
8813
8814 input_section = p->u.indirect.section;
8815
8816 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8817 elf_link_input_bfd ignores this section. */
8818 input_section->flags &= ~SEC_HAS_CONTENTS;
8819 }
8820
8821 /* Skip this section later on (I don't think this
8822 currently matters, but someday it might). */
8823 o->link_order_head = (struct bfd_link_order *) NULL;
8824
8825 /* Really remove the section. */
8826 for (secpp = &abfd->sections;
8827 *secpp != o;
8828 secpp = &(*secpp)->next)
8829 ;
8830 bfd_section_list_remove (abfd, secpp);
8831 --abfd->section_count;
8832
8833 continue;
8834 }
8835
8836 /* There is one gptab for initialized data, and one for
8837 uninitialized data. */
8838 if (strcmp (o->name, ".gptab.sdata") == 0)
8839 gptab_data_sec = o;
8840 else if (strcmp (o->name, ".gptab.sbss") == 0)
8841 gptab_bss_sec = o;
8842 else
8843 {
8844 (*_bfd_error_handler)
8845 (_("%s: illegal section name `%s'"),
8846 bfd_get_filename (abfd), o->name);
8847 bfd_set_error (bfd_error_nonrepresentable_section);
b34976b6 8848 return FALSE;
b49e97c9
TS		 8849 }
8850
8851 /* The linker script always combines .gptab.data and
8852 .gptab.sdata into .gptab.sdata, and likewise for
8853 .gptab.bss and .gptab.sbss. It is possible that there is
8854 no .sdata or .sbss section in the output file, in which
8855 case we must change the name of the output section. */
8856 subname = o->name + sizeof ".gptab" - 1;
8857 if (bfd_get_section_by_name (abfd, subname) == NULL)
8858 {
8859 if (o == gptab_data_sec)
8860 o->name = ".gptab.data";
8861 else
8862 o->name = ".gptab.bss";
8863 subname = o->name + sizeof ".gptab" - 1;
8864 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
8865 }
8866
8867 /* Set up the first entry. */
8868 c = 1;
8869 amt = c * sizeof (Elf32_gptab);
8870 tab = (Elf32_gptab *) bfd_malloc (amt);
8871 if (tab == NULL)
b34976b6 8872 return FALSE;
b49e97c9
TS		 8873 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
8874 tab[0].gt_header.gt_unused = 0;
8875
8876 /* Combine the input sections. */
8877 for (p = o->link_order_head;
8878 p != (struct bfd_link_order *) NULL;
8879 p = p->next)
8880 {
8881 asection *input_section;
8882 bfd *input_bfd;
8883 bfd_size_type size;
8884 unsigned long last;
8885 bfd_size_type gpentry;
8886
8887 if (p->type != bfd_indirect_link_order)
8888 {
8889 if (p->type == bfd_data_link_order)
8890 continue;
8891 abort ();
8892 }
8893
8894 input_section = p->u.indirect.section;
8895 input_bfd = input_section->owner;
8896
8897 /* Combine the gptab entries for this input section one
8898 by one. We know that the input gptab entries are
8899 sorted by ascending -G value. */
8900 size = bfd_section_size (input_bfd, input_section);
8901 last = 0;
8902 for (gpentry = sizeof (Elf32_External_gptab);
8903 gpentry < size;
8904 gpentry += sizeof (Elf32_External_gptab))
8905 {
8906 Elf32_External_gptab ext_gptab;
8907 Elf32_gptab int_gptab;
8908 unsigned long val;
8909 unsigned long add;
b34976b6 8910 bfd_boolean exact;
b49e97c9
TS		 8911 unsigned int look;
8912
8913 if (! (bfd_get_section_contents
8914 (input_bfd, input_section, (PTR) &ext_gptab,
8915 (file_ptr) gpentry,
8916 (bfd_size_type) sizeof (Elf32_External_gptab))))
8917 {
8918 free (tab);
b34976b6 8919 return FALSE;
b49e97c9
TS		 8920 }
8921
8922 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
8923 &int_gptab);
8924 val = int_gptab.gt_entry.gt_g_value;
8925 add = int_gptab.gt_entry.gt_bytes - last;
8926
b34976b6 8927 exact = FALSE;
b49e97c9
TS		 8928 for (look = 1; look < c; look++)
8929 {
8930 if (tab[look].gt_entry.gt_g_value >= val)
8931 tab[look].gt_entry.gt_bytes += add;
8932
8933 if (tab[look].gt_entry.gt_g_value == val)
b34976b6 8934 exact = TRUE;
b49e97c9
TS		 8935 }
8936
8937 if (! exact)
8938 {
8939 Elf32_gptab *new_tab;
8940 unsigned int max;
8941
8942 /* We need a new table entry. */
8943 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
8944 new_tab = (Elf32_gptab *) bfd_realloc ((PTR) tab, amt);
8945 if (new_tab == NULL)
8946 {
8947 free (tab);
b34976b6 8948 return FALSE;
b49e97c9
TS		 8949 }
8950 tab = new_tab;
8951 tab[c].gt_entry.gt_g_value = val;
8952 tab[c].gt_entry.gt_bytes = add;
8953
8954 /* Merge in the size for the next smallest -G
8955 value, since that will be implied by this new
8956 value. */
8957 max = 0;
8958 for (look = 1; look < c; look++)
8959 {
8960 if (tab[look].gt_entry.gt_g_value < val
8961 && (max == 0
8962 || (tab[look].gt_entry.gt_g_value
8963 > tab[max].gt_entry.gt_g_value)))
8964 max = look;
8965 }
8966 if (max != 0)
8967 tab[c].gt_entry.gt_bytes +=
8968 tab[max].gt_entry.gt_bytes;
8969
8970 ++c;
8971 }
8972
8973 last = int_gptab.gt_entry.gt_bytes;
8974 }
8975
8976 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8977 elf_link_input_bfd ignores this section. */
8978 input_section->flags &= ~SEC_HAS_CONTENTS;
8979 }
8980
8981 /* The table must be sorted by -G value. */
8982 if (c > 2)
8983 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
8984
8985 /* Swap out the table. */
8986 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
8987 ext_tab = (Elf32_External_gptab *) bfd_alloc (abfd, amt);
8988 if (ext_tab == NULL)
8989 {
8990 free (tab);
b34976b6 8991 return FALSE;
b49e97c9
TS		 8992 }
8993
8994 for (j = 0; j < c; j++)
8995 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
8996 free (tab);
8997
8998 o->_raw_size = c * sizeof (Elf32_External_gptab);
8999 o->contents = (bfd_byte *) ext_tab;
9000
9001 /* Skip this section later on (I don't think this currently
9002 matters, but someday it might). */
9003 o->link_order_head = (struct bfd_link_order *) NULL;
9004 }
9005 }
9006
9007 /* Invoke the regular ELF backend linker to do all the work. */
ee6423ed 9008 if (!MNAME(abfd,bfd_elf,bfd_final_link) (abfd, info))
b34976b6 9009 return FALSE;
b49e97c9
TS		 9010
9011 /* Now write out the computed sections. */
9012
9013 if (reginfo_sec != (asection *) NULL)
9014 {
9015 Elf32_External_RegInfo ext;
9016
9017 bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
9018 if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
9019 (file_ptr) 0,
9020 (bfd_size_type) sizeof ext))
b34976b6 9021 return FALSE;
b49e97c9
TS		 9022 }
9023
9024 if (mdebug_sec != (asection *) NULL)
9025 {
9026 BFD_ASSERT (abfd->output_has_begun);
9027 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
9028 swap, info,
9029 mdebug_sec->filepos))
b34976b6 9030 return FALSE;
b49e97c9
TS		 9031
9032 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
9033 }
9034
9035 if (gptab_data_sec != (asection *) NULL)
9036 {
9037 if (! bfd_set_section_contents (abfd, gptab_data_sec,
9038 gptab_data_sec->contents,
9039 (file_ptr) 0,
9040 gptab_data_sec->_raw_size))
b34976b6 9041 return FALSE;
b49e97c9
TS		 9042 }
9043
9044 if (gptab_bss_sec != (asection *) NULL)
9045 {
9046 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
9047 gptab_bss_sec->contents,
9048 (file_ptr) 0,
9049 gptab_bss_sec->_raw_size))
b34976b6 9050 return FALSE;
b49e97c9
TS		 9051 }
9052
9053 if (SGI_COMPAT (abfd))
9054 {
9055 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
9056 if (rtproc_sec != NULL)
9057 {
9058 if (! bfd_set_section_contents (abfd, rtproc_sec,
9059 rtproc_sec->contents,
9060 (file_ptr) 0,
9061 rtproc_sec->_raw_size))
b34976b6 9062 return FALSE;
b49e97c9
TS		 9063 }
9064 }
9065
b34976b6 9066 return TRUE;
b49e97c9
TS		 9067}
9068\f
64543e1a
RS		 9069/* Structure for saying that BFD machine EXTENSION extends BASE. */
9070
9071struct mips_mach_extension {
9072 unsigned long extension, base;
9073};
9074
9075
9076/* An array describing how BFD machines relate to one another. The entries
9077 are ordered topologically with MIPS I extensions listed last. */
9078
9079static const struct mips_mach_extension mips_mach_extensions[] = {
9080 /* MIPS64 extensions. */
9081 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
9082
9083 /* MIPS V extensions. */
9084 { bfd_mach_mipsisa64, bfd_mach_mips5 },
9085
9086 /* R10000 extensions. */
9087 { bfd_mach_mips12000, bfd_mach_mips10000 },
9088
9089 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
9090 vr5400 ISA, but doesn't include the multimedia stuff. It seems
9091 better to allow vr5400 and vr5500 code to be merged anyway, since
9092 many libraries will just use the core ISA. Perhaps we could add
9093 some sort of ASE flag if this ever proves a problem. */
9094 { bfd_mach_mips5500, bfd_mach_mips5400 },
9095 { bfd_mach_mips5400, bfd_mach_mips5000 },
9096
9097 /* MIPS IV extensions. */
9098 { bfd_mach_mips5, bfd_mach_mips8000 },
9099 { bfd_mach_mips10000, bfd_mach_mips8000 },
9100 { bfd_mach_mips5000, bfd_mach_mips8000 },
9101
9102 /* VR4100 extensions. */
9103 { bfd_mach_mips4120, bfd_mach_mips4100 },
9104 { bfd_mach_mips4111, bfd_mach_mips4100 },
9105
9106 /* MIPS III extensions. */
9107 { bfd_mach_mips8000, bfd_mach_mips4000 },
9108 { bfd_mach_mips4650, bfd_mach_mips4000 },
9109 { bfd_mach_mips4600, bfd_mach_mips4000 },
9110 { bfd_mach_mips4400, bfd_mach_mips4000 },
9111 { bfd_mach_mips4300, bfd_mach_mips4000 },
9112 { bfd_mach_mips4100, bfd_mach_mips4000 },
9113 { bfd_mach_mips4010, bfd_mach_mips4000 },
9114
9115 /* MIPS32 extensions. */
9116 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
9117
9118 /* MIPS II extensions. */
9119 { bfd_mach_mips4000, bfd_mach_mips6000 },
9120 { bfd_mach_mipsisa32, bfd_mach_mips6000 },
9121
9122 /* MIPS I extensions. */
9123 { bfd_mach_mips6000, bfd_mach_mips3000 },
9124 { bfd_mach_mips3900, bfd_mach_mips3000 }
9125};
9126
9127
9128/* Return true if bfd machine EXTENSION is an extension of machine BASE. */
9129
9130static bfd_boolean
9131mips_mach_extends_p (base, extension)
9132 unsigned long base, extension;
9133{
9134 size_t i;
9135
9136 for (i = 0; extension != base && i < ARRAY_SIZE (mips_mach_extensions); i++)
9137 if (extension == mips_mach_extensions[i].extension)
9138 extension = mips_mach_extensions[i].base;
9139
9140 return extension == base;
9141}
9142
9143
9144/* Return true if the given ELF header flags describe a 32-bit binary. */
00707a0e 9145
b34976b6 9146static bfd_boolean
64543e1a
RS		 9147mips_32bit_flags_p (flags)
9148 flagword flags;
00707a0e 9149{
64543e1a
RS		 9150 return ((flags & EF_MIPS_32BITMODE) != 0
9151 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
9152 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
9153 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
9154 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
9155 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
9156 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
00707a0e
RS		 9157}
9158
64543e1a 9159
b49e97c9
TS		 9160/* Merge backend specific data from an object file to the output
9161 object file when linking. */
9162
b34976b6 9163bfd_boolean
b49e97c9
TS		 9164_bfd_mips_elf_merge_private_bfd_data (ibfd, obfd)
9165 bfd *ibfd;
9166 bfd *obfd;
9167{
9168 flagword old_flags;
9169 flagword new_flags;
b34976b6
AM		 9170 bfd_boolean ok;
9171 bfd_boolean null_input_bfd = TRUE;
b49e97c9
TS		 9172 asection *sec;
9173
9174 /* Check if we have the same endianess */
82e51918 9175 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
aa701218
AO		 9176 {
9177 (*_bfd_error_handler)
9178 (_("%s: endianness incompatible with that of the selected emulation"),
9179 bfd_archive_filename (ibfd));
9180 return FALSE;
9181 }
b49e97c9
TS		 9182
9183 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
9184 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 9185 return TRUE;
b49e97c9 9186
aa701218
AO		 9187 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
9188 {
9189 (*_bfd_error_handler)
9190 (_("%s: ABI is incompatible with that of the selected emulation"),
9191 bfd_archive_filename (ibfd));
9192 return FALSE;
9193 }
9194
b49e97c9
TS		 9195 new_flags = elf_elfheader (ibfd)->e_flags;
9196 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
9197 old_flags = elf_elfheader (obfd)->e_flags;
9198
9199 if (! elf_flags_init (obfd))
9200 {
b34976b6 9201 elf_flags_init (obfd) = TRUE;
b49e97c9
TS		 9202 elf_elfheader (obfd)->e_flags = new_flags;
9203 elf_elfheader (obfd)->e_ident[EI_CLASS]
9204 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
9205
9206 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
9207 && bfd_get_arch_info (obfd)->the_default)
9208 {
9209 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
9210 bfd_get_mach (ibfd)))
b34976b6 9211 return FALSE;
b49e97c9
TS		 9212 }
9213
b34976b6 9214 return TRUE;
b49e97c9
TS		 9215 }
9216
9217 /* Check flag compatibility. */
9218
9219 new_flags &= ~EF_MIPS_NOREORDER;
9220 old_flags &= ~EF_MIPS_NOREORDER;
9221
f4416af6
AO		 9222 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9223 doesn't seem to matter. */
9224 new_flags &= ~EF_MIPS_XGOT;
9225 old_flags &= ~EF_MIPS_XGOT;
9226
b49e97c9 9227 if (new_flags == old_flags)
b34976b6 9228 return TRUE;
b49e97c9
TS		 9229
9230 /* Check to see if the input BFD actually contains any sections.
9231 If not, its flags may not have been initialised either, but it cannot
9232 actually cause any incompatibility. */
9233 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9234 {
9235 /* Ignore synthetic sections and empty .text, .data and .bss sections
9236 which are automatically generated by gas. */
9237 if (strcmp (sec->name, ".reginfo")
9238 && strcmp (sec->name, ".mdebug")
9239 && ((!strcmp (sec->name, ".text")
9240 || !strcmp (sec->name, ".data")
9241 || !strcmp (sec->name, ".bss"))
9242 && sec->_raw_size != 0))
9243 {
b34976b6 9244 null_input_bfd = FALSE;
b49e97c9
TS		 9245 break;
9246 }
9247 }
9248 if (null_input_bfd)
b34976b6 9249 return TRUE;
b49e97c9 9250
b34976b6 9251 ok = TRUE;
b49e97c9
TS		 9252
9253 if ((new_flags & EF_MIPS_PIC) != (old_flags & EF_MIPS_PIC))
9254 {
9255 new_flags &= ~EF_MIPS_PIC;
9256 old_flags &= ~EF_MIPS_PIC;
9257 (*_bfd_error_handler)
9258 (_("%s: linking PIC files with non-PIC files"),
9259 bfd_archive_filename (ibfd));
b34976b6 9260 ok = FALSE;
b49e97c9
TS		 9261 }
9262
9263 if ((new_flags & EF_MIPS_CPIC) != (old_flags & EF_MIPS_CPIC))
9264 {
9265 new_flags &= ~EF_MIPS_CPIC;
9266 old_flags &= ~EF_MIPS_CPIC;
9267 (*_bfd_error_handler)
9268 (_("%s: linking abicalls files with non-abicalls files"),
9269 bfd_archive_filename (ibfd));
b34976b6 9270 ok = FALSE;
b49e97c9
TS		 9271 }
9272
64543e1a
RS		 9273 /* Compare the ISAs. */
9274 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
b49e97c9 9275 {
64543e1a
RS		 9276 (*_bfd_error_handler)
9277 (_("%s: linking 32-bit code with 64-bit code"),
9278 bfd_archive_filename (ibfd));
9279 ok = FALSE;
9280 }
9281 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
9282 {
9283 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9284 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
b49e97c9 9285 {
64543e1a
RS		 9286 /* Copy the architecture info from IBFD to OBFD. Also copy
9287 the 32-bit flag (if set) so that we continue to recognise
9288 OBFD as a 32-bit binary. */
9289 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
9290 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
9291 elf_elfheader (obfd)->e_flags
9292 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9293
9294 /* Copy across the ABI flags if OBFD doesn't use them
9295 and if that was what caused us to treat IBFD as 32-bit. */
9296 if ((old_flags & EF_MIPS_ABI) == 0
9297 && mips_32bit_flags_p (new_flags)
9298 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
9299 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
b49e97c9
TS		 9300 }
9301 else
9302 {
64543e1a 9303 /* The ISAs aren't compatible. */
b49e97c9 9304 (*_bfd_error_handler)
64543e1a 9305 (_("%s: linking %s module with previous %s modules"),
b49e97c9 9306 bfd_archive_filename (ibfd),
64543e1a
RS		 9307 bfd_printable_name (ibfd),
9308 bfd_printable_name (obfd));
b34976b6 9309 ok = FALSE;
b49e97c9 9310 }
b49e97c9
TS		 9311 }
9312
64543e1a
RS		 9313 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9314 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9315
9316 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
b49e97c9
TS		 9317 does set EI_CLASS differently from any 32-bit ABI. */
9318 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
9319 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9320 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9321 {
9322 /* Only error if both are set (to different values). */
9323 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
9324 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9325 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9326 {
9327 (*_bfd_error_handler)
9328 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9329 bfd_archive_filename (ibfd),
9330 elf_mips_abi_name (ibfd),
9331 elf_mips_abi_name (obfd));
b34976b6 9332 ok = FALSE;
b49e97c9
TS		 9333 }
9334 new_flags &= ~EF_MIPS_ABI;
9335 old_flags &= ~EF_MIPS_ABI;
9336 }
9337
fb39dac1
RS		 9338 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9339 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
9340 {
9341 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
9342
9343 new_flags &= ~ EF_MIPS_ARCH_ASE;
9344 old_flags &= ~ EF_MIPS_ARCH_ASE;
9345 }
9346
b49e97c9
TS		 9347 /* Warn about any other mismatches */
9348 if (new_flags != old_flags)
9349 {
9350 (*_bfd_error_handler)
9351 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9352 bfd_archive_filename (ibfd), (unsigned long) new_flags,
9353 (unsigned long) old_flags);
b34976b6 9354 ok = FALSE;
b49e97c9
TS		 9355 }
9356
9357 if (! ok)
9358 {
9359 bfd_set_error (bfd_error_bad_value);
b34976b6 9360 return FALSE;
b49e97c9
TS		 9361 }
9362
b34976b6 9363 return TRUE;
b49e97c9
TS		 9364}
9365
9366/* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9367
b34976b6 9368bfd_boolean
b49e97c9
TS		 9369_bfd_mips_elf_set_private_flags (abfd, flags)
9370 bfd *abfd;
9371 flagword flags;
9372{
9373 BFD_ASSERT (!elf_flags_init (abfd)
9374 || elf_elfheader (abfd)->e_flags == flags);
9375
9376 elf_elfheader (abfd)->e_flags = flags;
b34976b6
AM		 9377 elf_flags_init (abfd) = TRUE;
9378 return TRUE;
b49e97c9
TS		 9379}
9380
b34976b6 9381bfd_boolean
b49e97c9
TS		 9382_bfd_mips_elf_print_private_bfd_data (abfd, ptr)
9383 bfd *abfd;
9384 PTR ptr;
9385{
9386 FILE *file = (FILE *) ptr;
9387
9388 BFD_ASSERT (abfd != NULL && ptr != NULL);
9389
9390 /* Print normal ELF private data. */
9391 _bfd_elf_print_private_bfd_data (abfd, ptr);
9392
9393 /* xgettext:c-format */
9394 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
9395
9396 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
9397 fprintf (file, _(" [abi=O32]"));
9398 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
9399 fprintf (file, _(" [abi=O64]"));
9400 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
9401 fprintf (file, _(" [abi=EABI32]"));
9402 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
9403 fprintf (file, _(" [abi=EABI64]"));
9404 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
9405 fprintf (file, _(" [abi unknown]"));
9406 else if (ABI_N32_P (abfd))
9407 fprintf (file, _(" [abi=N32]"));
9408 else if (ABI_64_P (abfd))
9409 fprintf (file, _(" [abi=64]"));
9410 else
9411 fprintf (file, _(" [no abi set]"));
9412
9413 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
9414 fprintf (file, _(" [mips1]"));
9415 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
9416 fprintf (file, _(" [mips2]"));
9417 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
9418 fprintf (file, _(" [mips3]"));
9419 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
9420 fprintf (file, _(" [mips4]"));
9421 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
9422 fprintf (file, _(" [mips5]"));
9423 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
9424 fprintf (file, _(" [mips32]"));
9425 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
9426 fprintf (file, _(" [mips64]"));
af7ee8bf
CD		 9427 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
9428 fprintf (file, _(" [mips32r2]"));
b49e97c9
TS		 9429 else
9430 fprintf (file, _(" [unknown ISA]"));
9431
40d32fc6
CD		 9432 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
9433 fprintf (file, _(" [mdmx]"));
9434
9435 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
9436 fprintf (file, _(" [mips16]"));
9437
b49e97c9
TS		 9438 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
9439 fprintf (file, _(" [32bitmode]"));
9440 else
9441 fprintf (file, _(" [not 32bitmode]"));
9442
9443 fputc ('\n', file);
9444
b34976b6 9445 return TRUE;
b49e97c9 9446}
GDB Binutils - Deliverables
This page took 0.512169 seconds and 4 git commands to generate.