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