elfxx-ia64.c revision 91041
1/* IA-64 support for 64-bit ELF 2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. 3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com> 4 5This file is part of BFD, the Binary File Descriptor library. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21#include "bfd.h" 22#include "sysdep.h" 23#include "libbfd.h" 24#include "elf-bfd.h" 25#include "opcode/ia64.h" 26#include "elf/ia64.h" 27 28/* 29 * THE RULES for all the stuff the linker creates -- 30 * 31 * GOT Entries created in response to LTOFF or LTOFF_FPTR 32 * relocations. Dynamic relocs created for dynamic 33 * symbols in an application; REL relocs for locals 34 * in a shared library. 35 * 36 * FPTR The canonical function descriptor. Created for local 37 * symbols in applications. Descriptors for dynamic symbols 38 * and local symbols in shared libraries are created by 39 * ld.so. Thus there are no dynamic relocs against these 40 * objects. The FPTR relocs for such _are_ passed through 41 * to the dynamic relocation tables. 42 * 43 * FULL_PLT Created for a PCREL21B relocation against a dynamic symbol. 44 * Requires the creation of a PLTOFF entry. This does not 45 * require any dynamic relocations. 46 * 47 * PLTOFF Created by PLTOFF relocations. For local symbols, this 48 * is an alternate function descriptor, and in shared libraries 49 * requires two REL relocations. Note that this cannot be 50 * transformed into an FPTR relocation, since it must be in 51 * range of the GP. For dynamic symbols, this is a function 52 * descriptor for a MIN_PLT entry, and requires one IPLT reloc. 53 * 54 * MIN_PLT Created by PLTOFF entries against dynamic symbols. This 55 * does not reqire dynamic relocations. 56 */ 57 58#define USE_RELA /* we want RELA relocs, not REL */ 59 60#define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0]))) 61 62typedef struct bfd_hash_entry *(*new_hash_entry_func) 63 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 64 65/* In dynamically (linker-) created sections, we generally need to keep track 66 of the place a symbol or expression got allocated to. This is done via hash 67 tables that store entries of the following type. */ 68 69struct elfNN_ia64_dyn_sym_info 70{ 71 /* The addend for which this entry is relevant. */ 72 bfd_vma addend; 73 74 /* Next addend in the list. */ 75 struct elfNN_ia64_dyn_sym_info *next; 76 77 bfd_vma got_offset; 78 bfd_vma fptr_offset; 79 bfd_vma pltoff_offset; 80 bfd_vma plt_offset; 81 bfd_vma plt2_offset; 82 83 /* The symbol table entry, if any, that this was derrived from. */ 84 struct elf_link_hash_entry *h; 85 86 /* Used to count non-got, non-plt relocations for delayed sizing 87 of relocation sections. */ 88 struct elfNN_ia64_dyn_reloc_entry 89 { 90 struct elfNN_ia64_dyn_reloc_entry *next; 91 asection *srel; 92 int type; 93 int count; 94 } *reloc_entries; 95 96 /* True when the section contents have been updated. */ 97 unsigned got_done : 1; 98 unsigned fptr_done : 1; 99 unsigned pltoff_done : 1; 100 101 /* True for the different kinds of linker data we want created. */ 102 unsigned want_got : 1; 103 unsigned want_fptr : 1; 104 unsigned want_ltoff_fptr : 1; 105 unsigned want_plt : 1; 106 unsigned want_plt2 : 1; 107 unsigned want_pltoff : 1; 108}; 109 110struct elfNN_ia64_local_hash_entry 111{ 112 struct bfd_hash_entry root; 113 struct elfNN_ia64_dyn_sym_info *info; 114 115 /* True if this hash entry's addends was translated for 116 SHF_MERGE optimization. */ 117 unsigned sec_merge_done : 1; 118}; 119 120struct elfNN_ia64_local_hash_table 121{ 122 struct bfd_hash_table root; 123 /* No additional fields for now. */ 124}; 125 126struct elfNN_ia64_link_hash_entry 127{ 128 struct elf_link_hash_entry root; 129 struct elfNN_ia64_dyn_sym_info *info; 130}; 131 132struct elfNN_ia64_link_hash_table 133{ 134 /* The main hash table */ 135 struct elf_link_hash_table root; 136 137 asection *got_sec; /* the linkage table section (or NULL) */ 138 asection *rel_got_sec; /* dynamic relocation section for same */ 139 asection *fptr_sec; /* function descriptor table (or NULL) */ 140 asection *plt_sec; /* the primary plt section (or NULL) */ 141 asection *pltoff_sec; /* private descriptors for plt (or NULL) */ 142 asection *rel_pltoff_sec; /* dynamic relocation section for same */ 143 144 bfd_size_type minplt_entries; /* number of minplt entries */ 145 unsigned reltext : 1; /* are there relocs against readonly sections? */ 146 147 struct elfNN_ia64_local_hash_table loc_hash_table; 148}; 149 150#define elfNN_ia64_hash_table(p) \ 151 ((struct elfNN_ia64_link_hash_table *) ((p)->hash)) 152 153static bfd_reloc_status_type elfNN_ia64_reloc 154 PARAMS ((bfd *abfd, arelent *reloc, asymbol *sym, PTR data, 155 asection *input_section, bfd *output_bfd, char **error_message)); 156static reloc_howto_type * lookup_howto 157 PARAMS ((unsigned int rtype)); 158static reloc_howto_type *elfNN_ia64_reloc_type_lookup 159 PARAMS ((bfd *abfd, bfd_reloc_code_real_type bfd_code)); 160static void elfNN_ia64_info_to_howto 161 PARAMS ((bfd *abfd, arelent *bfd_reloc, ElfNN_Internal_Rela *elf_reloc)); 162static boolean elfNN_ia64_relax_section 163 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info, 164 boolean *again)); 165static boolean is_unwind_section_name 166 PARAMS ((bfd *abfd, const char *)); 167static boolean elfNN_ia64_section_from_shdr 168 PARAMS ((bfd *, ElfNN_Internal_Shdr *, char *)); 169static boolean elfNN_ia64_section_flags 170 PARAMS ((flagword *, ElfNN_Internal_Shdr *)); 171static boolean elfNN_ia64_fake_sections 172 PARAMS ((bfd *abfd, ElfNN_Internal_Shdr *hdr, asection *sec)); 173static void elfNN_ia64_final_write_processing 174 PARAMS ((bfd *abfd, boolean linker)); 175static boolean elfNN_ia64_add_symbol_hook 176 PARAMS ((bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *sym, 177 const char **namep, flagword *flagsp, asection **secp, 178 bfd_vma *valp)); 179static boolean elfNN_ia64_aix_vec 180 PARAMS ((const bfd_target *vec)); 181static boolean elfNN_ia64_aix_add_symbol_hook 182 PARAMS ((bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *sym, 183 const char **namep, flagword *flagsp, asection **secp, 184 bfd_vma *valp)); 185static boolean elfNN_ia64_aix_link_add_symbols 186 PARAMS ((bfd *abfd, struct bfd_link_info *info)); 187static int elfNN_ia64_additional_program_headers 188 PARAMS ((bfd *abfd)); 189static boolean elfNN_ia64_modify_segment_map 190 PARAMS ((bfd *)); 191static boolean elfNN_ia64_is_local_label_name 192 PARAMS ((bfd *abfd, const char *name)); 193static boolean elfNN_ia64_dynamic_symbol_p 194 PARAMS ((struct elf_link_hash_entry *h, struct bfd_link_info *info)); 195static boolean elfNN_ia64_local_hash_table_init 196 PARAMS ((struct elfNN_ia64_local_hash_table *ht, bfd *abfd, 197 new_hash_entry_func new)); 198static struct bfd_hash_entry *elfNN_ia64_new_loc_hash_entry 199 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table, 200 const char *string)); 201static struct bfd_hash_entry *elfNN_ia64_new_elf_hash_entry 202 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table, 203 const char *string)); 204static void elfNN_ia64_hash_copy_indirect 205 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *)); 206static void elfNN_ia64_hash_hide_symbol 207 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean)); 208static struct bfd_link_hash_table *elfNN_ia64_hash_table_create 209 PARAMS ((bfd *abfd)); 210static struct elfNN_ia64_local_hash_entry *elfNN_ia64_local_hash_lookup 211 PARAMS ((struct elfNN_ia64_local_hash_table *table, const char *string, 212 boolean create, boolean copy)); 213static boolean elfNN_ia64_global_dyn_sym_thunk 214 PARAMS ((struct bfd_hash_entry *, PTR)); 215static boolean elfNN_ia64_local_dyn_sym_thunk 216 PARAMS ((struct bfd_hash_entry *, PTR)); 217static void elfNN_ia64_dyn_sym_traverse 218 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info, 219 boolean (*func) (struct elfNN_ia64_dyn_sym_info *, PTR), 220 PTR info)); 221static boolean elfNN_ia64_create_dynamic_sections 222 PARAMS ((bfd *abfd, struct bfd_link_info *info)); 223static struct elfNN_ia64_local_hash_entry * get_local_sym_hash 224 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info, 225 bfd *abfd, const Elf_Internal_Rela *rel, boolean create)); 226static struct elfNN_ia64_dyn_sym_info * get_dyn_sym_info 227 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info, 228 struct elf_link_hash_entry *h, 229 bfd *abfd, const Elf_Internal_Rela *rel, boolean create)); 230static asection *get_got 231 PARAMS ((bfd *abfd, struct bfd_link_info *info, 232 struct elfNN_ia64_link_hash_table *ia64_info)); 233static asection *get_fptr 234 PARAMS ((bfd *abfd, struct bfd_link_info *info, 235 struct elfNN_ia64_link_hash_table *ia64_info)); 236static asection *get_pltoff 237 PARAMS ((bfd *abfd, struct bfd_link_info *info, 238 struct elfNN_ia64_link_hash_table *ia64_info)); 239static asection *get_reloc_section 240 PARAMS ((bfd *abfd, struct elfNN_ia64_link_hash_table *ia64_info, 241 asection *sec, boolean create)); 242static boolean count_dyn_reloc 243 PARAMS ((bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i, 244 asection *srel, int type)); 245static boolean elfNN_ia64_check_relocs 246 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec, 247 const Elf_Internal_Rela *relocs)); 248static boolean elfNN_ia64_adjust_dynamic_symbol 249 PARAMS ((struct bfd_link_info *info, struct elf_link_hash_entry *h)); 250static long global_sym_index 251 PARAMS ((struct elf_link_hash_entry *h)); 252static boolean allocate_fptr 253 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data)); 254static boolean allocate_global_data_got 255 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data)); 256static boolean allocate_global_fptr_got 257 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data)); 258static boolean allocate_local_got 259 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data)); 260static boolean allocate_pltoff_entries 261 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data)); 262static boolean allocate_plt_entries 263 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data)); 264static boolean allocate_plt2_entries 265 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data)); 266static boolean allocate_dynrel_entries 267 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data)); 268static boolean elfNN_ia64_size_dynamic_sections 269 PARAMS ((bfd *output_bfd, struct bfd_link_info *info)); 270static bfd_reloc_status_type elfNN_ia64_install_value 271 PARAMS ((bfd *abfd, bfd_byte *hit_addr, bfd_vma val, unsigned int r_type)); 272static void elfNN_ia64_install_dyn_reloc 273 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec, 274 asection *srel, bfd_vma offset, unsigned int type, 275 long dynindx, bfd_vma addend)); 276static bfd_vma set_got_entry 277 PARAMS ((bfd *abfd, struct bfd_link_info *info, 278 struct elfNN_ia64_dyn_sym_info *dyn_i, long dynindx, 279 bfd_vma addend, bfd_vma value, unsigned int dyn_r_type)); 280static bfd_vma set_fptr_entry 281 PARAMS ((bfd *abfd, struct bfd_link_info *info, 282 struct elfNN_ia64_dyn_sym_info *dyn_i, 283 bfd_vma value)); 284static bfd_vma set_pltoff_entry 285 PARAMS ((bfd *abfd, struct bfd_link_info *info, 286 struct elfNN_ia64_dyn_sym_info *dyn_i, 287 bfd_vma value, boolean)); 288static int elfNN_ia64_unwind_entry_compare 289 PARAMS ((const PTR, const PTR)); 290static boolean elfNN_ia64_final_link 291 PARAMS ((bfd *abfd, struct bfd_link_info *info)); 292static boolean elfNN_ia64_relocate_section 293 PARAMS ((bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd, 294 asection *input_section, bfd_byte *contents, 295 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms, 296 asection **local_sections)); 297static boolean elfNN_ia64_finish_dynamic_symbol 298 PARAMS ((bfd *output_bfd, struct bfd_link_info *info, 299 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)); 300static boolean elfNN_ia64_finish_dynamic_sections 301 PARAMS ((bfd *abfd, struct bfd_link_info *info)); 302static boolean elfNN_ia64_set_private_flags 303 PARAMS ((bfd *abfd, flagword flags)); 304static boolean elfNN_ia64_merge_private_bfd_data 305 PARAMS ((bfd *ibfd, bfd *obfd)); 306static boolean elfNN_ia64_print_private_bfd_data 307 PARAMS ((bfd *abfd, PTR ptr)); 308static enum elf_reloc_type_class elfNN_ia64_reloc_type_class 309 PARAMS ((const Elf_Internal_Rela *)); 310static boolean elfNN_ia64_hpux_vec 311 PARAMS ((const bfd_target *vec)); 312static void elfNN_hpux_post_process_headers 313 PARAMS ((bfd *abfd, struct bfd_link_info *info)); 314boolean elfNN_hpux_backend_section_from_bfd_section 315 PARAMS ((bfd *abfd, asection *sec, int *retval)); 316 317/* ia64-specific relocation */ 318 319/* Perform a relocation. Not much to do here as all the hard work is 320 done in elfNN_ia64_final_link_relocate. */ 321static bfd_reloc_status_type 322elfNN_ia64_reloc (abfd, reloc, sym, data, input_section, 323 output_bfd, error_message) 324 bfd *abfd ATTRIBUTE_UNUSED; 325 arelent *reloc; 326 asymbol *sym ATTRIBUTE_UNUSED; 327 PTR data ATTRIBUTE_UNUSED; 328 asection *input_section; 329 bfd *output_bfd; 330 char **error_message; 331{ 332 if (output_bfd) 333 { 334 reloc->address += input_section->output_offset; 335 return bfd_reloc_ok; 336 } 337 *error_message = "Unsupported call to elfNN_ia64_reloc"; 338 return bfd_reloc_notsupported; 339} 340 341#define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \ 342 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \ 343 elfNN_ia64_reloc, NAME, false, 0, 0, IN) 344 345/* This table has to be sorted according to increasing number of the 346 TYPE field. */ 347static reloc_howto_type ia64_howto_table[] = 348 { 349 IA64_HOWTO (R_IA64_NONE, "NONE", 0, false, true), 350 351 IA64_HOWTO (R_IA64_IMM14, "IMM14", 0, false, true), 352 IA64_HOWTO (R_IA64_IMM22, "IMM22", 0, false, true), 353 IA64_HOWTO (R_IA64_IMM64, "IMM64", 0, false, true), 354 IA64_HOWTO (R_IA64_DIR32MSB, "DIR32MSB", 2, false, true), 355 IA64_HOWTO (R_IA64_DIR32LSB, "DIR32LSB", 2, false, true), 356 IA64_HOWTO (R_IA64_DIR64MSB, "DIR64MSB", 4, false, true), 357 IA64_HOWTO (R_IA64_DIR64LSB, "DIR64LSB", 4, false, true), 358 359 IA64_HOWTO (R_IA64_GPREL22, "GPREL22", 0, false, true), 360 IA64_HOWTO (R_IA64_GPREL64I, "GPREL64I", 0, false, true), 361 IA64_HOWTO (R_IA64_GPREL32MSB, "GPREL32MSB", 2, false, true), 362 IA64_HOWTO (R_IA64_GPREL32LSB, "GPREL32LSB", 2, false, true), 363 IA64_HOWTO (R_IA64_GPREL64MSB, "GPREL64MSB", 4, false, true), 364 IA64_HOWTO (R_IA64_GPREL64LSB, "GPREL64LSB", 4, false, true), 365 366 IA64_HOWTO (R_IA64_LTOFF22, "LTOFF22", 0, false, true), 367 IA64_HOWTO (R_IA64_LTOFF64I, "LTOFF64I", 0, false, true), 368 369 IA64_HOWTO (R_IA64_PLTOFF22, "PLTOFF22", 0, false, true), 370 IA64_HOWTO (R_IA64_PLTOFF64I, "PLTOFF64I", 0, false, true), 371 IA64_HOWTO (R_IA64_PLTOFF64MSB, "PLTOFF64MSB", 4, false, true), 372 IA64_HOWTO (R_IA64_PLTOFF64LSB, "PLTOFF64LSB", 4, false, true), 373 374 IA64_HOWTO (R_IA64_FPTR64I, "FPTR64I", 0, false, true), 375 IA64_HOWTO (R_IA64_FPTR32MSB, "FPTR32MSB", 2, false, true), 376 IA64_HOWTO (R_IA64_FPTR32LSB, "FPTR32LSB", 2, false, true), 377 IA64_HOWTO (R_IA64_FPTR64MSB, "FPTR64MSB", 4, false, true), 378 IA64_HOWTO (R_IA64_FPTR64LSB, "FPTR64LSB", 4, false, true), 379 380 IA64_HOWTO (R_IA64_PCREL60B, "PCREL60B", 0, true, true), 381 IA64_HOWTO (R_IA64_PCREL21B, "PCREL21B", 0, true, true), 382 IA64_HOWTO (R_IA64_PCREL21M, "PCREL21M", 0, true, true), 383 IA64_HOWTO (R_IA64_PCREL21F, "PCREL21F", 0, true, true), 384 IA64_HOWTO (R_IA64_PCREL32MSB, "PCREL32MSB", 2, true, true), 385 IA64_HOWTO (R_IA64_PCREL32LSB, "PCREL32LSB", 2, true, true), 386 IA64_HOWTO (R_IA64_PCREL64MSB, "PCREL64MSB", 4, true, true), 387 IA64_HOWTO (R_IA64_PCREL64LSB, "PCREL64LSB", 4, true, true), 388 389 IA64_HOWTO (R_IA64_LTOFF_FPTR22, "LTOFF_FPTR22", 0, false, true), 390 IA64_HOWTO (R_IA64_LTOFF_FPTR64I, "LTOFF_FPTR64I", 0, false, true), 391 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB, "LTOFF_FPTR32MSB", 2, false, true), 392 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB, "LTOFF_FPTR32LSB", 2, false, true), 393 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB, "LTOFF_FPTR64MSB", 4, false, true), 394 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB, "LTOFF_FPTR64LSB", 4, false, true), 395 396 IA64_HOWTO (R_IA64_SEGREL32MSB, "SEGREL32MSB", 2, false, true), 397 IA64_HOWTO (R_IA64_SEGREL32LSB, "SEGREL32LSB", 2, false, true), 398 IA64_HOWTO (R_IA64_SEGREL64MSB, "SEGREL64MSB", 4, false, true), 399 IA64_HOWTO (R_IA64_SEGREL64LSB, "SEGREL64LSB", 4, false, true), 400 401 IA64_HOWTO (R_IA64_SECREL32MSB, "SECREL32MSB", 2, false, true), 402 IA64_HOWTO (R_IA64_SECREL32LSB, "SECREL32LSB", 2, false, true), 403 IA64_HOWTO (R_IA64_SECREL64MSB, "SECREL64MSB", 4, false, true), 404 IA64_HOWTO (R_IA64_SECREL64LSB, "SECREL64LSB", 4, false, true), 405 406 IA64_HOWTO (R_IA64_REL32MSB, "REL32MSB", 2, false, true), 407 IA64_HOWTO (R_IA64_REL32LSB, "REL32LSB", 2, false, true), 408 IA64_HOWTO (R_IA64_REL64MSB, "REL64MSB", 4, false, true), 409 IA64_HOWTO (R_IA64_REL64LSB, "REL64LSB", 4, false, true), 410 411 IA64_HOWTO (R_IA64_LTV32MSB, "LTV32MSB", 2, false, true), 412 IA64_HOWTO (R_IA64_LTV32LSB, "LTV32LSB", 2, false, true), 413 IA64_HOWTO (R_IA64_LTV64MSB, "LTV64MSB", 4, false, true), 414 IA64_HOWTO (R_IA64_LTV64LSB, "LTV64LSB", 4, false, true), 415 416 IA64_HOWTO (R_IA64_PCREL21BI, "PCREL21BI", 0, true, true), 417 IA64_HOWTO (R_IA64_PCREL22, "PCREL22", 0, true, true), 418 IA64_HOWTO (R_IA64_PCREL64I, "PCREL64I", 0, true, true), 419 420 IA64_HOWTO (R_IA64_IPLTMSB, "IPLTMSB", 4, false, true), 421 IA64_HOWTO (R_IA64_IPLTLSB, "IPLTLSB", 4, false, true), 422 IA64_HOWTO (R_IA64_COPY, "COPY", 4, false, true), 423 IA64_HOWTO (R_IA64_LTOFF22X, "LTOFF22X", 0, false, true), 424 IA64_HOWTO (R_IA64_LDXMOV, "LDXMOV", 0, false, true), 425 426 IA64_HOWTO (R_IA64_TPREL22, "TPREL22", 0, false, false), 427 IA64_HOWTO (R_IA64_TPREL64MSB, "TPREL64MSB", 8, false, false), 428 IA64_HOWTO (R_IA64_TPREL64LSB, "TPREL64LSB", 8, false, false), 429 IA64_HOWTO (R_IA64_LTOFF_TP22, "LTOFF_TP22", 0, false, false), 430 }; 431 432static unsigned char elf_code_to_howto_index[R_IA64_MAX_RELOC_CODE + 1]; 433 434/* Given a BFD reloc type, return the matching HOWTO structure. */ 435 436static reloc_howto_type* 437lookup_howto (rtype) 438 unsigned int rtype; 439{ 440 static int inited = 0; 441 int i; 442 443 if (!inited) 444 { 445 inited = 1; 446 447 memset (elf_code_to_howto_index, 0xff, sizeof (elf_code_to_howto_index)); 448 for (i = 0; i < NELEMS (ia64_howto_table); ++i) 449 elf_code_to_howto_index[ia64_howto_table[i].type] = i; 450 } 451 452 BFD_ASSERT (rtype <= R_IA64_MAX_RELOC_CODE); 453 i = elf_code_to_howto_index[rtype]; 454 if (i >= NELEMS (ia64_howto_table)) 455 return 0; 456 return ia64_howto_table + i; 457} 458 459static reloc_howto_type* 460elfNN_ia64_reloc_type_lookup (abfd, bfd_code) 461 bfd *abfd ATTRIBUTE_UNUSED; 462 bfd_reloc_code_real_type bfd_code; 463{ 464 unsigned int rtype; 465 466 switch (bfd_code) 467 { 468 case BFD_RELOC_NONE: rtype = R_IA64_NONE; break; 469 470 case BFD_RELOC_IA64_IMM14: rtype = R_IA64_IMM14; break; 471 case BFD_RELOC_IA64_IMM22: rtype = R_IA64_IMM22; break; 472 case BFD_RELOC_IA64_IMM64: rtype = R_IA64_IMM64; break; 473 474 case BFD_RELOC_IA64_DIR32MSB: rtype = R_IA64_DIR32MSB; break; 475 case BFD_RELOC_IA64_DIR32LSB: rtype = R_IA64_DIR32LSB; break; 476 case BFD_RELOC_IA64_DIR64MSB: rtype = R_IA64_DIR64MSB; break; 477 case BFD_RELOC_IA64_DIR64LSB: rtype = R_IA64_DIR64LSB; break; 478 479 case BFD_RELOC_IA64_GPREL22: rtype = R_IA64_GPREL22; break; 480 case BFD_RELOC_IA64_GPREL64I: rtype = R_IA64_GPREL64I; break; 481 case BFD_RELOC_IA64_GPREL32MSB: rtype = R_IA64_GPREL32MSB; break; 482 case BFD_RELOC_IA64_GPREL32LSB: rtype = R_IA64_GPREL32LSB; break; 483 case BFD_RELOC_IA64_GPREL64MSB: rtype = R_IA64_GPREL64MSB; break; 484 case BFD_RELOC_IA64_GPREL64LSB: rtype = R_IA64_GPREL64LSB; break; 485 486 case BFD_RELOC_IA64_LTOFF22: rtype = R_IA64_LTOFF22; break; 487 case BFD_RELOC_IA64_LTOFF64I: rtype = R_IA64_LTOFF64I; break; 488 489 case BFD_RELOC_IA64_PLTOFF22: rtype = R_IA64_PLTOFF22; break; 490 case BFD_RELOC_IA64_PLTOFF64I: rtype = R_IA64_PLTOFF64I; break; 491 case BFD_RELOC_IA64_PLTOFF64MSB: rtype = R_IA64_PLTOFF64MSB; break; 492 case BFD_RELOC_IA64_PLTOFF64LSB: rtype = R_IA64_PLTOFF64LSB; break; 493 case BFD_RELOC_IA64_FPTR64I: rtype = R_IA64_FPTR64I; break; 494 case BFD_RELOC_IA64_FPTR32MSB: rtype = R_IA64_FPTR32MSB; break; 495 case BFD_RELOC_IA64_FPTR32LSB: rtype = R_IA64_FPTR32LSB; break; 496 case BFD_RELOC_IA64_FPTR64MSB: rtype = R_IA64_FPTR64MSB; break; 497 case BFD_RELOC_IA64_FPTR64LSB: rtype = R_IA64_FPTR64LSB; break; 498 499 case BFD_RELOC_IA64_PCREL21B: rtype = R_IA64_PCREL21B; break; 500 case BFD_RELOC_IA64_PCREL21BI: rtype = R_IA64_PCREL21BI; break; 501 case BFD_RELOC_IA64_PCREL21M: rtype = R_IA64_PCREL21M; break; 502 case BFD_RELOC_IA64_PCREL21F: rtype = R_IA64_PCREL21F; break; 503 case BFD_RELOC_IA64_PCREL22: rtype = R_IA64_PCREL22; break; 504 case BFD_RELOC_IA64_PCREL60B: rtype = R_IA64_PCREL60B; break; 505 case BFD_RELOC_IA64_PCREL64I: rtype = R_IA64_PCREL64I; break; 506 case BFD_RELOC_IA64_PCREL32MSB: rtype = R_IA64_PCREL32MSB; break; 507 case BFD_RELOC_IA64_PCREL32LSB: rtype = R_IA64_PCREL32LSB; break; 508 case BFD_RELOC_IA64_PCREL64MSB: rtype = R_IA64_PCREL64MSB; break; 509 case BFD_RELOC_IA64_PCREL64LSB: rtype = R_IA64_PCREL64LSB; break; 510 511 case BFD_RELOC_IA64_LTOFF_FPTR22: rtype = R_IA64_LTOFF_FPTR22; break; 512 case BFD_RELOC_IA64_LTOFF_FPTR64I: rtype = R_IA64_LTOFF_FPTR64I; break; 513 case BFD_RELOC_IA64_LTOFF_FPTR32MSB: rtype = R_IA64_LTOFF_FPTR32MSB; break; 514 case BFD_RELOC_IA64_LTOFF_FPTR32LSB: rtype = R_IA64_LTOFF_FPTR32LSB; break; 515 case BFD_RELOC_IA64_LTOFF_FPTR64MSB: rtype = R_IA64_LTOFF_FPTR64MSB; break; 516 case BFD_RELOC_IA64_LTOFF_FPTR64LSB: rtype = R_IA64_LTOFF_FPTR64LSB; break; 517 518 case BFD_RELOC_IA64_SEGREL32MSB: rtype = R_IA64_SEGREL32MSB; break; 519 case BFD_RELOC_IA64_SEGREL32LSB: rtype = R_IA64_SEGREL32LSB; break; 520 case BFD_RELOC_IA64_SEGREL64MSB: rtype = R_IA64_SEGREL64MSB; break; 521 case BFD_RELOC_IA64_SEGREL64LSB: rtype = R_IA64_SEGREL64LSB; break; 522 523 case BFD_RELOC_IA64_SECREL32MSB: rtype = R_IA64_SECREL32MSB; break; 524 case BFD_RELOC_IA64_SECREL32LSB: rtype = R_IA64_SECREL32LSB; break; 525 case BFD_RELOC_IA64_SECREL64MSB: rtype = R_IA64_SECREL64MSB; break; 526 case BFD_RELOC_IA64_SECREL64LSB: rtype = R_IA64_SECREL64LSB; break; 527 528 case BFD_RELOC_IA64_REL32MSB: rtype = R_IA64_REL32MSB; break; 529 case BFD_RELOC_IA64_REL32LSB: rtype = R_IA64_REL32LSB; break; 530 case BFD_RELOC_IA64_REL64MSB: rtype = R_IA64_REL64MSB; break; 531 case BFD_RELOC_IA64_REL64LSB: rtype = R_IA64_REL64LSB; break; 532 533 case BFD_RELOC_IA64_LTV32MSB: rtype = R_IA64_LTV32MSB; break; 534 case BFD_RELOC_IA64_LTV32LSB: rtype = R_IA64_LTV32LSB; break; 535 case BFD_RELOC_IA64_LTV64MSB: rtype = R_IA64_LTV64MSB; break; 536 case BFD_RELOC_IA64_LTV64LSB: rtype = R_IA64_LTV64LSB; break; 537 538 case BFD_RELOC_IA64_IPLTMSB: rtype = R_IA64_IPLTMSB; break; 539 case BFD_RELOC_IA64_IPLTLSB: rtype = R_IA64_IPLTLSB; break; 540 case BFD_RELOC_IA64_COPY: rtype = R_IA64_COPY; break; 541 case BFD_RELOC_IA64_LTOFF22X: rtype = R_IA64_LTOFF22X; break; 542 case BFD_RELOC_IA64_LDXMOV: rtype = R_IA64_LDXMOV; break; 543 544 case BFD_RELOC_IA64_TPREL22: rtype = R_IA64_TPREL22; break; 545 case BFD_RELOC_IA64_TPREL64MSB: rtype = R_IA64_TPREL64MSB; break; 546 case BFD_RELOC_IA64_TPREL64LSB: rtype = R_IA64_TPREL64LSB; break; 547 case BFD_RELOC_IA64_LTOFF_TP22: rtype = R_IA64_LTOFF_TP22; break; 548 549 default: return 0; 550 } 551 return lookup_howto (rtype); 552} 553 554/* Given a ELF reloc, return the matching HOWTO structure. */ 555 556static void 557elfNN_ia64_info_to_howto (abfd, bfd_reloc, elf_reloc) 558 bfd *abfd ATTRIBUTE_UNUSED; 559 arelent *bfd_reloc; 560 ElfNN_Internal_Rela *elf_reloc; 561{ 562 bfd_reloc->howto 563 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc->r_info)); 564} 565 566#define PLT_HEADER_SIZE (3 * 16) 567#define PLT_MIN_ENTRY_SIZE (1 * 16) 568#define PLT_FULL_ENTRY_SIZE (2 * 16) 569#define PLT_RESERVED_WORDS 3 570 571static const bfd_byte plt_header[PLT_HEADER_SIZE] = 572{ 573 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */ 574 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */ 575 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */ 576 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */ 577 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */ 578 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */ 579 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */ 580 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */ 581 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */ 582}; 583 584static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] = 585{ 586 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */ 587 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */ 588 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */ 589}; 590 591static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] = 592{ 593 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */ 594 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */ 595 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */ 596 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */ 597 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */ 598 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */ 599}; 600 601#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 602#define AIX_DYNAMIC_INTERPRETER "/usr/lib/ia64l64/libc.so.1" 603#define DYNAMIC_INTERPRETER(abfd) \ 604 (elfNN_ia64_aix_vec (abfd->xvec) ? AIX_DYNAMIC_INTERPRETER : ELF_DYNAMIC_INTERPRETER) 605 606/* Select out of range branch fixup type. Note that Itanium does 607 not support brl, and so it gets emulated by the kernel. */ 608#undef USE_BRL 609 610static const bfd_byte oor_brl[16] = 611{ 612 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */ 613 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */ 614 0x00, 0x00, 0x00, 0xc0 615}; 616 617static const bfd_byte oor_ip[48] = 618{ 619 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */ 620 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */ 621 0x01, 0x00, 0x00, 0x60, 622 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */ 623 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */ 624 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */ 625 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */ 626 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */ 627 0x60, 0x00, 0x80, 0x00 /* br b6;; */ 628}; 629 630/* These functions do relaxation for IA-64 ELF. 631 632 This is primarily to support branches to targets out of range; 633 relaxation of R_IA64_LTOFF22X and R_IA64_LDXMOV not yet supported. */ 634 635static boolean 636elfNN_ia64_relax_section (abfd, sec, link_info, again) 637 bfd *abfd; 638 asection *sec; 639 struct bfd_link_info *link_info; 640 boolean *again; 641{ 642 struct one_fixup 643 { 644 struct one_fixup *next; 645 asection *tsec; 646 bfd_vma toff; 647 bfd_vma trampoff; 648 }; 649 650 Elf_Internal_Shdr *symtab_hdr; 651 Elf_Internal_Shdr *shndx_hdr; 652 Elf_Internal_Rela *internal_relocs; 653 Elf_Internal_Rela *free_relocs = NULL; 654 Elf_Internal_Rela *irel, *irelend; 655 bfd_byte *contents; 656 bfd_byte *free_contents = NULL; 657 ElfNN_External_Sym *extsyms; 658 ElfNN_External_Sym *free_extsyms = NULL; 659 Elf_External_Sym_Shndx *shndx_buf = NULL; 660 struct elfNN_ia64_link_hash_table *ia64_info; 661 struct one_fixup *fixups = NULL; 662 boolean changed_contents = false; 663 boolean changed_relocs = false; 664 665 /* Assume we're not going to change any sizes, and we'll only need 666 one pass. */ 667 *again = false; 668 669 /* Nothing to do if there are no relocations. */ 670 if ((sec->flags & SEC_RELOC) == 0 671 || sec->reloc_count == 0) 672 return true; 673 674 /* If this is the first time we have been called for this section, 675 initialize the cooked size. */ 676 if (sec->_cooked_size == 0) 677 sec->_cooked_size = sec->_raw_size; 678 679 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 680 681 /* Load the relocations for this section. */ 682 internal_relocs = (_bfd_elfNN_link_read_relocs 683 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL, 684 link_info->keep_memory)); 685 if (internal_relocs == NULL) 686 goto error_return; 687 688 if (! link_info->keep_memory) 689 free_relocs = internal_relocs; 690 691 ia64_info = elfNN_ia64_hash_table (link_info); 692 irelend = internal_relocs + sec->reloc_count; 693 694 for (irel = internal_relocs; irel < irelend; irel++) 695 if (ELFNN_R_TYPE (irel->r_info) == (int) R_IA64_PCREL21B) 696 break; 697 698 /* No branch-type relocations. */ 699 if (irel == irelend) 700 { 701 if (free_relocs != NULL) 702 free (free_relocs); 703 return true; 704 } 705 706 /* Get the section contents. */ 707 if (elf_section_data (sec)->this_hdr.contents != NULL) 708 contents = elf_section_data (sec)->this_hdr.contents; 709 else 710 { 711 contents = (bfd_byte *) bfd_malloc (sec->_raw_size); 712 if (contents == NULL) 713 goto error_return; 714 free_contents = contents; 715 716 if (! bfd_get_section_contents (abfd, sec, contents, 717 (file_ptr) 0, sec->_raw_size)) 718 goto error_return; 719 } 720 721 /* Read this BFD's local symbols. */ 722 if (symtab_hdr->contents != NULL) 723 extsyms = (ElfNN_External_Sym *) symtab_hdr->contents; 724 else 725 { 726 bfd_size_type amt; 727 728 amt = symtab_hdr->sh_info * sizeof (ElfNN_External_Sym); 729 extsyms = (ElfNN_External_Sym *) bfd_malloc (amt); 730 if (extsyms == NULL) 731 goto error_return; 732 free_extsyms = extsyms; 733 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0 734 || bfd_bread (extsyms, amt, abfd) != amt) 735 goto error_return; 736 } 737 738 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr; 739 if (shndx_hdr->sh_size != 0) 740 { 741 bfd_size_type amt; 742 743 amt = symtab_hdr->sh_info * sizeof (Elf_External_Sym_Shndx); 744 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt); 745 if (shndx_buf == NULL) 746 goto error_return; 747 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0 748 || bfd_bread (shndx_buf, amt, abfd) != amt) 749 goto error_return; 750 } 751 752 for (; irel < irelend; irel++) 753 { 754 bfd_vma symaddr, reladdr, trampoff, toff, roff; 755 Elf_Internal_Sym isym; 756 asection *tsec; 757 struct one_fixup *f; 758 bfd_size_type amt; 759 760 if (ELFNN_R_TYPE (irel->r_info) != (int) R_IA64_PCREL21B) 761 continue; 762 763 /* Get the value of the symbol referred to by the reloc. */ 764 if (ELFNN_R_SYM (irel->r_info) < symtab_hdr->sh_info) 765 { 766 ElfNN_External_Sym *esym; 767 Elf_External_Sym_Shndx *shndx; 768 769 /* A local symbol. */ 770 esym = extsyms + ELFNN_R_SYM (irel->r_info); 771 shndx = shndx_buf + (shndx_buf ? ELFNN_R_SYM (irel->r_info) : 0); 772 bfd_elfNN_swap_symbol_in (abfd, esym, shndx, &isym); 773 if (isym.st_shndx == SHN_UNDEF) 774 continue; /* We can't do anthing with undefined symbols. */ 775 else if (isym.st_shndx == SHN_ABS) 776 tsec = bfd_abs_section_ptr; 777 else if (isym.st_shndx == SHN_COMMON) 778 tsec = bfd_com_section_ptr; 779 else if (isym.st_shndx == SHN_IA_64_ANSI_COMMON) 780 tsec = bfd_com_section_ptr; 781 else 782 tsec = bfd_section_from_elf_index (abfd, isym.st_shndx); 783 784 toff = isym.st_value; 785 } 786 else 787 { 788 unsigned long indx; 789 struct elf_link_hash_entry *h; 790 struct elfNN_ia64_dyn_sym_info *dyn_i; 791 792 indx = ELFNN_R_SYM (irel->r_info) - symtab_hdr->sh_info; 793 h = elf_sym_hashes (abfd)[indx]; 794 BFD_ASSERT (h != NULL); 795 796 while (h->root.type == bfd_link_hash_indirect 797 || h->root.type == bfd_link_hash_warning) 798 h = (struct elf_link_hash_entry *) h->root.u.i.link; 799 800 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, false); 801 802 /* For branches to dynamic symbols, we're interested instead 803 in a branch to the PLT entry. */ 804 if (dyn_i && dyn_i->want_plt2) 805 { 806 tsec = ia64_info->plt_sec; 807 toff = dyn_i->plt2_offset; 808 } 809 else 810 { 811 /* We can't do anthing with undefined symbols. */ 812 if (h->root.type == bfd_link_hash_undefined 813 || h->root.type == bfd_link_hash_undefweak) 814 continue; 815 816 tsec = h->root.u.def.section; 817 toff = h->root.u.def.value; 818 } 819 } 820 821 symaddr = (tsec->output_section->vma 822 + tsec->output_offset 823 + toff 824 + irel->r_addend); 825 826 roff = irel->r_offset; 827 reladdr = (sec->output_section->vma 828 + sec->output_offset 829 + roff) & (bfd_vma) -4; 830 831 /* If the branch is in range, no need to do anything. */ 832 if ((bfd_signed_vma) (symaddr - reladdr) >= -0x1000000 833 && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0) 834 continue; 835 836 /* If the branch and target are in the same section, you've 837 got one honking big section and we can't help you. You'll 838 get an error message later. */ 839 if (tsec == sec) 840 continue; 841 842 /* Look for an existing fixup to this address. */ 843 for (f = fixups; f ; f = f->next) 844 if (f->tsec == tsec && f->toff == toff) 845 break; 846 847 if (f == NULL) 848 { 849 /* Two alternatives: If it's a branch to a PLT entry, we can 850 make a copy of the FULL_PLT entry. Otherwise, we'll have 851 to use a `brl' insn to get where we're going. */ 852 853 size_t size; 854 855 if (tsec == ia64_info->plt_sec) 856 size = sizeof (plt_full_entry); 857 else 858 { 859#ifdef USE_BRL 860 size = sizeof (oor_brl); 861#else 862 size = sizeof (oor_ip); 863#endif 864 } 865 866 /* Resize the current section to make room for the new branch. */ 867 trampoff = (sec->_cooked_size + 15) & (bfd_vma) -16; 868 amt = trampoff + size; 869 contents = (bfd_byte *) bfd_realloc (contents, amt); 870 if (contents == NULL) 871 goto error_return; 872 sec->_cooked_size = amt; 873 874 if (tsec == ia64_info->plt_sec) 875 { 876 memcpy (contents + trampoff, plt_full_entry, size); 877 878 /* Hijack the old relocation for use as the PLTOFF reloc. */ 879 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info), 880 R_IA64_PLTOFF22); 881 irel->r_offset = trampoff; 882 } 883 else 884 { 885#ifdef USE_BRL 886 memcpy (contents + trampoff, oor_brl, size); 887 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info), 888 R_IA64_PCREL60B); 889 irel->r_offset = trampoff + 2; 890#else 891 memcpy (contents + trampoff, oor_ip, size); 892 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info), 893 R_IA64_PCREL64I); 894 irel->r_addend -= 16; 895 irel->r_offset = trampoff + 2; 896#endif 897 } 898 899 /* Record the fixup so we don't do it again this section. */ 900 f = (struct one_fixup *) bfd_malloc ((bfd_size_type) sizeof (*f)); 901 f->next = fixups; 902 f->tsec = tsec; 903 f->toff = toff; 904 f->trampoff = trampoff; 905 fixups = f; 906 } 907 else 908 { 909 /* Nop out the reloc, since we're finalizing things here. */ 910 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE); 911 } 912 913 /* Fix up the existing branch to hit the trampoline. Hope like 914 hell this doesn't overflow too. */ 915 if (elfNN_ia64_install_value (abfd, contents + roff, 916 f->trampoff - (roff & (bfd_vma) -4), 917 R_IA64_PCREL21B) != bfd_reloc_ok) 918 goto error_return; 919 920 changed_contents = true; 921 changed_relocs = true; 922 } 923 924 /* Clean up and go home. */ 925 while (fixups) 926 { 927 struct one_fixup *f = fixups; 928 fixups = fixups->next; 929 free (f); 930 } 931 932 if (changed_relocs) 933 elf_section_data (sec)->relocs = internal_relocs; 934 else if (free_relocs != NULL) 935 free (free_relocs); 936 937 if (changed_contents) 938 elf_section_data (sec)->this_hdr.contents = contents; 939 else if (free_contents != NULL) 940 { 941 if (! link_info->keep_memory) 942 free (free_contents); 943 else 944 { 945 /* Cache the section contents for elf_link_input_bfd. */ 946 elf_section_data (sec)->this_hdr.contents = contents; 947 } 948 } 949 950 if (shndx_buf != NULL) 951 free (shndx_buf); 952 953 if (free_extsyms != NULL) 954 { 955 if (! link_info->keep_memory) 956 free (free_extsyms); 957 else 958 { 959 /* Cache the symbols for elf_link_input_bfd. */ 960 symtab_hdr->contents = (unsigned char *) extsyms; 961 } 962 } 963 964 *again = changed_contents || changed_relocs; 965 return true; 966 967 error_return: 968 if (free_relocs != NULL) 969 free (free_relocs); 970 if (free_contents != NULL) 971 free (free_contents); 972 if (shndx_buf != NULL) 973 free (shndx_buf); 974 if (free_extsyms != NULL) 975 free (free_extsyms); 976 return false; 977} 978 979/* Return true if NAME is an unwind table section name. */ 980 981static inline boolean 982is_unwind_section_name (abfd, name) 983 bfd *abfd; 984 const char *name; 985{ 986 size_t len1, len2, len3; 987 988 if (elfNN_ia64_hpux_vec (abfd->xvec) 989 && !strcmp (name, ELF_STRING_ia64_unwind_hdr)) 990 return false; 991 992 len1 = sizeof (ELF_STRING_ia64_unwind) - 1; 993 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1; 994 len3 = sizeof (ELF_STRING_ia64_unwind_once) - 1; 995 return ((strncmp (name, ELF_STRING_ia64_unwind, len1) == 0 996 && strncmp (name, ELF_STRING_ia64_unwind_info, len2) != 0) 997 || strncmp (name, ELF_STRING_ia64_unwind_once, len3) == 0); 998} 999 1000/* Handle an IA-64 specific section when reading an object file. This 1001 is called when elfcode.h finds a section with an unknown type. */ 1002 1003static boolean 1004elfNN_ia64_section_from_shdr (abfd, hdr, name) 1005 bfd *abfd; 1006 ElfNN_Internal_Shdr *hdr; 1007 char *name; 1008{ 1009 asection *newsect; 1010 1011 /* There ought to be a place to keep ELF backend specific flags, but 1012 at the moment there isn't one. We just keep track of the 1013 sections by their name, instead. Fortunately, the ABI gives 1014 suggested names for all the MIPS specific sections, so we will 1015 probably get away with this. */ 1016 switch (hdr->sh_type) 1017 { 1018 case SHT_IA_64_UNWIND: 1019 case SHT_INIT_ARRAY: 1020 case SHT_FINI_ARRAY: 1021 case SHT_PREINIT_ARRAY: 1022 case SHT_IA_64_HP_OPT_ANOT: 1023 break; 1024 1025 case SHT_IA_64_EXT: 1026 if (strcmp (name, ELF_STRING_ia64_archext) != 0) 1027 return false; 1028 break; 1029 1030 default: 1031 return false; 1032 } 1033 1034 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name)) 1035 return false; 1036 newsect = hdr->bfd_section; 1037 1038 return true; 1039} 1040 1041/* Convert IA-64 specific section flags to bfd internal section flags. */ 1042 1043/* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV 1044 flag. */ 1045 1046static boolean 1047elfNN_ia64_section_flags (flags, hdr) 1048 flagword *flags; 1049 ElfNN_Internal_Shdr *hdr; 1050{ 1051 if (hdr->sh_flags & SHF_IA_64_SHORT) 1052 *flags |= SEC_SMALL_DATA; 1053 1054 return true; 1055} 1056 1057/* Set the correct type for an IA-64 ELF section. We do this by the 1058 section name, which is a hack, but ought to work. */ 1059 1060static boolean 1061elfNN_ia64_fake_sections (abfd, hdr, sec) 1062 bfd *abfd ATTRIBUTE_UNUSED; 1063 ElfNN_Internal_Shdr *hdr; 1064 asection *sec; 1065{ 1066 register const char *name; 1067 1068 name = bfd_get_section_name (abfd, sec); 1069 1070 if (is_unwind_section_name (abfd, name)) 1071 { 1072 /* We don't have the sections numbered at this point, so sh_info 1073 is set later, in elfNN_ia64_final_write_processing. */ 1074 hdr->sh_type = SHT_IA_64_UNWIND; 1075 hdr->sh_flags |= SHF_LINK_ORDER; 1076 } 1077 else if (strcmp (name, ELF_STRING_ia64_archext) == 0) 1078 hdr->sh_type = SHT_IA_64_EXT; 1079 else if (strcmp (name, ".init_array") == 0) 1080 hdr->sh_type = SHT_INIT_ARRAY; 1081 else if (strcmp (name, ".fini_array") == 0) 1082 hdr->sh_type = SHT_FINI_ARRAY; 1083 else if (strcmp (name, ".preinit_array") == 0) 1084 hdr->sh_type = SHT_PREINIT_ARRAY; 1085 else if (strcmp (name, ".HP.opt_annot") == 0) 1086 hdr->sh_type = SHT_IA_64_HP_OPT_ANOT; 1087 else if (strcmp (name, ".reloc") == 0) 1088 /* 1089 * This is an ugly, but unfortunately necessary hack that is 1090 * needed when producing EFI binaries on IA-64. It tells 1091 * elf.c:elf_fake_sections() not to consider ".reloc" as a section 1092 * containing ELF relocation info. We need this hack in order to 1093 * be able to generate ELF binaries that can be translated into 1094 * EFI applications (which are essentially COFF objects). Those 1095 * files contain a COFF ".reloc" section inside an ELFNN object, 1096 * which would normally cause BFD to segfault because it would 1097 * attempt to interpret this section as containing relocation 1098 * entries for section "oc". With this hack enabled, ".reloc" 1099 * will be treated as a normal data section, which will avoid the 1100 * segfault. However, you won't be able to create an ELFNN binary 1101 * with a section named "oc" that needs relocations, but that's 1102 * the kind of ugly side-effects you get when detecting section 1103 * types based on their names... In practice, this limitation is 1104 * unlikely to bite. 1105 */ 1106 hdr->sh_type = SHT_PROGBITS; 1107 1108 if (sec->flags & SEC_SMALL_DATA) 1109 hdr->sh_flags |= SHF_IA_64_SHORT; 1110 1111 return true; 1112} 1113 1114/* The final processing done just before writing out an IA-64 ELF 1115 object file. */ 1116 1117static void 1118elfNN_ia64_final_write_processing (abfd, linker) 1119 bfd *abfd; 1120 boolean linker ATTRIBUTE_UNUSED; 1121{ 1122 Elf_Internal_Shdr *hdr; 1123 const char *sname; 1124 asection *text_sect, *s; 1125 size_t len; 1126 1127 for (s = abfd->sections; s; s = s->next) 1128 { 1129 hdr = &elf_section_data (s)->this_hdr; 1130 switch (hdr->sh_type) 1131 { 1132 case SHT_IA_64_UNWIND: 1133 /* See comments in gas/config/tc-ia64.c:dot_endp on why we 1134 have to do this. */ 1135 sname = bfd_get_section_name (abfd, s); 1136 len = sizeof (ELF_STRING_ia64_unwind) - 1; 1137 if (sname && strncmp (sname, ELF_STRING_ia64_unwind, len) == 0) 1138 { 1139 sname += len; 1140 1141 if (sname[0] == '\0') 1142 /* .IA_64.unwind -> .text */ 1143 text_sect = bfd_get_section_by_name (abfd, ".text"); 1144 else 1145 /* .IA_64.unwindFOO -> FOO */ 1146 text_sect = bfd_get_section_by_name (abfd, sname); 1147 } 1148 else if (sname 1149 && (len = sizeof (ELF_STRING_ia64_unwind_once) - 1, 1150 strncmp (sname, ELF_STRING_ia64_unwind_once, len)) == 0) 1151 { 1152 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.t.FOO */ 1153 size_t len2 = sizeof (".gnu.linkonce.t.") - 1; 1154 char *once_name = bfd_malloc (len2 + strlen (sname + len) + 1); 1155 1156 if (once_name != NULL) 1157 { 1158 memcpy (once_name, ".gnu.linkonce.t.", len2); 1159 strcpy (once_name + len2, sname + len); 1160 text_sect = bfd_get_section_by_name (abfd, once_name); 1161 free (once_name); 1162 } 1163 else 1164 /* Should only happen if we run out of memory, in 1165 which case we're probably toast anyway. Try to 1166 cope by finding the section the slow way. */ 1167 for (text_sect = abfd->sections; 1168 text_sect != NULL; 1169 text_sect = text_sect->next) 1170 { 1171 if (strncmp (bfd_section_name (abfd, text_sect), 1172 ".gnu.linkonce.t.", len2) == 0 1173 && strcmp (bfd_section_name (abfd, text_sect) + len2, 1174 sname + len) == 0) 1175 break; 1176 } 1177 } 1178 else 1179 /* last resort: fall back on .text */ 1180 text_sect = bfd_get_section_by_name (abfd, ".text"); 1181 1182 if (text_sect) 1183 { 1184 /* The IA-64 processor-specific ABI requires setting 1185 sh_link to the unwind section, whereas HP-UX requires 1186 sh_info to do so. For maximum compatibility, we'll 1187 set both for now... */ 1188 hdr->sh_link = elf_section_data (text_sect)->this_idx; 1189 hdr->sh_info = elf_section_data (text_sect)->this_idx; 1190 } 1191 break; 1192 } 1193 } 1194} 1195 1196/* Hook called by the linker routine which adds symbols from an object 1197 file. We use it to put .comm items in .sbss, and not .bss. */ 1198 1199static boolean 1200elfNN_ia64_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp) 1201 bfd *abfd; 1202 struct bfd_link_info *info; 1203 const Elf_Internal_Sym *sym; 1204 const char **namep ATTRIBUTE_UNUSED; 1205 flagword *flagsp ATTRIBUTE_UNUSED; 1206 asection **secp; 1207 bfd_vma *valp; 1208{ 1209 if (sym->st_shndx == SHN_COMMON 1210 && !info->relocateable 1211 && sym->st_size <= elf_gp_size (abfd)) 1212 { 1213 /* Common symbols less than or equal to -G nn bytes are 1214 automatically put into .sbss. */ 1215 1216 asection *scomm = bfd_get_section_by_name (abfd, ".scommon"); 1217 1218 if (scomm == NULL) 1219 { 1220 scomm = bfd_make_section (abfd, ".scommon"); 1221 if (scomm == NULL 1222 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC 1223 | SEC_IS_COMMON 1224 | SEC_LINKER_CREATED))) 1225 return false; 1226 } 1227 1228 *secp = scomm; 1229 *valp = sym->st_size; 1230 } 1231 1232 return true; 1233} 1234 1235static boolean 1236elfNN_ia64_aix_vec (const bfd_target *vec) 1237{ 1238 extern const bfd_target bfd_elfNN_ia64_aix_little_vec; 1239 extern const bfd_target bfd_elfNN_ia64_aix_big_vec; 1240 1241 return (/**/vec == & bfd_elfNN_ia64_aix_little_vec 1242 || vec == & bfd_elfNN_ia64_aix_big_vec); 1243} 1244 1245/* Hook called by the linker routine which adds symbols from an object 1246 file. We use it to handle OS-specific symbols. */ 1247 1248static boolean 1249elfNN_ia64_aix_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp) 1250 bfd *abfd; 1251 struct bfd_link_info *info; 1252 const Elf_Internal_Sym *sym; 1253 const char **namep; 1254 flagword *flagsp; 1255 asection **secp; 1256 bfd_vma *valp; 1257{ 1258 if (strcmp (*namep, "__GLOB_DATA_PTR") == 0) 1259 { 1260 /* Define __GLOB_DATA_PTR when it is encountered. This is expected to 1261 be a linker-defined symbol by the Aix C runtime startup code. IBM sez 1262 no one else should use it b/c it is undocumented. */ 1263 struct elf_link_hash_entry *h; 1264 1265 h = elf_link_hash_lookup (elf_hash_table (info), *namep, 1266 false, false, false); 1267 if (h == NULL) 1268 { 1269 struct elf_backend_data *bed; 1270 struct elfNN_ia64_link_hash_table *ia64_info; 1271 1272 bed = get_elf_backend_data (abfd); 1273 ia64_info = elfNN_ia64_hash_table (info); 1274 1275 if (!(_bfd_generic_link_add_one_symbol 1276 (info, abfd, *namep, BSF_GLOBAL, 1277 bfd_get_section_by_name (abfd, ".bss"), 1278 bed->got_symbol_offset, (const char *) NULL, false, 1279 bed->collect, (struct bfd_link_hash_entry **) &h))) 1280 return false; 1281 1282 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR; 1283 h->type = STT_OBJECT; 1284 1285 if (! _bfd_elf_link_record_dynamic_symbol (info, h)) 1286 return false; 1287 } 1288 1289 return true; 1290 } 1291 else if (sym->st_shndx == SHN_LOOS) 1292 { 1293 unsigned int i; 1294 1295 /* SHN_AIX_SYSCALL: Treat this as any other symbol. The special symbol 1296 is only relevant when compiling code for extended system calls. 1297 Replace the "special" section with .text, if possible. 1298 Note that these symbols are always assumed to be in .text. */ 1299 for (i = 1; i < elf_numsections (abfd); i++) 1300 { 1301 asection * sec = bfd_section_from_elf_index (abfd, i); 1302 1303 if (sec && strcmp (sec->name, ".text") == 0) 1304 { 1305 *secp = sec; 1306 break; 1307 } 1308 } 1309 1310 if (*secp == NULL) 1311 *secp = bfd_abs_section_ptr; 1312 1313 *valp = sym->st_size; 1314 1315 return true; 1316 } 1317 else 1318 { 1319 return elfNN_ia64_add_symbol_hook (abfd, info, sym, 1320 namep, flagsp, secp, valp); 1321 } 1322} 1323 1324boolean 1325elfNN_ia64_aix_link_add_symbols (abfd, info) 1326 bfd *abfd; 1327 struct bfd_link_info *info; 1328{ 1329 /* Make sure dynamic sections are always created. */ 1330 if (! elf_hash_table (info)->dynamic_sections_created 1331 && abfd->xvec == info->hash->creator) 1332 { 1333 if (! bfd_elfNN_link_create_dynamic_sections (abfd, info)) 1334 return false; 1335 } 1336 1337 /* Now do the standard call. */ 1338 return bfd_elfNN_bfd_link_add_symbols (abfd, info); 1339} 1340 1341/* Return the number of additional phdrs we will need. */ 1342 1343static int 1344elfNN_ia64_additional_program_headers (abfd) 1345 bfd *abfd; 1346{ 1347 asection *s; 1348 int ret = 0; 1349 1350 /* See if we need a PT_IA_64_ARCHEXT segment. */ 1351 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext); 1352 if (s && (s->flags & SEC_LOAD)) 1353 ++ret; 1354 1355 /* Count how many PT_IA_64_UNWIND segments we need. */ 1356 for (s = abfd->sections; s; s = s->next) 1357 if (is_unwind_section_name (abfd, s->name) && (s->flags & SEC_LOAD)) 1358 ++ret; 1359 1360 return ret; 1361} 1362 1363static boolean 1364elfNN_ia64_modify_segment_map (abfd) 1365 bfd *abfd; 1366{ 1367 struct elf_segment_map *m, **pm; 1368 Elf_Internal_Shdr *hdr; 1369 asection *s; 1370 boolean unwind_found; 1371 asection *unwind_sec; 1372 1373 /* If we need a PT_IA_64_ARCHEXT segment, it must come before 1374 all PT_LOAD segments. */ 1375 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext); 1376 if (s && (s->flags & SEC_LOAD)) 1377 { 1378 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 1379 if (m->p_type == PT_IA_64_ARCHEXT) 1380 break; 1381 if (m == NULL) 1382 { 1383 m = ((struct elf_segment_map *) 1384 bfd_zalloc (abfd, (bfd_size_type) sizeof *m)); 1385 if (m == NULL) 1386 return false; 1387 1388 m->p_type = PT_IA_64_ARCHEXT; 1389 m->count = 1; 1390 m->sections[0] = s; 1391 1392 /* We want to put it after the PHDR and INTERP segments. */ 1393 pm = &elf_tdata (abfd)->segment_map; 1394 while (*pm != NULL 1395 && ((*pm)->p_type == PT_PHDR 1396 || (*pm)->p_type == PT_INTERP)) 1397 pm = &(*pm)->next; 1398 1399 m->next = *pm; 1400 *pm = m; 1401 } 1402 } 1403 1404 /* Install PT_IA_64_UNWIND segments, if needed. */ 1405 for (s = abfd->sections; s; s = s->next) 1406 { 1407 hdr = &elf_section_data (s)->this_hdr; 1408 if (hdr->sh_type != SHT_IA_64_UNWIND) 1409 continue; 1410 1411 if (s && (s->flags & SEC_LOAD)) 1412 { 1413 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 1414 if (m->p_type == PT_IA_64_UNWIND) 1415 { 1416 /* Look through all sections in the unwind segment 1417 for a match since there may be multiple sections 1418 to a segment. */ 1419 1420 unwind_sec = m->sections[0]; 1421 unwind_found = false; 1422 while (unwind_sec != NULL && !unwind_found) 1423 { 1424 if (unwind_sec == s) 1425 unwind_found = true; 1426 else 1427 unwind_sec = unwind_sec -> next; 1428 } 1429 if (unwind_found) 1430 break; 1431 } 1432 1433 if (m == NULL) 1434 { 1435 m = ((struct elf_segment_map *) 1436 bfd_zalloc (abfd, (bfd_size_type) sizeof *m)); 1437 if (m == NULL) 1438 return false; 1439 1440 m->p_type = PT_IA_64_UNWIND; 1441 m->count = 1; 1442 m->sections[0] = s; 1443 m->next = NULL; 1444 1445 /* We want to put it last. */ 1446 pm = &elf_tdata (abfd)->segment_map; 1447 while (*pm != NULL) 1448 pm = &(*pm)->next; 1449 *pm = m; 1450 } 1451 } 1452 } 1453 1454 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of 1455 the input sections for each output section in the segment and testing 1456 for SHF_IA_64_NORECOV on each. */ 1457 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 1458 if (m->p_type == PT_LOAD) 1459 { 1460 int i; 1461 for (i = m->count - 1; i >= 0; --i) 1462 { 1463 struct bfd_link_order *order = m->sections[i]->link_order_head; 1464 while (order) 1465 { 1466 if (order->type == bfd_indirect_link_order) 1467 { 1468 asection *is = order->u.indirect.section; 1469 bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags; 1470 if (flags & SHF_IA_64_NORECOV) 1471 { 1472 m->p_flags |= PF_IA_64_NORECOV; 1473 goto found; 1474 } 1475 } 1476 order = order->next; 1477 } 1478 } 1479 found:; 1480 } 1481 1482 return true; 1483} 1484 1485/* According to the Tahoe assembler spec, all labels starting with a 1486 '.' are local. */ 1487 1488static boolean 1489elfNN_ia64_is_local_label_name (abfd, name) 1490 bfd *abfd ATTRIBUTE_UNUSED; 1491 const char *name; 1492{ 1493 return name[0] == '.'; 1494} 1495 1496/* Should we do dynamic things to this symbol? */ 1497 1498static boolean 1499elfNN_ia64_dynamic_symbol_p (h, info) 1500 struct elf_link_hash_entry *h; 1501 struct bfd_link_info *info; 1502{ 1503 if (h == NULL) 1504 return false; 1505 1506 while (h->root.type == bfd_link_hash_indirect 1507 || h->root.type == bfd_link_hash_warning) 1508 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1509 1510 if (h->dynindx == -1) 1511 return false; 1512 switch (ELF_ST_VISIBILITY (h->other)) 1513 { 1514 case STV_INTERNAL: 1515 case STV_HIDDEN: 1516 return false; 1517 } 1518 1519 if (h->root.type == bfd_link_hash_undefweak 1520 || h->root.type == bfd_link_hash_defweak) 1521 return true; 1522 1523 if ((info->shared && (!info->symbolic || info->allow_shlib_undefined)) 1524 || ((h->elf_link_hash_flags 1525 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)) 1526 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))) 1527 return true; 1528 1529 return false; 1530} 1531 1532static boolean 1533elfNN_ia64_local_hash_table_init (ht, abfd, new) 1534 struct elfNN_ia64_local_hash_table *ht; 1535 bfd *abfd ATTRIBUTE_UNUSED; 1536 new_hash_entry_func new; 1537{ 1538 memset (ht, 0, sizeof (*ht)); 1539 return bfd_hash_table_init (&ht->root, new); 1540} 1541 1542static struct bfd_hash_entry* 1543elfNN_ia64_new_loc_hash_entry (entry, table, string) 1544 struct bfd_hash_entry *entry; 1545 struct bfd_hash_table *table; 1546 const char *string; 1547{ 1548 struct elfNN_ia64_local_hash_entry *ret; 1549 ret = (struct elfNN_ia64_local_hash_entry *) entry; 1550 1551 /* Allocate the structure if it has not already been allocated by a 1552 subclass. */ 1553 if (!ret) 1554 ret = bfd_hash_allocate (table, sizeof (*ret)); 1555 1556 if (!ret) 1557 return 0; 1558 1559 /* Initialize our local data. All zeros, and definitely easier 1560 than setting a handful of bit fields. */ 1561 memset (ret, 0, sizeof (*ret)); 1562 1563 /* Call the allocation method of the superclass. */ 1564 ret = ((struct elfNN_ia64_local_hash_entry *) 1565 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 1566 1567 return (struct bfd_hash_entry *) ret; 1568} 1569 1570static struct bfd_hash_entry* 1571elfNN_ia64_new_elf_hash_entry (entry, table, string) 1572 struct bfd_hash_entry *entry; 1573 struct bfd_hash_table *table; 1574 const char *string; 1575{ 1576 struct elfNN_ia64_link_hash_entry *ret; 1577 ret = (struct elfNN_ia64_link_hash_entry *) entry; 1578 1579 /* Allocate the structure if it has not already been allocated by a 1580 subclass. */ 1581 if (!ret) 1582 ret = bfd_hash_allocate (table, sizeof (*ret)); 1583 1584 if (!ret) 1585 return 0; 1586 1587 /* Initialize our local data. All zeros, and definitely easier 1588 than setting a handful of bit fields. */ 1589 memset (ret, 0, sizeof (*ret)); 1590 1591 /* Call the allocation method of the superclass. */ 1592 ret = ((struct elfNN_ia64_link_hash_entry *) 1593 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 1594 table, string)); 1595 1596 return (struct bfd_hash_entry *) ret; 1597} 1598 1599static void 1600elfNN_ia64_hash_copy_indirect (xdir, xind) 1601 struct elf_link_hash_entry *xdir, *xind; 1602{ 1603 struct elfNN_ia64_link_hash_entry *dir, *ind; 1604 1605 dir = (struct elfNN_ia64_link_hash_entry *) xdir; 1606 ind = (struct elfNN_ia64_link_hash_entry *) xind; 1607 1608 /* Copy down any references that we may have already seen to the 1609 symbol which just became indirect. */ 1610 1611 dir->root.elf_link_hash_flags |= 1612 (ind->root.elf_link_hash_flags 1613 & (ELF_LINK_HASH_REF_DYNAMIC 1614 | ELF_LINK_HASH_REF_REGULAR 1615 | ELF_LINK_HASH_REF_REGULAR_NONWEAK)); 1616 1617 if (ind->root.root.type != bfd_link_hash_indirect) 1618 return; 1619 1620 /* Copy over the got and plt data. This would have been done 1621 by check_relocs. */ 1622 1623 if (dir->info == NULL) 1624 { 1625 struct elfNN_ia64_dyn_sym_info *dyn_i; 1626 1627 dir->info = dyn_i = ind->info; 1628 ind->info = NULL; 1629 1630 /* Fix up the dyn_sym_info pointers to the global symbol. */ 1631 for (; dyn_i; dyn_i = dyn_i->next) 1632 dyn_i->h = &dir->root; 1633 } 1634 BFD_ASSERT (ind->info == NULL); 1635 1636 /* Copy over the dynindx. */ 1637 1638 if (dir->root.dynindx == -1) 1639 { 1640 dir->root.dynindx = ind->root.dynindx; 1641 dir->root.dynstr_index = ind->root.dynstr_index; 1642 ind->root.dynindx = -1; 1643 ind->root.dynstr_index = 0; 1644 } 1645 BFD_ASSERT (ind->root.dynindx == -1); 1646} 1647 1648static void 1649elfNN_ia64_hash_hide_symbol (info, xh, force_local) 1650 struct bfd_link_info *info; 1651 struct elf_link_hash_entry *xh; 1652 boolean force_local; 1653{ 1654 struct elfNN_ia64_link_hash_entry *h; 1655 struct elfNN_ia64_dyn_sym_info *dyn_i; 1656 1657 h = (struct elfNN_ia64_link_hash_entry *)xh; 1658 1659 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local); 1660 1661 for (dyn_i = h->info; dyn_i; dyn_i = dyn_i->next) 1662 dyn_i->want_plt2 = 0; 1663} 1664 1665/* Create the derived linker hash table. The IA-64 ELF port uses this 1666 derived hash table to keep information specific to the IA-64 ElF 1667 linker (without using static variables). */ 1668 1669static struct bfd_link_hash_table* 1670elfNN_ia64_hash_table_create (abfd) 1671 bfd *abfd; 1672{ 1673 struct elfNN_ia64_link_hash_table *ret; 1674 1675 ret = bfd_zalloc (abfd, (bfd_size_type) sizeof (*ret)); 1676 if (!ret) 1677 return 0; 1678 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 1679 elfNN_ia64_new_elf_hash_entry)) 1680 { 1681 bfd_release (abfd, ret); 1682 return 0; 1683 } 1684 1685 if (!elfNN_ia64_local_hash_table_init (&ret->loc_hash_table, abfd, 1686 elfNN_ia64_new_loc_hash_entry)) 1687 return 0; 1688 return &ret->root.root; 1689} 1690 1691/* Look up an entry in a Alpha ELF linker hash table. */ 1692 1693static INLINE struct elfNN_ia64_local_hash_entry * 1694elfNN_ia64_local_hash_lookup(table, string, create, copy) 1695 struct elfNN_ia64_local_hash_table *table; 1696 const char *string; 1697 boolean create, copy; 1698{ 1699 return ((struct elfNN_ia64_local_hash_entry *) 1700 bfd_hash_lookup (&table->root, string, create, copy)); 1701} 1702 1703/* Traverse both local and global hash tables. */ 1704 1705struct elfNN_ia64_dyn_sym_traverse_data 1706{ 1707 boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR)); 1708 PTR data; 1709}; 1710 1711static boolean 1712elfNN_ia64_global_dyn_sym_thunk (xentry, xdata) 1713 struct bfd_hash_entry *xentry; 1714 PTR xdata; 1715{ 1716 struct elfNN_ia64_link_hash_entry *entry 1717 = (struct elfNN_ia64_link_hash_entry *) xentry; 1718 struct elfNN_ia64_dyn_sym_traverse_data *data 1719 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata; 1720 struct elfNN_ia64_dyn_sym_info *dyn_i; 1721 1722 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next) 1723 if (! (*data->func) (dyn_i, data->data)) 1724 return false; 1725 return true; 1726} 1727 1728static boolean 1729elfNN_ia64_local_dyn_sym_thunk (xentry, xdata) 1730 struct bfd_hash_entry *xentry; 1731 PTR xdata; 1732{ 1733 struct elfNN_ia64_local_hash_entry *entry 1734 = (struct elfNN_ia64_local_hash_entry *) xentry; 1735 struct elfNN_ia64_dyn_sym_traverse_data *data 1736 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata; 1737 struct elfNN_ia64_dyn_sym_info *dyn_i; 1738 1739 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next) 1740 if (! (*data->func) (dyn_i, data->data)) 1741 return false; 1742 return true; 1743} 1744 1745static void 1746elfNN_ia64_dyn_sym_traverse (ia64_info, func, data) 1747 struct elfNN_ia64_link_hash_table *ia64_info; 1748 boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR)); 1749 PTR data; 1750{ 1751 struct elfNN_ia64_dyn_sym_traverse_data xdata; 1752 1753 xdata.func = func; 1754 xdata.data = data; 1755 1756 elf_link_hash_traverse (&ia64_info->root, 1757 elfNN_ia64_global_dyn_sym_thunk, &xdata); 1758 bfd_hash_traverse (&ia64_info->loc_hash_table.root, 1759 elfNN_ia64_local_dyn_sym_thunk, &xdata); 1760} 1761 1762static boolean 1763elfNN_ia64_create_dynamic_sections (abfd, info) 1764 bfd *abfd; 1765 struct bfd_link_info *info; 1766{ 1767 struct elfNN_ia64_link_hash_table *ia64_info; 1768 asection *s; 1769 1770 if (! _bfd_elf_create_dynamic_sections (abfd, info)) 1771 return false; 1772 1773 ia64_info = elfNN_ia64_hash_table (info); 1774 1775 ia64_info->plt_sec = bfd_get_section_by_name (abfd, ".plt"); 1776 ia64_info->got_sec = bfd_get_section_by_name (abfd, ".got"); 1777 1778 { 1779 flagword flags = bfd_get_section_flags (abfd, ia64_info->got_sec); 1780 bfd_set_section_flags (abfd, ia64_info->got_sec, SEC_SMALL_DATA | flags); 1781 } 1782 1783 if (!get_pltoff (abfd, info, ia64_info)) 1784 return false; 1785 1786 s = bfd_make_section(abfd, ".rela.IA_64.pltoff"); 1787 if (s == NULL 1788 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD 1789 | SEC_HAS_CONTENTS 1790 | SEC_IN_MEMORY 1791 | SEC_LINKER_CREATED 1792 | SEC_READONLY)) 1793 || !bfd_set_section_alignment (abfd, s, 3)) 1794 return false; 1795 ia64_info->rel_pltoff_sec = s; 1796 1797 s = bfd_make_section(abfd, ".rela.got"); 1798 if (s == NULL 1799 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD 1800 | SEC_HAS_CONTENTS 1801 | SEC_IN_MEMORY 1802 | SEC_LINKER_CREATED 1803 | SEC_READONLY)) 1804 || !bfd_set_section_alignment (abfd, s, 3)) 1805 return false; 1806 ia64_info->rel_got_sec = s; 1807 1808 return true; 1809} 1810 1811/* Find and/or create a hash entry for local symbol. */ 1812static struct elfNN_ia64_local_hash_entry * 1813get_local_sym_hash (ia64_info, abfd, rel, create) 1814 struct elfNN_ia64_link_hash_table *ia64_info; 1815 bfd *abfd; 1816 const Elf_Internal_Rela *rel; 1817 boolean create; 1818{ 1819 char *addr_name; 1820 size_t len; 1821 struct elfNN_ia64_local_hash_entry *ret; 1822 1823 /* Construct a string for use in the elfNN_ia64_local_hash_table. 1824 name describes what was once anonymous memory. */ 1825 1826 len = sizeof (void*)*2 + 1 + sizeof (bfd_vma)*4 + 1 + 1; 1827 len += 10; /* %p slop */ 1828 1829 addr_name = bfd_malloc (len); 1830 if (addr_name == NULL) 1831 return 0; 1832 sprintf (addr_name, "%p:%lx", 1833 (void *) abfd, (unsigned long) ELFNN_R_SYM (rel->r_info)); 1834 1835 /* Collect the canonical entry data for this address. */ 1836 ret = elfNN_ia64_local_hash_lookup (&ia64_info->loc_hash_table, 1837 addr_name, create, create); 1838 free (addr_name); 1839 return ret; 1840} 1841 1842/* Find and/or create a descriptor for dynamic symbol info. This will 1843 vary based on global or local symbol, and the addend to the reloc. */ 1844 1845static struct elfNN_ia64_dyn_sym_info * 1846get_dyn_sym_info (ia64_info, h, abfd, rel, create) 1847 struct elfNN_ia64_link_hash_table *ia64_info; 1848 struct elf_link_hash_entry *h; 1849 bfd *abfd; 1850 const Elf_Internal_Rela *rel; 1851 boolean create; 1852{ 1853 struct elfNN_ia64_dyn_sym_info **pp; 1854 struct elfNN_ia64_dyn_sym_info *dyn_i; 1855 bfd_vma addend = rel ? rel->r_addend : 0; 1856 1857 if (h) 1858 pp = &((struct elfNN_ia64_link_hash_entry *)h)->info; 1859 else 1860 { 1861 struct elfNN_ia64_local_hash_entry *loc_h; 1862 1863 loc_h = get_local_sym_hash (ia64_info, abfd, rel, create); 1864 BFD_ASSERT (loc_h); 1865 1866 pp = &loc_h->info; 1867 } 1868 1869 for (dyn_i = *pp; dyn_i && dyn_i->addend != addend; dyn_i = *pp) 1870 pp = &dyn_i->next; 1871 1872 if (dyn_i == NULL && create) 1873 { 1874 dyn_i = ((struct elfNN_ia64_dyn_sym_info *) 1875 bfd_zalloc (abfd, (bfd_size_type) sizeof *dyn_i)); 1876 *pp = dyn_i; 1877 dyn_i->addend = addend; 1878 } 1879 1880 return dyn_i; 1881} 1882 1883static asection * 1884get_got (abfd, info, ia64_info) 1885 bfd *abfd; 1886 struct bfd_link_info *info; 1887 struct elfNN_ia64_link_hash_table *ia64_info; 1888{ 1889 asection *got; 1890 bfd *dynobj; 1891 1892 got = ia64_info->got_sec; 1893 if (!got) 1894 { 1895 flagword flags; 1896 1897 dynobj = ia64_info->root.dynobj; 1898 if (!dynobj) 1899 ia64_info->root.dynobj = dynobj = abfd; 1900 if (!_bfd_elf_create_got_section (dynobj, info)) 1901 return 0; 1902 1903 got = bfd_get_section_by_name (dynobj, ".got"); 1904 BFD_ASSERT (got); 1905 ia64_info->got_sec = got; 1906 1907 flags = bfd_get_section_flags (abfd, got); 1908 bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags); 1909 } 1910 1911 return got; 1912} 1913 1914/* Create function descriptor section (.opd). This section is called .opd 1915 because it contains "official prodecure descriptors". The "official" 1916 refers to the fact that these descriptors are used when taking the address 1917 of a procedure, thus ensuring a unique address for each procedure. */ 1918 1919static asection * 1920get_fptr (abfd, info, ia64_info) 1921 bfd *abfd; 1922 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1923 struct elfNN_ia64_link_hash_table *ia64_info; 1924{ 1925 asection *fptr; 1926 bfd *dynobj; 1927 1928 fptr = ia64_info->fptr_sec; 1929 if (!fptr) 1930 { 1931 dynobj = ia64_info->root.dynobj; 1932 if (!dynobj) 1933 ia64_info->root.dynobj = dynobj = abfd; 1934 1935 fptr = bfd_make_section (dynobj, ".opd"); 1936 if (!fptr 1937 || !bfd_set_section_flags (dynobj, fptr, 1938 (SEC_ALLOC 1939 | SEC_LOAD 1940 | SEC_HAS_CONTENTS 1941 | SEC_IN_MEMORY 1942 | SEC_READONLY 1943 | SEC_LINKER_CREATED)) 1944 || !bfd_set_section_alignment (abfd, fptr, 4)) 1945 { 1946 BFD_ASSERT (0); 1947 return NULL; 1948 } 1949 1950 ia64_info->fptr_sec = fptr; 1951 } 1952 1953 return fptr; 1954} 1955 1956static asection * 1957get_pltoff (abfd, info, ia64_info) 1958 bfd *abfd; 1959 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1960 struct elfNN_ia64_link_hash_table *ia64_info; 1961{ 1962 asection *pltoff; 1963 bfd *dynobj; 1964 1965 pltoff = ia64_info->pltoff_sec; 1966 if (!pltoff) 1967 { 1968 dynobj = ia64_info->root.dynobj; 1969 if (!dynobj) 1970 ia64_info->root.dynobj = dynobj = abfd; 1971 1972 pltoff = bfd_make_section (dynobj, ELF_STRING_ia64_pltoff); 1973 if (!pltoff 1974 || !bfd_set_section_flags (dynobj, pltoff, 1975 (SEC_ALLOC 1976 | SEC_LOAD 1977 | SEC_HAS_CONTENTS 1978 | SEC_IN_MEMORY 1979 | SEC_SMALL_DATA 1980 | SEC_LINKER_CREATED)) 1981 || !bfd_set_section_alignment (abfd, pltoff, 4)) 1982 { 1983 BFD_ASSERT (0); 1984 return NULL; 1985 } 1986 1987 ia64_info->pltoff_sec = pltoff; 1988 } 1989 1990 return pltoff; 1991} 1992 1993static asection * 1994get_reloc_section (abfd, ia64_info, sec, create) 1995 bfd *abfd; 1996 struct elfNN_ia64_link_hash_table *ia64_info; 1997 asection *sec; 1998 boolean create; 1999{ 2000 const char *srel_name; 2001 asection *srel; 2002 bfd *dynobj; 2003 2004 srel_name = (bfd_elf_string_from_elf_section 2005 (abfd, elf_elfheader(abfd)->e_shstrndx, 2006 elf_section_data(sec)->rel_hdr.sh_name)); 2007 if (srel_name == NULL) 2008 return NULL; 2009 2010 BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0 2011 && strcmp (bfd_get_section_name (abfd, sec), 2012 srel_name+5) == 0) 2013 || (strncmp (srel_name, ".rel", 4) == 0 2014 && strcmp (bfd_get_section_name (abfd, sec), 2015 srel_name+4) == 0)); 2016 2017 dynobj = ia64_info->root.dynobj; 2018 if (!dynobj) 2019 ia64_info->root.dynobj = dynobj = abfd; 2020 2021 srel = bfd_get_section_by_name (dynobj, srel_name); 2022 if (srel == NULL && create) 2023 { 2024 srel = bfd_make_section (dynobj, srel_name); 2025 if (srel == NULL 2026 || !bfd_set_section_flags (dynobj, srel, 2027 (SEC_ALLOC 2028 | SEC_LOAD 2029 | SEC_HAS_CONTENTS 2030 | SEC_IN_MEMORY 2031 | SEC_LINKER_CREATED 2032 | SEC_READONLY)) 2033 || !bfd_set_section_alignment (dynobj, srel, 3)) 2034 return NULL; 2035 } 2036 2037 if (sec->flags & SEC_READONLY) 2038 ia64_info->reltext = 1; 2039 2040 return srel; 2041} 2042 2043static boolean 2044count_dyn_reloc (abfd, dyn_i, srel, type) 2045 bfd *abfd; 2046 struct elfNN_ia64_dyn_sym_info *dyn_i; 2047 asection *srel; 2048 int type; 2049{ 2050 struct elfNN_ia64_dyn_reloc_entry *rent; 2051 2052 for (rent = dyn_i->reloc_entries; rent; rent = rent->next) 2053 if (rent->srel == srel && rent->type == type) 2054 break; 2055 2056 if (!rent) 2057 { 2058 rent = ((struct elfNN_ia64_dyn_reloc_entry *) 2059 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent))); 2060 if (!rent) 2061 return false; 2062 2063 rent->next = dyn_i->reloc_entries; 2064 rent->srel = srel; 2065 rent->type = type; 2066 rent->count = 0; 2067 dyn_i->reloc_entries = rent; 2068 } 2069 rent->count++; 2070 2071 return true; 2072} 2073 2074static boolean 2075elfNN_ia64_check_relocs (abfd, info, sec, relocs) 2076 bfd *abfd; 2077 struct bfd_link_info *info; 2078 asection *sec; 2079 const Elf_Internal_Rela *relocs; 2080{ 2081 struct elfNN_ia64_link_hash_table *ia64_info; 2082 const Elf_Internal_Rela *relend; 2083 Elf_Internal_Shdr *symtab_hdr; 2084 const Elf_Internal_Rela *rel; 2085 asection *got, *fptr, *srel; 2086 2087 if (info->relocateable) 2088 return true; 2089 2090 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2091 ia64_info = elfNN_ia64_hash_table (info); 2092 2093 got = fptr = srel = NULL; 2094 2095 relend = relocs + sec->reloc_count; 2096 for (rel = relocs; rel < relend; ++rel) 2097 { 2098 enum { 2099 NEED_GOT = 1, 2100 NEED_FPTR = 2, 2101 NEED_PLTOFF = 4, 2102 NEED_MIN_PLT = 8, 2103 NEED_FULL_PLT = 16, 2104 NEED_DYNREL = 32, 2105 NEED_LTOFF_FPTR = 64, 2106 }; 2107 2108 struct elf_link_hash_entry *h = NULL; 2109 unsigned long r_symndx = ELFNN_R_SYM (rel->r_info); 2110 struct elfNN_ia64_dyn_sym_info *dyn_i; 2111 int need_entry; 2112 boolean maybe_dynamic; 2113 int dynrel_type = R_IA64_NONE; 2114 2115 if (r_symndx >= symtab_hdr->sh_info) 2116 { 2117 /* We're dealing with a global symbol -- find its hash entry 2118 and mark it as being referenced. */ 2119 long indx = r_symndx - symtab_hdr->sh_info; 2120 h = elf_sym_hashes (abfd)[indx]; 2121 while (h->root.type == bfd_link_hash_indirect 2122 || h->root.type == bfd_link_hash_warning) 2123 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2124 2125 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR; 2126 } 2127 2128 /* We can only get preliminary data on whether a symbol is 2129 locally or externally defined, as not all of the input files 2130 have yet been processed. Do something with what we know, as 2131 this may help reduce memory usage and processing time later. */ 2132 maybe_dynamic = false; 2133 if (h && ((info->shared 2134 && (!info->symbolic || info->allow_shlib_undefined)) 2135 || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) 2136 || h->root.type == bfd_link_hash_defweak 2137 || elfNN_ia64_aix_vec (abfd->xvec))) 2138 maybe_dynamic = true; 2139 2140 need_entry = 0; 2141 switch (ELFNN_R_TYPE (rel->r_info)) 2142 { 2143 case R_IA64_TPREL22: 2144 case R_IA64_TPREL64MSB: 2145 case R_IA64_TPREL64LSB: 2146 case R_IA64_LTOFF_TP22: 2147 return false; 2148 2149 case R_IA64_LTOFF_FPTR22: 2150 case R_IA64_LTOFF_FPTR64I: 2151 case R_IA64_LTOFF_FPTR32MSB: 2152 case R_IA64_LTOFF_FPTR32LSB: 2153 case R_IA64_LTOFF_FPTR64MSB: 2154 case R_IA64_LTOFF_FPTR64LSB: 2155 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR; 2156 break; 2157 2158 case R_IA64_FPTR64I: 2159 case R_IA64_FPTR32MSB: 2160 case R_IA64_FPTR32LSB: 2161 case R_IA64_FPTR64MSB: 2162 case R_IA64_FPTR64LSB: 2163 if (info->shared || h || elfNN_ia64_aix_vec (abfd->xvec)) 2164 need_entry = NEED_FPTR | NEED_DYNREL; 2165 else 2166 need_entry = NEED_FPTR; 2167 dynrel_type = R_IA64_FPTR64LSB; 2168 break; 2169 2170 case R_IA64_LTOFF22: 2171 case R_IA64_LTOFF22X: 2172 case R_IA64_LTOFF64I: 2173 need_entry = NEED_GOT; 2174 break; 2175 2176 case R_IA64_PLTOFF22: 2177 case R_IA64_PLTOFF64I: 2178 case R_IA64_PLTOFF64MSB: 2179 case R_IA64_PLTOFF64LSB: 2180 need_entry = NEED_PLTOFF; 2181 if (h) 2182 { 2183 if (maybe_dynamic) 2184 need_entry |= NEED_MIN_PLT; 2185 } 2186 else 2187 { 2188 (*info->callbacks->warning) 2189 (info, _("@pltoff reloc against local symbol"), 0, 2190 abfd, 0, (bfd_vma) 0); 2191 } 2192 break; 2193 2194 case R_IA64_PCREL21B: 2195 case R_IA64_PCREL60B: 2196 /* Depending on where this symbol is defined, we may or may not 2197 need a full plt entry. Only skip if we know we'll not need 2198 the entry -- static or symbolic, and the symbol definition 2199 has already been seen. */ 2200 if (maybe_dynamic && rel->r_addend == 0) 2201 need_entry = NEED_FULL_PLT; 2202 break; 2203 2204 case R_IA64_IMM14: 2205 case R_IA64_IMM22: 2206 case R_IA64_IMM64: 2207 case R_IA64_DIR32MSB: 2208 case R_IA64_DIR32LSB: 2209 case R_IA64_DIR64MSB: 2210 case R_IA64_DIR64LSB: 2211 /* Shared objects will always need at least a REL relocation. */ 2212 if (info->shared || maybe_dynamic 2213 || (elfNN_ia64_aix_vec (abfd->xvec) 2214 && (!h || strcmp (h->root.root.string, 2215 "__GLOB_DATA_PTR") != 0))) 2216 need_entry = NEED_DYNREL; 2217 dynrel_type = R_IA64_DIR64LSB; 2218 break; 2219 2220 case R_IA64_IPLTMSB: 2221 case R_IA64_IPLTLSB: 2222 /* Shared objects will always need at least a REL relocation. */ 2223 if (info->shared || maybe_dynamic) 2224 need_entry = NEED_DYNREL; 2225 dynrel_type = R_IA64_IPLTLSB; 2226 break; 2227 2228 case R_IA64_PCREL22: 2229 case R_IA64_PCREL64I: 2230 case R_IA64_PCREL32MSB: 2231 case R_IA64_PCREL32LSB: 2232 case R_IA64_PCREL64MSB: 2233 case R_IA64_PCREL64LSB: 2234 if (maybe_dynamic) 2235 need_entry = NEED_DYNREL; 2236 dynrel_type = R_IA64_PCREL64LSB; 2237 break; 2238 } 2239 2240 if (!need_entry) 2241 continue; 2242 2243 if ((need_entry & NEED_FPTR) != 0 2244 && rel->r_addend) 2245 { 2246 (*info->callbacks->warning) 2247 (info, _("non-zero addend in @fptr reloc"), 0, 2248 abfd, 0, (bfd_vma) 0); 2249 } 2250 2251 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, true); 2252 2253 /* Record whether or not this is a local symbol. */ 2254 dyn_i->h = h; 2255 2256 /* Create what's needed. */ 2257 if (need_entry & NEED_GOT) 2258 { 2259 if (!got) 2260 { 2261 got = get_got (abfd, info, ia64_info); 2262 if (!got) 2263 return false; 2264 } 2265 dyn_i->want_got = 1; 2266 } 2267 if (need_entry & NEED_FPTR) 2268 { 2269 if (!fptr) 2270 { 2271 fptr = get_fptr (abfd, info, ia64_info); 2272 if (!fptr) 2273 return false; 2274 } 2275 2276 /* FPTRs for shared libraries are allocated by the dynamic 2277 linker. Make sure this local symbol will appear in the 2278 dynamic symbol table. */ 2279 if (!h && (info->shared 2280 /* AIX also needs one */ 2281 || elfNN_ia64_aix_vec (abfd->xvec))) 2282 { 2283 if (! (_bfd_elfNN_link_record_local_dynamic_symbol 2284 (info, abfd, (long) r_symndx))) 2285 return false; 2286 } 2287 2288 dyn_i->want_fptr = 1; 2289 } 2290 if (need_entry & NEED_LTOFF_FPTR) 2291 dyn_i->want_ltoff_fptr = 1; 2292 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT)) 2293 { 2294 if (!ia64_info->root.dynobj) 2295 ia64_info->root.dynobj = abfd; 2296 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 2297 dyn_i->want_plt = 1; 2298 } 2299 if (need_entry & NEED_FULL_PLT) 2300 dyn_i->want_plt2 = 1; 2301 if (need_entry & NEED_PLTOFF) 2302 dyn_i->want_pltoff = 1; 2303 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC)) 2304 { 2305 if (!srel) 2306 { 2307 srel = get_reloc_section (abfd, ia64_info, sec, true); 2308 if (!srel) 2309 return false; 2310 } 2311 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type)) 2312 return false; 2313 } 2314 } 2315 2316 return true; 2317} 2318 2319struct elfNN_ia64_allocate_data 2320{ 2321 struct bfd_link_info *info; 2322 bfd_size_type ofs; 2323}; 2324 2325/* For cleanliness, and potentially faster dynamic loading, allocate 2326 external GOT entries first. */ 2327 2328static boolean 2329allocate_global_data_got (dyn_i, data) 2330 struct elfNN_ia64_dyn_sym_info *dyn_i; 2331 PTR data; 2332{ 2333 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2334 2335 if (dyn_i->want_got 2336 && ! dyn_i->want_fptr 2337 && (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info) 2338 || (elfNN_ia64_aix_vec (x->info->hash->creator) 2339 && (!dyn_i->h || strcmp (dyn_i->h->root.root.string, 2340 "__GLOB_DATA_PTR") != 0)))) 2341 { 2342 dyn_i->got_offset = x->ofs; 2343 x->ofs += 8; 2344 } 2345 return true; 2346} 2347 2348/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */ 2349 2350static boolean 2351allocate_global_fptr_got (dyn_i, data) 2352 struct elfNN_ia64_dyn_sym_info *dyn_i; 2353 PTR data; 2354{ 2355 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2356 2357 if (dyn_i->want_got 2358 && dyn_i->want_fptr 2359 && (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info) 2360 || elfNN_ia64_aix_vec (x->info->hash->creator))) 2361 { 2362 dyn_i->got_offset = x->ofs; 2363 x->ofs += 8; 2364 } 2365 return true; 2366} 2367 2368/* Lastly, allocate all the GOT entries for local data. */ 2369 2370static boolean 2371allocate_local_got (dyn_i, data) 2372 struct elfNN_ia64_dyn_sym_info *dyn_i; 2373 PTR data; 2374{ 2375 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2376 2377 if (dyn_i->want_got 2378 && ! (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info) 2379 || elfNN_ia64_aix_vec (x->info->hash->creator))) 2380 { 2381 dyn_i->got_offset = x->ofs; 2382 x->ofs += 8; 2383 } 2384 return true; 2385} 2386 2387/* Search for the index of a global symbol in it's defining object file. */ 2388 2389static long 2390global_sym_index (h) 2391 struct elf_link_hash_entry *h; 2392{ 2393 struct elf_link_hash_entry **p; 2394 bfd *obj; 2395 2396 BFD_ASSERT (h->root.type == bfd_link_hash_defined 2397 || h->root.type == bfd_link_hash_defweak); 2398 2399 obj = h->root.u.def.section->owner; 2400 for (p = elf_sym_hashes (obj); *p != h; ++p) 2401 continue; 2402 2403 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info; 2404} 2405 2406/* Allocate function descriptors. We can do these for every function 2407 in a main executable that is not exported. */ 2408 2409static boolean 2410allocate_fptr (dyn_i, data) 2411 struct elfNN_ia64_dyn_sym_info *dyn_i; 2412 PTR data; 2413{ 2414 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2415 2416 if (dyn_i->want_fptr) 2417 { 2418 struct elf_link_hash_entry *h = dyn_i->h; 2419 2420 if (h) 2421 while (h->root.type == bfd_link_hash_indirect 2422 || h->root.type == bfd_link_hash_warning) 2423 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2424 2425 if (x->info->shared 2426 /* AIX needs an FPTR in this case. */ 2427 || (elfNN_ia64_aix_vec (x->info->hash->creator) 2428 && (!h 2429 || h->root.type == bfd_link_hash_defined 2430 || h->root.type == bfd_link_hash_defweak))) 2431 { 2432 if (h && h->dynindx == -1) 2433 { 2434 BFD_ASSERT ((h->root.type == bfd_link_hash_defined) 2435 || (h->root.type == bfd_link_hash_defweak)); 2436 2437 if (!_bfd_elfNN_link_record_local_dynamic_symbol 2438 (x->info, h->root.u.def.section->owner, 2439 global_sym_index (h))) 2440 return false; 2441 } 2442 2443 dyn_i->want_fptr = 0; 2444 } 2445 else if (h == NULL || h->dynindx == -1) 2446 { 2447 dyn_i->fptr_offset = x->ofs; 2448 x->ofs += 16; 2449 } 2450 else 2451 dyn_i->want_fptr = 0; 2452 } 2453 return true; 2454} 2455 2456/* Allocate all the minimal PLT entries. */ 2457 2458static boolean 2459allocate_plt_entries (dyn_i, data) 2460 struct elfNN_ia64_dyn_sym_info *dyn_i; 2461 PTR data; 2462{ 2463 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2464 2465 if (dyn_i->want_plt) 2466 { 2467 struct elf_link_hash_entry *h = dyn_i->h; 2468 2469 if (h) 2470 while (h->root.type == bfd_link_hash_indirect 2471 || h->root.type == bfd_link_hash_warning) 2472 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2473 2474 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */ 2475 if (elfNN_ia64_dynamic_symbol_p (h, x->info)) 2476 { 2477 bfd_size_type offset = x->ofs; 2478 if (offset == 0) 2479 offset = PLT_HEADER_SIZE; 2480 dyn_i->plt_offset = offset; 2481 x->ofs = offset + PLT_MIN_ENTRY_SIZE; 2482 2483 dyn_i->want_pltoff = 1; 2484 } 2485 else 2486 { 2487 dyn_i->want_plt = 0; 2488 dyn_i->want_plt2 = 0; 2489 } 2490 } 2491 return true; 2492} 2493 2494/* Allocate all the full PLT entries. */ 2495 2496static boolean 2497allocate_plt2_entries (dyn_i, data) 2498 struct elfNN_ia64_dyn_sym_info *dyn_i; 2499 PTR data; 2500{ 2501 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2502 2503 if (dyn_i->want_plt2) 2504 { 2505 struct elf_link_hash_entry *h = dyn_i->h; 2506 bfd_size_type ofs = x->ofs; 2507 2508 dyn_i->plt2_offset = ofs; 2509 x->ofs = ofs + PLT_FULL_ENTRY_SIZE; 2510 2511 while (h->root.type == bfd_link_hash_indirect 2512 || h->root.type == bfd_link_hash_warning) 2513 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2514 dyn_i->h->plt.offset = ofs; 2515 } 2516 return true; 2517} 2518 2519/* Allocate all the PLTOFF entries requested by relocations and 2520 plt entries. We can't share space with allocated FPTR entries, 2521 because the latter are not necessarily addressable by the GP. 2522 ??? Relaxation might be able to determine that they are. */ 2523 2524static boolean 2525allocate_pltoff_entries (dyn_i, data) 2526 struct elfNN_ia64_dyn_sym_info *dyn_i; 2527 PTR data; 2528{ 2529 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2530 2531 if (dyn_i->want_pltoff) 2532 { 2533 dyn_i->pltoff_offset = x->ofs; 2534 x->ofs += 16; 2535 } 2536 return true; 2537} 2538 2539/* Allocate dynamic relocations for those symbols that turned out 2540 to be dynamic. */ 2541 2542static boolean 2543allocate_dynrel_entries (dyn_i, data) 2544 struct elfNN_ia64_dyn_sym_info *dyn_i; 2545 PTR data; 2546{ 2547 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data; 2548 struct elfNN_ia64_link_hash_table *ia64_info; 2549 struct elfNN_ia64_dyn_reloc_entry *rent; 2550 boolean dynamic_symbol, shared; 2551 2552 ia64_info = elfNN_ia64_hash_table (x->info); 2553 dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info) 2554 || (elfNN_ia64_aix_vec (x->info->hash->creator) 2555 /* Don't allocate an entry for __GLOB_DATA_PTR */ 2556 && (!dyn_i->h || strcmp (dyn_i->h->root.root.string, 2557 "__GLOB_DATA_PTR") != 0)); 2558 shared = x->info->shared; 2559 2560 /* Take care of the normal data relocations. */ 2561 2562 for (rent = dyn_i->reloc_entries; rent; rent = rent->next) 2563 { 2564 int count = rent->count; 2565 2566 switch (rent->type) 2567 { 2568 case R_IA64_FPTR64LSB: 2569 /* Allocate one iff !want_fptr, which by this point will 2570 be true only if we're actually allocating one statically 2571 in the main executable. */ 2572 if (dyn_i->want_fptr) 2573 continue; 2574 break; 2575 case R_IA64_PCREL64LSB: 2576 if (!dynamic_symbol) 2577 continue; 2578 break; 2579 case R_IA64_DIR64LSB: 2580 if (!dynamic_symbol && !shared) 2581 continue; 2582 break; 2583 case R_IA64_IPLTLSB: 2584 if (!dynamic_symbol && !shared) 2585 continue; 2586 /* Use two REL relocations for IPLT relocations 2587 against local symbols. */ 2588 if (!dynamic_symbol) 2589 count *= 2; 2590 break; 2591 default: 2592 abort (); 2593 } 2594 rent->srel->_raw_size += sizeof (ElfNN_External_Rela) * count; 2595 } 2596 2597 /* Take care of the GOT and PLT relocations. */ 2598 2599 if (((dynamic_symbol || shared) && dyn_i->want_got) 2600 || (dyn_i->want_ltoff_fptr && dyn_i->h && dyn_i->h->dynindx != -1)) 2601 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela); 2602 2603 if (dyn_i->want_pltoff) 2604 { 2605 bfd_size_type t = 0; 2606 2607 /* Dynamic symbols get one IPLT relocation. Local symbols in 2608 shared libraries get two REL relocations. Local symbols in 2609 main applications get nothing. */ 2610 if (dynamic_symbol) 2611 t = sizeof (ElfNN_External_Rela); 2612 else if (shared) 2613 t = 2 * sizeof (ElfNN_External_Rela); 2614 2615 ia64_info->rel_pltoff_sec->_raw_size += t; 2616 } 2617 2618 return true; 2619} 2620 2621static boolean 2622elfNN_ia64_adjust_dynamic_symbol (info, h) 2623 struct bfd_link_info *info ATTRIBUTE_UNUSED; 2624 struct elf_link_hash_entry *h; 2625{ 2626 /* ??? Undefined symbols with PLT entries should be re-defined 2627 to be the PLT entry. */ 2628 2629 /* If this is a weak symbol, and there is a real definition, the 2630 processor independent code will have arranged for us to see the 2631 real definition first, and we can just use the same value. */ 2632 if (h->weakdef != NULL) 2633 { 2634 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 2635 || h->weakdef->root.type == bfd_link_hash_defweak); 2636 h->root.u.def.section = h->weakdef->root.u.def.section; 2637 h->root.u.def.value = h->weakdef->root.u.def.value; 2638 return true; 2639 } 2640 2641 /* If this is a reference to a symbol defined by a dynamic object which 2642 is not a function, we might allocate the symbol in our .dynbss section 2643 and allocate a COPY dynamic relocation. 2644 2645 But IA-64 code is canonically PIC, so as a rule we can avoid this sort 2646 of hackery. */ 2647 2648 return true; 2649} 2650 2651static boolean 2652elfNN_ia64_size_dynamic_sections (output_bfd, info) 2653 bfd *output_bfd; 2654 struct bfd_link_info *info; 2655{ 2656 struct elfNN_ia64_allocate_data data; 2657 struct elfNN_ia64_link_hash_table *ia64_info; 2658 asection *sec; 2659 bfd *dynobj; 2660 boolean relplt = false; 2661 2662 dynobj = elf_hash_table(info)->dynobj; 2663 ia64_info = elfNN_ia64_hash_table (info); 2664 BFD_ASSERT(dynobj != NULL); 2665 data.info = info; 2666 2667 /* Set the contents of the .interp section to the interpreter. */ 2668 if (ia64_info->root.dynamic_sections_created 2669 && !info->shared) 2670 { 2671 sec = bfd_get_section_by_name (dynobj, ".interp"); 2672 BFD_ASSERT (sec != NULL); 2673 sec->contents = (bfd_byte *) DYNAMIC_INTERPRETER (output_bfd); 2674 sec->_raw_size = strlen (DYNAMIC_INTERPRETER (output_bfd)) + 1; 2675 } 2676 2677 /* Allocate the GOT entries. */ 2678 2679 if (ia64_info->got_sec) 2680 { 2681 data.ofs = 0; 2682 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data); 2683 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data); 2684 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data); 2685 ia64_info->got_sec->_raw_size = data.ofs; 2686 } 2687 2688 /* Allocate the FPTR entries. */ 2689 2690 if (ia64_info->fptr_sec) 2691 { 2692 data.ofs = 0; 2693 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data); 2694 ia64_info->fptr_sec->_raw_size = data.ofs; 2695 } 2696 2697 /* Now that we've seen all of the input files, we can decide which 2698 symbols need plt entries. Allocate the minimal PLT entries first. 2699 We do this even though dynamic_sections_created may be false, because 2700 this has the side-effect of clearing want_plt and want_plt2. */ 2701 2702 data.ofs = 0; 2703 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data); 2704 2705 ia64_info->minplt_entries = 0; 2706 if (data.ofs) 2707 { 2708 ia64_info->minplt_entries 2709 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE; 2710 } 2711 2712 /* Align the pointer for the plt2 entries. */ 2713 data.ofs = (data.ofs + 31) & (bfd_vma) -32; 2714 2715 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data); 2716 if (data.ofs != 0) 2717 { 2718 BFD_ASSERT (ia64_info->root.dynamic_sections_created); 2719 2720 ia64_info->plt_sec->_raw_size = data.ofs; 2721 2722 /* If we've got a .plt, we need some extra memory for the dynamic 2723 linker. We stuff these in .got.plt. */ 2724 sec = bfd_get_section_by_name (dynobj, ".got.plt"); 2725 sec->_raw_size = 8 * PLT_RESERVED_WORDS; 2726 } 2727 2728 /* Allocate the PLTOFF entries. */ 2729 2730 if (ia64_info->pltoff_sec) 2731 { 2732 data.ofs = 0; 2733 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data); 2734 ia64_info->pltoff_sec->_raw_size = data.ofs; 2735 } 2736 2737 if (ia64_info->root.dynamic_sections_created) 2738 { 2739 /* Allocate space for the dynamic relocations that turned out to be 2740 required. */ 2741 2742 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data); 2743 } 2744 2745 /* We have now determined the sizes of the various dynamic sections. 2746 Allocate memory for them. */ 2747 for (sec = dynobj->sections; sec != NULL; sec = sec->next) 2748 { 2749 boolean strip; 2750 2751 if (!(sec->flags & SEC_LINKER_CREATED)) 2752 continue; 2753 2754 /* If we don't need this section, strip it from the output file. 2755 There were several sections primarily related to dynamic 2756 linking that must be create before the linker maps input 2757 sections to output sections. The linker does that before 2758 bfd_elf_size_dynamic_sections is called, and it is that 2759 function which decides whether anything needs to go into 2760 these sections. */ 2761 2762 strip = (sec->_raw_size == 0); 2763 2764 if (sec == ia64_info->got_sec) 2765 strip = false; 2766 else if (sec == ia64_info->rel_got_sec) 2767 { 2768 if (strip) 2769 ia64_info->rel_got_sec = NULL; 2770 else 2771 /* We use the reloc_count field as a counter if we need to 2772 copy relocs into the output file. */ 2773 sec->reloc_count = 0; 2774 } 2775 else if (sec == ia64_info->fptr_sec) 2776 { 2777 if (strip) 2778 ia64_info->fptr_sec = NULL; 2779 } 2780 else if (sec == ia64_info->plt_sec) 2781 { 2782 if (strip) 2783 ia64_info->plt_sec = NULL; 2784 } 2785 else if (sec == ia64_info->pltoff_sec) 2786 { 2787 if (strip) 2788 ia64_info->pltoff_sec = NULL; 2789 } 2790 else if (sec == ia64_info->rel_pltoff_sec) 2791 { 2792 if (strip) 2793 ia64_info->rel_pltoff_sec = NULL; 2794 else 2795 { 2796 relplt = true; 2797 /* We use the reloc_count field as a counter if we need to 2798 copy relocs into the output file. */ 2799 sec->reloc_count = 0; 2800 } 2801 } 2802 else 2803 { 2804 const char *name; 2805 2806 /* It's OK to base decisions on the section name, because none 2807 of the dynobj section names depend upon the input files. */ 2808 name = bfd_get_section_name (dynobj, sec); 2809 2810 if (strcmp (name, ".got.plt") == 0) 2811 strip = false; 2812 else if (strncmp (name, ".rel", 4) == 0) 2813 { 2814 if (!strip) 2815 { 2816 /* We use the reloc_count field as a counter if we need to 2817 copy relocs into the output file. */ 2818 sec->reloc_count = 0; 2819 } 2820 } 2821 else 2822 continue; 2823 } 2824 2825 if (strip) 2826 _bfd_strip_section_from_output (info, sec); 2827 else 2828 { 2829 /* Allocate memory for the section contents. */ 2830 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->_raw_size); 2831 if (sec->contents == NULL && sec->_raw_size != 0) 2832 return false; 2833 } 2834 } 2835 2836 if (elf_hash_table (info)->dynamic_sections_created) 2837 { 2838 /* Add some entries to the .dynamic section. We fill in the values 2839 later (in finish_dynamic_sections) but we must add the entries now 2840 so that we get the correct size for the .dynamic section. */ 2841 2842 if (!info->shared) 2843 { 2844 /* The DT_DEBUG entry is filled in by the dynamic linker and used 2845 by the debugger. */ 2846#define add_dynamic_entry(TAG, VAL) \ 2847 bfd_elfNN_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL)) 2848 2849 if (!add_dynamic_entry (DT_DEBUG, 0)) 2850 return false; 2851 } 2852 2853 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0)) 2854 return false; 2855 if (!add_dynamic_entry (DT_PLTGOT, 0)) 2856 return false; 2857 2858 if (relplt) 2859 { 2860 if (!add_dynamic_entry (DT_PLTRELSZ, 0) 2861 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 2862 || !add_dynamic_entry (DT_JMPREL, 0)) 2863 return false; 2864 } 2865 2866 if (!add_dynamic_entry (DT_RELA, 0) 2867 || !add_dynamic_entry (DT_RELASZ, 0) 2868 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela))) 2869 return false; 2870 2871 if (ia64_info->reltext) 2872 { 2873 if (!add_dynamic_entry (DT_TEXTREL, 0)) 2874 return false; 2875 info->flags |= DF_TEXTREL; 2876 } 2877 } 2878 2879 /* ??? Perhaps force __gp local. */ 2880 2881 return true; 2882} 2883 2884static bfd_reloc_status_type 2885elfNN_ia64_install_value (abfd, hit_addr, v, r_type) 2886 bfd *abfd; 2887 bfd_byte *hit_addr; 2888 bfd_vma v; 2889 unsigned int r_type; 2890{ 2891 const struct ia64_operand *op; 2892 int bigendian = 0, shift = 0; 2893 bfd_vma t0, t1, insn, dword; 2894 enum ia64_opnd opnd; 2895 const char *err; 2896 size_t size = 8; 2897#ifdef BFD_HOST_U_64_BIT 2898 BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v; 2899#else 2900 bfd_vma val = v; 2901#endif 2902 2903 opnd = IA64_OPND_NIL; 2904 switch (r_type) 2905 { 2906 case R_IA64_NONE: 2907 case R_IA64_LDXMOV: 2908 return bfd_reloc_ok; 2909 2910 /* Instruction relocations. */ 2911 2912 case R_IA64_IMM14: opnd = IA64_OPND_IMM14; break; 2913 2914 case R_IA64_PCREL21F: opnd = IA64_OPND_TGT25; break; 2915 case R_IA64_PCREL21M: opnd = IA64_OPND_TGT25b; break; 2916 case R_IA64_PCREL60B: opnd = IA64_OPND_TGT64; break; 2917 case R_IA64_PCREL21B: 2918 case R_IA64_PCREL21BI: 2919 opnd = IA64_OPND_TGT25c; 2920 break; 2921 2922 case R_IA64_IMM22: 2923 case R_IA64_GPREL22: 2924 case R_IA64_LTOFF22: 2925 case R_IA64_LTOFF22X: 2926 case R_IA64_PLTOFF22: 2927 case R_IA64_PCREL22: 2928 case R_IA64_LTOFF_FPTR22: 2929 opnd = IA64_OPND_IMM22; 2930 break; 2931 2932 case R_IA64_IMM64: 2933 case R_IA64_GPREL64I: 2934 case R_IA64_LTOFF64I: 2935 case R_IA64_PLTOFF64I: 2936 case R_IA64_PCREL64I: 2937 case R_IA64_FPTR64I: 2938 case R_IA64_LTOFF_FPTR64I: 2939 opnd = IA64_OPND_IMMU64; 2940 break; 2941 2942 /* Data relocations. */ 2943 2944 case R_IA64_DIR32MSB: 2945 case R_IA64_GPREL32MSB: 2946 case R_IA64_FPTR32MSB: 2947 case R_IA64_PCREL32MSB: 2948 case R_IA64_LTOFF_FPTR32MSB: 2949 case R_IA64_SEGREL32MSB: 2950 case R_IA64_SECREL32MSB: 2951 case R_IA64_LTV32MSB: 2952 size = 4; bigendian = 1; 2953 break; 2954 2955 case R_IA64_DIR32LSB: 2956 case R_IA64_GPREL32LSB: 2957 case R_IA64_FPTR32LSB: 2958 case R_IA64_PCREL32LSB: 2959 case R_IA64_LTOFF_FPTR32LSB: 2960 case R_IA64_SEGREL32LSB: 2961 case R_IA64_SECREL32LSB: 2962 case R_IA64_LTV32LSB: 2963 size = 4; bigendian = 0; 2964 break; 2965 2966 case R_IA64_DIR64MSB: 2967 case R_IA64_GPREL64MSB: 2968 case R_IA64_PLTOFF64MSB: 2969 case R_IA64_FPTR64MSB: 2970 case R_IA64_PCREL64MSB: 2971 case R_IA64_LTOFF_FPTR64MSB: 2972 case R_IA64_SEGREL64MSB: 2973 case R_IA64_SECREL64MSB: 2974 case R_IA64_LTV64MSB: 2975 size = 8; bigendian = 1; 2976 break; 2977 2978 case R_IA64_DIR64LSB: 2979 case R_IA64_GPREL64LSB: 2980 case R_IA64_PLTOFF64LSB: 2981 case R_IA64_FPTR64LSB: 2982 case R_IA64_PCREL64LSB: 2983 case R_IA64_LTOFF_FPTR64LSB: 2984 case R_IA64_SEGREL64LSB: 2985 case R_IA64_SECREL64LSB: 2986 case R_IA64_LTV64LSB: 2987 size = 8; bigendian = 0; 2988 break; 2989 2990 /* Unsupported / Dynamic relocations. */ 2991 default: 2992 return bfd_reloc_notsupported; 2993 } 2994 2995 switch (opnd) 2996 { 2997 case IA64_OPND_IMMU64: 2998 hit_addr -= (long) hit_addr & 0x3; 2999 t0 = bfd_get_64 (abfd, hit_addr); 3000 t1 = bfd_get_64 (abfd, hit_addr + 8); 3001 3002 /* tmpl/s: bits 0.. 5 in t0 3003 slot 0: bits 5..45 in t0 3004 slot 1: bits 46..63 in t0, bits 0..22 in t1 3005 slot 2: bits 23..63 in t1 */ 3006 3007 /* First, clear the bits that form the 64 bit constant. */ 3008 t0 &= ~(0x3ffffLL << 46); 3009 t1 &= ~(0x7fffffLL 3010 | (( (0x07fLL << 13) | (0x1ffLL << 27) 3011 | (0x01fLL << 22) | (0x001LL << 21) 3012 | (0x001LL << 36)) << 23)); 3013 3014 t0 |= ((val >> 22) & 0x03ffffLL) << 46; /* 18 lsbs of imm41 */ 3015 t1 |= ((val >> 40) & 0x7fffffLL) << 0; /* 23 msbs of imm41 */ 3016 t1 |= ( (((val >> 0) & 0x07f) << 13) /* imm7b */ 3017 | (((val >> 7) & 0x1ff) << 27) /* imm9d */ 3018 | (((val >> 16) & 0x01f) << 22) /* imm5c */ 3019 | (((val >> 21) & 0x001) << 21) /* ic */ 3020 | (((val >> 63) & 0x001) << 36)) << 23; /* i */ 3021 3022 bfd_put_64 (abfd, t0, hit_addr); 3023 bfd_put_64 (abfd, t1, hit_addr + 8); 3024 break; 3025 3026 case IA64_OPND_TGT64: 3027 hit_addr -= (long) hit_addr & 0x3; 3028 t0 = bfd_get_64 (abfd, hit_addr); 3029 t1 = bfd_get_64 (abfd, hit_addr + 8); 3030 3031 /* tmpl/s: bits 0.. 5 in t0 3032 slot 0: bits 5..45 in t0 3033 slot 1: bits 46..63 in t0, bits 0..22 in t1 3034 slot 2: bits 23..63 in t1 */ 3035 3036 /* First, clear the bits that form the 64 bit constant. */ 3037 t0 &= ~(0x3ffffLL << 46); 3038 t1 &= ~(0x7fffffLL 3039 | ((1LL << 36 | 0xfffffLL << 13) << 23)); 3040 3041 val >>= 4; 3042 t0 |= ((val >> 20) & 0xffffLL) << 2 << 46; /* 16 lsbs of imm39 */ 3043 t1 |= ((val >> 36) & 0x7fffffLL) << 0; /* 23 msbs of imm39 */ 3044 t1 |= ((((val >> 0) & 0xfffffLL) << 13) /* imm20b */ 3045 | (((val >> 59) & 0x1LL) << 36)) << 23; /* i */ 3046 3047 bfd_put_64 (abfd, t0, hit_addr); 3048 bfd_put_64 (abfd, t1, hit_addr + 8); 3049 break; 3050 3051 default: 3052 switch ((long) hit_addr & 0x3) 3053 { 3054 case 0: shift = 5; break; 3055 case 1: shift = 14; hit_addr += 3; break; 3056 case 2: shift = 23; hit_addr += 6; break; 3057 case 3: return bfd_reloc_notsupported; /* shouldn't happen... */ 3058 } 3059 dword = bfd_get_64 (abfd, hit_addr); 3060 insn = (dword >> shift) & 0x1ffffffffffLL; 3061 3062 op = elf64_ia64_operands + opnd; 3063 err = (*op->insert) (op, val, (ia64_insn *)& insn); 3064 if (err) 3065 return bfd_reloc_overflow; 3066 3067 dword &= ~(0x1ffffffffffLL << shift); 3068 dword |= (insn << shift); 3069 bfd_put_64 (abfd, dword, hit_addr); 3070 break; 3071 3072 case IA64_OPND_NIL: 3073 /* A data relocation. */ 3074 if (bigendian) 3075 if (size == 4) 3076 bfd_putb32 (val, hit_addr); 3077 else 3078 bfd_putb64 (val, hit_addr); 3079 else 3080 if (size == 4) 3081 bfd_putl32 (val, hit_addr); 3082 else 3083 bfd_putl64 (val, hit_addr); 3084 break; 3085 } 3086 3087 return bfd_reloc_ok; 3088} 3089 3090static void 3091elfNN_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type, 3092 dynindx, addend) 3093 bfd *abfd; 3094 struct bfd_link_info *info; 3095 asection *sec; 3096 asection *srel; 3097 bfd_vma offset; 3098 unsigned int type; 3099 long dynindx; 3100 bfd_vma addend; 3101{ 3102 Elf_Internal_Rela outrel; 3103 3104 offset += sec->output_section->vma + sec->output_offset; 3105 3106 BFD_ASSERT (dynindx != -1); 3107 outrel.r_info = ELFNN_R_INFO (dynindx, type); 3108 outrel.r_addend = addend; 3109 outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset); 3110 if ((outrel.r_offset | 1) == (bfd_vma) -1) 3111 { 3112 /* Run for the hills. We shouldn't be outputting a relocation 3113 for this. So do what everyone else does and output a no-op. */ 3114 outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE); 3115 outrel.r_addend = 0; 3116 outrel.r_offset = 0; 3117 } 3118 3119 bfd_elfNN_swap_reloca_out (abfd, &outrel, 3120 ((ElfNN_External_Rela *) srel->contents 3121 + srel->reloc_count++)); 3122 BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count 3123 <= srel->_cooked_size); 3124} 3125 3126/* Store an entry for target address TARGET_ADDR in the linkage table 3127 and return the gp-relative address of the linkage table entry. */ 3128 3129static bfd_vma 3130set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type) 3131 bfd *abfd; 3132 struct bfd_link_info *info; 3133 struct elfNN_ia64_dyn_sym_info *dyn_i; 3134 long dynindx; 3135 bfd_vma addend; 3136 bfd_vma value; 3137 unsigned int dyn_r_type; 3138{ 3139 struct elfNN_ia64_link_hash_table *ia64_info; 3140 asection *got_sec; 3141 3142 ia64_info = elfNN_ia64_hash_table (info); 3143 got_sec = ia64_info->got_sec; 3144 3145 BFD_ASSERT ((dyn_i->got_offset & 7) == 0); 3146 3147 if (! dyn_i->got_done) 3148 { 3149 dyn_i->got_done = true; 3150 3151 /* Store the target address in the linkage table entry. */ 3152 bfd_put_64 (abfd, value, got_sec->contents + dyn_i->got_offset); 3153 3154 /* Install a dynamic relocation if needed. */ 3155 if (info->shared 3156 || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info) 3157 || elfNN_ia64_aix_vec (abfd->xvec) 3158 || (dynindx != -1 && dyn_r_type == R_IA64_FPTR64LSB)) 3159 { 3160 if (dynindx == -1) 3161 { 3162 dyn_r_type = R_IA64_REL64LSB; 3163 dynindx = 0; 3164 addend = value; 3165 } 3166 3167 if (bfd_big_endian (abfd)) 3168 { 3169 switch (dyn_r_type) 3170 { 3171 case R_IA64_REL64LSB: 3172 dyn_r_type = R_IA64_REL64MSB; 3173 break; 3174 case R_IA64_DIR64LSB: 3175 dyn_r_type = R_IA64_DIR64MSB; 3176 break; 3177 case R_IA64_FPTR64LSB: 3178 dyn_r_type = R_IA64_FPTR64MSB; 3179 break; 3180 default: 3181 BFD_ASSERT (false); 3182 break; 3183 } 3184 } 3185 3186 elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec, 3187 ia64_info->rel_got_sec, 3188 dyn_i->got_offset, dyn_r_type, 3189 dynindx, addend); 3190 } 3191 } 3192 3193 /* Return the address of the linkage table entry. */ 3194 value = (got_sec->output_section->vma 3195 + got_sec->output_offset 3196 + dyn_i->got_offset); 3197 3198 return value; 3199} 3200 3201/* Fill in a function descriptor consisting of the function's code 3202 address and its global pointer. Return the descriptor's address. */ 3203 3204static bfd_vma 3205set_fptr_entry (abfd, info, dyn_i, value) 3206 bfd *abfd; 3207 struct bfd_link_info *info; 3208 struct elfNN_ia64_dyn_sym_info *dyn_i; 3209 bfd_vma value; 3210{ 3211 struct elfNN_ia64_link_hash_table *ia64_info; 3212 asection *fptr_sec; 3213 3214 ia64_info = elfNN_ia64_hash_table (info); 3215 fptr_sec = ia64_info->fptr_sec; 3216 3217 if (!dyn_i->fptr_done) 3218 { 3219 dyn_i->fptr_done = 1; 3220 3221 /* Fill in the function descriptor. */ 3222 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset); 3223 bfd_put_64 (abfd, _bfd_get_gp_value (abfd), 3224 fptr_sec->contents + dyn_i->fptr_offset + 8); 3225 } 3226 3227 /* Return the descriptor's address. */ 3228 value = (fptr_sec->output_section->vma 3229 + fptr_sec->output_offset 3230 + dyn_i->fptr_offset); 3231 3232 return value; 3233} 3234 3235/* Fill in a PLTOFF entry consisting of the function's code address 3236 and its global pointer. Return the descriptor's address. */ 3237 3238static bfd_vma 3239set_pltoff_entry (abfd, info, dyn_i, value, is_plt) 3240 bfd *abfd; 3241 struct bfd_link_info *info; 3242 struct elfNN_ia64_dyn_sym_info *dyn_i; 3243 bfd_vma value; 3244 boolean is_plt; 3245{ 3246 struct elfNN_ia64_link_hash_table *ia64_info; 3247 asection *pltoff_sec; 3248 3249 ia64_info = elfNN_ia64_hash_table (info); 3250 pltoff_sec = ia64_info->pltoff_sec; 3251 3252 /* Don't do anything if this symbol uses a real PLT entry. In 3253 that case, we'll fill this in during finish_dynamic_symbol. */ 3254 if ((! dyn_i->want_plt || is_plt) 3255 && !dyn_i->pltoff_done) 3256 { 3257 bfd_vma gp = _bfd_get_gp_value (abfd); 3258 3259 /* Fill in the function descriptor. */ 3260 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset); 3261 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8); 3262 3263 /* Install dynamic relocations if needed. */ 3264 if (!is_plt && info->shared) 3265 { 3266 unsigned int dyn_r_type; 3267 3268 if (bfd_big_endian (abfd)) 3269 dyn_r_type = R_IA64_REL64MSB; 3270 else 3271 dyn_r_type = R_IA64_REL64LSB; 3272 3273 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec, 3274 ia64_info->rel_pltoff_sec, 3275 dyn_i->pltoff_offset, 3276 dyn_r_type, 0, value); 3277 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec, 3278 ia64_info->rel_pltoff_sec, 3279 dyn_i->pltoff_offset + 8, 3280 dyn_r_type, 0, gp); 3281 } 3282 3283 dyn_i->pltoff_done = 1; 3284 } 3285 3286 /* Return the descriptor's address. */ 3287 value = (pltoff_sec->output_section->vma 3288 + pltoff_sec->output_offset 3289 + dyn_i->pltoff_offset); 3290 3291 return value; 3292} 3293 3294/* Called through qsort to sort the .IA_64.unwind section during a 3295 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd 3296 to the output bfd so we can do proper endianness frobbing. */ 3297 3298static bfd *elfNN_ia64_unwind_entry_compare_bfd; 3299 3300static int 3301elfNN_ia64_unwind_entry_compare (a, b) 3302 const PTR a; 3303 const PTR b; 3304{ 3305 bfd_vma av, bv; 3306 3307 av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a); 3308 bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b); 3309 3310 return (av < bv ? -1 : av > bv ? 1 : 0); 3311} 3312 3313static boolean 3314elfNN_ia64_final_link (abfd, info) 3315 bfd *abfd; 3316 struct bfd_link_info *info; 3317{ 3318 struct elfNN_ia64_link_hash_table *ia64_info; 3319 asection *unwind_output_sec; 3320 3321 ia64_info = elfNN_ia64_hash_table (info); 3322 3323 /* Make sure we've got ourselves a nice fat __gp value. */ 3324 if (!info->relocateable) 3325 { 3326 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0; 3327 bfd_vma min_short_vma = min_vma, max_short_vma = 0; 3328 struct elf_link_hash_entry *gp; 3329 bfd_vma gp_val; 3330 asection *os; 3331 3332 /* Find the min and max vma of all sections marked short. Also 3333 collect min and max vma of any type, for use in selecting a 3334 nice gp. */ 3335 for (os = abfd->sections; os ; os = os->next) 3336 { 3337 bfd_vma lo, hi; 3338 3339 if ((os->flags & SEC_ALLOC) == 0) 3340 continue; 3341 3342 lo = os->vma; 3343 hi = os->vma + os->_raw_size; 3344 if (hi < lo) 3345 hi = (bfd_vma) -1; 3346 3347 if (min_vma > lo) 3348 min_vma = lo; 3349 if (max_vma < hi) 3350 max_vma = hi; 3351 if (os->flags & SEC_SMALL_DATA) 3352 { 3353 if (min_short_vma > lo) 3354 min_short_vma = lo; 3355 if (max_short_vma < hi) 3356 max_short_vma = hi; 3357 } 3358 } 3359 3360 /* See if the user wants to force a value. */ 3361 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false, 3362 false, false); 3363 3364 if (gp 3365 && (gp->root.type == bfd_link_hash_defined 3366 || gp->root.type == bfd_link_hash_defweak)) 3367 { 3368 asection *gp_sec = gp->root.u.def.section; 3369 gp_val = (gp->root.u.def.value 3370 + gp_sec->output_section->vma 3371 + gp_sec->output_offset); 3372 } 3373 else 3374 { 3375 /* Pick a sensible value. */ 3376 3377 asection *got_sec = ia64_info->got_sec; 3378 3379 /* Start with just the address of the .got. */ 3380 if (got_sec) 3381 gp_val = got_sec->output_section->vma; 3382 else if (max_short_vma != 0) 3383 gp_val = min_short_vma; 3384 else 3385 gp_val = min_vma; 3386 3387 /* If it is possible to address the entire image, but we 3388 don't with the choice above, adjust. */ 3389 if (max_vma - min_vma < 0x400000 3390 && max_vma - gp_val <= 0x200000 3391 && gp_val - min_vma > 0x200000) 3392 gp_val = min_vma + 0x200000; 3393 else if (max_short_vma != 0) 3394 { 3395 /* If we don't cover all the short data, adjust. */ 3396 if (max_short_vma - gp_val >= 0x200000) 3397 gp_val = min_short_vma + 0x200000; 3398 3399 /* If we're addressing stuff past the end, adjust back. */ 3400 if (gp_val > max_vma) 3401 gp_val = max_vma - 0x200000 + 8; 3402 } 3403 } 3404 3405 /* Validate whether all SHF_IA_64_SHORT sections are within 3406 range of the chosen GP. */ 3407 3408 if (max_short_vma != 0) 3409 { 3410 if (max_short_vma - min_short_vma >= 0x400000) 3411 { 3412 (*_bfd_error_handler) 3413 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"), 3414 bfd_get_filename (abfd), 3415 (unsigned long) (max_short_vma - min_short_vma)); 3416 return false; 3417 } 3418 else if ((gp_val > min_short_vma 3419 && gp_val - min_short_vma > 0x200000) 3420 || (gp_val < max_short_vma 3421 && max_short_vma - gp_val >= 0x200000)) 3422 { 3423 (*_bfd_error_handler) 3424 (_("%s: __gp does not cover short data segment"), 3425 bfd_get_filename (abfd)); 3426 return false; 3427 } 3428 } 3429 3430 _bfd_set_gp_value (abfd, gp_val); 3431 3432 if (gp) 3433 { 3434 gp->root.type = bfd_link_hash_defined; 3435 gp->root.u.def.value = gp_val; 3436 gp->root.u.def.section = bfd_abs_section_ptr; 3437 } 3438 } 3439 3440 /* If we're producing a final executable, we need to sort the contents 3441 of the .IA_64.unwind section. Force this section to be relocated 3442 into memory rather than written immediately to the output file. */ 3443 unwind_output_sec = NULL; 3444 if (!info->relocateable) 3445 { 3446 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind); 3447 if (s) 3448 { 3449 unwind_output_sec = s->output_section; 3450 unwind_output_sec->contents 3451 = bfd_malloc (unwind_output_sec->_raw_size); 3452 if (unwind_output_sec->contents == NULL) 3453 return false; 3454 } 3455 } 3456 3457 /* Invoke the regular ELF backend linker to do all the work. */ 3458 if (!bfd_elfNN_bfd_final_link (abfd, info)) 3459 return false; 3460 3461 if (unwind_output_sec) 3462 { 3463 elfNN_ia64_unwind_entry_compare_bfd = abfd; 3464 qsort (unwind_output_sec->contents, 3465 (size_t) (unwind_output_sec->_raw_size / 24), 3466 24, 3467 elfNN_ia64_unwind_entry_compare); 3468 3469 if (! bfd_set_section_contents (abfd, unwind_output_sec, 3470 unwind_output_sec->contents, (bfd_vma) 0, 3471 unwind_output_sec->_raw_size)) 3472 return false; 3473 } 3474 3475 return true; 3476} 3477 3478static boolean 3479elfNN_ia64_relocate_section (output_bfd, info, input_bfd, input_section, 3480 contents, relocs, local_syms, local_sections) 3481 bfd *output_bfd; 3482 struct bfd_link_info *info; 3483 bfd *input_bfd; 3484 asection *input_section; 3485 bfd_byte *contents; 3486 Elf_Internal_Rela *relocs; 3487 Elf_Internal_Sym *local_syms; 3488 asection **local_sections; 3489{ 3490 struct elfNN_ia64_link_hash_table *ia64_info; 3491 Elf_Internal_Shdr *symtab_hdr; 3492 Elf_Internal_Rela *rel; 3493 Elf_Internal_Rela *relend; 3494 asection *srel; 3495 boolean ret_val = true; /* for non-fatal errors */ 3496 bfd_vma gp_val; 3497 3498 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3499 ia64_info = elfNN_ia64_hash_table (info); 3500 3501 /* Infect various flags from the input section to the output section. */ 3502 if (info->relocateable) 3503 { 3504 bfd_vma flags; 3505 3506 flags = elf_section_data(input_section)->this_hdr.sh_flags; 3507 flags &= SHF_IA_64_NORECOV; 3508 3509 elf_section_data(input_section->output_section) 3510 ->this_hdr.sh_flags |= flags; 3511 } 3512 3513 gp_val = _bfd_get_gp_value (output_bfd); 3514 srel = get_reloc_section (input_bfd, ia64_info, input_section, false); 3515 3516 rel = relocs; 3517 relend = relocs + input_section->reloc_count; 3518 for (; rel < relend; ++rel) 3519 { 3520 struct elf_link_hash_entry *h; 3521 struct elfNN_ia64_dyn_sym_info *dyn_i; 3522 bfd_reloc_status_type r; 3523 reloc_howto_type *howto; 3524 unsigned long r_symndx; 3525 Elf_Internal_Sym *sym; 3526 unsigned int r_type; 3527 bfd_vma value; 3528 asection *sym_sec; 3529 bfd_byte *hit_addr; 3530 boolean dynamic_symbol_p; 3531 boolean undef_weak_ref; 3532 3533 r_type = ELFNN_R_TYPE (rel->r_info); 3534 if (r_type > R_IA64_MAX_RELOC_CODE) 3535 { 3536 (*_bfd_error_handler) 3537 (_("%s: unknown relocation type %d"), 3538 bfd_archive_filename (input_bfd), (int)r_type); 3539 bfd_set_error (bfd_error_bad_value); 3540 ret_val = false; 3541 continue; 3542 } 3543 howto = lookup_howto (r_type); 3544 r_symndx = ELFNN_R_SYM (rel->r_info); 3545 3546 if (info->relocateable) 3547 { 3548 /* This is a relocateable link. We don't have to change 3549 anything, unless the reloc is against a section symbol, 3550 in which case we have to adjust according to where the 3551 section symbol winds up in the output section. */ 3552 if (r_symndx < symtab_hdr->sh_info) 3553 { 3554 sym = local_syms + r_symndx; 3555 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 3556 { 3557 sym_sec = local_sections[r_symndx]; 3558 rel->r_addend += sym_sec->output_offset; 3559 } 3560 } 3561 continue; 3562 } 3563 3564 /* This is a final link. */ 3565 3566 h = NULL; 3567 sym = NULL; 3568 sym_sec = NULL; 3569 undef_weak_ref = false; 3570 3571 if (r_symndx < symtab_hdr->sh_info) 3572 { 3573 /* Reloc against local symbol. */ 3574 sym = local_syms + r_symndx; 3575 sym_sec = local_sections[r_symndx]; 3576 value = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel); 3577 if ((sym_sec->flags & SEC_MERGE) 3578 && ELF_ST_TYPE (sym->st_info) == STT_SECTION 3579 && (elf_section_data (sym_sec)->sec_info_type 3580 == ELF_INFO_TYPE_MERGE)) 3581 { 3582 struct elfNN_ia64_local_hash_entry *loc_h; 3583 3584 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, false); 3585 if (loc_h && ! loc_h->sec_merge_done) 3586 { 3587 struct elfNN_ia64_dyn_sym_info *dynent; 3588 asection *msec; 3589 3590 for (dynent = loc_h->info; dynent; dynent = dynent->next) 3591 { 3592 msec = sym_sec; 3593 dynent->addend = 3594 _bfd_merged_section_offset (output_bfd, &msec, 3595 elf_section_data (msec)-> 3596 sec_info, 3597 sym->st_value 3598 + dynent->addend, 3599 (bfd_vma) 0); 3600 dynent->addend -= sym->st_value; 3601 dynent->addend += msec->output_section->vma 3602 + msec->output_offset 3603 - sym_sec->output_section->vma 3604 - sym_sec->output_offset; 3605 } 3606 loc_h->sec_merge_done = 1; 3607 } 3608 } 3609 } 3610 else 3611 { 3612 long indx; 3613 3614 /* Reloc against global symbol. */ 3615 indx = r_symndx - symtab_hdr->sh_info; 3616 h = elf_sym_hashes (input_bfd)[indx]; 3617 while (h->root.type == bfd_link_hash_indirect 3618 || h->root.type == bfd_link_hash_warning) 3619 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3620 3621 value = 0; 3622 if (h->root.type == bfd_link_hash_defined 3623 || h->root.type == bfd_link_hash_defweak) 3624 { 3625 sym_sec = h->root.u.def.section; 3626 3627 /* Detect the cases that sym_sec->output_section is 3628 expected to be NULL -- all cases in which the symbol 3629 is defined in another shared module. This includes 3630 PLT relocs for which we've created a PLT entry and 3631 other relocs for which we're prepared to create 3632 dynamic relocations. */ 3633 /* ??? Just accept it NULL and continue. */ 3634 3635 if (sym_sec->output_section != NULL) 3636 { 3637 value = (h->root.u.def.value 3638 + sym_sec->output_section->vma 3639 + sym_sec->output_offset); 3640 } 3641 } 3642 else if (h->root.type == bfd_link_hash_undefweak) 3643 undef_weak_ref = true; 3644 else if (info->shared 3645 && (!info->symbolic || info->allow_shlib_undefined) 3646 && !info->no_undefined 3647 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 3648 ; 3649 else 3650 { 3651 if (! ((*info->callbacks->undefined_symbol) 3652 (info, h->root.root.string, input_bfd, 3653 input_section, rel->r_offset, 3654 (!info->shared || info->no_undefined 3655 || ELF_ST_VISIBILITY (h->other))))) 3656 return false; 3657 ret_val = false; 3658 continue; 3659 } 3660 } 3661 3662 hit_addr = contents + rel->r_offset; 3663 value += rel->r_addend; 3664 dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info); 3665 3666 switch (r_type) 3667 { 3668 case R_IA64_NONE: 3669 case R_IA64_LDXMOV: 3670 continue; 3671 3672 case R_IA64_IMM14: 3673 case R_IA64_IMM22: 3674 case R_IA64_IMM64: 3675 case R_IA64_DIR32MSB: 3676 case R_IA64_DIR32LSB: 3677 case R_IA64_DIR64MSB: 3678 case R_IA64_DIR64LSB: 3679 /* Install a dynamic relocation for this reloc. */ 3680 if ((dynamic_symbol_p || info->shared 3681 || (elfNN_ia64_aix_vec (info->hash->creator) 3682 /* Don't emit relocs for __GLOB_DATA_PTR on AIX. */ 3683 && (!h || strcmp (h->root.root.string, 3684 "__GLOB_DATA_PTR") != 0))) 3685 && r_symndx != 0 3686 && (input_section->flags & SEC_ALLOC) != 0) 3687 { 3688 unsigned int dyn_r_type; 3689 long dynindx; 3690 bfd_vma addend; 3691 3692 BFD_ASSERT (srel != NULL); 3693 3694 /* If we don't need dynamic symbol lookup, find a 3695 matching RELATIVE relocation. */ 3696 dyn_r_type = r_type; 3697 if (dynamic_symbol_p) 3698 { 3699 dynindx = h->dynindx; 3700 addend = rel->r_addend; 3701 value = 0; 3702 } 3703 else 3704 { 3705 switch (r_type) 3706 { 3707 case R_IA64_DIR32MSB: 3708 dyn_r_type = R_IA64_REL32MSB; 3709 break; 3710 case R_IA64_DIR32LSB: 3711 dyn_r_type = R_IA64_REL32LSB; 3712 break; 3713 case R_IA64_DIR64MSB: 3714 dyn_r_type = R_IA64_REL64MSB; 3715 break; 3716 case R_IA64_DIR64LSB: 3717 dyn_r_type = R_IA64_REL64LSB; 3718 break; 3719 3720 default: 3721 /* We can't represent this without a dynamic symbol. 3722 Adjust the relocation to be against an output 3723 section symbol, which are always present in the 3724 dynamic symbol table. */ 3725 /* ??? People shouldn't be doing non-pic code in 3726 shared libraries. Hork. */ 3727 (*_bfd_error_handler) 3728 (_("%s: linking non-pic code in a shared library"), 3729 bfd_archive_filename (input_bfd)); 3730 ret_val = false; 3731 continue; 3732 } 3733 dynindx = 0; 3734 addend = value; 3735 } 3736 3737 if (elfNN_ia64_aix_vec (info->hash->creator)) 3738 rel->r_addend = value; 3739 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section, 3740 srel, rel->r_offset, dyn_r_type, 3741 dynindx, addend); 3742 } 3743 /* FALLTHRU */ 3744 3745 case R_IA64_LTV32MSB: 3746 case R_IA64_LTV32LSB: 3747 case R_IA64_LTV64MSB: 3748 case R_IA64_LTV64LSB: 3749 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type); 3750 break; 3751 3752 case R_IA64_GPREL22: 3753 case R_IA64_GPREL64I: 3754 case R_IA64_GPREL32MSB: 3755 case R_IA64_GPREL32LSB: 3756 case R_IA64_GPREL64MSB: 3757 case R_IA64_GPREL64LSB: 3758 if (dynamic_symbol_p) 3759 { 3760 (*_bfd_error_handler) 3761 (_("%s: @gprel relocation against dynamic symbol %s"), 3762 bfd_archive_filename (input_bfd), h->root.root.string); 3763 ret_val = false; 3764 continue; 3765 } 3766 value -= gp_val; 3767 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type); 3768 break; 3769 3770 case R_IA64_LTOFF22: 3771 case R_IA64_LTOFF22X: 3772 case R_IA64_LTOFF64I: 3773 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 3774 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1), 3775 rel->r_addend, value, R_IA64_DIR64LSB); 3776 value -= gp_val; 3777 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type); 3778 break; 3779 3780 case R_IA64_PLTOFF22: 3781 case R_IA64_PLTOFF64I: 3782 case R_IA64_PLTOFF64MSB: 3783 case R_IA64_PLTOFF64LSB: 3784 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 3785 value = set_pltoff_entry (output_bfd, info, dyn_i, value, false); 3786 value -= gp_val; 3787 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type); 3788 break; 3789 3790 case R_IA64_FPTR64I: 3791 case R_IA64_FPTR32MSB: 3792 case R_IA64_FPTR32LSB: 3793 case R_IA64_FPTR64MSB: 3794 case R_IA64_FPTR64LSB: 3795 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 3796 if (dyn_i->want_fptr) 3797 { 3798 if (!undef_weak_ref) 3799 value = set_fptr_entry (output_bfd, info, dyn_i, value); 3800 } 3801 else 3802 { 3803 long dynindx; 3804 3805 /* Otherwise, we expect the dynamic linker to create 3806 the entry. */ 3807 3808 if (h) 3809 { 3810 if (h->dynindx != -1) 3811 dynindx = h->dynindx; 3812 else 3813 dynindx = (_bfd_elf_link_lookup_local_dynindx 3814 (info, h->root.u.def.section->owner, 3815 global_sym_index (h))); 3816 } 3817 else 3818 { 3819 dynindx = (_bfd_elf_link_lookup_local_dynindx 3820 (info, input_bfd, (long) r_symndx)); 3821 } 3822 3823 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section, 3824 srel, rel->r_offset, r_type, 3825 dynindx, rel->r_addend); 3826 value = 0; 3827 } 3828 3829 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type); 3830 break; 3831 3832 case R_IA64_LTOFF_FPTR22: 3833 case R_IA64_LTOFF_FPTR64I: 3834 case R_IA64_LTOFF_FPTR32MSB: 3835 case R_IA64_LTOFF_FPTR32LSB: 3836 case R_IA64_LTOFF_FPTR64MSB: 3837 case R_IA64_LTOFF_FPTR64LSB: 3838 { 3839 long dynindx; 3840 3841 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false); 3842 if (dyn_i->want_fptr) 3843 { 3844 BFD_ASSERT (h == NULL || h->dynindx == -1) 3845 if (!undef_weak_ref) 3846 value = set_fptr_entry (output_bfd, info, dyn_i, value); 3847 dynindx = -1; 3848 } 3849 else 3850 { 3851 /* Otherwise, we expect the dynamic linker to create 3852 the entry. */ 3853 if (h) 3854 { 3855 if (h->dynindx != -1) 3856 dynindx = h->dynindx; 3857 else 3858 dynindx = (_bfd_elf_link_lookup_local_dynindx 3859 (info, h->root.u.def.section->owner, 3860 global_sym_index (h))); 3861 } 3862 else 3863 dynindx = (_bfd_elf_link_lookup_local_dynindx 3864 (info, input_bfd, (long) r_symndx)); 3865 value = 0; 3866 } 3867 3868 value = set_got_entry (output_bfd, info, dyn_i, dynindx, 3869 rel->r_addend, value, R_IA64_FPTR64LSB); 3870 value -= gp_val; 3871 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type); 3872 } 3873 break; 3874 3875 case R_IA64_PCREL32MSB: 3876 case R_IA64_PCREL32LSB: 3877 case R_IA64_PCREL64MSB: 3878 case R_IA64_PCREL64LSB: 3879 /* Install a dynamic relocation for this reloc. */ 3880 if ((dynamic_symbol_p 3881 || elfNN_ia64_aix_vec (info->hash->creator)) 3882 && r_symndx != 0) 3883 { 3884 BFD_ASSERT (srel != NULL); 3885 3886 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section, 3887 srel, rel->r_offset, r_type, 3888 h->dynindx, rel->r_addend); 3889 } 3890 goto finish_pcrel; 3891 3892 case R_IA64_PCREL21BI: 3893 case R_IA64_PCREL21F: 3894 case R_IA64_PCREL21M: 3895 /* ??? These two are only used for speculation fixup code. 3896 They should never be dynamic. */ 3897 if (dynamic_symbol_p) 3898 { 3899 (*_bfd_error_handler) 3900 (_("%s: dynamic relocation against speculation fixup"), 3901 bfd_archive_filename (input_bfd)); 3902 ret_val = false; 3903 continue; 3904 } 3905 if (undef_weak_ref) 3906 { 3907 (*_bfd_error_handler) 3908 (_("%s: speculation fixup against undefined weak symbol"), 3909 bfd_archive_filename (input_bfd)); 3910 ret_val = false; 3911 continue; 3912 } 3913 goto finish_pcrel; 3914 3915 case R_IA64_PCREL21B: 3916 case R_IA64_PCREL60B: 3917 /* We should have created a PLT entry for any dynamic symbol. */ 3918 dyn_i = NULL; 3919 if (h) 3920 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false); 3921 3922 if (dyn_i && dyn_i->want_plt2) 3923 { 3924 /* Should have caught this earlier. */ 3925 BFD_ASSERT (rel->r_addend == 0); 3926 3927 value = (ia64_info->plt_sec->output_section->vma 3928 + ia64_info->plt_sec->output_offset 3929 + dyn_i->plt2_offset); 3930 } 3931 else 3932 { 3933 /* Since there's no PLT entry, Validate that this is 3934 locally defined. */ 3935 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL); 3936 3937 /* If the symbol is undef_weak, we shouldn't be trying 3938 to call it. There's every chance that we'd wind up 3939 with an out-of-range fixup here. Don't bother setting 3940 any value at all. */ 3941 if (undef_weak_ref) 3942 continue; 3943 } 3944 goto finish_pcrel; 3945 3946 case R_IA64_PCREL22: 3947 case R_IA64_PCREL64I: 3948 finish_pcrel: 3949 /* Make pc-relative. */ 3950 value -= (input_section->output_section->vma 3951 + input_section->output_offset 3952 + rel->r_offset) & ~ (bfd_vma) 0x3; 3953 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type); 3954 break; 3955 3956 case R_IA64_SEGREL32MSB: 3957 case R_IA64_SEGREL32LSB: 3958 case R_IA64_SEGREL64MSB: 3959 case R_IA64_SEGREL64LSB: 3960 if (r_symndx == 0) 3961 { 3962 /* If the input section was discarded from the output, then 3963 do nothing. */ 3964 r = bfd_reloc_ok; 3965 } 3966 else 3967 { 3968 struct elf_segment_map *m; 3969 Elf_Internal_Phdr *p; 3970 3971 /* Find the segment that contains the output_section. */ 3972 for (m = elf_tdata (output_bfd)->segment_map, 3973 p = elf_tdata (output_bfd)->phdr; 3974 m != NULL; 3975 m = m->next, p++) 3976 { 3977 int i; 3978 for (i = m->count - 1; i >= 0; i--) 3979 if (m->sections[i] == sym_sec->output_section) 3980 break; 3981 if (i >= 0) 3982 break; 3983 } 3984 3985 if (m == NULL) 3986 { 3987 r = bfd_reloc_notsupported; 3988 } 3989 else 3990 { 3991 /* The VMA of the segment is the vaddr of the associated 3992 program header. */ 3993 if (value > p->p_vaddr) 3994 value -= p->p_vaddr; 3995 else 3996 value = 0; 3997 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, 3998 r_type); 3999 } 4000 break; 4001 } 4002 4003 case R_IA64_SECREL32MSB: 4004 case R_IA64_SECREL32LSB: 4005 case R_IA64_SECREL64MSB: 4006 case R_IA64_SECREL64LSB: 4007 /* Make output-section relative. */ 4008 if (value > input_section->output_section->vma) 4009 value -= input_section->output_section->vma; 4010 else 4011 value = 0; 4012 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type); 4013 break; 4014 4015 case R_IA64_IPLTMSB: 4016 case R_IA64_IPLTLSB: 4017 /* Install a dynamic relocation for this reloc. */ 4018 if ((dynamic_symbol_p || info->shared) 4019 && (input_section->flags & SEC_ALLOC) != 0) 4020 { 4021 BFD_ASSERT (srel != NULL); 4022 4023 /* If we don't need dynamic symbol lookup, install two 4024 RELATIVE relocations. */ 4025 if (! dynamic_symbol_p) 4026 { 4027 unsigned int dyn_r_type; 4028 4029 if (r_type == R_IA64_IPLTMSB) 4030 dyn_r_type = R_IA64_REL64MSB; 4031 else 4032 dyn_r_type = R_IA64_REL64LSB; 4033 4034 elfNN_ia64_install_dyn_reloc (output_bfd, info, 4035 input_section, 4036 srel, rel->r_offset, 4037 dyn_r_type, 0, value); 4038 elfNN_ia64_install_dyn_reloc (output_bfd, info, 4039 input_section, 4040 srel, rel->r_offset + 8, 4041 dyn_r_type, 0, gp_val); 4042 } 4043 else 4044 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section, 4045 srel, rel->r_offset, r_type, 4046 h->dynindx, rel->r_addend); 4047 } 4048 4049 if (r_type == R_IA64_IPLTMSB) 4050 r_type = R_IA64_DIR64MSB; 4051 else 4052 r_type = R_IA64_DIR64LSB; 4053 elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type); 4054 r = elfNN_ia64_install_value (output_bfd, hit_addr + 8, gp_val, 4055 r_type); 4056 break; 4057 4058 default: 4059 r = bfd_reloc_notsupported; 4060 break; 4061 } 4062 4063 switch (r) 4064 { 4065 case bfd_reloc_ok: 4066 break; 4067 4068 case bfd_reloc_undefined: 4069 /* This can happen for global table relative relocs if 4070 __gp is undefined. This is a panic situation so we 4071 don't try to continue. */ 4072 (*info->callbacks->undefined_symbol) 4073 (info, "__gp", input_bfd, input_section, rel->r_offset, 1); 4074 return false; 4075 4076 case bfd_reloc_notsupported: 4077 { 4078 const char *name; 4079 4080 if (h) 4081 name = h->root.root.string; 4082 else 4083 { 4084 name = bfd_elf_string_from_elf_section (input_bfd, 4085 symtab_hdr->sh_link, 4086 sym->st_name); 4087 if (name == NULL) 4088 return false; 4089 if (*name == '\0') 4090 name = bfd_section_name (input_bfd, input_section); 4091 } 4092 if (!(*info->callbacks->warning) (info, _("unsupported reloc"), 4093 name, input_bfd, 4094 input_section, rel->r_offset)) 4095 return false; 4096 ret_val = false; 4097 } 4098 break; 4099 4100 case bfd_reloc_dangerous: 4101 case bfd_reloc_outofrange: 4102 case bfd_reloc_overflow: 4103 default: 4104 { 4105 const char *name; 4106 4107 if (h) 4108 name = h->root.root.string; 4109 else 4110 { 4111 name = bfd_elf_string_from_elf_section (input_bfd, 4112 symtab_hdr->sh_link, 4113 sym->st_name); 4114 if (name == NULL) 4115 return false; 4116 if (*name == '\0') 4117 name = bfd_section_name (input_bfd, input_section); 4118 } 4119 if (!(*info->callbacks->reloc_overflow) (info, name, 4120 howto->name, 4121 (bfd_vma) 0, 4122 input_bfd, 4123 input_section, 4124 rel->r_offset)) 4125 return false; 4126 ret_val = false; 4127 } 4128 break; 4129 } 4130 } 4131 4132 return ret_val; 4133} 4134 4135static boolean 4136elfNN_ia64_finish_dynamic_symbol (output_bfd, info, h, sym) 4137 bfd *output_bfd; 4138 struct bfd_link_info *info; 4139 struct elf_link_hash_entry *h; 4140 Elf_Internal_Sym *sym; 4141{ 4142 struct elfNN_ia64_link_hash_table *ia64_info; 4143 struct elfNN_ia64_dyn_sym_info *dyn_i; 4144 4145 ia64_info = elfNN_ia64_hash_table (info); 4146 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false); 4147 4148 /* Fill in the PLT data, if required. */ 4149 if (dyn_i && dyn_i->want_plt) 4150 { 4151 Elf_Internal_Rela outrel; 4152 bfd_byte *loc; 4153 asection *plt_sec; 4154 bfd_vma plt_addr, pltoff_addr, gp_val, index; 4155 ElfNN_External_Rela *rel; 4156 4157 gp_val = _bfd_get_gp_value (output_bfd); 4158 4159 /* Initialize the minimal PLT entry. */ 4160 4161 index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE; 4162 plt_sec = ia64_info->plt_sec; 4163 loc = plt_sec->contents + dyn_i->plt_offset; 4164 4165 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE); 4166 elfNN_ia64_install_value (output_bfd, loc, index, R_IA64_IMM22); 4167 elfNN_ia64_install_value (output_bfd, loc+2, -dyn_i->plt_offset, 4168 R_IA64_PCREL21B); 4169 4170 plt_addr = (plt_sec->output_section->vma 4171 + plt_sec->output_offset 4172 + dyn_i->plt_offset); 4173 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, true); 4174 4175 /* Initialize the FULL PLT entry, if needed. */ 4176 if (dyn_i->want_plt2) 4177 { 4178 loc = plt_sec->contents + dyn_i->plt2_offset; 4179 4180 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE); 4181 elfNN_ia64_install_value (output_bfd, loc, pltoff_addr - gp_val, 4182 R_IA64_IMM22); 4183 4184 /* Mark the symbol as undefined, rather than as defined in the 4185 plt section. Leave the value alone. */ 4186 /* ??? We didn't redefine it in adjust_dynamic_symbol in the 4187 first place. But perhaps elflink.h did some for us. */ 4188 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 4189 sym->st_shndx = SHN_UNDEF; 4190 } 4191 4192 /* Create the dynamic relocation. */ 4193 outrel.r_offset = pltoff_addr; 4194 if (bfd_little_endian (output_bfd)) 4195 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB); 4196 else 4197 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB); 4198 outrel.r_addend = 0; 4199 4200 /* This is fun. In the .IA_64.pltoff section, we've got entries 4201 that correspond both to real PLT entries, and those that 4202 happened to resolve to local symbols but need to be created 4203 to satisfy @pltoff relocations. The .rela.IA_64.pltoff 4204 relocations for the real PLT should come at the end of the 4205 section, so that they can be indexed by plt entry at runtime. 4206 4207 We emitted all of the relocations for the non-PLT @pltoff 4208 entries during relocate_section. So we can consider the 4209 existing sec->reloc_count to be the base of the array of 4210 PLT relocations. */ 4211 4212 rel = (ElfNN_External_Rela *)ia64_info->rel_pltoff_sec->contents; 4213 rel += ia64_info->rel_pltoff_sec->reloc_count; 4214 4215 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, rel + index); 4216 } 4217 4218 /* Mark some specially defined symbols as absolute. */ 4219 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 4220 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 4221 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0) 4222 sym->st_shndx = SHN_ABS; 4223 4224 return true; 4225} 4226 4227static boolean 4228elfNN_ia64_finish_dynamic_sections (abfd, info) 4229 bfd *abfd; 4230 struct bfd_link_info *info; 4231{ 4232 struct elfNN_ia64_link_hash_table *ia64_info; 4233 bfd *dynobj; 4234 4235 ia64_info = elfNN_ia64_hash_table (info); 4236 dynobj = ia64_info->root.dynobj; 4237 4238 if (elf_hash_table (info)->dynamic_sections_created) 4239 { 4240 ElfNN_External_Dyn *dyncon, *dynconend; 4241 asection *sdyn, *sgotplt; 4242 bfd_vma gp_val; 4243 4244 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 4245 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt"); 4246 BFD_ASSERT (sdyn != NULL); 4247 dyncon = (ElfNN_External_Dyn *) sdyn->contents; 4248 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 4249 4250 gp_val = _bfd_get_gp_value (abfd); 4251 4252 for (; dyncon < dynconend; dyncon++) 4253 { 4254 Elf_Internal_Dyn dyn; 4255 4256 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn); 4257 4258 switch (dyn.d_tag) 4259 { 4260 case DT_PLTGOT: 4261 dyn.d_un.d_ptr = gp_val; 4262 break; 4263 4264 case DT_PLTRELSZ: 4265 dyn.d_un.d_val = (ia64_info->minplt_entries 4266 * sizeof (ElfNN_External_Rela)); 4267 break; 4268 4269 case DT_JMPREL: 4270 /* See the comment above in finish_dynamic_symbol. */ 4271 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma 4272 + ia64_info->rel_pltoff_sec->output_offset 4273 + (ia64_info->rel_pltoff_sec->reloc_count 4274 * sizeof (ElfNN_External_Rela))); 4275 break; 4276 4277 case DT_IA_64_PLT_RESERVE: 4278 dyn.d_un.d_ptr = (sgotplt->output_section->vma 4279 + sgotplt->output_offset); 4280 break; 4281 4282 case DT_RELASZ: 4283 /* Do not have RELASZ include JMPREL. This makes things 4284 easier on ld.so. This is not what the rest of BFD set up. */ 4285 dyn.d_un.d_val -= (ia64_info->minplt_entries 4286 * sizeof (ElfNN_External_Rela)); 4287 break; 4288 } 4289 4290 bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon); 4291 } 4292 4293 /* Initialize the PLT0 entry */ 4294 if (ia64_info->plt_sec) 4295 { 4296 bfd_byte *loc = ia64_info->plt_sec->contents; 4297 bfd_vma pltres; 4298 4299 memcpy (loc, plt_header, PLT_HEADER_SIZE); 4300 4301 pltres = (sgotplt->output_section->vma 4302 + sgotplt->output_offset 4303 - gp_val); 4304 4305 elfNN_ia64_install_value (abfd, loc+1, pltres, R_IA64_GPREL22); 4306 } 4307 } 4308 4309 return true; 4310} 4311 4312/* ELF file flag handling: */ 4313 4314/* Function to keep IA-64 specific file flags. */ 4315static boolean 4316elfNN_ia64_set_private_flags (abfd, flags) 4317 bfd *abfd; 4318 flagword flags; 4319{ 4320 BFD_ASSERT (!elf_flags_init (abfd) 4321 || elf_elfheader (abfd)->e_flags == flags); 4322 4323 elf_elfheader (abfd)->e_flags = flags; 4324 elf_flags_init (abfd) = true; 4325 return true; 4326} 4327 4328/* Merge backend specific data from an object file to the output 4329 object file when linking. */ 4330static boolean 4331elfNN_ia64_merge_private_bfd_data (ibfd, obfd) 4332 bfd *ibfd, *obfd; 4333{ 4334 flagword out_flags; 4335 flagword in_flags; 4336 boolean ok = true; 4337 4338 /* Don't even pretend to support mixed-format linking. */ 4339 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 4340 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 4341 return false; 4342 4343 in_flags = elf_elfheader (ibfd)->e_flags; 4344 out_flags = elf_elfheader (obfd)->e_flags; 4345 4346 if (! elf_flags_init (obfd)) 4347 { 4348 elf_flags_init (obfd) = true; 4349 elf_elfheader (obfd)->e_flags = in_flags; 4350 4351 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 4352 && bfd_get_arch_info (obfd)->the_default) 4353 { 4354 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 4355 bfd_get_mach (ibfd)); 4356 } 4357 4358 return true; 4359 } 4360 4361 /* Check flag compatibility. */ 4362 if (in_flags == out_flags) 4363 return true; 4364 4365 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */ 4366 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP)) 4367 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP; 4368 4369 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL)) 4370 { 4371 (*_bfd_error_handler) 4372 (_("%s: linking trap-on-NULL-dereference with non-trapping files"), 4373 bfd_archive_filename (ibfd)); 4374 4375 bfd_set_error (bfd_error_bad_value); 4376 ok = false; 4377 } 4378 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE)) 4379 { 4380 (*_bfd_error_handler) 4381 (_("%s: linking big-endian files with little-endian files"), 4382 bfd_archive_filename (ibfd)); 4383 4384 bfd_set_error (bfd_error_bad_value); 4385 ok = false; 4386 } 4387 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64)) 4388 { 4389 (*_bfd_error_handler) 4390 (_("%s: linking 64-bit files with 32-bit files"), 4391 bfd_archive_filename (ibfd)); 4392 4393 bfd_set_error (bfd_error_bad_value); 4394 ok = false; 4395 } 4396 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP)) 4397 { 4398 (*_bfd_error_handler) 4399 (_("%s: linking constant-gp files with non-constant-gp files"), 4400 bfd_archive_filename (ibfd)); 4401 4402 bfd_set_error (bfd_error_bad_value); 4403 ok = false; 4404 } 4405 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP) 4406 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP)) 4407 { 4408 (*_bfd_error_handler) 4409 (_("%s: linking auto-pic files with non-auto-pic files"), 4410 bfd_archive_filename (ibfd)); 4411 4412 bfd_set_error (bfd_error_bad_value); 4413 ok = false; 4414 } 4415 4416 return ok; 4417} 4418 4419static boolean 4420elfNN_ia64_print_private_bfd_data (abfd, ptr) 4421 bfd *abfd; 4422 PTR ptr; 4423{ 4424 FILE *file = (FILE *) ptr; 4425 flagword flags = elf_elfheader (abfd)->e_flags; 4426 4427 BFD_ASSERT (abfd != NULL && ptr != NULL); 4428 4429 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n", 4430 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "", 4431 (flags & EF_IA_64_EXT) ? "EXT, " : "", 4432 (flags & EF_IA_64_BE) ? "BE, " : "LE, ", 4433 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "", 4434 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "", 4435 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "", 4436 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "", 4437 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32"); 4438 4439 _bfd_elf_print_private_bfd_data (abfd, ptr); 4440 return true; 4441} 4442 4443static enum elf_reloc_type_class 4444elfNN_ia64_reloc_type_class (rela) 4445 const Elf_Internal_Rela *rela; 4446{ 4447 switch ((int) ELFNN_R_TYPE (rela->r_info)) 4448 { 4449 case R_IA64_REL32MSB: 4450 case R_IA64_REL32LSB: 4451 case R_IA64_REL64MSB: 4452 case R_IA64_REL64LSB: 4453 return reloc_class_relative; 4454 case R_IA64_IPLTMSB: 4455 case R_IA64_IPLTLSB: 4456 return reloc_class_plt; 4457 case R_IA64_COPY: 4458 return reloc_class_copy; 4459 default: 4460 return reloc_class_normal; 4461 } 4462} 4463 4464static boolean 4465elfNN_ia64_hpux_vec (const bfd_target *vec) 4466{ 4467 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec; 4468 return (vec == & bfd_elfNN_ia64_hpux_big_vec); 4469} 4470 4471static void 4472elfNN_hpux_post_process_headers (abfd, info) 4473 bfd *abfd; 4474 struct bfd_link_info *info ATTRIBUTE_UNUSED; 4475{ 4476 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); 4477 4478 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX; 4479 i_ehdrp->e_ident[EI_ABIVERSION] = 1; 4480} 4481 4482boolean 4483elfNN_hpux_backend_section_from_bfd_section (abfd, sec, retval) 4484 bfd *abfd ATTRIBUTE_UNUSED; 4485 asection *sec; 4486 int *retval; 4487{ 4488 if (bfd_is_com_section (sec)) 4489 { 4490 *retval = SHN_IA_64_ANSI_COMMON; 4491 return true; 4492 } 4493 return false; 4494} 4495 4496#define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec 4497#define TARGET_LITTLE_NAME "elfNN-ia64-little" 4498#define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec 4499#define TARGET_BIG_NAME "elfNN-ia64-big" 4500#define ELF_ARCH bfd_arch_ia64 4501#define ELF_MACHINE_CODE EM_IA_64 4502#define ELF_MACHINE_ALT1 1999 /* EAS2.3 */ 4503#define ELF_MACHINE_ALT2 1998 /* EAS2.2 */ 4504#define ELF_MAXPAGESIZE 0x10000 /* 64KB */ 4505 4506#define elf_backend_section_from_shdr \ 4507 elfNN_ia64_section_from_shdr 4508#define elf_backend_section_flags \ 4509 elfNN_ia64_section_flags 4510#define elf_backend_fake_sections \ 4511 elfNN_ia64_fake_sections 4512#define elf_backend_final_write_processing \ 4513 elfNN_ia64_final_write_processing 4514#define elf_backend_add_symbol_hook \ 4515 elfNN_ia64_add_symbol_hook 4516#define elf_backend_additional_program_headers \ 4517 elfNN_ia64_additional_program_headers 4518#define elf_backend_modify_segment_map \ 4519 elfNN_ia64_modify_segment_map 4520#define elf_info_to_howto \ 4521 elfNN_ia64_info_to_howto 4522 4523#define bfd_elfNN_bfd_reloc_type_lookup \ 4524 elfNN_ia64_reloc_type_lookup 4525#define bfd_elfNN_bfd_is_local_label_name \ 4526 elfNN_ia64_is_local_label_name 4527#define bfd_elfNN_bfd_relax_section \ 4528 elfNN_ia64_relax_section 4529 4530/* Stuff for the BFD linker: */ 4531#define bfd_elfNN_bfd_link_hash_table_create \ 4532 elfNN_ia64_hash_table_create 4533#define elf_backend_create_dynamic_sections \ 4534 elfNN_ia64_create_dynamic_sections 4535#define elf_backend_check_relocs \ 4536 elfNN_ia64_check_relocs 4537#define elf_backend_adjust_dynamic_symbol \ 4538 elfNN_ia64_adjust_dynamic_symbol 4539#define elf_backend_size_dynamic_sections \ 4540 elfNN_ia64_size_dynamic_sections 4541#define elf_backend_relocate_section \ 4542 elfNN_ia64_relocate_section 4543#define elf_backend_finish_dynamic_symbol \ 4544 elfNN_ia64_finish_dynamic_symbol 4545#define elf_backend_finish_dynamic_sections \ 4546 elfNN_ia64_finish_dynamic_sections 4547#define bfd_elfNN_bfd_final_link \ 4548 elfNN_ia64_final_link 4549 4550#define bfd_elfNN_bfd_merge_private_bfd_data \ 4551 elfNN_ia64_merge_private_bfd_data 4552#define bfd_elfNN_bfd_set_private_flags \ 4553 elfNN_ia64_set_private_flags 4554#define bfd_elfNN_bfd_print_private_bfd_data \ 4555 elfNN_ia64_print_private_bfd_data 4556 4557#define elf_backend_plt_readonly 1 4558#define elf_backend_want_plt_sym 0 4559#define elf_backend_plt_alignment 5 4560#define elf_backend_got_header_size 0 4561#define elf_backend_plt_header_size PLT_HEADER_SIZE 4562#define elf_backend_want_got_plt 1 4563#define elf_backend_may_use_rel_p 1 4564#define elf_backend_may_use_rela_p 1 4565#define elf_backend_default_use_rela_p 1 4566#define elf_backend_want_dynbss 0 4567#define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect 4568#define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol 4569#define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class 4570 4571#include "elfNN-target.h" 4572 4573/* AIX-specific vectors. */ 4574 4575#undef TARGET_LITTLE_SYM 4576#define TARGET_LITTLE_SYM bfd_elfNN_ia64_aix_little_vec 4577#undef TARGET_LITTLE_NAME 4578#define TARGET_LITTLE_NAME "elfNN-ia64-aix-little" 4579#undef TARGET_BIG_SYM 4580#define TARGET_BIG_SYM bfd_elfNN_ia64_aix_big_vec 4581#undef TARGET_BIG_NAME 4582#define TARGET_BIG_NAME "elfNN-ia64-aix-big" 4583 4584#undef elf_backend_add_symbol_hook 4585#define elf_backend_add_symbol_hook elfNN_ia64_aix_add_symbol_hook 4586 4587#undef bfd_elfNN_bfd_link_add_symbols 4588#define bfd_elfNN_bfd_link_add_symbols elfNN_ia64_aix_link_add_symbols 4589 4590#define elfNN_bed elfNN_ia64_aix_bed 4591 4592#include "elfNN-target.h" 4593 4594/* HPUX-specific vectors. */ 4595 4596#undef TARGET_LITTLE_SYM 4597#undef TARGET_LITTLE_NAME 4598#undef TARGET_BIG_SYM 4599#define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec 4600#undef TARGET_BIG_NAME 4601#define TARGET_BIG_NAME "elfNN-ia64-hpux-big" 4602 4603/* We need to undo the AIX specific functions. */ 4604 4605#undef elf_backend_add_symbol_hook 4606#define elf_backend_add_symbol_hook elfNN_ia64_add_symbol_hook 4607 4608#undef bfd_elfNN_bfd_link_add_symbols 4609#define bfd_elfNN_bfd_link_add_symbols _bfd_generic_link_add_symbols 4610 4611/* These are HP-UX specific functions. */ 4612 4613#undef elf_backend_post_process_headers 4614#define elf_backend_post_process_headers elfNN_hpux_post_process_headers 4615 4616#undef elf_backend_section_from_bfd_section 4617#define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section 4618 4619#undef ELF_MAXPAGESIZE 4620#define ELF_MAXPAGESIZE 0x1000 /* 1K */ 4621 4622#undef elfNN_bed 4623#define elfNN_bed elfNN_ia64_hpux_bed 4624 4625#include "elfNN-target.h" 4626