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