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