1 /* BFD back-end for ALPHA Extended-Coff files.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 == bfd_section_size (abfd, sec)
466 || size + 8 == bfd_section_size (abfd, sec));
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)
637 switch (intern->r_type)
643 /* This relocs appear to be fully resolved when they are against
644 internal symbols. Against external symbols, BRADDR at least
645 appears to be resolved against the next instruction. */
646 if (! intern->r_extern)
649 rptr->addend = - (intern->r_vaddr + 4);
652 case ALPHA_R_GPREL32:
653 case ALPHA_R_LITERAL:
654 /* Copy the gp value for this object file into the addend, to
655 ensure that we are not confused by the linker. */
656 if (! intern->r_extern)
657 rptr->addend += ecoff_data (abfd)->gp;
662 /* The LITUSE and GPDISP relocs do not use a symbol, or an
663 addend, but they do use a special code. Put this code in the
665 rptr->addend = intern->r_size;
668 case ALPHA_R_OP_STORE:
669 /* The STORE reloc needs the size and offset fields. We store
670 them in the addend. */
671 BFD_ASSERT (intern->r_offset <= 256 && intern->r_size <= 256);
672 rptr->addend = (intern->r_offset << 8) + intern->r_size;
675 case ALPHA_R_OP_PUSH:
676 case ALPHA_R_OP_PSUB:
677 case ALPHA_R_OP_PRSHIFT:
678 /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
679 address. I believe that the address supplied is really an
681 rptr->addend = intern->r_vaddr;
684 case ALPHA_R_GPVALUE:
685 /* Set the addend field to the new GP value. */
686 rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp;
690 /* If the type is ALPHA_R_IGNORE, make sure this is a reference
691 to the absolute section so that the reloc is ignored. For
692 some reason the address of this reloc type is not adjusted by
693 the section vma. We record the gp value for this object file
694 here, for convenience when doing the GPDISP relocation. */
695 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
696 rptr->address = intern->r_vaddr;
697 rptr->addend = ecoff_data (abfd)->gp;
704 rptr->howto = &alpha_howto_table[intern->r_type];
707 /* When writing out a reloc we need to pull some values back out of
708 the addend field into the reloc. This is roughly the reverse of
709 alpha_adjust_reloc_in, except that there are several changes we do
713 alpha_adjust_reloc_out (abfd, rel, intern)
714 bfd *abfd ATTRIBUTE_UNUSED;
716 struct internal_reloc *intern;
718 switch (intern->r_type)
722 intern->r_size = rel->addend;
725 case ALPHA_R_OP_STORE:
726 intern->r_size = rel->addend & 0xff;
727 intern->r_offset = (rel->addend >> 8) & 0xff;
730 case ALPHA_R_OP_PUSH:
731 case ALPHA_R_OP_PSUB:
732 case ALPHA_R_OP_PRSHIFT:
733 intern->r_vaddr = rel->addend;
737 intern->r_vaddr = rel->address;
745 /* The size of the stack for the relocation evaluator. */
746 #define RELOC_STACKSIZE (10)
748 /* Alpha ECOFF relocs have a built in expression evaluator as well as
749 other interdependencies. Rather than use a bunch of special
750 functions and global variables, we use a single routine to do all
751 the relocation for a section. I haven't yet worked out how the
752 assembler is going to handle this. */
755 alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order,
756 data, relocatable, symbols)
758 struct bfd_link_info *link_info;
759 struct bfd_link_order *link_order;
761 bfd_boolean relocatable;
764 bfd *input_bfd = link_order->u.indirect.section->owner;
765 asection *input_section = link_order->u.indirect.section;
766 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
767 arelent **reloc_vector = NULL;
769 bfd *output_bfd = relocatable ? abfd : (bfd *) NULL;
771 bfd_boolean gp_undefined;
772 bfd_vma stack[RELOC_STACKSIZE];
777 reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
778 if (reloc_vector == NULL && reloc_size != 0)
781 if (! bfd_get_section_contents (input_bfd, input_section, data,
782 (file_ptr) 0, input_section->_raw_size))
785 /* The section size is not going to change. */
786 input_section->_cooked_size = input_section->_raw_size;
788 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
789 reloc_vector, symbols);
792 if (reloc_count == 0)
793 goto successful_return;
795 /* Get the GP value for the output BFD. */
796 gp_undefined = FALSE;
797 gp = _bfd_get_gp_value (abfd);
805 /* Make up a value. */
807 for (sec = abfd->sections; sec != NULL; sec = sec->next)
810 && (strcmp (sec->name, ".sbss") == 0
811 || strcmp (sec->name, ".sdata") == 0
812 || strcmp (sec->name, ".lit4") == 0
813 || strcmp (sec->name, ".lit8") == 0
814 || strcmp (sec->name, ".lita") == 0))
818 _bfd_set_gp_value (abfd, gp);
822 struct bfd_link_hash_entry *h;
824 h = bfd_link_hash_lookup (link_info->hash, "_gp", FALSE, FALSE,
826 if (h == (struct bfd_link_hash_entry *) NULL
827 || h->type != bfd_link_hash_defined)
832 + h->u.def.section->output_section->vma
833 + h->u.def.section->output_offset);
834 _bfd_set_gp_value (abfd, gp);
839 for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
842 bfd_reloc_status_type r;
847 switch (rel->howto->type)
850 rel->address += input_section->output_offset;
853 case ALPHA_R_REFLONG:
854 case ALPHA_R_REFQUAD:
861 && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
863 rel->address += input_section->output_offset;
866 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
870 case ALPHA_R_GPREL32:
871 /* This relocation is used in a switch table. It is a 32
872 bit offset from the current GP value. We must adjust it
873 by the different between the original GP value and the
874 current GP value. The original GP value is stored in the
875 addend. We adjust the addend and let
876 bfd_perform_relocation finish the job. */
878 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
880 if (r == bfd_reloc_ok && gp_undefined)
882 r = bfd_reloc_dangerous;
883 err = (char *) _("GP relative relocation used when GP not defined");
887 case ALPHA_R_LITERAL:
888 /* This is a reference to a literal value, generally
889 (always?) in the .lita section. This is a 16 bit GP
890 relative relocation. Sometimes the subsequent reloc is a
891 LITUSE reloc, which indicates how this reloc is used.
892 This sometimes permits rewriting the two instructions
893 referred to by the LITERAL and the LITUSE into different
894 instructions which do not refer to .lita. This can save
895 a memory reference, and permits removing a value from
896 .lita thus saving GP relative space.
898 We do not these optimizations. To do them we would need
899 to arrange to link the .lita section first, so that by
900 the time we got here we would know the final values to
901 use. This would not be particularly difficult, but it is
902 not currently implemented. */
907 /* I believe that the LITERAL reloc will only apply to a
908 ldq or ldl instruction, so check my assumption. */
909 insn = bfd_get_32 (input_bfd, data + rel->address);
910 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
911 || ((insn >> 26) & 0x3f) == 0x28);
914 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
916 if (r == bfd_reloc_ok && gp_undefined)
918 r = bfd_reloc_dangerous;
920 (char *) _("GP relative relocation used when GP not defined");
926 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
927 does not cause anything to happen, itself. */
928 rel->address += input_section->output_offset;
932 /* This marks the ldah of an ldah/lda pair which loads the
933 gp register with the difference of the gp value and the
934 current location. The second of the pair is r_size bytes
935 ahead; it used to be marked with an ALPHA_R_IGNORE reloc,
936 but that no longer happens in OSF/1 3.2. */
938 unsigned long insn1, insn2;
941 /* Get the two instructions. */
942 insn1 = bfd_get_32 (input_bfd, data + rel->address);
943 insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend);
945 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
946 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
948 /* Get the existing addend. We must account for the sign
949 extension done by lda and ldah. */
950 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
953 addend -= 0x80000000;
954 addend -= 0x80000000;
959 /* The existing addend includes the different between the
960 gp of the input BFD and the address in the input BFD.
961 Subtract this out. */
962 addend -= (ecoff_data (input_bfd)->gp
963 - (input_section->vma + rel->address));
965 /* Now add in the final gp value, and subtract out the
968 - (input_section->output_section->vma
969 + input_section->output_offset
972 /* Change the instructions, accounting for the sign
973 extension, and write them out. */
976 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
977 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
979 bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address);
980 bfd_put_32 (input_bfd, (bfd_vma) insn2,
981 data + rel->address + rel->addend);
983 rel->address += input_section->output_offset;
987 case ALPHA_R_OP_PUSH:
988 /* Push a value on the reloc evaluation stack. */
995 rel->address += input_section->output_offset;
999 /* Figure out the relocation of this symbol. */
1000 symbol = *rel->sym_ptr_ptr;
1002 if (bfd_is_und_section (symbol->section))
1003 r = bfd_reloc_undefined;
1005 if (bfd_is_com_section (symbol->section))
1008 relocation = symbol->value;
1009 relocation += symbol->section->output_section->vma;
1010 relocation += symbol->section->output_offset;
1011 relocation += rel->addend;
1013 if (tos >= RELOC_STACKSIZE)
1016 stack[tos++] = relocation;
1020 case ALPHA_R_OP_STORE:
1021 /* Store a value from the reloc stack into a bitfield. */
1028 rel->address += input_section->output_offset;
1035 /* The offset and size for this reloc are encoded into the
1036 addend field by alpha_adjust_reloc_in. */
1037 offset = (rel->addend >> 8) & 0xff;
1038 size = rel->addend & 0xff;
1040 val = bfd_get_64 (abfd, data + rel->address);
1041 val &=~ (((1 << size) - 1) << offset);
1042 val |= (stack[--tos] & ((1 << size) - 1)) << offset;
1043 bfd_put_64 (abfd, val, data + rel->address);
1047 case ALPHA_R_OP_PSUB:
1048 /* Subtract a value from the top of the stack. */
1055 rel->address += input_section->output_offset;
1059 /* Figure out the relocation of this symbol. */
1060 symbol = *rel->sym_ptr_ptr;
1062 if (bfd_is_und_section (symbol->section))
1063 r = bfd_reloc_undefined;
1065 if (bfd_is_com_section (symbol->section))
1068 relocation = symbol->value;
1069 relocation += symbol->section->output_section->vma;
1070 relocation += symbol->section->output_offset;
1071 relocation += rel->addend;
1076 stack[tos - 1] -= relocation;
1080 case ALPHA_R_OP_PRSHIFT:
1081 /* Shift the value on the top of the stack. */
1088 rel->address += input_section->output_offset;
1092 /* Figure out the relocation of this symbol. */
1093 symbol = *rel->sym_ptr_ptr;
1095 if (bfd_is_und_section (symbol->section))
1096 r = bfd_reloc_undefined;
1098 if (bfd_is_com_section (symbol->section))
1101 relocation = symbol->value;
1102 relocation += symbol->section->output_section->vma;
1103 relocation += symbol->section->output_offset;
1104 relocation += rel->addend;
1109 stack[tos - 1] >>= relocation;
1113 case ALPHA_R_GPVALUE:
1114 /* I really don't know if this does the right thing. */
1116 gp_undefined = FALSE;
1125 asection *os = input_section->output_section;
1127 /* A partial link, so keep the relocs. */
1128 os->orelocation[os->reloc_count] = rel;
1132 if (r != bfd_reloc_ok)
1136 case bfd_reloc_undefined:
1137 if (! ((*link_info->callbacks->undefined_symbol)
1138 (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1139 input_bfd, input_section, rel->address, TRUE)))
1142 case bfd_reloc_dangerous:
1143 if (! ((*link_info->callbacks->reloc_dangerous)
1144 (link_info, err, input_bfd, input_section,
1148 case bfd_reloc_overflow:
1149 if (! ((*link_info->callbacks->reloc_overflow)
1150 (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1151 rel->howto->name, rel->addend, input_bfd,
1152 input_section, rel->address)))
1155 case bfd_reloc_outofrange:
1167 if (reloc_vector != NULL)
1168 free (reloc_vector);
1172 if (reloc_vector != NULL)
1173 free (reloc_vector);
1177 /* Get the howto structure for a generic reloc type. */
1179 static reloc_howto_type *
1180 alpha_bfd_reloc_type_lookup (abfd, code)
1181 bfd *abfd ATTRIBUTE_UNUSED;
1182 bfd_reloc_code_real_type code;
1189 alpha_type = ALPHA_R_REFLONG;
1192 case BFD_RELOC_CTOR:
1193 alpha_type = ALPHA_R_REFQUAD;
1195 case BFD_RELOC_GPREL32:
1196 alpha_type = ALPHA_R_GPREL32;
1198 case BFD_RELOC_ALPHA_LITERAL:
1199 alpha_type = ALPHA_R_LITERAL;
1201 case BFD_RELOC_ALPHA_LITUSE:
1202 alpha_type = ALPHA_R_LITUSE;
1204 case BFD_RELOC_ALPHA_GPDISP_HI16:
1205 alpha_type = ALPHA_R_GPDISP;
1207 case BFD_RELOC_ALPHA_GPDISP_LO16:
1208 alpha_type = ALPHA_R_IGNORE;
1210 case BFD_RELOC_23_PCREL_S2:
1211 alpha_type = ALPHA_R_BRADDR;
1213 case BFD_RELOC_ALPHA_HINT:
1214 alpha_type = ALPHA_R_HINT;
1216 case BFD_RELOC_16_PCREL:
1217 alpha_type = ALPHA_R_SREL16;
1219 case BFD_RELOC_32_PCREL:
1220 alpha_type = ALPHA_R_SREL32;
1222 case BFD_RELOC_64_PCREL:
1223 alpha_type = ALPHA_R_SREL64;
1227 alpha_type = ALPHA_R_OP_PUSH;
1230 alpha_type = ALPHA_R_OP_STORE;
1233 alpha_type = ALPHA_R_OP_PSUB;
1236 alpha_type = ALPHA_R_OP_PRSHIFT;
1239 alpha_type = ALPHA_R_GPVALUE;
1243 return (reloc_howto_type *) NULL;
1246 return &alpha_howto_table[alpha_type];
1249 /* A helper routine for alpha_relocate_section which converts an
1250 external reloc when generating relocatable output. Returns the
1251 relocation amount. */
1254 alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h)
1255 bfd *output_bfd ATTRIBUTE_UNUSED;
1256 struct bfd_link_info *info;
1258 struct external_reloc *ext_rel;
1259 struct ecoff_link_hash_entry *h;
1261 unsigned long r_symndx;
1264 BFD_ASSERT (info->relocatable);
1266 if (h->root.type == bfd_link_hash_defined
1267 || h->root.type == bfd_link_hash_defweak)
1272 /* This symbol is defined in the output. Convert the reloc from
1273 being against the symbol to being against the section. */
1275 /* Clear the r_extern bit. */
1276 ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE;
1278 /* Compute a new r_symndx value. */
1279 hsec = h->root.u.def.section;
1280 name = bfd_get_section_name (output_bfd, hsec->output_section);
1282 r_symndx = (unsigned long) -1;
1286 if (strcmp (name, "*ABS*") == 0)
1287 r_symndx = RELOC_SECTION_ABS;
1290 if (strcmp (name, ".bss") == 0)
1291 r_symndx = RELOC_SECTION_BSS;
1294 if (strcmp (name, ".data") == 0)
1295 r_symndx = RELOC_SECTION_DATA;
1298 if (strcmp (name, ".fini") == 0)
1299 r_symndx = RELOC_SECTION_FINI;
1302 if (strcmp (name, ".init") == 0)
1303 r_symndx = RELOC_SECTION_INIT;
1306 if (strcmp (name, ".lita") == 0)
1307 r_symndx = RELOC_SECTION_LITA;
1308 else if (strcmp (name, ".lit8") == 0)
1309 r_symndx = RELOC_SECTION_LIT8;
1310 else if (strcmp (name, ".lit4") == 0)
1311 r_symndx = RELOC_SECTION_LIT4;
1314 if (strcmp (name, ".pdata") == 0)
1315 r_symndx = RELOC_SECTION_PDATA;
1318 if (strcmp (name, ".rdata") == 0)
1319 r_symndx = RELOC_SECTION_RDATA;
1320 else if (strcmp (name, ".rconst") == 0)
1321 r_symndx = RELOC_SECTION_RCONST;
1324 if (strcmp (name, ".sdata") == 0)
1325 r_symndx = RELOC_SECTION_SDATA;
1326 else if (strcmp (name, ".sbss") == 0)
1327 r_symndx = RELOC_SECTION_SBSS;
1330 if (strcmp (name, ".text") == 0)
1331 r_symndx = RELOC_SECTION_TEXT;
1334 if (strcmp (name, ".xdata") == 0)
1335 r_symndx = RELOC_SECTION_XDATA;
1339 if (r_symndx == (unsigned long) -1)
1342 /* Add the section VMA and the symbol value. */
1343 relocation = (h->root.u.def.value
1344 + hsec->output_section->vma
1345 + hsec->output_offset);
1349 /* Change the symndx value to the right one for
1352 if (r_symndx == (unsigned long) -1)
1354 /* Caller must give an error. */
1360 /* Write out the new r_symndx value. */
1361 H_PUT_32 (input_bfd, r_symndx, ext_rel->r_symndx);
1366 /* Relocate a section while linking an Alpha ECOFF file. This is
1367 quite similar to get_relocated_section_contents. Perhaps they
1368 could be combined somehow. */
1371 alpha_relocate_section (output_bfd, info, input_bfd, input_section,
1372 contents, external_relocs)
1374 struct bfd_link_info *info;
1376 asection *input_section;
1378 PTR external_relocs;
1380 asection **symndx_to_section, *lita_sec;
1381 struct ecoff_link_hash_entry **sym_hashes;
1383 bfd_boolean gp_undefined;
1384 bfd_vma stack[RELOC_STACKSIZE];
1386 struct external_reloc *ext_rel;
1387 struct external_reloc *ext_rel_end;
1390 /* We keep a table mapping the symndx found in an internal reloc to
1391 the appropriate section. This is faster than looking up the
1392 section by name each time. */
1393 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1394 if (symndx_to_section == (asection **) NULL)
1396 amt = NUM_RELOC_SECTIONS * sizeof (asection *);
1397 symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
1398 if (!symndx_to_section)
1401 symndx_to_section[RELOC_SECTION_NONE] = NULL;
1402 symndx_to_section[RELOC_SECTION_TEXT] =
1403 bfd_get_section_by_name (input_bfd, ".text");
1404 symndx_to_section[RELOC_SECTION_RDATA] =
1405 bfd_get_section_by_name (input_bfd, ".rdata");
1406 symndx_to_section[RELOC_SECTION_DATA] =
1407 bfd_get_section_by_name (input_bfd, ".data");
1408 symndx_to_section[RELOC_SECTION_SDATA] =
1409 bfd_get_section_by_name (input_bfd, ".sdata");
1410 symndx_to_section[RELOC_SECTION_SBSS] =
1411 bfd_get_section_by_name (input_bfd, ".sbss");
1412 symndx_to_section[RELOC_SECTION_BSS] =
1413 bfd_get_section_by_name (input_bfd, ".bss");
1414 symndx_to_section[RELOC_SECTION_INIT] =
1415 bfd_get_section_by_name (input_bfd, ".init");
1416 symndx_to_section[RELOC_SECTION_LIT8] =
1417 bfd_get_section_by_name (input_bfd, ".lit8");
1418 symndx_to_section[RELOC_SECTION_LIT4] =
1419 bfd_get_section_by_name (input_bfd, ".lit4");
1420 symndx_to_section[RELOC_SECTION_XDATA] =
1421 bfd_get_section_by_name (input_bfd, ".xdata");
1422 symndx_to_section[RELOC_SECTION_PDATA] =
1423 bfd_get_section_by_name (input_bfd, ".pdata");
1424 symndx_to_section[RELOC_SECTION_FINI] =
1425 bfd_get_section_by_name (input_bfd, ".fini");
1426 symndx_to_section[RELOC_SECTION_LITA] =
1427 bfd_get_section_by_name (input_bfd, ".lita");
1428 symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1429 symndx_to_section[RELOC_SECTION_RCONST] =
1430 bfd_get_section_by_name (input_bfd, ".rconst");
1432 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1435 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1437 /* On the Alpha, the .lita section must be addressable by the global
1438 pointer. To support large programs, we need to allow multiple
1439 global pointers. This works as long as each input .lita section
1440 is <64KB big. This implies that when producing relocatable
1441 output, the .lita section is limited to 64KB. . */
1443 lita_sec = symndx_to_section[RELOC_SECTION_LITA];
1444 gp = _bfd_get_gp_value (output_bfd);
1445 if (! info->relocatable && lita_sec != NULL)
1447 struct ecoff_section_tdata *lita_sec_data;
1449 /* Make sure we have a section data structure to which we can
1450 hang on to the gp value we pick for the section. */
1451 lita_sec_data = ecoff_section_data (input_bfd, lita_sec);
1452 if (lita_sec_data == NULL)
1454 amt = sizeof (struct ecoff_section_tdata);
1455 lita_sec_data = ((struct ecoff_section_tdata *)
1456 bfd_zalloc (input_bfd, amt));
1457 lita_sec->used_by_bfd = lita_sec_data;
1460 if (lita_sec_data->gp != 0)
1462 /* If we already assigned a gp to this section, we better
1463 stick with that value. */
1464 gp = lita_sec_data->gp;
1469 bfd_size_type lita_size;
1471 lita_vma = lita_sec->output_offset + lita_sec->output_section->vma;
1472 lita_size = lita_sec->_cooked_size;
1474 lita_size = lita_sec->_raw_size;
1477 || lita_vma < gp - 0x8000
1478 || lita_vma + lita_size >= gp + 0x8000)
1480 /* Either gp hasn't been set at all or the current gp
1481 cannot address this .lita section. In both cases we
1482 reset the gp to point into the "middle" of the
1483 current input .lita section. */
1484 if (gp && !ecoff_data (output_bfd)->issued_multiple_gp_warning)
1486 (*info->callbacks->warning) (info,
1487 _("using multiple gp values"),
1488 (char *) NULL, output_bfd,
1489 (asection *) NULL, (bfd_vma) 0);
1490 ecoff_data (output_bfd)->issued_multiple_gp_warning = TRUE;
1492 if (lita_vma < gp - 0x8000)
1493 gp = lita_vma + lita_size - 0x8000;
1495 gp = lita_vma + 0x8000;
1499 lita_sec_data->gp = gp;
1502 _bfd_set_gp_value (output_bfd, gp);
1505 gp_undefined = (gp == 0);
1507 BFD_ASSERT (bfd_header_little_endian (output_bfd));
1508 BFD_ASSERT (bfd_header_little_endian (input_bfd));
1510 ext_rel = (struct external_reloc *) external_relocs;
1511 ext_rel_end = ext_rel + input_section->reloc_count;
1512 for (; ext_rel < ext_rel_end; ext_rel++)
1515 unsigned long r_symndx;
1520 bfd_boolean relocatep;
1521 bfd_boolean adjust_addrp;
1522 bfd_boolean gp_usedp;
1525 r_vaddr = H_GET_64 (input_bfd, ext_rel->r_vaddr);
1526 r_symndx = H_GET_32 (input_bfd, ext_rel->r_symndx);
1528 r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1529 >> RELOC_BITS0_TYPE_SH_LITTLE);
1530 r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1531 r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1532 >> RELOC_BITS1_OFFSET_SH_LITTLE);
1533 /* Ignored the reserved bits. */
1534 r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1535 >> RELOC_BITS3_SIZE_SH_LITTLE);
1538 adjust_addrp = TRUE;
1547 case ALPHA_R_IGNORE:
1548 /* This reloc appears after a GPDISP reloc. On earlier
1549 versions of OSF/1, It marked the position of the second
1550 instruction to be altered by the GPDISP reloc, but it is
1551 not otherwise used for anything. For some reason, the
1552 address of the relocation does not appear to include the
1553 section VMA, unlike the other relocation types. */
1554 if (info->relocatable)
1555 H_PUT_64 (input_bfd, input_section->output_offset + r_vaddr,
1557 adjust_addrp = FALSE;
1560 case ALPHA_R_REFLONG:
1561 case ALPHA_R_REFQUAD:
1566 case ALPHA_R_BRADDR:
1567 case ALPHA_R_SREL16:
1568 case ALPHA_R_SREL32:
1569 case ALPHA_R_SREL64:
1571 addend += - (r_vaddr + 4);
1575 case ALPHA_R_GPREL32:
1576 /* This relocation is used in a switch table. It is a 32
1577 bit offset from the current GP value. We must adjust it
1578 by the different between the original GP value and the
1579 current GP value. */
1581 addend = ecoff_data (input_bfd)->gp - gp;
1585 case ALPHA_R_LITERAL:
1586 /* This is a reference to a literal value, generally
1587 (always?) in the .lita section. This is a 16 bit GP
1588 relative relocation. Sometimes the subsequent reloc is a
1589 LITUSE reloc, which indicates how this reloc is used.
1590 This sometimes permits rewriting the two instructions
1591 referred to by the LITERAL and the LITUSE into different
1592 instructions which do not refer to .lita. This can save
1593 a memory reference, and permits removing a value from
1594 .lita thus saving GP relative space.
1596 We do not these optimizations. To do them we would need
1597 to arrange to link the .lita section first, so that by
1598 the time we got here we would know the final values to
1599 use. This would not be particularly difficult, but it is
1600 not currently implemented. */
1602 /* I believe that the LITERAL reloc will only apply to a ldq
1603 or ldl instruction, so check my assumption. */
1607 insn = bfd_get_32 (input_bfd,
1608 contents + r_vaddr - input_section->vma);
1609 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1610 || ((insn >> 26) & 0x3f) == 0x28);
1614 addend = ecoff_data (input_bfd)->gp - gp;
1618 case ALPHA_R_LITUSE:
1619 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
1620 does not cause anything to happen, itself. */
1623 case ALPHA_R_GPDISP:
1624 /* This marks the ldah of an ldah/lda pair which loads the
1625 gp register with the difference of the gp value and the
1626 current location. The second of the pair is r_symndx
1627 bytes ahead. It used to be marked with an ALPHA_R_IGNORE
1628 reloc, but OSF/1 3.2 no longer does that. */
1630 unsigned long insn1, insn2;
1632 /* Get the two instructions. */
1633 insn1 = bfd_get_32 (input_bfd,
1634 contents + r_vaddr - input_section->vma);
1635 insn2 = bfd_get_32 (input_bfd,
1638 - input_section->vma
1641 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1642 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1644 /* Get the existing addend. We must account for the sign
1645 extension done by lda and ldah. */
1646 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1649 /* This is addend -= 0x100000000 without causing an
1650 integer overflow on a 32 bit host. */
1651 addend -= 0x80000000;
1652 addend -= 0x80000000;
1657 /* The existing addend includes the difference between the
1658 gp of the input BFD and the address in the input BFD.
1659 We want to change this to the difference between the
1660 final GP and the final address. */
1662 - ecoff_data (input_bfd)->gp
1663 + input_section->vma
1664 - (input_section->output_section->vma
1665 + input_section->output_offset));
1667 /* Change the instructions, accounting for the sign
1668 extension, and write them out. */
1669 if (addend & 0x8000)
1671 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1672 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1674 bfd_put_32 (input_bfd, (bfd_vma) insn1,
1675 contents + r_vaddr - input_section->vma);
1676 bfd_put_32 (input_bfd, (bfd_vma) insn2,
1677 contents + r_vaddr - input_section->vma + r_symndx);
1683 case ALPHA_R_OP_PUSH:
1684 case ALPHA_R_OP_PSUB:
1685 case ALPHA_R_OP_PRSHIFT:
1686 /* Manipulate values on the reloc evaluation stack. The
1687 r_vaddr field is not an address in input_section, it is
1688 the current value (including any addend) of the object
1694 s = symndx_to_section[r_symndx];
1695 if (s == (asection *) NULL)
1697 addend = s->output_section->vma + s->output_offset - s->vma;
1701 struct ecoff_link_hash_entry *h;
1703 h = sym_hashes[r_symndx];
1704 if (h == (struct ecoff_link_hash_entry *) NULL)
1707 if (! info->relocatable)
1709 if (h->root.type == bfd_link_hash_defined
1710 || h->root.type == bfd_link_hash_defweak)
1711 addend = (h->root.u.def.value
1712 + h->root.u.def.section->output_section->vma
1713 + h->root.u.def.section->output_offset);
1716 /* Note that we pass the address as 0, since we
1717 do not have a meaningful number for the
1718 location within the section that is being
1720 if (! ((*info->callbacks->undefined_symbol)
1721 (info, h->root.root.string, input_bfd,
1722 input_section, (bfd_vma) 0, TRUE)))
1729 if (h->root.type != bfd_link_hash_defined
1730 && h->root.type != bfd_link_hash_defweak
1733 /* This symbol is not being written out. Pass
1734 the address as 0, as with undefined_symbol,
1736 if (! ((*info->callbacks->unattached_reloc)
1737 (info, h->root.root.string, input_bfd,
1738 input_section, (bfd_vma) 0)))
1742 addend = alpha_convert_external_reloc (output_bfd, info,
1750 if (info->relocatable)
1752 /* Adjust r_vaddr by the addend. */
1753 H_PUT_64 (input_bfd, addend, ext_rel->r_vaddr);
1759 case ALPHA_R_OP_PUSH:
1760 if (tos >= RELOC_STACKSIZE)
1762 stack[tos++] = addend;
1765 case ALPHA_R_OP_PSUB:
1768 stack[tos - 1] -= addend;
1771 case ALPHA_R_OP_PRSHIFT:
1774 stack[tos - 1] >>= addend;
1779 adjust_addrp = FALSE;
1782 case ALPHA_R_OP_STORE:
1783 /* Store a value from the reloc stack into a bitfield. If
1784 we are generating relocatable output, all we do is
1785 adjust the address of the reloc. */
1786 if (! info->relocatable)
1794 /* Get the relocation mask. The separate steps and the
1795 casts to bfd_vma are attempts to avoid a bug in the
1796 Alpha OSF 1.3 C compiler. See reloc.c for more
1799 mask <<= (bfd_vma) r_size;
1802 /* FIXME: I don't know what kind of overflow checking,
1803 if any, should be done here. */
1804 val = bfd_get_64 (input_bfd,
1805 contents + r_vaddr - input_section->vma);
1806 val &=~ mask << (bfd_vma) r_offset;
1807 val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1808 bfd_put_64 (input_bfd, val,
1809 contents + r_vaddr - input_section->vma);
1813 case ALPHA_R_GPVALUE:
1814 /* I really don't know if this does the right thing. */
1815 gp = ecoff_data (input_bfd)->gp + r_symndx;
1816 gp_undefined = FALSE;
1822 reloc_howto_type *howto;
1823 struct ecoff_link_hash_entry *h = NULL;
1826 bfd_reloc_status_type r;
1828 /* Perform a relocation. */
1830 howto = &alpha_howto_table[r_type];
1834 h = sym_hashes[r_symndx];
1835 /* If h is NULL, that means that there is a reloc
1836 against an external symbol which we thought was just
1837 a debugging symbol. This should not happen. */
1838 if (h == (struct ecoff_link_hash_entry *) NULL)
1843 if (r_symndx >= NUM_RELOC_SECTIONS)
1846 s = symndx_to_section[r_symndx];
1848 if (s == (asection *) NULL)
1852 if (info->relocatable)
1854 /* We are generating relocatable output, and must
1855 convert the existing reloc. */
1858 if (h->root.type != bfd_link_hash_defined
1859 && h->root.type != bfd_link_hash_defweak
1862 /* This symbol is not being written out. */
1863 if (! ((*info->callbacks->unattached_reloc)
1864 (info, h->root.root.string, input_bfd,
1865 input_section, r_vaddr - input_section->vma)))
1869 relocation = alpha_convert_external_reloc (output_bfd,
1877 /* This is a relocation against a section. Adjust
1878 the value by the amount the section moved. */
1879 relocation = (s->output_section->vma
1884 /* If this is PC relative, the existing object file
1885 appears to already have the reloc worked out. We
1886 must subtract out the old value and add in the new
1888 if (howto->pc_relative)
1889 relocation -= (input_section->output_section->vma
1890 + input_section->output_offset
1891 - input_section->vma);
1893 /* Put in any addend. */
1894 relocation += addend;
1896 /* Adjust the contents. */
1897 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1900 - input_section->vma));
1904 /* We are producing a final executable. */
1907 /* This is a reloc against a symbol. */
1908 if (h->root.type == bfd_link_hash_defined
1909 || h->root.type == bfd_link_hash_defweak)
1913 hsec = h->root.u.def.section;
1914 relocation = (h->root.u.def.value
1915 + hsec->output_section->vma
1916 + hsec->output_offset);
1920 if (! ((*info->callbacks->undefined_symbol)
1921 (info, h->root.root.string, input_bfd,
1923 r_vaddr - input_section->vma, TRUE)))
1930 /* This is a reloc against a section. */
1931 relocation = (s->output_section->vma
1935 /* Adjust a PC relative relocation by removing the
1936 reference to the original source section. */
1937 if (howto->pc_relative)
1938 relocation += input_section->vma;
1941 r = _bfd_final_link_relocate (howto,
1945 r_vaddr - input_section->vma,
1950 if (r != bfd_reloc_ok)
1955 case bfd_reloc_outofrange:
1957 case bfd_reloc_overflow:
1962 name = sym_hashes[r_symndx]->root.root.string;
1964 name = bfd_section_name (input_bfd,
1965 symndx_to_section[r_symndx]);
1966 if (! ((*info->callbacks->reloc_overflow)
1967 (info, name, alpha_howto_table[r_type].name,
1968 (bfd_vma) 0, input_bfd, input_section,
1969 r_vaddr - input_section->vma)))
1977 if (info->relocatable && adjust_addrp)
1979 /* Change the address of the relocation. */
1980 H_PUT_64 (input_bfd,
1981 (input_section->output_section->vma
1982 + input_section->output_offset
1983 - input_section->vma
1988 if (gp_usedp && gp_undefined)
1990 if (! ((*info->callbacks->reloc_dangerous)
1991 (info, _("GP relative relocation used when GP not defined"),
1992 input_bfd, input_section, r_vaddr - input_section->vma)))
1994 /* Only give the error once per link. */
1996 _bfd_set_gp_value (output_bfd, gp);
1997 gp_undefined = FALSE;
2007 /* Do final adjustments to the filehdr and the aouthdr. This routine
2008 sets the dynamic bits in the file header. */
2011 alpha_adjust_headers (abfd, fhdr, ahdr)
2013 struct internal_filehdr *fhdr;
2014 struct internal_aouthdr *ahdr ATTRIBUTE_UNUSED;
2016 if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
2017 fhdr->f_flags |= F_ALPHA_CALL_SHARED;
2018 else if ((abfd->flags & DYNAMIC) != 0)
2019 fhdr->f_flags |= F_ALPHA_SHARABLE;
2023 /* Archive handling. In OSF/1 (or Digital Unix) v3.2, Digital
2024 introduced archive packing, in which the elements in an archive are
2025 optionally compressed using a simple dictionary scheme. We know
2026 how to read such archives, but we don't write them. */
2028 #define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap
2029 #define alpha_ecoff_slurp_extended_name_table \
2030 _bfd_ecoff_slurp_extended_name_table
2031 #define alpha_ecoff_construct_extended_name_table \
2032 _bfd_ecoff_construct_extended_name_table
2033 #define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname
2034 #define alpha_ecoff_write_armap _bfd_ecoff_write_armap
2035 #define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt
2036 #define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp
2038 /* A compressed file uses this instead of ARFMAG. */
2040 #define ARFZMAG "Z\012"
2042 /* Read an archive header. This is like the standard routine, but it
2043 also accepts ARFZMAG. */
2046 alpha_ecoff_read_ar_hdr (abfd)
2049 struct areltdata *ret;
2052 ret = (struct areltdata *) _bfd_generic_read_ar_hdr_mag (abfd, ARFZMAG);
2056 h = (struct ar_hdr *) ret->arch_header;
2057 if (strncmp (h->ar_fmag, ARFZMAG, 2) == 0)
2061 /* This is a compressed file. We must set the size correctly.
2062 The size is the eight bytes after the dummy file header. */
2063 if (bfd_seek (abfd, (file_ptr) FILHSZ, SEEK_CUR) != 0
2064 || bfd_bread (ab, (bfd_size_type) 8, abfd) != 8
2065 || bfd_seek (abfd, (file_ptr) (- (FILHSZ + 8)), SEEK_CUR) != 0)
2068 ret->parsed_size = H_GET_64 (abfd, ab);
2074 /* Get an archive element at a specified file position. This is where
2075 we uncompress the archive element if necessary. */
2078 alpha_ecoff_get_elt_at_filepos (archive, filepos)
2083 struct areltdata *tdata;
2088 struct bfd_in_memory *bim;
2090 nbfd = _bfd_get_elt_at_filepos (archive, filepos);
2094 if ((nbfd->flags & BFD_IN_MEMORY) != 0)
2096 /* We have already expanded this BFD. */
2100 tdata = (struct areltdata *) nbfd->arelt_data;
2101 hdr = (struct ar_hdr *) tdata->arch_header;
2102 if (strncmp (hdr->ar_fmag, ARFZMAG, 2) != 0)
2105 /* We must uncompress this element. We do this by copying it into a
2106 memory buffer, and making bfd_bread and bfd_seek use that buffer.
2107 This can use a lot of memory, but it's simpler than getting a
2108 temporary file, making that work with the file descriptor caching
2109 code, and making sure that it is deleted at all appropriate
2110 times. It can be changed if it ever becomes important. */
2112 /* The compressed file starts with a dummy ECOFF file header. */
2113 if (bfd_seek (nbfd, (file_ptr) FILHSZ, SEEK_SET) != 0)
2116 /* The next eight bytes are the real file size. */
2117 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2119 size = H_GET_64 (nbfd, ab);
2126 bfd_byte dict[4096];
2130 buf = (bfd_byte *) bfd_alloc (nbfd, size);
2137 /* I don't know what the next eight bytes are for. */
2138 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2141 /* This is the uncompression algorithm. It's a simple
2142 dictionary based scheme in which each character is predicted
2143 by a hash of the previous three characters. A control byte
2144 indicates whether the character is predicted or whether it
2145 appears in the input stream; each control byte manages the
2146 next eight bytes in the output stream. */
2147 memset (dict, 0, sizeof dict);
2149 while (bfd_bread (&b, (bfd_size_type) 1, nbfd) == 1)
2153 for (i = 0; i < 8; i++, b >>= 1)
2161 if (! bfd_bread (&n, (bfd_size_type) 1, nbfd))
2174 h &= sizeof dict - 1;
2182 /* Now the uncompressed file contents are in buf. */
2183 bim = ((struct bfd_in_memory *)
2184 bfd_alloc (nbfd, (bfd_size_type) sizeof (struct bfd_in_memory)));
2190 nbfd->mtime_set = TRUE;
2191 nbfd->mtime = strtol (hdr->ar_date, (char **) NULL, 10);
2193 nbfd->flags |= BFD_IN_MEMORY;
2194 nbfd->iostream = (PTR) bim;
2195 BFD_ASSERT (! nbfd->cacheable);
2205 /* Open the next archived file. */
2208 alpha_ecoff_openr_next_archived_file (archive, last_file)
2214 if (last_file == NULL)
2215 filestart = bfd_ardata (archive)->first_file_filepos;
2218 struct areltdata *t;
2222 /* We can't use arelt_size here, because that uses parsed_size,
2223 which is the uncompressed size. We need the compressed size. */
2224 t = (struct areltdata *) last_file->arelt_data;
2225 h = (struct ar_hdr *) t->arch_header;
2226 size = strtol (h->ar_size, (char **) NULL, 10);
2228 /* Pad to an even boundary...
2229 Note that last_file->origin can be odd in the case of
2230 BSD-4.4-style element with a long odd size. */
2231 filestart = last_file->origin + size;
2232 filestart += filestart % 2;
2235 return alpha_ecoff_get_elt_at_filepos (archive, filestart);
2238 /* Open the archive file given an index into the armap. */
2241 alpha_ecoff_get_elt_at_index (abfd, index)
2247 entry = bfd_ardata (abfd)->symdefs + index;
2248 return alpha_ecoff_get_elt_at_filepos (abfd, entry->file_offset);
2251 /* This is the ECOFF backend structure. The backend field of the
2252 target vector points to this. */
2254 static const struct ecoff_backend_data alpha_ecoff_backend_data =
2256 /* COFF backend structure. */
2258 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2259 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2260 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2261 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2262 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2263 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2264 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2265 alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
2266 alpha_ecoff_swap_scnhdr_out,
2267 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE, FALSE, 4, FALSE, 2,
2268 alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
2269 alpha_ecoff_swap_scnhdr_in, NULL,
2270 alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2271 alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2272 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2273 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2276 /* Supported architecture. */
2278 /* Initial portion of armap string. */
2280 /* The page boundary used to align sections in a demand-paged
2281 executable file. E.g., 0x1000. */
2283 /* TRUE if the .rdata section is part of the text segment, as on the
2284 Alpha. FALSE if .rdata is part of the data segment, as on the
2287 /* Bitsize of constructor entries. */
2289 /* Reloc to use for constructor entries. */
2290 &alpha_howto_table[ALPHA_R_REFQUAD],
2292 /* Symbol table magic number. */
2294 /* Alignment of debugging information. E.g., 4. */
2296 /* Sizes of external symbolic information. */
2297 sizeof (struct hdr_ext),
2298 sizeof (struct dnr_ext),
2299 sizeof (struct pdr_ext),
2300 sizeof (struct sym_ext),
2301 sizeof (struct opt_ext),
2302 sizeof (struct fdr_ext),
2303 sizeof (struct rfd_ext),
2304 sizeof (struct ext_ext),
2305 /* Functions to swap in external symbolic data. */
2314 _bfd_ecoff_swap_tir_in,
2315 _bfd_ecoff_swap_rndx_in,
2316 /* Functions to swap out external symbolic data. */
2325 _bfd_ecoff_swap_tir_out,
2326 _bfd_ecoff_swap_rndx_out,
2327 /* Function to read in symbolic data. */
2328 _bfd_ecoff_slurp_symbolic_info
2330 /* External reloc size. */
2332 /* Reloc swapping functions. */
2333 alpha_ecoff_swap_reloc_in,
2334 alpha_ecoff_swap_reloc_out,
2335 /* Backend reloc tweaking. */
2336 alpha_adjust_reloc_in,
2337 alpha_adjust_reloc_out,
2338 /* Relocate section contents while linking. */
2339 alpha_relocate_section,
2340 /* Do final adjustments to filehdr and aouthdr. */
2341 alpha_adjust_headers,
2342 /* Read an element from an archive at a given file position. */
2343 alpha_ecoff_get_elt_at_filepos
2346 /* Looking up a reloc type is Alpha specific. */
2347 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2349 /* So is getting relocated section contents. */
2350 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2351 alpha_ecoff_get_relocated_section_contents
2353 /* Handling file windows is generic. */
2354 #define _bfd_ecoff_get_section_contents_in_window \
2355 _bfd_generic_get_section_contents_in_window
2357 /* Relaxing sections is generic. */
2358 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2359 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2360 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
2361 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
2362 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
2364 const bfd_target ecoffalpha_little_vec =
2366 "ecoff-littlealpha", /* name */
2367 bfd_target_ecoff_flavour,
2368 BFD_ENDIAN_LITTLE, /* data byte order is little */
2369 BFD_ENDIAN_LITTLE, /* header byte order is little */
2371 (HAS_RELOC | EXEC_P | /* object flags */
2372 HAS_LINENO | HAS_DEBUG |
2373 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2375 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2376 0, /* leading underscore */
2377 ' ', /* ar_pad_char */
2378 15, /* ar_max_namelen */
2379 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2380 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2381 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2382 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2383 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2384 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2386 {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */
2387 _bfd_ecoff_archive_p, _bfd_dummy_target},
2388 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2389 _bfd_generic_mkarchive, bfd_false},
2390 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2391 _bfd_write_archive_contents, bfd_false},
2393 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2394 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2395 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2396 BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff),
2397 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2398 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2399 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2400 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2401 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2405 (PTR) &alpha_ecoff_backend_data