1 /* BFD back-end for ALPHA Extended-Coff files.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005 Free Software Foundation, Inc.
4 Modified from coff-mips.c by Steve Chamberlain <sac@cygnus.com> and
5 Ian Lance Taylor <ian@cygnus.com>.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
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.
13
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.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "coff/internal.h"
28 #include "coff/sym.h"
29 #include "coff/symconst.h"
30 #include "coff/ecoff.h"
31 #include "coff/alpha.h"
32 #include "aout/ar.h"
33 #include "libcoff.h"
34 #include "libecoff.h"
35
36 /* Prototypes for static functions. */
37
38 static const bfd_target *alpha_ecoff_object_p
39 PARAMS ((bfd *));
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
65 PARAMS ((bfd *));
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));
72
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.
78
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. */
82
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
109
110 #define ALPHAECOFF
111
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"
122
123 /* Get the ECOFF swapping routines. */
124 #define ECOFF_64
125 #include "ecoffswap.h"
126
127 /* How to process the various reloc types. */
128
129 static bfd_reloc_status_type reloc_nil
130 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
131
132 static bfd_reloc_status_type
reloc_nil(abfd,reloc,sym,data,sec,output_bfd,error_message)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;
141 {
142 return bfd_reloc_ok;
143 }
144
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)
148
149 static reloc_howto_type alpha_howto_table[] =
150 {
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 */
155 0, /* rightshift */
156 0, /* size (0 = byte, 1 = short, 2 = long) */
157 8, /* bitsize */
158 TRUE, /* pc_relative */
159 0, /* bitpos */
160 complain_overflow_dont, /* complain_on_overflow */
161 reloc_nil, /* special_function */
162 "IGNORE", /* name */
163 TRUE, /* partial_inplace */
164 0, /* src_mask */
165 0, /* dst_mask */
166 TRUE), /* pcrel_offset */
167
168 /* A 32 bit reference to a symbol. */
169 HOWTO (ALPHA_R_REFLONG, /* type */
170 0, /* rightshift */
171 2, /* size (0 = byte, 1 = short, 2 = long) */
172 32, /* bitsize */
173 FALSE, /* pc_relative */
174 0, /* bitpos */
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 */
182
183 /* A 64 bit reference to a symbol. */
184 HOWTO (ALPHA_R_REFQUAD, /* type */
185 0, /* rightshift */
186 4, /* size (0 = byte, 1 = short, 2 = long) */
187 64, /* bitsize */
188 FALSE, /* pc_relative */
189 0, /* bitpos */
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 */
197
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
200 added in. */
201 HOWTO (ALPHA_R_GPREL32, /* type */
202 0, /* rightshift */
203 2, /* size (0 = byte, 1 = short, 2 = long) */
204 32, /* bitsize */
205 FALSE, /* pc_relative */
206 0, /* bitpos */
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 */
214
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 */
219 0, /* rightshift */
220 2, /* size (0 = byte, 1 = short, 2 = long) */
221 16, /* bitsize */
222 FALSE, /* pc_relative */
223 0, /* bitpos */
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 */
231
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
240 relocation. */
241 HOWTO (ALPHA_R_LITUSE, /* type */
242 0, /* rightshift */
243 2, /* size (0 = byte, 1 = short, 2 = long) */
244 32, /* bitsize */
245 FALSE, /* pc_relative */
246 0, /* bitpos */
247 complain_overflow_dont, /* complain_on_overflow */
248 reloc_nil, /* special_function */
249 "LITUSE", /* name */
250 FALSE, /* partial_inplace */
251 0, /* src_mask */
252 0, /* dst_mask */
253 FALSE), /* pcrel_offset */
254
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
265 address. */
266 HOWTO (ALPHA_R_GPDISP, /* type */
267 16, /* rightshift */
268 2, /* size (0 = byte, 1 = short, 2 = long) */
269 16, /* bitsize */
270 TRUE, /* pc_relative */
271 0, /* bitpos */
272 complain_overflow_dont, /* complain_on_overflow */
273 reloc_nil, /* special_function */
274 "GPDISP", /* name */
275 TRUE, /* partial_inplace */
276 0xffff, /* src_mask */
277 0xffff, /* dst_mask */
278 TRUE), /* pcrel_offset */
279
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 */
284 2, /* rightshift */
285 2, /* size (0 = byte, 1 = short, 2 = long) */
286 21, /* bitsize */
287 TRUE, /* pc_relative */
288 0, /* bitpos */
289 complain_overflow_signed, /* complain_on_overflow */
290 0, /* special_function */
291 "BRADDR", /* name */
292 TRUE, /* partial_inplace */
293 0x1fffff, /* src_mask */
294 0x1fffff, /* dst_mask */
295 FALSE), /* pcrel_offset */
296
297 /* A hint for a jump to a register. */
298 HOWTO (ALPHA_R_HINT, /* type */
299 2, /* rightshift */
300 2, /* size (0 = byte, 1 = short, 2 = long) */
301 14, /* bitsize */
302 TRUE, /* pc_relative */
303 0, /* bitpos */
304 complain_overflow_dont, /* complain_on_overflow */
305 0, /* special_function */
306 "HINT", /* name */
307 TRUE, /* partial_inplace */
308 0x3fff, /* src_mask */
309 0x3fff, /* dst_mask */
310 FALSE), /* pcrel_offset */
311
312 /* 16 bit PC relative offset. */
313 HOWTO (ALPHA_R_SREL16, /* type */
314 0, /* rightshift */
315 1, /* size (0 = byte, 1 = short, 2 = long) */
316 16, /* bitsize */
317 TRUE, /* pc_relative */
318 0, /* bitpos */
319 complain_overflow_signed, /* complain_on_overflow */
320 0, /* special_function */
321 "SREL16", /* name */
322 TRUE, /* partial_inplace */
323 0xffff, /* src_mask */
324 0xffff, /* dst_mask */
325 FALSE), /* pcrel_offset */
326
327 /* 32 bit PC relative offset. */
328 HOWTO (ALPHA_R_SREL32, /* type */
329 0, /* rightshift */
330 2, /* size (0 = byte, 1 = short, 2 = long) */
331 32, /* bitsize */
332 TRUE, /* pc_relative */
333 0, /* bitpos */
334 complain_overflow_signed, /* complain_on_overflow */
335 0, /* special_function */
336 "SREL32", /* name */
337 TRUE, /* partial_inplace */
338 0xffffffff, /* src_mask */
339 0xffffffff, /* dst_mask */
340 FALSE), /* pcrel_offset */
341
342 /* A 64 bit PC relative offset. */
343 HOWTO (ALPHA_R_SREL64, /* type */
344 0, /* rightshift */
345 4, /* size (0 = byte, 1 = short, 2 = long) */
346 64, /* bitsize */
347 TRUE, /* pc_relative */
348 0, /* bitpos */
349 complain_overflow_signed, /* complain_on_overflow */
350 0, /* special_function */
351 "SREL64", /* name */
352 TRUE, /* partial_inplace */
353 MINUS_ONE, /* src_mask */
354 MINUS_ONE, /* dst_mask */
355 FALSE), /* pcrel_offset */
356
357 /* Push a value on the reloc evaluation stack. */
358 HOWTO (ALPHA_R_OP_PUSH, /* type */
359 0, /* rightshift */
360 0, /* size (0 = byte, 1 = short, 2 = long) */
361 0, /* bitsize */
362 FALSE, /* pc_relative */
363 0, /* bitpos */
364 complain_overflow_dont, /* complain_on_overflow */
365 0, /* special_function */
366 "OP_PUSH", /* name */
367 FALSE, /* partial_inplace */
368 0, /* src_mask */
369 0, /* dst_mask */
370 FALSE), /* pcrel_offset */
371
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 */
375 0, /* rightshift */
376 4, /* size (0 = byte, 1 = short, 2 = long) */
377 64, /* bitsize */
378 FALSE, /* pc_relative */
379 0, /* bitpos */
380 complain_overflow_dont, /* complain_on_overflow */
381 0, /* special_function */
382 "OP_STORE", /* name */
383 FALSE, /* partial_inplace */
384 0, /* src_mask */
385 MINUS_ONE, /* dst_mask */
386 FALSE), /* pcrel_offset */
387
388 /* Subtract the reloc address from the value on the top of the
389 relocation stack. */
390 HOWTO (ALPHA_R_OP_PSUB, /* type */
391 0, /* rightshift */
392 0, /* size (0 = byte, 1 = short, 2 = long) */
393 0, /* bitsize */
394 FALSE, /* pc_relative */
395 0, /* bitpos */
396 complain_overflow_dont, /* complain_on_overflow */
397 0, /* special_function */
398 "OP_PSUB", /* name */
399 FALSE, /* partial_inplace */
400 0, /* src_mask */
401 0, /* dst_mask */
402 FALSE), /* pcrel_offset */
403
404 /* Shift the value on the top of the relocation stack right by the
405 given value. */
406 HOWTO (ALPHA_R_OP_PRSHIFT, /* type */
407 0, /* rightshift */
408 0, /* size (0 = byte, 1 = short, 2 = long) */
409 0, /* bitsize */
410 FALSE, /* pc_relative */
411 0, /* bitpos */
412 complain_overflow_dont, /* complain_on_overflow */
413 0, /* special_function */
414 "OP_PRSHIFT", /* name */
415 FALSE, /* partial_inplace */
416 0, /* src_mask */
417 0, /* dst_mask */
418 FALSE), /* pcrel_offset */
419
420 /* Adjust the GP value for a new range in the object file. */
421 HOWTO (ALPHA_R_GPVALUE, /* type */
422 0, /* rightshift */
423 0, /* size (0 = byte, 1 = short, 2 = long) */
424 0, /* bitsize */
425 FALSE, /* pc_relative */
426 0, /* bitpos */
427 complain_overflow_dont, /* complain_on_overflow */
428 0, /* special_function */
429 "GPVALUE", /* name */
430 FALSE, /* partial_inplace */
431 0, /* src_mask */
432 0, /* dst_mask */
433 FALSE) /* pcrel_offset */
434 };
435
436 /* Recognize an Alpha ECOFF file. */
437
438 static const bfd_target *
alpha_ecoff_object_p(abfd)439 alpha_ecoff_object_p (abfd)
440 bfd *abfd;
441 {
442 static const bfd_target *ret;
443
444 ret = coff_object_p (abfd);
445
446 if (ret != NULL)
447 {
448 asection *sec;
449
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
458 alignment. */
459 sec = bfd_get_section_by_name (abfd, _PDATA);
460 if (sec != (asection *) NULL)
461 {
462 bfd_size_type size;
463
464 size = sec->line_filepos * 8;
465 BFD_ASSERT (size == sec->size
466 || size + 8 == sec->size);
467 if (! bfd_set_section_size (abfd, sec, size))
468 return NULL;
469 }
470 }
471
472 return ret;
473 }
474
475 /* See whether the magic number matches. */
476
477 static bfd_boolean
alpha_ecoff_bad_format_hook(abfd,filehdr)478 alpha_ecoff_bad_format_hook (abfd, filehdr)
479 bfd *abfd ATTRIBUTE_UNUSED;
480 PTR filehdr;
481 {
482 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
483
484 if (! ALPHA_ECOFF_BADMAG (*internal_f))
485 return TRUE;
486
487 if (ALPHA_ECOFF_COMPRESSEDMAG (*internal_f))
488 (*_bfd_error_handler)
489 (_("%B: Cannot handle compressed Alpha binaries.\n"
490 " Use compiler flags, or objZ, to generate uncompressed binaries."),
491 abfd);
492
493 return FALSE;
494 }
495
496 /* This is a hook called by coff_real_object_p to create any backend
497 specific information. */
498
499 static PTR
alpha_ecoff_mkobject_hook(abfd,filehdr,aouthdr)500 alpha_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
501 bfd *abfd;
502 PTR filehdr;
503 PTR aouthdr;
504 {
505 PTR ecoff;
506
507 ecoff = _bfd_ecoff_mkobject_hook (abfd, filehdr, aouthdr);
508
509 if (ecoff != NULL)
510 {
511 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
512
513 /* Set additional BFD flags according to the object type from the
514 machine specific file header flags. */
515 switch (internal_f->f_flags & F_ALPHA_OBJECT_TYPE_MASK)
516 {
517 case F_ALPHA_SHARABLE:
518 abfd->flags |= DYNAMIC;
519 break;
520 case F_ALPHA_CALL_SHARED:
521 /* Always executable if using shared libraries as the run time
522 loader might resolve undefined references. */
523 abfd->flags |= (DYNAMIC | EXEC_P);
524 break;
525 }
526 }
527 return ecoff;
528 }
529
530 /* Reloc handling. */
531
532 /* Swap a reloc in. */
533
534 static void
alpha_ecoff_swap_reloc_in(abfd,ext_ptr,intern)535 alpha_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
536 bfd *abfd;
537 PTR ext_ptr;
538 struct internal_reloc *intern;
539 {
540 const RELOC *ext = (RELOC *) ext_ptr;
541
542 intern->r_vaddr = H_GET_64 (abfd, ext->r_vaddr);
543 intern->r_symndx = H_GET_32 (abfd, ext->r_symndx);
544
545 BFD_ASSERT (bfd_header_little_endian (abfd));
546
547 intern->r_type = ((ext->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
548 >> RELOC_BITS0_TYPE_SH_LITTLE);
549 intern->r_extern = (ext->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
550 intern->r_offset = ((ext->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
551 >> RELOC_BITS1_OFFSET_SH_LITTLE);
552 /* Ignored the reserved bits. */
553 intern->r_size = ((ext->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
554 >> RELOC_BITS3_SIZE_SH_LITTLE);
555
556 if (intern->r_type == ALPHA_R_LITUSE
557 || intern->r_type == ALPHA_R_GPDISP)
558 {
559 /* Handle the LITUSE and GPDISP relocs specially. Its symndx
560 value is not actually a symbol index, but is instead a
561 special code. We put the code in the r_size field, and
562 clobber the symndx. */
563 if (intern->r_size != 0)
564 abort ();
565 intern->r_size = intern->r_symndx;
566 intern->r_symndx = RELOC_SECTION_NONE;
567 }
568 else if (intern->r_type == ALPHA_R_IGNORE)
569 {
570 /* The IGNORE reloc generally follows a GPDISP reloc, and is
571 against the .lita section. The section is irrelevant. */
572 if (! intern->r_extern &&
573 intern->r_symndx == RELOC_SECTION_ABS)
574 abort ();
575 if (! intern->r_extern && intern->r_symndx == RELOC_SECTION_LITA)
576 intern->r_symndx = RELOC_SECTION_ABS;
577 }
578 }
579
580 /* Swap a reloc out. */
581
582 static void
alpha_ecoff_swap_reloc_out(abfd,intern,dst)583 alpha_ecoff_swap_reloc_out (abfd, intern, dst)
584 bfd *abfd;
585 const struct internal_reloc *intern;
586 PTR dst;
587 {
588 RELOC *ext = (RELOC *) dst;
589 long symndx;
590 unsigned char size;
591
592 /* Undo the hackery done in swap_reloc_in. */
593 if (intern->r_type == ALPHA_R_LITUSE
594 || intern->r_type == ALPHA_R_GPDISP)
595 {
596 symndx = intern->r_size;
597 size = 0;
598 }
599 else if (intern->r_type == ALPHA_R_IGNORE
600 && ! intern->r_extern
601 && intern->r_symndx == RELOC_SECTION_ABS)
602 {
603 symndx = RELOC_SECTION_LITA;
604 size = intern->r_size;
605 }
606 else
607 {
608 symndx = intern->r_symndx;
609 size = intern->r_size;
610 }
611
612 /* XXX FIXME: The maximum symndx value used to be 14 but this
613 fails with object files produced by DEC's C++ compiler.
614 Where does the value 14 (or 15) come from anyway ? */
615 BFD_ASSERT (intern->r_extern
616 || (intern->r_symndx >= 0 && intern->r_symndx <= 15));
617
618 H_PUT_64 (abfd, intern->r_vaddr, ext->r_vaddr);
619 H_PUT_32 (abfd, symndx, ext->r_symndx);
620
621 BFD_ASSERT (bfd_header_little_endian (abfd));
622
623 ext->r_bits[0] = ((intern->r_type << RELOC_BITS0_TYPE_SH_LITTLE)
624 & RELOC_BITS0_TYPE_LITTLE);
625 ext->r_bits[1] = ((intern->r_extern ? RELOC_BITS1_EXTERN_LITTLE : 0)
626 | ((intern->r_offset << RELOC_BITS1_OFFSET_SH_LITTLE)
627 & RELOC_BITS1_OFFSET_LITTLE));
628 ext->r_bits[2] = 0;
629 ext->r_bits[3] = ((size << RELOC_BITS3_SIZE_SH_LITTLE)
630 & RELOC_BITS3_SIZE_LITTLE);
631 }
632
633 /* Finish canonicalizing a reloc. Part of this is generic to all
634 ECOFF targets, and that part is in ecoff.c. The rest is done in
635 this backend routine. It must fill in the howto field. */
636
637 static void
alpha_adjust_reloc_in(abfd,intern,rptr)638 alpha_adjust_reloc_in (abfd, intern, rptr)
639 bfd *abfd;
640 const struct internal_reloc *intern;
641 arelent *rptr;
642 {
643 if (intern->r_type > ALPHA_R_GPVALUE)
644 {
645 (*_bfd_error_handler)
646 (_("%B: unknown/unsupported relocation type %d"),
647 abfd, intern->r_type);
648 bfd_set_error (bfd_error_bad_value);
649 rptr->addend = 0;
650 rptr->howto = NULL;
651 return;
652 }
653
654 switch (intern->r_type)
655 {
656 case ALPHA_R_BRADDR:
657 case ALPHA_R_SREL16:
658 case ALPHA_R_SREL32:
659 case ALPHA_R_SREL64:
660 /* This relocs appear to be fully resolved when they are against
661 internal symbols. Against external symbols, BRADDR at least
662 appears to be resolved against the next instruction. */
663 if (! intern->r_extern)
664 rptr->addend = 0;
665 else
666 rptr->addend = - (intern->r_vaddr + 4);
667 break;
668
669 case ALPHA_R_GPREL32:
670 case ALPHA_R_LITERAL:
671 /* Copy the gp value for this object file into the addend, to
672 ensure that we are not confused by the linker. */
673 if (! intern->r_extern)
674 rptr->addend += ecoff_data (abfd)->gp;
675 break;
676
677 case ALPHA_R_LITUSE:
678 case ALPHA_R_GPDISP:
679 /* The LITUSE and GPDISP relocs do not use a symbol, or an
680 addend, but they do use a special code. Put this code in the
681 addend field. */
682 rptr->addend = intern->r_size;
683 break;
684
685 case ALPHA_R_OP_STORE:
686 /* The STORE reloc needs the size and offset fields. We store
687 them in the addend. */
688 BFD_ASSERT (intern->r_offset <= 256);
689 rptr->addend = (intern->r_offset << 8) + intern->r_size;
690 break;
691
692 case ALPHA_R_OP_PUSH:
693 case ALPHA_R_OP_PSUB:
694 case ALPHA_R_OP_PRSHIFT:
695 /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
696 address. I believe that the address supplied is really an
697 addend. */
698 rptr->addend = intern->r_vaddr;
699 break;
700
701 case ALPHA_R_GPVALUE:
702 /* Set the addend field to the new GP value. */
703 rptr->addend = intern->r_symndx + ecoff_data (abfd)->gp;
704 break;
705
706 case ALPHA_R_IGNORE:
707 /* If the type is ALPHA_R_IGNORE, make sure this is a reference
708 to the absolute section so that the reloc is ignored. For
709 some reason the address of this reloc type is not adjusted by
710 the section vma. We record the gp value for this object file
711 here, for convenience when doing the GPDISP relocation. */
712 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
713 rptr->address = intern->r_vaddr;
714 rptr->addend = ecoff_data (abfd)->gp;
715 break;
716
717 default:
718 break;
719 }
720
721 rptr->howto = &alpha_howto_table[intern->r_type];
722 }
723
724 /* When writing out a reloc we need to pull some values back out of
725 the addend field into the reloc. This is roughly the reverse of
726 alpha_adjust_reloc_in, except that there are several changes we do
727 not need to undo. */
728
729 static void
alpha_adjust_reloc_out(abfd,rel,intern)730 alpha_adjust_reloc_out (abfd, rel, intern)
731 bfd *abfd ATTRIBUTE_UNUSED;
732 const arelent *rel;
733 struct internal_reloc *intern;
734 {
735 switch (intern->r_type)
736 {
737 case ALPHA_R_LITUSE:
738 case ALPHA_R_GPDISP:
739 intern->r_size = rel->addend;
740 break;
741
742 case ALPHA_R_OP_STORE:
743 intern->r_size = rel->addend & 0xff;
744 intern->r_offset = (rel->addend >> 8) & 0xff;
745 break;
746
747 case ALPHA_R_OP_PUSH:
748 case ALPHA_R_OP_PSUB:
749 case ALPHA_R_OP_PRSHIFT:
750 intern->r_vaddr = rel->addend;
751 break;
752
753 case ALPHA_R_IGNORE:
754 intern->r_vaddr = rel->address;
755 break;
756
757 default:
758 break;
759 }
760 }
761
762 /* The size of the stack for the relocation evaluator. */
763 #define RELOC_STACKSIZE (10)
764
765 /* Alpha ECOFF relocs have a built in expression evaluator as well as
766 other interdependencies. Rather than use a bunch of special
767 functions and global variables, we use a single routine to do all
768 the relocation for a section. I haven't yet worked out how the
769 assembler is going to handle this. */
770
771 static bfd_byte *
alpha_ecoff_get_relocated_section_contents(abfd,link_info,link_order,data,relocatable,symbols)772 alpha_ecoff_get_relocated_section_contents (abfd, link_info, link_order,
773 data, relocatable, symbols)
774 bfd *abfd;
775 struct bfd_link_info *link_info;
776 struct bfd_link_order *link_order;
777 bfd_byte *data;
778 bfd_boolean relocatable;
779 asymbol **symbols;
780 {
781 bfd *input_bfd = link_order->u.indirect.section->owner;
782 asection *input_section = link_order->u.indirect.section;
783 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
784 arelent **reloc_vector = NULL;
785 long reloc_count;
786 bfd *output_bfd = relocatable ? abfd : (bfd *) NULL;
787 bfd_vma gp;
788 bfd_size_type sz;
789 bfd_boolean gp_undefined;
790 bfd_vma stack[RELOC_STACKSIZE];
791 int tos = 0;
792
793 if (reloc_size < 0)
794 goto error_return;
795 reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
796 if (reloc_vector == NULL && reloc_size != 0)
797 goto error_return;
798
799 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
800 if (! bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
801 goto error_return;
802
803 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
804 reloc_vector, symbols);
805 if (reloc_count < 0)
806 goto error_return;
807 if (reloc_count == 0)
808 goto successful_return;
809
810 /* Get the GP value for the output BFD. */
811 gp_undefined = FALSE;
812 gp = _bfd_get_gp_value (abfd);
813 if (gp == 0)
814 {
815 if (relocatable)
816 {
817 asection *sec;
818 bfd_vma lo;
819
820 /* Make up a value. */
821 lo = (bfd_vma) -1;
822 for (sec = abfd->sections; sec != NULL; sec = sec->next)
823 {
824 if (sec->vma < lo
825 && (strcmp (sec->name, ".sbss") == 0
826 || strcmp (sec->name, ".sdata") == 0
827 || strcmp (sec->name, ".lit4") == 0
828 || strcmp (sec->name, ".lit8") == 0
829 || strcmp (sec->name, ".lita") == 0))
830 lo = sec->vma;
831 }
832 gp = lo + 0x8000;
833 _bfd_set_gp_value (abfd, gp);
834 }
835 else
836 {
837 struct bfd_link_hash_entry *h;
838
839 h = bfd_link_hash_lookup (link_info->hash, "_gp", FALSE, FALSE,
840 TRUE);
841 if (h == (struct bfd_link_hash_entry *) NULL
842 || h->type != bfd_link_hash_defined)
843 gp_undefined = TRUE;
844 else
845 {
846 gp = (h->u.def.value
847 + h->u.def.section->output_section->vma
848 + h->u.def.section->output_offset);
849 _bfd_set_gp_value (abfd, gp);
850 }
851 }
852 }
853
854 for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
855 {
856 arelent *rel;
857 bfd_reloc_status_type r;
858 char *err;
859
860 rel = *reloc_vector;
861 r = bfd_reloc_ok;
862 switch (rel->howto->type)
863 {
864 case ALPHA_R_IGNORE:
865 rel->address += input_section->output_offset;
866 break;
867
868 case ALPHA_R_REFLONG:
869 case ALPHA_R_REFQUAD:
870 case ALPHA_R_BRADDR:
871 case ALPHA_R_HINT:
872 case ALPHA_R_SREL16:
873 case ALPHA_R_SREL32:
874 case ALPHA_R_SREL64:
875 if (relocatable
876 && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
877 {
878 rel->address += input_section->output_offset;
879 break;
880 }
881 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
882 output_bfd, &err);
883 break;
884
885 case ALPHA_R_GPREL32:
886 /* This relocation is used in a switch table. It is a 32
887 bit offset from the current GP value. We must adjust it
888 by the different between the original GP value and the
889 current GP value. The original GP value is stored in the
890 addend. We adjust the addend and let
891 bfd_perform_relocation finish the job. */
892 rel->addend -= gp;
893 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
894 output_bfd, &err);
895 if (r == bfd_reloc_ok && gp_undefined)
896 {
897 r = bfd_reloc_dangerous;
898 err = (char *) _("GP relative relocation used when GP not defined");
899 }
900 break;
901
902 case ALPHA_R_LITERAL:
903 /* This is a reference to a literal value, generally
904 (always?) in the .lita section. This is a 16 bit GP
905 relative relocation. Sometimes the subsequent reloc is a
906 LITUSE reloc, which indicates how this reloc is used.
907 This sometimes permits rewriting the two instructions
908 referred to by the LITERAL and the LITUSE into different
909 instructions which do not refer to .lita. This can save
910 a memory reference, and permits removing a value from
911 .lita thus saving GP relative space.
912
913 We do not these optimizations. To do them we would need
914 to arrange to link the .lita section first, so that by
915 the time we got here we would know the final values to
916 use. This would not be particularly difficult, but it is
917 not currently implemented. */
918
919 {
920 unsigned long insn;
921
922 /* I believe that the LITERAL reloc will only apply to a
923 ldq or ldl instruction, so check my assumption. */
924 insn = bfd_get_32 (input_bfd, data + rel->address);
925 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
926 || ((insn >> 26) & 0x3f) == 0x28);
927
928 rel->addend -= gp;
929 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
930 output_bfd, &err);
931 if (r == bfd_reloc_ok && gp_undefined)
932 {
933 r = bfd_reloc_dangerous;
934 err =
935 (char *) _("GP relative relocation used when GP not defined");
936 }
937 }
938 break;
939
940 case ALPHA_R_LITUSE:
941 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
942 does not cause anything to happen, itself. */
943 rel->address += input_section->output_offset;
944 break;
945
946 case ALPHA_R_GPDISP:
947 /* This marks the ldah of an ldah/lda pair which loads the
948 gp register with the difference of the gp value and the
949 current location. The second of the pair is r_size bytes
950 ahead; it used to be marked with an ALPHA_R_IGNORE reloc,
951 but that no longer happens in OSF/1 3.2. */
952 {
953 unsigned long insn1, insn2;
954 bfd_vma addend;
955
956 /* Get the two instructions. */
957 insn1 = bfd_get_32 (input_bfd, data + rel->address);
958 insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend);
959
960 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
961 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
962
963 /* Get the existing addend. We must account for the sign
964 extension done by lda and ldah. */
965 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
966 if (insn1 & 0x8000)
967 {
968 addend -= 0x80000000;
969 addend -= 0x80000000;
970 }
971 if (insn2 & 0x8000)
972 addend -= 0x10000;
973
974 /* The existing addend includes the different between the
975 gp of the input BFD and the address in the input BFD.
976 Subtract this out. */
977 addend -= (ecoff_data (input_bfd)->gp
978 - (input_section->vma + rel->address));
979
980 /* Now add in the final gp value, and subtract out the
981 final address. */
982 addend += (gp
983 - (input_section->output_section->vma
984 + input_section->output_offset
985 + rel->address));
986
987 /* Change the instructions, accounting for the sign
988 extension, and write them out. */
989 if (addend & 0x8000)
990 addend += 0x10000;
991 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
992 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
993
994 bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address);
995 bfd_put_32 (input_bfd, (bfd_vma) insn2,
996 data + rel->address + rel->addend);
997
998 rel->address += input_section->output_offset;
999 }
1000 break;
1001
1002 case ALPHA_R_OP_PUSH:
1003 /* Push a value on the reloc evaluation stack. */
1004 {
1005 asymbol *symbol;
1006 bfd_vma relocation;
1007
1008 if (relocatable)
1009 {
1010 rel->address += input_section->output_offset;
1011 break;
1012 }
1013
1014 /* Figure out the relocation of this symbol. */
1015 symbol = *rel->sym_ptr_ptr;
1016
1017 if (bfd_is_und_section (symbol->section))
1018 r = bfd_reloc_undefined;
1019
1020 if (bfd_is_com_section (symbol->section))
1021 relocation = 0;
1022 else
1023 relocation = symbol->value;
1024 relocation += symbol->section->output_section->vma;
1025 relocation += symbol->section->output_offset;
1026 relocation += rel->addend;
1027
1028 if (tos >= RELOC_STACKSIZE)
1029 abort ();
1030
1031 stack[tos++] = relocation;
1032 }
1033 break;
1034
1035 case ALPHA_R_OP_STORE:
1036 /* Store a value from the reloc stack into a bitfield. */
1037 {
1038 bfd_vma val;
1039 int offset, size;
1040
1041 if (relocatable)
1042 {
1043 rel->address += input_section->output_offset;
1044 break;
1045 }
1046
1047 if (tos == 0)
1048 abort ();
1049
1050 /* The offset and size for this reloc are encoded into the
1051 addend field by alpha_adjust_reloc_in. */
1052 offset = (rel->addend >> 8) & 0xff;
1053 size = rel->addend & 0xff;
1054
1055 val = bfd_get_64 (abfd, data + rel->address);
1056 val &=~ (((1 << size) - 1) << offset);
1057 val |= (stack[--tos] & ((1 << size) - 1)) << offset;
1058 bfd_put_64 (abfd, val, data + rel->address);
1059 }
1060 break;
1061
1062 case ALPHA_R_OP_PSUB:
1063 /* Subtract a value from the top of the stack. */
1064 {
1065 asymbol *symbol;
1066 bfd_vma relocation;
1067
1068 if (relocatable)
1069 {
1070 rel->address += input_section->output_offset;
1071 break;
1072 }
1073
1074 /* Figure out the relocation of this symbol. */
1075 symbol = *rel->sym_ptr_ptr;
1076
1077 if (bfd_is_und_section (symbol->section))
1078 r = bfd_reloc_undefined;
1079
1080 if (bfd_is_com_section (symbol->section))
1081 relocation = 0;
1082 else
1083 relocation = symbol->value;
1084 relocation += symbol->section->output_section->vma;
1085 relocation += symbol->section->output_offset;
1086 relocation += rel->addend;
1087
1088 if (tos == 0)
1089 abort ();
1090
1091 stack[tos - 1] -= relocation;
1092 }
1093 break;
1094
1095 case ALPHA_R_OP_PRSHIFT:
1096 /* Shift the value on the top of the stack. */
1097 {
1098 asymbol *symbol;
1099 bfd_vma relocation;
1100
1101 if (relocatable)
1102 {
1103 rel->address += input_section->output_offset;
1104 break;
1105 }
1106
1107 /* Figure out the relocation of this symbol. */
1108 symbol = *rel->sym_ptr_ptr;
1109
1110 if (bfd_is_und_section (symbol->section))
1111 r = bfd_reloc_undefined;
1112
1113 if (bfd_is_com_section (symbol->section))
1114 relocation = 0;
1115 else
1116 relocation = symbol->value;
1117 relocation += symbol->section->output_section->vma;
1118 relocation += symbol->section->output_offset;
1119 relocation += rel->addend;
1120
1121 if (tos == 0)
1122 abort ();
1123
1124 stack[tos - 1] >>= relocation;
1125 }
1126 break;
1127
1128 case ALPHA_R_GPVALUE:
1129 /* I really don't know if this does the right thing. */
1130 gp = rel->addend;
1131 gp_undefined = FALSE;
1132 break;
1133
1134 default:
1135 abort ();
1136 }
1137
1138 if (relocatable)
1139 {
1140 asection *os = input_section->output_section;
1141
1142 /* A partial link, so keep the relocs. */
1143 os->orelocation[os->reloc_count] = rel;
1144 os->reloc_count++;
1145 }
1146
1147 if (r != bfd_reloc_ok)
1148 {
1149 switch (r)
1150 {
1151 case bfd_reloc_undefined:
1152 if (! ((*link_info->callbacks->undefined_symbol)
1153 (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1154 input_bfd, input_section, rel->address, TRUE)))
1155 goto error_return;
1156 break;
1157 case bfd_reloc_dangerous:
1158 if (! ((*link_info->callbacks->reloc_dangerous)
1159 (link_info, err, input_bfd, input_section,
1160 rel->address)))
1161 goto error_return;
1162 break;
1163 case bfd_reloc_overflow:
1164 if (! ((*link_info->callbacks->reloc_overflow)
1165 (link_info, NULL,
1166 bfd_asymbol_name (*rel->sym_ptr_ptr),
1167 rel->howto->name, rel->addend, input_bfd,
1168 input_section, rel->address)))
1169 goto error_return;
1170 break;
1171 case bfd_reloc_outofrange:
1172 default:
1173 abort ();
1174 break;
1175 }
1176 }
1177 }
1178
1179 if (tos != 0)
1180 abort ();
1181
1182 successful_return:
1183 if (reloc_vector != NULL)
1184 free (reloc_vector);
1185 return data;
1186
1187 error_return:
1188 if (reloc_vector != NULL)
1189 free (reloc_vector);
1190 return NULL;
1191 }
1192
1193 /* Get the howto structure for a generic reloc type. */
1194
1195 static reloc_howto_type *
alpha_bfd_reloc_type_lookup(abfd,code)1196 alpha_bfd_reloc_type_lookup (abfd, code)
1197 bfd *abfd ATTRIBUTE_UNUSED;
1198 bfd_reloc_code_real_type code;
1199 {
1200 int alpha_type;
1201
1202 switch (code)
1203 {
1204 case BFD_RELOC_32:
1205 alpha_type = ALPHA_R_REFLONG;
1206 break;
1207 case BFD_RELOC_64:
1208 case BFD_RELOC_CTOR:
1209 alpha_type = ALPHA_R_REFQUAD;
1210 break;
1211 case BFD_RELOC_GPREL32:
1212 alpha_type = ALPHA_R_GPREL32;
1213 break;
1214 case BFD_RELOC_ALPHA_LITERAL:
1215 alpha_type = ALPHA_R_LITERAL;
1216 break;
1217 case BFD_RELOC_ALPHA_LITUSE:
1218 alpha_type = ALPHA_R_LITUSE;
1219 break;
1220 case BFD_RELOC_ALPHA_GPDISP_HI16:
1221 alpha_type = ALPHA_R_GPDISP;
1222 break;
1223 case BFD_RELOC_ALPHA_GPDISP_LO16:
1224 alpha_type = ALPHA_R_IGNORE;
1225 break;
1226 case BFD_RELOC_23_PCREL_S2:
1227 alpha_type = ALPHA_R_BRADDR;
1228 break;
1229 case BFD_RELOC_ALPHA_HINT:
1230 alpha_type = ALPHA_R_HINT;
1231 break;
1232 case BFD_RELOC_16_PCREL:
1233 alpha_type = ALPHA_R_SREL16;
1234 break;
1235 case BFD_RELOC_32_PCREL:
1236 alpha_type = ALPHA_R_SREL32;
1237 break;
1238 case BFD_RELOC_64_PCREL:
1239 alpha_type = ALPHA_R_SREL64;
1240 break;
1241 default:
1242 return (reloc_howto_type *) NULL;
1243 }
1244
1245 return &alpha_howto_table[alpha_type];
1246 }
1247
1248 /* A helper routine for alpha_relocate_section which converts an
1249 external reloc when generating relocatable output. Returns the
1250 relocation amount. */
1251
1252 static bfd_vma
alpha_convert_external_reloc(output_bfd,info,input_bfd,ext_rel,h)1253 alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h)
1254 bfd *output_bfd ATTRIBUTE_UNUSED;
1255 struct bfd_link_info *info;
1256 bfd *input_bfd;
1257 struct external_reloc *ext_rel;
1258 struct ecoff_link_hash_entry *h;
1259 {
1260 unsigned long r_symndx;
1261 bfd_vma relocation;
1262
1263 BFD_ASSERT (info->relocatable);
1264
1265 if (h->root.type == bfd_link_hash_defined
1266 || h->root.type == bfd_link_hash_defweak)
1267 {
1268 asection *hsec;
1269 const char *name;
1270
1271 /* This symbol is defined in the output. Convert the reloc from
1272 being against the symbol to being against the section. */
1273
1274 /* Clear the r_extern bit. */
1275 ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE;
1276
1277 /* Compute a new r_symndx value. */
1278 hsec = h->root.u.def.section;
1279 name = bfd_get_section_name (output_bfd, hsec->output_section);
1280
1281 r_symndx = (unsigned long) -1;
1282 switch (name[1])
1283 {
1284 case 'A':
1285 if (strcmp (name, "*ABS*") == 0)
1286 r_symndx = RELOC_SECTION_ABS;
1287 break;
1288 case 'b':
1289 if (strcmp (name, ".bss") == 0)
1290 r_symndx = RELOC_SECTION_BSS;
1291 break;
1292 case 'd':
1293 if (strcmp (name, ".data") == 0)
1294 r_symndx = RELOC_SECTION_DATA;
1295 break;
1296 case 'f':
1297 if (strcmp (name, ".fini") == 0)
1298 r_symndx = RELOC_SECTION_FINI;
1299 break;
1300 case 'i':
1301 if (strcmp (name, ".init") == 0)
1302 r_symndx = RELOC_SECTION_INIT;
1303 break;
1304 case 'l':
1305 if (strcmp (name, ".lita") == 0)
1306 r_symndx = RELOC_SECTION_LITA;
1307 else if (strcmp (name, ".lit8") == 0)
1308 r_symndx = RELOC_SECTION_LIT8;
1309 else if (strcmp (name, ".lit4") == 0)
1310 r_symndx = RELOC_SECTION_LIT4;
1311 break;
1312 case 'p':
1313 if (strcmp (name, ".pdata") == 0)
1314 r_symndx = RELOC_SECTION_PDATA;
1315 break;
1316 case 'r':
1317 if (strcmp (name, ".rdata") == 0)
1318 r_symndx = RELOC_SECTION_RDATA;
1319 else if (strcmp (name, ".rconst") == 0)
1320 r_symndx = RELOC_SECTION_RCONST;
1321 break;
1322 case 's':
1323 if (strcmp (name, ".sdata") == 0)
1324 r_symndx = RELOC_SECTION_SDATA;
1325 else if (strcmp (name, ".sbss") == 0)
1326 r_symndx = RELOC_SECTION_SBSS;
1327 break;
1328 case 't':
1329 if (strcmp (name, ".text") == 0)
1330 r_symndx = RELOC_SECTION_TEXT;
1331 break;
1332 case 'x':
1333 if (strcmp (name, ".xdata") == 0)
1334 r_symndx = RELOC_SECTION_XDATA;
1335 break;
1336 }
1337
1338 if (r_symndx == (unsigned long) -1)
1339 abort ();
1340
1341 /* Add the section VMA and the symbol value. */
1342 relocation = (h->root.u.def.value
1343 + hsec->output_section->vma
1344 + hsec->output_offset);
1345 }
1346 else
1347 {
1348 /* Change the symndx value to the right one for
1349 the output BFD. */
1350 r_symndx = h->indx;
1351 if (r_symndx == (unsigned long) -1)
1352 {
1353 /* Caller must give an error. */
1354 r_symndx = 0;
1355 }
1356 relocation = 0;
1357 }
1358
1359 /* Write out the new r_symndx value. */
1360 H_PUT_32 (input_bfd, r_symndx, ext_rel->r_symndx);
1361
1362 return relocation;
1363 }
1364
1365 /* Relocate a section while linking an Alpha ECOFF file. This is
1366 quite similar to get_relocated_section_contents. Perhaps they
1367 could be combined somehow. */
1368
1369 static bfd_boolean
alpha_relocate_section(output_bfd,info,input_bfd,input_section,contents,external_relocs)1370 alpha_relocate_section (output_bfd, info, input_bfd, input_section,
1371 contents, external_relocs)
1372 bfd *output_bfd;
1373 struct bfd_link_info *info;
1374 bfd *input_bfd;
1375 asection *input_section;
1376 bfd_byte *contents;
1377 PTR external_relocs;
1378 {
1379 asection **symndx_to_section, *lita_sec;
1380 struct ecoff_link_hash_entry **sym_hashes;
1381 bfd_vma gp;
1382 bfd_boolean gp_undefined;
1383 bfd_vma stack[RELOC_STACKSIZE];
1384 int tos = 0;
1385 struct external_reloc *ext_rel;
1386 struct external_reloc *ext_rel_end;
1387 bfd_size_type amt;
1388
1389 /* We keep a table mapping the symndx found in an internal reloc to
1390 the appropriate section. This is faster than looking up the
1391 section by name each time. */
1392 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1393 if (symndx_to_section == (asection **) NULL)
1394 {
1395 amt = NUM_RELOC_SECTIONS * sizeof (asection *);
1396 symndx_to_section = (asection **) bfd_alloc (input_bfd, amt);
1397 if (!symndx_to_section)
1398 return FALSE;
1399
1400 symndx_to_section[RELOC_SECTION_NONE] = NULL;
1401 symndx_to_section[RELOC_SECTION_TEXT] =
1402 bfd_get_section_by_name (input_bfd, ".text");
1403 symndx_to_section[RELOC_SECTION_RDATA] =
1404 bfd_get_section_by_name (input_bfd, ".rdata");
1405 symndx_to_section[RELOC_SECTION_DATA] =
1406 bfd_get_section_by_name (input_bfd, ".data");
1407 symndx_to_section[RELOC_SECTION_SDATA] =
1408 bfd_get_section_by_name (input_bfd, ".sdata");
1409 symndx_to_section[RELOC_SECTION_SBSS] =
1410 bfd_get_section_by_name (input_bfd, ".sbss");
1411 symndx_to_section[RELOC_SECTION_BSS] =
1412 bfd_get_section_by_name (input_bfd, ".bss");
1413 symndx_to_section[RELOC_SECTION_INIT] =
1414 bfd_get_section_by_name (input_bfd, ".init");
1415 symndx_to_section[RELOC_SECTION_LIT8] =
1416 bfd_get_section_by_name (input_bfd, ".lit8");
1417 symndx_to_section[RELOC_SECTION_LIT4] =
1418 bfd_get_section_by_name (input_bfd, ".lit4");
1419 symndx_to_section[RELOC_SECTION_XDATA] =
1420 bfd_get_section_by_name (input_bfd, ".xdata");
1421 symndx_to_section[RELOC_SECTION_PDATA] =
1422 bfd_get_section_by_name (input_bfd, ".pdata");
1423 symndx_to_section[RELOC_SECTION_FINI] =
1424 bfd_get_section_by_name (input_bfd, ".fini");
1425 symndx_to_section[RELOC_SECTION_LITA] =
1426 bfd_get_section_by_name (input_bfd, ".lita");
1427 symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1428 symndx_to_section[RELOC_SECTION_RCONST] =
1429 bfd_get_section_by_name (input_bfd, ".rconst");
1430
1431 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1432 }
1433
1434 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1435
1436 /* On the Alpha, the .lita section must be addressable by the global
1437 pointer. To support large programs, we need to allow multiple
1438 global pointers. This works as long as each input .lita section
1439 is <64KB big. This implies that when producing relocatable
1440 output, the .lita section is limited to 64KB. . */
1441
1442 lita_sec = symndx_to_section[RELOC_SECTION_LITA];
1443 gp = _bfd_get_gp_value (output_bfd);
1444 if (! info->relocatable && lita_sec != NULL)
1445 {
1446 struct ecoff_section_tdata *lita_sec_data;
1447
1448 /* Make sure we have a section data structure to which we can
1449 hang on to the gp value we pick for the section. */
1450 lita_sec_data = ecoff_section_data (input_bfd, lita_sec);
1451 if (lita_sec_data == NULL)
1452 {
1453 amt = sizeof (struct ecoff_section_tdata);
1454 lita_sec_data = ((struct ecoff_section_tdata *)
1455 bfd_zalloc (input_bfd, amt));
1456 lita_sec->used_by_bfd = lita_sec_data;
1457 }
1458
1459 if (lita_sec_data->gp != 0)
1460 {
1461 /* If we already assigned a gp to this section, we better
1462 stick with that value. */
1463 gp = lita_sec_data->gp;
1464 }
1465 else
1466 {
1467 bfd_vma lita_vma;
1468 bfd_size_type lita_size;
1469
1470 lita_vma = lita_sec->output_offset + lita_sec->output_section->vma;
1471 lita_size = lita_sec->size;
1472
1473 if (gp == 0
1474 || lita_vma < gp - 0x8000
1475 || lita_vma + lita_size >= gp + 0x8000)
1476 {
1477 /* Either gp hasn't been set at all or the current gp
1478 cannot address this .lita section. In both cases we
1479 reset the gp to point into the "middle" of the
1480 current input .lita section. */
1481 if (gp && !ecoff_data (output_bfd)->issued_multiple_gp_warning)
1482 {
1483 (*info->callbacks->warning) (info,
1484 _("using multiple gp values"),
1485 (char *) NULL, output_bfd,
1486 (asection *) NULL, (bfd_vma) 0);
1487 ecoff_data (output_bfd)->issued_multiple_gp_warning = TRUE;
1488 }
1489 if (lita_vma < gp - 0x8000)
1490 gp = lita_vma + lita_size - 0x8000;
1491 else
1492 gp = lita_vma + 0x8000;
1493
1494 }
1495
1496 lita_sec_data->gp = gp;
1497 }
1498
1499 _bfd_set_gp_value (output_bfd, gp);
1500 }
1501
1502 gp_undefined = (gp == 0);
1503
1504 BFD_ASSERT (bfd_header_little_endian (output_bfd));
1505 BFD_ASSERT (bfd_header_little_endian (input_bfd));
1506
1507 ext_rel = (struct external_reloc *) external_relocs;
1508 ext_rel_end = ext_rel + input_section->reloc_count;
1509 for (; ext_rel < ext_rel_end; ext_rel++)
1510 {
1511 bfd_vma r_vaddr;
1512 unsigned long r_symndx;
1513 int r_type;
1514 int r_extern;
1515 int r_offset;
1516 int r_size;
1517 bfd_boolean relocatep;
1518 bfd_boolean adjust_addrp;
1519 bfd_boolean gp_usedp;
1520 bfd_vma addend;
1521
1522 r_vaddr = H_GET_64 (input_bfd, ext_rel->r_vaddr);
1523 r_symndx = H_GET_32 (input_bfd, ext_rel->r_symndx);
1524
1525 r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1526 >> RELOC_BITS0_TYPE_SH_LITTLE);
1527 r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1528 r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1529 >> RELOC_BITS1_OFFSET_SH_LITTLE);
1530 /* Ignored the reserved bits. */
1531 r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1532 >> RELOC_BITS3_SIZE_SH_LITTLE);
1533
1534 relocatep = FALSE;
1535 adjust_addrp = TRUE;
1536 gp_usedp = FALSE;
1537 addend = 0;
1538
1539 switch (r_type)
1540 {
1541 case ALPHA_R_GPRELHIGH:
1542 (*_bfd_error_handler)
1543 (_("%B: unsupported relocation: ALPHA_R_GPRELHIGH"),
1544 input_bfd);
1545 bfd_set_error (bfd_error_bad_value);
1546 continue;
1547
1548 case ALPHA_R_GPRELLOW:
1549 (*_bfd_error_handler)
1550 (_("%B: unsupported relocation: ALPHA_R_GPRELLOW"),
1551 input_bfd);
1552 bfd_set_error (bfd_error_bad_value);
1553 continue;
1554
1555 default:
1556 (*_bfd_error_handler)
1557 (_("%B: unknown relocation type %d"),
1558 input_bfd, (int) r_type);
1559 bfd_set_error (bfd_error_bad_value);
1560 continue;
1561
1562 case ALPHA_R_IGNORE:
1563 /* This reloc appears after a GPDISP reloc. On earlier
1564 versions of OSF/1, It marked the position of the second
1565 instruction to be altered by the GPDISP reloc, but it is
1566 not otherwise used for anything. For some reason, the
1567 address of the relocation does not appear to include the
1568 section VMA, unlike the other relocation types. */
1569 if (info->relocatable)
1570 H_PUT_64 (input_bfd, input_section->output_offset + r_vaddr,
1571 ext_rel->r_vaddr);
1572 adjust_addrp = FALSE;
1573 break;
1574
1575 case ALPHA_R_REFLONG:
1576 case ALPHA_R_REFQUAD:
1577 case ALPHA_R_HINT:
1578 relocatep = TRUE;
1579 break;
1580
1581 case ALPHA_R_BRADDR:
1582 case ALPHA_R_SREL16:
1583 case ALPHA_R_SREL32:
1584 case ALPHA_R_SREL64:
1585 if (r_extern)
1586 addend += - (r_vaddr + 4);
1587 relocatep = TRUE;
1588 break;
1589
1590 case ALPHA_R_GPREL32:
1591 /* This relocation is used in a switch table. It is a 32
1592 bit offset from the current GP value. We must adjust it
1593 by the different between the original GP value and the
1594 current GP value. */
1595 relocatep = TRUE;
1596 addend = ecoff_data (input_bfd)->gp - gp;
1597 gp_usedp = TRUE;
1598 break;
1599
1600 case ALPHA_R_LITERAL:
1601 /* This is a reference to a literal value, generally
1602 (always?) in the .lita section. This is a 16 bit GP
1603 relative relocation. Sometimes the subsequent reloc is a
1604 LITUSE reloc, which indicates how this reloc is used.
1605 This sometimes permits rewriting the two instructions
1606 referred to by the LITERAL and the LITUSE into different
1607 instructions which do not refer to .lita. This can save
1608 a memory reference, and permits removing a value from
1609 .lita thus saving GP relative space.
1610
1611 We do not these optimizations. To do them we would need
1612 to arrange to link the .lita section first, so that by
1613 the time we got here we would know the final values to
1614 use. This would not be particularly difficult, but it is
1615 not currently implemented. */
1616
1617 /* I believe that the LITERAL reloc will only apply to a ldq
1618 or ldl instruction, so check my assumption. */
1619 {
1620 unsigned long insn;
1621
1622 insn = bfd_get_32 (input_bfd,
1623 contents + r_vaddr - input_section->vma);
1624 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1625 || ((insn >> 26) & 0x3f) == 0x28);
1626 }
1627
1628 relocatep = TRUE;
1629 addend = ecoff_data (input_bfd)->gp - gp;
1630 gp_usedp = TRUE;
1631 break;
1632
1633 case ALPHA_R_LITUSE:
1634 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
1635 does not cause anything to happen, itself. */
1636 break;
1637
1638 case ALPHA_R_GPDISP:
1639 /* This marks the ldah of an ldah/lda pair which loads the
1640 gp register with the difference of the gp value and the
1641 current location. The second of the pair is r_symndx
1642 bytes ahead. It used to be marked with an ALPHA_R_IGNORE
1643 reloc, but OSF/1 3.2 no longer does that. */
1644 {
1645 unsigned long insn1, insn2;
1646
1647 /* Get the two instructions. */
1648 insn1 = bfd_get_32 (input_bfd,
1649 contents + r_vaddr - input_section->vma);
1650 insn2 = bfd_get_32 (input_bfd,
1651 (contents
1652 + r_vaddr
1653 - input_section->vma
1654 + r_symndx));
1655
1656 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1657 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1658
1659 /* Get the existing addend. We must account for the sign
1660 extension done by lda and ldah. */
1661 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1662 if (insn1 & 0x8000)
1663 {
1664 /* This is addend -= 0x100000000 without causing an
1665 integer overflow on a 32 bit host. */
1666 addend -= 0x80000000;
1667 addend -= 0x80000000;
1668 }
1669 if (insn2 & 0x8000)
1670 addend -= 0x10000;
1671
1672 /* The existing addend includes the difference between the
1673 gp of the input BFD and the address in the input BFD.
1674 We want to change this to the difference between the
1675 final GP and the final address. */
1676 addend += (gp
1677 - ecoff_data (input_bfd)->gp
1678 + input_section->vma
1679 - (input_section->output_section->vma
1680 + input_section->output_offset));
1681
1682 /* Change the instructions, accounting for the sign
1683 extension, and write them out. */
1684 if (addend & 0x8000)
1685 addend += 0x10000;
1686 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1687 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1688
1689 bfd_put_32 (input_bfd, (bfd_vma) insn1,
1690 contents + r_vaddr - input_section->vma);
1691 bfd_put_32 (input_bfd, (bfd_vma) insn2,
1692 contents + r_vaddr - input_section->vma + r_symndx);
1693
1694 gp_usedp = TRUE;
1695 }
1696 break;
1697
1698 case ALPHA_R_OP_PUSH:
1699 case ALPHA_R_OP_PSUB:
1700 case ALPHA_R_OP_PRSHIFT:
1701 /* Manipulate values on the reloc evaluation stack. The
1702 r_vaddr field is not an address in input_section, it is
1703 the current value (including any addend) of the object
1704 being used. */
1705 if (! r_extern)
1706 {
1707 asection *s;
1708
1709 s = symndx_to_section[r_symndx];
1710 if (s == (asection *) NULL)
1711 abort ();
1712 addend = s->output_section->vma + s->output_offset - s->vma;
1713 }
1714 else
1715 {
1716 struct ecoff_link_hash_entry *h;
1717
1718 h = sym_hashes[r_symndx];
1719 if (h == (struct ecoff_link_hash_entry *) NULL)
1720 abort ();
1721
1722 if (! info->relocatable)
1723 {
1724 if (h->root.type == bfd_link_hash_defined
1725 || h->root.type == bfd_link_hash_defweak)
1726 addend = (h->root.u.def.value
1727 + h->root.u.def.section->output_section->vma
1728 + h->root.u.def.section->output_offset);
1729 else
1730 {
1731 /* Note that we pass the address as 0, since we
1732 do not have a meaningful number for the
1733 location within the section that is being
1734 relocated. */
1735 if (! ((*info->callbacks->undefined_symbol)
1736 (info, h->root.root.string, input_bfd,
1737 input_section, (bfd_vma) 0, TRUE)))
1738 return FALSE;
1739 addend = 0;
1740 }
1741 }
1742 else
1743 {
1744 if (h->root.type != bfd_link_hash_defined
1745 && h->root.type != bfd_link_hash_defweak
1746 && h->indx == -1)
1747 {
1748 /* This symbol is not being written out. Pass
1749 the address as 0, as with undefined_symbol,
1750 above. */
1751 if (! ((*info->callbacks->unattached_reloc)
1752 (info, h->root.root.string, input_bfd,
1753 input_section, (bfd_vma) 0)))
1754 return FALSE;
1755 }
1756
1757 addend = alpha_convert_external_reloc (output_bfd, info,
1758 input_bfd,
1759 ext_rel, h);
1760 }
1761 }
1762
1763 addend += r_vaddr;
1764
1765 if (info->relocatable)
1766 {
1767 /* Adjust r_vaddr by the addend. */
1768 H_PUT_64 (input_bfd, addend, ext_rel->r_vaddr);
1769 }
1770 else
1771 {
1772 switch (r_type)
1773 {
1774 case ALPHA_R_OP_PUSH:
1775 if (tos >= RELOC_STACKSIZE)
1776 abort ();
1777 stack[tos++] = addend;
1778 break;
1779
1780 case ALPHA_R_OP_PSUB:
1781 if (tos == 0)
1782 abort ();
1783 stack[tos - 1] -= addend;
1784 break;
1785
1786 case ALPHA_R_OP_PRSHIFT:
1787 if (tos == 0)
1788 abort ();
1789 stack[tos - 1] >>= addend;
1790 break;
1791 }
1792 }
1793
1794 adjust_addrp = FALSE;
1795 break;
1796
1797 case ALPHA_R_OP_STORE:
1798 /* Store a value from the reloc stack into a bitfield. If
1799 we are generating relocatable output, all we do is
1800 adjust the address of the reloc. */
1801 if (! info->relocatable)
1802 {
1803 bfd_vma mask;
1804 bfd_vma val;
1805
1806 if (tos == 0)
1807 abort ();
1808
1809 /* Get the relocation mask. The separate steps and the
1810 casts to bfd_vma are attempts to avoid a bug in the
1811 Alpha OSF 1.3 C compiler. See reloc.c for more
1812 details. */
1813 mask = 1;
1814 mask <<= (bfd_vma) r_size;
1815 mask -= 1;
1816
1817 /* FIXME: I don't know what kind of overflow checking,
1818 if any, should be done here. */
1819 val = bfd_get_64 (input_bfd,
1820 contents + r_vaddr - input_section->vma);
1821 val &=~ mask << (bfd_vma) r_offset;
1822 val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1823 bfd_put_64 (input_bfd, val,
1824 contents + r_vaddr - input_section->vma);
1825 }
1826 break;
1827
1828 case ALPHA_R_GPVALUE:
1829 /* I really don't know if this does the right thing. */
1830 gp = ecoff_data (input_bfd)->gp + r_symndx;
1831 gp_undefined = FALSE;
1832 break;
1833 }
1834
1835 if (relocatep)
1836 {
1837 reloc_howto_type *howto;
1838 struct ecoff_link_hash_entry *h = NULL;
1839 asection *s = NULL;
1840 bfd_vma relocation;
1841 bfd_reloc_status_type r;
1842
1843 /* Perform a relocation. */
1844
1845 howto = &alpha_howto_table[r_type];
1846
1847 if (r_extern)
1848 {
1849 h = sym_hashes[r_symndx];
1850 /* If h is NULL, that means that there is a reloc
1851 against an external symbol which we thought was just
1852 a debugging symbol. This should not happen. */
1853 if (h == (struct ecoff_link_hash_entry *) NULL)
1854 abort ();
1855 }
1856 else
1857 {
1858 if (r_symndx >= NUM_RELOC_SECTIONS)
1859 s = NULL;
1860 else
1861 s = symndx_to_section[r_symndx];
1862
1863 if (s == (asection *) NULL)
1864 abort ();
1865 }
1866
1867 if (info->relocatable)
1868 {
1869 /* We are generating relocatable output, and must
1870 convert the existing reloc. */
1871 if (r_extern)
1872 {
1873 if (h->root.type != bfd_link_hash_defined
1874 && h->root.type != bfd_link_hash_defweak
1875 && h->indx == -1)
1876 {
1877 /* This symbol is not being written out. */
1878 if (! ((*info->callbacks->unattached_reloc)
1879 (info, h->root.root.string, input_bfd,
1880 input_section, r_vaddr - input_section->vma)))
1881 return FALSE;
1882 }
1883
1884 relocation = alpha_convert_external_reloc (output_bfd,
1885 info,
1886 input_bfd,
1887 ext_rel,
1888 h);
1889 }
1890 else
1891 {
1892 /* This is a relocation against a section. Adjust
1893 the value by the amount the section moved. */
1894 relocation = (s->output_section->vma
1895 + s->output_offset
1896 - s->vma);
1897 }
1898
1899 /* If this is PC relative, the existing object file
1900 appears to already have the reloc worked out. We
1901 must subtract out the old value and add in the new
1902 one. */
1903 if (howto->pc_relative)
1904 relocation -= (input_section->output_section->vma
1905 + input_section->output_offset
1906 - input_section->vma);
1907
1908 /* Put in any addend. */
1909 relocation += addend;
1910
1911 /* Adjust the contents. */
1912 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1913 (contents
1914 + r_vaddr
1915 - input_section->vma));
1916 }
1917 else
1918 {
1919 /* We are producing a final executable. */
1920 if (r_extern)
1921 {
1922 /* This is a reloc against a symbol. */
1923 if (h->root.type == bfd_link_hash_defined
1924 || h->root.type == bfd_link_hash_defweak)
1925 {
1926 asection *hsec;
1927
1928 hsec = h->root.u.def.section;
1929 relocation = (h->root.u.def.value
1930 + hsec->output_section->vma
1931 + hsec->output_offset);
1932 }
1933 else
1934 {
1935 if (! ((*info->callbacks->undefined_symbol)
1936 (info, h->root.root.string, input_bfd,
1937 input_section,
1938 r_vaddr - input_section->vma, TRUE)))
1939 return FALSE;
1940 relocation = 0;
1941 }
1942 }
1943 else
1944 {
1945 /* This is a reloc against a section. */
1946 relocation = (s->output_section->vma
1947 + s->output_offset
1948 - s->vma);
1949
1950 /* Adjust a PC relative relocation by removing the
1951 reference to the original source section. */
1952 if (howto->pc_relative)
1953 relocation += input_section->vma;
1954 }
1955
1956 r = _bfd_final_link_relocate (howto,
1957 input_bfd,
1958 input_section,
1959 contents,
1960 r_vaddr - input_section->vma,
1961 relocation,
1962 addend);
1963 }
1964
1965 if (r != bfd_reloc_ok)
1966 {
1967 switch (r)
1968 {
1969 default:
1970 case bfd_reloc_outofrange:
1971 abort ();
1972 case bfd_reloc_overflow:
1973 {
1974 const char *name;
1975
1976 if (r_extern)
1977 name = sym_hashes[r_symndx]->root.root.string;
1978 else
1979 name = bfd_section_name (input_bfd,
1980 symndx_to_section[r_symndx]);
1981 if (! ((*info->callbacks->reloc_overflow)
1982 (info, NULL, name,
1983 alpha_howto_table[r_type].name,
1984 (bfd_vma) 0, input_bfd, input_section,
1985 r_vaddr - input_section->vma)))
1986 return FALSE;
1987 }
1988 break;
1989 }
1990 }
1991 }
1992
1993 if (info->relocatable && adjust_addrp)
1994 {
1995 /* Change the address of the relocation. */
1996 H_PUT_64 (input_bfd,
1997 (input_section->output_section->vma
1998 + input_section->output_offset
1999 - input_section->vma
2000 + r_vaddr),
2001 ext_rel->r_vaddr);
2002 }
2003
2004 if (gp_usedp && gp_undefined)
2005 {
2006 if (! ((*info->callbacks->reloc_dangerous)
2007 (info, _("GP relative relocation used when GP not defined"),
2008 input_bfd, input_section, r_vaddr - input_section->vma)))
2009 return FALSE;
2010 /* Only give the error once per link. */
2011 gp = 4;
2012 _bfd_set_gp_value (output_bfd, gp);
2013 gp_undefined = FALSE;
2014 }
2015 }
2016
2017 if (tos != 0)
2018 abort ();
2019
2020 return TRUE;
2021 }
2022
2023 /* Do final adjustments to the filehdr and the aouthdr. This routine
2024 sets the dynamic bits in the file header. */
2025
2026 static bfd_boolean
alpha_adjust_headers(abfd,fhdr,ahdr)2027 alpha_adjust_headers (abfd, fhdr, ahdr)
2028 bfd *abfd;
2029 struct internal_filehdr *fhdr;
2030 struct internal_aouthdr *ahdr ATTRIBUTE_UNUSED;
2031 {
2032 if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
2033 fhdr->f_flags |= F_ALPHA_CALL_SHARED;
2034 else if ((abfd->flags & DYNAMIC) != 0)
2035 fhdr->f_flags |= F_ALPHA_SHARABLE;
2036 return TRUE;
2037 }
2038
2039 /* Archive handling. In OSF/1 (or Digital Unix) v3.2, Digital
2040 introduced archive packing, in which the elements in an archive are
2041 optionally compressed using a simple dictionary scheme. We know
2042 how to read such archives, but we don't write them. */
2043
2044 #define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap
2045 #define alpha_ecoff_slurp_extended_name_table \
2046 _bfd_ecoff_slurp_extended_name_table
2047 #define alpha_ecoff_construct_extended_name_table \
2048 _bfd_ecoff_construct_extended_name_table
2049 #define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname
2050 #define alpha_ecoff_write_armap _bfd_ecoff_write_armap
2051 #define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt
2052 #define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp
2053
2054 /* A compressed file uses this instead of ARFMAG. */
2055
2056 #define ARFZMAG "Z\012"
2057
2058 /* Read an archive header. This is like the standard routine, but it
2059 also accepts ARFZMAG. */
2060
2061 static PTR
alpha_ecoff_read_ar_hdr(abfd)2062 alpha_ecoff_read_ar_hdr (abfd)
2063 bfd *abfd;
2064 {
2065 struct areltdata *ret;
2066 struct ar_hdr *h;
2067
2068 ret = (struct areltdata *) _bfd_generic_read_ar_hdr_mag (abfd, ARFZMAG);
2069 if (ret == NULL)
2070 return NULL;
2071
2072 h = (struct ar_hdr *) ret->arch_header;
2073 if (strncmp (h->ar_fmag, ARFZMAG, 2) == 0)
2074 {
2075 bfd_byte ab[8];
2076
2077 /* This is a compressed file. We must set the size correctly.
2078 The size is the eight bytes after the dummy file header. */
2079 if (bfd_seek (abfd, (file_ptr) FILHSZ, SEEK_CUR) != 0
2080 || bfd_bread (ab, (bfd_size_type) 8, abfd) != 8
2081 || bfd_seek (abfd, (file_ptr) (- (FILHSZ + 8)), SEEK_CUR) != 0)
2082 return NULL;
2083
2084 ret->parsed_size = H_GET_64 (abfd, ab);
2085 }
2086
2087 return (PTR) ret;
2088 }
2089
2090 /* Get an archive element at a specified file position. This is where
2091 we uncompress the archive element if necessary. */
2092
2093 static bfd *
alpha_ecoff_get_elt_at_filepos(archive,filepos)2094 alpha_ecoff_get_elt_at_filepos (archive, filepos)
2095 bfd *archive;
2096 file_ptr filepos;
2097 {
2098 bfd *nbfd = NULL;
2099 struct areltdata *tdata;
2100 struct ar_hdr *hdr;
2101 bfd_byte ab[8];
2102 bfd_size_type size;
2103 bfd_byte *buf, *p;
2104 struct bfd_in_memory *bim;
2105
2106 nbfd = _bfd_get_elt_at_filepos (archive, filepos);
2107 if (nbfd == NULL)
2108 goto error_return;
2109
2110 if ((nbfd->flags & BFD_IN_MEMORY) != 0)
2111 {
2112 /* We have already expanded this BFD. */
2113 return nbfd;
2114 }
2115
2116 tdata = (struct areltdata *) nbfd->arelt_data;
2117 hdr = (struct ar_hdr *) tdata->arch_header;
2118 if (strncmp (hdr->ar_fmag, ARFZMAG, 2) != 0)
2119 return nbfd;
2120
2121 /* We must uncompress this element. We do this by copying it into a
2122 memory buffer, and making bfd_bread and bfd_seek use that buffer.
2123 This can use a lot of memory, but it's simpler than getting a
2124 temporary file, making that work with the file descriptor caching
2125 code, and making sure that it is deleted at all appropriate
2126 times. It can be changed if it ever becomes important. */
2127
2128 /* The compressed file starts with a dummy ECOFF file header. */
2129 if (bfd_seek (nbfd, (file_ptr) FILHSZ, SEEK_SET) != 0)
2130 goto error_return;
2131
2132 /* The next eight bytes are the real file size. */
2133 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2134 goto error_return;
2135 size = H_GET_64 (nbfd, ab);
2136
2137 if (size == 0)
2138 buf = NULL;
2139 else
2140 {
2141 bfd_size_type left;
2142 bfd_byte dict[4096];
2143 unsigned int h;
2144 bfd_byte b;
2145
2146 buf = (bfd_byte *) bfd_alloc (nbfd, size);
2147 if (buf == NULL)
2148 goto error_return;
2149 p = buf;
2150
2151 left = size;
2152
2153 /* I don't know what the next eight bytes are for. */
2154 if (bfd_bread (ab, (bfd_size_type) 8, nbfd) != 8)
2155 goto error_return;
2156
2157 /* This is the uncompression algorithm. It's a simple
2158 dictionary based scheme in which each character is predicted
2159 by a hash of the previous three characters. A control byte
2160 indicates whether the character is predicted or whether it
2161 appears in the input stream; each control byte manages the
2162 next eight bytes in the output stream. */
2163 memset (dict, 0, sizeof dict);
2164 h = 0;
2165 while (bfd_bread (&b, (bfd_size_type) 1, nbfd) == 1)
2166 {
2167 unsigned int i;
2168
2169 for (i = 0; i < 8; i++, b >>= 1)
2170 {
2171 bfd_byte n;
2172
2173 if ((b & 1) == 0)
2174 n = dict[h];
2175 else
2176 {
2177 if (! bfd_bread (&n, (bfd_size_type) 1, nbfd))
2178 goto error_return;
2179 dict[h] = n;
2180 }
2181
2182 *p++ = n;
2183
2184 --left;
2185 if (left == 0)
2186 break;
2187
2188 h <<= 4;
2189 h ^= n;
2190 h &= sizeof dict - 1;
2191 }
2192
2193 if (left == 0)
2194 break;
2195 }
2196 }
2197
2198 /* Now the uncompressed file contents are in buf. */
2199 bim = ((struct bfd_in_memory *)
2200 bfd_alloc (nbfd, (bfd_size_type) sizeof (struct bfd_in_memory)));
2201 if (bim == NULL)
2202 goto error_return;
2203 bim->size = size;
2204 bim->buffer = buf;
2205
2206 nbfd->mtime_set = TRUE;
2207 nbfd->mtime = strtol (hdr->ar_date, (char **) NULL, 10);
2208
2209 nbfd->flags |= BFD_IN_MEMORY;
2210 nbfd->iostream = (PTR) bim;
2211 BFD_ASSERT (! nbfd->cacheable);
2212
2213 return nbfd;
2214
2215 error_return:
2216 if (nbfd != NULL)
2217 bfd_close (nbfd);
2218 return NULL;
2219 }
2220
2221 /* Open the next archived file. */
2222
2223 static bfd *
alpha_ecoff_openr_next_archived_file(archive,last_file)2224 alpha_ecoff_openr_next_archived_file (archive, last_file)
2225 bfd *archive;
2226 bfd *last_file;
2227 {
2228 file_ptr filestart;
2229
2230 if (last_file == NULL)
2231 filestart = bfd_ardata (archive)->first_file_filepos;
2232 else
2233 {
2234 struct areltdata *t;
2235 struct ar_hdr *h;
2236 bfd_size_type size;
2237
2238 /* We can't use arelt_size here, because that uses parsed_size,
2239 which is the uncompressed size. We need the compressed size. */
2240 t = (struct areltdata *) last_file->arelt_data;
2241 h = (struct ar_hdr *) t->arch_header;
2242 size = strtol (h->ar_size, (char **) NULL, 10);
2243
2244 /* Pad to an even boundary...
2245 Note that last_file->origin can be odd in the case of
2246 BSD-4.4-style element with a long odd size. */
2247 filestart = last_file->origin + size;
2248 filestart += filestart % 2;
2249 }
2250
2251 return alpha_ecoff_get_elt_at_filepos (archive, filestart);
2252 }
2253
2254 /* Open the archive file given an index into the armap. */
2255
2256 static bfd *
alpha_ecoff_get_elt_at_index(abfd,index)2257 alpha_ecoff_get_elt_at_index (abfd, index)
2258 bfd *abfd;
2259 symindex index;
2260 {
2261 carsym *entry;
2262
2263 entry = bfd_ardata (abfd)->symdefs + index;
2264 return alpha_ecoff_get_elt_at_filepos (abfd, entry->file_offset);
2265 }
2266
2267 /* This is the ECOFF backend structure. The backend field of the
2268 target vector points to this. */
2269
2270 static const struct ecoff_backend_data alpha_ecoff_backend_data =
2271 {
2272 /* COFF backend structure. */
2273 {
2274 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
2275 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
2276 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
2277 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
2278 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
2279 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
2280 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
2281 alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
2282 alpha_ecoff_swap_scnhdr_out,
2283 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, FILNMLEN, TRUE, FALSE, 4, FALSE, 2,
2284 alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
2285 alpha_ecoff_swap_scnhdr_in, NULL,
2286 alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
2287 alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
2288 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
2289 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2290 NULL, NULL, NULL
2291 },
2292 /* Supported architecture. */
2293 bfd_arch_alpha,
2294 /* Initial portion of armap string. */
2295 "________64",
2296 /* The page boundary used to align sections in a demand-paged
2297 executable file. E.g., 0x1000. */
2298 0x2000,
2299 /* TRUE if the .rdata section is part of the text segment, as on the
2300 Alpha. FALSE if .rdata is part of the data segment, as on the
2301 MIPS. */
2302 TRUE,
2303 /* Bitsize of constructor entries. */
2304 64,
2305 /* Reloc to use for constructor entries. */
2306 &alpha_howto_table[ALPHA_R_REFQUAD],
2307 {
2308 /* Symbol table magic number. */
2309 magicSym2,
2310 /* Alignment of debugging information. E.g., 4. */
2311 8,
2312 /* Sizes of external symbolic information. */
2313 sizeof (struct hdr_ext),
2314 sizeof (struct dnr_ext),
2315 sizeof (struct pdr_ext),
2316 sizeof (struct sym_ext),
2317 sizeof (struct opt_ext),
2318 sizeof (struct fdr_ext),
2319 sizeof (struct rfd_ext),
2320 sizeof (struct ext_ext),
2321 /* Functions to swap in external symbolic data. */
2322 ecoff_swap_hdr_in,
2323 ecoff_swap_dnr_in,
2324 ecoff_swap_pdr_in,
2325 ecoff_swap_sym_in,
2326 ecoff_swap_opt_in,
2327 ecoff_swap_fdr_in,
2328 ecoff_swap_rfd_in,
2329 ecoff_swap_ext_in,
2330 _bfd_ecoff_swap_tir_in,
2331 _bfd_ecoff_swap_rndx_in,
2332 /* Functions to swap out external symbolic data. */
2333 ecoff_swap_hdr_out,
2334 ecoff_swap_dnr_out,
2335 ecoff_swap_pdr_out,
2336 ecoff_swap_sym_out,
2337 ecoff_swap_opt_out,
2338 ecoff_swap_fdr_out,
2339 ecoff_swap_rfd_out,
2340 ecoff_swap_ext_out,
2341 _bfd_ecoff_swap_tir_out,
2342 _bfd_ecoff_swap_rndx_out,
2343 /* Function to read in symbolic data. */
2344 _bfd_ecoff_slurp_symbolic_info
2345 },
2346 /* External reloc size. */
2347 RELSZ,
2348 /* Reloc swapping functions. */
2349 alpha_ecoff_swap_reloc_in,
2350 alpha_ecoff_swap_reloc_out,
2351 /* Backend reloc tweaking. */
2352 alpha_adjust_reloc_in,
2353 alpha_adjust_reloc_out,
2354 /* Relocate section contents while linking. */
2355 alpha_relocate_section,
2356 /* Do final adjustments to filehdr and aouthdr. */
2357 alpha_adjust_headers,
2358 /* Read an element from an archive at a given file position. */
2359 alpha_ecoff_get_elt_at_filepos
2360 };
2361
2362 /* Looking up a reloc type is Alpha specific. */
2363 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2364
2365 /* So is getting relocated section contents. */
2366 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2367 alpha_ecoff_get_relocated_section_contents
2368
2369 /* Handling file windows is generic. */
2370 #define _bfd_ecoff_get_section_contents_in_window \
2371 _bfd_generic_get_section_contents_in_window
2372
2373 /* Relaxing sections is generic. */
2374 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2375 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2376 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
2377 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
2378 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
2379 #define _bfd_ecoff_section_already_linked \
2380 _bfd_generic_section_already_linked
2381
2382 const bfd_target ecoffalpha_little_vec =
2383 {
2384 "ecoff-littlealpha", /* name */
2385 bfd_target_ecoff_flavour,
2386 BFD_ENDIAN_LITTLE, /* data byte order is little */
2387 BFD_ENDIAN_LITTLE, /* header byte order is little */
2388
2389 (HAS_RELOC | EXEC_P | /* object flags */
2390 HAS_LINENO | HAS_DEBUG |
2391 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2392
2393 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2394 0, /* leading underscore */
2395 ' ', /* ar_pad_char */
2396 15, /* ar_max_namelen */
2397 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2398 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2399 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2400 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2401 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2402 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2403
2404 {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */
2405 _bfd_ecoff_archive_p, _bfd_dummy_target},
2406 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2407 _bfd_generic_mkarchive, bfd_false},
2408 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2409 _bfd_write_archive_contents, bfd_false},
2410
2411 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2412 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2413 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2414 BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff),
2415 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2416 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2417 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2418 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2419 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2420
2421 NULL,
2422
2423 (PTR) &alpha_ecoff_backend_data
2424 };
2425