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