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