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