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