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