]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf64-alpha.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* aout-adobe.c: Don't compare against "true" or "false.
[thirdparty/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;
9ad5cbcf 2040 Elf_Internal_Shdr *shndx_hdr;
252b5132
RH		 2041 Elf_Internal_Rela *internal_relocs;
2042 Elf_Internal_Rela *free_relocs = NULL;
2043 Elf_Internal_Rela *irel, *irelend;
2044 bfd_byte *free_contents = NULL;
9e756d64 2045 Elf64_External_Sym *extsyms;
252b5132 2046 Elf64_External_Sym *free_extsyms = NULL;
9ad5cbcf 2047 Elf_External_Sym_Shndx *shndx_buf = NULL;
252b5132
RH		 2048 struct alpha_elf_got_entry **local_got_entries;
2049 struct alpha_relax_info info;
9e756d64 2050 struct elf_link_tls_segment tls_segment;
252b5132
RH		 2051
2052 /* We are not currently changing any sizes, so only one pass. */
2053 *again = false;
2054
2055 if (link_info->relocateable
2056 || (sec->flags & SEC_RELOC) == 0
2057 || sec->reloc_count == 0)
2058 return true;
2059
2060 /* If this is the first time we have been called for this section,
2061 initialize the cooked size. */
2062 if (sec->_cooked_size == 0)
2063 sec->_cooked_size = sec->_raw_size;
2064
2065 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2066 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2067
2068 /* Load the relocations for this section. */
2069 internal_relocs = (_bfd_elf64_link_read_relocs
2070 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2071 link_info->keep_memory));
2072 if (internal_relocs == NULL)
2073 goto error_return;
2074 if (! link_info->keep_memory)
2075 free_relocs = internal_relocs;
2076
fe8bc63d 2077 memset(&info, 0, sizeof (info));
252b5132
RH		 2078 info.abfd = abfd;
2079 info.sec = sec;
2080 info.link_info = link_info;
9e756d64 2081 info.symtab_hdr = symtab_hdr;
252b5132
RH		 2082 info.relocs = internal_relocs;
2083 info.relend = irelend = internal_relocs + sec->reloc_count;
2084
cedb70c5 2085 /* Find the GP for this object. Do not store the result back via
b646261c 2086 _bfd_set_gp_value, since this could change again before final. */
252b5132
RH		 2087 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
2088 if (info.gotobj)
2089 {
2090 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
b646261c
RH		 2091 info.gp = (sgot->output_section->vma
2092 + sgot->output_offset
2093 + 0x8000);
252b5132
RH		 2094 }
2095
9e756d64
RH		 2096 /* Get the section contents. */
2097 if (elf_section_data (sec)->this_hdr.contents != NULL)
2098 info.contents = elf_section_data (sec)->this_hdr.contents;
2099 else
252b5132 2100 {
9e756d64 2101 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
252b5132 2102 if (info.contents == NULL)
9e756d64
RH		 2103 goto error_return;
2104 free_contents = info.contents;
252b5132 2105
9e756d64
RH		 2106 if (! bfd_get_section_contents (abfd, sec, info.contents,
2107 (file_ptr) 0, sec->_raw_size))
2108 goto error_return;
2109 }
252b5132 2110
9e756d64
RH		 2111 /* Read this BFD's symbols. */
2112 if (symtab_hdr->contents != NULL)
2113 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
2114 else
2115 {
2116 bfd_size_type amt = symtab_hdr->sh_info * sizeof (Elf64_External_Sym);
2117 extsyms = (Elf64_External_Sym *) bfd_malloc (amt);
252b5132 2118 if (extsyms == NULL)
9e756d64
RH		 2119 goto error_return;
2120 free_extsyms = extsyms;
2121 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2122 || bfd_bread ((PTR) extsyms, amt, abfd) != amt)
2123 goto error_return;
2124 }
9ad5cbcf 2125
9e756d64
RH		 2126 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2127 if (shndx_hdr->sh_size != 0)
2128 {
2129 bfd_size_type amt;
2130 amt = symtab_hdr->sh_info * sizeof (Elf_External_Sym_Shndx);
2131 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2132 if (shndx_buf == NULL)
2133 goto error_return;
2134 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2135 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
2136 goto error_return;
2137 }
9ad5cbcf 2138
9e756d64
RH		 2139 /* Compute the TLS segment information. The version normally found in
2140 elf_hash_table (link_info)->tls_segment isn't built until final_link.
2141 ??? Probably should look into extracting this into a common function. */
2142 info.tls_segment = elf64_alpha_relax_find_tls_segment (&info, &tls_segment);
2143
2144 for (irel = internal_relocs; irel < irelend; irel++)
2145 {
2146 bfd_vma symval;
2147 Elf_Internal_Sym isym;
2148 struct alpha_elf_got_entry *gotent;
2149 unsigned long r_type = ELF64_R_TYPE (irel->r_info);
2150
2151 /* Early exit for unhandled or unrelaxable relocations. */
2152 switch (r_type)
2153 {
2154 case R_ALPHA_LITERAL:
2155 case R_ALPHA_GPRELHIGH:
2156 case R_ALPHA_GPRELLOW:
2157 case R_ALPHA_GOTDTPREL:
2158 case R_ALPHA_GOTTPREL:
2159 case R_ALPHA_TLSGD:
2160 case R_ALPHA_TLSLDM:
2161 break;
2162 default:
2163 continue;
252b5132
RH		 2164 }
2165
2166 /* Get the value of the symbol referred to by the reloc. */
2167 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2168 {
2169 /* A local symbol. */
9ad5cbcf
AM		 2170 Elf64_External_Sym *esym;
2171 Elf_External_Sym_Shndx *shndx;
2172
2173 esym = extsyms + ELF64_R_SYM (irel->r_info);
2174 shndx = shndx_buf + (shndx_buf ? ELF64_R_SYM (irel->r_info) : 0);
f8ecb12b
AM		 2175 bfd_elf64_swap_symbol_in (abfd, (const PTR) esym, (const PTR) shndx,
2176 &isym);
252b5132 2177 if (isym.st_shndx == SHN_UNDEF)
4a67a098 2178 continue;
252b5132
RH		 2179 else if (isym.st_shndx == SHN_ABS)
2180 info.tsec = bfd_abs_section_ptr;
2181 else if (isym.st_shndx == SHN_COMMON)
2182 info.tsec = bfd_com_section_ptr;
fe8bc63d 2183 else
9ad5cbcf 2184 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
252b5132
RH		 2185
2186 info.h = NULL;
2187 info.other = isym.st_other;
9e756d64 2188 info.first_gotent = &local_got_entries[ELF64_R_SYM(irel->r_info)];
252b5132
RH		 2189 symval = isym.st_value;
2190 }
2191 else
2192 {
2193 unsigned long indx;
2194 struct alpha_elf_link_hash_entry *h;
2195
2196 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2197 h = alpha_elf_sym_hashes (abfd)[indx];
2198 BFD_ASSERT (h != NULL);
2199
2200 while (h->root.root.type == bfd_link_hash_indirect
2201 || h->root.root.type == bfd_link_hash_warning)
2202 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2203
4a67a098
RH		 2204 /* If the symbol is undefined, we can't do anything with it. */
2205 if (h->root.root.type == bfd_link_hash_undefweak
2206 || h->root.root.type == bfd_link_hash_undefined)
2207 continue;
2208
2209 /* If the symbol isn't defined in the current module, again
2210 we can't do anything. */
2211 if (!(h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2212 continue;
2213
252b5132 2214 info.h = h;
252b5132
RH		 2215 info.tsec = h->root.root.u.def.section;
2216 info.other = h->root.other;
9e756d64 2217 info.first_gotent = &h->got_entries;
252b5132
RH		 2218 symval = h->root.root.u.def.value;
2219 }
2220
2221 /* Search for the got entry to be used by this relocation. */
9e756d64
RH		 2222 for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
2223 if (gotent->gotobj == info.gotobj
2224 && gotent->reloc_type == r_type
2225 && gotent->addend == irel->r_addend)
2226 break;
252b5132
RH		 2227 info.gotent = gotent;
2228
2229 symval += info.tsec->output_section->vma + info.tsec->output_offset;
2230 symval += irel->r_addend;
2231
9e756d64
RH		 2232 switch (r_type)
2233 {
2234 case R_ALPHA_LITERAL:
2235 BFD_ASSERT(info.gotent != NULL);
252b5132 2236
9e756d64
RH		 2237 /* If there exist LITUSE relocations immediately following, this
2238 opens up all sorts of interesting optimizations, because we
2239 now know every location that this address load is used. */
2240 if (irel+1 < irelend
2241 && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
2242 {
2243 if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
2244 goto error_return;
2245 }
2246 else
2247 {
2248 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
2249 goto error_return;
2250 }
2251 break;
252b5132 2252
9e756d64
RH		 2253 case R_ALPHA_GPRELHIGH:
2254 case R_ALPHA_GPRELLOW:
2255 if (!elf64_alpha_relax_gprelhilo (&info, symval, irel,
2256 r_type == R_ALPHA_GPRELHIGH))
252b5132 2257 goto error_return;
9e756d64
RH		 2258 break;
2259
2260 case R_ALPHA_GOTDTPREL:
2261 case R_ALPHA_GOTTPREL:
2262 BFD_ASSERT(info.gotent != NULL);
2263 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
252b5132 2264 goto error_return;
9e756d64
RH		 2265 break;
2266
2267 case R_ALPHA_TLSGD:
2268 case R_ALPHA_TLSLDM:
2269 BFD_ASSERT(info.gotent != NULL);
2270 if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
2271 r_type == R_ALPHA_TLSGD))
2272 goto error_return;
2273 break;
252b5132
RH		 2274 }
2275 }
2276
f44f99a5
RH		 2277 if (!elf64_alpha_size_plt_section (link_info))
2278 return false;
2279 if (!elf64_alpha_size_got_sections (link_info))
2280 return false;
2281 if (!elf64_alpha_size_rela_got_section (link_info))
252b5132
RH		 2282 return false;
2283
2284 if (info.changed_relocs)
9e756d64 2285 elf_section_data (sec)->relocs = internal_relocs;
252b5132 2286 else if (free_relocs != NULL)
9e756d64 2287 free (free_relocs);
252b5132
RH		 2288
2289 if (info.changed_contents)
9e756d64 2290 elf_section_data (sec)->this_hdr.contents = info.contents;
252b5132
RH		 2291 else if (free_contents != NULL)
2292 {
2293 if (! link_info->keep_memory)
2294 free (free_contents);
2295 else
2296 {
2297 /* Cache the section contents for elf_link_input_bfd. */
2298 elf_section_data (sec)->this_hdr.contents = info.contents;
2299 }
2300 }
2301
9ad5cbcf
AM		 2302 if (shndx_buf != NULL)
2303 free (shndx_buf);
2304
252b5132
RH		 2305 if (free_extsyms != NULL)
2306 {
2307 if (! link_info->keep_memory)
2308 free (free_extsyms);
2309 else
2310 {
2311 /* Cache the symbols for elf_link_input_bfd. */
973ffd63 2312 symtab_hdr->contents = (unsigned char *) extsyms;
252b5132
RH		 2313 }
2314 }
2315
2316 *again = info.changed_contents || info.changed_relocs;
2317
2318 return true;
2319
2320 error_return:
2321 if (free_relocs != NULL)
2322 free (free_relocs);
2323 if (free_contents != NULL)
2324 free (free_contents);
9ad5cbcf
AM		 2325 if (shndx_buf != NULL)
2326 free (shndx_buf);
252b5132
RH		 2327 if (free_extsyms != NULL)
2328 free (free_extsyms);
2329 return false;
2330}
2331\f
2332/* PLT/GOT Stuff */
2333#define PLT_HEADER_SIZE 32
dc810e39
AM		 2334#define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
2335#define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
2336#define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
2337#define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
252b5132
RH		 2338
2339#define PLT_ENTRY_SIZE 12
2340#define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
2341#define PLT_ENTRY_WORD2 0
2342#define PLT_ENTRY_WORD3 0
2343
3765b1be 2344#define MAX_GOT_SIZE (64*1024)
252b5132
RH		 2345
2346#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
2347\f
2348/* Handle an Alpha specific section when reading an object file. This
2349 is called when elfcode.h finds a section with an unknown type.
2350 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
2351 how to. */
2352
2353static boolean
2354elf64_alpha_section_from_shdr (abfd, hdr, name)
2355 bfd *abfd;
2356 Elf64_Internal_Shdr *hdr;
90937f86 2357 const char *name;
252b5132
RH		 2358{
2359 asection *newsect;
2360
2361 /* There ought to be a place to keep ELF backend specific flags, but
2362 at the moment there isn't one. We just keep track of the
2363 sections by their name, instead. Fortunately, the ABI gives
2364 suggested names for all the MIPS specific sections, so we will
2365 probably get away with this. */
2366 switch (hdr->sh_type)
2367 {
2368 case SHT_ALPHA_DEBUG:
2369 if (strcmp (name, ".mdebug") != 0)
2370 return false;
2371 break;
252b5132
RH		 2372 default:
2373 return false;
2374 }
2375
2376 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2377 return false;
2378 newsect = hdr->bfd_section;
2379
2380 if (hdr->sh_type == SHT_ALPHA_DEBUG)
2381 {
2382 if (! bfd_set_section_flags (abfd, newsect,
2383 (bfd_get_section_flags (abfd, newsect)
2384 | SEC_DEBUGGING)))
2385 return false;
2386 }
2387
252b5132
RH		 2388 return true;
2389}
2390
204692d7
RH		 2391/* Convert Alpha specific section flags to bfd internal section flags. */
2392
2393static boolean
2394elf64_alpha_section_flags (flags, hdr)
2395 flagword *flags;
2396 Elf64_Internal_Shdr *hdr;
2397{
2398 if (hdr->sh_flags & SHF_ALPHA_GPREL)
2399 *flags |= SEC_SMALL_DATA;
2400
2401 return true;
2402}
2403
252b5132
RH		 2404/* Set the correct type for an Alpha ELF section. We do this by the
2405 section name, which is a hack, but ought to work. */
2406
2407static boolean
2408elf64_alpha_fake_sections (abfd, hdr, sec)
2409 bfd *abfd;
2410 Elf64_Internal_Shdr *hdr;
2411 asection *sec;
2412{
2413 register const char *name;
2414
2415 name = bfd_get_section_name (abfd, sec);
2416
2417 if (strcmp (name, ".mdebug") == 0)
2418 {
2419 hdr->sh_type = SHT_ALPHA_DEBUG;
2420 /* In a shared object on Irix 5.3, the .mdebug section has an
2421 entsize of 0. FIXME: Does this matter? */
2422 if ((abfd->flags & DYNAMIC) != 0 )
2423 hdr->sh_entsize = 0;
2424 else
2425 hdr->sh_entsize = 1;
2426 }
204692d7
RH		 2427 else if ((sec->flags & SEC_SMALL_DATA)
2428 || strcmp (name, ".sdata") == 0
252b5132
RH		 2429 || strcmp (name, ".sbss") == 0
2430 || strcmp (name, ".lit4") == 0
2431 || strcmp (name, ".lit8") == 0)
2432 hdr->sh_flags |= SHF_ALPHA_GPREL;
2433
2434 return true;
2435}
2436
2437/* Hook called by the linker routine which adds symbols from an object
2438 file. We use it to put .comm items in .sbss, and not .bss. */
2439
2440static boolean
2441elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2442 bfd *abfd;
2443 struct bfd_link_info *info;
2444 const Elf_Internal_Sym *sym;
56fc028e
AJ		 2445 const char **namep ATTRIBUTE_UNUSED;
2446 flagword *flagsp ATTRIBUTE_UNUSED;
252b5132
RH		 2447 asection **secp;
2448 bfd_vma *valp;
2449{
2450 if (sym->st_shndx == SHN_COMMON
2451 && !info->relocateable
c0846b23 2452 && sym->st_size <= elf_gp_size (abfd))
252b5132
RH		 2453 {
2454 /* Common symbols less than or equal to -G nn bytes are
2455 automatically put into .sbss. */
2456
2457 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
2458
2459 if (scomm == NULL)
2460 {
2461 scomm = bfd_make_section (abfd, ".scommon");
2462 if (scomm == NULL
2463 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
2464 | SEC_IS_COMMON
2465 | SEC_LINKER_CREATED)))
2466 return false;
2467 }
2468
2469 *secp = scomm;
2470 *valp = sym->st_size;
2471 }
2472
2473 return true;
2474}
2475
2476/* Create the .got section. */
2477
2478static boolean
2479elf64_alpha_create_got_section(abfd, info)
2480 bfd *abfd;
56fc028e 2481 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 2482{
2483 asection *s;
2484
2485 if (bfd_get_section_by_name (abfd, ".got"))
2486 return true;
2487
2488 s = bfd_make_section (abfd, ".got");
2489 if (s == NULL
2490 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
2491 | SEC_HAS_CONTENTS
2492 | SEC_IN_MEMORY
2493 | SEC_LINKER_CREATED))
2494 || !bfd_set_section_alignment (abfd, s, 3))
2495 return false;
2496
2497 alpha_elf_tdata (abfd)->got = s;
2498
2499 return true;
2500}
2501
2502/* Create all the dynamic sections. */
2503
2504static boolean
2505elf64_alpha_create_dynamic_sections (abfd, info)
2506 bfd *abfd;
2507 struct bfd_link_info *info;
2508{
2509 asection *s;
2510 struct elf_link_hash_entry *h;
2511
2512 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
2513
2514 s = bfd_make_section (abfd, ".plt");
2515 if (s == NULL
2516 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
2517 | SEC_HAS_CONTENTS
2518 | SEC_IN_MEMORY
2519 | SEC_LINKER_CREATED
2520 | SEC_CODE))
2521 || ! bfd_set_section_alignment (abfd, s, 3))
2522 return false;
2523
2524 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2525 .plt section. */
2526 h = NULL;
2527 if (! (_bfd_generic_link_add_one_symbol
2528 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2529 (bfd_vma) 0, (const char *) NULL, false,
2530 get_elf_backend_data (abfd)->collect,
2531 (struct bfd_link_hash_entry **) &h)))
2532 return false;
2533 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2534 h->type = STT_OBJECT;
2535
2536 if (info->shared
2537 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2538 return false;
2539
2540 s = bfd_make_section (abfd, ".rela.plt");
2541 if (s == NULL
2542 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
2543 | SEC_HAS_CONTENTS
2544 | SEC_IN_MEMORY
2545 | SEC_LINKER_CREATED
2546 | SEC_READONLY))
2547 || ! bfd_set_section_alignment (abfd, s, 3))
2548 return false;
2549
2550 /* We may or may not have created a .got section for this object, but
2551 we definitely havn't done the rest of the work. */
2552
2553 if (!elf64_alpha_create_got_section (abfd, info))
2554 return false;
2555
2556 s = bfd_make_section(abfd, ".rela.got");
2557 if (s == NULL
2558 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
2559 | SEC_HAS_CONTENTS
2560 | SEC_IN_MEMORY
2561 | SEC_LINKER_CREATED
2562 | SEC_READONLY))
2563 || !bfd_set_section_alignment (abfd, s, 3))
2564 return false;
2565
2566 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
2567 dynobj's .got section. We don't do this in the linker script
2568 because we don't want to define the symbol if we are not creating
2569 a global offset table. */
2570 h = NULL;
2571 if (!(_bfd_generic_link_add_one_symbol
2572 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
2573 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
2574 false, get_elf_backend_data (abfd)->collect,
2575 (struct bfd_link_hash_entry **) &h)))
2576 return false;
2577 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2578 h->type = STT_OBJECT;
2579
2580 if (info->shared
2581 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2582 return false;
2583
2584 elf_hash_table (info)->hgot = h;
2585
2586 return true;
2587}
2588\f
2589/* Read ECOFF debugging information from a .mdebug section into a
2590 ecoff_debug_info structure. */
2591
2592static boolean
2593elf64_alpha_read_ecoff_info (abfd, section, debug)
2594 bfd *abfd;
2595 asection *section;
2596 struct ecoff_debug_info *debug;
2597{
2598 HDRR *symhdr;
2599 const struct ecoff_debug_swap *swap;
2600 char *ext_hdr = NULL;
2601
2602 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
fe8bc63d 2603 memset (debug, 0, sizeof (*debug));
252b5132 2604
dc810e39 2605 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
252b5132
RH		 2606 if (ext_hdr == NULL && swap->external_hdr_size != 0)
2607 goto error_return;
2608
82e51918
AM		 2609 if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
2610 swap->external_hdr_size))
252b5132
RH		 2611 goto error_return;
2612
2613 symhdr = &debug->symbolic_header;
2614 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
2615
2616 /* The symbolic header contains absolute file offsets and sizes to
2617 read. */
2618#define READ(ptr, offset, count, size, type) \
2619 if (symhdr->count == 0) \
2620 debug->ptr = NULL; \
2621 else \
2622 { \
dc810e39
AM		 2623 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
2624 debug->ptr = (type) bfd_malloc (amt); \
252b5132
RH		 2625 if (debug->ptr == NULL) \
2626 goto error_return; \
2627 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
dc810e39 2628 || bfd_bread (debug->ptr, amt, abfd) != amt) \
252b5132
RH		 2629 goto error_return; \
2630 }
2631
2632 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
2633 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
2634 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
2635 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
2636 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
2637 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
2638 union aux_ext *);
2639 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
2640 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
2641 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
2642 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
2643 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
2644#undef READ
2645
2646 debug->fdr = NULL;
2647 debug->adjust = NULL;
2648
2649 return true;
2650
2651 error_return:
2652 if (ext_hdr != NULL)
2653 free (ext_hdr);
2654 if (debug->line != NULL)
2655 free (debug->line);
2656 if (debug->external_dnr != NULL)
2657 free (debug->external_dnr);
2658 if (debug->external_pdr != NULL)
2659 free (debug->external_pdr);
2660 if (debug->external_sym != NULL)
2661 free (debug->external_sym);
2662 if (debug->external_opt != NULL)
2663 free (debug->external_opt);
2664 if (debug->external_aux != NULL)
2665 free (debug->external_aux);
2666 if (debug->ss != NULL)
2667 free (debug->ss);
2668 if (debug->ssext != NULL)
2669 free (debug->ssext);
2670 if (debug->external_fdr != NULL)
2671 free (debug->external_fdr);
2672 if (debug->external_rfd != NULL)
2673 free (debug->external_rfd);
2674 if (debug->external_ext != NULL)
2675 free (debug->external_ext);
2676 return false;
2677}
2678
2679/* Alpha ELF local labels start with '$'. */
2680
2681static boolean
2682elf64_alpha_is_local_label_name (abfd, name)
56fc028e 2683 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 2684 const char *name;
2685{
2686 return name[0] == '$';
2687}
2688
2689/* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2690 routine in order to handle the ECOFF debugging information. We
2691 still call this mips_elf_find_line because of the slot
2692 find_line_info in elf_obj_tdata is declared that way. */
2693
2694struct mips_elf_find_line
2695{
2696 struct ecoff_debug_info d;
2697 struct ecoff_find_line i;
2698};
2699
2700static boolean
2701elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2702 functionname_ptr, line_ptr)
2703 bfd *abfd;
2704 asection *section;
2705 asymbol **symbols;
2706 bfd_vma offset;
2707 const char **filename_ptr;
2708 const char **functionname_ptr;
2709 unsigned int *line_ptr;
2710{
2711 asection *msec;
2712
95404643
RH		 2713 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2714 filename_ptr, functionname_ptr,
2715 line_ptr, 0,
2716 &elf_tdata (abfd)->dwarf2_find_line_info))
2717 return true;
2718
252b5132
RH		 2719 msec = bfd_get_section_by_name (abfd, ".mdebug");
2720 if (msec != NULL)
2721 {
2722 flagword origflags;
2723 struct mips_elf_find_line *fi;
2724 const struct ecoff_debug_swap * const swap =
2725 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2726
2727 /* If we are called during a link, alpha_elf_final_link may have
2728 cleared the SEC_HAS_CONTENTS field. We force it back on here
2729 if appropriate (which it normally will be). */
2730 origflags = msec->flags;
2731 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2732 msec->flags |= SEC_HAS_CONTENTS;
2733
2734 fi = elf_tdata (abfd)->find_line_info;
2735 if (fi == NULL)
2736 {
2737 bfd_size_type external_fdr_size;
2738 char *fraw_src;
2739 char *fraw_end;
2740 struct fdr *fdr_ptr;
dc810e39 2741 bfd_size_type amt = sizeof (struct mips_elf_find_line);
252b5132 2742
dc810e39 2743 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
252b5132
RH		 2744 if (fi == NULL)
2745 {
2746 msec->flags = origflags;
2747 return false;
2748 }
2749
2750 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2751 {
2752 msec->flags = origflags;
2753 return false;
2754 }
2755
2756 /* Swap in the FDR information. */
dc810e39
AM		 2757 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2758 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
252b5132
RH		 2759 if (fi->d.fdr == NULL)
2760 {
2761 msec->flags = origflags;
2762 return false;
2763 }
2764 external_fdr_size = swap->external_fdr_size;
2765 fdr_ptr = fi->d.fdr;
2766 fraw_src = (char *) fi->d.external_fdr;
2767 fraw_end = (fraw_src
2768 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2769 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2770 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2771
2772 elf_tdata (abfd)->find_line_info = fi;
2773
2774 /* Note that we don't bother to ever free this information.
2775 find_nearest_line is either called all the time, as in
2776 objdump -l, so the information should be saved, or it is
2777 rarely called, as in ld error messages, so the memory
2778 wasted is unimportant. Still, it would probably be a
2779 good idea for free_cached_info to throw it away. */
2780 }
2781
2782 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2783 &fi->i, filename_ptr, functionname_ptr,
2784 line_ptr))
2785 {
2786 msec->flags = origflags;
2787 return true;
2788 }
2789
2790 msec->flags = origflags;
2791 }
2792
2793 /* Fall back on the generic ELF find_nearest_line routine. */
2794
2795 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2796 filename_ptr, functionname_ptr,
2797 line_ptr);
2798}
2799\f
2800/* Structure used to pass information to alpha_elf_output_extsym. */
2801
2802struct extsym_info
2803{
2804 bfd *abfd;
2805 struct bfd_link_info *info;
2806 struct ecoff_debug_info *debug;
2807 const struct ecoff_debug_swap *swap;
2808 boolean failed;
2809};
2810
2811static boolean
2812elf64_alpha_output_extsym (h, data)
2813 struct alpha_elf_link_hash_entry *h;
2814 PTR data;
2815{
2816 struct extsym_info *einfo = (struct extsym_info *) data;
2817 boolean strip;
2818 asection *sec, *output_section;
2819
e92d460e
AM		 2820 if (h->root.root.type == bfd_link_hash_warning)
2821 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2822
252b5132
RH		 2823 if (h->root.indx == -2)
2824 strip = false;
2825 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
e92d460e
AM		 2826 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2827 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2828 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
252b5132
RH		 2829 strip = true;
2830 else if (einfo->info->strip == strip_all
e92d460e
AM		 2831 || (einfo->info->strip == strip_some
2832 && bfd_hash_lookup (einfo->info->keep_hash,
2833 h->root.root.root.string,
2834 false, false) == NULL))
252b5132
RH		 2835 strip = true;
2836 else
2837 strip = false;
2838
2839 if (strip)
2840 return true;
2841
2842 if (h->esym.ifd == -2)
2843 {
2844 h->esym.jmptbl = 0;
2845 h->esym.cobol_main = 0;
2846 h->esym.weakext = 0;
2847 h->esym.reserved = 0;
2848 h->esym.ifd = ifdNil;
2849 h->esym.asym.value = 0;
2850 h->esym.asym.st = stGlobal;
2851
2852 if (h->root.root.type != bfd_link_hash_defined
e92d460e
AM		 2853 && h->root.root.type != bfd_link_hash_defweak)
2854 h->esym.asym.sc = scAbs;
252b5132 2855 else
e92d460e
AM		 2856 {
2857 const char *name;
2858
2859 sec = h->root.root.u.def.section;
2860 output_section = sec->output_section;
2861
2862 /* When making a shared library and symbol h is the one from
2863 the another shared library, OUTPUT_SECTION may be null. */
2864 if (output_section == NULL)
2865 h->esym.asym.sc = scUndefined;
2866 else
2867 {
2868 name = bfd_section_name (output_section->owner, output_section);
2869
2870 if (strcmp (name, ".text") == 0)
2871 h->esym.asym.sc = scText;
2872 else if (strcmp (name, ".data") == 0)
2873 h->esym.asym.sc = scData;
2874 else if (strcmp (name, ".sdata") == 0)
2875 h->esym.asym.sc = scSData;
2876 else if (strcmp (name, ".rodata") == 0
2877 || strcmp (name, ".rdata") == 0)
2878 h->esym.asym.sc = scRData;
2879 else if (strcmp (name, ".bss") == 0)
2880 h->esym.asym.sc = scBss;
2881 else if (strcmp (name, ".sbss") == 0)
2882 h->esym.asym.sc = scSBss;
2883 else if (strcmp (name, ".init") == 0)
2884 h->esym.asym.sc = scInit;
2885 else if (strcmp (name, ".fini") == 0)
2886 h->esym.asym.sc = scFini;
2887 else
2888 h->esym.asym.sc = scAbs;
2889 }
2890 }
252b5132
RH		 2891
2892 h->esym.asym.reserved = 0;
2893 h->esym.asym.index = indexNil;
2894 }
2895
2896 if (h->root.root.type == bfd_link_hash_common)
2897 h->esym.asym.value = h->root.root.u.c.size;
2898 else if (h->root.root.type == bfd_link_hash_defined
2899 || h->root.root.type == bfd_link_hash_defweak)
2900 {
2901 if (h->esym.asym.sc == scCommon)
e92d460e 2902 h->esym.asym.sc = scBss;
252b5132 2903 else if (h->esym.asym.sc == scSCommon)
e92d460e 2904 h->esym.asym.sc = scSBss;
252b5132
RH		 2905
2906 sec = h->root.root.u.def.section;
2907 output_section = sec->output_section;
2908 if (output_section != NULL)
e92d460e
AM		 2909 h->esym.asym.value = (h->root.root.u.def.value
2910 + sec->output_offset
2911 + output_section->vma);
252b5132 2912 else
e92d460e 2913 h->esym.asym.value = 0;
252b5132
RH		 2914 }
2915 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2916 {
2917 /* Set type and value for a symbol with a function stub. */
2918 h->esym.asym.st = stProc;
2919 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2920 if (sec == NULL)
2921 h->esym.asym.value = 0;
2922 else
2923 {
2924 output_section = sec->output_section;
2925 if (output_section != NULL)
2926 h->esym.asym.value = (h->root.plt.offset
2927 + sec->output_offset
2928 + output_section->vma);
2929 else
2930 h->esym.asym.value = 0;
2931 }
252b5132
RH		 2932 }
2933
2934 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
e92d460e
AM		 2935 h->root.root.root.string,
2936 &h->esym))
252b5132
RH		 2937 {
2938 einfo->failed = true;
2939 return false;
2940 }
2941
2942 return true;
2943}
252b5132 2944\f
3765b1be
RH		 2945/* Search for and possibly create a got entry. */
2946
2947static struct alpha_elf_got_entry *
2948get_got_entry (abfd, h, r_type, r_symndx, r_addend)
2949 bfd *abfd;
2950 struct alpha_elf_link_hash_entry *h;
2951 unsigned long r_type, r_symndx;
2952 bfd_vma r_addend;
2953{
2954 struct alpha_elf_got_entry *gotent;
2955 struct alpha_elf_got_entry **slot;
2956
2957 if (h)
2958 slot = &h->got_entries;
2959 else
2960 {
2961 /* This is a local .got entry -- record for merge. */
2962
2963 struct alpha_elf_got_entry **local_got_entries;
2964
2965 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2966 if (!local_got_entries)
2967 {
2968 bfd_size_type size;
2969 Elf_Internal_Shdr *symtab_hdr;
2970
2971 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2972 size = symtab_hdr->sh_info;
2973 size *= sizeof (struct alpha_elf_got_entry *);
2974
2975 local_got_entries
9bab7074 2976 = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
3765b1be
RH		 2977 if (!local_got_entries)
2978 return NULL;
2979
3765b1be
RH		 2980 alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
2981 }
2982
2983 slot = &local_got_entries[r_symndx];
2984 }
2985
2986 for (gotent = *slot; gotent ; gotent = gotent->next)
2987 if (gotent->gotobj == abfd
2988 && gotent->reloc_type == r_type
2989 && gotent->addend == r_addend)
2990 break;
2991
2992 if (!gotent)
2993 {
2994 int entry_size;
2995 bfd_size_type amt;
2996
2997 amt = sizeof (struct alpha_elf_got_entry);
2998 gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
2999 if (!gotent)
3000 return NULL;
3001
3002 gotent->gotobj = abfd;
3003 gotent->addend = r_addend;
3004 gotent->got_offset = -1;
3005 gotent->use_count = 1;
3006 gotent->reloc_type = r_type;
3007 gotent->reloc_done = 0;
3008 gotent->reloc_xlated = 0;
3009
3010 gotent->next = *slot;
3011 *slot = gotent;
3012
3013 entry_size = alpha_got_entry_size (r_type);
3014 alpha_elf_tdata (abfd)->total_got_size += entry_size;
3015 if (!h)
3016 alpha_elf_tdata(abfd)->local_got_size += entry_size;
3017 }
3018 else
3019 gotent->use_count += 1;
3020
3021 return gotent;
3022}
3023
252b5132
RH		 3024/* Handle dynamic relocations when doing an Alpha ELF link. */
3025
3026static boolean
3027elf64_alpha_check_relocs (abfd, info, sec, relocs)
3028 bfd *abfd;
3029 struct bfd_link_info *info;
3030 asection *sec;
3031 const Elf_Internal_Rela *relocs;
3032{
3033 bfd *dynobj;
3034 asection *sreloc;
3035 const char *rel_sec_name;
3036 Elf_Internal_Shdr *symtab_hdr;
3037 struct alpha_elf_link_hash_entry **sym_hashes;
252b5132 3038 const Elf_Internal_Rela *rel, *relend;
3765b1be 3039 boolean got_created;
dc810e39 3040 bfd_size_type amt;
252b5132
RH		 3041
3042 if (info->relocateable)
3043 return true;
3044
3045 dynobj = elf_hash_table(info)->dynobj;
3046 if (dynobj == NULL)
3047 elf_hash_table(info)->dynobj = dynobj = abfd;
3048
3049 sreloc = NULL;
3050 rel_sec_name = NULL;
3051 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
3052 sym_hashes = alpha_elf_sym_hashes(abfd);
3765b1be 3053 got_created = false;
252b5132
RH		 3054
3055 relend = relocs + sec->reloc_count;
3056 for (rel = relocs; rel < relend; ++rel)
3057 {
3765b1be
RH		 3058 enum {
3059 NEED_GOT = 1,
3060 NEED_GOT_ENTRY = 2,
3061 NEED_DYNREL = 4
3062 };
3063
252b5132
RH		 3064 unsigned long r_symndx, r_type;
3065 struct alpha_elf_link_hash_entry *h;
3765b1be
RH		 3066 unsigned int gotent_flags;
3067 boolean maybe_dynamic;
3068 unsigned int need;
3069 bfd_vma addend;
252b5132
RH		 3070
3071 r_symndx = ELF64_R_SYM (rel->r_info);
3072 if (r_symndx < symtab_hdr->sh_info)
3073 h = NULL;
3074 else
3075 {
3076 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3077
3078 while (h->root.root.type == bfd_link_hash_indirect
3079 || h->root.root.type == bfd_link_hash_warning)
3080 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3081
3082 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
3083 }
3765b1be
RH		 3084
3085 /* We can only get preliminary data on whether a symbol is
3086 locally or externally defined, as not all of the input files
3087 have yet been processed. Do something with what we know, as
3088 this may help reduce memory usage and processing time later. */
3089 maybe_dynamic = false;
3090 if (h && ((info->shared
3091 && (!info->symbolic || info->allow_shlib_undefined))
3092 || ! (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
c853d7f6 3093 || h->root.root.type == bfd_link_hash_defweak))
3765b1be
RH		 3094 maybe_dynamic = true;
3095
3096 need = 0;
3097 gotent_flags = 0;
252b5132 3098 r_type = ELF64_R_TYPE (rel->r_info);
3765b1be 3099 addend = rel->r_addend;
252b5132
RH		 3100
3101 switch (r_type)
3102 {
3103 case R_ALPHA_LITERAL:
3765b1be
RH		 3104 need = NEED_GOT | NEED_GOT_ENTRY;
3105
3106 /* Remember how this literal is used from its LITUSEs.
3107 This will be important when it comes to decide if we can
3108 create a .plt entry for a function symbol. */
3109 while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
3110 if (rel->r_addend >= 1 && rel->r_addend <= 5)
3111 gotent_flags |= 1 << rel->r_addend;
3112 --rel;
3113
3114 /* No LITUSEs -- presumably the address is used somehow. */
3115 if (gotent_flags == 0)
3116 gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
3117 break;
252b5132
RH		 3118
3119 case R_ALPHA_GPDISP:
dfe57ca0 3120 case R_ALPHA_GPREL16:
252b5132
RH		 3121 case R_ALPHA_GPREL32:
3122 case R_ALPHA_GPRELHIGH:
3123 case R_ALPHA_GPRELLOW:
7793f4d0 3124 case R_ALPHA_BRSGP:
3765b1be
RH		 3125 need = NEED_GOT;
3126 break;
3127
3128 case R_ALPHA_REFLONG:
3129 case R_ALPHA_REFQUAD:
3130 if (info->shared || maybe_dynamic)
3131 need = NEED_DYNREL;
3132 break;
3133
3134 case R_ALPHA_TLSGD:
3135 case R_ALPHA_TLSLDM:
3136 case R_ALPHA_GOTDTPREL:
3137 need = NEED_GOT | NEED_GOT_ENTRY;
3138 break;
3139
3140 case R_ALPHA_GOTTPREL:
3141 need = NEED_GOT | NEED_GOT_ENTRY;
9e756d64 3142 gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
3765b1be
RH		 3143 if (info->shared)
3144 info->flags |= DF_STATIC_TLS;
3145 break;
3146
3147 case R_ALPHA_TPREL64:
3148 if (info->shared || maybe_dynamic)
3149 need = NEED_DYNREL;
3150 if (info->shared)
3151 info->flags |= DF_STATIC_TLS;
3152 break;
3153 }
3154
3155 if (need & NEED_GOT)
3156 {
252b5132
RH		 3157 if (!got_created)
3158 {
3159 if (!elf64_alpha_create_got_section (abfd, info))
3160 return false;
3161
3162 /* Make sure the object's gotobj is set to itself so
3163 that we default to every object with its own .got.
3164 We'll merge .gots later once we've collected each
3165 object's info. */
3166 alpha_elf_tdata(abfd)->gotobj = abfd;
3167
3168 got_created = 1;
3169 }
3765b1be 3170 }
252b5132 3171
3765b1be
RH		 3172 if (need & NEED_GOT_ENTRY)
3173 {
3174 struct alpha_elf_got_entry *gotent;
252b5132 3175
3765b1be
RH		 3176 gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
3177 if (!gotent)
3178 return false;
3179
3180 if (gotent_flags)
3181 {
3182 gotent->flags |= gotent_flags;
3183 if (h)
3184 {
3185 gotent_flags |= h->flags;
3186 h->flags = gotent_flags;
3187
3188 /* Make a guess as to whether a .plt entry is needed. */
3189 if ((gotent_flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
3190 && !(gotent_flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC))
3191 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3192 else
3193 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3194 }
3195 }
3196 }
3197
3198 if (need & NEED_DYNREL)
3199 {
252b5132
RH		 3200 if (rel_sec_name == NULL)
3201 {
3202 rel_sec_name = (bfd_elf_string_from_elf_section
3203 (abfd, elf_elfheader(abfd)->e_shstrndx,
3204 elf_section_data(sec)->rel_hdr.sh_name));
3205 if (rel_sec_name == NULL)
3206 return false;
3207
3208 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
3209 && strcmp (bfd_get_section_name (abfd, sec),
3210 rel_sec_name+5) == 0);
3211 }
3212
3213 /* We need to create the section here now whether we eventually
3214 use it or not so that it gets mapped to an output section by
3215 the linker. If not used, we'll kill it in
3216 size_dynamic_sections. */
3217 if (sreloc == NULL)
3218 {
3219 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
3220 if (sreloc == NULL)
3221 {
dc810e39
AM		 3222 flagword flags;
3223
252b5132 3224 sreloc = bfd_make_section (dynobj, rel_sec_name);
dc810e39
AM		 3225 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
3226 | SEC_LINKER_CREATED | SEC_READONLY);
3227 if (sec->flags & SEC_ALLOC)
3228 flags |= SEC_ALLOC | SEC_LOAD;
252b5132 3229 if (sreloc == NULL
dc810e39 3230 || !bfd_set_section_flags (dynobj, sreloc, flags)
252b5132
RH		 3231 || !bfd_set_section_alignment (dynobj, sreloc, 3))
3232 return false;
3233 }
3234 }
3235
3236 if (h)
3237 {
3238 /* Since we havn't seen all of the input symbols yet, we
3239 don't know whether we'll actually need a dynamic relocation
3240 entry for this reloc. So make a record of it. Once we
3241 find out if this thing needs dynamic relocation we'll
fe8bc63d 3242 expand the relocation sections by the appropriate amount. */
252b5132
RH		 3243
3244 struct alpha_elf_reloc_entry *rent;
3245
3246 for (rent = h->reloc_entries; rent; rent = rent->next)
3247 if (rent->rtype == r_type && rent->srel == sreloc)
3248 break;
3249
3250 if (!rent)
3251 {
dc810e39
AM		 3252 amt = sizeof (struct alpha_elf_reloc_entry);
3253 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
252b5132
RH		 3254 if (!rent)
3255 return false;
3256
3257 rent->srel = sreloc;
3258 rent->rtype = r_type;
3259 rent->count = 1;
73896efb
RH		 3260 rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC))
3261 == (SEC_READONLY | SEC_ALLOC));
252b5132
RH		 3262
3263 rent->next = h->reloc_entries;
3264 h->reloc_entries = rent;
3265 }
3266 else
3267 rent->count++;
3268 }
c853d7f6 3269 else if (info->shared)
252b5132 3270 {
c555c5c5
AM		 3271 /* If this is a shared library, and the section is to be
3272 loaded into memory, we need a RELATIVE reloc. */
252b5132 3273 sreloc->_raw_size += sizeof (Elf64_External_Rela);
c853d7f6
RH		 3274 if ((sec->flags & (SEC_READONLY | SEC_ALLOC))
3275 == (SEC_READONLY | SEC_ALLOC))
fcfbdf31 3276 info->flags |= DF_TEXTREL;
252b5132 3277 }
252b5132
RH		 3278 }
3279 }
3280
3281 return true;
3282}
3283
3284/* Adjust a symbol defined by a dynamic object and referenced by a
3285 regular object. The current definition is in some section of the
3286 dynamic object, but we're not including those sections. We have to
3287 change the definition to something the rest of the link can
3288 understand. */
3289
3290static boolean
3291elf64_alpha_adjust_dynamic_symbol (info, h)
3292 struct bfd_link_info *info;
3293 struct elf_link_hash_entry *h;
3294{
3295 bfd *dynobj;
3296 asection *s;
3297 struct alpha_elf_link_hash_entry *ah;
3298
3299 dynobj = elf_hash_table(info)->dynobj;
3300 ah = (struct alpha_elf_link_hash_entry *)h;
3301
3302 /* Now that we've seen all of the input symbols, finalize our decision
3303 about whether this symbol should get a .plt entry. */
3304
8ba89f17 3305 if (alpha_elf_dynamic_symbol_p (h, info)
252b5132
RH		 3306 && ((h->type == STT_FUNC
3307 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
3308 || (h->type == STT_NOTYPE
3765b1be
RH		 3309 && (ah->flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
3310 && !(ah->flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC)))
252b5132
RH		 3311 /* Don't prevent otherwise valid programs from linking by attempting
3312 to create a new .got entry somewhere. A Correct Solution would be
3313 to add a new .got section to a new object file and let it be merged
3314 somewhere later. But for now don't bother. */
3315 && ah->got_entries)
3316 {
3317 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3318
3319 s = bfd_get_section_by_name(dynobj, ".plt");
3320 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
3321 return false;
3322
3323 /* The first bit of the .plt is reserved. */
3324 if (s->_raw_size == 0)
3325 s->_raw_size = PLT_HEADER_SIZE;
3326
3327 h->plt.offset = s->_raw_size;
3328 s->_raw_size += PLT_ENTRY_SIZE;
3329
3330 /* If this symbol is not defined in a regular file, and we are not
3331 generating a shared library, then set the symbol to the location
3332 in the .plt. This is required to make function pointers compare
3333 equal between the normal executable and the shared library. */
3334 if (! info->shared
3335 && h->root.type != bfd_link_hash_defweak)
3336 {
3337 h->root.u.def.section = s;
3338 h->root.u.def.value = h->plt.offset;
3339 }
3340
3341 /* We also need a JMP_SLOT entry in the .rela.plt section. */
3342 s = bfd_get_section_by_name (dynobj, ".rela.plt");
3343 BFD_ASSERT (s != NULL);
3344 s->_raw_size += sizeof (Elf64_External_Rela);
3345
3346 return true;
3347 }
3348 else
3349 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3350
3351 /* If this is a weak symbol, and there is a real definition, the
3352 processor independent code will have arranged for us to see the
3353 real definition first, and we can just use the same value. */
3354 if (h->weakdef != NULL)
3355 {
3356 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3357 || h->weakdef->root.type == bfd_link_hash_defweak);
3358 h->root.u.def.section = h->weakdef->root.u.def.section;
3359 h->root.u.def.value = h->weakdef->root.u.def.value;
3360 return true;
3361 }
3362
3363 /* This is a reference to a symbol defined by a dynamic object which
3364 is not a function. The Alpha, since it uses .got entries for all
3365 symbols even in regular objects, does not need the hackery of a
3366 .dynbss section and COPY dynamic relocations. */
3367
3368 return true;
3369}
3370
3371/* Symbol versioning can create new symbols, and make our old symbols
3372 indirect to the new ones. Consolidate the got and reloc information
3373 in these situations. */
3374
3375static boolean
3376elf64_alpha_merge_ind_symbols (hi, dummy)
3377 struct alpha_elf_link_hash_entry *hi;
56fc028e 3378 PTR dummy ATTRIBUTE_UNUSED;
252b5132
RH		 3379{
3380 struct alpha_elf_link_hash_entry *hs;
3381
3382 if (hi->root.root.type != bfd_link_hash_indirect)
3383 return true;
3384 hs = hi;
3385 do {
3386 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
3387 } while (hs->root.root.type == bfd_link_hash_indirect);
3388
3389 /* Merge the flags. Whee. */
3390
3391 hs->flags |= hi->flags;
3392
3393 /* Merge the .got entries. Cannibalize the old symbol's list in
3394 doing so, since we don't need it anymore. */
3395
3396 if (hs->got_entries == NULL)
3397 hs->got_entries = hi->got_entries;
3398 else
3399 {
3400 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
3401
3402 gsh = hs->got_entries;
3403 for (gi = hi->got_entries; gi ; gi = gin)
3404 {
3405 gin = gi->next;
3406 for (gs = gsh; gs ; gs = gs->next)
3765b1be
RH		 3407 if (gi->gotobj == gs->gotobj
3408 && gi->reloc_type == gs->reloc_type
3409 && gi->addend == gs->addend)
3410 {
3411 gi->use_count += gs->use_count;
3412 goto got_found;
3413 }
252b5132
RH		 3414 gi->next = hs->got_entries;
3415 hs->got_entries = gi;
3416 got_found:;
3417 }
3418 }
3419 hi->got_entries = NULL;
3420
3421 /* And similar for the reloc entries. */
3422
3423 if (hs->reloc_entries == NULL)
3424 hs->reloc_entries = hi->reloc_entries;
3425 else
3426 {
3427 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
3428
3429 rsh = hs->reloc_entries;
3430 for (ri = hi->reloc_entries; ri ; ri = rin)
3431 {
3432 rin = ri->next;
3433 for (rs = rsh; rs ; rs = rs->next)
3434 if (ri->rtype == rs->rtype)
3435 {
3436 rs->count += ri->count;
3437 goto found_reloc;
3438 }
3439 ri->next = hs->reloc_entries;
3440 hs->reloc_entries = ri;
3441 found_reloc:;
3442 }
3443 }
3444 hi->reloc_entries = NULL;
3445
3446 return true;
3447}
3448
3449/* Is it possible to merge two object file's .got tables? */
3450
3451static boolean
3452elf64_alpha_can_merge_gots (a, b)
3453 bfd *a, *b;
3454{
3765b1be 3455 int total = alpha_elf_tdata (a)->total_got_size;
252b5132
RH		 3456 bfd *bsub;
3457
3458 /* Trivial quick fallout test. */
3765b1be 3459 if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
252b5132
RH		 3460 return true;
3461
3462 /* By their nature, local .got entries cannot be merged. */
3765b1be 3463 if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
252b5132
RH		 3464 return false;
3465
3466 /* Failing the common trivial comparison, we must effectively
3467 perform the merge. Not actually performing the merge means that
3468 we don't have to store undo information in case we fail. */
3469 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
3470 {
3471 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
3472 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
3473 int i, n;
3474
d9bc7a44 3475 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
252b5132
RH		 3476 for (i = 0; i < n; ++i)
3477 {
3478 struct alpha_elf_got_entry *ae, *be;
3479 struct alpha_elf_link_hash_entry *h;
3480
3481 h = hashes[i];
3482 while (h->root.root.type == bfd_link_hash_indirect
3483 || h->root.root.type == bfd_link_hash_warning)
3484 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3485
3486 for (be = h->got_entries; be ; be = be->next)
3487 {
3488 if (be->use_count == 0)
3489 continue;
3490 if (be->gotobj != b)
3491 continue;
3492
3493 for (ae = h->got_entries; ae ; ae = ae->next)
3765b1be
RH		 3494 if (ae->gotobj == a
3495 && ae->reloc_type == be->reloc_type
3496 && ae->addend == be->addend)
252b5132
RH		 3497 goto global_found;
3498
3765b1be
RH		 3499 total += alpha_got_entry_size (be->reloc_type);
3500 if (total > MAX_GOT_SIZE)
252b5132
RH		 3501 return false;
3502 global_found:;
3503 }
3504 }
3505 }
3506
3507 return true;
3508}
3509
3510/* Actually merge two .got tables. */
3511
3512static void
3513elf64_alpha_merge_gots (a, b)
3514 bfd *a, *b;
3515{
3765b1be 3516 int total = alpha_elf_tdata (a)->total_got_size;
252b5132
RH		 3517 bfd *bsub;
3518
3519 /* Remember local expansion. */
3520 {
3765b1be 3521 int e = alpha_elf_tdata (b)->local_got_size;
252b5132 3522 total += e;
3765b1be 3523 alpha_elf_tdata (a)->local_got_size += e;
252b5132
RH		 3524 }
3525
3526 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
3527 {
3528 struct alpha_elf_got_entry **local_got_entries;
3529 struct alpha_elf_link_hash_entry **hashes;
3530 Elf_Internal_Shdr *symtab_hdr;
3531 int i, n;
3532
3533 /* Let the local .got entries know they are part of a new subsegment. */
3534 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
3535 if (local_got_entries)
3536 {
3537 n = elf_tdata (bsub)->symtab_hdr.sh_info;
3538 for (i = 0; i < n; ++i)
3539 {
3540 struct alpha_elf_got_entry *ent;
3541 for (ent = local_got_entries[i]; ent; ent = ent->next)
3542 ent->gotobj = a;
3543 }
3544 }
3545
3546 /* Merge the global .got entries. */
3547 hashes = alpha_elf_sym_hashes (bsub);
3548 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
3549
d9bc7a44 3550 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
252b5132
RH		 3551 for (i = 0; i < n; ++i)
3552 {
3553 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
3554 struct alpha_elf_link_hash_entry *h;
3555
3556 h = hashes[i];
3557 while (h->root.root.type == bfd_link_hash_indirect
3558 || h->root.root.type == bfd_link_hash_warning)
3559 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3560
3561 start = &h->got_entries;
3562 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
3563 {
3564 if (be->use_count == 0)
3565 {
3566 *pbe = be->next;
3567 continue;
3568 }
3569 if (be->gotobj != b)
3570 continue;
3571
3572 for (ae = *start; ae ; ae = ae->next)
3765b1be
RH		 3573 if (ae->gotobj == a
3574 && ae->reloc_type == be->reloc_type
3575 && ae->addend == be->addend)
252b5132
RH		 3576 {
3577 ae->flags |= be->flags;
3578 ae->use_count += be->use_count;
3579 *pbe = be->next;
3580 goto global_found;
3581 }
3582 be->gotobj = a;
3765b1be 3583 total += alpha_got_entry_size (be->reloc_type);
252b5132
RH		 3584
3585 global_found:;
3586 }
3587 }
3588
3589 alpha_elf_tdata (bsub)->gotobj = a;
3590 }
3765b1be 3591 alpha_elf_tdata (a)->total_got_size = total;
252b5132
RH		 3592
3593 /* Merge the two in_got chains. */
3594 {
3595 bfd *next;
3596
3597 bsub = a;
3598 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
3599 bsub = next;
3600
3601 alpha_elf_tdata (bsub)->in_got_link_next = b;
3602 }
3603}
3604
3605/* Calculate the offsets for the got entries. */
3606
3607static boolean
3608elf64_alpha_calc_got_offsets_for_symbol (h, arg)
3609 struct alpha_elf_link_hash_entry *h;
52b9d213 3610 PTR arg ATTRIBUTE_UNUSED;
252b5132
RH		 3611{
3612 struct alpha_elf_got_entry *gotent;
3613
e92d460e
AM		 3614 if (h->root.root.type == bfd_link_hash_warning)
3615 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3616
252b5132
RH		 3617 for (gotent = h->got_entries; gotent; gotent = gotent->next)
3618 if (gotent->use_count > 0)
3619 {
3620 bfd_size_type *plge
3621 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
3622
3623 gotent->got_offset = *plge;
3765b1be 3624 *plge += alpha_got_entry_size (gotent->reloc_type);
252b5132
RH		 3625 }
3626
3627 return true;
3628}
3629
3630static void
3631elf64_alpha_calc_got_offsets (info)
3632 struct bfd_link_info *info;
3633{
3634 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
3635
3636 /* First, zero out the .got sizes, as we may be recalculating the
3637 .got after optimizing it. */
3638 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
3639 alpha_elf_tdata(i)->got->_raw_size = 0;
3640
3641 /* Next, fill in the offsets for all the global entries. */
3642 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3643 elf64_alpha_calc_got_offsets_for_symbol,
3644 NULL);
3645
3646 /* Finally, fill in the offsets for the local entries. */
3647 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
3648 {
3649 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
3650 bfd *j;
3651
3652 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
3653 {
3654 struct alpha_elf_got_entry **local_got_entries, *gotent;
3655 int k, n;
3656
3657 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
3658 if (!local_got_entries)
3659 continue;
3660
3661 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3662 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
3663 if (gotent->use_count > 0)
3664 {
3665 gotent->got_offset = got_offset;
3765b1be 3666 got_offset += alpha_got_entry_size (gotent->reloc_type);
252b5132
RH		 3667 }
3668 }
3669
3670 alpha_elf_tdata(i)->got->_raw_size = got_offset;
3671 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
3672 }
3673}
3674
3675/* Constructs the gots. */
3676
3677static boolean
f44f99a5 3678elf64_alpha_size_got_sections (info)
252b5132
RH		 3679 struct bfd_link_info *info;
3680{
52b9d213 3681 bfd *i, *got_list, *cur_got_obj = NULL;
252b5132
RH		 3682 int something_changed = 0;
3683
3684 got_list = alpha_elf_hash_table (info)->got_list;
3685
3686 /* On the first time through, pretend we have an existing got list
3687 consisting of all of the input files. */
3688 if (got_list == NULL)
3689 {
3690 for (i = info->input_bfds; i ; i = i->link_next)
3691 {
3692 bfd *this_got = alpha_elf_tdata (i)->gotobj;
3693 if (this_got == NULL)
3694 continue;
3695
3696 /* We are assuming no merging has yet ocurred. */
3697 BFD_ASSERT (this_got == i);
3698
3765b1be 3699 if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
252b5132
RH		 3700 {
3701 /* Yikes! A single object file has too many entries. */
3702 (*_bfd_error_handler)
3703 (_("%s: .got subsegment exceeds 64K (size %d)"),
8f615d07 3704 bfd_archive_filename (i),
3765b1be 3705 alpha_elf_tdata (this_got)->total_got_size);
252b5132
RH		 3706 return false;
3707 }
3708
3709 if (got_list == NULL)
3710 got_list = this_got;
3711 else
3712 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3713 cur_got_obj = this_got;
3714 }
3715
3716 /* Strange degenerate case of no got references. */
3717 if (got_list == NULL)
3718 return true;
3719
3720 alpha_elf_hash_table (info)->got_list = got_list;
3721
3722 /* Force got offsets to be recalculated. */
3723 something_changed = 1;
3724 }
3725
3726 cur_got_obj = got_list;
3727 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3728 while (i != NULL)
3729 {
3730 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3731 {
3732 elf64_alpha_merge_gots (cur_got_obj, i);
3733 i = alpha_elf_tdata(i)->got_link_next;
3734 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3735 something_changed = 1;
3736 }
3737 else
3738 {
3739 cur_got_obj = i;
3740 i = alpha_elf_tdata(i)->got_link_next;
3741 }
3742 }
3743
3744 /* Once the gots have been merged, fill in the got offsets for
3745 everything therein. */
3746 if (1 || something_changed)
3747 elf64_alpha_calc_got_offsets (info);
3748
3749 return true;
3750}
3751
cedb70c5 3752/* Called from relax_section to rebuild the PLT in light of
f44f99a5
RH		 3753 potential changes in the function's status. */
3754
3755static boolean
3756elf64_alpha_size_plt_section (info)
3757 struct bfd_link_info *info;
3758{
3759 asection *splt, *spltrel;
3760 unsigned long entries;
3761 bfd *dynobj;
3762
3763 dynobj = elf_hash_table(info)->dynobj;
3764 splt = bfd_get_section_by_name(dynobj, ".plt");
3765 if (splt == NULL)
3766 return true;
3767
3768 splt->_raw_size = 0;
3769
3770 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3771 elf64_alpha_size_plt_section_1, splt);
3772
3773 splt->_cooked_size = splt->_raw_size;
3774
3775 /* Every plt entry requires a JMP_SLOT relocation. */
3776 spltrel = bfd_get_section_by_name (dynobj, ".rela.plt");
3777 if (splt->_raw_size)
3778 entries = (splt->_raw_size - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3779 else
3780 entries = 0;
3781 spltrel->_raw_size = entries * sizeof (Elf64_External_Rela);
3782 spltrel->_cooked_size = spltrel->_raw_size;
3783
3784 return true;
3785}
3786
3787static boolean
3788elf64_alpha_size_plt_section_1 (h, data)
3789 struct alpha_elf_link_hash_entry *h;
3790 PTR data;
3791{
3792 asection *splt = (asection *) data;
3793 struct alpha_elf_got_entry *gotent;
3794
3795 /* If we didn't need an entry before, we still don't. */
3796 if (!(h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT))
3797 return true;
3798
3799 /* There must still be a LITERAL got entry for the function. */
3800 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3801 if (gotent->reloc_type == R_ALPHA_LITERAL
3802 && gotent->use_count > 0)
3803 break;
3804
3805 /* If there is, reset the PLT offset. If not, there's no longer
3806 a need for the PLT entry. */
3807 if (gotent)
3808 {
3809 if (splt->_raw_size == 0)
3810 splt->_raw_size = PLT_HEADER_SIZE;
3811 h->root.plt.offset = splt->_raw_size;
3812 splt->_raw_size += PLT_ENTRY_SIZE;
3813 }
3814 else
3815 {
3816 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3817 h->root.plt.offset = -1;
3818 }
3819
3820 return true;
3821}
3822
252b5132
RH		 3823static boolean
3824elf64_alpha_always_size_sections (output_bfd, info)
f44f99a5 3825 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 3826 struct bfd_link_info *info;
3827{
3828 bfd *i;
3829
3830 if (info->relocateable)
3831 return true;
3832
3833 /* First, take care of the indirect symbols created by versioning. */
3834 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3835 elf64_alpha_merge_ind_symbols,
3836 NULL);
3837
f44f99a5 3838 if (!elf64_alpha_size_got_sections (info))
252b5132
RH		 3839 return false;
3840
3841 /* Allocate space for all of the .got subsections. */
3842 i = alpha_elf_hash_table (info)->got_list;
3843 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3844 {
3845 asection *s = alpha_elf_tdata(i)->got;
3846 if (s->_raw_size > 0)
3847 {
3848 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3849 if (s->contents == NULL)
3850 return false;
3851 }
3852 }
3853
3854 return true;
3855}
3856
3765b1be
RH		 3857/* The number of dynamic relocations required by a static relocation. */
3858
3859static int
3860alpha_dynamic_entries_for_reloc (r_type, dynamic, shared)
3861 int r_type, dynamic, shared;
3862{
3863 switch (r_type)
3864 {
3865 /* May appear in GOT entries. */
3866 case R_ALPHA_TLSGD:
3867 return (dynamic ? 2 : shared ? 1 : 0);
3868 case R_ALPHA_TLSLDM:
3869 return shared;
3870 case R_ALPHA_LITERAL:
3871 return dynamic || shared;
3872 case R_ALPHA_GOTDTPREL:
3873 case R_ALPHA_GOTTPREL:
3874 return dynamic;
3875
3876 /* May appear in data sections. */
3877 case R_ALPHA_REFLONG:
3878 case R_ALPHA_REFQUAD:
3879 return dynamic || shared;
3880 case R_ALPHA_SREL64:
3881 case R_ALPHA_TPREL64:
3882 return dynamic;
3883
3884 /* Everything else is illegal. We'll issue an error during
3885 relocate_section. */
3886 default:
3887 return 0;
3888 }
3889}
3890
252b5132
RH		 3891/* Work out the sizes of the dynamic relocation entries. */
3892
3893static boolean
3894elf64_alpha_calc_dynrel_sizes (h, info)
3895 struct alpha_elf_link_hash_entry *h;
3896 struct bfd_link_info *info;
3897{
3765b1be
RH		 3898 boolean dynamic;
3899 struct alpha_elf_reloc_entry *relent;
f44f99a5 3900 unsigned long entries;
3765b1be 3901
e92d460e
AM		 3902 if (h->root.root.type == bfd_link_hash_warning)
3903 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3904
252b5132
RH		 3905 /* If the symbol was defined as a common symbol in a regular object
3906 file, and there was no definition in any dynamic object, then the
3907 linker will have allocated space for the symbol in a common
3908 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3909 set. This is done for dynamic symbols in
3910 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3911 symbols, somehow. */
3912 if (((h->root.elf_link_hash_flags
3913 & (ELF_LINK_HASH_DEF_REGULAR
3914 | ELF_LINK_HASH_REF_REGULAR
3915 | ELF_LINK_HASH_DEF_DYNAMIC))
3916 == ELF_LINK_HASH_REF_REGULAR)
3917 && (h->root.root.type == bfd_link_hash_defined
3918 || h->root.root.type == bfd_link_hash_defweak)
3919 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
f44f99a5 3920 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
252b5132
RH		 3921
3922 /* If the symbol is dynamic, we'll need all the relocations in their
3923 natural form. If this is a shared object, and it has been forced
3924 local, we'll need the same number of RELATIVE relocations. */
3925
3765b1be 3926 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
252b5132 3927
3765b1be
RH		 3928 for (relent = h->reloc_entries; relent; relent = relent->next)
3929 {
3930 entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
3931 info->shared);
3932 if (entries)
3933 {
3934 relent->srel->_raw_size +=
3935 entries * sizeof (Elf64_External_Rela) * relent->count;
3936 if (relent->reltext)
3937 info->flags |= DT_TEXTREL;
3938 }
3939 }
252b5132 3940
f44f99a5
RH		 3941 return true;
3942}
3943
3944/* Set the sizes of the dynamic relocation sections. */
3945
3946static boolean
3947elf64_alpha_size_rela_got_section (info)
3948 struct bfd_link_info *info;
3949{
3950 unsigned long entries;
3951 bfd *i, *dynobj;
3952 asection *srel;
3953
3954 /* Shared libraries often require RELATIVE relocs, and some relocs
3955 require attention for the main application as well. */
cedb70c5 3956
f44f99a5
RH		 3957 entries = 0;
3958 for (i = alpha_elf_hash_table(info)->got_list;
3959 i ; i = alpha_elf_tdata(i)->got_link_next)
3960 {
3961 bfd *j;
3962
3963 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
3964 {
3965 struct alpha_elf_got_entry **local_got_entries, *gotent;
3966 int k, n;
3967
3968 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
3969 if (!local_got_entries)
3970 continue;
3971
3972 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3973 for (gotent = local_got_entries[k];
3974 gotent ; gotent = gotent->next)
3975 if (gotent->use_count > 0)
3976 entries += (alpha_dynamic_entries_for_reloc
3977 (gotent->reloc_type, 0, info->shared));
3978 }
3979 }
3980
3981 dynobj = elf_hash_table(info)->dynobj;
3982 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3983 if (!srel)
3984 {
3985 BFD_ASSERT (entries == 0);
3986 return true;
3987 }
3988 srel->_raw_size = sizeof (Elf64_External_Rela) * entries;
3989
3990 /* Now do the non-local symbols. */
3991 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3992 elf64_alpha_size_rela_got_1, info);
3993
3994 srel->_cooked_size = srel->_raw_size;
3995
3996 return true;
3997}
3998
3999/* Subroutine of elf64_alpha_size_rela_got_section for doing the
4000 global symbols. */
4001
4002static boolean
4003elf64_alpha_size_rela_got_1 (h, info)
4004 struct alpha_elf_link_hash_entry *h;
4005 struct bfd_link_info *info;
4006{
4007 boolean dynamic;
4008 struct alpha_elf_got_entry *gotent;
4009 unsigned long entries;
4010
4011 if (h->root.root.type == bfd_link_hash_warning)
4012 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
4013
4014 /* If the symbol is dynamic, we'll need all the relocations in their
4015 natural form. If this is a shared object, and it has been forced
4016 local, we'll need the same number of RELATIVE relocations. */
4017
4018 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
4019
3765b1be
RH		 4020 entries = 0;
4021 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
f44f99a5
RH		 4022 if (gotent->use_count > 0)
4023 entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type,
4024 dynamic, info->shared);
252b5132 4025
3765b1be
RH		 4026 /* If we are using a .plt entry, subtract one, as the first
4027 reference uses a .rela.plt entry instead. */
4028 if (h->root.plt.offset != MINUS_ONE)
4029 entries--;
252b5132 4030
3765b1be
RH		 4031 if (entries > 0)
4032 {
4033 bfd *dynobj = elf_hash_table(info)->dynobj;
4034 asection *srel = bfd_get_section_by_name (dynobj, ".rela.got");
4035 BFD_ASSERT (srel != NULL);
4036 srel->_raw_size += sizeof (Elf64_External_Rela) * entries;
252b5132
RH		 4037 }
4038
4039 return true;
4040}
4041
4042/* Set the sizes of the dynamic sections. */
4043
4044static boolean
4045elf64_alpha_size_dynamic_sections (output_bfd, info)
24a35864 4046 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 4047 struct bfd_link_info *info;
4048{
4049 bfd *dynobj;
4050 asection *s;
252b5132
RH		 4051 boolean relplt;
4052
4053 dynobj = elf_hash_table(info)->dynobj;
4054 BFD_ASSERT(dynobj != NULL);
4055
4056 if (elf_hash_table (info)->dynamic_sections_created)
4057 {
4058 /* Set the contents of the .interp section to the interpreter. */
4059 if (!info->shared)
4060 {
4061 s = bfd_get_section_by_name (dynobj, ".interp");
4062 BFD_ASSERT (s != NULL);
4063 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
4064 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4065 }
4066
4067 /* Now that we've seen all of the input files, we can decide which
4068 symbols need dynamic relocation entries and which don't. We've
4069 collected information in check_relocs that we can now apply to
4070 size the dynamic relocation sections. */
4071 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
f44f99a5 4072 elf64_alpha_calc_dynrel_sizes, info);
252b5132 4073
f44f99a5 4074 elf64_alpha_size_rela_got_section (info);
252b5132
RH		 4075 }
4076 /* else we're not dynamic and by definition we don't need such things. */
4077
4078 /* The check_relocs and adjust_dynamic_symbol entry points have
4079 determined the sizes of the various dynamic sections. Allocate
4080 memory for them. */
252b5132
RH		 4081 relplt = false;
4082 for (s = dynobj->sections; s != NULL; s = s->next)
4083 {
4084 const char *name;
4085 boolean strip;
4086
4087 if (!(s->flags & SEC_LINKER_CREATED))
4088 continue;
4089
4090 /* It's OK to base decisions on the section name, because none
4091 of the dynobj section names depend upon the input files. */
4092 name = bfd_get_section_name (dynobj, s);
4093
4094 /* If we don't need this section, strip it from the output file.
4095 This is to handle .rela.bss and .rela.plt. We must create it
4096 in create_dynamic_sections, because it must be created before
4097 the linker maps input sections to output sections. The
4098 linker does that before adjust_dynamic_symbol is called, and
4099 it is that function which decides whether anything needs to
4100 go into these sections. */
4101
4102 strip = false;
4103
4104 if (strncmp (name, ".rela", 5) == 0)
4105 {
4106 strip = (s->_raw_size == 0);
4107
4108 if (!strip)
4109 {
252b5132
RH		 4110 if (strcmp(name, ".rela.plt") == 0)
4111 relplt = true;
4112
4113 /* We use the reloc_count field as a counter if we need
4114 to copy relocs into the output file. */
4115 s->reloc_count = 0;
4116 }
4117 }
4118 else if (strcmp (name, ".plt") != 0)
4119 {
4120 /* It's not one of our dynamic sections, so don't allocate space. */
4121 continue;
4122 }
4123
4124 if (strip)
7f8d5fc9 4125 _bfd_strip_section_from_output (info, s);
252b5132
RH		 4126 else
4127 {
4128 /* Allocate memory for the section contents. */
dc810e39 4129 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
252b5132
RH		 4130 if (s->contents == NULL && s->_raw_size != 0)
4131 return false;
4132 }
4133 }
4134
252b5132
RH		 4135 if (elf_hash_table (info)->dynamic_sections_created)
4136 {
4137 /* Add some entries to the .dynamic section. We fill in the
4138 values later, in elf64_alpha_finish_dynamic_sections, but we
4139 must add the entries now so that we get the correct size for
4140 the .dynamic section. The DT_DEBUG entry is filled in by the
4141 dynamic linker and used by the debugger. */
dc810e39
AM		 4142#define add_dynamic_entry(TAG, VAL) \
4143 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
4144
252b5132
RH		 4145 if (!info->shared)
4146 {
dc810e39 4147 if (!add_dynamic_entry (DT_DEBUG, 0))
252b5132
RH		 4148 return false;
4149 }
4150
dc810e39 4151 if (!add_dynamic_entry (DT_PLTGOT, 0))
252b5132
RH		 4152 return false;
4153
4154 if (relplt)
4155 {
dc810e39
AM		 4156 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
4157 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4158 || !add_dynamic_entry (DT_JMPREL, 0))
252b5132
RH		 4159 return false;
4160 }
4161
dc810e39
AM		 4162 if (!add_dynamic_entry (DT_RELA, 0)
4163 || !add_dynamic_entry (DT_RELASZ, 0)
4164 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
252b5132
RH		 4165 return false;
4166
fcfbdf31 4167 if (info->flags & DF_TEXTREL)
252b5132 4168 {
dc810e39 4169 if (!add_dynamic_entry (DT_TEXTREL, 0))
252b5132
RH		 4170 return false;
4171 }
4172 }
dc810e39 4173#undef add_dynamic_entry
252b5132
RH		 4174
4175 return true;
4176}
4177
4a67a098
RH		 4178/* Relocate an Alpha ELF section for a relocatable link.
4179
4180 We don't have to change anything unless the reloc is against a section
4181 symbol, in which case we have to adjust according to where the section
4182 symbol winds up in the output section. */
4183
4184static boolean
4185elf64_alpha_relocate_section_r (output_bfd, info, input_bfd, input_section,
4186 contents, relocs, local_syms, local_sections)
4187 bfd *output_bfd ATTRIBUTE_UNUSED;
4188 struct bfd_link_info *info ATTRIBUTE_UNUSED;
4189 bfd *input_bfd;
4190 asection *input_section;
4191 bfd_byte *contents ATTRIBUTE_UNUSED;
4192 Elf_Internal_Rela *relocs;
4193 Elf_Internal_Sym *local_syms;
4194 asection **local_sections;
4195{
4196 unsigned long symtab_hdr_sh_info;
4197 Elf_Internal_Rela *rel;
4198 Elf_Internal_Rela *relend;
4199 boolean ret_val = true;
4200
4201 symtab_hdr_sh_info = elf_tdata (input_bfd)->symtab_hdr.sh_info;
4202
4203 relend = relocs + input_section->reloc_count;
4204 for (rel = relocs; rel < relend; rel++)
4205 {
4206 unsigned long r_symndx;
4207 Elf_Internal_Sym *sym;
4208 asection *sec;
4209 unsigned long r_type;
4210
4211 r_type = ELF64_R_TYPE(rel->r_info);
4212 if (r_type >= R_ALPHA_max)
4213 {
4214 (*_bfd_error_handler)
4215 (_("%s: unknown relocation type %d"),
4216 bfd_archive_filename (input_bfd), (int)r_type);
4217 bfd_set_error (bfd_error_bad_value);
4218 ret_val = false;
4219 continue;
4220 }
4221
4222 r_symndx = ELF64_R_SYM(rel->r_info);
4223
4224 /* The symbol associated with GPDISP and LITUSE is
4225 immaterial. Only the addend is significant. */
4226 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4227 continue;
4228
4229 if (r_symndx < symtab_hdr_sh_info)
4230 {
4231 sym = local_syms + r_symndx;
4232 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
4233 {
4234 sec = local_sections[r_symndx];
4235 rel->r_addend += sec->output_offset + sym->st_value;
4236 }
4237 }
4238 }
4239
4240 return ret_val;
4241}
4242
252b5132
RH		 4243/* Relocate an Alpha ELF section. */
4244
4245static boolean
4246elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
4247 contents, relocs, local_syms, local_sections)
4248 bfd *output_bfd;
4249 struct bfd_link_info *info;
4250 bfd *input_bfd;
4251 asection *input_section;
4252 bfd_byte *contents;
4253 Elf_Internal_Rela *relocs;
4254 Elf_Internal_Sym *local_syms;
4255 asection **local_sections;
4256{
4a67a098 4257 Elf_Internal_Shdr *symtab_hdr;
252b5132
RH		 4258 Elf_Internal_Rela *rel;
4259 Elf_Internal_Rela *relend;
4a67a098
RH		 4260 struct elf_link_tls_segment *tls_segment;
4261 asection *sgot, *srel, *srelgot;
4262 bfd *dynobj, *gotobj;
4263 bfd_vma gp, tp_base, dtp_base;
4264 struct alpha_elf_got_entry **local_got_entries;
4265 boolean ret_val;
4266 const char *section_name;
252b5132 4267
4a67a098
RH		 4268 /* Handle relocatable links with a smaller loop. */
4269 if (info->relocateable)
4270 return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4271 input_section, contents, relocs,
4272 local_syms, local_sections);
4273
4274 /* This is a final link. */
4275
4276 ret_val = true;
252b5132 4277
4a67a098 4278 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3765b1be 4279
4a67a098
RH		 4280 dynobj = elf_hash_table (info)->dynobj;
4281 if (dynobj)
4282 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4283 else
4284 srelgot = NULL;
4285
4286 section_name = (bfd_elf_string_from_elf_section
4287 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4288 elf_section_data(input_section)->rel_hdr.sh_name));
4289 BFD_ASSERT(section_name != NULL);
4290 srel = bfd_get_section_by_name (dynobj, section_name);
3765b1be 4291
4a67a098
RH		 4292 /* Find the gp value for this input bfd. */
4293 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4294 if (gotobj)
4295 {
4296 sgot = alpha_elf_tdata (gotobj)->got;
4297 gp = _bfd_get_gp_value (gotobj);
4298 if (gp == 0)
252b5132 4299 {
4a67a098
RH		 4300 gp = (sgot->output_section->vma
4301 + sgot->output_offset
4302 + 0x8000);
4303 _bfd_set_gp_value (gotobj, gp);
4304 }
4305 }
4306 else
4307 {
4308 sgot = NULL;
4309 gp = 0;
4310 }
3765b1be 4311
4a67a098
RH		 4312 local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4313
4314 tls_segment = elf_hash_table (info)->tls_segment;
4315 if (tls_segment)
4316 {
4317 dtp_base = alpha_get_dtprel_base (tls_segment);
4318 tp_base = alpha_get_tprel_base (tls_segment);
252b5132 4319 }
4a67a098
RH		 4320 else
4321 dtp_base = tp_base = 0;
252b5132 4322
252b5132 4323 relend = relocs + input_section->reloc_count;
4a67a098 4324 for (rel = relocs; rel < relend; rel++)
252b5132 4325 {
4a67a098 4326 struct alpha_elf_link_hash_entry *h = NULL;
3765b1be
RH		 4327 struct alpha_elf_got_entry *gotent;
4328 bfd_reloc_status_type r;
252b5132
RH		 4329 reloc_howto_type *howto;
4330 unsigned long r_symndx;
4a67a098
RH		 4331 Elf_Internal_Sym *sym = NULL;
4332 asection *sec = NULL;
3765b1be 4333 bfd_vma value;
dc810e39 4334 bfd_vma addend;
3765b1be 4335 boolean dynamic_symbol_p;
4a67a098 4336 boolean undef_weak_ref = false;
3765b1be 4337 unsigned long r_type;
252b5132
RH		 4338
4339 r_type = ELF64_R_TYPE(rel->r_info);
3765b1be 4340 if (r_type >= R_ALPHA_max)
252b5132 4341 {
3765b1be
RH		 4342 (*_bfd_error_handler)
4343 (_("%s: unknown relocation type %d"),
4344 bfd_archive_filename (input_bfd), (int)r_type);
252b5132 4345 bfd_set_error (bfd_error_bad_value);
3765b1be
RH		 4346 ret_val = false;
4347 continue;
252b5132 4348 }
252b5132 4349
3765b1be 4350 howto = elf64_alpha_howto_table + r_type;
252b5132
RH		 4351 r_symndx = ELF64_R_SYM(rel->r_info);
4352
252b5132
RH		 4353 if (r_symndx < symtab_hdr->sh_info)
4354 {
4355 sym = local_syms + r_symndx;
4356 sec = local_sections[r_symndx];
3765b1be
RH		 4357 value = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
4358
4a67a098
RH		 4359 if (local_got_entries)
4360 gotent = local_got_entries[r_symndx];
4361 else
4362 gotent = NULL;
3765b1be
RH		 4363
4364 /* Need to adjust local GOT entries' addends for SEC_MERGE
4365 unless it has been done already. */
4366 if ((sec->flags & SEC_MERGE)
048d873d
RH		 4367 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4368 && (elf_section_data (sec)->sec_info_type
4369 == ELF_INFO_TYPE_MERGE)
4370 && gotent
4371 && !gotent->reloc_xlated)
3765b1be
RH		 4372 {
4373 struct alpha_elf_got_entry *ent;
4374 asection *msec;
4375
4376 for (ent = gotent; ent; ent = ent->next)
4377 {
4378 ent->reloc_xlated = 1;
4379 if (ent->use_count == 0)
4380 continue;
4381 msec = sec;
4382 ent->addend =
4383 _bfd_merged_section_offset (output_bfd, &msec,
4384 elf_section_data (sec)->
4385 sec_info,
4386 sym->st_value + ent->addend,
4387 (bfd_vma) 0);
4388 ent->addend -= sym->st_value;
4389 ent->addend += msec->output_section->vma
4390 + msec->output_offset
4391 - sec->output_section->vma
4392 - sec->output_offset;
4393 }
4394 }
4395
4396 dynamic_symbol_p = false;
252b5132
RH		 4397 }
4398 else
4399 {
4400 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
4401
4402 while (h->root.root.type == bfd_link_hash_indirect
4403 || h->root.root.type == bfd_link_hash_warning)
4404 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
4405
3765b1be 4406 value = 0;
252b5132
RH		 4407 if (h->root.root.type == bfd_link_hash_defined
4408 || h->root.root.type == bfd_link_hash_defweak)
4409 {
4410 sec = h->root.root.u.def.section;
4411
3765b1be
RH		 4412 /* Detect the cases that sym_sec->output_section is
4413 expected to be NULL -- all cases in which the symbol
4414 is defined in another shared module. This includes
4415 PLT relocs for which we've created a PLT entry and
4416 other relocs for which we're prepared to create
4417 dynamic relocations. */
4418 /* ??? Just accept it NULL and continue. */
4419
4420 if (sec->output_section != NULL)
4421 value = (h->root.root.u.def.value
4422 + sec->output_section->vma
4423 + sec->output_offset);
252b5132
RH		 4424 }
4425 else if (h->root.root.type == bfd_link_hash_undefweak)
3765b1be 4426 undef_weak_ref = true;
671bae9c
NC		 4427 else if (info->shared
4428 && (!info->symbolic || info->allow_shlib_undefined)
3a27a730 4429 && !info->no_undefined
edb72b3b 4430 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3765b1be 4431 ;
252b5132
RH		 4432 else
4433 {
4434 if (!((*info->callbacks->undefined_symbol)
4435 (info, h->root.root.root.string, input_bfd,
5cc7c785 4436 input_section, rel->r_offset,
3a27a730 4437 (!info->shared || info->no_undefined
edb72b3b 4438 || ELF_ST_VISIBILITY (h->root.other)))))
3765b1be
RH		 4439 return false;
4440 ret_val = false;
4441 continue;
252b5132 4442 }
3765b1be
RH		 4443
4444 dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4445 gotent = h->got_entries;
252b5132 4446 }
3765b1be 4447
252b5132 4448 addend = rel->r_addend;
3765b1be
RH		 4449 value += addend;
4450
4451 /* Search for the proper got entry. */
4452 for (; gotent ; gotent = gotent->next)
4453 if (gotent->gotobj == gotobj
4454 && gotent->reloc_type == r_type
4455 && gotent->addend == addend)
4456 break;
252b5132
RH		 4457
4458 switch (r_type)
4459 {
4460 case R_ALPHA_GPDISP:
4461 {
4462 bfd_byte *p_ldah, *p_lda;
4463
4464 BFD_ASSERT(gp != 0);
4465
3765b1be
RH		 4466 value = (input_section->output_section->vma
4467 + input_section->output_offset
4468 + rel->r_offset);
252b5132 4469
3765b1be 4470 p_ldah = contents + rel->r_offset;
252b5132
RH		 4471 p_lda = p_ldah + rel->r_addend;
4472
3765b1be 4473 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
252b5132
RH		 4474 p_ldah, p_lda);
4475 }
4476 break;
4477
252b5132 4478 case R_ALPHA_LITERAL:
3765b1be
RH		 4479 BFD_ASSERT(sgot != NULL);
4480 BFD_ASSERT(gp != 0);
4481 BFD_ASSERT(gotent != NULL);
4482 BFD_ASSERT(gotent->use_count >= 1);
f7460f5f 4483
3765b1be
RH		 4484 if (!gotent->reloc_done)
4485 {
4486 gotent->reloc_done = 1;
252b5132 4487
3765b1be
RH		 4488 bfd_put_64 (output_bfd, value,
4489 sgot->contents + gotent->got_offset);
252b5132 4490
3765b1be
RH		 4491 /* If the symbol has been forced local, output a
4492 RELATIVE reloc, otherwise it will be handled in
4493 finish_dynamic_symbol. */
4494 if (info->shared && !dynamic_symbol_p)
4495 {
4496 Elf_Internal_Rela outrel;
252b5132 4497
3765b1be 4498 BFD_ASSERT(srelgot != NULL);
252b5132 4499
3765b1be
RH		 4500 outrel.r_offset = (sgot->output_section->vma
4501 + sgot->output_offset
4502 + gotent->got_offset);
4503 outrel.r_info = ELF64_R_INFO (0, R_ALPHA_RELATIVE);
4504 outrel.r_addend = value;
252b5132 4505
3765b1be
RH		 4506 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
4507 ((Elf64_External_Rela *)
4508 srelgot->contents)
4509 + srelgot->reloc_count++);
4510 BFD_ASSERT (sizeof (Elf64_External_Rela)
4511 * srelgot->reloc_count
4512 <= srelgot->_cooked_size);
4513 }
4514 }
252b5132 4515
3765b1be
RH		 4516 value = (sgot->output_section->vma
4517 + sgot->output_offset
4518 + gotent->got_offset);
4519 value -= gp;
252b5132
RH		 4520 goto default_reloc;
4521
dfe57ca0 4522 case R_ALPHA_GPREL16:
252b5132
RH		 4523 case R_ALPHA_GPREL32:
4524 case R_ALPHA_GPRELLOW:
3765b1be 4525 if (dynamic_symbol_p)
f16fbd61
RH		 4526 {
4527 (*_bfd_error_handler)
4528 (_("%s: gp-relative relocation against dynamic symbol %s"),
8f615d07 4529 bfd_archive_filename (input_bfd), h->root.root.root.string);
f16fbd61
RH		 4530 ret_val = false;
4531 }
252b5132 4532 BFD_ASSERT(gp != 0);
3765b1be 4533 value -= gp;
252b5132
RH		 4534 goto default_reloc;
4535
4536 case R_ALPHA_GPRELHIGH:
3765b1be 4537 if (dynamic_symbol_p)
f16fbd61
RH		 4538 {
4539 (*_bfd_error_handler)
4540 (_("%s: gp-relative relocation against dynamic symbol %s"),
8f615d07 4541 bfd_archive_filename (input_bfd), h->root.root.root.string);
f16fbd61
RH		 4542 ret_val = false;
4543 }
252b5132 4544 BFD_ASSERT(gp != 0);
3765b1be
RH		 4545 value -= gp;
4546 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
252b5132
RH		 4547 goto default_reloc;
4548
252b5132 4549 case R_ALPHA_HINT:
f94952df
RH		 4550 /* A call to a dynamic symbol is definitely out of range of
4551 the 16-bit displacement. Don't bother writing anything. */
3765b1be 4552 if (dynamic_symbol_p)
f94952df
RH		 4553 {
4554 r = bfd_reloc_ok;
4555 break;
4556 }
3765b1be
RH		 4557 /* The regular PC-relative stuff measures from the start of
4558 the instruction rather than the end. */
4559 value -= 4;
4560 goto default_reloc;
f94952df
RH		 4561
4562 case R_ALPHA_BRADDR:
3765b1be
RH		 4563 if (dynamic_symbol_p)
4564 {
4565 (*_bfd_error_handler)
4566 (_("%s: pc-relative relocation against dynamic symbol %s"),
4567 bfd_archive_filename (input_bfd), h->root.root.root.string);
4568 ret_val = false;
4569 }
252b5132
RH		 4570 /* The regular PC-relative stuff measures from the start of
4571 the instruction rather than the end. */
3765b1be 4572 value -= 4;
252b5132
RH		 4573 goto default_reloc;
4574
7793f4d0
RH		 4575 case R_ALPHA_BRSGP:
4576 {
4577 int other;
4578 const char *name;
4579
4580 /* The regular PC-relative stuff measures from the start of
4581 the instruction rather than the end. */
3765b1be 4582 value -= 4;
7793f4d0 4583
ccf00ab6
RH		 4584 /* The source and destination gp must be the same. Note that
4585 the source will always have an assigned gp, since we forced
4586 one in check_relocs, but that the destination may not, as
cedb70c5 4587 it might not have had any relocations at all. Also take
ccf00ab6
RH		 4588 care not to crash if H is an undefined symbol. */
4589 if (h != NULL && sec != NULL
4590 && alpha_elf_tdata (sec->owner)->gotobj
7793f4d0
RH		 4591 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4592 {
7793f4d0
RH		 4593 (*_bfd_error_handler)
4594 (_("%s: change in gp: BRSGP %s"),
ccf00ab6 4595 bfd_archive_filename (input_bfd), h->root.root.root.string);
7793f4d0
RH		 4596 ret_val = false;
4597 }
4598
4599 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4600 if (h != NULL)
4601 other = h->root.other;
4602 else
4603 other = sym->st_other;
4604 switch (other & STO_ALPHA_STD_GPLOAD)
4605 {
4606 case STO_ALPHA_NOPV:
4607 break;
4608 case STO_ALPHA_STD_GPLOAD:
4609 addend += 8;
4610 break;
4611 default:
4612 if (h != NULL)
4613 name = h->root.root.root.string;
4614 else
4615 {
4616 name = (bfd_elf_string_from_elf_section
4617 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4618 if (name == NULL)
4619 name = _("<unknown>");
4620 else if (name[0] == 0)
4621 name = bfd_section_name (input_bfd, sec);
4622 }
4623 (*_bfd_error_handler)
4624 (_("%s: !samegp reloc against symbol without .prologue: %s"),
4625 bfd_archive_filename (input_bfd), name);
4626 ret_val = false;
4627 break;
4628 }
4629
4630 goto default_reloc;
4631 }
4632
252b5132
RH		 4633 case R_ALPHA_REFLONG:
4634 case R_ALPHA_REFQUAD:
3765b1be
RH		 4635 case R_ALPHA_DTPREL64:
4636 case R_ALPHA_TPREL64:
252b5132
RH		 4637 {
4638 Elf_Internal_Rela outrel;
252b5132
RH		 4639
4640 /* Careful here to remember RELATIVE relocations for global
4641 variables for symbolic shared objects. */
4642
3765b1be 4643 if (dynamic_symbol_p)
252b5132
RH		 4644 {
4645 BFD_ASSERT(h->root.dynindx != -1);
3765b1be 4646 outrel.r_info = ELF64_R_INFO (h->root.dynindx, r_type);
252b5132 4647 outrel.r_addend = addend;
3765b1be
RH		 4648 addend = 0, value = 0;
4649 }
4650 else if (r_type == R_ALPHA_DTPREL64)
4651 {
4652 BFD_ASSERT(tls_segment != NULL);
4653 value -= dtp_base;
4654 goto default_reloc;
4655 }
4656 else if (r_type == R_ALPHA_TPREL64)
4657 {
4658 BFD_ASSERT(tls_segment != NULL);
4659 value -= dtp_base;
4660 goto default_reloc;
252b5132 4661 }
ec338859
AM		 4662 else if (info->shared
4663 && r_symndx != 0
4664 && (input_section->flags & SEC_ALLOC))
252b5132 4665 {
3765b1be
RH		 4666 if (r_type == R_ALPHA_REFLONG)
4667 {
4668 (*_bfd_error_handler)
4669 (_("%s: unhandled dynamic relocation against %s"),
4670 bfd_archive_filename (input_bfd),
4671 h->root.root.root.string);
4672 ret_val = false;
4673 }
4674 outrel.r_info = ELF64_R_INFO (0, R_ALPHA_RELATIVE);
4675 outrel.r_addend = value;
252b5132
RH		 4676 }
4677 else
4678 goto default_reloc;
4679
3765b1be 4680 BFD_ASSERT(srel != NULL);
252b5132 4681
c629eae0
JJ		 4682 outrel.r_offset =
4683 _bfd_elf_section_offset (output_bfd, info, input_section,
4684 rel->r_offset);
0bb2d96a 4685 if ((outrel.r_offset | 1) != (bfd_vma) -1)
252b5132
RH		 4686 outrel.r_offset += (input_section->output_section->vma
4687 + input_section->output_offset);
4688 else
4689 memset (&outrel, 0, sizeof outrel);
4690
4691 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
4692 ((Elf64_External_Rela *)
4693 srel->contents)
4694 + srel->reloc_count++);
fe8bc63d 4695 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 4696 <= srel->_cooked_size);
4697 }
4698 goto default_reloc;
4699
3765b1be 4700 case R_ALPHA_SREL16:
84de6048
RH		 4701 case R_ALPHA_SREL32:
4702 case R_ALPHA_SREL64:
3765b1be
RH		 4703 if (dynamic_symbol_p)
4704 {
4705 (*_bfd_error_handler)
4706 (_("%s: pc-relative relocation against dynamic symbol %s"),
4707 bfd_archive_filename (input_bfd), h->root.root.root.string);
4708 ret_val = false;
4709 }
4710
84de6048
RH		 4711 /* ??? .eh_frame references to discarded sections will be smashed
4712 to relocations against SHN_UNDEF. The .eh_frame format allows
4713 NULL to be encoded as 0 in any format, so this works here. */
4714 if (r_symndx == 0)
4715 howto = (elf64_alpha_howto_table
4716 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4717 goto default_reloc;
4718
3765b1be
RH		 4719 case R_ALPHA_TLSLDM:
4720 /* Ignore the symbol for the relocation. The result is always
4721 the current module. */
4722 dynamic_symbol_p = 0;
4723 /* FALLTHRU */
4724
4725 case R_ALPHA_TLSGD:
4726 if (!gotent->reloc_done)
4727 {
4728 gotent->reloc_done = 1;
4729
4730 /* Note that the module index for the main program is 1. */
4731 bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p,
4732 sgot->contents + gotent->got_offset);
4733
4734 /* If the symbol has been forced local, output a
4735 DTPMOD64 reloc, otherwise it will be handled in
4736 finish_dynamic_symbol. */
4737 if (info->shared && !dynamic_symbol_p)
4738 {
4739 Elf_Internal_Rela outrel;
4740
4741 BFD_ASSERT(srelgot != NULL);
4742
4743 outrel.r_offset = (sgot->output_section->vma
4744 + sgot->output_offset
4745 + gotent->got_offset);
4746 /* ??? Proper dynindx here. */
4747 outrel.r_info = ELF64_R_INFO (0, R_ALPHA_DTPMOD64);
4748 outrel.r_addend = 0;
4749
4750 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
4751 ((Elf64_External_Rela *)
4752 srelgot->contents)
4753 + srelgot->reloc_count++);
4754 BFD_ASSERT (sizeof (Elf64_External_Rela)
4755 * srelgot->reloc_count
4756 <= srelgot->_cooked_size);
4757 }
4758
4759 if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4760 value = 0;
4761 else
4762 {
4763 BFD_ASSERT(tls_segment != NULL);
4764 value -= dtp_base;
4765 }
4766 bfd_put_64 (output_bfd, value,
4767 sgot->contents + gotent->got_offset + 8);
4768 }
4769
4770 value = (sgot->output_section->vma
4771 + sgot->output_offset
4772 + gotent->got_offset);
4773 value -= gp;
4774 goto default_reloc;
4775
4776 case R_ALPHA_DTPRELHI:
4777 case R_ALPHA_DTPRELLO:
4778 case R_ALPHA_DTPREL16:
4779 if (dynamic_symbol_p)
4780 {
4781 (*_bfd_error_handler)
4782 (_("%s: dtp-relative relocation against dynamic symbol %s"),
4783 bfd_archive_filename (input_bfd), h->root.root.root.string);
4784 ret_val = false;
4785 }
4786 BFD_ASSERT(tls_segment != NULL);
4787 value -= dtp_base;
9e756d64
RH		 4788 if (r_type == R_ALPHA_DTPRELHI)
4789 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
3765b1be
RH		 4790 goto default_reloc;
4791
4792 case R_ALPHA_TPRELHI:
4793 case R_ALPHA_TPRELLO:
4794 case R_ALPHA_TPREL16:
9e756d64
RH		 4795 if (info->shared)
4796 {
4797 (*_bfd_error_handler)
4798 (_("%s: TLS local exec code cannot be linked into shared objects"),
4799 bfd_archive_filename (input_bfd));
4800 ret_val = false;
4801 }
4802 else if (dynamic_symbol_p)
3765b1be
RH		 4803 {
4804 (*_bfd_error_handler)
4805 (_("%s: tp-relative relocation against dynamic symbol %s"),
4806 bfd_archive_filename (input_bfd), h->root.root.root.string);
4807 ret_val = false;
4808 }
4809 BFD_ASSERT(tls_segment != NULL);
4810 value -= tp_base;
9e756d64
RH		 4811 if (r_type == R_ALPHA_TPRELHI)
4812 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
3765b1be
RH		 4813 goto default_reloc;
4814
4815 case R_ALPHA_GOTDTPREL:
4816 case R_ALPHA_GOTTPREL:
4817 BFD_ASSERT(sgot != NULL);
4818 BFD_ASSERT(gp != 0);
4819 BFD_ASSERT(gotent != NULL);
4820 BFD_ASSERT(gotent->use_count >= 1);
4821
4822 if (!gotent->reloc_done)
4823 {
4824 gotent->reloc_done = 1;
4825
4826 if (dynamic_symbol_p)
4827 value = 0;
4828 else
4829 {
4830 BFD_ASSERT(tls_segment != NULL);
4831 value -= (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
4832 }
4833 bfd_put_64 (output_bfd, value,
4834 sgot->contents + gotent->got_offset);
4835 }
4836
4837 value = (sgot->output_section->vma
4838 + sgot->output_offset
4839 + gotent->got_offset);
4840 value -= gp;
4841 goto default_reloc;
4842
252b5132
RH		 4843 default:
4844 default_reloc:
4845 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3765b1be 4846 contents, rel->r_offset, value, 0);
252b5132
RH		 4847 break;
4848 }
4849
4850 switch (r)
4851 {
4852 case bfd_reloc_ok:
4853 break;
4854
4855 case bfd_reloc_overflow:
4856 {
4857 const char *name;
4858
ed4de5e2
JJ		 4859 /* Don't warn if the overflow is due to pc relative reloc
4860 against discarded section. Section optimization code should
4861 handle it. */
4862
4863 if (r_symndx < symtab_hdr->sh_info
4864 && sec != NULL && howto->pc_relative
4865 && elf_discarded_section (sec))
4866 break;
4867
252b5132
RH		 4868 if (h != NULL)
4869 name = h->root.root.root.string;
4870 else
4871 {
4872 name = (bfd_elf_string_from_elf_section
4873 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4874 if (name == NULL)
4875 return false;
4876 if (*name == '\0')
4877 name = bfd_section_name (input_bfd, sec);
4878 }
4879 if (! ((*info->callbacks->reloc_overflow)
4880 (info, name, howto->name, (bfd_vma) 0,
4881 input_bfd, input_section, rel->r_offset)))
f16fbd61 4882 ret_val = false;
252b5132
RH		 4883 }
4884 break;
4885
4886 default:
4887 case bfd_reloc_outofrange:
4888 abort ();
4889 }
4890 }
4891
f16fbd61 4892 return ret_val;
252b5132
RH		 4893}
4894
4895/* Finish up dynamic symbol handling. We set the contents of various
4896 dynamic sections here. */
4897
4898static boolean
4899elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
4900 bfd *output_bfd;
4901 struct bfd_link_info *info;
4902 struct elf_link_hash_entry *h;
4903 Elf_Internal_Sym *sym;
4904{
4905 bfd *dynobj = elf_hash_table(info)->dynobj;
4906
4907 if (h->plt.offset != MINUS_ONE)
4908 {
4909 /* Fill in the .plt entry for this symbol. */
4910 asection *splt, *sgot, *srel;
4911 Elf_Internal_Rela outrel;
4912 bfd_vma got_addr, plt_addr;
4913 bfd_vma plt_index;
4914 struct alpha_elf_got_entry *gotent;
4915
4916 BFD_ASSERT (h->dynindx != -1);
4917
4918 /* The first .got entry will be updated by the .plt with the
4919 address of the target function. */
4920 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4921 BFD_ASSERT (gotent && gotent->addend == 0);
4922
4923 splt = bfd_get_section_by_name (dynobj, ".plt");
4924 BFD_ASSERT (splt != NULL);
4925 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4926 BFD_ASSERT (srel != NULL);
4927 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4928 BFD_ASSERT (sgot != NULL);
4929
4930 got_addr = (sgot->output_section->vma
4931 + sgot->output_offset
4932 + gotent->got_offset);
4933 plt_addr = (splt->output_section->vma
4934 + splt->output_offset
4935 + h->plt.offset);
4936
4937 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4938
4939 /* Fill in the entry in the procedure linkage table. */
4940 {
dc810e39 4941 bfd_vma insn1, insn2, insn3;
252b5132
RH		 4942
4943 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
4944 insn2 = PLT_ENTRY_WORD2;
4945 insn3 = PLT_ENTRY_WORD3;
4946
4947 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
4948 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
4949 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
4950 }
4951
4952 /* Fill in the entry in the .rela.plt section. */
4953 outrel.r_offset = got_addr;
4954 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4955 outrel.r_addend = 0;
4956
4957 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
4958 ((Elf64_External_Rela *)srel->contents
4959 + plt_index));
4960
4961 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
4962 {
4963 /* Mark the symbol as undefined, rather than as defined in the
4964 .plt section. Leave the value alone. */
4965 sym->st_shndx = SHN_UNDEF;
4966 }
4967
4968 /* Fill in the entries in the .got. */
4969 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
4970
4971 /* Subsequent .got entries will continue to bounce through the .plt. */
4972 if (gotent->next)
4973 {
4974 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4975 BFD_ASSERT (! info->shared || srel != NULL);
4976
4977 gotent = gotent->next;
4978 do
4979 {
4980 sgot = alpha_elf_tdata(gotent->gotobj)->got;
4981 BFD_ASSERT(sgot != NULL);
4982 BFD_ASSERT(gotent->addend == 0);
4983
4984 bfd_put_64 (output_bfd, plt_addr,
4985 sgot->contents + gotent->got_offset);
4986
4987 if (info->shared)
4988 {
4989 outrel.r_offset = (sgot->output_section->vma
4990 + sgot->output_offset
4991 + gotent->got_offset);
4992 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
28cfee26 4993 outrel.r_addend = plt_addr;
252b5132
RH		 4994
4995 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
4996 ((Elf64_External_Rela *)
4997 srel->contents)
4998 + srel->reloc_count++);
fe8bc63d 4999 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 5000 <= srel->_cooked_size);
5001 }
5002
5003 gotent = gotent->next;
5004 }
5005 while (gotent != NULL);
5006 }
5007 }
5008 else if (alpha_elf_dynamic_symbol_p (h, info))
5009 {
5010 /* Fill in the dynamic relocations for this symbol's .got entries. */
5011 asection *srel;
5012 Elf_Internal_Rela outrel;
5013 struct alpha_elf_got_entry *gotent;
5014
5015 srel = bfd_get_section_by_name (dynobj, ".rela.got");
5016 BFD_ASSERT (srel != NULL);
5017
252b5132
RH		 5018 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
5019 gotent != NULL;
5020 gotent = gotent->next)
5021 {
f44f99a5 5022 asection *sgot;
3765b1be
RH		 5023 int r_type;
5024
f44f99a5
RH		 5025 if (gotent->use_count == 0)
5026 continue;
5027
5028 sgot = alpha_elf_tdata (gotent->gotobj)->got;
252b5132
RH		 5029 outrel.r_offset = (sgot->output_section->vma
5030 + sgot->output_offset
5031 + gotent->got_offset);
3765b1be
RH		 5032
5033 r_type = gotent->reloc_type;
5034 switch (r_type)
5035 {
5036 case R_ALPHA_LITERAL:
5037 r_type = R_ALPHA_GLOB_DAT;
5038 break;
5039 case R_ALPHA_TLSGD:
5040 r_type = R_ALPHA_DTPMOD64;
5041 break;
5042 case R_ALPHA_GOTDTPREL:
5043 r_type = R_ALPHA_DTPREL64;
5044 break;
5045 case R_ALPHA_GOTTPREL:
5046 r_type = R_ALPHA_TPREL64;
5047 break;
5048 case R_ALPHA_TLSLDM:
5049 default:
5050 abort ();
5051 }
5052
5053 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
252b5132
RH		 5054 outrel.r_addend = gotent->addend;
5055
5056 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
5057 ((Elf64_External_Rela *)srel->contents
5058 + srel->reloc_count++));
3765b1be
RH		 5059
5060 if (gotent->reloc_type == R_ALPHA_TLSGD)
5061 {
5062 outrel.r_offset += 8;
5063 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_DTPREL64);
5064
5065 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
5066 ((Elf64_External_Rela *)srel->contents
5067 + srel->reloc_count++));
5068 }
5069
fe8bc63d 5070 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 5071 <= srel->_cooked_size);
5072 }
5073 }
5074
5075 /* Mark some specially defined symbols as absolute. */
5076 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5077 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
5078 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
5079 sym->st_shndx = SHN_ABS;
5080
5081 return true;
5082}
5083
5084/* Finish up the dynamic sections. */
5085
5086static boolean
5087elf64_alpha_finish_dynamic_sections (output_bfd, info)
5088 bfd *output_bfd;
5089 struct bfd_link_info *info;
5090{
5091 bfd *dynobj;
5092 asection *sdyn;
5093
5094 dynobj = elf_hash_table (info)->dynobj;
5095 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5096
5097 if (elf_hash_table (info)->dynamic_sections_created)
5098 {
5099 asection *splt;
5100 Elf64_External_Dyn *dyncon, *dynconend;
5101
5102 splt = bfd_get_section_by_name (dynobj, ".plt");
5103 BFD_ASSERT (splt != NULL && sdyn != NULL);
5104
5105 dyncon = (Elf64_External_Dyn *) sdyn->contents;
5106 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
5107 for (; dyncon < dynconend; dyncon++)
5108 {
5109 Elf_Internal_Dyn dyn;
5110 const char *name;
5111 asection *s;
5112
5113 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
5114
5115 switch (dyn.d_tag)
5116 {
5117 case DT_PLTGOT:
5118 name = ".plt";
5119 goto get_vma;
5120 case DT_PLTRELSZ:
5121 name = ".rela.plt";
5122 goto get_size;
5123 case DT_JMPREL:
5124 name = ".rela.plt";
5125 goto get_vma;
5126
5127 case DT_RELASZ:
5128 /* My interpretation of the TIS v1.1 ELF document indicates
5129 that RELASZ should not include JMPREL. This is not what
5130 the rest of the BFD does. It is, however, what the
5131 glibc ld.so wants. Do this fixup here until we found
5132 out who is right. */
5133 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
5134 if (s)
5135 {
5136 dyn.d_un.d_val -=
5137 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
5138 }
5139 break;
5140
5141 get_vma:
5142 s = bfd_get_section_by_name (output_bfd, name);
5143 dyn.d_un.d_ptr = (s ? s->vma : 0);
5144 break;
5145
5146 get_size:
5147 s = bfd_get_section_by_name (output_bfd, name);
5148 dyn.d_un.d_val =
5149 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
5150 break;
5151 }
5152
5153 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5154 }
5155
5156 /* Initialize the PLT0 entry */
5157 if (splt->_raw_size > 0)
5158 {
5159 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
5160 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
5161 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
5162 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
5163
5164 /* The next two words will be filled in by ld.so */
dc810e39
AM		 5165 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
5166 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
252b5132
RH		 5167
5168 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
5169 PLT_HEADER_SIZE;
5170 }
5171 }
5172
252b5132
RH		 5173 return true;
5174}
5175
96e2734b
RH		 5176/* We need to use a special link routine to handle the .mdebug section.
5177 We need to merge all instances of these sections together, not write
5178 them all out sequentially. */
252b5132
RH		 5179
5180static boolean
5181elf64_alpha_final_link (abfd, info)
5182 bfd *abfd;
5183 struct bfd_link_info *info;
5184{
5185 asection *o;
5186 struct bfd_link_order *p;
96e2734b 5187 asection *mdebug_sec;
252b5132
RH		 5188 struct ecoff_debug_info debug;
5189 const struct ecoff_debug_swap *swap
5190 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5191 HDRR *symhdr = &debug.symbolic_header;
5192 PTR mdebug_handle = NULL;
5193
96e2734b 5194 /* Go through the sections and collect the mdebug information. */
252b5132 5195 mdebug_sec = NULL;
252b5132
RH		 5196 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5197 {
252b5132
RH		 5198 if (strcmp (o->name, ".mdebug") == 0)
5199 {
5200 struct extsym_info einfo;
5201
5202 /* We have found the .mdebug section in the output file.
5203 Look through all the link_orders comprising it and merge
5204 the information together. */
5205 symhdr->magic = swap->sym_magic;
5206 /* FIXME: What should the version stamp be? */
5207 symhdr->vstamp = 0;
5208 symhdr->ilineMax = 0;
5209 symhdr->cbLine = 0;
5210 symhdr->idnMax = 0;
5211 symhdr->ipdMax = 0;
5212 symhdr->isymMax = 0;
5213 symhdr->ioptMax = 0;
5214 symhdr->iauxMax = 0;
5215 symhdr->issMax = 0;
5216 symhdr->issExtMax = 0;
5217 symhdr->ifdMax = 0;
5218 symhdr->crfd = 0;
5219 symhdr->iextMax = 0;
5220
5221 /* We accumulate the debugging information itself in the
5222 debug_info structure. */
5223 debug.line = NULL;
5224 debug.external_dnr = NULL;
5225 debug.external_pdr = NULL;
5226 debug.external_sym = NULL;
5227 debug.external_opt = NULL;
5228 debug.external_aux = NULL;
5229 debug.ss = NULL;
5230 debug.ssext = debug.ssext_end = NULL;
5231 debug.external_fdr = NULL;
5232 debug.external_rfd = NULL;
5233 debug.external_ext = debug.external_ext_end = NULL;
5234
5235 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5236 if (mdebug_handle == (PTR) NULL)
5237 return false;
5238
5239 if (1)
5240 {
5241 asection *s;
5242 EXTR esym;
52b9d213 5243 bfd_vma last = 0;
252b5132
RH		 5244 unsigned int i;
5245 static const char * const name[] =
5246 {
5247 ".text", ".init", ".fini", ".data",
5248 ".rodata", ".sdata", ".sbss", ".bss"
5249 };
5250 static const int sc[] = { scText, scInit, scFini, scData,
5251 scRData, scSData, scSBss, scBss };
5252
5253 esym.jmptbl = 0;
5254 esym.cobol_main = 0;
5255 esym.weakext = 0;
5256 esym.reserved = 0;
5257 esym.ifd = ifdNil;
5258 esym.asym.iss = issNil;
5259 esym.asym.st = stLocal;
5260 esym.asym.reserved = 0;
5261 esym.asym.index = indexNil;
5262 for (i = 0; i < 8; i++)
5263 {
5264 esym.asym.sc = sc[i];
5265 s = bfd_get_section_by_name (abfd, name[i]);
5266 if (s != NULL)
5267 {
5268 esym.asym.value = s->vma;
5269 last = s->vma + s->_raw_size;
5270 }
5271 else
5272 esym.asym.value = last;
5273
5274 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5275 name[i], &esym))
5276 return false;
5277 }
5278 }
5279
5280 for (p = o->link_order_head;
5281 p != (struct bfd_link_order *) NULL;
5282 p = p->next)
5283 {
5284 asection *input_section;
5285 bfd *input_bfd;
5286 const struct ecoff_debug_swap *input_swap;
5287 struct ecoff_debug_info input_debug;
5288 char *eraw_src;
5289 char *eraw_end;
5290
5291 if (p->type != bfd_indirect_link_order)
5292 {
fd96f80f 5293 if (p->type == bfd_data_link_order)
252b5132
RH		 5294 continue;
5295 abort ();
5296 }
5297
5298 input_section = p->u.indirect.section;
5299 input_bfd = input_section->owner;
5300
5301 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
5302 || (get_elf_backend_data (input_bfd)
5303 ->elf_backend_ecoff_debug_swap) == NULL)
5304 {
5305 /* I don't know what a non ALPHA ELF bfd would be
5306 doing with a .mdebug section, but I don't really
5307 want to deal with it. */
5308 continue;
5309 }
5310
5311 input_swap = (get_elf_backend_data (input_bfd)
5312 ->elf_backend_ecoff_debug_swap);
5313
5314 BFD_ASSERT (p->size == input_section->_raw_size);
5315
5316 /* The ECOFF linking code expects that we have already
5317 read in the debugging information and set up an
5318 ecoff_debug_info structure, so we do that now. */
5319 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5320 &input_debug))
5321 return false;
5322
5323 if (! (bfd_ecoff_debug_accumulate
5324 (mdebug_handle, abfd, &debug, swap, input_bfd,
5325 &input_debug, input_swap, info)))
5326 return false;
5327
5328 /* Loop through the external symbols. For each one with
5329 interesting information, try to find the symbol in
5330 the linker global hash table and save the information
5331 for the output external symbols. */
5332 eraw_src = input_debug.external_ext;
5333 eraw_end = (eraw_src
5334 + (input_debug.symbolic_header.iextMax
5335 * input_swap->external_ext_size));
5336 for (;
5337 eraw_src < eraw_end;
5338 eraw_src += input_swap->external_ext_size)
5339 {
5340 EXTR ext;
5341 const char *name;
5342 struct alpha_elf_link_hash_entry *h;
5343
5344 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
5345 if (ext.asym.sc == scNil
5346 || ext.asym.sc == scUndefined
5347 || ext.asym.sc == scSUndefined)
5348 continue;
5349
5350 name = input_debug.ssext + ext.asym.iss;
5351 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
5352 name, false, false, true);
5353 if (h == NULL || h->esym.ifd != -2)
5354 continue;
5355
5356 if (ext.ifd != -1)
5357 {
5358 BFD_ASSERT (ext.ifd
5359 < input_debug.symbolic_header.ifdMax);
5360 ext.ifd = input_debug.ifdmap[ext.ifd];
5361 }
5362
5363 h->esym = ext;
5364 }
5365
5366 /* Free up the information we just read. */
5367 free (input_debug.line);
5368 free (input_debug.external_dnr);
5369 free (input_debug.external_pdr);
5370 free (input_debug.external_sym);
5371 free (input_debug.external_opt);
5372 free (input_debug.external_aux);
5373 free (input_debug.ss);
5374 free (input_debug.ssext);
5375 free (input_debug.external_fdr);
5376 free (input_debug.external_rfd);
5377 free (input_debug.external_ext);
5378
5379 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5380 elf_link_input_bfd ignores this section. */
5381 input_section->flags &=~ SEC_HAS_CONTENTS;
5382 }
5383
252b5132
RH		 5384 /* Build the external symbol information. */
5385 einfo.abfd = abfd;
5386 einfo.info = info;
5387 einfo.debug = &debug;
5388 einfo.swap = swap;
5389 einfo.failed = false;
5390 elf_link_hash_traverse (elf_hash_table (info),
5391 elf64_alpha_output_extsym,
5392 (PTR) &einfo);
5393 if (einfo.failed)
5394 return false;
5395
5396 /* Set the size of the .mdebug section. */
5397 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
5398
5399 /* Skip this section later on (I don't think this currently
5400 matters, but someday it might). */
5401 o->link_order_head = (struct bfd_link_order *) NULL;
5402
5403 mdebug_sec = o;
5404 }
252b5132
RH		 5405 }
5406
5407 /* Invoke the regular ELF backend linker to do all the work. */
5408 if (! bfd_elf64_bfd_final_link (abfd, info))
5409 return false;
5410
5411 /* Now write out the computed sections. */
5412
5413 /* The .got subsections... */
5414 {
5415 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5416 for (i = alpha_elf_hash_table(info)->got_list;
5417 i != NULL;
5418 i = alpha_elf_tdata(i)->got_link_next)
5419 {
5420 asection *sgot;
5421
5422 /* elf_bfd_final_link already did everything in dynobj. */
5423 if (i == dynobj)
5424 continue;
5425
5426 sgot = alpha_elf_tdata(i)->got;
5427 if (! bfd_set_section_contents (abfd, sgot->output_section,
dc810e39
AM		 5428 sgot->contents,
5429 (file_ptr) sgot->output_offset,
252b5132
RH		 5430 sgot->_raw_size))
5431 return false;
5432 }
5433 }
5434
252b5132
RH		 5435 if (mdebug_sec != (asection *) NULL)
5436 {
5437 BFD_ASSERT (abfd->output_has_begun);
5438 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5439 swap, info,
5440 mdebug_sec->filepos))
5441 return false;
5442
5443 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5444 }
5445
252b5132
RH		 5446 return true;
5447}
fcfbdf31
JJ		 5448
5449static enum elf_reloc_type_class
f51e552e
AM		 5450elf64_alpha_reloc_type_class (rela)
5451 const Elf_Internal_Rela *rela;
fcfbdf31 5452{
f51e552e 5453 switch ((int) ELF64_R_TYPE (rela->r_info))
fcfbdf31
JJ		 5454 {
5455 case R_ALPHA_RELATIVE:
5456 return reloc_class_relative;
5457 case R_ALPHA_JMP_SLOT:
5458 return reloc_class_plt;
5459 case R_ALPHA_COPY:
5460 return reloc_class_copy;
5461 default:
5462 return reloc_class_normal;
5463 }
5464}
252b5132
RH		 5465\f
5466/* ECOFF swapping routines. These are used when dealing with the
5467 .mdebug section, which is in the ECOFF debugging format. Copied
fe8bc63d 5468 from elf32-mips.c. */
252b5132
RH		 5469static const struct ecoff_debug_swap
5470elf64_alpha_ecoff_debug_swap =
5471{
5472 /* Symbol table magic number. */
5473 magicSym2,
5474 /* Alignment of debugging information. E.g., 4. */
5475 8,
5476 /* Sizes of external symbolic information. */
5477 sizeof (struct hdr_ext),
5478 sizeof (struct dnr_ext),
5479 sizeof (struct pdr_ext),
5480 sizeof (struct sym_ext),
5481 sizeof (struct opt_ext),
5482 sizeof (struct fdr_ext),
5483 sizeof (struct rfd_ext),
5484 sizeof (struct ext_ext),
5485 /* Functions to swap in external symbolic data. */
5486 ecoff_swap_hdr_in,
5487 ecoff_swap_dnr_in,
5488 ecoff_swap_pdr_in,
5489 ecoff_swap_sym_in,
5490 ecoff_swap_opt_in,
5491 ecoff_swap_fdr_in,
5492 ecoff_swap_rfd_in,
5493 ecoff_swap_ext_in,
5494 _bfd_ecoff_swap_tir_in,
5495 _bfd_ecoff_swap_rndx_in,
5496 /* Functions to swap out external symbolic data. */
5497 ecoff_swap_hdr_out,
5498 ecoff_swap_dnr_out,
5499 ecoff_swap_pdr_out,
5500 ecoff_swap_sym_out,
5501 ecoff_swap_opt_out,
5502 ecoff_swap_fdr_out,
5503 ecoff_swap_rfd_out,
5504 ecoff_swap_ext_out,
5505 _bfd_ecoff_swap_tir_out,
5506 _bfd_ecoff_swap_rndx_out,
5507 /* Function to read in symbolic data. */
5508 elf64_alpha_read_ecoff_info
5509};
5510\f
70bcb145
JW		 5511/* Use a non-standard hash bucket size of 8. */
5512
5513const struct elf_size_info alpha_elf_size_info =
5514{
5515 sizeof (Elf64_External_Ehdr),
5516 sizeof (Elf64_External_Phdr),
5517 sizeof (Elf64_External_Shdr),
5518 sizeof (Elf64_External_Rel),
5519 sizeof (Elf64_External_Rela),
5520 sizeof (Elf64_External_Sym),
5521 sizeof (Elf64_External_Dyn),
5522 sizeof (Elf_External_Note),
5523 8,
5524 1,
5525 64, 8,
5526 ELFCLASS64, EV_CURRENT,
5527 bfd_elf64_write_out_phdrs,
5528 bfd_elf64_write_shdrs_and_ehdr,
5529 bfd_elf64_write_relocs,
73ff0d56 5530 bfd_elf64_swap_symbol_in,
70bcb145
JW		 5531 bfd_elf64_swap_symbol_out,
5532 bfd_elf64_slurp_reloc_table,
5533 bfd_elf64_slurp_symbol_table,
5534 bfd_elf64_swap_dyn_in,
5535 bfd_elf64_swap_dyn_out,
5536 NULL,
5537 NULL,
5538 NULL,
5539 NULL
5540};
5541
252b5132
RH		 5542#define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5543#define TARGET_LITTLE_NAME "elf64-alpha"
5544#define ELF_ARCH bfd_arch_alpha
56fc028e
AJ		 5545#define ELF_MACHINE_CODE EM_ALPHA
5546#define ELF_MAXPAGESIZE 0x10000
252b5132
RH		 5547
5548#define bfd_elf64_bfd_link_hash_table_create \
5549 elf64_alpha_bfd_link_hash_table_create
5550
5551#define bfd_elf64_bfd_reloc_type_lookup \
5552 elf64_alpha_bfd_reloc_type_lookup
5553#define elf_info_to_howto \
5554 elf64_alpha_info_to_howto
5555
5556#define bfd_elf64_mkobject \
5557 elf64_alpha_mkobject
5558#define elf_backend_object_p \
5559 elf64_alpha_object_p
5560
5561#define elf_backend_section_from_shdr \
5562 elf64_alpha_section_from_shdr
204692d7
RH		 5563#define elf_backend_section_flags \
5564 elf64_alpha_section_flags
252b5132
RH		 5565#define elf_backend_fake_sections \
5566 elf64_alpha_fake_sections
5567
5568#define bfd_elf64_bfd_is_local_label_name \
5569 elf64_alpha_is_local_label_name
5570#define bfd_elf64_find_nearest_line \
5571 elf64_alpha_find_nearest_line
5572#define bfd_elf64_bfd_relax_section \
5573 elf64_alpha_relax_section
5574
5575#define elf_backend_add_symbol_hook \
5576 elf64_alpha_add_symbol_hook
5577#define elf_backend_check_relocs \
5578 elf64_alpha_check_relocs
5579#define elf_backend_create_dynamic_sections \
5580 elf64_alpha_create_dynamic_sections
5581#define elf_backend_adjust_dynamic_symbol \
5582 elf64_alpha_adjust_dynamic_symbol
5583#define elf_backend_always_size_sections \
5584 elf64_alpha_always_size_sections
5585#define elf_backend_size_dynamic_sections \
5586 elf64_alpha_size_dynamic_sections
5587#define elf_backend_relocate_section \
5588 elf64_alpha_relocate_section
5589#define elf_backend_finish_dynamic_symbol \
5590 elf64_alpha_finish_dynamic_symbol
5591#define elf_backend_finish_dynamic_sections \
5592 elf64_alpha_finish_dynamic_sections
5593#define bfd_elf64_bfd_final_link \
5594 elf64_alpha_final_link
fcfbdf31
JJ		 5595#define elf_backend_reloc_type_class \
5596 elf64_alpha_reloc_type_class
252b5132
RH		 5597
5598#define elf_backend_ecoff_debug_swap \
5599 &elf64_alpha_ecoff_debug_swap
5600
70bcb145
JW		 5601#define elf_backend_size_info \
5602 alpha_elf_size_info
5603
38b1a46c 5604/* A few constants that determine how the .plt section is set up. */
252b5132
RH		 5605#define elf_backend_want_got_plt 0
5606#define elf_backend_plt_readonly 0
5607#define elf_backend_want_plt_sym 1
5608#define elf_backend_got_header_size 0
5609#define elf_backend_plt_header_size PLT_HEADER_SIZE
5610
5611#include "elf64-target.h"
A mirror of the official binutils-gdb repository