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