1 /* BFD back-end for ALPHA Extended-Coff files.
2 Copyright (C) 1993-2018 Free Software Foundation, Inc.
3 Modified from coff-mips.c by Steve Chamberlain <sac@cygnus.com> and
4 Ian Lance Taylor <ian@cygnus.com>.
6 This file is part of BFD, the Binary File Descriptor library.
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 3 of the License, or
11 (at your option) any later version.
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.
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., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "coff/internal.h"
29 #include "coff/symconst.h"
30 #include "coff/ecoff.h"
31 #include "coff/alpha.h"
36 /* Prototypes for static functions. */
40 /* ECOFF has COFF sections, but the debugging information is stored in
41 a completely different format. ECOFF targets use some of the
42 swapping routines from coffswap.h, and some of the generic COFF
43 routines in coffgen.c, but, unlike the real COFF targets, do not
44 use coffcode.h itself.
46 Get the generic COFF swapping routines, except for the reloc,
47 symbol, and lineno ones. Give them ecoff names. Define some
48 accessor macros for the large sizes used for Alpha ECOFF. */
50 #define GET_FILEHDR_SYMPTR H_GET_64
51 #define PUT_FILEHDR_SYMPTR H_PUT_64
52 #define GET_AOUTHDR_TSIZE H_GET_64
53 #define PUT_AOUTHDR_TSIZE H_PUT_64
54 #define GET_AOUTHDR_DSIZE H_GET_64
55 #define PUT_AOUTHDR_DSIZE H_PUT_64
56 #define GET_AOUTHDR_BSIZE H_GET_64
57 #define PUT_AOUTHDR_BSIZE H_PUT_64
58 #define GET_AOUTHDR_ENTRY H_GET_64
59 #define PUT_AOUTHDR_ENTRY H_PUT_64
60 #define GET_AOUTHDR_TEXT_START H_GET_64
61 #define PUT_AOUTHDR_TEXT_START H_PUT_64
62 #define GET_AOUTHDR_DATA_START H_GET_64
63 #define PUT_AOUTHDR_DATA_START H_PUT_64
64 #define GET_SCNHDR_PADDR H_GET_64
65 #define PUT_SCNHDR_PADDR H_PUT_64
66 #define GET_SCNHDR_VADDR H_GET_64
67 #define PUT_SCNHDR_VADDR H_PUT_64
68 #define GET_SCNHDR_SIZE H_GET_64
69 #define PUT_SCNHDR_SIZE H_PUT_64
70 #define GET_SCNHDR_SCNPTR H_GET_64
71 #define PUT_SCNHDR_SCNPTR H_PUT_64
72 #define GET_SCNHDR_RELPTR H_GET_64
73 #define PUT_SCNHDR_RELPTR H_PUT_64
74 #define GET_SCNHDR_LNNOPTR H_GET_64
75 #define PUT_SCNHDR_LNNOPTR H_PUT_64
79 #define NO_COFF_RELOCS
80 #define NO_COFF_SYMBOLS
81 #define NO_COFF_LINENOS
82 #define coff_swap_filehdr_in alpha_ecoff_swap_filehdr_in
83 #define coff_swap_filehdr_out alpha_ecoff_swap_filehdr_out
84 #define coff_swap_aouthdr_in alpha_ecoff_swap_aouthdr_in
85 #define coff_swap_aouthdr_out alpha_ecoff_swap_aouthdr_out
86 #define coff_swap_scnhdr_in alpha_ecoff_swap_scnhdr_in
87 #define coff_swap_scnhdr_out alpha_ecoff_swap_scnhdr_out
90 /* Get the ECOFF swapping routines. */
92 #include "ecoffswap.h"
94 /* How to process the various reloc types. */
96 static bfd_reloc_status_type
97 reloc_nil (bfd *abfd ATTRIBUTE_UNUSED,
98 arelent *reloc ATTRIBUTE_UNUSED,
99 asymbol *sym ATTRIBUTE_UNUSED,
100 void * data ATTRIBUTE_UNUSED,
101 asection *sec ATTRIBUTE_UNUSED,
102 bfd *output_bfd ATTRIBUTE_UNUSED,
103 char **error_message ATTRIBUTE_UNUSED)
108 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
109 from smaller values. Start with zero, widen, *then* decrement. */
110 #define MINUS_ONE (((bfd_vma)0) - 1)
112 static reloc_howto_type alpha_howto_table[] =
114 /* Reloc type 0 is ignored by itself. However, it appears after a
115 GPDISP reloc to identify the location where the low order 16 bits
116 of the gp register are loaded. */
117 HOWTO (ALPHA_R_IGNORE, /* type */
119 0, /* size (0 = byte, 1 = short, 2 = long) */
121 TRUE, /* pc_relative */
123 complain_overflow_dont, /* complain_on_overflow */
124 reloc_nil, /* special_function */
126 TRUE, /* partial_inplace */
129 TRUE), /* pcrel_offset */
131 /* A 32 bit reference to a symbol. */
132 HOWTO (ALPHA_R_REFLONG, /* type */
134 2, /* size (0 = byte, 1 = short, 2 = long) */
136 FALSE, /* pc_relative */
138 complain_overflow_bitfield, /* complain_on_overflow */
139 0, /* special_function */
140 "REFLONG", /* name */
141 TRUE, /* partial_inplace */
142 0xffffffff, /* src_mask */
143 0xffffffff, /* dst_mask */
144 FALSE), /* pcrel_offset */
146 /* A 64 bit reference to a symbol. */
147 HOWTO (ALPHA_R_REFQUAD, /* type */
149 4, /* size (0 = byte, 1 = short, 2 = long) */
151 FALSE, /* pc_relative */
153 complain_overflow_bitfield, /* complain_on_overflow */
154 0, /* special_function */
155 "REFQUAD", /* name */
156 TRUE, /* partial_inplace */
157 MINUS_ONE, /* src_mask */
158 MINUS_ONE, /* dst_mask */
159 FALSE), /* pcrel_offset */
161 /* A 32 bit GP relative offset. This is just like REFLONG except
162 that when the value is used the value of the gp register will be
164 HOWTO (ALPHA_R_GPREL32, /* type */
166 2, /* size (0 = byte, 1 = short, 2 = long) */
168 FALSE, /* pc_relative */
170 complain_overflow_bitfield, /* complain_on_overflow */
171 0, /* special_function */
172 "GPREL32", /* name */
173 TRUE, /* partial_inplace */
174 0xffffffff, /* src_mask */
175 0xffffffff, /* dst_mask */
176 FALSE), /* pcrel_offset */
178 /* Used for an instruction that refers to memory off the GP
179 register. The offset is 16 bits of the 32 bit instruction. This
180 reloc always seems to be against the .lita section. */
181 HOWTO (ALPHA_R_LITERAL, /* type */
183 2, /* size (0 = byte, 1 = short, 2 = long) */
185 FALSE, /* pc_relative */
187 complain_overflow_signed, /* complain_on_overflow */
188 0, /* special_function */
189 "LITERAL", /* name */
190 TRUE, /* partial_inplace */
191 0xffff, /* src_mask */
192 0xffff, /* dst_mask */
193 FALSE), /* pcrel_offset */
195 /* This reloc only appears immediately following a LITERAL reloc.
196 It identifies a use of the literal. It seems that the linker can
197 use this to eliminate a portion of the .lita section. The symbol
198 index is special: 1 means the literal address is in the base
199 register of a memory format instruction; 2 means the literal
200 address is in the byte offset register of a byte-manipulation
201 instruction; 3 means the literal address is in the target
202 register of a jsr instruction. This does not actually do any
204 HOWTO (ALPHA_R_LITUSE, /* type */
206 2, /* size (0 = byte, 1 = short, 2 = long) */
208 FALSE, /* pc_relative */
210 complain_overflow_dont, /* complain_on_overflow */
211 reloc_nil, /* special_function */
213 FALSE, /* partial_inplace */
216 FALSE), /* pcrel_offset */
218 /* Load the gp register. This is always used for a ldah instruction
219 which loads the upper 16 bits of the gp register. The next reloc
220 will be an IGNORE reloc which identifies the location of the lda
221 instruction which loads the lower 16 bits. The symbol index of
222 the GPDISP instruction appears to actually be the number of bytes
223 between the ldah and lda instructions. This gives two different
224 ways to determine where the lda instruction is; I don't know why
225 both are used. The value to use for the relocation is the
226 difference between the GP value and the current location; the
227 load will always be done against a register holding the current
229 HOWTO (ALPHA_R_GPDISP, /* type */
231 2, /* size (0 = byte, 1 = short, 2 = long) */
233 TRUE, /* pc_relative */
235 complain_overflow_dont, /* complain_on_overflow */
236 reloc_nil, /* special_function */
238 TRUE, /* partial_inplace */
239 0xffff, /* src_mask */
240 0xffff, /* dst_mask */
241 TRUE), /* pcrel_offset */
243 /* A 21 bit branch. The native assembler generates these for
244 branches within the text segment, and also fills in the PC
245 relative offset in the instruction. */
246 HOWTO (ALPHA_R_BRADDR, /* type */
248 2, /* size (0 = byte, 1 = short, 2 = long) */
250 TRUE, /* pc_relative */
252 complain_overflow_signed, /* complain_on_overflow */
253 0, /* special_function */
255 TRUE, /* partial_inplace */
256 0x1fffff, /* src_mask */
257 0x1fffff, /* dst_mask */
258 FALSE), /* pcrel_offset */
260 /* A hint for a jump to a register. */
261 HOWTO (ALPHA_R_HINT, /* type */
263 2, /* size (0 = byte, 1 = short, 2 = long) */
265 TRUE, /* pc_relative */
267 complain_overflow_dont, /* complain_on_overflow */
268 0, /* special_function */
270 TRUE, /* partial_inplace */
271 0x3fff, /* src_mask */
272 0x3fff, /* dst_mask */
273 FALSE), /* pcrel_offset */
275 /* 16 bit PC relative offset. */
276 HOWTO (ALPHA_R_SREL16, /* type */
278 1, /* size (0 = byte, 1 = short, 2 = long) */
280 TRUE, /* pc_relative */
282 complain_overflow_signed, /* complain_on_overflow */
283 0, /* special_function */
285 TRUE, /* partial_inplace */
286 0xffff, /* src_mask */
287 0xffff, /* dst_mask */
288 FALSE), /* pcrel_offset */
290 /* 32 bit PC relative offset. */
291 HOWTO (ALPHA_R_SREL32, /* type */
293 2, /* size (0 = byte, 1 = short, 2 = long) */
295 TRUE, /* pc_relative */
297 complain_overflow_signed, /* complain_on_overflow */
298 0, /* special_function */
300 TRUE, /* partial_inplace */
301 0xffffffff, /* src_mask */
302 0xffffffff, /* dst_mask */
303 FALSE), /* pcrel_offset */
305 /* A 64 bit PC relative offset. */
306 HOWTO (ALPHA_R_SREL64, /* type */
308 4, /* size (0 = byte, 1 = short, 2 = long) */
310 TRUE, /* pc_relative */
312 complain_overflow_signed, /* complain_on_overflow */
313 0, /* special_function */
315 TRUE, /* partial_inplace */
316 MINUS_ONE, /* src_mask */
317 MINUS_ONE, /* dst_mask */
318 FALSE), /* pcrel_offset */
320 /* Push a value on the reloc evaluation stack. */
321 HOWTO (ALPHA_R_OP_PUSH, /* type */
323 0, /* size (0 = byte, 1 = short, 2 = long) */
325 FALSE, /* pc_relative */
327 complain_overflow_dont, /* complain_on_overflow */
328 0, /* special_function */
329 "OP_PUSH", /* name */
330 FALSE, /* partial_inplace */
333 FALSE), /* pcrel_offset */
335 /* Store the value from the stack at the given address. Store it in
336 a bitfield of size r_size starting at bit position r_offset. */
337 HOWTO (ALPHA_R_OP_STORE, /* type */
339 4, /* size (0 = byte, 1 = short, 2 = long) */
341 FALSE, /* pc_relative */
343 complain_overflow_dont, /* complain_on_overflow */
344 0, /* special_function */
345 "OP_STORE", /* name */
346 FALSE, /* partial_inplace */
348 MINUS_ONE, /* dst_mask */
349 FALSE), /* pcrel_offset */
351 /* Subtract the reloc address from the value on the top of the
353 HOWTO (ALPHA_R_OP_PSUB, /* type */
355 0, /* size (0 = byte, 1 = short, 2 = long) */
357 FALSE, /* pc_relative */
359 complain_overflow_dont, /* complain_on_overflow */
360 0, /* special_function */
361 "OP_PSUB", /* name */
362 FALSE, /* partial_inplace */
365 FALSE), /* pcrel_offset */
367 /* Shift the value on the top of the relocation stack right by the
369 HOWTO (ALPHA_R_OP_PRSHIFT, /* type */
371 0, /* size (0 = byte, 1 = short, 2 = long) */
373 FALSE, /* pc_relative */
375 complain_overflow_dont, /* complain_on_overflow */
376 0, /* special_function */
377 "OP_PRSHIFT", /* name */
378 FALSE, /* partial_inplace */
381 FALSE), /* pcrel_offset */
383 /* Adjust the GP value for a new range in the object file. */
384 HOWTO (ALPHA_R_GPVALUE, /* type */
386 0, /* size (0 = byte, 1 = short, 2 = long) */
388 FALSE, /* pc_relative */
390 complain_overflow_dont, /* complain_on_overflow */
391 0, /* special_function */
392 "GPVALUE", /* name */
393 FALSE, /* partial_inplace */
396 FALSE) /* pcrel_offset */
399 /* Recognize an Alpha ECOFF file. */
401 static const bfd_target *
402 alpha_ecoff_object_p (bfd *abfd)
404 static const bfd_target *ret;
406 ret = coff_object_p (abfd);
412 /* Alpha ECOFF has a .pdata section. The lnnoptr field of the
413 .pdata section is the number of entries it contains. Each
414 entry takes up 8 bytes. The number of entries is required
415 since the section is aligned to a 16 byte boundary. When we
416 link .pdata sections together, we do not want to include the
417 alignment bytes. We handle this on input by faking the size
418 of the .pdata section to remove the unwanted alignment bytes.
419 On output we will set the lnnoptr field and force the
421 sec = bfd_get_section_by_name (abfd, _PDATA);
422 if (sec != (asection *) NULL)
426 size = sec->line_filepos * 8;
427 BFD_ASSERT (size == sec->size
428 || size + 8 == sec->size);
429 if (! bfd_set_section_size (abfd, sec, size))
437 /* See whether the magic number matches. */
440 alpha_ecoff_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED,
443 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
445 if (! ALPHA_ECOFF_BADMAG (*internal_f))
448 if (ALPHA_ECOFF_COMPRESSEDMAG (*internal_f))
450 (_("%pB: Cannot handle compressed Alpha binaries.\n"
451 " Use compiler flags, or objZ, to generate uncompressed binaries."),
457 /* This is a hook called by coff_real_object_p to create any backend
458 specific information. */
461 alpha_ecoff_mkobject_hook (bfd *abfd, void * filehdr, void * aouthdr)
465 ecoff = _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr);
469 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
471 /* Set additional BFD flags according to the object type from the
472 machine specific file header flags. */
473 switch (internal_f->f_flags & F_ALPHA_OBJECT_TYPE_MASK)
475 case F_ALPHA_SHARABLE:
476 abfd->flags |= DYNAMIC;
478 case F_ALPHA_CALL_SHARED:
479 /* Always executable if using shared libraries as the run time
480 loader might resolve undefined references. */
481 abfd->flags |= (DYNAMIC | EXEC_P);
488 /* Reloc handling. */
490 /* Swap a reloc in. */
493 alpha_ecoff_swap_reloc_in (bfd *abfd,
495 struct internal_reloc *intern)
497 const RELOC *ext = (RELOC *) ext_ptr;
499 intern->r_vaddr = H_GET_64 (abfd, ext->r_vaddr);
500 intern->r_symndx = H_GET_32 (abfd, ext->r_symndx);
502 BFD_ASSERT (bfd_header_little_endian (abfd));
504 intern->r_type = ((ext->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
505 >> RELOC_BITS0_TYPE_SH_LITTLE);
506 intern->r_extern = (ext->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
507 intern->r_offset = ((ext->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
508 >> RELOC_BITS1_OFFSET_SH_LITTLE);
509 /* Ignored the reserved bits. */
510 intern->r_size = ((ext->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
511 >> RELOC_BITS3_SIZE_SH_LITTLE);
513 if (intern->r_type == ALPHA_R_LITUSE
514 || intern->r_type == ALPHA_R_GPDISP)
516 /* Handle the LITUSE and GPDISP relocs specially. Its symndx
517 value is not actually a symbol index, but is instead a
518 special code. We put the code in the r_size field, and
519 clobber the symndx. */
520 if (intern->r_size != 0)
522 intern->r_size = intern->r_symndx;
523 intern->r_symndx = RELOC_SECTION_NONE;
525 else if (intern->r_type == ALPHA_R_IGNORE)
527 /* The IGNORE reloc generally follows a GPDISP reloc, and is
528 against the .lita section. The section is irrelevant. */
529 if (! intern->r_extern &&
530 intern->r_symndx == RELOC_SECTION_ABS)
532 if (! intern->r_extern && intern->r_symndx == RELOC_SECTION_LITA)
533 intern->r_symndx = RELOC_SECTION_ABS;
537 /* Swap a reloc out. */
540 alpha_ecoff_swap_reloc_out (bfd *abfd,
541 const struct internal_reloc *intern,
544 RELOC *ext = (RELOC *) dst;
548 /* Undo the hackery done in swap_reloc_in. */
549 if (intern->r_type == ALPHA_R_LITUSE
550 || intern->r_type == ALPHA_R_GPDISP)
552 symndx = intern->r_size;
555 else if (intern->r_type == ALPHA_R_IGNORE
556 && ! intern->r_extern
557 && intern->r_symndx == RELOC_SECTION_ABS)
559 symndx = RELOC_SECTION_LITA;
560 size = intern->r_size;
564 symndx = intern->r_symndx;
565 size = intern->r_size;
568 /* XXX FIXME: The maximum symndx value used to be 14 but this
569 fails with object files produced by DEC's C++ compiler.
570 Where does the value 14 (or 15) come from anyway ? */
571 BFD_ASSERT (intern->r_extern
572 || (intern->r_symndx >= 0 && intern->r_symndx <= 15));
574 H_PUT_64 (abfd, intern->r_vaddr, ext->r_vaddr);
575 H_PUT_32 (abfd, symndx, ext->r_symndx);
577 BFD_ASSERT (bfd_header_little_endian (abfd));
579 ext->r_bits[0] = ((intern->r_type << RELOC_BITS0_TYPE_SH_LITTLE)
580 & RELOC_BITS0_TYPE_LITTLE);
581 ext->r_bits[1] = ((intern->r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
582 | ((intern->r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
583 & RELOC_BITS1_OFFSET_LITTLE));
585 ext->r_bits[3] = ((size << RELOC_BITS3_SIZE_SH_LITTLE)
586 & RELOC_BITS3_SIZE_LITTLE);
589 /* Finish canonicalizing a reloc. Part of this is generic to all
590 ECOFF targets, and that part is in ecoff.c. The rest is done in
591 this backend routine. It must fill in the howto field. */
594 alpha_adjust_reloc_in (bfd *abfd,
595 const struct internal_reloc *intern,
598 if (intern->r_type > ALPHA_R_GPVALUE)
600 /* xgettext:c-format */
602 (_("%pB: unknown/unsupported relocation type %d"),
603 abfd, intern->r_type);
604 bfd_set_error (bfd_error_bad_value);
610 switch (intern->r_type)
616 /* This relocs appear to be fully resolved when they are against
617 internal symbols. Against external symbols, BRADDR at least
618 appears to be resolved against the next instruction. */
619 if (! intern->r_extern)
622 rptr->addend = - (intern->r_vaddr + 4);
625 case ALPHA_R_GPREL32:
626 case ALPHA_R_LITERAL:
627 /* Copy the gp value for this object file into the addend, to
628 ensure that we are not confused by the linker. */
629 if (! intern->r_extern)
630 rptr->addend += ecoff_data (abfd)->gp;
635 /* The LITUSE and GPDISP relocs do not use a symbol, or an
636 addend, but they do use a special code. Put this code in the
638 rptr->addend = intern->r_size;
641 case ALPHA_R_OP_STORE:
642 /* The STORE reloc needs the size and offset fields. We store
643 them in the addend. */
644 BFD_ASSERT (intern->r_offset <= 256);
645 rptr->addend = (intern->r_offset << 8) + intern->r_size;
648 case ALPHA_R_OP_PUSH:
649 case ALPHA_R_OP_PSUB:
650 case ALPHA_R_OP_PRSHIFT:
651 /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
652 address. I believe that the address supplied is really an
654 rptr->addend = intern->r_vaddr;
657 case ALPHA_R_GPVALUE:
658 /* Set the addend field to the new GP value. */
659 rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp;
663 /* If the type is ALPHA_R_IGNORE, make sure this is a reference
664 to the absolute section so that the reloc is ignored. For
665 some reason the address of this reloc type is not adjusted by
666 the section vma. We record the gp value for this object file
667 here, for convenience when doing the GPDISP relocation. */
668 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
669 rptr->address = intern->r_vaddr;
670 rptr->addend = ecoff_data (abfd)->gp;
677 rptr->howto = &alpha_howto_table[intern->r_type];
680 /* When writing out a reloc we need to pull some values back out of
681 the addend field into the reloc. This is roughly the reverse of
682 alpha_adjust_reloc_in, except that there are several changes we do
686 alpha_adjust_reloc_out (bfd *abfd ATTRIBUTE_UNUSED,
688 struct internal_reloc *intern)
690 switch (intern->r_type)
694 intern->r_size = rel->addend;
697 case ALPHA_R_OP_STORE:
698 intern->r_size = rel->addend & 0xff;
699 intern->r_offset = (rel->addend >> 8) & 0xff;
702 case ALPHA_R_OP_PUSH:
703 case ALPHA_R_OP_PSUB:
704 case ALPHA_R_OP_PRSHIFT:
705 intern->r_vaddr = rel->addend;
709 intern->r_vaddr = rel->address;
717 /* The size of the stack for the relocation evaluator. */
718 #define RELOC_STACKSIZE (10)
720 /* Alpha ECOFF relocs have a built in expression evaluator as well as
721 other interdependencies. Rather than use a bunch of special
722 functions and global variables, we use a single routine to do all
723 the relocation for a section. I haven't yet worked out how the
724 assembler is going to handle this. */
727 alpha_ecoff_get_relocated_section_contents (bfd *abfd,
728 struct bfd_link_info *link_info,
729 struct bfd_link_order *link_order,
731 bfd_boolean relocatable,
734 bfd *input_bfd = link_order->u.indirect.section->owner;
735 asection *input_section = link_order->u.indirect.section;
736 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
737 arelent **reloc_vector = NULL;
739 bfd *output_bfd = relocatable ? abfd : (bfd *) NULL;
742 bfd_boolean gp_undefined;
743 bfd_vma stack[RELOC_STACKSIZE];
748 reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
749 if (reloc_vector == NULL && reloc_size != 0)
752 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
753 if (! bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
756 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
757 reloc_vector, symbols);
760 if (reloc_count == 0)
761 goto successful_return;
763 /* Get the GP value for the output BFD. */
764 gp_undefined = FALSE;
765 gp = _bfd_get_gp_value (abfd);
773 /* Make up a value. */
775 for (sec = abfd->sections; sec != NULL; sec = sec->next)
778 && (strcmp (sec->name, ".sbss") == 0
779 || strcmp (sec->name, ".sdata") == 0
780 || strcmp (sec->name, ".lit4") == 0
781 || strcmp (sec->name, ".lit8") == 0
782 || strcmp (sec->name, ".lita") == 0))
786 _bfd_set_gp_value (abfd, gp);
790 struct bfd_link_hash_entry *h;
792 h = bfd_link_hash_lookup (link_info->hash, "_gp", FALSE, FALSE,
794 if (h == (struct bfd_link_hash_entry *) NULL
795 || h->type != bfd_link_hash_defined)
800 + h->u.def.section->output_section->vma
801 + h->u.def.section->output_offset);
802 _bfd_set_gp_value (abfd, gp);
807 for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
810 bfd_reloc_status_type r;
815 switch (rel->howto->type)
818 rel->address += input_section->output_offset;
821 case ALPHA_R_REFLONG:
822 case ALPHA_R_REFQUAD:
829 && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
831 rel->address += input_section->output_offset;
834 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
838 case ALPHA_R_GPREL32:
839 /* This relocation is used in a switch table. It is a 32
840 bit offset from the current GP value. We must adjust it
841 by the different between the original GP value and the
842 current GP value. The original GP value is stored in the
843 addend. We adjust the addend and let
844 bfd_perform_relocation finish the job. */
846 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
848 if (r == bfd_reloc_ok && gp_undefined)
850 r = bfd_reloc_dangerous;
851 err = (char *) _("GP relative relocation used when GP not defined");
855 case ALPHA_R_LITERAL:
856 /* This is a reference to a literal value, generally
857 (always?) in the .lita section. This is a 16 bit GP
858 relative relocation. Sometimes the subsequent reloc is a
859 LITUSE reloc, which indicates how this reloc is used.
860 This sometimes permits rewriting the two instructions
861 referred to by the LITERAL and the LITUSE into different
862 instructions which do not refer to .lita. This can save
863 a memory reference, and permits removing a value from
864 .lita thus saving GP relative space.
866 We do not these optimizations. To do them we would need
867 to arrange to link the .lita section first, so that by
868 the time we got here we would know the final values to
869 use. This would not be particularly difficult, but it is
870 not currently implemented. */
875 /* I believe that the LITERAL reloc will only apply to a
876 ldq or ldl instruction, so check my assumption. */
877 insn = bfd_get_32 (input_bfd, data + rel->address);
878 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
879 || ((insn >> 26) & 0x3f) == 0x28);
882 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
884 if (r == bfd_reloc_ok && gp_undefined)
886 r = bfd_reloc_dangerous;
888 (char *) _("GP relative relocation used when GP not defined");
894 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
895 does not cause anything to happen, itself. */
896 rel->address += input_section->output_offset;
900 /* This marks the ldah of an ldah/lda pair which loads the
901 gp register with the difference of the gp value and the
902 current location. The second of the pair is r_size bytes
903 ahead; it used to be marked with an ALPHA_R_IGNORE reloc,
904 but that no longer happens in OSF/1 3.2. */
906 unsigned long insn1, insn2;
909 /* Get the two instructions. */
910 insn1 = bfd_get_32 (input_bfd, data + rel->address);
911 insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend);
913 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
914 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
916 /* Get the existing addend. We must account for the sign
917 extension done by lda and ldah. */
918 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
921 addend -= 0x80000000;
922 addend -= 0x80000000;
927 /* The existing addend includes the different between the
928 gp of the input BFD and the address in the input BFD.
929 Subtract this out. */
930 addend -= (ecoff_data (input_bfd)->gp
931 - (input_section->vma + rel->address));
933 /* Now add in the final gp value, and subtract out the
936 - (input_section->output_section->vma
937 + input_section->output_offset
940 /* Change the instructions, accounting for the sign
941 extension, and write them out. */
944 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
945 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
947 bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address);
948 bfd_put_32 (input_bfd, (bfd_vma) insn2,
949 data + rel->address + rel->addend);
951 rel->address += input_section->output_offset;
955 case ALPHA_R_OP_PUSH:
956 /* Push a value on the reloc evaluation stack. */
963 rel->address += input_section->output_offset;
967 /* Figure out the relocation of this symbol. */
968 symbol = *rel->sym_ptr_ptr;
970 if (bfd_is_und_section (symbol->section))
971 r = bfd_reloc_undefined;
973 if (bfd_is_com_section (symbol->section))
976 relocation = symbol->value;
977 relocation += symbol->section->output_section->vma;
978 relocation += symbol->section->output_offset;
979 relocation += rel->addend;
981 if (tos >= RELOC_STACKSIZE)
984 stack[tos++] = relocation;
988 case ALPHA_R_OP_STORE:
989 /* Store a value from the reloc stack into a bitfield. */
996 rel->address += input_section->output_offset;
1003 /* The offset and size for this reloc are encoded into the
1004 addend field by alpha_adjust_reloc_in. */
1005 offset = (rel->addend >> 8) & 0xff;
1006 size = rel->addend & 0xff;
1008 val = bfd_get_64 (abfd, data + rel->address);
1009 val &=~ (((1 << size) - 1) << offset);
1010 val |= (stack[--tos] & ((1 << size) - 1)) << offset;
1011 bfd_put_64 (abfd, val, data + rel->address);
1015 case ALPHA_R_OP_PSUB:
1016 /* Subtract a value from the top of the stack. */
1023 rel->address += input_section->output_offset;
1027 /* Figure out the relocation of this symbol. */
1028 symbol = *rel->sym_ptr_ptr;
1030 if (bfd_is_und_section (symbol->section))
1031 r = bfd_reloc_undefined;
1033 if (bfd_is_com_section (symbol->section))
1036 relocation = symbol->value;
1037 relocation += symbol->section->output_section->vma;
1038 relocation += symbol->section->output_offset;
1039 relocation += rel->addend;
1044 stack[tos - 1] -= relocation;
1048 case ALPHA_R_OP_PRSHIFT:
1049 /* Shift the value on the top of the stack. */
1056 rel->address += input_section->output_offset;
1060 /* Figure out the relocation of this symbol. */
1061 symbol = *rel->sym_ptr_ptr;
1063 if (bfd_is_und_section (symbol->section))
1064 r = bfd_reloc_undefined;
1066 if (bfd_is_com_section (symbol->section))
1069 relocation = symbol->value;
1070 relocation += symbol->section->output_section->vma;
1071 relocation += symbol->section->output_offset;
1072 relocation += rel->addend;
1077 stack[tos - 1] >>= relocation;
1081 case ALPHA_R_GPVALUE:
1082 /* I really don't know if this does the right thing. */
1084 gp_undefined = FALSE;
1093 asection *os = input_section->output_section;
1095 /* A partial link, so keep the relocs. */
1096 os->orelocation[os->reloc_count] = rel;
1100 if (r != bfd_reloc_ok)
1104 case bfd_reloc_undefined:
1105 (*link_info->callbacks->undefined_symbol)
1106 (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1107 input_bfd, input_section, rel->address, TRUE);
1109 case bfd_reloc_dangerous:
1110 (*link_info->callbacks->reloc_dangerous)
1111 (link_info, err, input_bfd, input_section, rel->address);
1113 case bfd_reloc_overflow:
1114 (*link_info->callbacks->reloc_overflow)
1115 (link_info, NULL, bfd_asymbol_name (*rel->sym_ptr_ptr),
1116 rel->howto->name, rel->addend, input_bfd,
1117 input_section, rel->address);
1119 case bfd_reloc_outofrange:
1131 if (reloc_vector != NULL)
1132 free (reloc_vector);
1136 if (reloc_vector != NULL)
1137 free (reloc_vector);
1141 /* Get the howto structure for a generic reloc type. */
1143 static reloc_howto_type *
1144 alpha_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1145 bfd_reloc_code_real_type code)
1152 alpha_type = ALPHA_R_REFLONG;
1155 case BFD_RELOC_CTOR:
1156 alpha_type = ALPHA_R_REFQUAD;
1158 case BFD_RELOC_GPREL32:
1159 alpha_type = ALPHA_R_GPREL32;
1161 case BFD_RELOC_ALPHA_LITERAL:
1162 alpha_type = ALPHA_R_LITERAL;
1164 case BFD_RELOC_ALPHA_LITUSE:
1165 alpha_type = ALPHA_R_LITUSE;
1167 case BFD_RELOC_ALPHA_GPDISP_HI16:
1168 alpha_type = ALPHA_R_GPDISP;
1170 case BFD_RELOC_ALPHA_GPDISP_LO16:
1171 alpha_type = ALPHA_R_IGNORE;
1173 case BFD_RELOC_23_PCREL_S2:
1174 alpha_type = ALPHA_R_BRADDR;
1176 case BFD_RELOC_ALPHA_HINT:
1177 alpha_type = ALPHA_R_HINT;
1179 case BFD_RELOC_16_PCREL:
1180 alpha_type = ALPHA_R_SREL16;
1182 case BFD_RELOC_32_PCREL:
1183 alpha_type = ALPHA_R_SREL32;
1185 case BFD_RELOC_64_PCREL:
1186 alpha_type = ALPHA_R_SREL64;
1189 return (reloc_howto_type *) NULL;
1192 return &alpha_howto_table[alpha_type];
1195 static reloc_howto_type *
1196 alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1202 i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
1204 if (alpha_howto_table[i].name != NULL
1205 && strcasecmp (alpha_howto_table[i].name, r_name) == 0)
1206 return &alpha_howto_table[i];
1211 /* A helper routine for alpha_relocate_section which converts an
1212 external reloc when generating relocatable output. Returns the
1213 relocation amount. */
1216 alpha_convert_external_reloc (bfd *output_bfd ATTRIBUTE_UNUSED,
1217 struct bfd_link_info *info,
1219 struct external_reloc *ext_rel,
1220 struct ecoff_link_hash_entry *h)
1222 unsigned long r_symndx;
1225 BFD_ASSERT (bfd_link_relocatable (info));
1227 if (h->root.type == bfd_link_hash_defined
1228 || h->root.type == bfd_link_hash_defweak)
1233 /* This symbol is defined in the output. Convert the reloc from
1234 being against the symbol to being against the section. */
1236 /* Clear the r_extern bit. */
1237 ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE;
1239 /* Compute a new r_symndx value. */
1240 hsec = h->root.u.def.section;
1241 name = bfd_get_section_name (output_bfd, hsec->output_section);
1243 r_symndx = (unsigned long) -1;
1247 if (strcmp (name, "*ABS*") == 0)
1248 r_symndx = RELOC_SECTION_ABS;
1251 if (strcmp (name, ".bss") == 0)
1252 r_symndx = RELOC_SECTION_BSS;
1255 if (strcmp (name, ".data") == 0)
1256 r_symndx = RELOC_SECTION_DATA;
1259 if (strcmp (name, ".fini") == 0)
1260 r_symndx = RELOC_SECTION_FINI;
1263 if (strcmp (name, ".init") == 0)
1264 r_symndx = RELOC_SECTION_INIT;
1267 if (strcmp (name, ".lita") == 0)
1268 r_symndx = RELOC_SECTION_LITA;
1269 else if (strcmp (name, ".lit8") == 0)
1270 r_symndx = RELOC_SECTION_LIT8;
1271 else if (strcmp (name, ".lit4") == 0)
1272 r_symndx = RELOC_SECTION_LIT4;
1275 if (strcmp (name, ".pdata") == 0)
1276 r_symndx = RELOC_SECTION_PDATA;
1279 if (strcmp (name, ".rdata") == 0)
1280 r_symndx = RELOC_SECTION_RDATA;
1281 else if (strcmp (name, ".rconst") == 0)
1282 r_symndx = RELOC_SECTION_RCONST;
1285 if (strcmp (name, ".sdata") == 0)
1286 r_symndx = RELOC_SECTION_SDATA;
1287 else if (strcmp (name, ".sbss") == 0)
1288 r_symndx = RELOC_SECTION_SBSS;
1291 if (strcmp (name, ".text") == 0)
1292 r_symndx = RELOC_SECTION_TEXT;
1295 if (strcmp (name, ".xdata") == 0)
1296 r_symndx = RELOC_SECTION_XDATA;
1300 if (r_symndx == (unsigned long) -1)
1303 /* Add the section VMA and the symbol value. */
1304 relocation = (h->root.u.def.value
1305 + hsec->output_section->vma
1306 + hsec->output_offset);
1310 /* Change the symndx value to the right one for
1313 if (r_symndx == (unsigned long) -1)
1315 /* Caller must give an error. */
1321 /* Write out the new r_symndx value. */
1322 H_PUT_32 (input_bfd, r_symndx, ext_rel->r_symndx);
1327 /* Relocate a section while linking an Alpha ECOFF file. This is
1328 quite similar to get_relocated_section_contents. Perhaps they
1329 could be combined somehow. */
1332 alpha_relocate_section (bfd *output_bfd,
1333 struct bfd_link_info *info,
1335 asection *input_section,
1337 void * external_relocs)
1339 asection **symndx_to_section, *lita_sec;
1340 struct ecoff_link_hash_entry **sym_hashes;
1342 bfd_boolean gp_undefined;
1343 bfd_vma stack[RELOC_STACKSIZE];
1345 struct external_reloc *ext_rel;
1346 struct external_reloc *ext_rel_end;
1349 /* We keep a table mapping the symndx found in an internal reloc to
1350 the appropriate section. This is faster than looking up the
1351 section by name each time. */
1352 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1353 if (symndx_to_section == (asection **) NULL)
1355 amt = NUM_RELOC_SECTIONS * sizeof (asection *);
1356 symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
1357 if (!symndx_to_section)
1360 symndx_to_section[RELOC_SECTION_NONE] = NULL;
1361 symndx_to_section[RELOC_SECTION_TEXT] =
1362 bfd_get_section_by_name (input_bfd, ".text");
1363 symndx_to_section[RELOC_SECTION_RDATA] =
1364 bfd_get_section_by_name (input_bfd, ".rdata");
1365 symndx_to_section[RELOC_SECTION_DATA] =
1366 bfd_get_section_by_name (input_bfd, ".data");
1367 symndx_to_section[RELOC_SECTION_SDATA] =
1368 bfd_get_section_by_name (input_bfd, ".sdata");
1369 symndx_to_section[RELOC_SECTION_SBSS] =
1370 bfd_get_section_by_name (input_bfd, ".sbss");
1371 symndx_to_section[RELOC_SECTION_BSS] =
1372 bfd_get_section_by_name (input_bfd, ".bss");
1373 symndx_to_section[RELOC_SECTION_INIT] =
1374 bfd_get_section_by_name (input_bfd, ".init");
1375 symndx_to_section[RELOC_SECTION_LIT8] =
1376 bfd_get_section_by_name (input_bfd, ".lit8");
1377 symndx_to_section[RELOC_SECTION_LIT4] =
1378 bfd_get_section_by_name (input_bfd, ".lit4");
1379 symndx_to_section[RELOC_SECTION_XDATA] =
1380 bfd_get_section_by_name (input_bfd, ".xdata");
1381 symndx_to_section[RELOC_SECTION_PDATA] =
1382 bfd_get_section_by_name (input_bfd, ".pdata");
1383 symndx_to_section[RELOC_SECTION_FINI] =
1384 bfd_get_section_by_name (input_bfd, ".fini");
1385 symndx_to_section[RELOC_SECTION_LITA] =
1386 bfd_get_section_by_name (input_bfd, ".lita");
1387 symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1388 symndx_to_section[RELOC_SECTION_RCONST] =
1389 bfd_get_section_by_name (input_bfd, ".rconst");
1391 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1394 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1396 /* On the Alpha, the .lita section must be addressable by the global
1397 pointer. To support large programs, we need to allow multiple
1398 global pointers. This works as long as each input .lita section
1399 is <64KB big. This implies that when producing relocatable
1400 output, the .lita section is limited to 64KB. . */
1402 lita_sec = symndx_to_section[RELOC_SECTION_LITA];
1403 gp = _bfd_get_gp_value (output_bfd);
1404 if (! bfd_link_relocatable (info) && lita_sec != NULL)
1406 struct ecoff_section_tdata *lita_sec_data;
1408 /* Make sure we have a section data structure to which we can
1409 hang on to the gp value we pick for the section. */
1410 lita_sec_data = ecoff_section_data (input_bfd, lita_sec);
1411 if (lita_sec_data == NULL)
1413 amt = sizeof (struct ecoff_section_tdata);
1414 lita_sec_data = ((struct ecoff_section_tdata *)
1415 bfd_zalloc (input_bfd, amt));
1416 lita_sec->used_by_bfd = lita_sec_data;
1419 if (lita_sec_data->gp != 0)
1421 /* If we already assigned a gp to this section, we better
1422 stick with that value. */
1423 gp = lita_sec_data->gp;
1428 bfd_size_type lita_size;
1430 lita_vma = lita_sec->output_offset + lita_sec->output_section->vma;
1431 lita_size = lita_sec->size;
1434 || lita_vma < gp - 0x8000
1435 || lita_vma + lita_size >= gp + 0x8000)
1437 /* Either gp hasn't been set at all or the current gp
1438 cannot address this .lita section. In both cases we
1439 reset the gp to point into the "middle" of the
1440 current input .lita section. */
1441 if (gp && !ecoff_data (output_bfd)->issued_multiple_gp_warning)
1443 (*info->callbacks->warning) (info,
1444 _("using multiple gp values"),
1445 (char *) NULL, output_bfd,
1446 (asection *) NULL, (bfd_vma) 0);
1447 ecoff_data (output_bfd)->issued_multiple_gp_warning = TRUE;
1449 if (lita_vma < gp - 0x8000)
1450 gp = lita_vma + lita_size - 0x8000;
1452 gp = lita_vma + 0x8000;
1456 lita_sec_data->gp = gp;
1459 _bfd_set_gp_value (output_bfd, gp);
1462 gp_undefined = (gp == 0);
1464 BFD_ASSERT (bfd_header_little_endian (output_bfd));
1465 BFD_ASSERT (bfd_header_little_endian (input_bfd));
1467 ext_rel = (struct external_reloc *) external_relocs;
1468 ext_rel_end = ext_rel + input_section->reloc_count;
1469 for (; ext_rel < ext_rel_end; ext_rel++)
1472 unsigned long r_symndx;
1477 bfd_boolean relocatep;
1478 bfd_boolean adjust_addrp;
1479 bfd_boolean gp_usedp;
1482 r_vaddr = H_GET_64 (input_bfd, ext_rel->r_vaddr);
1483 r_symndx = H_GET_32 (input_bfd, ext_rel->r_symndx);
1485 r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1486 >> RELOC_BITS0_TYPE_SH_LITTLE);
1487 r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1488 r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1489 >> RELOC_BITS1_OFFSET_SH_LITTLE);
1490 /* Ignored the reserved bits. */
1491 r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1492 >> RELOC_BITS3_SIZE_SH_LITTLE);
1495 adjust_addrp = TRUE;
1501 case ALPHA_R_GPRELHIGH:
1503 (_("%pB: unsupported relocation: ALPHA_R_GPRELHIGH"),
1505 bfd_set_error (bfd_error_bad_value);
1508 case ALPHA_R_GPRELLOW:
1510 (_("%pB: unsupported relocation: ALPHA_R_GPRELLOW"),
1512 bfd_set_error (bfd_error_bad_value);
1517 /* xgettext:c-format */
1518 (_("%pB: unknown relocation type %d"),
1519 input_bfd, (int) r_type);
1520 bfd_set_error (bfd_error_bad_value);
1523 case ALPHA_R_IGNORE:
1524 /* This reloc appears after a GPDISP reloc. On earlier
1525 versions of OSF/1, It marked the position of the second
1526 instruction to be altered by the GPDISP reloc, but it is
1527 not otherwise used for anything. For some reason, the
1528 address of the relocation does not appear to include the
1529 section VMA, unlike the other relocation types. */
1530 if (bfd_link_relocatable (info))
1531 H_PUT_64 (input_bfd, input_section->output_offset + r_vaddr,
1533 adjust_addrp = FALSE;
1536 case ALPHA_R_REFLONG:
1537 case ALPHA_R_REFQUAD:
1542 case ALPHA_R_BRADDR:
1543 case ALPHA_R_SREL16:
1544 case ALPHA_R_SREL32:
1545 case ALPHA_R_SREL64:
1547 addend += - (r_vaddr + 4);
1551 case ALPHA_R_GPREL32:
1552 /* This relocation is used in a switch table. It is a 32
1553 bit offset from the current GP value. We must adjust it
1554 by the different between the original GP value and the
1555 current GP value. */
1557 addend = ecoff_data (input_bfd)->gp - gp;
1561 case ALPHA_R_LITERAL:
1562 /* This is a reference to a literal value, generally
1563 (always?) in the .lita section. This is a 16 bit GP
1564 relative relocation. Sometimes the subsequent reloc is a
1565 LITUSE reloc, which indicates how this reloc is used.
1566 This sometimes permits rewriting the two instructions
1567 referred to by the LITERAL and the LITUSE into different
1568 instructions which do not refer to .lita. This can save
1569 a memory reference, and permits removing a value from
1570 .lita thus saving GP relative space.
1572 We do not these optimizations. To do them we would need
1573 to arrange to link the .lita section first, so that by
1574 the time we got here we would know the final values to
1575 use. This would not be particularly difficult, but it is
1576 not currently implemented. */
1578 /* I believe that the LITERAL reloc will only apply to a ldq
1579 or ldl instruction, so check my assumption. */
1583 insn = bfd_get_32 (input_bfd,
1584 contents + r_vaddr - input_section->vma);
1585 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1586 || ((insn >> 26) & 0x3f) == 0x28);
1590 addend = ecoff_data (input_bfd)->gp - gp;
1594 case ALPHA_R_LITUSE:
1595 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
1596 does not cause anything to happen, itself. */
1599 case ALPHA_R_GPDISP:
1600 /* This marks the ldah of an ldah/lda pair which loads the
1601 gp register with the difference of the gp value and the
1602 current location. The second of the pair is r_symndx
1603 bytes ahead. It used to be marked with an ALPHA_R_IGNORE
1604 reloc, but OSF/1 3.2 no longer does that. */
1606 unsigned long insn1, insn2;
1608 /* Get the two instructions. */
1609 insn1 = bfd_get_32 (input_bfd,
1610 contents + r_vaddr - input_section->vma);
1611 insn2 = bfd_get_32 (input_bfd,
1614 - input_section->vma
1617 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1618 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1620 /* Get the existing addend. We must account for the sign
1621 extension done by lda and ldah. */
1622 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1625 /* This is addend -= 0x100000000 without causing an
1626 integer overflow on a 32 bit host. */
1627 addend -= 0x80000000;
1628 addend -= 0x80000000;
1633 /* The existing addend includes the difference between the
1634 gp of the input BFD and the address in the input BFD.
1635 We want to change this to the difference between the
1636 final GP and the final address. */
1638 - ecoff_data (input_bfd)->gp
1639 + input_section->vma
1640 - (input_section->output_section->vma
1641 + input_section->output_offset));
1643 /* Change the instructions, accounting for the sign
1644 extension, and write them out. */
1645 if (addend & 0x8000)
1647 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1648 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1650 bfd_put_32 (input_bfd, (bfd_vma) insn1,
1651 contents + r_vaddr - input_section->vma);
1652 bfd_put_32 (input_bfd, (bfd_vma) insn2,
1653 contents + r_vaddr - input_section->vma + r_symndx);
1659 case ALPHA_R_OP_PUSH:
1660 case ALPHA_R_OP_PSUB:
1661 case ALPHA_R_OP_PRSHIFT:
1662 /* Manipulate values on the reloc evaluation stack. The
1663 r_vaddr field is not an address in input_section, it is
1664 the current value (including any addend) of the object
1670 s = symndx_to_section[r_symndx];
1671 if (s == (asection *) NULL)
1673 addend = s->output_section->vma + s->output_offset - s->vma;
1677 struct ecoff_link_hash_entry *h;
1679 h = sym_hashes[r_symndx];
1680 if (h == (struct ecoff_link_hash_entry *) NULL)
1683 if (! bfd_link_relocatable (info))
1685 if (h->root.type == bfd_link_hash_defined
1686 || h->root.type == bfd_link_hash_defweak)
1687 addend = (h->root.u.def.value
1688 + h->root.u.def.section->output_section->vma
1689 + h->root.u.def.section->output_offset);
1692 /* Note that we pass the address as 0, since we
1693 do not have a meaningful number for the
1694 location within the section that is being
1696 (*info->callbacks->undefined_symbol)
1697 (info, h->root.root.string, input_bfd,
1698 input_section, (bfd_vma) 0, TRUE);
1704 if (h->root.type != bfd_link_hash_defined
1705 && h->root.type != bfd_link_hash_defweak
1708 /* This symbol is not being written out. Pass
1709 the address as 0, as with undefined_symbol,
1711 (*info->callbacks->unattached_reloc)
1712 (info, h->root.root.string,
1713 input_bfd, input_section, (bfd_vma) 0);
1716 addend = alpha_convert_external_reloc (output_bfd, info,
1724 if (bfd_link_relocatable (info))
1726 /* Adjust r_vaddr by the addend. */
1727 H_PUT_64 (input_bfd, addend, ext_rel->r_vaddr);
1733 case ALPHA_R_OP_PUSH:
1734 if (tos >= RELOC_STACKSIZE)
1736 stack[tos++] = addend;
1739 case ALPHA_R_OP_PSUB:
1742 stack[tos - 1] -= addend;
1745 case ALPHA_R_OP_PRSHIFT:
1748 stack[tos - 1] >>= addend;
1753 adjust_addrp = FALSE;
1756 case ALPHA_R_OP_STORE:
1757 /* Store a value from the reloc stack into a bitfield. If
1758 we are generating relocatable output, all we do is
1759 adjust the address of the reloc. */
1760 if (! bfd_link_relocatable (info))
1768 /* Get the relocation mask. The separate steps and the
1769 casts to bfd_vma are attempts to avoid a bug in the
1770 Alpha OSF 1.3 C compiler. See reloc.c for more
1773 mask <<= (bfd_vma) r_size;
1776 /* FIXME: I don't know what kind of overflow checking,
1777 if any, should be done here. */
1778 val = bfd_get_64 (input_bfd,
1779 contents + r_vaddr - input_section->vma);
1780 val &=~ mask << (bfd_vma) r_offset;
1781 val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1782 bfd_put_64 (input_bfd, val,
1783 contents + r_vaddr - input_section->vma);
1787 case ALPHA_R_GPVALUE:
1788 /* I really don't know if this does the right thing. */
1789 gp = ecoff_data (input_bfd)->gp + r_symndx;
1790 gp_undefined = FALSE;
1796 reloc_howto_type *howto;
1797 struct ecoff_link_hash_entry *h = NULL;
1800 bfd_reloc_status_type r;
1802 /* Perform a relocation. */
1804 howto = &alpha_howto_table[r_type];
1808 h = sym_hashes[r_symndx];
1809 /* If h is NULL, that means that there is a reloc
1810 against an external symbol which we thought was just
1811 a debugging symbol. This should not happen. */
1812 if (h == (struct ecoff_link_hash_entry *) NULL)
1817 if (r_symndx >= NUM_RELOC_SECTIONS)
1820 s = symndx_to_section[r_symndx];
1822 if (s == (asection *) NULL)
1826 if (bfd_link_relocatable (info))
1828 /* We are generating relocatable output, and must
1829 convert the existing reloc. */
1832 if (h->root.type != bfd_link_hash_defined
1833 && h->root.type != bfd_link_hash_defweak
1836 /* This symbol is not being written out. */
1837 (*info->callbacks->unattached_reloc)
1838 (info, h->root.root.string, input_bfd,
1839 input_section, r_vaddr - input_section->vma);
1842 relocation = alpha_convert_external_reloc (output_bfd,
1850 /* This is a relocation against a section. Adjust
1851 the value by the amount the section moved. */
1852 relocation = (s->output_section->vma
1857 /* If this is PC relative, the existing object file
1858 appears to already have the reloc worked out. We
1859 must subtract out the old value and add in the new
1861 if (howto->pc_relative)
1862 relocation -= (input_section->output_section->vma
1863 + input_section->output_offset
1864 - input_section->vma);
1866 /* Put in any addend. */
1867 relocation += addend;
1869 /* Adjust the contents. */
1870 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1873 - input_section->vma));
1877 /* We are producing a final executable. */
1880 /* This is a reloc against a symbol. */
1881 if (h->root.type == bfd_link_hash_defined
1882 || h->root.type == bfd_link_hash_defweak)
1886 hsec = h->root.u.def.section;
1887 relocation = (h->root.u.def.value
1888 + hsec->output_section->vma
1889 + hsec->output_offset);
1893 (*info->callbacks->undefined_symbol)
1894 (info, h->root.root.string, input_bfd, input_section,
1895 r_vaddr - input_section->vma, TRUE);
1901 /* This is a reloc against a section. */
1902 relocation = (s->output_section->vma
1906 /* Adjust a PC relative relocation by removing the
1907 reference to the original source section. */
1908 if (howto->pc_relative)
1909 relocation += input_section->vma;
1912 r = _bfd_final_link_relocate (howto,
1916 r_vaddr - input_section->vma,
1921 if (r != bfd_reloc_ok)
1926 case bfd_reloc_outofrange:
1928 case bfd_reloc_overflow:
1933 name = sym_hashes[r_symndx]->root.root.string;
1935 name = bfd_section_name (input_bfd,
1936 symndx_to_section[r_symndx]);
1937 (*info->callbacks->reloc_overflow)
1938 (info, NULL, name, alpha_howto_table[r_type].name,
1939 (bfd_vma) 0, input_bfd, input_section,
1940 r_vaddr - input_section->vma);
1947 if (bfd_link_relocatable (info) && adjust_addrp)
1949 /* Change the address of the relocation. */
1950 H_PUT_64 (input_bfd,
1951 (input_section->output_section->vma
1952 + input_section->output_offset
1953 - input_section->vma
1958 if (gp_usedp && gp_undefined)
1960 (*info->callbacks->reloc_dangerous)
1961 (info, _("GP relative relocation used when GP not defined"),
1962 input_bfd, input_section, r_vaddr - input_section->vma);
1963 /* Only give the error once per link. */
1965 _bfd_set_gp_value (output_bfd, gp);
1966 gp_undefined = FALSE;
1976 /* Do final adjustments to the filehdr and the aouthdr. This routine
1977 sets the dynamic bits in the file header. */
1980 alpha_adjust_headers (bfd *abfd,
1981 struct internal_filehdr *fhdr,
1982 struct internal_aouthdr *ahdr ATTRIBUTE_UNUSED)
1984 if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
1985 fhdr->f_flags |= F_ALPHA_CALL_SHARED;
1986 else if ((abfd->flags & DYNAMIC) != 0)
1987 fhdr->f_flags |= F_ALPHA_SHARABLE;
1991 /* Archive handling. In OSF/1 (or Digital Unix) v3.2, Digital
1992 introduced archive packing, in which the elements in an archive are
1993 optionally compressed using a simple dictionary scheme. We know
1994 how to read such archives, but we don't write them. */
1996 #define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap
1997 #define alpha_ecoff_slurp_extended_name_table \
1998 _bfd_ecoff_slurp_extended_name_table
1999 #define alpha_ecoff_construct_extended_name_table \
2000 _bfd_ecoff_construct_extended_name_table
2001 #define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname
2002 #define alpha_ecoff_write_armap _bfd_ecoff_write_armap
2003 #define alpha_ecoff_write_ar_hdr _bfd_generic_write_ar_hdr
2004 #define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt
2005 #define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp
2007 /* A compressed file uses this instead of ARFMAG. */
2009 #define ARFZMAG "Z\012"
2011 /* Read an archive header. This is like the standard routine, but it
2012 also accepts ARFZMAG. */
2015 alpha_ecoff_read_ar_hdr (bfd *abfd)
2017 struct areltdata *ret;
2020 ret = (struct areltdata *) _bfd_generic_read_ar_hdr_mag (abfd, ARFZMAG);
2024 h = (struct ar_hdr *) ret->arch_header;
2025 if (strncmp (h->ar_fmag, ARFZMAG, 2) == 0)
2029 /* This is a compressed file. We must set the size correctly.
2030 The size is the eight bytes after the dummy file header. */
2031 if (bfd_seek (abfd, (file_ptr) FILHSZ, SEEK_CUR) != 0
2032 || bfd_bread (ab, (bfd_size_type) 8, abfd) != 8
2033 || bfd_seek (abfd, (file_ptr) (- (FILHSZ + 8)), SEEK_CUR) != 0)
2036 ret->parsed_size = H_GET_64 (abfd, ab);
2042 /* Get an archive element at a specified file position. This is where
2043 we uncompress the archive element if necessary. */
2046 alpha_ecoff_get_elt_at_filepos (bfd *archive, file_ptr filepos)
2049 struct areltdata *tdata;
2054 struct bfd_in_memory *bim;
2057 nbfd = _bfd_get_elt_at_filepos (archive, filepos);
2061 if ((nbfd->flags & BFD_IN_MEMORY) != 0)
2063 /* We have already expanded this BFD. */
2067 tdata = (struct areltdata *) nbfd->arelt_data;
2068 hdr = (struct ar_hdr *) tdata->arch_header;
2069 if (strncmp (hdr->ar_fmag, ARFZMAG, 2) != 0)
2072 /* We must uncompress this element. We do this by copying it into a
2073 memory buffer, and making bfd_bread and bfd_seek use that buffer.
2074 This can use a lot of memory, but it's simpler than getting a
2075 temporary file, making that work with the file descriptor caching
2076 code, and making sure that it is deleted at all appropriate
2077 times. It can be changed if it ever becomes important. */
2079 /* The compressed file starts with a dummy ECOFF file header. */
2080 if (bfd_seek (nbfd, (file_ptr) FILHSZ, SEEK_SET) != 0)
2083 /* The next eight bytes are the real file size. */
2084 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2086 size = H_GET_64 (nbfd, ab);
2091 bfd_byte dict[4096];
2095 buf = (bfd_byte *) bfd_malloc (size);
2102 /* I don't know what the next eight bytes are for. */
2103 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2106 /* This is the uncompression algorithm. It's a simple
2107 dictionary based scheme in which each character is predicted
2108 by a hash of the previous three characters. A control byte
2109 indicates whether the character is predicted or whether it
2110 appears in the input stream; each control byte manages the
2111 next eight bytes in the output stream. */
2112 memset (dict, 0, sizeof dict);
2114 while (bfd_bread (&b, (bfd_size_type) 1, nbfd) == 1)
2118 for (i = 0; i < 8; i++, b >>= 1)
2126 if (! bfd_bread (&n, (bfd_size_type) 1, nbfd))
2139 h &= sizeof dict - 1;
2147 /* Now the uncompressed file contents are in buf. */
2148 bim = ((struct bfd_in_memory *)
2149 bfd_malloc ((bfd_size_type) sizeof (struct bfd_in_memory)));
2155 nbfd->mtime_set = TRUE;
2156 nbfd->mtime = strtol (hdr->ar_date, (char **) NULL, 10);
2158 nbfd->flags |= BFD_IN_MEMORY;
2159 nbfd->iostream = bim;
2160 nbfd->iovec = &_bfd_memory_iovec;
2162 BFD_ASSERT (! nbfd->cacheable);
2174 /* Open the next archived file. */
2177 alpha_ecoff_openr_next_archived_file (bfd *archive, bfd *last_file)
2179 ufile_ptr filestart;
2181 if (last_file == NULL)
2182 filestart = bfd_ardata (archive)->first_file_filepos;
2185 struct areltdata *t;
2189 /* We can't use arelt_size here, because that uses parsed_size,
2190 which is the uncompressed size. We need the compressed size. */
2191 t = (struct areltdata *) last_file->arelt_data;
2192 h = (struct ar_hdr *) t->arch_header;
2193 size = strtol (h->ar_size, (char **) NULL, 10);
2195 /* Pad to an even boundary...
2196 Note that last_file->origin can be odd in the case of
2197 BSD-4.4-style element with a long odd size. */
2198 filestart = last_file->proxy_origin + size;
2199 filestart += filestart % 2;
2200 if (filestart < last_file->proxy_origin)
2202 /* Prevent looping. See PR19256. */
2203 bfd_set_error (bfd_error_malformed_archive);
2208 return alpha_ecoff_get_elt_at_filepos (archive, filestart);
2211 /* Open the archive file given an index into the armap. */
2214 alpha_ecoff_get_elt_at_index (bfd *abfd, symindex sym_index)
2218 entry = bfd_ardata (abfd)->symdefs + sym_index;
2219 return alpha_ecoff_get_elt_at_filepos (abfd, entry->file_offset);
2223 alpha_ecoff_swap_coff_aux_in (bfd *abfd ATTRIBUTE_UNUSED,
2224 void *ext1 ATTRIBUTE_UNUSED,
2225 int type ATTRIBUTE_UNUSED,
2226 int in_class ATTRIBUTE_UNUSED,
2227 int indx ATTRIBUTE_UNUSED,
2228 int numaux ATTRIBUTE_UNUSED,
2229 void *in1 ATTRIBUTE_UNUSED)
2234 alpha_ecoff_swap_coff_sym_in (bfd *abfd ATTRIBUTE_UNUSED,
2235 void *ext1 ATTRIBUTE_UNUSED,
2236 void *in1 ATTRIBUTE_UNUSED)
2241 alpha_ecoff_swap_coff_lineno_in (bfd *abfd ATTRIBUTE_UNUSED,
2242 void *ext1 ATTRIBUTE_UNUSED,
2243 void *in1 ATTRIBUTE_UNUSED)
2248 alpha_ecoff_swap_coff_aux_out (bfd *abfd ATTRIBUTE_UNUSED,
2249 void *inp ATTRIBUTE_UNUSED,
2250 int type ATTRIBUTE_UNUSED,
2251 int in_class ATTRIBUTE_UNUSED,
2252 int indx ATTRIBUTE_UNUSED,
2253 int numaux ATTRIBUTE_UNUSED,
2254 void *extp ATTRIBUTE_UNUSED)
2260 alpha_ecoff_swap_coff_sym_out (bfd *abfd ATTRIBUTE_UNUSED,
2261 void *inp ATTRIBUTE_UNUSED,
2262 void *extp ATTRIBUTE_UNUSED)
2268 alpha_ecoff_swap_coff_lineno_out (bfd *abfd ATTRIBUTE_UNUSED,
2269 void *inp ATTRIBUTE_UNUSED,
2270 void *extp ATTRIBUTE_UNUSED)
2276 alpha_ecoff_swap_coff_reloc_out (bfd *abfd ATTRIBUTE_UNUSED,
2277 void *inp ATTRIBUTE_UNUSED,
2278 void *extp ATTRIBUTE_UNUSED)
2283 /* This is the ECOFF backend structure. The backend field of the
2284 target vector points to this. */
2286 static const struct ecoff_backend_data alpha_ecoff_backend_data =
2288 /* COFF backend structure. */
2290 alpha_ecoff_swap_coff_aux_in, alpha_ecoff_swap_coff_sym_in,
2291 alpha_ecoff_swap_coff_lineno_in, alpha_ecoff_swap_coff_aux_out,
2292 alpha_ecoff_swap_coff_sym_out, alpha_ecoff_swap_coff_lineno_out,
2293 alpha_ecoff_swap_coff_reloc_out,
2294 alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
2295 alpha_ecoff_swap_scnhdr_out,
2296 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE,
2297 ECOFF_NO_LONG_SECTION_NAMES, 4, FALSE, 2, 32768,
2298 alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
2299 alpha_ecoff_swap_scnhdr_in, NULL,
2300 alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2301 alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2302 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2303 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2304 NULL, NULL, NULL, NULL
2306 /* Supported architecture. */
2308 /* Initial portion of armap string. */
2310 /* The page boundary used to align sections in a demand-paged
2311 executable file. E.g., 0x1000. */
2313 /* TRUE if the .rdata section is part of the text segment, as on the
2314 Alpha. FALSE if .rdata is part of the data segment, as on the
2317 /* Bitsize of constructor entries. */
2319 /* Reloc to use for constructor entries. */
2320 &alpha_howto_table[ALPHA_R_REFQUAD],
2322 /* Symbol table magic number. */
2324 /* Alignment of debugging information. E.g., 4. */
2326 /* Sizes of external symbolic information. */
2327 sizeof (struct hdr_ext),
2328 sizeof (struct dnr_ext),
2329 sizeof (struct pdr_ext),
2330 sizeof (struct sym_ext),
2331 sizeof (struct opt_ext),
2332 sizeof (struct fdr_ext),
2333 sizeof (struct rfd_ext),
2334 sizeof (struct ext_ext),
2335 /* Functions to swap in external symbolic data. */
2344 _bfd_ecoff_swap_tir_in,
2345 _bfd_ecoff_swap_rndx_in,
2346 /* Functions to swap out external symbolic data. */
2355 _bfd_ecoff_swap_tir_out,
2356 _bfd_ecoff_swap_rndx_out,
2357 /* Function to read in symbolic data. */
2358 _bfd_ecoff_slurp_symbolic_info
2360 /* External reloc size. */
2362 /* Reloc swapping functions. */
2363 alpha_ecoff_swap_reloc_in,
2364 alpha_ecoff_swap_reloc_out,
2365 /* Backend reloc tweaking. */
2366 alpha_adjust_reloc_in,
2367 alpha_adjust_reloc_out,
2368 /* Relocate section contents while linking. */
2369 alpha_relocate_section,
2370 /* Do final adjustments to filehdr and aouthdr. */
2371 alpha_adjust_headers,
2372 /* Read an element from an archive at a given file position. */
2373 alpha_ecoff_get_elt_at_filepos
2376 /* Looking up a reloc type is Alpha specific. */
2377 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2378 #define _bfd_ecoff_bfd_reloc_name_lookup \
2379 alpha_bfd_reloc_name_lookup
2381 /* So is getting relocated section contents. */
2382 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2383 alpha_ecoff_get_relocated_section_contents
2385 /* Handling file windows is generic. */
2386 #define _bfd_ecoff_get_section_contents_in_window \
2387 _bfd_generic_get_section_contents_in_window
2389 /* Input section flag lookup is generic. */
2390 #define _bfd_ecoff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
2392 /* Relaxing sections is generic. */
2393 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2394 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2395 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
2396 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
2397 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
2398 #define _bfd_ecoff_section_already_linked \
2399 _bfd_coff_section_already_linked
2400 #define _bfd_ecoff_bfd_define_common_symbol bfd_generic_define_common_symbol
2401 #define _bfd_ecoff_bfd_define_start_stop bfd_generic_define_start_stop
2402 #define _bfd_ecoff_bfd_link_check_relocs _bfd_generic_link_check_relocs
2404 /* Installing internal relocations in a section is also generic. */
2405 #define _bfd_ecoff_set_reloc _bfd_generic_set_reloc
2407 const bfd_target alpha_ecoff_le_vec =
2409 "ecoff-littlealpha", /* name */
2410 bfd_target_ecoff_flavour,
2411 BFD_ENDIAN_LITTLE, /* data byte order is little */
2412 BFD_ENDIAN_LITTLE, /* header byte order is little */
2414 (HAS_RELOC | EXEC_P /* object flags */
2415 | HAS_LINENO | HAS_DEBUG
2416 | HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2418 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2419 0, /* leading underscore */
2420 ' ', /* ar_pad_char */
2421 15, /* ar_max_namelen */
2422 0, /* match priority. */
2423 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2424 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2425 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2426 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2427 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2428 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2430 { /* bfd_check_format */
2432 alpha_ecoff_object_p,
2433 bfd_generic_archive_p,
2436 { /* bfd_set_format */
2437 _bfd_bool_bfd_false_error,
2438 _bfd_ecoff_mkobject,
2439 _bfd_generic_mkarchive,
2440 _bfd_bool_bfd_false_error
2442 { /* bfd_write_contents */
2443 _bfd_bool_bfd_false_error,
2444 _bfd_ecoff_write_object_contents,
2445 _bfd_write_archive_contents,
2446 _bfd_bool_bfd_false_error
2449 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2450 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2451 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2452 BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff),
2453 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2454 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2455 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2456 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2457 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2461 &alpha_ecoff_backend_data