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