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