projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* libbfd.c (bfd_malloc, bfd_realloc): New functions.
[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 **) bfd_malloc (reloc_size);
763 if (reloc_vector == NULL && reloc_size != 0)
764 goto error_return;
765
766 if (! bfd_get_section_contents (input_bfd, input_section, data,
767 (file_ptr) 0, input_section->_raw_size))
768 goto error_return;
769
770 /* The section size is not going to change. */
771 input_section->_cooked_size = input_section->_raw_size;
772 input_section->reloc_done = true;
773
774 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
775 reloc_vector, symbols);
776 if (reloc_count < 0)
777 goto error_return;
778 if (reloc_count == 0)
779 goto successful_return;
780
781 /* Get the GP value for the output BFD. */
782 gp_undefined = false;
783 if (ecoff_data (abfd)->gp == 0)
784 {
785 if (relocateable != false)
786 {
787 asection *sec;
788 bfd_vma lo;
789
790 /* Make up a value. */
791 lo = (bfd_vma) -1;
792 for (sec = abfd->sections; sec != NULL; sec = sec->next)
793 {
794 if (sec->vma < lo
795 && (strcmp (sec->name, ".sbss") == 0
796 || strcmp (sec->name, ".sdata") == 0
797 || strcmp (sec->name, ".lit4") == 0
798 || strcmp (sec->name, ".lit8") == 0
799 || strcmp (sec->name, ".lita") == 0))
800 lo = sec->vma;
801 }
802 ecoff_data (abfd)->gp = lo + 0x8000;
803 }
804 else
805 {
806 struct bfd_link_hash_entry *h;
807
808 h = bfd_link_hash_lookup (link_info->hash, "_gp", false, false,
809 true);
810 if (h == (struct bfd_link_hash_entry *) NULL
811 || h->type != bfd_link_hash_defined)
812 gp_undefined = true;
813 else
814 ecoff_data (abfd)->gp = (h->u.def.value
815 + h->u.def.section->output_section->vma
816 + h->u.def.section->output_offset);
817 }
818 }
819 gp = ecoff_data (abfd)->gp;
820
821 for (; *reloc_vector != (arelent *) NULL; reloc_vector++)
822 {
823 arelent *rel;
824 bfd_reloc_status_type r;
825 char *err;
826
827 rel = *reloc_vector;
828 r = bfd_reloc_ok;
829 switch (rel->howto->type)
830 {
831 case ALPHA_R_IGNORE:
832 rel->address += input_section->output_offset;
833 break;
834
835 case ALPHA_R_REFLONG:
836 case ALPHA_R_REFQUAD:
837 case ALPHA_R_BRADDR:
838 case ALPHA_R_HINT:
839 case ALPHA_R_SREL16:
840 case ALPHA_R_SREL32:
841 case ALPHA_R_SREL64:
842 if (relocateable
843 && ((*rel->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
844 {
845 rel->address += input_section->output_offset;
846 break;
847 }
848 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
849 output_bfd, &err);
850 break;
851
852 case ALPHA_R_GPREL32:
853 /* This relocation is used in a switch table. It is a 32
854 bit offset from the current GP value. We must adjust it
855 by the different between the original GP value and the
856 current GP value. The original GP value is stored in the
857 addend. We adjust the addend and let
858 bfd_perform_relocation finish the job. */
859 rel->addend -= gp;
860 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
861 output_bfd, &err);
862 if (r == bfd_reloc_ok && gp_undefined)
863 {
864 r = bfd_reloc_dangerous;
865 err = (char *) "GP relative relocation used when GP not defined";
866 }
867 break;
868
869 case ALPHA_R_LITERAL:
870 /* This is a reference to a literal value, generally
871 (always?) in the .lita section. This is a 16 bit GP
872 relative relocation. Sometimes the subsequent reloc is a
873 LITUSE reloc, which indicates how this reloc is used.
874 This sometimes permits rewriting the two instructions
875 referred to by the LITERAL and the LITUSE into different
876 instructions which do not refer to .lita. This can save
877 a memory reference, and permits removing a value from
878 .lita thus saving GP relative space.
879
880 We do not these optimizations. To do them we would need
881 to arrange to link the .lita section first, so that by
882 the time we got here we would know the final values to
883 use. This would not be particularly difficult, but it is
884 not currently implemented. */
885
886 {
887 unsigned long insn;
888
889 /* I believe that the LITERAL reloc will only apply to a
890 ldq or ldl instruction, so check my assumption. */
891 insn = bfd_get_32 (input_bfd, data + rel->address);
892 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
893 || ((insn >> 26) & 0x3f) == 0x28);
894
895 rel->addend -= gp;
896 r = bfd_perform_relocation (input_bfd, rel, data, input_section,
897 output_bfd, &err);
898 if (r == bfd_reloc_ok && gp_undefined)
899 {
900 r = bfd_reloc_dangerous;
901 err =
902 (char *) "GP relative relocation used when GP not defined";
903 }
904 }
905 break;
906
907 case ALPHA_R_LITUSE:
908 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
909 does not cause anything to happen, itself. */
910 rel->address += input_section->output_offset;
911 break;
912
913 case ALPHA_R_GPDISP:
914 /* This marks the ldah of an ldah/lda pair which loads the
915 gp register with the difference of the gp value and the
916 current location. The second of the pair is r_size bytes
917 ahead, and is marked with an ALPHA_R_IGNORE reloc. */
918 {
919 unsigned long insn1, insn2;
920 bfd_vma addend;
921
922 BFD_ASSERT (reloc_vector[1] != NULL
923 && reloc_vector[1]->howto->type == ALPHA_R_IGNORE
924 && (rel->address + rel->addend
925 == reloc_vector[1]->address));
926
927 /* Get the two instructions. */
928 insn1 = bfd_get_32 (input_bfd, data + rel->address);
929 insn2 = bfd_get_32 (input_bfd, data + rel->address + rel->addend);
930
931 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
932 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
933
934 /* Get the existing addend. We must account for the sign
935 extension done by lda and ldah. */
936 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
937 if (insn1 & 0x8000)
938 {
939 addend -= 0x80000000;
940 addend -= 0x80000000;
941 }
942 if (insn2 & 0x8000)
943 addend -= 0x10000;
944
945 /* The existing addend includes the different between the
946 gp of the input BFD and the address in the input BFD.
947 Subtract this out. */
948 addend -= (reloc_vector[1]->addend
949 - (input_section->vma + rel->address));
950
951 /* Now add in the final gp value, and subtract out the
952 final address. */
953 addend += (gp
954 - (input_section->output_section->vma
955 + input_section->output_offset
956 + rel->address));
957
958 /* Change the instructions, accounting for the sign
959 extension, and write them out. */
960 if (addend & 0x8000)
961 addend += 0x10000;
962 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
963 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
964
965 bfd_put_32 (input_bfd, (bfd_vma) insn1, data + rel->address);
966 bfd_put_32 (input_bfd, (bfd_vma) insn2,
967 data + rel->address + rel->addend);
968
969 rel->address += input_section->output_offset;
970 }
971 break;
972
973 case ALPHA_R_OP_PUSH:
974 /* Push a value on the reloc evaluation stack. */
975 {
976 asymbol *symbol;
977 bfd_vma relocation;
978
979 if (relocateable)
980 {
981 rel->address += input_section->output_offset;
982 break;
983 }
984
985 /* Figure out the relocation of this symbol. */
986 symbol = *rel->sym_ptr_ptr;
987
988 if (bfd_is_und_section (symbol->section))
989 r = bfd_reloc_undefined;
990
991 if (bfd_is_com_section (symbol->section))
992 relocation = 0;
993 else
994 relocation = symbol->value;
995 relocation += symbol->section->output_section->vma;
996 relocation += symbol->section->output_offset;
997 relocation += rel->addend;
998
999 if (tos >= RELOC_STACKSIZE)
1000 abort ();
1001
1002 stack[tos++] = relocation;
1003 }
1004 break;
1005
1006 case ALPHA_R_OP_STORE:
1007 /* Store a value from the reloc stack into a bitfield. */
1008 {
1009 bfd_vma val;
1010 int offset, size;
1011
1012 if (relocateable)
1013 {
1014 rel->address += input_section->output_offset;
1015 break;
1016 }
1017
1018 if (tos == 0)
1019 abort ();
1020
1021 /* The offset and size for this reloc are encoded into the
1022 addend field by alpha_adjust_reloc_in. */
1023 offset = (rel->addend >> 8) & 0xff;
1024 size = rel->addend & 0xff;
1025
1026 val = bfd_get_64 (abfd, data + rel->address);
1027 val &=~ (((1 << size) - 1) << offset);
1028 val |= (stack[--tos] & ((1 << size) - 1)) << offset;
1029 bfd_put_64 (abfd, val, data + rel->address);
1030 }
1031 break;
1032
1033 case ALPHA_R_OP_PSUB:
1034 /* Subtract a value from the top of the stack. */
1035 {
1036 asymbol *symbol;
1037 bfd_vma relocation;
1038
1039 if (relocateable)
1040 {
1041 rel->address += input_section->output_offset;
1042 break;
1043 }
1044
1045 /* Figure out the relocation of this symbol. */
1046 symbol = *rel->sym_ptr_ptr;
1047
1048 if (bfd_is_und_section (symbol->section))
1049 r = bfd_reloc_undefined;
1050
1051 if (bfd_is_com_section (symbol->section))
1052 relocation = 0;
1053 else
1054 relocation = symbol->value;
1055 relocation += symbol->section->output_section->vma;
1056 relocation += symbol->section->output_offset;
1057 relocation += rel->addend;
1058
1059 if (tos == 0)
1060 abort ();
1061
1062 stack[tos - 1] -= relocation;
1063 }
1064 break;
1065
1066 case ALPHA_R_OP_PRSHIFT:
1067 /* Shift the value on the top of the stack. */
1068 {
1069 asymbol *symbol;
1070 bfd_vma relocation;
1071
1072 if (relocateable)
1073 {
1074 rel->address += input_section->output_offset;
1075 break;
1076 }
1077
1078 /* Figure out the relocation of this symbol. */
1079 symbol = *rel->sym_ptr_ptr;
1080
1081 if (bfd_is_und_section (symbol->section))
1082 r = bfd_reloc_undefined;
1083
1084 if (bfd_is_com_section (symbol->section))
1085 relocation = 0;
1086 else
1087 relocation = symbol->value;
1088 relocation += symbol->section->output_section->vma;
1089 relocation += symbol->section->output_offset;
1090 relocation += rel->addend;
1091
1092 if (tos == 0)
1093 abort ();
1094
1095 stack[tos - 1] >>= relocation;
1096 }
1097 break;
1098
1099 case ALPHA_R_GPVALUE:
1100 /* I really don't know if this does the right thing. */
1101 gp = rel->addend;
1102 gp_undefined = false;
1103 break;
1104
1105 default:
1106 abort ();
1107 }
1108
1109 if (relocateable)
1110 {
1111 asection *os = input_section->output_section;
1112
1113 /* A partial link, so keep the relocs. */
1114 os->orelocation[os->reloc_count] = rel;
1115 os->reloc_count++;
1116 }
1117
1118 if (r != bfd_reloc_ok)
1119 {
1120 switch (r)
1121 {
1122 case bfd_reloc_undefined:
1123 if (! ((*link_info->callbacks->undefined_symbol)
1124 (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1125 input_bfd, input_section, rel->address)))
1126 goto error_return;
1127 break;
1128 case bfd_reloc_dangerous:
1129 if (! ((*link_info->callbacks->reloc_dangerous)
1130 (link_info, err, input_bfd, input_section,
1131 rel->address)))
1132 goto error_return;
1133 break;
1134 case bfd_reloc_overflow:
1135 if (! ((*link_info->callbacks->reloc_overflow)
1136 (link_info, bfd_asymbol_name (*rel->sym_ptr_ptr),
1137 rel->howto->name, rel->addend, input_bfd,
1138 input_section, rel->address)))
1139 goto error_return;
1140 break;
1141 case bfd_reloc_outofrange:
1142 default:
1143 abort ();
1144 break;
1145 }
1146 }
1147 }
1148
1149 if (tos != 0)
1150 abort ();
1151
1152 successful_return:
1153 if (reloc_vector != NULL)
1154 free (reloc_vector);
1155 return data;
1156
1157 error_return:
1158 if (reloc_vector != NULL)
1159 free (reloc_vector);
1160 return NULL;
1161 }
1162
1163 /* Get the howto structure for a generic reloc type. */
1164
1165 static reloc_howto_type *
1166 alpha_bfd_reloc_type_lookup (abfd, code)
1167 bfd *abfd;
1168 bfd_reloc_code_real_type code;
1169 {
1170 int alpha_type;
1171
1172 switch (code)
1173 {
1174 case BFD_RELOC_32:
1175 alpha_type = ALPHA_R_REFLONG;
1176 break;
1177 case BFD_RELOC_64:
1178 case BFD_RELOC_CTOR:
1179 alpha_type = ALPHA_R_REFQUAD;
1180 break;
1181 case BFD_RELOC_GPREL32:
1182 alpha_type = ALPHA_R_GPREL32;
1183 break;
1184 case BFD_RELOC_ALPHA_LITERAL:
1185 alpha_type = ALPHA_R_LITERAL;
1186 break;
1187 case BFD_RELOC_ALPHA_LITUSE:
1188 alpha_type = ALPHA_R_LITUSE;
1189 break;
1190 case BFD_RELOC_ALPHA_GPDISP_HI16:
1191 alpha_type = ALPHA_R_GPDISP;
1192 break;
1193 case BFD_RELOC_ALPHA_GPDISP_LO16:
1194 alpha_type = ALPHA_R_IGNORE;
1195 break;
1196 case BFD_RELOC_23_PCREL_S2:
1197 alpha_type = ALPHA_R_BRADDR;
1198 break;
1199 case BFD_RELOC_ALPHA_HINT:
1200 alpha_type = ALPHA_R_HINT;
1201 break;
1202 case BFD_RELOC_16_PCREL:
1203 alpha_type = ALPHA_R_SREL16;
1204 break;
1205 case BFD_RELOC_32_PCREL:
1206 alpha_type = ALPHA_R_SREL32;
1207 break;
1208 case BFD_RELOC_64_PCREL:
1209 alpha_type = ALPHA_R_SREL64;
1210 break;
1211 #if 0
1212 case ???:
1213 alpha_type = ALPHA_R_OP_PUSH;
1214 break;
1215 case ???:
1216 alpha_type = ALPHA_R_OP_STORE;
1217 break;
1218 case ???:
1219 alpha_type = ALPHA_R_OP_PSUB;
1220 break;
1221 case ???:
1222 alpha_type = ALPHA_R_OP_PRSHIFT;
1223 break;
1224 case ???:
1225 alpha_type = ALPHA_R_GPVALUE;
1226 break;
1227 #endif
1228 default:
1229 return (reloc_howto_type *) NULL;
1230 }
1231
1232 return &alpha_howto_table[alpha_type];
1233 }
1234 \f
1235 /* A helper routine for alpha_relocate_section which converts an
1236 external reloc when generating relocateable output. Returns the
1237 relocation amount. */
1238
1239 static bfd_vma
1240 alpha_convert_external_reloc (output_bfd, info, input_bfd, ext_rel, h)
1241 bfd *output_bfd;
1242 struct bfd_link_info *info;
1243 bfd *input_bfd;
1244 struct external_reloc *ext_rel;
1245 struct ecoff_link_hash_entry *h;
1246 {
1247 unsigned long r_symndx;
1248 bfd_vma relocation;
1249
1250 BFD_ASSERT (info->relocateable);
1251
1252 if (h->root.type == bfd_link_hash_defined
1253 || h->root.type == bfd_link_hash_defweak)
1254 {
1255 asection *hsec;
1256 const char *name;
1257
1258 /* This symbol is defined in the output. Convert the reloc from
1259 being against the symbol to being against the section. */
1260
1261 /* Clear the r_extern bit. */
1262 ext_rel->r_bits[1] &=~ RELOC_BITS1_EXTERN_LITTLE;
1263
1264 /* Compute a new r_symndx value. */
1265 hsec = h->root.u.def.section;
1266 name = bfd_get_section_name (output_bfd, hsec->output_section);
1267
1268 r_symndx = -1;
1269 switch (name[1])
1270 {
1271 case 'A':
1272 if (strcmp (name, "*ABS*") == 0)
1273 r_symndx = RELOC_SECTION_ABS;
1274 break;
1275 case 'b':
1276 if (strcmp (name, ".bss") == 0)
1277 r_symndx = RELOC_SECTION_BSS;
1278 break;
1279 case 'd':
1280 if (strcmp (name, ".data") == 0)
1281 r_symndx = RELOC_SECTION_DATA;
1282 break;
1283 case 'f':
1284 if (strcmp (name, ".fini") == 0)
1285 r_symndx = RELOC_SECTION_FINI;
1286 break;
1287 case 'i':
1288 if (strcmp (name, ".init") == 0)
1289 r_symndx = RELOC_SECTION_INIT;
1290 break;
1291 case 'l':
1292 if (strcmp (name, ".lita") == 0)
1293 r_symndx = RELOC_SECTION_LITA;
1294 else if (strcmp (name, ".lit8") == 0)
1295 r_symndx = RELOC_SECTION_LIT8;
1296 else if (strcmp (name, ".lit4") == 0)
1297 r_symndx = RELOC_SECTION_LIT4;
1298 break;
1299 case 'p':
1300 if (strcmp (name, ".pdata") == 0)
1301 r_symndx = RELOC_SECTION_PDATA;
1302 break;
1303 case 'r':
1304 if (strcmp (name, ".rdata") == 0)
1305 r_symndx = RELOC_SECTION_RDATA;
1306 else if (strcmp (name, ".rconst") == 0)
1307 r_symndx = RELOC_SECTION_RCONST;
1308 break;
1309 case 's':
1310 if (strcmp (name, ".sdata") == 0)
1311 r_symndx = RELOC_SECTION_SDATA;
1312 else if (strcmp (name, ".sbss") == 0)
1313 r_symndx = RELOC_SECTION_SBSS;
1314 break;
1315 case 't':
1316 if (strcmp (name, ".text") == 0)
1317 r_symndx = RELOC_SECTION_TEXT;
1318 break;
1319 case 'x':
1320 if (strcmp (name, ".xdata") == 0)
1321 r_symndx = RELOC_SECTION_XDATA;
1322 break;
1323 }
1324
1325 if (r_symndx == -1)
1326 abort ();
1327
1328 /* Add the section VMA and the symbol value. */
1329 relocation = (h->root.u.def.value
1330 + hsec->output_section->vma
1331 + hsec->output_offset);
1332 }
1333 else
1334 {
1335 /* Change the symndx value to the right one for
1336 the output BFD. */
1337 r_symndx = h->indx;
1338 if (r_symndx == -1)
1339 {
1340 /* Caller must give an error. */
1341 r_symndx = 0;
1342 }
1343 relocation = 0;
1344 }
1345
1346 /* Write out the new r_symndx value. */
1347 bfd_h_put_32 (input_bfd, (bfd_vma) r_symndx,
1348 (bfd_byte *) ext_rel->r_symndx);
1349
1350 return relocation;
1351 }
1352
1353 /* Relocate a section while linking an Alpha ECOFF file. This is
1354 quite similar to get_relocated_section_contents. Perhaps they
1355 could be combined somehow. */
1356
1357 static boolean
1358 alpha_relocate_section (output_bfd, info, input_bfd, input_section,
1359 contents, external_relocs)
1360 bfd *output_bfd;
1361 struct bfd_link_info *info;
1362 bfd *input_bfd;
1363 asection *input_section;
1364 bfd_byte *contents;
1365 PTR external_relocs;
1366 {
1367 asection **symndx_to_section;
1368 struct ecoff_link_hash_entry **sym_hashes;
1369 bfd_vma gp;
1370 boolean gp_undefined;
1371 bfd_vma stack[RELOC_STACKSIZE];
1372 int tos = 0;
1373 struct external_reloc *ext_rel;
1374 struct external_reloc *ext_rel_end;
1375
1376 /* We keep a table mapping the symndx found in an internal reloc to
1377 the appropriate section. This is faster than looking up the
1378 section by name each time. */
1379 symndx_to_section = ecoff_data (input_bfd)->symndx_to_section;
1380 if (symndx_to_section == (asection **) NULL)
1381 {
1382 symndx_to_section = ((asection **)
1383 bfd_alloc (input_bfd,
1384 (NUM_RELOC_SECTIONS
1385 * sizeof (asection *))));
1386 if (!symndx_to_section)
1387 return false;
1388
1389 symndx_to_section[RELOC_SECTION_NONE] = NULL;
1390 symndx_to_section[RELOC_SECTION_TEXT] =
1391 bfd_get_section_by_name (input_bfd, ".text");
1392 symndx_to_section[RELOC_SECTION_RDATA] =
1393 bfd_get_section_by_name (input_bfd, ".rdata");
1394 symndx_to_section[RELOC_SECTION_DATA] =
1395 bfd_get_section_by_name (input_bfd, ".data");
1396 symndx_to_section[RELOC_SECTION_SDATA] =
1397 bfd_get_section_by_name (input_bfd, ".sdata");
1398 symndx_to_section[RELOC_SECTION_SBSS] =
1399 bfd_get_section_by_name (input_bfd, ".sbss");
1400 symndx_to_section[RELOC_SECTION_BSS] =
1401 bfd_get_section_by_name (input_bfd, ".bss");
1402 symndx_to_section[RELOC_SECTION_INIT] =
1403 bfd_get_section_by_name (input_bfd, ".init");
1404 symndx_to_section[RELOC_SECTION_LIT8] =
1405 bfd_get_section_by_name (input_bfd, ".lit8");
1406 symndx_to_section[RELOC_SECTION_LIT4] =
1407 bfd_get_section_by_name (input_bfd, ".lit4");
1408 symndx_to_section[RELOC_SECTION_XDATA] =
1409 bfd_get_section_by_name (input_bfd, ".xdata");
1410 symndx_to_section[RELOC_SECTION_PDATA] =
1411 bfd_get_section_by_name (input_bfd, ".pdata");
1412 symndx_to_section[RELOC_SECTION_FINI] =
1413 bfd_get_section_by_name (input_bfd, ".fini");
1414 symndx_to_section[RELOC_SECTION_LITA] =
1415 bfd_get_section_by_name (input_bfd, ".lita");
1416 symndx_to_section[RELOC_SECTION_ABS] = bfd_abs_section_ptr;
1417 symndx_to_section[RELOC_SECTION_RCONST] =
1418 bfd_get_section_by_name (input_bfd, ".rconst");
1419
1420 ecoff_data (input_bfd)->symndx_to_section = symndx_to_section;
1421 }
1422
1423 sym_hashes = ecoff_data (input_bfd)->sym_hashes;
1424
1425 gp = ecoff_data (output_bfd)->gp;
1426 if (gp == 0)
1427 gp_undefined = true;
1428 else
1429 gp_undefined = false;
1430
1431 BFD_ASSERT (output_bfd->xvec->header_byteorder_big_p == false);
1432 BFD_ASSERT (input_bfd->xvec->header_byteorder_big_p == false);
1433
1434 ext_rel = (struct external_reloc *) external_relocs;
1435 ext_rel_end = ext_rel + input_section->reloc_count;
1436 for (; ext_rel < ext_rel_end; ext_rel++)
1437 {
1438 bfd_vma r_vaddr;
1439 unsigned long r_symndx;
1440 int r_type;
1441 int r_extern;
1442 int r_offset;
1443 int r_size;
1444 boolean relocatep;
1445 boolean adjust_addrp;
1446 boolean gp_usedp;
1447 bfd_vma addend;
1448
1449 r_vaddr = bfd_h_get_64 (input_bfd, (bfd_byte *) ext_rel->r_vaddr);
1450 r_symndx = bfd_h_get_32 (input_bfd, (bfd_byte *) ext_rel->r_symndx);
1451
1452 r_type = ((ext_rel->r_bits[0] & RELOC_BITS0_TYPE_LITTLE)
1453 >> RELOC_BITS0_TYPE_SH_LITTLE);
1454 r_extern = (ext_rel->r_bits[1] & RELOC_BITS1_EXTERN_LITTLE) != 0;
1455 r_offset = ((ext_rel->r_bits[1] & RELOC_BITS1_OFFSET_LITTLE)
1456 >> RELOC_BITS1_OFFSET_SH_LITTLE);
1457 /* Ignored the reserved bits. */
1458 r_size = ((ext_rel->r_bits[3] & RELOC_BITS3_SIZE_LITTLE)
1459 >> RELOC_BITS3_SIZE_SH_LITTLE);
1460
1461 relocatep = false;
1462 adjust_addrp = true;
1463 gp_usedp = false;
1464 addend = 0;
1465
1466 switch (r_type)
1467 {
1468 default:
1469 abort ();
1470
1471 case ALPHA_R_IGNORE:
1472 /* This reloc appears after a GPDISP reloc. It marks the
1473 position of the second instruction to be altered by the
1474 GPDISP reloc, but is not otherwise used for anything.
1475 For some reason, the address of the relocation does not
1476 appear to include the section VMA, unlike the other
1477 relocation types. */
1478 if (info->relocateable)
1479 bfd_h_put_64 (input_bfd,
1480 input_section->output_offset + r_vaddr,
1481 (bfd_byte *) ext_rel->r_vaddr);
1482 adjust_addrp = false;
1483 break;
1484
1485 case ALPHA_R_REFLONG:
1486 case ALPHA_R_REFQUAD:
1487 case ALPHA_R_BRADDR:
1488 case ALPHA_R_HINT:
1489 case ALPHA_R_SREL16:
1490 case ALPHA_R_SREL32:
1491 case ALPHA_R_SREL64:
1492 relocatep = true;
1493 break;
1494
1495 case ALPHA_R_GPREL32:
1496 /* This relocation is used in a switch table. It is a 32
1497 bit offset from the current GP value. We must adjust it
1498 by the different between the original GP value and the
1499 current GP value. */
1500 relocatep = true;
1501 addend = ecoff_data (input_bfd)->gp - gp;
1502 gp_usedp = true;
1503 break;
1504
1505 case ALPHA_R_LITERAL:
1506 /* This is a reference to a literal value, generally
1507 (always?) in the .lita section. This is a 16 bit GP
1508 relative relocation. Sometimes the subsequent reloc is a
1509 LITUSE reloc, which indicates how this reloc is used.
1510 This sometimes permits rewriting the two instructions
1511 referred to by the LITERAL and the LITUSE into different
1512 instructions which do not refer to .lita. This can save
1513 a memory reference, and permits removing a value from
1514 .lita thus saving GP relative space.
1515
1516 We do not these optimizations. To do them we would need
1517 to arrange to link the .lita section first, so that by
1518 the time we got here we would know the final values to
1519 use. This would not be particularly difficult, but it is
1520 not currently implemented. */
1521
1522 /* I believe that the LITERAL reloc will only apply to a ldq
1523 or ldl instruction, so check my assumption. */
1524 {
1525 unsigned long insn;
1526
1527 insn = bfd_get_32 (input_bfd,
1528 contents + r_vaddr - input_section->vma);
1529 BFD_ASSERT (((insn >> 26) & 0x3f) == 0x29
1530 || ((insn >> 26) & 0x3f) == 0x28);
1531 }
1532
1533 relocatep = true;
1534 addend = ecoff_data (input_bfd)->gp - gp;
1535 gp_usedp = true;
1536 break;
1537
1538 case ALPHA_R_LITUSE:
1539 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
1540 does not cause anything to happen, itself. */
1541 break;
1542
1543 case ALPHA_R_GPDISP:
1544 /* This marks the ldah of an ldah/lda pair which loads the
1545 gp register with the difference of the gp value and the
1546 current location. The second of the pair is r_symndx
1547 bytes ahead, and is also marked with an ALPHA_R_IGNORE
1548 reloc. */
1549 {
1550 unsigned long insn1, insn2;
1551
1552 BFD_ASSERT (ext_rel + 1 < ext_rel_end
1553 && (((ext_rel + 1)->r_bits[0]
1554 & RELOC_BITS0_TYPE_LITTLE)
1555 >> RELOC_BITS0_TYPE_SH_LITTLE) == ALPHA_R_IGNORE
1556 && (bfd_h_get_64 (input_bfd,
1557 (bfd_byte *) (ext_rel + 1)->r_vaddr)
1558 == r_vaddr - input_section->vma + r_symndx));
1559
1560 /* Get the two instructions. */
1561 insn1 = bfd_get_32 (input_bfd,
1562 contents + r_vaddr - input_section->vma);
1563 insn2 = bfd_get_32 (input_bfd,
1564 (contents
1565 + r_vaddr
1566 - input_section->vma
1567 + r_symndx));
1568
1569 BFD_ASSERT (((insn1 >> 26) & 0x3f) == 0x09); /* ldah */
1570 BFD_ASSERT (((insn2 >> 26) & 0x3f) == 0x08); /* lda */
1571
1572 /* Get the existing addend. We must account for the sign
1573 extension done by lda and ldah. */
1574 addend = ((insn1 & 0xffff) << 16) + (insn2 & 0xffff);
1575 if (insn1 & 0x8000)
1576 {
1577 /* This is addend -= 0x100000000 without causing an
1578 integer overflow on a 32 bit host. */
1579 addend -= 0x80000000;
1580 addend -= 0x80000000;
1581 }
1582 if (insn2 & 0x8000)
1583 addend -= 0x10000;
1584
1585 /* The existing addend includes the difference between the
1586 gp of the input BFD and the address in the input BFD.
1587 We want to change this to the difference between the
1588 final GP and the final address. */
1589 addend += (gp
1590 - ecoff_data (input_bfd)->gp
1591 + input_section->vma
1592 - (input_section->output_section->vma
1593 + input_section->output_offset));
1594
1595 /* Change the instructions, accounting for the sign
1596 extension, and write them out. */
1597 if (addend & 0x8000)
1598 addend += 0x10000;
1599 insn1 = (insn1 & 0xffff0000) | ((addend >> 16) & 0xffff);
1600 insn2 = (insn2 & 0xffff0000) | (addend & 0xffff);
1601
1602 bfd_put_32 (input_bfd, (bfd_vma) insn1,
1603 contents + r_vaddr - input_section->vma);
1604 bfd_put_32 (input_bfd, (bfd_vma) insn2,
1605 contents + r_vaddr - input_section->vma + r_symndx);
1606
1607 gp_usedp = true;
1608 }
1609 break;
1610
1611 case ALPHA_R_OP_PUSH:
1612 case ALPHA_R_OP_PSUB:
1613 case ALPHA_R_OP_PRSHIFT:
1614 /* Manipulate values on the reloc evaluation stack. The
1615 r_vaddr field is not an address in input_section, it is
1616 the current value (including any addend) of the object
1617 being used. */
1618 if (! r_extern)
1619 {
1620 asection *s;
1621
1622 s = symndx_to_section[r_symndx];
1623 if (s == (asection *) NULL)
1624 abort ();
1625 addend = s->output_section->vma + s->output_offset - s->vma;
1626 }
1627 else
1628 {
1629 struct ecoff_link_hash_entry *h;
1630
1631 h = sym_hashes[r_symndx];
1632 if (h == (struct ecoff_link_hash_entry *) NULL)
1633 abort ();
1634
1635 if (! info->relocateable)
1636 {
1637 if (h->root.type == bfd_link_hash_defined
1638 || h->root.type == bfd_link_hash_defweak)
1639 addend = (h->root.u.def.value
1640 + h->root.u.def.section->output_section->vma
1641 + h->root.u.def.section->output_offset);
1642 else
1643 {
1644 /* Note that we pass the address as 0, since we
1645 do not have a meaningful number for the
1646 location within the section that is being
1647 relocated. */
1648 if (! ((*info->callbacks->undefined_symbol)
1649 (info, h->root.root.string, input_bfd,
1650 input_section, (bfd_vma) 0)))
1651 return false;
1652 addend = 0;
1653 }
1654 }
1655 else
1656 {
1657 if (h->root.type != bfd_link_hash_defined
1658 && h->root.type != bfd_link_hash_defweak
1659 && h->indx == -1)
1660 {
1661 /* This symbol is not being written out. Pass
1662 the address as 0, as with undefined_symbol,
1663 above. */
1664 if (! ((*info->callbacks->unattached_reloc)
1665 (info, h->root.root.string, input_bfd,
1666 input_section, (bfd_vma) 0)))
1667 return false;
1668 }
1669
1670 addend = alpha_convert_external_reloc (output_bfd, info,
1671 input_bfd,
1672 ext_rel, h);
1673 }
1674 }
1675
1676 addend += r_vaddr;
1677
1678 if (info->relocateable)
1679 {
1680 /* Adjust r_vaddr by the addend. */
1681 bfd_h_put_64 (input_bfd, addend,
1682 (bfd_byte *) ext_rel->r_vaddr);
1683 }
1684 else
1685 {
1686 switch (r_type)
1687 {
1688 case ALPHA_R_OP_PUSH:
1689 if (tos >= RELOC_STACKSIZE)
1690 abort ();
1691 stack[tos++] = addend;
1692 break;
1693
1694 case ALPHA_R_OP_PSUB:
1695 if (tos == 0)
1696 abort ();
1697 stack[tos - 1] -= addend;
1698 break;
1699
1700 case ALPHA_R_OP_PRSHIFT:
1701 if (tos == 0)
1702 abort ();
1703 stack[tos - 1] >>= addend;
1704 break;
1705 }
1706 }
1707
1708 adjust_addrp = false;
1709 break;
1710
1711 case ALPHA_R_OP_STORE:
1712 /* Store a value from the reloc stack into a bitfield. If
1713 we are generating relocateable output, all we do is
1714 adjust the address of the reloc. */
1715 if (! info->relocateable)
1716 {
1717 bfd_vma mask;
1718 bfd_vma val;
1719
1720 if (tos == 0)
1721 abort ();
1722
1723 /* Get the relocation mask. The separate steps and the
1724 casts to bfd_vma are attempts to avoid a bug in the
1725 Alpha OSF 1.3 C compiler. See reloc.c for more
1726 details. */
1727 mask = 1;
1728 mask <<= (bfd_vma) r_size;
1729 mask -= 1;
1730
1731 /* FIXME: I don't know what kind of overflow checking,
1732 if any, should be done here. */
1733 val = bfd_get_64 (input_bfd,
1734 contents + r_vaddr - input_section->vma);
1735 val &=~ mask << (bfd_vma) r_offset;
1736 val |= (stack[--tos] & mask) << (bfd_vma) r_offset;
1737 bfd_put_64 (input_bfd, val,
1738 contents + r_vaddr - input_section->vma);
1739 }
1740 break;
1741
1742 case ALPHA_R_GPVALUE:
1743 /* I really don't know if this does the right thing. */
1744 gp = ecoff_data (input_bfd)->gp + r_symndx;
1745 gp_undefined = false;
1746 break;
1747 }
1748
1749 if (relocatep)
1750 {
1751 reloc_howto_type *howto;
1752 struct ecoff_link_hash_entry *h = NULL;
1753 asection *s = NULL;
1754 bfd_vma relocation;
1755 bfd_reloc_status_type r;
1756
1757 /* Perform a relocation. */
1758
1759 howto = &alpha_howto_table[r_type];
1760
1761 if (r_extern)
1762 {
1763 h = sym_hashes[r_symndx];
1764 /* If h is NULL, that means that there is a reloc
1765 against an external symbol which we thought was just
1766 a debugging symbol. This should not happen. */
1767 if (h == (struct ecoff_link_hash_entry *) NULL)
1768 abort ();
1769 }
1770 else
1771 {
1772 if (r_symndx >= NUM_RELOC_SECTIONS)
1773 s = NULL;
1774 else
1775 s = symndx_to_section[r_symndx];
1776
1777 if (s == (asection *) NULL)
1778 abort ();
1779 }
1780
1781 if (info->relocateable)
1782 {
1783 /* We are generating relocateable output, and must
1784 convert the existing reloc. */
1785 if (r_extern)
1786 {
1787 if (h->root.type != bfd_link_hash_defined
1788 && h->root.type != bfd_link_hash_defweak
1789 && h->indx == -1)
1790 {
1791 /* This symbol is not being written out. */
1792 if (! ((*info->callbacks->unattached_reloc)
1793 (info, h->root.root.string, input_bfd,
1794 input_section, r_vaddr - input_section->vma)))
1795 return false;
1796 }
1797
1798 relocation = alpha_convert_external_reloc (output_bfd,
1799 info,
1800 input_bfd,
1801 ext_rel,
1802 h);
1803 }
1804 else
1805 {
1806 /* This is a relocation against a section. Adjust
1807 the value by the amount the section moved. */
1808 relocation = (s->output_section->vma
1809 + s->output_offset
1810 - s->vma);
1811 }
1812
1813 /* If this is PC relative, the existing object file
1814 appears to already have the reloc worked out. We
1815 must subtract out the old value and add in the new
1816 one. */
1817 if (howto->pc_relative)
1818 relocation -= (input_section->output_section->vma
1819 + input_section->output_offset
1820 - input_section->vma);
1821
1822 /* Put in any addend. */
1823 relocation += addend;
1824
1825 /* Adjust the contents. */
1826 r = _bfd_relocate_contents (howto, input_bfd, relocation,
1827 (contents
1828 + r_vaddr
1829 - input_section->vma));
1830 }
1831 else
1832 {
1833 /* We are producing a final executable. */
1834 if (r_extern)
1835 {
1836 /* This is a reloc against a symbol. */
1837 if (h->root.type == bfd_link_hash_defined
1838 || h->root.type == bfd_link_hash_defweak)
1839 {
1840 asection *hsec;
1841
1842 hsec = h->root.u.def.section;
1843 relocation = (h->root.u.def.value
1844 + hsec->output_section->vma
1845 + hsec->output_offset);
1846 }
1847 else
1848 {
1849 if (! ((*info->callbacks->undefined_symbol)
1850 (info, h->root.root.string, input_bfd,
1851 input_section,
1852 r_vaddr - input_section->vma)))
1853 return false;
1854 relocation = 0;
1855 }
1856 }
1857 else
1858 {
1859 /* This is a reloc against a section. */
1860 relocation = (s->output_section->vma
1861 + s->output_offset
1862 - s->vma);
1863
1864 /* Adjust a PC relative relocation by removing the
1865 reference to the original source section. */
1866 if (howto->pc_relative)
1867 relocation += input_section->vma;
1868 }
1869
1870 r = _bfd_final_link_relocate (howto,
1871 input_bfd,
1872 input_section,
1873 contents,
1874 r_vaddr - input_section->vma,
1875 relocation,
1876 addend);
1877 }
1878
1879 if (r != bfd_reloc_ok)
1880 {
1881 switch (r)
1882 {
1883 default:
1884 case bfd_reloc_outofrange:
1885 abort ();
1886 case bfd_reloc_overflow:
1887 {
1888 const char *name;
1889
1890 if (r_extern)
1891 name = sym_hashes[r_symndx]->root.root.string;
1892 else
1893 name = bfd_section_name (input_bfd,
1894 symndx_to_section[r_symndx]);
1895 if (! ((*info->callbacks->reloc_overflow)
1896 (info, name, alpha_howto_table[r_type].name,
1897 (bfd_vma) 0, input_bfd, input_section,
1898 r_vaddr - input_section->vma)))
1899 return false;
1900 }
1901 break;
1902 }
1903 }
1904 }
1905
1906 if (info->relocateable && adjust_addrp)
1907 {
1908 /* Change the address of the relocation. */
1909 bfd_h_put_64 (input_bfd,
1910 (input_section->output_section->vma
1911 + input_section->output_offset
1912 - input_section->vma
1913 + r_vaddr),
1914 (bfd_byte *) ext_rel->r_vaddr);
1915 }
1916
1917 if (gp_usedp && gp_undefined)
1918 {
1919 if (! ((*info->callbacks->reloc_dangerous)
1920 (info, "GP relative relocation when GP not defined",
1921 input_bfd, input_section, r_vaddr - input_section->vma)))
1922 return false;
1923 /* Only give the error once per link. */
1924 ecoff_data (output_bfd)->gp = gp = 4;
1925 gp_undefined = false;
1926 }
1927 }
1928
1929 if (tos != 0)
1930 abort ();
1931
1932 return true;
1933 }
1934 \f
1935 /* Do final adjustments to the filehdr and the aouthdr. This routine
1936 sets the dynamic bits in the file header. */
1937
1938 /*ARGSUSED*/
1939 static boolean
1940 alpha_adjust_headers (abfd, fhdr, ahdr)
1941 bfd *abfd;
1942 struct internal_filehdr *fhdr;
1943 struct internal_aouthdr *ahdr;
1944 {
1945 if ((abfd->flags & (DYNAMIC | EXEC_P)) == (DYNAMIC | EXEC_P))
1946 fhdr->f_flags |= F_ALPHA_CALL_SHARED;
1947 else if ((abfd->flags & DYNAMIC) != 0)
1948 fhdr->f_flags |= F_ALPHA_SHARABLE;
1949 return true;
1950 }
1951 \f
1952 /* This is the ECOFF backend structure. The backend field of the
1953 target vector points to this. */
1954
1955 static const struct ecoff_backend_data alpha_ecoff_backend_data =
1956 {
1957 /* COFF backend structure. */
1958 {
1959 (void (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR))) bfd_void, /* aux_in */
1960 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
1961 (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
1962 (unsigned (*) PARAMS ((bfd *,PTR,int,int,int,int,PTR)))bfd_void,/*aux_out*/
1963 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
1964 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
1965 (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
1966 alpha_ecoff_swap_filehdr_out, alpha_ecoff_swap_aouthdr_out,
1967 alpha_ecoff_swap_scnhdr_out,
1968 FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, 0, true,
1969 alpha_ecoff_swap_filehdr_in, alpha_ecoff_swap_aouthdr_in,
1970 alpha_ecoff_swap_scnhdr_in, NULL,
1971 alpha_ecoff_bad_format_hook, _bfd_ecoff_set_arch_mach_hook,
1972 alpha_ecoff_mkobject_hook, _bfd_ecoff_styp_to_sec_flags,
1973 _bfd_ecoff_set_alignment_hook, _bfd_ecoff_slurp_symbol_table,
1974 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
1975 },
1976 /* Supported architecture. */
1977 bfd_arch_alpha,
1978 /* Initial portion of armap string. */
1979 "________64",
1980 /* The page boundary used to align sections in a demand-paged
1981 executable file. E.g., 0x1000. */
1982 0x2000,
1983 /* True if the .rdata section is part of the text segment, as on the
1984 Alpha. False if .rdata is part of the data segment, as on the
1985 MIPS. */
1986 true,
1987 /* Bitsize of constructor entries. */
1988 64,
1989 /* Reloc to use for constructor entries. */
1990 &alpha_howto_table[ALPHA_R_REFQUAD],
1991 {
1992 /* Symbol table magic number. */
1993 magicSym2,
1994 /* Alignment of debugging information. E.g., 4. */
1995 8,
1996 /* Sizes of external symbolic information. */
1997 sizeof (struct hdr_ext),
1998 sizeof (struct dnr_ext),
1999 sizeof (struct pdr_ext),
2000 sizeof (struct sym_ext),
2001 sizeof (struct opt_ext),
2002 sizeof (struct fdr_ext),
2003 sizeof (struct rfd_ext),
2004 sizeof (struct ext_ext),
2005 /* Functions to swap in external symbolic data. */
2006 ecoff_swap_hdr_in,
2007 ecoff_swap_dnr_in,
2008 ecoff_swap_pdr_in,
2009 ecoff_swap_sym_in,
2010 ecoff_swap_opt_in,
2011 ecoff_swap_fdr_in,
2012 ecoff_swap_rfd_in,
2013 ecoff_swap_ext_in,
2014 _bfd_ecoff_swap_tir_in,
2015 _bfd_ecoff_swap_rndx_in,
2016 /* Functions to swap out external symbolic data. */
2017 ecoff_swap_hdr_out,
2018 ecoff_swap_dnr_out,
2019 ecoff_swap_pdr_out,
2020 ecoff_swap_sym_out,
2021 ecoff_swap_opt_out,
2022 ecoff_swap_fdr_out,
2023 ecoff_swap_rfd_out,
2024 ecoff_swap_ext_out,
2025 _bfd_ecoff_swap_tir_out,
2026 _bfd_ecoff_swap_rndx_out,
2027 /* Function to read in symbolic data. */
2028 _bfd_ecoff_slurp_symbolic_info
2029 },
2030 /* External reloc size. */
2031 RELSZ,
2032 /* Reloc swapping functions. */
2033 alpha_ecoff_swap_reloc_in,
2034 alpha_ecoff_swap_reloc_out,
2035 /* Backend reloc tweaking. */
2036 alpha_adjust_reloc_in,
2037 alpha_adjust_reloc_out,
2038 /* Relocate section contents while linking. */
2039 alpha_relocate_section,
2040 /* Do final adjustments to filehdr and aouthdr. */
2041 alpha_adjust_headers
2042 };
2043
2044 /* Looking up a reloc type is Alpha specific. */
2045 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2046
2047 /* So is getting relocated section contents. */
2048 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2049 alpha_ecoff_get_relocated_section_contents
2050
2051 /* Handling file windows is generic. */
2052 #define _bfd_ecoff_get_section_contents_in_window \
2053 _bfd_generic_get_section_contents_in_window
2054
2055 /* Relaxing sections is generic. */
2056 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2057
2058 const bfd_target ecoffalpha_little_vec =
2059 {
2060 "ecoff-littlealpha", /* name */
2061 bfd_target_ecoff_flavour,
2062 false, /* data byte order is little */
2063 false, /* header byte order is little */
2064
2065 (HAS_RELOC | EXEC_P | /* object flags */
2066 HAS_LINENO | HAS_DEBUG |
2067 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2068
2069 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
2070 0, /* leading underscore */
2071 ' ', /* ar_pad_char */
2072 15, /* ar_max_namelen */
2073 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2074 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2075 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2076 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2077 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2078 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2079
2080 {_bfd_dummy_target, alpha_ecoff_object_p, /* bfd_check_format */
2081 _bfd_ecoff_archive_p, _bfd_dummy_target},
2082 {bfd_false, _bfd_ecoff_mkobject, /* bfd_set_format */
2083 _bfd_generic_mkarchive, bfd_false},
2084 {bfd_false, _bfd_ecoff_write_object_contents, /* bfd_write_contents */
2085 _bfd_write_archive_contents, bfd_false},
2086
2087 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff),
2088 BFD_JUMP_TABLE_COPY (_bfd_ecoff),
2089 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2090 BFD_JUMP_TABLE_ARCHIVE (_bfd_ecoff),
2091 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff),
2092 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff),
2093 BFD_JUMP_TABLE_WRITE (_bfd_ecoff),
2094 BFD_JUMP_TABLE_LINK (_bfd_ecoff),
2095 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2096
2097 (PTR) &alpha_ecoff_backend_data
2098 };
GDB Binutils - Deliverables
This page took 0.070425 seconds and 5 git commands to generate.