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