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