projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Support arbitrary length fill patterns.
[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
dc810e39 327 ret = (struct alpha_elf_link_hash_table *) bfd_zalloc (abfd, amt);
252b5132
RH		 328 if (ret == (struct alpha_elf_link_hash_table *) NULL)
329 return NULL;
330
331 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
332 elf64_alpha_link_hash_newfunc))
333 {
334 bfd_release (abfd, ret);
335 return NULL;
336 }
337
338 return &ret->root.root;
339}
340\f
341/* We have some private fields hanging off of the elf_tdata structure. */
342
343struct alpha_elf_obj_tdata
344{
345 struct elf_obj_tdata root;
346
347 /* For every input file, these are the got entries for that object's
348 local symbols. */
349 struct alpha_elf_got_entry ** local_got_entries;
350
351 /* For every input file, this is the object that owns the got that
352 this input file uses. */
353 bfd *gotobj;
354
355 /* For every got, this is a linked list through the objects using this got */
356 bfd *in_got_link_next;
357
358 /* For every got, this is a link to the next got subsegment. */
359 bfd *got_link_next;
360
361 /* For every got, this is the section. */
362 asection *got;
363
364 /* For every got, this is it's total number of *entries*. */
365 int total_got_entries;
366
367 /* For every got, this is the sum of the number of *entries* required
368 to hold all of the member object's local got. */
369 int n_local_got_entries;
370};
371
372#define alpha_elf_tdata(abfd) \
373 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
374
375static boolean
376elf64_alpha_mkobject (abfd)
377 bfd *abfd;
378{
dc810e39
AM		 379 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
380 abfd->tdata.any = bfd_zalloc (abfd, amt);
252b5132
RH		 381 if (abfd->tdata.any == NULL)
382 return false;
383 return true;
384}
385
386static boolean
387elf64_alpha_object_p (abfd)
388 bfd *abfd;
389{
390 /* Allocate our special target data. */
391 struct alpha_elf_obj_tdata *new_tdata;
dc810e39
AM		 392 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
393 new_tdata = bfd_zalloc (abfd, amt);
252b5132
RH		 394 if (new_tdata == NULL)
395 return false;
396 new_tdata->root = *abfd->tdata.elf_obj_data;
397 abfd->tdata.any = new_tdata;
398
399 /* Set the right machine number for an Alpha ELF file. */
400 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
401}
402\f
403/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
404 from smaller values. Start with zero, widen, *then* decrement. */
405#define MINUS_ONE (((bfd_vma)0) - 1)
406
dfe57ca0
RH		 407#define SKIP_HOWTO(N) \
408 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
409
252b5132
RH		 410static reloc_howto_type elf64_alpha_howto_table[] =
411{
412 HOWTO (R_ALPHA_NONE, /* type */
413 0, /* rightshift */
414 0, /* size (0 = byte, 1 = short, 2 = long) */
415 8, /* bitsize */
416 true, /* pc_relative */
417 0, /* bitpos */
418 complain_overflow_dont, /* complain_on_overflow */
419 elf64_alpha_reloc_nil, /* special_function */
420 "NONE", /* name */
421 false, /* partial_inplace */
422 0, /* src_mask */
423 0, /* dst_mask */
424 true), /* pcrel_offset */
425
426 /* A 32 bit reference to a symbol. */
427 HOWTO (R_ALPHA_REFLONG, /* type */
428 0, /* rightshift */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
430 32, /* bitsize */
431 false, /* pc_relative */
432 0, /* bitpos */
433 complain_overflow_bitfield, /* complain_on_overflow */
434 0, /* special_function */
435 "REFLONG", /* name */
436 false, /* partial_inplace */
437 0xffffffff, /* src_mask */
438 0xffffffff, /* dst_mask */
439 false), /* pcrel_offset */
440
441 /* A 64 bit reference to a symbol. */
442 HOWTO (R_ALPHA_REFQUAD, /* type */
443 0, /* rightshift */
444 4, /* size (0 = byte, 1 = short, 2 = long) */
445 64, /* bitsize */
446 false, /* pc_relative */
447 0, /* bitpos */
448 complain_overflow_bitfield, /* complain_on_overflow */
449 0, /* special_function */
450 "REFQUAD", /* name */
451 false, /* partial_inplace */
452 MINUS_ONE, /* src_mask */
453 MINUS_ONE, /* dst_mask */
454 false), /* pcrel_offset */
455
456 /* A 32 bit GP relative offset. This is just like REFLONG except
457 that when the value is used the value of the gp register will be
458 added in. */
459 HOWTO (R_ALPHA_GPREL32, /* type */
460 0, /* rightshift */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
462 32, /* bitsize */
463 false, /* pc_relative */
464 0, /* bitpos */
465 complain_overflow_bitfield, /* complain_on_overflow */
466 0, /* special_function */
467 "GPREL32", /* name */
468 false, /* partial_inplace */
469 0xffffffff, /* src_mask */
470 0xffffffff, /* dst_mask */
471 false), /* pcrel_offset */
472
473 /* Used for an instruction that refers to memory off the GP register. */
474 HOWTO (R_ALPHA_LITERAL, /* type */
475 0, /* rightshift */
dfe57ca0 476 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 477 16, /* bitsize */
478 false, /* pc_relative */
479 0, /* bitpos */
480 complain_overflow_signed, /* complain_on_overflow */
481 0, /* special_function */
482 "ELF_LITERAL", /* name */
483 false, /* partial_inplace */
484 0xffff, /* src_mask */
485 0xffff, /* dst_mask */
486 false), /* pcrel_offset */
487
488 /* This reloc only appears immediately following an ELF_LITERAL reloc.
489 It identifies a use of the literal. The symbol index is special:
490 1 means the literal address is in the base register of a memory
491 format instruction; 2 means the literal address is in the byte
492 offset register of a byte-manipulation instruction; 3 means the
493 literal address is in the target register of a jsr instruction.
494 This does not actually do any relocation. */
495 HOWTO (R_ALPHA_LITUSE, /* type */
496 0, /* rightshift */
dfe57ca0 497 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 498 32, /* bitsize */
499 false, /* pc_relative */
500 0, /* bitpos */
501 complain_overflow_dont, /* complain_on_overflow */
502 elf64_alpha_reloc_nil, /* special_function */
503 "LITUSE", /* name */
504 false, /* partial_inplace */
505 0, /* src_mask */
506 0, /* dst_mask */
507 false), /* pcrel_offset */
508
509 /* Load the gp register. This is always used for a ldah instruction
510 which loads the upper 16 bits of the gp register. The symbol
511 index of the GPDISP instruction is an offset in bytes to the lda
512 instruction that loads the lower 16 bits. The value to use for
513 the relocation is the difference between the GP value and the
514 current location; the load will always be done against a register
515 holding the current address.
516
517 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
518 any offset is present in the instructions, it is an offset from
519 the register to the ldah instruction. This lets us avoid any
520 stupid hackery like inventing a gp value to do partial relocation
521 against. Also unlike ECOFF, we do the whole relocation off of
522 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
523 space consuming bit, that, since all the information was present
524 in the GPDISP_HI16 reloc. */
525 HOWTO (R_ALPHA_GPDISP, /* type */
526 16, /* rightshift */
527 2, /* size (0 = byte, 1 = short, 2 = long) */
528 16, /* bitsize */
529 false, /* pc_relative */
530 0, /* bitpos */
531 complain_overflow_dont, /* complain_on_overflow */
532 elf64_alpha_reloc_gpdisp, /* special_function */
533 "GPDISP", /* name */
534 false, /* partial_inplace */
535 0xffff, /* src_mask */
536 0xffff, /* dst_mask */
537 true), /* pcrel_offset */
538
539 /* A 21 bit branch. */
540 HOWTO (R_ALPHA_BRADDR, /* type */
541 2, /* rightshift */
542 2, /* size (0 = byte, 1 = short, 2 = long) */
543 21, /* bitsize */
544 true, /* pc_relative */
545 0, /* bitpos */
546 complain_overflow_signed, /* complain_on_overflow */
547 0, /* special_function */
548 "BRADDR", /* name */
549 false, /* partial_inplace */
550 0x1fffff, /* src_mask */
551 0x1fffff, /* dst_mask */
552 true), /* pcrel_offset */
553
554 /* A hint for a jump to a register. */
555 HOWTO (R_ALPHA_HINT, /* type */
556 2, /* rightshift */
dfe57ca0 557 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 558 14, /* bitsize */
559 true, /* pc_relative */
560 0, /* bitpos */
561 complain_overflow_dont, /* complain_on_overflow */
562 0, /* special_function */
563 "HINT", /* name */
564 false, /* partial_inplace */
565 0x3fff, /* src_mask */
566 0x3fff, /* dst_mask */
567 true), /* pcrel_offset */
568
569 /* 16 bit PC relative offset. */
570 HOWTO (R_ALPHA_SREL16, /* type */
571 0, /* rightshift */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
573 16, /* bitsize */
574 true, /* pc_relative */
575 0, /* bitpos */
576 complain_overflow_signed, /* complain_on_overflow */
577 0, /* special_function */
578 "SREL16", /* name */
579 false, /* partial_inplace */
580 0xffff, /* src_mask */
581 0xffff, /* dst_mask */
16b65e4e 582 true), /* pcrel_offset */
252b5132
RH		 583
584 /* 32 bit PC relative offset. */
585 HOWTO (R_ALPHA_SREL32, /* type */
586 0, /* rightshift */
587 2, /* size (0 = byte, 1 = short, 2 = long) */
588 32, /* bitsize */
589 true, /* pc_relative */
590 0, /* bitpos */
591 complain_overflow_signed, /* complain_on_overflow */
592 0, /* special_function */
593 "SREL32", /* name */
594 false, /* partial_inplace */
595 0xffffffff, /* src_mask */
596 0xffffffff, /* dst_mask */
16b65e4e 597 true), /* pcrel_offset */
252b5132
RH		 598
599 /* A 64 bit PC relative offset. */
600 HOWTO (R_ALPHA_SREL64, /* type */
601 0, /* rightshift */
602 4, /* size (0 = byte, 1 = short, 2 = long) */
603 64, /* bitsize */
604 true, /* pc_relative */
605 0, /* bitpos */
606 complain_overflow_signed, /* complain_on_overflow */
607 0, /* special_function */
608 "SREL64", /* name */
609 false, /* partial_inplace */
610 MINUS_ONE, /* src_mask */
611 MINUS_ONE, /* dst_mask */
16b65e4e 612 true), /* pcrel_offset */
252b5132 613
dfe57ca0
RH		 614 /* Skip 12 - 16; deprecated ECOFF relocs. */
615 SKIP_HOWTO (12),
616 SKIP_HOWTO (13),
617 SKIP_HOWTO (14),
618 SKIP_HOWTO (15),
619 SKIP_HOWTO (16),
252b5132
RH		 620
621 /* The high 16 bits of the displacement from GP to the target. */
622 HOWTO (R_ALPHA_GPRELHIGH,
623 0, /* rightshift */
dfe57ca0 624 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 625 16, /* bitsize */
626 false, /* pc_relative */
627 0, /* bitpos */
628 complain_overflow_signed, /* complain_on_overflow */
dfe57ca0 629 0, /* special_function */
252b5132
RH		 630 "GPRELHIGH", /* name */
631 false, /* partial_inplace */
632 0xffff, /* src_mask */
633 0xffff, /* dst_mask */
634 false), /* pcrel_offset */
635
636 /* The low 16 bits of the displacement from GP to the target. */
637 HOWTO (R_ALPHA_GPRELLOW,
638 0, /* rightshift */
dfe57ca0 639 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 640 16, /* bitsize */
641 false, /* pc_relative */
642 0, /* bitpos */
643 complain_overflow_dont, /* complain_on_overflow */
dfe57ca0 644 0, /* special_function */
252b5132
RH		 645 "GPRELLOW", /* name */
646 false, /* partial_inplace */
647 0xffff, /* src_mask */
648 0xffff, /* dst_mask */
649 false), /* pcrel_offset */
650
651 /* A 16-bit displacement from the GP to the target. */
dfe57ca0 652 HOWTO (R_ALPHA_GPREL16,
252b5132 653 0, /* rightshift */
dfe57ca0 654 1, /* size (0 = byte, 1 = short, 2 = long) */
252b5132
RH		 655 16, /* bitsize */
656 false, /* pc_relative */
657 0, /* bitpos */
658 complain_overflow_signed, /* complain_on_overflow */
659 0, /* special_function */
dfe57ca0 660 "GPREL16", /* name */
252b5132
RH		 661 false, /* partial_inplace */
662 0xffff, /* src_mask */
663 0xffff, /* dst_mask */
664 false), /* pcrel_offset */
665
dfe57ca0
RH		 666 /* Skip 20 - 23; deprecated ECOFF relocs. */
667 SKIP_HOWTO (20),
668 SKIP_HOWTO (21),
669 SKIP_HOWTO (22),
670 SKIP_HOWTO (23),
252b5132 671
fe8bc63d 672 /* Misc ELF relocations. */
252b5132
RH		 673
674 /* A dynamic relocation to copy the target into our .dynbss section. */
675 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
676 is present because every other ELF has one, but should not be used
677 because .dynbss is an ugly thing. */
678 HOWTO (R_ALPHA_COPY,
679 0,
680 0,
681 0,
682 false,
683 0,
684 complain_overflow_dont,
685 bfd_elf_generic_reloc,
686 "COPY",
687 false,
688 0,
689 0,
690 true),
691
692 /* A dynamic relocation for a .got entry. */
693 HOWTO (R_ALPHA_GLOB_DAT,
694 0,
695 0,
696 0,
697 false,
698 0,
699 complain_overflow_dont,
700 bfd_elf_generic_reloc,
701 "GLOB_DAT",
702 false,
703 0,
704 0,
705 true),
706
707 /* A dynamic relocation for a .plt entry. */
708 HOWTO (R_ALPHA_JMP_SLOT,
709 0,
710 0,
711 0,
712 false,
713 0,
714 complain_overflow_dont,
715 bfd_elf_generic_reloc,
716 "JMP_SLOT",
717 false,
718 0,
719 0,
720 true),
721
722 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
723 HOWTO (R_ALPHA_RELATIVE,
724 0,
725 0,
726 0,
727 false,
728 0,
729 complain_overflow_dont,
730 bfd_elf_generic_reloc,
731 "RELATIVE",
732 false,
733 0,
734 0,
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
2123 if (h->root.indx == -2)
2124 strip = false;
2125 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2126 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2127 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2128 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2129 strip = true;
2130 else if (einfo->info->strip == strip_all
2131 || (einfo->info->strip == strip_some
2132 && bfd_hash_lookup (einfo->info->keep_hash,
2133 h->root.root.root.string,
2134 false, false) == NULL))
2135 strip = true;
2136 else
2137 strip = false;
2138
2139 if (strip)
2140 return true;
2141
2142 if (h->esym.ifd == -2)
2143 {
2144 h->esym.jmptbl = 0;
2145 h->esym.cobol_main = 0;
2146 h->esym.weakext = 0;
2147 h->esym.reserved = 0;
2148 h->esym.ifd = ifdNil;
2149 h->esym.asym.value = 0;
2150 h->esym.asym.st = stGlobal;
2151
2152 if (h->root.root.type != bfd_link_hash_defined
2153 && h->root.root.type != bfd_link_hash_defweak)
2154 h->esym.asym.sc = scAbs;
2155 else
2156 {
2157 const char *name;
2158
2159 sec = h->root.root.u.def.section;
2160 output_section = sec->output_section;
2161
2162 /* When making a shared library and symbol h is the one from
2163 the another shared library, OUTPUT_SECTION may be null. */
2164 if (output_section == NULL)
2165 h->esym.asym.sc = scUndefined;
2166 else
2167 {
2168 name = bfd_section_name (output_section->owner, output_section);
2169
2170 if (strcmp (name, ".text") == 0)
2171 h->esym.asym.sc = scText;
2172 else if (strcmp (name, ".data") == 0)
2173 h->esym.asym.sc = scData;
2174 else if (strcmp (name, ".sdata") == 0)
2175 h->esym.asym.sc = scSData;
2176 else if (strcmp (name, ".rodata") == 0
2177 || strcmp (name, ".rdata") == 0)
2178 h->esym.asym.sc = scRData;
2179 else if (strcmp (name, ".bss") == 0)
2180 h->esym.asym.sc = scBss;
2181 else if (strcmp (name, ".sbss") == 0)
2182 h->esym.asym.sc = scSBss;
2183 else if (strcmp (name, ".init") == 0)
2184 h->esym.asym.sc = scInit;
2185 else if (strcmp (name, ".fini") == 0)
2186 h->esym.asym.sc = scFini;
2187 else
2188 h->esym.asym.sc = scAbs;
2189 }
2190 }
2191
2192 h->esym.asym.reserved = 0;
2193 h->esym.asym.index = indexNil;
2194 }
2195
2196 if (h->root.root.type == bfd_link_hash_common)
2197 h->esym.asym.value = h->root.root.u.c.size;
2198 else if (h->root.root.type == bfd_link_hash_defined
2199 || h->root.root.type == bfd_link_hash_defweak)
2200 {
2201 if (h->esym.asym.sc == scCommon)
2202 h->esym.asym.sc = scBss;
2203 else if (h->esym.asym.sc == scSCommon)
2204 h->esym.asym.sc = scSBss;
2205
2206 sec = h->root.root.u.def.section;
2207 output_section = sec->output_section;
2208 if (output_section != NULL)
2209 h->esym.asym.value = (h->root.root.u.def.value
2210 + sec->output_offset
2211 + output_section->vma);
2212 else
2213 h->esym.asym.value = 0;
2214 }
2215 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2216 {
2217 /* Set type and value for a symbol with a function stub. */
2218 h->esym.asym.st = stProc;
2219 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2220 if (sec == NULL)
2221 h->esym.asym.value = 0;
2222 else
2223 {
2224 output_section = sec->output_section;
2225 if (output_section != NULL)
2226 h->esym.asym.value = (h->root.plt.offset
2227 + sec->output_offset
2228 + output_section->vma);
2229 else
2230 h->esym.asym.value = 0;
2231 }
252b5132
RH		 2232 }
2233
2234 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2235 h->root.root.root.string,
2236 &h->esym))
2237 {
2238 einfo->failed = true;
2239 return false;
2240 }
2241
2242 return true;
2243}
2244
2245/* FIXME: Create a runtime procedure table from the .mdebug section.
2246
2247static boolean
2248mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2249 PTR handle;
2250 bfd *abfd;
2251 struct bfd_link_info *info;
2252 asection *s;
2253 struct ecoff_debug_info *debug;
2254*/
2255\f
2256/* Handle dynamic relocations when doing an Alpha ELF link. */
2257
2258static boolean
2259elf64_alpha_check_relocs (abfd, info, sec, relocs)
2260 bfd *abfd;
2261 struct bfd_link_info *info;
2262 asection *sec;
2263 const Elf_Internal_Rela *relocs;
2264{
2265 bfd *dynobj;
2266 asection *sreloc;
2267 const char *rel_sec_name;
2268 Elf_Internal_Shdr *symtab_hdr;
2269 struct alpha_elf_link_hash_entry **sym_hashes;
2270 struct alpha_elf_got_entry **local_got_entries;
2271 const Elf_Internal_Rela *rel, *relend;
2272 int got_created;
dc810e39 2273 bfd_size_type amt;
252b5132
RH		 2274
2275 if (info->relocateable)
2276 return true;
2277
2278 dynobj = elf_hash_table(info)->dynobj;
2279 if (dynobj == NULL)
2280 elf_hash_table(info)->dynobj = dynobj = abfd;
2281
2282 sreloc = NULL;
2283 rel_sec_name = NULL;
2284 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2285 sym_hashes = alpha_elf_sym_hashes(abfd);
2286 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2287 got_created = 0;
2288
2289 relend = relocs + sec->reloc_count;
2290 for (rel = relocs; rel < relend; ++rel)
2291 {
2292 unsigned long r_symndx, r_type;
2293 struct alpha_elf_link_hash_entry *h;
2294
2295 r_symndx = ELF64_R_SYM (rel->r_info);
2296 if (r_symndx < symtab_hdr->sh_info)
2297 h = NULL;
2298 else
2299 {
2300 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2301
2302 while (h->root.root.type == bfd_link_hash_indirect
2303 || h->root.root.type == bfd_link_hash_warning)
2304 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2305
2306 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2307 }
2308 r_type = ELF64_R_TYPE (rel->r_info);
2309
2310 switch (r_type)
2311 {
2312 case R_ALPHA_LITERAL:
2313 {
2314 struct alpha_elf_got_entry *gotent;
2315 int flags = 0;
2316
2317 if (h)
2318 {
2319 /* Search for and possibly create a got entry. */
2320 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2321 if (gotent->gotobj == abfd &&
2322 gotent->addend == rel->r_addend)
2323 break;
2324
2325 if (!gotent)
2326 {
dc810e39 2327 amt = sizeof (struct alpha_elf_got_entry);
252b5132 2328 gotent = ((struct alpha_elf_got_entry *)
dc810e39 2329 bfd_alloc (abfd, amt));
252b5132
RH		 2330 if (!gotent)
2331 return false;
2332
2333 gotent->gotobj = abfd;
2334 gotent->addend = rel->r_addend;
2335 gotent->got_offset = -1;
2336 gotent->flags = 0;
2337 gotent->use_count = 1;
2338
2339 gotent->next = h->got_entries;
2340 h->got_entries = gotent;
2341
2342 alpha_elf_tdata (abfd)->total_got_entries++;
2343 }
2344 else
2345 gotent->use_count += 1;
2346 }
2347 else
2348 {
2349 /* This is a local .got entry -- record for merge. */
2350 if (!local_got_entries)
2351 {
dc810e39
AM		 2352 bfd_size_type size;
2353 size = symtab_hdr->sh_info;
2354 size *= sizeof (struct alpha_elf_got_entry *);
252b5132
RH		 2355
2356 local_got_entries = ((struct alpha_elf_got_entry **)
2357 bfd_alloc (abfd, size));
2358 if (!local_got_entries)
2359 return false;
2360
dc810e39 2361 memset (local_got_entries, 0, (size_t) size);
252b5132
RH		 2362 alpha_elf_tdata (abfd)->local_got_entries =
2363 local_got_entries;
2364 }
2365
2366 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2367 gotent != NULL && gotent->addend != rel->r_addend;
2368 gotent = gotent->next)
2369 continue;
2370 if (!gotent)
2371 {
dc810e39 2372 amt = sizeof (struct alpha_elf_got_entry);
252b5132 2373 gotent = ((struct alpha_elf_got_entry *)
dc810e39 2374 bfd_alloc (abfd, amt));
252b5132
RH		 2375 if (!gotent)
2376 return false;
2377
2378 gotent->gotobj = abfd;
2379 gotent->addend = rel->r_addend;
2380 gotent->got_offset = -1;
2381 gotent->flags = 0;
2382 gotent->use_count = 1;
2383
2384 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2385 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2386
2387 alpha_elf_tdata(abfd)->total_got_entries++;
2388 alpha_elf_tdata(abfd)->n_local_got_entries++;
2389 }
2390 else
2391 gotent->use_count += 1;
2392 }
2393
2394 /* Remember how this literal is used from its LITUSEs.
2395 This will be important when it comes to decide if we can
2396 create a .plt entry for a function symbol. */
2397 if (rel+1 < relend
2398 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2399 {
2400 do
2401 {
2402 ++rel;
2403 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2404 flags |= 1 << rel->r_addend;
2405 }
2406 while (rel+1 < relend &&
2407 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2408 }
2409 else
2410 {
2411 /* No LITUSEs -- presumably the address is not being
2412 loaded for nothing. */
2413 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2414 }
2415
2416 gotent->flags |= flags;
2417 if (h)
2418 {
2419 /* Make a guess as to whether a .plt entry will be needed. */
2420 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2421 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2422 else
2423 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2424 }
2425 }
2426 /* FALLTHRU */
2427
2428 case R_ALPHA_GPDISP:
dfe57ca0 2429 case R_ALPHA_GPREL16:
252b5132
RH		 2430 case R_ALPHA_GPREL32:
2431 case R_ALPHA_GPRELHIGH:
2432 case R_ALPHA_GPRELLOW:
7793f4d0 2433 case R_ALPHA_BRSGP:
252b5132
RH		 2434 /* We don't actually use the .got here, but the sections must
2435 be created before the linker maps input sections to output
2436 sections. */
2437 if (!got_created)
2438 {
2439 if (!elf64_alpha_create_got_section (abfd, info))
2440 return false;
2441
2442 /* Make sure the object's gotobj is set to itself so
2443 that we default to every object with its own .got.
2444 We'll merge .gots later once we've collected each
2445 object's info. */
2446 alpha_elf_tdata(abfd)->gotobj = abfd;
2447
2448 got_created = 1;
2449 }
2450 break;
2451
2452 case R_ALPHA_SREL16:
2453 case R_ALPHA_SREL32:
2454 case R_ALPHA_SREL64:
2455 if (h == NULL)
2456 break;
2457 /* FALLTHRU */
2458
2459 case R_ALPHA_REFLONG:
2460 case R_ALPHA_REFQUAD:
2461 if (rel_sec_name == NULL)
2462 {
2463 rel_sec_name = (bfd_elf_string_from_elf_section
2464 (abfd, elf_elfheader(abfd)->e_shstrndx,
2465 elf_section_data(sec)->rel_hdr.sh_name));
2466 if (rel_sec_name == NULL)
2467 return false;
2468
2469 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2470 && strcmp (bfd_get_section_name (abfd, sec),
2471 rel_sec_name+5) == 0);
2472 }
2473
2474 /* We need to create the section here now whether we eventually
2475 use it or not so that it gets mapped to an output section by
2476 the linker. If not used, we'll kill it in
2477 size_dynamic_sections. */
2478 if (sreloc == NULL)
2479 {
2480 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2481 if (sreloc == NULL)
2482 {
dc810e39
AM		 2483 flagword flags;
2484
252b5132 2485 sreloc = bfd_make_section (dynobj, rel_sec_name);
dc810e39
AM		 2486 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
2487 | SEC_LINKER_CREATED | SEC_READONLY);
2488 if (sec->flags & SEC_ALLOC)
2489 flags |= SEC_ALLOC | SEC_LOAD;
252b5132 2490 if (sreloc == NULL
dc810e39 2491 || !bfd_set_section_flags (dynobj, sreloc, flags)
252b5132
RH		 2492 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2493 return false;
2494 }
2495 }
2496
2497 if (h)
2498 {
2499 /* Since we havn't seen all of the input symbols yet, we
2500 don't know whether we'll actually need a dynamic relocation
2501 entry for this reloc. So make a record of it. Once we
2502 find out if this thing needs dynamic relocation we'll
fe8bc63d 2503 expand the relocation sections by the appropriate amount. */
252b5132
RH		 2504
2505 struct alpha_elf_reloc_entry *rent;
2506
2507 for (rent = h->reloc_entries; rent; rent = rent->next)
2508 if (rent->rtype == r_type && rent->srel == sreloc)
2509 break;
2510
2511 if (!rent)
2512 {
dc810e39
AM		 2513 amt = sizeof (struct alpha_elf_reloc_entry);
2514 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
252b5132
RH		 2515 if (!rent)
2516 return false;
2517
2518 rent->srel = sreloc;
2519 rent->rtype = r_type;
2520 rent->count = 1;
73896efb
RH		 2521 rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC))
2522 == (SEC_READONLY | SEC_ALLOC));
252b5132
RH		 2523
2524 rent->next = h->reloc_entries;
2525 h->reloc_entries = rent;
2526 }
2527 else
2528 rent->count++;
2529 }
c555c5c5 2530 else if (info->shared && (sec->flags & SEC_ALLOC))
252b5132 2531 {
c555c5c5
AM		 2532 /* If this is a shared library, and the section is to be
2533 loaded into memory, we need a RELATIVE reloc. */
252b5132 2534 sreloc->_raw_size += sizeof (Elf64_External_Rela);
fcfbdf31
JJ		 2535 if (sec->flags & SEC_READONLY)
2536 info->flags |= DF_TEXTREL;
252b5132
RH		 2537 }
2538 break;
2539 }
2540 }
2541
2542 return true;
2543}
2544
2545/* Adjust a symbol defined by a dynamic object and referenced by a
2546 regular object. The current definition is in some section of the
2547 dynamic object, but we're not including those sections. We have to
2548 change the definition to something the rest of the link can
2549 understand. */
2550
2551static boolean
2552elf64_alpha_adjust_dynamic_symbol (info, h)
2553 struct bfd_link_info *info;
2554 struct elf_link_hash_entry *h;
2555{
2556 bfd *dynobj;
2557 asection *s;
2558 struct alpha_elf_link_hash_entry *ah;
2559
2560 dynobj = elf_hash_table(info)->dynobj;
2561 ah = (struct alpha_elf_link_hash_entry *)h;
2562
2563 /* Now that we've seen all of the input symbols, finalize our decision
2564 about whether this symbol should get a .plt entry. */
2565
8ba89f17 2566 if (alpha_elf_dynamic_symbol_p (h, info)
252b5132
RH		 2567 && ((h->type == STT_FUNC
2568 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2569 || (h->type == STT_NOTYPE
2570 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2571 /* Don't prevent otherwise valid programs from linking by attempting
2572 to create a new .got entry somewhere. A Correct Solution would be
2573 to add a new .got section to a new object file and let it be merged
2574 somewhere later. But for now don't bother. */
2575 && ah->got_entries)
2576 {
2577 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2578
2579 s = bfd_get_section_by_name(dynobj, ".plt");
2580 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2581 return false;
2582
2583 /* The first bit of the .plt is reserved. */
2584 if (s->_raw_size == 0)
2585 s->_raw_size = PLT_HEADER_SIZE;
2586
2587 h->plt.offset = s->_raw_size;
2588 s->_raw_size += PLT_ENTRY_SIZE;
2589
2590 /* If this symbol is not defined in a regular file, and we are not
2591 generating a shared library, then set the symbol to the location
2592 in the .plt. This is required to make function pointers compare
2593 equal between the normal executable and the shared library. */
2594 if (! info->shared
2595 && h->root.type != bfd_link_hash_defweak)
2596 {
2597 h->root.u.def.section = s;
2598 h->root.u.def.value = h->plt.offset;
2599 }
2600
2601 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2602 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2603 BFD_ASSERT (s != NULL);
2604 s->_raw_size += sizeof (Elf64_External_Rela);
2605
2606 return true;
2607 }
2608 else
2609 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2610
2611 /* If this is a weak symbol, and there is a real definition, the
2612 processor independent code will have arranged for us to see the
2613 real definition first, and we can just use the same value. */
2614 if (h->weakdef != NULL)
2615 {
2616 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2617 || h->weakdef->root.type == bfd_link_hash_defweak);
2618 h->root.u.def.section = h->weakdef->root.u.def.section;
2619 h->root.u.def.value = h->weakdef->root.u.def.value;
2620 return true;
2621 }
2622
2623 /* This is a reference to a symbol defined by a dynamic object which
2624 is not a function. The Alpha, since it uses .got entries for all
2625 symbols even in regular objects, does not need the hackery of a
2626 .dynbss section and COPY dynamic relocations. */
2627
2628 return true;
2629}
2630
2631/* Symbol versioning can create new symbols, and make our old symbols
2632 indirect to the new ones. Consolidate the got and reloc information
2633 in these situations. */
2634
2635static boolean
2636elf64_alpha_merge_ind_symbols (hi, dummy)
2637 struct alpha_elf_link_hash_entry *hi;
56fc028e 2638 PTR dummy ATTRIBUTE_UNUSED;
252b5132
RH		 2639{
2640 struct alpha_elf_link_hash_entry *hs;
2641
2642 if (hi->root.root.type != bfd_link_hash_indirect)
2643 return true;
2644 hs = hi;
2645 do {
2646 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2647 } while (hs->root.root.type == bfd_link_hash_indirect);
2648
2649 /* Merge the flags. Whee. */
2650
2651 hs->flags |= hi->flags;
2652
2653 /* Merge the .got entries. Cannibalize the old symbol's list in
2654 doing so, since we don't need it anymore. */
2655
2656 if (hs->got_entries == NULL)
2657 hs->got_entries = hi->got_entries;
2658 else
2659 {
2660 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2661
2662 gsh = hs->got_entries;
2663 for (gi = hi->got_entries; gi ; gi = gin)
2664 {
2665 gin = gi->next;
2666 for (gs = gsh; gs ; gs = gs->next)
2667 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2668 goto got_found;
2669 gi->next = hs->got_entries;
2670 hs->got_entries = gi;
2671 got_found:;
2672 }
2673 }
2674 hi->got_entries = NULL;
2675
2676 /* And similar for the reloc entries. */
2677
2678 if (hs->reloc_entries == NULL)
2679 hs->reloc_entries = hi->reloc_entries;
2680 else
2681 {
2682 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2683
2684 rsh = hs->reloc_entries;
2685 for (ri = hi->reloc_entries; ri ; ri = rin)
2686 {
2687 rin = ri->next;
2688 for (rs = rsh; rs ; rs = rs->next)
2689 if (ri->rtype == rs->rtype)
2690 {
2691 rs->count += ri->count;
2692 goto found_reloc;
2693 }
2694 ri->next = hs->reloc_entries;
2695 hs->reloc_entries = ri;
2696 found_reloc:;
2697 }
2698 }
2699 hi->reloc_entries = NULL;
2700
2701 return true;
2702}
2703
2704/* Is it possible to merge two object file's .got tables? */
2705
2706static boolean
2707elf64_alpha_can_merge_gots (a, b)
2708 bfd *a, *b;
2709{
2710 int total = alpha_elf_tdata (a)->total_got_entries;
2711 bfd *bsub;
2712
2713 /* Trivial quick fallout test. */
2714 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2715 return true;
2716
2717 /* By their nature, local .got entries cannot be merged. */
2718 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2719 return false;
2720
2721 /* Failing the common trivial comparison, we must effectively
2722 perform the merge. Not actually performing the merge means that
2723 we don't have to store undo information in case we fail. */
2724 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2725 {
2726 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2727 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2728 int i, n;
2729
d9bc7a44 2730 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
252b5132
RH		 2731 for (i = 0; i < n; ++i)
2732 {
2733 struct alpha_elf_got_entry *ae, *be;
2734 struct alpha_elf_link_hash_entry *h;
2735
2736 h = hashes[i];
2737 while (h->root.root.type == bfd_link_hash_indirect
2738 || h->root.root.type == bfd_link_hash_warning)
2739 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2740
2741 for (be = h->got_entries; be ; be = be->next)
2742 {
2743 if (be->use_count == 0)
2744 continue;
2745 if (be->gotobj != b)
2746 continue;
2747
2748 for (ae = h->got_entries; ae ; ae = ae->next)
2749 if (ae->gotobj == a && ae->addend == be->addend)
2750 goto global_found;
2751
2752 if (++total > MAX_GOT_ENTRIES)
2753 return false;
2754 global_found:;
2755 }
2756 }
2757 }
2758
2759 return true;
2760}
2761
2762/* Actually merge two .got tables. */
2763
2764static void
2765elf64_alpha_merge_gots (a, b)
2766 bfd *a, *b;
2767{
2768 int total = alpha_elf_tdata (a)->total_got_entries;
2769 bfd *bsub;
2770
2771 /* Remember local expansion. */
2772 {
2773 int e = alpha_elf_tdata (b)->n_local_got_entries;
2774 total += e;
2775 alpha_elf_tdata (a)->n_local_got_entries += e;
2776 }
2777
2778 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2779 {
2780 struct alpha_elf_got_entry **local_got_entries;
2781 struct alpha_elf_link_hash_entry **hashes;
2782 Elf_Internal_Shdr *symtab_hdr;
2783 int i, n;
2784
2785 /* Let the local .got entries know they are part of a new subsegment. */
2786 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2787 if (local_got_entries)
2788 {
2789 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2790 for (i = 0; i < n; ++i)
2791 {
2792 struct alpha_elf_got_entry *ent;
2793 for (ent = local_got_entries[i]; ent; ent = ent->next)
2794 ent->gotobj = a;
2795 }
2796 }
2797
2798 /* Merge the global .got entries. */
2799 hashes = alpha_elf_sym_hashes (bsub);
2800 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2801
d9bc7a44 2802 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
252b5132
RH		 2803 for (i = 0; i < n; ++i)
2804 {
2805 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2806 struct alpha_elf_link_hash_entry *h;
2807
2808 h = hashes[i];
2809 while (h->root.root.type == bfd_link_hash_indirect
2810 || h->root.root.type == bfd_link_hash_warning)
2811 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2812
2813 start = &h->got_entries;
2814 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2815 {
2816 if (be->use_count == 0)
2817 {
2818 *pbe = be->next;
2819 continue;
2820 }
2821 if (be->gotobj != b)
2822 continue;
2823
2824 for (ae = *start; ae ; ae = ae->next)
2825 if (ae->gotobj == a && ae->addend == be->addend)
2826 {
2827 ae->flags |= be->flags;
2828 ae->use_count += be->use_count;
2829 *pbe = be->next;
2830 goto global_found;
2831 }
2832 be->gotobj = a;
2833 total += 1;
2834
2835 global_found:;
2836 }
2837 }
2838
2839 alpha_elf_tdata (bsub)->gotobj = a;
2840 }
2841 alpha_elf_tdata (a)->total_got_entries = total;
2842
2843 /* Merge the two in_got chains. */
2844 {
2845 bfd *next;
2846
2847 bsub = a;
2848 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2849 bsub = next;
2850
2851 alpha_elf_tdata (bsub)->in_got_link_next = b;
2852 }
2853}
2854
2855/* Calculate the offsets for the got entries. */
2856
2857static boolean
2858elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2859 struct alpha_elf_link_hash_entry *h;
52b9d213 2860 PTR arg ATTRIBUTE_UNUSED;
252b5132
RH		 2861{
2862 struct alpha_elf_got_entry *gotent;
2863
2864 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2865 if (gotent->use_count > 0)
2866 {
2867 bfd_size_type *plge
2868 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2869
2870 gotent->got_offset = *plge;
2871 *plge += 8;
2872 }
2873
2874 return true;
2875}
2876
2877static void
2878elf64_alpha_calc_got_offsets (info)
2879 struct bfd_link_info *info;
2880{
2881 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2882
2883 /* First, zero out the .got sizes, as we may be recalculating the
2884 .got after optimizing it. */
2885 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2886 alpha_elf_tdata(i)->got->_raw_size = 0;
2887
2888 /* Next, fill in the offsets for all the global entries. */
2889 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2890 elf64_alpha_calc_got_offsets_for_symbol,
2891 NULL);
2892
2893 /* Finally, fill in the offsets for the local entries. */
2894 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2895 {
2896 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2897 bfd *j;
2898
2899 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2900 {
2901 struct alpha_elf_got_entry **local_got_entries, *gotent;
2902 int k, n;
2903
2904 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2905 if (!local_got_entries)
2906 continue;
2907
2908 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2909 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2910 if (gotent->use_count > 0)
2911 {
2912 gotent->got_offset = got_offset;
2913 got_offset += 8;
2914 }
2915 }
2916
2917 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2918 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2919 }
2920}
2921
2922/* Constructs the gots. */
2923
2924static boolean
2925elf64_alpha_size_got_sections (output_bfd, info)
52b9d213 2926 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 2927 struct bfd_link_info *info;
2928{
52b9d213 2929 bfd *i, *got_list, *cur_got_obj = NULL;
252b5132
RH		 2930 int something_changed = 0;
2931
2932 got_list = alpha_elf_hash_table (info)->got_list;
2933
2934 /* On the first time through, pretend we have an existing got list
2935 consisting of all of the input files. */
2936 if (got_list == NULL)
2937 {
2938 for (i = info->input_bfds; i ; i = i->link_next)
2939 {
2940 bfd *this_got = alpha_elf_tdata (i)->gotobj;
2941 if (this_got == NULL)
2942 continue;
2943
2944 /* We are assuming no merging has yet ocurred. */
2945 BFD_ASSERT (this_got == i);
2946
2947 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2948 {
2949 /* Yikes! A single object file has too many entries. */
2950 (*_bfd_error_handler)
2951 (_("%s: .got subsegment exceeds 64K (size %d)"),
8f615d07 2952 bfd_archive_filename (i),
252b5132
RH		 2953 alpha_elf_tdata (this_got)->total_got_entries * 8);
2954 return false;
2955 }
2956
2957 if (got_list == NULL)
2958 got_list = this_got;
2959 else
2960 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2961 cur_got_obj = this_got;
2962 }
2963
2964 /* Strange degenerate case of no got references. */
2965 if (got_list == NULL)
2966 return true;
2967
2968 alpha_elf_hash_table (info)->got_list = got_list;
2969
2970 /* Force got offsets to be recalculated. */
2971 something_changed = 1;
2972 }
2973
2974 cur_got_obj = got_list;
2975 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2976 while (i != NULL)
2977 {
2978 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2979 {
2980 elf64_alpha_merge_gots (cur_got_obj, i);
2981 i = alpha_elf_tdata(i)->got_link_next;
2982 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2983 something_changed = 1;
2984 }
2985 else
2986 {
2987 cur_got_obj = i;
2988 i = alpha_elf_tdata(i)->got_link_next;
2989 }
2990 }
2991
2992 /* Once the gots have been merged, fill in the got offsets for
2993 everything therein. */
2994 if (1 || something_changed)
2995 elf64_alpha_calc_got_offsets (info);
2996
2997 return true;
2998}
2999
3000static boolean
3001elf64_alpha_always_size_sections (output_bfd, info)
3002 bfd *output_bfd;
3003 struct bfd_link_info *info;
3004{
3005 bfd *i;
3006
3007 if (info->relocateable)
3008 return true;
3009
3010 /* First, take care of the indirect symbols created by versioning. */
3011 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3012 elf64_alpha_merge_ind_symbols,
3013 NULL);
3014
3015 if (!elf64_alpha_size_got_sections (output_bfd, info))
3016 return false;
3017
3018 /* Allocate space for all of the .got subsections. */
3019 i = alpha_elf_hash_table (info)->got_list;
3020 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3021 {
3022 asection *s = alpha_elf_tdata(i)->got;
3023 if (s->_raw_size > 0)
3024 {
3025 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3026 if (s->contents == NULL)
3027 return false;
3028 }
3029 }
3030
3031 return true;
3032}
3033
3034/* Work out the sizes of the dynamic relocation entries. */
3035
3036static boolean
3037elf64_alpha_calc_dynrel_sizes (h, info)
3038 struct alpha_elf_link_hash_entry *h;
3039 struct bfd_link_info *info;
3040{
3041 /* If the symbol was defined as a common symbol in a regular object
3042 file, and there was no definition in any dynamic object, then the
3043 linker will have allocated space for the symbol in a common
3044 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3045 set. This is done for dynamic symbols in
3046 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3047 symbols, somehow. */
3048 if (((h->root.elf_link_hash_flags
3049 & (ELF_LINK_HASH_DEF_REGULAR
3050 | ELF_LINK_HASH_REF_REGULAR
3051 | ELF_LINK_HASH_DEF_DYNAMIC))
3052 == ELF_LINK_HASH_REF_REGULAR)
3053 && (h->root.root.type == bfd_link_hash_defined
3054 || h->root.root.type == bfd_link_hash_defweak)
3055 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3056 {
3057 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3058 }
3059
3060 /* If the symbol is dynamic, we'll need all the relocations in their
3061 natural form. If this is a shared object, and it has been forced
3062 local, we'll need the same number of RELATIVE relocations. */
3063
3064 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3065 {
3066 struct alpha_elf_reloc_entry *relent;
3067 bfd *dynobj;
3068 struct alpha_elf_got_entry *gotent;
3069 bfd_size_type count;
3070 asection *srel;
3071
3072 for (relent = h->reloc_entries; relent; relent = relent->next)
3073 if (relent->rtype == R_ALPHA_REFLONG
3074 || relent->rtype == R_ALPHA_REFQUAD)
3075 {
3076 relent->srel->_raw_size +=
fe8bc63d 3077 sizeof (Elf64_External_Rela) * relent->count;
fcfbdf31
JJ		 3078 if (relent->reltext)
3079 info->flags |= DT_TEXTREL;
252b5132
RH		 3080 }
3081
3082 dynobj = elf_hash_table(info)->dynobj;
3083 count = 0;
3084
3085 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3086 count++;
3087
3088 /* If we are using a .plt entry, subtract one, as the first
3089 reference uses a .rela.plt entry instead. */
3090 if (h->root.plt.offset != MINUS_ONE)
3091 count--;
3092
3093 if (count > 0)
3094 {
3095 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3096 BFD_ASSERT (srel != NULL);
3097 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3098 }
3099 }
3100
3101 return true;
3102}
3103
3104/* Set the sizes of the dynamic sections. */
3105
3106static boolean
3107elf64_alpha_size_dynamic_sections (output_bfd, info)
24a35864 3108 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 3109 struct bfd_link_info *info;
3110{
3111 bfd *dynobj;
3112 asection *s;
252b5132
RH		 3113 boolean relplt;
3114
3115 dynobj = elf_hash_table(info)->dynobj;
3116 BFD_ASSERT(dynobj != NULL);
3117
3118 if (elf_hash_table (info)->dynamic_sections_created)
3119 {
3120 /* Set the contents of the .interp section to the interpreter. */
3121 if (!info->shared)
3122 {
3123 s = bfd_get_section_by_name (dynobj, ".interp");
3124 BFD_ASSERT (s != NULL);
3125 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3126 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3127 }
3128
3129 /* Now that we've seen all of the input files, we can decide which
3130 symbols need dynamic relocation entries and which don't. We've
3131 collected information in check_relocs that we can now apply to
3132 size the dynamic relocation sections. */
3133 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3134 elf64_alpha_calc_dynrel_sizes,
3135 info);
3136
3137 /* When building shared libraries, each local .got entry needs a
3138 RELATIVE reloc. */
3139 if (info->shared)
3140 {
3141 bfd *i;
3142 asection *srel;
3143 bfd_size_type count;
3144
3145 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3146 BFD_ASSERT (srel != NULL);
3147
3148 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3149 i != NULL;
3150 i = alpha_elf_tdata(i)->got_link_next)
3151 count += alpha_elf_tdata(i)->n_local_got_entries;
3152
fe8bc63d 3153 srel->_raw_size += count * sizeof (Elf64_External_Rela);
252b5132
RH		 3154 }
3155 }
3156 /* else we're not dynamic and by definition we don't need such things. */
3157
3158 /* The check_relocs and adjust_dynamic_symbol entry points have
3159 determined the sizes of the various dynamic sections. Allocate
3160 memory for them. */
252b5132
RH		 3161 relplt = false;
3162 for (s = dynobj->sections; s != NULL; s = s->next)
3163 {
3164 const char *name;
3165 boolean strip;
3166
3167 if (!(s->flags & SEC_LINKER_CREATED))
3168 continue;
3169
3170 /* It's OK to base decisions on the section name, because none
3171 of the dynobj section names depend upon the input files. */
3172 name = bfd_get_section_name (dynobj, s);
3173
3174 /* If we don't need this section, strip it from the output file.
3175 This is to handle .rela.bss and .rela.plt. We must create it
3176 in create_dynamic_sections, because it must be created before
3177 the linker maps input sections to output sections. The
3178 linker does that before adjust_dynamic_symbol is called, and
3179 it is that function which decides whether anything needs to
3180 go into these sections. */
3181
3182 strip = false;
3183
3184 if (strncmp (name, ".rela", 5) == 0)
3185 {
3186 strip = (s->_raw_size == 0);
3187
3188 if (!strip)
3189 {
252b5132
RH		 3190 if (strcmp(name, ".rela.plt") == 0)
3191 relplt = true;
3192
3193 /* We use the reloc_count field as a counter if we need
3194 to copy relocs into the output file. */
3195 s->reloc_count = 0;
3196 }
3197 }
3198 else if (strcmp (name, ".plt") != 0)
3199 {
3200 /* It's not one of our dynamic sections, so don't allocate space. */
3201 continue;
3202 }
3203
3204 if (strip)
7f8d5fc9 3205 _bfd_strip_section_from_output (info, s);
252b5132
RH		 3206 else
3207 {
3208 /* Allocate memory for the section contents. */
dc810e39 3209 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
252b5132
RH		 3210 if (s->contents == NULL && s->_raw_size != 0)
3211 return false;
3212 }
3213 }
3214
252b5132
RH		 3215 if (elf_hash_table (info)->dynamic_sections_created)
3216 {
3217 /* Add some entries to the .dynamic section. We fill in the
3218 values later, in elf64_alpha_finish_dynamic_sections, but we
3219 must add the entries now so that we get the correct size for
3220 the .dynamic section. The DT_DEBUG entry is filled in by the
3221 dynamic linker and used by the debugger. */
dc810e39
AM		 3222#define add_dynamic_entry(TAG, VAL) \
3223 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3224
252b5132
RH		 3225 if (!info->shared)
3226 {
dc810e39 3227 if (!add_dynamic_entry (DT_DEBUG, 0))
252b5132
RH		 3228 return false;
3229 }
3230
dc810e39 3231 if (!add_dynamic_entry (DT_PLTGOT, 0))
252b5132
RH		 3232 return false;
3233
3234 if (relplt)
3235 {
dc810e39
AM		 3236 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3237 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3238 || !add_dynamic_entry (DT_JMPREL, 0))
252b5132
RH		 3239 return false;
3240 }
3241
dc810e39
AM		 3242 if (!add_dynamic_entry (DT_RELA, 0)
3243 || !add_dynamic_entry (DT_RELASZ, 0)
3244 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
252b5132
RH		 3245 return false;
3246
fcfbdf31 3247 if (info->flags & DF_TEXTREL)
252b5132 3248 {
dc810e39 3249 if (!add_dynamic_entry (DT_TEXTREL, 0))
252b5132
RH		 3250 return false;
3251 }
3252 }
dc810e39 3253#undef add_dynamic_entry
252b5132
RH		 3254
3255 return true;
3256}
3257
252b5132
RH		 3258/* Relocate an Alpha ELF section. */
3259
3260static boolean
3261elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3262 contents, relocs, local_syms, local_sections)
3263 bfd *output_bfd;
3264 struct bfd_link_info *info;
3265 bfd *input_bfd;
3266 asection *input_section;
3267 bfd_byte *contents;
3268 Elf_Internal_Rela *relocs;
3269 Elf_Internal_Sym *local_syms;
3270 asection **local_sections;
3271{
3272 Elf_Internal_Shdr *symtab_hdr;
3273 Elf_Internal_Rela *rel;
3274 Elf_Internal_Rela *relend;
3275 asection *sec, *sgot, *srel, *srelgot;
3276 bfd *dynobj, *gotobj;
3277 bfd_vma gp;
f16fbd61 3278 boolean ret_val = true;
252b5132
RH		 3279
3280 srelgot = srel = NULL;
3281 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3282 dynobj = elf_hash_table (info)->dynobj;
3283 if (dynobj)
3284 {
3285 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3286 }
3287
3288 /* Find the gp value for this input bfd. */
3289 sgot = NULL;
3290 gp = 0;
3291 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3292 if (gotobj)
3293 {
3294 sgot = alpha_elf_tdata (gotobj)->got;
3295 gp = _bfd_get_gp_value (gotobj);
3296 if (gp == 0)
3297 {
3298 gp = (sgot->output_section->vma
3299 + sgot->output_offset
3300 + 0x8000);
3301 _bfd_set_gp_value (gotobj, gp);
3302 }
3303 }
3304
3305 rel = relocs;
3306 relend = relocs + input_section->reloc_count;
3307 for (; rel < relend; rel++)
3308 {
3309 int r_type;
3310 reloc_howto_type *howto;
3311 unsigned long r_symndx;
3312 struct alpha_elf_link_hash_entry *h;
3313 Elf_Internal_Sym *sym;
3314 bfd_vma relocation;
dc810e39 3315 bfd_vma addend;
252b5132
RH		 3316 bfd_reloc_status_type r;
3317
3318 r_type = ELF64_R_TYPE(rel->r_info);
3319 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3320 {
3321 bfd_set_error (bfd_error_bad_value);
3322 return false;
3323 }
3324 howto = elf64_alpha_howto_table + r_type;
3325
3326 r_symndx = ELF64_R_SYM(rel->r_info);
3327
3328 if (info->relocateable)
3329 {
3330 /* This is a relocateable link. We don't have to change
3331 anything, unless the reloc is against a section symbol,
3332 in which case we have to adjust according to where the
3333 section symbol winds up in the output section. */
72b60c23 3334
fe8bc63d 3335 /* The symbol associated with GPDISP and LITUSE is
72b60c23
RH		 3336 immaterial. Only the addend is significant. */
3337 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3338 continue;
3339
252b5132
RH		 3340 if (r_symndx < symtab_hdr->sh_info)
3341 {
3342 sym = local_syms + r_symndx;
3343 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3344 {
3345 sec = local_sections[r_symndx];
3346 rel->r_addend += sec->output_offset + sym->st_value;
3347 }
3348 }
3349
3350 continue;
3351 }
3352
3353 /* This is a final link. */
3354
3355 h = NULL;
3356 sym = NULL;
3357 sec = NULL;
3358
3359 if (r_symndx < symtab_hdr->sh_info)
3360 {
3361 sym = local_syms + r_symndx;
3362 sec = local_sections[r_symndx];
f8df10f4 3363 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
252b5132
RH		 3364 }
3365 else
3366 {
3367 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3368
3369 while (h->root.root.type == bfd_link_hash_indirect
3370 || h->root.root.type == bfd_link_hash_warning)
3371 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3372
3373 if (h->root.root.type == bfd_link_hash_defined
3374 || h->root.root.type == bfd_link_hash_defweak)
3375 {
3376 sec = h->root.root.u.def.section;
3377
252b5132
RH		 3378 if (sec->output_section == NULL)
3379 relocation = 0;
252b5132
RH		 3380 else
3381 {
3382 relocation = (h->root.root.u.def.value
3383 + sec->output_section->vma
3384 + sec->output_offset);
3385 }
3386 }
3387 else if (h->root.root.type == bfd_link_hash_undefweak)
3388 relocation = 0;
671bae9c
NC		 3389 else if (info->shared
3390 && (!info->symbolic || info->allow_shlib_undefined)
3a27a730 3391 && !info->no_undefined
edb72b3b 3392 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
252b5132
RH		 3393 relocation = 0;
3394 else
3395 {
3396 if (!((*info->callbacks->undefined_symbol)
3397 (info, h->root.root.root.string, input_bfd,
5cc7c785 3398 input_section, rel->r_offset,
3a27a730 3399 (!info->shared || info->no_undefined
edb72b3b 3400 || ELF_ST_VISIBILITY (h->root.other)))))
f16fbd61 3401 ret_val = false;
252b5132
RH		 3402 relocation = 0;
3403 }
3404 }
3405 addend = rel->r_addend;
3406
3407 switch (r_type)
3408 {
3409 case R_ALPHA_GPDISP:
3410 {
3411 bfd_byte *p_ldah, *p_lda;
3412
3413 BFD_ASSERT(gp != 0);
3414
3415 relocation = (input_section->output_section->vma
3416 + input_section->output_offset
3417 + rel->r_offset);
3418
3419 p_ldah = contents + rel->r_offset - input_section->vma;
3420 p_lda = p_ldah + rel->r_addend;
3421
3422 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3423 p_ldah, p_lda);
3424 }
3425 break;
3426
252b5132
RH		 3427 case R_ALPHA_LITERAL:
3428 {
3429 struct alpha_elf_got_entry *gotent;
3430 boolean dynamic_symbol;
3431
3432 BFD_ASSERT(sgot != NULL);
3433 BFD_ASSERT(gp != 0);
3434
3435 if (h != NULL)
3436 {
3437 gotent = h->got_entries;
3438 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3439 }
3440 else
3441 {
3442 gotent = (alpha_elf_tdata(input_bfd)->
3443 local_got_entries[r_symndx]);
3444 dynamic_symbol = false;
f7460f5f
JJ		 3445
3446 /* Need to adjust local GOT entries' addends for SEC_MERGE
3447 unless it has been done already. */
3448 if ((sec->flags & SEC_MERGE)
3449 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
65765700
JJ		 3450 && (elf_section_data (sec)->sec_info_type
3451 == ELF_INFO_TYPE_MERGE)
f7460f5f
JJ		 3452 && (gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED) == 0)
3453 {
3454 struct alpha_elf_got_entry *ent;
3455 asection *msec;
3456
3457 for (ent = gotent; ent; ent = ent->next)
3458 {
3459 ent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED;
3460 if (ent->use_count == 0)
3461 continue;
3462 msec = sec;
3463 ent->addend =
3464 _bfd_merged_section_offset (output_bfd, &msec,
3465 elf_section_data (sec)->
65765700 3466 sec_info,
f7460f5f
JJ		 3467 sym->st_value
3468 + ent->addend,
3469 (bfd_vma) 0);
3470 ent->addend -= sym->st_value;
3471 ent->addend += msec->output_section->vma
3472 + msec->output_offset
3473 - sec->output_section->vma
3474 - sec->output_offset;
3475 }
3476 }
252b5132
RH		 3477 }
3478
3479 BFD_ASSERT(gotent != NULL);
3480
3481 while (gotent->gotobj != gotobj || gotent->addend != addend)
3482 gotent = gotent->next;
3483
3484 BFD_ASSERT(gotent->use_count >= 1);
3485
3486 /* Initialize the .got entry's value. */
3487 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3488 {
dc810e39 3489 bfd_put_64 (output_bfd, relocation + addend,
252b5132
RH		 3490 sgot->contents + gotent->got_offset);
3491
3492 /* If the symbol has been forced local, output a
3493 RELATIVE reloc, otherwise it will be handled in
3494 finish_dynamic_symbol. */
3495 if (info->shared && !dynamic_symbol)
3496 {
3497 Elf_Internal_Rela outrel;
3498
3499 BFD_ASSERT(srelgot != NULL);
3500
3501 outrel.r_offset = (sgot->output_section->vma
3502 + sgot->output_offset
3503 + gotent->got_offset);
3504 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
dc810e39 3505 outrel.r_addend = relocation + addend;
252b5132
RH		 3506
3507 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3508 ((Elf64_External_Rela *)
3509 srelgot->contents)
3510 + srelgot->reloc_count++);
fe8bc63d 3511 BFD_ASSERT (sizeof (Elf64_External_Rela)
252b5132
RH		 3512 * srelgot->reloc_count
3513 <= srelgot->_cooked_size);
3514 }
3515
3516 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3517 }
3518
3519 /* Figure the gprel relocation. */
3520 addend = 0;
3521 relocation = (sgot->output_section->vma
3522 + sgot->output_offset
3523 + gotent->got_offset);
3524 relocation -= gp;
3525 }
3526 /* overflow handled by _bfd_final_link_relocate */
3527 goto default_reloc;
3528
dfe57ca0 3529 case R_ALPHA_GPREL16:
252b5132
RH		 3530 case R_ALPHA_GPREL32:
3531 case R_ALPHA_GPRELLOW:
f16fbd61
RH		 3532 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3533 {
3534 (*_bfd_error_handler)
3535 (_("%s: gp-relative relocation against dynamic symbol %s"),
8f615d07 3536 bfd_archive_filename (input_bfd), h->root.root.root.string);
f16fbd61
RH		 3537 ret_val = false;
3538 }
252b5132
RH		 3539 BFD_ASSERT(gp != 0);
3540 relocation -= gp;
3541 goto default_reloc;
3542
3543 case R_ALPHA_GPRELHIGH:
f16fbd61
RH		 3544 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3545 {
3546 (*_bfd_error_handler)
3547 (_("%s: gp-relative relocation against dynamic symbol %s"),
8f615d07 3548 bfd_archive_filename (input_bfd), h->root.root.root.string);
f16fbd61
RH		 3549 ret_val = false;
3550 }
252b5132
RH		 3551 BFD_ASSERT(gp != 0);
3552 relocation -= gp;
3553 relocation += addend;
3554 addend = 0;
3555 relocation = (((bfd_signed_vma) relocation >> 16)
3556 + ((relocation >> 15) & 1));
3557 goto default_reloc;
3558
252b5132 3559 case R_ALPHA_HINT:
f94952df
RH		 3560 /* A call to a dynamic symbol is definitely out of range of
3561 the 16-bit displacement. Don't bother writing anything. */
3562 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3563 {
3564 r = bfd_reloc_ok;
3565 break;
3566 }
3567 /* FALLTHRU */
3568
3569 case R_ALPHA_BRADDR:
252b5132
RH		 3570 /* The regular PC-relative stuff measures from the start of
3571 the instruction rather than the end. */
3572 addend -= 4;
3573 goto default_reloc;
3574
7793f4d0
RH		 3575 case R_ALPHA_BRSGP:
3576 {
3577 int other;
3578 const char *name;
3579
3580 /* The regular PC-relative stuff measures from the start of
3581 the instruction rather than the end. */
3582 addend -= 4;
3583
3584 /* The source and destination gp must be the same. */
3585 if (h != NULL
3586 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
3587 {
3588 if (h != NULL)
3589 name = h->root.root.root.string;
3590 else
3591 {
3592 name = (bfd_elf_string_from_elf_section
3593 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3594 if (name == NULL)
3595 name = _("<unknown>");
3596 else if (name[0] == 0)
3597 name = bfd_section_name (input_bfd, sec);
3598 }
3599 (*_bfd_error_handler)
3600 (_("%s: change in gp: BRSGP %s"),
3601 bfd_archive_filename (input_bfd), name);
3602 ret_val = false;
3603 }
3604
3605 /* The symbol should be marked either NOPV or STD_GPLOAD. */
3606 if (h != NULL)
3607 other = h->root.other;
3608 else
3609 other = sym->st_other;
3610 switch (other & STO_ALPHA_STD_GPLOAD)
3611 {
3612 case STO_ALPHA_NOPV:
3613 break;
3614 case STO_ALPHA_STD_GPLOAD:
3615 addend += 8;
3616 break;
3617 default:
3618 if (h != NULL)
3619 name = h->root.root.root.string;
3620 else
3621 {
3622 name = (bfd_elf_string_from_elf_section
3623 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3624 if (name == NULL)
3625 name = _("<unknown>");
3626 else if (name[0] == 0)
3627 name = bfd_section_name (input_bfd, sec);
3628 }
3629 (*_bfd_error_handler)
3630 (_("%s: !samegp reloc against symbol without .prologue: %s"),
3631 bfd_archive_filename (input_bfd), name);
3632 ret_val = false;
3633 break;
3634 }
3635
3636 goto default_reloc;
3637 }
3638
252b5132
RH		 3639 case R_ALPHA_REFLONG:
3640 case R_ALPHA_REFQUAD:
3641 {
3642 Elf_Internal_Rela outrel;
252b5132
RH		 3643
3644 /* Careful here to remember RELATIVE relocations for global
3645 variables for symbolic shared objects. */
3646
3647 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3648 {
3649 BFD_ASSERT(h->root.dynindx != -1);
3650 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3651 outrel.r_addend = addend;
3652 addend = 0, relocation = 0;
3653 }
ec338859
AM		 3654 else if (info->shared
3655 && r_symndx != 0
3656 && (input_section->flags & SEC_ALLOC))
252b5132
RH		 3657 {
3658 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
28cfee26 3659 outrel.r_addend = relocation + addend;
252b5132
RH		 3660 }
3661 else
3662 goto default_reloc;
3663
3664 if (!srel)
3665 {
3666 const char *name;
3667
3668 name = (bfd_elf_string_from_elf_section
3669 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3670 elf_section_data(input_section)->rel_hdr.sh_name));
3671 BFD_ASSERT(name != NULL);
3672
3673 srel = bfd_get_section_by_name (dynobj, name);
3674 BFD_ASSERT(srel != NULL);
3675 }
3676
c629eae0
JJ		 3677 outrel.r_offset =
3678 _bfd_elf_section_offset (output_bfd, info, input_section,
3679 rel->r_offset);
3680 if (outrel.r_offset != (bfd_vma) -1)
252b5132
RH		 3681 outrel.r_offset += (input_section->output_section->vma
3682 + input_section->output_offset);
3683 else
3684 memset (&outrel, 0, sizeof outrel);
3685
3686 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3687 ((Elf64_External_Rela *)
3688 srel->contents)
3689 + srel->reloc_count++);
fe8bc63d 3690 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 3691 <= srel->_cooked_size);
3692 }
3693 goto default_reloc;
3694
3695 default:
3696 default_reloc:
3697 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3698 contents, rel->r_offset, relocation,
3699 addend);
3700 break;
3701 }
3702
3703 switch (r)
3704 {
3705 case bfd_reloc_ok:
3706 break;
3707
3708 case bfd_reloc_overflow:
3709 {
3710 const char *name;
3711
ed4de5e2
JJ		 3712 /* Don't warn if the overflow is due to pc relative reloc
3713 against discarded section. Section optimization code should
3714 handle it. */
3715
3716 if (r_symndx < symtab_hdr->sh_info
3717 && sec != NULL && howto->pc_relative
3718 && elf_discarded_section (sec))
3719 break;
3720
252b5132
RH		 3721 if (h != NULL)
3722 name = h->root.root.root.string;
3723 else
3724 {
3725 name = (bfd_elf_string_from_elf_section
3726 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3727 if (name == NULL)
3728 return false;
3729 if (*name == '\0')
3730 name = bfd_section_name (input_bfd, sec);
3731 }
3732 if (! ((*info->callbacks->reloc_overflow)
3733 (info, name, howto->name, (bfd_vma) 0,
3734 input_bfd, input_section, rel->r_offset)))
f16fbd61 3735 ret_val = false;
252b5132
RH		 3736 }
3737 break;
3738
3739 default:
3740 case bfd_reloc_outofrange:
3741 abort ();
3742 }
3743 }
3744
f16fbd61 3745 return ret_val;
252b5132
RH		 3746}
3747
3748/* Finish up dynamic symbol handling. We set the contents of various
3749 dynamic sections here. */
3750
3751static boolean
3752elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3753 bfd *output_bfd;
3754 struct bfd_link_info *info;
3755 struct elf_link_hash_entry *h;
3756 Elf_Internal_Sym *sym;
3757{
3758 bfd *dynobj = elf_hash_table(info)->dynobj;
3759
3760 if (h->plt.offset != MINUS_ONE)
3761 {
3762 /* Fill in the .plt entry for this symbol. */
3763 asection *splt, *sgot, *srel;
3764 Elf_Internal_Rela outrel;
3765 bfd_vma got_addr, plt_addr;
3766 bfd_vma plt_index;
3767 struct alpha_elf_got_entry *gotent;
3768
3769 BFD_ASSERT (h->dynindx != -1);
3770
3771 /* The first .got entry will be updated by the .plt with the
3772 address of the target function. */
3773 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3774 BFD_ASSERT (gotent && gotent->addend == 0);
3775
3776 splt = bfd_get_section_by_name (dynobj, ".plt");
3777 BFD_ASSERT (splt != NULL);
3778 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3779 BFD_ASSERT (srel != NULL);
3780 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3781 BFD_ASSERT (sgot != NULL);
3782
3783 got_addr = (sgot->output_section->vma
3784 + sgot->output_offset
3785 + gotent->got_offset);
3786 plt_addr = (splt->output_section->vma
3787 + splt->output_offset
3788 + h->plt.offset);
3789
3790 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3791
3792 /* Fill in the entry in the procedure linkage table. */
3793 {
dc810e39 3794 bfd_vma insn1, insn2, insn3;
252b5132
RH		 3795
3796 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3797 insn2 = PLT_ENTRY_WORD2;
3798 insn3 = PLT_ENTRY_WORD3;
3799
3800 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3801 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3802 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3803 }
3804
3805 /* Fill in the entry in the .rela.plt section. */
3806 outrel.r_offset = got_addr;
3807 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3808 outrel.r_addend = 0;
3809
3810 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3811 ((Elf64_External_Rela *)srel->contents
3812 + plt_index));
3813
3814 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3815 {
3816 /* Mark the symbol as undefined, rather than as defined in the
3817 .plt section. Leave the value alone. */
3818 sym->st_shndx = SHN_UNDEF;
3819 }
3820
3821 /* Fill in the entries in the .got. */
3822 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3823
3824 /* Subsequent .got entries will continue to bounce through the .plt. */
3825 if (gotent->next)
3826 {
3827 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3828 BFD_ASSERT (! info->shared || srel != NULL);
3829
3830 gotent = gotent->next;
3831 do
3832 {
3833 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3834 BFD_ASSERT(sgot != NULL);
3835 BFD_ASSERT(gotent->addend == 0);
3836
3837 bfd_put_64 (output_bfd, plt_addr,
3838 sgot->contents + gotent->got_offset);
3839
3840 if (info->shared)
3841 {
3842 outrel.r_offset = (sgot->output_section->vma
3843 + sgot->output_offset
3844 + gotent->got_offset);
3845 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
28cfee26 3846 outrel.r_addend = plt_addr;
252b5132
RH		 3847
3848 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3849 ((Elf64_External_Rela *)
3850 srel->contents)
3851 + srel->reloc_count++);
fe8bc63d 3852 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 3853 <= srel->_cooked_size);
3854 }
3855
3856 gotent = gotent->next;
3857 }
3858 while (gotent != NULL);
3859 }
3860 }
3861 else if (alpha_elf_dynamic_symbol_p (h, info))
3862 {
3863 /* Fill in the dynamic relocations for this symbol's .got entries. */
3864 asection *srel;
3865 Elf_Internal_Rela outrel;
3866 struct alpha_elf_got_entry *gotent;
3867
3868 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3869 BFD_ASSERT (srel != NULL);
3870
3871 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3872 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3873 gotent != NULL;
3874 gotent = gotent->next)
3875 {
3876 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3877 outrel.r_offset = (sgot->output_section->vma
3878 + sgot->output_offset
3879 + gotent->got_offset);
3880 outrel.r_addend = gotent->addend;
3881
3882 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3883 ((Elf64_External_Rela *)srel->contents
3884 + srel->reloc_count++));
fe8bc63d 3885 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 3886 <= srel->_cooked_size);
3887 }
3888 }
3889
3890 /* Mark some specially defined symbols as absolute. */
3891 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3892 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3893 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3894 sym->st_shndx = SHN_ABS;
3895
3896 return true;
3897}
3898
3899/* Finish up the dynamic sections. */
3900
3901static boolean
3902elf64_alpha_finish_dynamic_sections (output_bfd, info)
3903 bfd *output_bfd;
3904 struct bfd_link_info *info;
3905{
3906 bfd *dynobj;
3907 asection *sdyn;
3908
3909 dynobj = elf_hash_table (info)->dynobj;
3910 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3911
3912 if (elf_hash_table (info)->dynamic_sections_created)
3913 {
3914 asection *splt;
3915 Elf64_External_Dyn *dyncon, *dynconend;
3916
3917 splt = bfd_get_section_by_name (dynobj, ".plt");
3918 BFD_ASSERT (splt != NULL && sdyn != NULL);
3919
3920 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3921 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3922 for (; dyncon < dynconend; dyncon++)
3923 {
3924 Elf_Internal_Dyn dyn;
3925 const char *name;
3926 asection *s;
3927
3928 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3929
3930 switch (dyn.d_tag)
3931 {
3932 case DT_PLTGOT:
3933 name = ".plt";
3934 goto get_vma;
3935 case DT_PLTRELSZ:
3936 name = ".rela.plt";
3937 goto get_size;
3938 case DT_JMPREL:
3939 name = ".rela.plt";
3940 goto get_vma;
3941
3942 case DT_RELASZ:
3943 /* My interpretation of the TIS v1.1 ELF document indicates
3944 that RELASZ should not include JMPREL. This is not what
3945 the rest of the BFD does. It is, however, what the
3946 glibc ld.so wants. Do this fixup here until we found
3947 out who is right. */
3948 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3949 if (s)
3950 {
3951 dyn.d_un.d_val -=
3952 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3953 }
3954 break;
3955
3956 get_vma:
3957 s = bfd_get_section_by_name (output_bfd, name);
3958 dyn.d_un.d_ptr = (s ? s->vma : 0);
3959 break;
3960
3961 get_size:
3962 s = bfd_get_section_by_name (output_bfd, name);
3963 dyn.d_un.d_val =
3964 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3965 break;
3966 }
3967
3968 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3969 }
3970
3971 /* Initialize the PLT0 entry */
3972 if (splt->_raw_size > 0)
3973 {
3974 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3975 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3976 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3977 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3978
3979 /* The next two words will be filled in by ld.so */
dc810e39
AM		 3980 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
3981 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
252b5132
RH		 3982
3983 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3984 PLT_HEADER_SIZE;
3985 }
3986 }
3987
252b5132
RH		 3988 return true;
3989}
3990
96e2734b
RH		 3991/* We need to use a special link routine to handle the .mdebug section.
3992 We need to merge all instances of these sections together, not write
3993 them all out sequentially. */
252b5132
RH		 3994
3995static boolean
3996elf64_alpha_final_link (abfd, info)
3997 bfd *abfd;
3998 struct bfd_link_info *info;
3999{
4000 asection *o;
4001 struct bfd_link_order *p;
96e2734b 4002 asection *mdebug_sec;
252b5132
RH		 4003 struct ecoff_debug_info debug;
4004 const struct ecoff_debug_swap *swap
4005 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4006 HDRR *symhdr = &debug.symbolic_header;
4007 PTR mdebug_handle = NULL;
4008
96e2734b 4009 /* Go through the sections and collect the mdebug information. */
252b5132 4010 mdebug_sec = NULL;
252b5132
RH		 4011 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4012 {
252b5132
RH		 4013 if (strcmp (o->name, ".mdebug") == 0)
4014 {
4015 struct extsym_info einfo;
4016
4017 /* We have found the .mdebug section in the output file.
4018 Look through all the link_orders comprising it and merge
4019 the information together. */
4020 symhdr->magic = swap->sym_magic;
4021 /* FIXME: What should the version stamp be? */
4022 symhdr->vstamp = 0;
4023 symhdr->ilineMax = 0;
4024 symhdr->cbLine = 0;
4025 symhdr->idnMax = 0;
4026 symhdr->ipdMax = 0;
4027 symhdr->isymMax = 0;
4028 symhdr->ioptMax = 0;
4029 symhdr->iauxMax = 0;
4030 symhdr->issMax = 0;
4031 symhdr->issExtMax = 0;
4032 symhdr->ifdMax = 0;
4033 symhdr->crfd = 0;
4034 symhdr->iextMax = 0;
4035
4036 /* We accumulate the debugging information itself in the
4037 debug_info structure. */
4038 debug.line = NULL;
4039 debug.external_dnr = NULL;
4040 debug.external_pdr = NULL;
4041 debug.external_sym = NULL;
4042 debug.external_opt = NULL;
4043 debug.external_aux = NULL;
4044 debug.ss = NULL;
4045 debug.ssext = debug.ssext_end = NULL;
4046 debug.external_fdr = NULL;
4047 debug.external_rfd = NULL;
4048 debug.external_ext = debug.external_ext_end = NULL;
4049
4050 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4051 if (mdebug_handle == (PTR) NULL)
4052 return false;
4053
4054 if (1)
4055 {
4056 asection *s;
4057 EXTR esym;
52b9d213 4058 bfd_vma last = 0;
252b5132
RH		 4059 unsigned int i;
4060 static const char * const name[] =
4061 {
4062 ".text", ".init", ".fini", ".data",
4063 ".rodata", ".sdata", ".sbss", ".bss"
4064 };
4065 static const int sc[] = { scText, scInit, scFini, scData,
4066 scRData, scSData, scSBss, scBss };
4067
4068 esym.jmptbl = 0;
4069 esym.cobol_main = 0;
4070 esym.weakext = 0;
4071 esym.reserved = 0;
4072 esym.ifd = ifdNil;
4073 esym.asym.iss = issNil;
4074 esym.asym.st = stLocal;
4075 esym.asym.reserved = 0;
4076 esym.asym.index = indexNil;
4077 for (i = 0; i < 8; i++)
4078 {
4079 esym.asym.sc = sc[i];
4080 s = bfd_get_section_by_name (abfd, name[i]);
4081 if (s != NULL)
4082 {
4083 esym.asym.value = s->vma;
4084 last = s->vma + s->_raw_size;
4085 }
4086 else
4087 esym.asym.value = last;
4088
4089 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4090 name[i], &esym))
4091 return false;
4092 }
4093 }
4094
4095 for (p = o->link_order_head;
4096 p != (struct bfd_link_order *) NULL;
4097 p = p->next)
4098 {
4099 asection *input_section;
4100 bfd *input_bfd;
4101 const struct ecoff_debug_swap *input_swap;
4102 struct ecoff_debug_info input_debug;
4103 char *eraw_src;
4104 char *eraw_end;
4105
4106 if (p->type != bfd_indirect_link_order)
4107 {
4108 if (p->type == bfd_fill_link_order)
4109 continue;
4110 abort ();
4111 }
4112
4113 input_section = p->u.indirect.section;
4114 input_bfd = input_section->owner;
4115
4116 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4117 || (get_elf_backend_data (input_bfd)
4118 ->elf_backend_ecoff_debug_swap) == NULL)
4119 {
4120 /* I don't know what a non ALPHA ELF bfd would be
4121 doing with a .mdebug section, but I don't really
4122 want to deal with it. */
4123 continue;
4124 }
4125
4126 input_swap = (get_elf_backend_data (input_bfd)
4127 ->elf_backend_ecoff_debug_swap);
4128
4129 BFD_ASSERT (p->size == input_section->_raw_size);
4130
4131 /* The ECOFF linking code expects that we have already
4132 read in the debugging information and set up an
4133 ecoff_debug_info structure, so we do that now. */
4134 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4135 &input_debug))
4136 return false;
4137
4138 if (! (bfd_ecoff_debug_accumulate
4139 (mdebug_handle, abfd, &debug, swap, input_bfd,
4140 &input_debug, input_swap, info)))
4141 return false;
4142
4143 /* Loop through the external symbols. For each one with
4144 interesting information, try to find the symbol in
4145 the linker global hash table and save the information
4146 for the output external symbols. */
4147 eraw_src = input_debug.external_ext;
4148 eraw_end = (eraw_src
4149 + (input_debug.symbolic_header.iextMax
4150 * input_swap->external_ext_size));
4151 for (;
4152 eraw_src < eraw_end;
4153 eraw_src += input_swap->external_ext_size)
4154 {
4155 EXTR ext;
4156 const char *name;
4157 struct alpha_elf_link_hash_entry *h;
4158
4159 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4160 if (ext.asym.sc == scNil
4161 || ext.asym.sc == scUndefined
4162 || ext.asym.sc == scSUndefined)
4163 continue;
4164
4165 name = input_debug.ssext + ext.asym.iss;
4166 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4167 name, false, false, true);
4168 if (h == NULL || h->esym.ifd != -2)
4169 continue;
4170
4171 if (ext.ifd != -1)
4172 {
4173 BFD_ASSERT (ext.ifd
4174 < input_debug.symbolic_header.ifdMax);
4175 ext.ifd = input_debug.ifdmap[ext.ifd];
4176 }
4177
4178 h->esym = ext;
4179 }
4180
4181 /* Free up the information we just read. */
4182 free (input_debug.line);
4183 free (input_debug.external_dnr);
4184 free (input_debug.external_pdr);
4185 free (input_debug.external_sym);
4186 free (input_debug.external_opt);
4187 free (input_debug.external_aux);
4188 free (input_debug.ss);
4189 free (input_debug.ssext);
4190 free (input_debug.external_fdr);
4191 free (input_debug.external_rfd);
4192 free (input_debug.external_ext);
4193
4194 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4195 elf_link_input_bfd ignores this section. */
4196 input_section->flags &=~ SEC_HAS_CONTENTS;
4197 }
4198
252b5132
RH		 4199 /* Build the external symbol information. */
4200 einfo.abfd = abfd;
4201 einfo.info = info;
4202 einfo.debug = &debug;
4203 einfo.swap = swap;
4204 einfo.failed = false;
4205 elf_link_hash_traverse (elf_hash_table (info),
4206 elf64_alpha_output_extsym,
4207 (PTR) &einfo);
4208 if (einfo.failed)
4209 return false;
4210
4211 /* Set the size of the .mdebug section. */
4212 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4213
4214 /* Skip this section later on (I don't think this currently
4215 matters, but someday it might). */
4216 o->link_order_head = (struct bfd_link_order *) NULL;
4217
4218 mdebug_sec = o;
4219 }
252b5132
RH		 4220 }
4221
4222 /* Invoke the regular ELF backend linker to do all the work. */
4223 if (! bfd_elf64_bfd_final_link (abfd, info))
4224 return false;
4225
4226 /* Now write out the computed sections. */
4227
4228 /* The .got subsections... */
4229 {
4230 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4231 for (i = alpha_elf_hash_table(info)->got_list;
4232 i != NULL;
4233 i = alpha_elf_tdata(i)->got_link_next)
4234 {
4235 asection *sgot;
4236
4237 /* elf_bfd_final_link already did everything in dynobj. */
4238 if (i == dynobj)
4239 continue;
4240
4241 sgot = alpha_elf_tdata(i)->got;
4242 if (! bfd_set_section_contents (abfd, sgot->output_section,
dc810e39
AM		 4243 sgot->contents,
4244 (file_ptr) sgot->output_offset,
252b5132
RH		 4245 sgot->_raw_size))
4246 return false;
4247 }
4248 }
4249
252b5132
RH		 4250 if (mdebug_sec != (asection *) NULL)
4251 {
4252 BFD_ASSERT (abfd->output_has_begun);
4253 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4254 swap, info,
4255 mdebug_sec->filepos))
4256 return false;
4257
4258 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4259 }
4260
252b5132
RH		 4261 return true;
4262}
fcfbdf31
JJ		 4263
4264static enum elf_reloc_type_class
f51e552e
AM		 4265elf64_alpha_reloc_type_class (rela)
4266 const Elf_Internal_Rela *rela;
fcfbdf31 4267{
f51e552e 4268 switch ((int) ELF64_R_TYPE (rela->r_info))
fcfbdf31
JJ		 4269 {
4270 case R_ALPHA_RELATIVE:
4271 return reloc_class_relative;
4272 case R_ALPHA_JMP_SLOT:
4273 return reloc_class_plt;
4274 case R_ALPHA_COPY:
4275 return reloc_class_copy;
4276 default:
4277 return reloc_class_normal;
4278 }
4279}
252b5132
RH		 4280\f
4281/* ECOFF swapping routines. These are used when dealing with the
4282 .mdebug section, which is in the ECOFF debugging format. Copied
fe8bc63d 4283 from elf32-mips.c. */
252b5132
RH		 4284static const struct ecoff_debug_swap
4285elf64_alpha_ecoff_debug_swap =
4286{
4287 /* Symbol table magic number. */
4288 magicSym2,
4289 /* Alignment of debugging information. E.g., 4. */
4290 8,
4291 /* Sizes of external symbolic information. */
4292 sizeof (struct hdr_ext),
4293 sizeof (struct dnr_ext),
4294 sizeof (struct pdr_ext),
4295 sizeof (struct sym_ext),
4296 sizeof (struct opt_ext),
4297 sizeof (struct fdr_ext),
4298 sizeof (struct rfd_ext),
4299 sizeof (struct ext_ext),
4300 /* Functions to swap in external symbolic data. */
4301 ecoff_swap_hdr_in,
4302 ecoff_swap_dnr_in,
4303 ecoff_swap_pdr_in,
4304 ecoff_swap_sym_in,
4305 ecoff_swap_opt_in,
4306 ecoff_swap_fdr_in,
4307 ecoff_swap_rfd_in,
4308 ecoff_swap_ext_in,
4309 _bfd_ecoff_swap_tir_in,
4310 _bfd_ecoff_swap_rndx_in,
4311 /* Functions to swap out external symbolic data. */
4312 ecoff_swap_hdr_out,
4313 ecoff_swap_dnr_out,
4314 ecoff_swap_pdr_out,
4315 ecoff_swap_sym_out,
4316 ecoff_swap_opt_out,
4317 ecoff_swap_fdr_out,
4318 ecoff_swap_rfd_out,
4319 ecoff_swap_ext_out,
4320 _bfd_ecoff_swap_tir_out,
4321 _bfd_ecoff_swap_rndx_out,
4322 /* Function to read in symbolic data. */
4323 elf64_alpha_read_ecoff_info
4324};
4325\f
70bcb145
JW		 4326/* Use a non-standard hash bucket size of 8. */
4327
4328const struct elf_size_info alpha_elf_size_info =
4329{
4330 sizeof (Elf64_External_Ehdr),
4331 sizeof (Elf64_External_Phdr),
4332 sizeof (Elf64_External_Shdr),
4333 sizeof (Elf64_External_Rel),
4334 sizeof (Elf64_External_Rela),
4335 sizeof (Elf64_External_Sym),
4336 sizeof (Elf64_External_Dyn),
4337 sizeof (Elf_External_Note),
4338 8,
4339 1,
4340 64, 8,
4341 ELFCLASS64, EV_CURRENT,
4342 bfd_elf64_write_out_phdrs,
4343 bfd_elf64_write_shdrs_and_ehdr,
4344 bfd_elf64_write_relocs,
4345 bfd_elf64_swap_symbol_out,
4346 bfd_elf64_slurp_reloc_table,
4347 bfd_elf64_slurp_symbol_table,
4348 bfd_elf64_swap_dyn_in,
4349 bfd_elf64_swap_dyn_out,
4350 NULL,
4351 NULL,
4352 NULL,
4353 NULL
4354};
4355
252b5132
RH		 4356#define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4357#define TARGET_LITTLE_NAME "elf64-alpha"
4358#define ELF_ARCH bfd_arch_alpha
56fc028e
AJ		 4359#define ELF_MACHINE_CODE EM_ALPHA
4360#define ELF_MAXPAGESIZE 0x10000
252b5132
RH		 4361
4362#define bfd_elf64_bfd_link_hash_table_create \
4363 elf64_alpha_bfd_link_hash_table_create
4364
4365#define bfd_elf64_bfd_reloc_type_lookup \
4366 elf64_alpha_bfd_reloc_type_lookup
4367#define elf_info_to_howto \
4368 elf64_alpha_info_to_howto
4369
4370#define bfd_elf64_mkobject \
4371 elf64_alpha_mkobject
4372#define elf_backend_object_p \
4373 elf64_alpha_object_p
4374
4375#define elf_backend_section_from_shdr \
4376 elf64_alpha_section_from_shdr
204692d7
RH		 4377#define elf_backend_section_flags \
4378 elf64_alpha_section_flags
252b5132
RH		 4379#define elf_backend_fake_sections \
4380 elf64_alpha_fake_sections
4381
4382#define bfd_elf64_bfd_is_local_label_name \
4383 elf64_alpha_is_local_label_name
4384#define bfd_elf64_find_nearest_line \
4385 elf64_alpha_find_nearest_line
4386#define bfd_elf64_bfd_relax_section \
4387 elf64_alpha_relax_section
4388
4389#define elf_backend_add_symbol_hook \
4390 elf64_alpha_add_symbol_hook
4391#define elf_backend_check_relocs \
4392 elf64_alpha_check_relocs
4393#define elf_backend_create_dynamic_sections \
4394 elf64_alpha_create_dynamic_sections
4395#define elf_backend_adjust_dynamic_symbol \
4396 elf64_alpha_adjust_dynamic_symbol
4397#define elf_backend_always_size_sections \
4398 elf64_alpha_always_size_sections
4399#define elf_backend_size_dynamic_sections \
4400 elf64_alpha_size_dynamic_sections
4401#define elf_backend_relocate_section \
4402 elf64_alpha_relocate_section
4403#define elf_backend_finish_dynamic_symbol \
4404 elf64_alpha_finish_dynamic_symbol
4405#define elf_backend_finish_dynamic_sections \
4406 elf64_alpha_finish_dynamic_sections
4407#define bfd_elf64_bfd_final_link \
4408 elf64_alpha_final_link
fcfbdf31
JJ		 4409#define elf_backend_reloc_type_class \
4410 elf64_alpha_reloc_type_class
252b5132
RH		 4411
4412#define elf_backend_ecoff_debug_swap \
4413 &elf64_alpha_ecoff_debug_swap
4414
70bcb145
JW		 4415#define elf_backend_size_info \
4416 alpha_elf_size_info
4417
38b1a46c 4418/* A few constants that determine how the .plt section is set up. */
252b5132
RH		 4419#define elf_backend_want_got_plt 0
4420#define elf_backend_plt_readonly 0
4421#define elf_backend_want_plt_sym 1
4422#define elf_backend_got_header_size 0
4423#define elf_backend_plt_header_size PLT_HEADER_SIZE
4424
4425#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.31853 seconds and 4 git commands to generate.