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