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