1 /* BFD back-end for ALPHA Extended-Coff files.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005 Free Software Foundation, Inc.
4 Modified from coff-mips.c by Steve Chamberlain <sac@cygnus.com> and
5 Ian Lance Taylor <ian@cygnus.com>.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 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. */
38 static const bfd_target *alpha_ecoff_object_p
40 static bfd_boolean alpha_ecoff_bad_format_hook
41 PARAMS ((bfd *abfd, PTR filehdr));
42 static PTR alpha_ecoff_mkobject_hook
43 PARAMS ((bfd *, PTR filehdr, PTR aouthdr));
44 static void alpha_ecoff_swap_reloc_in
45 PARAMS ((bfd *, PTR, struct internal_reloc *));
46 static void alpha_ecoff_swap_reloc_out
47 PARAMS ((bfd *, const struct internal_reloc *, PTR));
48 static void alpha_adjust_reloc_in
49 PARAMS ((bfd *, const struct internal_reloc *, arelent *));
50 static void alpha_adjust_reloc_out
51 PARAMS ((bfd *, const arelent *, struct internal_reloc *));
52 static reloc_howto_type *alpha_bfd_reloc_type_lookup
53 PARAMS ((bfd *, bfd_reloc_code_real_type));
54 static bfd_byte *alpha_ecoff_get_relocated_section_contents
55 PARAMS ((bfd *abfd, struct bfd_link_info *, struct bfd_link_order *,
56 bfd_byte *data, bfd_boolean relocatable, asymbol **symbols));
57 static bfd_vma alpha_convert_external_reloc
58 PARAMS ((bfd *, struct bfd_link_info *, bfd *, struct external_reloc *,
59 struct ecoff_link_hash_entry *));
60 static bfd_boolean alpha_relocate_section
61 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, PTR));
62 static bfd_boolean alpha_adjust_headers
63 PARAMS ((bfd *, struct internal_filehdr *, struct internal_aouthdr *));
64 static PTR alpha_ecoff_read_ar_hdr
66 static bfd *alpha_ecoff_get_elt_at_filepos
67 PARAMS ((bfd *, file_ptr));
68 static bfd *alpha_ecoff_openr_next_archived_file
69 PARAMS ((bfd *, bfd *));
70 static bfd *alpha_ecoff_get_elt_at_index
71 PARAMS ((bfd *, symindex));
73 /* ECOFF has COFF sections, but the debugging information is stored in
74 a completely different format. ECOFF targets use some of the
75 swapping routines from coffswap.h, and some of the generic COFF
76 routines in coffgen.c, but, unlike the real COFF targets, do not
77 use coffcode.h itself.
79 Get the generic COFF swapping routines, except for the reloc,
80 symbol, and lineno ones. Give them ecoff names. Define some
81 accessor macros for the large sizes used for Alpha ECOFF. */
83 #define GET_FILEHDR_SYMPTR H_GET_64
84 #define PUT_FILEHDR_SYMPTR H_PUT_64
85 #define GET_AOUTHDR_TSIZE H_GET_64
86 #define PUT_AOUTHDR_TSIZE H_PUT_64
87 #define GET_AOUTHDR_DSIZE H_GET_64
88 #define PUT_AOUTHDR_DSIZE H_PUT_64
89 #define GET_AOUTHDR_BSIZE H_GET_64
90 #define PUT_AOUTHDR_BSIZE H_PUT_64
91 #define GET_AOUTHDR_ENTRY H_GET_64
92 #define PUT_AOUTHDR_ENTRY H_PUT_64
93 #define GET_AOUTHDR_TEXT_START H_GET_64
94 #define PUT_AOUTHDR_TEXT_START H_PUT_64
95 #define GET_AOUTHDR_DATA_START H_GET_64
96 #define PUT_AOUTHDR_DATA_START H_PUT_64
97 #define GET_SCNHDR_PADDR H_GET_64
98 #define PUT_SCNHDR_PADDR H_PUT_64
99 #define GET_SCNHDR_VADDR H_GET_64
100 #define PUT_SCNHDR_VADDR H_PUT_64
101 #define GET_SCNHDR_SIZE H_GET_64
102 #define PUT_SCNHDR_SIZE H_PUT_64
103 #define GET_SCNHDR_SCNPTR H_GET_64
104 #define PUT_SCNHDR_SCNPTR H_PUT_64
105 #define GET_SCNHDR_RELPTR H_GET_64
106 #define PUT_SCNHDR_RELPTR H_PUT_64
107 #define GET_SCNHDR_LNNOPTR H_GET_64
108 #define PUT_SCNHDR_LNNOPTR H_PUT_64
112 #define NO_COFF_RELOCS
113 #define NO_COFF_SYMBOLS
114 #define NO_COFF_LINENOS
115 #define coff_swap_filehdr_in alpha_ecoff_swap_filehdr_in
116 #define coff_swap_filehdr_out alpha_ecoff_swap_filehdr_out
117 #define coff_swap_aouthdr_in alpha_ecoff_swap_aouthdr_in
118 #define coff_swap_aouthdr_out alpha_ecoff_swap_aouthdr_out
119 #define coff_swap_scnhdr_in alpha_ecoff_swap_scnhdr_in
120 #define coff_swap_scnhdr_out alpha_ecoff_swap_scnhdr_out
121 #include "coffswap.h"
123 /* Get the ECOFF swapping routines. */
125 #include "ecoffswap.h"
127 /* How to process the various reloc types. */
129 static bfd_reloc_status_type reloc_nil
130 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
132 static bfd_reloc_status_type
133 reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
134 bfd *abfd ATTRIBUTE_UNUSED;
135 arelent *reloc ATTRIBUTE_UNUSED;
136 asymbol *sym ATTRIBUTE_UNUSED;
137 PTR data ATTRIBUTE_UNUSED;
138 asection *sec ATTRIBUTE_UNUSED;
139 bfd *output_bfd ATTRIBUTE_UNUSED;
140 char **error_message ATTRIBUTE_UNUSED;
145 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
146 from smaller values. Start with zero, widen, *then* decrement. */
147 #define MINUS_ONE (((bfd_vma)0) - 1)
149 static reloc_howto_type alpha_howto_table[] =
151 /* Reloc type 0 is ignored by itself. However, it appears after a
152 GPDISP reloc to identify the location where the low order 16 bits
153 of the gp register are loaded. */
154 HOWTO (ALPHA_R_IGNORE, /* type */
156 0, /* size (0 = byte, 1 = short, 2 = long) */
158 TRUE, /* pc_relative */
160 complain_overflow_dont, /* complain_on_overflow */
161 reloc_nil, /* special_function */
163 TRUE, /* partial_inplace */
166 TRUE), /* pcrel_offset */
168 /* A 32 bit reference to a symbol. */
169 HOWTO (ALPHA_R_REFLONG, /* type */
171 2, /* size (0 = byte, 1 = short, 2 = long) */
173 FALSE, /* pc_relative */
175 complain_overflow_bitfield, /* complain_on_overflow */
176 0, /* special_function */
177 "REFLONG", /* name */
178 TRUE, /* partial_inplace */
179 0xffffffff, /* src_mask */
180 0xffffffff, /* dst_mask */
181 FALSE), /* pcrel_offset */
183 /* A 64 bit reference to a symbol. */
184 HOWTO (ALPHA_R_REFQUAD, /* type */
186 4, /* size (0 = byte, 1 = short, 2 = long) */
188 FALSE, /* pc_relative */
190 complain_overflow_bitfield, /* complain_on_overflow */
191 0, /* special_function */
192 "REFQUAD", /* name */
193 TRUE, /* partial_inplace */
194 MINUS_ONE, /* src_mask */
195 MINUS_ONE, /* dst_mask */
196 FALSE), /* pcrel_offset */
198 /* A 32 bit GP relative offset. This is just like REFLONG except
199 that when the value is used the value of the gp register will be
201 HOWTO (ALPHA_R_GPREL32, /* type */
203 2, /* size (0 = byte, 1 = short, 2 = long) */
205 FALSE, /* pc_relative */
207 complain_overflow_bitfield, /* complain_on_overflow */
208 0, /* special_function */
209 "GPREL32", /* name */
210 TRUE, /* partial_inplace */
211 0xffffffff, /* src_mask */
212 0xffffffff, /* dst_mask */
213 FALSE), /* pcrel_offset */
215 /* Used for an instruction that refers to memory off the GP
216 register. The offset is 16 bits of the 32 bit instruction. This
217 reloc always seems to be against the .lita section. */
218 HOWTO (ALPHA_R_LITERAL, /* type */
220 2, /* size (0 = byte, 1 = short, 2 = long) */
222 FALSE, /* pc_relative */
224 complain_overflow_signed, /* complain_on_overflow */
225 0, /* special_function */
226 "LITERAL", /* name */
227 TRUE, /* partial_inplace */
228 0xffff, /* src_mask */
229 0xffff, /* dst_mask */
230 FALSE), /* pcrel_offset */
232 /* This reloc only appears immediately following a LITERAL reloc.
233 It identifies a use of the literal. It seems that the linker can
234 use this to eliminate a portion of the .lita section. The symbol
235 index is special: 1 means the literal address is in the base
236 register of a memory format instruction; 2 means the literal
237 address is in the byte offset register of a byte-manipulation
238 instruction; 3 means the literal address is in the target
239 register of a jsr instruction. This does not actually do any
241 HOWTO (ALPHA_R_LITUSE, /* type */
243 2, /* size (0 = byte, 1 = short, 2 = long) */
245 FALSE, /* pc_relative */
247 complain_overflow_dont, /* complain_on_overflow */
248 reloc_nil, /* special_function */
250 FALSE, /* partial_inplace */
253 FALSE), /* pcrel_offset */
255 /* Load the gp register. This is always used for a ldah instruction
256 which loads the upper 16 bits of the gp register. The next reloc
257 will be an IGNORE reloc which identifies the location of the lda
258 instruction which loads the lower 16 bits. The symbol index of
259 the GPDISP instruction appears to actually be the number of bytes
260 between the ldah and lda instructions. This gives two different
261 ways to determine where the lda instruction is; I don't know why
262 both are used. The value to use for the relocation is the
263 difference between the GP value and the current location; the
264 load will always be done against a register holding the current
266 HOWTO (ALPHA_R_GPDISP, /* type */
268 2, /* size (0 = byte, 1 = short, 2 = long) */
270 TRUE, /* pc_relative */
272 complain_overflow_dont, /* complain_on_overflow */
273 reloc_nil, /* special_function */
275 TRUE, /* partial_inplace */
276 0xffff, /* src_mask */
277 0xffff, /* dst_mask */
278 TRUE), /* pcrel_offset */
280 /* A 21 bit branch. The native assembler generates these for
281 branches within the text segment, and also fills in the PC
282 relative offset in the instruction. */
283 HOWTO (ALPHA_R_BRADDR, /* type */
285 2, /* size (0 = byte, 1 = short, 2 = long) */
287 TRUE, /* pc_relative */
289 complain_overflow_signed, /* complain_on_overflow */
290 0, /* special_function */
292 TRUE, /* partial_inplace */
293 0x1fffff, /* src_mask */
294 0x1fffff, /* dst_mask */
295 FALSE), /* pcrel_offset */
297 /* A hint for a jump to a register. */
298 HOWTO (ALPHA_R_HINT, /* type */
300 2, /* size (0 = byte, 1 = short, 2 = long) */
302 TRUE, /* pc_relative */
304 complain_overflow_dont, /* complain_on_overflow */
305 0, /* special_function */
307 TRUE, /* partial_inplace */
308 0x3fff, /* src_mask */
309 0x3fff, /* dst_mask */
310 FALSE), /* pcrel_offset */
312 /* 16 bit PC relative offset. */
313 HOWTO (ALPHA_R_SREL16, /* type */
315 1, /* size (0 = byte, 1 = short, 2 = long) */
317 TRUE, /* pc_relative */
319 complain_overflow_signed, /* complain_on_overflow */
320 0, /* special_function */
322 TRUE, /* partial_inplace */
323 0xffff, /* src_mask */
324 0xffff, /* dst_mask */
325 FALSE), /* pcrel_offset */
327 /* 32 bit PC relative offset. */
328 HOWTO (ALPHA_R_SREL32, /* type */
330 2, /* size (0 = byte, 1 = short, 2 = long) */
332 TRUE, /* pc_relative */
334 complain_overflow_signed, /* complain_on_overflow */
335 0, /* special_function */
337 TRUE, /* partial_inplace */
338 0xffffffff, /* src_mask */
339 0xffffffff, /* dst_mask */
340 FALSE), /* pcrel_offset */
342 /* A 64 bit PC relative offset. */
343 HOWTO (ALPHA_R_SREL64, /* type */
345 4, /* size (0 = byte, 1 = short, 2 = long) */
347 TRUE, /* pc_relative */
349 complain_overflow_signed, /* complain_on_overflow */
350 0, /* special_function */
352 TRUE, /* partial_inplace */
353 MINUS_ONE, /* src_mask */
354 MINUS_ONE, /* dst_mask */
355 FALSE), /* pcrel_offset */
357 /* Push a value on the reloc evaluation stack. */
358 HOWTO (ALPHA_R_OP_PUSH, /* type */
360 0, /* size (0 = byte, 1 = short, 2 = long) */
362 FALSE, /* pc_relative */
364 complain_overflow_dont, /* complain_on_overflow */
365 0, /* special_function */
366 "OP_PUSH", /* name */
367 FALSE, /* partial_inplace */
370 FALSE), /* pcrel_offset */
372 /* Store the value from the stack at the given address. Store it in
373 a bitfield of size r_size starting at bit position r_offset. */
374 HOWTO (ALPHA_R_OP_STORE, /* type */
376 4, /* size (0 = byte, 1 = short, 2 = long) */
378 FALSE, /* pc_relative */
380 complain_overflow_dont, /* complain_on_overflow */
381 0, /* special_function */
382 "OP_STORE", /* name */
383 FALSE, /* partial_inplace */
385 MINUS_ONE, /* dst_mask */
386 FALSE), /* pcrel_offset */
388 /* Subtract the reloc address from the value on the top of the
390 HOWTO (ALPHA_R_OP_PSUB, /* type */
392 0, /* size (0 = byte, 1 = short, 2 = long) */
394 FALSE, /* pc_relative */
396 complain_overflow_dont, /* complain_on_overflow */
397 0, /* special_function */
398 "OP_PSUB", /* name */
399 FALSE, /* partial_inplace */
402 FALSE), /* pcrel_offset */
404 /* Shift the value on the top of the relocation stack right by the
406 HOWTO (ALPHA_R_OP_PRSHIFT, /* type */
408 0, /* size (0 = byte, 1 = short, 2 = long) */
410 FALSE, /* pc_relative */
412 complain_overflow_dont, /* complain_on_overflow */
413 0, /* special_function */
414 "OP_PRSHIFT", /* name */
415 FALSE, /* partial_inplace */
418 FALSE), /* pcrel_offset */
420 /* Adjust the GP value for a new range in the object file. */
421 HOWTO (ALPHA_R_GPVALUE, /* type */
423 0, /* size (0 = byte, 1 = short, 2 = long) */
425 FALSE, /* pc_relative */
427 complain_overflow_dont, /* complain_on_overflow */
428 0, /* special_function */
429 "GPVALUE", /* name */
430 FALSE, /* partial_inplace */
433 FALSE) /* pcrel_offset */
436 /* Recognize an Alpha ECOFF file. */
438 static const bfd_target *
439 alpha_ecoff_object_p (abfd)
442 static const bfd_target *ret;
444 ret = coff_object_p (abfd);
450 /* Alpha ECOFF has a .pdata section. The lnnoptr field of the
451 .pdata section is the number of entries it contains. Each
452 entry takes up 8 bytes. The number of entries is required
453 since the section is aligned to a 16 byte boundary. When we
454 link .pdata sections together, we do not want to include the
455 alignment bytes. We handle this on input by faking the size
456 of the .pdata section to remove the unwanted alignment bytes.
457 On output we will set the lnnoptr field and force the
459 sec = bfd_get_section_by_name (abfd, _PDATA);
460 if (sec != (asection *) NULL)
464 size = sec->line_filepos * 8;
465 BFD_ASSERT (size == sec->size
466 || size + 8 == sec->size);
467 if (! bfd_set_section_size (abfd, sec, size))
475 /* See whether the magic number matches. */
478 alpha_ecoff_bad_format_hook (abfd, filehdr)
479 bfd *abfd ATTRIBUTE_UNUSED;
482 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
484 if (ALPHA_ECOFF_BADMAG (*internal_f))
490 /* This is a hook called by coff_real_object_p to create any backend
491 specific information. */
494 alpha_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
501 ecoff = _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr);
505 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
507 /* Set additional BFD flags according to the object type from the
508 machine specific file header flags. */
509 switch (internal_f->f_flags & F_ALPHA_OBJECT_TYPE_MASK)
511 case F_ALPHA_SHARABLE:
512 abfd->flags |= DYNAMIC;
514 case F_ALPHA_CALL_SHARED:
515 /* Always executable if using shared libraries as the run time
516 loader might resolve undefined references. */
517 abfd->flags |= (DYNAMIC | EXEC_P);
524 /* Reloc handling. */
526 /* Swap a reloc in. */
529 alpha_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
532 struct internal_reloc *intern;
534 const RELOC *ext = (RELOC *) ext_ptr;
536 intern->r_vaddr = H_GET_64 (abfd, ext->r_vaddr);
537 intern->r_symndx = H_GET_32 (abfd, ext->r_symndx);
539 BFD_ASSERT (bfd_header_little_endian (abfd));
541 intern->r_type = ((ext->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
542 >> RELOC_BITS0_TYPE_SH_LITTLE);
543 intern->r_extern = (ext->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
544 intern->r_offset = ((ext->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
545 >> RELOC_BITS1_OFFSET_SH_LITTLE);
546 /* Ignored the reserved bits. */
547 intern->r_size = ((ext->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
548 >> RELOC_BITS3_SIZE_SH_LITTLE);
550 if (intern->r_type == ALPHA_R_LITUSE
551 || intern->r_type == ALPHA_R_GPDISP)
553 /* Handle the LITUSE and GPDISP relocs specially. Its symndx
554 value is not actually a symbol index, but is instead a
555 special code. We put the code in the r_size field, and
556 clobber the symndx. */
557 if (intern->r_size != 0)
559 intern->r_size = intern->r_symndx;
560 intern->r_symndx = RELOC_SECTION_NONE;
562 else if (intern->r_type == ALPHA_R_IGNORE)
564 /* The IGNORE reloc generally follows a GPDISP reloc, and is
565 against the .lita section. The section is irrelevant. */
566 if (! intern->r_extern &&
567 intern->r_symndx == RELOC_SECTION_ABS)
569 if (! intern->r_extern && intern->r_symndx == RELOC_SECTION_LITA)
570 intern->r_symndx = RELOC_SECTION_ABS;
574 /* Swap a reloc out. */
577 alpha_ecoff_swap_reloc_out (abfd, intern, dst)
579 const struct internal_reloc *intern;
582 RELOC *ext = (RELOC *) dst;
586 /* Undo the hackery done in swap_reloc_in. */
587 if (intern->r_type == ALPHA_R_LITUSE
588 || intern->r_type == ALPHA_R_GPDISP)
590 symndx = intern->r_size;
593 else if (intern->r_type == ALPHA_R_IGNORE
594 && ! intern->r_extern
595 && intern->r_symndx == RELOC_SECTION_ABS)
597 symndx = RELOC_SECTION_LITA;
598 size = intern->r_size;
602 symndx = intern->r_symndx;
603 size = intern->r_size;
606 BFD_ASSERT (intern->r_extern
607 || (intern->r_symndx >= 0 && intern->r_symndx <= 14));
609 H_PUT_64 (abfd, intern->r_vaddr, ext->r_vaddr);
610 H_PUT_32 (abfd, symndx, ext->r_symndx);
612 BFD_ASSERT (bfd_header_little_endian (abfd));
614 ext->r_bits[0] = ((intern->r_type << RELOC_BITS0_TYPE_SH_LITTLE)
615 & RELOC_BITS0_TYPE_LITTLE);
616 ext->r_bits[1] = ((intern->r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
617 | ((intern->r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
618 & RELOC_BITS1_OFFSET_LITTLE));
620 ext->r_bits[3] = ((size << RELOC_BITS3_SIZE_SH_LITTLE)
621 & RELOC_BITS3_SIZE_LITTLE);
624 /* Finish canonicalizing a reloc. Part of this is generic to all
625 ECOFF targets, and that part is in ecoff.c. The rest is done in
626 this backend routine. It must fill in the howto field. */
629 alpha_adjust_reloc_in (abfd, intern, rptr)
631 const struct internal_reloc *intern;
634 if (intern->r_type > ALPHA_R_GPVALUE)
636 (*_bfd_error_handler)
637 (_("%B: unknown/unsupported relocation type %d"),
638 abfd, intern->r_type);
639 bfd_set_error (bfd_error_bad_value);
645 switch (intern->r_type)
651 /* This relocs appear to be fully resolved when they are against
652 internal symbols. Against external symbols, BRADDR at least
653 appears to be resolved against the next instruction. */
654 if (! intern->r_extern)
657 rptr->addend = - (intern->r_vaddr + 4);
660 case ALPHA_R_GPREL32:
661 case ALPHA_R_LITERAL:
662 /* Copy the gp value for this object file into the addend, to
663 ensure that we are not confused by the linker. */
664 if (! intern->r_extern)
665 rptr->addend += ecoff_data (abfd)->gp;
670 /* The LITUSE and GPDISP relocs do not use a symbol, or an
671 addend, but they do use a special code. Put this code in the
673 rptr->addend = intern->r_size;
676 case ALPHA_R_OP_STORE:
677 /* The STORE reloc needs the size and offset fields. We store
678 them in the addend. */
679 BFD_ASSERT (intern->r_offset <= 256);
680 rptr->addend = (intern->r_offset << 8) + intern->r_size;
683 case ALPHA_R_OP_PUSH:
684 case ALPHA_R_OP_PSUB:
685 case ALPHA_R_OP_PRSHIFT:
686 /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
687 address. I believe that the address supplied is really an
689 rptr->addend = intern->r_vaddr;
692 case ALPHA_R_GPVALUE:
693 /* Set the addend field to the new GP value. */
694 rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp;
698 /* If the type is ALPHA_R_IGNORE, make sure this is a reference
699 to the absolute section so that the reloc is ignored. For
700 some reason the address of this reloc type is not adjusted by
701 the section vma. We record the gp value for this object file
702 here, for convenience when doing the GPDISP relocation. */
703 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
704 rptr->address = intern->r_vaddr;
705 rptr->addend = ecoff_data (abfd)->gp;
712 rptr->howto = &alpha_howto_table[intern->r_type];
715 /* When writing out a reloc we need to pull some values back out of
716 the addend field into the reloc. This is roughly the reverse of
717 alpha_adjust_reloc_in, except that there are several changes we do
721 alpha_adjust_reloc_out (abfd, rel, intern)
722 bfd *abfd ATTRIBUTE_UNUSED;
724 struct internal_reloc *intern;
726 switch (intern->r_type)
730 intern->r_size = rel->addend;
733 case ALPHA_R_OP_STORE:
734 intern->r_size = rel->addend & 0xff;
735 intern->r_offset = (rel->addend >> 8) & 0xff;
738 case ALPHA_R_OP_PUSH:
739 case ALPHA_R_OP_PSUB:
740 case ALPHA_R_OP_PRSHIFT:
741 intern->r_vaddr = rel->addend;
745 intern->r_vaddr = rel->address;
753 /* The size of the stack for the relocation evaluator. */
754 #define RELOC_STACKSIZE (10)
756 /* Alpha ECOFF relocs have a built in expression evaluator as well as
757 other interdependencies. Rather than use a bunch of special
758 functions and global variables, we use a single routine to do all
759 the relocation for a section. I haven't yet worked out how the
760 assembler is going to handle this. */
763 alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order,
764 data, relocatable, symbols)
766 struct bfd_link_info *link_info;
767 struct bfd_link_order *link_order;
769 bfd_boolean relocatable;
772 bfd *input_bfd = link_order->u.indirect.section->owner;
773 asection *input_section = link_order->u.indirect.section;
774 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
775 arelent **reloc_vector = NULL;
777 bfd *output_bfd = relocatable ? abfd : (bfd *) NULL;
780 bfd_boolean gp_undefined;
781 bfd_vma stack[RELOC_STACKSIZE];
786 reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
787 if (reloc_vector == NULL && reloc_size != 0)
790 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
791 if (! bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
794 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
795 reloc_vector, symbols);
798 if (reloc_count == 0)
799 goto successful_return;
801 /* Get the GP value for the output BFD. */
802 gp_undefined = FALSE;
803 gp = _bfd_get_gp_value (abfd);
811 /* Make up a value. */
813 for (sec = abfd->sections; sec != NULL; sec = sec->next)
816 && (strcmp (sec->name, ".sbss") == 0
817 || strcmp (sec->name, ".sdata") == 0
818 || strcmp (sec->name, ".lit4") == 0
819 || strcmp (sec->name, ".lit8") == 0
820 || strcmp (sec->name, ".lita") == 0))
824 _bfd_set_gp_value (abfd, gp);
828 struct bfd_link_hash_entry *h;
830 h = bfd_link_hash_lookup (link_info->hash, "_gp", FALSE, FALSE,
832 if (h == (struct bfd_link_hash_entry *) NULL
833 || h->type != bfd_link_hash_defined)
838 + h->u.def.section->output_section->vma
839 + h->u.def.section->output_offset);
840 _bfd_set_gp_value (abfd, gp);
845 for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
848 bfd_reloc_status_type r;
853 switch (rel->howto->type)
856 rel->address += input_section->output_offset;
859 case ALPHA_R_REFLONG:
860 case ALPHA_R_REFQUAD:
867 && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
869 rel->address += input_section->output_offset;
872 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
876 case ALPHA_R_GPREL32:
877 /* This relocation is used in a switch table. It is a 32
878 bit offset from the current GP value. We must adjust it
879 by the different between the original GP value and the
880 current GP value. The original GP value is stored in the
881 addend. We adjust the addend and let
882 bfd_perform_relocation finish the job. */
884 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
886 if (r == bfd_reloc_ok && gp_undefined)
888 r = bfd_reloc_dangerous;
889 err = (char *) _("GP relative relocation used when GP not defined");
893 case ALPHA_R_LITERAL:
894 /* This is a reference to a literal value, generally
895 (always?) in the .lita section. This is a 16 bit GP
896 relative relocation. Sometimes the subsequent reloc is a
897 LITUSE reloc, which indicates how this reloc is used.
898 This sometimes permits rewriting the two instructions
899 referred to by the LITERAL and the LITUSE into different
900 instructions which do not refer to .lita. This can save
901 a memory reference, and permits removing a value from
902 .lita thus saving GP relative space.
904 We do not these optimizations. To do them we would need
905 to arrange to link the .lita section first, so that by
906 the time we got here we would know the final values to
907 use. This would not be particularly difficult, but it is
908 not currently implemented. */
913 /* I believe that the LITERAL reloc will only apply to a
914 ldq or ldl instruction, so check my assumption. */
915 insn = bfd_get_32 (input_bfd, data + rel->address);
916 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
917 || ((insn >> 26) & 0x3f) == 0x28);
920 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
922 if (r == bfd_reloc_ok && gp_undefined)
924 r = bfd_reloc_dangerous;
926 (char *) _("GP relative relocation used when GP not defined");
932 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
933 does not cause anything to happen, itself. */
934 rel->address += input_section->output_offset;
938 /* This marks the ldah of an ldah/lda pair which loads the
939 gp register with the difference of the gp value and the
940 current location. The second of the pair is r_size bytes
941 ahead; it used to be marked with an ALPHA_R_IGNORE reloc,
942 but that no longer happens in OSF/1 3.2. */
944 unsigned long insn1, insn2;
947 /* Get the two instructions. */
948 insn1 = bfd_get_32 (input_bfd, data + rel->address);
949 insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend);
951 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
952 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
954 /* Get the existing addend. We must account for the sign
955 extension done by lda and ldah. */
956 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
959 addend -= 0x80000000;
960 addend -= 0x80000000;
965 /* The existing addend includes the different between the
966 gp of the input BFD and the address in the input BFD.
967 Subtract this out. */
968 addend -= (ecoff_data (input_bfd)->gp
969 - (input_section->vma + rel->address));
971 /* Now add in the final gp value, and subtract out the
974 - (input_section->output_section->vma
975 + input_section->output_offset
978 /* Change the instructions, accounting for the sign
979 extension, and write them out. */
982 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
983 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
985 bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address);
986 bfd_put_32 (input_bfd, (bfd_vma) insn2,
987 data + rel->address + rel->addend);
989 rel->address += input_section->output_offset;
993 case ALPHA_R_OP_PUSH:
994 /* Push a value on the reloc evaluation stack. */
1001 rel->address += input_section->output_offset;
1005 /* Figure out the relocation of this symbol. */
1006 symbol = *rel->sym_ptr_ptr;
1008 if (bfd_is_und_section (symbol->section))
1009 r = bfd_reloc_undefined;
1011 if (bfd_is_com_section (symbol->section))
1014 relocation = symbol->value;
1015 relocation += symbol->section->output_section->vma;
1016 relocation += symbol->section->output_offset;
1017 relocation += rel->addend;
1019 if (tos >= RELOC_STACKSIZE)
1022 stack[tos++] = relocation;
1026 case ALPHA_R_OP_STORE:
1027 /* Store a value from the reloc stack into a bitfield. */
1034 rel->address += input_section->output_offset;
1041 /* The offset and size for this reloc are encoded into the
1042 addend field by alpha_adjust_reloc_in. */
1043 offset = (rel->addend >> 8) & 0xff;
1044 size = rel->addend & 0xff;
1046 val = bfd_get_64 (abfd, data + rel->address);
1047 val &=~ (((1 << size) - 1) << offset);
1048 val |= (stack[--tos] & ((1 << size) - 1)) << offset;
1049 bfd_put_64 (abfd, val, data + rel->address);
1053 case ALPHA_R_OP_PSUB:
1054 /* Subtract a value from the top of the stack. */
1061 rel->address += input_section->output_offset;
1065 /* Figure out the relocation of this symbol. */
1066 symbol = *rel->sym_ptr_ptr;
1068 if (bfd_is_und_section (symbol->section))
1069 r = bfd_reloc_undefined;
1071 if (bfd_is_com_section (symbol->section))
1074 relocation = symbol->value;
1075 relocation += symbol->section->output_section->vma;
1076 relocation += symbol->section->output_offset;
1077 relocation += rel->addend;
1082 stack[tos - 1] -= relocation;
1086 case ALPHA_R_OP_PRSHIFT:
1087 /* Shift the value on the top of the stack. */
1094 rel->address += input_section->output_offset;
1098 /* Figure out the relocation of this symbol. */
1099 symbol = *rel->sym_ptr_ptr;
1101 if (bfd_is_und_section (symbol->section))
1102 r = bfd_reloc_undefined;
1104 if (bfd_is_com_section (symbol->section))
1107 relocation = symbol->value;
1108 relocation += symbol->section->output_section->vma;
1109 relocation += symbol->section->output_offset;
1110 relocation += rel->addend;
1115 stack[tos - 1] >>= relocation;
1119 case ALPHA_R_GPVALUE:
1120 /* I really don't know if this does the right thing. */
1122 gp_undefined = FALSE;
1131 asection *os = input_section->output_section;
1133 /* A partial link, so keep the relocs. */
1134 os->orelocation[os->reloc_count] = rel;
1138 if (r != bfd_reloc_ok)
1142 case bfd_reloc_undefined:
1143 if (! ((*link_info->callbacks->undefined_symbol)
1144 (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1145 input_bfd, input_section, rel->address, TRUE)))
1148 case bfd_reloc_dangerous:
1149 if (! ((*link_info->callbacks->reloc_dangerous)
1150 (link_info, err, input_bfd, input_section,
1154 case bfd_reloc_overflow:
1155 if (! ((*link_info->callbacks->reloc_overflow)
1157 bfd_asymbol_name (*rel->sym_ptr_ptr),
1158 rel->howto->name, rel->addend, input_bfd,
1159 input_section, rel->address)))
1162 case bfd_reloc_outofrange:
1174 if (reloc_vector != NULL)
1175 free (reloc_vector);
1179 if (reloc_vector != NULL)
1180 free (reloc_vector);
1184 /* Get the howto structure for a generic reloc type. */
1186 static reloc_howto_type *
1187 alpha_bfd_reloc_type_lookup (abfd, code)
1188 bfd *abfd ATTRIBUTE_UNUSED;
1189 bfd_reloc_code_real_type code;
1196 alpha_type = ALPHA_R_REFLONG;
1199 case BFD_RELOC_CTOR:
1200 alpha_type = ALPHA_R_REFQUAD;
1202 case BFD_RELOC_GPREL32:
1203 alpha_type = ALPHA_R_GPREL32;
1205 case BFD_RELOC_ALPHA_LITERAL:
1206 alpha_type = ALPHA_R_LITERAL;
1208 case BFD_RELOC_ALPHA_LITUSE:
1209 alpha_type = ALPHA_R_LITUSE;
1211 case BFD_RELOC_ALPHA_GPDISP_HI16:
1212 alpha_type = ALPHA_R_GPDISP;
1214 case BFD_RELOC_ALPHA_GPDISP_LO16:
1215 alpha_type = ALPHA_R_IGNORE;
1217 case BFD_RELOC_23_PCREL_S2:
1218 alpha_type = ALPHA_R_BRADDR;
1220 case BFD_RELOC_ALPHA_HINT:
1221 alpha_type = ALPHA_R_HINT;
1223 case BFD_RELOC_16_PCREL:
1224 alpha_type = ALPHA_R_SREL16;
1226 case BFD_RELOC_32_PCREL:
1227 alpha_type = ALPHA_R_SREL32;
1229 case BFD_RELOC_64_PCREL:
1230 alpha_type = ALPHA_R_SREL64;
1233 return (reloc_howto_type *) NULL;
1236 return &alpha_howto_table[alpha_type];
1239 /* A helper routine for alpha_relocate_section which converts an
1240 external reloc when generating relocatable output. Returns the
1241 relocation amount. */
1244 alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h)
1245 bfd *output_bfd ATTRIBUTE_UNUSED;
1246 struct bfd_link_info *info;
1248 struct external_reloc *ext_rel;
1249 struct ecoff_link_hash_entry *h;
1251 unsigned long r_symndx;
1254 BFD_ASSERT (info->relocatable);
1256 if (h->root.type == bfd_link_hash_defined
1257 || h->root.type == bfd_link_hash_defweak)
1262 /* This symbol is defined in the output. Convert the reloc from
1263 being against the symbol to being against the section. */
1265 /* Clear the r_extern bit. */
1266 ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE;
1268 /* Compute a new r_symndx value. */
1269 hsec = h->root.u.def.section;
1270 name = bfd_get_section_name (output_bfd, hsec->output_section);
1272 r_symndx = (unsigned long) -1;
1276 if (strcmp (name, "*ABS*") == 0)
1277 r_symndx = RELOC_SECTION_ABS;
1280 if (strcmp (name, ".bss") == 0)
1281 r_symndx = RELOC_SECTION_BSS;
1284 if (strcmp (name, ".data") == 0)
1285 r_symndx = RELOC_SECTION_DATA;
1288 if (strcmp (name, ".fini") == 0)
1289 r_symndx = RELOC_SECTION_FINI;
1292 if (strcmp (name, ".init") == 0)
1293 r_symndx = RELOC_SECTION_INIT;
1296 if (strcmp (name, ".lita") == 0)
1297 r_symndx = RELOC_SECTION_LITA;
1298 else if (strcmp (name, ".lit8") == 0)
1299 r_symndx = RELOC_SECTION_LIT8;
1300 else if (strcmp (name, ".lit4") == 0)
1301 r_symndx = RELOC_SECTION_LIT4;
1304 if (strcmp (name, ".pdata") == 0)
1305 r_symndx = RELOC_SECTION_PDATA;
1308 if (strcmp (name, ".rdata") == 0)
1309 r_symndx = RELOC_SECTION_RDATA;
1310 else if (strcmp (name, ".rconst") == 0)
1311 r_symndx = RELOC_SECTION_RCONST;
1314 if (strcmp (name, ".sdata") == 0)
1315 r_symndx = RELOC_SECTION_SDATA;
1316 else if (strcmp (name, ".sbss") == 0)
1317 r_symndx = RELOC_SECTION_SBSS;
1320 if (strcmp (name, ".text") == 0)
1321 r_symndx = RELOC_SECTION_TEXT;
1324 if (strcmp (name, ".xdata") == 0)
1325 r_symndx = RELOC_SECTION_XDATA;
1329 if (r_symndx == (unsigned long) -1)
1332 /* Add the section VMA and the symbol value. */
1333 relocation = (h->root.u.def.value
1334 + hsec->output_section->vma
1335 + hsec->output_offset);
1339 /* Change the symndx value to the right one for
1342 if (r_symndx == (unsigned long) -1)
1344 /* Caller must give an error. */
1350 /* Write out the new r_symndx value. */
1351 H_PUT_32 (input_bfd, r_symndx, ext_rel->r_symndx);
1356 /* Relocate a section while linking an Alpha ECOFF file. This is
1357 quite similar to get_relocated_section_contents. Perhaps they
1358 could be combined somehow. */
1361 alpha_relocate_section (output_bfd, info, input_bfd, input_section,
1362 contents, external_relocs)
1364 struct bfd_link_info *info;
1366 asection *input_section;
1368 PTR external_relocs;
1370 asection **symndx_to_section, *lita_sec;
1371 struct ecoff_link_hash_entry **sym_hashes;
1373 bfd_boolean gp_undefined;
1374 bfd_vma stack[RELOC_STACKSIZE];
1376 struct external_reloc *ext_rel;
1377 struct external_reloc *ext_rel_end;
1380 /* We keep a table mapping the symndx found in an internal reloc to
1381 the appropriate section. This is faster than looking up the
1382 section by name each time. */
1383 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1384 if (symndx_to_section == (asection **) NULL)
1386 amt = NUM_RELOC_SECTIONS * sizeof (asection *);
1387 symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
1388 if (!symndx_to_section)
1391 symndx_to_section[RELOC_SECTION_NONE] = NULL;
1392 symndx_to_section[RELOC_SECTION_TEXT] =
1393 bfd_get_section_by_name (input_bfd, ".text");
1394 symndx_to_section[RELOC_SECTION_RDATA] =
1395 bfd_get_section_by_name (input_bfd, ".rdata");
1396 symndx_to_section[RELOC_SECTION_DATA] =
1397 bfd_get_section_by_name (input_bfd, ".data");
1398 symndx_to_section[RELOC_SECTION_SDATA] =
1399 bfd_get_section_by_name (input_bfd, ".sdata");
1400 symndx_to_section[RELOC_SECTION_SBSS] =
1401 bfd_get_section_by_name (input_bfd, ".sbss");
1402 symndx_to_section[RELOC_SECTION_BSS] =
1403 bfd_get_section_by_name (input_bfd, ".bss");
1404 symndx_to_section[RELOC_SECTION_INIT] =
1405 bfd_get_section_by_name (input_bfd, ".init");
1406 symndx_to_section[RELOC_SECTION_LIT8] =
1407 bfd_get_section_by_name (input_bfd, ".lit8");
1408 symndx_to_section[RELOC_SECTION_LIT4] =
1409 bfd_get_section_by_name (input_bfd, ".lit4");
1410 symndx_to_section[RELOC_SECTION_XDATA] =
1411 bfd_get_section_by_name (input_bfd, ".xdata");
1412 symndx_to_section[RELOC_SECTION_PDATA] =
1413 bfd_get_section_by_name (input_bfd, ".pdata");
1414 symndx_to_section[RELOC_SECTION_FINI] =
1415 bfd_get_section_by_name (input_bfd, ".fini");
1416 symndx_to_section[RELOC_SECTION_LITA] =
1417 bfd_get_section_by_name (input_bfd, ".lita");
1418 symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1419 symndx_to_section[RELOC_SECTION_RCONST] =
1420 bfd_get_section_by_name (input_bfd, ".rconst");
1422 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1425 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1427 /* On the Alpha, the .lita section must be addressable by the global
1428 pointer. To support large programs, we need to allow multiple
1429 global pointers. This works as long as each input .lita section
1430 is <64KB big. This implies that when producing relocatable
1431 output, the .lita section is limited to 64KB. . */
1433 lita_sec = symndx_to_section[RELOC_SECTION_LITA];
1434 gp = _bfd_get_gp_value (output_bfd);
1435 if (! info->relocatable && lita_sec != NULL)
1437 struct ecoff_section_tdata *lita_sec_data;
1439 /* Make sure we have a section data structure to which we can
1440 hang on to the gp value we pick for the section. */
1441 lita_sec_data = ecoff_section_data (input_bfd, lita_sec);
1442 if (lita_sec_data == NULL)
1444 amt = sizeof (struct ecoff_section_tdata);
1445 lita_sec_data = ((struct ecoff_section_tdata *)
1446 bfd_zalloc (input_bfd, amt));
1447 lita_sec->used_by_bfd = lita_sec_data;
1450 if (lita_sec_data->gp != 0)
1452 /* If we already assigned a gp to this section, we better
1453 stick with that value. */
1454 gp = lita_sec_data->gp;
1459 bfd_size_type lita_size;
1461 lita_vma = lita_sec->output_offset + lita_sec->output_section->vma;
1462 lita_size = lita_sec->size;
1465 || lita_vma < gp - 0x8000
1466 || lita_vma + lita_size >= gp + 0x8000)
1468 /* Either gp hasn't been set at all or the current gp
1469 cannot address this .lita section. In both cases we
1470 reset the gp to point into the "middle" of the
1471 current input .lita section. */
1472 if (gp && !ecoff_data (output_bfd)->issued_multiple_gp_warning)
1474 (*info->callbacks->warning) (info,
1475 _("using multiple gp values"),
1476 (char *) NULL, output_bfd,
1477 (asection *) NULL, (bfd_vma) 0);
1478 ecoff_data (output_bfd)->issued_multiple_gp_warning = TRUE;
1480 if (lita_vma < gp - 0x8000)
1481 gp = lita_vma + lita_size - 0x8000;
1483 gp = lita_vma + 0x8000;
1487 lita_sec_data->gp = gp;
1490 _bfd_set_gp_value (output_bfd, gp);
1493 gp_undefined = (gp == 0);
1495 BFD_ASSERT (bfd_header_little_endian (output_bfd));
1496 BFD_ASSERT (bfd_header_little_endian (input_bfd));
1498 ext_rel = (struct external_reloc *) external_relocs;
1499 ext_rel_end = ext_rel + input_section->reloc_count;
1500 for (; ext_rel < ext_rel_end; ext_rel++)
1503 unsigned long r_symndx;
1508 bfd_boolean relocatep;
1509 bfd_boolean adjust_addrp;
1510 bfd_boolean gp_usedp;
1513 r_vaddr = H_GET_64 (input_bfd, ext_rel->r_vaddr);
1514 r_symndx = H_GET_32 (input_bfd, ext_rel->r_symndx);
1516 r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1517 >> RELOC_BITS0_TYPE_SH_LITTLE);
1518 r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1519 r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1520 >> RELOC_BITS1_OFFSET_SH_LITTLE);
1521 /* Ignored the reserved bits. */
1522 r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1523 >> RELOC_BITS3_SIZE_SH_LITTLE);
1526 adjust_addrp = TRUE;
1532 case ALPHA_R_GPRELHIGH:
1533 (*_bfd_error_handler)
1534 (_("%B: unsupported relocation: ALPHA_R_GPRELHIGH"),
1536 bfd_set_error (bfd_error_bad_value);
1539 case ALPHA_R_GPRELLOW:
1540 (*_bfd_error_handler)
1541 (_("%B: unsupported relocation: ALPHA_R_GPRELLOW"),
1543 bfd_set_error (bfd_error_bad_value);
1547 (*_bfd_error_handler)
1548 (_("%B: unknown relocation type %d"),
1549 input_bfd, (int) r_type);
1550 bfd_set_error (bfd_error_bad_value);
1553 case ALPHA_R_IGNORE:
1554 /* This reloc appears after a GPDISP reloc. On earlier
1555 versions of OSF/1, It marked the position of the second
1556 instruction to be altered by the GPDISP reloc, but it is
1557 not otherwise used for anything. For some reason, the
1558 address of the relocation does not appear to include the
1559 section VMA, unlike the other relocation types. */
1560 if (info->relocatable)
1561 H_PUT_64 (input_bfd, input_section->output_offset + r_vaddr,
1563 adjust_addrp = FALSE;
1566 case ALPHA_R_REFLONG:
1567 case ALPHA_R_REFQUAD:
1572 case ALPHA_R_BRADDR:
1573 case ALPHA_R_SREL16:
1574 case ALPHA_R_SREL32:
1575 case ALPHA_R_SREL64:
1577 addend += - (r_vaddr + 4);
1581 case ALPHA_R_GPREL32:
1582 /* This relocation is used in a switch table. It is a 32
1583 bit offset from the current GP value. We must adjust it
1584 by the different between the original GP value and the
1585 current GP value. */
1587 addend = ecoff_data (input_bfd)->gp - gp;
1591 case ALPHA_R_LITERAL:
1592 /* This is a reference to a literal value, generally
1593 (always?) in the .lita section. This is a 16 bit GP
1594 relative relocation. Sometimes the subsequent reloc is a
1595 LITUSE reloc, which indicates how this reloc is used.
1596 This sometimes permits rewriting the two instructions
1597 referred to by the LITERAL and the LITUSE into different
1598 instructions which do not refer to .lita. This can save
1599 a memory reference, and permits removing a value from
1600 .lita thus saving GP relative space.
1602 We do not these optimizations. To do them we would need
1603 to arrange to link the .lita section first, so that by
1604 the time we got here we would know the final values to
1605 use. This would not be particularly difficult, but it is
1606 not currently implemented. */
1608 /* I believe that the LITERAL reloc will only apply to a ldq
1609 or ldl instruction, so check my assumption. */
1613 insn = bfd_get_32 (input_bfd,
1614 contents + r_vaddr - input_section->vma);
1615 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1616 || ((insn >> 26) & 0x3f) == 0x28);
1620 addend = ecoff_data (input_bfd)->gp - gp;
1624 case ALPHA_R_LITUSE:
1625 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
1626 does not cause anything to happen, itself. */
1629 case ALPHA_R_GPDISP:
1630 /* This marks the ldah of an ldah/lda pair which loads the
1631 gp register with the difference of the gp value and the
1632 current location. The second of the pair is r_symndx
1633 bytes ahead. It used to be marked with an ALPHA_R_IGNORE
1634 reloc, but OSF/1 3.2 no longer does that. */
1636 unsigned long insn1, insn2;
1638 /* Get the two instructions. */
1639 insn1 = bfd_get_32 (input_bfd,
1640 contents + r_vaddr - input_section->vma);
1641 insn2 = bfd_get_32 (input_bfd,
1644 - input_section->vma
1647 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1648 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1650 /* Get the existing addend. We must account for the sign
1651 extension done by lda and ldah. */
1652 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1655 /* This is addend -= 0x100000000 without causing an
1656 integer overflow on a 32 bit host. */
1657 addend -= 0x80000000;
1658 addend -= 0x80000000;
1663 /* The existing addend includes the difference between the
1664 gp of the input BFD and the address in the input BFD.
1665 We want to change this to the difference between the
1666 final GP and the final address. */
1668 - ecoff_data (input_bfd)->gp
1669 + input_section->vma
1670 - (input_section->output_section->vma
1671 + input_section->output_offset));
1673 /* Change the instructions, accounting for the sign
1674 extension, and write them out. */
1675 if (addend & 0x8000)
1677 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1678 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1680 bfd_put_32 (input_bfd, (bfd_vma) insn1,
1681 contents + r_vaddr - input_section->vma);
1682 bfd_put_32 (input_bfd, (bfd_vma) insn2,
1683 contents + r_vaddr - input_section->vma + r_symndx);
1689 case ALPHA_R_OP_PUSH:
1690 case ALPHA_R_OP_PSUB:
1691 case ALPHA_R_OP_PRSHIFT:
1692 /* Manipulate values on the reloc evaluation stack. The
1693 r_vaddr field is not an address in input_section, it is
1694 the current value (including any addend) of the object
1700 s = symndx_to_section[r_symndx];
1701 if (s == (asection *) NULL)
1703 addend = s->output_section->vma + s->output_offset - s->vma;
1707 struct ecoff_link_hash_entry *h;
1709 h = sym_hashes[r_symndx];
1710 if (h == (struct ecoff_link_hash_entry *) NULL)
1713 if (! info->relocatable)
1715 if (h->root.type == bfd_link_hash_defined
1716 || h->root.type == bfd_link_hash_defweak)
1717 addend = (h->root.u.def.value
1718 + h->root.u.def.section->output_section->vma
1719 + h->root.u.def.section->output_offset);
1722 /* Note that we pass the address as 0, since we
1723 do not have a meaningful number for the
1724 location within the section that is being
1726 if (! ((*info->callbacks->undefined_symbol)
1727 (info, h->root.root.string, input_bfd,
1728 input_section, (bfd_vma) 0, TRUE)))
1735 if (h->root.type != bfd_link_hash_defined
1736 && h->root.type != bfd_link_hash_defweak
1739 /* This symbol is not being written out. Pass
1740 the address as 0, as with undefined_symbol,
1742 if (! ((*info->callbacks->unattached_reloc)
1743 (info, h->root.root.string, input_bfd,
1744 input_section, (bfd_vma) 0)))
1748 addend = alpha_convert_external_reloc (output_bfd, info,
1756 if (info->relocatable)
1758 /* Adjust r_vaddr by the addend. */
1759 H_PUT_64 (input_bfd, addend, ext_rel->r_vaddr);
1765 case ALPHA_R_OP_PUSH:
1766 if (tos >= RELOC_STACKSIZE)
1768 stack[tos++] = addend;
1771 case ALPHA_R_OP_PSUB:
1774 stack[tos - 1] -= addend;
1777 case ALPHA_R_OP_PRSHIFT:
1780 stack[tos - 1] >>= addend;
1785 adjust_addrp = FALSE;
1788 case ALPHA_R_OP_STORE:
1789 /* Store a value from the reloc stack into a bitfield. If
1790 we are generating relocatable output, all we do is
1791 adjust the address of the reloc. */
1792 if (! info->relocatable)
1800 /* Get the relocation mask. The separate steps and the
1801 casts to bfd_vma are attempts to avoid a bug in the
1802 Alpha OSF 1.3 C compiler. See reloc.c for more
1805 mask <<= (bfd_vma) r_size;
1808 /* FIXME: I don't know what kind of overflow checking,
1809 if any, should be done here. */
1810 val = bfd_get_64 (input_bfd,
1811 contents + r_vaddr - input_section->vma);
1812 val &=~ mask << (bfd_vma) r_offset;
1813 val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1814 bfd_put_64 (input_bfd, val,
1815 contents + r_vaddr - input_section->vma);
1819 case ALPHA_R_GPVALUE:
1820 /* I really don't know if this does the right thing. */
1821 gp = ecoff_data (input_bfd)->gp + r_symndx;
1822 gp_undefined = FALSE;
1828 reloc_howto_type *howto;
1829 struct ecoff_link_hash_entry *h = NULL;
1832 bfd_reloc_status_type r;
1834 /* Perform a relocation. */
1836 howto = &alpha_howto_table[r_type];
1840 h = sym_hashes[r_symndx];
1841 /* If h is NULL, that means that there is a reloc
1842 against an external symbol which we thought was just
1843 a debugging symbol. This should not happen. */
1844 if (h == (struct ecoff_link_hash_entry *) NULL)
1849 if (r_symndx >= NUM_RELOC_SECTIONS)
1852 s = symndx_to_section[r_symndx];
1854 if (s == (asection *) NULL)
1858 if (info->relocatable)
1860 /* We are generating relocatable output, and must
1861 convert the existing reloc. */
1864 if (h->root.type != bfd_link_hash_defined
1865 && h->root.type != bfd_link_hash_defweak
1868 /* This symbol is not being written out. */
1869 if (! ((*info->callbacks->unattached_reloc)
1870 (info, h->root.root.string, input_bfd,
1871 input_section, r_vaddr - input_section->vma)))
1875 relocation = alpha_convert_external_reloc (output_bfd,
1883 /* This is a relocation against a section. Adjust
1884 the value by the amount the section moved. */
1885 relocation = (s->output_section->vma
1890 /* If this is PC relative, the existing object file
1891 appears to already have the reloc worked out. We
1892 must subtract out the old value and add in the new
1894 if (howto->pc_relative)
1895 relocation -= (input_section->output_section->vma
1896 + input_section->output_offset
1897 - input_section->vma);
1899 /* Put in any addend. */
1900 relocation += addend;
1902 /* Adjust the contents. */
1903 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1906 - input_section->vma));
1910 /* We are producing a final executable. */
1913 /* This is a reloc against a symbol. */
1914 if (h->root.type == bfd_link_hash_defined
1915 || h->root.type == bfd_link_hash_defweak)
1919 hsec = h->root.u.def.section;
1920 relocation = (h->root.u.def.value
1921 + hsec->output_section->vma
1922 + hsec->output_offset);
1926 if (! ((*info->callbacks->undefined_symbol)
1927 (info, h->root.root.string, input_bfd,
1929 r_vaddr - input_section->vma, TRUE)))
1936 /* This is a reloc against a section. */
1937 relocation = (s->output_section->vma
1941 /* Adjust a PC relative relocation by removing the
1942 reference to the original source section. */
1943 if (howto->pc_relative)
1944 relocation += input_section->vma;
1947 r = _bfd_final_link_relocate (howto,
1951 r_vaddr - input_section->vma,
1956 if (r != bfd_reloc_ok)
1961 case bfd_reloc_outofrange:
1963 case bfd_reloc_overflow:
1968 name = sym_hashes[r_symndx]->root.root.string;
1970 name = bfd_section_name (input_bfd,
1971 symndx_to_section[r_symndx]);
1972 if (! ((*info->callbacks->reloc_overflow)
1974 alpha_howto_table[r_type].name,
1975 (bfd_vma) 0, input_bfd, input_section,
1976 r_vaddr - input_section->vma)))
1984 if (info->relocatable && adjust_addrp)
1986 /* Change the address of the relocation. */
1987 H_PUT_64 (input_bfd,
1988 (input_section->output_section->vma
1989 + input_section->output_offset
1990 - input_section->vma
1995 if (gp_usedp && gp_undefined)
1997 if (! ((*info->callbacks->reloc_dangerous)
1998 (info, _("GP relative relocation used when GP not defined"),
1999 input_bfd, input_section, r_vaddr - input_section->vma)))
2001 /* Only give the error once per link. */
2003 _bfd_set_gp_value (output_bfd, gp);
2004 gp_undefined = FALSE;
2014 /* Do final adjustments to the filehdr and the aouthdr. This routine
2015 sets the dynamic bits in the file header. */
2018 alpha_adjust_headers (abfd, fhdr, ahdr)
2020 struct internal_filehdr *fhdr;
2021 struct internal_aouthdr *ahdr ATTRIBUTE_UNUSED;
2023 if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
2024 fhdr->f_flags |= F_ALPHA_CALL_SHARED;
2025 else if ((abfd->flags & DYNAMIC) != 0)
2026 fhdr->f_flags |= F_ALPHA_SHARABLE;
2030 /* Archive handling. In OSF/1 (or Digital Unix) v3.2, Digital
2031 introduced archive packing, in which the elements in an archive are
2032 optionally compressed using a simple dictionary scheme. We know
2033 how to read such archives, but we don't write them. */
2035 #define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap
2036 #define alpha_ecoff_slurp_extended_name_table \
2037 _bfd_ecoff_slurp_extended_name_table
2038 #define alpha_ecoff_construct_extended_name_table \
2039 _bfd_ecoff_construct_extended_name_table
2040 #define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname
2041 #define alpha_ecoff_write_armap _bfd_ecoff_write_armap
2042 #define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt
2043 #define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp
2045 /* A compressed file uses this instead of ARFMAG. */
2047 #define ARFZMAG "Z\012"
2049 /* Read an archive header. This is like the standard routine, but it
2050 also accepts ARFZMAG. */
2053 alpha_ecoff_read_ar_hdr (abfd)
2056 struct areltdata *ret;
2059 ret = (struct areltdata *) _bfd_generic_read_ar_hdr_mag (abfd, ARFZMAG);
2063 h = (struct ar_hdr *) ret->arch_header;
2064 if (strncmp (h->ar_fmag, ARFZMAG, 2) == 0)
2068 /* This is a compressed file. We must set the size correctly.
2069 The size is the eight bytes after the dummy file header. */
2070 if (bfd_seek (abfd, (file_ptr) FILHSZ, SEEK_CUR) != 0
2071 || bfd_bread (ab, (bfd_size_type) 8, abfd) != 8
2072 || bfd_seek (abfd, (file_ptr) (- (FILHSZ + 8)), SEEK_CUR) != 0)
2075 ret->parsed_size = H_GET_64 (abfd, ab);
2081 /* Get an archive element at a specified file position. This is where
2082 we uncompress the archive element if necessary. */
2085 alpha_ecoff_get_elt_at_filepos (archive, filepos)
2090 struct areltdata *tdata;
2095 struct bfd_in_memory *bim;
2097 nbfd = _bfd_get_elt_at_filepos (archive, filepos);
2101 if ((nbfd->flags & BFD_IN_MEMORY) != 0)
2103 /* We have already expanded this BFD. */
2107 tdata = (struct areltdata *) nbfd->arelt_data;
2108 hdr = (struct ar_hdr *) tdata->arch_header;
2109 if (strncmp (hdr->ar_fmag, ARFZMAG, 2) != 0)
2112 /* We must uncompress this element. We do this by copying it into a
2113 memory buffer, and making bfd_bread and bfd_seek use that buffer.
2114 This can use a lot of memory, but it's simpler than getting a
2115 temporary file, making that work with the file descriptor caching
2116 code, and making sure that it is deleted at all appropriate
2117 times. It can be changed if it ever becomes important. */
2119 /* The compressed file starts with a dummy ECOFF file header. */
2120 if (bfd_seek (nbfd, (file_ptr) FILHSZ, SEEK_SET) != 0)
2123 /* The next eight bytes are the real file size. */
2124 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2126 size = H_GET_64 (nbfd, ab);
2133 bfd_byte dict[4096];
2137 buf = (bfd_byte *) bfd_alloc (nbfd, size);
2144 /* I don't know what the next eight bytes are for. */
2145 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2148 /* This is the uncompression algorithm. It's a simple
2149 dictionary based scheme in which each character is predicted
2150 by a hash of the previous three characters. A control byte
2151 indicates whether the character is predicted or whether it
2152 appears in the input stream; each control byte manages the
2153 next eight bytes in the output stream. */
2154 memset (dict, 0, sizeof dict);
2156 while (bfd_bread (&b, (bfd_size_type) 1, nbfd) == 1)
2160 for (i = 0; i < 8; i++, b >>= 1)
2168 if (! bfd_bread (&n, (bfd_size_type) 1, nbfd))
2181 h &= sizeof dict - 1;
2189 /* Now the uncompressed file contents are in buf. */
2190 bim = ((struct bfd_in_memory *)
2191 bfd_alloc (nbfd, (bfd_size_type) sizeof (struct bfd_in_memory)));
2197 nbfd->mtime_set = TRUE;
2198 nbfd->mtime = strtol (hdr->ar_date, (char **) NULL, 10);
2200 nbfd->flags |= BFD_IN_MEMORY;
2201 nbfd->iostream = (PTR) bim;
2202 BFD_ASSERT (! nbfd->cacheable);
2212 /* Open the next archived file. */
2215 alpha_ecoff_openr_next_archived_file (archive, last_file)
2221 if (last_file == NULL)
2222 filestart = bfd_ardata (archive)->first_file_filepos;
2225 struct areltdata *t;
2229 /* We can't use arelt_size here, because that uses parsed_size,
2230 which is the uncompressed size. We need the compressed size. */
2231 t = (struct areltdata *) last_file->arelt_data;
2232 h = (struct ar_hdr *) t->arch_header;
2233 size = strtol (h->ar_size, (char **) NULL, 10);
2235 /* Pad to an even boundary...
2236 Note that last_file->origin can be odd in the case of
2237 BSD-4.4-style element with a long odd size. */
2238 filestart = last_file->origin + size;
2239 filestart += filestart % 2;
2242 return alpha_ecoff_get_elt_at_filepos (archive, filestart);
2245 /* Open the archive file given an index into the armap. */
2248 alpha_ecoff_get_elt_at_index (abfd, index)
2254 entry = bfd_ardata (abfd)->symdefs + index;
2255 return alpha_ecoff_get_elt_at_filepos (abfd, entry->file_offset);
2258 /* This is the ECOFF backend structure. The backend field of the
2259 target vector points to this. */
2261 static const struct ecoff_backend_data alpha_ecoff_backend_data =
2263 /* COFF backend structure. */
2265 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2266 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2267 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2268 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2269 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2270 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2271 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2272 alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
2273 alpha_ecoff_swap_scnhdr_out,
2274 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE, FALSE, 4, FALSE, 2,
2275 alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
2276 alpha_ecoff_swap_scnhdr_in, NULL,
2277 alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2278 alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2279 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2280 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2283 /* Supported architecture. */
2285 /* Initial portion of armap string. */
2287 /* The page boundary used to align sections in a demand-paged
2288 executable file. E.g., 0x1000. */
2290 /* TRUE if the .rdata section is part of the text segment, as on the
2291 Alpha. FALSE if .rdata is part of the data segment, as on the
2294 /* Bitsize of constructor entries. */
2296 /* Reloc to use for constructor entries. */
2297 &alpha_howto_table[ALPHA_R_REFQUAD],
2299 /* Symbol table magic number. */
2301 /* Alignment of debugging information. E.g., 4. */
2303 /* Sizes of external symbolic information. */
2304 sizeof (struct hdr_ext),
2305 sizeof (struct dnr_ext),
2306 sizeof (struct pdr_ext),
2307 sizeof (struct sym_ext),
2308 sizeof (struct opt_ext),
2309 sizeof (struct fdr_ext),
2310 sizeof (struct rfd_ext),
2311 sizeof (struct ext_ext),
2312 /* Functions to swap in external symbolic data. */
2321 _bfd_ecoff_swap_tir_in,
2322 _bfd_ecoff_swap_rndx_in,
2323 /* Functions to swap out external symbolic data. */
2332 _bfd_ecoff_swap_tir_out,
2333 _bfd_ecoff_swap_rndx_out,
2334 /* Function to read in symbolic data. */
2335 _bfd_ecoff_slurp_symbolic_info
2337 /* External reloc size. */
2339 /* Reloc swapping functions. */
2340 alpha_ecoff_swap_reloc_in,
2341 alpha_ecoff_swap_reloc_out,
2342 /* Backend reloc tweaking. */
2343 alpha_adjust_reloc_in,
2344 alpha_adjust_reloc_out,
2345 /* Relocate section contents while linking. */
2346 alpha_relocate_section,
2347 /* Do final adjustments to filehdr and aouthdr. */
2348 alpha_adjust_headers,
2349 /* Read an element from an archive at a given file position. */
2350 alpha_ecoff_get_elt_at_filepos
2353 /* Looking up a reloc type is Alpha specific. */
2354 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2356 /* So is getting relocated section contents. */
2357 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2358 alpha_ecoff_get_relocated_section_contents
2360 /* Handling file windows is generic. */
2361 #define _bfd_ecoff_get_section_contents_in_window \
2362 _bfd_generic_get_section_contents_in_window
2364 /* Relaxing sections is generic. */
2365 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2366 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2367 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
2368 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
2369 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
2370 #define _bfd_ecoff_section_already_linked \
2371 _bfd_generic_section_already_linked
2373 const bfd_target ecoffalpha_little_vec =
2375 "ecoff-littlealpha", /* name */
2376 bfd_target_ecoff_flavour,
2377 BFD_ENDIAN_LITTLE, /* data byte order is little */
2378 BFD_ENDIAN_LITTLE, /* header byte order is little */
2380 (HAS_RELOC | EXEC_P | /* object flags */
2381 HAS_LINENO | HAS_DEBUG |
2382 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2384 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2385 0, /* leading underscore */
2386 ' ', /* ar_pad_char */
2387 15, /* ar_max_namelen */
2388 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2389 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2390 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2391 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2392 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2393 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2395 {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */
2396 _bfd_ecoff_archive_p, _bfd_dummy_target},
2397 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2398 _bfd_generic_mkarchive, bfd_false},
2399 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2400 _bfd_write_archive_contents, bfd_false},
2402 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2403 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2404 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2405 BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff),
2406 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2407 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2408 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2409 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2410 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2414 (PTR) &alpha_ecoff_backend_data