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