1 /* BFD back-end for MIPS Extended-Coff files.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Original version by Per Bothner.
6 Full support added by Ian Lance Taylor, ian@cygnus.com.
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
24
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "coff/internal.h"
30 #include "coff/sym.h"
31 #include "coff/symconst.h"
32 #include "coff/ecoff.h"
33 #include "coff/mips.h"
34 #include "libcoff.h"
35 #include "libecoff.h"
36
37 /* Prototypes for static functions. */
38
39 static bfd_boolean mips_ecoff_bad_format_hook
40 PARAMS ((bfd *abfd, PTR filehdr));
41 static void mips_ecoff_swap_reloc_in
42 PARAMS ((bfd *, PTR, struct internal_reloc *));
43 static void mips_ecoff_swap_reloc_out
44 PARAMS ((bfd *, const struct internal_reloc *, PTR));
45 static void mips_adjust_reloc_in
46 PARAMS ((bfd *, const struct internal_reloc *, arelent *));
47 static void mips_adjust_reloc_out
48 PARAMS ((bfd *, const arelent *, struct internal_reloc *));
49 static bfd_reloc_status_type mips_generic_reloc
50 PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
51 asection *section, bfd *output_bfd, char **error));
52 static bfd_reloc_status_type mips_refhi_reloc
53 PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
54 asection *section, bfd *output_bfd, char **error));
55 static bfd_reloc_status_type mips_reflo_reloc
56 PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
57 asection *section, bfd *output_bfd, char **error));
58 static bfd_reloc_status_type mips_gprel_reloc
59 PARAMS ((bfd *abfd, arelent *reloc, asymbol *symbol, PTR data,
60 asection *section, bfd *output_bfd, char **error));
61 static void mips_relocate_hi
62 PARAMS ((struct internal_reloc *refhi, struct internal_reloc *reflo,
63 bfd *input_bfd, asection *input_section, bfd_byte *contents,
64 bfd_vma relocation));
65 static bfd_boolean mips_relocate_section
66 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, PTR));
67 static reloc_howto_type *mips_bfd_reloc_type_lookup
68 PARAMS ((bfd *, bfd_reloc_code_real_type));
69
70 /* ECOFF has COFF sections, but the debugging information is stored in
71 a completely different format. ECOFF targets use some of the
72 swapping routines from coffswap.h, and some of the generic COFF
73 routines in coffgen.c, but, unlike the real COFF targets, do not
74 use coffcode.h itself.
75
76 Get the generic COFF swapping routines, except for the reloc,
77 symbol, and lineno ones. Give them ECOFF names. */
78 #define MIPSECOFF
79 #define NO_COFF_RELOCS
80 #define NO_COFF_SYMBOLS
81 #define NO_COFF_LINENOS
82 #define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in
83 #define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
84 #define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in
85 #define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
86 #define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in
87 #define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out
88
89 #include "coffswap.h"
90
91 /* Get the ECOFF swapping routines. */
92 #define ECOFF_32
93 #include "ecoffswap.h"
94
95 /* How to process the various relocs types. */
96
97 static reloc_howto_type mips_howto_table[] =
98 {
99 /* Reloc type 0 is ignored. The reloc reading code ensures that
100 this is a reference to the .abs section, which will cause
101 bfd_perform_relocation to do nothing. */
102 HOWTO (MIPS_R_IGNORE, /* type */
103 0, /* rightshift */
104 0, /* size (0 = byte, 1 = short, 2 = long) */
105 8, /* bitsize */
106 FALSE, /* pc_relative */
107 0, /* bitpos */
108 complain_overflow_dont, /* complain_on_overflow */
109 0, /* special_function */
110 "IGNORE", /* name */
111 FALSE, /* partial_inplace */
112 0, /* src_mask */
113 0, /* dst_mask */
114 FALSE), /* pcrel_offset */
115
116 /* A 16 bit reference to a symbol, normally from a data section. */
117 HOWTO (MIPS_R_REFHALF, /* type */
118 0, /* rightshift */
119 1, /* size (0 = byte, 1 = short, 2 = long) */
120 16, /* bitsize */
121 FALSE, /* pc_relative */
122 0, /* bitpos */
123 complain_overflow_bitfield, /* complain_on_overflow */
124 mips_generic_reloc, /* special_function */
125 "REFHALF", /* name */
126 TRUE, /* partial_inplace */
127 0xffff, /* src_mask */
128 0xffff, /* dst_mask */
129 FALSE), /* pcrel_offset */
130
131 /* A 32 bit reference to a symbol, normally from a data section. */
132 HOWTO (MIPS_R_REFWORD, /* type */
133 0, /* rightshift */
134 2, /* size (0 = byte, 1 = short, 2 = long) */
135 32, /* bitsize */
136 FALSE, /* pc_relative */
137 0, /* bitpos */
138 complain_overflow_bitfield, /* complain_on_overflow */
139 mips_generic_reloc, /* special_function */
140 "REFWORD", /* name */
141 TRUE, /* partial_inplace */
142 0xffffffff, /* src_mask */
143 0xffffffff, /* dst_mask */
144 FALSE), /* pcrel_offset */
145
146 /* A 26 bit absolute jump address. */
147 HOWTO (MIPS_R_JMPADDR, /* type */
148 2, /* rightshift */
149 2, /* size (0 = byte, 1 = short, 2 = long) */
150 26, /* bitsize */
151 FALSE, /* pc_relative */
152 0, /* bitpos */
153 complain_overflow_dont, /* complain_on_overflow */
154 /* This needs complex overflow
155 detection, because the upper four
156 bits must match the PC. */
157 mips_generic_reloc, /* special_function */
158 "JMPADDR", /* name */
159 TRUE, /* partial_inplace */
160 0x3ffffff, /* src_mask */
161 0x3ffffff, /* dst_mask */
162 FALSE), /* pcrel_offset */
163
164 /* The high 16 bits of a symbol value. Handled by the function
165 mips_refhi_reloc. */
166 HOWTO (MIPS_R_REFHI, /* type */
167 16, /* rightshift */
168 2, /* size (0 = byte, 1 = short, 2 = long) */
169 16, /* bitsize */
170 FALSE, /* pc_relative */
171 0, /* bitpos */
172 complain_overflow_bitfield, /* complain_on_overflow */
173 mips_refhi_reloc, /* special_function */
174 "REFHI", /* name */
175 TRUE, /* partial_inplace */
176 0xffff, /* src_mask */
177 0xffff, /* dst_mask */
178 FALSE), /* pcrel_offset */
179
180 /* The low 16 bits of a symbol value. */
181 HOWTO (MIPS_R_REFLO, /* type */
182 0, /* rightshift */
183 2, /* size (0 = byte, 1 = short, 2 = long) */
184 16, /* bitsize */
185 FALSE, /* pc_relative */
186 0, /* bitpos */
187 complain_overflow_dont, /* complain_on_overflow */
188 mips_reflo_reloc, /* special_function */
189 "REFLO", /* name */
190 TRUE, /* partial_inplace */
191 0xffff, /* src_mask */
192 0xffff, /* dst_mask */
193 FALSE), /* pcrel_offset */
194
195 /* A reference to an offset from the gp register. Handled by the
196 function mips_gprel_reloc. */
197 HOWTO (MIPS_R_GPREL, /* type */
198 0, /* rightshift */
199 2, /* size (0 = byte, 1 = short, 2 = long) */
200 16, /* bitsize */
201 FALSE, /* pc_relative */
202 0, /* bitpos */
203 complain_overflow_signed, /* complain_on_overflow */
204 mips_gprel_reloc, /* special_function */
205 "GPREL", /* name */
206 TRUE, /* partial_inplace */
207 0xffff, /* src_mask */
208 0xffff, /* dst_mask */
209 FALSE), /* pcrel_offset */
210
211 /* A reference to a literal using an offset from the gp register.
212 Handled by the function mips_gprel_reloc. */
213 HOWTO (MIPS_R_LITERAL, /* type */
214 0, /* rightshift */
215 2, /* size (0 = byte, 1 = short, 2 = long) */
216 16, /* bitsize */
217 FALSE, /* pc_relative */
218 0, /* bitpos */
219 complain_overflow_signed, /* complain_on_overflow */
220 mips_gprel_reloc, /* special_function */
221 "LITERAL", /* name */
222 TRUE, /* partial_inplace */
223 0xffff, /* src_mask */
224 0xffff, /* dst_mask */
225 FALSE), /* pcrel_offset */
226
227 EMPTY_HOWTO (8),
228 EMPTY_HOWTO (9),
229 EMPTY_HOWTO (10),
230 EMPTY_HOWTO (11),
231
232 /* FIXME: This relocation is used (internally only) to represent branches
233 when assembling. It should never appear in output files, and
234 be removed. (It used to be used for embedded-PIC support.) */
235 HOWTO (MIPS_R_PCREL16, /* type */
236 2, /* rightshift */
237 2, /* size (0 = byte, 1 = short, 2 = long) */
238 16, /* bitsize */
239 TRUE, /* pc_relative */
240 0, /* bitpos */
241 complain_overflow_signed, /* complain_on_overflow */
242 mips_generic_reloc, /* special_function */
243 "PCREL16", /* name */
244 TRUE, /* partial_inplace */
245 0xffff, /* src_mask */
246 0xffff, /* dst_mask */
247 TRUE), /* pcrel_offset */
248 };
249
250 #define MIPS_HOWTO_COUNT \
251 (sizeof mips_howto_table / sizeof mips_howto_table[0])
252
253 /* See whether the magic number matches. */
254
255 static bfd_boolean
mips_ecoff_bad_format_hook(abfd,filehdr)256 mips_ecoff_bad_format_hook (abfd, filehdr)
257 bfd *abfd;
258 PTR filehdr;
259 {
260 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
261
262 switch (internal_f->f_magic)
263 {
264 case MIPS_MAGIC_1:
265 /* I don't know what endianness this implies. */
266 return TRUE;
267
268 case MIPS_MAGIC_BIG:
269 case MIPS_MAGIC_BIG2:
270 case MIPS_MAGIC_BIG3:
271 return bfd_big_endian (abfd);
272
273 case MIPS_MAGIC_LITTLE:
274 case MIPS_MAGIC_LITTLE2:
275 case MIPS_MAGIC_LITTLE3:
276 return bfd_little_endian (abfd);
277
278 default:
279 return FALSE;
280 }
281 }
282
283 /* Reloc handling. MIPS ECOFF relocs are packed into 8 bytes in
284 external form. They use a bit which indicates whether the symbol
285 is external. */
286
287 /* Swap a reloc in. */
288
289 static void
mips_ecoff_swap_reloc_in(abfd,ext_ptr,intern)290 mips_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
291 bfd *abfd;
292 PTR ext_ptr;
293 struct internal_reloc *intern;
294 {
295 const RELOC *ext = (RELOC *) ext_ptr;
296
297 intern->r_vaddr = H_GET_32 (abfd, ext->r_vaddr);
298 if (bfd_header_big_endian (abfd))
299 {
300 intern->r_symndx = (((int) ext->r_bits[0]
301 << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
302 | ((int) ext->r_bits[1]
303 << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
304 | ((int) ext->r_bits[2]
305 << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
306 intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
307 >> RELOC_BITS3_TYPE_SH_BIG);
308 intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
309 }
310 else
311 {
312 intern->r_symndx = (((int) ext->r_bits[0]
313 << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
314 | ((int) ext->r_bits[1]
315 << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
316 | ((int) ext->r_bits[2]
317 << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
318 intern->r_type = (((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
319 >> RELOC_BITS3_TYPE_SH_LITTLE)
320 | ((ext->r_bits[3] & RELOC_BITS3_TYPEHI_LITTLE)
321 << RELOC_BITS3_TYPEHI_SH_LITTLE));
322 intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
323 }
324 }
325
326 /* Swap a reloc out. */
327
328 static void
mips_ecoff_swap_reloc_out(abfd,intern,dst)329 mips_ecoff_swap_reloc_out (abfd, intern, dst)
330 bfd *abfd;
331 const struct internal_reloc *intern;
332 PTR dst;
333 {
334 RELOC *ext = (RELOC *) dst;
335 long r_symndx;
336
337 BFD_ASSERT (intern->r_extern
338 || (intern->r_symndx >= 0 && intern->r_symndx <= 12));
339
340 r_symndx = intern->r_symndx;
341
342 H_PUT_32 (abfd, intern->r_vaddr, ext->r_vaddr);
343 if (bfd_header_big_endian (abfd))
344 {
345 ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
346 ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
347 ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
348 ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
349 & RELOC_BITS3_TYPE_BIG)
350 | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
351 }
352 else
353 {
354 ext->r_bits[0] = r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
355 ext->r_bits[1] = r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
356 ext->r_bits[2] = r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
357 ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
358 & RELOC_BITS3_TYPE_LITTLE)
359 | ((intern->r_type >> RELOC_BITS3_TYPEHI_SH_LITTLE
360 & RELOC_BITS3_TYPEHI_LITTLE))
361 | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
362 }
363 }
364
365 /* Finish canonicalizing a reloc. Part of this is generic to all
366 ECOFF targets, and that part is in ecoff.c. The rest is done in
367 this backend routine. It must fill in the howto field. */
368
369 static void
mips_adjust_reloc_in(abfd,intern,rptr)370 mips_adjust_reloc_in (abfd, intern, rptr)
371 bfd *abfd;
372 const struct internal_reloc *intern;
373 arelent *rptr;
374 {
375 if (intern->r_type > MIPS_R_PCREL16)
376 abort ();
377
378 if (! intern->r_extern
379 && (intern->r_type == MIPS_R_GPREL
380 || intern->r_type == MIPS_R_LITERAL))
381 rptr->addend += ecoff_data (abfd)->gp;
382
383 /* If the type is MIPS_R_IGNORE, make sure this is a reference to
384 the absolute section so that the reloc is ignored. */
385 if (intern->r_type == MIPS_R_IGNORE)
386 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
387
388 rptr->howto = &mips_howto_table[intern->r_type];
389 }
390
391 /* Make any adjustments needed to a reloc before writing it out. None
392 are needed for MIPS. */
393
394 static void
mips_adjust_reloc_out(abfd,rel,intern)395 mips_adjust_reloc_out (abfd, rel, intern)
396 bfd *abfd ATTRIBUTE_UNUSED;
397 const arelent *rel ATTRIBUTE_UNUSED;
398 struct internal_reloc *intern ATTRIBUTE_UNUSED;
399 {
400 }
401
402 /* ECOFF relocs are either against external symbols, or against
403 sections. If we are producing relocatable output, and the reloc
404 is against an external symbol, and nothing has given us any
405 additional addend, the resulting reloc will also be against the
406 same symbol. In such a case, we don't want to change anything
407 about the way the reloc is handled, since it will all be done at
408 final link time. Rather than put special case code into
409 bfd_perform_relocation, all the reloc types use this howto
410 function. It just short circuits the reloc if producing
411 relocatable output against an external symbol. */
412
413 static bfd_reloc_status_type
mips_generic_reloc(abfd,reloc_entry,symbol,data,input_section,output_bfd,error_message)414 mips_generic_reloc (abfd,
415 reloc_entry,
416 symbol,
417 data,
418 input_section,
419 output_bfd,
420 error_message)
421 bfd *abfd ATTRIBUTE_UNUSED;
422 arelent *reloc_entry;
423 asymbol *symbol;
424 PTR data ATTRIBUTE_UNUSED;
425 asection *input_section;
426 bfd *output_bfd;
427 char **error_message ATTRIBUTE_UNUSED;
428 {
429 if (output_bfd != (bfd *) NULL
430 && (symbol->flags & BSF_SECTION_SYM) == 0
431 && reloc_entry->addend == 0)
432 {
433 reloc_entry->address += input_section->output_offset;
434 return bfd_reloc_ok;
435 }
436
437 return bfd_reloc_continue;
438 }
439
440 /* Do a REFHI relocation. This has to be done in combination with a
441 REFLO reloc, because there is a carry from the REFLO to the REFHI.
442 Here we just save the information we need; we do the actual
443 relocation when we see the REFLO. MIPS ECOFF requires that the
444 REFLO immediately follow the REFHI. As a GNU extension, we permit
445 an arbitrary number of HI relocs to be associated with a single LO
446 reloc. This extension permits gcc to output the HI and LO relocs
447 itself. */
448
449 struct mips_hi
450 {
451 struct mips_hi *next;
452 bfd_byte *addr;
453 bfd_vma addend;
454 };
455
456 /* FIXME: This should not be a static variable. */
457
458 static struct mips_hi *mips_refhi_list;
459
460 static bfd_reloc_status_type
mips_refhi_reloc(abfd,reloc_entry,symbol,data,input_section,output_bfd,error_message)461 mips_refhi_reloc (abfd,
462 reloc_entry,
463 symbol,
464 data,
465 input_section,
466 output_bfd,
467 error_message)
468 bfd *abfd ATTRIBUTE_UNUSED;
469 arelent *reloc_entry;
470 asymbol *symbol;
471 PTR data;
472 asection *input_section;
473 bfd *output_bfd;
474 char **error_message ATTRIBUTE_UNUSED;
475 {
476 bfd_reloc_status_type ret;
477 bfd_vma relocation;
478 struct mips_hi *n;
479
480 /* If we're relocating, and this an external symbol, we don't want
481 to change anything. */
482 if (output_bfd != (bfd *) NULL
483 && (symbol->flags & BSF_SECTION_SYM) == 0
484 && reloc_entry->addend == 0)
485 {
486 reloc_entry->address += input_section->output_offset;
487 return bfd_reloc_ok;
488 }
489
490 ret = bfd_reloc_ok;
491 if (bfd_is_und_section (symbol->section)
492 && output_bfd == (bfd *) NULL)
493 ret = bfd_reloc_undefined;
494
495 if (bfd_is_com_section (symbol->section))
496 relocation = 0;
497 else
498 relocation = symbol->value;
499
500 relocation += symbol->section->output_section->vma;
501 relocation += symbol->section->output_offset;
502 relocation += reloc_entry->addend;
503
504 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
505 return bfd_reloc_outofrange;
506
507 /* Save the information, and let REFLO do the actual relocation. */
508 n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);
509 if (n == NULL)
510 return bfd_reloc_outofrange;
511 n->addr = (bfd_byte *) data + reloc_entry->address;
512 n->addend = relocation;
513 n->next = mips_refhi_list;
514 mips_refhi_list = n;
515
516 if (output_bfd != (bfd *) NULL)
517 reloc_entry->address += input_section->output_offset;
518
519 return ret;
520 }
521
522 /* Do a REFLO relocation. This is a straightforward 16 bit inplace
523 relocation; this function exists in order to do the REFHI
524 relocation described above. */
525
526 static bfd_reloc_status_type
mips_reflo_reloc(abfd,reloc_entry,symbol,data,input_section,output_bfd,error_message)527 mips_reflo_reloc (abfd,
528 reloc_entry,
529 symbol,
530 data,
531 input_section,
532 output_bfd,
533 error_message)
534 bfd *abfd;
535 arelent *reloc_entry;
536 asymbol *symbol;
537 PTR data;
538 asection *input_section;
539 bfd *output_bfd;
540 char **error_message;
541 {
542 if (mips_refhi_list != NULL)
543 {
544 struct mips_hi *l;
545
546 l = mips_refhi_list;
547 while (l != NULL)
548 {
549 unsigned long insn;
550 unsigned long val;
551 unsigned long vallo;
552 struct mips_hi *next;
553
554 /* Do the REFHI relocation. Note that we actually don't
555 need to know anything about the REFLO itself, except
556 where to find the low 16 bits of the addend needed by the
557 REFHI. */
558 insn = bfd_get_32 (abfd, l->addr);
559 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
560 & 0xffff);
561 val = ((insn & 0xffff) << 16) + vallo;
562 val += l->addend;
563
564 /* The low order 16 bits are always treated as a signed
565 value. Therefore, a negative value in the low order bits
566 requires an adjustment in the high order bits. We need
567 to make this adjustment in two ways: once for the bits we
568 took from the data, and once for the bits we are putting
569 back in to the data. */
570 if ((vallo & 0x8000) != 0)
571 val -= 0x10000;
572 if ((val & 0x8000) != 0)
573 val += 0x10000;
574
575 insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
576 bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
577
578 next = l->next;
579 free (l);
580 l = next;
581 }
582
583 mips_refhi_list = NULL;
584 }
585
586 /* Now do the REFLO reloc in the usual way. */
587 return mips_generic_reloc (abfd, reloc_entry, symbol, data,
588 input_section, output_bfd, error_message);
589 }
590
591 /* Do a GPREL relocation. This is a 16 bit value which must become
592 the offset from the gp register. */
593
594 static bfd_reloc_status_type
mips_gprel_reloc(abfd,reloc_entry,symbol,data,input_section,output_bfd,error_message)595 mips_gprel_reloc (abfd,
596 reloc_entry,
597 symbol,
598 data,
599 input_section,
600 output_bfd,
601 error_message)
602 bfd *abfd;
603 arelent *reloc_entry;
604 asymbol *symbol;
605 PTR data;
606 asection *input_section;
607 bfd *output_bfd;
608 char **error_message;
609 {
610 bfd_boolean relocatable;
611 bfd_vma gp;
612 bfd_vma relocation;
613 unsigned long val;
614 unsigned long insn;
615
616 /* If we're relocating, and this is an external symbol with no
617 addend, we don't want to change anything. We will only have an
618 addend if this is a newly created reloc, not read from an ECOFF
619 file. */
620 if (output_bfd != (bfd *) NULL
621 && (symbol->flags & BSF_SECTION_SYM) == 0
622 && reloc_entry->addend == 0)
623 {
624 reloc_entry->address += input_section->output_offset;
625 return bfd_reloc_ok;
626 }
627
628 if (output_bfd != (bfd *) NULL)
629 relocatable = TRUE;
630 else
631 {
632 relocatable = FALSE;
633 output_bfd = symbol->section->output_section->owner;
634 }
635
636 if (bfd_is_und_section (symbol->section) && ! relocatable)
637 return bfd_reloc_undefined;
638
639 /* We have to figure out the gp value, so that we can adjust the
640 symbol value correctly. We look up the symbol _gp in the output
641 BFD. If we can't find it, we're stuck. We cache it in the ECOFF
642 target data. We don't need to adjust the symbol value for an
643 external symbol if we are producing relocatable output. */
644 gp = _bfd_get_gp_value (output_bfd);
645 if (gp == 0
646 && (! relocatable
647 || (symbol->flags & BSF_SECTION_SYM) != 0))
648 {
649 if (relocatable)
650 {
651 /* Make up a value. */
652 gp = symbol->section->output_section->vma + 0x4000;
653 _bfd_set_gp_value (output_bfd, gp);
654 }
655 else
656 {
657 unsigned int count;
658 asymbol **sym;
659 unsigned int i;
660
661 count = bfd_get_symcount (output_bfd);
662 sym = bfd_get_outsymbols (output_bfd);
663
664 if (sym == (asymbol **) NULL)
665 i = count;
666 else
667 {
668 for (i = 0; i < count; i++, sym++)
669 {
670 register const char *name;
671
672 name = bfd_asymbol_name (*sym);
673 if (*name == '_' && strcmp (name, "_gp") == 0)
674 {
675 gp = bfd_asymbol_value (*sym);
676 _bfd_set_gp_value (output_bfd, gp);
677 break;
678 }
679 }
680 }
681
682 if (i >= count)
683 {
684 /* Only get the error once. */
685 gp = 4;
686 _bfd_set_gp_value (output_bfd, gp);
687 *error_message =
688 (char *) _("GP relative relocation when _gp not defined");
689 return bfd_reloc_dangerous;
690 }
691 }
692 }
693
694 if (bfd_is_com_section (symbol->section))
695 relocation = 0;
696 else
697 relocation = symbol->value;
698
699 relocation += symbol->section->output_section->vma;
700 relocation += symbol->section->output_offset;
701
702 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
703 return bfd_reloc_outofrange;
704
705 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
706
707 /* Set val to the offset into the section or symbol. */
708 val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
709 if (val & 0x8000)
710 val -= 0x10000;
711
712 /* Adjust val for the final section location and GP value. If we
713 are producing relocatable output, we don't want to do this for
714 an external symbol. */
715 if (! relocatable
716 || (symbol->flags & BSF_SECTION_SYM) != 0)
717 val += relocation - gp;
718
719 insn = (insn &~ (unsigned) 0xffff) | (val & 0xffff);
720 bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + reloc_entry->address);
721
722 if (relocatable)
723 reloc_entry->address += input_section->output_offset;
724
725 /* Make sure it fit in 16 bits. */
726 if ((long) val >= 0x8000 || (long) val < -0x8000)
727 return bfd_reloc_overflow;
728
729 return bfd_reloc_ok;
730 }
731
732 /* Get the howto structure for a generic reloc type. */
733
734 static reloc_howto_type *
mips_bfd_reloc_type_lookup(abfd,code)735 mips_bfd_reloc_type_lookup (abfd, code)
736 bfd *abfd ATTRIBUTE_UNUSED;
737 bfd_reloc_code_real_type code;
738 {
739 int mips_type;
740
741 switch (code)
742 {
743 case BFD_RELOC_16:
744 mips_type = MIPS_R_REFHALF;
745 break;
746 case BFD_RELOC_32:
747 case BFD_RELOC_CTOR:
748 mips_type = MIPS_R_REFWORD;
749 break;
750 case BFD_RELOC_MIPS_JMP:
751 mips_type = MIPS_R_JMPADDR;
752 break;
753 case BFD_RELOC_HI16_S:
754 mips_type = MIPS_R_REFHI;
755 break;
756 case BFD_RELOC_LO16:
757 mips_type = MIPS_R_REFLO;
758 break;
759 case BFD_RELOC_GPREL16:
760 mips_type = MIPS_R_GPREL;
761 break;
762 case BFD_RELOC_MIPS_LITERAL:
763 mips_type = MIPS_R_LITERAL;
764 break;
765 case BFD_RELOC_16_PCREL_S2:
766 mips_type = MIPS_R_PCREL16;
767 break;
768 default:
769 return (reloc_howto_type *) NULL;
770 }
771
772 return &mips_howto_table[mips_type];
773 }
774
775 static reloc_howto_type *
mips_bfd_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)776 mips_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
777 const char *r_name)
778 {
779 unsigned int i;
780
781 for (i = 0;
782 i < sizeof (mips_howto_table) / sizeof (mips_howto_table[0]);
783 i++)
784 if (mips_howto_table[i].name != NULL
785 && strcasecmp (mips_howto_table[i].name, r_name) == 0)
786 return &mips_howto_table[i];
787
788 return NULL;
789 }
790
791 /* A helper routine for mips_relocate_section which handles the REFHI
792 relocations. The REFHI relocation must be followed by a REFLO
793 relocation, and the addend used is formed from the addends of both
794 instructions. */
795
796 static void
mips_relocate_hi(refhi,reflo,input_bfd,input_section,contents,relocation)797 mips_relocate_hi (refhi, reflo, input_bfd, input_section, contents,
798 relocation)
799 struct internal_reloc *refhi;
800 struct internal_reloc *reflo;
801 bfd *input_bfd;
802 asection *input_section;
803 bfd_byte *contents;
804 bfd_vma relocation;
805 {
806 unsigned long insn;
807 unsigned long val;
808 unsigned long vallo;
809
810 if (refhi == NULL)
811 return;
812
813 insn = bfd_get_32 (input_bfd,
814 contents + refhi->r_vaddr - input_section->vma);
815 if (reflo == NULL)
816 vallo = 0;
817 else
818 vallo = (bfd_get_32 (input_bfd,
819 contents + reflo->r_vaddr - input_section->vma)
820 & 0xffff);
821
822 val = ((insn & 0xffff) << 16) + vallo;
823 val += relocation;
824
825 /* The low order 16 bits are always treated as a signed value.
826 Therefore, a negative value in the low order bits requires an
827 adjustment in the high order bits. We need to make this
828 adjustment in two ways: once for the bits we took from the data,
829 and once for the bits we are putting back in to the data. */
830 if ((vallo & 0x8000) != 0)
831 val -= 0x10000;
832
833 if ((val & 0x8000) != 0)
834 val += 0x10000;
835
836 insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
837 bfd_put_32 (input_bfd, (bfd_vma) insn,
838 contents + refhi->r_vaddr - input_section->vma);
839 }
840
841 /* Relocate a section while linking a MIPS ECOFF file. */
842
843 static bfd_boolean
mips_relocate_section(output_bfd,info,input_bfd,input_section,contents,external_relocs)844 mips_relocate_section (output_bfd, info, input_bfd, input_section,
845 contents, external_relocs)
846 bfd *output_bfd;
847 struct bfd_link_info *info;
848 bfd *input_bfd;
849 asection *input_section;
850 bfd_byte *contents;
851 PTR external_relocs;
852 {
853 asection **symndx_to_section;
854 struct ecoff_link_hash_entry **sym_hashes;
855 bfd_vma gp;
856 bfd_boolean gp_undefined;
857 struct external_reloc *ext_rel;
858 struct external_reloc *ext_rel_end;
859 unsigned int i;
860 bfd_boolean got_lo;
861 struct internal_reloc lo_int_rel;
862 bfd_size_type amt;
863
864 BFD_ASSERT (input_bfd->xvec->byteorder
865 == output_bfd->xvec->byteorder);
866
867 /* We keep a table mapping the symndx found in an internal reloc to
868 the appropriate section. This is faster than looking up the
869 section by name each time. */
870 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
871 if (symndx_to_section == (asection **) NULL)
872 {
873 amt = NUM_RELOC_SECTIONS * sizeof (asection *);
874 symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
875 if (!symndx_to_section)
876 return FALSE;
877
878 symndx_to_section[RELOC_SECTION_NONE] = NULL;
879 symndx_to_section[RELOC_SECTION_TEXT] =
880 bfd_get_section_by_name (input_bfd, ".text");
881 symndx_to_section[RELOC_SECTION_RDATA] =
882 bfd_get_section_by_name (input_bfd, ".rdata");
883 symndx_to_section[RELOC_SECTION_DATA] =
884 bfd_get_section_by_name (input_bfd, ".data");
885 symndx_to_section[RELOC_SECTION_SDATA] =
886 bfd_get_section_by_name (input_bfd, ".sdata");
887 symndx_to_section[RELOC_SECTION_SBSS] =
888 bfd_get_section_by_name (input_bfd, ".sbss");
889 symndx_to_section[RELOC_SECTION_BSS] =
890 bfd_get_section_by_name (input_bfd, ".bss");
891 symndx_to_section[RELOC_SECTION_INIT] =
892 bfd_get_section_by_name (input_bfd, ".init");
893 symndx_to_section[RELOC_SECTION_LIT8] =
894 bfd_get_section_by_name (input_bfd, ".lit8");
895 symndx_to_section[RELOC_SECTION_LIT4] =
896 bfd_get_section_by_name (input_bfd, ".lit4");
897 symndx_to_section[RELOC_SECTION_XDATA] = NULL;
898 symndx_to_section[RELOC_SECTION_PDATA] = NULL;
899 symndx_to_section[RELOC_SECTION_FINI] =
900 bfd_get_section_by_name (input_bfd, ".fini");
901 symndx_to_section[RELOC_SECTION_LITA] = NULL;
902 symndx_to_section[RELOC_SECTION_ABS] = NULL;
903
904 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
905 }
906
907 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
908
909 gp = _bfd_get_gp_value (output_bfd);
910 if (gp == 0)
911 gp_undefined = TRUE;
912 else
913 gp_undefined = FALSE;
914
915 got_lo = FALSE;
916
917 ext_rel = (struct external_reloc *) external_relocs;
918 ext_rel_end = ext_rel + input_section->reloc_count;
919 for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
920 {
921 struct internal_reloc int_rel;
922 bfd_boolean use_lo = FALSE;
923 bfd_vma addend;
924 reloc_howto_type *howto;
925 struct ecoff_link_hash_entry *h = NULL;
926 asection *s = NULL;
927 bfd_vma relocation;
928 bfd_reloc_status_type r;
929
930 if (! got_lo)
931 mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
932 else
933 {
934 int_rel = lo_int_rel;
935 got_lo = FALSE;
936 }
937
938 BFD_ASSERT (int_rel.r_type
939 < sizeof mips_howto_table / sizeof mips_howto_table[0]);
940
941 /* The REFHI reloc requires special handling. It must be followed
942 by a REFLO reloc, and the addend is formed from both relocs. */
943 if (int_rel.r_type == MIPS_R_REFHI)
944 {
945 struct external_reloc *lo_ext_rel;
946
947 /* As a GNU extension, permit an arbitrary number of REFHI
948 relocs before the REFLO reloc. This permits gcc to emit
949 the HI and LO relocs itself. */
950 for (lo_ext_rel = ext_rel + 1;
951 lo_ext_rel < ext_rel_end;
952 lo_ext_rel++)
953 {
954 mips_ecoff_swap_reloc_in (input_bfd, (PTR) lo_ext_rel,
955 &lo_int_rel);
956 if (lo_int_rel.r_type != int_rel.r_type)
957 break;
958 }
959
960 if (lo_ext_rel < ext_rel_end
961 && lo_int_rel.r_type == MIPS_R_REFLO
962 && int_rel.r_extern == lo_int_rel.r_extern
963 && int_rel.r_symndx == lo_int_rel.r_symndx)
964 {
965 use_lo = TRUE;
966 if (lo_ext_rel == ext_rel + 1)
967 got_lo = TRUE;
968 }
969 }
970
971 howto = &mips_howto_table[int_rel.r_type];
972
973 if (int_rel.r_extern)
974 {
975 h = sym_hashes[int_rel.r_symndx];
976 /* If h is NULL, that means that there is a reloc against an
977 external symbol which we thought was just a debugging
978 symbol. This should not happen. */
979 if (h == (struct ecoff_link_hash_entry *) NULL)
980 abort ();
981 }
982 else
983 {
984 if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
985 s = NULL;
986 else
987 s = symndx_to_section[int_rel.r_symndx];
988
989 if (s == (asection *) NULL)
990 abort ();
991 }
992
993 /* The GPREL reloc uses an addend: the difference in the GP
994 values. */
995 if (int_rel.r_type != MIPS_R_GPREL
996 && int_rel.r_type != MIPS_R_LITERAL)
997 addend = 0;
998 else
999 {
1000 if (gp_undefined)
1001 {
1002 if (! ((*info->callbacks->reloc_dangerous)
1003 (info, _("GP relative relocation used when GP not defined"),
1004 input_bfd, input_section,
1005 int_rel.r_vaddr - input_section->vma)))
1006 return FALSE;
1007 /* Only give the error once per link. */
1008 gp = 4;
1009 _bfd_set_gp_value (output_bfd, gp);
1010 gp_undefined = FALSE;
1011 }
1012 if (! int_rel.r_extern)
1013 {
1014 /* This is a relocation against a section. The current
1015 addend in the instruction is the difference between
1016 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
1017 must change this to be the difference between the
1018 final definition (which will end up in RELOCATION)
1019 and the GP value of OUTPUT_BFD (which is in GP). */
1020 addend = ecoff_data (input_bfd)->gp - gp;
1021 }
1022 else if (! info->relocatable
1023 || h->root.type == bfd_link_hash_defined
1024 || h->root.type == bfd_link_hash_defweak)
1025 {
1026 /* This is a relocation against a defined symbol. The
1027 current addend in the instruction is simply the
1028 desired offset into the symbol (normally zero). We
1029 are going to change this into a relocation against a
1030 defined symbol, so we want the instruction to hold
1031 the difference between the final definition of the
1032 symbol (which will end up in RELOCATION) and the GP
1033 value of OUTPUT_BFD (which is in GP). */
1034 addend = - gp;
1035 }
1036 else
1037 {
1038 /* This is a relocation against an undefined or common
1039 symbol. The current addend in the instruction is
1040 simply the desired offset into the symbol (normally
1041 zero). We are generating relocatable output, and we
1042 aren't going to define this symbol, so we just leave
1043 the instruction alone. */
1044 addend = 0;
1045 }
1046 }
1047
1048 if (info->relocatable)
1049 {
1050 /* We are generating relocatable output, and must convert
1051 the existing reloc. */
1052 if (int_rel.r_extern)
1053 {
1054 if ((h->root.type == bfd_link_hash_defined
1055 || h->root.type == bfd_link_hash_defweak)
1056 && ! bfd_is_abs_section (h->root.u.def.section))
1057 {
1058 const char *name;
1059
1060 /* This symbol is defined in the output. Convert
1061 the reloc from being against the symbol to being
1062 against the section. */
1063
1064 /* Clear the r_extern bit. */
1065 int_rel.r_extern = 0;
1066
1067 /* Compute a new r_symndx value. */
1068 s = h->root.u.def.section;
1069 name = bfd_get_section_name (output_bfd,
1070 s->output_section);
1071
1072 int_rel.r_symndx = -1;
1073 switch (name[1])
1074 {
1075 case 'b':
1076 if (strcmp (name, ".bss") == 0)
1077 int_rel.r_symndx = RELOC_SECTION_BSS;
1078 break;
1079 case 'd':
1080 if (strcmp (name, ".data") == 0)
1081 int_rel.r_symndx = RELOC_SECTION_DATA;
1082 break;
1083 case 'f':
1084 if (strcmp (name, ".fini") == 0)
1085 int_rel.r_symndx = RELOC_SECTION_FINI;
1086 break;
1087 case 'i':
1088 if (strcmp (name, ".init") == 0)
1089 int_rel.r_symndx = RELOC_SECTION_INIT;
1090 break;
1091 case 'l':
1092 if (strcmp (name, ".lit8") == 0)
1093 int_rel.r_symndx = RELOC_SECTION_LIT8;
1094 else if (strcmp (name, ".lit4") == 0)
1095 int_rel.r_symndx = RELOC_SECTION_LIT4;
1096 break;
1097 case 'r':
1098 if (strcmp (name, ".rdata") == 0)
1099 int_rel.r_symndx = RELOC_SECTION_RDATA;
1100 break;
1101 case 's':
1102 if (strcmp (name, ".sdata") == 0)
1103 int_rel.r_symndx = RELOC_SECTION_SDATA;
1104 else if (strcmp (name, ".sbss") == 0)
1105 int_rel.r_symndx = RELOC_SECTION_SBSS;
1106 break;
1107 case 't':
1108 if (strcmp (name, ".text") == 0)
1109 int_rel.r_symndx = RELOC_SECTION_TEXT;
1110 break;
1111 }
1112
1113 if (int_rel.r_symndx == -1)
1114 abort ();
1115
1116 /* Add the section VMA and the symbol value. */
1117 relocation = (h->root.u.def.value
1118 + s->output_section->vma
1119 + s->output_offset);
1120
1121 /* For a PC relative relocation, the object file
1122 currently holds just the addend. We must adjust
1123 by the address to get the right value. */
1124 if (howto->pc_relative)
1125 relocation -= int_rel.r_vaddr - input_section->vma;
1126
1127 h = NULL;
1128 }
1129 else
1130 {
1131 /* Change the symndx value to the right one for the
1132 output BFD. */
1133 int_rel.r_symndx = h->indx;
1134 if (int_rel.r_symndx == -1)
1135 {
1136 /* This symbol is not being written out. */
1137 if (! ((*info->callbacks->unattached_reloc)
1138 (info, h->root.root.string, input_bfd,
1139 input_section,
1140 int_rel.r_vaddr - input_section->vma)))
1141 return FALSE;
1142 int_rel.r_symndx = 0;
1143 }
1144 relocation = 0;
1145 }
1146 }
1147 else
1148 {
1149 /* This is a relocation against a section. Adjust the
1150 value by the amount the section moved. */
1151 relocation = (s->output_section->vma
1152 + s->output_offset
1153 - s->vma);
1154 }
1155
1156 relocation += addend;
1157 addend = 0;
1158
1159 /* Adjust a PC relative relocation by removing the reference
1160 to the original address in the section and including the
1161 reference to the new address. */
1162 if (howto->pc_relative)
1163 relocation -= (input_section->output_section->vma
1164 + input_section->output_offset
1165 - input_section->vma);
1166
1167 /* Adjust the contents. */
1168 if (relocation == 0)
1169 r = bfd_reloc_ok;
1170 else
1171 {
1172 if (int_rel.r_type != MIPS_R_REFHI)
1173 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1174 (contents
1175 + int_rel.r_vaddr
1176 - input_section->vma));
1177 else
1178 {
1179 mips_relocate_hi (&int_rel,
1180 use_lo ? &lo_int_rel : NULL,
1181 input_bfd, input_section, contents,
1182 relocation);
1183 r = bfd_reloc_ok;
1184 }
1185 }
1186
1187 /* Adjust the reloc address. */
1188 int_rel.r_vaddr += (input_section->output_section->vma
1189 + input_section->output_offset
1190 - input_section->vma);
1191
1192 /* Save the changed reloc information. */
1193 mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
1194 }
1195 else
1196 {
1197 /* We are producing a final executable. */
1198 if (int_rel.r_extern)
1199 {
1200 /* This is a reloc against a symbol. */
1201 if (h->root.type == bfd_link_hash_defined
1202 || h->root.type == bfd_link_hash_defweak)
1203 {
1204 asection *hsec;
1205
1206 hsec = h->root.u.def.section;
1207 relocation = (h->root.u.def.value
1208 + hsec->output_section->vma
1209 + hsec->output_offset);
1210 }
1211 else
1212 {
1213 if (! ((*info->callbacks->undefined_symbol)
1214 (info, h->root.root.string, input_bfd,
1215 input_section,
1216 int_rel.r_vaddr - input_section->vma, TRUE)))
1217 return FALSE;
1218 relocation = 0;
1219 }
1220 }
1221 else
1222 {
1223 /* This is a reloc against a section. */
1224 relocation = (s->output_section->vma
1225 + s->output_offset
1226 - s->vma);
1227
1228 /* A PC relative reloc is already correct in the object
1229 file. Make it look like a pcrel_offset relocation by
1230 adding in the start address. */
1231 if (howto->pc_relative)
1232 relocation += int_rel.r_vaddr;
1233 }
1234
1235 if (int_rel.r_type != MIPS_R_REFHI)
1236 r = _bfd_final_link_relocate (howto,
1237 input_bfd,
1238 input_section,
1239 contents,
1240 (int_rel.r_vaddr
1241 - input_section->vma),
1242 relocation,
1243 addend);
1244 else
1245 {
1246 mips_relocate_hi (&int_rel,
1247 use_lo ? &lo_int_rel : NULL,
1248 input_bfd, input_section, contents,
1249 relocation);
1250 r = bfd_reloc_ok;
1251 }
1252 }
1253
1254 /* MIPS_R_JMPADDR requires peculiar overflow detection. The
1255 instruction provides a 28 bit address (the two lower bits are
1256 implicit zeroes) which is combined with the upper four bits
1257 of the instruction address. */
1258 if (r == bfd_reloc_ok
1259 && int_rel.r_type == MIPS_R_JMPADDR
1260 && (((relocation
1261 + addend
1262 + (int_rel.r_extern ? 0 : s->vma))
1263 & 0xf0000000)
1264 != ((input_section->output_section->vma
1265 + input_section->output_offset
1266 + (int_rel.r_vaddr - input_section->vma))
1267 & 0xf0000000)))
1268 r = bfd_reloc_overflow;
1269
1270 if (r != bfd_reloc_ok)
1271 {
1272 switch (r)
1273 {
1274 default:
1275 case bfd_reloc_outofrange:
1276 abort ();
1277 case bfd_reloc_overflow:
1278 {
1279 const char *name;
1280
1281 if (int_rel.r_extern)
1282 name = NULL;
1283 else
1284 name = bfd_section_name (input_bfd, s);
1285 if (! ((*info->callbacks->reloc_overflow)
1286 (info, (h ? &h->root : NULL), name, howto->name,
1287 (bfd_vma) 0, input_bfd, input_section,
1288 int_rel.r_vaddr - input_section->vma)))
1289 return FALSE;
1290 }
1291 break;
1292 }
1293 }
1294 }
1295
1296 return TRUE;
1297 }
1298
1299 /* This is the ECOFF backend structure. The backend field of the
1300 target vector points to this. */
1301
1302 static const struct ecoff_backend_data mips_ecoff_backend_data =
1303 {
1304 /* COFF backend structure. */
1305 {
1306 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
1307 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
1308 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
1309 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
1310 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
1311 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
1312 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
1313 mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
1314 mips_ecoff_swap_scnhdr_out,
1315 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE,
1316 ECOFF_NO_LONG_SECTION_NAMES, 4, FALSE, 2,
1317 mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
1318 mips_ecoff_swap_scnhdr_in, NULL,
1319 mips_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
1320 _bfd_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
1321 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
1322 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1323 NULL, NULL, NULL
1324 },
1325 /* Supported architecture. */
1326 bfd_arch_mips,
1327 /* Initial portion of armap string. */
1328 "__________",
1329 /* The page boundary used to align sections in a demand-paged
1330 executable file. E.g., 0x1000. */
1331 0x1000,
1332 /* TRUE if the .rdata section is part of the text segment, as on the
1333 Alpha. FALSE if .rdata is part of the data segment, as on the
1334 MIPS. */
1335 FALSE,
1336 /* Bitsize of constructor entries. */
1337 32,
1338 /* Reloc to use for constructor entries. */
1339 &mips_howto_table[MIPS_R_REFWORD],
1340 {
1341 /* Symbol table magic number. */
1342 magicSym,
1343 /* Alignment of debugging information. E.g., 4. */
1344 4,
1345 /* Sizes of external symbolic information. */
1346 sizeof (struct hdr_ext),
1347 sizeof (struct dnr_ext),
1348 sizeof (struct pdr_ext),
1349 sizeof (struct sym_ext),
1350 sizeof (struct opt_ext),
1351 sizeof (struct fdr_ext),
1352 sizeof (struct rfd_ext),
1353 sizeof (struct ext_ext),
1354 /* Functions to swap in external symbolic data. */
1355 ecoff_swap_hdr_in,
1356 ecoff_swap_dnr_in,
1357 ecoff_swap_pdr_in,
1358 ecoff_swap_sym_in,
1359 ecoff_swap_opt_in,
1360 ecoff_swap_fdr_in,
1361 ecoff_swap_rfd_in,
1362 ecoff_swap_ext_in,
1363 _bfd_ecoff_swap_tir_in,
1364 _bfd_ecoff_swap_rndx_in,
1365 /* Functions to swap out external symbolic data. */
1366 ecoff_swap_hdr_out,
1367 ecoff_swap_dnr_out,
1368 ecoff_swap_pdr_out,
1369 ecoff_swap_sym_out,
1370 ecoff_swap_opt_out,
1371 ecoff_swap_fdr_out,
1372 ecoff_swap_rfd_out,
1373 ecoff_swap_ext_out,
1374 _bfd_ecoff_swap_tir_out,
1375 _bfd_ecoff_swap_rndx_out,
1376 /* Function to read in symbolic data. */
1377 _bfd_ecoff_slurp_symbolic_info
1378 },
1379 /* External reloc size. */
1380 RELSZ,
1381 /* Reloc swapping functions. */
1382 mips_ecoff_swap_reloc_in,
1383 mips_ecoff_swap_reloc_out,
1384 /* Backend reloc tweaking. */
1385 mips_adjust_reloc_in,
1386 mips_adjust_reloc_out,
1387 /* Relocate section contents while linking. */
1388 mips_relocate_section,
1389 /* Do final adjustments to filehdr and aouthdr. */
1390 NULL,
1391 /* Read an element from an archive at a given file position. */
1392 _bfd_get_elt_at_filepos
1393 };
1394
1395 /* Looking up a reloc type is MIPS specific. */
1396 #define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
1397 #define _bfd_ecoff_bfd_reloc_name_lookup mips_bfd_reloc_name_lookup
1398
1399 /* Getting relocated section contents is generic. */
1400 #define _bfd_ecoff_bfd_get_relocated_section_contents \
1401 bfd_generic_get_relocated_section_contents
1402
1403 /* Handling file windows is generic. */
1404 #define _bfd_ecoff_get_section_contents_in_window \
1405 _bfd_generic_get_section_contents_in_window
1406
1407 /* Relaxing sections is MIPS specific. */
1408 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
1409
1410 /* GC of sections is not done. */
1411 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
1412
1413 /* Merging of sections is not done. */
1414 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
1415
1416 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
1417 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
1418 #define _bfd_ecoff_section_already_linked \
1419 _bfd_generic_section_already_linked
1420 #define _bfd_ecoff_bfd_define_common_symbol bfd_generic_define_common_symbol
1421
1422 extern const bfd_target ecoff_big_vec;
1423
1424 const bfd_target ecoff_little_vec =
1425 {
1426 "ecoff-littlemips", /* name */
1427 bfd_target_ecoff_flavour,
1428 BFD_ENDIAN_LITTLE, /* data byte order is little */
1429 BFD_ENDIAN_LITTLE, /* header byte order is little */
1430
1431 (HAS_RELOC | EXEC_P | /* object flags */
1432 HAS_LINENO | HAS_DEBUG |
1433 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1434
1435 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1436 0, /* leading underscore */
1437 ' ', /* ar_pad_char */
1438 15, /* ar_max_namelen */
1439 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1440 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1441 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1442 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1443 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1444 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1445
1446 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1447 bfd_generic_archive_p, _bfd_dummy_target},
1448 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1449 _bfd_generic_mkarchive, bfd_false},
1450 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1451 _bfd_write_archive_contents, bfd_false},
1452
1453 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1454 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1455 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1456 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1457 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1458 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1459 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1460 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1461 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1462
1463 & ecoff_big_vec,
1464
1465 (PTR) &mips_ecoff_backend_data
1466 };
1467
1468 const bfd_target ecoff_big_vec =
1469 {
1470 "ecoff-bigmips", /* name */
1471 bfd_target_ecoff_flavour,
1472 BFD_ENDIAN_BIG, /* data byte order is big */
1473 BFD_ENDIAN_BIG, /* header byte order is big */
1474
1475 (HAS_RELOC | EXEC_P | /* object flags */
1476 HAS_LINENO | HAS_DEBUG |
1477 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1478
1479 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1480 0, /* leading underscore */
1481 ' ', /* ar_pad_char */
1482 15, /* ar_max_namelen */
1483 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1484 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1485 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1486 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1487 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1488 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1489 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1490 bfd_generic_archive_p, _bfd_dummy_target},
1491 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1492 _bfd_generic_mkarchive, bfd_false},
1493 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1494 _bfd_write_archive_contents, bfd_false},
1495
1496 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1497 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1498 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1499 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1500 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1501 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1502 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1503 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1504 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1505
1506 & ecoff_little_vec,
1507
1508 (PTR) &mips_ecoff_backend_data
1509 };
1510
1511 const bfd_target ecoff_biglittle_vec =
1512 {
1513 "ecoff-biglittlemips", /* name */
1514 bfd_target_ecoff_flavour,
1515 BFD_ENDIAN_LITTLE, /* data byte order is little */
1516 BFD_ENDIAN_BIG, /* header byte order is big */
1517
1518 (HAS_RELOC | EXEC_P | /* object flags */
1519 HAS_LINENO | HAS_DEBUG |
1520 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1521
1522 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1523 0, /* leading underscore */
1524 ' ', /* ar_pad_char */
1525 15, /* ar_max_namelen */
1526 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1527 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1528 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1529 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1530 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1531 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1532
1533 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1534 bfd_generic_archive_p, _bfd_dummy_target},
1535 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1536 _bfd_generic_mkarchive, bfd_false},
1537 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1538 _bfd_write_archive_contents, bfd_false},
1539
1540 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1541 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1542 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1543 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1544 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1545 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1546 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1547 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1548 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1549
1550 NULL,
1551
1552 (PTR) &mips_ecoff_backend_data
1553 };
1554