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