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