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