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