elf64-alpha.c revision 99465
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 99465 2002-07-05 20:32:42Z 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.root.type == bfd_link_hash_warning) 2128 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link; 2129 2130 if (h->root.indx == -2) 2131 strip = false; 2132 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0 2133 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0) 2134 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0 2135 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0) 2136 strip = true; 2137 else if (einfo->info->strip == strip_all 2138 || (einfo->info->strip == strip_some 2139 && bfd_hash_lookup (einfo->info->keep_hash, 2140 h->root.root.root.string, 2141 false, false) == NULL)) 2142 strip = true; 2143 else 2144 strip = false; 2145 2146 if (strip) 2147 return true; 2148 2149 if (h->esym.ifd == -2) 2150 { 2151 h->esym.jmptbl = 0; 2152 h->esym.cobol_main = 0; 2153 h->esym.weakext = 0; 2154 h->esym.reserved = 0; 2155 h->esym.ifd = ifdNil; 2156 h->esym.asym.value = 0; 2157 h->esym.asym.st = stGlobal; 2158 2159 if (h->root.root.type != bfd_link_hash_defined 2160 && h->root.root.type != bfd_link_hash_defweak) 2161 h->esym.asym.sc = scAbs; 2162 else 2163 { 2164 const char *name; 2165 2166 sec = h->root.root.u.def.section; 2167 output_section = sec->output_section; 2168 2169 /* When making a shared library and symbol h is the one from 2170 the another shared library, OUTPUT_SECTION may be null. */ 2171 if (output_section == NULL) 2172 h->esym.asym.sc = scUndefined; 2173 else 2174 { 2175 name = bfd_section_name (output_section->owner, output_section); 2176 2177 if (strcmp (name, ".text") == 0) 2178 h->esym.asym.sc = scText; 2179 else if (strcmp (name, ".data") == 0) 2180 h->esym.asym.sc = scData; 2181 else if (strcmp (name, ".sdata") == 0) 2182 h->esym.asym.sc = scSData; 2183 else if (strcmp (name, ".rodata") == 0 2184 || strcmp (name, ".rdata") == 0) 2185 h->esym.asym.sc = scRData; 2186 else if (strcmp (name, ".bss") == 0) 2187 h->esym.asym.sc = scBss; 2188 else if (strcmp (name, ".sbss") == 0) 2189 h->esym.asym.sc = scSBss; 2190 else if (strcmp (name, ".init") == 0) 2191 h->esym.asym.sc = scInit; 2192 else if (strcmp (name, ".fini") == 0) 2193 h->esym.asym.sc = scFini; 2194 else 2195 h->esym.asym.sc = scAbs; 2196 } 2197 } 2198 2199 h->esym.asym.reserved = 0; 2200 h->esym.asym.index = indexNil; 2201 } 2202 2203 if (h->root.root.type == bfd_link_hash_common) 2204 h->esym.asym.value = h->root.root.u.c.size; 2205 else if (h->root.root.type == bfd_link_hash_defined 2206 || h->root.root.type == bfd_link_hash_defweak) 2207 { 2208 if (h->esym.asym.sc == scCommon) 2209 h->esym.asym.sc = scBss; 2210 else if (h->esym.asym.sc == scSCommon) 2211 h->esym.asym.sc = scSBss; 2212 2213 sec = h->root.root.u.def.section; 2214 output_section = sec->output_section; 2215 if (output_section != NULL) 2216 h->esym.asym.value = (h->root.root.u.def.value 2217 + sec->output_offset 2218 + output_section->vma); 2219 else 2220 h->esym.asym.value = 0; 2221 } 2222 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0) 2223 { 2224 /* Set type and value for a symbol with a function stub. */ 2225 h->esym.asym.st = stProc; 2226 sec = bfd_get_section_by_name (einfo->abfd, ".plt"); 2227 if (sec == NULL) 2228 h->esym.asym.value = 0; 2229 else 2230 { 2231 output_section = sec->output_section; 2232 if (output_section != NULL) 2233 h->esym.asym.value = (h->root.plt.offset 2234 + sec->output_offset 2235 + output_section->vma); 2236 else 2237 h->esym.asym.value = 0; 2238 } 2239 } 2240 2241 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap, 2242 h->root.root.root.string, 2243 &h->esym)) 2244 { 2245 einfo->failed = true; 2246 return false; 2247 } 2248 2249 return true; 2250} 2251 2252/* FIXME: Create a runtime procedure table from the .mdebug section. 2253 2254static boolean 2255mips_elf_create_procedure_table (handle, abfd, info, s, debug) 2256 PTR handle; 2257 bfd *abfd; 2258 struct bfd_link_info *info; 2259 asection *s; 2260 struct ecoff_debug_info *debug; 2261*/ 2262 2263/* Handle dynamic relocations when doing an Alpha ELF link. */ 2264 2265static boolean 2266elf64_alpha_check_relocs (abfd, info, sec, relocs) 2267 bfd *abfd; 2268 struct bfd_link_info *info; 2269 asection *sec; 2270 const Elf_Internal_Rela *relocs; 2271{ 2272 bfd *dynobj; 2273 asection *sreloc; 2274 const char *rel_sec_name; 2275 Elf_Internal_Shdr *symtab_hdr; 2276 struct alpha_elf_link_hash_entry **sym_hashes; 2277 struct alpha_elf_got_entry **local_got_entries; 2278 const Elf_Internal_Rela *rel, *relend; 2279 int got_created; 2280 bfd_size_type amt; 2281 2282 if (info->relocateable) 2283 return true; 2284 2285 dynobj = elf_hash_table(info)->dynobj; 2286 if (dynobj == NULL) 2287 elf_hash_table(info)->dynobj = dynobj = abfd; 2288 2289 sreloc = NULL; 2290 rel_sec_name = NULL; 2291 symtab_hdr = &elf_tdata(abfd)->symtab_hdr; 2292 sym_hashes = alpha_elf_sym_hashes(abfd); 2293 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries; 2294 got_created = 0; 2295 2296 relend = relocs + sec->reloc_count; 2297 for (rel = relocs; rel < relend; ++rel) 2298 { 2299 unsigned long r_symndx, r_type; 2300 struct alpha_elf_link_hash_entry *h; 2301 2302 r_symndx = ELF64_R_SYM (rel->r_info); 2303 if (r_symndx < symtab_hdr->sh_info) 2304 h = NULL; 2305 else 2306 { 2307 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2308 2309 while (h->root.root.type == bfd_link_hash_indirect 2310 || h->root.root.type == bfd_link_hash_warning) 2311 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link; 2312 2313 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR; 2314 } 2315 r_type = ELF64_R_TYPE (rel->r_info); 2316 2317 switch (r_type) 2318 { 2319 case R_ALPHA_LITERAL: 2320 { 2321 struct alpha_elf_got_entry *gotent; 2322 int flags = 0; 2323 2324 if (h) 2325 { 2326 /* Search for and possibly create a got entry. */ 2327 for (gotent = h->got_entries; gotent ; gotent = gotent->next) 2328 if (gotent->gotobj == abfd && 2329 gotent->addend == rel->r_addend) 2330 break; 2331 2332 if (!gotent) 2333 { 2334 amt = sizeof (struct alpha_elf_got_entry); 2335 gotent = ((struct alpha_elf_got_entry *) 2336 bfd_alloc (abfd, amt)); 2337 if (!gotent) 2338 return false; 2339 2340 gotent->gotobj = abfd; 2341 gotent->addend = rel->r_addend; 2342 gotent->got_offset = -1; 2343 gotent->flags = 0; 2344 gotent->use_count = 1; 2345 2346 gotent->next = h->got_entries; 2347 h->got_entries = gotent; 2348 2349 alpha_elf_tdata (abfd)->total_got_entries++; 2350 } 2351 else 2352 gotent->use_count += 1; 2353 } 2354 else 2355 { 2356 /* This is a local .got entry -- record for merge. */ 2357 if (!local_got_entries) 2358 { 2359 bfd_size_type size; 2360 size = symtab_hdr->sh_info; 2361 size *= sizeof (struct alpha_elf_got_entry *); 2362 2363 local_got_entries = ((struct alpha_elf_got_entry **) 2364 bfd_alloc (abfd, size)); 2365 if (!local_got_entries) 2366 return false; 2367 2368 memset (local_got_entries, 0, (size_t) size); 2369 alpha_elf_tdata (abfd)->local_got_entries = 2370 local_got_entries; 2371 } 2372 2373 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)]; 2374 gotent != NULL && gotent->addend != rel->r_addend; 2375 gotent = gotent->next) 2376 continue; 2377 if (!gotent) 2378 { 2379 amt = sizeof (struct alpha_elf_got_entry); 2380 gotent = ((struct alpha_elf_got_entry *) 2381 bfd_alloc (abfd, amt)); 2382 if (!gotent) 2383 return false; 2384 2385 gotent->gotobj = abfd; 2386 gotent->addend = rel->r_addend; 2387 gotent->got_offset = -1; 2388 gotent->flags = 0; 2389 gotent->use_count = 1; 2390 2391 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)]; 2392 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent; 2393 2394 alpha_elf_tdata(abfd)->total_got_entries++; 2395 alpha_elf_tdata(abfd)->n_local_got_entries++; 2396 } 2397 else 2398 gotent->use_count += 1; 2399 } 2400 2401 /* Remember how this literal is used from its LITUSEs. 2402 This will be important when it comes to decide if we can 2403 create a .plt entry for a function symbol. */ 2404 if (rel+1 < relend 2405 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE) 2406 { 2407 do 2408 { 2409 ++rel; 2410 if (rel->r_addend >= 1 && rel->r_addend <= 3) 2411 flags |= 1 << rel->r_addend; 2412 } 2413 while (rel+1 < relend && 2414 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE); 2415 } 2416 else 2417 { 2418 /* No LITUSEs -- presumably the address is not being 2419 loaded for nothing. */ 2420 flags = ALPHA_ELF_LINK_HASH_LU_ADDR; 2421 } 2422 2423 gotent->flags |= flags; 2424 if (h) 2425 { 2426 /* Make a guess as to whether a .plt entry will be needed. */ 2427 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC) 2428 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 2429 else 2430 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 2431 } 2432 } 2433 /* FALLTHRU */ 2434 2435 case R_ALPHA_GPDISP: 2436 case R_ALPHA_GPREL16: 2437 case R_ALPHA_GPREL32: 2438 case R_ALPHA_GPRELHIGH: 2439 case R_ALPHA_GPRELLOW: 2440 case R_ALPHA_BRSGP: 2441 /* We don't actually use the .got here, but the sections must 2442 be created before the linker maps input sections to output 2443 sections. */ 2444 if (!got_created) 2445 { 2446 if (!elf64_alpha_create_got_section (abfd, info)) 2447 return false; 2448 2449 /* Make sure the object's gotobj is set to itself so 2450 that we default to every object with its own .got. 2451 We'll merge .gots later once we've collected each 2452 object's info. */ 2453 alpha_elf_tdata(abfd)->gotobj = abfd; 2454 2455 got_created = 1; 2456 } 2457 break; 2458 2459 case R_ALPHA_SREL16: 2460 case R_ALPHA_SREL32: 2461 case R_ALPHA_SREL64: 2462 if (h == NULL) 2463 break; 2464 /* FALLTHRU */ 2465 2466 case R_ALPHA_REFLONG: 2467 case R_ALPHA_REFQUAD: 2468 if (rel_sec_name == NULL) 2469 { 2470 rel_sec_name = (bfd_elf_string_from_elf_section 2471 (abfd, elf_elfheader(abfd)->e_shstrndx, 2472 elf_section_data(sec)->rel_hdr.sh_name)); 2473 if (rel_sec_name == NULL) 2474 return false; 2475 2476 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0 2477 && strcmp (bfd_get_section_name (abfd, sec), 2478 rel_sec_name+5) == 0); 2479 } 2480 2481 /* We need to create the section here now whether we eventually 2482 use it or not so that it gets mapped to an output section by 2483 the linker. If not used, we'll kill it in 2484 size_dynamic_sections. */ 2485 if (sreloc == NULL) 2486 { 2487 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name); 2488 if (sreloc == NULL) 2489 { 2490 flagword flags; 2491 2492 sreloc = bfd_make_section (dynobj, rel_sec_name); 2493 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY 2494 | SEC_LINKER_CREATED | SEC_READONLY); 2495 if (sec->flags & SEC_ALLOC) 2496 flags |= SEC_ALLOC | SEC_LOAD; 2497 if (sreloc == NULL 2498 || !bfd_set_section_flags (dynobj, sreloc, flags) 2499 || !bfd_set_section_alignment (dynobj, sreloc, 3)) 2500 return false; 2501 } 2502 } 2503 2504 if (h) 2505 { 2506 /* Since we havn't seen all of the input symbols yet, we 2507 don't know whether we'll actually need a dynamic relocation 2508 entry for this reloc. So make a record of it. Once we 2509 find out if this thing needs dynamic relocation we'll 2510 expand the relocation sections by the appropriate amount. */ 2511 2512 struct alpha_elf_reloc_entry *rent; 2513 2514 for (rent = h->reloc_entries; rent; rent = rent->next) 2515 if (rent->rtype == r_type && rent->srel == sreloc) 2516 break; 2517 2518 if (!rent) 2519 { 2520 amt = sizeof (struct alpha_elf_reloc_entry); 2521 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt); 2522 if (!rent) 2523 return false; 2524 2525 rent->srel = sreloc; 2526 rent->rtype = r_type; 2527 rent->count = 1; 2528 rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC)) 2529 == (SEC_READONLY | SEC_ALLOC)); 2530 2531 rent->next = h->reloc_entries; 2532 h->reloc_entries = rent; 2533 } 2534 else 2535 rent->count++; 2536 } 2537 else if (info->shared && (sec->flags & SEC_ALLOC)) 2538 { 2539 /* If this is a shared library, and the section is to be 2540 loaded into memory, we need a RELATIVE reloc. */ 2541 sreloc->_raw_size += sizeof (Elf64_External_Rela); 2542 if (sec->flags & SEC_READONLY) 2543 info->flags |= DF_TEXTREL; 2544 } 2545 break; 2546 } 2547 } 2548 2549 return true; 2550} 2551 2552/* Adjust a symbol defined by a dynamic object and referenced by a 2553 regular object. The current definition is in some section of the 2554 dynamic object, but we're not including those sections. We have to 2555 change the definition to something the rest of the link can 2556 understand. */ 2557 2558static boolean 2559elf64_alpha_adjust_dynamic_symbol (info, h) 2560 struct bfd_link_info *info; 2561 struct elf_link_hash_entry *h; 2562{ 2563 bfd *dynobj; 2564 asection *s; 2565 struct alpha_elf_link_hash_entry *ah; 2566 2567 dynobj = elf_hash_table(info)->dynobj; 2568 ah = (struct alpha_elf_link_hash_entry *)h; 2569 2570 /* Now that we've seen all of the input symbols, finalize our decision 2571 about whether this symbol should get a .plt entry. */ 2572 2573 if (alpha_elf_dynamic_symbol_p (h, info) 2574 && ((h->type == STT_FUNC 2575 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR)) 2576 || (h->type == STT_NOTYPE 2577 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC)) 2578 /* Don't prevent otherwise valid programs from linking by attempting 2579 to create a new .got entry somewhere. A Correct Solution would be 2580 to add a new .got section to a new object file and let it be merged 2581 somewhere later. But for now don't bother. */ 2582 && ah->got_entries) 2583 { 2584 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 2585 2586 s = bfd_get_section_by_name(dynobj, ".plt"); 2587 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info)) 2588 return false; 2589 2590 /* The first bit of the .plt is reserved. */ 2591 if (s->_raw_size == 0) 2592 s->_raw_size = PLT_HEADER_SIZE; 2593 2594 h->plt.offset = s->_raw_size; 2595 s->_raw_size += PLT_ENTRY_SIZE; 2596 2597 /* If this symbol is not defined in a regular file, and we are not 2598 generating a shared library, then set the symbol to the location 2599 in the .plt. This is required to make function pointers compare 2600 equal between the normal executable and the shared library. */ 2601 if (! info->shared 2602 && h->root.type != bfd_link_hash_defweak) 2603 { 2604 h->root.u.def.section = s; 2605 h->root.u.def.value = h->plt.offset; 2606 } 2607 2608 /* We also need a JMP_SLOT entry in the .rela.plt section. */ 2609 s = bfd_get_section_by_name (dynobj, ".rela.plt"); 2610 BFD_ASSERT (s != NULL); 2611 s->_raw_size += sizeof (Elf64_External_Rela); 2612 2613 return true; 2614 } 2615 else 2616 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 2617 2618 /* If this is a weak symbol, and there is a real definition, the 2619 processor independent code will have arranged for us to see the 2620 real definition first, and we can just use the same value. */ 2621 if (h->weakdef != NULL) 2622 { 2623 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 2624 || h->weakdef->root.type == bfd_link_hash_defweak); 2625 h->root.u.def.section = h->weakdef->root.u.def.section; 2626 h->root.u.def.value = h->weakdef->root.u.def.value; 2627 return true; 2628 } 2629 2630 /* This is a reference to a symbol defined by a dynamic object which 2631 is not a function. The Alpha, since it uses .got entries for all 2632 symbols even in regular objects, does not need the hackery of a 2633 .dynbss section and COPY dynamic relocations. */ 2634 2635 return true; 2636} 2637 2638/* Symbol versioning can create new symbols, and make our old symbols 2639 indirect to the new ones. Consolidate the got and reloc information 2640 in these situations. */ 2641 2642static boolean 2643elf64_alpha_merge_ind_symbols (hi, dummy) 2644 struct alpha_elf_link_hash_entry *hi; 2645 PTR dummy ATTRIBUTE_UNUSED; 2646{ 2647 struct alpha_elf_link_hash_entry *hs; 2648 2649 if (hi->root.root.type != bfd_link_hash_indirect) 2650 return true; 2651 hs = hi; 2652 do { 2653 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link; 2654 } while (hs->root.root.type == bfd_link_hash_indirect); 2655 2656 /* Merge the flags. Whee. */ 2657 2658 hs->flags |= hi->flags; 2659 2660 /* Merge the .got entries. Cannibalize the old symbol's list in 2661 doing so, since we don't need it anymore. */ 2662 2663 if (hs->got_entries == NULL) 2664 hs->got_entries = hi->got_entries; 2665 else 2666 { 2667 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh; 2668 2669 gsh = hs->got_entries; 2670 for (gi = hi->got_entries; gi ; gi = gin) 2671 { 2672 gin = gi->next; 2673 for (gs = gsh; gs ; gs = gs->next) 2674 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend) 2675 goto got_found; 2676 gi->next = hs->got_entries; 2677 hs->got_entries = gi; 2678 got_found:; 2679 } 2680 } 2681 hi->got_entries = NULL; 2682 2683 /* And similar for the reloc entries. */ 2684 2685 if (hs->reloc_entries == NULL) 2686 hs->reloc_entries = hi->reloc_entries; 2687 else 2688 { 2689 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh; 2690 2691 rsh = hs->reloc_entries; 2692 for (ri = hi->reloc_entries; ri ; ri = rin) 2693 { 2694 rin = ri->next; 2695 for (rs = rsh; rs ; rs = rs->next) 2696 if (ri->rtype == rs->rtype) 2697 { 2698 rs->count += ri->count; 2699 goto found_reloc; 2700 } 2701 ri->next = hs->reloc_entries; 2702 hs->reloc_entries = ri; 2703 found_reloc:; 2704 } 2705 } 2706 hi->reloc_entries = NULL; 2707 2708 return true; 2709} 2710 2711/* Is it possible to merge two object file's .got tables? */ 2712 2713static boolean 2714elf64_alpha_can_merge_gots (a, b) 2715 bfd *a, *b; 2716{ 2717 int total = alpha_elf_tdata (a)->total_got_entries; 2718 bfd *bsub; 2719 2720 /* Trivial quick fallout test. */ 2721 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES) 2722 return true; 2723 2724 /* By their nature, local .got entries cannot be merged. */ 2725 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES) 2726 return false; 2727 2728 /* Failing the common trivial comparison, we must effectively 2729 perform the merge. Not actually performing the merge means that 2730 we don't have to store undo information in case we fail. */ 2731 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next) 2732 { 2733 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub); 2734 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr; 2735 int i, n; 2736 2737 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info; 2738 for (i = 0; i < n; ++i) 2739 { 2740 struct alpha_elf_got_entry *ae, *be; 2741 struct alpha_elf_link_hash_entry *h; 2742 2743 h = hashes[i]; 2744 while (h->root.root.type == bfd_link_hash_indirect 2745 || h->root.root.type == bfd_link_hash_warning) 2746 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link; 2747 2748 for (be = h->got_entries; be ; be = be->next) 2749 { 2750 if (be->use_count == 0) 2751 continue; 2752 if (be->gotobj != b) 2753 continue; 2754 2755 for (ae = h->got_entries; ae ; ae = ae->next) 2756 if (ae->gotobj == a && ae->addend == be->addend) 2757 goto global_found; 2758 2759 if (++total > MAX_GOT_ENTRIES) 2760 return false; 2761 global_found:; 2762 } 2763 } 2764 } 2765 2766 return true; 2767} 2768 2769/* Actually merge two .got tables. */ 2770 2771static void 2772elf64_alpha_merge_gots (a, b) 2773 bfd *a, *b; 2774{ 2775 int total = alpha_elf_tdata (a)->total_got_entries; 2776 bfd *bsub; 2777 2778 /* Remember local expansion. */ 2779 { 2780 int e = alpha_elf_tdata (b)->n_local_got_entries; 2781 total += e; 2782 alpha_elf_tdata (a)->n_local_got_entries += e; 2783 } 2784 2785 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next) 2786 { 2787 struct alpha_elf_got_entry **local_got_entries; 2788 struct alpha_elf_link_hash_entry **hashes; 2789 Elf_Internal_Shdr *symtab_hdr; 2790 int i, n; 2791 2792 /* Let the local .got entries know they are part of a new subsegment. */ 2793 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries; 2794 if (local_got_entries) 2795 { 2796 n = elf_tdata (bsub)->symtab_hdr.sh_info; 2797 for (i = 0; i < n; ++i) 2798 { 2799 struct alpha_elf_got_entry *ent; 2800 for (ent = local_got_entries[i]; ent; ent = ent->next) 2801 ent->gotobj = a; 2802 } 2803 } 2804 2805 /* Merge the global .got entries. */ 2806 hashes = alpha_elf_sym_hashes (bsub); 2807 symtab_hdr = &elf_tdata (bsub)->symtab_hdr; 2808 2809 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info; 2810 for (i = 0; i < n; ++i) 2811 { 2812 struct alpha_elf_got_entry *ae, *be, **pbe, **start; 2813 struct alpha_elf_link_hash_entry *h; 2814 2815 h = hashes[i]; 2816 while (h->root.root.type == bfd_link_hash_indirect 2817 || h->root.root.type == bfd_link_hash_warning) 2818 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link; 2819 2820 start = &h->got_entries; 2821 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next) 2822 { 2823 if (be->use_count == 0) 2824 { 2825 *pbe = be->next; 2826 continue; 2827 } 2828 if (be->gotobj != b) 2829 continue; 2830 2831 for (ae = *start; ae ; ae = ae->next) 2832 if (ae->gotobj == a && ae->addend == be->addend) 2833 { 2834 ae->flags |= be->flags; 2835 ae->use_count += be->use_count; 2836 *pbe = be->next; 2837 goto global_found; 2838 } 2839 be->gotobj = a; 2840 total += 1; 2841 2842 global_found:; 2843 } 2844 } 2845 2846 alpha_elf_tdata (bsub)->gotobj = a; 2847 } 2848 alpha_elf_tdata (a)->total_got_entries = total; 2849 2850 /* Merge the two in_got chains. */ 2851 { 2852 bfd *next; 2853 2854 bsub = a; 2855 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL) 2856 bsub = next; 2857 2858 alpha_elf_tdata (bsub)->in_got_link_next = b; 2859 } 2860} 2861 2862/* Calculate the offsets for the got entries. */ 2863 2864static boolean 2865elf64_alpha_calc_got_offsets_for_symbol (h, arg) 2866 struct alpha_elf_link_hash_entry *h; 2867 PTR arg ATTRIBUTE_UNUSED; 2868{ 2869 struct alpha_elf_got_entry *gotent; 2870 2871 if (h->root.root.type == bfd_link_hash_warning) 2872 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link; 2873 2874 for (gotent = h->got_entries; gotent; gotent = gotent->next) 2875 if (gotent->use_count > 0) 2876 { 2877 bfd_size_type *plge 2878 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size; 2879 2880 gotent->got_offset = *plge; 2881 *plge += 8; 2882 } 2883 2884 return true; 2885} 2886 2887static void 2888elf64_alpha_calc_got_offsets (info) 2889 struct bfd_link_info *info; 2890{ 2891 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list; 2892 2893 /* First, zero out the .got sizes, as we may be recalculating the 2894 .got after optimizing it. */ 2895 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next) 2896 alpha_elf_tdata(i)->got->_raw_size = 0; 2897 2898 /* Next, fill in the offsets for all the global entries. */ 2899 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info), 2900 elf64_alpha_calc_got_offsets_for_symbol, 2901 NULL); 2902 2903 /* Finally, fill in the offsets for the local entries. */ 2904 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next) 2905 { 2906 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size; 2907 bfd *j; 2908 2909 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next) 2910 { 2911 struct alpha_elf_got_entry **local_got_entries, *gotent; 2912 int k, n; 2913 2914 local_got_entries = alpha_elf_tdata(j)->local_got_entries; 2915 if (!local_got_entries) 2916 continue; 2917 2918 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k) 2919 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next) 2920 if (gotent->use_count > 0) 2921 { 2922 gotent->got_offset = got_offset; 2923 got_offset += 8; 2924 } 2925 } 2926 2927 alpha_elf_tdata(i)->got->_raw_size = got_offset; 2928 alpha_elf_tdata(i)->got->_cooked_size = got_offset; 2929 } 2930} 2931 2932/* Constructs the gots. */ 2933 2934static boolean 2935elf64_alpha_size_got_sections (output_bfd, info) 2936 bfd *output_bfd ATTRIBUTE_UNUSED; 2937 struct bfd_link_info *info; 2938{ 2939 bfd *i, *got_list, *cur_got_obj = NULL; 2940 int something_changed = 0; 2941 2942 got_list = alpha_elf_hash_table (info)->got_list; 2943 2944 /* On the first time through, pretend we have an existing got list 2945 consisting of all of the input files. */ 2946 if (got_list == NULL) 2947 { 2948 for (i = info->input_bfds; i ; i = i->link_next) 2949 { 2950 bfd *this_got = alpha_elf_tdata (i)->gotobj; 2951 if (this_got == NULL) 2952 continue; 2953 2954 /* We are assuming no merging has yet ocurred. */ 2955 BFD_ASSERT (this_got == i); 2956 2957 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES) 2958 { 2959 /* Yikes! A single object file has too many entries. */ 2960 (*_bfd_error_handler) 2961 (_("%s: .got subsegment exceeds 64K (size %d)"), 2962 bfd_archive_filename (i), 2963 alpha_elf_tdata (this_got)->total_got_entries * 8); 2964 return false; 2965 } 2966 2967 if (got_list == NULL) 2968 got_list = this_got; 2969 else 2970 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got; 2971 cur_got_obj = this_got; 2972 } 2973 2974 /* Strange degenerate case of no got references. */ 2975 if (got_list == NULL) 2976 return true; 2977 2978 alpha_elf_hash_table (info)->got_list = got_list; 2979 2980 /* Force got offsets to be recalculated. */ 2981 something_changed = 1; 2982 } 2983 2984 cur_got_obj = got_list; 2985 i = alpha_elf_tdata(cur_got_obj)->got_link_next; 2986 while (i != NULL) 2987 { 2988 if (elf64_alpha_can_merge_gots (cur_got_obj, i)) 2989 { 2990 elf64_alpha_merge_gots (cur_got_obj, i); 2991 i = alpha_elf_tdata(i)->got_link_next; 2992 alpha_elf_tdata(cur_got_obj)->got_link_next = i; 2993 something_changed = 1; 2994 } 2995 else 2996 { 2997 cur_got_obj = i; 2998 i = alpha_elf_tdata(i)->got_link_next; 2999 } 3000 } 3001 3002 /* Once the gots have been merged, fill in the got offsets for 3003 everything therein. */ 3004 if (1 || something_changed) 3005 elf64_alpha_calc_got_offsets (info); 3006 3007 return true; 3008} 3009 3010static boolean 3011elf64_alpha_always_size_sections (output_bfd, info) 3012 bfd *output_bfd; 3013 struct bfd_link_info *info; 3014{ 3015 bfd *i; 3016 3017 if (info->relocateable) 3018 return true; 3019 3020 /* First, take care of the indirect symbols created by versioning. */ 3021 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info), 3022 elf64_alpha_merge_ind_symbols, 3023 NULL); 3024 3025 if (!elf64_alpha_size_got_sections (output_bfd, info)) 3026 return false; 3027 3028 /* Allocate space for all of the .got subsections. */ 3029 i = alpha_elf_hash_table (info)->got_list; 3030 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next) 3031 { 3032 asection *s = alpha_elf_tdata(i)->got; 3033 if (s->_raw_size > 0) 3034 { 3035 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size); 3036 if (s->contents == NULL) 3037 return false; 3038 } 3039 } 3040 3041 return true; 3042} 3043 3044/* Work out the sizes of the dynamic relocation entries. */ 3045 3046static boolean 3047elf64_alpha_calc_dynrel_sizes (h, info) 3048 struct alpha_elf_link_hash_entry *h; 3049 struct bfd_link_info *info; 3050{ 3051 if (h->root.root.type == bfd_link_hash_warning) 3052 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link; 3053 3054 /* If the symbol was defined as a common symbol in a regular object 3055 file, and there was no definition in any dynamic object, then the 3056 linker will have allocated space for the symbol in a common 3057 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been 3058 set. This is done for dynamic symbols in 3059 elf_adjust_dynamic_symbol but this is not done for non-dynamic 3060 symbols, somehow. */ 3061 if (((h->root.elf_link_hash_flags 3062 & (ELF_LINK_HASH_DEF_REGULAR 3063 | ELF_LINK_HASH_REF_REGULAR 3064 | ELF_LINK_HASH_DEF_DYNAMIC)) 3065 == ELF_LINK_HASH_REF_REGULAR) 3066 && (h->root.root.type == bfd_link_hash_defined 3067 || h->root.root.type == bfd_link_hash_defweak) 3068 && !(h->root.root.u.def.section->owner->flags & DYNAMIC)) 3069 { 3070 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR; 3071 } 3072 3073 /* If the symbol is dynamic, we'll need all the relocations in their 3074 natural form. If this is a shared object, and it has been forced 3075 local, we'll need the same number of RELATIVE relocations. */ 3076 3077 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared) 3078 { 3079 struct alpha_elf_reloc_entry *relent; 3080 bfd *dynobj; 3081 struct alpha_elf_got_entry *gotent; 3082 bfd_size_type count; 3083 asection *srel; 3084 3085 for (relent = h->reloc_entries; relent; relent = relent->next) 3086 if (relent->rtype == R_ALPHA_REFLONG 3087 || relent->rtype == R_ALPHA_REFQUAD) 3088 { 3089 relent->srel->_raw_size += 3090 sizeof (Elf64_External_Rela) * relent->count; 3091 if (relent->reltext) 3092 info->flags |= DT_TEXTREL; 3093 } 3094 3095 dynobj = elf_hash_table(info)->dynobj; 3096 count = 0; 3097 3098 for (gotent = h->got_entries; gotent ; gotent = gotent->next) 3099 count++; 3100 3101 /* If we are using a .plt entry, subtract one, as the first 3102 reference uses a .rela.plt entry instead. */ 3103 if (h->root.plt.offset != MINUS_ONE) 3104 count--; 3105 3106 if (count > 0) 3107 { 3108 srel = bfd_get_section_by_name (dynobj, ".rela.got"); 3109 BFD_ASSERT (srel != NULL); 3110 srel->_raw_size += sizeof (Elf64_External_Rela) * count; 3111 } 3112 } 3113 3114 return true; 3115} 3116 3117/* Set the sizes of the dynamic sections. */ 3118 3119static boolean 3120elf64_alpha_size_dynamic_sections (output_bfd, info) 3121 bfd *output_bfd ATTRIBUTE_UNUSED; 3122 struct bfd_link_info *info; 3123{ 3124 bfd *dynobj; 3125 asection *s; 3126 boolean relplt; 3127 3128 dynobj = elf_hash_table(info)->dynobj; 3129 BFD_ASSERT(dynobj != NULL); 3130 3131 if (elf_hash_table (info)->dynamic_sections_created) 3132 { 3133 /* Set the contents of the .interp section to the interpreter. */ 3134 if (!info->shared) 3135 { 3136 s = bfd_get_section_by_name (dynobj, ".interp"); 3137 BFD_ASSERT (s != NULL); 3138 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 3139 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 3140 } 3141 3142 /* Now that we've seen all of the input files, we can decide which 3143 symbols need dynamic relocation entries and which don't. We've 3144 collected information in check_relocs that we can now apply to 3145 size the dynamic relocation sections. */ 3146 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info), 3147 elf64_alpha_calc_dynrel_sizes, 3148 info); 3149 3150 /* When building shared libraries, each local .got entry needs a 3151 RELATIVE reloc. */ 3152 if (info->shared) 3153 { 3154 bfd *i; 3155 asection *srel; 3156 bfd_size_type count; 3157 3158 srel = bfd_get_section_by_name (dynobj, ".rela.got"); 3159 BFD_ASSERT (srel != NULL); 3160 3161 for (i = alpha_elf_hash_table(info)->got_list, count = 0; 3162 i != NULL; 3163 i = alpha_elf_tdata(i)->got_link_next) 3164 count += alpha_elf_tdata(i)->n_local_got_entries; 3165 3166 srel->_raw_size += count * sizeof (Elf64_External_Rela); 3167 } 3168 } 3169 /* else we're not dynamic and by definition we don't need such things. */ 3170 3171 /* The check_relocs and adjust_dynamic_symbol entry points have 3172 determined the sizes of the various dynamic sections. Allocate 3173 memory for them. */ 3174 relplt = false; 3175 for (s = dynobj->sections; s != NULL; s = s->next) 3176 { 3177 const char *name; 3178 boolean strip; 3179 3180 if (!(s->flags & SEC_LINKER_CREATED)) 3181 continue; 3182 3183 /* It's OK to base decisions on the section name, because none 3184 of the dynobj section names depend upon the input files. */ 3185 name = bfd_get_section_name (dynobj, s); 3186 3187 /* If we don't need this section, strip it from the output file. 3188 This is to handle .rela.bss and .rela.plt. We must create it 3189 in create_dynamic_sections, because it must be created before 3190 the linker maps input sections to output sections. The 3191 linker does that before adjust_dynamic_symbol is called, and 3192 it is that function which decides whether anything needs to 3193 go into these sections. */ 3194 3195 strip = false; 3196 3197 if (strncmp (name, ".rela", 5) == 0) 3198 { 3199 strip = (s->_raw_size == 0); 3200 3201 if (!strip) 3202 { 3203 if (strcmp(name, ".rela.plt") == 0) 3204 relplt = true; 3205 3206 /* We use the reloc_count field as a counter if we need 3207 to copy relocs into the output file. */ 3208 s->reloc_count = 0; 3209 } 3210 } 3211 else if (strcmp (name, ".plt") != 0) 3212 { 3213 /* It's not one of our dynamic sections, so don't allocate space. */ 3214 continue; 3215 } 3216 3217 if (strip) 3218 _bfd_strip_section_from_output (info, s); 3219 else 3220 { 3221 /* Allocate memory for the section contents. */ 3222 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 3223 if (s->contents == NULL && s->_raw_size != 0) 3224 return false; 3225 } 3226 } 3227 3228 if (elf_hash_table (info)->dynamic_sections_created) 3229 { 3230 /* Add some entries to the .dynamic section. We fill in the 3231 values later, in elf64_alpha_finish_dynamic_sections, but we 3232 must add the entries now so that we get the correct size for 3233 the .dynamic section. The DT_DEBUG entry is filled in by the 3234 dynamic linker and used by the debugger. */ 3235#define add_dynamic_entry(TAG, VAL) \ 3236 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL)) 3237 3238 if (!info->shared) 3239 { 3240 if (!add_dynamic_entry (DT_DEBUG, 0)) 3241 return false; 3242 } 3243 3244 if (!add_dynamic_entry (DT_PLTGOT, 0)) 3245 return false; 3246 3247 if (relplt) 3248 { 3249 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 3250 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 3251 || !add_dynamic_entry (DT_JMPREL, 0)) 3252 return false; 3253 } 3254 3255 if (!add_dynamic_entry (DT_RELA, 0) 3256 || !add_dynamic_entry (DT_RELASZ, 0) 3257 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela))) 3258 return false; 3259 3260 if (info->flags & DF_TEXTREL) 3261 { 3262 if (!add_dynamic_entry (DT_TEXTREL, 0)) 3263 return false; 3264 } 3265 } 3266#undef add_dynamic_entry 3267 3268 return true; 3269} 3270 3271/* Relocate an Alpha ELF section. */ 3272 3273static boolean 3274elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section, 3275 contents, relocs, local_syms, local_sections) 3276 bfd *output_bfd; 3277 struct bfd_link_info *info; 3278 bfd *input_bfd; 3279 asection *input_section; 3280 bfd_byte *contents; 3281 Elf_Internal_Rela *relocs; 3282 Elf_Internal_Sym *local_syms; 3283 asection **local_sections; 3284{ 3285 Elf_Internal_Shdr *symtab_hdr; 3286 Elf_Internal_Rela *rel; 3287 Elf_Internal_Rela *relend; 3288 asection *sec, *sgot, *srel, *srelgot; 3289 bfd *dynobj, *gotobj; 3290 bfd_vma gp; 3291 boolean ret_val = true; 3292 3293 srelgot = srel = NULL; 3294 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3295 dynobj = elf_hash_table (info)->dynobj; 3296 if (dynobj) 3297 { 3298 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 3299 } 3300 3301 /* Find the gp value for this input bfd. */ 3302 sgot = NULL; 3303 gp = 0; 3304 gotobj = alpha_elf_tdata (input_bfd)->gotobj; 3305 if (gotobj) 3306 { 3307 sgot = alpha_elf_tdata (gotobj)->got; 3308 gp = _bfd_get_gp_value (gotobj); 3309 if (gp == 0) 3310 { 3311 gp = (sgot->output_section->vma 3312 + sgot->output_offset 3313 + 0x8000); 3314 _bfd_set_gp_value (gotobj, gp); 3315 } 3316 } 3317 3318 rel = relocs; 3319 relend = relocs + input_section->reloc_count; 3320 for (; rel < relend; rel++) 3321 { 3322 int r_type; 3323 reloc_howto_type *howto; 3324 unsigned long r_symndx; 3325 struct alpha_elf_link_hash_entry *h; 3326 Elf_Internal_Sym *sym; 3327 bfd_vma relocation; 3328 bfd_vma addend; 3329 bfd_reloc_status_type r; 3330 3331 r_type = ELF64_R_TYPE(rel->r_info); 3332 if (r_type < 0 || r_type >= (int) R_ALPHA_max) 3333 { 3334 bfd_set_error (bfd_error_bad_value); 3335 return false; 3336 } 3337 howto = elf64_alpha_howto_table + r_type; 3338 3339 r_symndx = ELF64_R_SYM(rel->r_info); 3340 3341 if (info->relocateable) 3342 { 3343 /* This is a relocateable link. We don't have to change 3344 anything, unless the reloc is against a section symbol, 3345 in which case we have to adjust according to where the 3346 section symbol winds up in the output section. */ 3347 3348 /* The symbol associated with GPDISP and LITUSE is 3349 immaterial. Only the addend is significant. */ 3350 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE) 3351 continue; 3352 3353 if (r_symndx < symtab_hdr->sh_info) 3354 { 3355 sym = local_syms + r_symndx; 3356 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION) 3357 { 3358 sec = local_sections[r_symndx]; 3359 rel->r_addend += sec->output_offset + sym->st_value; 3360 } 3361 } 3362 3363 continue; 3364 } 3365 3366 /* This is a final link. */ 3367 3368 h = NULL; 3369 sym = NULL; 3370 sec = NULL; 3371 3372 if (r_symndx < symtab_hdr->sh_info) 3373 { 3374 sym = local_syms + r_symndx; 3375 sec = local_sections[r_symndx]; 3376 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel); 3377 } 3378 else 3379 { 3380 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info]; 3381 3382 while (h->root.root.type == bfd_link_hash_indirect 3383 || h->root.root.type == bfd_link_hash_warning) 3384 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link; 3385 3386 if (h->root.root.type == bfd_link_hash_defined 3387 || h->root.root.type == bfd_link_hash_defweak) 3388 { 3389 sec = h->root.root.u.def.section; 3390 3391 if (sec->output_section == NULL) 3392 relocation = 0; 3393 else 3394 { 3395 relocation = (h->root.root.u.def.value 3396 + sec->output_section->vma 3397 + sec->output_offset); 3398 } 3399 } 3400 else if (h->root.root.type == bfd_link_hash_undefweak) 3401 relocation = 0; 3402 else if (info->shared 3403 && (!info->symbolic || info->allow_shlib_undefined) 3404 && !info->no_undefined 3405 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT) 3406 relocation = 0; 3407 else 3408 { 3409 if (!((*info->callbacks->undefined_symbol) 3410 (info, h->root.root.root.string, input_bfd, 3411 input_section, rel->r_offset, 3412 (!info->shared || info->no_undefined 3413 || ELF_ST_VISIBILITY (h->root.other))))) 3414 ret_val = false; 3415 relocation = 0; 3416 } 3417 } 3418 addend = rel->r_addend; 3419 3420 switch (r_type) 3421 { 3422 case R_ALPHA_GPDISP: 3423 { 3424 bfd_byte *p_ldah, *p_lda; 3425 3426 BFD_ASSERT(gp != 0); 3427 3428 relocation = (input_section->output_section->vma 3429 + input_section->output_offset 3430 + rel->r_offset); 3431 3432 p_ldah = contents + rel->r_offset - input_section->vma; 3433 p_lda = p_ldah + rel->r_addend; 3434 3435 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation, 3436 p_ldah, p_lda); 3437 } 3438 break; 3439 3440 case R_ALPHA_LITERAL: 3441 { 3442 struct alpha_elf_got_entry *gotent; 3443 boolean dynamic_symbol; 3444 3445 BFD_ASSERT(sgot != NULL); 3446 BFD_ASSERT(gp != 0); 3447 3448 if (h != NULL) 3449 { 3450 gotent = h->got_entries; 3451 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info); 3452 } 3453 else 3454 { 3455 gotent = (alpha_elf_tdata(input_bfd)-> 3456 local_got_entries[r_symndx]); 3457 dynamic_symbol = false; 3458 3459 /* Need to adjust local GOT entries' addends for SEC_MERGE 3460 unless it has been done already. */ 3461 if ((sec->flags & SEC_MERGE) 3462 && ELF_ST_TYPE (sym->st_info) == STT_SECTION 3463 && (elf_section_data (sec)->sec_info_type 3464 == ELF_INFO_TYPE_MERGE) 3465 && (gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED) == 0) 3466 { 3467 struct alpha_elf_got_entry *ent; 3468 asection *msec; 3469 3470 for (ent = gotent; ent; ent = ent->next) 3471 { 3472 ent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED; 3473 if (ent->use_count == 0) 3474 continue; 3475 msec = sec; 3476 ent->addend = 3477 _bfd_merged_section_offset (output_bfd, &msec, 3478 elf_section_data (sec)-> 3479 sec_info, 3480 sym->st_value 3481 + ent->addend, 3482 (bfd_vma) 0); 3483 ent->addend -= sym->st_value; 3484 ent->addend += msec->output_section->vma 3485 + msec->output_offset 3486 - sec->output_section->vma 3487 - sec->output_offset; 3488 } 3489 } 3490 } 3491 3492 BFD_ASSERT(gotent != NULL); 3493 3494 while (gotent->gotobj != gotobj || gotent->addend != addend) 3495 gotent = gotent->next; 3496 3497 BFD_ASSERT(gotent->use_count >= 1); 3498 3499 /* Initialize the .got entry's value. */ 3500 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE)) 3501 { 3502 bfd_put_64 (output_bfd, relocation + addend, 3503 sgot->contents + gotent->got_offset); 3504 3505 /* If the symbol has been forced local, output a 3506 RELATIVE reloc, otherwise it will be handled in 3507 finish_dynamic_symbol. */ 3508 if (info->shared && !dynamic_symbol) 3509 { 3510 Elf_Internal_Rela outrel; 3511 3512 BFD_ASSERT(srelgot != NULL); 3513 3514 outrel.r_offset = (sgot->output_section->vma 3515 + sgot->output_offset 3516 + gotent->got_offset); 3517 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE); 3518 outrel.r_addend = relocation + addend; 3519 3520 bfd_elf64_swap_reloca_out (output_bfd, &outrel, 3521 ((Elf64_External_Rela *) 3522 srelgot->contents) 3523 + srelgot->reloc_count++); 3524 BFD_ASSERT (sizeof (Elf64_External_Rela) 3525 * srelgot->reloc_count 3526 <= srelgot->_cooked_size); 3527 } 3528 3529 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE; 3530 } 3531 3532 /* Figure the gprel relocation. */ 3533 addend = 0; 3534 relocation = (sgot->output_section->vma 3535 + sgot->output_offset 3536 + gotent->got_offset); 3537 relocation -= gp; 3538 } 3539 /* overflow handled by _bfd_final_link_relocate */ 3540 goto default_reloc; 3541 3542 case R_ALPHA_GPREL16: 3543 case R_ALPHA_GPREL32: 3544 case R_ALPHA_GPRELLOW: 3545 if (h && alpha_elf_dynamic_symbol_p (&h->root, info)) 3546 { 3547 (*_bfd_error_handler) 3548 (_("%s: gp-relative relocation against dynamic symbol %s"), 3549 bfd_archive_filename (input_bfd), h->root.root.root.string); 3550 ret_val = false; 3551 } 3552 BFD_ASSERT(gp != 0); 3553 relocation -= gp; 3554 goto default_reloc; 3555 3556 case R_ALPHA_GPRELHIGH: 3557 if (h && alpha_elf_dynamic_symbol_p (&h->root, info)) 3558 { 3559 (*_bfd_error_handler) 3560 (_("%s: gp-relative relocation against dynamic symbol %s"), 3561 bfd_archive_filename (input_bfd), h->root.root.root.string); 3562 ret_val = false; 3563 } 3564 BFD_ASSERT(gp != 0); 3565 relocation -= gp; 3566 relocation += addend; 3567 addend = 0; 3568 relocation = (((bfd_signed_vma) relocation >> 16) 3569 + ((relocation >> 15) & 1)); 3570 goto default_reloc; 3571 3572 case R_ALPHA_HINT: 3573 /* A call to a dynamic symbol is definitely out of range of 3574 the 16-bit displacement. Don't bother writing anything. */ 3575 if (h && alpha_elf_dynamic_symbol_p (&h->root, info)) 3576 { 3577 r = bfd_reloc_ok; 3578 break; 3579 } 3580 /* FALLTHRU */ 3581 3582 case R_ALPHA_BRADDR: 3583 /* The regular PC-relative stuff measures from the start of 3584 the instruction rather than the end. */ 3585 addend -= 4; 3586 goto default_reloc; 3587 3588 case R_ALPHA_BRSGP: 3589 { 3590 int other; 3591 const char *name; 3592 3593 /* The regular PC-relative stuff measures from the start of 3594 the instruction rather than the end. */ 3595 addend -= 4; 3596 3597 /* The source and destination gp must be the same. Note that 3598 the source will always have an assigned gp, since we forced 3599 one in check_relocs, but that the destination may not, as 3600 it might not have had any relocations at all. Also take 3601 care not to crash if H is an undefined symbol. */ 3602 if (h != NULL && sec != NULL 3603 && alpha_elf_tdata (sec->owner)->gotobj 3604 && gotobj != alpha_elf_tdata (sec->owner)->gotobj) 3605 { 3606 (*_bfd_error_handler) 3607 (_("%s: change in gp: BRSGP %s"), 3608 bfd_archive_filename (input_bfd), h->root.root.root.string); 3609 ret_val = false; 3610 } 3611 3612 /* The symbol should be marked either NOPV or STD_GPLOAD. */ 3613 if (h != NULL) 3614 other = h->root.other; 3615 else 3616 other = sym->st_other; 3617 switch (other & STO_ALPHA_STD_GPLOAD) 3618 { 3619 case STO_ALPHA_NOPV: 3620 break; 3621 case STO_ALPHA_STD_GPLOAD: 3622 addend += 8; 3623 break; 3624 default: 3625 if (h != NULL) 3626 name = h->root.root.root.string; 3627 else 3628 { 3629 name = (bfd_elf_string_from_elf_section 3630 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 3631 if (name == NULL) 3632 name = _("<unknown>"); 3633 else if (name[0] == 0) 3634 name = bfd_section_name (input_bfd, sec); 3635 } 3636 (*_bfd_error_handler) 3637 (_("%s: !samegp reloc against symbol without .prologue: %s"), 3638 bfd_archive_filename (input_bfd), name); 3639 ret_val = false; 3640 break; 3641 } 3642 3643 goto default_reloc; 3644 } 3645 3646 case R_ALPHA_REFLONG: 3647 case R_ALPHA_REFQUAD: 3648 { 3649 Elf_Internal_Rela outrel; 3650 3651 /* Careful here to remember RELATIVE relocations for global 3652 variables for symbolic shared objects. */ 3653 3654 if (h && alpha_elf_dynamic_symbol_p (&h->root, info)) 3655 { 3656 BFD_ASSERT(h->root.dynindx != -1); 3657 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type); 3658 outrel.r_addend = addend; 3659 addend = 0, relocation = 0; 3660 } 3661 else if (info->shared 3662 && r_symndx != 0 3663 && (input_section->flags & SEC_ALLOC)) 3664 { 3665 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE); 3666 outrel.r_addend = relocation + addend; 3667 } 3668 else 3669 goto default_reloc; 3670 3671 if (!srel) 3672 { 3673 const char *name; 3674 3675 name = (bfd_elf_string_from_elf_section 3676 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx, 3677 elf_section_data(input_section)->rel_hdr.sh_name)); 3678 BFD_ASSERT(name != NULL); 3679 3680 srel = bfd_get_section_by_name (dynobj, name); 3681 BFD_ASSERT(srel != NULL); 3682 } 3683 3684 outrel.r_offset = 3685 _bfd_elf_section_offset (output_bfd, info, input_section, 3686 rel->r_offset); 3687 if ((outrel.r_offset | 1) != (bfd_vma) -1) 3688 outrel.r_offset += (input_section->output_section->vma 3689 + input_section->output_offset); 3690 else 3691 memset (&outrel, 0, sizeof outrel); 3692 3693 bfd_elf64_swap_reloca_out (output_bfd, &outrel, 3694 ((Elf64_External_Rela *) 3695 srel->contents) 3696 + srel->reloc_count++); 3697 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count 3698 <= srel->_cooked_size); 3699 } 3700 goto default_reloc; 3701 3702 case R_ALPHA_SREL32: 3703 case R_ALPHA_SREL64: 3704 /* ??? .eh_frame references to discarded sections will be smashed 3705 to relocations against SHN_UNDEF. The .eh_frame format allows 3706 NULL to be encoded as 0 in any format, so this works here. */ 3707 if (r_symndx == 0) 3708 howto = (elf64_alpha_howto_table 3709 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG)); 3710 goto default_reloc; 3711 3712 default: 3713 default_reloc: 3714 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 3715 contents, rel->r_offset, relocation, 3716 addend); 3717 break; 3718 } 3719 3720 switch (r) 3721 { 3722 case bfd_reloc_ok: 3723 break; 3724 3725 case bfd_reloc_overflow: 3726 { 3727 const char *name; 3728 3729 /* Don't warn if the overflow is due to pc relative reloc 3730 against discarded section. Section optimization code should 3731 handle it. */ 3732 3733 if (r_symndx < symtab_hdr->sh_info 3734 && sec != NULL && howto->pc_relative 3735 && elf_discarded_section (sec)) 3736 break; 3737 3738 if (h != NULL) 3739 name = h->root.root.root.string; 3740 else 3741 { 3742 name = (bfd_elf_string_from_elf_section 3743 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 3744 if (name == NULL) 3745 return false; 3746 if (*name == '\0') 3747 name = bfd_section_name (input_bfd, sec); 3748 } 3749 if (! ((*info->callbacks->reloc_overflow) 3750 (info, name, howto->name, (bfd_vma) 0, 3751 input_bfd, input_section, rel->r_offset))) 3752 ret_val = false; 3753 } 3754 break; 3755 3756 default: 3757 case bfd_reloc_outofrange: 3758 abort (); 3759 } 3760 } 3761 3762 return ret_val; 3763} 3764 3765/* Finish up dynamic symbol handling. We set the contents of various 3766 dynamic sections here. */ 3767 3768static boolean 3769elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym) 3770 bfd *output_bfd; 3771 struct bfd_link_info *info; 3772 struct elf_link_hash_entry *h; 3773 Elf_Internal_Sym *sym; 3774{ 3775 bfd *dynobj = elf_hash_table(info)->dynobj; 3776 3777 if (h->plt.offset != MINUS_ONE) 3778 { 3779 /* Fill in the .plt entry for this symbol. */ 3780 asection *splt, *sgot, *srel; 3781 Elf_Internal_Rela outrel; 3782 bfd_vma got_addr, plt_addr; 3783 bfd_vma plt_index; 3784 struct alpha_elf_got_entry *gotent; 3785 3786 BFD_ASSERT (h->dynindx != -1); 3787 3788 /* The first .got entry will be updated by the .plt with the 3789 address of the target function. */ 3790 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries; 3791 BFD_ASSERT (gotent && gotent->addend == 0); 3792 3793 splt = bfd_get_section_by_name (dynobj, ".plt"); 3794 BFD_ASSERT (splt != NULL); 3795 srel = bfd_get_section_by_name (dynobj, ".rela.plt"); 3796 BFD_ASSERT (srel != NULL); 3797 sgot = alpha_elf_tdata (gotent->gotobj)->got; 3798 BFD_ASSERT (sgot != NULL); 3799 3800 got_addr = (sgot->output_section->vma 3801 + sgot->output_offset 3802 + gotent->got_offset); 3803 plt_addr = (splt->output_section->vma 3804 + splt->output_offset 3805 + h->plt.offset); 3806 3807 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE; 3808 3809 /* Fill in the entry in the procedure linkage table. */ 3810 { 3811 bfd_vma insn1, insn2, insn3; 3812 3813 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff); 3814 insn2 = PLT_ENTRY_WORD2; 3815 insn3 = PLT_ENTRY_WORD3; 3816 3817 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset); 3818 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4); 3819 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8); 3820 } 3821 3822 /* Fill in the entry in the .rela.plt section. */ 3823 outrel.r_offset = got_addr; 3824 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT); 3825 outrel.r_addend = 0; 3826 3827 bfd_elf64_swap_reloca_out (output_bfd, &outrel, 3828 ((Elf64_External_Rela *)srel->contents 3829 + plt_index)); 3830 3831 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 3832 { 3833 /* Mark the symbol as undefined, rather than as defined in the 3834 .plt section. Leave the value alone. */ 3835 sym->st_shndx = SHN_UNDEF; 3836 } 3837 3838 /* Fill in the entries in the .got. */ 3839 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset); 3840 3841 /* Subsequent .got entries will continue to bounce through the .plt. */ 3842 if (gotent->next) 3843 { 3844 srel = bfd_get_section_by_name (dynobj, ".rela.got"); 3845 BFD_ASSERT (! info->shared || srel != NULL); 3846 3847 gotent = gotent->next; 3848 do 3849 { 3850 sgot = alpha_elf_tdata(gotent->gotobj)->got; 3851 BFD_ASSERT(sgot != NULL); 3852 BFD_ASSERT(gotent->addend == 0); 3853 3854 bfd_put_64 (output_bfd, plt_addr, 3855 sgot->contents + gotent->got_offset); 3856 3857 if (info->shared) 3858 { 3859 outrel.r_offset = (sgot->output_section->vma 3860 + sgot->output_offset 3861 + gotent->got_offset); 3862 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE); 3863 outrel.r_addend = plt_addr; 3864 3865 bfd_elf64_swap_reloca_out (output_bfd, &outrel, 3866 ((Elf64_External_Rela *) 3867 srel->contents) 3868 + srel->reloc_count++); 3869 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count 3870 <= srel->_cooked_size); 3871 } 3872 3873 gotent = gotent->next; 3874 } 3875 while (gotent != NULL); 3876 } 3877 } 3878 else if (alpha_elf_dynamic_symbol_p (h, info)) 3879 { 3880 /* Fill in the dynamic relocations for this symbol's .got entries. */ 3881 asection *srel; 3882 Elf_Internal_Rela outrel; 3883 struct alpha_elf_got_entry *gotent; 3884 3885 srel = bfd_get_section_by_name (dynobj, ".rela.got"); 3886 BFD_ASSERT (srel != NULL); 3887 3888 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT); 3889 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries; 3890 gotent != NULL; 3891 gotent = gotent->next) 3892 { 3893 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got; 3894 outrel.r_offset = (sgot->output_section->vma 3895 + sgot->output_offset 3896 + gotent->got_offset); 3897 outrel.r_addend = gotent->addend; 3898 3899 bfd_elf64_swap_reloca_out (output_bfd, &outrel, 3900 ((Elf64_External_Rela *)srel->contents 3901 + srel->reloc_count++)); 3902 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count 3903 <= srel->_cooked_size); 3904 } 3905 } 3906 3907 /* Mark some specially defined symbols as absolute. */ 3908 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 3909 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 3910 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0) 3911 sym->st_shndx = SHN_ABS; 3912 3913 return true; 3914} 3915 3916/* Finish up the dynamic sections. */ 3917 3918static boolean 3919elf64_alpha_finish_dynamic_sections (output_bfd, info) 3920 bfd *output_bfd; 3921 struct bfd_link_info *info; 3922{ 3923 bfd *dynobj; 3924 asection *sdyn; 3925 3926 dynobj = elf_hash_table (info)->dynobj; 3927 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 3928 3929 if (elf_hash_table (info)->dynamic_sections_created) 3930 { 3931 asection *splt; 3932 Elf64_External_Dyn *dyncon, *dynconend; 3933 3934 splt = bfd_get_section_by_name (dynobj, ".plt"); 3935 BFD_ASSERT (splt != NULL && sdyn != NULL); 3936 3937 dyncon = (Elf64_External_Dyn *) sdyn->contents; 3938 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 3939 for (; dyncon < dynconend; dyncon++) 3940 { 3941 Elf_Internal_Dyn dyn; 3942 const char *name; 3943 asection *s; 3944 3945 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); 3946 3947 switch (dyn.d_tag) 3948 { 3949 case DT_PLTGOT: 3950 name = ".plt"; 3951 goto get_vma; 3952 case DT_PLTRELSZ: 3953 name = ".rela.plt"; 3954 goto get_size; 3955 case DT_JMPREL: 3956 name = ".rela.plt"; 3957 goto get_vma; 3958 3959 case DT_RELASZ: 3960 /* My interpretation of the TIS v1.1 ELF document indicates 3961 that RELASZ should not include JMPREL. This is not what 3962 the rest of the BFD does. It is, however, what the 3963 glibc ld.so wants. Do this fixup here until we found 3964 out who is right. */ 3965 s = bfd_get_section_by_name (output_bfd, ".rela.plt"); 3966 if (s) 3967 { 3968 dyn.d_un.d_val -= 3969 (s->_cooked_size ? s->_cooked_size : s->_raw_size); 3970 } 3971 break; 3972 3973 get_vma: 3974 s = bfd_get_section_by_name (output_bfd, name); 3975 dyn.d_un.d_ptr = (s ? s->vma : 0); 3976 break; 3977 3978 get_size: 3979 s = bfd_get_section_by_name (output_bfd, name); 3980 dyn.d_un.d_val = 3981 (s->_cooked_size ? s->_cooked_size : s->_raw_size); 3982 break; 3983 } 3984 3985 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 3986 } 3987 3988 /* Initialize the PLT0 entry */ 3989 if (splt->_raw_size > 0) 3990 { 3991 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents); 3992 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4); 3993 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8); 3994 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12); 3995 3996 /* The next two words will be filled in by ld.so */ 3997 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16); 3998 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24); 3999 4000 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4001 PLT_HEADER_SIZE; 4002 } 4003 } 4004 4005 return true; 4006} 4007 4008/* We need to use a special link routine to handle the .mdebug section. 4009 We need to merge all instances of these sections together, not write 4010 them all out sequentially. */ 4011 4012static boolean 4013elf64_alpha_final_link (abfd, info) 4014 bfd *abfd; 4015 struct bfd_link_info *info; 4016{ 4017 asection *o; 4018 struct bfd_link_order *p; 4019 asection *mdebug_sec; 4020 struct ecoff_debug_info debug; 4021 const struct ecoff_debug_swap *swap 4022 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; 4023 HDRR *symhdr = &debug.symbolic_header; 4024 PTR mdebug_handle = NULL; 4025 4026 /* Go through the sections and collect the mdebug information. */ 4027 mdebug_sec = NULL; 4028 for (o = abfd->sections; o != (asection *) NULL; o = o->next) 4029 { 4030 if (strcmp (o->name, ".mdebug") == 0) 4031 { 4032 struct extsym_info einfo; 4033 4034 /* We have found the .mdebug section in the output file. 4035 Look through all the link_orders comprising it and merge 4036 the information together. */ 4037 symhdr->magic = swap->sym_magic; 4038 /* FIXME: What should the version stamp be? */ 4039 symhdr->vstamp = 0; 4040 symhdr->ilineMax = 0; 4041 symhdr->cbLine = 0; 4042 symhdr->idnMax = 0; 4043 symhdr->ipdMax = 0; 4044 symhdr->isymMax = 0; 4045 symhdr->ioptMax = 0; 4046 symhdr->iauxMax = 0; 4047 symhdr->issMax = 0; 4048 symhdr->issExtMax = 0; 4049 symhdr->ifdMax = 0; 4050 symhdr->crfd = 0; 4051 symhdr->iextMax = 0; 4052 4053 /* We accumulate the debugging information itself in the 4054 debug_info structure. */ 4055 debug.line = NULL; 4056 debug.external_dnr = NULL; 4057 debug.external_pdr = NULL; 4058 debug.external_sym = NULL; 4059 debug.external_opt = NULL; 4060 debug.external_aux = NULL; 4061 debug.ss = NULL; 4062 debug.ssext = debug.ssext_end = NULL; 4063 debug.external_fdr = NULL; 4064 debug.external_rfd = NULL; 4065 debug.external_ext = debug.external_ext_end = NULL; 4066 4067 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info); 4068 if (mdebug_handle == (PTR) NULL) 4069 return false; 4070 4071 if (1) 4072 { 4073 asection *s; 4074 EXTR esym; 4075 bfd_vma last = 0; 4076 unsigned int i; 4077 static const char * const name[] = 4078 { 4079 ".text", ".init", ".fini", ".data", 4080 ".rodata", ".sdata", ".sbss", ".bss" 4081 }; 4082 static const int sc[] = { scText, scInit, scFini, scData, 4083 scRData, scSData, scSBss, scBss }; 4084 4085 esym.jmptbl = 0; 4086 esym.cobol_main = 0; 4087 esym.weakext = 0; 4088 esym.reserved = 0; 4089 esym.ifd = ifdNil; 4090 esym.asym.iss = issNil; 4091 esym.asym.st = stLocal; 4092 esym.asym.reserved = 0; 4093 esym.asym.index = indexNil; 4094 for (i = 0; i < 8; i++) 4095 { 4096 esym.asym.sc = sc[i]; 4097 s = bfd_get_section_by_name (abfd, name[i]); 4098 if (s != NULL) 4099 { 4100 esym.asym.value = s->vma; 4101 last = s->vma + s->_raw_size; 4102 } 4103 else 4104 esym.asym.value = last; 4105 4106 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap, 4107 name[i], &esym)) 4108 return false; 4109 } 4110 } 4111 4112 for (p = o->link_order_head; 4113 p != (struct bfd_link_order *) NULL; 4114 p = p->next) 4115 { 4116 asection *input_section; 4117 bfd *input_bfd; 4118 const struct ecoff_debug_swap *input_swap; 4119 struct ecoff_debug_info input_debug; 4120 char *eraw_src; 4121 char *eraw_end; 4122 4123 if (p->type != bfd_indirect_link_order) 4124 { 4125 if (p->type == bfd_fill_link_order) 4126 continue; 4127 abort (); 4128 } 4129 4130 input_section = p->u.indirect.section; 4131 input_bfd = input_section->owner; 4132 4133 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour 4134 || (get_elf_backend_data (input_bfd) 4135 ->elf_backend_ecoff_debug_swap) == NULL) 4136 { 4137 /* I don't know what a non ALPHA ELF bfd would be 4138 doing with a .mdebug section, but I don't really 4139 want to deal with it. */ 4140 continue; 4141 } 4142 4143 input_swap = (get_elf_backend_data (input_bfd) 4144 ->elf_backend_ecoff_debug_swap); 4145 4146 BFD_ASSERT (p->size == input_section->_raw_size); 4147 4148 /* The ECOFF linking code expects that we have already 4149 read in the debugging information and set up an 4150 ecoff_debug_info structure, so we do that now. */ 4151 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section, 4152 &input_debug)) 4153 return false; 4154 4155 if (! (bfd_ecoff_debug_accumulate 4156 (mdebug_handle, abfd, &debug, swap, input_bfd, 4157 &input_debug, input_swap, info))) 4158 return false; 4159 4160 /* Loop through the external symbols. For each one with 4161 interesting information, try to find the symbol in 4162 the linker global hash table and save the information 4163 for the output external symbols. */ 4164 eraw_src = input_debug.external_ext; 4165 eraw_end = (eraw_src 4166 + (input_debug.symbolic_header.iextMax 4167 * input_swap->external_ext_size)); 4168 for (; 4169 eraw_src < eraw_end; 4170 eraw_src += input_swap->external_ext_size) 4171 { 4172 EXTR ext; 4173 const char *name; 4174 struct alpha_elf_link_hash_entry *h; 4175 4176 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext); 4177 if (ext.asym.sc == scNil 4178 || ext.asym.sc == scUndefined 4179 || ext.asym.sc == scSUndefined) 4180 continue; 4181 4182 name = input_debug.ssext + ext.asym.iss; 4183 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info), 4184 name, false, false, true); 4185 if (h == NULL || h->esym.ifd != -2) 4186 continue; 4187 4188 if (ext.ifd != -1) 4189 { 4190 BFD_ASSERT (ext.ifd 4191 < input_debug.symbolic_header.ifdMax); 4192 ext.ifd = input_debug.ifdmap[ext.ifd]; 4193 } 4194 4195 h->esym = ext; 4196 } 4197 4198 /* Free up the information we just read. */ 4199 free (input_debug.line); 4200 free (input_debug.external_dnr); 4201 free (input_debug.external_pdr); 4202 free (input_debug.external_sym); 4203 free (input_debug.external_opt); 4204 free (input_debug.external_aux); 4205 free (input_debug.ss); 4206 free (input_debug.ssext); 4207 free (input_debug.external_fdr); 4208 free (input_debug.external_rfd); 4209 free (input_debug.external_ext); 4210 4211 /* Hack: reset the SEC_HAS_CONTENTS flag so that 4212 elf_link_input_bfd ignores this section. */ 4213 input_section->flags &=~ SEC_HAS_CONTENTS; 4214 } 4215 4216 /* Build the external symbol information. */ 4217 einfo.abfd = abfd; 4218 einfo.info = info; 4219 einfo.debug = &debug; 4220 einfo.swap = swap; 4221 einfo.failed = false; 4222 elf_link_hash_traverse (elf_hash_table (info), 4223 elf64_alpha_output_extsym, 4224 (PTR) &einfo); 4225 if (einfo.failed) 4226 return false; 4227 4228 /* Set the size of the .mdebug section. */ 4229 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap); 4230 4231 /* Skip this section later on (I don't think this currently 4232 matters, but someday it might). */ 4233 o->link_order_head = (struct bfd_link_order *) NULL; 4234 4235 mdebug_sec = o; 4236 } 4237 } 4238 4239 /* Invoke the regular ELF backend linker to do all the work. */ 4240 if (! bfd_elf64_bfd_final_link (abfd, info)) 4241 return false; 4242 4243 /* Now write out the computed sections. */ 4244 4245 /* The .got subsections... */ 4246 { 4247 bfd *i, *dynobj = elf_hash_table(info)->dynobj; 4248 for (i = alpha_elf_hash_table(info)->got_list; 4249 i != NULL; 4250 i = alpha_elf_tdata(i)->got_link_next) 4251 { 4252 asection *sgot; 4253 4254 /* elf_bfd_final_link already did everything in dynobj. */ 4255 if (i == dynobj) 4256 continue; 4257 4258 sgot = alpha_elf_tdata(i)->got; 4259 if (! bfd_set_section_contents (abfd, sgot->output_section, 4260 sgot->contents, 4261 (file_ptr) sgot->output_offset, 4262 sgot->_raw_size)) 4263 return false; 4264 } 4265 } 4266 4267 if (mdebug_sec != (asection *) NULL) 4268 { 4269 BFD_ASSERT (abfd->output_has_begun); 4270 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug, 4271 swap, info, 4272 mdebug_sec->filepos)) 4273 return false; 4274 4275 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info); 4276 } 4277 4278 return true; 4279} 4280 4281static enum elf_reloc_type_class 4282elf64_alpha_reloc_type_class (rela) 4283 const Elf_Internal_Rela *rela; 4284{ 4285 switch ((int) ELF64_R_TYPE (rela->r_info)) 4286 { 4287 case R_ALPHA_RELATIVE: 4288 return reloc_class_relative; 4289 case R_ALPHA_JMP_SLOT: 4290 return reloc_class_plt; 4291 case R_ALPHA_COPY: 4292 return reloc_class_copy; 4293 default: 4294 return reloc_class_normal; 4295 } 4296} 4297 4298/* ECOFF swapping routines. These are used when dealing with the 4299 .mdebug section, which is in the ECOFF debugging format. Copied 4300 from elf32-mips.c. */ 4301static const struct ecoff_debug_swap 4302elf64_alpha_ecoff_debug_swap = 4303{ 4304 /* Symbol table magic number. */ 4305 magicSym2, 4306 /* Alignment of debugging information. E.g., 4. */ 4307 8, 4308 /* Sizes of external symbolic information. */ 4309 sizeof (struct hdr_ext), 4310 sizeof (struct dnr_ext), 4311 sizeof (struct pdr_ext), 4312 sizeof (struct sym_ext), 4313 sizeof (struct opt_ext), 4314 sizeof (struct fdr_ext), 4315 sizeof (struct rfd_ext), 4316 sizeof (struct ext_ext), 4317 /* Functions to swap in external symbolic data. */ 4318 ecoff_swap_hdr_in, 4319 ecoff_swap_dnr_in, 4320 ecoff_swap_pdr_in, 4321 ecoff_swap_sym_in, 4322 ecoff_swap_opt_in, 4323 ecoff_swap_fdr_in, 4324 ecoff_swap_rfd_in, 4325 ecoff_swap_ext_in, 4326 _bfd_ecoff_swap_tir_in, 4327 _bfd_ecoff_swap_rndx_in, 4328 /* Functions to swap out external symbolic data. */ 4329 ecoff_swap_hdr_out, 4330 ecoff_swap_dnr_out, 4331 ecoff_swap_pdr_out, 4332 ecoff_swap_sym_out, 4333 ecoff_swap_opt_out, 4334 ecoff_swap_fdr_out, 4335 ecoff_swap_rfd_out, 4336 ecoff_swap_ext_out, 4337 _bfd_ecoff_swap_tir_out, 4338 _bfd_ecoff_swap_rndx_out, 4339 /* Function to read in symbolic data. */ 4340 elf64_alpha_read_ecoff_info 4341}; 4342 4343/* Use a non-standard hash bucket size of 8. */ 4344 4345const struct elf_size_info alpha_elf_size_info = 4346{ 4347 sizeof (Elf64_External_Ehdr), 4348 sizeof (Elf64_External_Phdr), 4349 sizeof (Elf64_External_Shdr), 4350 sizeof (Elf64_External_Rel), 4351 sizeof (Elf64_External_Rela), 4352 sizeof (Elf64_External_Sym), 4353 sizeof (Elf64_External_Dyn), 4354 sizeof (Elf_External_Note), 4355 8, 4356 1, 4357 64, 8, 4358 ELFCLASS64, EV_CURRENT, 4359 bfd_elf64_write_out_phdrs, 4360 bfd_elf64_write_shdrs_and_ehdr, 4361 bfd_elf64_write_relocs, 4362 bfd_elf64_swap_symbol_out, 4363 bfd_elf64_slurp_reloc_table, 4364 bfd_elf64_slurp_symbol_table, 4365 bfd_elf64_swap_dyn_in, 4366 bfd_elf64_swap_dyn_out, 4367 NULL, 4368 NULL, 4369 NULL, 4370 NULL 4371}; 4372 4373#define TARGET_LITTLE_SYM bfd_elf64_alpha_vec 4374#define TARGET_LITTLE_NAME "elf64-alpha" 4375#define ELF_ARCH bfd_arch_alpha 4376#define ELF_MACHINE_CODE EM_ALPHA 4377#define ELF_MAXPAGESIZE 0x10000 4378 4379#define bfd_elf64_bfd_link_hash_table_create \ 4380 elf64_alpha_bfd_link_hash_table_create 4381 4382#define bfd_elf64_bfd_reloc_type_lookup \ 4383 elf64_alpha_bfd_reloc_type_lookup 4384#define elf_info_to_howto \ 4385 elf64_alpha_info_to_howto 4386 4387#define bfd_elf64_mkobject \ 4388 elf64_alpha_mkobject 4389#define elf_backend_object_p \ 4390 elf64_alpha_object_p 4391 4392#define elf_backend_section_from_shdr \ 4393 elf64_alpha_section_from_shdr 4394#define elf_backend_section_flags \ 4395 elf64_alpha_section_flags 4396#define elf_backend_fake_sections \ 4397 elf64_alpha_fake_sections 4398 4399#define bfd_elf64_bfd_is_local_label_name \ 4400 elf64_alpha_is_local_label_name 4401#define bfd_elf64_find_nearest_line \ 4402 elf64_alpha_find_nearest_line 4403#define bfd_elf64_bfd_relax_section \ 4404 elf64_alpha_relax_section 4405 4406#define elf_backend_add_symbol_hook \ 4407 elf64_alpha_add_symbol_hook 4408#define elf_backend_check_relocs \ 4409 elf64_alpha_check_relocs 4410#define elf_backend_create_dynamic_sections \ 4411 elf64_alpha_create_dynamic_sections 4412#define elf_backend_adjust_dynamic_symbol \ 4413 elf64_alpha_adjust_dynamic_symbol 4414#define elf_backend_always_size_sections \ 4415 elf64_alpha_always_size_sections 4416#define elf_backend_size_dynamic_sections \ 4417 elf64_alpha_size_dynamic_sections 4418#define elf_backend_relocate_section \ 4419 elf64_alpha_relocate_section 4420#define elf_backend_finish_dynamic_symbol \ 4421 elf64_alpha_finish_dynamic_symbol 4422#define elf_backend_finish_dynamic_sections \ 4423 elf64_alpha_finish_dynamic_sections 4424#define bfd_elf64_bfd_final_link \ 4425 elf64_alpha_final_link 4426#define elf_backend_reloc_type_class \ 4427 elf64_alpha_reloc_type_class 4428 4429#define elf_backend_ecoff_debug_swap \ 4430 &elf64_alpha_ecoff_debug_swap 4431 4432#define elf_backend_size_info \ 4433 alpha_elf_size_info 4434 4435/* A few constants that determine how the .plt section is set up. */ 4436#define elf_backend_want_got_plt 0 4437#define elf_backend_plt_readonly 0 4438#define elf_backend_want_plt_sym 1 4439#define elf_backend_got_header_size 0 4440#define elf_backend_plt_header_size PLT_HEADER_SIZE 4441 4442#include "elf64-target.h" 4443