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