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