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