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