1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
4 Contributed by Richard Henderson <rth@tamu.edu>.
6 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
22 /* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
30 #include "elf/alpha.h"
34 #define NO_COFF_RELOCS
35 #define NO_COFF_SYMBOLS
36 #define NO_COFF_LINENOS
38 /* Get the ECOFF swapping routines. Needed for the debug information. */
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/alpha.h"
48 #include "ecoffswap.h"
50 static bfd_boolean alpha_elf_dynamic_symbol_p
51 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*));
52 static struct bfd_hash_entry
* elf64_alpha_link_hash_newfunc
53 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
54 static struct bfd_link_hash_table
* elf64_alpha_bfd_link_hash_table_create
57 static bfd_reloc_status_type elf64_alpha_reloc_nil
58 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
59 static bfd_reloc_status_type elf64_alpha_reloc_bad
60 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
61 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
62 PARAMS ((bfd
*, bfd_vma
, bfd_byte
*, bfd_byte
*));
63 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
64 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
66 static reloc_howto_type
* elf64_alpha_bfd_reloc_type_lookup
67 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
68 static void elf64_alpha_info_to_howto
69 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
71 static bfd_boolean elf64_alpha_mkobject
73 static bfd_boolean elf64_alpha_object_p
75 static bfd_boolean elf64_alpha_section_from_shdr
76 PARAMS ((bfd
*, Elf_Internal_Shdr
*, const char *));
77 static bfd_boolean elf64_alpha_section_flags
78 PARAMS ((flagword
*, Elf_Internal_Shdr
*));
79 static bfd_boolean elf64_alpha_fake_sections
80 PARAMS ((bfd
*, Elf_Internal_Shdr
*, asection
*));
81 static bfd_boolean elf64_alpha_create_got_section
82 PARAMS ((bfd
*, struct bfd_link_info
*));
83 static bfd_boolean elf64_alpha_create_dynamic_sections
84 PARAMS ((bfd
*, struct bfd_link_info
*));
86 static bfd_boolean elf64_alpha_read_ecoff_info
87 PARAMS ((bfd
*, asection
*, struct ecoff_debug_info
*));
88 static bfd_boolean elf64_alpha_is_local_label_name
89 PARAMS ((bfd
*, const char *));
90 static bfd_boolean elf64_alpha_find_nearest_line
91 PARAMS ((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
92 const char **, unsigned int *));
94 #if defined(__STDC__) || defined(ALMOST_STDC)
95 struct alpha_elf_link_hash_entry
;
98 static bfd_boolean elf64_alpha_output_extsym
99 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
101 static bfd_boolean elf64_alpha_can_merge_gots
102 PARAMS ((bfd
*, bfd
*));
103 static void elf64_alpha_merge_gots
104 PARAMS ((bfd
*, bfd
*));
105 static bfd_boolean elf64_alpha_calc_got_offsets_for_symbol
106 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
107 static void elf64_alpha_calc_got_offsets
108 PARAMS ((struct bfd_link_info
*));
109 static bfd_boolean elf64_alpha_size_got_sections
110 PARAMS ((struct bfd_link_info
*));
111 static bfd_boolean elf64_alpha_size_plt_section
112 PARAMS ((struct bfd_link_info
*));
113 static bfd_boolean elf64_alpha_size_plt_section_1
114 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
115 static bfd_boolean elf64_alpha_always_size_sections
116 PARAMS ((bfd
*, struct bfd_link_info
*));
117 static int alpha_dynamic_entries_for_reloc
118 PARAMS ((int, int, int));
119 static bfd_boolean elf64_alpha_calc_dynrel_sizes
120 PARAMS ((struct alpha_elf_link_hash_entry
*, struct bfd_link_info
*));
121 static bfd_boolean elf64_alpha_size_rela_got_section
122 PARAMS ((struct bfd_link_info
*));
123 static bfd_boolean elf64_alpha_size_rela_got_1
124 PARAMS ((struct alpha_elf_link_hash_entry
*, struct bfd_link_info
*));
125 static bfd_boolean elf64_alpha_add_symbol_hook
126 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Sym
*,
127 const char **, flagword
*, asection
**, bfd_vma
*));
128 static struct alpha_elf_got_entry
*get_got_entry
129 PARAMS ((bfd
*, struct alpha_elf_link_hash_entry
*, unsigned long,
130 unsigned long, bfd_vma
));
131 static bfd_boolean elf64_alpha_check_relocs
132 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*sec
,
133 const Elf_Internal_Rela
*));
134 static bfd_boolean elf64_alpha_adjust_dynamic_symbol
135 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
136 static bfd_boolean elf64_alpha_size_dynamic_sections
137 PARAMS ((bfd
*, struct bfd_link_info
*));
138 static void elf64_alpha_emit_dynrel
139 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*, asection
*,
140 bfd_vma
, long, long, bfd_vma
));
141 static bfd_boolean elf64_alpha_relocate_section_r
142 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
143 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
144 static bfd_boolean elf64_alpha_relocate_section
145 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
146 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
147 static bfd_boolean elf64_alpha_finish_dynamic_symbol
148 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
149 Elf_Internal_Sym
*));
150 static bfd_boolean elf64_alpha_finish_dynamic_sections
151 PARAMS ((bfd
*, struct bfd_link_info
*));
152 static bfd_boolean elf64_alpha_final_link
153 PARAMS ((bfd
*, struct bfd_link_info
*));
154 static bfd_boolean elf64_alpha_merge_ind_symbols
155 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
156 static Elf_Internal_Rela
* elf64_alpha_find_reloc_at_ofs
157 PARAMS ((Elf_Internal_Rela
*, Elf_Internal_Rela
*, bfd_vma
, int));
158 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
159 PARAMS ((const Elf_Internal_Rela
*));
161 struct alpha_elf_link_hash_entry
163 struct elf_link_hash_entry root
;
165 /* External symbol information. */
168 /* Cumulative flags for all the .got entries. */
171 /* Contexts in which a literal was referenced. */
172 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
173 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
174 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
175 #define ALPHA_ELF_LINK_HASH_LU_JSR 0x08
176 #define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10
177 #define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20
178 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x38
179 #define ALPHA_ELF_LINK_HASH_TLS_IE 0x40
180 #define ALPHA_ELF_LINK_HASH_PLT_LOC 0x80
182 /* Used to undo the localization of a plt symbol. */
183 asection
*plt_old_section
;
184 bfd_vma plt_old_value
;
186 /* Used to implement multiple .got subsections. */
187 struct alpha_elf_got_entry
189 struct alpha_elf_got_entry
*next
;
191 /* Which .got subsection? */
194 /* The addend in effect for this entry. */
197 /* The .got offset for this entry. */
200 /* How many references to this entry? */
203 /* The relocation type of this entry. */
204 unsigned char reloc_type
;
206 /* How a LITERAL is used. */
209 /* Have we initialized the dynamic relocation for this entry? */
210 unsigned char reloc_done
;
212 /* Have we adjusted this entry for SEC_MERGE? */
213 unsigned char reloc_xlated
;
216 /* Used to count non-got, non-plt relocations for delayed sizing
217 of relocation sections. */
218 struct alpha_elf_reloc_entry
220 struct alpha_elf_reloc_entry
*next
;
222 /* Which .reloc section? */
225 /* What kind of relocation? */
228 /* Is this against read-only section? */
229 unsigned int reltext
: 1;
231 /* How many did we find? */
236 /* Alpha ELF linker hash table. */
238 struct alpha_elf_link_hash_table
240 struct elf_link_hash_table root
;
242 /* The head of a list of .got subsections linked through
243 alpha_elf_tdata(abfd)->got_link_next. */
247 /* Look up an entry in a Alpha ELF linker hash table. */
249 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
250 ((struct alpha_elf_link_hash_entry *) \
251 elf_link_hash_lookup (&(table)->root, (string), (create), \
254 /* Traverse a Alpha ELF linker hash table. */
256 #define alpha_elf_link_hash_traverse(table, func, info) \
257 (elf_link_hash_traverse \
259 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
262 /* Get the Alpha ELF linker hash table from a link_info structure. */
264 #define alpha_elf_hash_table(p) \
265 ((struct alpha_elf_link_hash_table *) ((p)->hash))
267 /* Get the object's symbols as our own entry type. */
269 #define alpha_elf_sym_hashes(abfd) \
270 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
272 /* Should we do dynamic things to this symbol? This differs from the
273 generic version in that we never need to consider function pointer
274 equality wrt PLT entries -- we don't create a PLT entry if a symbol's
275 address is ever taken. */
277 static inline bfd_boolean
278 alpha_elf_dynamic_symbol_p (h
, info
)
279 struct elf_link_hash_entry
*h
;
280 struct bfd_link_info
*info
;
282 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
285 /* Create an entry in a Alpha ELF linker hash table. */
287 static struct bfd_hash_entry
*
288 elf64_alpha_link_hash_newfunc (entry
, table
, string
)
289 struct bfd_hash_entry
*entry
;
290 struct bfd_hash_table
*table
;
293 struct alpha_elf_link_hash_entry
*ret
=
294 (struct alpha_elf_link_hash_entry
*) entry
;
296 /* Allocate the structure if it has not already been allocated by a
298 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
299 ret
= ((struct alpha_elf_link_hash_entry
*)
300 bfd_hash_allocate (table
,
301 sizeof (struct alpha_elf_link_hash_entry
)));
302 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
303 return (struct bfd_hash_entry
*) ret
;
305 /* Call the allocation method of the superclass. */
306 ret
= ((struct alpha_elf_link_hash_entry
*)
307 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
309 if (ret
!= (struct alpha_elf_link_hash_entry
*) NULL
)
311 /* Set local fields. */
312 memset (&ret
->esym
, 0, sizeof (EXTR
));
313 /* We use -2 as a marker to indicate that the information has
314 not been set. -1 means there is no associated ifd. */
317 ret
->got_entries
= NULL
;
318 ret
->reloc_entries
= NULL
;
321 return (struct bfd_hash_entry
*) ret
;
324 /* Create a Alpha ELF linker hash table. */
326 static struct bfd_link_hash_table
*
327 elf64_alpha_bfd_link_hash_table_create (abfd
)
330 struct alpha_elf_link_hash_table
*ret
;
331 bfd_size_type amt
= sizeof (struct alpha_elf_link_hash_table
);
333 ret
= (struct alpha_elf_link_hash_table
*) bfd_zmalloc (amt
);
334 if (ret
== (struct alpha_elf_link_hash_table
*) NULL
)
337 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
338 elf64_alpha_link_hash_newfunc
))
344 return &ret
->root
.root
;
347 /* We have some private fields hanging off of the elf_tdata structure. */
349 struct alpha_elf_obj_tdata
351 struct elf_obj_tdata root
;
353 /* For every input file, these are the got entries for that object's
355 struct alpha_elf_got_entry
** local_got_entries
;
357 /* For every input file, this is the object that owns the got that
358 this input file uses. */
361 /* For every got, this is a linked list through the objects using this got */
362 bfd
*in_got_link_next
;
364 /* For every got, this is a link to the next got subsegment. */
367 /* For every got, this is the section. */
370 /* For every got, this is it's total number of words. */
373 /* For every got, this is the sum of the number of words required
374 to hold all of the member object's local got. */
378 #define alpha_elf_tdata(abfd) \
379 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
382 elf64_alpha_mkobject (abfd
)
385 bfd_size_type amt
= sizeof (struct alpha_elf_obj_tdata
);
386 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
387 if (abfd
->tdata
.any
== NULL
)
393 elf64_alpha_object_p (abfd
)
396 /* Allocate our special target data. */
397 struct alpha_elf_obj_tdata
*new_tdata
;
398 bfd_size_type amt
= sizeof (struct alpha_elf_obj_tdata
);
399 new_tdata
= bfd_zalloc (abfd
, amt
);
400 if (new_tdata
== NULL
)
402 new_tdata
->root
= *abfd
->tdata
.elf_obj_data
;
403 abfd
->tdata
.any
= new_tdata
;
405 /* Set the right machine number for an Alpha ELF file. */
406 return bfd_default_set_arch_mach (abfd
, bfd_arch_alpha
, 0);
409 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
410 from smaller values. Start with zero, widen, *then* decrement. */
411 #define MINUS_ONE (((bfd_vma)0) - 1)
413 #define SKIP_HOWTO(N) \
414 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
416 static reloc_howto_type elf64_alpha_howto_table
[] =
418 HOWTO (R_ALPHA_NONE
, /* type */
420 0, /* size (0 = byte, 1 = short, 2 = long) */
422 TRUE
, /* pc_relative */
424 complain_overflow_dont
, /* complain_on_overflow */
425 elf64_alpha_reloc_nil
, /* special_function */
427 FALSE
, /* partial_inplace */
430 TRUE
), /* pcrel_offset */
432 /* A 32 bit reference to a symbol. */
433 HOWTO (R_ALPHA_REFLONG
, /* type */
435 2, /* size (0 = byte, 1 = short, 2 = long) */
437 FALSE
, /* pc_relative */
439 complain_overflow_bitfield
, /* complain_on_overflow */
440 0, /* special_function */
441 "REFLONG", /* name */
442 FALSE
, /* partial_inplace */
443 0xffffffff, /* src_mask */
444 0xffffffff, /* dst_mask */
445 FALSE
), /* pcrel_offset */
447 /* A 64 bit reference to a symbol. */
448 HOWTO (R_ALPHA_REFQUAD
, /* type */
450 4, /* size (0 = byte, 1 = short, 2 = long) */
452 FALSE
, /* pc_relative */
454 complain_overflow_bitfield
, /* complain_on_overflow */
455 0, /* special_function */
456 "REFQUAD", /* name */
457 FALSE
, /* partial_inplace */
458 MINUS_ONE
, /* src_mask */
459 MINUS_ONE
, /* dst_mask */
460 FALSE
), /* pcrel_offset */
462 /* A 32 bit GP relative offset. This is just like REFLONG except
463 that when the value is used the value of the gp register will be
465 HOWTO (R_ALPHA_GPREL32
, /* type */
467 2, /* size (0 = byte, 1 = short, 2 = long) */
469 FALSE
, /* pc_relative */
471 complain_overflow_bitfield
, /* complain_on_overflow */
472 0, /* special_function */
473 "GPREL32", /* name */
474 FALSE
, /* partial_inplace */
475 0xffffffff, /* src_mask */
476 0xffffffff, /* dst_mask */
477 FALSE
), /* pcrel_offset */
479 /* Used for an instruction that refers to memory off the GP register. */
480 HOWTO (R_ALPHA_LITERAL
, /* type */
482 1, /* size (0 = byte, 1 = short, 2 = long) */
484 FALSE
, /* pc_relative */
486 complain_overflow_signed
, /* complain_on_overflow */
487 0, /* special_function */
488 "ELF_LITERAL", /* name */
489 FALSE
, /* partial_inplace */
490 0xffff, /* src_mask */
491 0xffff, /* dst_mask */
492 FALSE
), /* pcrel_offset */
494 /* This reloc only appears immediately following an ELF_LITERAL reloc.
495 It identifies a use of the literal. The symbol index is special:
496 1 means the literal address is in the base register of a memory
497 format instruction; 2 means the literal address is in the byte
498 offset register of a byte-manipulation instruction; 3 means the
499 literal address is in the target register of a jsr instruction.
500 This does not actually do any relocation. */
501 HOWTO (R_ALPHA_LITUSE
, /* type */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
505 FALSE
, /* pc_relative */
507 complain_overflow_dont
, /* complain_on_overflow */
508 elf64_alpha_reloc_nil
, /* special_function */
510 FALSE
, /* partial_inplace */
513 FALSE
), /* pcrel_offset */
515 /* Load the gp register. This is always used for a ldah instruction
516 which loads the upper 16 bits of the gp register. The symbol
517 index of the GPDISP instruction is an offset in bytes to the lda
518 instruction that loads the lower 16 bits. The value to use for
519 the relocation is the difference between the GP value and the
520 current location; the load will always be done against a register
521 holding the current address.
523 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
524 any offset is present in the instructions, it is an offset from
525 the register to the ldah instruction. This lets us avoid any
526 stupid hackery like inventing a gp value to do partial relocation
527 against. Also unlike ECOFF, we do the whole relocation off of
528 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
529 space consuming bit, that, since all the information was present
530 in the GPDISP_HI16 reloc. */
531 HOWTO (R_ALPHA_GPDISP
, /* type */
533 2, /* size (0 = byte, 1 = short, 2 = long) */
535 FALSE
, /* pc_relative */
537 complain_overflow_dont
, /* complain_on_overflow */
538 elf64_alpha_reloc_gpdisp
, /* special_function */
540 FALSE
, /* partial_inplace */
541 0xffff, /* src_mask */
542 0xffff, /* dst_mask */
543 TRUE
), /* pcrel_offset */
545 /* A 21 bit branch. */
546 HOWTO (R_ALPHA_BRADDR
, /* type */
548 2, /* size (0 = byte, 1 = short, 2 = long) */
550 TRUE
, /* pc_relative */
552 complain_overflow_signed
, /* complain_on_overflow */
553 0, /* special_function */
555 FALSE
, /* partial_inplace */
556 0x1fffff, /* src_mask */
557 0x1fffff, /* dst_mask */
558 TRUE
), /* pcrel_offset */
560 /* A hint for a jump to a register. */
561 HOWTO (R_ALPHA_HINT
, /* type */
563 1, /* size (0 = byte, 1 = short, 2 = long) */
565 TRUE
, /* pc_relative */
567 complain_overflow_dont
, /* complain_on_overflow */
568 0, /* special_function */
570 FALSE
, /* partial_inplace */
571 0x3fff, /* src_mask */
572 0x3fff, /* dst_mask */
573 TRUE
), /* pcrel_offset */
575 /* 16 bit PC relative offset. */
576 HOWTO (R_ALPHA_SREL16
, /* type */
578 1, /* size (0 = byte, 1 = short, 2 = long) */
580 TRUE
, /* pc_relative */
582 complain_overflow_signed
, /* complain_on_overflow */
583 0, /* special_function */
585 FALSE
, /* partial_inplace */
586 0xffff, /* src_mask */
587 0xffff, /* dst_mask */
588 TRUE
), /* pcrel_offset */
590 /* 32 bit PC relative offset. */
591 HOWTO (R_ALPHA_SREL32
, /* type */
593 2, /* size (0 = byte, 1 = short, 2 = long) */
595 TRUE
, /* pc_relative */
597 complain_overflow_signed
, /* complain_on_overflow */
598 0, /* special_function */
600 FALSE
, /* partial_inplace */
601 0xffffffff, /* src_mask */
602 0xffffffff, /* dst_mask */
603 TRUE
), /* pcrel_offset */
605 /* A 64 bit PC relative offset. */
606 HOWTO (R_ALPHA_SREL64
, /* type */
608 4, /* size (0 = byte, 1 = short, 2 = long) */
610 TRUE
, /* pc_relative */
612 complain_overflow_signed
, /* complain_on_overflow */
613 0, /* special_function */
615 FALSE
, /* partial_inplace */
616 MINUS_ONE
, /* src_mask */
617 MINUS_ONE
, /* dst_mask */
618 TRUE
), /* pcrel_offset */
620 /* Skip 12 - 16; deprecated ECOFF relocs. */
627 /* The high 16 bits of the displacement from GP to the target. */
628 HOWTO (R_ALPHA_GPRELHIGH
,
630 1, /* size (0 = byte, 1 = short, 2 = long) */
632 FALSE
, /* pc_relative */
634 complain_overflow_signed
, /* complain_on_overflow */
635 0, /* special_function */
636 "GPRELHIGH", /* name */
637 FALSE
, /* partial_inplace */
638 0xffff, /* src_mask */
639 0xffff, /* dst_mask */
640 FALSE
), /* pcrel_offset */
642 /* The low 16 bits of the displacement from GP to the target. */
643 HOWTO (R_ALPHA_GPRELLOW
,
645 1, /* size (0 = byte, 1 = short, 2 = long) */
647 FALSE
, /* pc_relative */
649 complain_overflow_dont
, /* complain_on_overflow */
650 0, /* special_function */
651 "GPRELLOW", /* name */
652 FALSE
, /* partial_inplace */
653 0xffff, /* src_mask */
654 0xffff, /* dst_mask */
655 FALSE
), /* pcrel_offset */
657 /* A 16-bit displacement from the GP to the target. */
658 HOWTO (R_ALPHA_GPREL16
,
660 1, /* size (0 = byte, 1 = short, 2 = long) */
662 FALSE
, /* pc_relative */
664 complain_overflow_signed
, /* complain_on_overflow */
665 0, /* special_function */
666 "GPREL16", /* name */
667 FALSE
, /* partial_inplace */
668 0xffff, /* src_mask */
669 0xffff, /* dst_mask */
670 FALSE
), /* pcrel_offset */
672 /* Skip 20 - 23; deprecated ECOFF relocs. */
678 /* Misc ELF relocations. */
680 /* A dynamic relocation to copy the target into our .dynbss section. */
681 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
682 is present because every other ELF has one, but should not be used
683 because .dynbss is an ugly thing. */
690 complain_overflow_dont
,
691 bfd_elf_generic_reloc
,
698 /* A dynamic relocation for a .got entry. */
699 HOWTO (R_ALPHA_GLOB_DAT
,
705 complain_overflow_dont
,
706 bfd_elf_generic_reloc
,
713 /* A dynamic relocation for a .plt entry. */
714 HOWTO (R_ALPHA_JMP_SLOT
,
720 complain_overflow_dont
,
721 bfd_elf_generic_reloc
,
728 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
729 HOWTO (R_ALPHA_RELATIVE
,
735 complain_overflow_dont
,
736 bfd_elf_generic_reloc
,
743 /* A 21 bit branch that adjusts for gp loads. */
744 HOWTO (R_ALPHA_BRSGP
, /* type */
746 2, /* size (0 = byte, 1 = short, 2 = long) */
748 TRUE
, /* pc_relative */
750 complain_overflow_signed
, /* complain_on_overflow */
751 0, /* special_function */
753 FALSE
, /* partial_inplace */
754 0x1fffff, /* src_mask */
755 0x1fffff, /* dst_mask */
756 TRUE
), /* pcrel_offset */
758 /* Creates a tls_index for the symbol in the got. */
759 HOWTO (R_ALPHA_TLSGD
, /* type */
761 1, /* size (0 = byte, 1 = short, 2 = long) */
763 FALSE
, /* pc_relative */
765 complain_overflow_signed
, /* complain_on_overflow */
766 0, /* special_function */
768 FALSE
, /* partial_inplace */
769 0xffff, /* src_mask */
770 0xffff, /* dst_mask */
771 FALSE
), /* pcrel_offset */
773 /* Creates a tls_index for the (current) module in the got. */
774 HOWTO (R_ALPHA_TLSLDM
, /* type */
776 1, /* size (0 = byte, 1 = short, 2 = long) */
778 FALSE
, /* pc_relative */
780 complain_overflow_signed
, /* complain_on_overflow */
781 0, /* special_function */
783 FALSE
, /* partial_inplace */
784 0xffff, /* src_mask */
785 0xffff, /* dst_mask */
786 FALSE
), /* pcrel_offset */
788 /* A dynamic relocation for a DTP module entry. */
789 HOWTO (R_ALPHA_DTPMOD64
, /* type */
791 4, /* size (0 = byte, 1 = short, 2 = long) */
793 FALSE
, /* pc_relative */
795 complain_overflow_bitfield
, /* complain_on_overflow */
796 0, /* special_function */
797 "DTPMOD64", /* name */
798 FALSE
, /* partial_inplace */
799 MINUS_ONE
, /* src_mask */
800 MINUS_ONE
, /* dst_mask */
801 FALSE
), /* pcrel_offset */
803 /* Creates a 64-bit offset in the got for the displacement
804 from DTP to the target. */
805 HOWTO (R_ALPHA_GOTDTPREL
, /* type */
807 1, /* size (0 = byte, 1 = short, 2 = long) */
809 FALSE
, /* pc_relative */
811 complain_overflow_signed
, /* complain_on_overflow */
812 0, /* special_function */
813 "GOTDTPREL", /* name */
814 FALSE
, /* partial_inplace */
815 0xffff, /* src_mask */
816 0xffff, /* dst_mask */
817 FALSE
), /* pcrel_offset */
819 /* A dynamic relocation for a displacement from DTP to the target. */
820 HOWTO (R_ALPHA_DTPREL64
, /* type */
822 4, /* size (0 = byte, 1 = short, 2 = long) */
824 FALSE
, /* pc_relative */
826 complain_overflow_bitfield
, /* complain_on_overflow */
827 0, /* special_function */
828 "DTPREL64", /* name */
829 FALSE
, /* partial_inplace */
830 MINUS_ONE
, /* src_mask */
831 MINUS_ONE
, /* dst_mask */
832 FALSE
), /* pcrel_offset */
834 /* The high 16 bits of the displacement from DTP to the target. */
835 HOWTO (R_ALPHA_DTPRELHI
, /* type */
837 1, /* size (0 = byte, 1 = short, 2 = long) */
839 FALSE
, /* pc_relative */
841 complain_overflow_signed
, /* complain_on_overflow */
842 0, /* special_function */
843 "DTPRELHI", /* name */
844 FALSE
, /* partial_inplace */
845 0xffff, /* src_mask */
846 0xffff, /* dst_mask */
847 FALSE
), /* pcrel_offset */
849 /* The low 16 bits of the displacement from DTP to the target. */
850 HOWTO (R_ALPHA_DTPRELLO
, /* type */
852 1, /* size (0 = byte, 1 = short, 2 = long) */
854 FALSE
, /* pc_relative */
856 complain_overflow_dont
, /* complain_on_overflow */
857 0, /* special_function */
858 "DTPRELLO", /* name */
859 FALSE
, /* partial_inplace */
860 0xffff, /* src_mask */
861 0xffff, /* dst_mask */
862 FALSE
), /* pcrel_offset */
864 /* A 16-bit displacement from DTP to the target. */
865 HOWTO (R_ALPHA_DTPREL16
, /* type */
867 1, /* size (0 = byte, 1 = short, 2 = long) */
869 FALSE
, /* pc_relative */
871 complain_overflow_signed
, /* complain_on_overflow */
872 0, /* special_function */
873 "DTPREL16", /* name */
874 FALSE
, /* partial_inplace */
875 0xffff, /* src_mask */
876 0xffff, /* dst_mask */
877 FALSE
), /* pcrel_offset */
879 /* Creates a 64-bit offset in the got for the displacement
880 from TP to the target. */
881 HOWTO (R_ALPHA_GOTTPREL
, /* type */
883 1, /* size (0 = byte, 1 = short, 2 = long) */
885 FALSE
, /* pc_relative */
887 complain_overflow_signed
, /* complain_on_overflow */
888 0, /* special_function */
889 "GOTTPREL", /* name */
890 FALSE
, /* partial_inplace */
891 0xffff, /* src_mask */
892 0xffff, /* dst_mask */
893 FALSE
), /* pcrel_offset */
895 /* A dynamic relocation for a displacement from TP to the target. */
896 HOWTO (R_ALPHA_TPREL64
, /* type */
898 4, /* size (0 = byte, 1 = short, 2 = long) */
900 FALSE
, /* pc_relative */
902 complain_overflow_bitfield
, /* complain_on_overflow */
903 0, /* special_function */
904 "TPREL64", /* name */
905 FALSE
, /* partial_inplace */
906 MINUS_ONE
, /* src_mask */
907 MINUS_ONE
, /* dst_mask */
908 FALSE
), /* pcrel_offset */
910 /* The high 16 bits of the displacement from TP to the target. */
911 HOWTO (R_ALPHA_TPRELHI
, /* type */
913 1, /* size (0 = byte, 1 = short, 2 = long) */
915 FALSE
, /* pc_relative */
917 complain_overflow_signed
, /* complain_on_overflow */
918 0, /* special_function */
919 "TPRELHI", /* name */
920 FALSE
, /* partial_inplace */
921 0xffff, /* src_mask */
922 0xffff, /* dst_mask */
923 FALSE
), /* pcrel_offset */
925 /* The low 16 bits of the displacement from TP to the target. */
926 HOWTO (R_ALPHA_TPRELLO
, /* type */
928 1, /* size (0 = byte, 1 = short, 2 = long) */
930 FALSE
, /* pc_relative */
932 complain_overflow_dont
, /* complain_on_overflow */
933 0, /* special_function */
934 "TPRELLO", /* name */
935 FALSE
, /* partial_inplace */
936 0xffff, /* src_mask */
937 0xffff, /* dst_mask */
938 FALSE
), /* pcrel_offset */
940 /* A 16-bit displacement from TP to the target. */
941 HOWTO (R_ALPHA_TPREL16
, /* type */
943 1, /* size (0 = byte, 1 = short, 2 = long) */
945 FALSE
, /* pc_relative */
947 complain_overflow_signed
, /* complain_on_overflow */
948 0, /* special_function */
949 "TPREL16", /* name */
950 FALSE
, /* partial_inplace */
951 0xffff, /* src_mask */
952 0xffff, /* dst_mask */
953 FALSE
), /* pcrel_offset */
956 /* A relocation function which doesn't do anything. */
958 static bfd_reloc_status_type
959 elf64_alpha_reloc_nil (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
960 bfd
*abfd ATTRIBUTE_UNUSED
;
962 asymbol
*sym ATTRIBUTE_UNUSED
;
963 PTR data ATTRIBUTE_UNUSED
;
966 char **error_message ATTRIBUTE_UNUSED
;
969 reloc
->address
+= sec
->output_offset
;
973 /* A relocation function used for an unsupported reloc. */
975 static bfd_reloc_status_type
976 elf64_alpha_reloc_bad (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
977 bfd
*abfd ATTRIBUTE_UNUSED
;
979 asymbol
*sym ATTRIBUTE_UNUSED
;
980 PTR data ATTRIBUTE_UNUSED
;
983 char **error_message ATTRIBUTE_UNUSED
;
986 reloc
->address
+= sec
->output_offset
;
987 return bfd_reloc_notsupported
;
990 /* Do the work of the GPDISP relocation. */
992 static bfd_reloc_status_type
993 elf64_alpha_do_reloc_gpdisp (abfd
, gpdisp
, p_ldah
, p_lda
)
999 bfd_reloc_status_type ret
= bfd_reloc_ok
;
1001 unsigned long i_ldah
, i_lda
;
1003 i_ldah
= bfd_get_32 (abfd
, p_ldah
);
1004 i_lda
= bfd_get_32 (abfd
, p_lda
);
1006 /* Complain if the instructions are not correct. */
1007 if (((i_ldah
>> 26) & 0x3f) != 0x09
1008 || ((i_lda
>> 26) & 0x3f) != 0x08)
1009 ret
= bfd_reloc_dangerous
;
1011 /* Extract the user-supplied offset, mirroring the sign extensions
1012 that the instructions perform. */
1013 addend
= ((i_ldah
& 0xffff) << 16) | (i_lda
& 0xffff);
1014 addend
= (addend
^ 0x80008000) - 0x80008000;
1018 if ((bfd_signed_vma
) gpdisp
< -(bfd_signed_vma
) 0x80000000
1019 || (bfd_signed_vma
) gpdisp
>= (bfd_signed_vma
) 0x7fff8000)
1020 ret
= bfd_reloc_overflow
;
1022 /* compensate for the sign extension again. */
1023 i_ldah
= ((i_ldah
& 0xffff0000)
1024 | (((gpdisp
>> 16) + ((gpdisp
>> 15) & 1)) & 0xffff));
1025 i_lda
= (i_lda
& 0xffff0000) | (gpdisp
& 0xffff);
1027 bfd_put_32 (abfd
, (bfd_vma
) i_ldah
, p_ldah
);
1028 bfd_put_32 (abfd
, (bfd_vma
) i_lda
, p_lda
);
1033 /* The special function for the GPDISP reloc. */
1035 static bfd_reloc_status_type
1036 elf64_alpha_reloc_gpdisp (abfd
, reloc_entry
, sym
, data
, input_section
,
1037 output_bfd
, err_msg
)
1039 arelent
*reloc_entry
;
1040 asymbol
*sym ATTRIBUTE_UNUSED
;
1042 asection
*input_section
;
1046 bfd_reloc_status_type ret
;
1047 bfd_vma gp
, relocation
;
1048 bfd_byte
*p_ldah
, *p_lda
;
1050 /* Don't do anything if we're not doing a final link. */
1053 reloc_entry
->address
+= input_section
->output_offset
;
1054 return bfd_reloc_ok
;
1057 if (reloc_entry
->address
> input_section
->_cooked_size
||
1058 reloc_entry
->address
+ reloc_entry
->addend
> input_section
->_cooked_size
)
1059 return bfd_reloc_outofrange
;
1061 /* The gp used in the portion of the output object to which this
1062 input object belongs is cached on the input bfd. */
1063 gp
= _bfd_get_gp_value (abfd
);
1065 relocation
= (input_section
->output_section
->vma
1066 + input_section
->output_offset
1067 + reloc_entry
->address
);
1069 p_ldah
= (bfd_byte
*) data
+ reloc_entry
->address
;
1070 p_lda
= p_ldah
+ reloc_entry
->addend
;
1072 ret
= elf64_alpha_do_reloc_gpdisp (abfd
, gp
- relocation
, p_ldah
, p_lda
);
1074 /* Complain if the instructions are not correct. */
1075 if (ret
== bfd_reloc_dangerous
)
1076 *err_msg
= _("GPDISP relocation did not find ldah and lda instructions");
1081 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1083 struct elf_reloc_map
1085 bfd_reloc_code_real_type bfd_reloc_val
;
1089 static const struct elf_reloc_map elf64_alpha_reloc_map
[] =
1091 {BFD_RELOC_NONE
, R_ALPHA_NONE
},
1092 {BFD_RELOC_32
, R_ALPHA_REFLONG
},
1093 {BFD_RELOC_64
, R_ALPHA_REFQUAD
},
1094 {BFD_RELOC_CTOR
, R_ALPHA_REFQUAD
},
1095 {BFD_RELOC_GPREL32
, R_ALPHA_GPREL32
},
1096 {BFD_RELOC_ALPHA_ELF_LITERAL
, R_ALPHA_LITERAL
},
1097 {BFD_RELOC_ALPHA_LITUSE
, R_ALPHA_LITUSE
},
1098 {BFD_RELOC_ALPHA_GPDISP
, R_ALPHA_GPDISP
},
1099 {BFD_RELOC_23_PCREL_S2
, R_ALPHA_BRADDR
},
1100 {BFD_RELOC_ALPHA_HINT
, R_ALPHA_HINT
},
1101 {BFD_RELOC_16_PCREL
, R_ALPHA_SREL16
},
1102 {BFD_RELOC_32_PCREL
, R_ALPHA_SREL32
},
1103 {BFD_RELOC_64_PCREL
, R_ALPHA_SREL64
},
1104 {BFD_RELOC_ALPHA_GPREL_HI16
, R_ALPHA_GPRELHIGH
},
1105 {BFD_RELOC_ALPHA_GPREL_LO16
, R_ALPHA_GPRELLOW
},
1106 {BFD_RELOC_GPREL16
, R_ALPHA_GPREL16
},
1107 {BFD_RELOC_ALPHA_BRSGP
, R_ALPHA_BRSGP
},
1108 {BFD_RELOC_ALPHA_TLSGD
, R_ALPHA_TLSGD
},
1109 {BFD_RELOC_ALPHA_TLSLDM
, R_ALPHA_TLSLDM
},
1110 {BFD_RELOC_ALPHA_DTPMOD64
, R_ALPHA_DTPMOD64
},
1111 {BFD_RELOC_ALPHA_GOTDTPREL16
, R_ALPHA_GOTDTPREL
},
1112 {BFD_RELOC_ALPHA_DTPREL64
, R_ALPHA_DTPREL64
},
1113 {BFD_RELOC_ALPHA_DTPREL_HI16
, R_ALPHA_DTPRELHI
},
1114 {BFD_RELOC_ALPHA_DTPREL_LO16
, R_ALPHA_DTPRELLO
},
1115 {BFD_RELOC_ALPHA_DTPREL16
, R_ALPHA_DTPREL16
},
1116 {BFD_RELOC_ALPHA_GOTTPREL16
, R_ALPHA_GOTTPREL
},
1117 {BFD_RELOC_ALPHA_TPREL64
, R_ALPHA_TPREL64
},
1118 {BFD_RELOC_ALPHA_TPREL_HI16
, R_ALPHA_TPRELHI
},
1119 {BFD_RELOC_ALPHA_TPREL_LO16
, R_ALPHA_TPRELLO
},
1120 {BFD_RELOC_ALPHA_TPREL16
, R_ALPHA_TPREL16
},
1123 /* Given a BFD reloc type, return a HOWTO structure. */
1125 static reloc_howto_type
*
1126 elf64_alpha_bfd_reloc_type_lookup (abfd
, code
)
1127 bfd
*abfd ATTRIBUTE_UNUSED
;
1128 bfd_reloc_code_real_type code
;
1130 const struct elf_reloc_map
*i
, *e
;
1131 i
= e
= elf64_alpha_reloc_map
;
1132 e
+= sizeof (elf64_alpha_reloc_map
) / sizeof (struct elf_reloc_map
);
1135 if (i
->bfd_reloc_val
== code
)
1136 return &elf64_alpha_howto_table
[i
->elf_reloc_val
];
1141 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1144 elf64_alpha_info_to_howto (abfd
, cache_ptr
, dst
)
1145 bfd
*abfd ATTRIBUTE_UNUSED
;
1147 Elf_Internal_Rela
*dst
;
1151 r_type
= ELF64_R_TYPE(dst
->r_info
);
1152 BFD_ASSERT (r_type
< (unsigned int) R_ALPHA_max
);
1153 cache_ptr
->howto
= &elf64_alpha_howto_table
[r_type
];
1156 /* These two relocations create a two-word entry in the got. */
1157 #define alpha_got_entry_size(r_type) \
1158 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1160 /* This is PT_TLS segment p_vaddr. */
1161 #define alpha_get_dtprel_base(info) \
1162 (elf_hash_table (info)->tls_sec->vma)
1164 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1165 is assigned offset round(16, PT_TLS p_align). */
1166 #define alpha_get_tprel_base(info) \
1167 (elf_hash_table (info)->tls_sec->vma \
1168 - align_power ((bfd_vma) 16, \
1169 elf_hash_table (info)->tls_sec->alignment_power))
1171 /* These functions do relaxation for Alpha ELF.
1173 Currently I'm only handling what I can do with existing compiler
1174 and assembler support, which means no instructions are removed,
1175 though some may be nopped. At this time GCC does not emit enough
1176 information to do all of the relaxing that is possible. It will
1177 take some not small amount of work for that to happen.
1179 There are a couple of interesting papers that I once read on this
1180 subject, that I cannot find references to at the moment, that
1181 related to Alpha in particular. They are by David Wall, then of
1185 #define OP_LDAH 0x09
1186 #define INSN_JSR 0x68004000
1187 #define INSN_JSR_MASK 0xfc00c000
1191 #define INSN_UNOP 0x2ffe0000
1192 #define INSN_ADDQ 0x40000400
1193 #define INSN_RDUNIQ 0x0000009e
1195 struct alpha_relax_info
1200 Elf_Internal_Shdr
*symtab_hdr
;
1201 Elf_Internal_Rela
*relocs
, *relend
;
1202 struct bfd_link_info
*link_info
;
1206 struct alpha_elf_link_hash_entry
*h
;
1207 struct alpha_elf_got_entry
**first_gotent
;
1208 struct alpha_elf_got_entry
*gotent
;
1209 bfd_boolean changed_contents
;
1210 bfd_boolean changed_relocs
;
1211 unsigned char other
;
1214 static bfd_boolean elf64_alpha_relax_with_lituse
1215 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1216 Elf_Internal_Rela
*irel
));
1217 static bfd_vma elf64_alpha_relax_opt_call
1218 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
));
1219 static bfd_boolean elf64_alpha_relax_got_load
1220 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1221 Elf_Internal_Rela
*irel
, unsigned long));
1222 static bfd_boolean elf64_alpha_relax_gprelhilo
1223 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1224 Elf_Internal_Rela
*irel
, bfd_boolean
));
1225 static bfd_boolean elf64_alpha_relax_tls_get_addr
1226 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1227 Elf_Internal_Rela
*irel
, bfd_boolean
));
1228 static bfd_boolean elf64_alpha_relax_section
1229 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
1230 bfd_boolean
*again
));
1232 static Elf_Internal_Rela
*
1233 elf64_alpha_find_reloc_at_ofs (rel
, relend
, offset
, type
)
1234 Elf_Internal_Rela
*rel
, *relend
;
1238 while (rel
< relend
)
1240 if (rel
->r_offset
== offset
1241 && ELF64_R_TYPE (rel
->r_info
) == (unsigned int) type
)
1249 elf64_alpha_relax_with_lituse (info
, symval
, irel
)
1250 struct alpha_relax_info
*info
;
1252 Elf_Internal_Rela
*irel
;
1254 Elf_Internal_Rela
*urel
, *irelend
= info
->relend
;
1255 int flags
, count
, i
;
1256 bfd_signed_vma disp
;
1259 bfd_boolean lit_reused
= FALSE
;
1260 bfd_boolean all_optimized
= TRUE
;
1261 unsigned int lit_insn
;
1263 lit_insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1264 if (lit_insn
>> 26 != OP_LDQ
)
1266 ((*_bfd_error_handler
)
1267 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1268 bfd_archive_filename (info
->abfd
), info
->sec
->name
,
1269 (unsigned long) irel
->r_offset
));
1273 /* Can't relax dynamic symbols. */
1274 if (alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
1277 /* Summarize how this particular LITERAL is used. */
1278 for (urel
= irel
+1, flags
= count
= 0; urel
< irelend
; ++urel
, ++count
)
1280 if (ELF64_R_TYPE (urel
->r_info
) != R_ALPHA_LITUSE
)
1282 if (urel
->r_addend
<= 3)
1283 flags
|= 1 << urel
->r_addend
;
1286 /* A little preparation for the loop... */
1287 disp
= symval
- info
->gp
;
1289 for (urel
= irel
+1, i
= 0; i
< count
; ++i
, ++urel
)
1293 bfd_signed_vma xdisp
;
1295 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ urel
->r_offset
);
1297 switch (urel
->r_addend
)
1299 case LITUSE_ALPHA_ADDR
:
1301 /* This type is really just a placeholder to note that all
1302 uses cannot be optimized, but to still allow some. */
1303 all_optimized
= FALSE
;
1306 case LITUSE_ALPHA_BASE
:
1307 /* We can always optimize 16-bit displacements. */
1309 /* Extract the displacement from the instruction, sign-extending
1310 it if necessary, then test whether it is within 16 or 32 bits
1311 displacement from GP. */
1312 insn_disp
= insn
& 0x0000ffff;
1313 if (insn_disp
& 0x8000)
1314 insn_disp
|= ~0xffff; /* Negative: sign-extend. */
1316 xdisp
= disp
+ insn_disp
;
1317 fits16
= (xdisp
>= - (bfd_signed_vma
) 0x8000 && xdisp
< 0x8000);
1318 fits32
= (xdisp
>= - (bfd_signed_vma
) 0x80000000
1319 && xdisp
< 0x7fff8000);
1323 /* Take the op code and dest from this insn, take the base
1324 register from the literal insn. Leave the offset alone. */
1325 insn
= (insn
& 0xffe0ffff) | (lit_insn
& 0x001f0000);
1326 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1328 urel
->r_addend
= irel
->r_addend
;
1329 info
->changed_relocs
= TRUE
;
1331 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1332 info
->contents
+ urel
->r_offset
);
1333 info
->changed_contents
= TRUE
;
1336 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1337 else if (fits32
&& !(flags
& ~6))
1339 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1341 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1343 lit_insn
= (OP_LDAH
<< 26) | (lit_insn
& 0x03ff0000);
1344 bfd_put_32 (info
->abfd
, (bfd_vma
) lit_insn
,
1345 info
->contents
+ irel
->r_offset
);
1347 info
->changed_contents
= TRUE
;
1349 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1351 urel
->r_addend
= irel
->r_addend
;
1352 info
->changed_relocs
= TRUE
;
1355 all_optimized
= FALSE
;
1358 case LITUSE_ALPHA_BYTOFF
:
1359 /* We can always optimize byte instructions. */
1361 /* FIXME: sanity check the insn for byte op. Check that the
1362 literal dest reg is indeed Rb in the byte insn. */
1364 insn
&= ~ (unsigned) 0x001ff000;
1365 insn
|= ((symval
& 7) << 13) | 0x1000;
1367 urel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1369 info
->changed_relocs
= TRUE
;
1371 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1372 info
->contents
+ urel
->r_offset
);
1373 info
->changed_contents
= TRUE
;
1376 case LITUSE_ALPHA_JSR
:
1377 case LITUSE_ALPHA_TLSGD
:
1378 case LITUSE_ALPHA_TLSLDM
:
1380 bfd_vma optdest
, org
;
1381 bfd_signed_vma odisp
;
1383 /* If not zero, place to jump without needing pv. */
1384 optdest
= elf64_alpha_relax_opt_call (info
, symval
);
1385 org
= (info
->sec
->output_section
->vma
1386 + info
->sec
->output_offset
1387 + urel
->r_offset
+ 4);
1388 odisp
= (optdest
? optdest
: symval
) - org
;
1390 if (odisp
>= -0x400000 && odisp
< 0x400000)
1392 Elf_Internal_Rela
*xrel
;
1394 /* Preserve branch prediction call stack when possible. */
1395 if ((insn
& INSN_JSR_MASK
) == INSN_JSR
)
1396 insn
= (OP_BSR
<< 26) | (insn
& 0x03e00000);
1398 insn
= (OP_BR
<< 26) | (insn
& 0x03e00000);
1400 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1402 urel
->r_addend
= irel
->r_addend
;
1405 urel
->r_addend
+= optdest
- symval
;
1407 all_optimized
= FALSE
;
1409 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1410 info
->contents
+ urel
->r_offset
);
1412 /* Kill any HINT reloc that might exist for this insn. */
1413 xrel
= (elf64_alpha_find_reloc_at_ofs
1414 (info
->relocs
, info
->relend
, urel
->r_offset
,
1417 xrel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1419 info
->changed_contents
= TRUE
;
1420 info
->changed_relocs
= TRUE
;
1423 all_optimized
= FALSE
;
1425 /* Even if the target is not in range for a direct branch,
1426 if we share a GP, we can eliminate the gp reload. */
1429 Elf_Internal_Rela
*gpdisp
1430 = (elf64_alpha_find_reloc_at_ofs
1431 (info
->relocs
, irelend
, urel
->r_offset
+ 4,
1435 bfd_byte
*p_ldah
= info
->contents
+ gpdisp
->r_offset
;
1436 bfd_byte
*p_lda
= p_ldah
+ gpdisp
->r_addend
;
1437 unsigned int ldah
= bfd_get_32 (info
->abfd
, p_ldah
);
1438 unsigned int lda
= bfd_get_32 (info
->abfd
, p_lda
);
1440 /* Verify that the instruction is "ldah $29,0($26)".
1441 Consider a function that ends in a noreturn call,
1442 and that the next function begins with an ldgp,
1443 and that by accident there is no padding between.
1444 In that case the insn would use $27 as the base. */
1445 if (ldah
== 0x27ba0000 && lda
== 0x23bd0000)
1447 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, p_ldah
);
1448 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, p_lda
);
1450 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1451 info
->changed_contents
= TRUE
;
1452 info
->changed_relocs
= TRUE
;
1461 /* If all cases were optimized, we can reduce the use count on this
1462 got entry by one, possibly eliminating it. */
1465 if (--info
->gotent
->use_count
== 0)
1467 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
1468 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1470 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
1473 /* If the literal instruction is no longer needed (it may have been
1474 reused. We can eliminate it. */
1475 /* ??? For now, I don't want to deal with compacting the section,
1476 so just nop it out. */
1479 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1480 info
->changed_relocs
= TRUE
;
1482 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
,
1483 info
->contents
+ irel
->r_offset
);
1484 info
->changed_contents
= TRUE
;
1492 elf64_alpha_relax_opt_call (info
, symval
)
1493 struct alpha_relax_info
*info
;
1496 /* If the function has the same gp, and we can identify that the
1497 function does not use its function pointer, we can eliminate the
1500 /* If the symbol is marked NOPV, we are being told the function never
1501 needs its procedure value. */
1502 if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_NOPV
)
1505 /* If the symbol is marked STD_GP, we are being told the function does
1506 a normal ldgp in the first two words. */
1507 else if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_STD_GPLOAD
)
1510 /* Otherwise, we may be able to identify a GP load in the first two
1511 words, which we can then skip. */
1514 Elf_Internal_Rela
*tsec_relocs
, *tsec_relend
, *tsec_free
, *gpdisp
;
1517 /* Load the relocations from the section that the target symbol is in. */
1518 if (info
->sec
== info
->tsec
)
1520 tsec_relocs
= info
->relocs
;
1521 tsec_relend
= info
->relend
;
1526 tsec_relocs
= (_bfd_elf_link_read_relocs
1527 (info
->abfd
, info
->tsec
, (PTR
) NULL
,
1528 (Elf_Internal_Rela
*) NULL
,
1529 info
->link_info
->keep_memory
));
1530 if (tsec_relocs
== NULL
)
1532 tsec_relend
= tsec_relocs
+ info
->tsec
->reloc_count
;
1533 tsec_free
= (info
->link_info
->keep_memory
? NULL
: tsec_relocs
);
1536 /* Recover the symbol's offset within the section. */
1537 ofs
= (symval
- info
->tsec
->output_section
->vma
1538 - info
->tsec
->output_offset
);
1540 /* Look for a GPDISP reloc. */
1541 gpdisp
= (elf64_alpha_find_reloc_at_ofs
1542 (tsec_relocs
, tsec_relend
, ofs
, R_ALPHA_GPDISP
));
1544 if (!gpdisp
|| gpdisp
->r_addend
!= 4)
1554 /* We've now determined that we can skip an initial gp load. Verify
1555 that the call and the target use the same gp. */
1556 if (info
->link_info
->hash
->creator
!= info
->tsec
->owner
->xvec
1557 || info
->gotobj
!= alpha_elf_tdata (info
->tsec
->owner
)->gotobj
)
1564 elf64_alpha_relax_got_load (info
, symval
, irel
, r_type
)
1565 struct alpha_relax_info
*info
;
1567 Elf_Internal_Rela
*irel
;
1568 unsigned long r_type
;
1571 bfd_signed_vma disp
;
1573 /* Get the instruction. */
1574 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1576 if (insn
>> 26 != OP_LDQ
)
1578 reloc_howto_type
*howto
= elf64_alpha_howto_table
+ r_type
;
1579 ((*_bfd_error_handler
)
1580 ("%s: %s+0x%lx: warning: %s relocation against unexpected insn",
1581 bfd_archive_filename (info
->abfd
), info
->sec
->name
,
1582 (unsigned long) irel
->r_offset
, howto
->name
));
1586 /* Can't relax dynamic symbols. */
1587 if (alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
1590 /* Can't use local-exec relocations in shared libraries. */
1591 if (r_type
== R_ALPHA_GOTTPREL
&& info
->link_info
->shared
)
1594 if (r_type
== R_ALPHA_LITERAL
)
1595 disp
= symval
- info
->gp
;
1598 bfd_vma dtp_base
, tp_base
;
1600 BFD_ASSERT (elf_hash_table (info
->link_info
)->tls_sec
!= NULL
);
1601 dtp_base
= alpha_get_dtprel_base (info
->link_info
);
1602 tp_base
= alpha_get_tprel_base (info
->link_info
);
1603 disp
= symval
- (r_type
== R_ALPHA_GOTDTPREL
? dtp_base
: tp_base
);
1606 if (disp
< -0x8000 || disp
>= 0x8000)
1609 /* Exchange LDQ for LDA. In the case of the TLS relocs, we're loading
1610 a constant, so force the base register to be $31. */
1611 if (r_type
== R_ALPHA_LITERAL
)
1612 insn
= (OP_LDA
<< 26) | (insn
& 0x03ff0000);
1614 insn
= (OP_LDA
<< 26) | (insn
& (31 << 21)) | (31 << 16);
1615 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, info
->contents
+ irel
->r_offset
);
1616 info
->changed_contents
= TRUE
;
1618 /* Reduce the use count on this got entry by one, possibly
1620 if (--info
->gotent
->use_count
== 0)
1622 int sz
= alpha_got_entry_size (r_type
);
1623 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1625 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
1628 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
1631 case R_ALPHA_LITERAL
:
1632 r_type
= R_ALPHA_GPREL16
;
1634 case R_ALPHA_GOTDTPREL
:
1635 r_type
= R_ALPHA_DTPREL16
;
1637 case R_ALPHA_GOTTPREL
:
1638 r_type
= R_ALPHA_TPREL16
;
1645 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
), r_type
);
1646 info
->changed_relocs
= TRUE
;
1648 /* ??? Search forward through this basic block looking for insns
1649 that use the target register. Stop after an insn modifying the
1650 register is seen, or after a branch or call.
1652 Any such memory load insn may be substituted by a load directly
1653 off the GP. This allows the memory load insn to be issued before
1654 the calculated GP register would otherwise be ready.
1656 Any such jsr insn can be replaced by a bsr if it is in range.
1658 This would mean that we'd have to _add_ relocations, the pain of
1659 which gives one pause. */
1665 elf64_alpha_relax_gprelhilo (info
, symval
, irel
, hi
)
1666 struct alpha_relax_info
*info
;
1668 Elf_Internal_Rela
*irel
;
1672 bfd_signed_vma disp
;
1673 bfd_byte
*pos
= info
->contents
+ irel
->r_offset
;
1675 /* ??? This assumes that the compiler doesn't render
1679 ldah t, array(gp) !gprelhigh
1681 ldq r, array(t) !gprellow
1683 which would indeed be the most efficient way to implement this. */
1687 disp
= symval
- info
->gp
;
1688 if (disp
< -0x8000 || disp
>= 0x8000)
1693 /* Nop out the high instruction. */
1695 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
);
1696 info
->changed_contents
= TRUE
;
1698 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1700 info
->changed_relocs
= TRUE
;
1704 /* Adjust the low instruction to reference GP directly. */
1706 insn
= bfd_get_32 (info
->abfd
, pos
);
1707 insn
= (insn
& 0xffe00000) | (29 << 16);
1708 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
);
1709 info
->changed_contents
= TRUE
;
1711 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1713 info
->changed_relocs
= TRUE
;
1720 elf64_alpha_relax_tls_get_addr (info
, symval
, irel
, is_gd
)
1721 struct alpha_relax_info
*info
;
1723 Elf_Internal_Rela
*irel
;
1728 Elf_Internal_Rela
*gpdisp
, *hint
;
1729 bfd_boolean dynamic
, use_gottprel
, pos1_unusable
;
1730 unsigned long new_symndx
;
1732 dynamic
= alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
);
1734 /* If a TLS symbol is accessed using IE at least once, there is no point
1735 to use dynamic model for it. */
1736 if (is_gd
&& info
->h
&& (info
->h
->flags
& ALPHA_ELF_LINK_HASH_TLS_IE
))
1739 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
1740 then we might as well relax to IE. */
1741 else if (info
->link_info
->shared
&& !dynamic
1742 && (info
->link_info
->flags
& DF_STATIC_TLS
))
1745 /* Otherwise we must be building an executable to do anything. */
1746 else if (info
->link_info
->shared
)
1749 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
1750 the matching LITUSE_TLS relocations. */
1751 if (irel
+ 2 >= info
->relend
)
1753 if (ELF64_R_TYPE (irel
[1].r_info
) != R_ALPHA_LITERAL
1754 || ELF64_R_TYPE (irel
[2].r_info
) != R_ALPHA_LITUSE
1755 || irel
[2].r_addend
!= (is_gd
? LITUSE_ALPHA_TLSGD
: LITUSE_ALPHA_TLSLDM
))
1758 /* There must be a GPDISP relocation positioned immediately after the
1759 LITUSE relocation. */
1760 gpdisp
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
1761 irel
[2].r_offset
+ 4, R_ALPHA_GPDISP
);
1765 pos
[0] = info
->contents
+ irel
[0].r_offset
;
1766 pos
[1] = info
->contents
+ irel
[1].r_offset
;
1767 pos
[2] = info
->contents
+ irel
[2].r_offset
;
1768 pos
[3] = info
->contents
+ gpdisp
->r_offset
;
1769 pos
[4] = pos
[3] + gpdisp
->r_addend
;
1770 pos1_unusable
= FALSE
;
1772 /* Generally, the positions are not allowed to be out of order, lest the
1773 modified insn sequence have different register lifetimes. We can make
1774 an exception when pos 1 is adjacent to pos 0. */
1775 if (pos
[1] + 4 == pos
[0])
1777 bfd_byte
*tmp
= pos
[0];
1781 else if (pos
[1] < pos
[0])
1782 pos1_unusable
= TRUE
;
1783 if (pos
[1] >= pos
[2] || pos
[2] >= pos
[3])
1786 /* Reduce the use count on the LITERAL relocation. Do this before we
1787 smash the symndx when we adjust the relocations below. */
1789 struct alpha_elf_got_entry
*lit_gotent
;
1790 struct alpha_elf_link_hash_entry
*lit_h
;
1793 BFD_ASSERT (ELF64_R_SYM (irel
[1].r_info
) >= info
->symtab_hdr
->sh_info
);
1794 indx
= ELF64_R_SYM (irel
[1].r_info
) - info
->symtab_hdr
->sh_info
;
1795 lit_h
= alpha_elf_sym_hashes (info
->abfd
)[indx
];
1797 while (lit_h
->root
.root
.type
== bfd_link_hash_indirect
1798 || lit_h
->root
.root
.type
== bfd_link_hash_warning
)
1799 lit_h
= (struct alpha_elf_link_hash_entry
*) lit_h
->root
.root
.u
.i
.link
;
1801 for (lit_gotent
= lit_h
->got_entries
; lit_gotent
;
1802 lit_gotent
= lit_gotent
->next
)
1803 if (lit_gotent
->gotobj
== info
->gotobj
1804 && lit_gotent
->reloc_type
== R_ALPHA_LITERAL
1805 && lit_gotent
->addend
== irel
[1].r_addend
)
1807 BFD_ASSERT (lit_gotent
);
1809 if (--lit_gotent
->use_count
== 0)
1811 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
1812 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1818 lda $16,x($gp) !tlsgd!1
1819 ldq $27,__tls_get_addr($gp) !literal!1
1820 jsr $26,($27)__tls_get_addr !lituse_tlsgd!1
1821 ldah $29,0($26) !gpdisp!2
1822 lda $29,0($29) !gpdisp!2
1824 ldq $16,x($gp) !gottprel
1829 or the first pair to
1830 lda $16,x($gp) !tprel
1833 ldah $16,x($gp) !tprelhi
1834 lda $16,x($16) !tprello
1838 use_gottprel
= FALSE
;
1839 new_symndx
= is_gd
? ELF64_R_SYM (irel
->r_info
) : 0;
1840 switch (!dynamic
&& !info
->link_info
->shared
)
1845 bfd_signed_vma disp
;
1847 BFD_ASSERT (elf_hash_table (info
->link_info
)->tls_sec
!= NULL
);
1848 tp_base
= alpha_get_tprel_base (info
->link_info
);
1849 disp
= symval
- tp_base
;
1851 if (disp
>= -0x8000 && disp
< 0x8000)
1853 insn
= (OP_LDA
<< 26) | (16 << 21) | (31 << 16);
1854 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
1855 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
1857 irel
[0].r_offset
= pos
[0] - info
->contents
;
1858 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPREL16
);
1859 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1862 else if (disp
>= -(bfd_signed_vma
) 0x80000000
1863 && disp
< (bfd_signed_vma
) 0x7fff8000
1866 insn
= (OP_LDAH
<< 26) | (16 << 21) | (31 << 16);
1867 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
1868 insn
= (OP_LDA
<< 26) | (16 << 21) | (16 << 16);
1869 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[1]);
1871 irel
[0].r_offset
= pos
[0] - info
->contents
;
1872 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPRELHI
);
1873 irel
[1].r_offset
= pos
[1] - info
->contents
;
1874 irel
[1].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPRELLO
);
1881 use_gottprel
= TRUE
;
1883 insn
= (OP_LDQ
<< 26) | (16 << 21) | (29 << 16);
1884 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
1885 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
1887 irel
[0].r_offset
= pos
[0] - info
->contents
;
1888 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_GOTTPREL
);
1889 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1893 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_RDUNIQ
, pos
[2]);
1895 insn
= INSN_ADDQ
| (16 << 21) | (0 << 16) | (0 << 0);
1896 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[3]);
1898 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[4]);
1900 irel
[2].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1901 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1903 hint
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
1904 irel
[2].r_offset
, R_ALPHA_HINT
);
1906 hint
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1908 info
->changed_contents
= TRUE
;
1909 info
->changed_relocs
= TRUE
;
1911 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
1912 if (--info
->gotent
->use_count
== 0)
1914 int sz
= alpha_got_entry_size (info
->gotent
->reloc_type
);
1915 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1917 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
1920 /* If we've switched to a GOTTPREL relocation, increment the reference
1921 count on that got entry. */
1924 struct alpha_elf_got_entry
*tprel_gotent
;
1926 for (tprel_gotent
= *info
->first_gotent
; tprel_gotent
;
1927 tprel_gotent
= tprel_gotent
->next
)
1928 if (tprel_gotent
->gotobj
== info
->gotobj
1929 && tprel_gotent
->reloc_type
== R_ALPHA_GOTTPREL
1930 && tprel_gotent
->addend
== irel
->r_addend
)
1933 tprel_gotent
->use_count
++;
1936 if (info
->gotent
->use_count
== 0)
1937 tprel_gotent
= info
->gotent
;
1940 tprel_gotent
= (struct alpha_elf_got_entry
*)
1941 bfd_alloc (info
->abfd
, sizeof (struct alpha_elf_got_entry
));
1945 tprel_gotent
->next
= *info
->first_gotent
;
1946 *info
->first_gotent
= tprel_gotent
;
1948 tprel_gotent
->gotobj
= info
->gotobj
;
1949 tprel_gotent
->addend
= irel
->r_addend
;
1950 tprel_gotent
->got_offset
= -1;
1951 tprel_gotent
->reloc_done
= 0;
1952 tprel_gotent
->reloc_xlated
= 0;
1955 tprel_gotent
->use_count
= 1;
1956 tprel_gotent
->reloc_type
= R_ALPHA_GOTTPREL
;
1964 elf64_alpha_relax_section (abfd
, sec
, link_info
, again
)
1967 struct bfd_link_info
*link_info
;
1970 Elf_Internal_Shdr
*symtab_hdr
;
1971 Elf_Internal_Rela
*internal_relocs
;
1972 Elf_Internal_Rela
*irel
, *irelend
;
1973 Elf_Internal_Sym
*isymbuf
= NULL
;
1974 struct alpha_elf_got_entry
**local_got_entries
;
1975 struct alpha_relax_info info
;
1977 /* We are not currently changing any sizes, so only one pass. */
1980 if (link_info
->relocatable
1981 || (sec
->flags
& SEC_RELOC
) == 0
1982 || sec
->reloc_count
== 0)
1985 /* If this is the first time we have been called for this section,
1986 initialize the cooked size. */
1987 if (sec
->_cooked_size
== 0)
1988 sec
->_cooked_size
= sec
->_raw_size
;
1990 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1991 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
1993 /* Load the relocations for this section. */
1994 internal_relocs
= (_bfd_elf_link_read_relocs
1995 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
1996 link_info
->keep_memory
));
1997 if (internal_relocs
== NULL
)
2000 memset(&info
, 0, sizeof (info
));
2003 info
.link_info
= link_info
;
2004 info
.symtab_hdr
= symtab_hdr
;
2005 info
.relocs
= internal_relocs
;
2006 info
.relend
= irelend
= internal_relocs
+ sec
->reloc_count
;
2008 /* Find the GP for this object. Do not store the result back via
2009 _bfd_set_gp_value, since this could change again before final. */
2010 info
.gotobj
= alpha_elf_tdata (abfd
)->gotobj
;
2013 asection
*sgot
= alpha_elf_tdata (info
.gotobj
)->got
;
2014 info
.gp
= (sgot
->output_section
->vma
2015 + sgot
->output_offset
2019 /* Get the section contents. */
2020 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2021 info
.contents
= elf_section_data (sec
)->this_hdr
.contents
;
2024 info
.contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
2025 if (info
.contents
== NULL
)
2028 if (! bfd_get_section_contents (abfd
, sec
, info
.contents
,
2029 (file_ptr
) 0, sec
->_raw_size
))
2033 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2036 struct alpha_elf_got_entry
*gotent
;
2037 unsigned long r_type
= ELF64_R_TYPE (irel
->r_info
);
2038 unsigned long r_symndx
= ELF64_R_SYM (irel
->r_info
);
2040 /* Early exit for unhandled or unrelaxable relocations. */
2043 case R_ALPHA_LITERAL
:
2044 case R_ALPHA_GPRELHIGH
:
2045 case R_ALPHA_GPRELLOW
:
2046 case R_ALPHA_GOTDTPREL
:
2047 case R_ALPHA_GOTTPREL
:
2051 case R_ALPHA_TLSLDM
:
2052 /* The symbol for a TLSLDM reloc is ignored. Collapse the
2053 reloc to the 0 symbol so that they all match. */
2061 /* Get the value of the symbol referred to by the reloc. */
2062 if (r_symndx
< symtab_hdr
->sh_info
)
2064 /* A local symbol. */
2065 Elf_Internal_Sym
*isym
;
2067 /* Read this BFD's local symbols. */
2068 if (isymbuf
== NULL
)
2070 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2071 if (isymbuf
== NULL
)
2072 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2073 symtab_hdr
->sh_info
, 0,
2075 if (isymbuf
== NULL
)
2079 isym
= isymbuf
+ r_symndx
;
2081 /* Given the symbol for a TLSLDM reloc is ignored, this also
2082 means forcing the symbol value to the tp base. */
2083 if (r_type
== R_ALPHA_TLSLDM
)
2085 info
.tsec
= bfd_abs_section_ptr
;
2086 symval
= alpha_get_tprel_base (info
.link_info
);
2090 symval
= isym
->st_value
;
2091 if (isym
->st_shndx
== SHN_UNDEF
)
2093 else if (isym
->st_shndx
== SHN_ABS
)
2094 info
.tsec
= bfd_abs_section_ptr
;
2095 else if (isym
->st_shndx
== SHN_COMMON
)
2096 info
.tsec
= bfd_com_section_ptr
;
2098 info
.tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2102 info
.other
= isym
->st_other
;
2103 if (local_got_entries
)
2104 info
.first_gotent
= &local_got_entries
[r_symndx
];
2107 info
.first_gotent
= &info
.gotent
;
2114 struct alpha_elf_link_hash_entry
*h
;
2116 indx
= r_symndx
- symtab_hdr
->sh_info
;
2117 h
= alpha_elf_sym_hashes (abfd
)[indx
];
2118 BFD_ASSERT (h
!= NULL
);
2120 while (h
->root
.root
.type
== bfd_link_hash_indirect
2121 || h
->root
.root
.type
== bfd_link_hash_warning
)
2122 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2124 /* If the symbol is undefined, we can't do anything with it. */
2125 if (h
->root
.root
.type
== bfd_link_hash_undefweak
2126 || h
->root
.root
.type
== bfd_link_hash_undefined
)
2129 /* If the symbol isn't defined in the current module, again
2130 we can't do anything. */
2131 if (!(h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2133 /* Except for TLSGD relocs, which can sometimes be
2134 relaxed to GOTTPREL relocs. */
2135 if (r_type
!= R_ALPHA_TLSGD
)
2137 info
.tsec
= bfd_abs_section_ptr
;
2142 info
.tsec
= h
->root
.root
.u
.def
.section
;
2143 symval
= h
->root
.root
.u
.def
.value
;
2147 info
.other
= h
->root
.other
;
2148 info
.first_gotent
= &h
->got_entries
;
2151 /* Search for the got entry to be used by this relocation. */
2152 for (gotent
= *info
.first_gotent
; gotent
; gotent
= gotent
->next
)
2153 if (gotent
->gotobj
== info
.gotobj
2154 && gotent
->reloc_type
== r_type
2155 && gotent
->addend
== irel
->r_addend
)
2157 info
.gotent
= gotent
;
2159 symval
+= info
.tsec
->output_section
->vma
+ info
.tsec
->output_offset
;
2160 symval
+= irel
->r_addend
;
2164 case R_ALPHA_LITERAL
:
2165 BFD_ASSERT(info
.gotent
!= NULL
);
2167 /* If there exist LITUSE relocations immediately following, this
2168 opens up all sorts of interesting optimizations, because we
2169 now know every location that this address load is used. */
2170 if (irel
+1 < irelend
2171 && ELF64_R_TYPE (irel
[1].r_info
) == R_ALPHA_LITUSE
)
2173 if (!elf64_alpha_relax_with_lituse (&info
, symval
, irel
))
2178 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
2183 case R_ALPHA_GPRELHIGH
:
2184 case R_ALPHA_GPRELLOW
:
2185 if (!elf64_alpha_relax_gprelhilo (&info
, symval
, irel
,
2186 r_type
== R_ALPHA_GPRELHIGH
))
2190 case R_ALPHA_GOTDTPREL
:
2191 case R_ALPHA_GOTTPREL
:
2192 BFD_ASSERT(info
.gotent
!= NULL
);
2193 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
2198 case R_ALPHA_TLSLDM
:
2199 BFD_ASSERT(info
.gotent
!= NULL
);
2200 if (!elf64_alpha_relax_tls_get_addr (&info
, symval
, irel
,
2201 r_type
== R_ALPHA_TLSGD
))
2207 if (!elf64_alpha_size_plt_section (link_info
))
2209 if (!elf64_alpha_size_got_sections (link_info
))
2211 if (!elf64_alpha_size_rela_got_section (link_info
))
2215 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2217 if (!link_info
->keep_memory
)
2221 /* Cache the symbols for elf_link_input_bfd. */
2222 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2226 if (info
.contents
!= NULL
2227 && elf_section_data (sec
)->this_hdr
.contents
!= info
.contents
)
2229 if (!info
.changed_contents
&& !link_info
->keep_memory
)
2230 free (info
.contents
);
2233 /* Cache the section contents for elf_link_input_bfd. */
2234 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
2238 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2240 if (!info
.changed_relocs
)
2241 free (internal_relocs
);
2243 elf_section_data (sec
)->relocs
= internal_relocs
;
2246 *again
= info
.changed_contents
|| info
.changed_relocs
;
2252 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2254 if (info
.contents
!= NULL
2255 && elf_section_data (sec
)->this_hdr
.contents
!= info
.contents
)
2256 free (info
.contents
);
2257 if (internal_relocs
!= NULL
2258 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2259 free (internal_relocs
);
2264 #define PLT_HEADER_SIZE 32
2265 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
2266 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
2267 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
2268 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
2270 #define PLT_ENTRY_SIZE 12
2271 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
2272 #define PLT_ENTRY_WORD2 0
2273 #define PLT_ENTRY_WORD3 0
2275 #define MAX_GOT_SIZE (64*1024)
2277 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
2279 /* Handle an Alpha specific section when reading an object file. This
2280 is called when elfcode.h finds a section with an unknown type.
2281 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
2285 elf64_alpha_section_from_shdr (abfd
, hdr
, name
)
2287 Elf_Internal_Shdr
*hdr
;
2292 /* There ought to be a place to keep ELF backend specific flags, but
2293 at the moment there isn't one. We just keep track of the
2294 sections by their name, instead. Fortunately, the ABI gives
2295 suggested names for all the MIPS specific sections, so we will
2296 probably get away with this. */
2297 switch (hdr
->sh_type
)
2299 case SHT_ALPHA_DEBUG
:
2300 if (strcmp (name
, ".mdebug") != 0)
2307 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
2309 newsect
= hdr
->bfd_section
;
2311 if (hdr
->sh_type
== SHT_ALPHA_DEBUG
)
2313 if (! bfd_set_section_flags (abfd
, newsect
,
2314 (bfd_get_section_flags (abfd
, newsect
)
2322 /* Convert Alpha specific section flags to bfd internal section flags. */
2325 elf64_alpha_section_flags (flags
, hdr
)
2327 Elf_Internal_Shdr
*hdr
;
2329 if (hdr
->sh_flags
& SHF_ALPHA_GPREL
)
2330 *flags
|= SEC_SMALL_DATA
;
2335 /* Set the correct type for an Alpha ELF section. We do this by the
2336 section name, which is a hack, but ought to work. */
2339 elf64_alpha_fake_sections (abfd
, hdr
, sec
)
2341 Elf_Internal_Shdr
*hdr
;
2344 register const char *name
;
2346 name
= bfd_get_section_name (abfd
, sec
);
2348 if (strcmp (name
, ".mdebug") == 0)
2350 hdr
->sh_type
= SHT_ALPHA_DEBUG
;
2351 /* In a shared object on Irix 5.3, the .mdebug section has an
2352 entsize of 0. FIXME: Does this matter? */
2353 if ((abfd
->flags
& DYNAMIC
) != 0 )
2354 hdr
->sh_entsize
= 0;
2356 hdr
->sh_entsize
= 1;
2358 else if ((sec
->flags
& SEC_SMALL_DATA
)
2359 || strcmp (name
, ".sdata") == 0
2360 || strcmp (name
, ".sbss") == 0
2361 || strcmp (name
, ".lit4") == 0
2362 || strcmp (name
, ".lit8") == 0)
2363 hdr
->sh_flags
|= SHF_ALPHA_GPREL
;
2368 /* Hook called by the linker routine which adds symbols from an object
2369 file. We use it to put .comm items in .sbss, and not .bss. */
2372 elf64_alpha_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
2374 struct bfd_link_info
*info
;
2375 const Elf_Internal_Sym
*sym
;
2376 const char **namep ATTRIBUTE_UNUSED
;
2377 flagword
*flagsp ATTRIBUTE_UNUSED
;
2381 if (sym
->st_shndx
== SHN_COMMON
2382 && !info
->relocatable
2383 && sym
->st_size
<= elf_gp_size (abfd
))
2385 /* Common symbols less than or equal to -G nn bytes are
2386 automatically put into .sbss. */
2388 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
2392 scomm
= bfd_make_section (abfd
, ".scommon");
2394 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
2396 | SEC_LINKER_CREATED
)))
2401 *valp
= sym
->st_size
;
2407 /* Create the .got section. */
2410 elf64_alpha_create_got_section(abfd
, info
)
2412 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2416 if ((s
= bfd_get_section_by_name (abfd
, ".got")))
2418 /* Check for a non-linker created .got? */
2419 if (alpha_elf_tdata (abfd
)->got
== NULL
)
2420 alpha_elf_tdata (abfd
)->got
= s
;
2424 s
= bfd_make_section (abfd
, ".got");
2426 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2429 | SEC_LINKER_CREATED
))
2430 || !bfd_set_section_alignment (abfd
, s
, 3))
2433 alpha_elf_tdata (abfd
)->got
= s
;
2438 /* Create all the dynamic sections. */
2441 elf64_alpha_create_dynamic_sections (abfd
, info
)
2443 struct bfd_link_info
*info
;
2446 struct elf_link_hash_entry
*h
;
2447 struct bfd_link_hash_entry
*bh
;
2449 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
2451 s
= bfd_make_section (abfd
, ".plt");
2453 || ! bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2456 | SEC_LINKER_CREATED
2458 || ! bfd_set_section_alignment (abfd
, s
, 3))
2461 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2464 if (! (_bfd_generic_link_add_one_symbol
2465 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2466 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2467 get_elf_backend_data (abfd
)->collect
, &bh
)))
2469 h
= (struct elf_link_hash_entry
*) bh
;
2470 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2471 h
->type
= STT_OBJECT
;
2474 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2477 s
= bfd_make_section (abfd
, ".rela.plt");
2479 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2482 | SEC_LINKER_CREATED
2484 || ! bfd_set_section_alignment (abfd
, s
, 3))
2487 /* We may or may not have created a .got section for this object, but
2488 we definitely havn't done the rest of the work. */
2490 if (!elf64_alpha_create_got_section (abfd
, info
))
2493 s
= bfd_make_section(abfd
, ".rela.got");
2495 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2498 | SEC_LINKER_CREATED
2500 || !bfd_set_section_alignment (abfd
, s
, 3))
2503 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
2504 dynobj's .got section. We don't do this in the linker script
2505 because we don't want to define the symbol if we are not creating
2506 a global offset table. */
2508 if (!(_bfd_generic_link_add_one_symbol
2509 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
,
2510 alpha_elf_tdata(abfd
)->got
, (bfd_vma
) 0, (const char *) NULL
,
2511 FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
2513 h
= (struct elf_link_hash_entry
*) bh
;
2514 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2515 h
->type
= STT_OBJECT
;
2518 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2521 elf_hash_table (info
)->hgot
= h
;
2526 /* Read ECOFF debugging information from a .mdebug section into a
2527 ecoff_debug_info structure. */
2530 elf64_alpha_read_ecoff_info (abfd
, section
, debug
)
2533 struct ecoff_debug_info
*debug
;
2536 const struct ecoff_debug_swap
*swap
;
2537 char *ext_hdr
= NULL
;
2539 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2540 memset (debug
, 0, sizeof (*debug
));
2542 ext_hdr
= (char *) bfd_malloc (swap
->external_hdr_size
);
2543 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
2546 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
2547 swap
->external_hdr_size
))
2550 symhdr
= &debug
->symbolic_header
;
2551 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
2553 /* The symbolic header contains absolute file offsets and sizes to
2555 #define READ(ptr, offset, count, size, type) \
2556 if (symhdr->count == 0) \
2557 debug->ptr = NULL; \
2560 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
2561 debug->ptr = (type) bfd_malloc (amt); \
2562 if (debug->ptr == NULL) \
2563 goto error_return; \
2564 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2565 || bfd_bread (debug->ptr, amt, abfd) != amt) \
2566 goto error_return; \
2569 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
2570 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
2571 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
2572 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
2573 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
2574 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
2576 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
2577 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
2578 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
2579 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
2580 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
2584 debug
->adjust
= NULL
;
2589 if (ext_hdr
!= NULL
)
2591 if (debug
->line
!= NULL
)
2593 if (debug
->external_dnr
!= NULL
)
2594 free (debug
->external_dnr
);
2595 if (debug
->external_pdr
!= NULL
)
2596 free (debug
->external_pdr
);
2597 if (debug
->external_sym
!= NULL
)
2598 free (debug
->external_sym
);
2599 if (debug
->external_opt
!= NULL
)
2600 free (debug
->external_opt
);
2601 if (debug
->external_aux
!= NULL
)
2602 free (debug
->external_aux
);
2603 if (debug
->ss
!= NULL
)
2605 if (debug
->ssext
!= NULL
)
2606 free (debug
->ssext
);
2607 if (debug
->external_fdr
!= NULL
)
2608 free (debug
->external_fdr
);
2609 if (debug
->external_rfd
!= NULL
)
2610 free (debug
->external_rfd
);
2611 if (debug
->external_ext
!= NULL
)
2612 free (debug
->external_ext
);
2616 /* Alpha ELF local labels start with '$'. */
2619 elf64_alpha_is_local_label_name (abfd
, name
)
2620 bfd
*abfd ATTRIBUTE_UNUSED
;
2623 return name
[0] == '$';
2626 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2627 routine in order to handle the ECOFF debugging information. We
2628 still call this mips_elf_find_line because of the slot
2629 find_line_info in elf_obj_tdata is declared that way. */
2631 struct mips_elf_find_line
2633 struct ecoff_debug_info d
;
2634 struct ecoff_find_line i
;
2638 elf64_alpha_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2639 functionname_ptr
, line_ptr
)
2644 const char **filename_ptr
;
2645 const char **functionname_ptr
;
2646 unsigned int *line_ptr
;
2650 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2651 filename_ptr
, functionname_ptr
,
2653 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2656 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
2660 struct mips_elf_find_line
*fi
;
2661 const struct ecoff_debug_swap
* const swap
=
2662 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2664 /* If we are called during a link, alpha_elf_final_link may have
2665 cleared the SEC_HAS_CONTENTS field. We force it back on here
2666 if appropriate (which it normally will be). */
2667 origflags
= msec
->flags
;
2668 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
2669 msec
->flags
|= SEC_HAS_CONTENTS
;
2671 fi
= elf_tdata (abfd
)->find_line_info
;
2674 bfd_size_type external_fdr_size
;
2677 struct fdr
*fdr_ptr
;
2678 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
2680 fi
= (struct mips_elf_find_line
*) bfd_zalloc (abfd
, amt
);
2683 msec
->flags
= origflags
;
2687 if (!elf64_alpha_read_ecoff_info (abfd
, msec
, &fi
->d
))
2689 msec
->flags
= origflags
;
2693 /* Swap in the FDR information. */
2694 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
2695 fi
->d
.fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
2696 if (fi
->d
.fdr
== NULL
)
2698 msec
->flags
= origflags
;
2701 external_fdr_size
= swap
->external_fdr_size
;
2702 fdr_ptr
= fi
->d
.fdr
;
2703 fraw_src
= (char *) fi
->d
.external_fdr
;
2704 fraw_end
= (fraw_src
2705 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
2706 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
2707 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
2709 elf_tdata (abfd
)->find_line_info
= fi
;
2711 /* Note that we don't bother to ever free this information.
2712 find_nearest_line is either called all the time, as in
2713 objdump -l, so the information should be saved, or it is
2714 rarely called, as in ld error messages, so the memory
2715 wasted is unimportant. Still, it would probably be a
2716 good idea for free_cached_info to throw it away. */
2719 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
2720 &fi
->i
, filename_ptr
, functionname_ptr
,
2723 msec
->flags
= origflags
;
2727 msec
->flags
= origflags
;
2730 /* Fall back on the generic ELF find_nearest_line routine. */
2732 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
2733 filename_ptr
, functionname_ptr
,
2737 /* Structure used to pass information to alpha_elf_output_extsym. */
2742 struct bfd_link_info
*info
;
2743 struct ecoff_debug_info
*debug
;
2744 const struct ecoff_debug_swap
*swap
;
2749 elf64_alpha_output_extsym (h
, data
)
2750 struct alpha_elf_link_hash_entry
*h
;
2753 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
2755 asection
*sec
, *output_section
;
2757 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2758 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2760 if (h
->root
.indx
== -2)
2762 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2763 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2764 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2765 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2767 else if (einfo
->info
->strip
== strip_all
2768 || (einfo
->info
->strip
== strip_some
2769 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2770 h
->root
.root
.root
.string
,
2771 FALSE
, FALSE
) == NULL
))
2779 if (h
->esym
.ifd
== -2)
2782 h
->esym
.cobol_main
= 0;
2783 h
->esym
.weakext
= 0;
2784 h
->esym
.reserved
= 0;
2785 h
->esym
.ifd
= ifdNil
;
2786 h
->esym
.asym
.value
= 0;
2787 h
->esym
.asym
.st
= stGlobal
;
2789 if (h
->root
.root
.type
!= bfd_link_hash_defined
2790 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2791 h
->esym
.asym
.sc
= scAbs
;
2796 sec
= h
->root
.root
.u
.def
.section
;
2797 output_section
= sec
->output_section
;
2799 /* When making a shared library and symbol h is the one from
2800 the another shared library, OUTPUT_SECTION may be null. */
2801 if (output_section
== NULL
)
2802 h
->esym
.asym
.sc
= scUndefined
;
2805 name
= bfd_section_name (output_section
->owner
, output_section
);
2807 if (strcmp (name
, ".text") == 0)
2808 h
->esym
.asym
.sc
= scText
;
2809 else if (strcmp (name
, ".data") == 0)
2810 h
->esym
.asym
.sc
= scData
;
2811 else if (strcmp (name
, ".sdata") == 0)
2812 h
->esym
.asym
.sc
= scSData
;
2813 else if (strcmp (name
, ".rodata") == 0
2814 || strcmp (name
, ".rdata") == 0)
2815 h
->esym
.asym
.sc
= scRData
;
2816 else if (strcmp (name
, ".bss") == 0)
2817 h
->esym
.asym
.sc
= scBss
;
2818 else if (strcmp (name
, ".sbss") == 0)
2819 h
->esym
.asym
.sc
= scSBss
;
2820 else if (strcmp (name
, ".init") == 0)
2821 h
->esym
.asym
.sc
= scInit
;
2822 else if (strcmp (name
, ".fini") == 0)
2823 h
->esym
.asym
.sc
= scFini
;
2825 h
->esym
.asym
.sc
= scAbs
;
2829 h
->esym
.asym
.reserved
= 0;
2830 h
->esym
.asym
.index
= indexNil
;
2833 if (h
->root
.root
.type
== bfd_link_hash_common
)
2834 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2835 else if (h
->root
.root
.type
== bfd_link_hash_defined
2836 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2838 if (h
->esym
.asym
.sc
== scCommon
)
2839 h
->esym
.asym
.sc
= scBss
;
2840 else if (h
->esym
.asym
.sc
== scSCommon
)
2841 h
->esym
.asym
.sc
= scSBss
;
2843 sec
= h
->root
.root
.u
.def
.section
;
2844 output_section
= sec
->output_section
;
2845 if (output_section
!= NULL
)
2846 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2847 + sec
->output_offset
2848 + output_section
->vma
);
2850 h
->esym
.asym
.value
= 0;
2852 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2854 /* Set type and value for a symbol with a function stub. */
2855 h
->esym
.asym
.st
= stProc
;
2856 sec
= bfd_get_section_by_name (einfo
->abfd
, ".plt");
2858 h
->esym
.asym
.value
= 0;
2861 output_section
= sec
->output_section
;
2862 if (output_section
!= NULL
)
2863 h
->esym
.asym
.value
= (h
->root
.plt
.offset
2864 + sec
->output_offset
2865 + output_section
->vma
);
2867 h
->esym
.asym
.value
= 0;
2871 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2872 h
->root
.root
.root
.string
,
2875 einfo
->failed
= TRUE
;
2882 /* Search for and possibly create a got entry. */
2884 static struct alpha_elf_got_entry
*
2885 get_got_entry (abfd
, h
, r_type
, r_symndx
, r_addend
)
2887 struct alpha_elf_link_hash_entry
*h
;
2888 unsigned long r_type
, r_symndx
;
2891 struct alpha_elf_got_entry
*gotent
;
2892 struct alpha_elf_got_entry
**slot
;
2895 slot
= &h
->got_entries
;
2898 /* This is a local .got entry -- record for merge. */
2900 struct alpha_elf_got_entry
**local_got_entries
;
2902 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
2903 if (!local_got_entries
)
2906 Elf_Internal_Shdr
*symtab_hdr
;
2908 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2909 size
= symtab_hdr
->sh_info
;
2910 size
*= sizeof (struct alpha_elf_got_entry
*);
2913 = (struct alpha_elf_got_entry
**) bfd_zalloc (abfd
, size
);
2914 if (!local_got_entries
)
2917 alpha_elf_tdata (abfd
)->local_got_entries
= local_got_entries
;
2920 slot
= &local_got_entries
[r_symndx
];
2923 for (gotent
= *slot
; gotent
; gotent
= gotent
->next
)
2924 if (gotent
->gotobj
== abfd
2925 && gotent
->reloc_type
== r_type
2926 && gotent
->addend
== r_addend
)
2934 amt
= sizeof (struct alpha_elf_got_entry
);
2935 gotent
= (struct alpha_elf_got_entry
*) bfd_alloc (abfd
, amt
);
2939 gotent
->gotobj
= abfd
;
2940 gotent
->addend
= r_addend
;
2941 gotent
->got_offset
= -1;
2942 gotent
->use_count
= 1;
2943 gotent
->reloc_type
= r_type
;
2944 gotent
->reloc_done
= 0;
2945 gotent
->reloc_xlated
= 0;
2947 gotent
->next
= *slot
;
2950 entry_size
= alpha_got_entry_size (r_type
);
2951 alpha_elf_tdata (abfd
)->total_got_size
+= entry_size
;
2953 alpha_elf_tdata(abfd
)->local_got_size
+= entry_size
;
2956 gotent
->use_count
+= 1;
2961 /* Handle dynamic relocations when doing an Alpha ELF link. */
2964 elf64_alpha_check_relocs (abfd
, info
, sec
, relocs
)
2966 struct bfd_link_info
*info
;
2968 const Elf_Internal_Rela
*relocs
;
2972 const char *rel_sec_name
;
2973 Elf_Internal_Shdr
*symtab_hdr
;
2974 struct alpha_elf_link_hash_entry
**sym_hashes
;
2975 const Elf_Internal_Rela
*rel
, *relend
;
2976 bfd_boolean got_created
;
2979 if (info
->relocatable
)
2982 dynobj
= elf_hash_table(info
)->dynobj
;
2984 elf_hash_table(info
)->dynobj
= dynobj
= abfd
;
2987 rel_sec_name
= NULL
;
2988 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2989 sym_hashes
= alpha_elf_sym_hashes(abfd
);
2990 got_created
= FALSE
;
2992 relend
= relocs
+ sec
->reloc_count
;
2993 for (rel
= relocs
; rel
< relend
; ++rel
)
3001 unsigned long r_symndx
, r_type
;
3002 struct alpha_elf_link_hash_entry
*h
;
3003 unsigned int gotent_flags
;
3004 bfd_boolean maybe_dynamic
;
3008 r_symndx
= ELF64_R_SYM (rel
->r_info
);
3009 if (r_symndx
< symtab_hdr
->sh_info
)
3013 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3015 while (h
->root
.root
.type
== bfd_link_hash_indirect
3016 || h
->root
.root
.type
== bfd_link_hash_warning
)
3017 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3019 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
3022 /* We can only get preliminary data on whether a symbol is
3023 locally or externally defined, as not all of the input files
3024 have yet been processed. Do something with what we know, as
3025 this may help reduce memory usage and processing time later. */
3026 maybe_dynamic
= FALSE
;
3027 if (h
&& ((info
->shared
3028 && (!info
->symbolic
|| info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
3029 || ! (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
3030 || h
->root
.root
.type
== bfd_link_hash_defweak
))
3031 maybe_dynamic
= TRUE
;
3035 r_type
= ELF64_R_TYPE (rel
->r_info
);
3036 addend
= rel
->r_addend
;
3040 case R_ALPHA_LITERAL
:
3041 need
= NEED_GOT
| NEED_GOT_ENTRY
;
3043 /* Remember how this literal is used from its LITUSEs.
3044 This will be important when it comes to decide if we can
3045 create a .plt entry for a function symbol. */
3046 while (++rel
< relend
&& ELF64_R_TYPE (rel
->r_info
) == R_ALPHA_LITUSE
)
3047 if (rel
->r_addend
>= 1 && rel
->r_addend
<= 5)
3048 gotent_flags
|= 1 << rel
->r_addend
;
3051 /* No LITUSEs -- presumably the address is used somehow. */
3052 if (gotent_flags
== 0)
3053 gotent_flags
= ALPHA_ELF_LINK_HASH_LU_ADDR
;
3056 case R_ALPHA_GPDISP
:
3057 case R_ALPHA_GPREL16
:
3058 case R_ALPHA_GPREL32
:
3059 case R_ALPHA_GPRELHIGH
:
3060 case R_ALPHA_GPRELLOW
:
3065 case R_ALPHA_REFLONG
:
3066 case R_ALPHA_REFQUAD
:
3067 if ((info
->shared
&& (sec
->flags
& SEC_ALLOC
)) || maybe_dynamic
)
3071 case R_ALPHA_TLSLDM
:
3072 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3073 reloc to the 0 symbol so that they all match. */
3076 maybe_dynamic
= FALSE
;
3080 case R_ALPHA_GOTDTPREL
:
3081 need
= NEED_GOT
| NEED_GOT_ENTRY
;
3084 case R_ALPHA_GOTTPREL
:
3085 need
= NEED_GOT
| NEED_GOT_ENTRY
;
3086 gotent_flags
= ALPHA_ELF_LINK_HASH_TLS_IE
;
3088 info
->flags
|= DF_STATIC_TLS
;
3091 case R_ALPHA_TPREL64
:
3092 if (info
->shared
|| maybe_dynamic
)
3095 info
->flags
|= DF_STATIC_TLS
;
3099 if (need
& NEED_GOT
)
3103 if (!elf64_alpha_create_got_section (abfd
, info
))
3106 /* Make sure the object's gotobj is set to itself so
3107 that we default to every object with its own .got.
3108 We'll merge .gots later once we've collected each
3110 alpha_elf_tdata(abfd
)->gotobj
= abfd
;
3116 if (need
& NEED_GOT_ENTRY
)
3118 struct alpha_elf_got_entry
*gotent
;
3120 gotent
= get_got_entry (abfd
, h
, r_type
, r_symndx
, addend
);
3126 gotent
->flags
|= gotent_flags
;
3129 gotent_flags
|= h
->flags
;
3130 h
->flags
= gotent_flags
;
3132 /* Make a guess as to whether a .plt entry is needed. */
3133 if ((gotent_flags
& ALPHA_ELF_LINK_HASH_LU_FUNC
)
3134 && !(gotent_flags
& ~ALPHA_ELF_LINK_HASH_LU_FUNC
))
3135 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
3137 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3142 if (need
& NEED_DYNREL
)
3144 if (rel_sec_name
== NULL
)
3146 rel_sec_name
= (bfd_elf_string_from_elf_section
3147 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
3148 elf_section_data(sec
)->rel_hdr
.sh_name
));
3149 if (rel_sec_name
== NULL
)
3152 BFD_ASSERT (strncmp (rel_sec_name
, ".rela", 5) == 0
3153 && strcmp (bfd_get_section_name (abfd
, sec
),
3154 rel_sec_name
+5) == 0);
3157 /* We need to create the section here now whether we eventually
3158 use it or not so that it gets mapped to an output section by
3159 the linker. If not used, we'll kill it in
3160 size_dynamic_sections. */
3163 sreloc
= bfd_get_section_by_name (dynobj
, rel_sec_name
);
3168 sreloc
= bfd_make_section (dynobj
, rel_sec_name
);
3169 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3170 | SEC_LINKER_CREATED
| SEC_READONLY
);
3171 if (sec
->flags
& SEC_ALLOC
)
3172 flags
|= SEC_ALLOC
| SEC_LOAD
;
3174 || !bfd_set_section_flags (dynobj
, sreloc
, flags
)
3175 || !bfd_set_section_alignment (dynobj
, sreloc
, 3))
3182 /* Since we havn't seen all of the input symbols yet, we
3183 don't know whether we'll actually need a dynamic relocation
3184 entry for this reloc. So make a record of it. Once we
3185 find out if this thing needs dynamic relocation we'll
3186 expand the relocation sections by the appropriate amount. */
3188 struct alpha_elf_reloc_entry
*rent
;
3190 for (rent
= h
->reloc_entries
; rent
; rent
= rent
->next
)
3191 if (rent
->rtype
== r_type
&& rent
->srel
== sreloc
)
3196 amt
= sizeof (struct alpha_elf_reloc_entry
);
3197 rent
= (struct alpha_elf_reloc_entry
*) bfd_alloc (abfd
, amt
);
3201 rent
->srel
= sreloc
;
3202 rent
->rtype
= r_type
;
3204 rent
->reltext
= ((sec
->flags
& (SEC_READONLY
| SEC_ALLOC
))
3205 == (SEC_READONLY
| SEC_ALLOC
));
3207 rent
->next
= h
->reloc_entries
;
3208 h
->reloc_entries
= rent
;
3213 else if (info
->shared
)
3215 /* If this is a shared library, and the section is to be
3216 loaded into memory, we need a RELATIVE reloc. */
3217 sreloc
->_raw_size
+= sizeof (Elf64_External_Rela
);
3218 if ((sec
->flags
& (SEC_READONLY
| SEC_ALLOC
))
3219 == (SEC_READONLY
| SEC_ALLOC
))
3220 info
->flags
|= DF_TEXTREL
;
3228 /* Adjust a symbol defined by a dynamic object and referenced by a
3229 regular object. The current definition is in some section of the
3230 dynamic object, but we're not including those sections. We have to
3231 change the definition to something the rest of the link can
3235 elf64_alpha_adjust_dynamic_symbol (info
, h
)
3236 struct bfd_link_info
*info
;
3237 struct elf_link_hash_entry
*h
;
3241 struct alpha_elf_link_hash_entry
*ah
;
3243 dynobj
= elf_hash_table(info
)->dynobj
;
3244 ah
= (struct alpha_elf_link_hash_entry
*)h
;
3246 /* Now that we've seen all of the input symbols, finalize our decision
3247 about whether this symbol should get a .plt entry. */
3249 if (alpha_elf_dynamic_symbol_p (h
, info
)
3250 && ((h
->type
== STT_FUNC
3251 && !(ah
->flags
& ALPHA_ELF_LINK_HASH_LU_ADDR
))
3252 || (h
->type
== STT_NOTYPE
3253 && (ah
->flags
& ALPHA_ELF_LINK_HASH_LU_FUNC
)
3254 && !(ah
->flags
& ~ALPHA_ELF_LINK_HASH_LU_FUNC
)))
3255 /* Don't prevent otherwise valid programs from linking by attempting
3256 to create a new .got entry somewhere. A Correct Solution would be
3257 to add a new .got section to a new object file and let it be merged
3258 somewhere later. But for now don't bother. */
3261 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
3263 s
= bfd_get_section_by_name(dynobj
, ".plt");
3264 if (!s
&& !elf64_alpha_create_dynamic_sections (dynobj
, info
))
3267 /* The first bit of the .plt is reserved. */
3268 if (s
->_raw_size
== 0)
3269 s
->_raw_size
= PLT_HEADER_SIZE
;
3271 h
->plt
.offset
= s
->_raw_size
;
3272 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3274 /* If this symbol is not defined in a regular file, and we are not
3275 generating a shared library, then set the symbol to the location
3276 in the .plt. This is required to make function pointers compare
3277 equal between the normal executable and the shared library. */
3279 && h
->root
.type
!= bfd_link_hash_defweak
)
3281 ah
->plt_old_section
= h
->root
.u
.def
.section
;
3282 ah
->plt_old_value
= h
->root
.u
.def
.value
;
3283 ah
->flags
|= ALPHA_ELF_LINK_HASH_PLT_LOC
;
3284 h
->root
.u
.def
.section
= s
;
3285 h
->root
.u
.def
.value
= h
->plt
.offset
;
3288 /* We also need a JMP_SLOT entry in the .rela.plt section. */
3289 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
3290 BFD_ASSERT (s
!= NULL
);
3291 s
->_raw_size
+= sizeof (Elf64_External_Rela
);
3296 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3298 /* If this is a weak symbol, and there is a real definition, the
3299 processor independent code will have arranged for us to see the
3300 real definition first, and we can just use the same value. */
3301 if (h
->weakdef
!= NULL
)
3303 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3304 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3305 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3306 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3310 /* This is a reference to a symbol defined by a dynamic object which
3311 is not a function. The Alpha, since it uses .got entries for all
3312 symbols even in regular objects, does not need the hackery of a
3313 .dynbss section and COPY dynamic relocations. */
3318 /* Symbol versioning can create new symbols, and make our old symbols
3319 indirect to the new ones. Consolidate the got and reloc information
3320 in these situations. */
3323 elf64_alpha_merge_ind_symbols (hi
, dummy
)
3324 struct alpha_elf_link_hash_entry
*hi
;
3325 PTR dummy ATTRIBUTE_UNUSED
;
3327 struct alpha_elf_link_hash_entry
*hs
;
3329 if (hi
->root
.root
.type
!= bfd_link_hash_indirect
)
3333 hs
= (struct alpha_elf_link_hash_entry
*)hs
->root
.root
.u
.i
.link
;
3334 } while (hs
->root
.root
.type
== bfd_link_hash_indirect
);
3336 /* Merge the flags. Whee. */
3338 hs
->flags
|= hi
->flags
;
3340 /* Merge the .got entries. Cannibalize the old symbol's list in
3341 doing so, since we don't need it anymore. */
3343 if (hs
->got_entries
== NULL
)
3344 hs
->got_entries
= hi
->got_entries
;
3347 struct alpha_elf_got_entry
*gi
, *gs
, *gin
, *gsh
;
3349 gsh
= hs
->got_entries
;
3350 for (gi
= hi
->got_entries
; gi
; gi
= gin
)
3353 for (gs
= gsh
; gs
; gs
= gs
->next
)
3354 if (gi
->gotobj
== gs
->gotobj
3355 && gi
->reloc_type
== gs
->reloc_type
3356 && gi
->addend
== gs
->addend
)
3358 gi
->use_count
+= gs
->use_count
;
3361 gi
->next
= hs
->got_entries
;
3362 hs
->got_entries
= gi
;
3366 hi
->got_entries
= NULL
;
3368 /* And similar for the reloc entries. */
3370 if (hs
->reloc_entries
== NULL
)
3371 hs
->reloc_entries
= hi
->reloc_entries
;
3374 struct alpha_elf_reloc_entry
*ri
, *rs
, *rin
, *rsh
;
3376 rsh
= hs
->reloc_entries
;
3377 for (ri
= hi
->reloc_entries
; ri
; ri
= rin
)
3380 for (rs
= rsh
; rs
; rs
= rs
->next
)
3381 if (ri
->rtype
== rs
->rtype
&& ri
->srel
== rs
->srel
)
3383 rs
->count
+= ri
->count
;
3386 ri
->next
= hs
->reloc_entries
;
3387 hs
->reloc_entries
= ri
;
3391 hi
->reloc_entries
= NULL
;
3396 /* Is it possible to merge two object file's .got tables? */
3399 elf64_alpha_can_merge_gots (a
, b
)
3402 int total
= alpha_elf_tdata (a
)->total_got_size
;
3405 /* Trivial quick fallout test. */
3406 if (total
+ alpha_elf_tdata (b
)->total_got_size
<= MAX_GOT_SIZE
)
3409 /* By their nature, local .got entries cannot be merged. */
3410 if ((total
+= alpha_elf_tdata (b
)->local_got_size
) > MAX_GOT_SIZE
)
3413 /* Failing the common trivial comparison, we must effectively
3414 perform the merge. Not actually performing the merge means that
3415 we don't have to store undo information in case we fail. */
3416 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
3418 struct alpha_elf_link_hash_entry
**hashes
= alpha_elf_sym_hashes (bsub
);
3419 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
3422 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
3423 for (i
= 0; i
< n
; ++i
)
3425 struct alpha_elf_got_entry
*ae
, *be
;
3426 struct alpha_elf_link_hash_entry
*h
;
3429 while (h
->root
.root
.type
== bfd_link_hash_indirect
3430 || h
->root
.root
.type
== bfd_link_hash_warning
)
3431 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3433 for (be
= h
->got_entries
; be
; be
= be
->next
)
3435 if (be
->use_count
== 0)
3437 if (be
->gotobj
!= b
)
3440 for (ae
= h
->got_entries
; ae
; ae
= ae
->next
)
3442 && ae
->reloc_type
== be
->reloc_type
3443 && ae
->addend
== be
->addend
)
3446 total
+= alpha_got_entry_size (be
->reloc_type
);
3447 if (total
> MAX_GOT_SIZE
)
3457 /* Actually merge two .got tables. */
3460 elf64_alpha_merge_gots (a
, b
)
3463 int total
= alpha_elf_tdata (a
)->total_got_size
;
3466 /* Remember local expansion. */
3468 int e
= alpha_elf_tdata (b
)->local_got_size
;
3470 alpha_elf_tdata (a
)->local_got_size
+= e
;
3473 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
3475 struct alpha_elf_got_entry
**local_got_entries
;
3476 struct alpha_elf_link_hash_entry
**hashes
;
3477 Elf_Internal_Shdr
*symtab_hdr
;
3480 /* Let the local .got entries know they are part of a new subsegment. */
3481 local_got_entries
= alpha_elf_tdata (bsub
)->local_got_entries
;
3482 if (local_got_entries
)
3484 n
= elf_tdata (bsub
)->symtab_hdr
.sh_info
;
3485 for (i
= 0; i
< n
; ++i
)
3487 struct alpha_elf_got_entry
*ent
;
3488 for (ent
= local_got_entries
[i
]; ent
; ent
= ent
->next
)
3493 /* Merge the global .got entries. */
3494 hashes
= alpha_elf_sym_hashes (bsub
);
3495 symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
3497 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
3498 for (i
= 0; i
< n
; ++i
)
3500 struct alpha_elf_got_entry
*ae
, *be
, **pbe
, **start
;
3501 struct alpha_elf_link_hash_entry
*h
;
3504 while (h
->root
.root
.type
== bfd_link_hash_indirect
3505 || h
->root
.root
.type
== bfd_link_hash_warning
)
3506 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3508 start
= &h
->got_entries
;
3509 for (pbe
= start
, be
= *start
; be
; pbe
= &be
->next
, be
= be
->next
)
3511 if (be
->use_count
== 0)
3516 if (be
->gotobj
!= b
)
3519 for (ae
= *start
; ae
; ae
= ae
->next
)
3521 && ae
->reloc_type
== be
->reloc_type
3522 && ae
->addend
== be
->addend
)
3524 ae
->flags
|= be
->flags
;
3525 ae
->use_count
+= be
->use_count
;
3530 total
+= alpha_got_entry_size (be
->reloc_type
);
3536 alpha_elf_tdata (bsub
)->gotobj
= a
;
3538 alpha_elf_tdata (a
)->total_got_size
= total
;
3540 /* Merge the two in_got chains. */
3545 while ((next
= alpha_elf_tdata (bsub
)->in_got_link_next
) != NULL
)
3548 alpha_elf_tdata (bsub
)->in_got_link_next
= b
;
3552 /* Calculate the offsets for the got entries. */
3555 elf64_alpha_calc_got_offsets_for_symbol (h
, arg
)
3556 struct alpha_elf_link_hash_entry
*h
;
3557 PTR arg ATTRIBUTE_UNUSED
;
3559 struct alpha_elf_got_entry
*gotent
;
3561 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3562 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3564 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3565 if (gotent
->use_count
> 0)
3568 = &alpha_elf_tdata (gotent
->gotobj
)->got
->_raw_size
;
3570 gotent
->got_offset
= *plge
;
3571 *plge
+= alpha_got_entry_size (gotent
->reloc_type
);
3578 elf64_alpha_calc_got_offsets (info
)
3579 struct bfd_link_info
*info
;
3581 bfd
*i
, *got_list
= alpha_elf_hash_table(info
)->got_list
;
3583 /* First, zero out the .got sizes, as we may be recalculating the
3584 .got after optimizing it. */
3585 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3586 alpha_elf_tdata(i
)->got
->_raw_size
= 0;
3588 /* Next, fill in the offsets for all the global entries. */
3589 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3590 elf64_alpha_calc_got_offsets_for_symbol
,
3593 /* Finally, fill in the offsets for the local entries. */
3594 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3596 bfd_size_type got_offset
= alpha_elf_tdata(i
)->got
->_raw_size
;
3599 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
3601 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
3604 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
3605 if (!local_got_entries
)
3608 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
3609 for (gotent
= local_got_entries
[k
]; gotent
; gotent
= gotent
->next
)
3610 if (gotent
->use_count
> 0)
3612 gotent
->got_offset
= got_offset
;
3613 got_offset
+= alpha_got_entry_size (gotent
->reloc_type
);
3617 alpha_elf_tdata(i
)->got
->_raw_size
= got_offset
;
3618 alpha_elf_tdata(i
)->got
->_cooked_size
= got_offset
;
3622 /* Constructs the gots. */
3625 elf64_alpha_size_got_sections (info
)
3626 struct bfd_link_info
*info
;
3628 bfd
*i
, *got_list
, *cur_got_obj
= NULL
;
3629 int something_changed
= 0;
3631 got_list
= alpha_elf_hash_table (info
)->got_list
;
3633 /* On the first time through, pretend we have an existing got list
3634 consisting of all of the input files. */
3635 if (got_list
== NULL
)
3637 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
3639 bfd
*this_got
= alpha_elf_tdata (i
)->gotobj
;
3640 if (this_got
== NULL
)
3643 /* We are assuming no merging has yet occurred. */
3644 BFD_ASSERT (this_got
== i
);
3646 if (alpha_elf_tdata (this_got
)->total_got_size
> MAX_GOT_SIZE
)
3648 /* Yikes! A single object file has too many entries. */
3649 (*_bfd_error_handler
)
3650 (_("%s: .got subsegment exceeds 64K (size %d)"),
3651 bfd_archive_filename (i
),
3652 alpha_elf_tdata (this_got
)->total_got_size
);
3656 if (got_list
== NULL
)
3657 got_list
= this_got
;
3659 alpha_elf_tdata(cur_got_obj
)->got_link_next
= this_got
;
3660 cur_got_obj
= this_got
;
3663 /* Strange degenerate case of no got references. */
3664 if (got_list
== NULL
)
3667 alpha_elf_hash_table (info
)->got_list
= got_list
;
3669 /* Force got offsets to be recalculated. */
3670 something_changed
= 1;
3673 cur_got_obj
= got_list
;
3674 i
= alpha_elf_tdata(cur_got_obj
)->got_link_next
;
3677 if (elf64_alpha_can_merge_gots (cur_got_obj
, i
))
3679 elf64_alpha_merge_gots (cur_got_obj
, i
);
3680 i
= alpha_elf_tdata(i
)->got_link_next
;
3681 alpha_elf_tdata(cur_got_obj
)->got_link_next
= i
;
3682 something_changed
= 1;
3687 i
= alpha_elf_tdata(i
)->got_link_next
;
3691 /* Once the gots have been merged, fill in the got offsets for
3692 everything therein. */
3693 if (1 || something_changed
)
3694 elf64_alpha_calc_got_offsets (info
);
3699 /* Called from relax_section to rebuild the PLT in light of
3700 potential changes in the function's status. */
3703 elf64_alpha_size_plt_section (info
)
3704 struct bfd_link_info
*info
;
3706 asection
*splt
, *spltrel
;
3707 unsigned long entries
;
3710 dynobj
= elf_hash_table(info
)->dynobj
;
3711 splt
= bfd_get_section_by_name(dynobj
, ".plt");
3715 splt
->_raw_size
= 0;
3717 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3718 elf64_alpha_size_plt_section_1
, splt
);
3720 splt
->_cooked_size
= splt
->_raw_size
;
3722 /* Every plt entry requires a JMP_SLOT relocation. */
3723 spltrel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
3724 if (splt
->_raw_size
)
3725 entries
= (splt
->_raw_size
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3728 spltrel
->_raw_size
= entries
* sizeof (Elf64_External_Rela
);
3729 spltrel
->_cooked_size
= spltrel
->_raw_size
;
3735 elf64_alpha_size_plt_section_1 (h
, data
)
3736 struct alpha_elf_link_hash_entry
*h
;
3739 asection
*splt
= (asection
*) data
;
3740 struct alpha_elf_got_entry
*gotent
;
3742 /* If we didn't need an entry before, we still don't. */
3743 if (!(h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
))
3746 /* There must still be a LITERAL got entry for the function. */
3747 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3748 if (gotent
->reloc_type
== R_ALPHA_LITERAL
3749 && gotent
->use_count
> 0)
3752 /* If there is, reset the PLT offset. If not, there's no longer
3753 a need for the PLT entry. */
3756 if (splt
->_raw_size
== 0)
3757 splt
->_raw_size
= PLT_HEADER_SIZE
;
3758 h
->root
.plt
.offset
= splt
->_raw_size
;
3759 splt
->_raw_size
+= PLT_ENTRY_SIZE
;
3763 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3764 h
->root
.plt
.offset
= -1;
3766 /* Undo the definition frobbing begun in adjust_dynamic_symbol. */
3767 if (h
->flags
& ALPHA_ELF_LINK_HASH_PLT_LOC
)
3769 h
->root
.root
.u
.def
.section
= h
->plt_old_section
;
3770 h
->root
.root
.u
.def
.value
= h
->plt_old_value
;
3771 h
->flags
&= ~ALPHA_ELF_LINK_HASH_PLT_LOC
;
3779 elf64_alpha_always_size_sections (output_bfd
, info
)
3780 bfd
*output_bfd ATTRIBUTE_UNUSED
;
3781 struct bfd_link_info
*info
;
3785 if (info
->relocatable
)
3788 /* First, take care of the indirect symbols created by versioning. */
3789 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3790 elf64_alpha_merge_ind_symbols
,
3793 if (!elf64_alpha_size_got_sections (info
))
3796 /* Allocate space for all of the .got subsections. */
3797 i
= alpha_elf_hash_table (info
)->got_list
;
3798 for ( ; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3800 asection
*s
= alpha_elf_tdata(i
)->got
;
3801 if (s
->_raw_size
> 0)
3803 s
->contents
= (bfd_byte
*) bfd_zalloc (i
, s
->_raw_size
);
3804 if (s
->contents
== NULL
)
3812 /* The number of dynamic relocations required by a static relocation. */
3815 alpha_dynamic_entries_for_reloc (r_type
, dynamic
, shared
)
3816 int r_type
, dynamic
, shared
;
3820 /* May appear in GOT entries. */
3822 return (dynamic
? 2 : shared
? 1 : 0);
3823 case R_ALPHA_TLSLDM
:
3825 case R_ALPHA_LITERAL
:
3826 case R_ALPHA_GOTTPREL
:
3827 return dynamic
|| shared
;
3828 case R_ALPHA_GOTDTPREL
:
3831 /* May appear in data sections. */
3832 case R_ALPHA_REFLONG
:
3833 case R_ALPHA_REFQUAD
:
3834 case R_ALPHA_TPREL64
:
3835 return dynamic
|| shared
;
3837 /* Everything else is illegal. We'll issue an error during
3838 relocate_section. */
3844 /* Work out the sizes of the dynamic relocation entries. */
3847 elf64_alpha_calc_dynrel_sizes (h
, info
)
3848 struct alpha_elf_link_hash_entry
*h
;
3849 struct bfd_link_info
*info
;
3851 bfd_boolean dynamic
;
3852 struct alpha_elf_reloc_entry
*relent
;
3853 unsigned long entries
;
3855 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3856 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3858 /* If the symbol was defined as a common symbol in a regular object
3859 file, and there was no definition in any dynamic object, then the
3860 linker will have allocated space for the symbol in a common
3861 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3862 set. This is done for dynamic symbols in
3863 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3864 symbols, somehow. */
3865 if (((h
->root
.elf_link_hash_flags
3866 & (ELF_LINK_HASH_DEF_REGULAR
3867 | ELF_LINK_HASH_REF_REGULAR
3868 | ELF_LINK_HASH_DEF_DYNAMIC
))
3869 == ELF_LINK_HASH_REF_REGULAR
)
3870 && (h
->root
.root
.type
== bfd_link_hash_defined
3871 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3872 && !(h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3873 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3875 /* If the symbol is dynamic, we'll need all the relocations in their
3876 natural form. If this is a shared object, and it has been forced
3877 local, we'll need the same number of RELATIVE relocations. */
3879 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
3881 for (relent
= h
->reloc_entries
; relent
; relent
= relent
->next
)
3883 entries
= alpha_dynamic_entries_for_reloc (relent
->rtype
, dynamic
,
3887 relent
->srel
->_raw_size
+=
3888 entries
* sizeof (Elf64_External_Rela
) * relent
->count
;
3889 if (relent
->reltext
)
3890 info
->flags
|= DT_TEXTREL
;
3897 /* Set the sizes of the dynamic relocation sections. */
3900 elf64_alpha_size_rela_got_section (info
)
3901 struct bfd_link_info
*info
;
3903 unsigned long entries
;
3907 /* Shared libraries often require RELATIVE relocs, and some relocs
3908 require attention for the main application as well. */
3911 for (i
= alpha_elf_hash_table(info
)->got_list
;
3912 i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3916 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
3918 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
3921 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
3922 if (!local_got_entries
)
3925 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
3926 for (gotent
= local_got_entries
[k
];
3927 gotent
; gotent
= gotent
->next
)
3928 if (gotent
->use_count
> 0)
3929 entries
+= (alpha_dynamic_entries_for_reloc
3930 (gotent
->reloc_type
, 0, info
->shared
));
3934 dynobj
= elf_hash_table(info
)->dynobj
;
3935 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3938 BFD_ASSERT (entries
== 0);
3941 srel
->_raw_size
= sizeof (Elf64_External_Rela
) * entries
;
3943 /* Now do the non-local symbols. */
3944 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3945 elf64_alpha_size_rela_got_1
, info
);
3947 srel
->_cooked_size
= srel
->_raw_size
;
3952 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
3956 elf64_alpha_size_rela_got_1 (h
, info
)
3957 struct alpha_elf_link_hash_entry
*h
;
3958 struct bfd_link_info
*info
;
3960 bfd_boolean dynamic
;
3961 struct alpha_elf_got_entry
*gotent
;
3962 unsigned long entries
;
3964 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3965 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3967 /* If the symbol is dynamic, we'll need all the relocations in their
3968 natural form. If this is a shared object, and it has been forced
3969 local, we'll need the same number of RELATIVE relocations. */
3971 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
3974 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3975 if (gotent
->use_count
> 0)
3976 entries
+= alpha_dynamic_entries_for_reloc (gotent
->reloc_type
,
3977 dynamic
, info
->shared
);
3979 /* If we are using a .plt entry, subtract one, as the first
3980 reference uses a .rela.plt entry instead. */
3981 if (h
->root
.plt
.offset
!= MINUS_ONE
)
3986 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
3987 asection
*srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3988 BFD_ASSERT (srel
!= NULL
);
3989 srel
->_raw_size
+= sizeof (Elf64_External_Rela
) * entries
;
3995 /* Set the sizes of the dynamic sections. */
3998 elf64_alpha_size_dynamic_sections (output_bfd
, info
)
3999 bfd
*output_bfd ATTRIBUTE_UNUSED
;
4000 struct bfd_link_info
*info
;
4006 dynobj
= elf_hash_table(info
)->dynobj
;
4007 BFD_ASSERT(dynobj
!= NULL
);
4009 if (elf_hash_table (info
)->dynamic_sections_created
)
4011 /* Set the contents of the .interp section to the interpreter. */
4012 if (info
->executable
)
4014 s
= bfd_get_section_by_name (dynobj
, ".interp");
4015 BFD_ASSERT (s
!= NULL
);
4016 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
4017 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
4020 /* Now that we've seen all of the input files, we can decide which
4021 symbols need dynamic relocation entries and which don't. We've
4022 collected information in check_relocs that we can now apply to
4023 size the dynamic relocation sections. */
4024 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
4025 elf64_alpha_calc_dynrel_sizes
, info
);
4027 elf64_alpha_size_rela_got_section (info
);
4029 /* else we're not dynamic and by definition we don't need such things. */
4031 /* The check_relocs and adjust_dynamic_symbol entry points have
4032 determined the sizes of the various dynamic sections. Allocate
4035 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
4040 if (!(s
->flags
& SEC_LINKER_CREATED
))
4043 /* It's OK to base decisions on the section name, because none
4044 of the dynobj section names depend upon the input files. */
4045 name
= bfd_get_section_name (dynobj
, s
);
4047 /* If we don't need this section, strip it from the output file.
4048 This is to handle .rela.bss and .rela.plt. We must create it
4049 in create_dynamic_sections, because it must be created before
4050 the linker maps input sections to output sections. The
4051 linker does that before adjust_dynamic_symbol is called, and
4052 it is that function which decides whether anything needs to
4053 go into these sections. */
4057 if (strncmp (name
, ".rela", 5) == 0)
4059 strip
= (s
->_raw_size
== 0);
4063 if (strcmp(name
, ".rela.plt") == 0)
4066 /* We use the reloc_count field as a counter if we need
4067 to copy relocs into the output file. */
4071 else if (strcmp (name
, ".plt") != 0)
4073 /* It's not one of our dynamic sections, so don't allocate space. */
4078 _bfd_strip_section_from_output (info
, s
);
4081 /* Allocate memory for the section contents. */
4082 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
4083 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4088 if (elf_hash_table (info
)->dynamic_sections_created
)
4090 /* Add some entries to the .dynamic section. We fill in the
4091 values later, in elf64_alpha_finish_dynamic_sections, but we
4092 must add the entries now so that we get the correct size for
4093 the .dynamic section. The DT_DEBUG entry is filled in by the
4094 dynamic linker and used by the debugger. */
4095 #define add_dynamic_entry(TAG, VAL) \
4096 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
4098 if (info
->executable
)
4100 if (!add_dynamic_entry (DT_DEBUG
, 0))
4106 if (!add_dynamic_entry (DT_PLTGOT
, 0)
4107 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
4108 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
4109 || !add_dynamic_entry (DT_JMPREL
, 0))
4113 if (!add_dynamic_entry (DT_RELA
, 0)
4114 || !add_dynamic_entry (DT_RELASZ
, 0)
4115 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
4118 if (info
->flags
& DF_TEXTREL
)
4120 if (!add_dynamic_entry (DT_TEXTREL
, 0))
4124 #undef add_dynamic_entry
4129 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4130 into the next available slot in SREL. */
4133 elf64_alpha_emit_dynrel (abfd
, info
, sec
, srel
, offset
, dynindx
, rtype
, addend
)
4135 struct bfd_link_info
*info
;
4136 asection
*sec
, *srel
;
4137 bfd_vma offset
, addend
;
4138 long dynindx
, rtype
;
4140 Elf_Internal_Rela outrel
;
4143 BFD_ASSERT (srel
!= NULL
);
4145 outrel
.r_info
= ELF64_R_INFO (dynindx
, rtype
);
4146 outrel
.r_addend
= addend
;
4148 offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
4149 if ((offset
| 1) != (bfd_vma
) -1)
4150 outrel
.r_offset
= sec
->output_section
->vma
+ sec
->output_offset
+ offset
;
4152 memset (&outrel
, 0, sizeof (outrel
));
4154 loc
= srel
->contents
;
4155 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
4156 bfd_elf64_swap_reloca_out (abfd
, &outrel
, loc
);
4157 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
4158 <= srel
->_cooked_size
);
4161 /* Relocate an Alpha ELF section for a relocatable link.
4163 We don't have to change anything unless the reloc is against a section
4164 symbol, in which case we have to adjust according to where the section
4165 symbol winds up in the output section. */
4168 elf64_alpha_relocate_section_r (output_bfd
, info
, input_bfd
, input_section
,
4169 contents
, relocs
, local_syms
, local_sections
)
4170 bfd
*output_bfd ATTRIBUTE_UNUSED
;
4171 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4173 asection
*input_section
;
4174 bfd_byte
*contents ATTRIBUTE_UNUSED
;
4175 Elf_Internal_Rela
*relocs
;
4176 Elf_Internal_Sym
*local_syms
;
4177 asection
**local_sections
;
4179 unsigned long symtab_hdr_sh_info
;
4180 Elf_Internal_Rela
*rel
;
4181 Elf_Internal_Rela
*relend
;
4182 bfd_boolean ret_val
= TRUE
;
4184 symtab_hdr_sh_info
= elf_tdata (input_bfd
)->symtab_hdr
.sh_info
;
4186 relend
= relocs
+ input_section
->reloc_count
;
4187 for (rel
= relocs
; rel
< relend
; rel
++)
4189 unsigned long r_symndx
;
4190 Elf_Internal_Sym
*sym
;
4192 unsigned long r_type
;
4194 r_type
= ELF64_R_TYPE(rel
->r_info
);
4195 if (r_type
>= R_ALPHA_max
)
4197 (*_bfd_error_handler
)
4198 (_("%s: unknown relocation type %d"),
4199 bfd_archive_filename (input_bfd
), (int)r_type
);
4200 bfd_set_error (bfd_error_bad_value
);
4205 r_symndx
= ELF64_R_SYM(rel
->r_info
);
4207 /* The symbol associated with GPDISP and LITUSE is
4208 immaterial. Only the addend is significant. */
4209 if (r_type
== R_ALPHA_GPDISP
|| r_type
== R_ALPHA_LITUSE
)
4212 if (r_symndx
< symtab_hdr_sh_info
)
4214 sym
= local_syms
+ r_symndx
;
4215 if (ELF_ST_TYPE(sym
->st_info
) == STT_SECTION
)
4217 sec
= local_sections
[r_symndx
];
4218 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
4226 /* Relocate an Alpha ELF section. */
4229 elf64_alpha_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
4230 contents
, relocs
, local_syms
, local_sections
)
4232 struct bfd_link_info
*info
;
4234 asection
*input_section
;
4236 Elf_Internal_Rela
*relocs
;
4237 Elf_Internal_Sym
*local_syms
;
4238 asection
**local_sections
;
4240 Elf_Internal_Shdr
*symtab_hdr
;
4241 Elf_Internal_Rela
*rel
;
4242 Elf_Internal_Rela
*relend
;
4243 asection
*sgot
, *srel
, *srelgot
;
4244 bfd
*dynobj
, *gotobj
;
4245 bfd_vma gp
, tp_base
, dtp_base
;
4246 struct alpha_elf_got_entry
**local_got_entries
;
4247 bfd_boolean ret_val
;
4248 const char *section_name
;
4250 /* Handle relocatable links with a smaller loop. */
4251 if (info
->relocatable
)
4252 return elf64_alpha_relocate_section_r (output_bfd
, info
, input_bfd
,
4253 input_section
, contents
, relocs
,
4254 local_syms
, local_sections
);
4256 /* This is a final link. */
4260 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4262 dynobj
= elf_hash_table (info
)->dynobj
;
4264 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
4268 section_name
= (bfd_elf_string_from_elf_section
4269 (input_bfd
, elf_elfheader(input_bfd
)->e_shstrndx
,
4270 elf_section_data(input_section
)->rel_hdr
.sh_name
));
4271 BFD_ASSERT(section_name
!= NULL
);
4272 srel
= bfd_get_section_by_name (dynobj
, section_name
);
4274 /* Find the gp value for this input bfd. */
4275 gotobj
= alpha_elf_tdata (input_bfd
)->gotobj
;
4278 sgot
= alpha_elf_tdata (gotobj
)->got
;
4279 gp
= _bfd_get_gp_value (gotobj
);
4282 gp
= (sgot
->output_section
->vma
4283 + sgot
->output_offset
4285 _bfd_set_gp_value (gotobj
, gp
);
4294 local_got_entries
= alpha_elf_tdata(input_bfd
)->local_got_entries
;
4296 if (elf_hash_table (info
)->tls_sec
!= NULL
)
4298 dtp_base
= alpha_get_dtprel_base (info
);
4299 tp_base
= alpha_get_tprel_base (info
);
4302 dtp_base
= tp_base
= 0;
4304 relend
= relocs
+ input_section
->reloc_count
;
4305 for (rel
= relocs
; rel
< relend
; rel
++)
4307 struct alpha_elf_link_hash_entry
*h
= NULL
;
4308 struct alpha_elf_got_entry
*gotent
;
4309 bfd_reloc_status_type r
;
4310 reloc_howto_type
*howto
;
4311 unsigned long r_symndx
;
4312 Elf_Internal_Sym
*sym
= NULL
;
4313 asection
*sec
= NULL
;
4316 bfd_boolean dynamic_symbol_p
;
4317 bfd_boolean undef_weak_ref
= FALSE
;
4318 unsigned long r_type
;
4320 r_type
= ELF64_R_TYPE(rel
->r_info
);
4321 if (r_type
>= R_ALPHA_max
)
4323 (*_bfd_error_handler
)
4324 (_("%s: unknown relocation type %d"),
4325 bfd_archive_filename (input_bfd
), (int)r_type
);
4326 bfd_set_error (bfd_error_bad_value
);
4331 howto
= elf64_alpha_howto_table
+ r_type
;
4332 r_symndx
= ELF64_R_SYM(rel
->r_info
);
4334 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4335 reloc to the 0 symbol so that they all match. */
4336 if (r_type
== R_ALPHA_TLSLDM
)
4339 if (r_symndx
< symtab_hdr
->sh_info
)
4342 sym
= local_syms
+ r_symndx
;
4343 sec
= local_sections
[r_symndx
];
4345 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
4347 /* If this is a tp-relative relocation against sym 0,
4348 this is hackery from relax_section. Force the value to
4351 && (r_type
== R_ALPHA_TLSLDM
4352 || r_type
== R_ALPHA_GOTTPREL
4353 || r_type
== R_ALPHA_TPREL64
4354 || r_type
== R_ALPHA_TPRELHI
4355 || r_type
== R_ALPHA_TPRELLO
4356 || r_type
== R_ALPHA_TPREL16
))
4359 if (local_got_entries
)
4360 gotent
= local_got_entries
[r_symndx
];
4364 /* Need to adjust local GOT entries' addends for SEC_MERGE
4365 unless it has been done already. */
4366 if ((sec
->flags
& SEC_MERGE
)
4367 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
4368 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
4370 && !gotent
->reloc_xlated
)
4372 struct alpha_elf_got_entry
*ent
;
4374 for (ent
= gotent
; ent
; ent
= ent
->next
)
4376 ent
->reloc_xlated
= 1;
4377 if (ent
->use_count
== 0)
4381 _bfd_merged_section_offset (output_bfd
, &msec
,
4382 elf_section_data (sec
)->
4384 sym
->st_value
+ ent
->addend
,
4386 ent
->addend
-= sym
->st_value
;
4387 ent
->addend
+= msec
->output_section
->vma
4388 + msec
->output_offset
4389 - sec
->output_section
->vma
4390 - sec
->output_offset
;
4394 dynamic_symbol_p
= FALSE
;
4399 bfd_boolean unresolved_reloc
;
4400 struct elf_link_hash_entry
*hh
;
4402 RELOC_FOR_GLOBAL_SYMBOL (hh
,
4403 (struct elf_link_hash_entry
*) alpha_elf_sym_hashes (input_bfd
),
4404 r_symndx
, symtab_hdr
, value
,
4405 sec
, unresolved_reloc
, info
,
4412 && ! unresolved_reloc
4413 && hh
->root
.type
== bfd_link_hash_undefweak
)
4414 undef_weak_ref
= TRUE
;
4416 h
= (struct alpha_elf_link_hash_entry
*) hh
;
4417 dynamic_symbol_p
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
4418 gotent
= h
->got_entries
;
4421 addend
= rel
->r_addend
;
4424 /* Search for the proper got entry. */
4425 for (; gotent
; gotent
= gotent
->next
)
4426 if (gotent
->gotobj
== gotobj
4427 && gotent
->reloc_type
== r_type
4428 && gotent
->addend
== addend
)
4433 case R_ALPHA_GPDISP
:
4435 bfd_byte
*p_ldah
, *p_lda
;
4437 BFD_ASSERT(gp
!= 0);
4439 value
= (input_section
->output_section
->vma
4440 + input_section
->output_offset
4443 p_ldah
= contents
+ rel
->r_offset
;
4444 p_lda
= p_ldah
+ rel
->r_addend
;
4446 r
= elf64_alpha_do_reloc_gpdisp (input_bfd
, gp
- value
,
4451 case R_ALPHA_LITERAL
:
4452 BFD_ASSERT(sgot
!= NULL
);
4453 BFD_ASSERT(gp
!= 0);
4454 BFD_ASSERT(gotent
!= NULL
);
4455 BFD_ASSERT(gotent
->use_count
>= 1);
4457 if (!gotent
->reloc_done
)
4459 gotent
->reloc_done
= 1;
4461 bfd_put_64 (output_bfd
, value
,
4462 sgot
->contents
+ gotent
->got_offset
);
4464 /* If the symbol has been forced local, output a
4465 RELATIVE reloc, otherwise it will be handled in
4466 finish_dynamic_symbol. */
4467 if (info
->shared
&& !dynamic_symbol_p
)
4468 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4469 gotent
->got_offset
, 0,
4470 R_ALPHA_RELATIVE
, value
);
4473 value
= (sgot
->output_section
->vma
4474 + sgot
->output_offset
4475 + gotent
->got_offset
);
4479 case R_ALPHA_GPREL32
:
4480 /* If the target section was a removed linkonce section,
4481 r_symndx will be zero. In this case, assume that the
4482 switch will not be used, so don't fill it in. If we
4483 do nothing here, we'll get relocation truncated messages,
4484 due to the placement of the application above 4GB. */
4492 case R_ALPHA_GPREL16
:
4493 case R_ALPHA_GPRELLOW
:
4494 if (dynamic_symbol_p
)
4496 (*_bfd_error_handler
)
4497 (_("%s: gp-relative relocation against dynamic symbol %s"),
4498 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4501 BFD_ASSERT(gp
!= 0);
4505 case R_ALPHA_GPRELHIGH
:
4506 if (dynamic_symbol_p
)
4508 (*_bfd_error_handler
)
4509 (_("%s: gp-relative relocation against dynamic symbol %s"),
4510 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4513 BFD_ASSERT(gp
!= 0);
4515 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4519 /* A call to a dynamic symbol is definitely out of range of
4520 the 16-bit displacement. Don't bother writing anything. */
4521 if (dynamic_symbol_p
)
4526 /* The regular PC-relative stuff measures from the start of
4527 the instruction rather than the end. */
4531 case R_ALPHA_BRADDR
:
4532 if (dynamic_symbol_p
)
4534 (*_bfd_error_handler
)
4535 (_("%s: pc-relative relocation against dynamic symbol %s"),
4536 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4539 /* The regular PC-relative stuff measures from the start of
4540 the instruction rather than the end. */
4549 /* The regular PC-relative stuff measures from the start of
4550 the instruction rather than the end. */
4553 /* The source and destination gp must be the same. Note that
4554 the source will always have an assigned gp, since we forced
4555 one in check_relocs, but that the destination may not, as
4556 it might not have had any relocations at all. Also take
4557 care not to crash if H is an undefined symbol. */
4558 if (h
!= NULL
&& sec
!= NULL
4559 && alpha_elf_tdata (sec
->owner
)->gotobj
4560 && gotobj
!= alpha_elf_tdata (sec
->owner
)->gotobj
)
4562 (*_bfd_error_handler
)
4563 (_("%s: change in gp: BRSGP %s"),
4564 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4568 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4570 other
= h
->root
.other
;
4572 other
= sym
->st_other
;
4573 switch (other
& STO_ALPHA_STD_GPLOAD
)
4575 case STO_ALPHA_NOPV
:
4577 case STO_ALPHA_STD_GPLOAD
:
4582 name
= h
->root
.root
.root
.string
;
4585 name
= (bfd_elf_string_from_elf_section
4586 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4588 name
= _("<unknown>");
4589 else if (name
[0] == 0)
4590 name
= bfd_section_name (input_bfd
, sec
);
4592 (*_bfd_error_handler
)
4593 (_("%s: !samegp reloc against symbol without .prologue: %s"),
4594 bfd_archive_filename (input_bfd
), name
);
4602 case R_ALPHA_REFLONG
:
4603 case R_ALPHA_REFQUAD
:
4604 case R_ALPHA_DTPREL64
:
4605 case R_ALPHA_TPREL64
:
4607 long dynindx
, dyntype
= r_type
;
4610 /* Careful here to remember RELATIVE relocations for global
4611 variables for symbolic shared objects. */
4613 if (dynamic_symbol_p
)
4615 BFD_ASSERT(h
->root
.dynindx
!= -1);
4616 dynindx
= h
->root
.dynindx
;
4618 addend
= 0, value
= 0;
4620 else if (r_type
== R_ALPHA_DTPREL64
)
4622 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4626 else if (r_type
== R_ALPHA_TPREL64
)
4628 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4635 dynaddend
= value
- dtp_base
;
4637 else if (info
->shared
4639 && (input_section
->flags
& SEC_ALLOC
))
4641 if (r_type
== R_ALPHA_REFLONG
)
4643 (*_bfd_error_handler
)
4644 (_("%s: unhandled dynamic relocation against %s"),
4645 bfd_archive_filename (input_bfd
),
4646 h
->root
.root
.root
.string
);
4650 dyntype
= R_ALPHA_RELATIVE
;
4656 elf64_alpha_emit_dynrel (output_bfd
, info
, input_section
,
4657 srel
, rel
->r_offset
, dynindx
,
4658 dyntype
, dynaddend
);
4662 case R_ALPHA_SREL16
:
4663 case R_ALPHA_SREL32
:
4664 case R_ALPHA_SREL64
:
4665 if (dynamic_symbol_p
)
4667 (*_bfd_error_handler
)
4668 (_("%s: pc-relative relocation against dynamic symbol %s"),
4669 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4673 /* ??? .eh_frame references to discarded sections will be smashed
4674 to relocations against SHN_UNDEF. The .eh_frame format allows
4675 NULL to be encoded as 0 in any format, so this works here. */
4677 howto
= (elf64_alpha_howto_table
4678 + (r_type
- R_ALPHA_SREL32
+ R_ALPHA_REFLONG
));
4681 case R_ALPHA_TLSLDM
:
4682 /* Ignore the symbol for the relocation. The result is always
4683 the current module. */
4684 dynamic_symbol_p
= 0;
4688 if (!gotent
->reloc_done
)
4690 gotent
->reloc_done
= 1;
4692 /* Note that the module index for the main program is 1. */
4693 bfd_put_64 (output_bfd
, !info
->shared
&& !dynamic_symbol_p
,
4694 sgot
->contents
+ gotent
->got_offset
);
4696 /* If the symbol has been forced local, output a
4697 DTPMOD64 reloc, otherwise it will be handled in
4698 finish_dynamic_symbol. */
4699 if (info
->shared
&& !dynamic_symbol_p
)
4700 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4701 gotent
->got_offset
, 0,
4702 R_ALPHA_DTPMOD64
, 0);
4704 if (dynamic_symbol_p
|| r_type
== R_ALPHA_TLSLDM
)
4708 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4711 bfd_put_64 (output_bfd
, value
,
4712 sgot
->contents
+ gotent
->got_offset
+ 8);
4715 value
= (sgot
->output_section
->vma
4716 + sgot
->output_offset
4717 + gotent
->got_offset
);
4721 case R_ALPHA_DTPRELHI
:
4722 case R_ALPHA_DTPRELLO
:
4723 case R_ALPHA_DTPREL16
:
4724 if (dynamic_symbol_p
)
4726 (*_bfd_error_handler
)
4727 (_("%s: dtp-relative relocation against dynamic symbol %s"),
4728 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4731 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4733 if (r_type
== R_ALPHA_DTPRELHI
)
4734 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4737 case R_ALPHA_TPRELHI
:
4738 case R_ALPHA_TPRELLO
:
4739 case R_ALPHA_TPREL16
:
4742 (*_bfd_error_handler
)
4743 (_("%s: TLS local exec code cannot be linked into shared objects"),
4744 bfd_archive_filename (input_bfd
));
4747 else if (dynamic_symbol_p
)
4749 (*_bfd_error_handler
)
4750 (_("%s: tp-relative relocation against dynamic symbol %s"),
4751 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4754 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4756 if (r_type
== R_ALPHA_TPRELHI
)
4757 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4760 case R_ALPHA_GOTDTPREL
:
4761 case R_ALPHA_GOTTPREL
:
4762 BFD_ASSERT(sgot
!= NULL
);
4763 BFD_ASSERT(gp
!= 0);
4764 BFD_ASSERT(gotent
!= NULL
);
4765 BFD_ASSERT(gotent
->use_count
>= 1);
4767 if (!gotent
->reloc_done
)
4769 gotent
->reloc_done
= 1;
4771 if (dynamic_symbol_p
)
4775 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4776 if (r_type
== R_ALPHA_GOTDTPREL
)
4778 else if (!info
->shared
)
4782 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4783 gotent
->got_offset
, 0,
4789 bfd_put_64 (output_bfd
, value
,
4790 sgot
->contents
+ gotent
->got_offset
);
4793 value
= (sgot
->output_section
->vma
4794 + sgot
->output_offset
4795 + gotent
->got_offset
);
4801 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4802 contents
, rel
->r_offset
, value
, 0);
4811 case bfd_reloc_overflow
:
4815 /* Don't warn if the overflow is due to pc relative reloc
4816 against discarded section. Section optimization code should
4819 if (r_symndx
< symtab_hdr
->sh_info
4820 && sec
!= NULL
&& howto
->pc_relative
4821 && elf_discarded_section (sec
))
4825 name
= h
->root
.root
.root
.string
;
4828 name
= (bfd_elf_string_from_elf_section
4829 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4833 name
= bfd_section_name (input_bfd
, sec
);
4835 if (! ((*info
->callbacks
->reloc_overflow
)
4836 (info
, name
, howto
->name
, (bfd_vma
) 0,
4837 input_bfd
, input_section
, rel
->r_offset
)))
4843 case bfd_reloc_outofrange
:
4851 /* Finish up dynamic symbol handling. We set the contents of various
4852 dynamic sections here. */
4855 elf64_alpha_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4857 struct bfd_link_info
*info
;
4858 struct elf_link_hash_entry
*h
;
4859 Elf_Internal_Sym
*sym
;
4861 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
4863 if (h
->plt
.offset
!= MINUS_ONE
)
4865 /* Fill in the .plt entry for this symbol. */
4866 asection
*splt
, *sgot
, *srel
;
4867 Elf_Internal_Rela outrel
;
4869 bfd_vma got_addr
, plt_addr
;
4871 struct alpha_elf_got_entry
*gotent
;
4873 BFD_ASSERT (h
->dynindx
!= -1);
4875 /* The first .got entry will be updated by the .plt with the
4876 address of the target function. */
4877 gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
4878 BFD_ASSERT (gotent
&& gotent
->addend
== 0);
4880 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4881 BFD_ASSERT (splt
!= NULL
);
4882 srel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
4883 BFD_ASSERT (srel
!= NULL
);
4884 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4885 BFD_ASSERT (sgot
!= NULL
);
4887 got_addr
= (sgot
->output_section
->vma
4888 + sgot
->output_offset
4889 + gotent
->got_offset
);
4890 plt_addr
= (splt
->output_section
->vma
4891 + splt
->output_offset
4894 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
4896 /* Fill in the entry in the procedure linkage table. */
4898 bfd_vma insn1
, insn2
, insn3
;
4900 insn1
= PLT_ENTRY_WORD1
| ((-(h
->plt
.offset
+ 4) >> 2) & 0x1fffff);
4901 insn2
= PLT_ENTRY_WORD2
;
4902 insn3
= PLT_ENTRY_WORD3
;
4904 bfd_put_32 (output_bfd
, insn1
, splt
->contents
+ h
->plt
.offset
);
4905 bfd_put_32 (output_bfd
, insn2
, splt
->contents
+ h
->plt
.offset
+ 4);
4906 bfd_put_32 (output_bfd
, insn3
, splt
->contents
+ h
->plt
.offset
+ 8);
4909 /* Fill in the entry in the .rela.plt section. */
4910 outrel
.r_offset
= got_addr
;
4911 outrel
.r_info
= ELF64_R_INFO(h
->dynindx
, R_ALPHA_JMP_SLOT
);
4912 outrel
.r_addend
= 0;
4914 loc
= srel
->contents
+ plt_index
* sizeof (Elf64_External_Rela
);
4915 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
4917 if (!(h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
4919 /* Mark the symbol as undefined, rather than as defined in the
4920 .plt section. Leave the value alone. */
4921 sym
->st_shndx
= SHN_UNDEF
;
4924 /* Fill in the entries in the .got. */
4925 bfd_put_64 (output_bfd
, plt_addr
, sgot
->contents
+ gotent
->got_offset
);
4927 /* Subsequent .got entries will continue to bounce through the .plt. */
4930 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4931 BFD_ASSERT (! info
->shared
|| srel
!= NULL
);
4933 gotent
= gotent
->next
;
4936 sgot
= alpha_elf_tdata(gotent
->gotobj
)->got
;
4937 BFD_ASSERT(sgot
!= NULL
);
4938 BFD_ASSERT(gotent
->addend
== 0);
4940 bfd_put_64 (output_bfd
, plt_addr
,
4941 sgot
->contents
+ gotent
->got_offset
);
4944 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
4945 gotent
->got_offset
, 0,
4946 R_ALPHA_RELATIVE
, plt_addr
);
4948 gotent
= gotent
->next
;
4950 while (gotent
!= NULL
);
4953 else if (alpha_elf_dynamic_symbol_p (h
, info
))
4955 /* Fill in the dynamic relocations for this symbol's .got entries. */
4957 struct alpha_elf_got_entry
*gotent
;
4959 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4960 BFD_ASSERT (srel
!= NULL
);
4962 for (gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
4964 gotent
= gotent
->next
)
4969 if (gotent
->use_count
== 0)
4972 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4974 r_type
= gotent
->reloc_type
;
4977 case R_ALPHA_LITERAL
:
4978 r_type
= R_ALPHA_GLOB_DAT
;
4981 r_type
= R_ALPHA_DTPMOD64
;
4983 case R_ALPHA_GOTDTPREL
:
4984 r_type
= R_ALPHA_DTPREL64
;
4986 case R_ALPHA_GOTTPREL
:
4987 r_type
= R_ALPHA_TPREL64
;
4989 case R_ALPHA_TLSLDM
:
4994 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
4995 gotent
->got_offset
, h
->dynindx
,
4996 r_type
, gotent
->addend
);
4998 if (gotent
->reloc_type
== R_ALPHA_TLSGD
)
4999 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
5000 gotent
->got_offset
+ 8, h
->dynindx
,
5001 R_ALPHA_DTPREL64
, gotent
->addend
);
5005 /* Mark some specially defined symbols as absolute. */
5006 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
5007 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
5008 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
5009 sym
->st_shndx
= SHN_ABS
;
5014 /* Finish up the dynamic sections. */
5017 elf64_alpha_finish_dynamic_sections (output_bfd
, info
)
5019 struct bfd_link_info
*info
;
5024 dynobj
= elf_hash_table (info
)->dynobj
;
5025 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
5027 if (elf_hash_table (info
)->dynamic_sections_created
)
5030 Elf64_External_Dyn
*dyncon
, *dynconend
;
5032 splt
= bfd_get_section_by_name (dynobj
, ".plt");
5033 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
5035 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
5036 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
5037 for (; dyncon
< dynconend
; dyncon
++)
5039 Elf_Internal_Dyn dyn
;
5043 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5058 /* My interpretation of the TIS v1.1 ELF document indicates
5059 that RELASZ should not include JMPREL. This is not what
5060 the rest of the BFD does. It is, however, what the
5061 glibc ld.so wants. Do this fixup here until we found
5062 out who is right. */
5063 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
5067 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
5072 s
= bfd_get_section_by_name (output_bfd
, name
);
5073 dyn
.d_un
.d_ptr
= (s
? s
->vma
: 0);
5077 s
= bfd_get_section_by_name (output_bfd
, name
);
5079 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
5083 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5086 /* Initialize the PLT0 entry. */
5087 if (splt
->_raw_size
> 0)
5089 bfd_put_32 (output_bfd
, PLT_HEADER_WORD1
, splt
->contents
);
5090 bfd_put_32 (output_bfd
, PLT_HEADER_WORD2
, splt
->contents
+ 4);
5091 bfd_put_32 (output_bfd
, PLT_HEADER_WORD3
, splt
->contents
+ 8);
5092 bfd_put_32 (output_bfd
, PLT_HEADER_WORD4
, splt
->contents
+ 12);
5094 /* The next two words will be filled in by ld.so */
5095 bfd_put_64 (output_bfd
, (bfd_vma
) 0, splt
->contents
+ 16);
5096 bfd_put_64 (output_bfd
, (bfd_vma
) 0, splt
->contents
+ 24);
5098 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 0;
5105 /* We need to use a special link routine to handle the .mdebug section.
5106 We need to merge all instances of these sections together, not write
5107 them all out sequentially. */
5110 elf64_alpha_final_link (abfd
, info
)
5112 struct bfd_link_info
*info
;
5115 struct bfd_link_order
*p
;
5116 asection
*mdebug_sec
;
5117 struct ecoff_debug_info debug
;
5118 const struct ecoff_debug_swap
*swap
5119 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
5120 HDRR
*symhdr
= &debug
.symbolic_header
;
5121 PTR mdebug_handle
= NULL
;
5123 /* Go through the sections and collect the mdebug information. */
5125 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5127 if (strcmp (o
->name
, ".mdebug") == 0)
5129 struct extsym_info einfo
;
5131 /* We have found the .mdebug section in the output file.
5132 Look through all the link_orders comprising it and merge
5133 the information together. */
5134 symhdr
->magic
= swap
->sym_magic
;
5135 /* FIXME: What should the version stamp be? */
5137 symhdr
->ilineMax
= 0;
5141 symhdr
->isymMax
= 0;
5142 symhdr
->ioptMax
= 0;
5143 symhdr
->iauxMax
= 0;
5145 symhdr
->issExtMax
= 0;
5148 symhdr
->iextMax
= 0;
5150 /* We accumulate the debugging information itself in the
5151 debug_info structure. */
5153 debug
.external_dnr
= NULL
;
5154 debug
.external_pdr
= NULL
;
5155 debug
.external_sym
= NULL
;
5156 debug
.external_opt
= NULL
;
5157 debug
.external_aux
= NULL
;
5159 debug
.ssext
= debug
.ssext_end
= NULL
;
5160 debug
.external_fdr
= NULL
;
5161 debug
.external_rfd
= NULL
;
5162 debug
.external_ext
= debug
.external_ext_end
= NULL
;
5164 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
5165 if (mdebug_handle
== (PTR
) NULL
)
5174 static const char * const name
[] =
5176 ".text", ".init", ".fini", ".data",
5177 ".rodata", ".sdata", ".sbss", ".bss"
5179 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
5180 scRData
, scSData
, scSBss
, scBss
};
5183 esym
.cobol_main
= 0;
5187 esym
.asym
.iss
= issNil
;
5188 esym
.asym
.st
= stLocal
;
5189 esym
.asym
.reserved
= 0;
5190 esym
.asym
.index
= indexNil
;
5191 for (i
= 0; i
< 8; i
++)
5193 esym
.asym
.sc
= sc
[i
];
5194 s
= bfd_get_section_by_name (abfd
, name
[i
]);
5197 esym
.asym
.value
= s
->vma
;
5198 last
= s
->vma
+ s
->_raw_size
;
5201 esym
.asym
.value
= last
;
5203 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
5209 for (p
= o
->link_order_head
;
5210 p
!= (struct bfd_link_order
*) NULL
;
5213 asection
*input_section
;
5215 const struct ecoff_debug_swap
*input_swap
;
5216 struct ecoff_debug_info input_debug
;
5220 if (p
->type
!= bfd_indirect_link_order
)
5222 if (p
->type
== bfd_data_link_order
)
5227 input_section
= p
->u
.indirect
.section
;
5228 input_bfd
= input_section
->owner
;
5230 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
5231 || (get_elf_backend_data (input_bfd
)
5232 ->elf_backend_ecoff_debug_swap
) == NULL
)
5234 /* I don't know what a non ALPHA ELF bfd would be
5235 doing with a .mdebug section, but I don't really
5236 want to deal with it. */
5240 input_swap
= (get_elf_backend_data (input_bfd
)
5241 ->elf_backend_ecoff_debug_swap
);
5243 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
5245 /* The ECOFF linking code expects that we have already
5246 read in the debugging information and set up an
5247 ecoff_debug_info structure, so we do that now. */
5248 if (!elf64_alpha_read_ecoff_info (input_bfd
, input_section
,
5252 if (! (bfd_ecoff_debug_accumulate
5253 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
5254 &input_debug
, input_swap
, info
)))
5257 /* Loop through the external symbols. For each one with
5258 interesting information, try to find the symbol in
5259 the linker global hash table and save the information
5260 for the output external symbols. */
5261 eraw_src
= input_debug
.external_ext
;
5262 eraw_end
= (eraw_src
5263 + (input_debug
.symbolic_header
.iextMax
5264 * input_swap
->external_ext_size
));
5266 eraw_src
< eraw_end
;
5267 eraw_src
+= input_swap
->external_ext_size
)
5271 struct alpha_elf_link_hash_entry
*h
;
5273 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
5274 if (ext
.asym
.sc
== scNil
5275 || ext
.asym
.sc
== scUndefined
5276 || ext
.asym
.sc
== scSUndefined
)
5279 name
= input_debug
.ssext
+ ext
.asym
.iss
;
5280 h
= alpha_elf_link_hash_lookup (alpha_elf_hash_table (info
),
5281 name
, FALSE
, FALSE
, TRUE
);
5282 if (h
== NULL
|| h
->esym
.ifd
!= -2)
5288 < input_debug
.symbolic_header
.ifdMax
);
5289 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
5295 /* Free up the information we just read. */
5296 free (input_debug
.line
);
5297 free (input_debug
.external_dnr
);
5298 free (input_debug
.external_pdr
);
5299 free (input_debug
.external_sym
);
5300 free (input_debug
.external_opt
);
5301 free (input_debug
.external_aux
);
5302 free (input_debug
.ss
);
5303 free (input_debug
.ssext
);
5304 free (input_debug
.external_fdr
);
5305 free (input_debug
.external_rfd
);
5306 free (input_debug
.external_ext
);
5308 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5309 elf_link_input_bfd ignores this section. */
5310 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
5313 /* Build the external symbol information. */
5316 einfo
.debug
= &debug
;
5318 einfo
.failed
= FALSE
;
5319 elf_link_hash_traverse (elf_hash_table (info
),
5320 elf64_alpha_output_extsym
,
5325 /* Set the size of the .mdebug section. */
5326 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
5328 /* Skip this section later on (I don't think this currently
5329 matters, but someday it might). */
5330 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
5336 /* Invoke the regular ELF backend linker to do all the work. */
5337 if (! bfd_elf64_bfd_final_link (abfd
, info
))
5340 /* Now write out the computed sections. */
5342 /* The .got subsections... */
5344 bfd
*i
, *dynobj
= elf_hash_table(info
)->dynobj
;
5345 for (i
= alpha_elf_hash_table(info
)->got_list
;
5347 i
= alpha_elf_tdata(i
)->got_link_next
)
5351 /* elf_bfd_final_link already did everything in dynobj. */
5355 sgot
= alpha_elf_tdata(i
)->got
;
5356 if (! bfd_set_section_contents (abfd
, sgot
->output_section
,
5358 (file_ptr
) sgot
->output_offset
,
5364 if (mdebug_sec
!= (asection
*) NULL
)
5366 BFD_ASSERT (abfd
->output_has_begun
);
5367 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
5369 mdebug_sec
->filepos
))
5372 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
5378 static enum elf_reloc_type_class
5379 elf64_alpha_reloc_type_class (rela
)
5380 const Elf_Internal_Rela
*rela
;
5382 switch ((int) ELF64_R_TYPE (rela
->r_info
))
5384 case R_ALPHA_RELATIVE
:
5385 return reloc_class_relative
;
5386 case R_ALPHA_JMP_SLOT
:
5387 return reloc_class_plt
;
5389 return reloc_class_copy
;
5391 return reloc_class_normal
;
5395 static struct bfd_elf_special_section
const elf64_alpha_special_sections
[]=
5397 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_ALPHA_GPREL
},
5398 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_ALPHA_GPREL
},
5399 { NULL
, 0, 0, 0, 0 }
5402 /* ECOFF swapping routines. These are used when dealing with the
5403 .mdebug section, which is in the ECOFF debugging format. Copied
5404 from elf32-mips.c. */
5405 static const struct ecoff_debug_swap
5406 elf64_alpha_ecoff_debug_swap
=
5408 /* Symbol table magic number. */
5410 /* Alignment of debugging information. E.g., 4. */
5412 /* Sizes of external symbolic information. */
5413 sizeof (struct hdr_ext
),
5414 sizeof (struct dnr_ext
),
5415 sizeof (struct pdr_ext
),
5416 sizeof (struct sym_ext
),
5417 sizeof (struct opt_ext
),
5418 sizeof (struct fdr_ext
),
5419 sizeof (struct rfd_ext
),
5420 sizeof (struct ext_ext
),
5421 /* Functions to swap in external symbolic data. */
5430 _bfd_ecoff_swap_tir_in
,
5431 _bfd_ecoff_swap_rndx_in
,
5432 /* Functions to swap out external symbolic data. */
5441 _bfd_ecoff_swap_tir_out
,
5442 _bfd_ecoff_swap_rndx_out
,
5443 /* Function to read in symbolic data. */
5444 elf64_alpha_read_ecoff_info
5447 /* Use a non-standard hash bucket size of 8. */
5449 static const struct elf_size_info alpha_elf_size_info
=
5451 sizeof (Elf64_External_Ehdr
),
5452 sizeof (Elf64_External_Phdr
),
5453 sizeof (Elf64_External_Shdr
),
5454 sizeof (Elf64_External_Rel
),
5455 sizeof (Elf64_External_Rela
),
5456 sizeof (Elf64_External_Sym
),
5457 sizeof (Elf64_External_Dyn
),
5458 sizeof (Elf_External_Note
),
5462 ELFCLASS64
, EV_CURRENT
,
5463 bfd_elf64_write_out_phdrs
,
5464 bfd_elf64_write_shdrs_and_ehdr
,
5465 bfd_elf64_write_relocs
,
5466 bfd_elf64_swap_symbol_in
,
5467 bfd_elf64_swap_symbol_out
,
5468 bfd_elf64_slurp_reloc_table
,
5469 bfd_elf64_slurp_symbol_table
,
5470 bfd_elf64_swap_dyn_in
,
5471 bfd_elf64_swap_dyn_out
,
5472 bfd_elf64_swap_reloc_in
,
5473 bfd_elf64_swap_reloc_out
,
5474 bfd_elf64_swap_reloca_in
,
5475 bfd_elf64_swap_reloca_out
5478 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5479 #define TARGET_LITTLE_NAME "elf64-alpha"
5480 #define ELF_ARCH bfd_arch_alpha
5481 #define ELF_MACHINE_CODE EM_ALPHA
5482 #define ELF_MAXPAGESIZE 0x10000
5484 #define bfd_elf64_bfd_link_hash_table_create \
5485 elf64_alpha_bfd_link_hash_table_create
5487 #define bfd_elf64_bfd_reloc_type_lookup \
5488 elf64_alpha_bfd_reloc_type_lookup
5489 #define elf_info_to_howto \
5490 elf64_alpha_info_to_howto
5492 #define bfd_elf64_mkobject \
5493 elf64_alpha_mkobject
5494 #define elf_backend_object_p \
5495 elf64_alpha_object_p
5497 #define elf_backend_section_from_shdr \
5498 elf64_alpha_section_from_shdr
5499 #define elf_backend_section_flags \
5500 elf64_alpha_section_flags
5501 #define elf_backend_fake_sections \
5502 elf64_alpha_fake_sections
5504 #define bfd_elf64_bfd_is_local_label_name \
5505 elf64_alpha_is_local_label_name
5506 #define bfd_elf64_find_nearest_line \
5507 elf64_alpha_find_nearest_line
5508 #define bfd_elf64_bfd_relax_section \
5509 elf64_alpha_relax_section
5511 #define elf_backend_add_symbol_hook \
5512 elf64_alpha_add_symbol_hook
5513 #define elf_backend_check_relocs \
5514 elf64_alpha_check_relocs
5515 #define elf_backend_create_dynamic_sections \
5516 elf64_alpha_create_dynamic_sections
5517 #define elf_backend_adjust_dynamic_symbol \
5518 elf64_alpha_adjust_dynamic_symbol
5519 #define elf_backend_always_size_sections \
5520 elf64_alpha_always_size_sections
5521 #define elf_backend_size_dynamic_sections \
5522 elf64_alpha_size_dynamic_sections
5523 #define elf_backend_relocate_section \
5524 elf64_alpha_relocate_section
5525 #define elf_backend_finish_dynamic_symbol \
5526 elf64_alpha_finish_dynamic_symbol
5527 #define elf_backend_finish_dynamic_sections \
5528 elf64_alpha_finish_dynamic_sections
5529 #define bfd_elf64_bfd_final_link \
5530 elf64_alpha_final_link
5531 #define elf_backend_reloc_type_class \
5532 elf64_alpha_reloc_type_class
5534 #define elf_backend_ecoff_debug_swap \
5535 &elf64_alpha_ecoff_debug_swap
5537 #define elf_backend_size_info \
5540 #define elf_backend_special_sections \
5541 elf64_alpha_special_sections
5543 /* A few constants that determine how the .plt section is set up. */
5544 #define elf_backend_want_got_plt 0
5545 #define elf_backend_plt_readonly 0
5546 #define elf_backend_want_plt_sym 1
5547 #define elf_backend_got_header_size 0
5549 #include "elf64-target.h"
5551 /* FreeBSD support. */
5553 #undef TARGET_LITTLE_SYM
5554 #define TARGET_LITTLE_SYM bfd_elf64_alpha_freebsd_vec
5555 #undef TARGET_LITTLE_NAME
5556 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5558 /* The kernel recognizes executables as valid only if they carry a
5559 "FreeBSD" label in the ELF header. So we put this label on all
5560 executables and (for simplicity) also all other object files. */
5562 static void elf64_alpha_fbsd_post_process_headers
5563 PARAMS ((bfd
*, struct bfd_link_info
*));
5566 elf64_alpha_fbsd_post_process_headers (abfd
, link_info
)
5568 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
5570 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
5572 i_ehdrp
= elf_elfheader (abfd
);
5574 /* Put an ABI label supported by FreeBSD >= 4.1. */
5575 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
5576 #ifdef OLD_FREEBSD_ABI_LABEL
5577 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5578 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
5582 #undef elf_backend_post_process_headers
5583 #define elf_backend_post_process_headers \
5584 elf64_alpha_fbsd_post_process_headers
5587 #define elf64_bed elf64_alpha_fbsd_bed
5589 #include "elf64-target.h"