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