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