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