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