1 /* BFD back-end for ALPHA Extended-Coff files.
2 Copyright 1993, 1994 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "coff/internal.h"
28 #include "coff/symconst.h"
29 #include "coff/ecoff.h"
30 #include "coff/alpha.h"
35 /* Prototypes for static functions. */
37 static const bfd_target
*alpha_ecoff_object_p
PARAMS ((bfd
*));
38 static boolean alpha_ecoff_bad_format_hook
PARAMS ((bfd
*abfd
, PTR filehdr
));
39 static PTR alpha_ecoff_mkobject_hook
PARAMS ((bfd
*, PTR filehdr
, PTR aouthdr
));
40 static void alpha_ecoff_swap_reloc_in
PARAMS ((bfd
*, PTR
,
41 struct internal_reloc
*));
42 static void alpha_ecoff_swap_reloc_out
PARAMS ((bfd
*,
43 const struct internal_reloc
*,
45 static void alpha_adjust_reloc_in
PARAMS ((bfd
*,
46 const struct internal_reloc
*,
48 static void alpha_adjust_reloc_out
PARAMS ((bfd
*, const arelent
*,
49 struct internal_reloc
*));
50 static bfd_byte
*alpha_ecoff_get_relocated_section_contents
51 PARAMS ((bfd
*abfd
, struct bfd_link_info
*, struct bfd_link_order
*,
52 bfd_byte
*data
, boolean relocateable
, asymbol
**symbols
));
53 static bfd_vma alpha_convert_external_reloc
54 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, struct external_reloc
*,
55 struct ecoff_link_hash_entry
*));
56 static boolean alpha_relocate_section
PARAMS ((bfd
*, struct bfd_link_info
*,
59 static boolean alpha_adjust_headers
60 PARAMS ((bfd
*, struct internal_filehdr
*, struct internal_aouthdr
*));
61 static PTR alpha_ecoff_read_ar_hdr
PARAMS ((bfd
*));
62 static bfd
*alpha_ecoff_get_elt_at_filepos
PARAMS ((bfd
*, file_ptr
));
63 static bfd
*alpha_ecoff_openr_next_archived_file
PARAMS ((bfd
*, bfd
*));
64 static bfd
*alpha_ecoff_get_elt_at_index
PARAMS ((bfd
*, symindex
));
66 /* ECOFF has COFF sections, but the debugging information is stored in
67 a completely different format. ECOFF targets use some of the
68 swapping routines from coffswap.h, and some of the generic COFF
69 routines in coffgen.c, but, unlike the real COFF targets, do not
70 use coffcode.h itself.
72 Get the generic COFF swapping routines, except for the reloc,
73 symbol, and lineno ones. Give them ecoff names. Define some
74 accessor macros for the large sizes used for Alpha ECOFF. */
76 #define GET_FILEHDR_SYMPTR bfd_h_get_64
77 #define PUT_FILEHDR_SYMPTR bfd_h_put_64
78 #define GET_AOUTHDR_TSIZE bfd_h_get_64
79 #define PUT_AOUTHDR_TSIZE bfd_h_put_64
80 #define GET_AOUTHDR_DSIZE bfd_h_get_64
81 #define PUT_AOUTHDR_DSIZE bfd_h_put_64
82 #define GET_AOUTHDR_BSIZE bfd_h_get_64
83 #define PUT_AOUTHDR_BSIZE bfd_h_put_64
84 #define GET_AOUTHDR_ENTRY bfd_h_get_64
85 #define PUT_AOUTHDR_ENTRY bfd_h_put_64
86 #define GET_AOUTHDR_TEXT_START bfd_h_get_64
87 #define PUT_AOUTHDR_TEXT_START bfd_h_put_64
88 #define GET_AOUTHDR_DATA_START bfd_h_get_64
89 #define PUT_AOUTHDR_DATA_START bfd_h_put_64
90 #define GET_SCNHDR_PADDR bfd_h_get_64
91 #define PUT_SCNHDR_PADDR bfd_h_put_64
92 #define GET_SCNHDR_VADDR bfd_h_get_64
93 #define PUT_SCNHDR_VADDR bfd_h_put_64
94 #define GET_SCNHDR_SIZE bfd_h_get_64
95 #define PUT_SCNHDR_SIZE bfd_h_put_64
96 #define GET_SCNHDR_SCNPTR bfd_h_get_64
97 #define PUT_SCNHDR_SCNPTR bfd_h_put_64
98 #define GET_SCNHDR_RELPTR bfd_h_get_64
99 #define PUT_SCNHDR_RELPTR bfd_h_put_64
100 #define GET_SCNHDR_LNNOPTR bfd_h_get_64
101 #define PUT_SCNHDR_LNNOPTR bfd_h_put_64
105 #define NO_COFF_RELOCS
106 #define NO_COFF_SYMBOLS
107 #define NO_COFF_LINENOS
108 #define coff_swap_filehdr_in alpha_ecoff_swap_filehdr_in
109 #define coff_swap_filehdr_out alpha_ecoff_swap_filehdr_out
110 #define coff_swap_aouthdr_in alpha_ecoff_swap_aouthdr_in
111 #define coff_swap_aouthdr_out alpha_ecoff_swap_aouthdr_out
112 #define coff_swap_scnhdr_in alpha_ecoff_swap_scnhdr_in
113 #define coff_swap_scnhdr_out alpha_ecoff_swap_scnhdr_out
114 #include "coffswap.h"
116 /* Get the ECOFF swapping routines. */
118 #include "ecoffswap.h"
120 /* How to process the various reloc types. */
122 static bfd_reloc_status_type
123 reloc_nil
PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
,
124 asection
*, bfd
*, char **));
126 static bfd_reloc_status_type
127 reloc_nil (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
134 char **error_message
;
139 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
140 from smaller values. Start with zero, widen, *then* decrement. */
141 #define MINUS_ONE (((bfd_vma)0) - 1)
143 static reloc_howto_type alpha_howto_table
[] =
145 /* Reloc type 0 is ignored by itself. However, it appears after a
146 GPDISP reloc to identify the location where the low order 16 bits
147 of the gp register are loaded. */
148 HOWTO (ALPHA_R_IGNORE
, /* type */
150 0, /* size (0 = byte, 1 = short, 2 = long) */
152 true, /* pc_relative */
154 complain_overflow_dont
, /* complain_on_overflow */
155 reloc_nil
, /* special_function */
157 true, /* partial_inplace */
160 true), /* pcrel_offset */
162 /* A 32 bit reference to a symbol. */
163 HOWTO (ALPHA_R_REFLONG
, /* type */
165 2, /* size (0 = byte, 1 = short, 2 = long) */
167 false, /* pc_relative */
169 complain_overflow_bitfield
, /* complain_on_overflow */
170 0, /* special_function */
171 "REFLONG", /* name */
172 true, /* partial_inplace */
173 0xffffffff, /* src_mask */
174 0xffffffff, /* dst_mask */
175 false), /* pcrel_offset */
177 /* A 64 bit reference to a symbol. */
178 HOWTO (ALPHA_R_REFQUAD
, /* type */
180 4, /* size (0 = byte, 1 = short, 2 = long) */
182 false, /* pc_relative */
184 complain_overflow_bitfield
, /* complain_on_overflow */
185 0, /* special_function */
186 "REFQUAD", /* name */
187 true, /* partial_inplace */
188 MINUS_ONE
, /* src_mask */
189 MINUS_ONE
, /* dst_mask */
190 false), /* pcrel_offset */
192 /* A 32 bit GP relative offset. This is just like REFLONG except
193 that when the value is used the value of the gp register will be
195 HOWTO (ALPHA_R_GPREL32
, /* type */
197 2, /* size (0 = byte, 1 = short, 2 = long) */
199 false, /* pc_relative */
201 complain_overflow_bitfield
, /* complain_on_overflow */
202 0, /* special_function */
203 "GPREL32", /* name */
204 true, /* partial_inplace */
205 0xffffffff, /* src_mask */
206 0xffffffff, /* dst_mask */
207 false), /* pcrel_offset */
209 /* Used for an instruction that refers to memory off the GP
210 register. The offset is 16 bits of the 32 bit instruction. This
211 reloc always seems to be against the .lita section. */
212 HOWTO (ALPHA_R_LITERAL
, /* type */
214 2, /* size (0 = byte, 1 = short, 2 = long) */
216 false, /* pc_relative */
218 complain_overflow_signed
, /* complain_on_overflow */
219 0, /* special_function */
220 "LITERAL", /* name */
221 true, /* partial_inplace */
222 0xffff, /* src_mask */
223 0xffff, /* dst_mask */
224 false), /* pcrel_offset */
226 /* This reloc only appears immediately following a LITERAL reloc.
227 It identifies a use of the literal. It seems that the linker can
228 use this to eliminate a portion of the .lita section. The symbol
229 index is special: 1 means the literal address is in the base
230 register of a memory format instruction; 2 means the literal
231 address is in the byte offset register of a byte-manipulation
232 instruction; 3 means the literal address is in the target
233 register of a jsr instruction. This does not actually do any
235 HOWTO (ALPHA_R_LITUSE
, /* type */
237 2, /* size (0 = byte, 1 = short, 2 = long) */
239 false, /* pc_relative */
241 complain_overflow_dont
, /* complain_on_overflow */
242 reloc_nil
, /* special_function */
244 false, /* partial_inplace */
247 false), /* pcrel_offset */
249 /* Load the gp register. This is always used for a ldah instruction
250 which loads the upper 16 bits of the gp register. The next reloc
251 will be an IGNORE reloc which identifies the location of the lda
252 instruction which loads the lower 16 bits. The symbol index of
253 the GPDISP instruction appears to actually be the number of bytes
254 between the ldah and lda instructions. This gives two different
255 ways to determine where the lda instruction is; I don't know why
256 both are used. The value to use for the relocation is the
257 difference between the GP value and the current location; the
258 load will always be done against a register holding the current
260 HOWTO (ALPHA_R_GPDISP
, /* type */
262 2, /* size (0 = byte, 1 = short, 2 = long) */
264 true, /* pc_relative */
266 complain_overflow_dont
, /* complain_on_overflow */
267 reloc_nil
, /* special_function */
269 true, /* partial_inplace */
270 0xffff, /* src_mask */
271 0xffff, /* dst_mask */
272 true), /* pcrel_offset */
274 /* A 21 bit branch. The native assembler generates these for
275 branches within the text segment, and also fills in the PC
276 relative offset in the instruction. */
277 HOWTO (ALPHA_R_BRADDR
, /* type */
279 2, /* size (0 = byte, 1 = short, 2 = long) */
281 true, /* pc_relative */
283 complain_overflow_signed
, /* complain_on_overflow */
284 0, /* special_function */
286 true, /* partial_inplace */
287 0x1fffff, /* src_mask */
288 0x1fffff, /* dst_mask */
289 false), /* pcrel_offset */
291 /* A hint for a jump to a register. */
292 HOWTO (ALPHA_R_HINT
, /* type */
294 2, /* size (0 = byte, 1 = short, 2 = long) */
296 true, /* pc_relative */
298 complain_overflow_dont
, /* complain_on_overflow */
299 0, /* special_function */
301 true, /* partial_inplace */
302 0x3fff, /* src_mask */
303 0x3fff, /* dst_mask */
304 false), /* pcrel_offset */
306 /* 16 bit PC relative offset. */
307 HOWTO (ALPHA_R_SREL16
, /* type */
309 1, /* size (0 = byte, 1 = short, 2 = long) */
311 true, /* pc_relative */
313 complain_overflow_signed
, /* complain_on_overflow */
314 0, /* special_function */
316 true, /* partial_inplace */
317 0xffff, /* src_mask */
318 0xffff, /* dst_mask */
319 false), /* pcrel_offset */
321 /* 32 bit PC relative offset. */
322 HOWTO (ALPHA_R_SREL32
, /* type */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
326 true, /* pc_relative */
328 complain_overflow_signed
, /* complain_on_overflow */
329 0, /* special_function */
331 true, /* partial_inplace */
332 0xffffffff, /* src_mask */
333 0xffffffff, /* dst_mask */
334 false), /* pcrel_offset */
336 /* A 64 bit PC relative offset. */
337 HOWTO (ALPHA_R_SREL64
, /* type */
339 4, /* size (0 = byte, 1 = short, 2 = long) */
341 true, /* pc_relative */
343 complain_overflow_signed
, /* complain_on_overflow */
344 0, /* special_function */
346 true, /* partial_inplace */
347 MINUS_ONE
, /* src_mask */
348 MINUS_ONE
, /* dst_mask */
349 false), /* pcrel_offset */
351 /* Push a value on the reloc evaluation stack. */
352 HOWTO (ALPHA_R_OP_PUSH
, /* type */
354 0, /* size (0 = byte, 1 = short, 2 = long) */
356 false, /* pc_relative */
358 complain_overflow_dont
, /* complain_on_overflow */
359 0, /* special_function */
360 "OP_PUSH", /* name */
361 false, /* partial_inplace */
364 false), /* pcrel_offset */
366 /* Store the value from the stack at the given address. Store it in
367 a bitfield of size r_size starting at bit position r_offset. */
368 HOWTO (ALPHA_R_OP_STORE
, /* type */
370 4, /* size (0 = byte, 1 = short, 2 = long) */
372 false, /* pc_relative */
374 complain_overflow_dont
, /* complain_on_overflow */
375 0, /* special_function */
376 "OP_STORE", /* name */
377 false, /* partial_inplace */
379 MINUS_ONE
, /* dst_mask */
380 false), /* pcrel_offset */
382 /* Subtract the reloc address from the value on the top of the
384 HOWTO (ALPHA_R_OP_PSUB
, /* 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 "OP_PSUB", /* name */
393 false, /* partial_inplace */
396 false), /* pcrel_offset */
398 /* Shift the value on the top of the relocation stack right by the
400 HOWTO (ALPHA_R_OP_PRSHIFT
, /* type */
402 0, /* size (0 = byte, 1 = short, 2 = long) */
404 false, /* pc_relative */
406 complain_overflow_dont
, /* complain_on_overflow */
407 0, /* special_function */
408 "OP_PRSHIFT", /* name */
409 false, /* partial_inplace */
412 false), /* pcrel_offset */
414 /* Adjust the GP value for a new range in the object file. */
415 HOWTO (ALPHA_R_GPVALUE
, /* type */
417 0, /* size (0 = byte, 1 = short, 2 = long) */
419 false, /* pc_relative */
421 complain_overflow_dont
, /* complain_on_overflow */
422 0, /* special_function */
423 "GPVALUE", /* name */
424 false, /* partial_inplace */
427 false) /* pcrel_offset */
430 /* Recognize an Alpha ECOFF file. */
432 static const bfd_target
*
433 alpha_ecoff_object_p (abfd
)
436 static const bfd_target
*ret
;
438 ret
= coff_object_p (abfd
);
444 /* Alpha ECOFF has a .pdata section. The lnnoptr field of the
445 .pdata section is the number of entries it contains. Each
446 entry takes up 8 bytes. The number of entries is required
447 since the section is aligned to a 16 byte boundary. When we
448 link .pdata sections together, we do not want to include the
449 alignment bytes. We handle this on input by faking the size
450 of the .pdata section to remove the unwanted alignment bytes.
451 On output we will set the lnnoptr field and force the
453 sec
= bfd_get_section_by_name (abfd
, _PDATA
);
454 if (sec
!= (asection
*) NULL
)
458 size
= sec
->line_filepos
* 8;
459 BFD_ASSERT (size
== bfd_section_size (abfd
, sec
)
460 || size
+ 8 == bfd_section_size (abfd
, sec
));
461 if (! bfd_set_section_size (abfd
, sec
, size
))
469 /* See whether the magic number matches. */
472 alpha_ecoff_bad_format_hook (abfd
, filehdr
)
476 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
478 if (ALPHA_ECOFF_BADMAG (*internal_f
))
484 /* This is a hook called by coff_real_object_p to create any backend
485 specific information. */
488 alpha_ecoff_mkobject_hook (abfd
, filehdr
, aouthdr
)
495 ecoff
= _bfd_ecoff_mkobject_hook (abfd
, filehdr
, aouthdr
);
499 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
501 /* Set additional BFD flags according to the object type from the
502 machine specific file header flags. */
503 switch (internal_f
->f_flags
& F_ALPHA_OBJECT_TYPE_MASK
)
505 case F_ALPHA_SHARABLE
:
506 abfd
->flags
|= DYNAMIC
;
508 case F_ALPHA_CALL_SHARED
:
509 /* Always executable if using shared libraries as the run time
510 loader might resolve undefined references. */
511 abfd
->flags
|= (DYNAMIC
| EXEC_P
);
518 /* Reloc handling. */
520 /* Swap a reloc in. */
523 alpha_ecoff_swap_reloc_in (abfd
, ext_ptr
, intern
)
526 struct internal_reloc
*intern
;
528 const RELOC
*ext
= (RELOC
*) ext_ptr
;
530 intern
->r_vaddr
= bfd_h_get_64 (abfd
, (bfd_byte
*) ext
->r_vaddr
);
531 intern
->r_symndx
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->r_symndx
);
533 BFD_ASSERT (bfd_header_little_endian (abfd
));
535 intern
->r_type
= ((ext
->r_bits
[0] & RELOC_BITS0_TYPE_LITTLE
)
536 >> RELOC_BITS0_TYPE_SH_LITTLE
);
537 intern
->r_extern
= (ext
->r_bits
[1] & RELOC_BITS1_EXTERN_LITTLE
) != 0;
538 intern
->r_offset
= ((ext
->r_bits
[1] & RELOC_BITS1_OFFSET_LITTLE
)
539 >> RELOC_BITS1_OFFSET_SH_LITTLE
);
540 /* Ignored the reserved bits. */
541 intern
->r_size
= ((ext
->r_bits
[3] & RELOC_BITS3_SIZE_LITTLE
)
542 >> RELOC_BITS3_SIZE_SH_LITTLE
);
544 if (intern
->r_type
== ALPHA_R_LITUSE
545 || intern
->r_type
== ALPHA_R_GPDISP
)
547 /* Handle the LITUSE and GPDISP relocs specially. Its symndx
548 value is not actually a symbol index, but is instead a
549 special code. We put the code in the r_size field, and
550 clobber the symndx. */
551 if (intern
->r_size
!= 0)
553 intern
->r_size
= intern
->r_symndx
;
554 intern
->r_symndx
= RELOC_SECTION_NONE
;
556 else if (intern
->r_type
== ALPHA_R_IGNORE
)
558 /* The IGNORE reloc generally follows a GPDISP reloc, and is
559 against the .lita section. The section is irrelevant. */
560 if (! intern
->r_extern
&&
561 intern
->r_symndx
== RELOC_SECTION_ABS
)
563 if (! intern
->r_extern
&& intern
->r_symndx
== RELOC_SECTION_LITA
)
564 intern
->r_symndx
= RELOC_SECTION_ABS
;
568 /* Swap a reloc out. */
571 alpha_ecoff_swap_reloc_out (abfd
, intern
, dst
)
573 const struct internal_reloc
*intern
;
576 RELOC
*ext
= (RELOC
*) dst
;
580 /* Undo the hackery done in swap_reloc_in. */
581 if (intern
->r_type
== ALPHA_R_LITUSE
582 || intern
->r_type
== ALPHA_R_GPDISP
)
584 symndx
= intern
->r_size
;
587 else if (intern
->r_type
== ALPHA_R_IGNORE
588 && ! intern
->r_extern
589 && intern
->r_symndx
== RELOC_SECTION_ABS
)
591 symndx
= RELOC_SECTION_LITA
;
592 size
= intern
->r_size
;
596 symndx
= intern
->r_symndx
;
597 size
= intern
->r_size
;
600 BFD_ASSERT (intern
->r_extern
601 || (intern
->r_symndx
>= 0 && intern
->r_symndx
<= 14));
603 bfd_h_put_64 (abfd
, intern
->r_vaddr
, (bfd_byte
*) ext
->r_vaddr
);
604 bfd_h_put_32 (abfd
, symndx
, (bfd_byte
*) ext
->r_symndx
);
606 BFD_ASSERT (bfd_header_little_endian (abfd
));
608 ext
->r_bits
[0] = ((intern
->r_type
<< RELOC_BITS0_TYPE_SH_LITTLE
)
609 & RELOC_BITS0_TYPE_LITTLE
);
610 ext
->r_bits
[1] = ((intern
->r_extern
? RELOC_BITS1_EXTERN_LITTLE
: 0)
611 | ((intern
->r_offset
<< RELOC_BITS1_OFFSET_SH_LITTLE
)
612 & RELOC_BITS1_OFFSET_LITTLE
));
614 ext
->r_bits
[3] = ((size
<< RELOC_BITS3_SIZE_SH_LITTLE
)
615 & RELOC_BITS3_SIZE_LITTLE
);
618 /* Finish canonicalizing a reloc. Part of this is generic to all
619 ECOFF targets, and that part is in ecoff.c. The rest is done in
620 this backend routine. It must fill in the howto field. */
623 alpha_adjust_reloc_in (abfd
, intern
, rptr
)
625 const struct internal_reloc
*intern
;
628 if (intern
->r_type
> ALPHA_R_GPVALUE
)
631 switch (intern
->r_type
)
637 /* The PC relative relocs do not seem to use the section VMA as
638 a negative addend. */
642 case ALPHA_R_GPREL32
:
643 case ALPHA_R_LITERAL
:
644 /* Copy the gp value for this object file into the addend, to
645 ensure that we are not confused by the linker. */
646 if (! intern
->r_extern
)
647 rptr
->addend
+= ecoff_data (abfd
)->gp
;
652 /* The LITUSE and GPDISP relocs do not use a symbol, or an
653 addend, but they do use a special code. Put this code in the
655 rptr
->addend
= intern
->r_size
;
658 case ALPHA_R_OP_STORE
:
659 /* The STORE reloc needs the size and offset fields. We store
660 them in the addend. */
661 BFD_ASSERT (intern
->r_offset
<= 256 && intern
->r_size
<= 256);
662 rptr
->addend
= (intern
->r_offset
<< 8) + intern
->r_size
;
665 case ALPHA_R_OP_PUSH
:
666 case ALPHA_R_OP_PSUB
:
667 case ALPHA_R_OP_PRSHIFT
:
668 /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
669 address. I believe that the address supplied is really an
671 rptr
->addend
= intern
->r_vaddr
;
674 case ALPHA_R_GPVALUE
:
675 /* Set the addend field to the new GP value. */
676 rptr
->addend
= intern
->r_symndx
+ ecoff_data (abfd
)->gp
;
680 /* If the type is ALPHA_R_IGNORE, make sure this is a reference
681 to the absolute section so that the reloc is ignored. For
682 some reason the address of this reloc type is not adjusted by
683 the section vma. We record the gp value for this object file
684 here, for convenience when doing the GPDISP relocation. */
685 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
686 rptr
->address
= intern
->r_vaddr
;
687 rptr
->addend
= ecoff_data (abfd
)->gp
;
694 rptr
->howto
= &alpha_howto_table
[intern
->r_type
];
697 /* When writing out a reloc we need to pull some values back out of
698 the addend field into the reloc. This is roughly the reverse of
699 alpha_adjust_reloc_in, except that there are several changes we do
703 alpha_adjust_reloc_out (abfd
, rel
, intern
)
706 struct internal_reloc
*intern
;
708 switch (intern
->r_type
)
712 intern
->r_size
= rel
->addend
;
715 case ALPHA_R_OP_STORE
:
716 intern
->r_size
= rel
->addend
& 0xff;
717 intern
->r_offset
= (rel
->addend
>> 8) & 0xff;
720 case ALPHA_R_OP_PUSH
:
721 case ALPHA_R_OP_PSUB
:
722 case ALPHA_R_OP_PRSHIFT
:
723 intern
->r_vaddr
= rel
->addend
;
727 intern
->r_vaddr
= rel
->address
;
735 /* The size of the stack for the relocation evaluator. */
736 #define RELOC_STACKSIZE (10)
738 /* Alpha ECOFF relocs have a built in expression evaluator as well as
739 other interdependencies. Rather than use a bunch of special
740 functions and global variables, we use a single routine to do all
741 the relocation for a section. I haven't yet worked out how the
742 assembler is going to handle this. */
745 alpha_ecoff_get_relocated_section_contents (abfd
, link_info
, link_order
,
746 data
, relocateable
, symbols
)
748 struct bfd_link_info
*link_info
;
749 struct bfd_link_order
*link_order
;
751 boolean relocateable
;
754 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
755 asection
*input_section
= link_order
->u
.indirect
.section
;
756 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
757 arelent
**reloc_vector
= NULL
;
759 bfd
*output_bfd
= relocateable
? abfd
: (bfd
*) NULL
;
761 boolean gp_undefined
;
762 bfd_vma stack
[RELOC_STACKSIZE
];
767 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
768 if (reloc_vector
== NULL
&& reloc_size
!= 0)
771 if (! bfd_get_section_contents (input_bfd
, input_section
, data
,
772 (file_ptr
) 0, input_section
->_raw_size
))
775 /* The section size is not going to change. */
776 input_section
->_cooked_size
= input_section
->_raw_size
;
777 input_section
->reloc_done
= true;
779 reloc_count
= bfd_canonicalize_reloc (input_bfd
, input_section
,
780 reloc_vector
, symbols
);
783 if (reloc_count
== 0)
784 goto successful_return
;
786 /* Get the GP value for the output BFD. */
787 gp_undefined
= false;
788 if (ecoff_data (abfd
)->gp
== 0)
790 if (relocateable
!= false)
795 /* Make up a value. */
797 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
800 && (strcmp (sec
->name
, ".sbss") == 0
801 || strcmp (sec
->name
, ".sdata") == 0
802 || strcmp (sec
->name
, ".lit4") == 0
803 || strcmp (sec
->name
, ".lit8") == 0
804 || strcmp (sec
->name
, ".lita") == 0))
807 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
811 struct bfd_link_hash_entry
*h
;
813 h
= bfd_link_hash_lookup (link_info
->hash
, "_gp", false, false,
815 if (h
== (struct bfd_link_hash_entry
*) NULL
816 || h
->type
!= bfd_link_hash_defined
)
819 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
820 + h
->u
.def
.section
->output_section
->vma
821 + h
->u
.def
.section
->output_offset
);
824 gp
= ecoff_data (abfd
)->gp
;
826 for (; *reloc_vector
!= (arelent
*) NULL
; reloc_vector
++)
829 bfd_reloc_status_type r
;
834 switch (rel
->howto
->type
)
837 rel
->address
+= input_section
->output_offset
;
840 case ALPHA_R_REFLONG
:
841 case ALPHA_R_REFQUAD
:
848 && ((*rel
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
850 rel
->address
+= input_section
->output_offset
;
853 r
= bfd_perform_relocation (input_bfd
, rel
, data
, input_section
,
857 case ALPHA_R_GPREL32
:
858 /* This relocation is used in a switch table. It is a 32
859 bit offset from the current GP value. We must adjust it
860 by the different between the original GP value and the
861 current GP value. The original GP value is stored in the
862 addend. We adjust the addend and let
863 bfd_perform_relocation finish the job. */
865 r
= bfd_perform_relocation (input_bfd
, rel
, data
, input_section
,
867 if (r
== bfd_reloc_ok
&& gp_undefined
)
869 r
= bfd_reloc_dangerous
;
870 err
= (char *) "GP relative relocation used when GP not defined";
874 case ALPHA_R_LITERAL
:
875 /* This is a reference to a literal value, generally
876 (always?) in the .lita section. This is a 16 bit GP
877 relative relocation. Sometimes the subsequent reloc is a
878 LITUSE reloc, which indicates how this reloc is used.
879 This sometimes permits rewriting the two instructions
880 referred to by the LITERAL and the LITUSE into different
881 instructions which do not refer to .lita. This can save
882 a memory reference, and permits removing a value from
883 .lita thus saving GP relative space.
885 We do not these optimizations. To do them we would need
886 to arrange to link the .lita section first, so that by
887 the time we got here we would know the final values to
888 use. This would not be particularly difficult, but it is
889 not currently implemented. */
894 /* I believe that the LITERAL reloc will only apply to a
895 ldq or ldl instruction, so check my assumption. */
896 insn
= bfd_get_32 (input_bfd
, data
+ rel
->address
);
897 BFD_ASSERT (((insn
>> 26) & 0x3f) == 0x29
898 || ((insn
>> 26) & 0x3f) == 0x28);
901 r
= bfd_perform_relocation (input_bfd
, rel
, data
, input_section
,
903 if (r
== bfd_reloc_ok
&& gp_undefined
)
905 r
= bfd_reloc_dangerous
;
907 (char *) "GP relative relocation used when GP not defined";
913 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
914 does not cause anything to happen, itself. */
915 rel
->address
+= input_section
->output_offset
;
919 /* This marks the ldah of an ldah/lda pair which loads the
920 gp register with the difference of the gp value and the
921 current location. The second of the pair is r_size bytes
922 ahead; it used to be marked with an ALPHA_R_IGNORE reloc,
923 but that no longer happens in OSF/1 3.2. */
925 unsigned long insn1
, insn2
;
928 /* Get the two instructions. */
929 insn1
= bfd_get_32 (input_bfd
, data
+ rel
->address
);
930 insn2
= bfd_get_32 (input_bfd
, data
+ rel
->address
+ rel
->addend
);
932 BFD_ASSERT (((insn1
>> 26) & 0x3f) == 0x09); /* ldah */
933 BFD_ASSERT (((insn2
>> 26) & 0x3f) == 0x08); /* lda */
935 /* Get the existing addend. We must account for the sign
936 extension done by lda and ldah. */
937 addend
= ((insn1
& 0xffff) << 16) + (insn2
& 0xffff);
940 addend
-= 0x80000000;
941 addend
-= 0x80000000;
946 /* The existing addend includes the different between the
947 gp of the input BFD and the address in the input BFD.
948 Subtract this out. */
949 addend
-= (ecoff_data (input_bfd
)->gp
950 - (input_section
->vma
+ rel
->address
));
952 /* Now add in the final gp value, and subtract out the
955 - (input_section
->output_section
->vma
956 + input_section
->output_offset
959 /* Change the instructions, accounting for the sign
960 extension, and write them out. */
963 insn1
= (insn1
& 0xffff0000) | ((addend
>> 16) & 0xffff);
964 insn2
= (insn2
& 0xffff0000) | (addend
& 0xffff);
966 bfd_put_32 (input_bfd
, (bfd_vma
) insn1
, data
+ rel
->address
);
967 bfd_put_32 (input_bfd
, (bfd_vma
) insn2
,
968 data
+ rel
->address
+ rel
->addend
);
970 rel
->address
+= input_section
->output_offset
;
974 case ALPHA_R_OP_PUSH
:
975 /* Push a value on the reloc evaluation stack. */
982 rel
->address
+= input_section
->output_offset
;
986 /* Figure out the relocation of this symbol. */
987 symbol
= *rel
->sym_ptr_ptr
;
989 if (bfd_is_und_section (symbol
->section
))
990 r
= bfd_reloc_undefined
;
992 if (bfd_is_com_section (symbol
->section
))
995 relocation
= symbol
->value
;
996 relocation
+= symbol
->section
->output_section
->vma
;
997 relocation
+= symbol
->section
->output_offset
;
998 relocation
+= rel
->addend
;
1000 if (tos
>= RELOC_STACKSIZE
)
1003 stack
[tos
++] = relocation
;
1007 case ALPHA_R_OP_STORE
:
1008 /* Store a value from the reloc stack into a bitfield. */
1015 rel
->address
+= input_section
->output_offset
;
1022 /* The offset and size for this reloc are encoded into the
1023 addend field by alpha_adjust_reloc_in. */
1024 offset
= (rel
->addend
>> 8) & 0xff;
1025 size
= rel
->addend
& 0xff;
1027 val
= bfd_get_64 (abfd
, data
+ rel
->address
);
1028 val
&=~ (((1 << size
) - 1) << offset
);
1029 val
|= (stack
[--tos
] & ((1 << size
) - 1)) << offset
;
1030 bfd_put_64 (abfd
, val
, data
+ rel
->address
);
1034 case ALPHA_R_OP_PSUB
:
1035 /* Subtract a value from the top of the stack. */
1042 rel
->address
+= input_section
->output_offset
;
1046 /* Figure out the relocation of this symbol. */
1047 symbol
= *rel
->sym_ptr_ptr
;
1049 if (bfd_is_und_section (symbol
->section
))
1050 r
= bfd_reloc_undefined
;
1052 if (bfd_is_com_section (symbol
->section
))
1055 relocation
= symbol
->value
;
1056 relocation
+= symbol
->section
->output_section
->vma
;
1057 relocation
+= symbol
->section
->output_offset
;
1058 relocation
+= rel
->addend
;
1063 stack
[tos
- 1] -= relocation
;
1067 case ALPHA_R_OP_PRSHIFT
:
1068 /* Shift the value on the top of the stack. */
1075 rel
->address
+= input_section
->output_offset
;
1079 /* Figure out the relocation of this symbol. */
1080 symbol
= *rel
->sym_ptr_ptr
;
1082 if (bfd_is_und_section (symbol
->section
))
1083 r
= bfd_reloc_undefined
;
1085 if (bfd_is_com_section (symbol
->section
))
1088 relocation
= symbol
->value
;
1089 relocation
+= symbol
->section
->output_section
->vma
;
1090 relocation
+= symbol
->section
->output_offset
;
1091 relocation
+= rel
->addend
;
1096 stack
[tos
- 1] >>= relocation
;
1100 case ALPHA_R_GPVALUE
:
1101 /* I really don't know if this does the right thing. */
1103 gp_undefined
= false;
1112 asection
*os
= input_section
->output_section
;
1114 /* A partial link, so keep the relocs. */
1115 os
->orelocation
[os
->reloc_count
] = rel
;
1119 if (r
!= bfd_reloc_ok
)
1123 case bfd_reloc_undefined
:
1124 if (! ((*link_info
->callbacks
->undefined_symbol
)
1125 (link_info
, bfd_asymbol_name (*rel
->sym_ptr_ptr
),
1126 input_bfd
, input_section
, rel
->address
)))
1129 case bfd_reloc_dangerous
:
1130 if (! ((*link_info
->callbacks
->reloc_dangerous
)
1131 (link_info
, err
, input_bfd
, input_section
,
1135 case bfd_reloc_overflow
:
1136 if (! ((*link_info
->callbacks
->reloc_overflow
)
1137 (link_info
, bfd_asymbol_name (*rel
->sym_ptr_ptr
),
1138 rel
->howto
->name
, rel
->addend
, input_bfd
,
1139 input_section
, rel
->address
)))
1142 case bfd_reloc_outofrange
:
1154 if (reloc_vector
!= NULL
)
1155 free (reloc_vector
);
1159 if (reloc_vector
!= NULL
)
1160 free (reloc_vector
);
1164 /* Get the howto structure for a generic reloc type. */
1166 static reloc_howto_type
*
1167 alpha_bfd_reloc_type_lookup (abfd
, code
)
1169 bfd_reloc_code_real_type code
;
1176 alpha_type
= ALPHA_R_REFLONG
;
1179 case BFD_RELOC_CTOR
:
1180 alpha_type
= ALPHA_R_REFQUAD
;
1182 case BFD_RELOC_GPREL32
:
1183 alpha_type
= ALPHA_R_GPREL32
;
1185 case BFD_RELOC_ALPHA_LITERAL
:
1186 alpha_type
= ALPHA_R_LITERAL
;
1188 case BFD_RELOC_ALPHA_LITUSE
:
1189 alpha_type
= ALPHA_R_LITUSE
;
1191 case BFD_RELOC_ALPHA_GPDISP_HI16
:
1192 alpha_type
= ALPHA_R_GPDISP
;
1194 case BFD_RELOC_ALPHA_GPDISP_LO16
:
1195 alpha_type
= ALPHA_R_IGNORE
;
1197 case BFD_RELOC_23_PCREL_S2
:
1198 alpha_type
= ALPHA_R_BRADDR
;
1200 case BFD_RELOC_ALPHA_HINT
:
1201 alpha_type
= ALPHA_R_HINT
;
1203 case BFD_RELOC_16_PCREL
:
1204 alpha_type
= ALPHA_R_SREL16
;
1206 case BFD_RELOC_32_PCREL
:
1207 alpha_type
= ALPHA_R_SREL32
;
1209 case BFD_RELOC_64_PCREL
:
1210 alpha_type
= ALPHA_R_SREL64
;
1214 alpha_type
= ALPHA_R_OP_PUSH
;
1217 alpha_type
= ALPHA_R_OP_STORE
;
1220 alpha_type
= ALPHA_R_OP_PSUB
;
1223 alpha_type
= ALPHA_R_OP_PRSHIFT
;
1226 alpha_type
= ALPHA_R_GPVALUE
;
1230 return (reloc_howto_type
*) NULL
;
1233 return &alpha_howto_table
[alpha_type
];
1236 /* A helper routine for alpha_relocate_section which converts an
1237 external reloc when generating relocateable output. Returns the
1238 relocation amount. */
1241 alpha_convert_external_reloc (output_bfd
, info
, input_bfd
, ext_rel
, h
)
1243 struct bfd_link_info
*info
;
1245 struct external_reloc
*ext_rel
;
1246 struct ecoff_link_hash_entry
*h
;
1248 unsigned long r_symndx
;
1251 BFD_ASSERT (info
->relocateable
);
1253 if (h
->root
.type
== bfd_link_hash_defined
1254 || h
->root
.type
== bfd_link_hash_defweak
)
1259 /* This symbol is defined in the output. Convert the reloc from
1260 being against the symbol to being against the section. */
1262 /* Clear the r_extern bit. */
1263 ext_rel
->r_bits
[1] &=~ RELOC_BITS1_EXTERN_LITTLE
;
1265 /* Compute a new r_symndx value. */
1266 hsec
= h
->root
.u
.def
.section
;
1267 name
= bfd_get_section_name (output_bfd
, hsec
->output_section
);
1273 if (strcmp (name
, "*ABS*") == 0)
1274 r_symndx
= RELOC_SECTION_ABS
;
1277 if (strcmp (name
, ".bss") == 0)
1278 r_symndx
= RELOC_SECTION_BSS
;
1281 if (strcmp (name
, ".data") == 0)
1282 r_symndx
= RELOC_SECTION_DATA
;
1285 if (strcmp (name
, ".fini") == 0)
1286 r_symndx
= RELOC_SECTION_FINI
;
1289 if (strcmp (name
, ".init") == 0)
1290 r_symndx
= RELOC_SECTION_INIT
;
1293 if (strcmp (name
, ".lita") == 0)
1294 r_symndx
= RELOC_SECTION_LITA
;
1295 else if (strcmp (name
, ".lit8") == 0)
1296 r_symndx
= RELOC_SECTION_LIT8
;
1297 else if (strcmp (name
, ".lit4") == 0)
1298 r_symndx
= RELOC_SECTION_LIT4
;
1301 if (strcmp (name
, ".pdata") == 0)
1302 r_symndx
= RELOC_SECTION_PDATA
;
1305 if (strcmp (name
, ".rdata") == 0)
1306 r_symndx
= RELOC_SECTION_RDATA
;
1307 else if (strcmp (name
, ".rconst") == 0)
1308 r_symndx
= RELOC_SECTION_RCONST
;
1311 if (strcmp (name
, ".sdata") == 0)
1312 r_symndx
= RELOC_SECTION_SDATA
;
1313 else if (strcmp (name
, ".sbss") == 0)
1314 r_symndx
= RELOC_SECTION_SBSS
;
1317 if (strcmp (name
, ".text") == 0)
1318 r_symndx
= RELOC_SECTION_TEXT
;
1321 if (strcmp (name
, ".xdata") == 0)
1322 r_symndx
= RELOC_SECTION_XDATA
;
1329 /* Add the section VMA and the symbol value. */
1330 relocation
= (h
->root
.u
.def
.value
1331 + hsec
->output_section
->vma
1332 + hsec
->output_offset
);
1336 /* Change the symndx value to the right one for
1341 /* Caller must give an error. */
1347 /* Write out the new r_symndx value. */
1348 bfd_h_put_32 (input_bfd
, (bfd_vma
) r_symndx
,
1349 (bfd_byte
*) ext_rel
->r_symndx
);
1354 /* Relocate a section while linking an Alpha ECOFF file. This is
1355 quite similar to get_relocated_section_contents. Perhaps they
1356 could be combined somehow. */
1359 alpha_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1360 contents
, external_relocs
)
1362 struct bfd_link_info
*info
;
1364 asection
*input_section
;
1366 PTR external_relocs
;
1368 asection
**symndx_to_section
, *lita_sec
;
1369 struct ecoff_link_hash_entry
**sym_hashes
;
1371 boolean gp_undefined
;
1372 bfd_vma stack
[RELOC_STACKSIZE
];
1374 struct external_reloc
*ext_rel
;
1375 struct external_reloc
*ext_rel_end
;
1377 /* We keep a table mapping the symndx found in an internal reloc to
1378 the appropriate section. This is faster than looking up the
1379 section by name each time. */
1380 symndx_to_section
= ecoff_data (input_bfd
)->symndx_to_section
;
1381 if (symndx_to_section
== (asection
**) NULL
)
1383 symndx_to_section
= ((asection
**)
1384 bfd_alloc (input_bfd
,
1386 * sizeof (asection
*))));
1387 if (!symndx_to_section
)
1390 symndx_to_section
[RELOC_SECTION_NONE
] = NULL
;
1391 symndx_to_section
[RELOC_SECTION_TEXT
] =
1392 bfd_get_section_by_name (input_bfd
, ".text");
1393 symndx_to_section
[RELOC_SECTION_RDATA
] =
1394 bfd_get_section_by_name (input_bfd
, ".rdata");
1395 symndx_to_section
[RELOC_SECTION_DATA
] =
1396 bfd_get_section_by_name (input_bfd
, ".data");
1397 symndx_to_section
[RELOC_SECTION_SDATA
] =
1398 bfd_get_section_by_name (input_bfd
, ".sdata");
1399 symndx_to_section
[RELOC_SECTION_SBSS
] =
1400 bfd_get_section_by_name (input_bfd
, ".sbss");
1401 symndx_to_section
[RELOC_SECTION_BSS
] =
1402 bfd_get_section_by_name (input_bfd
, ".bss");
1403 symndx_to_section
[RELOC_SECTION_INIT
] =
1404 bfd_get_section_by_name (input_bfd
, ".init");
1405 symndx_to_section
[RELOC_SECTION_LIT8
] =
1406 bfd_get_section_by_name (input_bfd
, ".lit8");
1407 symndx_to_section
[RELOC_SECTION_LIT4
] =
1408 bfd_get_section_by_name (input_bfd
, ".lit4");
1409 symndx_to_section
[RELOC_SECTION_XDATA
] =
1410 bfd_get_section_by_name (input_bfd
, ".xdata");
1411 symndx_to_section
[RELOC_SECTION_PDATA
] =
1412 bfd_get_section_by_name (input_bfd
, ".pdata");
1413 symndx_to_section
[RELOC_SECTION_FINI
] =
1414 bfd_get_section_by_name (input_bfd
, ".fini");
1415 symndx_to_section
[RELOC_SECTION_LITA
] =
1416 bfd_get_section_by_name (input_bfd
, ".lita");
1417 symndx_to_section
[RELOC_SECTION_ABS
] = bfd_abs_section_ptr
;
1418 symndx_to_section
[RELOC_SECTION_RCONST
] =
1419 bfd_get_section_by_name (input_bfd
, ".rconst");
1421 ecoff_data (input_bfd
)->symndx_to_section
= symndx_to_section
;
1424 sym_hashes
= ecoff_data (input_bfd
)->sym_hashes
;
1426 /* On the Alpha, the .lita section must be addressable by the global
1427 pointer. To support large programs, we need to allow multiple
1428 global pointers. This works as long as each input .lita section
1429 is <64KB big. This implies that when producing relocatable
1430 output, the .lita section is limited to 64KB. . */
1432 lita_sec
= symndx_to_section
[RELOC_SECTION_LITA
];
1433 gp
= ecoff_data (output_bfd
)->gp
;
1434 if (! info
->relocateable
&& lita_sec
!= NULL
)
1436 struct ecoff_section_tdata
*lita_sec_data
;
1438 /* Make sure we have a section data structure to which we can
1439 hang on to the gp value we pick for the section. */
1440 lita_sec_data
= ecoff_section_data (input_bfd
, lita_sec
);
1441 if (lita_sec_data
== NULL
)
1443 lita_sec_data
= ((struct ecoff_section_tdata
*)
1444 bfd_zalloc (input_bfd
,
1445 sizeof (struct ecoff_section_tdata
)));
1446 ecoff_section_data (input_bfd
, lita_sec
) = lita_sec_data
;
1449 if (lita_sec_data
->gp
!= 0)
1451 /* If we already assigned a gp to this section, we better
1452 stick with that value. */
1453 gp
= lita_sec_data
->gp
;
1458 bfd_size_type lita_size
;
1460 lita_vma
= lita_sec
->output_offset
+ lita_sec
->output_section
->vma
;
1461 lita_size
= lita_sec
->_cooked_size
;
1463 lita_size
= lita_sec
->_raw_size
;
1466 || lita_vma
< gp
- 0x8000
1467 || lita_vma
+ lita_size
>= gp
+ 0x8000)
1469 /* Either gp hasn't been set at all or the current gp
1470 cannot address this .lita section. In both cases we
1471 reset the gp to point into the "middle" of the
1472 current input .lita section. For now, we issue a
1473 warning when redefining the gp value (probably should
1474 be made optional). */
1475 if (gp
&& !ecoff_data (output_bfd
)->issued_multiple_gp_warning
)
1477 (*_bfd_error_handler
)
1478 ("%s: warning: using multiple gp values",
1479 bfd_get_filename (output_bfd
));
1480 ecoff_data (output_bfd
)->issued_multiple_gp_warning
= true;
1482 if (lita_vma
< gp
- 0x8000)
1483 gp
= lita_vma
+ lita_size
- 0x8000;
1485 gp
= lita_vma
+ 0x8000;
1489 lita_sec_data
->gp
= gp
;
1492 ecoff_data (output_bfd
)->gp
= gp
;
1495 gp_undefined
= (gp
== 0);
1497 BFD_ASSERT (bfd_header_little_endian (output_bfd
));
1498 BFD_ASSERT (bfd_header_little_endian (input_bfd
));
1500 ext_rel
= (struct external_reloc
*) external_relocs
;
1501 ext_rel_end
= ext_rel
+ input_section
->reloc_count
;
1502 for (; ext_rel
< ext_rel_end
; ext_rel
++)
1505 unsigned long r_symndx
;
1511 boolean adjust_addrp
;
1515 r_vaddr
= bfd_h_get_64 (input_bfd
, (bfd_byte
*) ext_rel
->r_vaddr
);
1516 r_symndx
= bfd_h_get_32 (input_bfd
, (bfd_byte
*) ext_rel
->r_symndx
);
1518 r_type
= ((ext_rel
->r_bits
[0] & RELOC_BITS0_TYPE_LITTLE
)
1519 >> RELOC_BITS0_TYPE_SH_LITTLE
);
1520 r_extern
= (ext_rel
->r_bits
[1] & RELOC_BITS1_EXTERN_LITTLE
) != 0;
1521 r_offset
= ((ext_rel
->r_bits
[1] & RELOC_BITS1_OFFSET_LITTLE
)
1522 >> RELOC_BITS1_OFFSET_SH_LITTLE
);
1523 /* Ignored the reserved bits. */
1524 r_size
= ((ext_rel
->r_bits
[3] & RELOC_BITS3_SIZE_LITTLE
)
1525 >> RELOC_BITS3_SIZE_SH_LITTLE
);
1528 adjust_addrp
= true;
1537 case ALPHA_R_IGNORE
:
1538 /* This reloc appears after a GPDISP reloc. On earlier
1539 versions of OSF/1, It marked the position of the second
1540 instruction to be altered by the GPDISP reloc, but it is
1541 not otherwise used for anything. For some reason, the
1542 address of the relocation does not appear to include the
1543 section VMA, unlike the other relocation types. */
1544 if (info
->relocateable
)
1545 bfd_h_put_64 (input_bfd
,
1546 input_section
->output_offset
+ r_vaddr
,
1547 (bfd_byte
*) ext_rel
->r_vaddr
);
1548 adjust_addrp
= false;
1551 case ALPHA_R_REFLONG
:
1552 case ALPHA_R_REFQUAD
:
1553 case ALPHA_R_BRADDR
:
1555 case ALPHA_R_SREL16
:
1556 case ALPHA_R_SREL32
:
1557 case ALPHA_R_SREL64
:
1561 case ALPHA_R_GPREL32
:
1562 /* This relocation is used in a switch table. It is a 32
1563 bit offset from the current GP value. We must adjust it
1564 by the different between the original GP value and the
1565 current GP value. */
1567 addend
= ecoff_data (input_bfd
)->gp
- gp
;
1571 case ALPHA_R_LITERAL
:
1572 /* This is a reference to a literal value, generally
1573 (always?) in the .lita section. This is a 16 bit GP
1574 relative relocation. Sometimes the subsequent reloc is a
1575 LITUSE reloc, which indicates how this reloc is used.
1576 This sometimes permits rewriting the two instructions
1577 referred to by the LITERAL and the LITUSE into different
1578 instructions which do not refer to .lita. This can save
1579 a memory reference, and permits removing a value from
1580 .lita thus saving GP relative space.
1582 We do not these optimizations. To do them we would need
1583 to arrange to link the .lita section first, so that by
1584 the time we got here we would know the final values to
1585 use. This would not be particularly difficult, but it is
1586 not currently implemented. */
1588 /* I believe that the LITERAL reloc will only apply to a ldq
1589 or ldl instruction, so check my assumption. */
1593 insn
= bfd_get_32 (input_bfd
,
1594 contents
+ r_vaddr
- input_section
->vma
);
1595 BFD_ASSERT (((insn
>> 26) & 0x3f) == 0x29
1596 || ((insn
>> 26) & 0x3f) == 0x28);
1600 addend
= ecoff_data (input_bfd
)->gp
- gp
;
1604 case ALPHA_R_LITUSE
:
1605 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
1606 does not cause anything to happen, itself. */
1609 case ALPHA_R_GPDISP
:
1610 /* This marks the ldah of an ldah/lda pair which loads the
1611 gp register with the difference of the gp value and the
1612 current location. The second of the pair is r_symndx
1613 bytes ahead. It used to be marked with an ALPHA_R_IGNORE
1614 reloc, but OSF/1 3.2 no longer does that. */
1616 unsigned long insn1
, insn2
;
1618 /* Get the two instructions. */
1619 insn1
= bfd_get_32 (input_bfd
,
1620 contents
+ r_vaddr
- input_section
->vma
);
1621 insn2
= bfd_get_32 (input_bfd
,
1624 - input_section
->vma
1627 BFD_ASSERT (((insn1
>> 26) & 0x3f) == 0x09); /* ldah */
1628 BFD_ASSERT (((insn2
>> 26) & 0x3f) == 0x08); /* lda */
1630 /* Get the existing addend. We must account for the sign
1631 extension done by lda and ldah. */
1632 addend
= ((insn1
& 0xffff) << 16) + (insn2
& 0xffff);
1635 /* This is addend -= 0x100000000 without causing an
1636 integer overflow on a 32 bit host. */
1637 addend
-= 0x80000000;
1638 addend
-= 0x80000000;
1643 /* The existing addend includes the difference between the
1644 gp of the input BFD and the address in the input BFD.
1645 We want to change this to the difference between the
1646 final GP and the final address. */
1648 - ecoff_data (input_bfd
)->gp
1649 + input_section
->vma
1650 - (input_section
->output_section
->vma
1651 + input_section
->output_offset
));
1653 /* Change the instructions, accounting for the sign
1654 extension, and write them out. */
1655 if (addend
& 0x8000)
1657 insn1
= (insn1
& 0xffff0000) | ((addend
>> 16) & 0xffff);
1658 insn2
= (insn2
& 0xffff0000) | (addend
& 0xffff);
1660 bfd_put_32 (input_bfd
, (bfd_vma
) insn1
,
1661 contents
+ r_vaddr
- input_section
->vma
);
1662 bfd_put_32 (input_bfd
, (bfd_vma
) insn2
,
1663 contents
+ r_vaddr
- input_section
->vma
+ r_symndx
);
1669 case ALPHA_R_OP_PUSH
:
1670 case ALPHA_R_OP_PSUB
:
1671 case ALPHA_R_OP_PRSHIFT
:
1672 /* Manipulate values on the reloc evaluation stack. The
1673 r_vaddr field is not an address in input_section, it is
1674 the current value (including any addend) of the object
1680 s
= symndx_to_section
[r_symndx
];
1681 if (s
== (asection
*) NULL
)
1683 addend
= s
->output_section
->vma
+ s
->output_offset
- s
->vma
;
1687 struct ecoff_link_hash_entry
*h
;
1689 h
= sym_hashes
[r_symndx
];
1690 if (h
== (struct ecoff_link_hash_entry
*) NULL
)
1693 if (! info
->relocateable
)
1695 if (h
->root
.type
== bfd_link_hash_defined
1696 || h
->root
.type
== bfd_link_hash_defweak
)
1697 addend
= (h
->root
.u
.def
.value
1698 + h
->root
.u
.def
.section
->output_section
->vma
1699 + h
->root
.u
.def
.section
->output_offset
);
1702 /* Note that we pass the address as 0, since we
1703 do not have a meaningful number for the
1704 location within the section that is being
1706 if (! ((*info
->callbacks
->undefined_symbol
)
1707 (info
, h
->root
.root
.string
, input_bfd
,
1708 input_section
, (bfd_vma
) 0)))
1715 if (h
->root
.type
!= bfd_link_hash_defined
1716 && h
->root
.type
!= bfd_link_hash_defweak
1719 /* This symbol is not being written out. Pass
1720 the address as 0, as with undefined_symbol,
1722 if (! ((*info
->callbacks
->unattached_reloc
)
1723 (info
, h
->root
.root
.string
, input_bfd
,
1724 input_section
, (bfd_vma
) 0)))
1728 addend
= alpha_convert_external_reloc (output_bfd
, info
,
1736 if (info
->relocateable
)
1738 /* Adjust r_vaddr by the addend. */
1739 bfd_h_put_64 (input_bfd
, addend
,
1740 (bfd_byte
*) ext_rel
->r_vaddr
);
1746 case ALPHA_R_OP_PUSH
:
1747 if (tos
>= RELOC_STACKSIZE
)
1749 stack
[tos
++] = addend
;
1752 case ALPHA_R_OP_PSUB
:
1755 stack
[tos
- 1] -= addend
;
1758 case ALPHA_R_OP_PRSHIFT
:
1761 stack
[tos
- 1] >>= addend
;
1766 adjust_addrp
= false;
1769 case ALPHA_R_OP_STORE
:
1770 /* Store a value from the reloc stack into a bitfield. If
1771 we are generating relocateable output, all we do is
1772 adjust the address of the reloc. */
1773 if (! info
->relocateable
)
1781 /* Get the relocation mask. The separate steps and the
1782 casts to bfd_vma are attempts to avoid a bug in the
1783 Alpha OSF 1.3 C compiler. See reloc.c for more
1786 mask
<<= (bfd_vma
) r_size
;
1789 /* FIXME: I don't know what kind of overflow checking,
1790 if any, should be done here. */
1791 val
= bfd_get_64 (input_bfd
,
1792 contents
+ r_vaddr
- input_section
->vma
);
1793 val
&=~ mask
<< (bfd_vma
) r_offset
;
1794 val
|= (stack
[--tos
] & mask
) << (bfd_vma
) r_offset
;
1795 bfd_put_64 (input_bfd
, val
,
1796 contents
+ r_vaddr
- input_section
->vma
);
1800 case ALPHA_R_GPVALUE
:
1801 /* I really don't know if this does the right thing. */
1802 gp
= ecoff_data (input_bfd
)->gp
+ r_symndx
;
1803 gp_undefined
= false;
1809 reloc_howto_type
*howto
;
1810 struct ecoff_link_hash_entry
*h
= NULL
;
1813 bfd_reloc_status_type r
;
1815 /* Perform a relocation. */
1817 howto
= &alpha_howto_table
[r_type
];
1821 h
= sym_hashes
[r_symndx
];
1822 /* If h is NULL, that means that there is a reloc
1823 against an external symbol which we thought was just
1824 a debugging symbol. This should not happen. */
1825 if (h
== (struct ecoff_link_hash_entry
*) NULL
)
1830 if (r_symndx
>= NUM_RELOC_SECTIONS
)
1833 s
= symndx_to_section
[r_symndx
];
1835 if (s
== (asection
*) NULL
)
1839 if (info
->relocateable
)
1841 /* We are generating relocateable output, and must
1842 convert the existing reloc. */
1845 if (h
->root
.type
!= bfd_link_hash_defined
1846 && h
->root
.type
!= bfd_link_hash_defweak
1849 /* This symbol is not being written out. */
1850 if (! ((*info
->callbacks
->unattached_reloc
)
1851 (info
, h
->root
.root
.string
, input_bfd
,
1852 input_section
, r_vaddr
- input_section
->vma
)))
1856 relocation
= alpha_convert_external_reloc (output_bfd
,
1864 /* This is a relocation against a section. Adjust
1865 the value by the amount the section moved. */
1866 relocation
= (s
->output_section
->vma
1871 /* If this is PC relative, the existing object file
1872 appears to already have the reloc worked out. We
1873 must subtract out the old value and add in the new
1875 if (howto
->pc_relative
)
1876 relocation
-= (input_section
->output_section
->vma
1877 + input_section
->output_offset
1878 - input_section
->vma
);
1880 /* Put in any addend. */
1881 relocation
+= addend
;
1883 /* Adjust the contents. */
1884 r
= _bfd_relocate_contents (howto
, input_bfd
, relocation
,
1887 - input_section
->vma
));
1891 /* We are producing a final executable. */
1894 /* This is a reloc against a symbol. */
1895 if (h
->root
.type
== bfd_link_hash_defined
1896 || h
->root
.type
== bfd_link_hash_defweak
)
1900 hsec
= h
->root
.u
.def
.section
;
1901 relocation
= (h
->root
.u
.def
.value
1902 + hsec
->output_section
->vma
1903 + hsec
->output_offset
);
1907 if (! ((*info
->callbacks
->undefined_symbol
)
1908 (info
, h
->root
.root
.string
, input_bfd
,
1910 r_vaddr
- input_section
->vma
)))
1917 /* This is a reloc against a section. */
1918 relocation
= (s
->output_section
->vma
1922 /* Adjust a PC relative relocation by removing the
1923 reference to the original source section. */
1924 if (howto
->pc_relative
)
1925 relocation
+= input_section
->vma
;
1928 r
= _bfd_final_link_relocate (howto
,
1932 r_vaddr
- input_section
->vma
,
1937 if (r
!= bfd_reloc_ok
)
1942 case bfd_reloc_outofrange
:
1944 case bfd_reloc_overflow
:
1949 name
= sym_hashes
[r_symndx
]->root
.root
.string
;
1951 name
= bfd_section_name (input_bfd
,
1952 symndx_to_section
[r_symndx
]);
1953 if (! ((*info
->callbacks
->reloc_overflow
)
1954 (info
, name
, alpha_howto_table
[r_type
].name
,
1955 (bfd_vma
) 0, input_bfd
, input_section
,
1956 r_vaddr
- input_section
->vma
)))
1964 if (info
->relocateable
&& adjust_addrp
)
1966 /* Change the address of the relocation. */
1967 bfd_h_put_64 (input_bfd
,
1968 (input_section
->output_section
->vma
1969 + input_section
->output_offset
1970 - input_section
->vma
1972 (bfd_byte
*) ext_rel
->r_vaddr
);
1975 if (gp_usedp
&& gp_undefined
)
1977 if (! ((*info
->callbacks
->reloc_dangerous
)
1978 (info
, "GP relative relocation when GP not defined",
1979 input_bfd
, input_section
, r_vaddr
- input_section
->vma
)))
1981 /* Only give the error once per link. */
1982 ecoff_data (output_bfd
)->gp
= gp
= 4;
1983 gp_undefined
= false;
1993 /* Do final adjustments to the filehdr and the aouthdr. This routine
1994 sets the dynamic bits in the file header. */
1998 alpha_adjust_headers (abfd
, fhdr
, ahdr
)
2000 struct internal_filehdr
*fhdr
;
2001 struct internal_aouthdr
*ahdr
;
2003 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == (DYNAMIC
| EXEC_P
))
2004 fhdr
->f_flags
|= F_ALPHA_CALL_SHARED
;
2005 else if ((abfd
->flags
& DYNAMIC
) != 0)
2006 fhdr
->f_flags
|= F_ALPHA_SHARABLE
;
2010 /* Archive handling. In OSF/1 (or Digital Unix) v3.2, Digital
2011 introduced archive packing, in which the elements in an archive are
2012 optionally compressed using a simple dictionary scheme. We know
2013 how to read such archives, but we don't write them. */
2015 #define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap
2016 #define alpha_ecoff_slurp_extended_name_table \
2017 _bfd_ecoff_slurp_extended_name_table
2018 #define alpha_ecoff_construct_extended_name_table \
2019 _bfd_ecoff_construct_extended_name_table
2020 #define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname
2021 #define alpha_ecoff_write_armap _bfd_ecoff_write_armap
2022 #define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt
2023 #define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp
2025 /* A compressed file uses this instead of ARFMAG. */
2027 #define ARFZMAG "Z\012"
2029 /* Read an archive header. This is like the standard routine, but it
2030 also accepts ARFZMAG. */
2033 alpha_ecoff_read_ar_hdr (abfd
)
2036 struct areltdata
*ret
;
2039 ret
= (struct areltdata
*) _bfd_generic_read_ar_hdr_mag (abfd
, ARFZMAG
);
2043 h
= (struct ar_hdr
*) ret
->arch_header
;
2044 if (strncmp (h
->ar_fmag
, ARFZMAG
, 2) == 0)
2048 /* This is a compressed file. We must set the size correctly.
2049 The size is the eight bytes after the dummy file header. */
2050 if (bfd_seek (abfd
, FILHSZ
, SEEK_CUR
) != 0
2051 || bfd_read (ab
, 1, 8, abfd
) != 8
2052 || bfd_seek (abfd
, - (FILHSZ
+ 8), SEEK_CUR
) != 0)
2055 ret
->parsed_size
= bfd_h_get_64 (abfd
, ab
);
2061 /* Get an archive element at a specified file position. This is where
2062 we uncompress the archive element if necessary. */
2065 alpha_ecoff_get_elt_at_filepos (archive
, filepos
)
2070 struct areltdata
*tdata
;
2075 struct bfd_in_memory
*bim
;
2077 nbfd
= _bfd_get_elt_at_filepos (archive
, filepos
);
2081 if ((nbfd
->flags
& BFD_IN_MEMORY
) != 0)
2083 /* We have already expanded this BFD. */
2087 tdata
= (struct areltdata
*) nbfd
->arelt_data
;
2088 hdr
= (struct ar_hdr
*) tdata
->arch_header
;
2089 if (strncmp (hdr
->ar_fmag
, ARFZMAG
, 2) != 0)
2092 /* We must uncompress this element. We do this by copying it into a
2093 memory buffer, and making bfd_read and bfd_seek use that buffer.
2094 This can use a lot of memory, but it's simpler than getting a
2095 temporary file, making that work with the file descriptor caching
2096 code, and making sure that it is deleted at all appropriate
2097 times. It can be changed if it ever becomes important. */
2099 /* The compressed file starts with a dummy ECOFF file header. */
2100 if (bfd_seek (nbfd
, FILHSZ
, SEEK_SET
) != 0)
2103 /* The next eight bytes are the real file size. */
2104 if (bfd_read (ab
, 1, 8, nbfd
) != 8)
2106 size
= bfd_h_get_64 (nbfd
, ab
);
2113 bfd_byte dict
[4096];
2117 buf
= (bfd_byte
*) bfd_alloc (nbfd
, size
);
2124 /* I don't know what the next eight bytes are for. */
2125 if (bfd_read (ab
, 1, 8, nbfd
) != 8)
2128 /* This is the uncompression algorithm. It's a simple
2129 dictionary based scheme in which each character is predicted
2130 by a hash of the previous three characters. A control byte
2131 indicates whether the character is predicted or whether it
2132 appears in the input stream; each control byte manages the
2133 next eight bytes in the output stream. */
2134 memset (dict
, 0, sizeof dict
);
2136 while (bfd_read (&b
, 1, 1, nbfd
) == 1)
2140 for (i
= 0; i
< 8; i
++, b
>>= 1)
2148 if (! bfd_read (&n
, 1, 1, nbfd
))
2161 h
&= sizeof dict
- 1;
2169 /* Now the uncompressed file contents are in buf. */
2170 bim
= ((struct bfd_in_memory
*)
2171 bfd_alloc (nbfd
, sizeof (struct bfd_in_memory
)));
2177 nbfd
->mtime_set
= true;
2178 nbfd
->mtime
= strtol (hdr
->ar_date
, (char **) NULL
, 10);
2180 nbfd
->flags
|= BFD_IN_MEMORY
;
2181 nbfd
->iostream
= (PTR
) bim
;
2182 BFD_ASSERT (! nbfd
->cacheable
);
2192 /* Open the next archived file. */
2195 alpha_ecoff_openr_next_archived_file (archive
, last_file
)
2201 if (last_file
== NULL
)
2202 filestart
= bfd_ardata (archive
)->first_file_filepos
;
2205 struct areltdata
*t
;
2209 /* We can't use arelt_size here, because that uses parsed_size,
2210 which is the uncompressed size. We need the compressed size. */
2211 t
= (struct areltdata
*) last_file
->arelt_data
;
2212 h
= (struct ar_hdr
*) t
->arch_header
;
2213 size
= strtol (h
->ar_size
, (char **) NULL
, 10);
2215 /* Pad to an even boundary...
2216 Note that last_file->origin can be odd in the case of
2217 BSD-4.4-style element with a long odd size. */
2218 filestart
= last_file
->origin
+ size
;
2219 filestart
+= filestart
% 2;
2222 return alpha_ecoff_get_elt_at_filepos (archive
, filestart
);
2225 /* Open the archive file given an index into the armap. */
2228 alpha_ecoff_get_elt_at_index (abfd
, index
)
2234 entry
= bfd_ardata (abfd
)->symdefs
+ index
;
2235 return alpha_ecoff_get_elt_at_filepos (abfd
, entry
->file_offset
);
2238 /* This is the ECOFF backend structure. The backend field of the
2239 target vector points to this. */
2241 static const struct ecoff_backend_data alpha_ecoff_backend_data
=
2243 /* COFF backend structure. */
2245 (void (*) PARAMS ((bfd
*,PTR
,int,int,int,int,PTR
))) bfd_void
, /* aux_in */
2246 (void (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* sym_in */
2247 (void (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* lineno_in */
2248 (unsigned (*) PARAMS ((bfd
*,PTR
,int,int,int,int,PTR
)))bfd_void
,/*aux_out*/
2249 (unsigned (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* sym_out */
2250 (unsigned (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* lineno_out */
2251 (unsigned (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* reloc_out */
2252 alpha_ecoff_swap_filehdr_out
, alpha_ecoff_swap_aouthdr_out
,
2253 alpha_ecoff_swap_scnhdr_out
,
2254 FILHSZ
, AOUTSZ
, SCNHSZ
, 0, 0, 0, 0, true,
2255 alpha_ecoff_swap_filehdr_in
, alpha_ecoff_swap_aouthdr_in
,
2256 alpha_ecoff_swap_scnhdr_in
, NULL
,
2257 alpha_ecoff_bad_format_hook
, _bfd_ecoff_set_arch_mach_hook
,
2258 alpha_ecoff_mkobject_hook
, _bfd_ecoff_styp_to_sec_flags
,
2259 _bfd_ecoff_set_alignment_hook
, _bfd_ecoff_slurp_symbol_table
,
2260 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
2262 /* Supported architecture. */
2264 /* Initial portion of armap string. */
2266 /* The page boundary used to align sections in a demand-paged
2267 executable file. E.g., 0x1000. */
2269 /* True if the .rdata section is part of the text segment, as on the
2270 Alpha. False if .rdata is part of the data segment, as on the
2273 /* Bitsize of constructor entries. */
2275 /* Reloc to use for constructor entries. */
2276 &alpha_howto_table
[ALPHA_R_REFQUAD
],
2278 /* Symbol table magic number. */
2280 /* Alignment of debugging information. E.g., 4. */
2282 /* Sizes of external symbolic information. */
2283 sizeof (struct hdr_ext
),
2284 sizeof (struct dnr_ext
),
2285 sizeof (struct pdr_ext
),
2286 sizeof (struct sym_ext
),
2287 sizeof (struct opt_ext
),
2288 sizeof (struct fdr_ext
),
2289 sizeof (struct rfd_ext
),
2290 sizeof (struct ext_ext
),
2291 /* Functions to swap in external symbolic data. */
2300 _bfd_ecoff_swap_tir_in
,
2301 _bfd_ecoff_swap_rndx_in
,
2302 /* Functions to swap out external symbolic data. */
2311 _bfd_ecoff_swap_tir_out
,
2312 _bfd_ecoff_swap_rndx_out
,
2313 /* Function to read in symbolic data. */
2314 _bfd_ecoff_slurp_symbolic_info
2316 /* External reloc size. */
2318 /* Reloc swapping functions. */
2319 alpha_ecoff_swap_reloc_in
,
2320 alpha_ecoff_swap_reloc_out
,
2321 /* Backend reloc tweaking. */
2322 alpha_adjust_reloc_in
,
2323 alpha_adjust_reloc_out
,
2324 /* Relocate section contents while linking. */
2325 alpha_relocate_section
,
2326 /* Do final adjustments to filehdr and aouthdr. */
2327 alpha_adjust_headers
,
2328 /* Read an element from an archive at a given file position. */
2329 alpha_ecoff_get_elt_at_filepos
2332 /* Looking up a reloc type is Alpha specific. */
2333 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2335 /* So is getting relocated section contents. */
2336 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2337 alpha_ecoff_get_relocated_section_contents
2339 /* Handling file windows is generic. */
2340 #define _bfd_ecoff_get_section_contents_in_window \
2341 _bfd_generic_get_section_contents_in_window
2343 /* Relaxing sections is generic. */
2344 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2346 const bfd_target ecoffalpha_little_vec
=
2348 "ecoff-littlealpha", /* name */
2349 bfd_target_ecoff_flavour
,
2350 BFD_ENDIAN_LITTLE
, /* data byte order is little */
2351 BFD_ENDIAN_LITTLE
, /* header byte order is little */
2353 (HAS_RELOC
| EXEC_P
| /* object flags */
2354 HAS_LINENO
| HAS_DEBUG
|
2355 HAS_SYMS
| HAS_LOCALS
| DYNAMIC
| WP_TEXT
| D_PAGED
),
2357 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
| SEC_DATA
),
2358 0, /* leading underscore */
2359 ' ', /* ar_pad_char */
2360 15, /* ar_max_namelen */
2361 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2362 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2363 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* data */
2364 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2365 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2366 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* hdrs */
2368 {_bfd_dummy_target
, alpha_ecoff_object_p
, /* bfd_check_format */
2369 _bfd_ecoff_archive_p
, _bfd_dummy_target
},
2370 {bfd_false
, _bfd_ecoff_mkobject
, /* bfd_set_format */
2371 _bfd_generic_mkarchive
, bfd_false
},
2372 {bfd_false
, _bfd_ecoff_write_object_contents
, /* bfd_write_contents */
2373 _bfd_write_archive_contents
, bfd_false
},
2375 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff
),
2376 BFD_JUMP_TABLE_COPY (_bfd_ecoff
),
2377 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
2378 BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff
),
2379 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff
),
2380 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff
),
2381 BFD_JUMP_TABLE_WRITE (_bfd_ecoff
),
2382 BFD_JUMP_TABLE_LINK (_bfd_ecoff
),
2383 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
2385 (PTR
) &alpha_ecoff_backend_data