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