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