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