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