]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf64-alpha.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* sol-thread.c (restore_inferior_pid): Save the PID in a freshly
[thirdparty/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
95404643
RH		 2108 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2109 filename_ptr, functionname_ptr,
2110 line_ptr, 0,
2111 &elf_tdata (abfd)->dwarf2_find_line_info))
2112 return true;
2113
252b5132
RH		 2114 msec = bfd_get_section_by_name (abfd, ".mdebug");
2115 if (msec != NULL)
2116 {
2117 flagword origflags;
2118 struct mips_elf_find_line *fi;
2119 const struct ecoff_debug_swap * const swap =
2120 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2121
2122 /* If we are called during a link, alpha_elf_final_link may have
2123 cleared the SEC_HAS_CONTENTS field. We force it back on here
2124 if appropriate (which it normally will be). */
2125 origflags = msec->flags;
2126 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2127 msec->flags |= SEC_HAS_CONTENTS;
2128
2129 fi = elf_tdata (abfd)->find_line_info;
2130 if (fi == NULL)
2131 {
2132 bfd_size_type external_fdr_size;
2133 char *fraw_src;
2134 char *fraw_end;
2135 struct fdr *fdr_ptr;
2136
2137 fi = ((struct mips_elf_find_line *)
2138 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
2139 if (fi == NULL)
2140 {
2141 msec->flags = origflags;
2142 return false;
2143 }
2144
2145 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2146 {
2147 msec->flags = origflags;
2148 return false;
2149 }
2150
2151 /* Swap in the FDR information. */
2152 fi->d.fdr = ((struct fdr *)
2153 bfd_alloc (abfd,
2154 (fi->d.symbolic_header.ifdMax *
2155 sizeof (struct fdr))));
2156 if (fi->d.fdr == NULL)
2157 {
2158 msec->flags = origflags;
2159 return false;
2160 }
2161 external_fdr_size = swap->external_fdr_size;
2162 fdr_ptr = fi->d.fdr;
2163 fraw_src = (char *) fi->d.external_fdr;
2164 fraw_end = (fraw_src
2165 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2166 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2167 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2168
2169 elf_tdata (abfd)->find_line_info = fi;
2170
2171 /* Note that we don't bother to ever free this information.
2172 find_nearest_line is either called all the time, as in
2173 objdump -l, so the information should be saved, or it is
2174 rarely called, as in ld error messages, so the memory
2175 wasted is unimportant. Still, it would probably be a
2176 good idea for free_cached_info to throw it away. */
2177 }
2178
2179 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2180 &fi->i, filename_ptr, functionname_ptr,
2181 line_ptr))
2182 {
2183 msec->flags = origflags;
2184 return true;
2185 }
2186
2187 msec->flags = origflags;
2188 }
2189
2190 /* Fall back on the generic ELF find_nearest_line routine. */
2191
2192 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2193 filename_ptr, functionname_ptr,
2194 line_ptr);
2195}
2196\f
2197/* Structure used to pass information to alpha_elf_output_extsym. */
2198
2199struct extsym_info
2200{
2201 bfd *abfd;
2202 struct bfd_link_info *info;
2203 struct ecoff_debug_info *debug;
2204 const struct ecoff_debug_swap *swap;
2205 boolean failed;
2206};
2207
2208static boolean
2209elf64_alpha_output_extsym (h, data)
2210 struct alpha_elf_link_hash_entry *h;
2211 PTR data;
2212{
2213 struct extsym_info *einfo = (struct extsym_info *) data;
2214 boolean strip;
2215 asection *sec, *output_section;
2216
2217 if (h->root.indx == -2)
2218 strip = false;
2219 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2220 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2221 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2222 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2223 strip = true;
2224 else if (einfo->info->strip == strip_all
2225 || (einfo->info->strip == strip_some
2226 && bfd_hash_lookup (einfo->info->keep_hash,
2227 h->root.root.root.string,
2228 false, false) == NULL))
2229 strip = true;
2230 else
2231 strip = false;
2232
2233 if (strip)
2234 return true;
2235
2236 if (h->esym.ifd == -2)
2237 {
2238 h->esym.jmptbl = 0;
2239 h->esym.cobol_main = 0;
2240 h->esym.weakext = 0;
2241 h->esym.reserved = 0;
2242 h->esym.ifd = ifdNil;
2243 h->esym.asym.value = 0;
2244 h->esym.asym.st = stGlobal;
2245
2246 if (h->root.root.type != bfd_link_hash_defined
2247 && h->root.root.type != bfd_link_hash_defweak)
2248 h->esym.asym.sc = scAbs;
2249 else
2250 {
2251 const char *name;
2252
2253 sec = h->root.root.u.def.section;
2254 output_section = sec->output_section;
2255
2256 /* When making a shared library and symbol h is the one from
2257 the another shared library, OUTPUT_SECTION may be null. */
2258 if (output_section == NULL)
2259 h->esym.asym.sc = scUndefined;
2260 else
2261 {
2262 name = bfd_section_name (output_section->owner, output_section);
2263
2264 if (strcmp (name, ".text") == 0)
2265 h->esym.asym.sc = scText;
2266 else if (strcmp (name, ".data") == 0)
2267 h->esym.asym.sc = scData;
2268 else if (strcmp (name, ".sdata") == 0)
2269 h->esym.asym.sc = scSData;
2270 else if (strcmp (name, ".rodata") == 0
2271 || strcmp (name, ".rdata") == 0)
2272 h->esym.asym.sc = scRData;
2273 else if (strcmp (name, ".bss") == 0)
2274 h->esym.asym.sc = scBss;
2275 else if (strcmp (name, ".sbss") == 0)
2276 h->esym.asym.sc = scSBss;
2277 else if (strcmp (name, ".init") == 0)
2278 h->esym.asym.sc = scInit;
2279 else if (strcmp (name, ".fini") == 0)
2280 h->esym.asym.sc = scFini;
2281 else
2282 h->esym.asym.sc = scAbs;
2283 }
2284 }
2285
2286 h->esym.asym.reserved = 0;
2287 h->esym.asym.index = indexNil;
2288 }
2289
2290 if (h->root.root.type == bfd_link_hash_common)
2291 h->esym.asym.value = h->root.root.u.c.size;
2292 else if (h->root.root.type == bfd_link_hash_defined
2293 || h->root.root.type == bfd_link_hash_defweak)
2294 {
2295 if (h->esym.asym.sc == scCommon)
2296 h->esym.asym.sc = scBss;
2297 else if (h->esym.asym.sc == scSCommon)
2298 h->esym.asym.sc = scSBss;
2299
2300 sec = h->root.root.u.def.section;
2301 output_section = sec->output_section;
2302 if (output_section != NULL)
2303 h->esym.asym.value = (h->root.root.u.def.value
2304 + sec->output_offset
2305 + output_section->vma);
2306 else
2307 h->esym.asym.value = 0;
2308 }
2309 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2310 {
2311 /* Set type and value for a symbol with a function stub. */
2312 h->esym.asym.st = stProc;
2313 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2314 if (sec == NULL)
2315 h->esym.asym.value = 0;
2316 else
2317 {
2318 output_section = sec->output_section;
2319 if (output_section != NULL)
2320 h->esym.asym.value = (h->root.plt.offset
2321 + sec->output_offset
2322 + output_section->vma);
2323 else
2324 h->esym.asym.value = 0;
2325 }
2326#if 0 /* FIXME? */
2327 h->esym.ifd = 0;
2328#endif
2329 }
2330
2331 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2332 h->root.root.root.string,
2333 &h->esym))
2334 {
2335 einfo->failed = true;
2336 return false;
2337 }
2338
2339 return true;
2340}
2341
2342/* FIXME: Create a runtime procedure table from the .mdebug section.
2343
2344static boolean
2345mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2346 PTR handle;
2347 bfd *abfd;
2348 struct bfd_link_info *info;
2349 asection *s;
2350 struct ecoff_debug_info *debug;
2351*/
2352\f
2353/* Handle dynamic relocations when doing an Alpha ELF link. */
2354
2355static boolean
2356elf64_alpha_check_relocs (abfd, info, sec, relocs)
2357 bfd *abfd;
2358 struct bfd_link_info *info;
2359 asection *sec;
2360 const Elf_Internal_Rela *relocs;
2361{
2362 bfd *dynobj;
2363 asection *sreloc;
2364 const char *rel_sec_name;
2365 Elf_Internal_Shdr *symtab_hdr;
2366 struct alpha_elf_link_hash_entry **sym_hashes;
2367 struct alpha_elf_got_entry **local_got_entries;
2368 const Elf_Internal_Rela *rel, *relend;
2369 int got_created;
2370
2371 if (info->relocateable)
2372 return true;
2373
2374 dynobj = elf_hash_table(info)->dynobj;
2375 if (dynobj == NULL)
2376 elf_hash_table(info)->dynobj = dynobj = abfd;
2377
2378 sreloc = NULL;
2379 rel_sec_name = NULL;
2380 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2381 sym_hashes = alpha_elf_sym_hashes(abfd);
2382 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2383 got_created = 0;
2384
2385 relend = relocs + sec->reloc_count;
2386 for (rel = relocs; rel < relend; ++rel)
2387 {
2388 unsigned long r_symndx, r_type;
2389 struct alpha_elf_link_hash_entry *h;
2390
2391 r_symndx = ELF64_R_SYM (rel->r_info);
2392 if (r_symndx < symtab_hdr->sh_info)
2393 h = NULL;
2394 else
2395 {
2396 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2397
2398 while (h->root.root.type == bfd_link_hash_indirect
2399 || h->root.root.type == bfd_link_hash_warning)
2400 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2401
2402 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2403 }
2404 r_type = ELF64_R_TYPE (rel->r_info);
2405
2406 switch (r_type)
2407 {
2408 case R_ALPHA_LITERAL:
2409 {
2410 struct alpha_elf_got_entry *gotent;
2411 int flags = 0;
2412
2413 if (h)
2414 {
2415 /* Search for and possibly create a got entry. */
2416 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2417 if (gotent->gotobj == abfd &&
2418 gotent->addend == rel->r_addend)
2419 break;
2420
2421 if (!gotent)
2422 {
2423 gotent = ((struct alpha_elf_got_entry *)
2424 bfd_alloc (abfd,
2425 sizeof (struct alpha_elf_got_entry)));
2426 if (!gotent)
2427 return false;
2428
2429 gotent->gotobj = abfd;
2430 gotent->addend = rel->r_addend;
2431 gotent->got_offset = -1;
2432 gotent->flags = 0;
2433 gotent->use_count = 1;
2434
2435 gotent->next = h->got_entries;
2436 h->got_entries = gotent;
2437
2438 alpha_elf_tdata (abfd)->total_got_entries++;
2439 }
2440 else
2441 gotent->use_count += 1;
2442 }
2443 else
2444 {
2445 /* This is a local .got entry -- record for merge. */
2446 if (!local_got_entries)
2447 {
2448 size_t size;
2449 size = (symtab_hdr->sh_info
2450 * sizeof (struct alpha_elf_got_entry *));
2451
2452 local_got_entries = ((struct alpha_elf_got_entry **)
2453 bfd_alloc (abfd, size));
2454 if (!local_got_entries)
2455 return false;
2456
2457 memset (local_got_entries, 0, size);
2458 alpha_elf_tdata (abfd)->local_got_entries =
2459 local_got_entries;
2460 }
2461
2462 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2463 gotent != NULL && gotent->addend != rel->r_addend;
2464 gotent = gotent->next)
2465 continue;
2466 if (!gotent)
2467 {
2468 gotent = ((struct alpha_elf_got_entry *)
2469 bfd_alloc (abfd,
2470 sizeof (struct alpha_elf_got_entry)));
2471 if (!gotent)
2472 return false;
2473
2474 gotent->gotobj = abfd;
2475 gotent->addend = rel->r_addend;
2476 gotent->got_offset = -1;
2477 gotent->flags = 0;
2478 gotent->use_count = 1;
2479
2480 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2481 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2482
2483 alpha_elf_tdata(abfd)->total_got_entries++;
2484 alpha_elf_tdata(abfd)->n_local_got_entries++;
2485 }
2486 else
2487 gotent->use_count += 1;
2488 }
2489
2490 /* Remember how this literal is used from its LITUSEs.
2491 This will be important when it comes to decide if we can
2492 create a .plt entry for a function symbol. */
2493 if (rel+1 < relend
2494 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2495 {
2496 do
2497 {
2498 ++rel;
2499 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2500 flags |= 1 << rel->r_addend;
2501 }
2502 while (rel+1 < relend &&
2503 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2504 }
2505 else
2506 {
2507 /* No LITUSEs -- presumably the address is not being
2508 loaded for nothing. */
2509 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2510 }
2511
2512 gotent->flags |= flags;
2513 if (h)
2514 {
2515 /* Make a guess as to whether a .plt entry will be needed. */
2516 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2517 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2518 else
2519 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2520 }
2521 }
2522 /* FALLTHRU */
2523
2524 case R_ALPHA_GPDISP:
2525 case R_ALPHA_GPREL32:
2526 case R_ALPHA_GPRELHIGH:
2527 case R_ALPHA_GPRELLOW:
2528 /* We don't actually use the .got here, but the sections must
2529 be created before the linker maps input sections to output
2530 sections. */
2531 if (!got_created)
2532 {
2533 if (!elf64_alpha_create_got_section (abfd, info))
2534 return false;
2535
2536 /* Make sure the object's gotobj is set to itself so
2537 that we default to every object with its own .got.
2538 We'll merge .gots later once we've collected each
2539 object's info. */
2540 alpha_elf_tdata(abfd)->gotobj = abfd;
2541
2542 got_created = 1;
2543 }
2544 break;
2545
2546 case R_ALPHA_SREL16:
2547 case R_ALPHA_SREL32:
2548 case R_ALPHA_SREL64:
2549 if (h == NULL)
2550 break;
2551 /* FALLTHRU */
2552
2553 case R_ALPHA_REFLONG:
2554 case R_ALPHA_REFQUAD:
2555 if (rel_sec_name == NULL)
2556 {
2557 rel_sec_name = (bfd_elf_string_from_elf_section
2558 (abfd, elf_elfheader(abfd)->e_shstrndx,
2559 elf_section_data(sec)->rel_hdr.sh_name));
2560 if (rel_sec_name == NULL)
2561 return false;
2562
2563 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2564 && strcmp (bfd_get_section_name (abfd, sec),
2565 rel_sec_name+5) == 0);
2566 }
2567
2568 /* We need to create the section here now whether we eventually
2569 use it or not so that it gets mapped to an output section by
2570 the linker. If not used, we'll kill it in
2571 size_dynamic_sections. */
2572 if (sreloc == NULL)
2573 {
2574 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2575 if (sreloc == NULL)
2576 {
2577 sreloc = bfd_make_section (dynobj, rel_sec_name);
2578 if (sreloc == NULL
2579 || !bfd_set_section_flags (dynobj, sreloc,
dac544a8
RH		 2580 ((sec->flags & (SEC_ALLOC
2581 | SEC_LOAD))
252b5132
RH		 2582 | SEC_HAS_CONTENTS
2583 | SEC_IN_MEMORY
2584 | SEC_LINKER_CREATED
2585 | SEC_READONLY))
2586 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2587 return false;
2588 }
2589 }
2590
2591 if (h)
2592 {
2593 /* Since we havn't seen all of the input symbols yet, we
2594 don't know whether we'll actually need a dynamic relocation
2595 entry for this reloc. So make a record of it. Once we
2596 find out if this thing needs dynamic relocation we'll
fe8bc63d 2597 expand the relocation sections by the appropriate amount. */
252b5132
RH		 2598
2599 struct alpha_elf_reloc_entry *rent;
2600
2601 for (rent = h->reloc_entries; rent; rent = rent->next)
2602 if (rent->rtype == r_type && rent->srel == sreloc)
2603 break;
2604
2605 if (!rent)
2606 {
2607 rent = ((struct alpha_elf_reloc_entry *)
2608 bfd_alloc (abfd,
2609 sizeof (struct alpha_elf_reloc_entry)));
2610 if (!rent)
2611 return false;
2612
2613 rent->srel = sreloc;
2614 rent->rtype = r_type;
2615 rent->count = 1;
2616
2617 rent->next = h->reloc_entries;
2618 h->reloc_entries = rent;
2619 }
2620 else
2621 rent->count++;
2622 }
c555c5c5 2623 else if (info->shared && (sec->flags & SEC_ALLOC))
252b5132 2624 {
c555c5c5
AM		 2625 /* If this is a shared library, and the section is to be
2626 loaded into memory, we need a RELATIVE reloc. */
252b5132
RH		 2627 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2628 }
2629 break;
2630 }
2631 }
2632
2633 return true;
2634}
2635
2636/* Adjust a symbol defined by a dynamic object and referenced by a
2637 regular object. The current definition is in some section of the
2638 dynamic object, but we're not including those sections. We have to
2639 change the definition to something the rest of the link can
2640 understand. */
2641
2642static boolean
2643elf64_alpha_adjust_dynamic_symbol (info, h)
2644 struct bfd_link_info *info;
2645 struct elf_link_hash_entry *h;
2646{
2647 bfd *dynobj;
2648 asection *s;
2649 struct alpha_elf_link_hash_entry *ah;
2650
2651 dynobj = elf_hash_table(info)->dynobj;
2652 ah = (struct alpha_elf_link_hash_entry *)h;
2653
2654 /* Now that we've seen all of the input symbols, finalize our decision
2655 about whether this symbol should get a .plt entry. */
2656
2657 if (h->root.type != bfd_link_hash_undefweak
2658 && alpha_elf_dynamic_symbol_p (h, info)
2659 && ((h->type == STT_FUNC
2660 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2661 || (h->type == STT_NOTYPE
2662 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2663 /* Don't prevent otherwise valid programs from linking by attempting
2664 to create a new .got entry somewhere. A Correct Solution would be
2665 to add a new .got section to a new object file and let it be merged
2666 somewhere later. But for now don't bother. */
2667 && ah->got_entries)
2668 {
2669 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2670
2671 s = bfd_get_section_by_name(dynobj, ".plt");
2672 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2673 return false;
2674
2675 /* The first bit of the .plt is reserved. */
2676 if (s->_raw_size == 0)
2677 s->_raw_size = PLT_HEADER_SIZE;
2678
2679 h->plt.offset = s->_raw_size;
2680 s->_raw_size += PLT_ENTRY_SIZE;
2681
2682 /* If this symbol is not defined in a regular file, and we are not
2683 generating a shared library, then set the symbol to the location
2684 in the .plt. This is required to make function pointers compare
2685 equal between the normal executable and the shared library. */
2686 if (! info->shared
2687 && h->root.type != bfd_link_hash_defweak)
2688 {
2689 h->root.u.def.section = s;
2690 h->root.u.def.value = h->plt.offset;
2691 }
2692
2693 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2694 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2695 BFD_ASSERT (s != NULL);
2696 s->_raw_size += sizeof (Elf64_External_Rela);
2697
2698 return true;
2699 }
2700 else
2701 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2702
2703 /* If this is a weak symbol, and there is a real definition, the
2704 processor independent code will have arranged for us to see the
2705 real definition first, and we can just use the same value. */
2706 if (h->weakdef != NULL)
2707 {
2708 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2709 || h->weakdef->root.type == bfd_link_hash_defweak);
2710 h->root.u.def.section = h->weakdef->root.u.def.section;
2711 h->root.u.def.value = h->weakdef->root.u.def.value;
2712 return true;
2713 }
2714
2715 /* This is a reference to a symbol defined by a dynamic object which
2716 is not a function. The Alpha, since it uses .got entries for all
2717 symbols even in regular objects, does not need the hackery of a
2718 .dynbss section and COPY dynamic relocations. */
2719
2720 return true;
2721}
2722
2723/* Symbol versioning can create new symbols, and make our old symbols
2724 indirect to the new ones. Consolidate the got and reloc information
2725 in these situations. */
2726
2727static boolean
2728elf64_alpha_merge_ind_symbols (hi, dummy)
2729 struct alpha_elf_link_hash_entry *hi;
2730 PTR dummy;
2731{
2732 struct alpha_elf_link_hash_entry *hs;
2733
2734 if (hi->root.root.type != bfd_link_hash_indirect)
2735 return true;
2736 hs = hi;
2737 do {
2738 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2739 } while (hs->root.root.type == bfd_link_hash_indirect);
2740
2741 /* Merge the flags. Whee. */
2742
2743 hs->flags |= hi->flags;
2744
2745 /* Merge the .got entries. Cannibalize the old symbol's list in
2746 doing so, since we don't need it anymore. */
2747
2748 if (hs->got_entries == NULL)
2749 hs->got_entries = hi->got_entries;
2750 else
2751 {
2752 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2753
2754 gsh = hs->got_entries;
2755 for (gi = hi->got_entries; gi ; gi = gin)
2756 {
2757 gin = gi->next;
2758 for (gs = gsh; gs ; gs = gs->next)
2759 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2760 goto got_found;
2761 gi->next = hs->got_entries;
2762 hs->got_entries = gi;
2763 got_found:;
2764 }
2765 }
2766 hi->got_entries = NULL;
2767
2768 /* And similar for the reloc entries. */
2769
2770 if (hs->reloc_entries == NULL)
2771 hs->reloc_entries = hi->reloc_entries;
2772 else
2773 {
2774 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2775
2776 rsh = hs->reloc_entries;
2777 for (ri = hi->reloc_entries; ri ; ri = rin)
2778 {
2779 rin = ri->next;
2780 for (rs = rsh; rs ; rs = rs->next)
2781 if (ri->rtype == rs->rtype)
2782 {
2783 rs->count += ri->count;
2784 goto found_reloc;
2785 }
2786 ri->next = hs->reloc_entries;
2787 hs->reloc_entries = ri;
2788 found_reloc:;
2789 }
2790 }
2791 hi->reloc_entries = NULL;
2792
2793 return true;
2794}
2795
2796/* Is it possible to merge two object file's .got tables? */
2797
2798static boolean
2799elf64_alpha_can_merge_gots (a, b)
2800 bfd *a, *b;
2801{
2802 int total = alpha_elf_tdata (a)->total_got_entries;
2803 bfd *bsub;
2804
2805 /* Trivial quick fallout test. */
2806 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2807 return true;
2808
2809 /* By their nature, local .got entries cannot be merged. */
2810 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2811 return false;
2812
2813 /* Failing the common trivial comparison, we must effectively
2814 perform the merge. Not actually performing the merge means that
2815 we don't have to store undo information in case we fail. */
2816 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2817 {
2818 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2819 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2820 int i, n;
2821
2822 n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2823 for (i = 0; i < n; ++i)
2824 {
2825 struct alpha_elf_got_entry *ae, *be;
2826 struct alpha_elf_link_hash_entry *h;
2827
2828 h = hashes[i];
2829 while (h->root.root.type == bfd_link_hash_indirect
2830 || h->root.root.type == bfd_link_hash_warning)
2831 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2832
2833 for (be = h->got_entries; be ; be = be->next)
2834 {
2835 if (be->use_count == 0)
2836 continue;
2837 if (be->gotobj != b)
2838 continue;
2839
2840 for (ae = h->got_entries; ae ; ae = ae->next)
2841 if (ae->gotobj == a && ae->addend == be->addend)
2842 goto global_found;
2843
2844 if (++total > MAX_GOT_ENTRIES)
2845 return false;
2846 global_found:;
2847 }
2848 }
2849 }
2850
2851 return true;
2852}
2853
2854/* Actually merge two .got tables. */
2855
2856static void
2857elf64_alpha_merge_gots (a, b)
2858 bfd *a, *b;
2859{
2860 int total = alpha_elf_tdata (a)->total_got_entries;
2861 bfd *bsub;
2862
2863 /* Remember local expansion. */
2864 {
2865 int e = alpha_elf_tdata (b)->n_local_got_entries;
2866 total += e;
2867 alpha_elf_tdata (a)->n_local_got_entries += e;
2868 }
2869
2870 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2871 {
2872 struct alpha_elf_got_entry **local_got_entries;
2873 struct alpha_elf_link_hash_entry **hashes;
2874 Elf_Internal_Shdr *symtab_hdr;
2875 int i, n;
2876
2877 /* Let the local .got entries know they are part of a new subsegment. */
2878 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2879 if (local_got_entries)
2880 {
2881 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2882 for (i = 0; i < n; ++i)
2883 {
2884 struct alpha_elf_got_entry *ent;
2885 for (ent = local_got_entries[i]; ent; ent = ent->next)
2886 ent->gotobj = a;
2887 }
2888 }
2889
2890 /* Merge the global .got entries. */
2891 hashes = alpha_elf_sym_hashes (bsub);
2892 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2893
2894 n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2895 for (i = 0; i < n; ++i)
2896 {
2897 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2898 struct alpha_elf_link_hash_entry *h;
2899
2900 h = hashes[i];
2901 while (h->root.root.type == bfd_link_hash_indirect
2902 || h->root.root.type == bfd_link_hash_warning)
2903 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2904
2905 start = &h->got_entries;
2906 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2907 {
2908 if (be->use_count == 0)
2909 {
2910 *pbe = be->next;
2911 continue;
2912 }
2913 if (be->gotobj != b)
2914 continue;
2915
2916 for (ae = *start; ae ; ae = ae->next)
2917 if (ae->gotobj == a && ae->addend == be->addend)
2918 {
2919 ae->flags |= be->flags;
2920 ae->use_count += be->use_count;
2921 *pbe = be->next;
2922 goto global_found;
2923 }
2924 be->gotobj = a;
2925 total += 1;
2926
2927 global_found:;
2928 }
2929 }
2930
2931 alpha_elf_tdata (bsub)->gotobj = a;
2932 }
2933 alpha_elf_tdata (a)->total_got_entries = total;
2934
2935 /* Merge the two in_got chains. */
2936 {
2937 bfd *next;
2938
2939 bsub = a;
2940 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2941 bsub = next;
2942
2943 alpha_elf_tdata (bsub)->in_got_link_next = b;
2944 }
2945}
2946
2947/* Calculate the offsets for the got entries. */
2948
2949static boolean
2950elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2951 struct alpha_elf_link_hash_entry *h;
2952 PTR arg;
2953{
2954 struct alpha_elf_got_entry *gotent;
2955
2956 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2957 if (gotent->use_count > 0)
2958 {
2959 bfd_size_type *plge
2960 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2961
2962 gotent->got_offset = *plge;
2963 *plge += 8;
2964 }
2965
2966 return true;
2967}
2968
2969static void
2970elf64_alpha_calc_got_offsets (info)
2971 struct bfd_link_info *info;
2972{
2973 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2974
2975 /* First, zero out the .got sizes, as we may be recalculating the
2976 .got after optimizing it. */
2977 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2978 alpha_elf_tdata(i)->got->_raw_size = 0;
2979
2980 /* Next, fill in the offsets for all the global entries. */
2981 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2982 elf64_alpha_calc_got_offsets_for_symbol,
2983 NULL);
2984
2985 /* Finally, fill in the offsets for the local entries. */
2986 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2987 {
2988 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2989 bfd *j;
2990
2991 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2992 {
2993 struct alpha_elf_got_entry **local_got_entries, *gotent;
2994 int k, n;
2995
2996 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2997 if (!local_got_entries)
2998 continue;
2999
3000 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3001 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
3002 if (gotent->use_count > 0)
3003 {
3004 gotent->got_offset = got_offset;
3005 got_offset += 8;
3006 }
3007 }
3008
3009 alpha_elf_tdata(i)->got->_raw_size = got_offset;
3010 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
3011 }
3012}
3013
3014/* Constructs the gots. */
3015
3016static boolean
3017elf64_alpha_size_got_sections (output_bfd, info)
3018 bfd *output_bfd;
3019 struct bfd_link_info *info;
3020{
3021 bfd *i, *got_list, *cur_got_obj;
3022 int something_changed = 0;
3023
3024 got_list = alpha_elf_hash_table (info)->got_list;
3025
3026 /* On the first time through, pretend we have an existing got list
3027 consisting of all of the input files. */
3028 if (got_list == NULL)
3029 {
3030 for (i = info->input_bfds; i ; i = i->link_next)
3031 {
3032 bfd *this_got = alpha_elf_tdata (i)->gotobj;
3033 if (this_got == NULL)
3034 continue;
3035
3036 /* We are assuming no merging has yet ocurred. */
3037 BFD_ASSERT (this_got == i);
3038
3039 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
3040 {
3041 /* Yikes! A single object file has too many entries. */
3042 (*_bfd_error_handler)
3043 (_("%s: .got subsegment exceeds 64K (size %d)"),
3044 bfd_get_filename (i),
3045 alpha_elf_tdata (this_got)->total_got_entries * 8);
3046 return false;
3047 }
3048
3049 if (got_list == NULL)
3050 got_list = this_got;
3051 else
3052 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3053 cur_got_obj = this_got;
3054 }
3055
3056 /* Strange degenerate case of no got references. */
3057 if (got_list == NULL)
3058 return true;
3059
3060 alpha_elf_hash_table (info)->got_list = got_list;
3061
3062 /* Force got offsets to be recalculated. */
3063 something_changed = 1;
3064 }
3065
3066 cur_got_obj = got_list;
3067 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3068 while (i != NULL)
3069 {
3070 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3071 {
3072 elf64_alpha_merge_gots (cur_got_obj, i);
3073 i = alpha_elf_tdata(i)->got_link_next;
3074 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3075 something_changed = 1;
3076 }
3077 else
3078 {
3079 cur_got_obj = i;
3080 i = alpha_elf_tdata(i)->got_link_next;
3081 }
3082 }
3083
3084 /* Once the gots have been merged, fill in the got offsets for
3085 everything therein. */
3086 if (1 || something_changed)
3087 elf64_alpha_calc_got_offsets (info);
3088
3089 return true;
3090}
3091
3092static boolean
3093elf64_alpha_always_size_sections (output_bfd, info)
3094 bfd *output_bfd;
3095 struct bfd_link_info *info;
3096{
3097 bfd *i;
3098
3099 if (info->relocateable)
3100 return true;
3101
3102 /* First, take care of the indirect symbols created by versioning. */
3103 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3104 elf64_alpha_merge_ind_symbols,
3105 NULL);
3106
3107 if (!elf64_alpha_size_got_sections (output_bfd, info))
3108 return false;
3109
3110 /* Allocate space for all of the .got subsections. */
3111 i = alpha_elf_hash_table (info)->got_list;
3112 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3113 {
3114 asection *s = alpha_elf_tdata(i)->got;
3115 if (s->_raw_size > 0)
3116 {
3117 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3118 if (s->contents == NULL)
3119 return false;
3120 }
3121 }
3122
3123 return true;
3124}
3125
3126/* Work out the sizes of the dynamic relocation entries. */
3127
3128static boolean
3129elf64_alpha_calc_dynrel_sizes (h, info)
3130 struct alpha_elf_link_hash_entry *h;
3131 struct bfd_link_info *info;
3132{
3133 /* If the symbol was defined as a common symbol in a regular object
3134 file, and there was no definition in any dynamic object, then the
3135 linker will have allocated space for the symbol in a common
3136 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3137 set. This is done for dynamic symbols in
3138 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3139 symbols, somehow. */
3140 if (((h->root.elf_link_hash_flags
3141 & (ELF_LINK_HASH_DEF_REGULAR
3142 | ELF_LINK_HASH_REF_REGULAR
3143 | ELF_LINK_HASH_DEF_DYNAMIC))
3144 == ELF_LINK_HASH_REF_REGULAR)
3145 && (h->root.root.type == bfd_link_hash_defined
3146 || h->root.root.type == bfd_link_hash_defweak)
3147 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3148 {
3149 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3150 }
3151
3152 /* If the symbol is dynamic, we'll need all the relocations in their
3153 natural form. If this is a shared object, and it has been forced
3154 local, we'll need the same number of RELATIVE relocations. */
3155
3156 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3157 {
3158 struct alpha_elf_reloc_entry *relent;
3159 bfd *dynobj;
3160 struct alpha_elf_got_entry *gotent;
3161 bfd_size_type count;
3162 asection *srel;
3163
3164 for (relent = h->reloc_entries; relent; relent = relent->next)
3165 if (relent->rtype == R_ALPHA_REFLONG
3166 || relent->rtype == R_ALPHA_REFQUAD)
3167 {
3168 relent->srel->_raw_size +=
fe8bc63d 3169 sizeof (Elf64_External_Rela) * relent->count;
252b5132
RH		 3170 }
3171
3172 dynobj = elf_hash_table(info)->dynobj;
3173 count = 0;
3174
3175 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3176 count++;
3177
3178 /* If we are using a .plt entry, subtract one, as the first
3179 reference uses a .rela.plt entry instead. */
3180 if (h->root.plt.offset != MINUS_ONE)
3181 count--;
3182
3183 if (count > 0)
3184 {
3185 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3186 BFD_ASSERT (srel != NULL);
3187 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3188 }
3189 }
3190
3191 return true;
3192}
3193
3194/* Set the sizes of the dynamic sections. */
3195
3196static boolean
3197elf64_alpha_size_dynamic_sections (output_bfd, info)
3198 bfd *output_bfd;
3199 struct bfd_link_info *info;
3200{
3201 bfd *dynobj;
3202 asection *s;
3203 boolean reltext;
3204 boolean relplt;
3205
3206 dynobj = elf_hash_table(info)->dynobj;
3207 BFD_ASSERT(dynobj != NULL);
3208
3209 if (elf_hash_table (info)->dynamic_sections_created)
3210 {
3211 /* Set the contents of the .interp section to the interpreter. */
3212 if (!info->shared)
3213 {
3214 s = bfd_get_section_by_name (dynobj, ".interp");
3215 BFD_ASSERT (s != NULL);
3216 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3217 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3218 }
3219
3220 /* Now that we've seen all of the input files, we can decide which
3221 symbols need dynamic relocation entries and which don't. We've
3222 collected information in check_relocs that we can now apply to
3223 size the dynamic relocation sections. */
3224 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3225 elf64_alpha_calc_dynrel_sizes,
3226 info);
3227
3228 /* When building shared libraries, each local .got entry needs a
3229 RELATIVE reloc. */
3230 if (info->shared)
3231 {
3232 bfd *i;
3233 asection *srel;
3234 bfd_size_type count;
3235
3236 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3237 BFD_ASSERT (srel != NULL);
3238
3239 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3240 i != NULL;
3241 i = alpha_elf_tdata(i)->got_link_next)
3242 count += alpha_elf_tdata(i)->n_local_got_entries;
3243
fe8bc63d 3244 srel->_raw_size += count * sizeof (Elf64_External_Rela);
252b5132
RH		 3245 }
3246 }
3247 /* else we're not dynamic and by definition we don't need such things. */
3248
3249 /* The check_relocs and adjust_dynamic_symbol entry points have
3250 determined the sizes of the various dynamic sections. Allocate
3251 memory for them. */
3252 reltext = false;
3253 relplt = false;
3254 for (s = dynobj->sections; s != NULL; s = s->next)
3255 {
3256 const char *name;
3257 boolean strip;
3258
3259 if (!(s->flags & SEC_LINKER_CREATED))
3260 continue;
3261
3262 /* It's OK to base decisions on the section name, because none
3263 of the dynobj section names depend upon the input files. */
3264 name = bfd_get_section_name (dynobj, s);
3265
3266 /* If we don't need this section, strip it from the output file.
3267 This is to handle .rela.bss and .rela.plt. We must create it
3268 in create_dynamic_sections, because it must be created before
3269 the linker maps input sections to output sections. The
3270 linker does that before adjust_dynamic_symbol is called, and
3271 it is that function which decides whether anything needs to
3272 go into these sections. */
3273
3274 strip = false;
3275
3276 if (strncmp (name, ".rela", 5) == 0)
3277 {
3278 strip = (s->_raw_size == 0);
3279
3280 if (!strip)
3281 {
3282 const char *outname;
3283 asection *target;
3284
3285 /* If this relocation section applies to a read only
3286 section, then we probably need a DT_TEXTREL entry. */
3287 outname = bfd_get_section_name (output_bfd,
3288 s->output_section);
3289 target = bfd_get_section_by_name (output_bfd, outname + 5);
3290 if (target != NULL
3291 && (target->flags & SEC_READONLY) != 0
3292 && (target->flags & SEC_ALLOC) != 0)
3293 reltext = true;
3294
3295 if (strcmp(name, ".rela.plt") == 0)
3296 relplt = true;
3297
3298 /* We use the reloc_count field as a counter if we need
3299 to copy relocs into the output file. */
3300 s->reloc_count = 0;
3301 }
3302 }
3303 else if (strcmp (name, ".plt") != 0)
3304 {
3305 /* It's not one of our dynamic sections, so don't allocate space. */
3306 continue;
3307 }
3308
3309 if (strip)
7f8d5fc9 3310 _bfd_strip_section_from_output (info, s);
252b5132
RH		 3311 else
3312 {
3313 /* Allocate memory for the section contents. */
3314 s->contents = (bfd_byte *) bfd_zalloc(dynobj, s->_raw_size);
3315 if (s->contents == NULL && s->_raw_size != 0)
3316 return false;
3317 }
3318 }
3319
252b5132
RH		 3320 if (elf_hash_table (info)->dynamic_sections_created)
3321 {
3322 /* Add some entries to the .dynamic section. We fill in the
3323 values later, in elf64_alpha_finish_dynamic_sections, but we
3324 must add the entries now so that we get the correct size for
3325 the .dynamic section. The DT_DEBUG entry is filled in by the
3326 dynamic linker and used by the debugger. */
3327 if (!info->shared)
3328 {
3329 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
3330 return false;
3331 }
3332
3333 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
3334 return false;
3335
3336 if (relplt)
3337 {
3338 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3339 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3340 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
3341 return false;
3342 }
3343
3344 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
3345 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
3346 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
fe8bc63d 3347 sizeof (Elf64_External_Rela)))
252b5132
RH		 3348 return false;
3349
3350 if (reltext)
3351 {
3352 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
3353 return false;
d6cf2879 3354 info->flags |= DF_TEXTREL;
252b5132
RH		 3355 }
3356 }
3357
3358 return true;
3359}
3360
252b5132
RH		 3361/* Relocate an Alpha ELF section. */
3362
3363static boolean
3364elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3365 contents, relocs, local_syms, local_sections)
3366 bfd *output_bfd;
3367 struct bfd_link_info *info;
3368 bfd *input_bfd;
3369 asection *input_section;
3370 bfd_byte *contents;
3371 Elf_Internal_Rela *relocs;
3372 Elf_Internal_Sym *local_syms;
3373 asection **local_sections;
3374{
3375 Elf_Internal_Shdr *symtab_hdr;
3376 Elf_Internal_Rela *rel;
3377 Elf_Internal_Rela *relend;
3378 asection *sec, *sgot, *srel, *srelgot;
3379 bfd *dynobj, *gotobj;
3380 bfd_vma gp;
3381
3382 srelgot = srel = NULL;
3383 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3384 dynobj = elf_hash_table (info)->dynobj;
3385 if (dynobj)
3386 {
3387 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3388 }
3389
3390 /* Find the gp value for this input bfd. */
3391 sgot = NULL;
3392 gp = 0;
3393 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3394 if (gotobj)
3395 {
3396 sgot = alpha_elf_tdata (gotobj)->got;
3397 gp = _bfd_get_gp_value (gotobj);
3398 if (gp == 0)
3399 {
3400 gp = (sgot->output_section->vma
3401 + sgot->output_offset
3402 + 0x8000);
3403 _bfd_set_gp_value (gotobj, gp);
3404 }
3405 }
3406
3407 rel = relocs;
3408 relend = relocs + input_section->reloc_count;
3409 for (; rel < relend; rel++)
3410 {
3411 int r_type;
3412 reloc_howto_type *howto;
3413 unsigned long r_symndx;
3414 struct alpha_elf_link_hash_entry *h;
3415 Elf_Internal_Sym *sym;
3416 bfd_vma relocation;
3417 bfd_vma addend;
3418 bfd_reloc_status_type r;
3419
3420 r_type = ELF64_R_TYPE(rel->r_info);
3421 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3422 {
3423 bfd_set_error (bfd_error_bad_value);
3424 return false;
3425 }
3426 howto = elf64_alpha_howto_table + r_type;
3427
3428 r_symndx = ELF64_R_SYM(rel->r_info);
3429
3430 if (info->relocateable)
3431 {
3432 /* This is a relocateable link. We don't have to change
3433 anything, unless the reloc is against a section symbol,
3434 in which case we have to adjust according to where the
3435 section symbol winds up in the output section. */
72b60c23 3436
fe8bc63d 3437 /* The symbol associated with GPDISP and LITUSE is
72b60c23
RH		 3438 immaterial. Only the addend is significant. */
3439 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3440 continue;
3441
252b5132
RH		 3442 if (r_symndx < symtab_hdr->sh_info)
3443 {
3444 sym = local_syms + r_symndx;
3445 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3446 {
3447 sec = local_sections[r_symndx];
3448 rel->r_addend += sec->output_offset + sym->st_value;
3449 }
3450 }
3451
3452 continue;
3453 }
3454
3455 /* This is a final link. */
3456
3457 h = NULL;
3458 sym = NULL;
3459 sec = NULL;
3460
3461 if (r_symndx < symtab_hdr->sh_info)
3462 {
3463 sym = local_syms + r_symndx;
3464 sec = local_sections[r_symndx];
3465 relocation = (sec->output_section->vma
3466 + sec->output_offset
3467 + sym->st_value);
3468 }
3469 else
3470 {
3471 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3472
3473 while (h->root.root.type == bfd_link_hash_indirect
3474 || h->root.root.type == bfd_link_hash_warning)
3475 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3476
3477 if (h->root.root.type == bfd_link_hash_defined
3478 || h->root.root.type == bfd_link_hash_defweak)
3479 {
3480 sec = h->root.root.u.def.section;
3481
3482#if rth_notdef
3483 if ((r_type == R_ALPHA_LITERAL
3484 && elf_hash_table(info)->dynamic_sections_created
3485 && (!info->shared
3486 || !info->symbolic
3487 || !(h->root.elf_link_hash_flags
3488 & ELF_LINK_HASH_DEF_REGULAR)))
3489 || (info->shared
3490 && (!info->symbolic
3491 || !(h->root.elf_link_hash_flags
3492 & ELF_LINK_HASH_DEF_REGULAR))
3493 && (input_section->flags & SEC_ALLOC)
3494 && (r_type == R_ALPHA_REFLONG
3495 || r_type == R_ALPHA_REFQUAD
3496 || r_type == R_ALPHA_LITERAL)))
3497 {
3498 /* In these cases, we don't need the relocation value.
3499 We check specially because in some obscure cases
3500 sec->output_section will be NULL. */
3501 relocation = 0;
3502 }
3503#else
3504 /* FIXME: Are not these obscure cases simply bugs? Let's
3505 get something working and come back to this. */
3506 if (sec->output_section == NULL)
3507 relocation = 0;
3508#endif /* rth_notdef */
3509 else
3510 {
3511 relocation = (h->root.root.u.def.value
3512 + sec->output_section->vma
3513 + sec->output_offset);
3514 }
3515 }
3516 else if (h->root.root.type == bfd_link_hash_undefweak)
3517 relocation = 0;
3a27a730
L		 3518 else if (info->shared && !info->symbolic
3519 && !info->no_undefined
edb72b3b 3520 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
252b5132
RH		 3521 relocation = 0;
3522 else
3523 {
3524 if (!((*info->callbacks->undefined_symbol)
3525 (info, h->root.root.root.string, input_bfd,
5cc7c785 3526 input_section, rel->r_offset,
3a27a730 3527 (!info->shared || info->no_undefined
edb72b3b 3528 || ELF_ST_VISIBILITY (h->root.other)))))
252b5132
RH		 3529 return false;
3530 relocation = 0;
3531 }
3532 }
3533 addend = rel->r_addend;
3534
3535 switch (r_type)
3536 {
3537 case R_ALPHA_GPDISP:
3538 {
3539 bfd_byte *p_ldah, *p_lda;
3540
3541 BFD_ASSERT(gp != 0);
3542
3543 relocation = (input_section->output_section->vma
3544 + input_section->output_offset
3545 + rel->r_offset);
3546
3547 p_ldah = contents + rel->r_offset - input_section->vma;
3548 p_lda = p_ldah + rel->r_addend;
3549
3550 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3551 p_ldah, p_lda);
3552 }
3553 break;
3554
3555 case R_ALPHA_OP_PUSH:
3556 case R_ALPHA_OP_STORE:
3557 case R_ALPHA_OP_PSUB:
3558 case R_ALPHA_OP_PRSHIFT:
3559 /* We hate these silly beasts. */
fe8bc63d 3560 abort ();
252b5132
RH		 3561
3562 case R_ALPHA_LITERAL:
3563 {
3564 struct alpha_elf_got_entry *gotent;
3565 boolean dynamic_symbol;
3566
3567 BFD_ASSERT(sgot != NULL);
3568 BFD_ASSERT(gp != 0);
3569
3570 if (h != NULL)
3571 {
3572 gotent = h->got_entries;
3573 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3574 }
3575 else
3576 {
3577 gotent = (alpha_elf_tdata(input_bfd)->
3578 local_got_entries[r_symndx]);
3579 dynamic_symbol = false;
3580 }
3581
3582 BFD_ASSERT(gotent != NULL);
3583
3584 while (gotent->gotobj != gotobj || gotent->addend != addend)
3585 gotent = gotent->next;
3586
3587 BFD_ASSERT(gotent->use_count >= 1);
3588
3589 /* Initialize the .got entry's value. */
3590 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3591 {
3592 bfd_put_64 (output_bfd, relocation+addend,
3593 sgot->contents + gotent->got_offset);
3594
3595 /* If the symbol has been forced local, output a
3596 RELATIVE reloc, otherwise it will be handled in
3597 finish_dynamic_symbol. */
3598 if (info->shared && !dynamic_symbol)
3599 {
3600 Elf_Internal_Rela outrel;
3601
3602 BFD_ASSERT(srelgot != NULL);
3603
3604 outrel.r_offset = (sgot->output_section->vma
3605 + sgot->output_offset
3606 + gotent->got_offset);
3607 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3608 outrel.r_addend = 0;
3609
3610 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3611 ((Elf64_External_Rela *)
3612 srelgot->contents)
3613 + srelgot->reloc_count++);
fe8bc63d 3614 BFD_ASSERT (sizeof (Elf64_External_Rela)
252b5132
RH		 3615 * srelgot->reloc_count
3616 <= srelgot->_cooked_size);
3617 }
3618
3619 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3620 }
3621
3622 /* Figure the gprel relocation. */
3623 addend = 0;
3624 relocation = (sgot->output_section->vma
3625 + sgot->output_offset
3626 + gotent->got_offset);
3627 relocation -= gp;
3628 }
3629 /* overflow handled by _bfd_final_link_relocate */
3630 goto default_reloc;
3631
3632 case R_ALPHA_GPREL32:
3633 case R_ALPHA_GPRELLOW:
3634 BFD_ASSERT(gp != 0);
3635 relocation -= gp;
3636 goto default_reloc;
3637
3638 case R_ALPHA_GPRELHIGH:
3639 BFD_ASSERT(gp != 0);
3640 relocation -= gp;
3641 relocation += addend;
3642 addend = 0;
3643 relocation = (((bfd_signed_vma) relocation >> 16)
3644 + ((relocation >> 15) & 1));
3645 goto default_reloc;
3646
3647 case R_ALPHA_BRADDR:
3648 case R_ALPHA_HINT:
3649 /* The regular PC-relative stuff measures from the start of
3650 the instruction rather than the end. */
3651 addend -= 4;
3652 goto default_reloc;
3653
3654 case R_ALPHA_REFLONG:
3655 case R_ALPHA_REFQUAD:
3656 {
3657 Elf_Internal_Rela outrel;
3658 boolean skip;
3659
3660 /* Careful here to remember RELATIVE relocations for global
3661 variables for symbolic shared objects. */
3662
3663 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3664 {
3665 BFD_ASSERT(h->root.dynindx != -1);
3666 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3667 outrel.r_addend = addend;
3668 addend = 0, relocation = 0;
3669 }
c555c5c5 3670 else if (info->shared && (input_section->flags & SEC_ALLOC))
252b5132
RH		 3671 {
3672 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3673 outrel.r_addend = 0;
3674 }
3675 else
3676 goto default_reloc;
3677
3678 if (!srel)
3679 {
3680 const char *name;
3681
3682 name = (bfd_elf_string_from_elf_section
3683 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3684 elf_section_data(input_section)->rel_hdr.sh_name));
3685 BFD_ASSERT(name != NULL);
3686
3687 srel = bfd_get_section_by_name (dynobj, name);
3688 BFD_ASSERT(srel != NULL);
3689 }
3690
3691 skip = false;
3692
3693 if (elf_section_data (input_section)->stab_info == NULL)
3694 outrel.r_offset = rel->r_offset;
3695 else
3696 {
3697 bfd_vma off;
3698
3699 off = (_bfd_stab_section_offset
3700 (output_bfd, &elf_hash_table (info)->stab_info,
3701 input_section,
3702 &elf_section_data (input_section)->stab_info,
3703 rel->r_offset));
3704 if (off == (bfd_vma) -1)
3705 skip = true;
3706 outrel.r_offset = off;
3707 }
3708
3709 if (! skip)
3710 outrel.r_offset += (input_section->output_section->vma
3711 + input_section->output_offset);
3712 else
3713 memset (&outrel, 0, sizeof outrel);
3714
3715 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3716 ((Elf64_External_Rela *)
3717 srel->contents)
3718 + srel->reloc_count++);
fe8bc63d 3719 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 3720 <= srel->_cooked_size);
3721 }
3722 goto default_reloc;
3723
3724 default:
3725 default_reloc:
3726 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3727 contents, rel->r_offset, relocation,
3728 addend);
3729 break;
3730 }
3731
3732 switch (r)
3733 {
3734 case bfd_reloc_ok:
3735 break;
3736
3737 case bfd_reloc_overflow:
3738 {
3739 const char *name;
3740
3741 if (h != NULL)
3742 name = h->root.root.root.string;
3743 else
3744 {
3745 name = (bfd_elf_string_from_elf_section
3746 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3747 if (name == NULL)
3748 return false;
3749 if (*name == '\0')
3750 name = bfd_section_name (input_bfd, sec);
3751 }
3752 if (! ((*info->callbacks->reloc_overflow)
3753 (info, name, howto->name, (bfd_vma) 0,
3754 input_bfd, input_section, rel->r_offset)))
3755 return false;
3756 }
3757 break;
3758
3759 default:
3760 case bfd_reloc_outofrange:
3761 abort ();
3762 }
3763 }
3764
3765 return true;
3766}
3767
3768/* Finish up dynamic symbol handling. We set the contents of various
3769 dynamic sections here. */
3770
3771static boolean
3772elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3773 bfd *output_bfd;
3774 struct bfd_link_info *info;
3775 struct elf_link_hash_entry *h;
3776 Elf_Internal_Sym *sym;
3777{
3778 bfd *dynobj = elf_hash_table(info)->dynobj;
3779
3780 if (h->plt.offset != MINUS_ONE)
3781 {
3782 /* Fill in the .plt entry for this symbol. */
3783 asection *splt, *sgot, *srel;
3784 Elf_Internal_Rela outrel;
3785 bfd_vma got_addr, plt_addr;
3786 bfd_vma plt_index;
3787 struct alpha_elf_got_entry *gotent;
3788
3789 BFD_ASSERT (h->dynindx != -1);
3790
3791 /* The first .got entry will be updated by the .plt with the
3792 address of the target function. */
3793 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3794 BFD_ASSERT (gotent && gotent->addend == 0);
3795
3796 splt = bfd_get_section_by_name (dynobj, ".plt");
3797 BFD_ASSERT (splt != NULL);
3798 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3799 BFD_ASSERT (srel != NULL);
3800 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3801 BFD_ASSERT (sgot != NULL);
3802
3803 got_addr = (sgot->output_section->vma
3804 + sgot->output_offset
3805 + gotent->got_offset);
3806 plt_addr = (splt->output_section->vma
3807 + splt->output_offset
3808 + h->plt.offset);
3809
3810 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3811
3812 /* Fill in the entry in the procedure linkage table. */
3813 {
3814 unsigned insn1, insn2, insn3;
3815
3816 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3817 insn2 = PLT_ENTRY_WORD2;
3818 insn3 = PLT_ENTRY_WORD3;
3819
3820 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3821 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3822 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3823 }
3824
3825 /* Fill in the entry in the .rela.plt section. */
3826 outrel.r_offset = got_addr;
3827 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3828 outrel.r_addend = 0;
3829
3830 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3831 ((Elf64_External_Rela *)srel->contents
3832 + plt_index));
3833
3834 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3835 {
3836 /* Mark the symbol as undefined, rather than as defined in the
3837 .plt section. Leave the value alone. */
3838 sym->st_shndx = SHN_UNDEF;
3839 }
3840
3841 /* Fill in the entries in the .got. */
3842 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3843
3844 /* Subsequent .got entries will continue to bounce through the .plt. */
3845 if (gotent->next)
3846 {
3847 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3848 BFD_ASSERT (! info->shared || srel != NULL);
3849
3850 gotent = gotent->next;
3851 do
3852 {
3853 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3854 BFD_ASSERT(sgot != NULL);
3855 BFD_ASSERT(gotent->addend == 0);
3856
3857 bfd_put_64 (output_bfd, plt_addr,
3858 sgot->contents + gotent->got_offset);
3859
3860 if (info->shared)
3861 {
3862 outrel.r_offset = (sgot->output_section->vma
3863 + sgot->output_offset
3864 + gotent->got_offset);
3865 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3866 outrel.r_addend = 0;
3867
3868 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3869 ((Elf64_External_Rela *)
3870 srel->contents)
3871 + srel->reloc_count++);
fe8bc63d 3872 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 3873 <= srel->_cooked_size);
3874 }
3875
3876 gotent = gotent->next;
3877 }
3878 while (gotent != NULL);
3879 }
3880 }
3881 else if (alpha_elf_dynamic_symbol_p (h, info))
3882 {
3883 /* Fill in the dynamic relocations for this symbol's .got entries. */
3884 asection *srel;
3885 Elf_Internal_Rela outrel;
3886 struct alpha_elf_got_entry *gotent;
3887
3888 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3889 BFD_ASSERT (srel != NULL);
3890
3891 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3892 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3893 gotent != NULL;
3894 gotent = gotent->next)
3895 {
3896 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3897 outrel.r_offset = (sgot->output_section->vma
3898 + sgot->output_offset
3899 + gotent->got_offset);
3900 outrel.r_addend = gotent->addend;
3901
3902 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3903 ((Elf64_External_Rela *)srel->contents
3904 + srel->reloc_count++));
fe8bc63d 3905 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
252b5132
RH		 3906 <= srel->_cooked_size);
3907 }
3908 }
3909
3910 /* Mark some specially defined symbols as absolute. */
3911 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3912 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3913 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3914 sym->st_shndx = SHN_ABS;
3915
3916 return true;
3917}
3918
3919/* Finish up the dynamic sections. */
3920
3921static boolean
3922elf64_alpha_finish_dynamic_sections (output_bfd, info)
3923 bfd *output_bfd;
3924 struct bfd_link_info *info;
3925{
3926 bfd *dynobj;
3927 asection *sdyn;
3928
3929 dynobj = elf_hash_table (info)->dynobj;
3930 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3931
3932 if (elf_hash_table (info)->dynamic_sections_created)
3933 {
3934 asection *splt;
3935 Elf64_External_Dyn *dyncon, *dynconend;
3936
3937 splt = bfd_get_section_by_name (dynobj, ".plt");
3938 BFD_ASSERT (splt != NULL && sdyn != NULL);
3939
3940 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3941 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3942 for (; dyncon < dynconend; dyncon++)
3943 {
3944 Elf_Internal_Dyn dyn;
3945 const char *name;
3946 asection *s;
3947
3948 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3949
3950 switch (dyn.d_tag)
3951 {
3952 case DT_PLTGOT:
3953 name = ".plt";
3954 goto get_vma;
3955 case DT_PLTRELSZ:
3956 name = ".rela.plt";
3957 goto get_size;
3958 case DT_JMPREL:
3959 name = ".rela.plt";
3960 goto get_vma;
3961
3962 case DT_RELASZ:
3963 /* My interpretation of the TIS v1.1 ELF document indicates
3964 that RELASZ should not include JMPREL. This is not what
3965 the rest of the BFD does. It is, however, what the
3966 glibc ld.so wants. Do this fixup here until we found
3967 out who is right. */
3968 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3969 if (s)
3970 {
3971 dyn.d_un.d_val -=
3972 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3973 }
3974 break;
3975
3976 get_vma:
3977 s = bfd_get_section_by_name (output_bfd, name);
3978 dyn.d_un.d_ptr = (s ? s->vma : 0);
3979 break;
3980
3981 get_size:
3982 s = bfd_get_section_by_name (output_bfd, name);
3983 dyn.d_un.d_val =
3984 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3985 break;
3986 }
3987
3988 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3989 }
3990
3991 /* Initialize the PLT0 entry */
3992 if (splt->_raw_size > 0)
3993 {
3994 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3995 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3996 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3997 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3998
3999 /* The next two words will be filled in by ld.so */
4000 bfd_put_64 (output_bfd, 0, splt->contents + 16);
4001 bfd_put_64 (output_bfd, 0, splt->contents + 24);
4002
4003 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
4004 PLT_HEADER_SIZE;
4005 }
4006 }
4007
252b5132
RH		 4008 return true;
4009}
4010
4011/* We need to use a special link routine to handle the .reginfo and
4012 the .mdebug sections. We need to merge all instances of these
4013 sections together, not write them all out sequentially. */
4014
4015static boolean
4016elf64_alpha_final_link (abfd, info)
4017 bfd *abfd;
4018 struct bfd_link_info *info;
4019{
4020 asection *o;
4021 struct bfd_link_order *p;
4022 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
4023 struct ecoff_debug_info debug;
4024 const struct ecoff_debug_swap *swap
4025 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4026 HDRR *symhdr = &debug.symbolic_header;
4027 PTR mdebug_handle = NULL;
4028
4029#if 0
4030 if (++ngots == 2)
4031 {
4032 (*info->callbacks->warning)
4033 (info, _("using multiple gp values"), (char *) NULL,
4034 output_bfd, (asection *) NULL, (bfd_vma) 0);
4035 }
4036#endif
4037
4038 /* Go through the sections and collect the .reginfo and .mdebug
4039 information. */
4040 reginfo_sec = NULL;
4041 mdebug_sec = NULL;
4042 gptab_data_sec = NULL;
4043 gptab_bss_sec = NULL;
4044 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4045 {
4046#ifdef ERIC_neverdef
4047 if (strcmp (o->name, ".reginfo") == 0)
4048 {
4049 memset (&reginfo, 0, sizeof reginfo);
4050
4051 /* We have found the .reginfo section in the output file.
4052 Look through all the link_orders comprising it and merge
4053 the information together. */
4054 for (p = o->link_order_head;
4055 p != (struct bfd_link_order *) NULL;
4056 p = p->next)
4057 {
4058 asection *input_section;
4059 bfd *input_bfd;
4060 Elf64_External_RegInfo ext;
4061 Elf64_RegInfo sub;
4062
4063 if (p->type != bfd_indirect_link_order)
4064 {
4065 if (p->type == bfd_fill_link_order)
4066 continue;
4067 abort ();
4068 }
4069
4070 input_section = p->u.indirect.section;
4071 input_bfd = input_section->owner;
4072
4073 /* The linker emulation code has probably clobbered the
4074 size to be zero bytes. */
4075 if (input_section->_raw_size == 0)
4076 input_section->_raw_size = sizeof (Elf64_External_RegInfo);
4077
4078 if (! bfd_get_section_contents (input_bfd, input_section,
4079 (PTR) &ext,
4080 (file_ptr) 0,
4081 sizeof ext))
4082 return false;
4083
4084 bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
4085
4086 reginfo.ri_gprmask |= sub.ri_gprmask;
4087 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4088 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4089 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4090 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4091
4092 /* ri_gp_value is set by the function
4093 alpha_elf_section_processing when the section is
4094 finally written out. */
4095
4096 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4097 elf_link_input_bfd ignores this section. */
4098 input_section->flags &=~ SEC_HAS_CONTENTS;
4099 }
4100
4101 /* Force the section size to the value we want. */
4102 o->_raw_size = sizeof (Elf64_External_RegInfo);
4103
4104 /* Skip this section later on (I don't think this currently
4105 matters, but someday it might). */
4106 o->link_order_head = (struct bfd_link_order *) NULL;
4107
4108 reginfo_sec = o;
4109 }
4110#endif
4111
4112 if (strcmp (o->name, ".mdebug") == 0)
4113 {
4114 struct extsym_info einfo;
4115
4116 /* We have found the .mdebug section in the output file.
4117 Look through all the link_orders comprising it and merge
4118 the information together. */
4119 symhdr->magic = swap->sym_magic;
4120 /* FIXME: What should the version stamp be? */
4121 symhdr->vstamp = 0;
4122 symhdr->ilineMax = 0;
4123 symhdr->cbLine = 0;
4124 symhdr->idnMax = 0;
4125 symhdr->ipdMax = 0;
4126 symhdr->isymMax = 0;
4127 symhdr->ioptMax = 0;
4128 symhdr->iauxMax = 0;
4129 symhdr->issMax = 0;
4130 symhdr->issExtMax = 0;
4131 symhdr->ifdMax = 0;
4132 symhdr->crfd = 0;
4133 symhdr->iextMax = 0;
4134
4135 /* We accumulate the debugging information itself in the
4136 debug_info structure. */
4137 debug.line = NULL;
4138 debug.external_dnr = NULL;
4139 debug.external_pdr = NULL;
4140 debug.external_sym = NULL;
4141 debug.external_opt = NULL;
4142 debug.external_aux = NULL;
4143 debug.ss = NULL;
4144 debug.ssext = debug.ssext_end = NULL;
4145 debug.external_fdr = NULL;
4146 debug.external_rfd = NULL;
4147 debug.external_ext = debug.external_ext_end = NULL;
4148
4149 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4150 if (mdebug_handle == (PTR) NULL)
4151 return false;
4152
4153 if (1)
4154 {
4155 asection *s;
4156 EXTR esym;
4157 bfd_vma last;
4158 unsigned int i;
4159 static const char * const name[] =
4160 {
4161 ".text", ".init", ".fini", ".data",
4162 ".rodata", ".sdata", ".sbss", ".bss"
4163 };
4164 static const int sc[] = { scText, scInit, scFini, scData,
4165 scRData, scSData, scSBss, scBss };
4166
4167 esym.jmptbl = 0;
4168 esym.cobol_main = 0;
4169 esym.weakext = 0;
4170 esym.reserved = 0;
4171 esym.ifd = ifdNil;
4172 esym.asym.iss = issNil;
4173 esym.asym.st = stLocal;
4174 esym.asym.reserved = 0;
4175 esym.asym.index = indexNil;
4176 for (i = 0; i < 8; i++)
4177 {
4178 esym.asym.sc = sc[i];
4179 s = bfd_get_section_by_name (abfd, name[i]);
4180 if (s != NULL)
4181 {
4182 esym.asym.value = s->vma;
4183 last = s->vma + s->_raw_size;
4184 }
4185 else
4186 esym.asym.value = last;
4187
4188 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4189 name[i], &esym))
4190 return false;
4191 }
4192 }
4193
4194 for (p = o->link_order_head;
4195 p != (struct bfd_link_order *) NULL;
4196 p = p->next)
4197 {
4198 asection *input_section;
4199 bfd *input_bfd;
4200 const struct ecoff_debug_swap *input_swap;
4201 struct ecoff_debug_info input_debug;
4202 char *eraw_src;
4203 char *eraw_end;
4204
4205 if (p->type != bfd_indirect_link_order)
4206 {
4207 if (p->type == bfd_fill_link_order)
4208 continue;
4209 abort ();
4210 }
4211
4212 input_section = p->u.indirect.section;
4213 input_bfd = input_section->owner;
4214
4215 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4216 || (get_elf_backend_data (input_bfd)
4217 ->elf_backend_ecoff_debug_swap) == NULL)
4218 {
4219 /* I don't know what a non ALPHA ELF bfd would be
4220 doing with a .mdebug section, but I don't really
4221 want to deal with it. */
4222 continue;
4223 }
4224
4225 input_swap = (get_elf_backend_data (input_bfd)
4226 ->elf_backend_ecoff_debug_swap);
4227
4228 BFD_ASSERT (p->size == input_section->_raw_size);
4229
4230 /* The ECOFF linking code expects that we have already
4231 read in the debugging information and set up an
4232 ecoff_debug_info structure, so we do that now. */
4233 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4234 &input_debug))
4235 return false;
4236
4237 if (! (bfd_ecoff_debug_accumulate
4238 (mdebug_handle, abfd, &debug, swap, input_bfd,
4239 &input_debug, input_swap, info)))
4240 return false;
4241
4242 /* Loop through the external symbols. For each one with
4243 interesting information, try to find the symbol in
4244 the linker global hash table and save the information
4245 for the output external symbols. */
4246 eraw_src = input_debug.external_ext;
4247 eraw_end = (eraw_src
4248 + (input_debug.symbolic_header.iextMax
4249 * input_swap->external_ext_size));
4250 for (;
4251 eraw_src < eraw_end;
4252 eraw_src += input_swap->external_ext_size)
4253 {
4254 EXTR ext;
4255 const char *name;
4256 struct alpha_elf_link_hash_entry *h;
4257
4258 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4259 if (ext.asym.sc == scNil
4260 || ext.asym.sc == scUndefined
4261 || ext.asym.sc == scSUndefined)
4262 continue;
4263
4264 name = input_debug.ssext + ext.asym.iss;
4265 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4266 name, false, false, true);
4267 if (h == NULL || h->esym.ifd != -2)
4268 continue;
4269
4270 if (ext.ifd != -1)
4271 {
4272 BFD_ASSERT (ext.ifd
4273 < input_debug.symbolic_header.ifdMax);
4274 ext.ifd = input_debug.ifdmap[ext.ifd];
4275 }
4276
4277 h->esym = ext;
4278 }
4279
4280 /* Free up the information we just read. */
4281 free (input_debug.line);
4282 free (input_debug.external_dnr);
4283 free (input_debug.external_pdr);
4284 free (input_debug.external_sym);
4285 free (input_debug.external_opt);
4286 free (input_debug.external_aux);
4287 free (input_debug.ss);
4288 free (input_debug.ssext);
4289 free (input_debug.external_fdr);
4290 free (input_debug.external_rfd);
4291 free (input_debug.external_ext);
4292
4293 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4294 elf_link_input_bfd ignores this section. */
4295 input_section->flags &=~ SEC_HAS_CONTENTS;
4296 }
4297
4298#ifdef ERIC_neverdef
4299 if (info->shared)
4300 {
4301 /* Create .rtproc section. */
4302 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4303 if (rtproc_sec == NULL)
4304 {
4305 flagword flags = (SEC_HAS_CONTENTS
4306 | SEC_IN_MEMORY
4307 | SEC_LINKER_CREATED
4308 | SEC_READONLY);
4309
4310 rtproc_sec = bfd_make_section (abfd, ".rtproc");
4311 if (rtproc_sec == NULL
4312 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4313 || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
4314 return false;
4315 }
4316
4317 if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
4318 info, rtproc_sec, &debug))
4319 return false;
4320 }
4321#endif
4322
252b5132
RH		 4323 /* Build the external symbol information. */
4324 einfo.abfd = abfd;
4325 einfo.info = info;
4326 einfo.debug = &debug;
4327 einfo.swap = swap;
4328 einfo.failed = false;
4329 elf_link_hash_traverse (elf_hash_table (info),
4330 elf64_alpha_output_extsym,
4331 (PTR) &einfo);
4332 if (einfo.failed)
4333 return false;
4334
4335 /* Set the size of the .mdebug section. */
4336 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4337
4338 /* Skip this section later on (I don't think this currently
4339 matters, but someday it might). */
4340 o->link_order_head = (struct bfd_link_order *) NULL;
4341
4342 mdebug_sec = o;
4343 }
4344
4345#ifdef ERIC_neverdef
4346 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4347 {
4348 const char *subname;
4349 unsigned int c;
4350 Elf64_gptab *tab;
4351 Elf64_External_gptab *ext_tab;
4352 unsigned int i;
4353
4354 /* The .gptab.sdata and .gptab.sbss sections hold
4355 information describing how the small data area would
4356 change depending upon the -G switch. These sections
4357 not used in executables files. */
4358 if (! info->relocateable)
4359 {
4360 asection **secpp;
4361
4362 for (p = o->link_order_head;
4363 p != (struct bfd_link_order *) NULL;
4364 p = p->next)
4365 {
4366 asection *input_section;
4367
4368 if (p->type != bfd_indirect_link_order)
4369 {
4370 if (p->type == bfd_fill_link_order)
4371 continue;
4372 abort ();
4373 }
4374
4375 input_section = p->u.indirect.section;
4376
4377 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4378 elf_link_input_bfd ignores this section. */
4379 input_section->flags &=~ SEC_HAS_CONTENTS;
4380 }
4381
4382 /* Skip this section later on (I don't think this
4383 currently matters, but someday it might). */
4384 o->link_order_head = (struct bfd_link_order *) NULL;
4385
4386 /* Really remove the section. */
4387 for (secpp = &abfd->sections;
4388 *secpp != o;
4389 secpp = &(*secpp)->next)
4390 ;
4391 *secpp = (*secpp)->next;
4392 --abfd->section_count;
4393
4394 continue;
4395 }
4396
4397 /* There is one gptab for initialized data, and one for
4398 uninitialized data. */
4399 if (strcmp (o->name, ".gptab.sdata") == 0)
4400 gptab_data_sec = o;
4401 else if (strcmp (o->name, ".gptab.sbss") == 0)
4402 gptab_bss_sec = o;
4403 else
4404 {
4405 (*_bfd_error_handler)
4406 (_("%s: illegal section name `%s'"),
4407 bfd_get_filename (abfd), o->name);
4408 bfd_set_error (bfd_error_nonrepresentable_section);
4409 return false;
4410 }
4411
4412 /* The linker script always combines .gptab.data and
4413 .gptab.sdata into .gptab.sdata, and likewise for
4414 .gptab.bss and .gptab.sbss. It is possible that there is
4415 no .sdata or .sbss section in the output file, in which
4416 case we must change the name of the output section. */
4417 subname = o->name + sizeof ".gptab" - 1;
4418 if (bfd_get_section_by_name (abfd, subname) == NULL)
4419 {
4420 if (o == gptab_data_sec)
4421 o->name = ".gptab.data";
4422 else
4423 o->name = ".gptab.bss";
4424 subname = o->name + sizeof ".gptab" - 1;
4425 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
4426 }
4427
4428 /* Set up the first entry. */
4429 c = 1;
4430 tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
4431 if (tab == NULL)
4432 return false;
4433 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
4434 tab[0].gt_header.gt_unused = 0;
4435
4436 /* Combine the input sections. */
4437 for (p = o->link_order_head;
4438 p != (struct bfd_link_order *) NULL;
4439 p = p->next)
4440 {
4441 asection *input_section;
4442 bfd *input_bfd;
4443 bfd_size_type size;
4444 unsigned long last;
4445 bfd_size_type gpentry;
4446
4447 if (p->type != bfd_indirect_link_order)
4448 {
4449 if (p->type == bfd_fill_link_order)
4450 continue;
4451 abort ();
4452 }
4453
4454 input_section = p->u.indirect.section;
4455 input_bfd = input_section->owner;
4456
4457 /* Combine the gptab entries for this input section one
4458 by one. We know that the input gptab entries are
4459 sorted by ascending -G value. */
4460 size = bfd_section_size (input_bfd, input_section);
4461 last = 0;
4462 for (gpentry = sizeof (Elf64_External_gptab);
4463 gpentry < size;
4464 gpentry += sizeof (Elf64_External_gptab))
4465 {
4466 Elf64_External_gptab ext_gptab;
4467 Elf64_gptab int_gptab;
4468 unsigned long val;
4469 unsigned long add;
4470 boolean exact;
4471 unsigned int look;
4472
4473 if (! (bfd_get_section_contents
4474 (input_bfd, input_section, (PTR) &ext_gptab,
4475 gpentry, sizeof (Elf64_External_gptab))))
4476 {
4477 free (tab);
4478 return false;
4479 }
4480
4481 bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
4482 &int_gptab);
4483 val = int_gptab.gt_entry.gt_g_value;
4484 add = int_gptab.gt_entry.gt_bytes - last;
4485
4486 exact = false;
4487 for (look = 1; look < c; look++)
4488 {
4489 if (tab[look].gt_entry.gt_g_value >= val)
4490 tab[look].gt_entry.gt_bytes += add;
4491
4492 if (tab[look].gt_entry.gt_g_value == val)
4493 exact = true;
4494 }
4495
4496 if (! exact)
4497 {
4498 Elf64_gptab *new_tab;
4499 unsigned int max;
4500
4501 /* We need a new table entry. */
4502 new_tab = ((Elf64_gptab *)
4503 bfd_realloc ((PTR) tab,
4504 (c + 1) * sizeof (Elf64_gptab)));
4505 if (new_tab == NULL)
4506 {
4507 free (tab);
4508 return false;
4509 }
4510 tab = new_tab;
4511 tab[c].gt_entry.gt_g_value = val;
4512 tab[c].gt_entry.gt_bytes = add;
4513
4514 /* Merge in the size for the next smallest -G
4515 value, since that will be implied by this new
4516 value. */
4517 max = 0;
4518 for (look = 1; look < c; look++)
4519 {
4520 if (tab[look].gt_entry.gt_g_value < val
4521 && (max == 0
4522 || (tab[look].gt_entry.gt_g_value
4523 > tab[max].gt_entry.gt_g_value)))
4524 max = look;
4525 }
4526 if (max != 0)
4527 tab[c].gt_entry.gt_bytes +=
4528 tab[max].gt_entry.gt_bytes;
4529
4530 ++c;
4531 }
4532
4533 last = int_gptab.gt_entry.gt_bytes;
4534 }
4535
4536 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4537 elf_link_input_bfd ignores this section. */
4538 input_section->flags &=~ SEC_HAS_CONTENTS;
4539 }
4540
4541 /* The table must be sorted by -G value. */
4542 if (c > 2)
4543 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
4544
4545 /* Swap out the table. */
4546 ext_tab = ((Elf64_External_gptab *)
4547 bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
4548 if (ext_tab == NULL)
4549 {
4550 free (tab);
4551 return false;
4552 }
4553
4554 for (i = 0; i < c; i++)
4555 bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
4556 free (tab);
4557
4558 o->_raw_size = c * sizeof (Elf64_External_gptab);
4559 o->contents = (bfd_byte *) ext_tab;
4560
4561 /* Skip this section later on (I don't think this currently
4562 matters, but someday it might). */
4563 o->link_order_head = (struct bfd_link_order *) NULL;
4564 }
4565#endif
4566
4567 }
4568
4569 /* Invoke the regular ELF backend linker to do all the work. */
4570 if (! bfd_elf64_bfd_final_link (abfd, info))
4571 return false;
4572
4573 /* Now write out the computed sections. */
4574
4575 /* The .got subsections... */
4576 {
4577 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4578 for (i = alpha_elf_hash_table(info)->got_list;
4579 i != NULL;
4580 i = alpha_elf_tdata(i)->got_link_next)
4581 {
4582 asection *sgot;
4583
4584 /* elf_bfd_final_link already did everything in dynobj. */
4585 if (i == dynobj)
4586 continue;
4587
4588 sgot = alpha_elf_tdata(i)->got;
4589 if (! bfd_set_section_contents (abfd, sgot->output_section,
4590 sgot->contents, sgot->output_offset,
4591 sgot->_raw_size))
4592 return false;
4593 }
4594 }
4595
4596#ifdef ERIC_neverdef
4597 if (reginfo_sec != (asection *) NULL)
4598 {
4599 Elf64_External_RegInfo ext;
4600
4601 bfd_alpha_elf64_swap_reginfo_out (abfd, &reginfo, &ext);
4602 if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
4603 (file_ptr) 0, sizeof ext))
4604 return false;
4605 }
4606#endif
4607
4608 if (mdebug_sec != (asection *) NULL)
4609 {
4610 BFD_ASSERT (abfd->output_has_begun);
4611 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4612 swap, info,
4613 mdebug_sec->filepos))
4614 return false;
4615
4616 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4617 }
4618
4619 if (gptab_data_sec != (asection *) NULL)
4620 {
4621 if (! bfd_set_section_contents (abfd, gptab_data_sec,
4622 gptab_data_sec->contents,
4623 (file_ptr) 0,
4624 gptab_data_sec->_raw_size))
4625 return false;
4626 }
4627
4628 if (gptab_bss_sec != (asection *) NULL)
4629 {
4630 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
4631 gptab_bss_sec->contents,
4632 (file_ptr) 0,
4633 gptab_bss_sec->_raw_size))
4634 return false;
4635 }
4636
4637 return true;
4638}
4639\f
4640/* ECOFF swapping routines. These are used when dealing with the
4641 .mdebug section, which is in the ECOFF debugging format. Copied
fe8bc63d 4642 from elf32-mips.c. */
252b5132
RH		 4643static const struct ecoff_debug_swap
4644elf64_alpha_ecoff_debug_swap =
4645{
4646 /* Symbol table magic number. */
4647 magicSym2,
4648 /* Alignment of debugging information. E.g., 4. */
4649 8,
4650 /* Sizes of external symbolic information. */
4651 sizeof (struct hdr_ext),
4652 sizeof (struct dnr_ext),
4653 sizeof (struct pdr_ext),
4654 sizeof (struct sym_ext),
4655 sizeof (struct opt_ext),
4656 sizeof (struct fdr_ext),
4657 sizeof (struct rfd_ext),
4658 sizeof (struct ext_ext),
4659 /* Functions to swap in external symbolic data. */
4660 ecoff_swap_hdr_in,
4661 ecoff_swap_dnr_in,
4662 ecoff_swap_pdr_in,
4663 ecoff_swap_sym_in,
4664 ecoff_swap_opt_in,
4665 ecoff_swap_fdr_in,
4666 ecoff_swap_rfd_in,
4667 ecoff_swap_ext_in,
4668 _bfd_ecoff_swap_tir_in,
4669 _bfd_ecoff_swap_rndx_in,
4670 /* Functions to swap out external symbolic data. */
4671 ecoff_swap_hdr_out,
4672 ecoff_swap_dnr_out,
4673 ecoff_swap_pdr_out,
4674 ecoff_swap_sym_out,
4675 ecoff_swap_opt_out,
4676 ecoff_swap_fdr_out,
4677 ecoff_swap_rfd_out,
4678 ecoff_swap_ext_out,
4679 _bfd_ecoff_swap_tir_out,
4680 _bfd_ecoff_swap_rndx_out,
4681 /* Function to read in symbolic data. */
4682 elf64_alpha_read_ecoff_info
4683};
4684\f
70bcb145
JW		 4685/* Use a non-standard hash bucket size of 8. */
4686
4687const struct elf_size_info alpha_elf_size_info =
4688{
4689 sizeof (Elf64_External_Ehdr),
4690 sizeof (Elf64_External_Phdr),
4691 sizeof (Elf64_External_Shdr),
4692 sizeof (Elf64_External_Rel),
4693 sizeof (Elf64_External_Rela),
4694 sizeof (Elf64_External_Sym),
4695 sizeof (Elf64_External_Dyn),
4696 sizeof (Elf_External_Note),
4697 8,
4698 1,
4699 64, 8,
4700 ELFCLASS64, EV_CURRENT,
4701 bfd_elf64_write_out_phdrs,
4702 bfd_elf64_write_shdrs_and_ehdr,
4703 bfd_elf64_write_relocs,
4704 bfd_elf64_swap_symbol_out,
4705 bfd_elf64_slurp_reloc_table,
4706 bfd_elf64_slurp_symbol_table,
4707 bfd_elf64_swap_dyn_in,
4708 bfd_elf64_swap_dyn_out,
4709 NULL,
4710 NULL,
4711 NULL,
4712 NULL
4713};
4714
252b5132
RH		 4715#define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4716#define TARGET_LITTLE_NAME "elf64-alpha"
4717#define ELF_ARCH bfd_arch_alpha
4718#define ELF_MACHINE_CODE EM_ALPHA
4719#define ELF_MAXPAGESIZE 0x10000
4720
4721#define bfd_elf64_bfd_link_hash_table_create \
4722 elf64_alpha_bfd_link_hash_table_create
4723
4724#define bfd_elf64_bfd_reloc_type_lookup \
4725 elf64_alpha_bfd_reloc_type_lookup
4726#define elf_info_to_howto \
4727 elf64_alpha_info_to_howto
4728
4729#define bfd_elf64_mkobject \
4730 elf64_alpha_mkobject
4731#define elf_backend_object_p \
4732 elf64_alpha_object_p
4733
4734#define elf_backend_section_from_shdr \
4735 elf64_alpha_section_from_shdr
4736#define elf_backend_fake_sections \
4737 elf64_alpha_fake_sections
4738
4739#define bfd_elf64_bfd_is_local_label_name \
4740 elf64_alpha_is_local_label_name
4741#define bfd_elf64_find_nearest_line \
4742 elf64_alpha_find_nearest_line
4743#define bfd_elf64_bfd_relax_section \
4744 elf64_alpha_relax_section
4745
4746#define elf_backend_add_symbol_hook \
4747 elf64_alpha_add_symbol_hook
4748#define elf_backend_check_relocs \
4749 elf64_alpha_check_relocs
4750#define elf_backend_create_dynamic_sections \
4751 elf64_alpha_create_dynamic_sections
4752#define elf_backend_adjust_dynamic_symbol \
4753 elf64_alpha_adjust_dynamic_symbol
4754#define elf_backend_always_size_sections \
4755 elf64_alpha_always_size_sections
4756#define elf_backend_size_dynamic_sections \
4757 elf64_alpha_size_dynamic_sections
4758#define elf_backend_relocate_section \
4759 elf64_alpha_relocate_section
4760#define elf_backend_finish_dynamic_symbol \
4761 elf64_alpha_finish_dynamic_symbol
4762#define elf_backend_finish_dynamic_sections \
4763 elf64_alpha_finish_dynamic_sections
4764#define bfd_elf64_bfd_final_link \
4765 elf64_alpha_final_link
4766
4767#define elf_backend_ecoff_debug_swap \
4768 &elf64_alpha_ecoff_debug_swap
4769
70bcb145
JW		 4770#define elf_backend_size_info \
4771 alpha_elf_size_info
4772
38b1a46c 4773/* A few constants that determine how the .plt section is set up. */
252b5132
RH		 4774#define elf_backend_want_got_plt 0
4775#define elf_backend_plt_readonly 0
4776#define elf_backend_want_plt_sym 1
4777#define elf_backend_got_header_size 0
4778#define elf_backend_plt_header_size PLT_HEADER_SIZE
4779
4780#include "elf64-target.h"
A mirror of the official binutils-gdb repository