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