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