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