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