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