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