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