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