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