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