projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2001-12-06 Michael Snyder <msnyder@redhat.com>
[deliverable/binutils-gdb.git] / bfd / elf64-alpha.c
CommitLineData
252b5132 1/* Alpha specific support for 64-bit ELF
7898deda
NC		 2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
252b5132
RH		 4 Contributed by Richard Henderson <rth@tamu.edu>.
5
6This file is part of BFD, the Binary File Descriptor library.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22/* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
24
25#include "bfd.h"
26#include "sysdep.h"
27#include "libbfd.h"
28#include "elf-bfd.h"
29
30#include "elf/alpha.h"
31
32#define ALPHAECOFF
33
34#define NO_COFF_RELOCS
35#define NO_COFF_SYMBOLS
36#define NO_COFF_LINENOS
37
fe8bc63d 38/* Get the ECOFF swapping routines. Needed for the debug information. */
252b5132
RH		 39#include "coff/internal.h"
40#include "coff/sym.h"
41#include "coff/symconst.h"
42#include "coff/ecoff.h"
43#include "coff/alpha.h"
44#include "aout/ar.h"
45#include "libcoff.h"
46#include "libecoff.h"
47#define ECOFF_64
48#include "ecoffswap.h"
49
8fb35fed
RH		 50static int alpha_elf_dynamic_symbol_p
51 PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
252b5132
RH		 52static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
53 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
54static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
55 PARAMS((bfd *));
56
57static bfd_reloc_status_type elf64_alpha_reloc_nil
58 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
59static bfd_reloc_status_type elf64_alpha_reloc_bad
60 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
61static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
62 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
63static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
64 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
65
66static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
67 PARAMS((bfd *, bfd_reloc_code_real_type));
68static void elf64_alpha_info_to_howto
69 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
70
8fb35fed
RH		 71static boolean elf64_alpha_mkobject
72 PARAMS((bfd *));
252b5132
RH		 73static boolean elf64_alpha_object_p
74 PARAMS((bfd *));
75static boolean elf64_alpha_section_from_shdr
76 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
204692d7
RH		 77static boolean elf64_alpha_section_flags
78 PARAMS((flagword *, Elf64_Internal_Shdr *));
252b5132
RH		 79static boolean elf64_alpha_fake_sections
80 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
81static boolean elf64_alpha_create_got_section
82 PARAMS((bfd *, struct bfd_link_info *));
83static boolean elf64_alpha_create_dynamic_sections
84 PARAMS((bfd *, struct bfd_link_info *));
85
86static boolean elf64_alpha_read_ecoff_info
87 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
88static boolean elf64_alpha_is_local_label_name
89 PARAMS((bfd *, const char *));
90static boolean elf64_alpha_find_nearest_line
91 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
92 const char **, unsigned int *));
93
94#if defined(__STDC__) || defined(ALMOST_STDC)
95struct alpha_elf_link_hash_entry;
96#endif
97
98static boolean elf64_alpha_output_extsym
99 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
100
101static boolean elf64_alpha_can_merge_gots
102 PARAMS((bfd *, bfd *));
103static void elf64_alpha_merge_gots
104 PARAMS((bfd *, bfd *));
105static boolean elf64_alpha_calc_got_offsets_for_symbol
106 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
107static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
108static boolean elf64_alpha_size_got_sections
109 PARAMS ((bfd *, struct bfd_link_info *));
110static boolean elf64_alpha_always_size_sections
111 PARAMS ((bfd *, struct bfd_link_info *));
112static boolean elf64_alpha_calc_dynrel_sizes
113 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
114static boolean elf64_alpha_add_symbol_hook
115 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
116 const char **, flagword *, asection **, bfd_vma *));
117static boolean elf64_alpha_check_relocs
118 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
119 const Elf_Internal_Rela *));
120static boolean elf64_alpha_adjust_dynamic_symbol
121 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
122static boolean elf64_alpha_size_dynamic_sections
123 PARAMS((bfd *, struct bfd_link_info *));
252b5132
RH		 124static boolean elf64_alpha_relocate_section
125 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
126 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
127static boolean elf64_alpha_finish_dynamic_symbol
128 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
129 Elf_Internal_Sym *));
130static boolean elf64_alpha_finish_dynamic_sections
131 PARAMS((bfd *, struct bfd_link_info *));
132static boolean elf64_alpha_final_link
133 PARAMS((bfd *, struct bfd_link_info *));
cd6f9321
L		 134static boolean elf64_alpha_merge_ind_symbols
135 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
136static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
137 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
fcfbdf31 138static enum elf_reloc_type_class elf64_alpha_reloc_type_class
f51e552e 139 PARAMS ((const Elf_Internal_Rela *));
252b5132
RH		 140\f
141struct alpha_elf_link_hash_entry
142{
143 struct elf_link_hash_entry root;
144
145 /* External symbol information. */
146 EXTR esym;
147
148 /* Cumulative flags for all the .got entries. */
149 int flags;
150
151 /* Contexts (LITUSE) in which a literal was referenced. */
152#define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
153#define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
154#define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
155#define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
156
157 /* Used to implement multiple .got subsections. */
158 struct alpha_elf_got_entry
159 {
160 struct alpha_elf_got_entry *next;
161
162 /* which .got subsection? */
163 bfd *gotobj;
164
165 /* the addend in effect for this entry. */
dc810e39 166 bfd_vma addend;
252b5132
RH		 167
168 /* the .got offset for this entry. */
169 int got_offset;
170
171 int flags;
172
f7460f5f 173 /* Additional flags. */
252b5132 174#define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
f7460f5f 175#define ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED 0x20
252b5132
RH		 176
177 int use_count;
178 } *got_entries;
179
180 /* used to count non-got, non-plt relocations for delayed sizing
181 of relocation sections. */
182 struct alpha_elf_reloc_entry
183 {
184 struct alpha_elf_reloc_entry *next;
185
186 /* which .reloc section? */
187 asection *srel;
188
189 /* what kind of relocation? */
fcfbdf31
JJ		 190 unsigned int rtype;
191
192 /* is this against read-only section? */
193 unsigned int reltext : 1;
252b5132
RH		 194
195 /* how many did we find? */
196 unsigned long count;
197 } *reloc_entries;
198};
199
200/* Alpha ELF linker hash table. */
201
202struct alpha_elf_link_hash_table
203{
204 struct elf_link_hash_table root;
205
206 /* The head of a list of .got subsections linked through
207 alpha_elf_tdata(abfd)->got_link_next. */
208 bfd *got_list;
209};
210
211/* Look up an entry in a Alpha ELF linker hash table. */
212
213#define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
214 ((struct alpha_elf_link_hash_entry *) \
215 elf_link_hash_lookup (&(table)->root, (string), (create), \
216 (copy), (follow)))
217
218/* Traverse a Alpha ELF linker hash table. */
219
220#define alpha_elf_link_hash_traverse(table, func, info) \
221 (elf_link_hash_traverse \
222 (&(table)->root, \
223 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
224 (info)))
225
226/* Get the Alpha ELF linker hash table from a link_info structure. */
227
228#define alpha_elf_hash_table(p) \
229 ((struct alpha_elf_link_hash_table *) ((p)->hash))
230
231/* Get the object's symbols as our own entry type. */
232
233#define alpha_elf_sym_hashes(abfd) \
234 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
235
236/* Should we do dynamic things to this symbol? */
237
8fb35fed
RH		 238static int
239alpha_elf_dynamic_symbol_p (h, info)
240 struct elf_link_hash_entry *h;
241 struct bfd_link_info *info;
242{
243 if (h == NULL)
244 return false;
245
246 while (h->root.type == bfd_link_hash_indirect
247 || h->root.type == bfd_link_hash_warning)
248 h = (struct elf_link_hash_entry *) h->root.u.i.link;
249
250 if (h->dynindx == -1)
251 return false;
ca88208a
RH		 252
253 if (h->root.type == bfd_link_hash_undefweak
254 || h->root.type == bfd_link_hash_defweak)
255 return true;
256
2719f880
L		 257 switch (ELF_ST_VISIBILITY (h->other))
258 {
ca88208a
RH		 259 case STV_DEFAULT:
260 break;
2719f880 261 case STV_HIDDEN:
ca88208a 262 case STV_INTERNAL:
2719f880 263 return false;
ca88208a
RH		 264 case STV_PROTECTED:
265 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
266 return false;
267 break;
2719f880 268 }
8fb35fed 269
8fb35fed
RH		 270 if ((info->shared && !info->symbolic)
271 || ((h->elf_link_hash_flags
272 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
273 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
274 return true;
275
276 return false;
277}
252b5132
RH		 278
279/* Create an entry in a Alpha ELF linker hash table. */
280
281static struct bfd_hash_entry *
282elf64_alpha_link_hash_newfunc (entry, table, string)
283 struct bfd_hash_entry *entry;
284 struct bfd_hash_table *table;
285 const char *string;
286{
287 struct alpha_elf_link_hash_entry *ret =
288 (struct alpha_elf_link_hash_entry *) entry;
289
290 /* Allocate the structure if it has not already been allocated by a
291 subclass. */
292 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
293 ret = ((struct alpha_elf_link_hash_entry *)
294 bfd_hash_allocate (table,
295 sizeof (struct alpha_elf_link_hash_entry)));
296 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
297 return (struct bfd_hash_entry *) ret;
298
299 /* Call the allocation method of the superclass. */
300 ret = ((struct alpha_elf_link_hash_entry *)
301 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
302 table, string));
303 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
304 {
305 /* Set local fields. */
306 memset (&ret->esym, 0, sizeof (EXTR));
307 /* We use -2 as a marker to indicate that the information has
308 not been set. -1 means there is no associated ifd. */
309 ret->esym.ifd = -2;
310 ret->flags = 0;
311 ret->got_entries = NULL;
312 ret->reloc_entries = NULL;
313 }
314
315 return (struct bfd_hash_entry *) ret;
316}
317
318/* Create a Alpha ELF linker hash table. */
319
320static struct bfd_link_hash_table *
321elf64_alpha_bfd_link_hash_table_create (abfd)
322 bfd *abfd;
323{
324 struct alpha_elf_link_hash_table *ret;
dc810e39 325 bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
252b5132 326
dc810e39 327 ret = (struct alpha_elf_link_hash_table *) bfd_zalloc (abfd, amt);
252b5132
RH		 328 if (ret == (struct alpha_elf_link_hash_table *) NULL)
329 return NULL;
330
331 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
332 elf64_alpha_link_hash_newfunc))
333 {
334 bfd_release (abfd, ret);
335 return NULL;
336 }
337
338 return &ret->root.root;
339}
340\f
341/* We have some private fields hanging off of the elf_tdata structure. */
342
343struct alpha_elf_obj_tdata
344{
345 struct elf_obj_tdata root;
346
347 /* For every input file, these are the got entries for that object's
348 local symbols. */
349 struct alpha_elf_got_entry ** local_got_entries;
350
351 /* For every input file, this is the object that owns the got that
352 this input file uses. */
353 bfd *gotobj;
354
355 /* For every got, this is a linked list through the objects using this got */
356 bfd *in_got_link_next;
357
358 /* For every got, this is a link to the next got subsegment. */
359 bfd *got_link_next;
360
361 /* For every got, this is the section. */
362 asection *got;
363
364 /* For every got, this is it's total number of *entries*. */
365 int total_got_entries;
366
367 /* For every got, this is the sum of the number of *entries* required
368 to hold all of the member object's local got. */
369 int n_local_got_entries;
370};
371
372#define alpha_elf_tdata(abfd) \
373 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
374
375static boolean
376elf64_alpha_mkobject (abfd)
377 bfd *abfd;
378{
dc810e39
AM		 379 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
380 abfd->tdata.any = bfd_zalloc (abfd, amt);
252b5132
RH		 381 if (abfd->tdata.any == NULL)
382 return false;
383 return true;
384}
385
386static boolean
387elf64_alpha_object_p (abfd)
388 bfd *abfd;
389{
390 /* Allocate our special target data. */
391 struct alpha_elf_obj_tdata *new_tdata;
dc810e39
AM		 392 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
393 new_tdata = bfd_zalloc (abfd, amt);
252b5132
RH		 394 if (new_tdata == NULL)
395 return false;
396 new_tdata->root = *abfd->tdata.elf_obj_data;
397 abfd->tdata.any = new_tdata;
398
399 /* Set the right machine number for an Alpha ELF file. */
400 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
401}
402\f
403/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
404 from smaller values. Start with zero, widen, *then* decrement. */
405#define MINUS_ONE (((bfd_vma)0) - 1)
406
dfe57ca0
RH		 407#define SKIP_HOWTO(N) \
408 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
409
252b5132
RH		 410static reloc_howto_type elf64_alpha_howto_table[] =
411{
412 HOWTO (R_ALPHA_NONE, /* type */
413 0, /* rightshift */
414 0, /* size (0 = byte, 1 = short, 2 = long) */
415 8, /* bitsize */
416 true, /* pc_relative */
417 0, /* bitpos */
418 complain_overflow_dont, /* complain_on_overflow */
419 elf64_alpha_reloc_nil, /* special_function */
420 "NONE", /* name */
421 false, /* partial_inplace */
422 0, /* src_mask */
423 0, /* dst_mask */
424 true), /* pcrel_offset */
425
426 /* A 32 bit reference to a symbol. */
427 HOWTO (R_ALPHA_REFLONG, /* type */
428 0, /* rightshift */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
430 32, /* bitsize */
431 false, /* pc_relative */
432 0, /* bitpos */
433 complain_overflow_bitfield, /* complain_on_overflow */
434 0, /* special_function */
435 "REFLONG", /* name */
436 false, /* partial_inplace */
437 0xffffffff, /* src_mask */
438 0xffffffff, /* dst_mask */
439 false), /* pcrel_offset */
440
441 /* A 64 bit reference to a symbol. */
442 HOWTO (R_ALPHA_REFQUAD, /* type */
443 0, /* rightshift */
444 4, /* size (0 = byte, 1 = short, 2 = long) */
445 64, /* bitsize */
446 false, /* pc_relative */
447 0, /* bitpos */
448 complain_overflow_bitfield, /* complain_on_overflow */
449 0, /* special_function */
450 "REFQUAD", /* name */
451 false, /* partial_inplace */
452 MINUS_ONE, /* src_mask */
453 MINUS_ONE, /* dst_mask */
454 false), /* pcrel_offset */
455
456 /* A 32 bit GP relative offset. This is just like REFLONG except
457 that when the value is used the value of the gp register will be
458 added in. */
459 HOWTO (R_ALPHA_GPREL32, /* type */
460 0, /* rightshift */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
462 32, /* bitsize */
463 false, /* pc_relative */
464 0, /* bitpos */
465 complain_overflow_bitfield, /* complain_on_overflow */
466 0, /* special_function */
467 "GPREL32", /* name */
468 false, /* partial_inplace */
469 0xffffffff, /* src_mask */
470 0xffffffff, /* dst_mask */
471 false), /* pcrel_offset */
472
473 /* Used for an instruction that refers to memory off the GP register. */
474 HOWTO (R_ALPHA_LITERAL, /* type */
475 0, /* rightshift */
dfe57ca0 476 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 477 16, /* bitsize */
478 false, /* pc_relative */
479 0, /* bitpos */
480 complain_overflow_signed, /* complain_on_overflow */
481 0, /* special_function */
482 "ELF_LITERAL", /* name */
483 false, /* partial_inplace */
484 0xffff, /* src_mask */
485 0xffff, /* dst_mask */
486 false), /* pcrel_offset */
487
488 /* This reloc only appears immediately following an ELF_LITERAL reloc.
489 It identifies a use of the literal. The symbol index is special:
490 1 means the literal address is in the base register of a memory
491 format instruction; 2 means the literal address is in the byte
492 offset register of a byte-manipulation instruction; 3 means the
493 literal address is in the target register of a jsr instruction.
494 This does not actually do any relocation. */
495 HOWTO (R_ALPHA_LITUSE, /* type */
496 0, /* rightshift */
dfe57ca0 497 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 498 32, /* bitsize */
499 false, /* pc_relative */
500 0, /* bitpos */
501 complain_overflow_dont, /* complain_on_overflow */
502 elf64_alpha_reloc_nil, /* special_function */
503 "LITUSE", /* name */
504 false, /* partial_inplace */
505 0, /* src_mask */
506 0, /* dst_mask */
507 false), /* pcrel_offset */
508
509 /* Load the gp register. This is always used for a ldah instruction
510 which loads the upper 16 bits of the gp register. The symbol
511 index of the GPDISP instruction is an offset in bytes to the lda
512 instruction that loads the lower 16 bits. The value to use for
513 the relocation is the difference between the GP value and the
514 current location; the load will always be done against a register
515 holding the current address.
516
517 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
518 any offset is present in the instructions, it is an offset from
519 the register to the ldah instruction. This lets us avoid any
520 stupid hackery like inventing a gp value to do partial relocation
521 against. Also unlike ECOFF, we do the whole relocation off of
522 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
523 space consuming bit, that, since all the information was present
524 in the GPDISP_HI16 reloc. */
525 HOWTO (R_ALPHA_GPDISP, /* type */
526 16, /* rightshift */
527 2, /* size (0 = byte, 1 = short, 2 = long) */
528 16, /* bitsize */
529 false, /* pc_relative */
530 0, /* bitpos */
531 complain_overflow_dont, /* complain_on_overflow */
532 elf64_alpha_reloc_gpdisp, /* special_function */
533 "GPDISP", /* name */
534 false, /* partial_inplace */
535 0xffff, /* src_mask */
536 0xffff, /* dst_mask */
537 true), /* pcrel_offset */
538
539 /* A 21 bit branch. */
540 HOWTO (R_ALPHA_BRADDR, /* type */
541 2, /* rightshift */
542 2, /* size (0 = byte, 1 = short, 2 = long) */
543 21, /* bitsize */
544 true, /* pc_relative */
545 0, /* bitpos */
546 complain_overflow_signed, /* complain_on_overflow */
547 0, /* special_function */
548 "BRADDR", /* name */
549 false, /* partial_inplace */
550 0x1fffff, /* src_mask */
551 0x1fffff, /* dst_mask */
552 true), /* pcrel_offset */
553
554 /* A hint for a jump to a register. */
555 HOWTO (R_ALPHA_HINT, /* type */
556 2, /* rightshift */
dfe57ca0 557 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 558 14, /* bitsize */
559 true, /* pc_relative */
560 0, /* bitpos */
561 complain_overflow_dont, /* complain_on_overflow */
562 0, /* special_function */
563 "HINT", /* name */
564 false, /* partial_inplace */
565 0x3fff, /* src_mask */
566 0x3fff, /* dst_mask */
567 true), /* pcrel_offset */
568
569 /* 16 bit PC relative offset. */
570 HOWTO (R_ALPHA_SREL16, /* type */
571 0, /* rightshift */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
573 16, /* bitsize */
574 true, /* pc_relative */
575 0, /* bitpos */
576 complain_overflow_signed, /* complain_on_overflow */
577 0, /* special_function */
578 "SREL16", /* name */
579 false, /* partial_inplace */
580 0xffff, /* src_mask */
581 0xffff, /* dst_mask */
16b65e4e 582 true), /* pcrel_offset */
252b5132
RH		 583
584 /* 32 bit PC relative offset. */
585 HOWTO (R_ALPHA_SREL32, /* type */
586 0, /* rightshift */
587 2, /* size (0 = byte, 1 = short, 2 = long) */
588 32, /* bitsize */
589 true, /* pc_relative */
590 0, /* bitpos */
591 complain_overflow_signed, /* complain_on_overflow */
592 0, /* special_function */
593 "SREL32", /* name */
594 false, /* partial_inplace */
595 0xffffffff, /* src_mask */
596 0xffffffff, /* dst_mask */
16b65e4e 597 true), /* pcrel_offset */
252b5132
RH		 598
599 /* A 64 bit PC relative offset. */
600 HOWTO (R_ALPHA_SREL64, /* type */
601 0, /* rightshift */
602 4, /* size (0 = byte, 1 = short, 2 = long) */
603 64, /* bitsize */
604 true, /* pc_relative */
605 0, /* bitpos */
606 complain_overflow_signed, /* complain_on_overflow */
607 0, /* special_function */
608 "SREL64", /* name */
609 false, /* partial_inplace */
610 MINUS_ONE, /* src_mask */
611 MINUS_ONE, /* dst_mask */
16b65e4e 612 true), /* pcrel_offset */
252b5132 613
dfe57ca0
RH		 614 /* Skip 12 - 16; deprecated ECOFF relocs. */
615 SKIP_HOWTO (12),
616 SKIP_HOWTO (13),
617 SKIP_HOWTO (14),
618 SKIP_HOWTO (15),
619 SKIP_HOWTO (16),
252b5132
RH		 620
621 /* The high 16 bits of the displacement from GP to the target. */
622 HOWTO (R_ALPHA_GPRELHIGH,
623 0, /* rightshift */
dfe57ca0 624 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 625 16, /* bitsize */
626 false, /* pc_relative */
627 0, /* bitpos */
628 complain_overflow_signed, /* complain_on_overflow */
dfe57ca0 629 0, /* special_function */
252b5132
RH		 630 "GPRELHIGH", /* name */
631 false, /* partial_inplace */
632 0xffff, /* src_mask */
633 0xffff, /* dst_mask */
634 false), /* pcrel_offset */
635
636 /* The low 16 bits of the displacement from GP to the target. */
637 HOWTO (R_ALPHA_GPRELLOW,
638 0, /* rightshift */
dfe57ca0 639 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 640 16, /* bitsize */
641 false, /* pc_relative */
642 0, /* bitpos */
643 complain_overflow_dont, /* complain_on_overflow */
dfe57ca0 644 0, /* special_function */
252b5132
RH		 645 "GPRELLOW", /* name */
646 false, /* partial_inplace */
647 0xffff, /* src_mask */
648 0xffff, /* dst_mask */
649 false), /* pcrel_offset */
650
651 /* A 16-bit displacement from the GP to the target. */
dfe57ca0 652 HOWTO (R_ALPHA_GPREL16,
252b5132 653 0, /* rightshift */
dfe57ca0 654 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 655 16, /* bitsize */
656 false, /* pc_relative */
657 0, /* bitpos */
658 complain_overflow_signed, /* complain_on_overflow */
659 0, /* special_function */
dfe57ca0 660 "GPREL16", /* name */
252b5132
RH		 661 false, /* partial_inplace */
662 0xffff, /* src_mask */
663 0xffff, /* dst_mask */
664 false), /* pcrel_offset */
665
dfe57ca0
RH		 666 /* Skip 20 - 23; deprecated ECOFF relocs. */
667 SKIP_HOWTO (20),
668 SKIP_HOWTO (21),
669 SKIP_HOWTO (22),
670 SKIP_HOWTO (23),
252b5132 671
fe8bc63d 672 /* Misc ELF relocations. */
252b5132
RH		 673
674 /* A dynamic relocation to copy the target into our .dynbss section. */
675 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
676 is present because every other ELF has one, but should not be used
677 because .dynbss is an ugly thing. */
678 HOWTO (R_ALPHA_COPY,
679 0,
680 0,
681 0,
682 false,
683 0,
684 complain_overflow_dont,
685 bfd_elf_generic_reloc,
686 "COPY",
687 false,
688 0,
689 0,
690 true),
691
692 /* A dynamic relocation for a .got entry. */
693 HOWTO (R_ALPHA_GLOB_DAT,
694 0,
695 0,
696 0,
697 false,
698 0,
699 complain_overflow_dont,
700 bfd_elf_generic_reloc,
701 "GLOB_DAT",
702 false,
703 0,
704 0,
705 true),
706
707 /* A dynamic relocation for a .plt entry. */
708 HOWTO (R_ALPHA_JMP_SLOT,
709 0,
710 0,
711 0,
712 false,
713 0,
714 complain_overflow_dont,
715 bfd_elf_generic_reloc,
716 "JMP_SLOT",
717 false,
718 0,
719 0,
720 true),
721
722 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
723 HOWTO (R_ALPHA_RELATIVE,
724 0,
725 0,
726 0,
727 false,
728 0,
729 complain_overflow_dont,
730 bfd_elf_generic_reloc,
731 "RELATIVE",
732 false,
733 0,
734 0,
735 true)
736};
737
738/* A relocation function which doesn't do anything. */
739
740static bfd_reloc_status_type
741elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
56fc028e 742 bfd *abfd ATTRIBUTE_UNUSED;
252b5132 743 arelent *reloc;
56fc028e
AJ		 744 asymbol *sym ATTRIBUTE_UNUSED;
745 PTR data ATTRIBUTE_UNUSED;
252b5132
RH		 746 asection *sec;
747 bfd *output_bfd;
56fc028e 748 char **error_message ATTRIBUTE_UNUSED;
252b5132
RH		 749{
750 if (output_bfd)
751 reloc->address += sec->output_offset;
752 return bfd_reloc_ok;
753}
754
755/* A relocation function used for an unsupported reloc. */
756
757static bfd_reloc_status_type
758elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
56fc028e 759 bfd *abfd ATTRIBUTE_UNUSED;
252b5132 760 arelent *reloc;
56fc028e
AJ		 761 asymbol *sym ATTRIBUTE_UNUSED;
762 PTR data ATTRIBUTE_UNUSED;
252b5132
RH		 763 asection *sec;
764 bfd *output_bfd;
56fc028e 765 char **error_message ATTRIBUTE_UNUSED;
252b5132
RH		 766{
767 if (output_bfd)
768 reloc->address += sec->output_offset;
769 return bfd_reloc_notsupported;
770}
771
772/* Do the work of the GPDISP relocation. */
773
774static bfd_reloc_status_type
775elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
776 bfd *abfd;
777 bfd_vma gpdisp;
778 bfd_byte *p_ldah;
779 bfd_byte *p_lda;
780{
781 bfd_reloc_status_type ret = bfd_reloc_ok;
782 bfd_vma addend;
783 unsigned long i_ldah, i_lda;
784
785 i_ldah = bfd_get_32 (abfd, p_ldah);
786 i_lda = bfd_get_32 (abfd, p_lda);
787
788 /* Complain if the instructions are not correct. */
789 if (((i_ldah >> 26) & 0x3f) != 0x09
790 || ((i_lda >> 26) & 0x3f) != 0x08)
791 ret = bfd_reloc_dangerous;
792
793 /* Extract the user-supplied offset, mirroring the sign extensions
794 that the instructions perform. */
795 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
796 addend = (addend ^ 0x80008000) - 0x80008000;
797
798 gpdisp += addend;
799
800 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
801 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
802 ret = bfd_reloc_overflow;
803
804 /* compensate for the sign extension again. */
805 i_ldah = ((i_ldah & 0xffff0000)
806 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
807 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
808
dc810e39
AM		 809 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
810 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
252b5132
RH		 811
812 return ret;
813}
814
815/* The special function for the GPDISP reloc. */
816
817static bfd_reloc_status_type
818elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
819 output_bfd, err_msg)
820 bfd *abfd;
821 arelent *reloc_entry;
56fc028e 822 asymbol *sym ATTRIBUTE_UNUSED;
252b5132
RH		 823 PTR data;
824 asection *input_section;
825 bfd *output_bfd;
826 char **err_msg;
827{
828 bfd_reloc_status_type ret;
829 bfd_vma gp, relocation;
830 bfd_byte *p_ldah, *p_lda;
831
832 /* Don't do anything if we're not doing a final link. */
833 if (output_bfd)
834 {
835 reloc_entry->address += input_section->output_offset;
836 return bfd_reloc_ok;
837 }
838
839 if (reloc_entry->address > input_section->_cooked_size ||
840 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
841 return bfd_reloc_outofrange;
842
843 /* The gp used in the portion of the output object to which this
844 input object belongs is cached on the input bfd. */
845 gp = _bfd_get_gp_value (abfd);
846
847 relocation = (input_section->output_section->vma
848 + input_section->output_offset
849 + reloc_entry->address);
850
851 p_ldah = (bfd_byte *) data + reloc_entry->address;
852 p_lda = p_ldah + reloc_entry->addend;
853
854 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
855
856 /* Complain if the instructions are not correct. */
857 if (ret == bfd_reloc_dangerous)
858 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
859
860 return ret;
861}
862
863/* A mapping from BFD reloc types to Alpha ELF reloc types. */
864
865struct elf_reloc_map
866{
867 bfd_reloc_code_real_type bfd_reloc_val;
868 int elf_reloc_val;
869};
870
871static const struct elf_reloc_map elf64_alpha_reloc_map[] =
872{
dfe57ca0
RH		 873 {BFD_RELOC_NONE, R_ALPHA_NONE},
874 {BFD_RELOC_32, R_ALPHA_REFLONG},
875 {BFD_RELOC_64, R_ALPHA_REFQUAD},
876 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
877 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
878 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
879 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
880 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
881 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
882 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
883 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
884 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
885 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
886 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
887 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
888 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
252b5132
RH		 889};
890
891/* Given a BFD reloc type, return a HOWTO structure. */
892
893static reloc_howto_type *
894elf64_alpha_bfd_reloc_type_lookup (abfd, code)
56fc028e 895 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 896 bfd_reloc_code_real_type code;
897{
898 const struct elf_reloc_map *i, *e;
899 i = e = elf64_alpha_reloc_map;
900 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
901 for (; i != e; ++i)
902 {
903 if (i->bfd_reloc_val == code)
904 return &elf64_alpha_howto_table[i->elf_reloc_val];
905 }
906 return 0;
907}
908
909/* Given an Alpha ELF reloc type, fill in an arelent structure. */
910
911static void
912elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
56fc028e 913 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 914 arelent *cache_ptr;
915 Elf64_Internal_Rela *dst;
916{
917 unsigned r_type;
918
919 r_type = ELF64_R_TYPE(dst->r_info);
920 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
921 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
922}
923\f
fe8bc63d 924/* These functions do relaxation for Alpha ELF.
252b5132
RH		 925
926 Currently I'm only handling what I can do with existing compiler
927 and assembler support, which means no instructions are removed,
928 though some may be nopped. At this time GCC does not emit enough
929 information to do all of the relaxing that is possible. It will
930 take some not small amount of work for that to happen.
931
932 There are a couple of interesting papers that I once read on this
933 subject, that I cannot find references to at the moment, that
934 related to Alpha in particular. They are by David Wall, then of
935 DEC WRL. */
936
937#define OP_LDA 0x08
938#define OP_LDAH 0x09
939#define INSN_JSR 0x68004000
940#define INSN_JSR_MASK 0xfc00c000
941#define OP_LDQ 0x29
942#define OP_BR 0x30
943#define OP_BSR 0x34
944#define INSN_UNOP 0x2fe00000
945
946struct alpha_relax_info
947{
948 bfd *abfd;
949 asection *sec;
950 bfd_byte *contents;
951 Elf_Internal_Rela *relocs, *relend;
952 struct bfd_link_info *link_info;
953 boolean changed_contents;
954 boolean changed_relocs;
955 bfd_vma gp;
956 bfd *gotobj;
957 asection *tsec;
958 struct alpha_elf_link_hash_entry *h;
959 struct alpha_elf_got_entry *gotent;
960 unsigned char other;
961};
962
963static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
fe8bc63d 964 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
252b5132
RH		 965 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
966
967static boolean elf64_alpha_relax_without_lituse
fe8bc63d 968 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
252b5132
RH		 969 Elf_Internal_Rela *irel));
970
971static bfd_vma elf64_alpha_relax_opt_call
972 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
973
974static boolean elf64_alpha_relax_section
975 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
976 boolean *again));
977
978static Elf_Internal_Rela *
979elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
980 Elf_Internal_Rela *rel, *relend;
981 bfd_vma offset;
982 int type;
983{
984 while (rel < relend)
985 {
52b9d213
AM		 986 if (rel->r_offset == offset
987 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
252b5132
RH		 988 return rel;
989 ++rel;
990 }
991 return NULL;
992}
993
994static Elf_Internal_Rela *
995elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
996 struct alpha_relax_info *info;
997 bfd_vma symval;
998 Elf_Internal_Rela *irel, *irelend;
999{
1000 Elf_Internal_Rela *urel;
1001 int flags, count, i;
1002 bfd_signed_vma disp;
1003 boolean fits16;
1004 boolean fits32;
1005 boolean lit_reused = false;
1006 boolean all_optimized = true;
1007 unsigned int lit_insn;
1008
1009 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1010 if (lit_insn >> 26 != OP_LDQ)
1011 {
1012 ((*_bfd_error_handler)
1013 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
8f615d07
AM		 1014 bfd_archive_filename (info->abfd), info->sec->name,
1015 (unsigned long) irel->r_offset));
252b5132
RH		 1016 return irel;
1017 }
1018
1019 /* Summarize how this particular LITERAL is used. */
1020 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1021 {
1022 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1023 break;
1e738b87 1024 if (urel->r_addend <= 3)
252b5132
RH		 1025 flags |= 1 << urel->r_addend;
1026 }
1027
fe8bc63d 1028 /* A little preparation for the loop... */
252b5132 1029 disp = symval - info->gp;
252b5132
RH		 1030
1031 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1032 {
1033 unsigned int insn;
ffcb7aff
NC		 1034 int insn_disp;
1035 bfd_signed_vma xdisp;
1036
252b5132
RH		 1037 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1038
1039 switch (urel->r_addend)
1040 {
1041 default: /* 0 = ADDRESS FORMAT */
1042 /* This type is really just a placeholder to note that all
1043 uses cannot be optimized, but to still allow some. */
1044 all_optimized = false;
1045 break;
1046
1047 case 1: /* MEM FORMAT */
1048 /* We can always optimize 16-bit displacements. */
ffcb7aff
NC		 1049
1050 /* Extract the displacement from the instruction, sign-extending
1051 it if necessary, then test whether it is within 16 or 32 bits
1052 displacement from GP. */
1053 insn_disp = insn & 0x0000ffff;
1054 if (insn_disp & 0x00008000)
1055 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1056
1057 xdisp = disp + insn_disp;
1058 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1059 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1060
252b5132
RH		 1061 if (fits16)
1062 {
ffcb7aff 1063 /* Take the op code and dest from this insn, take the base
fe8bc63d 1064 register from the literal insn. Leave the offset alone. */
ffcb7aff 1065 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
252b5132 1066 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
dfe57ca0 1067 R_ALPHA_GPREL16);
252b5132
RH		 1068 urel->r_addend = irel->r_addend;
1069 info->changed_relocs = true;
1070
dc810e39
AM		 1071 bfd_put_32 (info->abfd, (bfd_vma) insn,
1072 info->contents + urel->r_offset);
252b5132
RH		 1073 info->changed_contents = true;
1074 }
1075
1076 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1077 else if (fits32 && !(flags & ~6))
1078 {
ffcb7aff 1079 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
252b5132
RH		 1080
1081 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1082 R_ALPHA_GPRELHIGH);
1083 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
dc810e39 1084 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
252b5132
RH		 1085 info->contents + irel->r_offset);
1086 lit_reused = true;
1087 info->changed_contents = true;
1088
1089 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1090 R_ALPHA_GPRELLOW);
1091 urel->r_addend = irel->r_addend;
1092 info->changed_relocs = true;
1093 }
1094 else
1095 all_optimized = false;
1096 break;
1097
1098 case 2: /* BYTE OFFSET FORMAT */
1099 /* We can always optimize byte instructions. */
1100
1101 /* FIXME: sanity check the insn for byte op. Check that the
1102 literal dest reg is indeed Rb in the byte insn. */
1103
dc810e39
AM		 1104 insn &= ~ (unsigned) 0x001ff000;
1105 insn |= ((symval & 7) << 13) | 0x1000;
252b5132
RH		 1106
1107 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1108 urel->r_addend = 0;
1109 info->changed_relocs = true;
1110
dc810e39
AM		 1111 bfd_put_32 (info->abfd, (bfd_vma) insn,
1112 info->contents + urel->r_offset);
252b5132
RH		 1113 info->changed_contents = true;
1114 break;
1115
1116 case 3: /* CALL FORMAT */
1117 {
1118 /* If not zero, place to jump without needing pv. */
1119 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1120 bfd_vma org = (info->sec->output_section->vma
1121 + info->sec->output_offset
1122 + urel->r_offset + 4);
1123 bfd_signed_vma odisp;
1124
1125 odisp = (optdest ? optdest : symval) - org;
1126 if (odisp >= -0x400000 && odisp < 0x400000)
1127 {
1128 Elf_Internal_Rela *xrel;
1129
fe8bc63d 1130 /* Preserve branch prediction call stack when possible. */
252b5132
RH		 1131 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1132 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1133 else
1134 insn = (OP_BR << 26) | (insn & 0x03e00000);
fe8bc63d 1135
252b5132
RH		 1136 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1137 R_ALPHA_BRADDR);
1138 urel->r_addend = irel->r_addend;
1139
1140 if (optdest)
1141 urel->r_addend += optdest - symval;
1142 else
1143 all_optimized = false;
1144
dc810e39
AM		 1145 bfd_put_32 (info->abfd, (bfd_vma) insn,
1146 info->contents + urel->r_offset);
252b5132
RH		 1147
1148 /* Kill any HINT reloc that might exist for this insn. */
1149 xrel = (elf64_alpha_find_reloc_at_ofs
fe8bc63d 1150 (info->relocs, info->relend, urel->r_offset,
252b5132
RH		 1151 R_ALPHA_HINT));
1152 if (xrel)
1153 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1154
1155 info->changed_contents = true;
1156 info->changed_relocs = true;
1157 }
1158 else
1159 all_optimized = false;
1160
1cd6895c
RH		 1161 /* Even if the target is not in range for a direct branch,
1162 if we share a GP, we can eliminate the gp reload. */
1163 if (optdest)
1164 {
1165 Elf_Internal_Rela *gpdisp
1166 = (elf64_alpha_find_reloc_at_ofs
1167 (irel, irelend, urel->r_offset + 4, R_ALPHA_GPDISP));
1168 if (gpdisp)
1169 {
1170 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
1171 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1172 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1173 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1174
1175 /* Verify that the instruction is "ldah $29,0($26)".
1176 Consider a function that ends in a noreturn call,
1177 and that the next function begins with an ldgp,
1178 and that by accident there is no padding between.
1179 In that case the insn would use $27 as the base. */
1180 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1181 {
dc810e39
AM		 1182 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
1183 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
1cd6895c
RH		 1184
1185 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1186 info->changed_contents = true;
1187 info->changed_relocs = true;
1188 }
1189 }
1190 }
252b5132
RH		 1191 }
1192 break;
1193 }
1194 }
1195
1196 /* If all cases were optimized, we can reduce the use count on this
1197 got entry by one, possibly eliminating it. */
1198 if (all_optimized)
1199 {
1200 info->gotent->use_count -= 1;
1201 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1202 if (!info->h)
1203 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1204
1205 /* If the literal instruction is no longer needed (it may have been
1206 reused. We can eliminate it.
1207 ??? For now, I don't want to deal with compacting the section,
1208 so just nop it out. */
1209 if (!lit_reused)
1210 {
1211 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1212 info->changed_relocs = true;
1213
dc810e39
AM		 1214 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
1215 info->contents + irel->r_offset);
252b5132
RH		 1216 info->changed_contents = true;
1217 }
1218 }
1219
1220 return irel + count;
1221}
1222
1223static bfd_vma
1224elf64_alpha_relax_opt_call (info, symval)
1225 struct alpha_relax_info *info;
1226 bfd_vma symval;
1227{
1228 /* If the function has the same gp, and we can identify that the
1229 function does not use its function pointer, we can eliminate the
1230 address load. */
1231
1232 /* If the symbol is marked NOPV, we are being told the function never
1233 needs its procedure value. */
c810873d 1234 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
252b5132
RH		 1235 return symval;
1236
1237 /* If the symbol is marked STD_GP, we are being told the function does
fe8bc63d 1238 a normal ldgp in the first two words. */
c810873d 1239 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
252b5132
RH		 1240 ;
1241
1242 /* Otherwise, we may be able to identify a GP load in the first two
1243 words, which we can then skip. */
fe8bc63d 1244 else
252b5132
RH		 1245 {
1246 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1247 bfd_vma ofs;
1248
fe8bc63d 1249 /* Load the relocations from the section that the target symbol is in. */
252b5132
RH		 1250 if (info->sec == info->tsec)
1251 {
1252 tsec_relocs = info->relocs;
1253 tsec_relend = info->relend;
1254 tsec_free = NULL;
1255 }
1256 else
1257 {
1258 tsec_relocs = (_bfd_elf64_link_read_relocs
1259 (info->abfd, info->tsec, (PTR) NULL,
1260 (Elf_Internal_Rela *) NULL,
1261 info->link_info->keep_memory));
1262 if (tsec_relocs == NULL)
1263 return 0;
1264 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1265 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1266 }
1267
1268 /* Recover the symbol's offset within the section. */
1269 ofs = (symval - info->tsec->output_section->vma
1270 - info->tsec->output_offset);
fe8bc63d 1271
252b5132
RH		 1272 /* Look for a GPDISP reloc. */
1273 gpdisp = (elf64_alpha_find_reloc_at_ofs
1274 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1275
1276 if (!gpdisp || gpdisp->r_addend != 4)
1277 {
1278 if (tsec_free)
1279 free (tsec_free);
1280 return 0;
1281 }
1282 if (tsec_free)
1283 free (tsec_free);
1284 }
1285
fe8bc63d 1286 /* We've now determined that we can skip an initial gp load. Verify
252b5132
RH		 1287 that the call and the target use the same gp. */
1288 if (info->link_info->hash->creator != info->tsec->owner->xvec
1289 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1290 return 0;
1291
1292 return symval + 8;
1293}
1294
1295static boolean
1296elf64_alpha_relax_without_lituse (info, symval, irel)
1297 struct alpha_relax_info *info;
1298 bfd_vma symval;
1299 Elf_Internal_Rela *irel;
1300{
1301 unsigned int insn;
1302 bfd_signed_vma disp;
1303
1304 /* Get the instruction. */
1305 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1306
1307 if (insn >> 26 != OP_LDQ)
1308 {
1309 ((*_bfd_error_handler)
1310 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
8f615d07 1311 bfd_archive_filename (info->abfd), info->sec->name,
252b5132
RH		 1312 (unsigned long) irel->r_offset));
1313 return true;
1314 }
1315
1316 /* So we aren't told much. Do what we can with the address load and
1317 fake the rest. All of the optimizations here require that the
1318 offset from the GP fit in 16 bits. */
1319
1320 disp = symval - info->gp;
1321 if (disp < -0x8000 || disp >= 0x8000)
1322 return true;
1323
1324 /* On the LITERAL instruction itself, consider exchanging
1325 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1326
1327 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
dc810e39 1328 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
252b5132
RH		 1329 info->changed_contents = true;
1330
dfe57ca0 1331 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPREL16);
252b5132
RH		 1332 info->changed_relocs = true;
1333
1334 /* Reduce the use count on this got entry by one, possibly
1335 eliminating it. */
1336 info->gotent->use_count -= 1;
1337 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1338 if (!info->h)
1339 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1340
1341 /* ??? Search forward through this basic block looking for insns
1342 that use the target register. Stop after an insn modifying the
1343 register is seen, or after a branch or call.
1344
1345 Any such memory load insn may be substituted by a load directly
1346 off the GP. This allows the memory load insn to be issued before
fe8bc63d 1347 the calculated GP register would otherwise be ready.
252b5132
RH		 1348
1349 Any such jsr insn can be replaced by a bsr if it is in range.
1350
1351 This would mean that we'd have to _add_ relocations, the pain of
1352 which gives one pause. */
1353
1354 return true;
1355}
1356
1357static boolean
1358elf64_alpha_relax_section (abfd, sec, link_info, again)
1359 bfd *abfd;
1360 asection *sec;
1361 struct bfd_link_info *link_info;
1362 boolean *again;
1363{
1364 Elf_Internal_Shdr *symtab_hdr;
1365 Elf_Internal_Rela *internal_relocs;
1366 Elf_Internal_Rela *free_relocs = NULL;
1367 Elf_Internal_Rela *irel, *irelend;
1368 bfd_byte *free_contents = NULL;
1369 Elf64_External_Sym *extsyms = NULL;
1370 Elf64_External_Sym *free_extsyms = NULL;
1371 struct alpha_elf_got_entry **local_got_entries;
1372 struct alpha_relax_info info;
1373
1374 /* We are not currently changing any sizes, so only one pass. */
1375 *again = false;
1376
1377 if (link_info->relocateable
1378 || (sec->flags & SEC_RELOC) == 0
1379 || sec->reloc_count == 0)
1380 return true;
1381
1382 /* If this is the first time we have been called for this section,
1383 initialize the cooked size. */
1384 if (sec->_cooked_size == 0)
1385 sec->_cooked_size = sec->_raw_size;
1386
1387 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1388 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1389
1390 /* Load the relocations for this section. */
1391 internal_relocs = (_bfd_elf64_link_read_relocs
1392 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1393 link_info->keep_memory));
1394 if (internal_relocs == NULL)
1395 goto error_return;
1396 if (! link_info->keep_memory)
1397 free_relocs = internal_relocs;
1398
fe8bc63d 1399 memset(&info, 0, sizeof (info));
252b5132
RH		 1400 info.abfd = abfd;
1401 info.sec = sec;
1402 info.link_info = link_info;
1403 info.relocs = internal_relocs;
1404 info.relend = irelend = internal_relocs + sec->reloc_count;
1405
1406 /* Find the GP for this object. */
1407 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1408 if (info.gotobj)
1409 {
1410 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1411 info.gp = _bfd_get_gp_value (info.gotobj);
1412 if (info.gp == 0)
1413 {
1414 info.gp = (sgot->output_section->vma
1415 + sgot->output_offset
1416 + 0x8000);
1417 _bfd_set_gp_value (info.gotobj, info.gp);
1418 }
1419 }
1420
1421 for (irel = internal_relocs; irel < irelend; irel++)
1422 {
1423 bfd_vma symval;
1424 Elf_Internal_Sym isym;
1425 struct alpha_elf_got_entry *gotent;
1426
1427 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1428 continue;
1429
1430 /* Get the section contents. */
1431 if (info.contents == NULL)
1432 {
1433 if (elf_section_data (sec)->this_hdr.contents != NULL)
1434 info.contents = elf_section_data (sec)->this_hdr.contents;
1435 else
1436 {
1437 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1438 if (info.contents == NULL)
1439 goto error_return;
1440 free_contents = info.contents;
1441
1442 if (! bfd_get_section_contents (abfd, sec, info.contents,
1443 (file_ptr) 0, sec->_raw_size))
1444 goto error_return;
1445 }
1446 }
1447
1448 /* Read this BFD's symbols if we haven't done so already. */
1449 if (extsyms == NULL)
1450 {
1451 if (symtab_hdr->contents != NULL)
1452 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1453 else
1454 {
dc810e39 1455 extsyms = (Elf64_External_Sym *) bfd_malloc (symtab_hdr->sh_size);
252b5132
RH		 1456 if (extsyms == NULL)
1457 goto error_return;
1458 free_extsyms = extsyms;
1459 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
dc810e39 1460 || (bfd_bread (extsyms, symtab_hdr->sh_size, abfd)
252b5132
RH		 1461 != symtab_hdr->sh_size))
1462 goto error_return;
1463 }
1464 }
1465
1466 /* Get the value of the symbol referred to by the reloc. */
1467 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1468 {
1469 /* A local symbol. */
1470 bfd_elf64_swap_symbol_in (abfd,
1471 extsyms + ELF64_R_SYM (irel->r_info),
1472 &isym);
1473 if (isym.st_shndx == SHN_UNDEF)
1474 info.tsec = bfd_und_section_ptr;
1475 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1476 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1477 else if (isym.st_shndx == SHN_ABS)
1478 info.tsec = bfd_abs_section_ptr;
1479 else if (isym.st_shndx == SHN_COMMON)
1480 info.tsec = bfd_com_section_ptr;
fe8bc63d
KH		 1481 else
1482 continue; /* who knows. */
252b5132
RH		 1483
1484 info.h = NULL;
1485 info.other = isym.st_other;
1486 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1487 symval = isym.st_value;
1488 }
1489 else
1490 {
1491 unsigned long indx;
1492 struct alpha_elf_link_hash_entry *h;
1493
1494 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1495 h = alpha_elf_sym_hashes (abfd)[indx];
1496 BFD_ASSERT (h != NULL);
1497
1498 while (h->root.root.type == bfd_link_hash_indirect
1499 || h->root.root.type == bfd_link_hash_warning)
1500 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1501
1502 /* We can't do anthing with undefined or dynamic symbols. */
1503 if (h->root.root.type == bfd_link_hash_undefined
1504 || h->root.root.type == bfd_link_hash_undefweak
1505 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1506 continue;
1507
1508 info.h = h;
252b5132
RH		 1509 info.tsec = h->root.root.u.def.section;
1510 info.other = h->root.other;
1511 gotent = h->got_entries;
1512 symval = h->root.root.u.def.value;
1513 }
1514
1515 /* Search for the got entry to be used by this relocation. */
1516 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1517 gotent = gotent->next;
1518 info.gotent = gotent;
1519
1520 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1521 symval += irel->r_addend;
1522
1523 BFD_ASSERT(info.gotent != NULL);
1524
1525 /* If there exist LITUSE relocations immediately following, this
1526 opens up all sorts of interesting optimizations, because we
1527 now know every location that this address load is used. */
1528
1529 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1530 {
1531 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1532 if (irel == NULL)
1533 goto error_return;
1534 }
1535 else
1536 {
1537 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1538 goto error_return;
1539 }
1540 }
1541
1542 if (!elf64_alpha_size_got_sections (abfd, link_info))
1543 return false;
1544
1545 if (info.changed_relocs)
1546 {
1547 elf_section_data (sec)->relocs = internal_relocs;
1548 }
1549 else if (free_relocs != NULL)
1550 {
1551 free (free_relocs);
1552 }
1553
1554 if (info.changed_contents)
1555 {
1556 elf_section_data (sec)->this_hdr.contents = info.contents;
1557 }
1558 else if (free_contents != NULL)
1559 {
1560 if (! link_info->keep_memory)
1561 free (free_contents);
1562 else
1563 {
1564 /* Cache the section contents for elf_link_input_bfd. */
1565 elf_section_data (sec)->this_hdr.contents = info.contents;
1566 }
1567 }
1568
1569 if (free_extsyms != NULL)
1570 {
1571 if (! link_info->keep_memory)
1572 free (free_extsyms);
1573 else
1574 {
1575 /* Cache the symbols for elf_link_input_bfd. */
973ffd63 1576 symtab_hdr->contents = (unsigned char *) extsyms;
252b5132
RH		 1577 }
1578 }
1579
1580 *again = info.changed_contents || info.changed_relocs;
1581
1582 return true;
1583
1584 error_return:
1585 if (free_relocs != NULL)
1586 free (free_relocs);
1587 if (free_contents != NULL)
1588 free (free_contents);
1589 if (free_extsyms != NULL)
1590 free (free_extsyms);
1591 return false;
1592}
1593\f
1594/* PLT/GOT Stuff */
1595#define PLT_HEADER_SIZE 32
dc810e39
AM		 1596#define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
1597#define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
1598#define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
1599#define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
252b5132
RH		 1600
1601#define PLT_ENTRY_SIZE 12
1602#define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1603#define PLT_ENTRY_WORD2 0
1604#define PLT_ENTRY_WORD3 0
1605
1606#define MAX_GOT_ENTRIES (64*1024 / 8)
1607
1608#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1609\f
1610/* Handle an Alpha specific section when reading an object file. This
1611 is called when elfcode.h finds a section with an unknown type.
1612 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1613 how to. */
1614
1615static boolean
1616elf64_alpha_section_from_shdr (abfd, hdr, name)
1617 bfd *abfd;
1618 Elf64_Internal_Shdr *hdr;
1619 char *name;
1620{
1621 asection *newsect;
1622
1623 /* There ought to be a place to keep ELF backend specific flags, but
1624 at the moment there isn't one. We just keep track of the
1625 sections by their name, instead. Fortunately, the ABI gives
1626 suggested names for all the MIPS specific sections, so we will
1627 probably get away with this. */
1628 switch (hdr->sh_type)
1629 {
1630 case SHT_ALPHA_DEBUG:
1631 if (strcmp (name, ".mdebug") != 0)
1632 return false;
1633 break;
252b5132
RH		 1634 default:
1635 return false;
1636 }
1637
1638 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1639 return false;
1640 newsect = hdr->bfd_section;
1641
1642 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1643 {
1644 if (! bfd_set_section_flags (abfd, newsect,
1645 (bfd_get_section_flags (abfd, newsect)
1646 | SEC_DEBUGGING)))
1647 return false;
1648 }
1649
252b5132
RH		 1650 return true;
1651}
1652
204692d7
RH		 1653/* Convert Alpha specific section flags to bfd internal section flags. */
1654
1655static boolean
1656elf64_alpha_section_flags (flags, hdr)
1657 flagword *flags;
1658 Elf64_Internal_Shdr *hdr;
1659{
1660 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1661 *flags |= SEC_SMALL_DATA;
1662
1663 return true;
1664}
1665
252b5132
RH		 1666/* Set the correct type for an Alpha ELF section. We do this by the
1667 section name, which is a hack, but ought to work. */
1668
1669static boolean
1670elf64_alpha_fake_sections (abfd, hdr, sec)
1671 bfd *abfd;
1672 Elf64_Internal_Shdr *hdr;
1673 asection *sec;
1674{
1675 register const char *name;
1676
1677 name = bfd_get_section_name (abfd, sec);
1678
1679 if (strcmp (name, ".mdebug") == 0)
1680 {
1681 hdr->sh_type = SHT_ALPHA_DEBUG;
1682 /* In a shared object on Irix 5.3, the .mdebug section has an
1683 entsize of 0. FIXME: Does this matter? */
1684 if ((abfd->flags & DYNAMIC) != 0 )
1685 hdr->sh_entsize = 0;
1686 else
1687 hdr->sh_entsize = 1;
1688 }
204692d7
RH		 1689 else if ((sec->flags & SEC_SMALL_DATA)
1690 || strcmp (name, ".sdata") == 0
252b5132
RH		 1691 || strcmp (name, ".sbss") == 0
1692 || strcmp (name, ".lit4") == 0
1693 || strcmp (name, ".lit8") == 0)
1694 hdr->sh_flags |= SHF_ALPHA_GPREL;
1695
1696 return true;
1697}
1698
1699/* Hook called by the linker routine which adds symbols from an object
1700 file. We use it to put .comm items in .sbss, and not .bss. */
1701
1702static boolean
1703elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1704 bfd *abfd;
1705 struct bfd_link_info *info;
1706 const Elf_Internal_Sym *sym;
56fc028e
AJ		 1707 const char **namep ATTRIBUTE_UNUSED;
1708 flagword *flagsp ATTRIBUTE_UNUSED;
252b5132
RH		 1709 asection **secp;
1710 bfd_vma *valp;
1711{
1712 if (sym->st_shndx == SHN_COMMON
1713 && !info->relocateable
c0846b23 1714 && sym->st_size <= elf_gp_size (abfd))
252b5132
RH		 1715 {
1716 /* Common symbols less than or equal to -G nn bytes are
1717 automatically put into .sbss. */
1718
1719 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1720
1721 if (scomm == NULL)
1722 {
1723 scomm = bfd_make_section (abfd, ".scommon");
1724 if (scomm == NULL
1725 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1726 | SEC_IS_COMMON
1727 | SEC_LINKER_CREATED)))
1728 return false;
1729 }
1730
1731 *secp = scomm;
1732 *valp = sym->st_size;
1733 }
1734
1735 return true;
1736}
1737
1738/* Create the .got section. */
1739
1740static boolean
1741elf64_alpha_create_got_section(abfd, info)
1742 bfd *abfd;
56fc028e 1743 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 1744{
1745 asection *s;
1746
1747 if (bfd_get_section_by_name (abfd, ".got"))
1748 return true;
1749
1750 s = bfd_make_section (abfd, ".got");
1751 if (s == NULL
1752 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1753 | SEC_HAS_CONTENTS
1754 | SEC_IN_MEMORY
1755 | SEC_LINKER_CREATED))
1756 || !bfd_set_section_alignment (abfd, s, 3))
1757 return false;
1758
1759 alpha_elf_tdata (abfd)->got = s;
1760
1761 return true;
1762}
1763
1764/* Create all the dynamic sections. */
1765
1766static boolean
1767elf64_alpha_create_dynamic_sections (abfd, info)
1768 bfd *abfd;
1769 struct bfd_link_info *info;
1770{
1771 asection *s;
1772 struct elf_link_hash_entry *h;
1773
1774 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1775
1776 s = bfd_make_section (abfd, ".plt");
1777 if (s == NULL
1778 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1779 | SEC_HAS_CONTENTS
1780 | SEC_IN_MEMORY
1781 | SEC_LINKER_CREATED
1782 | SEC_CODE))
1783 || ! bfd_set_section_alignment (abfd, s, 3))
1784 return false;
1785
1786 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1787 .plt section. */
1788 h = NULL;
1789 if (! (_bfd_generic_link_add_one_symbol
1790 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1791 (bfd_vma) 0, (const char *) NULL, false,
1792 get_elf_backend_data (abfd)->collect,
1793 (struct bfd_link_hash_entry **) &h)))
1794 return false;
1795 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1796 h->type = STT_OBJECT;
1797
1798 if (info->shared
1799 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1800 return false;
1801
1802 s = bfd_make_section (abfd, ".rela.plt");
1803 if (s == NULL
1804 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1805 | SEC_HAS_CONTENTS
1806 | SEC_IN_MEMORY
1807 | SEC_LINKER_CREATED
1808 | SEC_READONLY))
1809 || ! bfd_set_section_alignment (abfd, s, 3))
1810 return false;
1811
1812 /* We may or may not have created a .got section for this object, but
1813 we definitely havn't done the rest of the work. */
1814
1815 if (!elf64_alpha_create_got_section (abfd, info))
1816 return false;
1817
1818 s = bfd_make_section(abfd, ".rela.got");
1819 if (s == NULL
1820 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1821 | SEC_HAS_CONTENTS
1822 | SEC_IN_MEMORY
1823 | SEC_LINKER_CREATED
1824 | SEC_READONLY))
1825 || !bfd_set_section_alignment (abfd, s, 3))
1826 return false;
1827
1828 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1829 dynobj's .got section. We don't do this in the linker script
1830 because we don't want to define the symbol if we are not creating
1831 a global offset table. */
1832 h = NULL;
1833 if (!(_bfd_generic_link_add_one_symbol
1834 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1835 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1836 false, get_elf_backend_data (abfd)->collect,
1837 (struct bfd_link_hash_entry **) &h)))
1838 return false;
1839 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1840 h->type = STT_OBJECT;
1841
1842 if (info->shared
1843 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1844 return false;
1845
1846 elf_hash_table (info)->hgot = h;
1847
1848 return true;
1849}
1850\f
1851/* Read ECOFF debugging information from a .mdebug section into a
1852 ecoff_debug_info structure. */
1853
1854static boolean
1855elf64_alpha_read_ecoff_info (abfd, section, debug)
1856 bfd *abfd;
1857 asection *section;
1858 struct ecoff_debug_info *debug;
1859{
1860 HDRR *symhdr;
1861 const struct ecoff_debug_swap *swap;
1862 char *ext_hdr = NULL;
1863
1864 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
fe8bc63d 1865 memset (debug, 0, sizeof (*debug));
252b5132 1866
dc810e39 1867 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
252b5132
RH		 1868 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1869 goto error_return;
1870
1871 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1872 swap->external_hdr_size)
1873 == false)
1874 goto error_return;
1875
1876 symhdr = &debug->symbolic_header;
1877 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1878
1879 /* The symbolic header contains absolute file offsets and sizes to
1880 read. */
1881#define READ(ptr, offset, count, size, type) \
1882 if (symhdr->count == 0) \
1883 debug->ptr = NULL; \
1884 else \
1885 { \
dc810e39
AM		 1886 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1887 debug->ptr = (type) bfd_malloc (amt); \
252b5132
RH		 1888 if (debug->ptr == NULL) \
1889 goto error_return; \
1890 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
dc810e39 1891 || bfd_bread (debug->ptr, amt, abfd) != amt) \
252b5132
RH		 1892 goto error_return; \
1893 }
1894
1895 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1896 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1897 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1898 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1899 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1900 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1901 union aux_ext *);
1902 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1903 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1904 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1905 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1906 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1907#undef READ
1908
1909 debug->fdr = NULL;
1910 debug->adjust = NULL;
1911
1912 return true;
1913
1914 error_return:
1915 if (ext_hdr != NULL)
1916 free (ext_hdr);
1917 if (debug->line != NULL)
1918 free (debug->line);
1919 if (debug->external_dnr != NULL)
1920 free (debug->external_dnr);
1921 if (debug->external_pdr != NULL)
1922 free (debug->external_pdr);
1923 if (debug->external_sym != NULL)
1924 free (debug->external_sym);
1925 if (debug->external_opt != NULL)
1926 free (debug->external_opt);
1927 if (debug->external_aux != NULL)
1928 free (debug->external_aux);
1929 if (debug->ss != NULL)
1930 free (debug->ss);
1931 if (debug->ssext != NULL)
1932 free (debug->ssext);
1933 if (debug->external_fdr != NULL)
1934 free (debug->external_fdr);
1935 if (debug->external_rfd != NULL)
1936 free (debug->external_rfd);
1937 if (debug->external_ext != NULL)
1938 free (debug->external_ext);
1939 return false;
1940}
1941
1942/* Alpha ELF local labels start with '$'. */
1943
1944static boolean
1945elf64_alpha_is_local_label_name (abfd, name)
56fc028e 1946 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1947 const char *name;
1948{
1949 return name[0] == '$';
1950}
1951
1952/* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1953 routine in order to handle the ECOFF debugging information. We
1954 still call this mips_elf_find_line because of the slot
1955 find_line_info in elf_obj_tdata is declared that way. */
1956
1957struct mips_elf_find_line
1958{
1959 struct ecoff_debug_info d;
1960 struct ecoff_find_line i;
1961};
1962
1963static boolean
1964elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
1965 functionname_ptr, line_ptr)
1966 bfd *abfd;
1967 asection *section;
1968 asymbol **symbols;
1969 bfd_vma offset;
1970 const char **filename_ptr;
1971 const char **functionname_ptr;
1972 unsigned int *line_ptr;
1973{
1974 asection *msec;
1975
95404643
RH		 1976 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1977 filename_ptr, functionname_ptr,
1978 line_ptr, 0,
1979 &elf_tdata (abfd)->dwarf2_find_line_info))
1980 return true;
1981
252b5132
RH		 1982 msec = bfd_get_section_by_name (abfd, ".mdebug");
1983 if (msec != NULL)
1984 {
1985 flagword origflags;
1986 struct mips_elf_find_line *fi;
1987 const struct ecoff_debug_swap * const swap =
1988 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1989
1990 /* If we are called during a link, alpha_elf_final_link may have
1991 cleared the SEC_HAS_CONTENTS field. We force it back on here
1992 if appropriate (which it normally will be). */
1993 origflags = msec->flags;
1994 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1995 msec->flags |= SEC_HAS_CONTENTS;
1996
1997 fi = elf_tdata (abfd)->find_line_info;
1998 if (fi == NULL)
1999 {
2000 bfd_size_type external_fdr_size;
2001 char *fraw_src;
2002 char *fraw_end;
2003 struct fdr *fdr_ptr;
dc810e39 2004 bfd_size_type amt = sizeof (struct mips_elf_find_line);
252b5132 2005
dc810e39 2006 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
252b5132
RH		 2007 if (fi == NULL)
2008 {
2009 msec->flags = origflags;
2010 return false;
2011 }
2012
2013 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2014 {
2015 msec->flags = origflags;
2016 return false;
2017 }
2018
2019 /* Swap in the FDR information. */
dc810e39
AM		 2020 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2021 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
252b5132
RH		 2022 if (fi->d.fdr == NULL)
2023 {
2024 msec->flags = origflags;
2025 return false;
2026 }
2027 external_fdr_size = swap->external_fdr_size;
2028 fdr_ptr = fi->d.fdr;
2029 fraw_src = (char *) fi->d.external_fdr;
2030 fraw_end = (fraw_src
2031 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2032 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2033 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2034
2035 elf_tdata (abfd)->find_line_info = fi;
2036
2037 /* Note that we don't bother to ever free this information.
2038 find_nearest_line is either called all the time, as in
2039 objdump -l, so the information should be saved, or it is
2040 rarely called, as in ld error messages, so the memory
2041 wasted is unimportant. Still, it would probably be a
2042 good idea for free_cached_info to throw it away. */
2043 }
2044
2045 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2046 &fi->i, filename_ptr, functionname_ptr,
2047 line_ptr))
2048 {
2049 msec->flags = origflags;
2050 return true;
2051 }
2052
2053 msec->flags = origflags;
2054 }
2055
2056 /* Fall back on the generic ELF find_nearest_line routine. */
2057
2058 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2059 filename_ptr, functionname_ptr,
2060 line_ptr);
2061}
2062\f
2063/* Structure used to pass information to alpha_elf_output_extsym. */
2064
2065struct extsym_info
2066{
2067 bfd *abfd;
2068 struct bfd_link_info *info;
2069 struct ecoff_debug_info *debug;
2070 const struct ecoff_debug_swap *swap;
2071 boolean failed;
2072};
2073
2074static boolean
2075elf64_alpha_output_extsym (h, data)
2076 struct alpha_elf_link_hash_entry *h;
2077 PTR data;
2078{
2079 struct extsym_info *einfo = (struct extsym_info *) data;
2080 boolean strip;
2081 asection *sec, *output_section;
2082
2083 if (h->root.indx == -2)
2084 strip = false;
2085 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2086 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2087 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2088 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2089 strip = true;
2090 else if (einfo->info->strip == strip_all
2091 || (einfo->info->strip == strip_some
2092 && bfd_hash_lookup (einfo->info->keep_hash,
2093 h->root.root.root.string,
2094 false, false) == NULL))
2095 strip = true;
2096 else
2097 strip = false;
2098
2099 if (strip)
2100 return true;
2101
2102 if (h->esym.ifd == -2)
2103 {
2104 h->esym.jmptbl = 0;
2105 h->esym.cobol_main = 0;
2106 h->esym.weakext = 0;
2107 h->esym.reserved = 0;
2108 h->esym.ifd = ifdNil;
2109 h->esym.asym.value = 0;
2110 h->esym.asym.st = stGlobal;
2111
2112 if (h->root.root.type != bfd_link_hash_defined
2113 && h->root.root.type != bfd_link_hash_defweak)
2114 h->esym.asym.sc = scAbs;
2115 else
2116 {
2117 const char *name;
2118
2119 sec = h->root.root.u.def.section;
2120 output_section = sec->output_section;
2121
2122 /* When making a shared library and symbol h is the one from
2123 the another shared library, OUTPUT_SECTION may be null. */
2124 if (output_section == NULL)
2125 h->esym.asym.sc = scUndefined;
2126 else
2127 {
2128 name = bfd_section_name (output_section->owner, output_section);
2129
2130 if (strcmp (name, ".text") == 0)
2131 h->esym.asym.sc = scText;
2132 else if (strcmp (name, ".data") == 0)
2133 h->esym.asym.sc = scData;
2134 else if (strcmp (name, ".sdata") == 0)
2135 h->esym.asym.sc = scSData;
2136 else if (strcmp (name, ".rodata") == 0
2137 || strcmp (name, ".rdata") == 0)
2138 h->esym.asym.sc = scRData;
2139 else if (strcmp (name, ".bss") == 0)
2140 h->esym.asym.sc = scBss;
2141 else if (strcmp (name, ".sbss") == 0)
2142 h->esym.asym.sc = scSBss;
2143 else if (strcmp (name, ".init") == 0)
2144 h->esym.asym.sc = scInit;
2145 else if (strcmp (name, ".fini") == 0)
2146 h->esym.asym.sc = scFini;
2147 else
2148 h->esym.asym.sc = scAbs;
2149 }
2150 }
2151
2152 h->esym.asym.reserved = 0;
2153 h->esym.asym.index = indexNil;
2154 }
2155
2156 if (h->root.root.type == bfd_link_hash_common)
2157 h->esym.asym.value = h->root.root.u.c.size;
2158 else if (h->root.root.type == bfd_link_hash_defined
2159 || h->root.root.type == bfd_link_hash_defweak)
2160 {
2161 if (h->esym.asym.sc == scCommon)
2162 h->esym.asym.sc = scBss;
2163 else if (h->esym.asym.sc == scSCommon)
2164 h->esym.asym.sc = scSBss;
2165
2166 sec = h->root.root.u.def.section;
2167 output_section = sec->output_section;
2168 if (output_section != NULL)
2169 h->esym.asym.value = (h->root.root.u.def.value
2170 + sec->output_offset
2171 + output_section->vma);
2172 else
2173 h->esym.asym.value = 0;
2174 }
2175 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2176 {
2177 /* Set type and value for a symbol with a function stub. */
2178 h->esym.asym.st = stProc;
2179 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2180 if (sec == NULL)
2181 h->esym.asym.value = 0;
2182 else
2183 {
2184 output_section = sec->output_section;
2185 if (output_section != NULL)
2186 h->esym.asym.value = (h->root.plt.offset
2187 + sec->output_offset
2188 + output_section->vma);
2189 else
2190 h->esym.asym.value = 0;
2191 }
252b5132
RH		 2192 }
2193
2194 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2195 h->root.root.root.string,
2196 &h->esym))
2197 {
2198 einfo->failed = true;
2199 return false;
2200 }
2201
2202 return true;
2203}
2204
2205/* FIXME: Create a runtime procedure table from the .mdebug section.
2206
2207static boolean
2208mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2209 PTR handle;
2210 bfd *abfd;
2211 struct bfd_link_info *info;
2212 asection *s;
2213 struct ecoff_debug_info *debug;
2214*/
2215\f
2216/* Handle dynamic relocations when doing an Alpha ELF link. */
2217
2218static boolean
2219elf64_alpha_check_relocs (abfd, info, sec, relocs)
2220 bfd *abfd;
2221 struct bfd_link_info *info;
2222 asection *sec;
2223 const Elf_Internal_Rela *relocs;
2224{
2225 bfd *dynobj;
2226 asection *sreloc;
2227 const char *rel_sec_name;
2228 Elf_Internal_Shdr *symtab_hdr;
2229 struct alpha_elf_link_hash_entry **sym_hashes;
2230 struct alpha_elf_got_entry **local_got_entries;
2231 const Elf_Internal_Rela *rel, *relend;
2232 int got_created;
dc810e39 2233 bfd_size_type amt;
252b5132
RH		 2234
2235 if (info->relocateable)
2236 return true;
2237
2238 dynobj = elf_hash_table(info)->dynobj;
2239 if (dynobj == NULL)
2240 elf_hash_table(info)->dynobj = dynobj = abfd;
2241
2242 sreloc = NULL;
2243 rel_sec_name = NULL;
2244 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2245 sym_hashes = alpha_elf_sym_hashes(abfd);
2246 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2247 got_created = 0;
2248
2249 relend = relocs + sec->reloc_count;
2250 for (rel = relocs; rel < relend; ++rel)
2251 {
2252 unsigned long r_symndx, r_type;
2253 struct alpha_elf_link_hash_entry *h;
2254
2255 r_symndx = ELF64_R_SYM (rel->r_info);
2256 if (r_symndx < symtab_hdr->sh_info)
2257 h = NULL;
2258 else
2259 {
2260 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2261
2262 while (h->root.root.type == bfd_link_hash_indirect
2263 || h->root.root.type == bfd_link_hash_warning)
2264 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2265
2266 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2267 }
2268 r_type = ELF64_R_TYPE (rel->r_info);
2269
2270 switch (r_type)
2271 {
2272 case R_ALPHA_LITERAL:
2273 {
2274 struct alpha_elf_got_entry *gotent;
2275 int flags = 0;
2276
2277 if (h)
2278 {
2279 /* Search for and possibly create a got entry. */
2280 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2281 if (gotent->gotobj == abfd &&
2282 gotent->addend == rel->r_addend)
2283 break;
2284
2285 if (!gotent)
2286 {
dc810e39 2287 amt = sizeof (struct alpha_elf_got_entry);
252b5132 2288 gotent = ((struct alpha_elf_got_entry *)
dc810e39 2289 bfd_alloc (abfd, amt));
252b5132
RH		 2290 if (!gotent)
2291 return false;
2292
2293 gotent->gotobj = abfd;
2294 gotent->addend = rel->r_addend;
2295 gotent->got_offset = -1;
2296 gotent->flags = 0;
2297 gotent->use_count = 1;
2298
2299 gotent->next = h->got_entries;
2300 h->got_entries = gotent;
2301
2302 alpha_elf_tdata (abfd)->total_got_entries++;
2303 }
2304 else
2305 gotent->use_count += 1;
2306 }
2307 else
2308 {
2309 /* This is a local .got entry -- record for merge. */
2310 if (!local_got_entries)
2311 {
dc810e39
AM		 2312 bfd_size_type size;
2313 size = symtab_hdr->sh_info;
2314 size *= sizeof (struct alpha_elf_got_entry *);
252b5132
RH		 2315
2316 local_got_entries = ((struct alpha_elf_got_entry **)
2317 bfd_alloc (abfd, size));
2318 if (!local_got_entries)
2319 return false;
2320
dc810e39 2321 memset (local_got_entries, 0, (size_t) size);
252b5132
RH		 2322 alpha_elf_tdata (abfd)->local_got_entries =
2323 local_got_entries;
2324 }
2325
2326 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2327 gotent != NULL && gotent->addend != rel->r_addend;
2328 gotent = gotent->next)
2329 continue;
2330 if (!gotent)
2331 {
dc810e39 2332 amt = sizeof (struct alpha_elf_got_entry);
252b5132 2333 gotent = ((struct alpha_elf_got_entry *)
dc810e39 2334 bfd_alloc (abfd, amt));
252b5132
RH		 2335 if (!gotent)
2336 return false;
2337
2338 gotent->gotobj = abfd;
2339 gotent->addend = rel->r_addend;
2340 gotent->got_offset = -1;
2341 gotent->flags = 0;
2342 gotent->use_count = 1;
2343
2344 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2345 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2346
2347 alpha_elf_tdata(abfd)->total_got_entries++;
2348 alpha_elf_tdata(abfd)->n_local_got_entries++;
2349 }
2350 else
2351 gotent->use_count += 1;
2352 }
2353
2354 /* Remember how this literal is used from its LITUSEs.
2355 This will be important when it comes to decide if we can
2356 create a .plt entry for a function symbol. */
2357 if (rel+1 < relend
2358 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2359 {
2360 do
2361 {
2362 ++rel;
2363 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2364 flags |= 1 << rel->r_addend;
2365 }
2366 while (rel+1 < relend &&
2367 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2368 }
2369 else
2370 {
2371 /* No LITUSEs -- presumably the address is not being
2372 loaded for nothing. */
2373 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2374 }
2375
2376 gotent->flags |= flags;
2377 if (h)
2378 {
2379 /* Make a guess as to whether a .plt entry will be needed. */
2380 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2381 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2382 else
2383 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2384 }
2385 }
2386 /* FALLTHRU */
2387
2388 case R_ALPHA_GPDISP:
dfe57ca0 2389 case R_ALPHA_GPREL16:
252b5132
RH		 2390 case R_ALPHA_GPREL32:
2391 case R_ALPHA_GPRELHIGH:
2392 case R_ALPHA_GPRELLOW:
2393 /* We don't actually use the .got here, but the sections must
2394 be created before the linker maps input sections to output
2395 sections. */
2396 if (!got_created)
2397 {
2398 if (!elf64_alpha_create_got_section (abfd, info))
2399 return false;
2400
2401 /* Make sure the object's gotobj is set to itself so
2402 that we default to every object with its own .got.
2403 We'll merge .gots later once we've collected each
2404 object's info. */
2405 alpha_elf_tdata(abfd)->gotobj = abfd;
2406
2407 got_created = 1;
2408 }
2409 break;
2410
2411 case R_ALPHA_SREL16:
2412 case R_ALPHA_SREL32:
2413 case R_ALPHA_SREL64:
2414 if (h == NULL)
2415 break;
2416 /* FALLTHRU */
2417
2418 case R_ALPHA_REFLONG:
2419 case R_ALPHA_REFQUAD:
2420 if (rel_sec_name == NULL)
2421 {
2422 rel_sec_name = (bfd_elf_string_from_elf_section
2423 (abfd, elf_elfheader(abfd)->e_shstrndx,
2424 elf_section_data(sec)->rel_hdr.sh_name));
2425 if (rel_sec_name == NULL)
2426 return false;
2427
2428 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2429 && strcmp (bfd_get_section_name (abfd, sec),
2430 rel_sec_name+5) == 0);
2431 }
2432
2433 /* We need to create the section here now whether we eventually
2434 use it or not so that it gets mapped to an output section by
2435 the linker. If not used, we'll kill it in
2436 size_dynamic_sections. */
2437 if (sreloc == NULL)
2438 {
2439 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2440 if (sreloc == NULL)
2441 {
dc810e39
AM		 2442 flagword flags;
2443
252b5132 2444 sreloc = bfd_make_section (dynobj, rel_sec_name);
dc810e39
AM		 2445 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
2446 | SEC_LINKER_CREATED | SEC_READONLY);
2447 if (sec->flags & SEC_ALLOC)
2448 flags |= SEC_ALLOC | SEC_LOAD;
252b5132 2449 if (sreloc == NULL
dc810e39 2450 || !bfd_set_section_flags (dynobj, sreloc, flags)
252b5132
RH		 2451 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2452 return false;
2453 }
2454 }
2455
2456 if (h)
2457 {
2458 /* Since we havn't seen all of the input symbols yet, we
2459 don't know whether we'll actually need a dynamic relocation
2460 entry for this reloc. So make a record of it. Once we
2461 find out if this thing needs dynamic relocation we'll
fe8bc63d 2462 expand the relocation sections by the appropriate amount. */
252b5132
RH		 2463
2464 struct alpha_elf_reloc_entry *rent;
2465
2466 for (rent = h->reloc_entries; rent; rent = rent->next)
2467 if (rent->rtype == r_type && rent->srel == sreloc)
2468 break;
2469
2470 if (!rent)
2471 {
dc810e39
AM		 2472 amt = sizeof (struct alpha_elf_reloc_entry);
2473 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
252b5132
RH		 2474 if (!rent)
2475 return false;
2476
2477 rent->srel = sreloc;
2478 rent->rtype = r_type;
2479 rent->count = 1;
fcfbdf31 2480 rent->reltext = (sec->flags & SEC_READONLY) != 0;
252b5132
RH		 2481
2482 rent->next = h->reloc_entries;
2483 h->reloc_entries = rent;
2484 }
2485 else
2486 rent->count++;
2487 }
c555c5c5 2488 else if (info->shared && (sec->flags & SEC_ALLOC))
252b5132 2489 {
c555c5c5
AM		 2490 /* If this is a shared library, and the section is to be
2491 loaded into memory, we need a RELATIVE reloc. */
252b5132 2492 sreloc->_raw_size += sizeof (Elf64_External_Rela);
fcfbdf31
JJ		 2493 if (sec->flags & SEC_READONLY)
2494 info->flags |= DF_TEXTREL;
252b5132
RH		 2495 }
2496 break;
2497 }
2498 }
2499
2500 return true;
2501}
2502
2503/* Adjust a symbol defined by a dynamic object and referenced by a
2504 regular object. The current definition is in some section of the
2505 dynamic object, but we're not including those sections. We have to
2506 change the definition to something the rest of the link can
2507 understand. */
2508
2509static boolean
2510elf64_alpha_adjust_dynamic_symbol (info, h)
2511 struct bfd_link_info *info;
2512 struct elf_link_hash_entry *h;
2513{
2514 bfd *dynobj;
2515 asection *s;
2516 struct alpha_elf_link_hash_entry *ah;
2517
2518 dynobj = elf_hash_table(info)->dynobj;
2519 ah = (struct alpha_elf_link_hash_entry *)h;
2520
2521 /* Now that we've seen all of the input symbols, finalize our decision
2522 about whether this symbol should get a .plt entry. */
2523
2524 if (h->root.type != bfd_link_hash_undefweak
2525 && alpha_elf_dynamic_symbol_p (h, info)
2526 && ((h->type == STT_FUNC
2527 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2528 || (h->type == STT_NOTYPE
2529 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2530 /* Don't prevent otherwise valid programs from linking by attempting
2531 to create a new .got entry somewhere. A Correct Solution would be
2532 to add a new .got section to a new object file and let it be merged
2533 somewhere later. But for now don't bother. */
2534 && ah->got_entries)
2535 {
2536 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2537
2538 s = bfd_get_section_by_name(dynobj, ".plt");
2539 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2540 return false;
2541
2542 /* The first bit of the .plt is reserved. */
2543 if (s->_raw_size == 0)
2544 s->_raw_size = PLT_HEADER_SIZE;
2545
2546 h->plt.offset = s->_raw_size;
2547 s->_raw_size += PLT_ENTRY_SIZE;
2548
2549 /* If this symbol is not defined in a regular file, and we are not
2550 generating a shared library, then set the symbol to the location
2551 in the .plt. This is required to make function pointers compare
2552 equal between the normal executable and the shared library. */
2553 if (! info->shared
2554 && h->root.type != bfd_link_hash_defweak)
2555 {
2556 h->root.u.def.section = s;
2557 h->root.u.def.value = h->plt.offset;
2558 }
2559
2560 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2561 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2562 BFD_ASSERT (s != NULL);
2563 s->_raw_size += sizeof (Elf64_External_Rela);
2564
2565 return true;
2566 }
2567 else
2568 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2569
2570 /* If this is a weak symbol, and there is a real definition, the
2571 processor independent code will have arranged for us to see the
2572 real definition first, and we can just use the same value. */
2573 if (h->weakdef != NULL)
2574 {
2575 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2576 || h->weakdef->root.type == bfd_link_hash_defweak);
2577 h->root.u.def.section = h->weakdef->root.u.def.section;
2578 h->root.u.def.value = h->weakdef->root.u.def.value;
2579 return true;
2580 }
2581
2582 /* This is a reference to a symbol defined by a dynamic object which
2583 is not a function. The Alpha, since it uses .got entries for all
2584 symbols even in regular objects, does not need the hackery of a
2585 .dynbss section and COPY dynamic relocations. */
2586
2587 return true;
2588}
2589
2590/* Symbol versioning can create new symbols, and make our old symbols
2591 indirect to the new ones. Consolidate the got and reloc information
2592 in these situations. */
2593
2594static boolean
2595elf64_alpha_merge_ind_symbols (hi, dummy)
2596 struct alpha_elf_link_hash_entry *hi;
56fc028e 2597 PTR dummy ATTRIBUTE_UNUSED;
252b5132
RH		 2598{
2599 struct alpha_elf_link_hash_entry *hs;
2600
2601 if (hi->root.root.type != bfd_link_hash_indirect)
2602 return true;
2603 hs = hi;
2604 do {
2605 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2606 } while (hs->root.root.type == bfd_link_hash_indirect);
2607
2608 /* Merge the flags. Whee. */
2609
2610 hs->flags |= hi->flags;
2611
2612 /* Merge the .got entries. Cannibalize the old symbol's list in
2613 doing so, since we don't need it anymore. */
2614
2615 if (hs->got_entries == NULL)
2616 hs->got_entries = hi->got_entries;
2617 else
2618 {
2619 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2620
2621 gsh = hs->got_entries;
2622 for (gi = hi->got_entries; gi ; gi = gin)
2623 {
2624 gin = gi->next;
2625 for (gs = gsh; gs ; gs = gs->next)
2626 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2627 goto got_found;
2628 gi->next = hs->got_entries;
2629 hs->got_entries = gi;
2630 got_found:;
2631 }
2632 }
2633 hi->got_entries = NULL;
2634
2635 /* And similar for the reloc entries. */
2636
2637 if (hs->reloc_entries == NULL)
2638 hs->reloc_entries = hi->reloc_entries;
2639 else
2640 {
2641 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2642
2643 rsh = hs->reloc_entries;
2644 for (ri = hi->reloc_entries; ri ; ri = rin)
2645 {
2646 rin = ri->next;
2647 for (rs = rsh; rs ; rs = rs->next)
2648 if (ri->rtype == rs->rtype)
2649 {
2650 rs->count += ri->count;
2651 goto found_reloc;
2652 }
2653 ri->next = hs->reloc_entries;
2654 hs->reloc_entries = ri;
2655 found_reloc:;
2656 }
2657 }
2658 hi->reloc_entries = NULL;
2659
2660 return true;
2661}
2662
2663/* Is it possible to merge two object file's .got tables? */
2664
2665static boolean
2666elf64_alpha_can_merge_gots (a, b)
2667 bfd *a, *b;
2668{
2669 int total = alpha_elf_tdata (a)->total_got_entries;
2670 bfd *bsub;
2671
2672 /* Trivial quick fallout test. */
2673 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2674 return true;
2675
2676 /* By their nature, local .got entries cannot be merged. */
2677 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2678 return false;
2679
2680 /* Failing the common trivial comparison, we must effectively
2681 perform the merge. Not actually performing the merge means that
2682 we don't have to store undo information in case we fail. */
2683 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2684 {
2685 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2686 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2687 int i, n;
2688
d9bc7a44 2689 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
252b5132
RH		 2690 for (i = 0; i < n; ++i)
2691 {
2692 struct alpha_elf_got_entry *ae, *be;
2693 struct alpha_elf_link_hash_entry *h;
2694
2695 h = hashes[i];
2696 while (h->root.root.type == bfd_link_hash_indirect
2697 || h->root.root.type == bfd_link_hash_warning)
2698 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2699
2700 for (be = h->got_entries; be ; be = be->next)
2701 {
2702 if (be->use_count == 0)
2703 continue;
2704 if (be->gotobj != b)
2705 continue;
2706
2707 for (ae = h->got_entries; ae ; ae = ae->next)
2708 if (ae->gotobj == a && ae->addend == be->addend)
2709 goto global_found;
2710
2711 if (++total > MAX_GOT_ENTRIES)
2712 return false;
2713 global_found:;
2714 }
2715 }
2716 }
2717
2718 return true;
2719}
2720
2721/* Actually merge two .got tables. */
2722
2723static void
2724elf64_alpha_merge_gots (a, b)
2725 bfd *a, *b;
2726{
2727 int total = alpha_elf_tdata (a)->total_got_entries;
2728 bfd *bsub;
2729
2730 /* Remember local expansion. */
2731 {
2732 int e = alpha_elf_tdata (b)->n_local_got_entries;
2733 total += e;
2734 alpha_elf_tdata (a)->n_local_got_entries += e;
2735 }
2736
2737 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2738 {
2739 struct alpha_elf_got_entry **local_got_entries;
2740 struct alpha_elf_link_hash_entry **hashes;
2741 Elf_Internal_Shdr *symtab_hdr;
2742 int i, n;
2743
2744 /* Let the local .got entries know they are part of a new subsegment. */
2745 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2746 if (local_got_entries)
2747 {
2748 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2749 for (i = 0; i < n; ++i)
2750 {
2751 struct alpha_elf_got_entry *ent;
2752 for (ent = local_got_entries[i]; ent; ent = ent->next)
2753 ent->gotobj = a;
2754 }
2755 }
2756
2757 /* Merge the global .got entries. */
2758 hashes = alpha_elf_sym_hashes (bsub);
2759 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2760
d9bc7a44 2761 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
252b5132
RH		 2762 for (i = 0; i < n; ++i)
2763 {
2764 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2765 struct alpha_elf_link_hash_entry *h;
2766
2767 h = hashes[i];
2768 while (h->root.root.type == bfd_link_hash_indirect
2769 || h->root.root.type == bfd_link_hash_warning)
2770 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2771
2772 start = &h->got_entries;
2773 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2774 {
2775 if (be->use_count == 0)
2776 {
2777 *pbe = be->next;
2778 continue;
2779 }
2780 if (be->gotobj != b)
2781 continue;
2782
2783 for (ae = *start; ae ; ae = ae->next)
2784 if (ae->gotobj == a && ae->addend == be->addend)
2785 {
2786 ae->flags |= be->flags;
2787 ae->use_count += be->use_count;
2788 *pbe = be->next;
2789 goto global_found;
2790 }
2791 be->gotobj = a;
2792 total += 1;
2793
2794 global_found:;
2795 }
2796 }
2797
2798 alpha_elf_tdata (bsub)->gotobj = a;
2799 }
2800 alpha_elf_tdata (a)->total_got_entries = total;
2801
2802 /* Merge the two in_got chains. */
2803 {
2804 bfd *next;
2805
2806 bsub = a;
2807 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2808 bsub = next;
2809
2810 alpha_elf_tdata (bsub)->in_got_link_next = b;
2811 }
2812}
2813
2814/* Calculate the offsets for the got entries. */
2815
2816static boolean
2817elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2818 struct alpha_elf_link_hash_entry *h;
52b9d213 2819 PTR arg ATTRIBUTE_UNUSED;
252b5132
RH		 2820{
2821 struct alpha_elf_got_entry *gotent;
2822
2823 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2824 if (gotent->use_count > 0)
2825 {
2826 bfd_size_type *plge
2827 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2828
2829 gotent->got_offset = *plge;
2830 *plge += 8;
2831 }
2832
2833 return true;
2834}
2835
2836static void
2837elf64_alpha_calc_got_offsets (info)
2838 struct bfd_link_info *info;
2839{
2840 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2841
2842 /* First, zero out the .got sizes, as we may be recalculating the
2843 .got after optimizing it. */
2844 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2845 alpha_elf_tdata(i)->got->_raw_size = 0;
2846
2847 /* Next, fill in the offsets for all the global entries. */
2848 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2849 elf64_alpha_calc_got_offsets_for_symbol,
2850 NULL);
2851
2852 /* Finally, fill in the offsets for the local entries. */
2853 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2854 {
2855 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2856 bfd *j;
2857
2858 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2859 {
2860 struct alpha_elf_got_entry **local_got_entries, *gotent;
2861 int k, n;
2862
2863 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2864 if (!local_got_entries)
2865 continue;
2866
2867 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2868 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2869 if (gotent->use_count > 0)
2870 {
2871 gotent->got_offset = got_offset;
2872 got_offset += 8;
2873 }
2874 }
2875
2876 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2877 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2878 }
2879}
2880
2881/* Constructs the gots. */
2882
2883static boolean
2884elf64_alpha_size_got_sections (output_bfd, info)
52b9d213 2885 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 2886 struct bfd_link_info *info;
2887{
52b9d213 2888 bfd *i, *got_list, *cur_got_obj = NULL;
252b5132
RH		 2889 int something_changed = 0;
2890
2891 got_list = alpha_elf_hash_table (info)->got_list;
2892
2893 /* On the first time through, pretend we have an existing got list
2894 consisting of all of the input files. */
2895 if (got_list == NULL)
2896 {
2897 for (i = info->input_bfds; i ; i = i->link_next)
2898 {
2899 bfd *this_got = alpha_elf_tdata (i)->gotobj;
2900 if (this_got == NULL)
2901 continue;
2902
2903 /* We are assuming no merging has yet ocurred. */
2904 BFD_ASSERT (this_got == i);
2905
2906 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2907 {
2908 /* Yikes! A single object file has too many entries. */
2909 (*_bfd_error_handler)
2910 (_("%s: .got subsegment exceeds 64K (size %d)"),
8f615d07 2911 bfd_archive_filename (i),
252b5132
RH		 2912 alpha_elf_tdata (this_got)->total_got_entries * 8);
2913 return false;
2914 }
2915
2916 if (got_list == NULL)
2917 got_list = this_got;
2918 else
2919 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2920 cur_got_obj = this_got;
2921 }
2922
2923 /* Strange degenerate case of no got references. */
2924 if (got_list == NULL)
2925 return true;
2926
2927 alpha_elf_hash_table (info)->got_list = got_list;
2928
2929 /* Force got offsets to be recalculated. */
2930 something_changed = 1;
2931 }
2932
2933 cur_got_obj = got_list;
2934 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2935 while (i != NULL)
2936 {
2937 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2938 {
2939 elf64_alpha_merge_gots (cur_got_obj, i);
2940 i = alpha_elf_tdata(i)->got_link_next;
2941 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2942 something_changed = 1;
2943 }
2944 else
2945 {
2946 cur_got_obj = i;
2947 i = alpha_elf_tdata(i)->got_link_next;
2948 }
2949 }
2950
2951 /* Once the gots have been merged, fill in the got offsets for
2952 everything therein. */
2953 if (1 || something_changed)
2954 elf64_alpha_calc_got_offsets (info);
2955
2956 return true;
2957}
2958
2959static boolean
2960elf64_alpha_always_size_sections (output_bfd, info)
2961 bfd *output_bfd;
2962 struct bfd_link_info *info;
2963{
2964 bfd *i;
2965
2966 if (info->relocateable)
2967 return true;
2968
2969 /* First, take care of the indirect symbols created by versioning. */
2970 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2971 elf64_alpha_merge_ind_symbols,
2972 NULL);
2973
2974 if (!elf64_alpha_size_got_sections (output_bfd, info))
2975 return false;
2976
2977 /* Allocate space for all of the .got subsections. */
2978 i = alpha_elf_hash_table (info)->got_list;
2979 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2980 {
2981 asection *s = alpha_elf_tdata(i)->got;
2982 if (s->_raw_size > 0)
2983 {
2984 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
2985 if (s->contents == NULL)
2986 return false;
2987 }
2988 }
2989
2990 return true;
2991}
2992
2993/* Work out the sizes of the dynamic relocation entries. */
2994
2995static boolean
2996elf64_alpha_calc_dynrel_sizes (h, info)
2997 struct alpha_elf_link_hash_entry *h;
2998 struct bfd_link_info *info;
2999{
3000 /* If the symbol was defined as a common symbol in a regular object
3001 file, and there was no definition in any dynamic object, then the
3002 linker will have allocated space for the symbol in a common
3003 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3004 set. This is done for dynamic symbols in
3005 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3006 symbols, somehow. */
3007 if (((h->root.elf_link_hash_flags
3008 & (ELF_LINK_HASH_DEF_REGULAR
3009 | ELF_LINK_HASH_REF_REGULAR
3010 | ELF_LINK_HASH_DEF_DYNAMIC))
3011 == ELF_LINK_HASH_REF_REGULAR)
3012 && (h->root.root.type == bfd_link_hash_defined
3013 || h->root.root.type == bfd_link_hash_defweak)
3014 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3015 {
3016 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3017 }
3018
3019 /* If the symbol is dynamic, we'll need all the relocations in their
3020 natural form. If this is a shared object, and it has been forced
3021 local, we'll need the same number of RELATIVE relocations. */
3022
3023 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3024 {
3025 struct alpha_elf_reloc_entry *relent;
3026 bfd *dynobj;
3027 struct alpha_elf_got_entry *gotent;
3028 bfd_size_type count;
3029 asection *srel;
3030
3031 for (relent = h->reloc_entries; relent; relent = relent->next)
3032 if (relent->rtype == R_ALPHA_REFLONG
3033 || relent->rtype == R_ALPHA_REFQUAD)
3034 {
3035 relent->srel->_raw_size +=
fe8bc63d 3036 sizeof (Elf64_External_Rela) * relent->count;
fcfbdf31
JJ		 3037 if (relent->reltext)
3038 info->flags |= DT_TEXTREL;
252b5132
RH		 3039 }
3040
3041 dynobj = elf_hash_table(info)->dynobj;
3042 count = 0;
3043
3044 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3045 count++;
3046
3047 /* If we are using a .plt entry, subtract one, as the first
3048 reference uses a .rela.plt entry instead. */
3049 if (h->root.plt.offset != MINUS_ONE)
3050 count--;
3051
3052 if (count > 0)
3053 {
3054 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3055 BFD_ASSERT (srel != NULL);
3056 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3057 }
3058 }
3059
3060 return true;
3061}
3062
3063/* Set the sizes of the dynamic sections. */
3064
3065static boolean
3066elf64_alpha_size_dynamic_sections (output_bfd, info)
24a35864 3067 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 3068 struct bfd_link_info *info;
3069{
3070 bfd *dynobj;
3071 asection *s;
252b5132
RH		 3072 boolean relplt;
3073
3074 dynobj = elf_hash_table(info)->dynobj;
3075 BFD_ASSERT(dynobj != NULL);
3076
3077 if (elf_hash_table (info)->dynamic_sections_created)
3078 {
3079 /* Set the contents of the .interp section to the interpreter. */
3080 if (!info->shared)
3081 {
3082 s = bfd_get_section_by_name (dynobj, ".interp");
3083 BFD_ASSERT (s != NULL);
3084 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3085 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3086 }
3087
3088 /* Now that we've seen all of the input files, we can decide which
3089 symbols need dynamic relocation entries and which don't. We've
3090 collected information in check_relocs that we can now apply to
3091 size the dynamic relocation sections. */
3092 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3093 elf64_alpha_calc_dynrel_sizes,
3094 info);
3095
3096 /* When building shared libraries, each local .got entry needs a
3097 RELATIVE reloc. */
3098 if (info->shared)
3099 {
3100 bfd *i;
3101 asection *srel;
3102 bfd_size_type count;
3103
3104 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3105 BFD_ASSERT (srel != NULL);
3106
3107 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3108 i != NULL;
3109 i = alpha_elf_tdata(i)->got_link_next)
3110 count += alpha_elf_tdata(i)->n_local_got_entries;
3111
fe8bc63d 3112 srel->_raw_size += count * sizeof (Elf64_External_Rela);
252b5132
RH		 3113 }
3114 }
3115 /* else we're not dynamic and by definition we don't need such things. */
3116
3117 /* The check_relocs and adjust_dynamic_symbol entry points have
3118 determined the sizes of the various dynamic sections. Allocate
3119 memory for them. */
252b5132
RH		 3120 relplt = false;
3121 for (s = dynobj->sections; s != NULL; s = s->next)
3122 {
3123 const char *name;
3124 boolean strip;
3125
3126 if (!(s->flags & SEC_LINKER_CREATED))
3127 continue;
3128
3129 /* It's OK to base decisions on the section name, because none
3130 of the dynobj section names depend upon the input files. */
3131 name = bfd_get_section_name (dynobj, s);
3132
3133 /* If we don't need this section, strip it from the output file.
3134 This is to handle .rela.bss and .rela.plt. We must create it
3135 in create_dynamic_sections, because it must be created before
3136 the linker maps input sections to output sections. The
3137 linker does that before adjust_dynamic_symbol is called, and
3138 it is that function which decides whether anything needs to
3139 go into these sections. */
3140
3141 strip = false;
3142
3143 if (strncmp (name, ".rela", 5) == 0)
3144 {
3145 strip = (s->_raw_size == 0);
3146
3147 if (!strip)
3148 {
252b5132
RH		 3149 if (strcmp(name, ".rela.plt") == 0)
3150 relplt = true;
3151
3152 /* We use the reloc_count field as a counter if we need
3153 to copy relocs into the output file. */
3154 s->reloc_count = 0;
3155 }
3156 }
3157 else if (strcmp (name, ".plt") != 0)
3158 {
3159 /* It's not one of our dynamic sections, so don't allocate space. */
3160 continue;
3161 }
3162
3163 if (strip)
7f8d5fc9 3164 _bfd_strip_section_from_output (info, s);
252b5132
RH		 3165 else
3166 {
3167 /* Allocate memory for the section contents. */
dc810e39 3168 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
252b5132
RH		 3169 if (s->contents == NULL && s->_raw_size != 0)
3170 return false;
3171 }
3172 }
3173
252b5132
RH		 3174 if (elf_hash_table (info)->dynamic_sections_created)
3175 {
3176 /* Add some entries to the .dynamic section. We fill in the
3177 values later, in elf64_alpha_finish_dynamic_sections, but we
3178 must add the entries now so that we get the correct size for
3179 the .dynamic section. The DT_DEBUG entry is filled in by the
3180 dynamic linker and used by the debugger. */
dc810e39
AM		 3181#define add_dynamic_entry(TAG, VAL) \
3182 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3183
252b5132
RH		 3184 if (!info->shared)
3185 {
dc810e39 3186 if (!add_dynamic_entry (DT_DEBUG, 0))
252b5132
RH		 3187 return false;
3188 }
3189
dc810e39 3190 if (!add_dynamic_entry (DT_PLTGOT, 0))
252b5132
RH		 3191 return false;
3192
3193 if (relplt)
3194 {
dc810e39
AM		 3195 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3196 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3197 || !add_dynamic_entry (DT_JMPREL, 0))
252b5132
RH		 3198 return false;
3199 }
3200
dc810e39
AM		 3201 if (!add_dynamic_entry (DT_RELA, 0)
3202 || !add_dynamic_entry (DT_RELASZ, 0)
3203 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
252b5132
RH		 3204 return false;
3205
fcfbdf31 3206 if (info->flags & DF_TEXTREL)
252b5132 3207 {
dc810e39 3208 if (!add_dynamic_entry (DT_TEXTREL, 0))
252b5132
RH		 3209 return false;
3210 }
3211 }
dc810e39 3212#undef add_dynamic_entry
252b5132
RH		 3213
3214 return true;
3215}
3216
252b5132
RH		 3217/* Relocate an Alpha ELF section. */
3218
3219static boolean
3220elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3221 contents, relocs, local_syms, local_sections)
3222 bfd *output_bfd;
3223 struct bfd_link_info *info;
3224 bfd *input_bfd;
3225 asection *input_section;
3226 bfd_byte *contents;
3227 Elf_Internal_Rela *relocs;
3228 Elf_Internal_Sym *local_syms;
3229 asection **local_sections;
3230{
3231 Elf_Internal_Shdr *symtab_hdr;
3232 Elf_Internal_Rela *rel;
3233 Elf_Internal_Rela *relend;
3234 asection *sec, *sgot, *srel, *srelgot;
3235 bfd *dynobj, *gotobj;
3236 bfd_vma gp;
f16fbd61 3237 boolean ret_val = true;
252b5132
RH		 3238
3239 srelgot = srel = NULL;
3240 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3241 dynobj = elf_hash_table (info)->dynobj;
3242 if (dynobj)
3243 {
3244 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3245 }
3246
3247 /* Find the gp value for this input bfd. */
3248 sgot = NULL;
3249 gp = 0;
3250 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3251 if (gotobj)
3252 {
3253 sgot = alpha_elf_tdata (gotobj)->got;
3254 gp = _bfd_get_gp_value (gotobj);
3255 if (gp == 0)
3256 {
3257 gp = (sgot->output_section->vma
3258 + sgot->output_offset
3259 + 0x8000);
3260 _bfd_set_gp_value (gotobj, gp);
3261 }
3262 }
3263
3264 rel = relocs;
3265 relend = relocs + input_section->reloc_count;
3266 for (; rel < relend; rel++)
3267 {
3268 int r_type;
3269 reloc_howto_type *howto;
3270 unsigned long r_symndx;
3271 struct alpha_elf_link_hash_entry *h;
3272 Elf_Internal_Sym *sym;
3273 bfd_vma relocation;
dc810e39 3274 bfd_vma addend;
252b5132
RH		 3275 bfd_reloc_status_type r;
3276
3277 r_type = ELF64_R_TYPE(rel->r_info);
3278 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3279 {
3280 bfd_set_error (bfd_error_bad_value);
3281 return false;
3282 }
3283 howto = elf64_alpha_howto_table + r_type;
3284
3285 r_symndx = ELF64_R_SYM(rel->r_info);
3286
3287 if (info->relocateable)
3288 {
3289 /* This is a relocateable link. We don't have to change
3290 anything, unless the reloc is against a section symbol,
3291 in which case we have to adjust according to where the
3292 section symbol winds up in the output section. */
72b60c23 3293
fe8bc63d 3294 /* The symbol associated with GPDISP and LITUSE is
72b60c23
RH		 3295 immaterial. Only the addend is significant. */
3296 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3297 continue;
3298
252b5132
RH		 3299 if (r_symndx < symtab_hdr->sh_info)
3300 {
3301 sym = local_syms + r_symndx;
3302 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3303 {
3304 sec = local_sections[r_symndx];
3305 rel->r_addend += sec->output_offset + sym->st_value;
3306 }
3307 }
3308
3309 continue;
3310 }
3311
3312 /* This is a final link. */
3313
3314 h = NULL;
3315 sym = NULL;
3316 sec = NULL;
3317
3318 if (r_symndx < symtab_hdr->sh_info)
3319 {
3320 sym = local_syms + r_symndx;
3321 sec = local_sections[r_symndx];
f8df10f4 3322 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
252b5132
RH		 3323 }
3324 else
3325 {
3326 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3327
3328 while (h->root.root.type == bfd_link_hash_indirect
3329 || h->root.root.type == bfd_link_hash_warning)
3330 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3331
3332 if (h->root.root.type == bfd_link_hash_defined
3333 || h->root.root.type == bfd_link_hash_defweak)
3334 {
3335 sec = h->root.root.u.def.section;
3336
252b5132
RH		 3337 if (sec->output_section == NULL)
3338 relocation = 0;
252b5132
RH		 3339 else
3340 {
3341 relocation = (h->root.root.u.def.value
3342 + sec->output_section->vma
3343 + sec->output_offset);
3344 }
3345 }
3346 else if (h->root.root.type == bfd_link_hash_undefweak)
3347 relocation = 0;
671bae9c
NC		 3348 else if (info->shared
3349 && (!info->symbolic || info->allow_shlib_undefined)
3a27a730 3350 && !info->no_undefined
edb72b3b 3351 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
252b5132
RH		 3352 relocation = 0;
3353 else
3354 {
3355 if (!((*info->callbacks->undefined_symbol)
3356 (info, h->root.root.root.string, input_bfd,
5cc7c785 3357 input_section, rel->r_offset,
3a27a730 3358 (!info->shared || info->no_undefined
edb72b3b 3359 || ELF_ST_VISIBILITY (h->root.other)))))
f16fbd61 3360 ret_val = false;
252b5132
RH		 3361 relocation = 0;
3362 }
3363 }
3364 addend = rel->r_addend;
3365
3366 switch (r_type)
3367 {
3368 case R_ALPHA_GPDISP:
3369 {
3370 bfd_byte *p_ldah, *p_lda;
3371
3372 BFD_ASSERT(gp != 0);
3373
3374 relocation = (input_section->output_section->vma
3375 + input_section->output_offset
3376 + rel->r_offset);
3377
3378 p_ldah = contents + rel->r_offset - input_section->vma;
3379 p_lda = p_ldah + rel->r_addend;
3380
3381 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3382 p_ldah, p_lda);
3383 }
3384 break;
3385
252b5132
RH		 3386 case R_ALPHA_LITERAL:
3387 {
3388 struct alpha_elf_got_entry *gotent;
3389 boolean dynamic_symbol;
3390
3391 BFD_ASSERT(sgot != NULL);
3392 BFD_ASSERT(gp != 0);
3393
3394 if (h != NULL)
3395 {
3396 gotent = h->got_entries;
3397 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3398 }
3399 else
3400 {
3401 gotent = (alpha_elf_tdata(input_bfd)->
3402 local_got_entries[r_symndx]);
3403 dynamic_symbol = false;
f7460f5f
JJ		 3404
3405 /* Need to adjust local GOT entries' addends for SEC_MERGE
3406 unless it has been done already. */
3407 if ((sec->flags & SEC_MERGE)
3408 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3409 && elf_section_data (sec)->merge_info
3410 && (gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED) == 0)
3411 {
3412 struct alpha_elf_got_entry *ent;
3413 asection *msec;
3414
3415 for (ent = gotent; ent; ent = ent->next)
3416 {
3417 ent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED;
3418 if (ent->use_count == 0)
3419 continue;
3420 msec = sec;
3421 ent->addend =
3422 _bfd_merged_section_offset (output_bfd, &msec,
3423 elf_section_data (sec)->
3424 merge_info,
3425 sym->st_value
3426 + ent->addend,
3427 (bfd_vma) 0);
3428 ent->addend -= sym->st_value;
3429 ent->addend += msec->output_section->vma
3430 + msec->output_offset
3431 - sec->output_section->vma
3432 - sec->output_offset;
3433 }
3434 }
252b5132
RH		 3435 }
3436
3437 BFD_ASSERT(gotent != NULL);
3438
3439 while (gotent->gotobj != gotobj || gotent->addend != addend)
3440 gotent = gotent->next;
3441
3442 BFD_ASSERT(gotent->use_count >= 1);
3443
3444 /* Initialize the .got entry's value. */
3445 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3446 {
dc810e39 3447 bfd_put_64 (output_bfd, relocation + addend,
252b5132
RH		 3448 sgot->contents + gotent->got_offset);
3449
3450 /* If the symbol has been forced local, output a
3451 RELATIVE reloc, otherwise it will be handled in
3452 finish_dynamic_symbol. */
3453 if (info->shared && !dynamic_symbol)
3454 {
3455 Elf_Internal_Rela outrel;
3456
3457 BFD_ASSERT(srelgot != NULL);
3458
3459 outrel.r_offset = (sgot->output_section->vma
3460 + sgot->output_offset
3461 + gotent->got_offset);
3462 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
dc810e39 3463 outrel.r_addend = relocation + addend;
252b5132
RH		 3464
3465 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3466 ((Elf64_External_Rela *)
3467 srelgot->contents)
3468 + srelgot->reloc_count++);
fe8bc63d 3469 BFD_ASSERT (sizeof (Elf64_External_Rela)
252b5132
RH		 3470 * srelgot->reloc_count
3471 <= srelgot->_cooked_size);
3472 }
3473
3474 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3475 }
3476
3477 /* Figure the gprel relocation. */
3478 addend = 0;
3479 relocation = (sgot->output_section->vma
3480 + sgot->output_offset
3481 + gotent->got_offset);
3482 relocation -= gp;
3483 }
3484 /* overflow handled by _bfd_final_link_relocate */
3485 goto default_reloc;
3486
dfe57ca0 3487 case R_ALPHA_GPREL16:
252b5132
RH		 3488 case R_ALPHA_GPREL32:
3489 case R_ALPHA_GPRELLOW:
f16fbd61
RH		 3490 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3491 {
3492 (*_bfd_error_handler)
3493 (_("%s: gp-relative relocation against dynamic symbol %s"),
8f615d07 3494 bfd_archive_filename (input_bfd), h->root.root.root.string);
f16fbd61
RH		 3495 ret_val = false;
3496 }
252b5132
RH		 3497 BFD_ASSERT(gp != 0);
3498 relocation -= gp;
3499 goto default_reloc;
3500
3501 case R_ALPHA_GPRELHIGH:
f16fbd61
RH		 3502 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3503 {
3504 (*_bfd_error_handler)
3505 (_("%s: gp-relative relocation against dynamic symbol %s"),
8f615d07 3506 bfd_archive_filename (input_bfd), h->root.root.root.string);
f16fbd61
RH		 3507 ret_val = false;
3508 }
252b5132
RH		 3509 BFD_ASSERT(gp != 0);
3510 relocation -= gp;
3511 relocation += addend;
3512 addend = 0;
3513 relocation = (((bfd_signed_vma) relocation >> 16)
3514 + ((relocation >> 15) & 1));
3515 goto default_reloc;
3516
252b5132 3517 case R_ALPHA_HINT:
f94952df
RH		 3518 /* A call to a dynamic symbol is definitely out of range of
3519 the 16-bit displacement. Don't bother writing anything. */
3520 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3521 {
3522 r = bfd_reloc_ok;
3523 break;
3524 }
3525 /* FALLTHRU */
3526
3527 case R_ALPHA_BRADDR:
252b5132
RH		 3528 /* The regular PC-relative stuff measures from the start of
3529 the instruction rather than the end. */
3530 addend -= 4;
3531 goto default_reloc;
3532
3533 case R_ALPHA_REFLONG:
3534 case R_ALPHA_REFQUAD:
3535 {
3536 Elf_Internal_Rela outrel;
3537 boolean skip;
3538
3539 /* Careful here to remember RELATIVE relocations for global
3540 variables for symbolic shared objects. */
3541
3542 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3543 {
3544 BFD_ASSERT(h->root.dynindx != -1);
3545 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3546 outrel.r_addend = addend;
3547 addend = 0, relocation = 0;
3548 }
ec338859
AM		 3549 else if (info->shared
3550 && r_symndx != 0
3551 && (input_section->flags & SEC_ALLOC))
252b5132
RH		 3552 {
3553 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
28cfee26 3554 outrel.r_addend = relocation + addend;
252b5132
RH		 3555 }
3556 else
3557 goto default_reloc;
3558
3559 if (!srel)
3560 {
3561 const char *name;
3562
3563 name = (bfd_elf_string_from_elf_section
3564 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3565 elf_section_data(input_section)->rel_hdr.sh_name));
3566 BFD_ASSERT(name != NULL);
3567
3568 srel = bfd_get_section_by_name (dynobj, name);
3569 BFD_ASSERT(srel != NULL);
3570 }
3571
3572 skip = false;
3573
3574 if (elf_section_data (input_section)->stab_info == NULL)
3575 outrel.r_offset = rel->r_offset;
3576 else
3577 {
3578 bfd_vma off;
3579
3580 off = (_bfd_stab_section_offset
3581 (output_bfd, &elf_hash_table (info)->stab_info,
3582 input_section,
3583 &elf_section_data (input_section)->stab_info,
3584 rel->r_offset));
3585 if (off == (bfd_vma) -1)
3586 skip = true;
3587 outrel.r_offset = off;
3588 }
3589
3590 if (! skip)
3591 outrel.r_offset += (input_section->output_section->vma
3592 + input_section->output_offset);
3593 else
3594 memset (&outrel, 0, sizeof outrel);
3595
3596 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3597 ((Elf64_External_Rela *)
3598 srel->contents)
3599 + srel->reloc_count++);
fe8bc63d 3600 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 3601 <= srel->_cooked_size);
3602 }
3603 goto default_reloc;
3604
3605 default:
3606 default_reloc:
3607 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3608 contents, rel->r_offset, relocation,
3609 addend);
3610 break;
3611 }
3612
3613 switch (r)
3614 {
3615 case bfd_reloc_ok:
3616 break;
3617
3618 case bfd_reloc_overflow:
3619 {
3620 const char *name;
3621
3622 if (h != NULL)
3623 name = h->root.root.root.string;
3624 else
3625 {
3626 name = (bfd_elf_string_from_elf_section
3627 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3628 if (name == NULL)
3629 return false;
3630 if (*name == '\0')
3631 name = bfd_section_name (input_bfd, sec);
3632 }
3633 if (! ((*info->callbacks->reloc_overflow)
3634 (info, name, howto->name, (bfd_vma) 0,
3635 input_bfd, input_section, rel->r_offset)))
f16fbd61 3636 ret_val = false;
252b5132
RH		 3637 }
3638 break;
3639
3640 default:
3641 case bfd_reloc_outofrange:
3642 abort ();
3643 }
3644 }
3645
f16fbd61 3646 return ret_val;
252b5132
RH		 3647}
3648
3649/* Finish up dynamic symbol handling. We set the contents of various
3650 dynamic sections here. */
3651
3652static boolean
3653elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3654 bfd *output_bfd;
3655 struct bfd_link_info *info;
3656 struct elf_link_hash_entry *h;
3657 Elf_Internal_Sym *sym;
3658{
3659 bfd *dynobj = elf_hash_table(info)->dynobj;
3660
3661 if (h->plt.offset != MINUS_ONE)
3662 {
3663 /* Fill in the .plt entry for this symbol. */
3664 asection *splt, *sgot, *srel;
3665 Elf_Internal_Rela outrel;
3666 bfd_vma got_addr, plt_addr;
3667 bfd_vma plt_index;
3668 struct alpha_elf_got_entry *gotent;
3669
3670 BFD_ASSERT (h->dynindx != -1);
3671
3672 /* The first .got entry will be updated by the .plt with the
3673 address of the target function. */
3674 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3675 BFD_ASSERT (gotent && gotent->addend == 0);
3676
3677 splt = bfd_get_section_by_name (dynobj, ".plt");
3678 BFD_ASSERT (splt != NULL);
3679 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3680 BFD_ASSERT (srel != NULL);
3681 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3682 BFD_ASSERT (sgot != NULL);
3683
3684 got_addr = (sgot->output_section->vma
3685 + sgot->output_offset
3686 + gotent->got_offset);
3687 plt_addr = (splt->output_section->vma
3688 + splt->output_offset
3689 + h->plt.offset);
3690
3691 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3692
3693 /* Fill in the entry in the procedure linkage table. */
3694 {
dc810e39 3695 bfd_vma insn1, insn2, insn3;
252b5132
RH		 3696
3697 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3698 insn2 = PLT_ENTRY_WORD2;
3699 insn3 = PLT_ENTRY_WORD3;
3700
3701 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3702 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3703 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3704 }
3705
3706 /* Fill in the entry in the .rela.plt section. */
3707 outrel.r_offset = got_addr;
3708 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3709 outrel.r_addend = 0;
3710
3711 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3712 ((Elf64_External_Rela *)srel->contents
3713 + plt_index));
3714
3715 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3716 {
3717 /* Mark the symbol as undefined, rather than as defined in the
3718 .plt section. Leave the value alone. */
3719 sym->st_shndx = SHN_UNDEF;
3720 }
3721
3722 /* Fill in the entries in the .got. */
3723 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3724
3725 /* Subsequent .got entries will continue to bounce through the .plt. */
3726 if (gotent->next)
3727 {
3728 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3729 BFD_ASSERT (! info->shared || srel != NULL);
3730
3731 gotent = gotent->next;
3732 do
3733 {
3734 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3735 BFD_ASSERT(sgot != NULL);
3736 BFD_ASSERT(gotent->addend == 0);
3737
3738 bfd_put_64 (output_bfd, plt_addr,
3739 sgot->contents + gotent->got_offset);
3740
3741 if (info->shared)
3742 {
3743 outrel.r_offset = (sgot->output_section->vma
3744 + sgot->output_offset
3745 + gotent->got_offset);
3746 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
28cfee26 3747 outrel.r_addend = plt_addr;
252b5132
RH		 3748
3749 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3750 ((Elf64_External_Rela *)
3751 srel->contents)
3752 + srel->reloc_count++);
fe8bc63d 3753 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 3754 <= srel->_cooked_size);
3755 }
3756
3757 gotent = gotent->next;
3758 }
3759 while (gotent != NULL);
3760 }
3761 }
3762 else if (alpha_elf_dynamic_symbol_p (h, info))
3763 {
3764 /* Fill in the dynamic relocations for this symbol's .got entries. */
3765 asection *srel;
3766 Elf_Internal_Rela outrel;
3767 struct alpha_elf_got_entry *gotent;
3768
3769 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3770 BFD_ASSERT (srel != NULL);
3771
3772 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3773 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3774 gotent != NULL;
3775 gotent = gotent->next)
3776 {
3777 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3778 outrel.r_offset = (sgot->output_section->vma
3779 + sgot->output_offset
3780 + gotent->got_offset);
3781 outrel.r_addend = gotent->addend;
3782
3783 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3784 ((Elf64_External_Rela *)srel->contents
3785 + srel->reloc_count++));
fe8bc63d 3786 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 3787 <= srel->_cooked_size);
3788 }
3789 }
3790
3791 /* Mark some specially defined symbols as absolute. */
3792 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3793 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3794 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3795 sym->st_shndx = SHN_ABS;
3796
3797 return true;
3798}
3799
3800/* Finish up the dynamic sections. */
3801
3802static boolean
3803elf64_alpha_finish_dynamic_sections (output_bfd, info)
3804 bfd *output_bfd;
3805 struct bfd_link_info *info;
3806{
3807 bfd *dynobj;
3808 asection *sdyn;
3809
3810 dynobj = elf_hash_table (info)->dynobj;
3811 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3812
3813 if (elf_hash_table (info)->dynamic_sections_created)
3814 {
3815 asection *splt;
3816 Elf64_External_Dyn *dyncon, *dynconend;
3817
3818 splt = bfd_get_section_by_name (dynobj, ".plt");
3819 BFD_ASSERT (splt != NULL && sdyn != NULL);
3820
3821 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3822 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3823 for (; dyncon < dynconend; dyncon++)
3824 {
3825 Elf_Internal_Dyn dyn;
3826 const char *name;
3827 asection *s;
3828
3829 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3830
3831 switch (dyn.d_tag)
3832 {
3833 case DT_PLTGOT:
3834 name = ".plt";
3835 goto get_vma;
3836 case DT_PLTRELSZ:
3837 name = ".rela.plt";
3838 goto get_size;
3839 case DT_JMPREL:
3840 name = ".rela.plt";
3841 goto get_vma;
3842
3843 case DT_RELASZ:
3844 /* My interpretation of the TIS v1.1 ELF document indicates
3845 that RELASZ should not include JMPREL. This is not what
3846 the rest of the BFD does. It is, however, what the
3847 glibc ld.so wants. Do this fixup here until we found
3848 out who is right. */
3849 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3850 if (s)
3851 {
3852 dyn.d_un.d_val -=
3853 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3854 }
3855 break;
3856
3857 get_vma:
3858 s = bfd_get_section_by_name (output_bfd, name);
3859 dyn.d_un.d_ptr = (s ? s->vma : 0);
3860 break;
3861
3862 get_size:
3863 s = bfd_get_section_by_name (output_bfd, name);
3864 dyn.d_un.d_val =
3865 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3866 break;
3867 }
3868
3869 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3870 }
3871
3872 /* Initialize the PLT0 entry */
3873 if (splt->_raw_size > 0)
3874 {
3875 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3876 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3877 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3878 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3879
3880 /* The next two words will be filled in by ld.so */
dc810e39
AM		 3881 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
3882 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
252b5132
RH		 3883
3884 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3885 PLT_HEADER_SIZE;
3886 }
3887 }
3888
252b5132
RH		 3889 return true;
3890}
3891
96e2734b
RH		 3892/* We need to use a special link routine to handle the .mdebug section.
3893 We need to merge all instances of these sections together, not write
3894 them all out sequentially. */
252b5132
RH		 3895
3896static boolean
3897elf64_alpha_final_link (abfd, info)
3898 bfd *abfd;
3899 struct bfd_link_info *info;
3900{
3901 asection *o;
3902 struct bfd_link_order *p;
96e2734b 3903 asection *mdebug_sec;
252b5132
RH		 3904 struct ecoff_debug_info debug;
3905 const struct ecoff_debug_swap *swap
3906 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3907 HDRR *symhdr = &debug.symbolic_header;
3908 PTR mdebug_handle = NULL;
3909
96e2734b 3910 /* Go through the sections and collect the mdebug information. */
252b5132 3911 mdebug_sec = NULL;
252b5132
RH		 3912 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3913 {
252b5132
RH		 3914 if (strcmp (o->name, ".mdebug") == 0)
3915 {
3916 struct extsym_info einfo;
3917
3918 /* We have found the .mdebug section in the output file.
3919 Look through all the link_orders comprising it and merge
3920 the information together. */
3921 symhdr->magic = swap->sym_magic;
3922 /* FIXME: What should the version stamp be? */
3923 symhdr->vstamp = 0;
3924 symhdr->ilineMax = 0;
3925 symhdr->cbLine = 0;
3926 symhdr->idnMax = 0;
3927 symhdr->ipdMax = 0;
3928 symhdr->isymMax = 0;
3929 symhdr->ioptMax = 0;
3930 symhdr->iauxMax = 0;
3931 symhdr->issMax = 0;
3932 symhdr->issExtMax = 0;
3933 symhdr->ifdMax = 0;
3934 symhdr->crfd = 0;
3935 symhdr->iextMax = 0;
3936
3937 /* We accumulate the debugging information itself in the
3938 debug_info structure. */
3939 debug.line = NULL;
3940 debug.external_dnr = NULL;
3941 debug.external_pdr = NULL;
3942 debug.external_sym = NULL;
3943 debug.external_opt = NULL;
3944 debug.external_aux = NULL;
3945 debug.ss = NULL;
3946 debug.ssext = debug.ssext_end = NULL;
3947 debug.external_fdr = NULL;
3948 debug.external_rfd = NULL;
3949 debug.external_ext = debug.external_ext_end = NULL;
3950
3951 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
3952 if (mdebug_handle == (PTR) NULL)
3953 return false;
3954
3955 if (1)
3956 {
3957 asection *s;
3958 EXTR esym;
52b9d213 3959 bfd_vma last = 0;
252b5132
RH		 3960 unsigned int i;
3961 static const char * const name[] =
3962 {
3963 ".text", ".init", ".fini", ".data",
3964 ".rodata", ".sdata", ".sbss", ".bss"
3965 };
3966 static const int sc[] = { scText, scInit, scFini, scData,
3967 scRData, scSData, scSBss, scBss };
3968
3969 esym.jmptbl = 0;
3970 esym.cobol_main = 0;
3971 esym.weakext = 0;
3972 esym.reserved = 0;
3973 esym.ifd = ifdNil;
3974 esym.asym.iss = issNil;
3975 esym.asym.st = stLocal;
3976 esym.asym.reserved = 0;
3977 esym.asym.index = indexNil;
3978 for (i = 0; i < 8; i++)
3979 {
3980 esym.asym.sc = sc[i];
3981 s = bfd_get_section_by_name (abfd, name[i]);
3982 if (s != NULL)
3983 {
3984 esym.asym.value = s->vma;
3985 last = s->vma + s->_raw_size;
3986 }
3987 else
3988 esym.asym.value = last;
3989
3990 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
3991 name[i], &esym))
3992 return false;
3993 }
3994 }
3995
3996 for (p = o->link_order_head;
3997 p != (struct bfd_link_order *) NULL;
3998 p = p->next)
3999 {
4000 asection *input_section;
4001 bfd *input_bfd;
4002 const struct ecoff_debug_swap *input_swap;
4003 struct ecoff_debug_info input_debug;
4004 char *eraw_src;
4005 char *eraw_end;
4006
4007 if (p->type != bfd_indirect_link_order)
4008 {
4009 if (p->type == bfd_fill_link_order)
4010 continue;
4011 abort ();
4012 }
4013
4014 input_section = p->u.indirect.section;
4015 input_bfd = input_section->owner;
4016
4017 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4018 || (get_elf_backend_data (input_bfd)
4019 ->elf_backend_ecoff_debug_swap) == NULL)
4020 {
4021 /* I don't know what a non ALPHA ELF bfd would be
4022 doing with a .mdebug section, but I don't really
4023 want to deal with it. */
4024 continue;
4025 }
4026
4027 input_swap = (get_elf_backend_data (input_bfd)
4028 ->elf_backend_ecoff_debug_swap);
4029
4030 BFD_ASSERT (p->size == input_section->_raw_size);
4031
4032 /* The ECOFF linking code expects that we have already
4033 read in the debugging information and set up an
4034 ecoff_debug_info structure, so we do that now. */
4035 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4036 &input_debug))
4037 return false;
4038
4039 if (! (bfd_ecoff_debug_accumulate
4040 (mdebug_handle, abfd, &debug, swap, input_bfd,
4041 &input_debug, input_swap, info)))
4042 return false;
4043
4044 /* Loop through the external symbols. For each one with
4045 interesting information, try to find the symbol in
4046 the linker global hash table and save the information
4047 for the output external symbols. */
4048 eraw_src = input_debug.external_ext;
4049 eraw_end = (eraw_src
4050 + (input_debug.symbolic_header.iextMax
4051 * input_swap->external_ext_size));
4052 for (;
4053 eraw_src < eraw_end;
4054 eraw_src += input_swap->external_ext_size)
4055 {
4056 EXTR ext;
4057 const char *name;
4058 struct alpha_elf_link_hash_entry *h;
4059
4060 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4061 if (ext.asym.sc == scNil
4062 || ext.asym.sc == scUndefined
4063 || ext.asym.sc == scSUndefined)
4064 continue;
4065
4066 name = input_debug.ssext + ext.asym.iss;
4067 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4068 name, false, false, true);
4069 if (h == NULL || h->esym.ifd != -2)
4070 continue;
4071
4072 if (ext.ifd != -1)
4073 {
4074 BFD_ASSERT (ext.ifd
4075 < input_debug.symbolic_header.ifdMax);
4076 ext.ifd = input_debug.ifdmap[ext.ifd];
4077 }
4078
4079 h->esym = ext;
4080 }
4081
4082 /* Free up the information we just read. */
4083 free (input_debug.line);
4084 free (input_debug.external_dnr);
4085 free (input_debug.external_pdr);
4086 free (input_debug.external_sym);
4087 free (input_debug.external_opt);
4088 free (input_debug.external_aux);
4089 free (input_debug.ss);
4090 free (input_debug.ssext);
4091 free (input_debug.external_fdr);
4092 free (input_debug.external_rfd);
4093 free (input_debug.external_ext);
4094
4095 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4096 elf_link_input_bfd ignores this section. */
4097 input_section->flags &=~ SEC_HAS_CONTENTS;
4098 }
4099
252b5132
RH		 4100 /* Build the external symbol information. */
4101 einfo.abfd = abfd;
4102 einfo.info = info;
4103 einfo.debug = &debug;
4104 einfo.swap = swap;
4105 einfo.failed = false;
4106 elf_link_hash_traverse (elf_hash_table (info),
4107 elf64_alpha_output_extsym,
4108 (PTR) &einfo);
4109 if (einfo.failed)
4110 return false;
4111
4112 /* Set the size of the .mdebug section. */
4113 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4114
4115 /* Skip this section later on (I don't think this currently
4116 matters, but someday it might). */
4117 o->link_order_head = (struct bfd_link_order *) NULL;
4118
4119 mdebug_sec = o;
4120 }
252b5132
RH		 4121 }
4122
4123 /* Invoke the regular ELF backend linker to do all the work. */
4124 if (! bfd_elf64_bfd_final_link (abfd, info))
4125 return false;
4126
4127 /* Now write out the computed sections. */
4128
4129 /* The .got subsections... */
4130 {
4131 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4132 for (i = alpha_elf_hash_table(info)->got_list;
4133 i != NULL;
4134 i = alpha_elf_tdata(i)->got_link_next)
4135 {
4136 asection *sgot;
4137
4138 /* elf_bfd_final_link already did everything in dynobj. */
4139 if (i == dynobj)
4140 continue;
4141
4142 sgot = alpha_elf_tdata(i)->got;
4143 if (! bfd_set_section_contents (abfd, sgot->output_section,
dc810e39
AM		 4144 sgot->contents,
4145 (file_ptr) sgot->output_offset,
252b5132
RH		 4146 sgot->_raw_size))
4147 return false;
4148 }
4149 }
4150
252b5132
RH		 4151 if (mdebug_sec != (asection *) NULL)
4152 {
4153 BFD_ASSERT (abfd->output_has_begun);
4154 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4155 swap, info,
4156 mdebug_sec->filepos))
4157 return false;
4158
4159 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4160 }
4161
252b5132
RH		 4162 return true;
4163}
fcfbdf31
JJ		 4164
4165static enum elf_reloc_type_class
f51e552e
AM		 4166elf64_alpha_reloc_type_class (rela)
4167 const Elf_Internal_Rela *rela;
fcfbdf31 4168{
f51e552e 4169 switch ((int) ELF64_R_TYPE (rela->r_info))
fcfbdf31
JJ		 4170 {
4171 case R_ALPHA_RELATIVE:
4172 return reloc_class_relative;
4173 case R_ALPHA_JMP_SLOT:
4174 return reloc_class_plt;
4175 case R_ALPHA_COPY:
4176 return reloc_class_copy;
4177 default:
4178 return reloc_class_normal;
4179 }
4180}
252b5132
RH		 4181\f
4182/* ECOFF swapping routines. These are used when dealing with the
4183 .mdebug section, which is in the ECOFF debugging format. Copied
fe8bc63d 4184 from elf32-mips.c. */
252b5132
RH		 4185static const struct ecoff_debug_swap
4186elf64_alpha_ecoff_debug_swap =
4187{
4188 /* Symbol table magic number. */
4189 magicSym2,
4190 /* Alignment of debugging information. E.g., 4. */
4191 8,
4192 /* Sizes of external symbolic information. */
4193 sizeof (struct hdr_ext),
4194 sizeof (struct dnr_ext),
4195 sizeof (struct pdr_ext),
4196 sizeof (struct sym_ext),
4197 sizeof (struct opt_ext),
4198 sizeof (struct fdr_ext),
4199 sizeof (struct rfd_ext),
4200 sizeof (struct ext_ext),
4201 /* Functions to swap in external symbolic data. */
4202 ecoff_swap_hdr_in,
4203 ecoff_swap_dnr_in,
4204 ecoff_swap_pdr_in,
4205 ecoff_swap_sym_in,
4206 ecoff_swap_opt_in,
4207 ecoff_swap_fdr_in,
4208 ecoff_swap_rfd_in,
4209 ecoff_swap_ext_in,
4210 _bfd_ecoff_swap_tir_in,
4211 _bfd_ecoff_swap_rndx_in,
4212 /* Functions to swap out external symbolic data. */
4213 ecoff_swap_hdr_out,
4214 ecoff_swap_dnr_out,
4215 ecoff_swap_pdr_out,
4216 ecoff_swap_sym_out,
4217 ecoff_swap_opt_out,
4218 ecoff_swap_fdr_out,
4219 ecoff_swap_rfd_out,
4220 ecoff_swap_ext_out,
4221 _bfd_ecoff_swap_tir_out,
4222 _bfd_ecoff_swap_rndx_out,
4223 /* Function to read in symbolic data. */
4224 elf64_alpha_read_ecoff_info
4225};
4226\f
70bcb145
JW		 4227/* Use a non-standard hash bucket size of 8. */
4228
4229const struct elf_size_info alpha_elf_size_info =
4230{
4231 sizeof (Elf64_External_Ehdr),
4232 sizeof (Elf64_External_Phdr),
4233 sizeof (Elf64_External_Shdr),
4234 sizeof (Elf64_External_Rel),
4235 sizeof (Elf64_External_Rela),
4236 sizeof (Elf64_External_Sym),
4237 sizeof (Elf64_External_Dyn),
4238 sizeof (Elf_External_Note),
4239 8,
4240 1,
4241 64, 8,
4242 ELFCLASS64, EV_CURRENT,
4243 bfd_elf64_write_out_phdrs,
4244 bfd_elf64_write_shdrs_and_ehdr,
4245 bfd_elf64_write_relocs,
4246 bfd_elf64_swap_symbol_out,
4247 bfd_elf64_slurp_reloc_table,
4248 bfd_elf64_slurp_symbol_table,
4249 bfd_elf64_swap_dyn_in,
4250 bfd_elf64_swap_dyn_out,
4251 NULL,
4252 NULL,
4253 NULL,
4254 NULL
4255};
4256
252b5132
RH		 4257#define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4258#define TARGET_LITTLE_NAME "elf64-alpha"
4259#define ELF_ARCH bfd_arch_alpha
56fc028e
AJ		 4260#define ELF_MACHINE_CODE EM_ALPHA
4261#define ELF_MAXPAGESIZE 0x10000
252b5132
RH		 4262
4263#define bfd_elf64_bfd_link_hash_table_create \
4264 elf64_alpha_bfd_link_hash_table_create
4265
4266#define bfd_elf64_bfd_reloc_type_lookup \
4267 elf64_alpha_bfd_reloc_type_lookup
4268#define elf_info_to_howto \
4269 elf64_alpha_info_to_howto
4270
4271#define bfd_elf64_mkobject \
4272 elf64_alpha_mkobject
4273#define elf_backend_object_p \
4274 elf64_alpha_object_p
4275
4276#define elf_backend_section_from_shdr \
4277 elf64_alpha_section_from_shdr
204692d7
RH		 4278#define elf_backend_section_flags \
4279 elf64_alpha_section_flags
252b5132
RH		 4280#define elf_backend_fake_sections \
4281 elf64_alpha_fake_sections
4282
4283#define bfd_elf64_bfd_is_local_label_name \
4284 elf64_alpha_is_local_label_name
4285#define bfd_elf64_find_nearest_line \
4286 elf64_alpha_find_nearest_line
4287#define bfd_elf64_bfd_relax_section \
4288 elf64_alpha_relax_section
4289
4290#define elf_backend_add_symbol_hook \
4291 elf64_alpha_add_symbol_hook
4292#define elf_backend_check_relocs \
4293 elf64_alpha_check_relocs
4294#define elf_backend_create_dynamic_sections \
4295 elf64_alpha_create_dynamic_sections
4296#define elf_backend_adjust_dynamic_symbol \
4297 elf64_alpha_adjust_dynamic_symbol
4298#define elf_backend_always_size_sections \
4299 elf64_alpha_always_size_sections
4300#define elf_backend_size_dynamic_sections \
4301 elf64_alpha_size_dynamic_sections
4302#define elf_backend_relocate_section \
4303 elf64_alpha_relocate_section
4304#define elf_backend_finish_dynamic_symbol \
4305 elf64_alpha_finish_dynamic_symbol
4306#define elf_backend_finish_dynamic_sections \
4307 elf64_alpha_finish_dynamic_sections
4308#define bfd_elf64_bfd_final_link \
4309 elf64_alpha_final_link
fcfbdf31
JJ		 4310#define elf_backend_reloc_type_class \
4311 elf64_alpha_reloc_type_class
252b5132
RH		 4312
4313#define elf_backend_ecoff_debug_swap \
4314 &elf64_alpha_ecoff_debug_swap
4315
70bcb145
JW		 4316#define elf_backend_size_info \
4317 alpha_elf_size_info
4318
38b1a46c 4319/* A few constants that determine how the .plt section is set up. */
252b5132
RH		 4320#define elf_backend_want_got_plt 0
4321#define elf_backend_plt_readonly 0
4322#define elf_backend_want_plt_sym 1
4323#define elf_backend_got_header_size 0
4324#define elf_backend_plt_header_size PLT_HEADER_SIZE
4325
4326#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.481911 seconds and 4 git commands to generate.