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