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