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., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 #include "coff/internal.h"
28 #include "coff/symconst.h"
29 #include "coff/ecoff.h"
30 #include "coff/alpha.h"
34 /* Prototypes for static functions. */
36 static const bfd_target
*alpha_ecoff_object_p
PARAMS ((bfd
*));
37 static boolean alpha_ecoff_bad_format_hook
PARAMS ((bfd
*abfd
, PTR filehdr
));
38 static PTR alpha_ecoff_mkobject_hook
PARAMS ((bfd
*, PTR filehdr
, PTR aouthdr
));
39 static void alpha_ecoff_swap_reloc_in
PARAMS ((bfd
*, PTR
,
40 struct internal_reloc
*));
41 static void alpha_ecoff_swap_reloc_out
PARAMS ((bfd
*,
42 const struct internal_reloc
*,
44 static void alpha_adjust_reloc_in
PARAMS ((bfd
*,
45 const struct internal_reloc
*,
47 static void alpha_adjust_reloc_out
PARAMS ((bfd
*, const arelent
*,
48 struct internal_reloc
*));
49 static bfd_byte
*alpha_ecoff_get_relocated_section_contents
50 PARAMS ((bfd
*abfd
, struct bfd_link_info
*, struct bfd_link_order
*,
51 bfd_byte
*data
, boolean relocateable
, asymbol
**symbols
));
52 static bfd_vma alpha_convert_external_reloc
53 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, struct external_reloc
*,
54 struct ecoff_link_hash_entry
*));
55 static boolean alpha_relocate_section
PARAMS ((bfd
*, struct bfd_link_info
*,
59 /* ECOFF has COFF sections, but the debugging information is stored in
60 a completely different format. ECOFF targets use some of the
61 swapping routines from coffswap.h, and some of the generic COFF
62 routines in coffgen.c, but, unlike the real COFF targets, do not
63 use coffcode.h itself.
65 Get the generic COFF swapping routines, except for the reloc,
66 symbol, and lineno ones. Give them ecoff names. Define some
67 accessor macros for the large sizes used for Alpha ECOFF. */
69 #define GET_FILEHDR_SYMPTR bfd_h_get_64
70 #define PUT_FILEHDR_SYMPTR bfd_h_put_64
71 #define GET_AOUTHDR_TSIZE bfd_h_get_64
72 #define PUT_AOUTHDR_TSIZE bfd_h_put_64
73 #define GET_AOUTHDR_DSIZE bfd_h_get_64
74 #define PUT_AOUTHDR_DSIZE bfd_h_put_64
75 #define GET_AOUTHDR_BSIZE bfd_h_get_64
76 #define PUT_AOUTHDR_BSIZE bfd_h_put_64
77 #define GET_AOUTHDR_ENTRY bfd_h_get_64
78 #define PUT_AOUTHDR_ENTRY bfd_h_put_64
79 #define GET_AOUTHDR_TEXT_START bfd_h_get_64
80 #define PUT_AOUTHDR_TEXT_START bfd_h_put_64
81 #define GET_AOUTHDR_DATA_START bfd_h_get_64
82 #define PUT_AOUTHDR_DATA_START bfd_h_put_64
83 #define GET_SCNHDR_PADDR bfd_h_get_64
84 #define PUT_SCNHDR_PADDR bfd_h_put_64
85 #define GET_SCNHDR_VADDR bfd_h_get_64
86 #define PUT_SCNHDR_VADDR bfd_h_put_64
87 #define GET_SCNHDR_SIZE bfd_h_get_64
88 #define PUT_SCNHDR_SIZE bfd_h_put_64
89 #define GET_SCNHDR_SCNPTR bfd_h_get_64
90 #define PUT_SCNHDR_SCNPTR bfd_h_put_64
91 #define GET_SCNHDR_RELPTR bfd_h_get_64
92 #define PUT_SCNHDR_RELPTR bfd_h_put_64
93 #define GET_SCNHDR_LNNOPTR bfd_h_get_64
94 #define PUT_SCNHDR_LNNOPTR bfd_h_put_64
98 #define NO_COFF_RELOCS
99 #define NO_COFF_SYMBOLS
100 #define NO_COFF_LINENOS
101 #define coff_swap_filehdr_in alpha_ecoff_swap_filehdr_in
102 #define coff_swap_filehdr_out alpha_ecoff_swap_filehdr_out
103 #define coff_swap_aouthdr_in alpha_ecoff_swap_aouthdr_in
104 #define coff_swap_aouthdr_out alpha_ecoff_swap_aouthdr_out
105 #define coff_swap_scnhdr_in alpha_ecoff_swap_scnhdr_in
106 #define coff_swap_scnhdr_out alpha_ecoff_swap_scnhdr_out
107 #include "coffswap.h"
109 /* Get the ECOFF swapping routines. */
111 #include "ecoffswap.h"
113 /* How to process the various reloc types. */
115 static bfd_reloc_status_type
116 reloc_nil
PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
,
117 asection
*, bfd
*, char **));
119 static bfd_reloc_status_type
120 reloc_nil (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
127 char **error_message
;
132 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
133 from smaller values. Start with zero, widen, *then* decrement. */
134 #define MINUS_ONE (((bfd_vma)0) - 1)
136 static reloc_howto_type alpha_howto_table
[] =
138 /* Reloc type 0 is ignored by itself. However, it appears after a
139 GPDISP reloc to identify the location where the low order 16 bits
140 of the gp register are loaded. */
141 HOWTO (ALPHA_R_IGNORE
, /* type */
143 0, /* size (0 = byte, 1 = short, 2 = long) */
145 true, /* pc_relative */
147 complain_overflow_dont
, /* complain_on_overflow */
148 reloc_nil
, /* special_function */
150 true, /* partial_inplace */
153 true), /* pcrel_offset */
155 /* A 32 bit reference to a symbol. */
156 HOWTO (ALPHA_R_REFLONG
, /* type */
158 2, /* size (0 = byte, 1 = short, 2 = long) */
160 false, /* pc_relative */
162 complain_overflow_bitfield
, /* complain_on_overflow */
163 0, /* special_function */
164 "REFLONG", /* name */
165 true, /* partial_inplace */
166 0xffffffff, /* src_mask */
167 0xffffffff, /* dst_mask */
168 false), /* pcrel_offset */
170 /* A 64 bit reference to a symbol. */
171 HOWTO (ALPHA_R_REFQUAD
, /* type */
173 4, /* size (0 = byte, 1 = short, 2 = long) */
175 false, /* pc_relative */
177 complain_overflow_bitfield
, /* complain_on_overflow */
178 0, /* special_function */
179 "REFQUAD", /* name */
180 true, /* partial_inplace */
181 MINUS_ONE
, /* src_mask */
182 MINUS_ONE
, /* dst_mask */
183 false), /* pcrel_offset */
185 /* A 32 bit GP relative offset. This is just like REFLONG except
186 that when the value is used the value of the gp register will be
188 HOWTO (ALPHA_R_GPREL32
, /* type */
190 2, /* size (0 = byte, 1 = short, 2 = long) */
192 false, /* pc_relative */
194 complain_overflow_bitfield
, /* complain_on_overflow */
195 0, /* special_function */
196 "GPREL32", /* name */
197 true, /* partial_inplace */
198 0xffffffff, /* src_mask */
199 0xffffffff, /* dst_mask */
200 false), /* pcrel_offset */
202 /* Used for an instruction that refers to memory off the GP
203 register. The offset is 16 bits of the 32 bit instruction. This
204 reloc always seems to be against the .lita section. */
205 HOWTO (ALPHA_R_LITERAL
, /* type */
207 2, /* size (0 = byte, 1 = short, 2 = long) */
209 false, /* pc_relative */
211 complain_overflow_signed
, /* complain_on_overflow */
212 0, /* special_function */
213 "LITERAL", /* name */
214 true, /* partial_inplace */
215 0xffff, /* src_mask */
216 0xffff, /* dst_mask */
217 false), /* pcrel_offset */
219 /* This reloc only appears immediately following a LITERAL reloc.
220 It identifies a use of the literal. It seems that the linker can
221 use this to eliminate a portion of the .lita section. The symbol
222 index is special: 1 means the literal address is in the base
223 register of a memory format instruction; 2 means the literal
224 address is in the byte offset register of a byte-manipulation
225 instruction; 3 means the literal address is in the target
226 register of a jsr instruction. This does not actually do any
228 HOWTO (ALPHA_R_LITUSE
, /* type */
230 2, /* size (0 = byte, 1 = short, 2 = long) */
232 false, /* pc_relative */
234 complain_overflow_dont
, /* complain_on_overflow */
235 reloc_nil
, /* special_function */
237 false, /* partial_inplace */
240 false), /* pcrel_offset */
242 /* Load the gp register. This is always used for a ldah instruction
243 which loads the upper 16 bits of the gp register. The next reloc
244 will be an IGNORE reloc which identifies the location of the lda
245 instruction which loads the lower 16 bits. The symbol index of
246 the GPDISP instruction appears to actually be the number of bytes
247 between the ldah and lda instructions. This gives two different
248 ways to determine where the lda instruction is; I don't know why
249 both are used. The value to use for the relocation is the
250 difference between the GP value and the current location; the
251 load will always be done against a register holding the current
253 HOWTO (ALPHA_R_GPDISP
, /* type */
255 2, /* size (0 = byte, 1 = short, 2 = long) */
257 true, /* pc_relative */
259 complain_overflow_dont
, /* complain_on_overflow */
260 reloc_nil
, /* special_function */
262 true, /* partial_inplace */
263 0xffff, /* src_mask */
264 0xffff, /* dst_mask */
265 true), /* pcrel_offset */
267 /* A 21 bit branch. The native assembler generates these for
268 branches within the text segment, and also fills in the PC
269 relative offset in the instruction. */
270 HOWTO (ALPHA_R_BRADDR
, /* type */
272 2, /* size (0 = byte, 1 = short, 2 = long) */
274 true, /* pc_relative */
276 complain_overflow_signed
, /* complain_on_overflow */
277 0, /* special_function */
279 true, /* partial_inplace */
280 0x1fffff, /* src_mask */
281 0x1fffff, /* dst_mask */
282 false), /* pcrel_offset */
284 /* A hint for a jump to a register. */
285 HOWTO (ALPHA_R_HINT
, /* type */
287 2, /* size (0 = byte, 1 = short, 2 = long) */
289 true, /* pc_relative */
291 complain_overflow_dont
, /* complain_on_overflow */
292 0, /* special_function */
294 true, /* partial_inplace */
295 0x3fff, /* src_mask */
296 0x3fff, /* dst_mask */
297 false), /* pcrel_offset */
299 /* 16 bit PC relative offset. */
300 HOWTO (ALPHA_R_SREL16
, /* type */
302 1, /* size (0 = byte, 1 = short, 2 = long) */
304 true, /* pc_relative */
306 complain_overflow_signed
, /* complain_on_overflow */
307 0, /* special_function */
309 true, /* partial_inplace */
310 0xffff, /* src_mask */
311 0xffff, /* dst_mask */
312 false), /* pcrel_offset */
314 /* 32 bit PC relative offset. */
315 HOWTO (ALPHA_R_SREL32
, /* type */
317 2, /* size (0 = byte, 1 = short, 2 = long) */
319 true, /* pc_relative */
321 complain_overflow_signed
, /* complain_on_overflow */
322 0, /* special_function */
324 true, /* partial_inplace */
325 0xffffffff, /* src_mask */
326 0xffffffff, /* dst_mask */
327 false), /* pcrel_offset */
329 /* A 64 bit PC relative offset. */
330 HOWTO (ALPHA_R_SREL64
, /* type */
332 4, /* size (0 = byte, 1 = short, 2 = long) */
334 true, /* pc_relative */
336 complain_overflow_signed
, /* complain_on_overflow */
337 0, /* special_function */
339 true, /* partial_inplace */
340 MINUS_ONE
, /* src_mask */
341 MINUS_ONE
, /* dst_mask */
342 false), /* pcrel_offset */
344 /* Push a value on the reloc evaluation stack. */
345 HOWTO (ALPHA_R_OP_PUSH
, /* type */
347 0, /* size (0 = byte, 1 = short, 2 = long) */
349 false, /* pc_relative */
351 complain_overflow_dont
, /* complain_on_overflow */
352 0, /* special_function */
353 "OP_PUSH", /* name */
354 false, /* partial_inplace */
357 false), /* pcrel_offset */
359 /* Store the value from the stack at the given address. Store it in
360 a bitfield of size r_size starting at bit position r_offset. */
361 HOWTO (ALPHA_R_OP_STORE
, /* type */
363 4, /* size (0 = byte, 1 = short, 2 = long) */
365 false, /* pc_relative */
367 complain_overflow_dont
, /* complain_on_overflow */
368 0, /* special_function */
369 "OP_STORE", /* name */
370 false, /* partial_inplace */
372 MINUS_ONE
, /* dst_mask */
373 false), /* pcrel_offset */
375 /* Subtract the reloc address from the value on the top of the
377 HOWTO (ALPHA_R_OP_PSUB
, /* type */
379 0, /* size (0 = byte, 1 = short, 2 = long) */
381 false, /* pc_relative */
383 complain_overflow_dont
, /* complain_on_overflow */
384 0, /* special_function */
385 "OP_PSUB", /* name */
386 false, /* partial_inplace */
389 false), /* pcrel_offset */
391 /* Shift the value on the top of the relocation stack right by the
393 HOWTO (ALPHA_R_OP_PRSHIFT
, /* type */
395 0, /* size (0 = byte, 1 = short, 2 = long) */
397 false, /* pc_relative */
399 complain_overflow_dont
, /* complain_on_overflow */
400 0, /* special_function */
401 "OP_PRSHIFT", /* name */
402 false, /* partial_inplace */
405 false), /* pcrel_offset */
407 /* Adjust the GP value for a new range in the object file. */
408 HOWTO (ALPHA_R_GPVALUE
, /* type */
410 0, /* size (0 = byte, 1 = short, 2 = long) */
412 false, /* pc_relative */
414 complain_overflow_dont
, /* complain_on_overflow */
415 0, /* special_function */
416 "GPVALUE", /* name */
417 false, /* partial_inplace */
420 false) /* pcrel_offset */
423 /* Recognize an Alpha ECOFF file. */
425 static const bfd_target
*
426 alpha_ecoff_object_p (abfd
)
429 static const bfd_target
*ret
;
431 ret
= coff_object_p (abfd
);
437 /* Alpha ECOFF has a .pdata section. The lnnoptr field of the
438 .pdata section is the number of entries it contains. Each
439 entry takes up 8 bytes. The number of entries is required
440 since the section is aligned to a 16 byte boundary. When we
441 link .pdata sections together, we do not want to include the
442 alignment bytes. We handle this on input by faking the size
443 of the .pdata section to remove the unwanted alignment bytes.
444 On output we will set the lnnoptr field and force the
446 sec
= bfd_get_section_by_name (abfd
, _PDATA
);
447 if (sec
!= (asection
*) NULL
)
451 size
= sec
->line_filepos
* 8;
452 BFD_ASSERT (size
== bfd_section_size (abfd
, sec
)
453 || size
+ 8 == bfd_section_size (abfd
, sec
));
454 if (! bfd_set_section_size (abfd
, sec
, size
))
462 /* See whether the magic number matches. */
465 alpha_ecoff_bad_format_hook (abfd
, filehdr
)
469 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
471 if (ALPHA_ECOFF_BADMAG (*internal_f
))
477 /* This is a hook called by coff_real_object_p to create any backend
478 specific information. */
481 alpha_ecoff_mkobject_hook (abfd
, filehdr
, aouthdr
)
488 ecoff
= _bfd_ecoff_mkobject_hook (abfd
, filehdr
, aouthdr
);
492 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
494 /* Set additional BFD flags according to the object type from the
495 machine specific file header flags. */
496 switch (internal_f
->f_flags
& F_ALPHA_OBJECT_TYPE_MASK
)
498 case F_ALPHA_SHARABLE
:
499 abfd
->flags
|= DYNAMIC
;
501 case F_ALPHA_CALL_SHARED
:
502 /* Always executable if using shared libraries as the run time
503 loader might resolve undefined references. */
504 abfd
->flags
|= (DYNAMIC
| EXEC_P
);
511 /* Reloc handling. */
513 /* Swap a reloc in. */
516 alpha_ecoff_swap_reloc_in (abfd
, ext_ptr
, intern
)
519 struct internal_reloc
*intern
;
521 const RELOC
*ext
= (RELOC
*) ext_ptr
;
523 intern
->r_vaddr
= bfd_h_get_64 (abfd
, (bfd_byte
*) ext
->r_vaddr
);
524 intern
->r_symndx
= bfd_h_get_32 (abfd
, (bfd_byte
*) ext
->r_symndx
);
526 BFD_ASSERT (abfd
->xvec
->header_byteorder_big_p
== false);
528 intern
->r_type
= ((ext
->r_bits
[0] & RELOC_BITS0_TYPE_LITTLE
)
529 >> RELOC_BITS0_TYPE_SH_LITTLE
);
530 intern
->r_extern
= (ext
->r_bits
[1] & RELOC_BITS1_EXTERN_LITTLE
) != 0;
531 intern
->r_offset
= ((ext
->r_bits
[1] & RELOC_BITS1_OFFSET_LITTLE
)
532 >> RELOC_BITS1_OFFSET_SH_LITTLE
);
533 /* Ignored the reserved bits. */
534 intern
->r_size
= ((ext
->r_bits
[3] & RELOC_BITS3_SIZE_LITTLE
)
535 >> RELOC_BITS3_SIZE_SH_LITTLE
);
537 if (intern
->r_type
== ALPHA_R_LITUSE
538 || intern
->r_type
== ALPHA_R_GPDISP
)
540 /* Handle the LITUSE and GPDISP relocs specially. Its symndx
541 value is not actually a symbol index, but is instead a
542 special code. We put the code in the r_size field, and
543 clobber the symndx. */
544 if (intern
->r_size
!= 0)
546 intern
->r_size
= intern
->r_symndx
;
547 intern
->r_symndx
= RELOC_SECTION_NONE
;
549 else if (intern
->r_type
== ALPHA_R_IGNORE
)
551 /* The IGNORE reloc generally follows a GPDISP reloc, and is
552 against the .lita section. The section is irrelevant. */
553 if (! intern
->r_extern
&&
554 (intern
->r_symndx
== RELOC_SECTION_NONE
555 || intern
->r_symndx
== RELOC_SECTION_ABS
))
557 if (! intern
->r_extern
&& intern
->r_symndx
== RELOC_SECTION_LITA
)
558 intern
->r_symndx
= RELOC_SECTION_NONE
;
562 /* Swap a reloc out. */
565 alpha_ecoff_swap_reloc_out (abfd
, intern
, dst
)
567 const struct internal_reloc
*intern
;
570 RELOC
*ext
= (RELOC
*) dst
;
574 /* Undo the hackery done in swap_reloc_in. */
575 if (intern
->r_type
== ALPHA_R_LITUSE
576 || intern
->r_type
== ALPHA_R_GPDISP
)
578 symndx
= intern
->r_size
;
581 else if (intern
->r_type
== ALPHA_R_IGNORE
582 && ! intern
->r_extern
583 && intern
->r_symndx
== RELOC_SECTION_NONE
)
585 symndx
= RELOC_SECTION_LITA
;
586 size
= intern
->r_size
;
590 symndx
= intern
->r_symndx
;
591 size
= intern
->r_size
;
594 BFD_ASSERT (intern
->r_extern
595 || (intern
->r_symndx
>= 0 && intern
->r_symndx
<= 14));
597 bfd_h_put_64 (abfd
, intern
->r_vaddr
, (bfd_byte
*) ext
->r_vaddr
);
598 bfd_h_put_32 (abfd
, symndx
, (bfd_byte
*) ext
->r_symndx
);
600 BFD_ASSERT (abfd
->xvec
->header_byteorder_big_p
== false);
602 ext
->r_bits
[0] = ((intern
->r_type
<< RELOC_BITS0_TYPE_SH_LITTLE
)
603 & RELOC_BITS0_TYPE_LITTLE
);
604 ext
->r_bits
[1] = ((intern
->r_extern
? RELOC_BITS1_EXTERN_LITTLE
: 0)
605 | ((intern
->r_offset
<< RELOC_BITS1_OFFSET_SH_LITTLE
)
606 & RELOC_BITS1_OFFSET_LITTLE
));
608 ext
->r_bits
[3] = ((size
<< RELOC_BITS3_SIZE_SH_LITTLE
)
609 & RELOC_BITS3_SIZE_LITTLE
);
612 /* Finish canonicalizing a reloc. Part of this is generic to all
613 ECOFF targets, and that part is in ecoff.c. The rest is done in
614 this backend routine. It must fill in the howto field. */
617 alpha_adjust_reloc_in (abfd
, intern
, rptr
)
619 const struct internal_reloc
*intern
;
622 if (intern
->r_type
> ALPHA_R_GPVALUE
)
625 switch (intern
->r_type
)
631 /* The PC relative relocs do not seem to use the section VMA as
632 a negative addend. */
636 case ALPHA_R_GPREL32
:
637 case ALPHA_R_LITERAL
:
638 /* Copy the gp value for this object file into the addend, to
639 ensure that we are not confused by the linker. */
640 if (! intern
->r_extern
)
641 rptr
->addend
+= ecoff_data (abfd
)->gp
;
646 /* The LITUSE and GPDISP relocs do not use a symbol, or an
647 addend, but they do use a special code. Put this code in the
649 rptr
->addend
= intern
->r_size
;
652 case ALPHA_R_OP_STORE
:
653 /* The STORE reloc needs the size and offset fields. We store
654 them in the addend. */
655 BFD_ASSERT (intern
->r_offset
<= 256 && intern
->r_size
<= 256);
656 rptr
->addend
= (intern
->r_offset
<< 8) + intern
->r_size
;
659 case ALPHA_R_OP_PUSH
:
660 case ALPHA_R_OP_PSUB
:
661 case ALPHA_R_OP_PRSHIFT
:
662 /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
663 address. I believe that the address supplied is really an
665 rptr
->addend
= intern
->r_vaddr
;
668 case ALPHA_R_GPVALUE
:
669 /* Set the addend field to the new GP value. */
670 rptr
->addend
= intern
->r_symndx
+ ecoff_data (abfd
)->gp
;
674 /* If the type is ALPHA_R_IGNORE, make sure this is a reference
675 to the absolute section so that the reloc is ignored. For
676 some reason the address of this reloc type is not adjusted by
677 the section vma. We record the gp value for this object file
678 here, for convenience when doing the GPDISP relocation. */
679 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
680 rptr
->address
= intern
->r_vaddr
;
681 rptr
->addend
= ecoff_data (abfd
)->gp
;
688 rptr
->howto
= &alpha_howto_table
[intern
->r_type
];
691 /* When writing out a reloc we need to pull some values back out of
692 the addend field into the reloc. This is roughly the reverse of
693 alpha_adjust_reloc_in, except that there are several changes we do
697 alpha_adjust_reloc_out (abfd
, rel
, intern
)
700 struct internal_reloc
*intern
;
702 switch (intern
->r_type
)
706 intern
->r_size
= rel
->addend
;
709 case ALPHA_R_OP_STORE
:
710 intern
->r_size
= rel
->addend
& 0xff;
711 intern
->r_offset
= (rel
->addend
>> 8) & 0xff;
714 case ALPHA_R_OP_PUSH
:
715 case ALPHA_R_OP_PSUB
:
716 case ALPHA_R_OP_PRSHIFT
:
717 intern
->r_vaddr
= rel
->addend
;
721 intern
->r_vaddr
= rel
->address
;
722 if (intern
->r_symndx
== RELOC_SECTION_ABS
)
723 intern
->r_symndx
= RELOC_SECTION_NONE
;
731 /* The size of the stack for the relocation evaluator. */
732 #define RELOC_STACKSIZE (10)
734 /* Alpha ECOFF relocs have a built in expression evaluator as well as
735 other interdependencies. Rather than use a bunch of special
736 functions and global variables, we use a single routine to do all
737 the relocation for a section. I haven't yet worked out how the
738 assembler is going to handle this. */
741 alpha_ecoff_get_relocated_section_contents (abfd
, link_info
, link_order
,
742 data
, relocateable
, symbols
)
744 struct bfd_link_info
*link_info
;
745 struct bfd_link_order
*link_order
;
747 boolean relocateable
;
750 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
751 asection
*input_section
= link_order
->u
.indirect
.section
;
752 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
753 arelent
**reloc_vector
= NULL
;
755 bfd
*output_bfd
= relocateable
? abfd
: (bfd
*) NULL
;
757 boolean gp_undefined
;
758 bfd_vma stack
[RELOC_STACKSIZE
];
763 reloc_vector
= (arelent
**) malloc (reloc_size
);
764 if (reloc_vector
== NULL
&& reloc_size
!= 0)
766 bfd_set_error (bfd_error_no_memory
);
770 if (! bfd_get_section_contents (input_bfd
, input_section
, data
,
771 (file_ptr
) 0, input_section
->_raw_size
))
774 /* The section size is not going to change. */
775 input_section
->_cooked_size
= input_section
->_raw_size
;
776 input_section
->reloc_done
= true;
778 reloc_count
= bfd_canonicalize_reloc (input_bfd
, input_section
,
779 reloc_vector
, symbols
);
782 if (reloc_count
== 0)
783 goto successful_return
;
785 /* Get the GP value for the output BFD. */
786 gp_undefined
= false;
787 if (ecoff_data (abfd
)->gp
== 0)
789 if (relocateable
!= false)
794 /* Make up a value. */
796 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
799 && (strcmp (sec
->name
, ".sbss") == 0
800 || strcmp (sec
->name
, ".sdata") == 0
801 || strcmp (sec
->name
, ".lit4") == 0
802 || strcmp (sec
->name
, ".lit8") == 0
803 || strcmp (sec
->name
, ".lita") == 0))
806 ecoff_data (abfd
)->gp
= lo
+ 0x8000;
810 struct bfd_link_hash_entry
*h
;
812 h
= bfd_link_hash_lookup (link_info
->hash
, "_gp", false, false,
814 if (h
== (struct bfd_link_hash_entry
*) NULL
815 || h
->type
!= bfd_link_hash_defined
)
818 ecoff_data (abfd
)->gp
= (h
->u
.def
.value
819 + h
->u
.def
.section
->output_section
->vma
820 + h
->u
.def
.section
->output_offset
);
823 gp
= ecoff_data (abfd
)->gp
;
825 for (; *reloc_vector
!= (arelent
*) NULL
; reloc_vector
++)
828 bfd_reloc_status_type r
;
833 switch (rel
->howto
->type
)
836 rel
->address
+= input_section
->output_offset
;
839 case ALPHA_R_REFLONG
:
840 case ALPHA_R_REFQUAD
:
847 && ((*rel
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
849 rel
->address
+= input_section
->output_offset
;
852 r
= bfd_perform_relocation (input_bfd
, rel
, data
, input_section
,
856 case ALPHA_R_GPREL32
:
857 /* This relocation is used in a switch table. It is a 32
858 bit offset from the current GP value. We must adjust it
859 by the different between the original GP value and the
860 current GP value. The original GP value is stored in the
861 addend. We adjust the addend and let
862 bfd_perform_relocation finish the job. */
864 r
= bfd_perform_relocation (input_bfd
, rel
, data
, input_section
,
866 if (r
== bfd_reloc_ok
&& gp_undefined
)
868 r
= bfd_reloc_dangerous
;
869 err
= (char *) "GP relative relocation used when GP not defined";
873 case ALPHA_R_LITERAL
:
874 /* This is a reference to a literal value, generally
875 (always?) in the .lita section. This is a 16 bit GP
876 relative relocation. Sometimes the subsequent reloc is a
877 LITUSE reloc, which indicates how this reloc is used.
878 This sometimes permits rewriting the two instructions
879 referred to by the LITERAL and the LITUSE into different
880 instructions which do not refer to .lita. This can save
881 a memory reference, and permits removing a value from
882 .lita thus saving GP relative space.
884 We do not these optimizations. To do them we would need
885 to arrange to link the .lita section first, so that by
886 the time we got here we would know the final values to
887 use. This would not be particularly difficult, but it is
888 not currently implemented. */
893 /* I believe that the LITERAL reloc will only apply to a
894 ldq or ldl instruction, so check my assumption. */
895 insn
= bfd_get_32 (input_bfd
, data
+ rel
->address
);
896 BFD_ASSERT (((insn
>> 26) & 0x3f) == 0x29
897 || ((insn
>> 26) & 0x3f) == 0x28);
900 r
= bfd_perform_relocation (input_bfd
, rel
, data
, input_section
,
902 if (r
== bfd_reloc_ok
&& gp_undefined
)
904 r
= bfd_reloc_dangerous
;
906 (char *) "GP relative relocation used when GP not defined";
912 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
913 does not cause anything to happen, itself. */
914 rel
->address
+= input_section
->output_offset
;
918 /* This marks the ldah of an ldah/lda pair which loads the
919 gp register with the difference of the gp value and the
920 current location. The second of the pair is r_size bytes
921 ahead, and is marked with an ALPHA_R_IGNORE reloc. */
923 unsigned long insn1
, insn2
;
926 BFD_ASSERT (reloc_vector
[1] != NULL
927 && reloc_vector
[1]->howto
->type
== ALPHA_R_IGNORE
928 && (rel
->address
+ rel
->addend
929 == reloc_vector
[1]->address
));
931 /* Get the two instructions. */
932 insn1
= bfd_get_32 (input_bfd
, data
+ rel
->address
);
933 insn2
= bfd_get_32 (input_bfd
, data
+ rel
->address
+ rel
->addend
);
935 BFD_ASSERT (((insn1
>> 26) & 0x3f) == 0x09); /* ldah */
936 BFD_ASSERT (((insn2
>> 26) & 0x3f) == 0x08); /* lda */
938 /* Get the existing addend. We must account for the sign
939 extension done by lda and ldah. */
940 addend
= ((insn1
& 0xffff) << 16) + (insn2
& 0xffff);
943 addend
-= 0x80000000;
944 addend
-= 0x80000000;
949 /* The existing addend includes the different between the
950 gp of the input BFD and the address in the input BFD.
951 Subtract this out. */
952 addend
-= (reloc_vector
[1]->addend
953 - (input_section
->vma
+ rel
->address
));
955 /* Now add in the final gp value, and subtract out the
958 - (input_section
->output_section
->vma
959 + input_section
->output_offset
962 /* Change the instructions, accounting for the sign
963 extension, and write them out. */
966 insn1
= (insn1
& 0xffff0000) | ((addend
>> 16) & 0xffff);
967 insn2
= (insn2
& 0xffff0000) | (addend
& 0xffff);
969 bfd_put_32 (input_bfd
, (bfd_vma
) insn1
, data
+ rel
->address
);
970 bfd_put_32 (input_bfd
, (bfd_vma
) insn2
,
971 data
+ rel
->address
+ rel
->addend
);
973 rel
->address
+= input_section
->output_offset
;
977 case ALPHA_R_OP_PUSH
:
978 /* Push a value on the reloc evaluation stack. */
985 rel
->address
+= input_section
->output_offset
;
989 /* Figure out the relocation of this symbol. */
990 symbol
= *rel
->sym_ptr_ptr
;
992 if (bfd_is_und_section (symbol
->section
))
993 r
= bfd_reloc_undefined
;
995 if (bfd_is_com_section (symbol
->section
))
998 relocation
= symbol
->value
;
999 relocation
+= symbol
->section
->output_section
->vma
;
1000 relocation
+= symbol
->section
->output_offset
;
1001 relocation
+= rel
->addend
;
1003 if (tos
>= RELOC_STACKSIZE
)
1006 stack
[tos
++] = relocation
;
1010 case ALPHA_R_OP_STORE
:
1011 /* Store a value from the reloc stack into a bitfield. */
1018 rel
->address
+= input_section
->output_offset
;
1025 /* The offset and size for this reloc are encoded into the
1026 addend field by alpha_adjust_reloc_in. */
1027 offset
= (rel
->addend
>> 8) & 0xff;
1028 size
= rel
->addend
& 0xff;
1030 val
= bfd_get_64 (abfd
, data
+ rel
->address
);
1031 val
&=~ (((1 << size
) - 1) << offset
);
1032 val
|= (stack
[--tos
] & ((1 << size
) - 1)) << offset
;
1033 bfd_put_64 (abfd
, val
, data
+ rel
->address
);
1037 case ALPHA_R_OP_PSUB
:
1038 /* Subtract a value from the top of the stack. */
1045 rel
->address
+= input_section
->output_offset
;
1049 /* Figure out the relocation of this symbol. */
1050 symbol
= *rel
->sym_ptr_ptr
;
1052 if (bfd_is_und_section (symbol
->section
))
1053 r
= bfd_reloc_undefined
;
1055 if (bfd_is_com_section (symbol
->section
))
1058 relocation
= symbol
->value
;
1059 relocation
+= symbol
->section
->output_section
->vma
;
1060 relocation
+= symbol
->section
->output_offset
;
1061 relocation
+= rel
->addend
;
1066 stack
[tos
- 1] -= relocation
;
1070 case ALPHA_R_OP_PRSHIFT
:
1071 /* Shift the value on the top of the stack. */
1078 rel
->address
+= input_section
->output_offset
;
1082 /* Figure out the relocation of this symbol. */
1083 symbol
= *rel
->sym_ptr_ptr
;
1085 if (bfd_is_und_section (symbol
->section
))
1086 r
= bfd_reloc_undefined
;
1088 if (bfd_is_com_section (symbol
->section
))
1091 relocation
= symbol
->value
;
1092 relocation
+= symbol
->section
->output_section
->vma
;
1093 relocation
+= symbol
->section
->output_offset
;
1094 relocation
+= rel
->addend
;
1099 stack
[tos
- 1] >>= relocation
;
1103 case ALPHA_R_GPVALUE
:
1104 /* I really don't know if this does the right thing. */
1106 gp_undefined
= false;
1115 asection
*os
= input_section
->output_section
;
1117 /* A partial link, so keep the relocs. */
1118 os
->orelocation
[os
->reloc_count
] = rel
;
1122 if (r
!= bfd_reloc_ok
)
1126 case bfd_reloc_undefined
:
1127 if (! ((*link_info
->callbacks
->undefined_symbol
)
1128 (link_info
, bfd_asymbol_name (*rel
->sym_ptr_ptr
),
1129 input_bfd
, input_section
, rel
->address
)))
1132 case bfd_reloc_dangerous
:
1133 if (! ((*link_info
->callbacks
->reloc_dangerous
)
1134 (link_info
, err
, input_bfd
, input_section
,
1138 case bfd_reloc_overflow
:
1139 if (! ((*link_info
->callbacks
->reloc_overflow
)
1140 (link_info
, bfd_asymbol_name (*rel
->sym_ptr_ptr
),
1141 rel
->howto
->name
, rel
->addend
, input_bfd
,
1142 input_section
, rel
->address
)))
1145 case bfd_reloc_outofrange
:
1157 if (reloc_vector
!= NULL
)
1158 free (reloc_vector
);
1162 if (reloc_vector
!= NULL
)
1163 free (reloc_vector
);
1167 /* Get the howto structure for a generic reloc type. */
1169 static CONST
struct reloc_howto_struct
*
1170 alpha_bfd_reloc_type_lookup (abfd
, code
)
1172 bfd_reloc_code_real_type code
;
1179 alpha_type
= ALPHA_R_REFLONG
;
1182 case BFD_RELOC_CTOR
:
1183 alpha_type
= ALPHA_R_REFQUAD
;
1185 case BFD_RELOC_GPREL32
:
1186 alpha_type
= ALPHA_R_GPREL32
;
1188 case BFD_RELOC_ALPHA_LITERAL
:
1189 alpha_type
= ALPHA_R_LITERAL
;
1191 case BFD_RELOC_ALPHA_LITUSE
:
1192 alpha_type
= ALPHA_R_LITUSE
;
1194 case BFD_RELOC_ALPHA_GPDISP_HI16
:
1195 alpha_type
= ALPHA_R_GPDISP
;
1197 case BFD_RELOC_ALPHA_GPDISP_LO16
:
1198 alpha_type
= ALPHA_R_IGNORE
;
1200 case BFD_RELOC_23_PCREL_S2
:
1201 alpha_type
= ALPHA_R_BRADDR
;
1203 case BFD_RELOC_ALPHA_HINT
:
1204 alpha_type
= ALPHA_R_HINT
;
1206 case BFD_RELOC_16_PCREL
:
1207 alpha_type
= ALPHA_R_SREL16
;
1209 case BFD_RELOC_32_PCREL
:
1210 alpha_type
= ALPHA_R_SREL32
;
1212 case BFD_RELOC_64_PCREL
:
1213 alpha_type
= ALPHA_R_SREL64
;
1217 alpha_type
= ALPHA_R_OP_PUSH
;
1220 alpha_type
= ALPHA_R_OP_STORE
;
1223 alpha_type
= ALPHA_R_OP_PSUB
;
1226 alpha_type
= ALPHA_R_OP_PRSHIFT
;
1229 alpha_type
= ALPHA_R_GPVALUE
;
1233 return (CONST
struct reloc_howto_struct
*) NULL
;
1236 return &alpha_howto_table
[alpha_type
];
1239 /* A helper routine for alpha_relocate_section which converts an
1240 external reloc when generating relocateable output. Returns the
1241 relocation amount. */
1244 alpha_convert_external_reloc (output_bfd
, info
, input_bfd
, ext_rel
, h
)
1246 struct bfd_link_info
*info
;
1248 struct external_reloc
*ext_rel
;
1249 struct ecoff_link_hash_entry
*h
;
1251 unsigned long r_symndx
;
1254 BFD_ASSERT (info
->relocateable
);
1256 if (h
->root
.type
== bfd_link_hash_defined
)
1261 /* This symbol is defined in the output. Convert the reloc from
1262 being against the symbol to being against the section. */
1264 /* Clear the r_extern bit. */
1265 ext_rel
->r_bits
[1] &=~ RELOC_BITS1_EXTERN_LITTLE
;
1267 /* Compute a new r_symndx value. */
1268 hsec
= h
->root
.u
.def
.section
;
1269 name
= bfd_get_section_name (output_bfd
, hsec
->output_section
);
1275 if (strcmp (name
, "*ABS*") == 0)
1276 r_symndx
= RELOC_SECTION_ABS
;
1279 if (strcmp (name
, ".bss") == 0)
1280 r_symndx
= RELOC_SECTION_BSS
;
1283 if (strcmp (name
, ".data") == 0)
1284 r_symndx
= RELOC_SECTION_DATA
;
1287 if (strcmp (name
, ".fini") == 0)
1288 r_symndx
= RELOC_SECTION_FINI
;
1291 if (strcmp (name
, ".init") == 0)
1292 r_symndx
= RELOC_SECTION_INIT
;
1295 if (strcmp (name
, ".lita") == 0)
1296 r_symndx
= RELOC_SECTION_LITA
;
1297 else if (strcmp (name
, ".lit8") == 0)
1298 r_symndx
= RELOC_SECTION_LIT8
;
1299 else if (strcmp (name
, ".lit4") == 0)
1300 r_symndx
= RELOC_SECTION_LIT4
;
1303 if (strcmp (name
, ".pdata") == 0)
1304 r_symndx
= RELOC_SECTION_PDATA
;
1307 if (strcmp (name
, ".rdata") == 0)
1308 r_symndx
= RELOC_SECTION_RDATA
;
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
;
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
)
1389 bfd_set_error (bfd_error_no_memory
);
1393 symndx_to_section
[RELOC_SECTION_NONE
] = NULL
;
1394 symndx_to_section
[RELOC_SECTION_TEXT
] =
1395 bfd_get_section_by_name (input_bfd
, ".text");
1396 symndx_to_section
[RELOC_SECTION_RDATA
] =
1397 bfd_get_section_by_name (input_bfd
, ".rdata");
1398 symndx_to_section
[RELOC_SECTION_DATA
] =
1399 bfd_get_section_by_name (input_bfd
, ".data");
1400 symndx_to_section
[RELOC_SECTION_SDATA
] =
1401 bfd_get_section_by_name (input_bfd
, ".sdata");
1402 symndx_to_section
[RELOC_SECTION_SBSS
] =
1403 bfd_get_section_by_name (input_bfd
, ".sbss");
1404 symndx_to_section
[RELOC_SECTION_BSS
] =
1405 bfd_get_section_by_name (input_bfd
, ".bss");
1406 symndx_to_section
[RELOC_SECTION_INIT
] =
1407 bfd_get_section_by_name (input_bfd
, ".init");
1408 symndx_to_section
[RELOC_SECTION_LIT8
] =
1409 bfd_get_section_by_name (input_bfd
, ".lit8");
1410 symndx_to_section
[RELOC_SECTION_LIT4
] =
1411 bfd_get_section_by_name (input_bfd
, ".lit4");
1412 symndx_to_section
[RELOC_SECTION_XDATA
] =
1413 bfd_get_section_by_name (input_bfd
, ".xdata");
1414 symndx_to_section
[RELOC_SECTION_PDATA
] =
1415 bfd_get_section_by_name (input_bfd
, ".pdata");
1416 symndx_to_section
[RELOC_SECTION_FINI
] =
1417 bfd_get_section_by_name (input_bfd
, ".fini");
1418 symndx_to_section
[RELOC_SECTION_LITA
] =
1419 bfd_get_section_by_name (input_bfd
, ".lita");
1420 symndx_to_section
[RELOC_SECTION_ABS
] = bfd_abs_section_ptr
;
1422 ecoff_data (input_bfd
)->symndx_to_section
= symndx_to_section
;
1425 sym_hashes
= ecoff_data (input_bfd
)->sym_hashes
;
1427 gp
= ecoff_data (output_bfd
)->gp
;
1429 gp_undefined
= true;
1431 gp_undefined
= false;
1433 BFD_ASSERT (output_bfd
->xvec
->header_byteorder_big_p
== false);
1434 BFD_ASSERT (input_bfd
->xvec
->header_byteorder_big_p
== false);
1436 ext_rel
= (struct external_reloc
*) external_relocs
;
1437 ext_rel_end
= ext_rel
+ input_section
->reloc_count
;
1438 for (; ext_rel
< ext_rel_end
; ext_rel
++)
1441 unsigned long r_symndx
;
1447 boolean adjust_addrp
;
1451 r_vaddr
= bfd_h_get_64 (input_bfd
, (bfd_byte
*) ext_rel
->r_vaddr
);
1452 r_symndx
= bfd_h_get_32 (input_bfd
, (bfd_byte
*) ext_rel
->r_symndx
);
1454 r_type
= ((ext_rel
->r_bits
[0] & RELOC_BITS0_TYPE_LITTLE
)
1455 >> RELOC_BITS0_TYPE_SH_LITTLE
);
1456 r_extern
= (ext_rel
->r_bits
[1] & RELOC_BITS1_EXTERN_LITTLE
) != 0;
1457 r_offset
= ((ext_rel
->r_bits
[1] & RELOC_BITS1_OFFSET_LITTLE
)
1458 >> RELOC_BITS1_OFFSET_SH_LITTLE
);
1459 /* Ignored the reserved bits. */
1460 r_size
= ((ext_rel
->r_bits
[3] & RELOC_BITS3_SIZE_LITTLE
)
1461 >> RELOC_BITS3_SIZE_SH_LITTLE
);
1464 adjust_addrp
= true;
1473 case ALPHA_R_IGNORE
:
1474 /* This reloc appears after a GPDISP reloc. It marks the
1475 position of the second instruction to be altered by the
1476 GPDISP reloc, but is not otherwise used for anything.
1477 For some reason, the address of the relocation does not
1478 appear to include the section VMA, unlike the other
1479 relocation types. */
1480 if (info
->relocateable
)
1481 bfd_h_put_64 (input_bfd
,
1482 input_section
->output_offset
+ r_vaddr
,
1483 (bfd_byte
*) ext_rel
->r_vaddr
);
1484 adjust_addrp
= false;
1487 case ALPHA_R_REFLONG
:
1488 case ALPHA_R_REFQUAD
:
1489 case ALPHA_R_BRADDR
:
1491 case ALPHA_R_SREL16
:
1492 case ALPHA_R_SREL32
:
1493 case ALPHA_R_SREL64
:
1497 case ALPHA_R_GPREL32
:
1498 /* This relocation is used in a switch table. It is a 32
1499 bit offset from the current GP value. We must adjust it
1500 by the different between the original GP value and the
1501 current GP value. */
1503 addend
= ecoff_data (input_bfd
)->gp
- gp
;
1507 case ALPHA_R_LITERAL
:
1508 /* This is a reference to a literal value, generally
1509 (always?) in the .lita section. This is a 16 bit GP
1510 relative relocation. Sometimes the subsequent reloc is a
1511 LITUSE reloc, which indicates how this reloc is used.
1512 This sometimes permits rewriting the two instructions
1513 referred to by the LITERAL and the LITUSE into different
1514 instructions which do not refer to .lita. This can save
1515 a memory reference, and permits removing a value from
1516 .lita thus saving GP relative space.
1518 We do not these optimizations. To do them we would need
1519 to arrange to link the .lita section first, so that by
1520 the time we got here we would know the final values to
1521 use. This would not be particularly difficult, but it is
1522 not currently implemented. */
1524 /* I believe that the LITERAL reloc will only apply to a ldq
1525 or ldl instruction, so check my assumption. */
1529 insn
= bfd_get_32 (input_bfd
,
1530 contents
+ r_vaddr
- input_section
->vma
);
1531 BFD_ASSERT (((insn
>> 26) & 0x3f) == 0x29
1532 || ((insn
>> 26) & 0x3f) == 0x28);
1536 addend
= ecoff_data (input_bfd
)->gp
- gp
;
1540 case ALPHA_R_LITUSE
:
1541 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
1542 does not cause anything to happen, itself. */
1545 case ALPHA_R_GPDISP
:
1546 /* This marks the ldah of an ldah/lda pair which loads the
1547 gp register with the difference of the gp value and the
1548 current location. The second of the pair is r_symndx
1549 bytes ahead, and is also marked with an ALPHA_R_IGNORE
1552 unsigned long insn1
, insn2
;
1554 BFD_ASSERT (ext_rel
+ 1 < ext_rel_end
1555 && (((ext_rel
+ 1)->r_bits
[0]
1556 & RELOC_BITS0_TYPE_LITTLE
)
1557 >> RELOC_BITS0_TYPE_SH_LITTLE
) == ALPHA_R_IGNORE
1558 && (bfd_h_get_64 (input_bfd
,
1559 (bfd_byte
*) (ext_rel
+ 1)->r_vaddr
)
1560 == r_vaddr
- input_section
->vma
+ r_symndx
));
1562 /* Get the two instructions. */
1563 insn1
= bfd_get_32 (input_bfd
,
1564 contents
+ r_vaddr
- input_section
->vma
);
1565 insn2
= bfd_get_32 (input_bfd
,
1568 - input_section
->vma
1571 BFD_ASSERT (((insn1
>> 26) & 0x3f) == 0x09); /* ldah */
1572 BFD_ASSERT (((insn2
>> 26) & 0x3f) == 0x08); /* lda */
1574 /* Get the existing addend. We must account for the sign
1575 extension done by lda and ldah. */
1576 addend
= ((insn1
& 0xffff) << 16) + (insn2
& 0xffff);
1579 /* This is addend -= 0x100000000 without causing an
1580 integer overflow on a 32 bit host. */
1581 addend
-= 0x80000000;
1582 addend
-= 0x80000000;
1587 /* The existing addend includes the difference between the
1588 gp of the input BFD and the address in the input BFD.
1589 We want to change this to the difference between the
1590 final GP and the final address. */
1592 - ecoff_data (input_bfd
)->gp
1593 + input_section
->vma
1594 - (input_section
->output_section
->vma
1595 + input_section
->output_offset
));
1597 /* Change the instructions, accounting for the sign
1598 extension, and write them out. */
1599 if (addend
& 0x8000)
1601 insn1
= (insn1
& 0xffff0000) | ((addend
>> 16) & 0xffff);
1602 insn2
= (insn2
& 0xffff0000) | (addend
& 0xffff);
1604 bfd_put_32 (input_bfd
, (bfd_vma
) insn1
,
1605 contents
+ r_vaddr
- input_section
->vma
);
1606 bfd_put_32 (input_bfd
, (bfd_vma
) insn2
,
1607 contents
+ r_vaddr
- input_section
->vma
+ r_symndx
);
1613 case ALPHA_R_OP_PUSH
:
1614 case ALPHA_R_OP_PSUB
:
1615 case ALPHA_R_OP_PRSHIFT
:
1616 /* Manipulate values on the reloc evaluation stack. The
1617 r_vaddr field is not an address in input_section, it is
1618 the current value (including any addend) of the object
1624 s
= symndx_to_section
[r_symndx
];
1625 if (s
== (asection
*) NULL
)
1627 addend
= s
->output_section
->vma
+ s
->output_offset
- s
->vma
;
1631 struct ecoff_link_hash_entry
*h
;
1633 h
= sym_hashes
[r_symndx
];
1634 if (h
== (struct ecoff_link_hash_entry
*) NULL
)
1637 if (! info
->relocateable
)
1639 if (h
->root
.type
== bfd_link_hash_defined
)
1640 addend
= (h
->root
.u
.def
.value
1641 + h
->root
.u
.def
.section
->output_section
->vma
1642 + h
->root
.u
.def
.section
->output_offset
);
1645 /* Note that we pass the address as 0, since we
1646 do not have a meaningful number for the
1647 location within the section that is being
1649 if (! ((*info
->callbacks
->undefined_symbol
)
1650 (info
, h
->root
.root
.string
, input_bfd
,
1651 input_section
, (bfd_vma
) 0)))
1658 if (h
->root
.type
!= bfd_link_hash_defined
1661 /* This symbol is not being written out. Pass
1662 the address as 0, as with undefined_symbol,
1664 if (! ((*info
->callbacks
->unattached_reloc
)
1665 (info
, h
->root
.root
.string
, input_bfd
,
1666 input_section
, (bfd_vma
) 0)))
1670 addend
= alpha_convert_external_reloc (output_bfd
, info
,
1678 if (info
->relocateable
)
1680 /* Adjust r_vaddr by the addend. */
1681 bfd_h_put_64 (input_bfd
, addend
,
1682 (bfd_byte
*) ext_rel
->r_vaddr
);
1688 case ALPHA_R_OP_PUSH
:
1689 if (tos
>= RELOC_STACKSIZE
)
1691 stack
[tos
++] = addend
;
1694 case ALPHA_R_OP_PSUB
:
1697 stack
[tos
- 1] -= addend
;
1700 case ALPHA_R_OP_PRSHIFT
:
1703 stack
[tos
- 1] >>= addend
;
1708 adjust_addrp
= false;
1711 case ALPHA_R_OP_STORE
:
1712 /* Store a value from the reloc stack into a bitfield. If
1713 we are generating relocateable output, all we do is
1714 adjust the address of the reloc. */
1715 if (! info
->relocateable
)
1723 /* Get the relocation mask. The separate steps and the
1724 casts to bfd_vma are attempts to avoid a bug in the
1725 Alpha OSF 1.3 C compiler. See reloc.c for more
1728 mask
<<= (bfd_vma
) r_size
;
1731 /* FIXME: I don't know what kind of overflow checking,
1732 if any, should be done here. */
1733 val
= bfd_get_64 (input_bfd
,
1734 contents
+ r_vaddr
- input_section
->vma
);
1735 val
&=~ mask
<< (bfd_vma
) r_offset
;
1736 val
|= (stack
[--tos
] & mask
) << (bfd_vma
) r_offset
;
1737 bfd_put_64 (input_bfd
, val
,
1738 contents
+ r_vaddr
- input_section
->vma
);
1742 case ALPHA_R_GPVALUE
:
1743 /* I really don't know if this does the right thing. */
1744 gp
= ecoff_data (input_bfd
)->gp
+ r_symndx
;
1745 gp_undefined
= false;
1751 reloc_howto_type
*howto
;
1752 struct ecoff_link_hash_entry
*h
= NULL
;
1755 bfd_reloc_status_type r
;
1757 /* Perform a relocation. */
1759 howto
= &alpha_howto_table
[r_type
];
1763 h
= sym_hashes
[r_symndx
];
1764 /* If h is NULL, that means that there is a reloc
1765 against an external symbol which we thought was just
1766 a debugging symbol. This should not happen. */
1767 if (h
== (struct ecoff_link_hash_entry
*) NULL
)
1772 if (r_symndx
>= NUM_RELOC_SECTIONS
)
1775 s
= symndx_to_section
[r_symndx
];
1777 if (s
== (asection
*) NULL
)
1781 if (info
->relocateable
)
1783 /* We are generating relocateable output, and must
1784 convert the existing reloc. */
1787 if (h
->root
.type
!= bfd_link_hash_defined
1790 /* This symbol is not being written out. */
1791 if (! ((*info
->callbacks
->unattached_reloc
)
1792 (info
, h
->root
.root
.string
, input_bfd
,
1793 input_section
, r_vaddr
- input_section
->vma
)))
1797 relocation
= alpha_convert_external_reloc (output_bfd
,
1805 /* This is a relocation against a section. Adjust
1806 the value by the amount the section moved. */
1807 relocation
= (s
->output_section
->vma
1812 /* If this is PC relative, the existing object file
1813 appears to already have the reloc worked out. We
1814 must subtract out the old value and add in the new
1816 if (howto
->pc_relative
)
1817 relocation
-= (input_section
->output_section
->vma
1818 + input_section
->output_offset
1819 - input_section
->vma
);
1821 /* Put in any addend. */
1822 relocation
+= addend
;
1824 /* Adjust the contents. */
1825 r
= _bfd_relocate_contents (howto
, input_bfd
, relocation
,
1828 - input_section
->vma
));
1832 /* We are producing a final executable. */
1835 /* This is a reloc against a symbol. */
1836 if (h
->root
.type
== bfd_link_hash_defined
)
1840 hsec
= h
->root
.u
.def
.section
;
1841 relocation
= (h
->root
.u
.def
.value
1842 + hsec
->output_section
->vma
1843 + hsec
->output_offset
);
1847 if (! ((*info
->callbacks
->undefined_symbol
)
1848 (info
, h
->root
.root
.string
, input_bfd
,
1850 r_vaddr
- input_section
->vma
)))
1857 /* This is a reloc against a section. */
1858 relocation
= (s
->output_section
->vma
1862 /* Adjust a PC relative relocation by removing the
1863 reference to the original source section. */
1864 if (howto
->pc_relative
)
1865 relocation
+= input_section
->vma
;
1868 r
= _bfd_final_link_relocate (howto
,
1872 r_vaddr
- input_section
->vma
,
1877 if (r
!= bfd_reloc_ok
)
1882 case bfd_reloc_outofrange
:
1884 case bfd_reloc_overflow
:
1889 name
= sym_hashes
[r_symndx
]->root
.root
.string
;
1891 name
= bfd_section_name (input_bfd
,
1892 symndx_to_section
[r_symndx
]);
1893 if (! ((*info
->callbacks
->reloc_overflow
)
1894 (info
, name
, alpha_howto_table
[r_type
].name
,
1895 (bfd_vma
) 0, input_bfd
, input_section
,
1896 r_vaddr
- input_section
->vma
)))
1904 if (info
->relocateable
&& adjust_addrp
)
1906 /* Change the address of the relocation. */
1907 bfd_h_put_64 (input_bfd
,
1908 (input_section
->output_section
->vma
1909 + input_section
->output_offset
1910 - input_section
->vma
1912 (bfd_byte
*) ext_rel
->r_vaddr
);
1915 if (gp_usedp
&& gp_undefined
)
1917 if (! ((*info
->callbacks
->reloc_dangerous
)
1918 (info
, "GP relative relocation when GP not defined",
1919 input_bfd
, input_section
, r_vaddr
- input_section
->vma
)))
1921 /* Only give the error once per link. */
1922 ecoff_data (output_bfd
)->gp
= gp
= 4;
1923 gp_undefined
= false;
1933 /* This is the ECOFF backend structure. The backend field of the
1934 target vector points to this. */
1936 static const struct ecoff_backend_data alpha_ecoff_backend_data
=
1938 /* COFF backend structure. */
1940 (void (*) PARAMS ((bfd
*,PTR
,int,int,int,int,PTR
))) bfd_void
, /* aux_in */
1941 (void (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* sym_in */
1942 (void (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* lineno_in */
1943 (unsigned (*) PARAMS ((bfd
*,PTR
,int,int,int,int,PTR
)))bfd_void
,/*aux_out*/
1944 (unsigned (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* sym_out */
1945 (unsigned (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* lineno_out */
1946 (unsigned (*) PARAMS ((bfd
*,PTR
,PTR
))) bfd_void
, /* reloc_out */
1947 alpha_ecoff_swap_filehdr_out
, alpha_ecoff_swap_aouthdr_out
,
1948 alpha_ecoff_swap_scnhdr_out
,
1949 FILHSZ
, AOUTSZ
, SCNHSZ
, 0, 0, 0, 0, true,
1950 alpha_ecoff_swap_filehdr_in
, alpha_ecoff_swap_aouthdr_in
,
1951 alpha_ecoff_swap_scnhdr_in
, NULL
,
1952 alpha_ecoff_bad_format_hook
, _bfd_ecoff_set_arch_mach_hook
,
1953 alpha_ecoff_mkobject_hook
, _bfd_ecoff_styp_to_sec_flags
,
1954 _bfd_ecoff_make_section_hook
, _bfd_ecoff_set_alignment_hook
,
1955 _bfd_ecoff_slurp_symbol_table
,
1956 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
1958 /* Supported architecture. */
1960 /* Initial portion of armap string. */
1962 /* The page boundary used to align sections in a demand-paged
1963 executable file. E.g., 0x1000. */
1965 /* True if the .rdata section is part of the text segment, as on the
1966 Alpha. False if .rdata is part of the data segment, as on the
1969 /* Bitsize of constructor entries. */
1971 /* Reloc to use for constructor entries. */
1972 &alpha_howto_table
[ALPHA_R_REFQUAD
],
1974 /* Symbol table magic number. */
1976 /* Alignment of debugging information. E.g., 4. */
1978 /* Sizes of external symbolic information. */
1979 sizeof (struct hdr_ext
),
1980 sizeof (struct dnr_ext
),
1981 sizeof (struct pdr_ext
),
1982 sizeof (struct sym_ext
),
1983 sizeof (struct opt_ext
),
1984 sizeof (struct fdr_ext
),
1985 sizeof (struct rfd_ext
),
1986 sizeof (struct ext_ext
),
1987 /* Functions to swap in external symbolic data. */
1996 _bfd_ecoff_swap_tir_in
,
1997 _bfd_ecoff_swap_rndx_in
,
1998 /* Functions to swap out external symbolic data. */
2007 _bfd_ecoff_swap_tir_out
,
2008 _bfd_ecoff_swap_rndx_out
,
2009 /* Function to read in symbolic data. */
2010 _bfd_ecoff_slurp_symbolic_info
2012 /* External reloc size. */
2014 /* Reloc swapping functions. */
2015 alpha_ecoff_swap_reloc_in
,
2016 alpha_ecoff_swap_reloc_out
,
2017 /* Backend reloc tweaking. */
2018 alpha_adjust_reloc_in
,
2019 alpha_adjust_reloc_out
,
2020 /* Relocate section contents while linking. */
2021 alpha_relocate_section
2024 /* Looking up a reloc type is Alpha specific. */
2025 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2027 /* So is getting relocated section contents. */
2028 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2029 alpha_ecoff_get_relocated_section_contents
2031 /* Relaxing sections is generic. */
2032 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2034 const bfd_target ecoffalpha_little_vec
=
2036 "ecoff-littlealpha", /* name */
2037 bfd_target_ecoff_flavour
,
2038 false, /* data byte order is little */
2039 false, /* header byte order is little */
2041 (HAS_RELOC
| EXEC_P
| /* object flags */
2042 HAS_LINENO
| HAS_DEBUG
|
2043 HAS_SYMS
| HAS_LOCALS
| DYNAMIC
| WP_TEXT
| D_PAGED
),
2045 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
), /* sect
2047 0, /* leading underscore */
2048 ' ', /* ar_pad_char */
2049 15, /* ar_max_namelen */
2050 4, /* minimum alignment power */
2051 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2052 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2053 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* data */
2054 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2055 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2056 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* hdrs */
2058 {_bfd_dummy_target
, alpha_ecoff_object_p
, /* bfd_check_format */
2059 _bfd_ecoff_archive_p
, _bfd_dummy_target
},
2060 {bfd_false
, _bfd_ecoff_mkobject
, /* bfd_set_format */
2061 _bfd_generic_mkarchive
, bfd_false
},
2062 {bfd_false
, _bfd_ecoff_write_object_contents
, /* bfd_write_contents */
2063 _bfd_write_archive_contents
, bfd_false
},
2065 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff
),
2066 BFD_JUMP_TABLE_COPY (_bfd_ecoff
),
2067 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
2068 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff
),
2069 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff
),
2070 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff
),
2071 BFD_JUMP_TABLE_WRITE (_bfd_ecoff
),
2072 BFD_JUMP_TABLE_LINK (_bfd_ecoff
),
2073 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
2075 (PTR
) &alpha_ecoff_backend_data