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