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