* elf32-i386.c (elf_i386_relocate_section): Make undefined symbols
[deliverable/binutils-gdb.git] / bfd / elf64-alpha.c
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>.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22 /* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
24
25 #include "bfd.h"
26 #include "sysdep.h"
27 #include "libbfd.h"
28 #include "elf-bfd.h"
29
30 #include "elf/alpha.h"
31
32 #define ALPHAECOFF
33
34 #define NO_COFF_RELOCS
35 #define NO_COFF_SYMBOLS
36 #define NO_COFF_LINENOS
37
38 /* Get the ECOFF swapping routines. Needed for the debug information. */
39 #include "coff/internal.h"
40 #include "coff/sym.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/alpha.h"
44 #include "aout/ar.h"
45 #include "libcoff.h"
46 #include "libecoff.h"
47 #define ECOFF_64
48 #include "ecoffswap.h"
49
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
55 PARAMS ((bfd *));
56
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 **));
65
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 *));
70
71 static bfd_boolean elf64_alpha_mkobject
72 PARAMS ((bfd *));
73 static bfd_boolean elf64_alpha_object_p
74 PARAMS ((bfd *));
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 *));
85
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 *));
93
94 #if defined(__STDC__) || defined(ALMOST_STDC)
95 struct alpha_elf_link_hash_entry;
96 #endif
97
98 static bfd_boolean elf64_alpha_output_extsym
99 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
100
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 *));
160 \f
161 struct alpha_elf_link_hash_entry
162 {
163 struct elf_link_hash_entry root;
164
165 /* External symbol information. */
166 EXTR esym;
167
168 /* Cumulative flags for all the .got entries. */
169 int flags;
170
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
181
182 /* Used to undo the localization of a plt symbol. */
183 asection *plt_old_section;
184 bfd_vma plt_old_value;
185
186 /* Used to implement multiple .got subsections. */
187 struct alpha_elf_got_entry
188 {
189 struct alpha_elf_got_entry *next;
190
191 /* Which .got subsection? */
192 bfd *gotobj;
193
194 /* The addend in effect for this entry. */
195 bfd_vma addend;
196
197 /* The .got offset for this entry. */
198 int got_offset;
199
200 /* How many references to this entry? */
201 int use_count;
202
203 /* The relocation type of this entry. */
204 unsigned char reloc_type;
205
206 /* How a LITERAL is used. */
207 unsigned char flags;
208
209 /* Have we initialized the dynamic relocation for this entry? */
210 unsigned char reloc_done;
211
212 /* Have we adjusted this entry for SEC_MERGE? */
213 unsigned char reloc_xlated;
214 } *got_entries;
215
216 /* Used to count non-got, non-plt relocations for delayed sizing
217 of relocation sections. */
218 struct alpha_elf_reloc_entry
219 {
220 struct alpha_elf_reloc_entry *next;
221
222 /* Which .reloc section? */
223 asection *srel;
224
225 /* What kind of relocation? */
226 unsigned int rtype;
227
228 /* Is this against read-only section? */
229 unsigned int reltext : 1;
230
231 /* How many did we find? */
232 unsigned long count;
233 } *reloc_entries;
234 };
235
236 /* Alpha ELF linker hash table. */
237
238 struct alpha_elf_link_hash_table
239 {
240 struct elf_link_hash_table root;
241
242 /* The head of a list of .got subsections linked through
243 alpha_elf_tdata(abfd)->got_link_next. */
244 bfd *got_list;
245 };
246
247 /* Look up an entry in a Alpha ELF linker hash table. */
248
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), \
252 (copy), (follow)))
253
254 /* Traverse a Alpha ELF linker hash table. */
255
256 #define alpha_elf_link_hash_traverse(table, func, info) \
257 (elf_link_hash_traverse \
258 (&(table)->root, \
259 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
260 (info)))
261
262 /* Get the Alpha ELF linker hash table from a link_info structure. */
263
264 #define alpha_elf_hash_table(p) \
265 ((struct alpha_elf_link_hash_table *) ((p)->hash))
266
267 /* Get the object's symbols as our own entry type. */
268
269 #define alpha_elf_sym_hashes(abfd) \
270 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
271
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. */
276
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;
281 {
282 return _bfd_elf_dynamic_symbol_p (h, info, 0);
283 }
284
285 /* Create an entry in a Alpha ELF linker hash table. */
286
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;
291 const char *string;
292 {
293 struct alpha_elf_link_hash_entry *ret =
294 (struct alpha_elf_link_hash_entry *) entry;
295
296 /* Allocate the structure if it has not already been allocated by a
297 subclass. */
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;
304
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,
308 table, string));
309 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
310 {
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. */
315 ret->esym.ifd = -2;
316 ret->flags = 0;
317 ret->got_entries = NULL;
318 ret->reloc_entries = NULL;
319 }
320
321 return (struct bfd_hash_entry *) ret;
322 }
323
324 /* Create a Alpha ELF linker hash table. */
325
326 static struct bfd_link_hash_table *
327 elf64_alpha_bfd_link_hash_table_create (abfd)
328 bfd *abfd;
329 {
330 struct alpha_elf_link_hash_table *ret;
331 bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
332
333 ret = (struct alpha_elf_link_hash_table *) bfd_zmalloc (amt);
334 if (ret == (struct alpha_elf_link_hash_table *) NULL)
335 return NULL;
336
337 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
338 elf64_alpha_link_hash_newfunc))
339 {
340 free (ret);
341 return NULL;
342 }
343
344 return &ret->root.root;
345 }
346 \f
347 /* We have some private fields hanging off of the elf_tdata structure. */
348
349 struct alpha_elf_obj_tdata
350 {
351 struct elf_obj_tdata root;
352
353 /* For every input file, these are the got entries for that object's
354 local symbols. */
355 struct alpha_elf_got_entry ** local_got_entries;
356
357 /* For every input file, this is the object that owns the got that
358 this input file uses. */
359 bfd *gotobj;
360
361 /* For every got, this is a linked list through the objects using this got */
362 bfd *in_got_link_next;
363
364 /* For every got, this is a link to the next got subsegment. */
365 bfd *got_link_next;
366
367 /* For every got, this is the section. */
368 asection *got;
369
370 /* For every got, this is it's total number of words. */
371 int total_got_size;
372
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. */
375 int local_got_size;
376 };
377
378 #define alpha_elf_tdata(abfd) \
379 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
380
381 static bfd_boolean
382 elf64_alpha_mkobject (abfd)
383 bfd *abfd;
384 {
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)
388 return FALSE;
389 return TRUE;
390 }
391
392 static bfd_boolean
393 elf64_alpha_object_p (abfd)
394 bfd *abfd;
395 {
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)
401 return FALSE;
402 new_tdata->root = *abfd->tdata.elf_obj_data;
403 abfd->tdata.any = new_tdata;
404
405 /* Set the right machine number for an Alpha ELF file. */
406 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
407 }
408 \f
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)
412
413 #define SKIP_HOWTO(N) \
414 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
415
416 static reloc_howto_type elf64_alpha_howto_table[] =
417 {
418 HOWTO (R_ALPHA_NONE, /* type */
419 0, /* rightshift */
420 0, /* size (0 = byte, 1 = short, 2 = long) */
421 8, /* bitsize */
422 TRUE, /* pc_relative */
423 0, /* bitpos */
424 complain_overflow_dont, /* complain_on_overflow */
425 elf64_alpha_reloc_nil, /* special_function */
426 "NONE", /* name */
427 FALSE, /* partial_inplace */
428 0, /* src_mask */
429 0, /* dst_mask */
430 TRUE), /* pcrel_offset */
431
432 /* A 32 bit reference to a symbol. */
433 HOWTO (R_ALPHA_REFLONG, /* type */
434 0, /* rightshift */
435 2, /* size (0 = byte, 1 = short, 2 = long) */
436 32, /* bitsize */
437 FALSE, /* pc_relative */
438 0, /* bitpos */
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 */
446
447 /* A 64 bit reference to a symbol. */
448 HOWTO (R_ALPHA_REFQUAD, /* type */
449 0, /* rightshift */
450 4, /* size (0 = byte, 1 = short, 2 = long) */
451 64, /* bitsize */
452 FALSE, /* pc_relative */
453 0, /* bitpos */
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 */
461
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
464 added in. */
465 HOWTO (R_ALPHA_GPREL32, /* type */
466 0, /* rightshift */
467 2, /* size (0 = byte, 1 = short, 2 = long) */
468 32, /* bitsize */
469 FALSE, /* pc_relative */
470 0, /* bitpos */
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 */
478
479 /* Used for an instruction that refers to memory off the GP register. */
480 HOWTO (R_ALPHA_LITERAL, /* type */
481 0, /* rightshift */
482 1, /* size (0 = byte, 1 = short, 2 = long) */
483 16, /* bitsize */
484 FALSE, /* pc_relative */
485 0, /* bitpos */
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 */
493
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 */
502 0, /* rightshift */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
504 32, /* bitsize */
505 FALSE, /* pc_relative */
506 0, /* bitpos */
507 complain_overflow_dont, /* complain_on_overflow */
508 elf64_alpha_reloc_nil, /* special_function */
509 "LITUSE", /* name */
510 FALSE, /* partial_inplace */
511 0, /* src_mask */
512 0, /* dst_mask */
513 FALSE), /* pcrel_offset */
514
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.
522
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 */
532 16, /* rightshift */
533 2, /* size (0 = byte, 1 = short, 2 = long) */
534 16, /* bitsize */
535 FALSE, /* pc_relative */
536 0, /* bitpos */
537 complain_overflow_dont, /* complain_on_overflow */
538 elf64_alpha_reloc_gpdisp, /* special_function */
539 "GPDISP", /* name */
540 FALSE, /* partial_inplace */
541 0xffff, /* src_mask */
542 0xffff, /* dst_mask */
543 TRUE), /* pcrel_offset */
544
545 /* A 21 bit branch. */
546 HOWTO (R_ALPHA_BRADDR, /* type */
547 2, /* rightshift */
548 2, /* size (0 = byte, 1 = short, 2 = long) */
549 21, /* bitsize */
550 TRUE, /* pc_relative */
551 0, /* bitpos */
552 complain_overflow_signed, /* complain_on_overflow */
553 0, /* special_function */
554 "BRADDR", /* name */
555 FALSE, /* partial_inplace */
556 0x1fffff, /* src_mask */
557 0x1fffff, /* dst_mask */
558 TRUE), /* pcrel_offset */
559
560 /* A hint for a jump to a register. */
561 HOWTO (R_ALPHA_HINT, /* type */
562 2, /* rightshift */
563 1, /* size (0 = byte, 1 = short, 2 = long) */
564 14, /* bitsize */
565 TRUE, /* pc_relative */
566 0, /* bitpos */
567 complain_overflow_dont, /* complain_on_overflow */
568 0, /* special_function */
569 "HINT", /* name */
570 FALSE, /* partial_inplace */
571 0x3fff, /* src_mask */
572 0x3fff, /* dst_mask */
573 TRUE), /* pcrel_offset */
574
575 /* 16 bit PC relative offset. */
576 HOWTO (R_ALPHA_SREL16, /* type */
577 0, /* rightshift */
578 1, /* size (0 = byte, 1 = short, 2 = long) */
579 16, /* bitsize */
580 TRUE, /* pc_relative */
581 0, /* bitpos */
582 complain_overflow_signed, /* complain_on_overflow */
583 0, /* special_function */
584 "SREL16", /* name */
585 FALSE, /* partial_inplace */
586 0xffff, /* src_mask */
587 0xffff, /* dst_mask */
588 TRUE), /* pcrel_offset */
589
590 /* 32 bit PC relative offset. */
591 HOWTO (R_ALPHA_SREL32, /* type */
592 0, /* rightshift */
593 2, /* size (0 = byte, 1 = short, 2 = long) */
594 32, /* bitsize */
595 TRUE, /* pc_relative */
596 0, /* bitpos */
597 complain_overflow_signed, /* complain_on_overflow */
598 0, /* special_function */
599 "SREL32", /* name */
600 FALSE, /* partial_inplace */
601 0xffffffff, /* src_mask */
602 0xffffffff, /* dst_mask */
603 TRUE), /* pcrel_offset */
604
605 /* A 64 bit PC relative offset. */
606 HOWTO (R_ALPHA_SREL64, /* type */
607 0, /* rightshift */
608 4, /* size (0 = byte, 1 = short, 2 = long) */
609 64, /* bitsize */
610 TRUE, /* pc_relative */
611 0, /* bitpos */
612 complain_overflow_signed, /* complain_on_overflow */
613 0, /* special_function */
614 "SREL64", /* name */
615 FALSE, /* partial_inplace */
616 MINUS_ONE, /* src_mask */
617 MINUS_ONE, /* dst_mask */
618 TRUE), /* pcrel_offset */
619
620 /* Skip 12 - 16; deprecated ECOFF relocs. */
621 SKIP_HOWTO (12),
622 SKIP_HOWTO (13),
623 SKIP_HOWTO (14),
624 SKIP_HOWTO (15),
625 SKIP_HOWTO (16),
626
627 /* The high 16 bits of the displacement from GP to the target. */
628 HOWTO (R_ALPHA_GPRELHIGH,
629 0, /* rightshift */
630 1, /* size (0 = byte, 1 = short, 2 = long) */
631 16, /* bitsize */
632 FALSE, /* pc_relative */
633 0, /* bitpos */
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 */
641
642 /* The low 16 bits of the displacement from GP to the target. */
643 HOWTO (R_ALPHA_GPRELLOW,
644 0, /* rightshift */
645 1, /* size (0 = byte, 1 = short, 2 = long) */
646 16, /* bitsize */
647 FALSE, /* pc_relative */
648 0, /* bitpos */
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 */
656
657 /* A 16-bit displacement from the GP to the target. */
658 HOWTO (R_ALPHA_GPREL16,
659 0, /* rightshift */
660 1, /* size (0 = byte, 1 = short, 2 = long) */
661 16, /* bitsize */
662 FALSE, /* pc_relative */
663 0, /* bitpos */
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 */
671
672 /* Skip 20 - 23; deprecated ECOFF relocs. */
673 SKIP_HOWTO (20),
674 SKIP_HOWTO (21),
675 SKIP_HOWTO (22),
676 SKIP_HOWTO (23),
677
678 /* Misc ELF relocations. */
679
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. */
684 HOWTO (R_ALPHA_COPY,
685 0,
686 0,
687 0,
688 FALSE,
689 0,
690 complain_overflow_dont,
691 bfd_elf_generic_reloc,
692 "COPY",
693 FALSE,
694 0,
695 0,
696 TRUE),
697
698 /* A dynamic relocation for a .got entry. */
699 HOWTO (R_ALPHA_GLOB_DAT,
700 0,
701 0,
702 0,
703 FALSE,
704 0,
705 complain_overflow_dont,
706 bfd_elf_generic_reloc,
707 "GLOB_DAT",
708 FALSE,
709 0,
710 0,
711 TRUE),
712
713 /* A dynamic relocation for a .plt entry. */
714 HOWTO (R_ALPHA_JMP_SLOT,
715 0,
716 0,
717 0,
718 FALSE,
719 0,
720 complain_overflow_dont,
721 bfd_elf_generic_reloc,
722 "JMP_SLOT",
723 FALSE,
724 0,
725 0,
726 TRUE),
727
728 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
729 HOWTO (R_ALPHA_RELATIVE,
730 0,
731 0,
732 0,
733 FALSE,
734 0,
735 complain_overflow_dont,
736 bfd_elf_generic_reloc,
737 "RELATIVE",
738 FALSE,
739 0,
740 0,
741 TRUE),
742
743 /* A 21 bit branch that adjusts for gp loads. */
744 HOWTO (R_ALPHA_BRSGP, /* type */
745 2, /* rightshift */
746 2, /* size (0 = byte, 1 = short, 2 = long) */
747 21, /* bitsize */
748 TRUE, /* pc_relative */
749 0, /* bitpos */
750 complain_overflow_signed, /* complain_on_overflow */
751 0, /* special_function */
752 "BRSGP", /* name */
753 FALSE, /* partial_inplace */
754 0x1fffff, /* src_mask */
755 0x1fffff, /* dst_mask */
756 TRUE), /* pcrel_offset */
757
758 /* Creates a tls_index for the symbol in the got. */
759 HOWTO (R_ALPHA_TLSGD, /* type */
760 0, /* rightshift */
761 1, /* size (0 = byte, 1 = short, 2 = long) */
762 16, /* bitsize */
763 FALSE, /* pc_relative */
764 0, /* bitpos */
765 complain_overflow_signed, /* complain_on_overflow */
766 0, /* special_function */
767 "TLSGD", /* name */
768 FALSE, /* partial_inplace */
769 0xffff, /* src_mask */
770 0xffff, /* dst_mask */
771 FALSE), /* pcrel_offset */
772
773 /* Creates a tls_index for the (current) module in the got. */
774 HOWTO (R_ALPHA_TLSLDM, /* type */
775 0, /* rightshift */
776 1, /* size (0 = byte, 1 = short, 2 = long) */
777 16, /* bitsize */
778 FALSE, /* pc_relative */
779 0, /* bitpos */
780 complain_overflow_signed, /* complain_on_overflow */
781 0, /* special_function */
782 "TLSLDM", /* name */
783 FALSE, /* partial_inplace */
784 0xffff, /* src_mask */
785 0xffff, /* dst_mask */
786 FALSE), /* pcrel_offset */
787
788 /* A dynamic relocation for a DTP module entry. */
789 HOWTO (R_ALPHA_DTPMOD64, /* type */
790 0, /* rightshift */
791 4, /* size (0 = byte, 1 = short, 2 = long) */
792 64, /* bitsize */
793 FALSE, /* pc_relative */
794 0, /* bitpos */
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 */
802
803 /* Creates a 64-bit offset in the got for the displacement
804 from DTP to the target. */
805 HOWTO (R_ALPHA_GOTDTPREL, /* type */
806 0, /* rightshift */
807 1, /* size (0 = byte, 1 = short, 2 = long) */
808 16, /* bitsize */
809 FALSE, /* pc_relative */
810 0, /* bitpos */
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 */
818
819 /* A dynamic relocation for a displacement from DTP to the target. */
820 HOWTO (R_ALPHA_DTPREL64, /* type */
821 0, /* rightshift */
822 4, /* size (0 = byte, 1 = short, 2 = long) */
823 64, /* bitsize */
824 FALSE, /* pc_relative */
825 0, /* bitpos */
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 */
833
834 /* The high 16 bits of the displacement from DTP to the target. */
835 HOWTO (R_ALPHA_DTPRELHI, /* type */
836 0, /* rightshift */
837 1, /* size (0 = byte, 1 = short, 2 = long) */
838 16, /* bitsize */
839 FALSE, /* pc_relative */
840 0, /* bitpos */
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 */
848
849 /* The low 16 bits of the displacement from DTP to the target. */
850 HOWTO (R_ALPHA_DTPRELLO, /* type */
851 0, /* rightshift */
852 1, /* size (0 = byte, 1 = short, 2 = long) */
853 16, /* bitsize */
854 FALSE, /* pc_relative */
855 0, /* bitpos */
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 */
863
864 /* A 16-bit displacement from DTP to the target. */
865 HOWTO (R_ALPHA_DTPREL16, /* type */
866 0, /* rightshift */
867 1, /* size (0 = byte, 1 = short, 2 = long) */
868 16, /* bitsize */
869 FALSE, /* pc_relative */
870 0, /* bitpos */
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 */
878
879 /* Creates a 64-bit offset in the got for the displacement
880 from TP to the target. */
881 HOWTO (R_ALPHA_GOTTPREL, /* type */
882 0, /* rightshift */
883 1, /* size (0 = byte, 1 = short, 2 = long) */
884 16, /* bitsize */
885 FALSE, /* pc_relative */
886 0, /* bitpos */
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 */
894
895 /* A dynamic relocation for a displacement from TP to the target. */
896 HOWTO (R_ALPHA_TPREL64, /* type */
897 0, /* rightshift */
898 4, /* size (0 = byte, 1 = short, 2 = long) */
899 64, /* bitsize */
900 FALSE, /* pc_relative */
901 0, /* bitpos */
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 */
909
910 /* The high 16 bits of the displacement from TP to the target. */
911 HOWTO (R_ALPHA_TPRELHI, /* type */
912 0, /* rightshift */
913 1, /* size (0 = byte, 1 = short, 2 = long) */
914 16, /* bitsize */
915 FALSE, /* pc_relative */
916 0, /* bitpos */
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 */
924
925 /* The low 16 bits of the displacement from TP to the target. */
926 HOWTO (R_ALPHA_TPRELLO, /* type */
927 0, /* rightshift */
928 1, /* size (0 = byte, 1 = short, 2 = long) */
929 16, /* bitsize */
930 FALSE, /* pc_relative */
931 0, /* bitpos */
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 */
939
940 /* A 16-bit displacement from TP to the target. */
941 HOWTO (R_ALPHA_TPREL16, /* type */
942 0, /* rightshift */
943 1, /* size (0 = byte, 1 = short, 2 = long) */
944 16, /* bitsize */
945 FALSE, /* pc_relative */
946 0, /* bitpos */
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 */
954 };
955
956 /* A relocation function which doesn't do anything. */
957
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;
961 arelent *reloc;
962 asymbol *sym ATTRIBUTE_UNUSED;
963 PTR data ATTRIBUTE_UNUSED;
964 asection *sec;
965 bfd *output_bfd;
966 char **error_message ATTRIBUTE_UNUSED;
967 {
968 if (output_bfd)
969 reloc->address += sec->output_offset;
970 return bfd_reloc_ok;
971 }
972
973 /* A relocation function used for an unsupported reloc. */
974
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;
978 arelent *reloc;
979 asymbol *sym ATTRIBUTE_UNUSED;
980 PTR data ATTRIBUTE_UNUSED;
981 asection *sec;
982 bfd *output_bfd;
983 char **error_message ATTRIBUTE_UNUSED;
984 {
985 if (output_bfd)
986 reloc->address += sec->output_offset;
987 return bfd_reloc_notsupported;
988 }
989
990 /* Do the work of the GPDISP relocation. */
991
992 static bfd_reloc_status_type
993 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
994 bfd *abfd;
995 bfd_vma gpdisp;
996 bfd_byte *p_ldah;
997 bfd_byte *p_lda;
998 {
999 bfd_reloc_status_type ret = bfd_reloc_ok;
1000 bfd_vma addend;
1001 unsigned long i_ldah, i_lda;
1002
1003 i_ldah = bfd_get_32 (abfd, p_ldah);
1004 i_lda = bfd_get_32 (abfd, p_lda);
1005
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;
1010
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;
1015
1016 gpdisp += addend;
1017
1018 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
1019 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
1020 ret = bfd_reloc_overflow;
1021
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);
1026
1027 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
1028 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
1029
1030 return ret;
1031 }
1032
1033 /* The special function for the GPDISP reloc. */
1034
1035 static bfd_reloc_status_type
1036 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
1037 output_bfd, err_msg)
1038 bfd *abfd;
1039 arelent *reloc_entry;
1040 asymbol *sym ATTRIBUTE_UNUSED;
1041 PTR data;
1042 asection *input_section;
1043 bfd *output_bfd;
1044 char **err_msg;
1045 {
1046 bfd_reloc_status_type ret;
1047 bfd_vma gp, relocation;
1048 bfd_byte *p_ldah, *p_lda;
1049
1050 /* Don't do anything if we're not doing a final link. */
1051 if (output_bfd)
1052 {
1053 reloc_entry->address += input_section->output_offset;
1054 return bfd_reloc_ok;
1055 }
1056
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;
1060
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);
1064
1065 relocation = (input_section->output_section->vma
1066 + input_section->output_offset
1067 + reloc_entry->address);
1068
1069 p_ldah = (bfd_byte *) data + reloc_entry->address;
1070 p_lda = p_ldah + reloc_entry->addend;
1071
1072 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
1073
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");
1077
1078 return ret;
1079 }
1080
1081 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1082
1083 struct elf_reloc_map
1084 {
1085 bfd_reloc_code_real_type bfd_reloc_val;
1086 int elf_reloc_val;
1087 };
1088
1089 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
1090 {
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},
1121 };
1122
1123 /* Given a BFD reloc type, return a HOWTO structure. */
1124
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;
1129 {
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);
1133 for (; i != e; ++i)
1134 {
1135 if (i->bfd_reloc_val == code)
1136 return &elf64_alpha_howto_table[i->elf_reloc_val];
1137 }
1138 return 0;
1139 }
1140
1141 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1142
1143 static void
1144 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
1145 bfd *abfd ATTRIBUTE_UNUSED;
1146 arelent *cache_ptr;
1147 Elf_Internal_Rela *dst;
1148 {
1149 unsigned r_type;
1150
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];
1154 }
1155
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)
1159
1160 /* This is PT_TLS segment p_vaddr. */
1161 #define alpha_get_dtprel_base(tlss) \
1162 ((tlss)->start)
1163
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(tlss) \
1167 ((tlss)->start - align_power ((bfd_vma) 16, (tlss)->align))
1168 \f
1169 /* These functions do relaxation for Alpha ELF.
1170
1171 Currently I'm only handling what I can do with existing compiler
1172 and assembler support, which means no instructions are removed,
1173 though some may be nopped. At this time GCC does not emit enough
1174 information to do all of the relaxing that is possible. It will
1175 take some not small amount of work for that to happen.
1176
1177 There are a couple of interesting papers that I once read on this
1178 subject, that I cannot find references to at the moment, that
1179 related to Alpha in particular. They are by David Wall, then of
1180 DEC WRL. */
1181
1182 #define OP_LDA 0x08
1183 #define OP_LDAH 0x09
1184 #define INSN_JSR 0x68004000
1185 #define INSN_JSR_MASK 0xfc00c000
1186 #define OP_LDQ 0x29
1187 #define OP_BR 0x30
1188 #define OP_BSR 0x34
1189 #define INSN_UNOP 0x2ffe0000
1190 #define INSN_ADDQ 0x40000400
1191 #define INSN_RDUNIQ 0x0000009e
1192
1193 struct alpha_relax_info
1194 {
1195 bfd *abfd;
1196 asection *sec;
1197 bfd_byte *contents;
1198 Elf_Internal_Shdr *symtab_hdr;
1199 Elf_Internal_Rela *relocs, *relend;
1200 struct bfd_link_info *link_info;
1201 struct elf_link_tls_segment *tls_segment;
1202 bfd_vma gp;
1203 bfd *gotobj;
1204 asection *tsec;
1205 struct alpha_elf_link_hash_entry *h;
1206 struct alpha_elf_got_entry **first_gotent;
1207 struct alpha_elf_got_entry *gotent;
1208 bfd_boolean changed_contents;
1209 bfd_boolean changed_relocs;
1210 unsigned char other;
1211 };
1212
1213 static bfd_boolean elf64_alpha_relax_with_lituse
1214 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1215 Elf_Internal_Rela *irel));
1216 static bfd_vma elf64_alpha_relax_opt_call
1217 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
1218 static bfd_boolean elf64_alpha_relax_got_load
1219 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1220 Elf_Internal_Rela *irel, unsigned long));
1221 static bfd_boolean elf64_alpha_relax_gprelhilo
1222 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1223 Elf_Internal_Rela *irel, bfd_boolean));
1224 static bfd_boolean elf64_alpha_relax_tls_get_addr
1225 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1226 Elf_Internal_Rela *irel, bfd_boolean));
1227 static struct elf_link_tls_segment *elf64_alpha_relax_find_tls_segment
1228 PARAMS((struct alpha_relax_info *, struct elf_link_tls_segment *));
1229 static bfd_boolean elf64_alpha_relax_section
1230 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
1231 bfd_boolean *again));
1232
1233 static Elf_Internal_Rela *
1234 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
1235 Elf_Internal_Rela *rel, *relend;
1236 bfd_vma offset;
1237 int type;
1238 {
1239 while (rel < relend)
1240 {
1241 if (rel->r_offset == offset
1242 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
1243 return rel;
1244 ++rel;
1245 }
1246 return NULL;
1247 }
1248
1249 static bfd_boolean
1250 elf64_alpha_relax_with_lituse (info, symval, irel)
1251 struct alpha_relax_info *info;
1252 bfd_vma symval;
1253 Elf_Internal_Rela *irel;
1254 {
1255 Elf_Internal_Rela *urel, *irelend = info->relend;
1256 int flags, count, i;
1257 bfd_signed_vma disp;
1258 bfd_boolean fits16;
1259 bfd_boolean fits32;
1260 bfd_boolean lit_reused = FALSE;
1261 bfd_boolean all_optimized = TRUE;
1262 unsigned int lit_insn;
1263
1264 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1265 if (lit_insn >> 26 != OP_LDQ)
1266 {
1267 ((*_bfd_error_handler)
1268 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1269 bfd_archive_filename (info->abfd), info->sec->name,
1270 (unsigned long) irel->r_offset));
1271 return TRUE;
1272 }
1273
1274 /* Can't relax dynamic symbols. */
1275 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
1276 return TRUE;
1277
1278 /* Summarize how this particular LITERAL is used. */
1279 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1280 {
1281 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1282 break;
1283 if (urel->r_addend <= 3)
1284 flags |= 1 << urel->r_addend;
1285 }
1286
1287 /* A little preparation for the loop... */
1288 disp = symval - info->gp;
1289
1290 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1291 {
1292 unsigned int insn;
1293 int insn_disp;
1294 bfd_signed_vma xdisp;
1295
1296 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1297
1298 switch (urel->r_addend)
1299 {
1300 case LITUSE_ALPHA_ADDR:
1301 default:
1302 /* This type is really just a placeholder to note that all
1303 uses cannot be optimized, but to still allow some. */
1304 all_optimized = FALSE;
1305 break;
1306
1307 case LITUSE_ALPHA_BASE:
1308 /* We can always optimize 16-bit displacements. */
1309
1310 /* Extract the displacement from the instruction, sign-extending
1311 it if necessary, then test whether it is within 16 or 32 bits
1312 displacement from GP. */
1313 insn_disp = insn & 0x0000ffff;
1314 if (insn_disp & 0x8000)
1315 insn_disp |= ~0xffff; /* Negative: sign-extend. */
1316
1317 xdisp = disp + insn_disp;
1318 fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
1319 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
1320 && xdisp < 0x7fff8000);
1321
1322 if (fits16)
1323 {
1324 /* Take the op code and dest from this insn, take the base
1325 register from the literal insn. Leave the offset alone. */
1326 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1327 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1328 R_ALPHA_GPREL16);
1329 urel->r_addend = irel->r_addend;
1330 info->changed_relocs = TRUE;
1331
1332 bfd_put_32 (info->abfd, (bfd_vma) insn,
1333 info->contents + urel->r_offset);
1334 info->changed_contents = TRUE;
1335 }
1336
1337 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1338 else if (fits32 && !(flags & ~6))
1339 {
1340 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1341
1342 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1343 R_ALPHA_GPRELHIGH);
1344 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1345 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
1346 info->contents + irel->r_offset);
1347 lit_reused = TRUE;
1348 info->changed_contents = TRUE;
1349
1350 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1351 R_ALPHA_GPRELLOW);
1352 urel->r_addend = irel->r_addend;
1353 info->changed_relocs = TRUE;
1354 }
1355 else
1356 all_optimized = FALSE;
1357 break;
1358
1359 case LITUSE_ALPHA_BYTOFF:
1360 /* We can always optimize byte instructions. */
1361
1362 /* FIXME: sanity check the insn for byte op. Check that the
1363 literal dest reg is indeed Rb in the byte insn. */
1364
1365 insn &= ~ (unsigned) 0x001ff000;
1366 insn |= ((symval & 7) << 13) | 0x1000;
1367
1368 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1369 urel->r_addend = 0;
1370 info->changed_relocs = TRUE;
1371
1372 bfd_put_32 (info->abfd, (bfd_vma) insn,
1373 info->contents + urel->r_offset);
1374 info->changed_contents = TRUE;
1375 break;
1376
1377 case LITUSE_ALPHA_JSR:
1378 case LITUSE_ALPHA_TLSGD:
1379 case LITUSE_ALPHA_TLSLDM:
1380 {
1381 bfd_vma optdest, org;
1382 bfd_signed_vma odisp;
1383
1384 /* If not zero, place to jump without needing pv. */
1385 optdest = elf64_alpha_relax_opt_call (info, symval);
1386 org = (info->sec->output_section->vma
1387 + info->sec->output_offset
1388 + urel->r_offset + 4);
1389 odisp = (optdest ? optdest : symval) - org;
1390
1391 if (odisp >= -0x400000 && odisp < 0x400000)
1392 {
1393 Elf_Internal_Rela *xrel;
1394
1395 /* Preserve branch prediction call stack when possible. */
1396 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1397 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1398 else
1399 insn = (OP_BR << 26) | (insn & 0x03e00000);
1400
1401 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1402 R_ALPHA_BRADDR);
1403 urel->r_addend = irel->r_addend;
1404
1405 if (optdest)
1406 urel->r_addend += optdest - symval;
1407 else
1408 all_optimized = FALSE;
1409
1410 bfd_put_32 (info->abfd, (bfd_vma) insn,
1411 info->contents + urel->r_offset);
1412
1413 /* Kill any HINT reloc that might exist for this insn. */
1414 xrel = (elf64_alpha_find_reloc_at_ofs
1415 (info->relocs, info->relend, urel->r_offset,
1416 R_ALPHA_HINT));
1417 if (xrel)
1418 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1419
1420 info->changed_contents = TRUE;
1421 info->changed_relocs = TRUE;
1422 }
1423 else
1424 all_optimized = FALSE;
1425
1426 /* Even if the target is not in range for a direct branch,
1427 if we share a GP, we can eliminate the gp reload. */
1428 if (optdest)
1429 {
1430 Elf_Internal_Rela *gpdisp
1431 = (elf64_alpha_find_reloc_at_ofs
1432 (info->relocs, irelend, urel->r_offset + 4,
1433 R_ALPHA_GPDISP));
1434 if (gpdisp)
1435 {
1436 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
1437 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1438 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1439 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1440
1441 /* Verify that the instruction is "ldah $29,0($26)".
1442 Consider a function that ends in a noreturn call,
1443 and that the next function begins with an ldgp,
1444 and that by accident there is no padding between.
1445 In that case the insn would use $27 as the base. */
1446 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1447 {
1448 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
1449 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
1450
1451 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1452 info->changed_contents = TRUE;
1453 info->changed_relocs = TRUE;
1454 }
1455 }
1456 }
1457 }
1458 break;
1459 }
1460 }
1461
1462 /* If all cases were optimized, we can reduce the use count on this
1463 got entry by one, possibly eliminating it. */
1464 if (all_optimized)
1465 {
1466 if (--info->gotent->use_count == 0)
1467 {
1468 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
1469 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
1470 if (!info->h)
1471 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
1472 }
1473
1474 /* If the literal instruction is no longer needed (it may have been
1475 reused. We can eliminate it. */
1476 /* ??? For now, I don't want to deal with compacting the section,
1477 so just nop it out. */
1478 if (!lit_reused)
1479 {
1480 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1481 info->changed_relocs = TRUE;
1482
1483 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
1484 info->contents + irel->r_offset);
1485 info->changed_contents = TRUE;
1486 }
1487 }
1488
1489 return TRUE;
1490 }
1491
1492 static bfd_vma
1493 elf64_alpha_relax_opt_call (info, symval)
1494 struct alpha_relax_info *info;
1495 bfd_vma symval;
1496 {
1497 /* If the function has the same gp, and we can identify that the
1498 function does not use its function pointer, we can eliminate the
1499 address load. */
1500
1501 /* If the symbol is marked NOPV, we are being told the function never
1502 needs its procedure value. */
1503 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1504 return symval;
1505
1506 /* If the symbol is marked STD_GP, we are being told the function does
1507 a normal ldgp in the first two words. */
1508 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1509 ;
1510
1511 /* Otherwise, we may be able to identify a GP load in the first two
1512 words, which we can then skip. */
1513 else
1514 {
1515 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1516 bfd_vma ofs;
1517
1518 /* Load the relocations from the section that the target symbol is in. */
1519 if (info->sec == info->tsec)
1520 {
1521 tsec_relocs = info->relocs;
1522 tsec_relend = info->relend;
1523 tsec_free = NULL;
1524 }
1525 else
1526 {
1527 tsec_relocs = (_bfd_elf_link_read_relocs
1528 (info->abfd, info->tsec, (PTR) NULL,
1529 (Elf_Internal_Rela *) NULL,
1530 info->link_info->keep_memory));
1531 if (tsec_relocs == NULL)
1532 return 0;
1533 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1534 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1535 }
1536
1537 /* Recover the symbol's offset within the section. */
1538 ofs = (symval - info->tsec->output_section->vma
1539 - info->tsec->output_offset);
1540
1541 /* Look for a GPDISP reloc. */
1542 gpdisp = (elf64_alpha_find_reloc_at_ofs
1543 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1544
1545 if (!gpdisp || gpdisp->r_addend != 4)
1546 {
1547 if (tsec_free)
1548 free (tsec_free);
1549 return 0;
1550 }
1551 if (tsec_free)
1552 free (tsec_free);
1553 }
1554
1555 /* We've now determined that we can skip an initial gp load. Verify
1556 that the call and the target use the same gp. */
1557 if (info->link_info->hash->creator != info->tsec->owner->xvec
1558 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1559 return 0;
1560
1561 return symval + 8;
1562 }
1563
1564 static bfd_boolean
1565 elf64_alpha_relax_got_load (info, symval, irel, r_type)
1566 struct alpha_relax_info *info;
1567 bfd_vma symval;
1568 Elf_Internal_Rela *irel;
1569 unsigned long r_type;
1570 {
1571 unsigned int insn;
1572 bfd_signed_vma disp;
1573
1574 /* Get the instruction. */
1575 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1576
1577 if (insn >> 26 != OP_LDQ)
1578 {
1579 reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
1580 ((*_bfd_error_handler)
1581 ("%s: %s+0x%lx: warning: %s relocation against unexpected insn",
1582 bfd_archive_filename (info->abfd), info->sec->name,
1583 (unsigned long) irel->r_offset, howto->name));
1584 return TRUE;
1585 }
1586
1587 /* Can't relax dynamic symbols. */
1588 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
1589 return TRUE;
1590
1591 /* Can't use local-exec relocations in shared libraries. */
1592 if (r_type == R_ALPHA_GOTTPREL && info->link_info->shared)
1593 return TRUE;
1594
1595 if (r_type == R_ALPHA_LITERAL)
1596 disp = symval - info->gp;
1597 else
1598 {
1599 bfd_vma dtp_base, tp_base;
1600
1601 BFD_ASSERT (info->tls_segment != NULL);
1602 dtp_base = alpha_get_dtprel_base (info->tls_segment);
1603 tp_base = alpha_get_tprel_base (info->tls_segment);
1604 disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
1605 }
1606
1607 if (disp < -0x8000 || disp >= 0x8000)
1608 return TRUE;
1609
1610 /* Exchange LDQ for LDA. In the case of the TLS relocs, we're loading
1611 a constant, so force the base register to be $31. */
1612 if (r_type == R_ALPHA_LITERAL)
1613 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1614 else
1615 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
1616 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
1617 info->changed_contents = TRUE;
1618
1619 /* Reduce the use count on this got entry by one, possibly
1620 eliminating it. */
1621 if (--info->gotent->use_count == 0)
1622 {
1623 int sz = alpha_got_entry_size (r_type);
1624 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
1625 if (!info->h)
1626 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
1627 }
1628
1629 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
1630 switch (r_type)
1631 {
1632 case R_ALPHA_LITERAL:
1633 r_type = R_ALPHA_GPREL16;
1634 break;
1635 case R_ALPHA_GOTDTPREL:
1636 r_type = R_ALPHA_DTPREL16;
1637 break;
1638 case R_ALPHA_GOTTPREL:
1639 r_type = R_ALPHA_TPREL16;
1640 break;
1641 default:
1642 BFD_ASSERT (0);
1643 return FALSE;
1644 }
1645
1646 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
1647 info->changed_relocs = TRUE;
1648
1649 /* ??? Search forward through this basic block looking for insns
1650 that use the target register. Stop after an insn modifying the
1651 register is seen, or after a branch or call.
1652
1653 Any such memory load insn may be substituted by a load directly
1654 off the GP. This allows the memory load insn to be issued before
1655 the calculated GP register would otherwise be ready.
1656
1657 Any such jsr insn can be replaced by a bsr if it is in range.
1658
1659 This would mean that we'd have to _add_ relocations, the pain of
1660 which gives one pause. */
1661
1662 return TRUE;
1663 }
1664
1665 static bfd_boolean
1666 elf64_alpha_relax_gprelhilo (info, symval, irel, hi)
1667 struct alpha_relax_info *info;
1668 bfd_vma symval;
1669 Elf_Internal_Rela *irel;
1670 bfd_boolean hi;
1671 {
1672 unsigned int insn;
1673 bfd_signed_vma disp;
1674 bfd_byte *pos = info->contents + irel->r_offset;
1675
1676 /* ??? This assumes that the compiler doesn't render
1677
1678 array[i]
1679 as
1680 ldah t, array(gp) !gprelhigh
1681 s8addl i, t, t
1682 ldq r, array(t) !gprellow
1683
1684 which would indeed be the most efficient way to implement this. */
1685
1686 return TRUE;
1687
1688 disp = symval - info->gp;
1689 if (disp < -0x8000 || disp >= 0x8000)
1690 return TRUE;
1691
1692 if (hi)
1693 {
1694 /* Nop out the high instruction. */
1695
1696 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos);
1697 info->changed_contents = TRUE;
1698
1699 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1700 irel->r_addend = 0;
1701 info->changed_relocs = TRUE;
1702 }
1703 else
1704 {
1705 /* Adjust the low instruction to reference GP directly. */
1706
1707 insn = bfd_get_32 (info->abfd, pos);
1708 insn = (insn & 0xffe00000) | (29 << 16);
1709 bfd_put_32 (info->abfd, (bfd_vma) insn, pos);
1710 info->changed_contents = TRUE;
1711
1712 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1713 R_ALPHA_GPREL16);
1714 info->changed_relocs = TRUE;
1715 }
1716
1717 return TRUE;
1718 }
1719
1720 static bfd_boolean
1721 elf64_alpha_relax_tls_get_addr (info, symval, irel, is_gd)
1722 struct alpha_relax_info *info;
1723 bfd_vma symval;
1724 Elf_Internal_Rela *irel;
1725 bfd_boolean is_gd;
1726 {
1727 bfd_byte *pos[5];
1728 unsigned int insn;
1729 Elf_Internal_Rela *gpdisp, *hint;
1730 bfd_boolean dynamic, use_gottprel, pos1_unusable;
1731 unsigned long new_symndx;
1732
1733 dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
1734
1735 /* If a TLS symbol is accessed using IE at least once, there is no point
1736 to use dynamic model for it. */
1737 if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
1738 ;
1739
1740 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
1741 then we might as well relax to IE. */
1742 else if (info->link_info->shared && !dynamic
1743 && (info->link_info->flags & DF_STATIC_TLS))
1744 ;
1745
1746 /* Otherwise we must be building an executable to do anything. */
1747 else if (info->link_info->shared)
1748 return TRUE;
1749
1750 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
1751 the matching LITUSE_TLS relocations. */
1752 if (irel + 2 >= info->relend)
1753 return TRUE;
1754 if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
1755 || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
1756 || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
1757 return TRUE;
1758
1759 /* There must be a GPDISP relocation positioned immediately after the
1760 LITUSE relocation. */
1761 gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
1762 irel[2].r_offset + 4, R_ALPHA_GPDISP);
1763 if (!gpdisp)
1764 return TRUE;
1765
1766 pos[0] = info->contents + irel[0].r_offset;
1767 pos[1] = info->contents + irel[1].r_offset;
1768 pos[2] = info->contents + irel[2].r_offset;
1769 pos[3] = info->contents + gpdisp->r_offset;
1770 pos[4] = pos[3] + gpdisp->r_addend;
1771 pos1_unusable = FALSE;
1772
1773 /* Generally, the positions are not allowed to be out of order, lest the
1774 modified insn sequence have different register lifetimes. We can make
1775 an exception when pos 1 is adjacent to pos 0. */
1776 if (pos[1] + 4 == pos[0])
1777 {
1778 bfd_byte *tmp = pos[0];
1779 pos[0] = pos[1];
1780 pos[1] = tmp;
1781 }
1782 else if (pos[1] < pos[0])
1783 pos1_unusable = TRUE;
1784 if (pos[1] >= pos[2] || pos[2] >= pos[3])
1785 return TRUE;
1786
1787 /* Reduce the use count on the LITERAL relocation. Do this before we
1788 smash the symndx when we adjust the relocations below. */
1789 {
1790 struct alpha_elf_got_entry *lit_gotent;
1791 struct alpha_elf_link_hash_entry *lit_h;
1792 unsigned long indx;
1793
1794 BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
1795 indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
1796 lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
1797
1798 while (lit_h->root.root.type == bfd_link_hash_indirect
1799 || lit_h->root.root.type == bfd_link_hash_warning)
1800 lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
1801
1802 for (lit_gotent = lit_h->got_entries; lit_gotent ;
1803 lit_gotent = lit_gotent->next)
1804 if (lit_gotent->gotobj == info->gotobj
1805 && lit_gotent->reloc_type == R_ALPHA_LITERAL
1806 && lit_gotent->addend == irel[1].r_addend)
1807 break;
1808 BFD_ASSERT (lit_gotent);
1809
1810 if (--lit_gotent->use_count == 0)
1811 {
1812 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
1813 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
1814 }
1815 }
1816
1817 /* Change
1818
1819 lda $16,x($gp) !tlsgd!1
1820 ldq $27,__tls_get_addr($gp) !literal!1
1821 jsr $26,($27)__tls_get_addr !lituse_tlsgd!1
1822 ldah $29,0($26) !gpdisp!2
1823 lda $29,0($29) !gpdisp!2
1824 to
1825 ldq $16,x($gp) !gottprel
1826 unop
1827 call_pal rduniq
1828 addq $16,$0,$0
1829 unop
1830 or the first pair to
1831 lda $16,x($gp) !tprel
1832 unop
1833 or
1834 ldah $16,x($gp) !tprelhi
1835 lda $16,x($16) !tprello
1836
1837 as appropriate. */
1838
1839 use_gottprel = FALSE;
1840 new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : 0;
1841 switch (!dynamic && !info->link_info->shared)
1842 {
1843 case 1:
1844 {
1845 bfd_vma tp_base;
1846 bfd_signed_vma disp;
1847
1848 BFD_ASSERT (info->tls_segment != NULL);
1849 tp_base = alpha_get_tprel_base (info->tls_segment);
1850 disp = symval - tp_base;
1851
1852 if (disp >= -0x8000 && disp < 0x8000)
1853 {
1854 insn = (OP_LDA << 26) | (16 << 21) | (31 << 16);
1855 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
1856 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
1857
1858 irel[0].r_offset = pos[0] - info->contents;
1859 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
1860 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1861 break;
1862 }
1863 else if (disp >= -(bfd_signed_vma) 0x80000000
1864 && disp < (bfd_signed_vma) 0x7fff8000
1865 && !pos1_unusable)
1866 {
1867 insn = (OP_LDAH << 26) | (16 << 21) | (31 << 16);
1868 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
1869 insn = (OP_LDA << 26) | (16 << 21) | (16 << 16);
1870 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
1871
1872 irel[0].r_offset = pos[0] - info->contents;
1873 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
1874 irel[1].r_offset = pos[1] - info->contents;
1875 irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
1876 break;
1877 }
1878 }
1879 /* FALLTHRU */
1880
1881 default:
1882 use_gottprel = TRUE;
1883
1884 insn = (OP_LDQ << 26) | (16 << 21) | (29 << 16);
1885 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
1886 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
1887
1888 irel[0].r_offset = pos[0] - info->contents;
1889 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
1890 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1891 break;
1892 }
1893
1894 bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
1895
1896 insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
1897 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
1898
1899 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
1900
1901 irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1902 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1903
1904 hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
1905 irel[2].r_offset, R_ALPHA_HINT);
1906 if (hint)
1907 hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1908
1909 info->changed_contents = TRUE;
1910 info->changed_relocs = TRUE;
1911
1912 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
1913 if (--info->gotent->use_count == 0)
1914 {
1915 int sz = alpha_got_entry_size (info->gotent->reloc_type);
1916 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
1917 if (!info->h)
1918 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
1919 }
1920
1921 /* If we've switched to a GOTTPREL relocation, increment the reference
1922 count on that got entry. */
1923 if (use_gottprel)
1924 {
1925 struct alpha_elf_got_entry *tprel_gotent;
1926
1927 for (tprel_gotent = *info->first_gotent; tprel_gotent ;
1928 tprel_gotent = tprel_gotent->next)
1929 if (tprel_gotent->gotobj == info->gotobj
1930 && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
1931 && tprel_gotent->addend == irel->r_addend)
1932 break;
1933 if (tprel_gotent)
1934 tprel_gotent->use_count++;
1935 else
1936 {
1937 if (info->gotent->use_count == 0)
1938 tprel_gotent = info->gotent;
1939 else
1940 {
1941 tprel_gotent = (struct alpha_elf_got_entry *)
1942 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
1943 if (!tprel_gotent)
1944 return FALSE;
1945
1946 tprel_gotent->next = *info->first_gotent;
1947 *info->first_gotent = tprel_gotent;
1948
1949 tprel_gotent->gotobj = info->gotobj;
1950 tprel_gotent->addend = irel->r_addend;
1951 tprel_gotent->got_offset = -1;
1952 tprel_gotent->reloc_done = 0;
1953 tprel_gotent->reloc_xlated = 0;
1954 }
1955
1956 tprel_gotent->use_count = 1;
1957 tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
1958 }
1959 }
1960
1961 return TRUE;
1962 }
1963
1964 static struct elf_link_tls_segment *
1965 elf64_alpha_relax_find_tls_segment (info, seg)
1966 struct alpha_relax_info *info;
1967 struct elf_link_tls_segment *seg;
1968 {
1969 bfd *output_bfd = info->sec->output_section->owner;
1970 asection *o;
1971 unsigned int align;
1972 bfd_vma base, end;
1973
1974 for (o = output_bfd->sections; o ; o = o->next)
1975 if ((o->flags & SEC_THREAD_LOCAL) != 0
1976 && (o->flags & SEC_LOAD) != 0)
1977 break;
1978 if (!o)
1979 return NULL;
1980
1981 base = o->vma;
1982 align = 0;
1983
1984 do
1985 {
1986 bfd_vma size;
1987
1988 if (bfd_get_section_alignment (output_bfd, o) > align)
1989 align = bfd_get_section_alignment (output_bfd, o);
1990
1991 size = o->_raw_size;
1992 if (size == 0 && (o->flags & SEC_HAS_CONTENTS) == 0)
1993 {
1994 struct bfd_link_order *lo;
1995 for (lo = o->link_order_head; lo ; lo = lo->next)
1996 if (size < lo->offset + lo->size)
1997 size = lo->offset + lo->size;
1998 }
1999 end = o->vma + size;
2000 o = o->next;
2001 }
2002 while (o && (o->flags & SEC_THREAD_LOCAL));
2003
2004 seg->start = base;
2005 seg->size = end - base;
2006 seg->align = align;
2007
2008 return seg;
2009 }
2010
2011 static bfd_boolean
2012 elf64_alpha_relax_section (abfd, sec, link_info, again)
2013 bfd *abfd;
2014 asection *sec;
2015 struct bfd_link_info *link_info;
2016 bfd_boolean *again;
2017 {
2018 Elf_Internal_Shdr *symtab_hdr;
2019 Elf_Internal_Rela *internal_relocs;
2020 Elf_Internal_Rela *irel, *irelend;
2021 Elf_Internal_Sym *isymbuf = NULL;
2022 struct alpha_elf_got_entry **local_got_entries;
2023 struct alpha_relax_info info;
2024 struct elf_link_tls_segment tls_segment;
2025
2026 /* We are not currently changing any sizes, so only one pass. */
2027 *again = FALSE;
2028
2029 if (link_info->relocatable
2030 || (sec->flags & SEC_RELOC) == 0
2031 || sec->reloc_count == 0)
2032 return TRUE;
2033
2034 /* If this is the first time we have been called for this section,
2035 initialize the cooked size. */
2036 if (sec->_cooked_size == 0)
2037 sec->_cooked_size = sec->_raw_size;
2038
2039 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2040 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2041
2042 /* Load the relocations for this section. */
2043 internal_relocs = (_bfd_elf_link_read_relocs
2044 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2045 link_info->keep_memory));
2046 if (internal_relocs == NULL)
2047 return FALSE;
2048
2049 memset(&info, 0, sizeof (info));
2050 info.abfd = abfd;
2051 info.sec = sec;
2052 info.link_info = link_info;
2053 info.symtab_hdr = symtab_hdr;
2054 info.relocs = internal_relocs;
2055 info.relend = irelend = internal_relocs + sec->reloc_count;
2056
2057 /* Find the GP for this object. Do not store the result back via
2058 _bfd_set_gp_value, since this could change again before final. */
2059 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
2060 if (info.gotobj)
2061 {
2062 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
2063 info.gp = (sgot->output_section->vma
2064 + sgot->output_offset
2065 + 0x8000);
2066 }
2067
2068 /* Get the section contents. */
2069 if (elf_section_data (sec)->this_hdr.contents != NULL)
2070 info.contents = elf_section_data (sec)->this_hdr.contents;
2071 else
2072 {
2073 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2074 if (info.contents == NULL)
2075 goto error_return;
2076
2077 if (! bfd_get_section_contents (abfd, sec, info.contents,
2078 (file_ptr) 0, sec->_raw_size))
2079 goto error_return;
2080 }
2081
2082 /* Compute the TLS segment information. The version normally found in
2083 elf_hash_table (link_info)->tls_segment isn't built until final_link.
2084 ??? Probably should look into extracting this into a common function. */
2085 info.tls_segment = elf64_alpha_relax_find_tls_segment (&info, &tls_segment);
2086
2087 for (irel = internal_relocs; irel < irelend; irel++)
2088 {
2089 bfd_vma symval;
2090 struct alpha_elf_got_entry *gotent;
2091 unsigned long r_type = ELF64_R_TYPE (irel->r_info);
2092 unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
2093
2094 /* Early exit for unhandled or unrelaxable relocations. */
2095 switch (r_type)
2096 {
2097 case R_ALPHA_LITERAL:
2098 case R_ALPHA_GPRELHIGH:
2099 case R_ALPHA_GPRELLOW:
2100 case R_ALPHA_GOTDTPREL:
2101 case R_ALPHA_GOTTPREL:
2102 case R_ALPHA_TLSGD:
2103 break;
2104
2105 case R_ALPHA_TLSLDM:
2106 /* The symbol for a TLSLDM reloc is ignored. Collapse the
2107 reloc to the 0 symbol so that they all match. */
2108 r_symndx = 0;
2109 break;
2110
2111 default:
2112 continue;
2113 }
2114
2115 /* Get the value of the symbol referred to by the reloc. */
2116 if (r_symndx < symtab_hdr->sh_info)
2117 {
2118 /* A local symbol. */
2119 Elf_Internal_Sym *isym;
2120
2121 /* Read this BFD's local symbols. */
2122 if (isymbuf == NULL)
2123 {
2124 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2125 if (isymbuf == NULL)
2126 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2127 symtab_hdr->sh_info, 0,
2128 NULL, NULL, NULL);
2129 if (isymbuf == NULL)
2130 goto error_return;
2131 }
2132
2133 isym = isymbuf + r_symndx;
2134
2135 /* Given the symbol for a TLSLDM reloc is ignored, this also
2136 means forcing the symbol value to the tp base. */
2137 if (r_type == R_ALPHA_TLSLDM)
2138 {
2139 info.tsec = bfd_abs_section_ptr;
2140 symval = alpha_get_tprel_base (info.tls_segment);
2141 }
2142 else
2143 {
2144 symval = isym->st_value;
2145 if (isym->st_shndx == SHN_UNDEF)
2146 continue;
2147 else if (isym->st_shndx == SHN_ABS)
2148 info.tsec = bfd_abs_section_ptr;
2149 else if (isym->st_shndx == SHN_COMMON)
2150 info.tsec = bfd_com_section_ptr;
2151 else
2152 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2153 }
2154
2155 info.h = NULL;
2156 info.other = isym->st_other;
2157 if (local_got_entries)
2158 info.first_gotent = &local_got_entries[r_symndx];
2159 else
2160 {
2161 info.first_gotent = &info.gotent;
2162 info.gotent = NULL;
2163 }
2164 }
2165 else
2166 {
2167 unsigned long indx;
2168 struct alpha_elf_link_hash_entry *h;
2169
2170 indx = r_symndx - symtab_hdr->sh_info;
2171 h = alpha_elf_sym_hashes (abfd)[indx];
2172 BFD_ASSERT (h != NULL);
2173
2174 while (h->root.root.type == bfd_link_hash_indirect
2175 || h->root.root.type == bfd_link_hash_warning)
2176 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2177
2178 /* If the symbol is undefined, we can't do anything with it. */
2179 if (h->root.root.type == bfd_link_hash_undefweak
2180 || h->root.root.type == bfd_link_hash_undefined)
2181 continue;
2182
2183 /* If the symbol isn't defined in the current module, again
2184 we can't do anything. */
2185 if (!(h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2186 {
2187 /* Except for TLSGD relocs, which can sometimes be
2188 relaxed to GOTTPREL relocs. */
2189 if (r_type != R_ALPHA_TLSGD)
2190 continue;
2191 info.tsec = bfd_abs_section_ptr;
2192 symval = 0;
2193 }
2194 else
2195 {
2196 info.tsec = h->root.root.u.def.section;
2197 symval = h->root.root.u.def.value;
2198 }
2199
2200 info.h = h;
2201 info.other = h->root.other;
2202 info.first_gotent = &h->got_entries;
2203 }
2204
2205 /* Search for the got entry to be used by this relocation. */
2206 for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
2207 if (gotent->gotobj == info.gotobj
2208 && gotent->reloc_type == r_type
2209 && gotent->addend == irel->r_addend)
2210 break;
2211 info.gotent = gotent;
2212
2213 symval += info.tsec->output_section->vma + info.tsec->output_offset;
2214 symval += irel->r_addend;
2215
2216 switch (r_type)
2217 {
2218 case R_ALPHA_LITERAL:
2219 BFD_ASSERT(info.gotent != NULL);
2220
2221 /* If there exist LITUSE relocations immediately following, this
2222 opens up all sorts of interesting optimizations, because we
2223 now know every location that this address load is used. */
2224 if (irel+1 < irelend
2225 && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
2226 {
2227 if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
2228 goto error_return;
2229 }
2230 else
2231 {
2232 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
2233 goto error_return;
2234 }
2235 break;
2236
2237 case R_ALPHA_GPRELHIGH:
2238 case R_ALPHA_GPRELLOW:
2239 if (!elf64_alpha_relax_gprelhilo (&info, symval, irel,
2240 r_type == R_ALPHA_GPRELHIGH))
2241 goto error_return;
2242 break;
2243
2244 case R_ALPHA_GOTDTPREL:
2245 case R_ALPHA_GOTTPREL:
2246 BFD_ASSERT(info.gotent != NULL);
2247 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
2248 goto error_return;
2249 break;
2250
2251 case R_ALPHA_TLSGD:
2252 case R_ALPHA_TLSLDM:
2253 BFD_ASSERT(info.gotent != NULL);
2254 if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
2255 r_type == R_ALPHA_TLSGD))
2256 goto error_return;
2257 break;
2258 }
2259 }
2260
2261 if (!elf64_alpha_size_plt_section (link_info))
2262 return FALSE;
2263 if (!elf64_alpha_size_got_sections (link_info))
2264 return FALSE;
2265 if (!elf64_alpha_size_rela_got_section (link_info))
2266 return FALSE;
2267
2268 if (isymbuf != NULL
2269 && symtab_hdr->contents != (unsigned char *) isymbuf)
2270 {
2271 if (!link_info->keep_memory)
2272 free (isymbuf);
2273 else
2274 {
2275 /* Cache the symbols for elf_link_input_bfd. */
2276 symtab_hdr->contents = (unsigned char *) isymbuf;
2277 }
2278 }
2279
2280 if (info.contents != NULL
2281 && elf_section_data (sec)->this_hdr.contents != info.contents)
2282 {
2283 if (!info.changed_contents && !link_info->keep_memory)
2284 free (info.contents);
2285 else
2286 {
2287 /* Cache the section contents for elf_link_input_bfd. */
2288 elf_section_data (sec)->this_hdr.contents = info.contents;
2289 }
2290 }
2291
2292 if (elf_section_data (sec)->relocs != internal_relocs)
2293 {
2294 if (!info.changed_relocs)
2295 free (internal_relocs);
2296 else
2297 elf_section_data (sec)->relocs = internal_relocs;
2298 }
2299
2300 *again = info.changed_contents || info.changed_relocs;
2301
2302 return TRUE;
2303
2304 error_return:
2305 if (isymbuf != NULL
2306 && symtab_hdr->contents != (unsigned char *) isymbuf)
2307 free (isymbuf);
2308 if (info.contents != NULL
2309 && elf_section_data (sec)->this_hdr.contents != info.contents)
2310 free (info.contents);
2311 if (internal_relocs != NULL
2312 && elf_section_data (sec)->relocs != internal_relocs)
2313 free (internal_relocs);
2314 return FALSE;
2315 }
2316 \f
2317 /* PLT/GOT Stuff */
2318 #define PLT_HEADER_SIZE 32
2319 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
2320 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
2321 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
2322 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
2323
2324 #define PLT_ENTRY_SIZE 12
2325 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
2326 #define PLT_ENTRY_WORD2 0
2327 #define PLT_ENTRY_WORD3 0
2328
2329 #define MAX_GOT_SIZE (64*1024)
2330
2331 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
2332 \f
2333 /* Handle an Alpha specific section when reading an object file. This
2334 is called when elfcode.h finds a section with an unknown type.
2335 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
2336 how to. */
2337
2338 static bfd_boolean
2339 elf64_alpha_section_from_shdr (abfd, hdr, name)
2340 bfd *abfd;
2341 Elf_Internal_Shdr *hdr;
2342 const char *name;
2343 {
2344 asection *newsect;
2345
2346 /* There ought to be a place to keep ELF backend specific flags, but
2347 at the moment there isn't one. We just keep track of the
2348 sections by their name, instead. Fortunately, the ABI gives
2349 suggested names for all the MIPS specific sections, so we will
2350 probably get away with this. */
2351 switch (hdr->sh_type)
2352 {
2353 case SHT_ALPHA_DEBUG:
2354 if (strcmp (name, ".mdebug") != 0)
2355 return FALSE;
2356 break;
2357 default:
2358 return FALSE;
2359 }
2360
2361 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2362 return FALSE;
2363 newsect = hdr->bfd_section;
2364
2365 if (hdr->sh_type == SHT_ALPHA_DEBUG)
2366 {
2367 if (! bfd_set_section_flags (abfd, newsect,
2368 (bfd_get_section_flags (abfd, newsect)
2369 | SEC_DEBUGGING)))
2370 return FALSE;
2371 }
2372
2373 return TRUE;
2374 }
2375
2376 /* Convert Alpha specific section flags to bfd internal section flags. */
2377
2378 static bfd_boolean
2379 elf64_alpha_section_flags (flags, hdr)
2380 flagword *flags;
2381 Elf_Internal_Shdr *hdr;
2382 {
2383 if (hdr->sh_flags & SHF_ALPHA_GPREL)
2384 *flags |= SEC_SMALL_DATA;
2385
2386 return TRUE;
2387 }
2388
2389 /* Set the correct type for an Alpha ELF section. We do this by the
2390 section name, which is a hack, but ought to work. */
2391
2392 static bfd_boolean
2393 elf64_alpha_fake_sections (abfd, hdr, sec)
2394 bfd *abfd;
2395 Elf_Internal_Shdr *hdr;
2396 asection *sec;
2397 {
2398 register const char *name;
2399
2400 name = bfd_get_section_name (abfd, sec);
2401
2402 if (strcmp (name, ".mdebug") == 0)
2403 {
2404 hdr->sh_type = SHT_ALPHA_DEBUG;
2405 /* In a shared object on Irix 5.3, the .mdebug section has an
2406 entsize of 0. FIXME: Does this matter? */
2407 if ((abfd->flags & DYNAMIC) != 0 )
2408 hdr->sh_entsize = 0;
2409 else
2410 hdr->sh_entsize = 1;
2411 }
2412 else if ((sec->flags & SEC_SMALL_DATA)
2413 || strcmp (name, ".sdata") == 0
2414 || strcmp (name, ".sbss") == 0
2415 || strcmp (name, ".lit4") == 0
2416 || strcmp (name, ".lit8") == 0)
2417 hdr->sh_flags |= SHF_ALPHA_GPREL;
2418
2419 return TRUE;
2420 }
2421
2422 /* Hook called by the linker routine which adds symbols from an object
2423 file. We use it to put .comm items in .sbss, and not .bss. */
2424
2425 static bfd_boolean
2426 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2427 bfd *abfd;
2428 struct bfd_link_info *info;
2429 const Elf_Internal_Sym *sym;
2430 const char **namep ATTRIBUTE_UNUSED;
2431 flagword *flagsp ATTRIBUTE_UNUSED;
2432 asection **secp;
2433 bfd_vma *valp;
2434 {
2435 if (sym->st_shndx == SHN_COMMON
2436 && !info->relocatable
2437 && sym->st_size <= elf_gp_size (abfd))
2438 {
2439 /* Common symbols less than or equal to -G nn bytes are
2440 automatically put into .sbss. */
2441
2442 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
2443
2444 if (scomm == NULL)
2445 {
2446 scomm = bfd_make_section (abfd, ".scommon");
2447 if (scomm == NULL
2448 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
2449 | SEC_IS_COMMON
2450 | SEC_LINKER_CREATED)))
2451 return FALSE;
2452 }
2453
2454 *secp = scomm;
2455 *valp = sym->st_size;
2456 }
2457
2458 return TRUE;
2459 }
2460
2461 /* Create the .got section. */
2462
2463 static bfd_boolean
2464 elf64_alpha_create_got_section(abfd, info)
2465 bfd *abfd;
2466 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2467 {
2468 asection *s;
2469
2470 if (bfd_get_section_by_name (abfd, ".got"))
2471 return TRUE;
2472
2473 s = bfd_make_section (abfd, ".got");
2474 if (s == NULL
2475 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
2476 | SEC_HAS_CONTENTS
2477 | SEC_IN_MEMORY
2478 | SEC_LINKER_CREATED))
2479 || !bfd_set_section_alignment (abfd, s, 3))
2480 return FALSE;
2481
2482 alpha_elf_tdata (abfd)->got = s;
2483
2484 return TRUE;
2485 }
2486
2487 /* Create all the dynamic sections. */
2488
2489 static bfd_boolean
2490 elf64_alpha_create_dynamic_sections (abfd, info)
2491 bfd *abfd;
2492 struct bfd_link_info *info;
2493 {
2494 asection *s;
2495 struct elf_link_hash_entry *h;
2496 struct bfd_link_hash_entry *bh;
2497
2498 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
2499
2500 s = bfd_make_section (abfd, ".plt");
2501 if (s == NULL
2502 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
2503 | SEC_HAS_CONTENTS
2504 | SEC_IN_MEMORY
2505 | SEC_LINKER_CREATED
2506 | SEC_CODE))
2507 || ! bfd_set_section_alignment (abfd, s, 3))
2508 return FALSE;
2509
2510 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2511 .plt section. */
2512 bh = NULL;
2513 if (! (_bfd_generic_link_add_one_symbol
2514 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2515 (bfd_vma) 0, (const char *) NULL, FALSE,
2516 get_elf_backend_data (abfd)->collect, &bh)))
2517 return FALSE;
2518 h = (struct elf_link_hash_entry *) bh;
2519 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2520 h->type = STT_OBJECT;
2521
2522 if (info->shared
2523 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2524 return FALSE;
2525
2526 s = bfd_make_section (abfd, ".rela.plt");
2527 if (s == NULL
2528 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
2529 | SEC_HAS_CONTENTS
2530 | SEC_IN_MEMORY
2531 | SEC_LINKER_CREATED
2532 | SEC_READONLY))
2533 || ! bfd_set_section_alignment (abfd, s, 3))
2534 return FALSE;
2535
2536 /* We may or may not have created a .got section for this object, but
2537 we definitely havn't done the rest of the work. */
2538
2539 if (!elf64_alpha_create_got_section (abfd, info))
2540 return FALSE;
2541
2542 s = bfd_make_section(abfd, ".rela.got");
2543 if (s == NULL
2544 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
2545 | SEC_HAS_CONTENTS
2546 | SEC_IN_MEMORY
2547 | SEC_LINKER_CREATED
2548 | SEC_READONLY))
2549 || !bfd_set_section_alignment (abfd, s, 3))
2550 return FALSE;
2551
2552 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
2553 dynobj's .got section. We don't do this in the linker script
2554 because we don't want to define the symbol if we are not creating
2555 a global offset table. */
2556 bh = NULL;
2557 if (!(_bfd_generic_link_add_one_symbol
2558 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
2559 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
2560 FALSE, get_elf_backend_data (abfd)->collect, &bh)))
2561 return FALSE;
2562 h = (struct elf_link_hash_entry *) bh;
2563 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2564 h->type = STT_OBJECT;
2565
2566 if (info->shared
2567 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2568 return FALSE;
2569
2570 elf_hash_table (info)->hgot = h;
2571
2572 return TRUE;
2573 }
2574 \f
2575 /* Read ECOFF debugging information from a .mdebug section into a
2576 ecoff_debug_info structure. */
2577
2578 static bfd_boolean
2579 elf64_alpha_read_ecoff_info (abfd, section, debug)
2580 bfd *abfd;
2581 asection *section;
2582 struct ecoff_debug_info *debug;
2583 {
2584 HDRR *symhdr;
2585 const struct ecoff_debug_swap *swap;
2586 char *ext_hdr = NULL;
2587
2588 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2589 memset (debug, 0, sizeof (*debug));
2590
2591 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
2592 if (ext_hdr == NULL && swap->external_hdr_size != 0)
2593 goto error_return;
2594
2595 if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
2596 swap->external_hdr_size))
2597 goto error_return;
2598
2599 symhdr = &debug->symbolic_header;
2600 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
2601
2602 /* The symbolic header contains absolute file offsets and sizes to
2603 read. */
2604 #define READ(ptr, offset, count, size, type) \
2605 if (symhdr->count == 0) \
2606 debug->ptr = NULL; \
2607 else \
2608 { \
2609 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
2610 debug->ptr = (type) bfd_malloc (amt); \
2611 if (debug->ptr == NULL) \
2612 goto error_return; \
2613 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2614 || bfd_bread (debug->ptr, amt, abfd) != amt) \
2615 goto error_return; \
2616 }
2617
2618 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
2619 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
2620 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
2621 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
2622 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
2623 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
2624 union aux_ext *);
2625 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
2626 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
2627 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
2628 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
2629 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
2630 #undef READ
2631
2632 debug->fdr = NULL;
2633 debug->adjust = NULL;
2634
2635 return TRUE;
2636
2637 error_return:
2638 if (ext_hdr != NULL)
2639 free (ext_hdr);
2640 if (debug->line != NULL)
2641 free (debug->line);
2642 if (debug->external_dnr != NULL)
2643 free (debug->external_dnr);
2644 if (debug->external_pdr != NULL)
2645 free (debug->external_pdr);
2646 if (debug->external_sym != NULL)
2647 free (debug->external_sym);
2648 if (debug->external_opt != NULL)
2649 free (debug->external_opt);
2650 if (debug->external_aux != NULL)
2651 free (debug->external_aux);
2652 if (debug->ss != NULL)
2653 free (debug->ss);
2654 if (debug->ssext != NULL)
2655 free (debug->ssext);
2656 if (debug->external_fdr != NULL)
2657 free (debug->external_fdr);
2658 if (debug->external_rfd != NULL)
2659 free (debug->external_rfd);
2660 if (debug->external_ext != NULL)
2661 free (debug->external_ext);
2662 return FALSE;
2663 }
2664
2665 /* Alpha ELF local labels start with '$'. */
2666
2667 static bfd_boolean
2668 elf64_alpha_is_local_label_name (abfd, name)
2669 bfd *abfd ATTRIBUTE_UNUSED;
2670 const char *name;
2671 {
2672 return name[0] == '$';
2673 }
2674
2675 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2676 routine in order to handle the ECOFF debugging information. We
2677 still call this mips_elf_find_line because of the slot
2678 find_line_info in elf_obj_tdata is declared that way. */
2679
2680 struct mips_elf_find_line
2681 {
2682 struct ecoff_debug_info d;
2683 struct ecoff_find_line i;
2684 };
2685
2686 static bfd_boolean
2687 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2688 functionname_ptr, line_ptr)
2689 bfd *abfd;
2690 asection *section;
2691 asymbol **symbols;
2692 bfd_vma offset;
2693 const char **filename_ptr;
2694 const char **functionname_ptr;
2695 unsigned int *line_ptr;
2696 {
2697 asection *msec;
2698
2699 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2700 filename_ptr, functionname_ptr,
2701 line_ptr, 0,
2702 &elf_tdata (abfd)->dwarf2_find_line_info))
2703 return TRUE;
2704
2705 msec = bfd_get_section_by_name (abfd, ".mdebug");
2706 if (msec != NULL)
2707 {
2708 flagword origflags;
2709 struct mips_elf_find_line *fi;
2710 const struct ecoff_debug_swap * const swap =
2711 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2712
2713 /* If we are called during a link, alpha_elf_final_link may have
2714 cleared the SEC_HAS_CONTENTS field. We force it back on here
2715 if appropriate (which it normally will be). */
2716 origflags = msec->flags;
2717 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2718 msec->flags |= SEC_HAS_CONTENTS;
2719
2720 fi = elf_tdata (abfd)->find_line_info;
2721 if (fi == NULL)
2722 {
2723 bfd_size_type external_fdr_size;
2724 char *fraw_src;
2725 char *fraw_end;
2726 struct fdr *fdr_ptr;
2727 bfd_size_type amt = sizeof (struct mips_elf_find_line);
2728
2729 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
2730 if (fi == NULL)
2731 {
2732 msec->flags = origflags;
2733 return FALSE;
2734 }
2735
2736 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2737 {
2738 msec->flags = origflags;
2739 return FALSE;
2740 }
2741
2742 /* Swap in the FDR information. */
2743 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2744 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
2745 if (fi->d.fdr == NULL)
2746 {
2747 msec->flags = origflags;
2748 return FALSE;
2749 }
2750 external_fdr_size = swap->external_fdr_size;
2751 fdr_ptr = fi->d.fdr;
2752 fraw_src = (char *) fi->d.external_fdr;
2753 fraw_end = (fraw_src
2754 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2755 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2756 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2757
2758 elf_tdata (abfd)->find_line_info = fi;
2759
2760 /* Note that we don't bother to ever free this information.
2761 find_nearest_line is either called all the time, as in
2762 objdump -l, so the information should be saved, or it is
2763 rarely called, as in ld error messages, so the memory
2764 wasted is unimportant. Still, it would probably be a
2765 good idea for free_cached_info to throw it away. */
2766 }
2767
2768 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2769 &fi->i, filename_ptr, functionname_ptr,
2770 line_ptr))
2771 {
2772 msec->flags = origflags;
2773 return TRUE;
2774 }
2775
2776 msec->flags = origflags;
2777 }
2778
2779 /* Fall back on the generic ELF find_nearest_line routine. */
2780
2781 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2782 filename_ptr, functionname_ptr,
2783 line_ptr);
2784 }
2785 \f
2786 /* Structure used to pass information to alpha_elf_output_extsym. */
2787
2788 struct extsym_info
2789 {
2790 bfd *abfd;
2791 struct bfd_link_info *info;
2792 struct ecoff_debug_info *debug;
2793 const struct ecoff_debug_swap *swap;
2794 bfd_boolean failed;
2795 };
2796
2797 static bfd_boolean
2798 elf64_alpha_output_extsym (h, data)
2799 struct alpha_elf_link_hash_entry *h;
2800 PTR data;
2801 {
2802 struct extsym_info *einfo = (struct extsym_info *) data;
2803 bfd_boolean strip;
2804 asection *sec, *output_section;
2805
2806 if (h->root.root.type == bfd_link_hash_warning)
2807 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2808
2809 if (h->root.indx == -2)
2810 strip = FALSE;
2811 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2812 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2813 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2814 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2815 strip = TRUE;
2816 else if (einfo->info->strip == strip_all
2817 || (einfo->info->strip == strip_some
2818 && bfd_hash_lookup (einfo->info->keep_hash,
2819 h->root.root.root.string,
2820 FALSE, FALSE) == NULL))
2821 strip = TRUE;
2822 else
2823 strip = FALSE;
2824
2825 if (strip)
2826 return TRUE;
2827
2828 if (h->esym.ifd == -2)
2829 {
2830 h->esym.jmptbl = 0;
2831 h->esym.cobol_main = 0;
2832 h->esym.weakext = 0;
2833 h->esym.reserved = 0;
2834 h->esym.ifd = ifdNil;
2835 h->esym.asym.value = 0;
2836 h->esym.asym.st = stGlobal;
2837
2838 if (h->root.root.type != bfd_link_hash_defined
2839 && h->root.root.type != bfd_link_hash_defweak)
2840 h->esym.asym.sc = scAbs;
2841 else
2842 {
2843 const char *name;
2844
2845 sec = h->root.root.u.def.section;
2846 output_section = sec->output_section;
2847
2848 /* When making a shared library and symbol h is the one from
2849 the another shared library, OUTPUT_SECTION may be null. */
2850 if (output_section == NULL)
2851 h->esym.asym.sc = scUndefined;
2852 else
2853 {
2854 name = bfd_section_name (output_section->owner, output_section);
2855
2856 if (strcmp (name, ".text") == 0)
2857 h->esym.asym.sc = scText;
2858 else if (strcmp (name, ".data") == 0)
2859 h->esym.asym.sc = scData;
2860 else if (strcmp (name, ".sdata") == 0)
2861 h->esym.asym.sc = scSData;
2862 else if (strcmp (name, ".rodata") == 0
2863 || strcmp (name, ".rdata") == 0)
2864 h->esym.asym.sc = scRData;
2865 else if (strcmp (name, ".bss") == 0)
2866 h->esym.asym.sc = scBss;
2867 else if (strcmp (name, ".sbss") == 0)
2868 h->esym.asym.sc = scSBss;
2869 else if (strcmp (name, ".init") == 0)
2870 h->esym.asym.sc = scInit;
2871 else if (strcmp (name, ".fini") == 0)
2872 h->esym.asym.sc = scFini;
2873 else
2874 h->esym.asym.sc = scAbs;
2875 }
2876 }
2877
2878 h->esym.asym.reserved = 0;
2879 h->esym.asym.index = indexNil;
2880 }
2881
2882 if (h->root.root.type == bfd_link_hash_common)
2883 h->esym.asym.value = h->root.root.u.c.size;
2884 else if (h->root.root.type == bfd_link_hash_defined
2885 || h->root.root.type == bfd_link_hash_defweak)
2886 {
2887 if (h->esym.asym.sc == scCommon)
2888 h->esym.asym.sc = scBss;
2889 else if (h->esym.asym.sc == scSCommon)
2890 h->esym.asym.sc = scSBss;
2891
2892 sec = h->root.root.u.def.section;
2893 output_section = sec->output_section;
2894 if (output_section != NULL)
2895 h->esym.asym.value = (h->root.root.u.def.value
2896 + sec->output_offset
2897 + output_section->vma);
2898 else
2899 h->esym.asym.value = 0;
2900 }
2901 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2902 {
2903 /* Set type and value for a symbol with a function stub. */
2904 h->esym.asym.st = stProc;
2905 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2906 if (sec == NULL)
2907 h->esym.asym.value = 0;
2908 else
2909 {
2910 output_section = sec->output_section;
2911 if (output_section != NULL)
2912 h->esym.asym.value = (h->root.plt.offset
2913 + sec->output_offset
2914 + output_section->vma);
2915 else
2916 h->esym.asym.value = 0;
2917 }
2918 }
2919
2920 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2921 h->root.root.root.string,
2922 &h->esym))
2923 {
2924 einfo->failed = TRUE;
2925 return FALSE;
2926 }
2927
2928 return TRUE;
2929 }
2930 \f
2931 /* Search for and possibly create a got entry. */
2932
2933 static struct alpha_elf_got_entry *
2934 get_got_entry (abfd, h, r_type, r_symndx, r_addend)
2935 bfd *abfd;
2936 struct alpha_elf_link_hash_entry *h;
2937 unsigned long r_type, r_symndx;
2938 bfd_vma r_addend;
2939 {
2940 struct alpha_elf_got_entry *gotent;
2941 struct alpha_elf_got_entry **slot;
2942
2943 if (h)
2944 slot = &h->got_entries;
2945 else
2946 {
2947 /* This is a local .got entry -- record for merge. */
2948
2949 struct alpha_elf_got_entry **local_got_entries;
2950
2951 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2952 if (!local_got_entries)
2953 {
2954 bfd_size_type size;
2955 Elf_Internal_Shdr *symtab_hdr;
2956
2957 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2958 size = symtab_hdr->sh_info;
2959 size *= sizeof (struct alpha_elf_got_entry *);
2960
2961 local_got_entries
2962 = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
2963 if (!local_got_entries)
2964 return NULL;
2965
2966 alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
2967 }
2968
2969 slot = &local_got_entries[r_symndx];
2970 }
2971
2972 for (gotent = *slot; gotent ; gotent = gotent->next)
2973 if (gotent->gotobj == abfd
2974 && gotent->reloc_type == r_type
2975 && gotent->addend == r_addend)
2976 break;
2977
2978 if (!gotent)
2979 {
2980 int entry_size;
2981 bfd_size_type amt;
2982
2983 amt = sizeof (struct alpha_elf_got_entry);
2984 gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
2985 if (!gotent)
2986 return NULL;
2987
2988 gotent->gotobj = abfd;
2989 gotent->addend = r_addend;
2990 gotent->got_offset = -1;
2991 gotent->use_count = 1;
2992 gotent->reloc_type = r_type;
2993 gotent->reloc_done = 0;
2994 gotent->reloc_xlated = 0;
2995
2996 gotent->next = *slot;
2997 *slot = gotent;
2998
2999 entry_size = alpha_got_entry_size (r_type);
3000 alpha_elf_tdata (abfd)->total_got_size += entry_size;
3001 if (!h)
3002 alpha_elf_tdata(abfd)->local_got_size += entry_size;
3003 }
3004 else
3005 gotent->use_count += 1;
3006
3007 return gotent;
3008 }
3009
3010 /* Handle dynamic relocations when doing an Alpha ELF link. */
3011
3012 static bfd_boolean
3013 elf64_alpha_check_relocs (abfd, info, sec, relocs)
3014 bfd *abfd;
3015 struct bfd_link_info *info;
3016 asection *sec;
3017 const Elf_Internal_Rela *relocs;
3018 {
3019 bfd *dynobj;
3020 asection *sreloc;
3021 const char *rel_sec_name;
3022 Elf_Internal_Shdr *symtab_hdr;
3023 struct alpha_elf_link_hash_entry **sym_hashes;
3024 const Elf_Internal_Rela *rel, *relend;
3025 bfd_boolean got_created;
3026 bfd_size_type amt;
3027
3028 if (info->relocatable)
3029 return TRUE;
3030
3031 dynobj = elf_hash_table(info)->dynobj;
3032 if (dynobj == NULL)
3033 elf_hash_table(info)->dynobj = dynobj = abfd;
3034
3035 sreloc = NULL;
3036 rel_sec_name = NULL;
3037 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
3038 sym_hashes = alpha_elf_sym_hashes(abfd);
3039 got_created = FALSE;
3040
3041 relend = relocs + sec->reloc_count;
3042 for (rel = relocs; rel < relend; ++rel)
3043 {
3044 enum {
3045 NEED_GOT = 1,
3046 NEED_GOT_ENTRY = 2,
3047 NEED_DYNREL = 4
3048 };
3049
3050 unsigned long r_symndx, r_type;
3051 struct alpha_elf_link_hash_entry *h;
3052 unsigned int gotent_flags;
3053 bfd_boolean maybe_dynamic;
3054 unsigned int need;
3055 bfd_vma addend;
3056
3057 r_symndx = ELF64_R_SYM (rel->r_info);
3058 if (r_symndx < symtab_hdr->sh_info)
3059 h = NULL;
3060 else
3061 {
3062 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3063
3064 while (h->root.root.type == bfd_link_hash_indirect
3065 || h->root.root.type == bfd_link_hash_warning)
3066 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3067
3068 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
3069 }
3070
3071 /* We can only get preliminary data on whether a symbol is
3072 locally or externally defined, as not all of the input files
3073 have yet been processed. Do something with what we know, as
3074 this may help reduce memory usage and processing time later. */
3075 maybe_dynamic = FALSE;
3076 if (h && ((info->shared
3077 && (!info->symbolic || info->allow_shlib_undefined))
3078 || ! (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
3079 || h->root.root.type == bfd_link_hash_defweak))
3080 maybe_dynamic = TRUE;
3081
3082 need = 0;
3083 gotent_flags = 0;
3084 r_type = ELF64_R_TYPE (rel->r_info);
3085 addend = rel->r_addend;
3086
3087 switch (r_type)
3088 {
3089 case R_ALPHA_LITERAL:
3090 need = NEED_GOT | NEED_GOT_ENTRY;
3091
3092 /* Remember how this literal is used from its LITUSEs.
3093 This will be important when it comes to decide if we can
3094 create a .plt entry for a function symbol. */
3095 while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
3096 if (rel->r_addend >= 1 && rel->r_addend <= 5)
3097 gotent_flags |= 1 << rel->r_addend;
3098 --rel;
3099
3100 /* No LITUSEs -- presumably the address is used somehow. */
3101 if (gotent_flags == 0)
3102 gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
3103 break;
3104
3105 case R_ALPHA_GPDISP:
3106 case R_ALPHA_GPREL16:
3107 case R_ALPHA_GPREL32:
3108 case R_ALPHA_GPRELHIGH:
3109 case R_ALPHA_GPRELLOW:
3110 case R_ALPHA_BRSGP:
3111 need = NEED_GOT;
3112 break;
3113
3114 case R_ALPHA_REFLONG:
3115 case R_ALPHA_REFQUAD:
3116 if ((info->shared && (sec->flags & SEC_ALLOC)) || maybe_dynamic)
3117 need = NEED_DYNREL;
3118 break;
3119
3120 case R_ALPHA_TLSLDM:
3121 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3122 reloc to the 0 symbol so that they all match. */
3123 r_symndx = 0;
3124 h = 0;
3125 maybe_dynamic = FALSE;
3126 /* FALLTHRU */
3127
3128 case R_ALPHA_TLSGD:
3129 case R_ALPHA_GOTDTPREL:
3130 need = NEED_GOT | NEED_GOT_ENTRY;
3131 break;
3132
3133 case R_ALPHA_GOTTPREL:
3134 need = NEED_GOT | NEED_GOT_ENTRY;
3135 gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
3136 if (info->shared)
3137 info->flags |= DF_STATIC_TLS;
3138 break;
3139
3140 case R_ALPHA_TPREL64:
3141 if (info->shared || maybe_dynamic)
3142 need = NEED_DYNREL;
3143 if (info->shared)
3144 info->flags |= DF_STATIC_TLS;
3145 break;
3146 }
3147
3148 if (need & NEED_GOT)
3149 {
3150 if (!got_created)
3151 {
3152 if (!elf64_alpha_create_got_section (abfd, info))
3153 return FALSE;
3154
3155 /* Make sure the object's gotobj is set to itself so
3156 that we default to every object with its own .got.
3157 We'll merge .gots later once we've collected each
3158 object's info. */
3159 alpha_elf_tdata(abfd)->gotobj = abfd;
3160
3161 got_created = 1;
3162 }
3163 }
3164
3165 if (need & NEED_GOT_ENTRY)
3166 {
3167 struct alpha_elf_got_entry *gotent;
3168
3169 gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
3170 if (!gotent)
3171 return FALSE;
3172
3173 if (gotent_flags)
3174 {
3175 gotent->flags |= gotent_flags;
3176 if (h)
3177 {
3178 gotent_flags |= h->flags;
3179 h->flags = gotent_flags;
3180
3181 /* Make a guess as to whether a .plt entry is needed. */
3182 if ((gotent_flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
3183 && !(gotent_flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC))
3184 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3185 else
3186 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3187 }
3188 }
3189 }
3190
3191 if (need & NEED_DYNREL)
3192 {
3193 if (rel_sec_name == NULL)
3194 {
3195 rel_sec_name = (bfd_elf_string_from_elf_section
3196 (abfd, elf_elfheader(abfd)->e_shstrndx,
3197 elf_section_data(sec)->rel_hdr.sh_name));
3198 if (rel_sec_name == NULL)
3199 return FALSE;
3200
3201 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
3202 && strcmp (bfd_get_section_name (abfd, sec),
3203 rel_sec_name+5) == 0);
3204 }
3205
3206 /* We need to create the section here now whether we eventually
3207 use it or not so that it gets mapped to an output section by
3208 the linker. If not used, we'll kill it in
3209 size_dynamic_sections. */
3210 if (sreloc == NULL)
3211 {
3212 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
3213 if (sreloc == NULL)
3214 {
3215 flagword flags;
3216
3217 sreloc = bfd_make_section (dynobj, rel_sec_name);
3218 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
3219 | SEC_LINKER_CREATED | SEC_READONLY);
3220 if (sec->flags & SEC_ALLOC)
3221 flags |= SEC_ALLOC | SEC_LOAD;
3222 if (sreloc == NULL
3223 || !bfd_set_section_flags (dynobj, sreloc, flags)
3224 || !bfd_set_section_alignment (dynobj, sreloc, 3))
3225 return FALSE;
3226 }
3227 }
3228
3229 if (h)
3230 {
3231 /* Since we havn't seen all of the input symbols yet, we
3232 don't know whether we'll actually need a dynamic relocation
3233 entry for this reloc. So make a record of it. Once we
3234 find out if this thing needs dynamic relocation we'll
3235 expand the relocation sections by the appropriate amount. */
3236
3237 struct alpha_elf_reloc_entry *rent;
3238
3239 for (rent = h->reloc_entries; rent; rent = rent->next)
3240 if (rent->rtype == r_type && rent->srel == sreloc)
3241 break;
3242
3243 if (!rent)
3244 {
3245 amt = sizeof (struct alpha_elf_reloc_entry);
3246 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
3247 if (!rent)
3248 return FALSE;
3249
3250 rent->srel = sreloc;
3251 rent->rtype = r_type;
3252 rent->count = 1;
3253 rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC))
3254 == (SEC_READONLY | SEC_ALLOC));
3255
3256 rent->next = h->reloc_entries;
3257 h->reloc_entries = rent;
3258 }
3259 else
3260 rent->count++;
3261 }
3262 else if (info->shared)
3263 {
3264 /* If this is a shared library, and the section is to be
3265 loaded into memory, we need a RELATIVE reloc. */
3266 sreloc->_raw_size += sizeof (Elf64_External_Rela);
3267 if ((sec->flags & (SEC_READONLY | SEC_ALLOC))
3268 == (SEC_READONLY | SEC_ALLOC))
3269 info->flags |= DF_TEXTREL;
3270 }
3271 }
3272 }
3273
3274 return TRUE;
3275 }
3276
3277 /* Adjust a symbol defined by a dynamic object and referenced by a
3278 regular object. The current definition is in some section of the
3279 dynamic object, but we're not including those sections. We have to
3280 change the definition to something the rest of the link can
3281 understand. */
3282
3283 static bfd_boolean
3284 elf64_alpha_adjust_dynamic_symbol (info, h)
3285 struct bfd_link_info *info;
3286 struct elf_link_hash_entry *h;
3287 {
3288 bfd *dynobj;
3289 asection *s;
3290 struct alpha_elf_link_hash_entry *ah;
3291
3292 dynobj = elf_hash_table(info)->dynobj;
3293 ah = (struct alpha_elf_link_hash_entry *)h;
3294
3295 /* Now that we've seen all of the input symbols, finalize our decision
3296 about whether this symbol should get a .plt entry. */
3297
3298 if (alpha_elf_dynamic_symbol_p (h, info)
3299 && ((h->type == STT_FUNC
3300 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
3301 || (h->type == STT_NOTYPE
3302 && (ah->flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
3303 && !(ah->flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC)))
3304 /* Don't prevent otherwise valid programs from linking by attempting
3305 to create a new .got entry somewhere. A Correct Solution would be
3306 to add a new .got section to a new object file and let it be merged
3307 somewhere later. But for now don't bother. */
3308 && ah->got_entries)
3309 {
3310 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3311
3312 s = bfd_get_section_by_name(dynobj, ".plt");
3313 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
3314 return FALSE;
3315
3316 /* The first bit of the .plt is reserved. */
3317 if (s->_raw_size == 0)
3318 s->_raw_size = PLT_HEADER_SIZE;
3319
3320 h->plt.offset = s->_raw_size;
3321 s->_raw_size += PLT_ENTRY_SIZE;
3322
3323 /* If this symbol is not defined in a regular file, and we are not
3324 generating a shared library, then set the symbol to the location
3325 in the .plt. This is required to make function pointers compare
3326 equal between the normal executable and the shared library. */
3327 if (! info->shared
3328 && h->root.type != bfd_link_hash_defweak)
3329 {
3330 ah->plt_old_section = h->root.u.def.section;
3331 ah->plt_old_value = h->root.u.def.value;
3332 ah->flags |= ALPHA_ELF_LINK_HASH_PLT_LOC;
3333 h->root.u.def.section = s;
3334 h->root.u.def.value = h->plt.offset;
3335 }
3336
3337 /* We also need a JMP_SLOT entry in the .rela.plt section. */
3338 s = bfd_get_section_by_name (dynobj, ".rela.plt");
3339 BFD_ASSERT (s != NULL);
3340 s->_raw_size += sizeof (Elf64_External_Rela);
3341
3342 return TRUE;
3343 }
3344 else
3345 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3346
3347 /* If this is a weak symbol, and there is a real definition, the
3348 processor independent code will have arranged for us to see the
3349 real definition first, and we can just use the same value. */
3350 if (h->weakdef != NULL)
3351 {
3352 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3353 || h->weakdef->root.type == bfd_link_hash_defweak);
3354 h->root.u.def.section = h->weakdef->root.u.def.section;
3355 h->root.u.def.value = h->weakdef->root.u.def.value;
3356 return TRUE;
3357 }
3358
3359 /* This is a reference to a symbol defined by a dynamic object which
3360 is not a function. The Alpha, since it uses .got entries for all
3361 symbols even in regular objects, does not need the hackery of a
3362 .dynbss section and COPY dynamic relocations. */
3363
3364 return TRUE;
3365 }
3366
3367 /* Symbol versioning can create new symbols, and make our old symbols
3368 indirect to the new ones. Consolidate the got and reloc information
3369 in these situations. */
3370
3371 static bfd_boolean
3372 elf64_alpha_merge_ind_symbols (hi, dummy)
3373 struct alpha_elf_link_hash_entry *hi;
3374 PTR dummy ATTRIBUTE_UNUSED;
3375 {
3376 struct alpha_elf_link_hash_entry *hs;
3377
3378 if (hi->root.root.type != bfd_link_hash_indirect)
3379 return TRUE;
3380 hs = hi;
3381 do {
3382 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
3383 } while (hs->root.root.type == bfd_link_hash_indirect);
3384
3385 /* Merge the flags. Whee. */
3386
3387 hs->flags |= hi->flags;
3388
3389 /* Merge the .got entries. Cannibalize the old symbol's list in
3390 doing so, since we don't need it anymore. */
3391
3392 if (hs->got_entries == NULL)
3393 hs->got_entries = hi->got_entries;
3394 else
3395 {
3396 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
3397
3398 gsh = hs->got_entries;
3399 for (gi = hi->got_entries; gi ; gi = gin)
3400 {
3401 gin = gi->next;
3402 for (gs = gsh; gs ; gs = gs->next)
3403 if (gi->gotobj == gs->gotobj
3404 && gi->reloc_type == gs->reloc_type
3405 && gi->addend == gs->addend)
3406 {
3407 gi->use_count += gs->use_count;
3408 goto got_found;
3409 }
3410 gi->next = hs->got_entries;
3411 hs->got_entries = gi;
3412 got_found:;
3413 }
3414 }
3415 hi->got_entries = NULL;
3416
3417 /* And similar for the reloc entries. */
3418
3419 if (hs->reloc_entries == NULL)
3420 hs->reloc_entries = hi->reloc_entries;
3421 else
3422 {
3423 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
3424
3425 rsh = hs->reloc_entries;
3426 for (ri = hi->reloc_entries; ri ; ri = rin)
3427 {
3428 rin = ri->next;
3429 for (rs = rsh; rs ; rs = rs->next)
3430 if (ri->rtype == rs->rtype && ri->srel == rs->srel)
3431 {
3432 rs->count += ri->count;
3433 goto found_reloc;
3434 }
3435 ri->next = hs->reloc_entries;
3436 hs->reloc_entries = ri;
3437 found_reloc:;
3438 }
3439 }
3440 hi->reloc_entries = NULL;
3441
3442 return TRUE;
3443 }
3444
3445 /* Is it possible to merge two object file's .got tables? */
3446
3447 static bfd_boolean
3448 elf64_alpha_can_merge_gots (a, b)
3449 bfd *a, *b;
3450 {
3451 int total = alpha_elf_tdata (a)->total_got_size;
3452 bfd *bsub;
3453
3454 /* Trivial quick fallout test. */
3455 if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
3456 return TRUE;
3457
3458 /* By their nature, local .got entries cannot be merged. */
3459 if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
3460 return FALSE;
3461
3462 /* Failing the common trivial comparison, we must effectively
3463 perform the merge. Not actually performing the merge means that
3464 we don't have to store undo information in case we fail. */
3465 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
3466 {
3467 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
3468 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
3469 int i, n;
3470
3471 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
3472 for (i = 0; i < n; ++i)
3473 {
3474 struct alpha_elf_got_entry *ae, *be;
3475 struct alpha_elf_link_hash_entry *h;
3476
3477 h = hashes[i];
3478 while (h->root.root.type == bfd_link_hash_indirect
3479 || h->root.root.type == bfd_link_hash_warning)
3480 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3481
3482 for (be = h->got_entries; be ; be = be->next)
3483 {
3484 if (be->use_count == 0)
3485 continue;
3486 if (be->gotobj != b)
3487 continue;
3488
3489 for (ae = h->got_entries; ae ; ae = ae->next)
3490 if (ae->gotobj == a
3491 && ae->reloc_type == be->reloc_type
3492 && ae->addend == be->addend)
3493 goto global_found;
3494
3495 total += alpha_got_entry_size (be->reloc_type);
3496 if (total > MAX_GOT_SIZE)
3497 return FALSE;
3498 global_found:;
3499 }
3500 }
3501 }
3502
3503 return TRUE;
3504 }
3505
3506 /* Actually merge two .got tables. */
3507
3508 static void
3509 elf64_alpha_merge_gots (a, b)
3510 bfd *a, *b;
3511 {
3512 int total = alpha_elf_tdata (a)->total_got_size;
3513 bfd *bsub;
3514
3515 /* Remember local expansion. */
3516 {
3517 int e = alpha_elf_tdata (b)->local_got_size;
3518 total += e;
3519 alpha_elf_tdata (a)->local_got_size += e;
3520 }
3521
3522 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
3523 {
3524 struct alpha_elf_got_entry **local_got_entries;
3525 struct alpha_elf_link_hash_entry **hashes;
3526 Elf_Internal_Shdr *symtab_hdr;
3527 int i, n;
3528
3529 /* Let the local .got entries know they are part of a new subsegment. */
3530 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
3531 if (local_got_entries)
3532 {
3533 n = elf_tdata (bsub)->symtab_hdr.sh_info;
3534 for (i = 0; i < n; ++i)
3535 {
3536 struct alpha_elf_got_entry *ent;
3537 for (ent = local_got_entries[i]; ent; ent = ent->next)
3538 ent->gotobj = a;
3539 }
3540 }
3541
3542 /* Merge the global .got entries. */
3543 hashes = alpha_elf_sym_hashes (bsub);
3544 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
3545
3546 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
3547 for (i = 0; i < n; ++i)
3548 {
3549 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
3550 struct alpha_elf_link_hash_entry *h;
3551
3552 h = hashes[i];
3553 while (h->root.root.type == bfd_link_hash_indirect
3554 || h->root.root.type == bfd_link_hash_warning)
3555 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3556
3557 start = &h->got_entries;
3558 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
3559 {
3560 if (be->use_count == 0)
3561 {
3562 *pbe = be->next;
3563 continue;
3564 }
3565 if (be->gotobj != b)
3566 continue;
3567
3568 for (ae = *start; ae ; ae = ae->next)
3569 if (ae->gotobj == a
3570 && ae->reloc_type == be->reloc_type
3571 && ae->addend == be->addend)
3572 {
3573 ae->flags |= be->flags;
3574 ae->use_count += be->use_count;
3575 *pbe = be->next;
3576 goto global_found;
3577 }
3578 be->gotobj = a;
3579 total += alpha_got_entry_size (be->reloc_type);
3580
3581 global_found:;
3582 }
3583 }
3584
3585 alpha_elf_tdata (bsub)->gotobj = a;
3586 }
3587 alpha_elf_tdata (a)->total_got_size = total;
3588
3589 /* Merge the two in_got chains. */
3590 {
3591 bfd *next;
3592
3593 bsub = a;
3594 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
3595 bsub = next;
3596
3597 alpha_elf_tdata (bsub)->in_got_link_next = b;
3598 }
3599 }
3600
3601 /* Calculate the offsets for the got entries. */
3602
3603 static bfd_boolean
3604 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
3605 struct alpha_elf_link_hash_entry *h;
3606 PTR arg ATTRIBUTE_UNUSED;
3607 {
3608 struct alpha_elf_got_entry *gotent;
3609
3610 if (h->root.root.type == bfd_link_hash_warning)
3611 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3612
3613 for (gotent = h->got_entries; gotent; gotent = gotent->next)
3614 if (gotent->use_count > 0)
3615 {
3616 bfd_size_type *plge
3617 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
3618
3619 gotent->got_offset = *plge;
3620 *plge += alpha_got_entry_size (gotent->reloc_type);
3621 }
3622
3623 return TRUE;
3624 }
3625
3626 static void
3627 elf64_alpha_calc_got_offsets (info)
3628 struct bfd_link_info *info;
3629 {
3630 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
3631
3632 /* First, zero out the .got sizes, as we may be recalculating the
3633 .got after optimizing it. */
3634 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
3635 alpha_elf_tdata(i)->got->_raw_size = 0;
3636
3637 /* Next, fill in the offsets for all the global entries. */
3638 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3639 elf64_alpha_calc_got_offsets_for_symbol,
3640 NULL);
3641
3642 /* Finally, fill in the offsets for the local entries. */
3643 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
3644 {
3645 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
3646 bfd *j;
3647
3648 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
3649 {
3650 struct alpha_elf_got_entry **local_got_entries, *gotent;
3651 int k, n;
3652
3653 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
3654 if (!local_got_entries)
3655 continue;
3656
3657 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3658 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
3659 if (gotent->use_count > 0)
3660 {
3661 gotent->got_offset = got_offset;
3662 got_offset += alpha_got_entry_size (gotent->reloc_type);
3663 }
3664 }
3665
3666 alpha_elf_tdata(i)->got->_raw_size = got_offset;
3667 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
3668 }
3669 }
3670
3671 /* Constructs the gots. */
3672
3673 static bfd_boolean
3674 elf64_alpha_size_got_sections (info)
3675 struct bfd_link_info *info;
3676 {
3677 bfd *i, *got_list, *cur_got_obj = NULL;
3678 int something_changed = 0;
3679
3680 got_list = alpha_elf_hash_table (info)->got_list;
3681
3682 /* On the first time through, pretend we have an existing got list
3683 consisting of all of the input files. */
3684 if (got_list == NULL)
3685 {
3686 for (i = info->input_bfds; i ; i = i->link_next)
3687 {
3688 bfd *this_got = alpha_elf_tdata (i)->gotobj;
3689 if (this_got == NULL)
3690 continue;
3691
3692 /* We are assuming no merging has yet ocurred. */
3693 BFD_ASSERT (this_got == i);
3694
3695 if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
3696 {
3697 /* Yikes! A single object file has too many entries. */
3698 (*_bfd_error_handler)
3699 (_("%s: .got subsegment exceeds 64K (size %d)"),
3700 bfd_archive_filename (i),
3701 alpha_elf_tdata (this_got)->total_got_size);
3702 return FALSE;
3703 }
3704
3705 if (got_list == NULL)
3706 got_list = this_got;
3707 else
3708 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3709 cur_got_obj = this_got;
3710 }
3711
3712 /* Strange degenerate case of no got references. */
3713 if (got_list == NULL)
3714 return TRUE;
3715
3716 alpha_elf_hash_table (info)->got_list = got_list;
3717
3718 /* Force got offsets to be recalculated. */
3719 something_changed = 1;
3720 }
3721
3722 cur_got_obj = got_list;
3723 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3724 while (i != NULL)
3725 {
3726 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3727 {
3728 elf64_alpha_merge_gots (cur_got_obj, i);
3729 i = alpha_elf_tdata(i)->got_link_next;
3730 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3731 something_changed = 1;
3732 }
3733 else
3734 {
3735 cur_got_obj = i;
3736 i = alpha_elf_tdata(i)->got_link_next;
3737 }
3738 }
3739
3740 /* Once the gots have been merged, fill in the got offsets for
3741 everything therein. */
3742 if (1 || something_changed)
3743 elf64_alpha_calc_got_offsets (info);
3744
3745 return TRUE;
3746 }
3747
3748 /* Called from relax_section to rebuild the PLT in light of
3749 potential changes in the function's status. */
3750
3751 static bfd_boolean
3752 elf64_alpha_size_plt_section (info)
3753 struct bfd_link_info *info;
3754 {
3755 asection *splt, *spltrel;
3756 unsigned long entries;
3757 bfd *dynobj;
3758
3759 dynobj = elf_hash_table(info)->dynobj;
3760 splt = bfd_get_section_by_name(dynobj, ".plt");
3761 if (splt == NULL)
3762 return TRUE;
3763
3764 splt->_raw_size = 0;
3765
3766 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3767 elf64_alpha_size_plt_section_1, splt);
3768
3769 splt->_cooked_size = splt->_raw_size;
3770
3771 /* Every plt entry requires a JMP_SLOT relocation. */
3772 spltrel = bfd_get_section_by_name (dynobj, ".rela.plt");
3773 if (splt->_raw_size)
3774 entries = (splt->_raw_size - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3775 else
3776 entries = 0;
3777 spltrel->_raw_size = entries * sizeof (Elf64_External_Rela);
3778 spltrel->_cooked_size = spltrel->_raw_size;
3779
3780 return TRUE;
3781 }
3782
3783 static bfd_boolean
3784 elf64_alpha_size_plt_section_1 (h, data)
3785 struct alpha_elf_link_hash_entry *h;
3786 PTR data;
3787 {
3788 asection *splt = (asection *) data;
3789 struct alpha_elf_got_entry *gotent;
3790
3791 /* If we didn't need an entry before, we still don't. */
3792 if (!(h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT))
3793 return TRUE;
3794
3795 /* There must still be a LITERAL got entry for the function. */
3796 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3797 if (gotent->reloc_type == R_ALPHA_LITERAL
3798 && gotent->use_count > 0)
3799 break;
3800
3801 /* If there is, reset the PLT offset. If not, there's no longer
3802 a need for the PLT entry. */
3803 if (gotent)
3804 {
3805 if (splt->_raw_size == 0)
3806 splt->_raw_size = PLT_HEADER_SIZE;
3807 h->root.plt.offset = splt->_raw_size;
3808 splt->_raw_size += PLT_ENTRY_SIZE;
3809 }
3810 else
3811 {
3812 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3813 h->root.plt.offset = -1;
3814
3815 /* Undo the definition frobbing begun in adjust_dynamic_symbol. */
3816 if (h->flags & ALPHA_ELF_LINK_HASH_PLT_LOC)
3817 {
3818 h->root.root.u.def.section = h->plt_old_section;
3819 h->root.root.u.def.value = h->plt_old_value;
3820 h->flags &= ~ALPHA_ELF_LINK_HASH_PLT_LOC;
3821 }
3822 }
3823
3824 return TRUE;
3825 }
3826
3827 static bfd_boolean
3828 elf64_alpha_always_size_sections (output_bfd, info)
3829 bfd *output_bfd ATTRIBUTE_UNUSED;
3830 struct bfd_link_info *info;
3831 {
3832 bfd *i;
3833
3834 if (info->relocatable)
3835 return TRUE;
3836
3837 /* First, take care of the indirect symbols created by versioning. */
3838 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3839 elf64_alpha_merge_ind_symbols,
3840 NULL);
3841
3842 if (!elf64_alpha_size_got_sections (info))
3843 return FALSE;
3844
3845 /* Allocate space for all of the .got subsections. */
3846 i = alpha_elf_hash_table (info)->got_list;
3847 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3848 {
3849 asection *s = alpha_elf_tdata(i)->got;
3850 if (s->_raw_size > 0)
3851 {
3852 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3853 if (s->contents == NULL)
3854 return FALSE;
3855 }
3856 }
3857
3858 return TRUE;
3859 }
3860
3861 /* The number of dynamic relocations required by a static relocation. */
3862
3863 static int
3864 alpha_dynamic_entries_for_reloc (r_type, dynamic, shared)
3865 int r_type, dynamic, shared;
3866 {
3867 switch (r_type)
3868 {
3869 /* May appear in GOT entries. */
3870 case R_ALPHA_TLSGD:
3871 return (dynamic ? 2 : shared ? 1 : 0);
3872 case R_ALPHA_TLSLDM:
3873 return shared;
3874 case R_ALPHA_LITERAL:
3875 case R_ALPHA_GOTTPREL:
3876 return dynamic || shared;
3877 case R_ALPHA_GOTDTPREL:
3878 return dynamic;
3879
3880 /* May appear in data sections. */
3881 case R_ALPHA_REFLONG:
3882 case R_ALPHA_REFQUAD:
3883 case R_ALPHA_TPREL64:
3884 return dynamic || shared;
3885
3886 /* Everything else is illegal. We'll issue an error during
3887 relocate_section. */
3888 default:
3889 return 0;
3890 }
3891 }
3892
3893 /* Work out the sizes of the dynamic relocation entries. */
3894
3895 static bfd_boolean
3896 elf64_alpha_calc_dynrel_sizes (h, info)
3897 struct alpha_elf_link_hash_entry *h;
3898 struct bfd_link_info *info;
3899 {
3900 bfd_boolean dynamic;
3901 struct alpha_elf_reloc_entry *relent;
3902 unsigned long entries;
3903
3904 if (h->root.root.type == bfd_link_hash_warning)
3905 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3906
3907 /* If the symbol was defined as a common symbol in a regular object
3908 file, and there was no definition in any dynamic object, then the
3909 linker will have allocated space for the symbol in a common
3910 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3911 set. This is done for dynamic symbols in
3912 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3913 symbols, somehow. */
3914 if (((h->root.elf_link_hash_flags
3915 & (ELF_LINK_HASH_DEF_REGULAR
3916 | ELF_LINK_HASH_REF_REGULAR
3917 | ELF_LINK_HASH_DEF_DYNAMIC))
3918 == ELF_LINK_HASH_REF_REGULAR)
3919 && (h->root.root.type == bfd_link_hash_defined
3920 || h->root.root.type == bfd_link_hash_defweak)
3921 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3922 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3923
3924 /* If the symbol is dynamic, we'll need all the relocations in their
3925 natural form. If this is a shared object, and it has been forced
3926 local, we'll need the same number of RELATIVE relocations. */
3927
3928 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
3929
3930 for (relent = h->reloc_entries; relent; relent = relent->next)
3931 {
3932 entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
3933 info->shared);
3934 if (entries)
3935 {
3936 relent->srel->_raw_size +=
3937 entries * sizeof (Elf64_External_Rela) * relent->count;
3938 if (relent->reltext)
3939 info->flags |= DT_TEXTREL;
3940 }
3941 }
3942
3943 return TRUE;
3944 }
3945
3946 /* Set the sizes of the dynamic relocation sections. */
3947
3948 static bfd_boolean
3949 elf64_alpha_size_rela_got_section (info)
3950 struct bfd_link_info *info;
3951 {
3952 unsigned long entries;
3953 bfd *i, *dynobj;
3954 asection *srel;
3955
3956 /* Shared libraries often require RELATIVE relocs, and some relocs
3957 require attention for the main application as well. */
3958
3959 entries = 0;
3960 for (i = alpha_elf_hash_table(info)->got_list;
3961 i ; i = alpha_elf_tdata(i)->got_link_next)
3962 {
3963 bfd *j;
3964
3965 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
3966 {
3967 struct alpha_elf_got_entry **local_got_entries, *gotent;
3968 int k, n;
3969
3970 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
3971 if (!local_got_entries)
3972 continue;
3973
3974 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3975 for (gotent = local_got_entries[k];
3976 gotent ; gotent = gotent->next)
3977 if (gotent->use_count > 0)
3978 entries += (alpha_dynamic_entries_for_reloc
3979 (gotent->reloc_type, 0, info->shared));
3980 }
3981 }
3982
3983 dynobj = elf_hash_table(info)->dynobj;
3984 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3985 if (!srel)
3986 {
3987 BFD_ASSERT (entries == 0);
3988 return TRUE;
3989 }
3990 srel->_raw_size = sizeof (Elf64_External_Rela) * entries;
3991
3992 /* Now do the non-local symbols. */
3993 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3994 elf64_alpha_size_rela_got_1, info);
3995
3996 srel->_cooked_size = srel->_raw_size;
3997
3998 return TRUE;
3999 }
4000
4001 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
4002 global symbols. */
4003
4004 static bfd_boolean
4005 elf64_alpha_size_rela_got_1 (h, info)
4006 struct alpha_elf_link_hash_entry *h;
4007 struct bfd_link_info *info;
4008 {
4009 bfd_boolean dynamic;
4010 struct alpha_elf_got_entry *gotent;
4011 unsigned long entries;
4012
4013 if (h->root.root.type == bfd_link_hash_warning)
4014 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
4015
4016 /* If the symbol is dynamic, we'll need all the relocations in their
4017 natural form. If this is a shared object, and it has been forced
4018 local, we'll need the same number of RELATIVE relocations. */
4019
4020 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
4021
4022 entries = 0;
4023 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
4024 if (gotent->use_count > 0)
4025 entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type,
4026 dynamic, info->shared);
4027
4028 /* If we are using a .plt entry, subtract one, as the first
4029 reference uses a .rela.plt entry instead. */
4030 if (h->root.plt.offset != MINUS_ONE)
4031 entries--;
4032
4033 if (entries > 0)
4034 {
4035 bfd *dynobj = elf_hash_table(info)->dynobj;
4036 asection *srel = bfd_get_section_by_name (dynobj, ".rela.got");
4037 BFD_ASSERT (srel != NULL);
4038 srel->_raw_size += sizeof (Elf64_External_Rela) * entries;
4039 }
4040
4041 return TRUE;
4042 }
4043
4044 /* Set the sizes of the dynamic sections. */
4045
4046 static bfd_boolean
4047 elf64_alpha_size_dynamic_sections (output_bfd, info)
4048 bfd *output_bfd ATTRIBUTE_UNUSED;
4049 struct bfd_link_info *info;
4050 {
4051 bfd *dynobj;
4052 asection *s;
4053 bfd_boolean relplt;
4054
4055 dynobj = elf_hash_table(info)->dynobj;
4056 BFD_ASSERT(dynobj != NULL);
4057
4058 if (elf_hash_table (info)->dynamic_sections_created)
4059 {
4060 /* Set the contents of the .interp section to the interpreter. */
4061 if (info->executable)
4062 {
4063 s = bfd_get_section_by_name (dynobj, ".interp");
4064 BFD_ASSERT (s != NULL);
4065 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
4066 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4067 }
4068
4069 /* Now that we've seen all of the input files, we can decide which
4070 symbols need dynamic relocation entries and which don't. We've
4071 collected information in check_relocs that we can now apply to
4072 size the dynamic relocation sections. */
4073 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
4074 elf64_alpha_calc_dynrel_sizes, info);
4075
4076 elf64_alpha_size_rela_got_section (info);
4077 }
4078 /* else we're not dynamic and by definition we don't need such things. */
4079
4080 /* The check_relocs and adjust_dynamic_symbol entry points have
4081 determined the sizes of the various dynamic sections. Allocate
4082 memory for them. */
4083 relplt = FALSE;
4084 for (s = dynobj->sections; s != NULL; s = s->next)
4085 {
4086 const char *name;
4087 bfd_boolean strip;
4088
4089 if (!(s->flags & SEC_LINKER_CREATED))
4090 continue;
4091
4092 /* It's OK to base decisions on the section name, because none
4093 of the dynobj section names depend upon the input files. */
4094 name = bfd_get_section_name (dynobj, s);
4095
4096 /* If we don't need this section, strip it from the output file.
4097 This is to handle .rela.bss and .rela.plt. We must create it
4098 in create_dynamic_sections, because it must be created before
4099 the linker maps input sections to output sections. The
4100 linker does that before adjust_dynamic_symbol is called, and
4101 it is that function which decides whether anything needs to
4102 go into these sections. */
4103
4104 strip = FALSE;
4105
4106 if (strncmp (name, ".rela", 5) == 0)
4107 {
4108 strip = (s->_raw_size == 0);
4109
4110 if (!strip)
4111 {
4112 if (strcmp(name, ".rela.plt") == 0)
4113 relplt = TRUE;
4114
4115 /* We use the reloc_count field as a counter if we need
4116 to copy relocs into the output file. */
4117 s->reloc_count = 0;
4118 }
4119 }
4120 else if (strcmp (name, ".plt") != 0)
4121 {
4122 /* It's not one of our dynamic sections, so don't allocate space. */
4123 continue;
4124 }
4125
4126 if (strip)
4127 _bfd_strip_section_from_output (info, s);
4128 else
4129 {
4130 /* Allocate memory for the section contents. */
4131 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
4132 if (s->contents == NULL && s->_raw_size != 0)
4133 return FALSE;
4134 }
4135 }
4136
4137 if (elf_hash_table (info)->dynamic_sections_created)
4138 {
4139 /* Add some entries to the .dynamic section. We fill in the
4140 values later, in elf64_alpha_finish_dynamic_sections, but we
4141 must add the entries now so that we get the correct size for
4142 the .dynamic section. The DT_DEBUG entry is filled in by the
4143 dynamic linker and used by the debugger. */
4144 #define add_dynamic_entry(TAG, VAL) \
4145 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
4146
4147 if (info->executable)
4148 {
4149 if (!add_dynamic_entry (DT_DEBUG, 0))
4150 return FALSE;
4151 }
4152
4153 if (relplt)
4154 {
4155 if (!add_dynamic_entry (DT_PLTGOT, 0)
4156 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4157 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4158 || !add_dynamic_entry (DT_JMPREL, 0))
4159 return FALSE;
4160 }
4161
4162 if (!add_dynamic_entry (DT_RELA, 0)
4163 || !add_dynamic_entry (DT_RELASZ, 0)
4164 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
4165 return FALSE;
4166
4167 if (info->flags & DF_TEXTREL)
4168 {
4169 if (!add_dynamic_entry (DT_TEXTREL, 0))
4170 return FALSE;
4171 }
4172 }
4173 #undef add_dynamic_entry
4174
4175 return TRUE;
4176 }
4177
4178 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4179 into the next available slot in SREL. */
4180
4181 static void
4182 elf64_alpha_emit_dynrel (abfd, info, sec, srel, offset, dynindx, rtype, addend)
4183 bfd *abfd;
4184 struct bfd_link_info *info;
4185 asection *sec, *srel;
4186 bfd_vma offset, addend;
4187 long dynindx, rtype;
4188 {
4189 Elf_Internal_Rela outrel;
4190 bfd_byte *loc;
4191
4192 BFD_ASSERT (srel != NULL);
4193
4194 outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4195 outrel.r_addend = addend;
4196
4197 offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4198 if ((offset | 1) != (bfd_vma) -1)
4199 outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4200 else
4201 memset (&outrel, 0, sizeof (outrel));
4202
4203 loc = srel->contents;
4204 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4205 bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4206 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
4207 <= srel->_cooked_size);
4208 }
4209
4210 /* Relocate an Alpha ELF section for a relocatable link.
4211
4212 We don't have to change anything unless the reloc is against a section
4213 symbol, in which case we have to adjust according to where the section
4214 symbol winds up in the output section. */
4215
4216 static bfd_boolean
4217 elf64_alpha_relocate_section_r (output_bfd, info, input_bfd, input_section,
4218 contents, relocs, local_syms, local_sections)
4219 bfd *output_bfd ATTRIBUTE_UNUSED;
4220 struct bfd_link_info *info ATTRIBUTE_UNUSED;
4221 bfd *input_bfd;
4222 asection *input_section;
4223 bfd_byte *contents ATTRIBUTE_UNUSED;
4224 Elf_Internal_Rela *relocs;
4225 Elf_Internal_Sym *local_syms;
4226 asection **local_sections;
4227 {
4228 unsigned long symtab_hdr_sh_info;
4229 Elf_Internal_Rela *rel;
4230 Elf_Internal_Rela *relend;
4231 bfd_boolean ret_val = TRUE;
4232
4233 symtab_hdr_sh_info = elf_tdata (input_bfd)->symtab_hdr.sh_info;
4234
4235 relend = relocs + input_section->reloc_count;
4236 for (rel = relocs; rel < relend; rel++)
4237 {
4238 unsigned long r_symndx;
4239 Elf_Internal_Sym *sym;
4240 asection *sec;
4241 unsigned long r_type;
4242
4243 r_type = ELF64_R_TYPE(rel->r_info);
4244 if (r_type >= R_ALPHA_max)
4245 {
4246 (*_bfd_error_handler)
4247 (_("%s: unknown relocation type %d"),
4248 bfd_archive_filename (input_bfd), (int)r_type);
4249 bfd_set_error (bfd_error_bad_value);
4250 ret_val = FALSE;
4251 continue;
4252 }
4253
4254 r_symndx = ELF64_R_SYM(rel->r_info);
4255
4256 /* The symbol associated with GPDISP and LITUSE is
4257 immaterial. Only the addend is significant. */
4258 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4259 continue;
4260
4261 if (r_symndx < symtab_hdr_sh_info)
4262 {
4263 sym = local_syms + r_symndx;
4264 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
4265 {
4266 sec = local_sections[r_symndx];
4267 rel->r_addend += sec->output_offset + sym->st_value;
4268 }
4269 }
4270 }
4271
4272 return ret_val;
4273 }
4274
4275 /* Relocate an Alpha ELF section. */
4276
4277 static bfd_boolean
4278 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
4279 contents, relocs, local_syms, local_sections)
4280 bfd *output_bfd;
4281 struct bfd_link_info *info;
4282 bfd *input_bfd;
4283 asection *input_section;
4284 bfd_byte *contents;
4285 Elf_Internal_Rela *relocs;
4286 Elf_Internal_Sym *local_syms;
4287 asection **local_sections;
4288 {
4289 Elf_Internal_Shdr *symtab_hdr;
4290 Elf_Internal_Rela *rel;
4291 Elf_Internal_Rela *relend;
4292 struct elf_link_tls_segment *tls_segment;
4293 asection *sgot, *srel, *srelgot;
4294 bfd *dynobj, *gotobj;
4295 bfd_vma gp, tp_base, dtp_base;
4296 struct alpha_elf_got_entry **local_got_entries;
4297 bfd_boolean ret_val;
4298 const char *section_name;
4299
4300 /* Handle relocatable links with a smaller loop. */
4301 if (info->relocatable)
4302 return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4303 input_section, contents, relocs,
4304 local_syms, local_sections);
4305
4306 /* This is a final link. */
4307
4308 ret_val = TRUE;
4309
4310 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4311
4312 dynobj = elf_hash_table (info)->dynobj;
4313 if (dynobj)
4314 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4315 else
4316 srelgot = NULL;
4317
4318 section_name = (bfd_elf_string_from_elf_section
4319 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4320 elf_section_data(input_section)->rel_hdr.sh_name));
4321 BFD_ASSERT(section_name != NULL);
4322 srel = bfd_get_section_by_name (dynobj, section_name);
4323
4324 /* Find the gp value for this input bfd. */
4325 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4326 if (gotobj)
4327 {
4328 sgot = alpha_elf_tdata (gotobj)->got;
4329 gp = _bfd_get_gp_value (gotobj);
4330 if (gp == 0)
4331 {
4332 gp = (sgot->output_section->vma
4333 + sgot->output_offset
4334 + 0x8000);
4335 _bfd_set_gp_value (gotobj, gp);
4336 }
4337 }
4338 else
4339 {
4340 sgot = NULL;
4341 gp = 0;
4342 }
4343
4344 local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4345
4346 tls_segment = elf_hash_table (info)->tls_segment;
4347 if (tls_segment)
4348 {
4349 dtp_base = alpha_get_dtprel_base (tls_segment);
4350 tp_base = alpha_get_tprel_base (tls_segment);
4351 }
4352 else
4353 dtp_base = tp_base = 0;
4354
4355 relend = relocs + input_section->reloc_count;
4356 for (rel = relocs; rel < relend; rel++)
4357 {
4358 struct alpha_elf_link_hash_entry *h = NULL;
4359 struct alpha_elf_got_entry *gotent;
4360 bfd_reloc_status_type r;
4361 reloc_howto_type *howto;
4362 unsigned long r_symndx;
4363 Elf_Internal_Sym *sym = NULL;
4364 asection *sec = NULL;
4365 bfd_vma value;
4366 bfd_vma addend;
4367 bfd_boolean dynamic_symbol_p;
4368 bfd_boolean undef_weak_ref = FALSE;
4369 unsigned long r_type;
4370
4371 r_type = ELF64_R_TYPE(rel->r_info);
4372 if (r_type >= R_ALPHA_max)
4373 {
4374 (*_bfd_error_handler)
4375 (_("%s: unknown relocation type %d"),
4376 bfd_archive_filename (input_bfd), (int)r_type);
4377 bfd_set_error (bfd_error_bad_value);
4378 ret_val = FALSE;
4379 continue;
4380 }
4381
4382 howto = elf64_alpha_howto_table + r_type;
4383 r_symndx = ELF64_R_SYM(rel->r_info);
4384
4385 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4386 reloc to the 0 symbol so that they all match. */
4387 if (r_type == R_ALPHA_TLSLDM)
4388 r_symndx = 0;
4389
4390 if (r_symndx < symtab_hdr->sh_info)
4391 {
4392 sym = local_syms + r_symndx;
4393 sec = local_sections[r_symndx];
4394 value = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
4395
4396 /* If this is a tp-relative relocation against sym 0,
4397 this is hackery from relax_section. Force the value to
4398 be the tls base. */
4399 if (r_symndx == 0
4400 && (r_type == R_ALPHA_TLSLDM
4401 || r_type == R_ALPHA_GOTTPREL
4402 || r_type == R_ALPHA_TPREL64
4403 || r_type == R_ALPHA_TPRELHI
4404 || r_type == R_ALPHA_TPRELLO
4405 || r_type == R_ALPHA_TPREL16))
4406 value = tp_base;
4407
4408 if (local_got_entries)
4409 gotent = local_got_entries[r_symndx];
4410 else
4411 gotent = NULL;
4412
4413 /* Need to adjust local GOT entries' addends for SEC_MERGE
4414 unless it has been done already. */
4415 if ((sec->flags & SEC_MERGE)
4416 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4417 && sec->sec_info_type == ELF_INFO_TYPE_MERGE
4418 && gotent
4419 && !gotent->reloc_xlated)
4420 {
4421 struct alpha_elf_got_entry *ent;
4422 asection *msec;
4423
4424 for (ent = gotent; ent; ent = ent->next)
4425 {
4426 ent->reloc_xlated = 1;
4427 if (ent->use_count == 0)
4428 continue;
4429 msec = sec;
4430 ent->addend =
4431 _bfd_merged_section_offset (output_bfd, &msec,
4432 elf_section_data (sec)->
4433 sec_info,
4434 sym->st_value + ent->addend,
4435 (bfd_vma) 0);
4436 ent->addend -= sym->st_value;
4437 ent->addend += msec->output_section->vma
4438 + msec->output_offset
4439 - sec->output_section->vma
4440 - sec->output_offset;
4441 }
4442 }
4443
4444 dynamic_symbol_p = FALSE;
4445 }
4446 else
4447 {
4448 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
4449
4450 while (h->root.root.type == bfd_link_hash_indirect
4451 || h->root.root.type == bfd_link_hash_warning)
4452 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
4453
4454 value = 0;
4455 if (h->root.root.type == bfd_link_hash_defined
4456 || h->root.root.type == bfd_link_hash_defweak)
4457 {
4458 sec = h->root.root.u.def.section;
4459
4460 /* Detect the cases that sym_sec->output_section is
4461 expected to be NULL -- all cases in which the symbol
4462 is defined in another shared module. This includes
4463 PLT relocs for which we've created a PLT entry and
4464 other relocs for which we're prepared to create
4465 dynamic relocations. */
4466 /* ??? Just accept it NULL and continue. */
4467
4468 if (sec->output_section != NULL)
4469 value = (h->root.root.u.def.value
4470 + sec->output_section->vma
4471 + sec->output_offset);
4472 }
4473 else if (h->root.root.type == bfd_link_hash_undefweak)
4474 undef_weak_ref = TRUE;
4475 else if (!info->executable
4476 && !info->no_undefined
4477 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
4478 ;
4479 else
4480 {
4481 if (!((*info->callbacks->undefined_symbol)
4482 (info, h->root.root.root.string, input_bfd,
4483 input_section, rel->r_offset,
4484 (info->executable || info->no_undefined
4485 || ELF_ST_VISIBILITY (h->root.other)))))
4486 return FALSE;
4487 continue;
4488 }
4489
4490 dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4491 gotent = h->got_entries;
4492 }
4493
4494 addend = rel->r_addend;
4495 value += addend;
4496
4497 /* Search for the proper got entry. */
4498 for (; gotent ; gotent = gotent->next)
4499 if (gotent->gotobj == gotobj
4500 && gotent->reloc_type == r_type
4501 && gotent->addend == addend)
4502 break;
4503
4504 switch (r_type)
4505 {
4506 case R_ALPHA_GPDISP:
4507 {
4508 bfd_byte *p_ldah, *p_lda;
4509
4510 BFD_ASSERT(gp != 0);
4511
4512 value = (input_section->output_section->vma
4513 + input_section->output_offset
4514 + rel->r_offset);
4515
4516 p_ldah = contents + rel->r_offset;
4517 p_lda = p_ldah + rel->r_addend;
4518
4519 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4520 p_ldah, p_lda);
4521 }
4522 break;
4523
4524 case R_ALPHA_LITERAL:
4525 BFD_ASSERT(sgot != NULL);
4526 BFD_ASSERT(gp != 0);
4527 BFD_ASSERT(gotent != NULL);
4528 BFD_ASSERT(gotent->use_count >= 1);
4529
4530 if (!gotent->reloc_done)
4531 {
4532 gotent->reloc_done = 1;
4533
4534 bfd_put_64 (output_bfd, value,
4535 sgot->contents + gotent->got_offset);
4536
4537 /* If the symbol has been forced local, output a
4538 RELATIVE reloc, otherwise it will be handled in
4539 finish_dynamic_symbol. */
4540 if (info->shared && !dynamic_symbol_p)
4541 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4542 gotent->got_offset, 0,
4543 R_ALPHA_RELATIVE, value);
4544 }
4545
4546 value = (sgot->output_section->vma
4547 + sgot->output_offset
4548 + gotent->got_offset);
4549 value -= gp;
4550 goto default_reloc;
4551
4552 case R_ALPHA_GPREL32:
4553 /* If the target section was a removed linkonce section,
4554 r_symndx will be zero. In this case, assume that the
4555 switch will not be used, so don't fill it in. If we
4556 do nothing here, we'll get relocation truncated messages,
4557 due to the placement of the application above 4GB. */
4558 if (r_symndx == 0)
4559 {
4560 r = bfd_reloc_ok;
4561 break;
4562 }
4563 /* FALLTHRU */
4564
4565 case R_ALPHA_GPREL16:
4566 case R_ALPHA_GPRELLOW:
4567 if (dynamic_symbol_p)
4568 {
4569 (*_bfd_error_handler)
4570 (_("%s: gp-relative relocation against dynamic symbol %s"),
4571 bfd_archive_filename (input_bfd), h->root.root.root.string);
4572 ret_val = FALSE;
4573 }
4574 BFD_ASSERT(gp != 0);
4575 value -= gp;
4576 goto default_reloc;
4577
4578 case R_ALPHA_GPRELHIGH:
4579 if (dynamic_symbol_p)
4580 {
4581 (*_bfd_error_handler)
4582 (_("%s: gp-relative relocation against dynamic symbol %s"),
4583 bfd_archive_filename (input_bfd), h->root.root.root.string);
4584 ret_val = FALSE;
4585 }
4586 BFD_ASSERT(gp != 0);
4587 value -= gp;
4588 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4589 goto default_reloc;
4590
4591 case R_ALPHA_HINT:
4592 /* A call to a dynamic symbol is definitely out of range of
4593 the 16-bit displacement. Don't bother writing anything. */
4594 if (dynamic_symbol_p)
4595 {
4596 r = bfd_reloc_ok;
4597 break;
4598 }
4599 /* The regular PC-relative stuff measures from the start of
4600 the instruction rather than the end. */
4601 value -= 4;
4602 goto default_reloc;
4603
4604 case R_ALPHA_BRADDR:
4605 if (dynamic_symbol_p)
4606 {
4607 (*_bfd_error_handler)
4608 (_("%s: pc-relative relocation against dynamic symbol %s"),
4609 bfd_archive_filename (input_bfd), h->root.root.root.string);
4610 ret_val = FALSE;
4611 }
4612 /* The regular PC-relative stuff measures from the start of
4613 the instruction rather than the end. */
4614 value -= 4;
4615 goto default_reloc;
4616
4617 case R_ALPHA_BRSGP:
4618 {
4619 int other;
4620 const char *name;
4621
4622 /* The regular PC-relative stuff measures from the start of
4623 the instruction rather than the end. */
4624 value -= 4;
4625
4626 /* The source and destination gp must be the same. Note that
4627 the source will always have an assigned gp, since we forced
4628 one in check_relocs, but that the destination may not, as
4629 it might not have had any relocations at all. Also take
4630 care not to crash if H is an undefined symbol. */
4631 if (h != NULL && sec != NULL
4632 && alpha_elf_tdata (sec->owner)->gotobj
4633 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4634 {
4635 (*_bfd_error_handler)
4636 (_("%s: change in gp: BRSGP %s"),
4637 bfd_archive_filename (input_bfd), h->root.root.root.string);
4638 ret_val = FALSE;
4639 }
4640
4641 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4642 if (h != NULL)
4643 other = h->root.other;
4644 else
4645 other = sym->st_other;
4646 switch (other & STO_ALPHA_STD_GPLOAD)
4647 {
4648 case STO_ALPHA_NOPV:
4649 break;
4650 case STO_ALPHA_STD_GPLOAD:
4651 value += 8;
4652 break;
4653 default:
4654 if (h != NULL)
4655 name = h->root.root.root.string;
4656 else
4657 {
4658 name = (bfd_elf_string_from_elf_section
4659 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4660 if (name == NULL)
4661 name = _("<unknown>");
4662 else if (name[0] == 0)
4663 name = bfd_section_name (input_bfd, sec);
4664 }
4665 (*_bfd_error_handler)
4666 (_("%s: !samegp reloc against symbol without .prologue: %s"),
4667 bfd_archive_filename (input_bfd), name);
4668 ret_val = FALSE;
4669 break;
4670 }
4671
4672 goto default_reloc;
4673 }
4674
4675 case R_ALPHA_REFLONG:
4676 case R_ALPHA_REFQUAD:
4677 case R_ALPHA_DTPREL64:
4678 case R_ALPHA_TPREL64:
4679 {
4680 long dynindx, dyntype = r_type;
4681 bfd_vma dynaddend;
4682
4683 /* Careful here to remember RELATIVE relocations for global
4684 variables for symbolic shared objects. */
4685
4686 if (dynamic_symbol_p)
4687 {
4688 BFD_ASSERT(h->root.dynindx != -1);
4689 dynindx = h->root.dynindx;
4690 dynaddend = addend;
4691 addend = 0, value = 0;
4692 }
4693 else if (r_type == R_ALPHA_DTPREL64)
4694 {
4695 BFD_ASSERT(tls_segment != NULL);
4696 value -= dtp_base;
4697 goto default_reloc;
4698 }
4699 else if (r_type == R_ALPHA_TPREL64)
4700 {
4701 BFD_ASSERT(tls_segment != NULL);
4702 if (!info->shared)
4703 {
4704 value -= tp_base;
4705 goto default_reloc;
4706 }
4707 dynindx = 0;
4708 dynaddend = value - dtp_base;
4709 }
4710 else if (info->shared
4711 && r_symndx != 0
4712 && (input_section->flags & SEC_ALLOC))
4713 {
4714 if (r_type == R_ALPHA_REFLONG)
4715 {
4716 (*_bfd_error_handler)
4717 (_("%s: unhandled dynamic relocation against %s"),
4718 bfd_archive_filename (input_bfd),
4719 h->root.root.root.string);
4720 ret_val = FALSE;
4721 }
4722 dynindx = 0;
4723 dyntype = R_ALPHA_RELATIVE;
4724 dynaddend = value;
4725 }
4726 else
4727 goto default_reloc;
4728
4729 elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4730 srel, rel->r_offset, dynindx,
4731 dyntype, dynaddend);
4732 }
4733 goto default_reloc;
4734
4735 case R_ALPHA_SREL16:
4736 case R_ALPHA_SREL32:
4737 case R_ALPHA_SREL64:
4738 if (dynamic_symbol_p)
4739 {
4740 (*_bfd_error_handler)
4741 (_("%s: pc-relative relocation against dynamic symbol %s"),
4742 bfd_archive_filename (input_bfd), h->root.root.root.string);
4743 ret_val = FALSE;
4744 }
4745
4746 /* ??? .eh_frame references to discarded sections will be smashed
4747 to relocations against SHN_UNDEF. The .eh_frame format allows
4748 NULL to be encoded as 0 in any format, so this works here. */
4749 if (r_symndx == 0)
4750 howto = (elf64_alpha_howto_table
4751 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4752 goto default_reloc;
4753
4754 case R_ALPHA_TLSLDM:
4755 /* Ignore the symbol for the relocation. The result is always
4756 the current module. */
4757 dynamic_symbol_p = 0;
4758 /* FALLTHRU */
4759
4760 case R_ALPHA_TLSGD:
4761 if (!gotent->reloc_done)
4762 {
4763 gotent->reloc_done = 1;
4764
4765 /* Note that the module index for the main program is 1. */
4766 bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p,
4767 sgot->contents + gotent->got_offset);
4768
4769 /* If the symbol has been forced local, output a
4770 DTPMOD64 reloc, otherwise it will be handled in
4771 finish_dynamic_symbol. */
4772 if (info->shared && !dynamic_symbol_p)
4773 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4774 gotent->got_offset, 0,
4775 R_ALPHA_DTPMOD64, 0);
4776
4777 if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4778 value = 0;
4779 else
4780 {
4781 BFD_ASSERT(tls_segment != NULL);
4782 value -= dtp_base;
4783 }
4784 bfd_put_64 (output_bfd, value,
4785 sgot->contents + gotent->got_offset + 8);
4786 }
4787
4788 value = (sgot->output_section->vma
4789 + sgot->output_offset
4790 + gotent->got_offset);
4791 value -= gp;
4792 goto default_reloc;
4793
4794 case R_ALPHA_DTPRELHI:
4795 case R_ALPHA_DTPRELLO:
4796 case R_ALPHA_DTPREL16:
4797 if (dynamic_symbol_p)
4798 {
4799 (*_bfd_error_handler)
4800 (_("%s: dtp-relative relocation against dynamic symbol %s"),
4801 bfd_archive_filename (input_bfd), h->root.root.root.string);
4802 ret_val = FALSE;
4803 }
4804 BFD_ASSERT(tls_segment != NULL);
4805 value -= dtp_base;
4806 if (r_type == R_ALPHA_DTPRELHI)
4807 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4808 goto default_reloc;
4809
4810 case R_ALPHA_TPRELHI:
4811 case R_ALPHA_TPRELLO:
4812 case R_ALPHA_TPREL16:
4813 if (info->shared)
4814 {
4815 (*_bfd_error_handler)
4816 (_("%s: TLS local exec code cannot be linked into shared objects"),
4817 bfd_archive_filename (input_bfd));
4818 ret_val = FALSE;
4819 }
4820 else if (dynamic_symbol_p)
4821 {
4822 (*_bfd_error_handler)
4823 (_("%s: tp-relative relocation against dynamic symbol %s"),
4824 bfd_archive_filename (input_bfd), h->root.root.root.string);
4825 ret_val = FALSE;
4826 }
4827 BFD_ASSERT(tls_segment != NULL);
4828 value -= tp_base;
4829 if (r_type == R_ALPHA_TPRELHI)
4830 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4831 goto default_reloc;
4832
4833 case R_ALPHA_GOTDTPREL:
4834 case R_ALPHA_GOTTPREL:
4835 BFD_ASSERT(sgot != NULL);
4836 BFD_ASSERT(gp != 0);
4837 BFD_ASSERT(gotent != NULL);
4838 BFD_ASSERT(gotent->use_count >= 1);
4839
4840 if (!gotent->reloc_done)
4841 {
4842 gotent->reloc_done = 1;
4843
4844 if (dynamic_symbol_p)
4845 value = 0;
4846 else
4847 {
4848 BFD_ASSERT(tls_segment != NULL);
4849 if (r_type == R_ALPHA_GOTDTPREL)
4850 value -= dtp_base;
4851 else if (!info->shared)
4852 value -= tp_base;
4853 else
4854 {
4855 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4856 gotent->got_offset, 0,
4857 R_ALPHA_TPREL64,
4858 value - dtp_base);
4859 value = 0;
4860 }
4861 }
4862 bfd_put_64 (output_bfd, value,
4863 sgot->contents + gotent->got_offset);
4864 }
4865
4866 value = (sgot->output_section->vma
4867 + sgot->output_offset
4868 + gotent->got_offset);
4869 value -= gp;
4870 goto default_reloc;
4871
4872 default:
4873 default_reloc:
4874 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4875 contents, rel->r_offset, value, 0);
4876 break;
4877 }
4878
4879 switch (r)
4880 {
4881 case bfd_reloc_ok:
4882 break;
4883
4884 case bfd_reloc_overflow:
4885 {
4886 const char *name;
4887
4888 /* Don't warn if the overflow is due to pc relative reloc
4889 against discarded section. Section optimization code should
4890 handle it. */
4891
4892 if (r_symndx < symtab_hdr->sh_info
4893 && sec != NULL && howto->pc_relative
4894 && elf_discarded_section (sec))
4895 break;
4896
4897 if (h != NULL)
4898 name = h->root.root.root.string;
4899 else
4900 {
4901 name = (bfd_elf_string_from_elf_section
4902 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4903 if (name == NULL)
4904 return FALSE;
4905 if (*name == '\0')
4906 name = bfd_section_name (input_bfd, sec);
4907 }
4908 if (! ((*info->callbacks->reloc_overflow)
4909 (info, name, howto->name, (bfd_vma) 0,
4910 input_bfd, input_section, rel->r_offset)))
4911 ret_val = FALSE;
4912 }
4913 break;
4914
4915 default:
4916 case bfd_reloc_outofrange:
4917 abort ();
4918 }
4919 }
4920
4921 return ret_val;
4922 }
4923
4924 /* Finish up dynamic symbol handling. We set the contents of various
4925 dynamic sections here. */
4926
4927 static bfd_boolean
4928 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
4929 bfd *output_bfd;
4930 struct bfd_link_info *info;
4931 struct elf_link_hash_entry *h;
4932 Elf_Internal_Sym *sym;
4933 {
4934 bfd *dynobj = elf_hash_table(info)->dynobj;
4935
4936 if (h->plt.offset != MINUS_ONE)
4937 {
4938 /* Fill in the .plt entry for this symbol. */
4939 asection *splt, *sgot, *srel;
4940 Elf_Internal_Rela outrel;
4941 bfd_byte *loc;
4942 bfd_vma got_addr, plt_addr;
4943 bfd_vma plt_index;
4944 struct alpha_elf_got_entry *gotent;
4945
4946 BFD_ASSERT (h->dynindx != -1);
4947
4948 /* The first .got entry will be updated by the .plt with the
4949 address of the target function. */
4950 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4951 BFD_ASSERT (gotent && gotent->addend == 0);
4952
4953 splt = bfd_get_section_by_name (dynobj, ".plt");
4954 BFD_ASSERT (splt != NULL);
4955 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4956 BFD_ASSERT (srel != NULL);
4957 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4958 BFD_ASSERT (sgot != NULL);
4959
4960 got_addr = (sgot->output_section->vma
4961 + sgot->output_offset
4962 + gotent->got_offset);
4963 plt_addr = (splt->output_section->vma
4964 + splt->output_offset
4965 + h->plt.offset);
4966
4967 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4968
4969 /* Fill in the entry in the procedure linkage table. */
4970 {
4971 bfd_vma insn1, insn2, insn3;
4972
4973 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
4974 insn2 = PLT_ENTRY_WORD2;
4975 insn3 = PLT_ENTRY_WORD3;
4976
4977 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
4978 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
4979 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
4980 }
4981
4982 /* Fill in the entry in the .rela.plt section. */
4983 outrel.r_offset = got_addr;
4984 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4985 outrel.r_addend = 0;
4986
4987 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4988 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4989
4990 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
4991 {
4992 /* Mark the symbol as undefined, rather than as defined in the
4993 .plt section. Leave the value alone. */
4994 sym->st_shndx = SHN_UNDEF;
4995 }
4996
4997 /* Fill in the entries in the .got. */
4998 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
4999
5000 /* Subsequent .got entries will continue to bounce through the .plt. */
5001 if (gotent->next)
5002 {
5003 srel = bfd_get_section_by_name (dynobj, ".rela.got");
5004 BFD_ASSERT (! info->shared || srel != NULL);
5005
5006 gotent = gotent->next;
5007 do
5008 {
5009 sgot = alpha_elf_tdata(gotent->gotobj)->got;
5010 BFD_ASSERT(sgot != NULL);
5011 BFD_ASSERT(gotent->addend == 0);
5012
5013 bfd_put_64 (output_bfd, plt_addr,
5014 sgot->contents + gotent->got_offset);
5015
5016 if (info->shared)
5017 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
5018 gotent->got_offset, 0,
5019 R_ALPHA_RELATIVE, plt_addr);
5020
5021 gotent = gotent->next;
5022 }
5023 while (gotent != NULL);
5024 }
5025 }
5026 else if (alpha_elf_dynamic_symbol_p (h, info))
5027 {
5028 /* Fill in the dynamic relocations for this symbol's .got entries. */
5029 asection *srel;
5030 struct alpha_elf_got_entry *gotent;
5031
5032 srel = bfd_get_section_by_name (dynobj, ".rela.got");
5033 BFD_ASSERT (srel != NULL);
5034
5035 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
5036 gotent != NULL;
5037 gotent = gotent->next)
5038 {
5039 asection *sgot;
5040 long r_type;
5041
5042 if (gotent->use_count == 0)
5043 continue;
5044
5045 sgot = alpha_elf_tdata (gotent->gotobj)->got;
5046
5047 r_type = gotent->reloc_type;
5048 switch (r_type)
5049 {
5050 case R_ALPHA_LITERAL:
5051 r_type = R_ALPHA_GLOB_DAT;
5052 break;
5053 case R_ALPHA_TLSGD:
5054 r_type = R_ALPHA_DTPMOD64;
5055 break;
5056 case R_ALPHA_GOTDTPREL:
5057 r_type = R_ALPHA_DTPREL64;
5058 break;
5059 case R_ALPHA_GOTTPREL:
5060 r_type = R_ALPHA_TPREL64;
5061 break;
5062 case R_ALPHA_TLSLDM:
5063 default:
5064 abort ();
5065 }
5066
5067 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
5068 gotent->got_offset, h->dynindx,
5069 r_type, gotent->addend);
5070
5071 if (gotent->reloc_type == R_ALPHA_TLSGD)
5072 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
5073 gotent->got_offset + 8, h->dynindx,
5074 R_ALPHA_DTPREL64, gotent->addend);
5075 }
5076 }
5077
5078 /* Mark some specially defined symbols as absolute. */
5079 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5080 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
5081 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
5082 sym->st_shndx = SHN_ABS;
5083
5084 return TRUE;
5085 }
5086
5087 /* Finish up the dynamic sections. */
5088
5089 static bfd_boolean
5090 elf64_alpha_finish_dynamic_sections (output_bfd, info)
5091 bfd *output_bfd;
5092 struct bfd_link_info *info;
5093 {
5094 bfd *dynobj;
5095 asection *sdyn;
5096
5097 dynobj = elf_hash_table (info)->dynobj;
5098 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5099
5100 if (elf_hash_table (info)->dynamic_sections_created)
5101 {
5102 asection *splt;
5103 Elf64_External_Dyn *dyncon, *dynconend;
5104
5105 splt = bfd_get_section_by_name (dynobj, ".plt");
5106 BFD_ASSERT (splt != NULL && sdyn != NULL);
5107
5108 dyncon = (Elf64_External_Dyn *) sdyn->contents;
5109 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
5110 for (; dyncon < dynconend; dyncon++)
5111 {
5112 Elf_Internal_Dyn dyn;
5113 const char *name;
5114 asection *s;
5115
5116 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
5117
5118 switch (dyn.d_tag)
5119 {
5120 case DT_PLTGOT:
5121 name = ".plt";
5122 goto get_vma;
5123 case DT_PLTRELSZ:
5124 name = ".rela.plt";
5125 goto get_size;
5126 case DT_JMPREL:
5127 name = ".rela.plt";
5128 goto get_vma;
5129
5130 case DT_RELASZ:
5131 /* My interpretation of the TIS v1.1 ELF document indicates
5132 that RELASZ should not include JMPREL. This is not what
5133 the rest of the BFD does. It is, however, what the
5134 glibc ld.so wants. Do this fixup here until we found
5135 out who is right. */
5136 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
5137 if (s)
5138 {
5139 dyn.d_un.d_val -=
5140 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
5141 }
5142 break;
5143
5144 get_vma:
5145 s = bfd_get_section_by_name (output_bfd, name);
5146 dyn.d_un.d_ptr = (s ? s->vma : 0);
5147 break;
5148
5149 get_size:
5150 s = bfd_get_section_by_name (output_bfd, name);
5151 dyn.d_un.d_val =
5152 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
5153 break;
5154 }
5155
5156 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5157 }
5158
5159 /* Initialize the PLT0 entry. */
5160 if (splt->_raw_size > 0)
5161 {
5162 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
5163 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
5164 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
5165 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
5166
5167 /* The next two words will be filled in by ld.so */
5168 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
5169 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
5170
5171 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5172 }
5173 }
5174
5175 return TRUE;
5176 }
5177
5178 /* We need to use a special link routine to handle the .mdebug section.
5179 We need to merge all instances of these sections together, not write
5180 them all out sequentially. */
5181
5182 static bfd_boolean
5183 elf64_alpha_final_link (abfd, info)
5184 bfd *abfd;
5185 struct bfd_link_info *info;
5186 {
5187 asection *o;
5188 struct bfd_link_order *p;
5189 asection *mdebug_sec;
5190 struct ecoff_debug_info debug;
5191 const struct ecoff_debug_swap *swap
5192 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5193 HDRR *symhdr = &debug.symbolic_header;
5194 PTR mdebug_handle = NULL;
5195
5196 /* Go through the sections and collect the mdebug information. */
5197 mdebug_sec = NULL;
5198 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5199 {
5200 if (strcmp (o->name, ".mdebug") == 0)
5201 {
5202 struct extsym_info einfo;
5203
5204 /* We have found the .mdebug section in the output file.
5205 Look through all the link_orders comprising it and merge
5206 the information together. */
5207 symhdr->magic = swap->sym_magic;
5208 /* FIXME: What should the version stamp be? */
5209 symhdr->vstamp = 0;
5210 symhdr->ilineMax = 0;
5211 symhdr->cbLine = 0;
5212 symhdr->idnMax = 0;
5213 symhdr->ipdMax = 0;
5214 symhdr->isymMax = 0;
5215 symhdr->ioptMax = 0;
5216 symhdr->iauxMax = 0;
5217 symhdr->issMax = 0;
5218 symhdr->issExtMax = 0;
5219 symhdr->ifdMax = 0;
5220 symhdr->crfd = 0;
5221 symhdr->iextMax = 0;
5222
5223 /* We accumulate the debugging information itself in the
5224 debug_info structure. */
5225 debug.line = NULL;
5226 debug.external_dnr = NULL;
5227 debug.external_pdr = NULL;
5228 debug.external_sym = NULL;
5229 debug.external_opt = NULL;
5230 debug.external_aux = NULL;
5231 debug.ss = NULL;
5232 debug.ssext = debug.ssext_end = NULL;
5233 debug.external_fdr = NULL;
5234 debug.external_rfd = NULL;
5235 debug.external_ext = debug.external_ext_end = NULL;
5236
5237 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5238 if (mdebug_handle == (PTR) NULL)
5239 return FALSE;
5240
5241 if (1)
5242 {
5243 asection *s;
5244 EXTR esym;
5245 bfd_vma last = 0;
5246 unsigned int i;
5247 static const char * const name[] =
5248 {
5249 ".text", ".init", ".fini", ".data",
5250 ".rodata", ".sdata", ".sbss", ".bss"
5251 };
5252 static const int sc[] = { scText, scInit, scFini, scData,
5253 scRData, scSData, scSBss, scBss };
5254
5255 esym.jmptbl = 0;
5256 esym.cobol_main = 0;
5257 esym.weakext = 0;
5258 esym.reserved = 0;
5259 esym.ifd = ifdNil;
5260 esym.asym.iss = issNil;
5261 esym.asym.st = stLocal;
5262 esym.asym.reserved = 0;
5263 esym.asym.index = indexNil;
5264 for (i = 0; i < 8; i++)
5265 {
5266 esym.asym.sc = sc[i];
5267 s = bfd_get_section_by_name (abfd, name[i]);
5268 if (s != NULL)
5269 {
5270 esym.asym.value = s->vma;
5271 last = s->vma + s->_raw_size;
5272 }
5273 else
5274 esym.asym.value = last;
5275
5276 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5277 name[i], &esym))
5278 return FALSE;
5279 }
5280 }
5281
5282 for (p = o->link_order_head;
5283 p != (struct bfd_link_order *) NULL;
5284 p = p->next)
5285 {
5286 asection *input_section;
5287 bfd *input_bfd;
5288 const struct ecoff_debug_swap *input_swap;
5289 struct ecoff_debug_info input_debug;
5290 char *eraw_src;
5291 char *eraw_end;
5292
5293 if (p->type != bfd_indirect_link_order)
5294 {
5295 if (p->type == bfd_data_link_order)
5296 continue;
5297 abort ();
5298 }
5299
5300 input_section = p->u.indirect.section;
5301 input_bfd = input_section->owner;
5302
5303 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
5304 || (get_elf_backend_data (input_bfd)
5305 ->elf_backend_ecoff_debug_swap) == NULL)
5306 {
5307 /* I don't know what a non ALPHA ELF bfd would be
5308 doing with a .mdebug section, but I don't really
5309 want to deal with it. */
5310 continue;
5311 }
5312
5313 input_swap = (get_elf_backend_data (input_bfd)
5314 ->elf_backend_ecoff_debug_swap);
5315
5316 BFD_ASSERT (p->size == input_section->_raw_size);
5317
5318 /* The ECOFF linking code expects that we have already
5319 read in the debugging information and set up an
5320 ecoff_debug_info structure, so we do that now. */
5321 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5322 &input_debug))
5323 return FALSE;
5324
5325 if (! (bfd_ecoff_debug_accumulate
5326 (mdebug_handle, abfd, &debug, swap, input_bfd,
5327 &input_debug, input_swap, info)))
5328 return FALSE;
5329
5330 /* Loop through the external symbols. For each one with
5331 interesting information, try to find the symbol in
5332 the linker global hash table and save the information
5333 for the output external symbols. */
5334 eraw_src = input_debug.external_ext;
5335 eraw_end = (eraw_src
5336 + (input_debug.symbolic_header.iextMax
5337 * input_swap->external_ext_size));
5338 for (;
5339 eraw_src < eraw_end;
5340 eraw_src += input_swap->external_ext_size)
5341 {
5342 EXTR ext;
5343 const char *name;
5344 struct alpha_elf_link_hash_entry *h;
5345
5346 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
5347 if (ext.asym.sc == scNil
5348 || ext.asym.sc == scUndefined
5349 || ext.asym.sc == scSUndefined)
5350 continue;
5351
5352 name = input_debug.ssext + ext.asym.iss;
5353 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
5354 name, FALSE, FALSE, TRUE);
5355 if (h == NULL || h->esym.ifd != -2)
5356 continue;
5357
5358 if (ext.ifd != -1)
5359 {
5360 BFD_ASSERT (ext.ifd
5361 < input_debug.symbolic_header.ifdMax);
5362 ext.ifd = input_debug.ifdmap[ext.ifd];
5363 }
5364
5365 h->esym = ext;
5366 }
5367
5368 /* Free up the information we just read. */
5369 free (input_debug.line);
5370 free (input_debug.external_dnr);
5371 free (input_debug.external_pdr);
5372 free (input_debug.external_sym);
5373 free (input_debug.external_opt);
5374 free (input_debug.external_aux);
5375 free (input_debug.ss);
5376 free (input_debug.ssext);
5377 free (input_debug.external_fdr);
5378 free (input_debug.external_rfd);
5379 free (input_debug.external_ext);
5380
5381 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5382 elf_link_input_bfd ignores this section. */
5383 input_section->flags &=~ SEC_HAS_CONTENTS;
5384 }
5385
5386 /* Build the external symbol information. */
5387 einfo.abfd = abfd;
5388 einfo.info = info;
5389 einfo.debug = &debug;
5390 einfo.swap = swap;
5391 einfo.failed = FALSE;
5392 elf_link_hash_traverse (elf_hash_table (info),
5393 elf64_alpha_output_extsym,
5394 (PTR) &einfo);
5395 if (einfo.failed)
5396 return FALSE;
5397
5398 /* Set the size of the .mdebug section. */
5399 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
5400
5401 /* Skip this section later on (I don't think this currently
5402 matters, but someday it might). */
5403 o->link_order_head = (struct bfd_link_order *) NULL;
5404
5405 mdebug_sec = o;
5406 }
5407 }
5408
5409 /* Invoke the regular ELF backend linker to do all the work. */
5410 if (! bfd_elf64_bfd_final_link (abfd, info))
5411 return FALSE;
5412
5413 /* Now write out the computed sections. */
5414
5415 /* The .got subsections... */
5416 {
5417 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5418 for (i = alpha_elf_hash_table(info)->got_list;
5419 i != NULL;
5420 i = alpha_elf_tdata(i)->got_link_next)
5421 {
5422 asection *sgot;
5423
5424 /* elf_bfd_final_link already did everything in dynobj. */
5425 if (i == dynobj)
5426 continue;
5427
5428 sgot = alpha_elf_tdata(i)->got;
5429 if (! bfd_set_section_contents (abfd, sgot->output_section,
5430 sgot->contents,
5431 (file_ptr) sgot->output_offset,
5432 sgot->_raw_size))
5433 return FALSE;
5434 }
5435 }
5436
5437 if (mdebug_sec != (asection *) NULL)
5438 {
5439 BFD_ASSERT (abfd->output_has_begun);
5440 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5441 swap, info,
5442 mdebug_sec->filepos))
5443 return FALSE;
5444
5445 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5446 }
5447
5448 return TRUE;
5449 }
5450
5451 static enum elf_reloc_type_class
5452 elf64_alpha_reloc_type_class (rela)
5453 const Elf_Internal_Rela *rela;
5454 {
5455 switch ((int) ELF64_R_TYPE (rela->r_info))
5456 {
5457 case R_ALPHA_RELATIVE:
5458 return reloc_class_relative;
5459 case R_ALPHA_JMP_SLOT:
5460 return reloc_class_plt;
5461 case R_ALPHA_COPY:
5462 return reloc_class_copy;
5463 default:
5464 return reloc_class_normal;
5465 }
5466 }
5467 \f
5468 static struct bfd_elf_special_section const elf64_alpha_special_sections[]=
5469 {
5470 { ".sdata", 0, NULL, 0,
5471 SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5472 { ".sbss", 0, NULL, 0,
5473 SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5474 { NULL, 0, NULL, 0,
5475 0, 0 }
5476 };
5477
5478 /* ECOFF swapping routines. These are used when dealing with the
5479 .mdebug section, which is in the ECOFF debugging format. Copied
5480 from elf32-mips.c. */
5481 static const struct ecoff_debug_swap
5482 elf64_alpha_ecoff_debug_swap =
5483 {
5484 /* Symbol table magic number. */
5485 magicSym2,
5486 /* Alignment of debugging information. E.g., 4. */
5487 8,
5488 /* Sizes of external symbolic information. */
5489 sizeof (struct hdr_ext),
5490 sizeof (struct dnr_ext),
5491 sizeof (struct pdr_ext),
5492 sizeof (struct sym_ext),
5493 sizeof (struct opt_ext),
5494 sizeof (struct fdr_ext),
5495 sizeof (struct rfd_ext),
5496 sizeof (struct ext_ext),
5497 /* Functions to swap in external symbolic data. */
5498 ecoff_swap_hdr_in,
5499 ecoff_swap_dnr_in,
5500 ecoff_swap_pdr_in,
5501 ecoff_swap_sym_in,
5502 ecoff_swap_opt_in,
5503 ecoff_swap_fdr_in,
5504 ecoff_swap_rfd_in,
5505 ecoff_swap_ext_in,
5506 _bfd_ecoff_swap_tir_in,
5507 _bfd_ecoff_swap_rndx_in,
5508 /* Functions to swap out external symbolic data. */
5509 ecoff_swap_hdr_out,
5510 ecoff_swap_dnr_out,
5511 ecoff_swap_pdr_out,
5512 ecoff_swap_sym_out,
5513 ecoff_swap_opt_out,
5514 ecoff_swap_fdr_out,
5515 ecoff_swap_rfd_out,
5516 ecoff_swap_ext_out,
5517 _bfd_ecoff_swap_tir_out,
5518 _bfd_ecoff_swap_rndx_out,
5519 /* Function to read in symbolic data. */
5520 elf64_alpha_read_ecoff_info
5521 };
5522 \f
5523 /* Use a non-standard hash bucket size of 8. */
5524
5525 static const struct elf_size_info alpha_elf_size_info =
5526 {
5527 sizeof (Elf64_External_Ehdr),
5528 sizeof (Elf64_External_Phdr),
5529 sizeof (Elf64_External_Shdr),
5530 sizeof (Elf64_External_Rel),
5531 sizeof (Elf64_External_Rela),
5532 sizeof (Elf64_External_Sym),
5533 sizeof (Elf64_External_Dyn),
5534 sizeof (Elf_External_Note),
5535 8,
5536 1,
5537 64, 3,
5538 ELFCLASS64, EV_CURRENT,
5539 bfd_elf64_write_out_phdrs,
5540 bfd_elf64_write_shdrs_and_ehdr,
5541 bfd_elf64_write_relocs,
5542 bfd_elf64_swap_symbol_in,
5543 bfd_elf64_swap_symbol_out,
5544 bfd_elf64_slurp_reloc_table,
5545 bfd_elf64_slurp_symbol_table,
5546 bfd_elf64_swap_dyn_in,
5547 bfd_elf64_swap_dyn_out,
5548 bfd_elf64_swap_reloc_in,
5549 bfd_elf64_swap_reloc_out,
5550 bfd_elf64_swap_reloca_in,
5551 bfd_elf64_swap_reloca_out
5552 };
5553
5554 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5555 #define TARGET_LITTLE_NAME "elf64-alpha"
5556 #define ELF_ARCH bfd_arch_alpha
5557 #define ELF_MACHINE_CODE EM_ALPHA
5558 #define ELF_MAXPAGESIZE 0x10000
5559
5560 #define bfd_elf64_bfd_link_hash_table_create \
5561 elf64_alpha_bfd_link_hash_table_create
5562
5563 #define bfd_elf64_bfd_reloc_type_lookup \
5564 elf64_alpha_bfd_reloc_type_lookup
5565 #define elf_info_to_howto \
5566 elf64_alpha_info_to_howto
5567
5568 #define bfd_elf64_mkobject \
5569 elf64_alpha_mkobject
5570 #define elf_backend_object_p \
5571 elf64_alpha_object_p
5572
5573 #define elf_backend_section_from_shdr \
5574 elf64_alpha_section_from_shdr
5575 #define elf_backend_section_flags \
5576 elf64_alpha_section_flags
5577 #define elf_backend_fake_sections \
5578 elf64_alpha_fake_sections
5579
5580 #define bfd_elf64_bfd_is_local_label_name \
5581 elf64_alpha_is_local_label_name
5582 #define bfd_elf64_find_nearest_line \
5583 elf64_alpha_find_nearest_line
5584 #define bfd_elf64_bfd_relax_section \
5585 elf64_alpha_relax_section
5586
5587 #define elf_backend_add_symbol_hook \
5588 elf64_alpha_add_symbol_hook
5589 #define elf_backend_check_relocs \
5590 elf64_alpha_check_relocs
5591 #define elf_backend_create_dynamic_sections \
5592 elf64_alpha_create_dynamic_sections
5593 #define elf_backend_adjust_dynamic_symbol \
5594 elf64_alpha_adjust_dynamic_symbol
5595 #define elf_backend_always_size_sections \
5596 elf64_alpha_always_size_sections
5597 #define elf_backend_size_dynamic_sections \
5598 elf64_alpha_size_dynamic_sections
5599 #define elf_backend_relocate_section \
5600 elf64_alpha_relocate_section
5601 #define elf_backend_finish_dynamic_symbol \
5602 elf64_alpha_finish_dynamic_symbol
5603 #define elf_backend_finish_dynamic_sections \
5604 elf64_alpha_finish_dynamic_sections
5605 #define bfd_elf64_bfd_final_link \
5606 elf64_alpha_final_link
5607 #define elf_backend_reloc_type_class \
5608 elf64_alpha_reloc_type_class
5609
5610 #define elf_backend_ecoff_debug_swap \
5611 &elf64_alpha_ecoff_debug_swap
5612
5613 #define elf_backend_size_info \
5614 alpha_elf_size_info
5615
5616 #define elf_backend_special_sections \
5617 elf64_alpha_special_sections
5618
5619 /* A few constants that determine how the .plt section is set up. */
5620 #define elf_backend_want_got_plt 0
5621 #define elf_backend_plt_readonly 0
5622 #define elf_backend_want_plt_sym 1
5623 #define elf_backend_got_header_size 0
5624 #define elf_backend_plt_header_size PLT_HEADER_SIZE
5625
5626 #include "elf64-target.h"
5627 \f
5628 /* FreeBSD support. */
5629
5630 #undef TARGET_LITTLE_SYM
5631 #define TARGET_LITTLE_SYM bfd_elf64_alpha_freebsd_vec
5632 #undef TARGET_LITTLE_NAME
5633 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5634
5635 /* The kernel recognizes executables as valid only if they carry a
5636 "FreeBSD" label in the ELF header. So we put this label on all
5637 executables and (for simplicity) also all other object files. */
5638
5639 static void elf64_alpha_fbsd_post_process_headers
5640 PARAMS ((bfd *, struct bfd_link_info *));
5641
5642 static void
5643 elf64_alpha_fbsd_post_process_headers (abfd, link_info)
5644 bfd * abfd;
5645 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
5646 {
5647 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
5648
5649 i_ehdrp = elf_elfheader (abfd);
5650
5651 /* Put an ABI label supported by FreeBSD >= 4.1. */
5652 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
5653 #ifdef OLD_FREEBSD_ABI_LABEL
5654 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5655 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5656 #endif
5657 }
5658
5659 #undef elf_backend_post_process_headers
5660 #define elf_backend_post_process_headers \
5661 elf64_alpha_fbsd_post_process_headers
5662
5663 #undef elf64_bed
5664 #define elf64_bed elf64_alpha_fbsd_bed
5665
5666 #include "elf64-target.h"
This page took 0.141348 seconds and 5 git commands to generate.