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