projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bfd/
[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
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 bfd_size_type sz;
477 struct mips_hi *n;
478
479 /* If we're relocating, and this an external symbol, we don't want
480 to change anything. */
481 if (output_bfd != (bfd *) NULL
482 && (symbol->flags & BSF_SECTION_SYM) == 0
483 && reloc_entry->addend == 0)
484 {
485 reloc_entry->address += input_section->output_offset;
486 return bfd_reloc_ok;
487 }
488
489 ret = bfd_reloc_ok;
490 if (bfd_is_und_section (symbol->section)
491 && output_bfd == (bfd *) NULL)
492 ret = bfd_reloc_undefined;
493
494 if (bfd_is_com_section (symbol->section))
495 relocation = 0;
496 else
497 relocation = symbol->value;
498
499 relocation += symbol->section->output_section->vma;
500 relocation += symbol->section->output_offset;
501 relocation += reloc_entry->addend;
502
503 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
504 if (reloc_entry->address > sz)
505 return bfd_reloc_outofrange;
506
507 /* Save the information, and let REFLO do the actual relocation. */
508 n = (struct mips_hi *) bfd_malloc ((bfd_size_type) sizeof *n);
509 if (n == NULL)
510 return bfd_reloc_outofrange;
511 n->addr = (bfd_byte *) data + reloc_entry->address;
512 n->addend = relocation;
513 n->next = mips_refhi_list;
514 mips_refhi_list = n;
515
516 if (output_bfd != (bfd *) NULL)
517 reloc_entry->address += input_section->output_offset;
518
519 return ret;
520 }
521
522 /* Do a REFLO relocation. This is a straightforward 16 bit inplace
523 relocation; this function exists in order to do the REFHI
524 relocation described above. */
525
526 static bfd_reloc_status_type
527 mips_reflo_reloc (abfd,
528 reloc_entry,
529 symbol,
530 data,
531 input_section,
532 output_bfd,
533 error_message)
534 bfd *abfd;
535 arelent *reloc_entry;
536 asymbol *symbol;
537 PTR data;
538 asection *input_section;
539 bfd *output_bfd;
540 char **error_message;
541 {
542 if (mips_refhi_list != NULL)
543 {
544 struct mips_hi *l;
545
546 l = mips_refhi_list;
547 while (l != NULL)
548 {
549 unsigned long insn;
550 unsigned long val;
551 unsigned long vallo;
552 struct mips_hi *next;
553
554 /* Do the REFHI relocation. Note that we actually don't
555 need to know anything about the REFLO itself, except
556 where to find the low 16 bits of the addend needed by the
557 REFHI. */
558 insn = bfd_get_32 (abfd, l->addr);
559 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
560 & 0xffff);
561 val = ((insn & 0xffff) << 16) + vallo;
562 val += l->addend;
563
564 /* The low order 16 bits are always treated as a signed
565 value. Therefore, a negative value in the low order bits
566 requires an adjustment in the high order bits. We need
567 to make this adjustment in two ways: once for the bits we
568 took from the data, and once for the bits we are putting
569 back in to the data. */
570 if ((vallo & 0x8000) != 0)
571 val -= 0x10000;
572 if ((val & 0x8000) != 0)
573 val += 0x10000;
574
575 insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
576 bfd_put_32 (abfd, (bfd_vma) insn, l->addr);
577
578 next = l->next;
579 free (l);
580 l = next;
581 }
582
583 mips_refhi_list = NULL;
584 }
585
586 /* Now do the REFLO reloc in the usual way. */
587 return mips_generic_reloc (abfd, reloc_entry, symbol, data,
588 input_section, output_bfd, error_message);
589 }
590
591 /* Do a GPREL relocation. This is a 16 bit value which must become
592 the offset from the gp register. */
593
594 static bfd_reloc_status_type
595 mips_gprel_reloc (abfd,
596 reloc_entry,
597 symbol,
598 data,
599 input_section,
600 output_bfd,
601 error_message)
602 bfd *abfd;
603 arelent *reloc_entry;
604 asymbol *symbol;
605 PTR data;
606 asection *input_section;
607 bfd *output_bfd;
608 char **error_message;
609 {
610 bfd_boolean relocatable;
611 bfd_vma gp;
612 bfd_vma relocation;
613 bfd_size_type sz;
614 unsigned long val;
615 unsigned long insn;
616
617 /* If we're relocating, and this is an external symbol with no
618 addend, we don't want to change anything. We will only have an
619 addend if this is a newly created reloc, not read from an ECOFF
620 file. */
621 if (output_bfd != (bfd *) NULL
622 && (symbol->flags & BSF_SECTION_SYM) == 0
623 && reloc_entry->addend == 0)
624 {
625 reloc_entry->address += input_section->output_offset;
626 return bfd_reloc_ok;
627 }
628
629 if (output_bfd != (bfd *) NULL)
630 relocatable = TRUE;
631 else
632 {
633 relocatable = FALSE;
634 output_bfd = symbol->section->output_section->owner;
635 }
636
637 if (bfd_is_und_section (symbol->section) && ! relocatable)
638 return bfd_reloc_undefined;
639
640 /* We have to figure out the gp value, so that we can adjust the
641 symbol value correctly. We look up the symbol _gp in the output
642 BFD. If we can't find it, we're stuck. We cache it in the ECOFF
643 target data. We don't need to adjust the symbol value for an
644 external symbol if we are producing relocatable output. */
645 gp = _bfd_get_gp_value (output_bfd);
646 if (gp == 0
647 && (! relocatable
648 || (symbol->flags & BSF_SECTION_SYM) != 0))
649 {
650 if (relocatable)
651 {
652 /* Make up a value. */
653 gp = symbol->section->output_section->vma + 0x4000;
654 _bfd_set_gp_value (output_bfd, gp);
655 }
656 else
657 {
658 unsigned int count;
659 asymbol **sym;
660 unsigned int i;
661
662 count = bfd_get_symcount (output_bfd);
663 sym = bfd_get_outsymbols (output_bfd);
664
665 if (sym == (asymbol **) NULL)
666 i = count;
667 else
668 {
669 for (i = 0; i < count; i++, sym++)
670 {
671 register const char *name;
672
673 name = bfd_asymbol_name (*sym);
674 if (*name == '_' && strcmp (name, "_gp") == 0)
675 {
676 gp = bfd_asymbol_value (*sym);
677 _bfd_set_gp_value (output_bfd, gp);
678 break;
679 }
680 }
681 }
682
683 if (i >= count)
684 {
685 /* Only get the error once. */
686 gp = 4;
687 _bfd_set_gp_value (output_bfd, gp);
688 *error_message =
689 (char *) _("GP relative relocation when _gp not defined");
690 return bfd_reloc_dangerous;
691 }
692 }
693 }
694
695 if (bfd_is_com_section (symbol->section))
696 relocation = 0;
697 else
698 relocation = symbol->value;
699
700 relocation += symbol->section->output_section->vma;
701 relocation += symbol->section->output_offset;
702
703 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
704 if (reloc_entry->address > sz)
705 return bfd_reloc_outofrange;
706
707 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
708
709 /* Set val to the offset into the section or symbol. */
710 val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
711 if (val & 0x8000)
712 val -= 0x10000;
713
714 /* Adjust val for the final section location and GP value. If we
715 are producing relocatable output, we don't want to do this for
716 an external symbol. */
717 if (! relocatable
718 || (symbol->flags & BSF_SECTION_SYM) != 0)
719 val += relocation - gp;
720
721 insn = (insn &~ (unsigned) 0xffff) | (val & 0xffff);
722 bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + reloc_entry->address);
723
724 if (relocatable)
725 reloc_entry->address += input_section->output_offset;
726
727 /* Make sure it fit in 16 bits. */
728 if ((long) val >= 0x8000 || (long) val < -0x8000)
729 return bfd_reloc_overflow;
730
731 return bfd_reloc_ok;
732 }
733
734 /* Get the howto structure for a generic reloc type. */
735
736 static reloc_howto_type *
737 mips_bfd_reloc_type_lookup (abfd, code)
738 bfd *abfd ATTRIBUTE_UNUSED;
739 bfd_reloc_code_real_type code;
740 {
741 int mips_type;
742
743 switch (code)
744 {
745 case BFD_RELOC_16:
746 mips_type = MIPS_R_REFHALF;
747 break;
748 case BFD_RELOC_32:
749 case BFD_RELOC_CTOR:
750 mips_type = MIPS_R_REFWORD;
751 break;
752 case BFD_RELOC_MIPS_JMP:
753 mips_type = MIPS_R_JMPADDR;
754 break;
755 case BFD_RELOC_HI16_S:
756 mips_type = MIPS_R_REFHI;
757 break;
758 case BFD_RELOC_LO16:
759 mips_type = MIPS_R_REFLO;
760 break;
761 case BFD_RELOC_GPREL16:
762 mips_type = MIPS_R_GPREL;
763 break;
764 case BFD_RELOC_MIPS_LITERAL:
765 mips_type = MIPS_R_LITERAL;
766 break;
767 case BFD_RELOC_16_PCREL_S2:
768 mips_type = MIPS_R_PCREL16;
769 break;
770 default:
771 return (reloc_howto_type *) NULL;
772 }
773
774 return &mips_howto_table[mips_type];
775 }
776 \f
777 /* A helper routine for mips_relocate_section which handles the REFHI
778 relocations. The REFHI relocation must be followed by a REFLO
779 relocation, and the addend used is formed from the addends of both
780 instructions. */
781
782 static void
783 mips_relocate_hi (refhi, reflo, input_bfd, input_section, contents,
784 relocation)
785 struct internal_reloc *refhi;
786 struct internal_reloc *reflo;
787 bfd *input_bfd;
788 asection *input_section;
789 bfd_byte *contents;
790 bfd_vma relocation;
791 {
792 unsigned long insn;
793 unsigned long val;
794 unsigned long vallo;
795
796 if (refhi == NULL)
797 return;
798
799 insn = bfd_get_32 (input_bfd,
800 contents + refhi->r_vaddr - input_section->vma);
801 if (reflo == NULL)
802 vallo = 0;
803 else
804 vallo = (bfd_get_32 (input_bfd,
805 contents + reflo->r_vaddr - input_section->vma)
806 & 0xffff);
807
808 val = ((insn & 0xffff) << 16) + vallo;
809 val += relocation;
810
811 /* The low order 16 bits are always treated as a signed value.
812 Therefore, a negative value in the low order bits requires an
813 adjustment in the high order bits. We need to make this
814 adjustment in two ways: once for the bits we took from the data,
815 and once for the bits we are putting back in to the data. */
816 if ((vallo & 0x8000) != 0)
817 val -= 0x10000;
818
819 if ((val & 0x8000) != 0)
820 val += 0x10000;
821
822 insn = (insn &~ (unsigned) 0xffff) | ((val >> 16) & 0xffff);
823 bfd_put_32 (input_bfd, (bfd_vma) insn,
824 contents + refhi->r_vaddr - input_section->vma);
825 }
826
827 /* Relocate a section while linking a MIPS ECOFF file. */
828
829 static bfd_boolean
830 mips_relocate_section (output_bfd, info, input_bfd, input_section,
831 contents, external_relocs)
832 bfd *output_bfd;
833 struct bfd_link_info *info;
834 bfd *input_bfd;
835 asection *input_section;
836 bfd_byte *contents;
837 PTR external_relocs;
838 {
839 asection **symndx_to_section;
840 struct ecoff_link_hash_entry **sym_hashes;
841 bfd_vma gp;
842 bfd_boolean gp_undefined;
843 struct external_reloc *ext_rel;
844 struct external_reloc *ext_rel_end;
845 unsigned int i;
846 bfd_boolean got_lo;
847 struct internal_reloc lo_int_rel;
848 bfd_size_type amt;
849
850 BFD_ASSERT (input_bfd->xvec->byteorder
851 == output_bfd->xvec->byteorder);
852
853 /* We keep a table mapping the symndx found in an internal reloc to
854 the appropriate section. This is faster than looking up the
855 section by name each time. */
856 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
857 if (symndx_to_section == (asection **) NULL)
858 {
859 amt = NUM_RELOC_SECTIONS * sizeof (asection *);
860 symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
861 if (!symndx_to_section)
862 return FALSE;
863
864 symndx_to_section[RELOC_SECTION_NONE] = NULL;
865 symndx_to_section[RELOC_SECTION_TEXT] =
866 bfd_get_section_by_name (input_bfd, ".text");
867 symndx_to_section[RELOC_SECTION_RDATA] =
868 bfd_get_section_by_name (input_bfd, ".rdata");
869 symndx_to_section[RELOC_SECTION_DATA] =
870 bfd_get_section_by_name (input_bfd, ".data");
871 symndx_to_section[RELOC_SECTION_SDATA] =
872 bfd_get_section_by_name (input_bfd, ".sdata");
873 symndx_to_section[RELOC_SECTION_SBSS] =
874 bfd_get_section_by_name (input_bfd, ".sbss");
875 symndx_to_section[RELOC_SECTION_BSS] =
876 bfd_get_section_by_name (input_bfd, ".bss");
877 symndx_to_section[RELOC_SECTION_INIT] =
878 bfd_get_section_by_name (input_bfd, ".init");
879 symndx_to_section[RELOC_SECTION_LIT8] =
880 bfd_get_section_by_name (input_bfd, ".lit8");
881 symndx_to_section[RELOC_SECTION_LIT4] =
882 bfd_get_section_by_name (input_bfd, ".lit4");
883 symndx_to_section[RELOC_SECTION_XDATA] = NULL;
884 symndx_to_section[RELOC_SECTION_PDATA] = NULL;
885 symndx_to_section[RELOC_SECTION_FINI] =
886 bfd_get_section_by_name (input_bfd, ".fini");
887 symndx_to_section[RELOC_SECTION_LITA] = NULL;
888 symndx_to_section[RELOC_SECTION_ABS] = NULL;
889
890 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
891 }
892
893 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
894
895 gp = _bfd_get_gp_value (output_bfd);
896 if (gp == 0)
897 gp_undefined = TRUE;
898 else
899 gp_undefined = FALSE;
900
901 got_lo = FALSE;
902
903 ext_rel = (struct external_reloc *) external_relocs;
904 ext_rel_end = ext_rel + input_section->reloc_count;
905 for (i = 0; ext_rel < ext_rel_end; ext_rel++, i++)
906 {
907 struct internal_reloc int_rel;
908 bfd_boolean use_lo = FALSE;
909 bfd_vma addend;
910 reloc_howto_type *howto;
911 struct ecoff_link_hash_entry *h = NULL;
912 asection *s = NULL;
913 bfd_vma relocation;
914 bfd_reloc_status_type r;
915
916 if (! got_lo)
917 mips_ecoff_swap_reloc_in (input_bfd, (PTR) ext_rel, &int_rel);
918 else
919 {
920 int_rel = lo_int_rel;
921 got_lo = FALSE;
922 }
923
924 BFD_ASSERT (int_rel.r_type
925 < sizeof mips_howto_table / sizeof mips_howto_table[0]);
926
927 /* The REFHI reloc requires special handling. It must be followed
928 by a REFLO reloc, and the addend is formed from both relocs. */
929 if (int_rel.r_type == MIPS_R_REFHI)
930 {
931 struct external_reloc *lo_ext_rel;
932
933 /* As a GNU extension, permit an arbitrary number of REFHI
934 relocs before the REFLO reloc. This permits gcc to emit
935 the HI and LO relocs itself. */
936 for (lo_ext_rel = ext_rel + 1;
937 lo_ext_rel < ext_rel_end;
938 lo_ext_rel++)
939 {
940 mips_ecoff_swap_reloc_in (input_bfd, (PTR) lo_ext_rel,
941 &lo_int_rel);
942 if (lo_int_rel.r_type != int_rel.r_type)
943 break;
944 }
945
946 if (lo_ext_rel < ext_rel_end
947 && lo_int_rel.r_type == MIPS_R_REFLO
948 && int_rel.r_extern == lo_int_rel.r_extern
949 && int_rel.r_symndx == lo_int_rel.r_symndx)
950 {
951 use_lo = TRUE;
952 if (lo_ext_rel == ext_rel + 1)
953 got_lo = TRUE;
954 }
955 }
956
957 howto = &mips_howto_table[int_rel.r_type];
958
959 if (int_rel.r_extern)
960 {
961 h = sym_hashes[int_rel.r_symndx];
962 /* If h is NULL, that means that there is a reloc against an
963 external symbol which we thought was just a debugging
964 symbol. This should not happen. */
965 if (h == (struct ecoff_link_hash_entry *) NULL)
966 abort ();
967 }
968 else
969 {
970 if (int_rel.r_symndx < 0 || int_rel.r_symndx >= NUM_RELOC_SECTIONS)
971 s = NULL;
972 else
973 s = symndx_to_section[int_rel.r_symndx];
974
975 if (s == (asection *) NULL)
976 abort ();
977 }
978
979 /* The GPREL reloc uses an addend: the difference in the GP
980 values. */
981 if (int_rel.r_type != MIPS_R_GPREL
982 && int_rel.r_type != MIPS_R_LITERAL)
983 addend = 0;
984 else
985 {
986 if (gp_undefined)
987 {
988 if (! ((*info->callbacks->reloc_dangerous)
989 (info, _("GP relative relocation used when GP not defined"),
990 input_bfd, input_section,
991 int_rel.r_vaddr - input_section->vma)))
992 return FALSE;
993 /* Only give the error once per link. */
994 gp = 4;
995 _bfd_set_gp_value (output_bfd, gp);
996 gp_undefined = FALSE;
997 }
998 if (! int_rel.r_extern)
999 {
1000 /* This is a relocation against a section. The current
1001 addend in the instruction is the difference between
1002 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
1003 must change this to be the difference between the
1004 final definition (which will end up in RELOCATION)
1005 and the GP value of OUTPUT_BFD (which is in GP). */
1006 addend = ecoff_data (input_bfd)->gp - gp;
1007 }
1008 else if (! info->relocatable
1009 || h->root.type == bfd_link_hash_defined
1010 || h->root.type == bfd_link_hash_defweak)
1011 {
1012 /* This is a relocation against a defined symbol. The
1013 current addend in the instruction is simply the
1014 desired offset into the symbol (normally zero). We
1015 are going to change this into a relocation against a
1016 defined symbol, so we want the instruction to hold
1017 the difference between the final definition of the
1018 symbol (which will end up in RELOCATION) and the GP
1019 value of OUTPUT_BFD (which is in GP). */
1020 addend = - gp;
1021 }
1022 else
1023 {
1024 /* This is a relocation against an undefined or common
1025 symbol. The current addend in the instruction is
1026 simply the desired offset into the symbol (normally
1027 zero). We are generating relocatable output, and we
1028 aren't going to define this symbol, so we just leave
1029 the instruction alone. */
1030 addend = 0;
1031 }
1032 }
1033
1034 if (info->relocatable)
1035 {
1036 /* We are generating relocatable output, and must convert
1037 the existing reloc. */
1038 if (int_rel.r_extern)
1039 {
1040 if ((h->root.type == bfd_link_hash_defined
1041 || h->root.type == bfd_link_hash_defweak)
1042 && ! bfd_is_abs_section (h->root.u.def.section))
1043 {
1044 const char *name;
1045
1046 /* This symbol is defined in the output. Convert
1047 the reloc from being against the symbol to being
1048 against the section. */
1049
1050 /* Clear the r_extern bit. */
1051 int_rel.r_extern = 0;
1052
1053 /* Compute a new r_symndx value. */
1054 s = h->root.u.def.section;
1055 name = bfd_get_section_name (output_bfd,
1056 s->output_section);
1057
1058 int_rel.r_symndx = -1;
1059 switch (name[1])
1060 {
1061 case 'b':
1062 if (strcmp (name, ".bss") == 0)
1063 int_rel.r_symndx = RELOC_SECTION_BSS;
1064 break;
1065 case 'd':
1066 if (strcmp (name, ".data") == 0)
1067 int_rel.r_symndx = RELOC_SECTION_DATA;
1068 break;
1069 case 'f':
1070 if (strcmp (name, ".fini") == 0)
1071 int_rel.r_symndx = RELOC_SECTION_FINI;
1072 break;
1073 case 'i':
1074 if (strcmp (name, ".init") == 0)
1075 int_rel.r_symndx = RELOC_SECTION_INIT;
1076 break;
1077 case 'l':
1078 if (strcmp (name, ".lit8") == 0)
1079 int_rel.r_symndx = RELOC_SECTION_LIT8;
1080 else if (strcmp (name, ".lit4") == 0)
1081 int_rel.r_symndx = RELOC_SECTION_LIT4;
1082 break;
1083 case 'r':
1084 if (strcmp (name, ".rdata") == 0)
1085 int_rel.r_symndx = RELOC_SECTION_RDATA;
1086 break;
1087 case 's':
1088 if (strcmp (name, ".sdata") == 0)
1089 int_rel.r_symndx = RELOC_SECTION_SDATA;
1090 else if (strcmp (name, ".sbss") == 0)
1091 int_rel.r_symndx = RELOC_SECTION_SBSS;
1092 break;
1093 case 't':
1094 if (strcmp (name, ".text") == 0)
1095 int_rel.r_symndx = RELOC_SECTION_TEXT;
1096 break;
1097 }
1098
1099 if (int_rel.r_symndx == -1)
1100 abort ();
1101
1102 /* Add the section VMA and the symbol value. */
1103 relocation = (h->root.u.def.value
1104 + s->output_section->vma
1105 + s->output_offset);
1106
1107 /* For a PC relative relocation, the object file
1108 currently holds just the addend. We must adjust
1109 by the address to get the right value. */
1110 if (howto->pc_relative)
1111 relocation -= int_rel.r_vaddr - input_section->vma;
1112
1113 h = NULL;
1114 }
1115 else
1116 {
1117 /* Change the symndx value to the right one for the
1118 output BFD. */
1119 int_rel.r_symndx = h->indx;
1120 if (int_rel.r_symndx == -1)
1121 {
1122 /* This symbol is not being written out. */
1123 if (! ((*info->callbacks->unattached_reloc)
1124 (info, h->root.root.string, input_bfd,
1125 input_section,
1126 int_rel.r_vaddr - input_section->vma)))
1127 return FALSE;
1128 int_rel.r_symndx = 0;
1129 }
1130 relocation = 0;
1131 }
1132 }
1133 else
1134 {
1135 /* This is a relocation against a section. Adjust the
1136 value by the amount the section moved. */
1137 relocation = (s->output_section->vma
1138 + s->output_offset
1139 - s->vma);
1140 }
1141
1142 relocation += addend;
1143 addend = 0;
1144
1145 /* Adjust a PC relative relocation by removing the reference
1146 to the original address in the section and including the
1147 reference to the new address. */
1148 if (howto->pc_relative)
1149 relocation -= (input_section->output_section->vma
1150 + input_section->output_offset
1151 - input_section->vma);
1152
1153 /* Adjust the contents. */
1154 if (relocation == 0)
1155 r = bfd_reloc_ok;
1156 else
1157 {
1158 if (int_rel.r_type != MIPS_R_REFHI)
1159 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1160 (contents
1161 + int_rel.r_vaddr
1162 - input_section->vma));
1163 else
1164 {
1165 mips_relocate_hi (&int_rel,
1166 use_lo ? &lo_int_rel : NULL,
1167 input_bfd, input_section, contents,
1168 relocation);
1169 r = bfd_reloc_ok;
1170 }
1171 }
1172
1173 /* Adjust the reloc address. */
1174 int_rel.r_vaddr += (input_section->output_section->vma
1175 + input_section->output_offset
1176 - input_section->vma);
1177
1178 /* Save the changed reloc information. */
1179 mips_ecoff_swap_reloc_out (input_bfd, &int_rel, (PTR) ext_rel);
1180 }
1181 else
1182 {
1183 /* We are producing a final executable. */
1184 if (int_rel.r_extern)
1185 {
1186 /* This is a reloc against a symbol. */
1187 if (h->root.type == bfd_link_hash_defined
1188 || h->root.type == bfd_link_hash_defweak)
1189 {
1190 asection *hsec;
1191
1192 hsec = h->root.u.def.section;
1193 relocation = (h->root.u.def.value
1194 + hsec->output_section->vma
1195 + hsec->output_offset);
1196 }
1197 else
1198 {
1199 if (! ((*info->callbacks->undefined_symbol)
1200 (info, h->root.root.string, input_bfd,
1201 input_section,
1202 int_rel.r_vaddr - input_section->vma, TRUE)))
1203 return FALSE;
1204 relocation = 0;
1205 }
1206 }
1207 else
1208 {
1209 /* This is a reloc against a section. */
1210 relocation = (s->output_section->vma
1211 + s->output_offset
1212 - s->vma);
1213
1214 /* A PC relative reloc is already correct in the object
1215 file. Make it look like a pcrel_offset relocation by
1216 adding in the start address. */
1217 if (howto->pc_relative)
1218 relocation += int_rel.r_vaddr;
1219 }
1220
1221 if (int_rel.r_type != MIPS_R_REFHI)
1222 r = _bfd_final_link_relocate (howto,
1223 input_bfd,
1224 input_section,
1225 contents,
1226 (int_rel.r_vaddr
1227 - input_section->vma),
1228 relocation,
1229 addend);
1230 else
1231 {
1232 mips_relocate_hi (&int_rel,
1233 use_lo ? &lo_int_rel : NULL,
1234 input_bfd, input_section, contents,
1235 relocation);
1236 r = bfd_reloc_ok;
1237 }
1238 }
1239
1240 /* MIPS_R_JMPADDR requires peculiar overflow detection. The
1241 instruction provides a 28 bit address (the two lower bits are
1242 implicit zeroes) which is combined with the upper four bits
1243 of the instruction address. */
1244 if (r == bfd_reloc_ok
1245 && int_rel.r_type == MIPS_R_JMPADDR
1246 && (((relocation
1247 + addend
1248 + (int_rel.r_extern ? 0 : s->vma))
1249 & 0xf0000000)
1250 != ((input_section->output_section->vma
1251 + input_section->output_offset
1252 + (int_rel.r_vaddr - input_section->vma))
1253 & 0xf0000000)))
1254 r = bfd_reloc_overflow;
1255
1256 if (r != bfd_reloc_ok)
1257 {
1258 switch (r)
1259 {
1260 default:
1261 case bfd_reloc_outofrange:
1262 abort ();
1263 case bfd_reloc_overflow:
1264 {
1265 const char *name;
1266
1267 if (int_rel.r_extern)
1268 name = h->root.root.string;
1269 else
1270 name = bfd_section_name (input_bfd, s);
1271 if (! ((*info->callbacks->reloc_overflow)
1272 (info, name, howto->name, (bfd_vma) 0,
1273 input_bfd, input_section,
1274 int_rel.r_vaddr - input_section->vma)))
1275 return FALSE;
1276 }
1277 break;
1278 }
1279 }
1280 }
1281
1282 return TRUE;
1283 }
1284 \f
1285 /* This is the ECOFF backend structure. The backend field of the
1286 target vector points to this. */
1287
1288 static const struct ecoff_backend_data mips_ecoff_backend_data =
1289 {
1290 /* COFF backend structure. */
1291 {
1292 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
1293 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
1294 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
1295 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
1296 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
1297 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
1298 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
1299 mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
1300 mips_ecoff_swap_scnhdr_out,
1301 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE, FALSE, 4, FALSE, 2,
1302 mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
1303 mips_ecoff_swap_scnhdr_in, NULL,
1304 mips_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
1305 _bfd_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
1306 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
1307 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1308 NULL, NULL
1309 },
1310 /* Supported architecture. */
1311 bfd_arch_mips,
1312 /* Initial portion of armap string. */
1313 "__________",
1314 /* The page boundary used to align sections in a demand-paged
1315 executable file. E.g., 0x1000. */
1316 0x1000,
1317 /* TRUE if the .rdata section is part of the text segment, as on the
1318 Alpha. FALSE if .rdata is part of the data segment, as on the
1319 MIPS. */
1320 FALSE,
1321 /* Bitsize of constructor entries. */
1322 32,
1323 /* Reloc to use for constructor entries. */
1324 &mips_howto_table[MIPS_R_REFWORD],
1325 {
1326 /* Symbol table magic number. */
1327 magicSym,
1328 /* Alignment of debugging information. E.g., 4. */
1329 4,
1330 /* Sizes of external symbolic information. */
1331 sizeof (struct hdr_ext),
1332 sizeof (struct dnr_ext),
1333 sizeof (struct pdr_ext),
1334 sizeof (struct sym_ext),
1335 sizeof (struct opt_ext),
1336 sizeof (struct fdr_ext),
1337 sizeof (struct rfd_ext),
1338 sizeof (struct ext_ext),
1339 /* Functions to swap in external symbolic data. */
1340 ecoff_swap_hdr_in,
1341 ecoff_swap_dnr_in,
1342 ecoff_swap_pdr_in,
1343 ecoff_swap_sym_in,
1344 ecoff_swap_opt_in,
1345 ecoff_swap_fdr_in,
1346 ecoff_swap_rfd_in,
1347 ecoff_swap_ext_in,
1348 _bfd_ecoff_swap_tir_in,
1349 _bfd_ecoff_swap_rndx_in,
1350 /* Functions to swap out external symbolic data. */
1351 ecoff_swap_hdr_out,
1352 ecoff_swap_dnr_out,
1353 ecoff_swap_pdr_out,
1354 ecoff_swap_sym_out,
1355 ecoff_swap_opt_out,
1356 ecoff_swap_fdr_out,
1357 ecoff_swap_rfd_out,
1358 ecoff_swap_ext_out,
1359 _bfd_ecoff_swap_tir_out,
1360 _bfd_ecoff_swap_rndx_out,
1361 /* Function to read in symbolic data. */
1362 _bfd_ecoff_slurp_symbolic_info
1363 },
1364 /* External reloc size. */
1365 RELSZ,
1366 /* Reloc swapping functions. */
1367 mips_ecoff_swap_reloc_in,
1368 mips_ecoff_swap_reloc_out,
1369 /* Backend reloc tweaking. */
1370 mips_adjust_reloc_in,
1371 mips_adjust_reloc_out,
1372 /* Relocate section contents while linking. */
1373 mips_relocate_section,
1374 /* Do final adjustments to filehdr and aouthdr. */
1375 NULL,
1376 /* Read an element from an archive at a given file position. */
1377 _bfd_get_elt_at_filepos
1378 };
1379
1380 /* Looking up a reloc type is MIPS specific. */
1381 #define _bfd_ecoff_bfd_reloc_type_lookup mips_bfd_reloc_type_lookup
1382
1383 /* Getting relocated section contents is generic. */
1384 #define _bfd_ecoff_bfd_get_relocated_section_contents \
1385 bfd_generic_get_relocated_section_contents
1386
1387 /* Handling file windows is generic. */
1388 #define _bfd_ecoff_get_section_contents_in_window \
1389 _bfd_generic_get_section_contents_in_window
1390
1391 /* Relaxing sections is MIPS specific. */
1392 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
1393
1394 /* GC of sections is not done. */
1395 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
1396
1397 /* Merging of sections is not done. */
1398 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
1399
1400 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
1401 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
1402
1403 extern const bfd_target ecoff_big_vec;
1404
1405 const bfd_target ecoff_little_vec =
1406 {
1407 "ecoff-littlemips", /* name */
1408 bfd_target_ecoff_flavour,
1409 BFD_ENDIAN_LITTLE, /* data byte order is little */
1410 BFD_ENDIAN_LITTLE, /* header byte order is little */
1411
1412 (HAS_RELOC | EXEC_P | /* object flags */
1413 HAS_LINENO | HAS_DEBUG |
1414 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1415
1416 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1417 0, /* leading underscore */
1418 ' ', /* ar_pad_char */
1419 15, /* ar_max_namelen */
1420 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1421 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1422 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1423 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1424 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1425 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1426
1427 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1428 _bfd_ecoff_archive_p, _bfd_dummy_target},
1429 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1430 _bfd_generic_mkarchive, bfd_false},
1431 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1432 _bfd_write_archive_contents, bfd_false},
1433
1434 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1435 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1436 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1437 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1438 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1439 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1440 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1441 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1442 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1443
1444 & ecoff_big_vec,
1445
1446 (PTR) &mips_ecoff_backend_data
1447 };
1448
1449 const bfd_target ecoff_big_vec =
1450 {
1451 "ecoff-bigmips", /* name */
1452 bfd_target_ecoff_flavour,
1453 BFD_ENDIAN_BIG, /* data byte order is big */
1454 BFD_ENDIAN_BIG, /* header byte order is big */
1455
1456 (HAS_RELOC | EXEC_P | /* object flags */
1457 HAS_LINENO | HAS_DEBUG |
1458 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1459
1460 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1461 0, /* leading underscore */
1462 ' ', /* ar_pad_char */
1463 15, /* ar_max_namelen */
1464 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1465 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1466 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1467 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1468 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1469 bfd_getb16, bfd_getb_signed_16, bfd_putb16,
1470 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1471 _bfd_ecoff_archive_p, _bfd_dummy_target},
1472 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1473 _bfd_generic_mkarchive, bfd_false},
1474 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1475 _bfd_write_archive_contents, bfd_false},
1476
1477 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1478 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1479 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1480 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1481 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1482 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1483 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1484 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1485 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1486
1487 & ecoff_little_vec,
1488
1489 (PTR) &mips_ecoff_backend_data
1490 };
1491
1492 const bfd_target ecoff_biglittle_vec =
1493 {
1494 "ecoff-biglittlemips", /* name */
1495 bfd_target_ecoff_flavour,
1496 BFD_ENDIAN_LITTLE, /* data byte order is little */
1497 BFD_ENDIAN_BIG, /* header byte order is big */
1498
1499 (HAS_RELOC | EXEC_P | /* object flags */
1500 HAS_LINENO | HAS_DEBUG |
1501 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1502
1503 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
1504 0, /* leading underscore */
1505 ' ', /* ar_pad_char */
1506 15, /* ar_max_namelen */
1507 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1508 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1509 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1510 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1511 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1512 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1513
1514 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
1515 _bfd_ecoff_archive_p, _bfd_dummy_target},
1516 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
1517 _bfd_generic_mkarchive, bfd_false},
1518 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
1519 _bfd_write_archive_contents, bfd_false},
1520
1521 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
1522 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
1523 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1524 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
1525 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
1526 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
1527 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
1528 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
1529 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1530
1531 NULL,
1532
1533 (PTR) &mips_ecoff_backend_data
1534 };
GDB Binutils - Deliverables
This page took 0.084771 seconds and 5 git commands to generate.