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