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