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