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