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