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