elf64-sparc.c revision 107492
150476Speter/* SPARC-specific support for 64-bit ELF 222787Swosch Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 374856Sru Free Software Foundation, Inc. 422787Swosch 522787SwoschThis 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/sparc.h" 26 27/* This is defined if one wants to build upward compatible binaries 28 with the original sparc64-elf toolchain. The support is kept in for 29 now but is turned off by default. dje 970930 */ 30/*#define SPARC64_OLD_RELOCS*/ 31 32#include "elf/sparc.h" 33 34/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */ 35#define MINUS_ONE (~ (bfd_vma) 0) 36 37static struct bfd_link_hash_table * sparc64_elf_bfd_link_hash_table_create 38 PARAMS ((bfd *)); 39static bfd_reloc_status_type init_insn_reloc 40 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, 41 bfd *, bfd_vma *, bfd_vma *)); 42static reloc_howto_type *sparc64_elf_reloc_type_lookup 43 PARAMS ((bfd *, bfd_reloc_code_real_type)); 44static void sparc64_elf_info_to_howto 45 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 46 47static void sparc64_elf_build_plt 48 PARAMS ((bfd *, unsigned char *, int)); 49static bfd_vma sparc64_elf_plt_entry_offset 50 PARAMS ((bfd_vma)); 51static bfd_vma sparc64_elf_plt_ptr_offset 52 PARAMS ((bfd_vma, bfd_vma)); 53 54static boolean sparc64_elf_check_relocs 55 PARAMS ((bfd *, struct bfd_link_info *, asection *sec, 56 const Elf_Internal_Rela *)); 57static boolean sparc64_elf_adjust_dynamic_symbol 58 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 59static boolean sparc64_elf_size_dynamic_sections 60 PARAMS ((bfd *, struct bfd_link_info *)); 61static int sparc64_elf_get_symbol_type 62 PARAMS (( Elf_Internal_Sym *, int)); 63static boolean sparc64_elf_add_symbol_hook 64 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *, 65 const char **, flagword *, asection **, bfd_vma *)); 66static boolean sparc64_elf_output_arch_syms 67 PARAMS ((bfd *, struct bfd_link_info *, PTR, 68 boolean (*) (PTR, const char *, Elf_Internal_Sym *, asection *))); 69static void sparc64_elf_symbol_processing 70 PARAMS ((bfd *, asymbol *)); 71 72static boolean sparc64_elf_merge_private_bfd_data 73 PARAMS ((bfd *, bfd *)); 74 75static boolean sparc64_elf_fake_sections 76 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *)); 77 78static const char *sparc64_elf_print_symbol_all 79 PARAMS ((bfd *, PTR, asymbol *)); 80static boolean sparc64_elf_relax_section 81 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *)); 82static boolean sparc64_elf_relocate_section 83 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 84 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 85static boolean sparc64_elf_finish_dynamic_symbol 86 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 87 Elf_Internal_Sym *)); 88static boolean sparc64_elf_finish_dynamic_sections 89 PARAMS ((bfd *, struct bfd_link_info *)); 90static boolean sparc64_elf_object_p PARAMS ((bfd *)); 91static long sparc64_elf_get_reloc_upper_bound PARAMS ((bfd *, asection *)); 92static long sparc64_elf_get_dynamic_reloc_upper_bound PARAMS ((bfd *)); 93static boolean sparc64_elf_slurp_one_reloc_table 94 PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, asymbol **, boolean)); 95static boolean sparc64_elf_slurp_reloc_table 96 PARAMS ((bfd *, asection *, asymbol **, boolean)); 97static long sparc64_elf_canonicalize_dynamic_reloc 98 PARAMS ((bfd *, arelent **, asymbol **)); 99static void sparc64_elf_write_relocs PARAMS ((bfd *, asection *, PTR)); 100static enum elf_reloc_type_class sparc64_elf_reloc_type_class 101 PARAMS ((const Elf_Internal_Rela *)); 102 103/* The relocation "howto" table. */ 104 105static bfd_reloc_status_type sparc_elf_notsup_reloc 106 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 107static bfd_reloc_status_type sparc_elf_wdisp16_reloc 108 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 109static bfd_reloc_status_type sparc_elf_hix22_reloc 110 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 111static bfd_reloc_status_type sparc_elf_lox10_reloc 112 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 113 114static reloc_howto_type sparc64_elf_howto_table[] = 115{ 116 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 117 HOWTO(R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", false,0,0x000000ff,true), 118 HOWTO(R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", false,0,0x0000ffff,true), 119 HOWTO(R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", false,0,0xffffffff,true), 120 HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", false,0,0x000000ff,true), 121 HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", false,0,0x0000ffff,true), 122 HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", false,0,0xffffffff,true), 123 HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", false,0,0x3fffffff,true), 124 HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", false,0,0x003fffff,true), 125 HOWTO(R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", false,0,0x003fffff,true), 126 HOWTO(R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", false,0,0x003fffff,true), 127 HOWTO(R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", false,0,0x00001fff,true), 128 HOWTO(R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", false,0,0x000003ff,true), 129 HOWTO(R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", false,0,0x000003ff,true), 130 HOWTO(R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", false,0,0x00001fff,true), 131 HOWTO(R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", false,0,0x003fffff,true), 132 HOWTO(R_SPARC_PC10, 0,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", false,0,0x000003ff,true), 133 HOWTO(R_SPARC_PC22, 10,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", false,0,0x003fffff,true), 134 HOWTO(R_SPARC_WPLT30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", false,0,0x3fffffff,true), 135 HOWTO(R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", false,0,0x00000000,true), 136 HOWTO(R_SPARC_GLOB_DAT, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GLOB_DAT",false,0,0x00000000,true), 137 HOWTO(R_SPARC_JMP_SLOT, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_JMP_SLOT",false,0,0x00000000,true), 138 HOWTO(R_SPARC_RELATIVE, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",false,0,0x00000000,true), 139 HOWTO(R_SPARC_UA32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", false,0,0xffffffff,true), 140#ifndef SPARC64_OLD_RELOCS 141 HOWTO(R_SPARC_PLT32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", false,0,0xffffffff,true), 142 /* These aren't implemented yet. */ 143 HOWTO(R_SPARC_HIPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", false,0,0x00000000,true), 144 HOWTO(R_SPARC_LOPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", false,0,0x00000000,true), 145 HOWTO(R_SPARC_PCPLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", false,0,0x00000000,true), 146 HOWTO(R_SPARC_PCPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", false,0,0x00000000,true), 147 HOWTO(R_SPARC_PCPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", false,0,0x00000000,true), 148#endif 149 HOWTO(R_SPARC_10, 0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", false,0,0x000003ff,true), 150 HOWTO(R_SPARC_11, 0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", false,0,0x000007ff,true), 151 HOWTO(R_SPARC_64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", false,0,MINUS_ONE, true), 152 HOWTO(R_SPARC_OLO10, 0,2,13,false,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", false,0,0x00001fff,true), 153 HOWTO(R_SPARC_HH22, 42,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true), 154 HOWTO(R_SPARC_HM10, 32,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true), 155 HOWTO(R_SPARC_LM22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true), 156 HOWTO(R_SPARC_PC_HH22, 42,2,22,true, 0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_PC_HH22", false,0,0x003fffff,true), 157 HOWTO(R_SPARC_PC_HM10, 32,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_HM10", false,0,0x000003ff,true), 158 HOWTO(R_SPARC_PC_LM22, 10,2,22,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_LM22", false,0,0x003fffff,true), 159 HOWTO(R_SPARC_WDISP16, 2,2,16,true, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true), 160 HOWTO(R_SPARC_WDISP19, 2,2,19,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true), 161 HOWTO(R_SPARC_UNUSED_42, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_UNUSED_42",false,0,0x00000000,true), 162 HOWTO(R_SPARC_7, 0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", false,0,0x0000007f,true), 163 HOWTO(R_SPARC_5, 0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", false,0,0x0000001f,true), 164 HOWTO(R_SPARC_6, 0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", false,0,0x0000003f,true), 165 HOWTO(R_SPARC_DISP64, 0,4,64,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", false,0,MINUS_ONE, true), 166 HOWTO(R_SPARC_PLT64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT64", false,0,MINUS_ONE, true), 167 HOWTO(R_SPARC_HIX22, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", false,0,MINUS_ONE, false), 168 HOWTO(R_SPARC_LOX10, 0,4, 0,false,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", false,0,MINUS_ONE, false), 169 HOWTO(R_SPARC_H44, 22,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", false,0,0x003fffff,false), 170 HOWTO(R_SPARC_M44, 12,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", false,0,0x000003ff,false), 171 HOWTO(R_SPARC_L44, 0,2,13,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", false,0,0x00000fff,false), 172 HOWTO(R_SPARC_REGISTER, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",false,0,MINUS_ONE, false), 173 HOWTO(R_SPARC_UA64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", false,0,MINUS_ONE, true), 174 HOWTO(R_SPARC_UA16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", false,0,0x0000ffff,true) 175}; 176 177struct elf_reloc_map { 178 bfd_reloc_code_real_type bfd_reloc_val; 179 unsigned char elf_reloc_val; 180}; 181 182static const struct elf_reloc_map sparc_reloc_map[] = 183{ 184 { BFD_RELOC_NONE, R_SPARC_NONE, }, 185 { BFD_RELOC_16, R_SPARC_16, }, 186 { BFD_RELOC_16_PCREL, R_SPARC_DISP16 }, 187 { BFD_RELOC_8, R_SPARC_8 }, 188 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 }, 189 { BFD_RELOC_CTOR, R_SPARC_64 }, 190 { BFD_RELOC_32, R_SPARC_32 }, 191 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 }, 192 { BFD_RELOC_HI22, R_SPARC_HI22 }, 193 { BFD_RELOC_LO10, R_SPARC_LO10, }, 194 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 }, 195 { BFD_RELOC_64_PCREL, R_SPARC_DISP64 }, 196 { BFD_RELOC_SPARC22, R_SPARC_22 }, 197 { BFD_RELOC_SPARC13, R_SPARC_13 }, 198 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 }, 199 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 }, 200 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 }, 201 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 }, 202 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 }, 203 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 }, 204 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY }, 205 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT }, 206 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT }, 207 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE }, 208 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 }, 209 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 }, 210 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, 211 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 }, 212 { BFD_RELOC_SPARC_10, R_SPARC_10 }, 213 { BFD_RELOC_SPARC_11, R_SPARC_11 }, 214 { BFD_RELOC_SPARC_64, R_SPARC_64 }, 215 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 }, 216 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 }, 217 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 }, 218 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 }, 219 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 }, 220 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 }, 221 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 }, 222 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 }, 223 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 }, 224 { BFD_RELOC_SPARC_7, R_SPARC_7 }, 225 { BFD_RELOC_SPARC_5, R_SPARC_5 }, 226 { BFD_RELOC_SPARC_6, R_SPARC_6 }, 227 { BFD_RELOC_SPARC_DISP64, R_SPARC_DISP64 }, 228#ifndef SPARC64_OLD_RELOCS 229 { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 }, 230#endif 231 { BFD_RELOC_SPARC_PLT64, R_SPARC_PLT64 }, 232 { BFD_RELOC_SPARC_HIX22, R_SPARC_HIX22 }, 233 { BFD_RELOC_SPARC_LOX10, R_SPARC_LOX10 }, 234 { BFD_RELOC_SPARC_H44, R_SPARC_H44 }, 235 { BFD_RELOC_SPARC_M44, R_SPARC_M44 }, 236 { BFD_RELOC_SPARC_L44, R_SPARC_L44 }, 237 { BFD_RELOC_SPARC_REGISTER, R_SPARC_REGISTER } 238}; 239 240static reloc_howto_type * 241sparc64_elf_reloc_type_lookup (abfd, code) 242 bfd *abfd ATTRIBUTE_UNUSED; 243 bfd_reloc_code_real_type code; 244{ 245 unsigned int i; 246 for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++) 247 { 248 if (sparc_reloc_map[i].bfd_reloc_val == code) 249 return &sparc64_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val]; 250 } 251 return 0; 252} 253 254static void 255sparc64_elf_info_to_howto (abfd, cache_ptr, dst) 256 bfd *abfd ATTRIBUTE_UNUSED; 257 arelent *cache_ptr; 258 Elf64_Internal_Rela *dst; 259{ 260 BFD_ASSERT (ELF64_R_TYPE_ID (dst->r_info) < (unsigned int) R_SPARC_max_std); 261 cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (dst->r_info)]; 262} 263 264/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA 265 section can represent up to two relocs, we must tell the user to allocate 266 more space. */ 267 268static long 269sparc64_elf_get_reloc_upper_bound (abfd, sec) 270 bfd *abfd ATTRIBUTE_UNUSED; 271 asection *sec; 272{ 273 return (sec->reloc_count * 2 + 1) * sizeof (arelent *); 274} 275 276static long 277sparc64_elf_get_dynamic_reloc_upper_bound (abfd) 278 bfd *abfd; 279{ 280 return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2; 281} 282 283/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of 284 them. We cannot use generic elf routines for this, because R_SPARC_OLO10 285 has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations 286 for the same location, R_SPARC_LO10 and R_SPARC_13. */ 287 288static boolean 289sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, dynamic) 290 bfd *abfd; 291 asection *asect; 292 Elf_Internal_Shdr *rel_hdr; 293 asymbol **symbols; 294 boolean dynamic; 295{ 296 PTR allocated = NULL; 297 bfd_byte *native_relocs; 298 arelent *relent; 299 unsigned int i; 300 int entsize; 301 bfd_size_type count; 302 arelent *relents; 303 304 allocated = (PTR) bfd_malloc (rel_hdr->sh_size); 305 if (allocated == NULL) 306 goto error_return; 307 308 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0 309 || bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size) 310 goto error_return; 311 312 native_relocs = (bfd_byte *) allocated; 313 314 relents = asect->relocation + asect->reloc_count; 315 316 entsize = rel_hdr->sh_entsize; 317 BFD_ASSERT (entsize == sizeof (Elf64_External_Rela)); 318 319 count = rel_hdr->sh_size / entsize; 320 321 for (i = 0, relent = relents; i < count; 322 i++, relent++, native_relocs += entsize) 323 { 324 Elf_Internal_Rela rela; 325 326 bfd_elf64_swap_reloca_in (abfd, (Elf64_External_Rela *) native_relocs, &rela); 327 328 /* The address of an ELF reloc is section relative for an object 329 file, and absolute for an executable file or shared library. 330 The address of a normal BFD reloc is always section relative, 331 and the address of a dynamic reloc is absolute.. */ 332 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic) 333 relent->address = rela.r_offset; 334 else 335 relent->address = rela.r_offset - asect->vma; 336 337 if (ELF64_R_SYM (rela.r_info) == 0) 338 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 339 else 340 { 341 asymbol **ps, *s; 342 343 ps = symbols + ELF64_R_SYM (rela.r_info) - 1; 344 s = *ps; 345 346 /* Canonicalize ELF section symbols. FIXME: Why? */ 347 if ((s->flags & BSF_SECTION_SYM) == 0) 348 relent->sym_ptr_ptr = ps; 349 else 350 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr; 351 } 352 353 relent->addend = rela.r_addend; 354 355 BFD_ASSERT (ELF64_R_TYPE_ID (rela.r_info) < (unsigned int) R_SPARC_max_std); 356 if (ELF64_R_TYPE_ID (rela.r_info) == R_SPARC_OLO10) 357 { 358 relent->howto = &sparc64_elf_howto_table[R_SPARC_LO10]; 359 relent[1].address = relent->address; 360 relent++; 361 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 362 relent->addend = ELF64_R_TYPE_DATA (rela.r_info); 363 relent->howto = &sparc64_elf_howto_table[R_SPARC_13]; 364 } 365 else 366 relent->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (rela.r_info)]; 367 } 368 369 asect->reloc_count += relent - relents; 370 371 if (allocated != NULL) 372 free (allocated); 373 374 return true; 375 376 error_return: 377 if (allocated != NULL) 378 free (allocated); 379 return false; 380} 381 382/* Read in and swap the external relocs. */ 383 384static boolean 385sparc64_elf_slurp_reloc_table (abfd, asect, symbols, dynamic) 386 bfd *abfd; 387 asection *asect; 388 asymbol **symbols; 389 boolean dynamic; 390{ 391 struct bfd_elf_section_data * const d = elf_section_data (asect); 392 Elf_Internal_Shdr *rel_hdr; 393 Elf_Internal_Shdr *rel_hdr2; 394 bfd_size_type amt; 395 396 if (asect->relocation != NULL) 397 return true; 398 399 if (! dynamic) 400 { 401 if ((asect->flags & SEC_RELOC) == 0 402 || asect->reloc_count == 0) 403 return true; 404 405 rel_hdr = &d->rel_hdr; 406 rel_hdr2 = d->rel_hdr2; 407 408 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset 409 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset)); 410 } 411 else 412 { 413 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this 414 case because relocations against this section may use the 415 dynamic symbol table, and in that case bfd_section_from_shdr 416 in elf.c does not update the RELOC_COUNT. */ 417 if (asect->_raw_size == 0) 418 return true; 419 420 rel_hdr = &d->this_hdr; 421 asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr); 422 rel_hdr2 = NULL; 423 } 424 425 amt = asect->reloc_count; 426 amt *= 2 * sizeof (arelent); 427 asect->relocation = (arelent *) bfd_alloc (abfd, amt); 428 if (asect->relocation == NULL) 429 return false; 430 431 /* The sparc64_elf_slurp_one_reloc_table routine increments reloc_count. */ 432 asect->reloc_count = 0; 433 434 if (!sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, 435 dynamic)) 436 return false; 437 438 if (rel_hdr2 439 && !sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols, 440 dynamic)) 441 return false; 442 443 return true; 444} 445 446/* Canonicalize the dynamic relocation entries. Note that we return 447 the dynamic relocations as a single block, although they are 448 actually associated with particular sections; the interface, which 449 was designed for SunOS style shared libraries, expects that there 450 is only one set of dynamic relocs. Any section that was actually 451 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses 452 the dynamic symbol table, is considered to be a dynamic reloc 453 section. */ 454 455static long 456sparc64_elf_canonicalize_dynamic_reloc (abfd, storage, syms) 457 bfd *abfd; 458 arelent **storage; 459 asymbol **syms; 460{ 461 asection *s; 462 long ret; 463 464 if (elf_dynsymtab (abfd) == 0) 465 { 466 bfd_set_error (bfd_error_invalid_operation); 467 return -1; 468 } 469 470 ret = 0; 471 for (s = abfd->sections; s != NULL; s = s->next) 472 { 473 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 474 && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 475 { 476 arelent *p; 477 long count, i; 478 479 if (! sparc64_elf_slurp_reloc_table (abfd, s, syms, true)) 480 return -1; 481 count = s->reloc_count; 482 p = s->relocation; 483 for (i = 0; i < count; i++) 484 *storage++ = p++; 485 ret += count; 486 } 487 } 488 489 *storage = NULL; 490 491 return ret; 492} 493 494/* Write out the relocs. */ 495 496static void 497sparc64_elf_write_relocs (abfd, sec, data) 498 bfd *abfd; 499 asection *sec; 500 PTR data; 501{ 502 boolean *failedp = (boolean *) data; 503 Elf_Internal_Shdr *rela_hdr; 504 Elf64_External_Rela *outbound_relocas, *src_rela; 505 unsigned int idx, count; 506 asymbol *last_sym = 0; 507 int last_sym_idx = 0; 508 509 /* If we have already failed, don't do anything. */ 510 if (*failedp) 511 return; 512 513 if ((sec->flags & SEC_RELOC) == 0) 514 return; 515 516 /* The linker backend writes the relocs out itself, and sets the 517 reloc_count field to zero to inhibit writing them here. Also, 518 sometimes the SEC_RELOC flag gets set even when there aren't any 519 relocs. */ 520 if (sec->reloc_count == 0) 521 return; 522 523 /* We can combine two relocs that refer to the same address 524 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the 525 latter is R_SPARC_13 with no associated symbol. */ 526 count = 0; 527 for (idx = 0; idx < sec->reloc_count; idx++) 528 { 529 bfd_vma addr; 530 531 ++count; 532 533 addr = sec->orelocation[idx]->address; 534 if (sec->orelocation[idx]->howto->type == R_SPARC_LO10 535 && idx < sec->reloc_count - 1) 536 { 537 arelent *r = sec->orelocation[idx + 1]; 538 539 if (r->howto->type == R_SPARC_13 540 && r->address == addr 541 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section) 542 && (*r->sym_ptr_ptr)->value == 0) 543 ++idx; 544 } 545 } 546 547 rela_hdr = &elf_section_data (sec)->rel_hdr; 548 549 rela_hdr->sh_size = rela_hdr->sh_entsize * count; 550 rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size); 551 if (rela_hdr->contents == NULL) 552 { 553 *failedp = true; 554 return; 555 } 556 557 /* Figure out whether the relocations are RELA or REL relocations. */ 558 if (rela_hdr->sh_type != SHT_RELA) 559 abort (); 560 561 /* orelocation has the data, reloc_count has the count... */ 562 outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents; 563 src_rela = outbound_relocas; 564 565 for (idx = 0; idx < sec->reloc_count; idx++) 566 { 567 Elf_Internal_Rela dst_rela; 568 arelent *ptr; 569 asymbol *sym; 570 int n; 571 572 ptr = sec->orelocation[idx]; 573 574 /* The address of an ELF reloc is section relative for an object 575 file, and absolute for an executable file or shared library. 576 The address of a BFD reloc is always section relative. */ 577 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) 578 dst_rela.r_offset = ptr->address; 579 else 580 dst_rela.r_offset = ptr->address + sec->vma; 581 582 sym = *ptr->sym_ptr_ptr; 583 if (sym == last_sym) 584 n = last_sym_idx; 585 else if (bfd_is_abs_section (sym->section) && sym->value == 0) 586 n = STN_UNDEF; 587 else 588 { 589 last_sym = sym; 590 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym); 591 if (n < 0) 592 { 593 *failedp = true; 594 return; 595 } 596 last_sym_idx = n; 597 } 598 599 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL 600 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec 601 && ! _bfd_elf_validate_reloc (abfd, ptr)) 602 { 603 *failedp = true; 604 return; 605 } 606 607 if (ptr->howto->type == R_SPARC_LO10 608 && idx < sec->reloc_count - 1) 609 { 610 arelent *r = sec->orelocation[idx + 1]; 611 612 if (r->howto->type == R_SPARC_13 613 && r->address == ptr->address 614 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section) 615 && (*r->sym_ptr_ptr)->value == 0) 616 { 617 idx++; 618 dst_rela.r_info 619 = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend, 620 R_SPARC_OLO10)); 621 } 622 else 623 dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10); 624 } 625 else 626 dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type); 627 628 dst_rela.r_addend = ptr->addend; 629 bfd_elf64_swap_reloca_out (abfd, &dst_rela, src_rela); 630 ++src_rela; 631 } 632} 633 634/* Sparc64 ELF linker hash table. */ 635 636struct sparc64_elf_app_reg 637{ 638 unsigned char bind; 639 unsigned short shndx; 640 bfd *abfd; 641 char *name; 642}; 643 644struct sparc64_elf_link_hash_table 645{ 646 struct elf_link_hash_table root; 647 648 struct sparc64_elf_app_reg app_regs [4]; 649}; 650 651/* Get the Sparc64 ELF linker hash table from a link_info structure. */ 652 653#define sparc64_elf_hash_table(p) \ 654 ((struct sparc64_elf_link_hash_table *) ((p)->hash)) 655 656/* Create a Sparc64 ELF linker hash table. */ 657 658static struct bfd_link_hash_table * 659sparc64_elf_bfd_link_hash_table_create (abfd) 660 bfd *abfd; 661{ 662 struct sparc64_elf_link_hash_table *ret; 663 bfd_size_type amt = sizeof (struct sparc64_elf_link_hash_table); 664 665 ret = (struct sparc64_elf_link_hash_table *) bfd_zmalloc (amt); 666 if (ret == (struct sparc64_elf_link_hash_table *) NULL) 667 return NULL; 668 669 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd, 670 _bfd_elf_link_hash_newfunc)) 671 { 672 free (ret); 673 return NULL; 674 } 675 676 return &ret->root.root; 677} 678 679/* Utility for performing the standard initial work of an instruction 680 relocation. 681 *PRELOCATION will contain the relocated item. 682 *PINSN will contain the instruction from the input stream. 683 If the result is `bfd_reloc_other' the caller can continue with 684 performing the relocation. Otherwise it must stop and return the 685 value to its caller. */ 686 687static bfd_reloc_status_type 688init_insn_reloc (abfd, 689 reloc_entry, 690 symbol, 691 data, 692 input_section, 693 output_bfd, 694 prelocation, 695 pinsn) 696 bfd *abfd; 697 arelent *reloc_entry; 698 asymbol *symbol; 699 PTR data; 700 asection *input_section; 701 bfd *output_bfd; 702 bfd_vma *prelocation; 703 bfd_vma *pinsn; 704{ 705 bfd_vma relocation; 706 reloc_howto_type *howto = reloc_entry->howto; 707 708 if (output_bfd != (bfd *) NULL 709 && (symbol->flags & BSF_SECTION_SYM) == 0 710 && (! howto->partial_inplace 711 || reloc_entry->addend == 0)) 712 { 713 reloc_entry->address += input_section->output_offset; 714 return bfd_reloc_ok; 715 } 716 717 /* This works because partial_inplace is false. */ 718 if (output_bfd != NULL) 719 return bfd_reloc_continue; 720 721 if (reloc_entry->address > input_section->_cooked_size) 722 return bfd_reloc_outofrange; 723 724 relocation = (symbol->value 725 + symbol->section->output_section->vma 726 + symbol->section->output_offset); 727 relocation += reloc_entry->addend; 728 if (howto->pc_relative) 729 { 730 relocation -= (input_section->output_section->vma 731 + input_section->output_offset); 732 relocation -= reloc_entry->address; 733 } 734 735 *prelocation = relocation; 736 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 737 return bfd_reloc_other; 738} 739 740/* For unsupported relocs. */ 741 742static bfd_reloc_status_type 743sparc_elf_notsup_reloc (abfd, 744 reloc_entry, 745 symbol, 746 data, 747 input_section, 748 output_bfd, 749 error_message) 750 bfd *abfd ATTRIBUTE_UNUSED; 751 arelent *reloc_entry ATTRIBUTE_UNUSED; 752 asymbol *symbol ATTRIBUTE_UNUSED; 753 PTR data ATTRIBUTE_UNUSED; 754 asection *input_section ATTRIBUTE_UNUSED; 755 bfd *output_bfd ATTRIBUTE_UNUSED; 756 char **error_message ATTRIBUTE_UNUSED; 757{ 758 return bfd_reloc_notsupported; 759} 760 761/* Handle the WDISP16 reloc. */ 762 763static bfd_reloc_status_type 764sparc_elf_wdisp16_reloc (abfd, reloc_entry, symbol, data, input_section, 765 output_bfd, error_message) 766 bfd *abfd; 767 arelent *reloc_entry; 768 asymbol *symbol; 769 PTR data; 770 asection *input_section; 771 bfd *output_bfd; 772 char **error_message ATTRIBUTE_UNUSED; 773{ 774 bfd_vma relocation; 775 bfd_vma insn; 776 bfd_reloc_status_type status; 777 778 status = init_insn_reloc (abfd, reloc_entry, symbol, data, 779 input_section, output_bfd, &relocation, &insn); 780 if (status != bfd_reloc_other) 781 return status; 782 783 insn &= ~ (bfd_vma) 0x303fff; 784 insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff); 785 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 786 787 if ((bfd_signed_vma) relocation < - 0x40000 788 || (bfd_signed_vma) relocation > 0x3ffff) 789 return bfd_reloc_overflow; 790 else 791 return bfd_reloc_ok; 792} 793 794/* Handle the HIX22 reloc. */ 795 796static bfd_reloc_status_type 797sparc_elf_hix22_reloc (abfd, 798 reloc_entry, 799 symbol, 800 data, 801 input_section, 802 output_bfd, 803 error_message) 804 bfd *abfd; 805 arelent *reloc_entry; 806 asymbol *symbol; 807 PTR data; 808 asection *input_section; 809 bfd *output_bfd; 810 char **error_message ATTRIBUTE_UNUSED; 811{ 812 bfd_vma relocation; 813 bfd_vma insn; 814 bfd_reloc_status_type status; 815 816 status = init_insn_reloc (abfd, reloc_entry, symbol, data, 817 input_section, output_bfd, &relocation, &insn); 818 if (status != bfd_reloc_other) 819 return status; 820 821 relocation ^= MINUS_ONE; 822 insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff); 823 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 824 825 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0) 826 return bfd_reloc_overflow; 827 else 828 return bfd_reloc_ok; 829} 830 831/* Handle the LOX10 reloc. */ 832 833static bfd_reloc_status_type 834sparc_elf_lox10_reloc (abfd, 835 reloc_entry, 836 symbol, 837 data, 838 input_section, 839 output_bfd, 840 error_message) 841 bfd *abfd; 842 arelent *reloc_entry; 843 asymbol *symbol; 844 PTR data; 845 asection *input_section; 846 bfd *output_bfd; 847 char **error_message ATTRIBUTE_UNUSED; 848{ 849 bfd_vma relocation; 850 bfd_vma insn; 851 bfd_reloc_status_type status; 852 853 status = init_insn_reloc (abfd, reloc_entry, symbol, data, 854 input_section, output_bfd, &relocation, &insn); 855 if (status != bfd_reloc_other) 856 return status; 857 858 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff); 859 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 860 861 return bfd_reloc_ok; 862} 863 864/* PLT/GOT stuff */ 865 866/* Both the headers and the entries are icache aligned. */ 867#define PLT_ENTRY_SIZE 32 868#define PLT_HEADER_SIZE (4 * PLT_ENTRY_SIZE) 869#define LARGE_PLT_THRESHOLD 32768 870#define GOT_RESERVED_ENTRIES 1 871 872#define ELF_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1" 873 874/* Fill in the .plt section. */ 875 876static void 877sparc64_elf_build_plt (output_bfd, contents, nentries) 878 bfd *output_bfd; 879 unsigned char *contents; 880 int nentries; 881{ 882 const unsigned int nop = 0x01000000; 883 int i, j; 884 885 /* The first four entries are reserved, and are initially undefined. 886 We fill them with `illtrap 0' to force ld.so to do something. */ 887 888 for (i = 0; i < PLT_HEADER_SIZE/4; ++i) 889 bfd_put_32 (output_bfd, (bfd_vma) 0, contents+i*4); 890 891 /* The first 32768 entries are close enough to plt1 to get there via 892 a straight branch. */ 893 894 for (i = 4; i < LARGE_PLT_THRESHOLD && i < nentries; ++i) 895 { 896 unsigned char *entry = contents + i * PLT_ENTRY_SIZE; 897 unsigned int sethi, ba; 898 899 /* sethi (. - plt0), %g1 */ 900 sethi = 0x03000000 | (i * PLT_ENTRY_SIZE); 901 902 /* ba,a,pt %xcc, plt1 */ 903 ba = 0x30680000 | (((contents+PLT_ENTRY_SIZE) - (entry+4)) / 4 & 0x7ffff); 904 905 bfd_put_32 (output_bfd, (bfd_vma) sethi, entry); 906 bfd_put_32 (output_bfd, (bfd_vma) ba, entry + 4); 907 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8); 908 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 12); 909 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 16); 910 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 20); 911 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 24); 912 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 28); 913 } 914 915 /* Now the tricky bit. Entries 32768 and higher are grouped in blocks of 916 160: 160 entries and 160 pointers. This is to separate code from data, 917 which is much friendlier on the cache. */ 918 919 for (; i < nentries; i += 160) 920 { 921 int block = (i + 160 <= nentries ? 160 : nentries - i); 922 for (j = 0; j < block; ++j) 923 { 924 unsigned char *entry, *ptr; 925 unsigned int ldx; 926 927 entry = contents + i*PLT_ENTRY_SIZE + j*4*6; 928 ptr = contents + i*PLT_ENTRY_SIZE + block*4*6 + j*8; 929 930 /* ldx [%o7 + ptr - (entry+4)], %g1 */ 931 ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff); 932 933 /* mov %o7,%g5 934 call .+8 935 nop 936 ldx [%o7+P],%g1 937 jmpl %o7+%g1,%g1 938 mov %g5,%o7 */ 939 bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry); 940 bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4); 941 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8); 942 bfd_put_32 (output_bfd, (bfd_vma) ldx, entry + 12); 943 bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16); 944 bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20); 945 946 bfd_put_64 (output_bfd, (bfd_vma) (contents - (entry + 4)), ptr); 947 } 948 } 949} 950 951/* Return the offset of a particular plt entry within the .plt section. */ 952 953static bfd_vma 954sparc64_elf_plt_entry_offset (index) 955 bfd_vma index; 956{ 957 bfd_vma block, ofs; 958 959 if (index < LARGE_PLT_THRESHOLD) 960 return index * PLT_ENTRY_SIZE; 961 962 /* See above for details. */ 963 964 block = (index - LARGE_PLT_THRESHOLD) / 160; 965 ofs = (index - LARGE_PLT_THRESHOLD) % 160; 966 967 return (LARGE_PLT_THRESHOLD + block * 160) * PLT_ENTRY_SIZE + ofs * 6 * 4; 968} 969 970static bfd_vma 971sparc64_elf_plt_ptr_offset (index, max) 972 bfd_vma index; 973 bfd_vma max; 974{ 975 bfd_vma block, ofs, last; 976 977 BFD_ASSERT(index >= LARGE_PLT_THRESHOLD); 978 979 /* See above for details. */ 980 981 block = (((index - LARGE_PLT_THRESHOLD) / 160) * 160) + LARGE_PLT_THRESHOLD; 982 ofs = index - block; 983 if (block + 160 > max) 984 last = (max - LARGE_PLT_THRESHOLD) % 160; 985 else 986 last = 160; 987 988 return (block * PLT_ENTRY_SIZE 989 + last * 6*4 990 + ofs * 8); 991} 992 993/* Look through the relocs for a section during the first phase, and 994 allocate space in the global offset table or procedure linkage 995 table. */ 996 997static boolean 998sparc64_elf_check_relocs (abfd, info, sec, relocs) 999 bfd *abfd; 1000 struct bfd_link_info *info; 1001 asection *sec; 1002 const Elf_Internal_Rela *relocs; 1003{ 1004 bfd *dynobj; 1005 Elf_Internal_Shdr *symtab_hdr; 1006 struct elf_link_hash_entry **sym_hashes; 1007 bfd_vma *local_got_offsets; 1008 const Elf_Internal_Rela *rel; 1009 const Elf_Internal_Rela *rel_end; 1010 asection *sgot; 1011 asection *srelgot; 1012 asection *sreloc; 1013 1014 if (info->relocateable || !(sec->flags & SEC_ALLOC)) 1015 return true; 1016 1017 dynobj = elf_hash_table (info)->dynobj; 1018 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1019 sym_hashes = elf_sym_hashes (abfd); 1020 local_got_offsets = elf_local_got_offsets (abfd); 1021 1022 sgot = NULL; 1023 srelgot = NULL; 1024 sreloc = NULL; 1025 1026 rel_end = relocs + NUM_SHDR_ENTRIES (& elf_section_data (sec)->rel_hdr); 1027 for (rel = relocs; rel < rel_end; rel++) 1028 { 1029 unsigned long r_symndx; 1030 struct elf_link_hash_entry *h; 1031 1032 r_symndx = ELF64_R_SYM (rel->r_info); 1033 if (r_symndx < symtab_hdr->sh_info) 1034 h = NULL; 1035 else 1036 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1037 1038 switch (ELF64_R_TYPE_ID (rel->r_info)) 1039 { 1040 case R_SPARC_GOT10: 1041 case R_SPARC_GOT13: 1042 case R_SPARC_GOT22: 1043 /* This symbol requires a global offset table entry. */ 1044 1045 if (dynobj == NULL) 1046 { 1047 /* Create the .got section. */ 1048 elf_hash_table (info)->dynobj = dynobj = abfd; 1049 if (! _bfd_elf_create_got_section (dynobj, info)) 1050 return false; 1051 } 1052 1053 if (sgot == NULL) 1054 { 1055 sgot = bfd_get_section_by_name (dynobj, ".got"); 1056 BFD_ASSERT (sgot != NULL); 1057 } 1058 1059 if (srelgot == NULL && (h != NULL || info->shared)) 1060 { 1061 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 1062 if (srelgot == NULL) 1063 { 1064 srelgot = bfd_make_section (dynobj, ".rela.got"); 1065 if (srelgot == NULL 1066 || ! bfd_set_section_flags (dynobj, srelgot, 1067 (SEC_ALLOC 1068 | SEC_LOAD 1069 | SEC_HAS_CONTENTS 1070 | SEC_IN_MEMORY 1071 | SEC_LINKER_CREATED 1072 | SEC_READONLY)) 1073 || ! bfd_set_section_alignment (dynobj, srelgot, 3)) 1074 return false; 1075 } 1076 } 1077 1078 if (h != NULL) 1079 { 1080 if (h->got.offset != (bfd_vma) -1) 1081 { 1082 /* We have already allocated space in the .got. */ 1083 break; 1084 } 1085 h->got.offset = sgot->_raw_size; 1086 1087 /* Make sure this symbol is output as a dynamic symbol. */ 1088 if (h->dynindx == -1) 1089 { 1090 if (! bfd_elf64_link_record_dynamic_symbol (info, h)) 1091 return false; 1092 } 1093 1094 srelgot->_raw_size += sizeof (Elf64_External_Rela); 1095 } 1096 else 1097 { 1098 /* This is a global offset table entry for a local 1099 symbol. */ 1100 if (local_got_offsets == NULL) 1101 { 1102 bfd_size_type size; 1103 register unsigned int i; 1104 1105 size = symtab_hdr->sh_info; 1106 size *= sizeof (bfd_vma); 1107 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size); 1108 if (local_got_offsets == NULL) 1109 return false; 1110 elf_local_got_offsets (abfd) = local_got_offsets; 1111 for (i = 0; i < symtab_hdr->sh_info; i++) 1112 local_got_offsets[i] = (bfd_vma) -1; 1113 } 1114 if (local_got_offsets[r_symndx] != (bfd_vma) -1) 1115 { 1116 /* We have already allocated space in the .got. */ 1117 break; 1118 } 1119 local_got_offsets[r_symndx] = sgot->_raw_size; 1120 1121 if (info->shared) 1122 { 1123 /* If we are generating a shared object, we need to 1124 output a R_SPARC_RELATIVE reloc so that the 1125 dynamic linker can adjust this GOT entry. */ 1126 srelgot->_raw_size += sizeof (Elf64_External_Rela); 1127 } 1128 } 1129 1130 sgot->_raw_size += 8; 1131 1132#if 0 1133 /* Doesn't work for 64-bit -fPIC, since sethi/or builds 1134 unsigned numbers. If we permit ourselves to modify 1135 code so we get sethi/xor, this could work. 1136 Question: do we consider conditionally re-enabling 1137 this for -fpic, once we know about object code models? */ 1138 /* If the .got section is more than 0x1000 bytes, we add 1139 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13 1140 bit relocations have a greater chance of working. */ 1141 if (sgot->_raw_size >= 0x1000 1142 && elf_hash_table (info)->hgot->root.u.def.value == 0) 1143 elf_hash_table (info)->hgot->root.u.def.value = 0x1000; 1144#endif 1145 1146 break; 1147 1148 case R_SPARC_WPLT30: 1149 case R_SPARC_PLT32: 1150 case R_SPARC_HIPLT22: 1151 case R_SPARC_LOPLT10: 1152 case R_SPARC_PCPLT32: 1153 case R_SPARC_PCPLT22: 1154 case R_SPARC_PCPLT10: 1155 case R_SPARC_PLT64: 1156 /* This symbol requires a procedure linkage table entry. We 1157 actually build the entry in adjust_dynamic_symbol, 1158 because this might be a case of linking PIC code without 1159 linking in any dynamic objects, in which case we don't 1160 need to generate a procedure linkage table after all. */ 1161 1162 if (h == NULL) 1163 { 1164 /* It does not make sense to have a procedure linkage 1165 table entry for a local symbol. */ 1166 bfd_set_error (bfd_error_bad_value); 1167 return false; 1168 } 1169 1170 /* Make sure this symbol is output as a dynamic symbol. */ 1171 if (h->dynindx == -1) 1172 { 1173 if (! bfd_elf64_link_record_dynamic_symbol (info, h)) 1174 return false; 1175 } 1176 1177 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 1178 if (ELF64_R_TYPE_ID (rel->r_info) != R_SPARC_PLT32 1179 && ELF64_R_TYPE_ID (rel->r_info) != R_SPARC_PLT64) 1180 break; 1181 /* Fall through. */ 1182 case R_SPARC_PC10: 1183 case R_SPARC_PC22: 1184 case R_SPARC_PC_HH22: 1185 case R_SPARC_PC_HM10: 1186 case R_SPARC_PC_LM22: 1187 if (h != NULL 1188 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1189 break; 1190 /* Fall through. */ 1191 case R_SPARC_DISP8: 1192 case R_SPARC_DISP16: 1193 case R_SPARC_DISP32: 1194 case R_SPARC_DISP64: 1195 case R_SPARC_WDISP30: 1196 case R_SPARC_WDISP22: 1197 case R_SPARC_WDISP19: 1198 case R_SPARC_WDISP16: 1199 if (h == NULL) 1200 break; 1201 /* Fall through. */ 1202 case R_SPARC_8: 1203 case R_SPARC_16: 1204 case R_SPARC_32: 1205 case R_SPARC_HI22: 1206 case R_SPARC_22: 1207 case R_SPARC_13: 1208 case R_SPARC_LO10: 1209 case R_SPARC_UA32: 1210 case R_SPARC_10: 1211 case R_SPARC_11: 1212 case R_SPARC_64: 1213 case R_SPARC_OLO10: 1214 case R_SPARC_HH22: 1215 case R_SPARC_HM10: 1216 case R_SPARC_LM22: 1217 case R_SPARC_7: 1218 case R_SPARC_5: 1219 case R_SPARC_6: 1220 case R_SPARC_HIX22: 1221 case R_SPARC_LOX10: 1222 case R_SPARC_H44: 1223 case R_SPARC_M44: 1224 case R_SPARC_L44: 1225 case R_SPARC_UA64: 1226 case R_SPARC_UA16: 1227 /* When creating a shared object, we must copy these relocs 1228 into the output file. We create a reloc section in 1229 dynobj and make room for the reloc. 1230 1231 But don't do this for debugging sections -- this shows up 1232 with DWARF2 -- first because they are not loaded, and 1233 second because DWARF sez the debug info is not to be 1234 biased by the load address. */ 1235 if (info->shared && (sec->flags & SEC_ALLOC)) 1236 { 1237 if (sreloc == NULL) 1238 { 1239 const char *name; 1240 1241 name = (bfd_elf_string_from_elf_section 1242 (abfd, 1243 elf_elfheader (abfd)->e_shstrndx, 1244 elf_section_data (sec)->rel_hdr.sh_name)); 1245 if (name == NULL) 1246 return false; 1247 1248 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 1249 && strcmp (bfd_get_section_name (abfd, sec), 1250 name + 5) == 0); 1251 1252 sreloc = bfd_get_section_by_name (dynobj, name); 1253 if (sreloc == NULL) 1254 { 1255 flagword flags; 1256 1257 sreloc = bfd_make_section (dynobj, name); 1258 flags = (SEC_HAS_CONTENTS | SEC_READONLY 1259 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 1260 if ((sec->flags & SEC_ALLOC) != 0) 1261 flags |= SEC_ALLOC | SEC_LOAD; 1262 if (sreloc == NULL 1263 || ! bfd_set_section_flags (dynobj, sreloc, flags) 1264 || ! bfd_set_section_alignment (dynobj, sreloc, 3)) 1265 return false; 1266 } 1267 if (sec->flags & SEC_READONLY) 1268 info->flags |= DF_TEXTREL; 1269 } 1270 1271 sreloc->_raw_size += sizeof (Elf64_External_Rela); 1272 } 1273 break; 1274 1275 case R_SPARC_REGISTER: 1276 /* Nothing to do. */ 1277 break; 1278 1279 default: 1280 (*_bfd_error_handler) (_("%s: check_relocs: unhandled reloc type %d"), 1281 bfd_archive_filename (abfd), 1282 ELF64_R_TYPE_ID (rel->r_info)); 1283 return false; 1284 } 1285 } 1286 1287 return true; 1288} 1289 1290/* Hook called by the linker routine which adds symbols from an object 1291 file. We use it for STT_REGISTER symbols. */ 1292 1293static boolean 1294sparc64_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp) 1295 bfd *abfd; 1296 struct bfd_link_info *info; 1297 const Elf_Internal_Sym *sym; 1298 const char **namep; 1299 flagword *flagsp ATTRIBUTE_UNUSED; 1300 asection **secp ATTRIBUTE_UNUSED; 1301 bfd_vma *valp ATTRIBUTE_UNUSED; 1302{ 1303 static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" }; 1304 1305 if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER) 1306 { 1307 int reg; 1308 struct sparc64_elf_app_reg *p; 1309 1310 reg = (int)sym->st_value; 1311 switch (reg & ~1) 1312 { 1313 case 2: reg -= 2; break; 1314 case 6: reg -= 4; break; 1315 default: 1316 (*_bfd_error_handler) 1317 (_("%s: Only registers %%g[2367] can be declared using STT_REGISTER"), 1318 bfd_archive_filename (abfd)); 1319 return false; 1320 } 1321 1322 if (info->hash->creator != abfd->xvec 1323 || (abfd->flags & DYNAMIC) != 0) 1324 { 1325 /* STT_REGISTER only works when linking an elf64_sparc object. 1326 If STT_REGISTER comes from a dynamic object, don't put it into 1327 the output bfd. The dynamic linker will recheck it. */ 1328 *namep = NULL; 1329 return true; 1330 } 1331 1332 p = sparc64_elf_hash_table(info)->app_regs + reg; 1333 1334 if (p->name != NULL && strcmp (p->name, *namep)) 1335 { 1336 (*_bfd_error_handler) 1337 (_("Register %%g%d used incompatibly: %s in %s, previously %s in %s"), 1338 (int) sym->st_value, 1339 **namep ? *namep : "#scratch", bfd_archive_filename (abfd), 1340 *p->name ? p->name : "#scratch", bfd_archive_filename (p->abfd)); 1341 return false; 1342 } 1343 1344 if (p->name == NULL) 1345 { 1346 if (**namep) 1347 { 1348 struct elf_link_hash_entry *h; 1349 1350 h = (struct elf_link_hash_entry *) 1351 bfd_link_hash_lookup (info->hash, *namep, false, false, false); 1352 1353 if (h != NULL) 1354 { 1355 unsigned char type = h->type; 1356 1357 if (type > STT_FUNC) 1358 type = 0; 1359 (*_bfd_error_handler) 1360 (_("Symbol `%s' has differing types: REGISTER in %s, previously %s in %s"), 1361 *namep, bfd_archive_filename (abfd), 1362 stt_types[type], bfd_archive_filename (p->abfd)); 1363 return false; 1364 } 1365 1366 p->name = bfd_hash_allocate (&info->hash->table, 1367 strlen (*namep) + 1); 1368 if (!p->name) 1369 return false; 1370 1371 strcpy (p->name, *namep); 1372 } 1373 else 1374 p->name = ""; 1375 p->bind = ELF_ST_BIND (sym->st_info); 1376 p->abfd = abfd; 1377 p->shndx = sym->st_shndx; 1378 } 1379 else 1380 { 1381 if (p->bind == STB_WEAK 1382 && ELF_ST_BIND (sym->st_info) == STB_GLOBAL) 1383 { 1384 p->bind = STB_GLOBAL; 1385 p->abfd = abfd; 1386 } 1387 } 1388 *namep = NULL; 1389 return true; 1390 } 1391 else if (*namep && **namep 1392 && info->hash->creator == abfd->xvec) 1393 { 1394 int i; 1395 struct sparc64_elf_app_reg *p; 1396 1397 p = sparc64_elf_hash_table(info)->app_regs; 1398 for (i = 0; i < 4; i++, p++) 1399 if (p->name != NULL && ! strcmp (p->name, *namep)) 1400 { 1401 unsigned char type = ELF_ST_TYPE (sym->st_info); 1402 1403 if (type > STT_FUNC) 1404 type = 0; 1405 (*_bfd_error_handler) 1406 (_("Symbol `%s' has differing types: %s in %s, previously REGISTER in %s"), 1407 *namep, stt_types[type], bfd_archive_filename (abfd), 1408 bfd_archive_filename (p->abfd)); 1409 return false; 1410 } 1411 } 1412 return true; 1413} 1414 1415/* This function takes care of emiting STT_REGISTER symbols 1416 which we cannot easily keep in the symbol hash table. */ 1417 1418static boolean 1419sparc64_elf_output_arch_syms (output_bfd, info, finfo, func) 1420 bfd *output_bfd ATTRIBUTE_UNUSED; 1421 struct bfd_link_info *info; 1422 PTR finfo; 1423 boolean (*func) PARAMS ((PTR, const char *, 1424 Elf_Internal_Sym *, asection *)); 1425{ 1426 int reg; 1427 struct sparc64_elf_app_reg *app_regs = 1428 sparc64_elf_hash_table(info)->app_regs; 1429 Elf_Internal_Sym sym; 1430 1431 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries 1432 at the end of the dynlocal list, so they came at the end of the local 1433 symbols in the symtab. Except that they aren't STB_LOCAL, so we need 1434 to back up symtab->sh_info. */ 1435 if (elf_hash_table (info)->dynlocal) 1436 { 1437 bfd * dynobj = elf_hash_table (info)->dynobj; 1438 asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym"); 1439 struct elf_link_local_dynamic_entry *e; 1440 1441 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next) 1442 if (e->input_indx == -1) 1443 break; 1444 if (e) 1445 { 1446 elf_section_data (dynsymsec->output_section)->this_hdr.sh_info 1447 = e->dynindx; 1448 } 1449 } 1450 1451 if (info->strip == strip_all) 1452 return true; 1453 1454 for (reg = 0; reg < 4; reg++) 1455 if (app_regs [reg].name != NULL) 1456 { 1457 if (info->strip == strip_some 1458 && bfd_hash_lookup (info->keep_hash, 1459 app_regs [reg].name, 1460 false, false) == NULL) 1461 continue; 1462 1463 sym.st_value = reg < 2 ? reg + 2 : reg + 4; 1464 sym.st_size = 0; 1465 sym.st_other = 0; 1466 sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER); 1467 sym.st_shndx = app_regs [reg].shndx; 1468 if (! (*func) (finfo, app_regs [reg].name, &sym, 1469 sym.st_shndx == SHN_ABS 1470 ? bfd_abs_section_ptr : bfd_und_section_ptr)) 1471 return false; 1472 } 1473 1474 return true; 1475} 1476 1477static int 1478sparc64_elf_get_symbol_type (elf_sym, type) 1479 Elf_Internal_Sym * elf_sym; 1480 int type; 1481{ 1482 if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER) 1483 return STT_REGISTER; 1484 else 1485 return type; 1486} 1487 1488/* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL 1489 even in SHN_UNDEF section. */ 1490 1491static void 1492sparc64_elf_symbol_processing (abfd, asym) 1493 bfd *abfd ATTRIBUTE_UNUSED; 1494 asymbol *asym; 1495{ 1496 elf_symbol_type *elfsym; 1497 1498 elfsym = (elf_symbol_type *) asym; 1499 if (elfsym->internal_elf_sym.st_info 1500 == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER)) 1501 { 1502 asym->flags |= BSF_GLOBAL; 1503 } 1504} 1505 1506/* Adjust a symbol defined by a dynamic object and referenced by a 1507 regular object. The current definition is in some section of the 1508 dynamic object, but we're not including those sections. We have to 1509 change the definition to something the rest of the link can 1510 understand. */ 1511 1512static boolean 1513sparc64_elf_adjust_dynamic_symbol (info, h) 1514 struct bfd_link_info *info; 1515 struct elf_link_hash_entry *h; 1516{ 1517 bfd *dynobj; 1518 asection *s; 1519 unsigned int power_of_two; 1520 1521 dynobj = elf_hash_table (info)->dynobj; 1522 1523 /* Make sure we know what is going on here. */ 1524 BFD_ASSERT (dynobj != NULL 1525 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) 1526 || h->weakdef != NULL 1527 || ((h->elf_link_hash_flags 1528 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 1529 && (h->elf_link_hash_flags 1530 & ELF_LINK_HASH_REF_REGULAR) != 0 1531 && (h->elf_link_hash_flags 1532 & ELF_LINK_HASH_DEF_REGULAR) == 0))); 1533 1534 /* If this is a function, put it in the procedure linkage table. We 1535 will fill in the contents of the procedure linkage table later 1536 (although we could actually do it here). The STT_NOTYPE 1537 condition is a hack specifically for the Oracle libraries 1538 delivered for Solaris; for some inexplicable reason, they define 1539 some of their functions as STT_NOTYPE when they really should be 1540 STT_FUNC. */ 1541 if (h->type == STT_FUNC 1542 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0 1543 || (h->type == STT_NOTYPE 1544 && (h->root.type == bfd_link_hash_defined 1545 || h->root.type == bfd_link_hash_defweak) 1546 && (h->root.u.def.section->flags & SEC_CODE) != 0)) 1547 { 1548 if (! elf_hash_table (info)->dynamic_sections_created) 1549 { 1550 /* This case can occur if we saw a WPLT30 reloc in an input 1551 file, but none of the input files were dynamic objects. 1552 In such a case, we don't actually need to build a 1553 procedure linkage table, and we can just do a WDISP30 1554 reloc instead. */ 1555 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0); 1556 return true; 1557 } 1558 1559 s = bfd_get_section_by_name (dynobj, ".plt"); 1560 BFD_ASSERT (s != NULL); 1561 1562 /* The first four bit in .plt is reserved. */ 1563 if (s->_raw_size == 0) 1564 s->_raw_size = PLT_HEADER_SIZE; 1565 1566 /* To simplify matters later, just store the plt index here. */ 1567 h->plt.offset = s->_raw_size / PLT_ENTRY_SIZE; 1568 1569 /* If this symbol is not defined in a regular file, and we are 1570 not generating a shared library, then set the symbol to this 1571 location in the .plt. This is required to make function 1572 pointers compare as equal between the normal executable and 1573 the shared library. */ 1574 if (! info->shared 1575 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1576 { 1577 h->root.u.def.section = s; 1578 h->root.u.def.value = sparc64_elf_plt_entry_offset (h->plt.offset); 1579 } 1580 1581 /* Make room for this entry. */ 1582 s->_raw_size += PLT_ENTRY_SIZE; 1583 1584 /* We also need to make an entry in the .rela.plt section. */ 1585 1586 s = bfd_get_section_by_name (dynobj, ".rela.plt"); 1587 BFD_ASSERT (s != NULL); 1588 1589 s->_raw_size += sizeof (Elf64_External_Rela); 1590 1591 /* The procedure linkage table size is bounded by the magnitude 1592 of the offset we can describe in the entry. */ 1593 if (s->_raw_size >= (bfd_vma)1 << 32) 1594 { 1595 bfd_set_error (bfd_error_bad_value); 1596 return false; 1597 } 1598 1599 return true; 1600 } 1601 1602 /* If this is a weak symbol, and there is a real definition, the 1603 processor independent code will have arranged for us to see the 1604 real definition first, and we can just use the same value. */ 1605 if (h->weakdef != NULL) 1606 { 1607 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 1608 || h->weakdef->root.type == bfd_link_hash_defweak); 1609 h->root.u.def.section = h->weakdef->root.u.def.section; 1610 h->root.u.def.value = h->weakdef->root.u.def.value; 1611 return true; 1612 } 1613 1614 /* This is a reference to a symbol defined by a dynamic object which 1615 is not a function. */ 1616 1617 /* If we are creating a shared library, we must presume that the 1618 only references to the symbol are via the global offset table. 1619 For such cases we need not do anything here; the relocations will 1620 be handled correctly by relocate_section. */ 1621 if (info->shared) 1622 return true; 1623 1624 /* We must allocate the symbol in our .dynbss section, which will 1625 become part of the .bss section of the executable. There will be 1626 an entry for this symbol in the .dynsym section. The dynamic 1627 object will contain position independent code, so all references 1628 from the dynamic object to this symbol will go through the global 1629 offset table. The dynamic linker will use the .dynsym entry to 1630 determine the address it must put in the global offset table, so 1631 both the dynamic object and the regular object will refer to the 1632 same memory location for the variable. */ 1633 1634 s = bfd_get_section_by_name (dynobj, ".dynbss"); 1635 BFD_ASSERT (s != NULL); 1636 1637 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker 1638 to copy the initial value out of the dynamic object and into the 1639 runtime process image. We need to remember the offset into the 1640 .rel.bss section we are going to use. */ 1641 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 1642 { 1643 asection *srel; 1644 1645 srel = bfd_get_section_by_name (dynobj, ".rela.bss"); 1646 BFD_ASSERT (srel != NULL); 1647 srel->_raw_size += sizeof (Elf64_External_Rela); 1648 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 1649 } 1650 1651 /* We need to figure out the alignment required for this symbol. I 1652 have no idea how ELF linkers handle this. 16-bytes is the size 1653 of the largest type that requires hard alignment -- long double. */ 1654 power_of_two = bfd_log2 (h->size); 1655 if (power_of_two > 4) 1656 power_of_two = 4; 1657 1658 /* Apply the required alignment. */ 1659 s->_raw_size = BFD_ALIGN (s->_raw_size, 1660 (bfd_size_type) (1 << power_of_two)); 1661 if (power_of_two > bfd_get_section_alignment (dynobj, s)) 1662 { 1663 if (! bfd_set_section_alignment (dynobj, s, power_of_two)) 1664 return false; 1665 } 1666 1667 /* Define the symbol as being at this point in the section. */ 1668 h->root.u.def.section = s; 1669 h->root.u.def.value = s->_raw_size; 1670 1671 /* Increment the section size to make room for the symbol. */ 1672 s->_raw_size += h->size; 1673 1674 return true; 1675} 1676 1677/* Set the sizes of the dynamic sections. */ 1678 1679static boolean 1680sparc64_elf_size_dynamic_sections (output_bfd, info) 1681 bfd *output_bfd; 1682 struct bfd_link_info *info; 1683{ 1684 bfd *dynobj; 1685 asection *s; 1686 boolean relplt; 1687 1688 dynobj = elf_hash_table (info)->dynobj; 1689 BFD_ASSERT (dynobj != NULL); 1690 1691 if (elf_hash_table (info)->dynamic_sections_created) 1692 { 1693 /* Set the contents of the .interp section to the interpreter. */ 1694 if (! info->shared) 1695 { 1696 s = bfd_get_section_by_name (dynobj, ".interp"); 1697 BFD_ASSERT (s != NULL); 1698 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 1699 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1700 } 1701 } 1702 else 1703 { 1704 /* We may have created entries in the .rela.got section. 1705 However, if we are not creating the dynamic sections, we will 1706 not actually use these entries. Reset the size of .rela.got, 1707 which will cause it to get stripped from the output file 1708 below. */ 1709 s = bfd_get_section_by_name (dynobj, ".rela.got"); 1710 if (s != NULL) 1711 s->_raw_size = 0; 1712 } 1713 1714 /* The check_relocs and adjust_dynamic_symbol entry points have 1715 determined the sizes of the various dynamic sections. Allocate 1716 memory for them. */ 1717 relplt = false; 1718 for (s = dynobj->sections; s != NULL; s = s->next) 1719 { 1720 const char *name; 1721 boolean strip; 1722 1723 if ((s->flags & SEC_LINKER_CREATED) == 0) 1724 continue; 1725 1726 /* It's OK to base decisions on the section name, because none 1727 of the dynobj section names depend upon the input files. */ 1728 name = bfd_get_section_name (dynobj, s); 1729 1730 strip = false; 1731 1732 if (strncmp (name, ".rela", 5) == 0) 1733 { 1734 if (s->_raw_size == 0) 1735 { 1736 /* If we don't need this section, strip it from the 1737 output file. This is to handle .rela.bss and 1738 .rel.plt. We must create it in 1739 create_dynamic_sections, because it must be created 1740 before the linker maps input sections to output 1741 sections. The linker does that before 1742 adjust_dynamic_symbol is called, and it is that 1743 function which decides whether anything needs to go 1744 into these sections. */ 1745 strip = true; 1746 } 1747 else 1748 { 1749 if (strcmp (name, ".rela.plt") == 0) 1750 relplt = true; 1751 1752 /* We use the reloc_count field as a counter if we need 1753 to copy relocs into the output file. */ 1754 s->reloc_count = 0; 1755 } 1756 } 1757 else if (strcmp (name, ".plt") != 0 1758 && strncmp (name, ".got", 4) != 0) 1759 { 1760 /* It's not one of our sections, so don't allocate space. */ 1761 continue; 1762 } 1763 1764 if (strip) 1765 { 1766 _bfd_strip_section_from_output (info, s); 1767 continue; 1768 } 1769 1770 /* Allocate memory for the section contents. Zero the memory 1771 for the benefit of .rela.plt, which has 4 unused entries 1772 at the beginning, and we don't want garbage. */ 1773 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 1774 if (s->contents == NULL && s->_raw_size != 0) 1775 return false; 1776 } 1777 1778 if (elf_hash_table (info)->dynamic_sections_created) 1779 { 1780 /* Add some entries to the .dynamic section. We fill in the 1781 values later, in sparc64_elf_finish_dynamic_sections, but we 1782 must add the entries now so that we get the correct size for 1783 the .dynamic section. The DT_DEBUG entry is filled in by the 1784 dynamic linker and used by the debugger. */ 1785#define add_dynamic_entry(TAG, VAL) \ 1786 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL)) 1787 1788 int reg; 1789 struct sparc64_elf_app_reg * app_regs; 1790 struct elf_strtab_hash *dynstr; 1791 struct elf_link_hash_table *eht = elf_hash_table (info); 1792 1793 if (!info->shared) 1794 { 1795 if (!add_dynamic_entry (DT_DEBUG, 0)) 1796 return false; 1797 } 1798 1799 if (relplt) 1800 { 1801 if (!add_dynamic_entry (DT_PLTGOT, 0) 1802 || !add_dynamic_entry (DT_PLTRELSZ, 0) 1803 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 1804 || !add_dynamic_entry (DT_JMPREL, 0)) 1805 return false; 1806 } 1807 1808 if (!add_dynamic_entry (DT_RELA, 0) 1809 || !add_dynamic_entry (DT_RELASZ, 0) 1810 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela))) 1811 return false; 1812 1813 if (info->flags & DF_TEXTREL) 1814 { 1815 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1816 return false; 1817 } 1818 1819 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER 1820 entries if needed. */ 1821 app_regs = sparc64_elf_hash_table (info)->app_regs; 1822 dynstr = eht->dynstr; 1823 1824 for (reg = 0; reg < 4; reg++) 1825 if (app_regs [reg].name != NULL) 1826 { 1827 struct elf_link_local_dynamic_entry *entry, *e; 1828 1829 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0)) 1830 return false; 1831 1832 entry = (struct elf_link_local_dynamic_entry *) 1833 bfd_hash_allocate (&info->hash->table, sizeof (*entry)); 1834 if (entry == NULL) 1835 return false; 1836 1837 /* We cheat here a little bit: the symbol will not be local, so we 1838 put it at the end of the dynlocal linked list. We will fix it 1839 later on, as we have to fix other fields anyway. */ 1840 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4; 1841 entry->isym.st_size = 0; 1842 if (*app_regs [reg].name != '\0') 1843 entry->isym.st_name 1844 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, false); 1845 else 1846 entry->isym.st_name = 0; 1847 entry->isym.st_other = 0; 1848 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind, 1849 STT_REGISTER); 1850 entry->isym.st_shndx = app_regs [reg].shndx; 1851 entry->next = NULL; 1852 entry->input_bfd = output_bfd; 1853 entry->input_indx = -1; 1854 1855 if (eht->dynlocal == NULL) 1856 eht->dynlocal = entry; 1857 else 1858 { 1859 for (e = eht->dynlocal; e->next; e = e->next) 1860 ; 1861 e->next = entry; 1862 } 1863 eht->dynsymcount++; 1864 } 1865 } 1866#undef add_dynamic_entry 1867 1868 return true; 1869} 1870 1871#define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0) 1872#define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1) 1873 1874static boolean 1875sparc64_elf_relax_section (abfd, section, link_info, again) 1876 bfd *abfd ATTRIBUTE_UNUSED; 1877 asection *section ATTRIBUTE_UNUSED; 1878 struct bfd_link_info *link_info ATTRIBUTE_UNUSED; 1879 boolean *again; 1880{ 1881 *again = false; 1882 SET_SEC_DO_RELAX (section); 1883 return true; 1884} 1885 1886/* This is the condition under which finish_dynamic_symbol will be called 1887 from elflink.h. If elflink.h doesn't call our finish_dynamic_symbol 1888 routine, we'll need to do something about initializing any .plt and 1889 .got entries in relocate_section. */ 1890#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \ 1891 ((DYN) \ 1892 && ((INFO)->shared \ 1893 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \ 1894 && ((H)->dynindx != -1 \ 1895 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)) 1896 1897/* Relocate a SPARC64 ELF section. */ 1898 1899static boolean 1900sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section, 1901 contents, relocs, local_syms, local_sections) 1902 bfd *output_bfd; 1903 struct bfd_link_info *info; 1904 bfd *input_bfd; 1905 asection *input_section; 1906 bfd_byte *contents; 1907 Elf_Internal_Rela *relocs; 1908 Elf_Internal_Sym *local_syms; 1909 asection **local_sections; 1910{ 1911 bfd *dynobj; 1912 Elf_Internal_Shdr *symtab_hdr; 1913 struct elf_link_hash_entry **sym_hashes; 1914 bfd_vma *local_got_offsets; 1915 bfd_vma got_base; 1916 asection *sgot; 1917 asection *splt; 1918 asection *sreloc; 1919 Elf_Internal_Rela *rel; 1920 Elf_Internal_Rela *relend; 1921 1922 dynobj = elf_hash_table (info)->dynobj; 1923 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1924 sym_hashes = elf_sym_hashes (input_bfd); 1925 local_got_offsets = elf_local_got_offsets (input_bfd); 1926 1927 if (elf_hash_table(info)->hgot == NULL) 1928 got_base = 0; 1929 else 1930 got_base = elf_hash_table (info)->hgot->root.u.def.value; 1931 1932 sgot = splt = sreloc = NULL; 1933 1934 rel = relocs; 1935 relend = relocs + NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr); 1936 for (; rel < relend; rel++) 1937 { 1938 int r_type; 1939 reloc_howto_type *howto; 1940 unsigned long r_symndx; 1941 struct elf_link_hash_entry *h; 1942 Elf_Internal_Sym *sym; 1943 asection *sec; 1944 bfd_vma relocation, off; 1945 bfd_reloc_status_type r; 1946 boolean is_plt = false; 1947 boolean unresolved_reloc; 1948 1949 r_type = ELF64_R_TYPE_ID (rel->r_info); 1950 if (r_type < 0 || r_type >= (int) R_SPARC_max_std) 1951 { 1952 bfd_set_error (bfd_error_bad_value); 1953 return false; 1954 } 1955 howto = sparc64_elf_howto_table + r_type; 1956 1957 r_symndx = ELF64_R_SYM (rel->r_info); 1958 1959 if (info->relocateable) 1960 { 1961 /* This is a relocateable link. We don't have to change 1962 anything, unless the reloc is against a section symbol, 1963 in which case we have to adjust according to where the 1964 section symbol winds up in the output section. */ 1965 if (r_symndx < symtab_hdr->sh_info) 1966 { 1967 sym = local_syms + r_symndx; 1968 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1969 { 1970 sec = local_sections[r_symndx]; 1971 rel->r_addend += sec->output_offset + sym->st_value; 1972 } 1973 } 1974 1975 continue; 1976 } 1977 1978 /* This is a final link. */ 1979 h = NULL; 1980 sym = NULL; 1981 sec = NULL; 1982 unresolved_reloc = false; 1983 if (r_symndx < symtab_hdr->sh_info) 1984 { 1985 sym = local_syms + r_symndx; 1986 sec = local_sections[r_symndx]; 1987 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel); 1988 } 1989 else 1990 { 1991 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1992 while (h->root.type == bfd_link_hash_indirect 1993 || h->root.type == bfd_link_hash_warning) 1994 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1995 1996 relocation = 0; 1997 if (h->root.type == bfd_link_hash_defined 1998 || h->root.type == bfd_link_hash_defweak) 1999 { 2000 sec = h->root.u.def.section; 2001 if (sec->output_section == NULL) 2002 /* Set a flag that will be cleared later if we find a 2003 relocation value for this symbol. output_section 2004 is typically NULL for symbols satisfied by a shared 2005 library. */ 2006 unresolved_reloc = true; 2007 else 2008 relocation = (h->root.u.def.value 2009 + sec->output_section->vma 2010 + sec->output_offset); 2011 } 2012 else if (h->root.type == bfd_link_hash_undefweak) 2013 ; 2014 else if (info->shared 2015 && (!info->symbolic || info->allow_shlib_undefined) 2016 && !info->no_undefined 2017 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 2018 ; 2019 else 2020 { 2021 if (! ((*info->callbacks->undefined_symbol) 2022 (info, h->root.root.string, input_bfd, 2023 input_section, rel->r_offset, 2024 (!info->shared || info->no_undefined 2025 || ELF_ST_VISIBILITY (h->other))))) 2026 return false; 2027 2028 /* To avoid generating warning messages about truncated 2029 relocations, set the relocation's address to be the same as 2030 the start of this section. */ 2031 2032 if (input_section->output_section != NULL) 2033 relocation = input_section->output_section->vma; 2034 else 2035 relocation = 0; 2036 } 2037 } 2038 2039 do_dynreloc: 2040 /* When generating a shared object, these relocations are copied 2041 into the output file to be resolved at run time. */ 2042 if (info->shared && r_symndx != 0 && (input_section->flags & SEC_ALLOC)) 2043 { 2044 switch (r_type) 2045 { 2046 case R_SPARC_PC10: 2047 case R_SPARC_PC22: 2048 case R_SPARC_PC_HH22: 2049 case R_SPARC_PC_HM10: 2050 case R_SPARC_PC_LM22: 2051 if (h != NULL 2052 && !strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_")) 2053 break; 2054 /* Fall through. */ 2055 case R_SPARC_DISP8: 2056 case R_SPARC_DISP16: 2057 case R_SPARC_DISP32: 2058 case R_SPARC_DISP64: 2059 case R_SPARC_WDISP30: 2060 case R_SPARC_WDISP22: 2061 case R_SPARC_WDISP19: 2062 case R_SPARC_WDISP16: 2063 if (h == NULL) 2064 break; 2065 /* Fall through. */ 2066 case R_SPARC_8: 2067 case R_SPARC_16: 2068 case R_SPARC_32: 2069 case R_SPARC_HI22: 2070 case R_SPARC_22: 2071 case R_SPARC_13: 2072 case R_SPARC_LO10: 2073 case R_SPARC_UA32: 2074 case R_SPARC_10: 2075 case R_SPARC_11: 2076 case R_SPARC_64: 2077 case R_SPARC_OLO10: 2078 case R_SPARC_HH22: 2079 case R_SPARC_HM10: 2080 case R_SPARC_LM22: 2081 case R_SPARC_7: 2082 case R_SPARC_5: 2083 case R_SPARC_6: 2084 case R_SPARC_HIX22: 2085 case R_SPARC_LOX10: 2086 case R_SPARC_H44: 2087 case R_SPARC_M44: 2088 case R_SPARC_L44: 2089 case R_SPARC_UA64: 2090 case R_SPARC_UA16: 2091 { 2092 Elf_Internal_Rela outrel; 2093 boolean skip, relocate; 2094 2095 if (sreloc == NULL) 2096 { 2097 const char *name = 2098 (bfd_elf_string_from_elf_section 2099 (input_bfd, 2100 elf_elfheader (input_bfd)->e_shstrndx, 2101 elf_section_data (input_section)->rel_hdr.sh_name)); 2102 2103 if (name == NULL) 2104 return false; 2105 2106 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 2107 && strcmp (bfd_get_section_name(input_bfd, 2108 input_section), 2109 name + 5) == 0); 2110 2111 sreloc = bfd_get_section_by_name (dynobj, name); 2112 BFD_ASSERT (sreloc != NULL); 2113 } 2114 2115 skip = false; 2116 relocate = false; 2117 2118 outrel.r_offset = 2119 _bfd_elf_section_offset (output_bfd, info, input_section, 2120 rel->r_offset); 2121 if (outrel.r_offset == (bfd_vma) -1) 2122 skip = true; 2123 else if (outrel.r_offset == (bfd_vma) -2) 2124 skip = true, relocate = true; 2125 2126 outrel.r_offset += (input_section->output_section->vma 2127 + input_section->output_offset); 2128 2129 /* Optimize unaligned reloc usage now that we know where 2130 it finally resides. */ 2131 switch (r_type) 2132 { 2133 case R_SPARC_16: 2134 if (outrel.r_offset & 1) r_type = R_SPARC_UA16; 2135 break; 2136 case R_SPARC_UA16: 2137 if (!(outrel.r_offset & 1)) r_type = R_SPARC_16; 2138 break; 2139 case R_SPARC_32: 2140 if (outrel.r_offset & 3) r_type = R_SPARC_UA32; 2141 break; 2142 case R_SPARC_UA32: 2143 if (!(outrel.r_offset & 3)) r_type = R_SPARC_32; 2144 break; 2145 case R_SPARC_64: 2146 if (outrel.r_offset & 7) r_type = R_SPARC_UA64; 2147 break; 2148 case R_SPARC_UA64: 2149 if (!(outrel.r_offset & 7)) r_type = R_SPARC_64; 2150 break; 2151 case R_SPARC_DISP8: 2152 case R_SPARC_DISP16: 2153 case R_SPARC_DISP32: 2154 case R_SPARC_DISP64: 2155 /* If the symbol is not dynamic, we should not keep 2156 a dynamic relocation. But an .rela.* slot has been 2157 allocated for it, output R_SPARC_NONE. 2158 FIXME: Add code tracking needed dynamic relocs as 2159 e.g. i386 has. */ 2160 if (h->dynindx == -1) 2161 skip = true, relocate = true; 2162 break; 2163 } 2164 2165 if (skip) 2166 memset (&outrel, 0, sizeof outrel); 2167 /* h->dynindx may be -1 if the symbol was marked to 2168 become local. */ 2169 else if (h != NULL && ! is_plt 2170 && ((! info->symbolic && h->dynindx != -1) 2171 || (h->elf_link_hash_flags 2172 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 2173 { 2174 BFD_ASSERT (h->dynindx != -1); 2175 outrel.r_info 2176 = ELF64_R_INFO (h->dynindx, 2177 ELF64_R_TYPE_INFO ( 2178 ELF64_R_TYPE_DATA (rel->r_info), 2179 r_type)); 2180 outrel.r_addend = rel->r_addend; 2181 } 2182 else 2183 { 2184 outrel.r_addend = relocation + rel->r_addend; 2185 if (r_type == R_SPARC_64) 2186 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE); 2187 else 2188 { 2189 long indx; 2190 2191 if (is_plt) 2192 sec = splt; 2193 else if (h == NULL) 2194 sec = local_sections[r_symndx]; 2195 else 2196 { 2197 BFD_ASSERT (h->root.type == bfd_link_hash_defined 2198 || (h->root.type 2199 == bfd_link_hash_defweak)); 2200 sec = h->root.u.def.section; 2201 } 2202 if (sec != NULL && bfd_is_abs_section (sec)) 2203 indx = 0; 2204 else if (sec == NULL || sec->owner == NULL) 2205 { 2206 bfd_set_error (bfd_error_bad_value); 2207 return false; 2208 } 2209 else 2210 { 2211 asection *osec; 2212 2213 osec = sec->output_section; 2214 indx = elf_section_data (osec)->dynindx; 2215 2216 /* We are turning this relocation into one 2217 against a section symbol, so subtract out 2218 the output section's address but not the 2219 offset of the input section in the output 2220 section. */ 2221 outrel.r_addend -= osec->vma; 2222 2223 /* FIXME: we really should be able to link non-pic 2224 shared libraries. */ 2225 if (indx == 0) 2226 { 2227 BFD_FAIL (); 2228 (*_bfd_error_handler) 2229 (_("%s: probably compiled without -fPIC?"), 2230 bfd_archive_filename (input_bfd)); 2231 bfd_set_error (bfd_error_bad_value); 2232 return false; 2233 } 2234 } 2235 2236 outrel.r_info 2237 = ELF64_R_INFO (indx, 2238 ELF64_R_TYPE_INFO ( 2239 ELF64_R_TYPE_DATA (rel->r_info), 2240 r_type)); 2241 } 2242 } 2243 2244 bfd_elf64_swap_reloca_out (output_bfd, &outrel, 2245 (((Elf64_External_Rela *) 2246 sreloc->contents) 2247 + sreloc->reloc_count)); 2248 ++sreloc->reloc_count; 2249 2250 /* This reloc will be computed at runtime, so there's no 2251 need to do anything now. */ 2252 if (! relocate) 2253 continue; 2254 } 2255 break; 2256 } 2257 } 2258 2259 switch (r_type) 2260 { 2261 case R_SPARC_GOT10: 2262 case R_SPARC_GOT13: 2263 case R_SPARC_GOT22: 2264 /* Relocation is to the entry for this symbol in the global 2265 offset table. */ 2266 if (sgot == NULL) 2267 { 2268 sgot = bfd_get_section_by_name (dynobj, ".got"); 2269 BFD_ASSERT (sgot != NULL); 2270 } 2271 2272 if (h != NULL) 2273 { 2274 boolean dyn; 2275 2276 off = h->got.offset; 2277 BFD_ASSERT (off != (bfd_vma) -1); 2278 dyn = elf_hash_table (info)->dynamic_sections_created; 2279 2280 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h) 2281 || (info->shared 2282 && (info->symbolic 2283 || h->dynindx == -1 2284 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) 2285 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) 2286 { 2287 /* This is actually a static link, or it is a -Bsymbolic 2288 link and the symbol is defined locally, or the symbol 2289 was forced to be local because of a version file. We 2290 must initialize this entry in the global offset table. 2291 Since the offset must always be a multiple of 8, we 2292 use the least significant bit to record whether we 2293 have initialized it already. 2294 2295 When doing a dynamic link, we create a .rela.got 2296 relocation entry to initialize the value. This is 2297 done in the finish_dynamic_symbol routine. */ 2298 2299 if ((off & 1) != 0) 2300 off &= ~1; 2301 else 2302 { 2303 bfd_put_64 (output_bfd, relocation, 2304 sgot->contents + off); 2305 h->got.offset |= 1; 2306 } 2307 } 2308 else 2309 unresolved_reloc = false; 2310 } 2311 else 2312 { 2313 BFD_ASSERT (local_got_offsets != NULL); 2314 off = local_got_offsets[r_symndx]; 2315 BFD_ASSERT (off != (bfd_vma) -1); 2316 2317 /* The offset must always be a multiple of 8. We use 2318 the least significant bit to record whether we have 2319 already processed this entry. */ 2320 if ((off & 1) != 0) 2321 off &= ~1; 2322 else 2323 { 2324 local_got_offsets[r_symndx] |= 1; 2325 2326 if (info->shared) 2327 { 2328 asection *srelgot; 2329 Elf_Internal_Rela outrel; 2330 2331 /* The Solaris 2.7 64-bit linker adds the contents 2332 of the location to the value of the reloc. 2333 Note this is different behaviour to the 2334 32-bit linker, which both adds the contents 2335 and ignores the addend. So clear the location. */ 2336 bfd_put_64 (output_bfd, (bfd_vma) 0, 2337 sgot->contents + off); 2338 2339 /* We need to generate a R_SPARC_RELATIVE reloc 2340 for the dynamic linker. */ 2341 srelgot = bfd_get_section_by_name(dynobj, ".rela.got"); 2342 BFD_ASSERT (srelgot != NULL); 2343 2344 outrel.r_offset = (sgot->output_section->vma 2345 + sgot->output_offset 2346 + off); 2347 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE); 2348 outrel.r_addend = relocation; 2349 bfd_elf64_swap_reloca_out (output_bfd, &outrel, 2350 (((Elf64_External_Rela *) 2351 srelgot->contents) 2352 + srelgot->reloc_count)); 2353 ++srelgot->reloc_count; 2354 } 2355 else 2356 bfd_put_64 (output_bfd, relocation, sgot->contents + off); 2357 } 2358 } 2359 relocation = sgot->output_offset + off - got_base; 2360 goto do_default; 2361 2362 case R_SPARC_WPLT30: 2363 case R_SPARC_PLT32: 2364 case R_SPARC_HIPLT22: 2365 case R_SPARC_LOPLT10: 2366 case R_SPARC_PCPLT32: 2367 case R_SPARC_PCPLT22: 2368 case R_SPARC_PCPLT10: 2369 case R_SPARC_PLT64: 2370 /* Relocation is to the entry for this symbol in the 2371 procedure linkage table. */ 2372 BFD_ASSERT (h != NULL); 2373 2374 if (h->plt.offset == (bfd_vma) -1) 2375 { 2376 /* We didn't make a PLT entry for this symbol. This 2377 happens when statically linking PIC code, or when 2378 using -Bsymbolic. */ 2379 goto do_default; 2380 } 2381 2382 if (splt == NULL) 2383 { 2384 splt = bfd_get_section_by_name (dynobj, ".plt"); 2385 BFD_ASSERT (splt != NULL); 2386 } 2387 2388 relocation = (splt->output_section->vma 2389 + splt->output_offset 2390 + sparc64_elf_plt_entry_offset (h->plt.offset)); 2391 unresolved_reloc = false; 2392 if (r_type == R_SPARC_WPLT30) 2393 goto do_wplt30; 2394 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64) 2395 { 2396 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64; 2397 is_plt = true; 2398 goto do_dynreloc; 2399 } 2400 goto do_default; 2401 2402 case R_SPARC_OLO10: 2403 { 2404 bfd_vma x; 2405 2406 relocation += rel->r_addend; 2407 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info); 2408 2409 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2410 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff); 2411 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 2412 2413 r = bfd_check_overflow (howto->complain_on_overflow, 2414 howto->bitsize, howto->rightshift, 2415 bfd_arch_bits_per_address (input_bfd), 2416 relocation); 2417 } 2418 break; 2419 2420 case R_SPARC_WDISP16: 2421 { 2422 bfd_vma x; 2423 2424 relocation += rel->r_addend; 2425 /* Adjust for pc-relative-ness. */ 2426 relocation -= (input_section->output_section->vma 2427 + input_section->output_offset); 2428 relocation -= rel->r_offset; 2429 2430 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2431 x &= ~(bfd_vma) 0x303fff; 2432 x |= ((((relocation >> 2) & 0xc000) << 6) 2433 | ((relocation >> 2) & 0x3fff)); 2434 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 2435 2436 r = bfd_check_overflow (howto->complain_on_overflow, 2437 howto->bitsize, howto->rightshift, 2438 bfd_arch_bits_per_address (input_bfd), 2439 relocation); 2440 } 2441 break; 2442 2443 case R_SPARC_HIX22: 2444 { 2445 bfd_vma x; 2446 2447 relocation += rel->r_addend; 2448 relocation = relocation ^ MINUS_ONE; 2449 2450 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2451 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff); 2452 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 2453 2454 r = bfd_check_overflow (howto->complain_on_overflow, 2455 howto->bitsize, howto->rightshift, 2456 bfd_arch_bits_per_address (input_bfd), 2457 relocation); 2458 } 2459 break; 2460 2461 case R_SPARC_LOX10: 2462 { 2463 bfd_vma x; 2464 2465 relocation += rel->r_addend; 2466 relocation = (relocation & 0x3ff) | 0x1c00; 2467 2468 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2469 x = (x & ~(bfd_vma) 0x1fff) | relocation; 2470 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 2471 2472 r = bfd_reloc_ok; 2473 } 2474 break; 2475 2476 case R_SPARC_WDISP30: 2477 do_wplt30: 2478 if (SEC_DO_RELAX (input_section) 2479 && rel->r_offset + 4 < input_section->_raw_size) 2480 { 2481#define G0 0 2482#define O7 15 2483#define XCC (2 << 20) 2484#define COND(x) (((x)&0xf)<<25) 2485#define CONDA COND(0x8) 2486#define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC) 2487#define INSN_BA (F2(0,2) | CONDA) 2488#define INSN_OR F3(2, 0x2, 0) 2489#define INSN_NOP F2(0,4) 2490 2491 bfd_vma x, y; 2492 2493 /* If the instruction is a call with either: 2494 restore 2495 arithmetic instruction with rd == %o7 2496 where rs1 != %o7 and rs2 if it is register != %o7 2497 then we can optimize if the call destination is near 2498 by changing the call into a branch always. */ 2499 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2500 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4); 2501 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2)) 2502 { 2503 if (((y & OP3(~0)) == OP3(0x3d) /* restore */ 2504 || ((y & OP3(0x28)) == 0 /* arithmetic */ 2505 && (y & RD(~0)) == RD(O7))) 2506 && (y & RS1(~0)) != RS1(O7) 2507 && ((y & F3I(~0)) 2508 || (y & RS2(~0)) != RS2(O7))) 2509 { 2510 bfd_vma reloc; 2511 2512 reloc = relocation + rel->r_addend - rel->r_offset; 2513 reloc -= (input_section->output_section->vma 2514 + input_section->output_offset); 2515 if (reloc & 3) 2516 goto do_default; 2517 2518 /* Ensure the branch fits into simm22. */ 2519 if ((reloc & ~(bfd_vma)0x7fffff) 2520 && ((reloc | 0x7fffff) != MINUS_ONE)) 2521 goto do_default; 2522 reloc >>= 2; 2523 2524 /* Check whether it fits into simm19. */ 2525 if ((reloc & 0x3c0000) == 0 2526 || (reloc & 0x3c0000) == 0x3c0000) 2527 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */ 2528 else 2529 x = INSN_BA | (reloc & 0x3fffff); /* ba */ 2530 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 2531 r = bfd_reloc_ok; 2532 if (rel->r_offset >= 4 2533 && (y & (0xffffffff ^ RS1(~0))) 2534 == (INSN_OR | RD(O7) | RS2(G0))) 2535 { 2536 bfd_vma z; 2537 unsigned int reg; 2538 2539 z = bfd_get_32 (input_bfd, 2540 contents + rel->r_offset - 4); 2541 if ((z & (0xffffffff ^ RD(~0))) 2542 != (INSN_OR | RS1(O7) | RS2(G0))) 2543 break; 2544 2545 /* The sequence was 2546 or %o7, %g0, %rN 2547 call foo 2548 or %rN, %g0, %o7 2549 2550 If call foo was replaced with ba, replace 2551 or %rN, %g0, %o7 with nop. */ 2552 2553 reg = (y & RS1(~0)) >> 14; 2554 if (reg != ((z & RD(~0)) >> 25) 2555 || reg == G0 || reg == O7) 2556 break; 2557 2558 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP, 2559 contents + rel->r_offset + 4); 2560 } 2561 break; 2562 } 2563 } 2564 } 2565 /* FALLTHROUGH */ 2566 2567 default: 2568 do_default: 2569 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 2570 contents, rel->r_offset, 2571 relocation, rel->r_addend); 2572 break; 2573 } 2574 2575 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 2576 because such sections are not SEC_ALLOC and thus ld.so will 2577 not process them. */ 2578 if (unresolved_reloc 2579 && !((input_section->flags & SEC_DEBUGGING) != 0 2580 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)) 2581 (*_bfd_error_handler) 2582 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"), 2583 bfd_archive_filename (input_bfd), 2584 bfd_get_section_name (input_bfd, input_section), 2585 (long) rel->r_offset, 2586 h->root.root.string); 2587 2588 switch (r) 2589 { 2590 case bfd_reloc_ok: 2591 break; 2592 2593 default: 2594 case bfd_reloc_outofrange: 2595 abort (); 2596 2597 case bfd_reloc_overflow: 2598 { 2599 const char *name; 2600 2601 /* The Solaris native linker silently disregards 2602 overflows. We don't, but this breaks stabs debugging 2603 info, whose relocations are only 32-bits wide. Ignore 2604 overflows in this case. */ 2605 if (r_type == R_SPARC_32 2606 && (input_section->flags & SEC_DEBUGGING) != 0 2607 && strcmp (bfd_section_name (input_bfd, input_section), 2608 ".stab") == 0) 2609 break; 2610 2611 if (h != NULL) 2612 { 2613 if (h->root.type == bfd_link_hash_undefweak 2614 && howto->pc_relative) 2615 { 2616 /* Assume this is a call protected by other code that 2617 detect the symbol is undefined. If this is the case, 2618 we can safely ignore the overflow. If not, the 2619 program is hosed anyway, and a little warning isn't 2620 going to help. */ 2621 break; 2622 } 2623 2624 name = h->root.root.string; 2625 } 2626 else 2627 { 2628 name = (bfd_elf_string_from_elf_section 2629 (input_bfd, 2630 symtab_hdr->sh_link, 2631 sym->st_name)); 2632 if (name == NULL) 2633 return false; 2634 if (*name == '\0') 2635 name = bfd_section_name (input_bfd, sec); 2636 } 2637 if (! ((*info->callbacks->reloc_overflow) 2638 (info, name, howto->name, (bfd_vma) 0, 2639 input_bfd, input_section, rel->r_offset))) 2640 return false; 2641 } 2642 break; 2643 } 2644 } 2645 2646 return true; 2647} 2648 2649/* Finish up dynamic symbol handling. We set the contents of various 2650 dynamic sections here. */ 2651 2652static boolean 2653sparc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym) 2654 bfd *output_bfd; 2655 struct bfd_link_info *info; 2656 struct elf_link_hash_entry *h; 2657 Elf_Internal_Sym *sym; 2658{ 2659 bfd *dynobj; 2660 2661 dynobj = elf_hash_table (info)->dynobj; 2662 2663 if (h->plt.offset != (bfd_vma) -1) 2664 { 2665 asection *splt; 2666 asection *srela; 2667 Elf_Internal_Rela rela; 2668 2669 /* This symbol has an entry in the PLT. Set it up. */ 2670 2671 BFD_ASSERT (h->dynindx != -1); 2672 2673 splt = bfd_get_section_by_name (dynobj, ".plt"); 2674 srela = bfd_get_section_by_name (dynobj, ".rela.plt"); 2675 BFD_ASSERT (splt != NULL && srela != NULL); 2676 2677 /* Fill in the entry in the .rela.plt section. */ 2678 2679 if (h->plt.offset < LARGE_PLT_THRESHOLD) 2680 { 2681 rela.r_offset = sparc64_elf_plt_entry_offset (h->plt.offset); 2682 rela.r_addend = 0; 2683 } 2684 else 2685 { 2686 bfd_vma max = splt->_raw_size / PLT_ENTRY_SIZE; 2687 rela.r_offset = sparc64_elf_plt_ptr_offset (h->plt.offset, max); 2688 rela.r_addend = -(sparc64_elf_plt_entry_offset (h->plt.offset) + 4) 2689 -(splt->output_section->vma + splt->output_offset); 2690 } 2691 rela.r_offset += (splt->output_section->vma + splt->output_offset); 2692 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_JMP_SLOT); 2693 2694 /* Adjust for the first 4 reserved elements in the .plt section 2695 when setting the offset in the .rela.plt section. 2696 Sun forgot to read their own ABI and copied elf32-sparc behaviour, 2697 thus .plt[4] has corresponding .rela.plt[0] and so on. */ 2698 2699 bfd_elf64_swap_reloca_out (output_bfd, &rela, 2700 ((Elf64_External_Rela *) srela->contents 2701 + (h->plt.offset - 4))); 2702 2703 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 2704 { 2705 /* Mark the symbol as undefined, rather than as defined in 2706 the .plt section. Leave the value alone. */ 2707 sym->st_shndx = SHN_UNDEF; 2708 /* If the symbol is weak, we do need to clear the value. 2709 Otherwise, the PLT entry would provide a definition for 2710 the symbol even if the symbol wasn't defined anywhere, 2711 and so the symbol would never be NULL. */ 2712 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK) 2713 == 0) 2714 sym->st_value = 0; 2715 } 2716 } 2717 2718 if (h->got.offset != (bfd_vma) -1) 2719 { 2720 asection *sgot; 2721 asection *srela; 2722 Elf_Internal_Rela rela; 2723 2724 /* This symbol has an entry in the GOT. Set it up. */ 2725 2726 sgot = bfd_get_section_by_name (dynobj, ".got"); 2727 srela = bfd_get_section_by_name (dynobj, ".rela.got"); 2728 BFD_ASSERT (sgot != NULL && srela != NULL); 2729 2730 rela.r_offset = (sgot->output_section->vma 2731 + sgot->output_offset 2732 + (h->got.offset &~ (bfd_vma) 1)); 2733 2734 /* If this is a -Bsymbolic link, and the symbol is defined 2735 locally, we just want to emit a RELATIVE reloc. Likewise if 2736 the symbol was forced to be local because of a version file. 2737 The entry in the global offset table will already have been 2738 initialized in the relocate_section function. */ 2739 if (info->shared 2740 && (info->symbolic || h->dynindx == -1) 2741 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 2742 { 2743 asection *sec = h->root.u.def.section; 2744 rela.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE); 2745 rela.r_addend = (h->root.u.def.value 2746 + sec->output_section->vma 2747 + sec->output_offset); 2748 } 2749 else 2750 { 2751 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 2752 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_GLOB_DAT); 2753 rela.r_addend = 0; 2754 } 2755 2756 bfd_elf64_swap_reloca_out (output_bfd, &rela, 2757 ((Elf64_External_Rela *) srela->contents 2758 + srela->reloc_count)); 2759 ++srela->reloc_count; 2760 } 2761 2762 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 2763 { 2764 asection *s; 2765 Elf_Internal_Rela rela; 2766 2767 /* This symbols needs a copy reloc. Set it up. */ 2768 2769 BFD_ASSERT (h->dynindx != -1); 2770 2771 s = bfd_get_section_by_name (h->root.u.def.section->owner, 2772 ".rela.bss"); 2773 BFD_ASSERT (s != NULL); 2774 2775 rela.r_offset = (h->root.u.def.value 2776 + h->root.u.def.section->output_section->vma 2777 + h->root.u.def.section->output_offset); 2778 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_COPY); 2779 rela.r_addend = 0; 2780 bfd_elf64_swap_reloca_out (output_bfd, &rela, 2781 ((Elf64_External_Rela *) s->contents 2782 + s->reloc_count)); 2783 ++s->reloc_count; 2784 } 2785 2786 /* Mark some specially defined symbols as absolute. */ 2787 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2788 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 2789 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0) 2790 sym->st_shndx = SHN_ABS; 2791 2792 return true; 2793} 2794 2795/* Finish up the dynamic sections. */ 2796 2797static boolean 2798sparc64_elf_finish_dynamic_sections (output_bfd, info) 2799 bfd *output_bfd; 2800 struct bfd_link_info *info; 2801{ 2802 bfd *dynobj; 2803 int stt_regidx = -1; 2804 asection *sdyn; 2805 asection *sgot; 2806 2807 dynobj = elf_hash_table (info)->dynobj; 2808 2809 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2810 2811 if (elf_hash_table (info)->dynamic_sections_created) 2812 { 2813 asection *splt; 2814 Elf64_External_Dyn *dyncon, *dynconend; 2815 2816 splt = bfd_get_section_by_name (dynobj, ".plt"); 2817 BFD_ASSERT (splt != NULL && sdyn != NULL); 2818 2819 dyncon = (Elf64_External_Dyn *) sdyn->contents; 2820 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 2821 for (; dyncon < dynconend; dyncon++) 2822 { 2823 Elf_Internal_Dyn dyn; 2824 const char *name; 2825 boolean size; 2826 2827 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); 2828 2829 switch (dyn.d_tag) 2830 { 2831 case DT_PLTGOT: name = ".plt"; size = false; break; 2832 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break; 2833 case DT_JMPREL: name = ".rela.plt"; size = false; break; 2834 case DT_SPARC_REGISTER: 2835 if (stt_regidx == -1) 2836 { 2837 stt_regidx = 2838 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1); 2839 if (stt_regidx == -1) 2840 return false; 2841 } 2842 dyn.d_un.d_val = stt_regidx++; 2843 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2844 /* fallthrough */ 2845 default: name = NULL; size = false; break; 2846 } 2847 2848 if (name != NULL) 2849 { 2850 asection *s; 2851 2852 s = bfd_get_section_by_name (output_bfd, name); 2853 if (s == NULL) 2854 dyn.d_un.d_val = 0; 2855 else 2856 { 2857 if (! size) 2858 dyn.d_un.d_ptr = s->vma; 2859 else 2860 { 2861 if (s->_cooked_size != 0) 2862 dyn.d_un.d_val = s->_cooked_size; 2863 else 2864 dyn.d_un.d_val = s->_raw_size; 2865 } 2866 } 2867 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2868 } 2869 } 2870 2871 /* Initialize the contents of the .plt section. */ 2872 if (splt->_raw_size > 0) 2873 { 2874 sparc64_elf_build_plt (output_bfd, splt->contents, 2875 (int) (splt->_raw_size / PLT_ENTRY_SIZE)); 2876 } 2877 2878 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 2879 PLT_ENTRY_SIZE; 2880 } 2881 2882 /* Set the first entry in the global offset table to the address of 2883 the dynamic section. */ 2884 sgot = bfd_get_section_by_name (dynobj, ".got"); 2885 BFD_ASSERT (sgot != NULL); 2886 if (sgot->_raw_size > 0) 2887 { 2888 if (sdyn == NULL) 2889 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents); 2890 else 2891 bfd_put_64 (output_bfd, 2892 sdyn->output_section->vma + sdyn->output_offset, 2893 sgot->contents); 2894 } 2895 2896 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8; 2897 2898 return true; 2899} 2900 2901static enum elf_reloc_type_class 2902sparc64_elf_reloc_type_class (rela) 2903 const Elf_Internal_Rela *rela; 2904{ 2905 switch ((int) ELF64_R_TYPE (rela->r_info)) 2906 { 2907 case R_SPARC_RELATIVE: 2908 return reloc_class_relative; 2909 case R_SPARC_JMP_SLOT: 2910 return reloc_class_plt; 2911 case R_SPARC_COPY: 2912 return reloc_class_copy; 2913 default: 2914 return reloc_class_normal; 2915 } 2916} 2917 2918/* Functions for dealing with the e_flags field. */ 2919 2920/* Merge backend specific data from an object file to the output 2921 object file when linking. */ 2922 2923static boolean 2924sparc64_elf_merge_private_bfd_data (ibfd, obfd) 2925 bfd *ibfd; 2926 bfd *obfd; 2927{ 2928 boolean error; 2929 flagword new_flags, old_flags; 2930 int new_mm, old_mm; 2931 2932 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 2933 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 2934 return true; 2935 2936 new_flags = elf_elfheader (ibfd)->e_flags; 2937 old_flags = elf_elfheader (obfd)->e_flags; 2938 2939 if (!elf_flags_init (obfd)) /* First call, no flags set */ 2940 { 2941 elf_flags_init (obfd) = true; 2942 elf_elfheader (obfd)->e_flags = new_flags; 2943 } 2944 2945 else if (new_flags == old_flags) /* Compatible flags are ok */ 2946 ; 2947 2948 else /* Incompatible flags */ 2949 { 2950 error = false; 2951 2952#define EF_SPARC_ISA_EXTENSIONS \ 2953 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1) 2954 2955 if ((ibfd->flags & DYNAMIC) != 0) 2956 { 2957 /* We don't want dynamic objects memory ordering and 2958 architecture to have any role. That's what dynamic linker 2959 should do. */ 2960 new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS); 2961 new_flags |= (old_flags 2962 & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS)); 2963 } 2964 else 2965 { 2966 /* Choose the highest architecture requirements. */ 2967 old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS); 2968 new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS); 2969 if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3)) 2970 && (old_flags & EF_SPARC_HAL_R1)) 2971 { 2972 error = true; 2973 (*_bfd_error_handler) 2974 (_("%s: linking UltraSPARC specific with HAL specific code"), 2975 bfd_archive_filename (ibfd)); 2976 } 2977 /* Choose the most restrictive memory ordering. */ 2978 old_mm = (old_flags & EF_SPARCV9_MM); 2979 new_mm = (new_flags & EF_SPARCV9_MM); 2980 old_flags &= ~EF_SPARCV9_MM; 2981 new_flags &= ~EF_SPARCV9_MM; 2982 if (new_mm < old_mm) 2983 old_mm = new_mm; 2984 old_flags |= old_mm; 2985 new_flags |= old_mm; 2986 } 2987 2988 /* Warn about any other mismatches */ 2989 if (new_flags != old_flags) 2990 { 2991 error = true; 2992 (*_bfd_error_handler) 2993 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"), 2994 bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags); 2995 } 2996 2997 elf_elfheader (obfd)->e_flags = old_flags; 2998 2999 if (error) 3000 { 3001 bfd_set_error (bfd_error_bad_value); 3002 return false; 3003 } 3004 } 3005 return true; 3006} 3007 3008/* MARCO: Set the correct entry size for the .stab section. */ 3009 3010static boolean 3011sparc64_elf_fake_sections (abfd, hdr, sec) 3012 bfd *abfd ATTRIBUTE_UNUSED; 3013 Elf32_Internal_Shdr *hdr ATTRIBUTE_UNUSED; 3014 asection *sec; 3015{ 3016 const char *name; 3017 3018 name = bfd_get_section_name (abfd, sec); 3019 3020 if (strcmp (name, ".stab") == 0) 3021 { 3022 /* Even in the 64bit case the stab entries are only 12 bytes long. */ 3023 elf_section_data (sec)->this_hdr.sh_entsize = 12; 3024 } 3025 3026 return true; 3027} 3028 3029/* Print a STT_REGISTER symbol to file FILE. */ 3030 3031static const char * 3032sparc64_elf_print_symbol_all (abfd, filep, symbol) 3033 bfd *abfd ATTRIBUTE_UNUSED; 3034 PTR filep; 3035 asymbol *symbol; 3036{ 3037 FILE *file = (FILE *) filep; 3038 int reg, type; 3039 3040 if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info) 3041 != STT_REGISTER) 3042 return NULL; 3043 3044 reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value; 3045 type = symbol->flags; 3046 fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "", 3047 ((type & BSF_LOCAL) 3048 ? (type & BSF_GLOBAL) ? '!' : 'l' 3049 : (type & BSF_GLOBAL) ? 'g' : ' '), 3050 (type & BSF_WEAK) ? 'w' : ' '); 3051 if (symbol->name == NULL || symbol->name [0] == '\0') 3052 return "#scratch"; 3053 else 3054 return symbol->name; 3055} 3056 3057/* Set the right machine number for a SPARC64 ELF file. */ 3058 3059static boolean 3060sparc64_elf_object_p (abfd) 3061 bfd *abfd; 3062{ 3063 unsigned long mach = bfd_mach_sparc_v9; 3064 3065 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3) 3066 mach = bfd_mach_sparc_v9b; 3067 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1) 3068 mach = bfd_mach_sparc_v9a; 3069 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach); 3070} 3071 3072/* Relocations in the 64 bit SPARC ELF ABI are more complex than in 3073 standard ELF, because R_SPARC_OLO10 has secondary addend in 3074 ELF64_R_TYPE_DATA field. This structure is used to redirect the 3075 relocation handling routines. */ 3076 3077const struct elf_size_info sparc64_elf_size_info = 3078{ 3079 sizeof (Elf64_External_Ehdr), 3080 sizeof (Elf64_External_Phdr), 3081 sizeof (Elf64_External_Shdr), 3082 sizeof (Elf64_External_Rel), 3083 sizeof (Elf64_External_Rela), 3084 sizeof (Elf64_External_Sym), 3085 sizeof (Elf64_External_Dyn), 3086 sizeof (Elf_External_Note), 3087 4, /* hash-table entry size */ 3088 /* internal relocations per external relocations. 3089 For link purposes we use just 1 internal per 3090 1 external, for assembly and slurp symbol table 3091 we use 2. */ 3092 1, 3093 64, /* arch_size */ 3094 8, /* file_align */ 3095 ELFCLASS64, 3096 EV_CURRENT, 3097 bfd_elf64_write_out_phdrs, 3098 bfd_elf64_write_shdrs_and_ehdr, 3099 sparc64_elf_write_relocs, 3100 bfd_elf64_swap_symbol_in, 3101 bfd_elf64_swap_symbol_out, 3102 sparc64_elf_slurp_reloc_table, 3103 bfd_elf64_slurp_symbol_table, 3104 bfd_elf64_swap_dyn_in, 3105 bfd_elf64_swap_dyn_out, 3106 NULL, 3107 NULL, 3108 NULL, 3109 NULL 3110}; 3111 3112#define TARGET_BIG_SYM bfd_elf64_sparc_vec 3113#define TARGET_BIG_NAME "elf64-sparc" 3114#define ELF_ARCH bfd_arch_sparc 3115#define ELF_MAXPAGESIZE 0x100000 3116 3117/* This is the official ABI value. */ 3118#define ELF_MACHINE_CODE EM_SPARCV9 3119 3120/* This is the value that we used before the ABI was released. */ 3121#define ELF_MACHINE_ALT1 EM_OLD_SPARCV9 3122 3123#define bfd_elf64_bfd_link_hash_table_create \ 3124 sparc64_elf_bfd_link_hash_table_create 3125 3126#define elf_info_to_howto \ 3127 sparc64_elf_info_to_howto 3128#define bfd_elf64_get_reloc_upper_bound \ 3129 sparc64_elf_get_reloc_upper_bound 3130#define bfd_elf64_get_dynamic_reloc_upper_bound \ 3131 sparc64_elf_get_dynamic_reloc_upper_bound 3132#define bfd_elf64_canonicalize_dynamic_reloc \ 3133 sparc64_elf_canonicalize_dynamic_reloc 3134#define bfd_elf64_bfd_reloc_type_lookup \ 3135 sparc64_elf_reloc_type_lookup 3136#define bfd_elf64_bfd_relax_section \ 3137 sparc64_elf_relax_section 3138 3139#define elf_backend_create_dynamic_sections \ 3140 _bfd_elf_create_dynamic_sections 3141#define elf_backend_add_symbol_hook \ 3142 sparc64_elf_add_symbol_hook 3143#define elf_backend_get_symbol_type \ 3144 sparc64_elf_get_symbol_type 3145#define elf_backend_symbol_processing \ 3146 sparc64_elf_symbol_processing 3147#define elf_backend_check_relocs \ 3148 sparc64_elf_check_relocs 3149#define elf_backend_adjust_dynamic_symbol \ 3150 sparc64_elf_adjust_dynamic_symbol 3151#define elf_backend_size_dynamic_sections \ 3152 sparc64_elf_size_dynamic_sections 3153#define elf_backend_relocate_section \ 3154 sparc64_elf_relocate_section 3155#define elf_backend_finish_dynamic_symbol \ 3156 sparc64_elf_finish_dynamic_symbol 3157#define elf_backend_finish_dynamic_sections \ 3158 sparc64_elf_finish_dynamic_sections 3159#define elf_backend_print_symbol_all \ 3160 sparc64_elf_print_symbol_all 3161#define elf_backend_output_arch_syms \ 3162 sparc64_elf_output_arch_syms 3163#define bfd_elf64_bfd_merge_private_bfd_data \ 3164 sparc64_elf_merge_private_bfd_data 3165#define elf_backend_fake_sections \ 3166 sparc64_elf_fake_sections 3167 3168#define elf_backend_size_info \ 3169 sparc64_elf_size_info 3170#define elf_backend_object_p \ 3171 sparc64_elf_object_p 3172#define elf_backend_reloc_type_class \ 3173 sparc64_elf_reloc_type_class 3174 3175#define elf_backend_want_got_plt 0 3176#define elf_backend_plt_readonly 0 3177#define elf_backend_want_plt_sym 1 3178 3179/* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */ 3180#define elf_backend_plt_alignment 8 3181 3182#define elf_backend_got_header_size 8 3183#define elf_backend_plt_header_size PLT_HEADER_SIZE 3184 3185#include "elf64-target.h" 3186