1 /* SPARC-specific support for ELF 2 Copyright (C) 2005-2018 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 22 /* This file handles functionality common to the different SPARC ABI's. */ 23 24 #include "sysdep.h" 25 #include "bfd.h" 26 #include "bfdlink.h" 27 #include "libbfd.h" 28 #include "libiberty.h" 29 #include "elf-bfd.h" 30 #include "elf/sparc.h" 31 #include "opcode/sparc.h" 32 #include "elfxx-sparc.h" 33 #include "elf-vxworks.h" 34 #include "objalloc.h" 35 #include "hashtab.h" 36 37 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */ 38 #define MINUS_ONE (~ (bfd_vma) 0) 39 40 #define ABI_64_P(abfd) \ 41 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64) 42 43 /* The relocation "howto" table. */ 44 45 /* Utility for performing the standard initial work of an instruction 46 relocation. 47 *PRELOCATION will contain the relocated item. 48 *PINSN will contain the instruction from the input stream. 49 If the result is `bfd_reloc_other' the caller can continue with 50 performing the relocation. Otherwise it must stop and return the 51 value to its caller. */ 52 53 static bfd_reloc_status_type 54 init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 55 void * data, asection *input_section, bfd *output_bfd, 56 bfd_vma *prelocation, bfd_vma *pinsn) 57 { 58 bfd_vma relocation; 59 reloc_howto_type *howto = reloc_entry->howto; 60 61 if (output_bfd != (bfd *) NULL 62 && (symbol->flags & BSF_SECTION_SYM) == 0 63 && (! howto->partial_inplace 64 || reloc_entry->addend == 0)) 65 { 66 reloc_entry->address += input_section->output_offset; 67 return bfd_reloc_ok; 68 } 69 70 /* This works because partial_inplace is FALSE. */ 71 if (output_bfd != NULL) 72 return bfd_reloc_continue; 73 74 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 75 return bfd_reloc_outofrange; 76 77 relocation = (symbol->value 78 + symbol->section->output_section->vma 79 + symbol->section->output_offset); 80 relocation += reloc_entry->addend; 81 if (howto->pc_relative) 82 { 83 relocation -= (input_section->output_section->vma 84 + input_section->output_offset); 85 relocation -= reloc_entry->address; 86 } 87 88 *prelocation = relocation; 89 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 90 return bfd_reloc_other; 91 } 92 93 /* For unsupported relocs. */ 94 95 static bfd_reloc_status_type 96 sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED, 97 arelent *reloc_entry ATTRIBUTE_UNUSED, 98 asymbol *symbol ATTRIBUTE_UNUSED, 99 void * data ATTRIBUTE_UNUSED, 100 asection *input_section ATTRIBUTE_UNUSED, 101 bfd *output_bfd ATTRIBUTE_UNUSED, 102 char **error_message ATTRIBUTE_UNUSED) 103 { 104 return bfd_reloc_notsupported; 105 } 106 107 /* Handle the WDISP16 reloc. */ 108 109 static bfd_reloc_status_type 110 sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 111 void * data, asection *input_section, bfd *output_bfd, 112 char **error_message ATTRIBUTE_UNUSED) 113 { 114 bfd_vma relocation; 115 bfd_vma insn; 116 bfd_reloc_status_type status; 117 118 status = init_insn_reloc (abfd, reloc_entry, symbol, data, 119 input_section, output_bfd, &relocation, &insn); 120 if (status != bfd_reloc_other) 121 return status; 122 123 insn &= ~ (bfd_vma) 0x303fff; 124 insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff); 125 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 126 127 if ((bfd_signed_vma) relocation < - 0x40000 128 || (bfd_signed_vma) relocation > 0x3ffff) 129 return bfd_reloc_overflow; 130 else 131 return bfd_reloc_ok; 132 } 133 134 /* Handle the WDISP10 reloc. */ 135 136 static bfd_reloc_status_type 137 sparc_elf_wdisp10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 138 void * data, asection *input_section, bfd *output_bfd, 139 char **error_message ATTRIBUTE_UNUSED) 140 { 141 bfd_vma relocation; 142 bfd_vma insn; 143 bfd_reloc_status_type status; 144 145 status = init_insn_reloc (abfd, reloc_entry, symbol, data, 146 input_section, output_bfd, &relocation, &insn); 147 if (status != bfd_reloc_other) 148 return status; 149 150 insn &= ~ (bfd_vma) 0x181fe0; 151 insn |= (((relocation >> 2) & 0x300) << 11) 152 | (((relocation >> 2) & 0xff) << 5); 153 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 154 155 if ((bfd_signed_vma) relocation < - 0x1000 156 || (bfd_signed_vma) relocation > 0xfff) 157 return bfd_reloc_overflow; 158 else 159 return bfd_reloc_ok; 160 } 161 162 /* Handle the HIX22 reloc. */ 163 164 static bfd_reloc_status_type 165 sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 166 void * data, asection *input_section, bfd *output_bfd, 167 char **error_message ATTRIBUTE_UNUSED) 168 { 169 bfd_vma relocation; 170 bfd_vma insn; 171 bfd_reloc_status_type status; 172 173 status = init_insn_reloc (abfd, reloc_entry, symbol, data, 174 input_section, output_bfd, &relocation, &insn); 175 if (status != bfd_reloc_other) 176 return status; 177 178 relocation ^= MINUS_ONE; 179 insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff); 180 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 181 182 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0) 183 return bfd_reloc_overflow; 184 else 185 return bfd_reloc_ok; 186 } 187 188 /* Handle the LOX10 reloc. */ 189 190 static bfd_reloc_status_type 191 sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 192 void * data, asection *input_section, bfd *output_bfd, 193 char **error_message ATTRIBUTE_UNUSED) 194 { 195 bfd_vma relocation; 196 bfd_vma insn; 197 bfd_reloc_status_type status; 198 199 status = init_insn_reloc (abfd, reloc_entry, symbol, data, 200 input_section, output_bfd, &relocation, &insn); 201 if (status != bfd_reloc_other) 202 return status; 203 204 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff); 205 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 206 207 return bfd_reloc_ok; 208 } 209 210 static reloc_howto_type _bfd_sparc_elf_howto_table[] = 211 { 212 HOWTO(R_SPARC_NONE, 0,3, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 213 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE), 214 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE), 215 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE), 216 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE), 217 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE), 218 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE), 219 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE), 220 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE), 221 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE), 222 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE), 223 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE), 224 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE), 225 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE), 226 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE), 227 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE), 228 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE), 229 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE), 230 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE), 231 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE), 232 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), 233 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), 234 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE), 235 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE), 236 HOWTO(R_SPARC_PLT32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE), 237 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE), 238 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE), 239 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE), 240 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE), 241 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE), 242 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE), 243 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE), 244 HOWTO(R_SPARC_64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", FALSE,0,MINUS_ONE, TRUE), 245 HOWTO(R_SPARC_OLO10, 0,2,13,FALSE,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", FALSE,0,0x00001fff,TRUE), 246 HOWTO(R_SPARC_HH22, 42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", FALSE,0,0x003fffff,TRUE), 247 HOWTO(R_SPARC_HM10, 32,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", FALSE,0,0x000003ff,TRUE), 248 HOWTO(R_SPARC_LM22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", FALSE,0,0x003fffff,TRUE), 249 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), 250 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), 251 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), 252 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE), 253 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE), 254 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), 255 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE), 256 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE), 257 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE), 258 HOWTO(R_SPARC_DISP64, 0,4,64,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", FALSE,0,MINUS_ONE, TRUE), 259 HOWTO(R_SPARC_PLT64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT64", FALSE,0,MINUS_ONE, TRUE), 260 HOWTO(R_SPARC_HIX22, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", FALSE,0,MINUS_ONE, FALSE), 261 HOWTO(R_SPARC_LOX10, 0,4, 0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", FALSE,0,MINUS_ONE, FALSE), 262 HOWTO(R_SPARC_H44, 22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", FALSE,0,0x003fffff,FALSE), 263 HOWTO(R_SPARC_M44, 12,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", FALSE,0,0x000003ff,FALSE), 264 HOWTO(R_SPARC_L44, 0,2,13,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", FALSE,0,0x00000fff,FALSE), 265 HOWTO(R_SPARC_REGISTER, 0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE), 266 HOWTO(R_SPARC_UA64, 0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", FALSE,0,MINUS_ONE, TRUE), 267 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE), 268 HOWTO(R_SPARC_TLS_GD_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_HI22",FALSE,0,0x003fffff,TRUE), 269 HOWTO(R_SPARC_TLS_GD_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_LO10",FALSE,0,0x000003ff,TRUE), 270 HOWTO(R_SPARC_TLS_GD_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_ADD",FALSE,0,0x00000000,TRUE), 271 HOWTO(R_SPARC_TLS_GD_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_CALL",FALSE,0,0x3fffffff,TRUE), 272 HOWTO(R_SPARC_TLS_LDM_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_HI22",FALSE,0,0x003fffff,TRUE), 273 HOWTO(R_SPARC_TLS_LDM_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_LO10",FALSE,0,0x000003ff,TRUE), 274 HOWTO(R_SPARC_TLS_LDM_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_ADD",FALSE,0,0x00000000,TRUE), 275 HOWTO(R_SPARC_TLS_LDM_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_CALL",FALSE,0,0x3fffffff,TRUE), 276 HOWTO(R_SPARC_TLS_LDO_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_TLS_LDO_HIX22",FALSE,0,0x003fffff, FALSE), 277 HOWTO(R_SPARC_TLS_LDO_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LDO_LOX10",FALSE,0,0x000003ff, FALSE), 278 HOWTO(R_SPARC_TLS_LDO_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDO_ADD",FALSE,0,0x00000000,TRUE), 279 HOWTO(R_SPARC_TLS_IE_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_HI22",FALSE,0,0x003fffff,TRUE), 280 HOWTO(R_SPARC_TLS_IE_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LO10",FALSE,0,0x000003ff,TRUE), 281 HOWTO(R_SPARC_TLS_IE_LD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LD",FALSE,0,0x00000000,TRUE), 282 HOWTO(R_SPARC_TLS_IE_LDX,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LDX",FALSE,0,0x00000000,TRUE), 283 HOWTO(R_SPARC_TLS_IE_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_ADD",FALSE,0,0x00000000,TRUE), 284 HOWTO(R_SPARC_TLS_LE_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_TLS_LE_HIX22",FALSE,0,0x003fffff, FALSE), 285 HOWTO(R_SPARC_TLS_LE_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LE_LOX10",FALSE,0,0x000003ff, FALSE), 286 HOWTO(R_SPARC_TLS_DTPMOD32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD32",FALSE,0,0x00000000,TRUE), 287 HOWTO(R_SPARC_TLS_DTPMOD64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD64",FALSE,0,0x00000000,TRUE), 288 HOWTO(R_SPARC_TLS_DTPOFF32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF32",FALSE,0,0xffffffff,TRUE), 289 HOWTO(R_SPARC_TLS_DTPOFF64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF64",FALSE,0,MINUS_ONE,TRUE), 290 HOWTO(R_SPARC_TLS_TPOFF32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF32",FALSE,0,0x00000000,TRUE), 291 HOWTO(R_SPARC_TLS_TPOFF64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF64",FALSE,0,0x00000000,TRUE), 292 HOWTO(R_SPARC_GOTDATA_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_HIX22",FALSE,0,0x003fffff, FALSE), 293 HOWTO(R_SPARC_GOTDATA_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_LOX10",FALSE,0,0x000003ff, FALSE), 294 HOWTO(R_SPARC_GOTDATA_OP_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_OP_HIX22",FALSE,0,0x003fffff, FALSE), 295 HOWTO(R_SPARC_GOTDATA_OP_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_GOTDATA_OP_LOX10",FALSE,0,0x000003ff, FALSE), 296 HOWTO(R_SPARC_GOTDATA_OP,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOTDATA_OP",FALSE,0,0x00000000,TRUE), 297 HOWTO(R_SPARC_H34,12,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,"R_SPARC_H34",FALSE,0,0x003fffff,FALSE), 298 HOWTO(R_SPARC_SIZE32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_SIZE32",FALSE,0,0xffffffff,TRUE), 299 HOWTO(R_SPARC_SIZE64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_SIZE64",FALSE,0,MINUS_ONE, TRUE), 300 HOWTO(R_SPARC_WDISP10,2,2,10,TRUE, 0,complain_overflow_signed,sparc_elf_wdisp10_reloc,"R_SPARC_WDISP10",FALSE,0,0x00000000,TRUE), 301 }; 302 static reloc_howto_type sparc_jmp_irel_howto = 303 HOWTO(R_SPARC_JMP_IREL, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_JMP_IREL",FALSE,0,0x00000000,TRUE); 304 static reloc_howto_type sparc_irelative_howto = 305 HOWTO(R_SPARC_IRELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_IRELATIVE",FALSE,0,0x00000000,TRUE); 306 static reloc_howto_type sparc_vtinherit_howto = 307 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE); 308 static reloc_howto_type sparc_vtentry_howto = 309 HOWTO (R_SPARC_GNU_VTENTRY, 0,2,0,FALSE,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_SPARC_GNU_VTENTRY", FALSE,0,0, FALSE); 310 static reloc_howto_type sparc_rev32_howto = 311 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE); 312 313 reloc_howto_type * 314 _bfd_sparc_elf_reloc_type_lookup (bfd *abfd, 315 bfd_reloc_code_real_type code) 316 { 317 /* We explicitly handle each relocation type in the switch 318 instead of using a lookup table for efficiency. */ 319 switch (code) 320 { 321 case BFD_RELOC_NONE: 322 return &_bfd_sparc_elf_howto_table[R_SPARC_NONE]; 323 324 case BFD_RELOC_8: 325 return &_bfd_sparc_elf_howto_table[R_SPARC_8]; 326 327 case BFD_RELOC_16: 328 return &_bfd_sparc_elf_howto_table[R_SPARC_16]; 329 330 case BFD_RELOC_32: 331 return &_bfd_sparc_elf_howto_table[R_SPARC_32]; 332 333 case BFD_RELOC_8_PCREL: 334 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP8]; 335 336 case BFD_RELOC_16_PCREL: 337 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP16]; 338 339 case BFD_RELOC_32_PCREL: 340 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP32]; 341 342 case BFD_RELOC_32_PCREL_S2: 343 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP30]; 344 345 case BFD_RELOC_SPARC_WDISP22: 346 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP22]; 347 348 case BFD_RELOC_HI22: 349 return &_bfd_sparc_elf_howto_table[R_SPARC_HI22]; 350 351 case BFD_RELOC_SPARC22: 352 return &_bfd_sparc_elf_howto_table[R_SPARC_22]; 353 354 case BFD_RELOC_SPARC13: 355 return &_bfd_sparc_elf_howto_table[R_SPARC_13]; 356 357 case BFD_RELOC_LO10: 358 return &_bfd_sparc_elf_howto_table[R_SPARC_LO10]; 359 360 case BFD_RELOC_SPARC_GOT10: 361 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT10]; 362 363 case BFD_RELOC_SPARC_GOT13: 364 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT13]; 365 366 case BFD_RELOC_SPARC_GOT22: 367 return &_bfd_sparc_elf_howto_table[R_SPARC_GOT22]; 368 369 case BFD_RELOC_SPARC_PC10: 370 return &_bfd_sparc_elf_howto_table[R_SPARC_PC10]; 371 372 case BFD_RELOC_SPARC_PC22: 373 return &_bfd_sparc_elf_howto_table[R_SPARC_PC22]; 374 375 case BFD_RELOC_SPARC_WPLT30: 376 return &_bfd_sparc_elf_howto_table[R_SPARC_WPLT30]; 377 378 case BFD_RELOC_SPARC_COPY: 379 return &_bfd_sparc_elf_howto_table[R_SPARC_COPY]; 380 381 case BFD_RELOC_SPARC_GLOB_DAT: 382 return &_bfd_sparc_elf_howto_table[R_SPARC_GLOB_DAT]; 383 384 case BFD_RELOC_SPARC_JMP_SLOT: 385 return &_bfd_sparc_elf_howto_table[R_SPARC_JMP_SLOT]; 386 387 case BFD_RELOC_SPARC_RELATIVE: 388 return &_bfd_sparc_elf_howto_table[R_SPARC_RELATIVE]; 389 390 case BFD_RELOC_SPARC_UA32: 391 return &_bfd_sparc_elf_howto_table[R_SPARC_UA32]; 392 393 case BFD_RELOC_SPARC_PLT32: 394 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT32]; 395 396 case BFD_RELOC_SPARC_10: 397 return &_bfd_sparc_elf_howto_table[R_SPARC_10]; 398 399 case BFD_RELOC_SPARC_11: 400 return &_bfd_sparc_elf_howto_table[R_SPARC_11]; 401 402 case BFD_RELOC_SPARC_64: 403 return &_bfd_sparc_elf_howto_table[R_SPARC_64]; 404 405 case BFD_RELOC_SPARC_OLO10: 406 return &_bfd_sparc_elf_howto_table[R_SPARC_OLO10]; 407 408 case BFD_RELOC_SPARC_HH22: 409 return &_bfd_sparc_elf_howto_table[R_SPARC_HH22]; 410 411 case BFD_RELOC_SPARC_HM10: 412 return &_bfd_sparc_elf_howto_table[R_SPARC_HM10]; 413 414 case BFD_RELOC_SPARC_LM22: 415 return &_bfd_sparc_elf_howto_table[R_SPARC_LM22]; 416 417 case BFD_RELOC_SPARC_PC_HH22: 418 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HH22]; 419 420 case BFD_RELOC_SPARC_PC_HM10: 421 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HM10]; 422 423 case BFD_RELOC_SPARC_PC_LM22: 424 return &_bfd_sparc_elf_howto_table[R_SPARC_PC_LM22]; 425 426 case BFD_RELOC_SPARC_WDISP16: 427 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP16]; 428 429 case BFD_RELOC_SPARC_WDISP19: 430 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP19]; 431 432 case BFD_RELOC_SPARC_7: 433 return &_bfd_sparc_elf_howto_table[R_SPARC_7]; 434 435 case BFD_RELOC_SPARC_5: 436 return &_bfd_sparc_elf_howto_table[R_SPARC_5]; 437 438 case BFD_RELOC_SPARC_6: 439 return &_bfd_sparc_elf_howto_table[R_SPARC_6]; 440 441 case BFD_RELOC_SPARC_DISP64: 442 return &_bfd_sparc_elf_howto_table[R_SPARC_DISP64]; 443 444 case BFD_RELOC_SPARC_PLT64: 445 return &_bfd_sparc_elf_howto_table[R_SPARC_PLT64]; 446 447 case BFD_RELOC_SPARC_HIX22: 448 return &_bfd_sparc_elf_howto_table[R_SPARC_HIX22]; 449 450 case BFD_RELOC_SPARC_LOX10: 451 return &_bfd_sparc_elf_howto_table[R_SPARC_LOX10]; 452 453 case BFD_RELOC_SPARC_H44: 454 return &_bfd_sparc_elf_howto_table[R_SPARC_H44]; 455 456 case BFD_RELOC_SPARC_M44: 457 return &_bfd_sparc_elf_howto_table[R_SPARC_M44]; 458 459 case BFD_RELOC_SPARC_L44: 460 return &_bfd_sparc_elf_howto_table[R_SPARC_L44]; 461 462 case BFD_RELOC_SPARC_REGISTER: 463 return &_bfd_sparc_elf_howto_table[R_SPARC_REGISTER]; 464 465 case BFD_RELOC_SPARC_UA64: 466 return &_bfd_sparc_elf_howto_table[R_SPARC_UA64]; 467 468 case BFD_RELOC_SPARC_UA16: 469 return &_bfd_sparc_elf_howto_table[R_SPARC_UA16]; 470 471 case BFD_RELOC_SPARC_TLS_GD_HI22: 472 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_HI22]; 473 474 case BFD_RELOC_SPARC_TLS_GD_LO10: 475 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_LO10]; 476 477 case BFD_RELOC_SPARC_TLS_GD_ADD: 478 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_ADD]; 479 480 case BFD_RELOC_SPARC_TLS_GD_CALL: 481 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_CALL]; 482 483 case BFD_RELOC_SPARC_TLS_LDM_HI22: 484 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_HI22]; 485 486 case BFD_RELOC_SPARC_TLS_LDM_LO10: 487 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_LO10]; 488 489 case BFD_RELOC_SPARC_TLS_LDM_ADD: 490 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_ADD]; 491 492 case BFD_RELOC_SPARC_TLS_LDM_CALL: 493 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_CALL]; 494 495 case BFD_RELOC_SPARC_TLS_LDO_HIX22: 496 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_HIX22]; 497 498 case BFD_RELOC_SPARC_TLS_LDO_LOX10: 499 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_LOX10]; 500 501 case BFD_RELOC_SPARC_TLS_LDO_ADD: 502 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_ADD]; 503 504 case BFD_RELOC_SPARC_TLS_IE_HI22: 505 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_HI22]; 506 507 case BFD_RELOC_SPARC_TLS_IE_LO10: 508 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LO10]; 509 510 case BFD_RELOC_SPARC_TLS_IE_LD: 511 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LD]; 512 513 case BFD_RELOC_SPARC_TLS_IE_LDX: 514 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LDX]; 515 516 case BFD_RELOC_SPARC_TLS_IE_ADD: 517 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_ADD]; 518 519 case BFD_RELOC_SPARC_TLS_LE_HIX22: 520 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_HIX22]; 521 522 case BFD_RELOC_SPARC_TLS_LE_LOX10: 523 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_LOX10]; 524 525 case BFD_RELOC_SPARC_TLS_DTPMOD32: 526 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD32]; 527 528 case BFD_RELOC_SPARC_TLS_DTPMOD64: 529 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD64]; 530 531 case BFD_RELOC_SPARC_TLS_DTPOFF32: 532 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF32]; 533 534 case BFD_RELOC_SPARC_TLS_DTPOFF64: 535 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF64]; 536 537 case BFD_RELOC_SPARC_TLS_TPOFF32: 538 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF32]; 539 540 case BFD_RELOC_SPARC_TLS_TPOFF64: 541 return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF64]; 542 543 case BFD_RELOC_SPARC_GOTDATA_HIX22: 544 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_HIX22]; 545 546 case BFD_RELOC_SPARC_GOTDATA_LOX10: 547 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_LOX10]; 548 549 case BFD_RELOC_SPARC_GOTDATA_OP_HIX22: 550 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_HIX22]; 551 552 case BFD_RELOC_SPARC_GOTDATA_OP_LOX10: 553 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_LOX10]; 554 555 case BFD_RELOC_SPARC_GOTDATA_OP: 556 return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP]; 557 558 case BFD_RELOC_SPARC_H34: 559 return &_bfd_sparc_elf_howto_table[R_SPARC_H34]; 560 561 case BFD_RELOC_SPARC_SIZE32: 562 return &_bfd_sparc_elf_howto_table[R_SPARC_SIZE32]; 563 564 case BFD_RELOC_SPARC_SIZE64: 565 return &_bfd_sparc_elf_howto_table[R_SPARC_SIZE64]; 566 567 case BFD_RELOC_SPARC_WDISP10: 568 return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP10]; 569 570 case BFD_RELOC_SPARC_JMP_IREL: 571 return &sparc_jmp_irel_howto; 572 573 case BFD_RELOC_SPARC_IRELATIVE: 574 return &sparc_irelative_howto; 575 576 case BFD_RELOC_VTABLE_INHERIT: 577 return &sparc_vtinherit_howto; 578 579 case BFD_RELOC_VTABLE_ENTRY: 580 return &sparc_vtentry_howto; 581 582 case BFD_RELOC_SPARC_REV32: 583 return &sparc_rev32_howto; 584 585 default: 586 break; 587 } 588 /* xgettext:c-format */ 589 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code); 590 bfd_set_error (bfd_error_bad_value); 591 return NULL; 592 } 593 594 reloc_howto_type * 595 _bfd_sparc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 596 const char *r_name) 597 { 598 unsigned int i; 599 600 for (i = 0; i < ARRAY_SIZE (_bfd_sparc_elf_howto_table); i++) 601 if (_bfd_sparc_elf_howto_table[i].name != NULL 602 && strcasecmp (_bfd_sparc_elf_howto_table[i].name, r_name) == 0) 603 return &_bfd_sparc_elf_howto_table[i]; 604 605 if (strcasecmp (sparc_vtinherit_howto.name, r_name) == 0) 606 return &sparc_vtinherit_howto; 607 if (strcasecmp (sparc_vtentry_howto.name, r_name) == 0) 608 return &sparc_vtentry_howto; 609 if (strcasecmp (sparc_rev32_howto.name, r_name) == 0) 610 return &sparc_rev32_howto; 611 612 return NULL; 613 } 614 615 reloc_howto_type * 616 _bfd_sparc_elf_info_to_howto_ptr (bfd *abfd ATTRIBUTE_UNUSED, 617 unsigned int r_type) 618 { 619 switch (r_type) 620 { 621 case R_SPARC_JMP_IREL: 622 return &sparc_jmp_irel_howto; 623 624 case R_SPARC_IRELATIVE: 625 return &sparc_irelative_howto; 626 627 case R_SPARC_GNU_VTINHERIT: 628 return &sparc_vtinherit_howto; 629 630 case R_SPARC_GNU_VTENTRY: 631 return &sparc_vtentry_howto; 632 633 case R_SPARC_REV32: 634 return &sparc_rev32_howto; 635 636 default: 637 if (r_type >= (unsigned int) R_SPARC_max_std) 638 { 639 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 640 abfd, r_type); 641 bfd_set_error (bfd_error_bad_value); 642 return NULL; 643 } 644 return &_bfd_sparc_elf_howto_table[r_type]; 645 } 646 } 647 648 /* Both 32-bit and 64-bit sparc encode this in an identical manner, 649 so just take advantage of that. */ 650 #define SPARC_ELF_R_TYPE(r_info) \ 651 ((r_info) & 0xff) 652 653 bfd_boolean 654 _bfd_sparc_elf_info_to_howto (bfd *abfd, arelent *cache_ptr, 655 Elf_Internal_Rela *dst) 656 { 657 unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info); 658 659 if ((cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, r_type)) == NULL) 660 { 661 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 662 abfd, r_type); 663 bfd_set_error (bfd_error_bad_value); 664 return FALSE; 665 } 666 return TRUE; 667 } 668 669 670 /* The nop opcode we use. */ 671 #define SPARC_NOP 0x01000000 672 673 #define SPARC_INSN_BYTES 4 674 675 /* Is an undefined weak symbol resolved to 0 ? 676 Reference to an undefined weak symbol is resolved to 0 when 677 building an executable if it isn't dynamic and 678 1. Has non-GOT/non-PLT relocations in text section. 679 Or 680 2. Has no GOT/PLT relocation. */ 681 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, EH) \ 682 ((EH)->elf.root.type == bfd_link_hash_undefweak \ 683 && bfd_link_executable (INFO) \ 684 && (_bfd_sparc_elf_hash_table (INFO)->interp == NULL \ 685 || !(INFO)->dynamic_undefined_weak \ 686 || (EH)->has_non_got_reloc \ 687 || !(EH)->has_got_reloc)) 688 689 /* SPARC ELF linker hash entry. */ 690 691 struct _bfd_sparc_elf_link_hash_entry 692 { 693 struct elf_link_hash_entry elf; 694 695 /* Track dynamic relocs copied for this symbol. */ 696 struct elf_dyn_relocs *dyn_relocs; 697 698 #define GOT_UNKNOWN 0 699 #define GOT_NORMAL 1 700 #define GOT_TLS_GD 2 701 #define GOT_TLS_IE 3 702 unsigned char tls_type; 703 704 /* Symbol has GOT or PLT relocations. */ 705 unsigned int has_got_reloc : 1; 706 707 /* Symbol has old-style, non-relaxable GOT relocations. */ 708 unsigned int has_old_style_got_reloc : 1; 709 710 /* Symbol has non-GOT/non-PLT relocations in text sections. */ 711 unsigned int has_non_got_reloc : 1; 712 713 }; 714 715 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent)) 716 717 struct _bfd_sparc_elf_obj_tdata 718 { 719 struct elf_obj_tdata root; 720 721 /* tls_type for each local got entry. */ 722 char *local_got_tls_type; 723 724 /* TRUE if TLS GD relocs has been seen for this object. */ 725 bfd_boolean has_tlsgd; 726 }; 727 728 #define _bfd_sparc_elf_tdata(abfd) \ 729 ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any) 730 731 #define _bfd_sparc_elf_local_got_tls_type(abfd) \ 732 (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type) 733 734 #define is_sparc_elf(bfd) \ 735 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 736 && elf_tdata (bfd) != NULL \ 737 && elf_object_id (bfd) == SPARC_ELF_DATA) 738 739 bfd_boolean 740 _bfd_sparc_elf_mkobject (bfd *abfd) 741 { 742 return bfd_elf_allocate_object (abfd, sizeof (struct _bfd_sparc_elf_obj_tdata), 743 SPARC_ELF_DATA); 744 } 745 746 static void 747 sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr) 748 { 749 bfd_put_32 (abfd, val, ptr); 750 } 751 752 static void 753 sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr) 754 { 755 bfd_put_64 (abfd, val, ptr); 756 } 757 758 static void 759 sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel) 760 { 761 const struct elf_backend_data *bed; 762 bfd_byte *loc; 763 764 bed = get_elf_backend_data (abfd); 765 BFD_ASSERT (s->reloc_count * bed->s->sizeof_rela < s->size); 766 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela); 767 bed->s->swap_reloca_out (abfd, rel, loc); 768 } 769 770 static bfd_vma 771 sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED, 772 bfd_vma rel_index ATTRIBUTE_UNUSED, 773 bfd_vma type ATTRIBUTE_UNUSED) 774 { 775 return ELF64_R_INFO (rel_index, 776 (in_rel ? 777 ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info), 778 type) : type)); 779 } 780 781 static bfd_vma 782 sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED, 783 bfd_vma rel_index, bfd_vma type) 784 { 785 return ELF32_R_INFO (rel_index, type); 786 } 787 788 static bfd_vma 789 sparc_elf_r_symndx_64 (bfd_vma r_info) 790 { 791 bfd_vma r_symndx = ELF32_R_SYM (r_info); 792 return (r_symndx >> 24); 793 } 794 795 static bfd_vma 796 sparc_elf_r_symndx_32 (bfd_vma r_info) 797 { 798 return ELF32_R_SYM (r_info); 799 } 800 801 /* PLT/GOT stuff */ 802 803 #define PLT32_ENTRY_SIZE 12 804 #define PLT32_HEADER_SIZE (4 * PLT32_ENTRY_SIZE) 805 806 /* The first four entries in a 32-bit procedure linkage table are reserved, 807 and the initial contents are unimportant (we zero them out). 808 Subsequent entries look like this. See the SVR4 ABI SPARC 809 supplement to see how this works. */ 810 811 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */ 812 #define PLT32_ENTRY_WORD0 0x03000000 813 /* b,a .plt0. We fill in the offset later. */ 814 #define PLT32_ENTRY_WORD1 0x30800000 815 /* nop. */ 816 #define PLT32_ENTRY_WORD2 SPARC_NOP 817 818 static int 819 sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset, 820 bfd_vma max ATTRIBUTE_UNUSED, 821 bfd_vma *r_offset) 822 { 823 bfd_put_32 (output_bfd, 824 PLT32_ENTRY_WORD0 + offset, 825 splt->contents + offset); 826 bfd_put_32 (output_bfd, 827 (PLT32_ENTRY_WORD1 828 + (((- (offset + 4)) >> 2) & 0x3fffff)), 829 splt->contents + offset + 4); 830 bfd_put_32 (output_bfd, (bfd_vma) PLT32_ENTRY_WORD2, 831 splt->contents + offset + 8); 832 833 *r_offset = offset; 834 835 return offset / PLT32_ENTRY_SIZE - 4; 836 } 837 838 /* Both the headers and the entries are icache aligned. */ 839 #define PLT64_ENTRY_SIZE 32 840 #define PLT64_HEADER_SIZE (4 * PLT64_ENTRY_SIZE) 841 #define PLT64_LARGE_THRESHOLD 32768 842 843 static int 844 sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset, 845 bfd_vma max, bfd_vma *r_offset) 846 { 847 unsigned char *entry = splt->contents + offset; 848 const unsigned int nop = SPARC_NOP; 849 int plt_index; 850 851 if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)) 852 { 853 unsigned int sethi, ba; 854 855 *r_offset = offset; 856 857 plt_index = (offset / PLT64_ENTRY_SIZE); 858 859 sethi = 0x03000000 | (plt_index * PLT64_ENTRY_SIZE); 860 ba = 0x30680000 861 | (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff); 862 863 bfd_put_32 (output_bfd, (bfd_vma) sethi, entry); 864 bfd_put_32 (output_bfd, (bfd_vma) ba, entry + 4); 865 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 8); 866 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 12); 867 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 16); 868 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 20); 869 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 24); 870 bfd_put_32 (output_bfd, (bfd_vma) nop, entry + 28); 871 } 872 else 873 { 874 unsigned char *ptr; 875 unsigned int ldx; 876 int block, last_block, ofs, last_ofs, chunks_this_block; 877 const int insn_chunk_size = (6 * 4); 878 const int ptr_chunk_size = (1 * 8); 879 const int entries_per_block = 160; 880 const int block_size = entries_per_block * (insn_chunk_size 881 + ptr_chunk_size); 882 883 /* Entries 32768 and higher are grouped into blocks of 160. 884 The blocks are further subdivided into 160 sequences of 885 6 instructions and 160 pointers. If a block does not require 886 the full 160 entries, let's say it requires N, then there 887 will be N sequences of 6 instructions and N pointers. */ 888 889 offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE); 890 max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE); 891 892 block = offset / block_size; 893 last_block = max / block_size; 894 if (block != last_block) 895 { 896 chunks_this_block = 160; 897 } 898 else 899 { 900 last_ofs = max % block_size; 901 chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size); 902 } 903 904 ofs = offset % block_size; 905 906 plt_index = (PLT64_LARGE_THRESHOLD + 907 (block * 160) + 908 (ofs / insn_chunk_size)); 909 910 ptr = splt->contents 911 + (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE) 912 + (block * block_size) 913 + (chunks_this_block * insn_chunk_size) 914 + (ofs / insn_chunk_size) * ptr_chunk_size; 915 916 *r_offset = (bfd_vma) (ptr - splt->contents); 917 918 ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff); 919 920 /* mov %o7,%g5 921 call .+8 922 nop 923 ldx [%o7+P],%g1 924 jmpl %o7+%g1,%g1 925 mov %g5,%o7 */ 926 bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry); 927 bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4); 928 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, entry + 8); 929 bfd_put_32 (output_bfd, (bfd_vma) ldx, entry + 12); 930 bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16); 931 bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20); 932 933 bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr); 934 } 935 936 return plt_index - 4; 937 } 938 939 /* The format of the first PLT entry in a VxWorks executable. */ 940 static const bfd_vma sparc_vxworks_exec_plt0_entry[] = 941 { 942 0x05000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */ 943 0x8410a000, /* or %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */ 944 0xc4008000, /* ld [ %g2 ], %g2 */ 945 0x81c08000, /* jmp %g2 */ 946 0x01000000 /* nop */ 947 }; 948 949 /* The format of subsequent PLT entries. */ 950 static const bfd_vma sparc_vxworks_exec_plt_entry[] = 951 { 952 0x03000000, /* sethi %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */ 953 0x82106000, /* or %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */ 954 0xc2004000, /* ld [ %g1 ], %g1 */ 955 0x81c04000, /* jmp %g1 */ 956 0x01000000, /* nop */ 957 0x03000000, /* sethi %hi(f@pltindex), %g1 */ 958 0x10800000, /* b _PLT_resolve */ 959 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */ 960 }; 961 962 /* The format of the first PLT entry in a VxWorks shared object. */ 963 static const bfd_vma sparc_vxworks_shared_plt0_entry[] = 964 { 965 0xc405e008, /* ld [ %l7 + 8 ], %g2 */ 966 0x81c08000, /* jmp %g2 */ 967 0x01000000 /* nop */ 968 }; 969 970 /* The format of subsequent PLT entries. */ 971 static const bfd_vma sparc_vxworks_shared_plt_entry[] = 972 { 973 0x03000000, /* sethi %hi(f@got), %g1 */ 974 0x82106000, /* or %g1, %lo(f@got), %g1 */ 975 0xc205c001, /* ld [ %l7 + %g1 ], %g1 */ 976 0x81c04000, /* jmp %g1 */ 977 0x01000000, /* nop */ 978 0x03000000, /* sethi %hi(f@pltindex), %g1 */ 979 0x10800000, /* b _PLT_resolve */ 980 0x82106000 /* or %g1, %lo(f@pltindex), %g1 */ 981 }; 982 983 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr) \ 984 htab->put_word(bfd, val, ptr) 985 986 #define SPARC_ELF_R_INFO(htab, in_rel, index, type) \ 987 htab->r_info(in_rel, index, type) 988 989 #define SPARC_ELF_R_SYMNDX(htab, r_info) \ 990 htab->r_symndx(r_info) 991 992 #define SPARC_ELF_WORD_BYTES(htab) \ 993 htab->bytes_per_word 994 995 #define SPARC_ELF_RELA_BYTES(htab) \ 996 htab->bytes_per_rela 997 998 #define SPARC_ELF_DTPOFF_RELOC(htab) \ 999 htab->dtpoff_reloc 1000 1001 #define SPARC_ELF_DTPMOD_RELOC(htab) \ 1002 htab->dtpmod_reloc 1003 1004 #define SPARC_ELF_TPOFF_RELOC(htab) \ 1005 htab->tpoff_reloc 1006 1007 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \ 1008 htab->build_plt_entry (obfd, splt, off, max, r_off) 1009 1010 /* Create an entry in an SPARC ELF linker hash table. */ 1011 1012 static struct bfd_hash_entry * 1013 link_hash_newfunc (struct bfd_hash_entry *entry, 1014 struct bfd_hash_table *table, const char *string) 1015 { 1016 /* Allocate the structure if it has not already been allocated by a 1017 subclass. */ 1018 if (entry == NULL) 1019 { 1020 entry = bfd_hash_allocate (table, 1021 sizeof (struct _bfd_sparc_elf_link_hash_entry)); 1022 if (entry == NULL) 1023 return entry; 1024 } 1025 1026 /* Call the allocation method of the superclass. */ 1027 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 1028 if (entry != NULL) 1029 { 1030 struct _bfd_sparc_elf_link_hash_entry *eh; 1031 1032 eh = (struct _bfd_sparc_elf_link_hash_entry *) entry; 1033 eh->dyn_relocs = NULL; 1034 eh->tls_type = GOT_UNKNOWN; 1035 eh->has_got_reloc = 0; 1036 eh->has_non_got_reloc = 0; 1037 } 1038 1039 return entry; 1040 } 1041 1042 /* The name of the dynamic interpreter. This is put in the .interp 1043 section. */ 1044 1045 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 1046 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1" 1047 1048 /* Compute a hash of a local hash entry. We use elf_link_hash_entry 1049 for local symbol so that we can handle local STT_GNU_IFUNC symbols 1050 as global symbol. We reuse indx and dynstr_index for local symbol 1051 hash since they aren't used by global symbols in this backend. */ 1052 1053 static hashval_t 1054 elf_sparc_local_htab_hash (const void *ptr) 1055 { 1056 struct elf_link_hash_entry *h 1057 = (struct elf_link_hash_entry *) ptr; 1058 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index); 1059 } 1060 1061 /* Compare local hash entries. */ 1062 1063 static int 1064 elf_sparc_local_htab_eq (const void *ptr1, const void *ptr2) 1065 { 1066 struct elf_link_hash_entry *h1 1067 = (struct elf_link_hash_entry *) ptr1; 1068 struct elf_link_hash_entry *h2 1069 = (struct elf_link_hash_entry *) ptr2; 1070 1071 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index; 1072 } 1073 1074 /* Find and/or create a hash entry for local symbol. */ 1075 1076 static struct elf_link_hash_entry * 1077 elf_sparc_get_local_sym_hash (struct _bfd_sparc_elf_link_hash_table *htab, 1078 bfd *abfd, const Elf_Internal_Rela *rel, 1079 bfd_boolean create) 1080 { 1081 struct _bfd_sparc_elf_link_hash_entry e, *ret; 1082 asection *sec = abfd->sections; 1083 unsigned long r_symndx; 1084 hashval_t h; 1085 void **slot; 1086 1087 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info); 1088 h = ELF_LOCAL_SYMBOL_HASH (sec->id, r_symndx); 1089 1090 e.elf.indx = sec->id; 1091 e.elf.dynstr_index = r_symndx; 1092 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h, 1093 create ? INSERT : NO_INSERT); 1094 1095 if (!slot) 1096 return NULL; 1097 1098 if (*slot) 1099 { 1100 ret = (struct _bfd_sparc_elf_link_hash_entry *) *slot; 1101 return &ret->elf; 1102 } 1103 1104 ret = (struct _bfd_sparc_elf_link_hash_entry *) 1105 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory, 1106 sizeof (struct _bfd_sparc_elf_link_hash_entry)); 1107 if (ret) 1108 { 1109 memset (ret, 0, sizeof (*ret)); 1110 ret->elf.indx = sec->id; 1111 ret->elf.dynstr_index = r_symndx; 1112 ret->elf.dynindx = -1; 1113 ret->elf.plt.offset = (bfd_vma) -1; 1114 ret->elf.got.offset = (bfd_vma) -1; 1115 *slot = ret; 1116 } 1117 return &ret->elf; 1118 } 1119 1120 /* Destroy a SPARC ELF linker hash table. */ 1121 1122 static void 1123 _bfd_sparc_elf_link_hash_table_free (bfd *obfd) 1124 { 1125 struct _bfd_sparc_elf_link_hash_table *htab 1126 = (struct _bfd_sparc_elf_link_hash_table *) obfd->link.hash; 1127 1128 if (htab->loc_hash_table) 1129 htab_delete (htab->loc_hash_table); 1130 if (htab->loc_hash_memory) 1131 objalloc_free ((struct objalloc *) htab->loc_hash_memory); 1132 _bfd_elf_link_hash_table_free (obfd); 1133 } 1134 1135 /* Create a SPARC ELF linker hash table. */ 1136 1137 struct bfd_link_hash_table * 1138 _bfd_sparc_elf_link_hash_table_create (bfd *abfd) 1139 { 1140 struct _bfd_sparc_elf_link_hash_table *ret; 1141 bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table); 1142 1143 ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt); 1144 if (ret == NULL) 1145 return NULL; 1146 1147 if (ABI_64_P (abfd)) 1148 { 1149 ret->put_word = sparc_put_word_64; 1150 ret->r_info = sparc_elf_r_info_64; 1151 ret->r_symndx = sparc_elf_r_symndx_64; 1152 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF64; 1153 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD64; 1154 ret->tpoff_reloc = R_SPARC_TLS_TPOFF64; 1155 ret->word_align_power = 3; 1156 ret->align_power_max = 4; 1157 ret->bytes_per_word = 8; 1158 ret->bytes_per_rela = sizeof (Elf64_External_Rela); 1159 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER; 1160 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER; 1161 1162 ret->build_plt_entry = sparc64_plt_entry_build; 1163 ret->plt_header_size = PLT64_HEADER_SIZE; 1164 ret->plt_entry_size = PLT64_ENTRY_SIZE; 1165 } 1166 else 1167 { 1168 ret->put_word = sparc_put_word_32; 1169 ret->r_info = sparc_elf_r_info_32; 1170 ret->r_symndx = sparc_elf_r_symndx_32; 1171 ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF32; 1172 ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD32; 1173 ret->tpoff_reloc = R_SPARC_TLS_TPOFF32; 1174 ret->word_align_power = 2; 1175 ret->align_power_max = 3; 1176 ret->bytes_per_word = 4; 1177 ret->bytes_per_rela = sizeof (Elf32_External_Rela); 1178 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER; 1179 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER; 1180 1181 ret->build_plt_entry = sparc32_plt_entry_build; 1182 ret->plt_header_size = PLT32_HEADER_SIZE; 1183 ret->plt_entry_size = PLT32_ENTRY_SIZE; 1184 } 1185 1186 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc, 1187 sizeof (struct _bfd_sparc_elf_link_hash_entry), 1188 SPARC_ELF_DATA)) 1189 { 1190 free (ret); 1191 return NULL; 1192 } 1193 1194 ret->loc_hash_table = htab_try_create (1024, 1195 elf_sparc_local_htab_hash, 1196 elf_sparc_local_htab_eq, 1197 NULL); 1198 ret->loc_hash_memory = objalloc_create (); 1199 if (!ret->loc_hash_table || !ret->loc_hash_memory) 1200 { 1201 _bfd_sparc_elf_link_hash_table_free (abfd); 1202 return NULL; 1203 } 1204 ret->elf.root.hash_table_free = _bfd_sparc_elf_link_hash_table_free; 1205 1206 return &ret->elf.root; 1207 } 1208 1209 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and 1210 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our 1211 hash table. */ 1212 1213 bfd_boolean 1214 _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj, 1215 struct bfd_link_info *info) 1216 { 1217 struct _bfd_sparc_elf_link_hash_table *htab; 1218 1219 htab = _bfd_sparc_elf_hash_table (info); 1220 BFD_ASSERT (htab != NULL); 1221 1222 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 1223 return FALSE; 1224 1225 if (htab->is_vxworks) 1226 { 1227 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2)) 1228 return FALSE; 1229 if (bfd_link_pic (info)) 1230 { 1231 htab->plt_header_size 1232 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); 1233 htab->plt_entry_size 1234 = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry); 1235 } 1236 else 1237 { 1238 htab->plt_header_size 1239 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry); 1240 htab->plt_entry_size 1241 = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry); 1242 } 1243 } 1244 1245 if (!htab->elf.splt || !htab->elf.srelplt || !htab->elf.sdynbss 1246 || (!bfd_link_pic (info) && !htab->elf.srelbss)) 1247 abort (); 1248 1249 return TRUE; 1250 } 1251 1252 static bfd_boolean 1253 create_ifunc_sections (bfd *abfd, struct bfd_link_info *info) 1254 { 1255 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 1256 struct elf_link_hash_table *htab = elf_hash_table (info); 1257 flagword flags, pltflags; 1258 asection *s; 1259 1260 if (htab->irelifunc != NULL || htab->iplt != NULL) 1261 return TRUE; 1262 1263 flags = bed->dynamic_sec_flags; 1264 pltflags = flags | SEC_ALLOC | SEC_CODE | SEC_LOAD; 1265 1266 s = bfd_make_section_with_flags (abfd, ".iplt", pltflags); 1267 if (s == NULL 1268 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) 1269 return FALSE; 1270 htab->iplt = s; 1271 1272 s = bfd_make_section_with_flags (abfd, ".rela.iplt", 1273 flags | SEC_READONLY); 1274 if (s == NULL 1275 || ! bfd_set_section_alignment (abfd, s, 1276 bed->s->log_file_align)) 1277 return FALSE; 1278 htab->irelplt = s; 1279 1280 return TRUE; 1281 } 1282 1283 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 1284 1285 void 1286 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info, 1287 struct elf_link_hash_entry *dir, 1288 struct elf_link_hash_entry *ind) 1289 { 1290 struct _bfd_sparc_elf_link_hash_entry *edir, *eind; 1291 1292 edir = (struct _bfd_sparc_elf_link_hash_entry *) dir; 1293 eind = (struct _bfd_sparc_elf_link_hash_entry *) ind; 1294 1295 if (eind->dyn_relocs != NULL) 1296 { 1297 if (edir->dyn_relocs != NULL) 1298 { 1299 struct elf_dyn_relocs **pp; 1300 struct elf_dyn_relocs *p; 1301 1302 /* Add reloc counts against the indirect sym to the direct sym 1303 list. Merge any entries against the same section. */ 1304 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 1305 { 1306 struct elf_dyn_relocs *q; 1307 1308 for (q = edir->dyn_relocs; q != NULL; q = q->next) 1309 if (q->sec == p->sec) 1310 { 1311 q->pc_count += p->pc_count; 1312 q->count += p->count; 1313 *pp = p->next; 1314 break; 1315 } 1316 if (q == NULL) 1317 pp = &p->next; 1318 } 1319 *pp = edir->dyn_relocs; 1320 } 1321 1322 edir->dyn_relocs = eind->dyn_relocs; 1323 eind->dyn_relocs = NULL; 1324 } 1325 1326 if (ind->root.type == bfd_link_hash_indirect && dir->got.refcount <= 0) 1327 { 1328 edir->tls_type = eind->tls_type; 1329 eind->tls_type = GOT_UNKNOWN; 1330 } 1331 1332 /* Copy has_got_reloc and has_non_got_reloc. */ 1333 edir->has_got_reloc |= eind->has_got_reloc; 1334 edir->has_non_got_reloc |= eind->has_non_got_reloc; 1335 1336 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 1337 } 1338 1339 static int 1340 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd, 1341 int r_type, int is_local) 1342 { 1343 if (! ABI_64_P (abfd) 1344 && r_type == R_SPARC_TLS_GD_HI22 1345 && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd) 1346 return R_SPARC_REV32; 1347 1348 if (!bfd_link_executable (info)) 1349 return r_type; 1350 1351 switch (r_type) 1352 { 1353 case R_SPARC_TLS_GD_HI22: 1354 return is_local ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_IE_HI22; 1355 case R_SPARC_TLS_GD_LO10: 1356 return is_local ? R_SPARC_TLS_LE_LOX10 : R_SPARC_TLS_IE_LO10; 1357 case R_SPARC_TLS_LDM_HI22: 1358 return R_SPARC_TLS_LE_HIX22; 1359 case R_SPARC_TLS_LDM_LO10: 1360 return R_SPARC_TLS_LE_LOX10; 1361 case R_SPARC_TLS_IE_HI22: 1362 return is_local ? R_SPARC_TLS_LE_HIX22 : r_type; 1363 case R_SPARC_TLS_IE_LO10: 1364 return is_local ? R_SPARC_TLS_LE_LOX10 : r_type; 1365 } 1366 1367 return r_type; 1368 } 1369 1370 /* Look through the relocs for a section during the first phase, and 1371 allocate space in the global offset table or procedure linkage 1372 table. */ 1373 1374 bfd_boolean 1375 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, 1376 asection *sec, const Elf_Internal_Rela *relocs) 1377 { 1378 struct _bfd_sparc_elf_link_hash_table *htab; 1379 Elf_Internal_Shdr *symtab_hdr; 1380 struct elf_link_hash_entry **sym_hashes; 1381 const Elf_Internal_Rela *rel; 1382 const Elf_Internal_Rela *rel_end; 1383 asection *sreloc; 1384 int num_relocs; 1385 bfd_boolean checked_tlsgd = FALSE; 1386 1387 if (bfd_link_relocatable (info)) 1388 return TRUE; 1389 1390 htab = _bfd_sparc_elf_hash_table (info); 1391 BFD_ASSERT (htab != NULL); 1392 symtab_hdr = &elf_symtab_hdr (abfd); 1393 sym_hashes = elf_sym_hashes (abfd); 1394 1395 sreloc = NULL; 1396 1397 if (ABI_64_P (abfd)) 1398 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec)); 1399 else 1400 num_relocs = sec->reloc_count; 1401 1402 BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0); 1403 1404 if (htab->elf.dynobj == NULL) 1405 htab->elf.dynobj = abfd; 1406 if (!create_ifunc_sections (htab->elf.dynobj, info)) 1407 return FALSE; 1408 1409 rel_end = relocs + num_relocs; 1410 for (rel = relocs; rel < rel_end; rel++) 1411 { 1412 unsigned int r_type; 1413 unsigned int r_symndx; 1414 struct elf_link_hash_entry *h; 1415 struct _bfd_sparc_elf_link_hash_entry *eh; 1416 Elf_Internal_Sym *isym; 1417 1418 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info); 1419 r_type = SPARC_ELF_R_TYPE (rel->r_info); 1420 1421 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 1422 { 1423 /* xgettext:c-format */ 1424 _bfd_error_handler (_("%pB: bad symbol index: %d"), abfd, r_symndx); 1425 return FALSE; 1426 } 1427 1428 isym = NULL; 1429 if (r_symndx < symtab_hdr->sh_info) 1430 { 1431 /* A local symbol. */ 1432 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx); 1433 if (isym == NULL) 1434 return FALSE; 1435 1436 /* Check relocation against local STT_GNU_IFUNC symbol. */ 1437 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) 1438 { 1439 h = elf_sparc_get_local_sym_hash (htab, abfd, rel, TRUE); 1440 if (h == NULL) 1441 return FALSE; 1442 1443 /* Fake a STT_GNU_IFUNC symbol. */ 1444 h->type = STT_GNU_IFUNC; 1445 h->def_regular = 1; 1446 h->ref_regular = 1; 1447 h->forced_local = 1; 1448 h->root.type = bfd_link_hash_defined; 1449 } 1450 else 1451 h = NULL; 1452 } 1453 else 1454 { 1455 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1456 while (h->root.type == bfd_link_hash_indirect 1457 || h->root.type == bfd_link_hash_warning) 1458 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1459 } 1460 1461 if (h && h->type == STT_GNU_IFUNC && h->def_regular) 1462 { 1463 h->ref_regular = 1; 1464 h->plt.refcount += 1; 1465 } 1466 1467 /* Compatibility with old R_SPARC_REV32 reloc conflicting 1468 with R_SPARC_TLS_GD_HI22. */ 1469 if (! ABI_64_P (abfd) && ! checked_tlsgd) 1470 switch (r_type) 1471 { 1472 case R_SPARC_TLS_GD_HI22: 1473 { 1474 const Elf_Internal_Rela *relt; 1475 1476 for (relt = rel + 1; relt < rel_end; relt++) 1477 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10 1478 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD 1479 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL) 1480 break; 1481 checked_tlsgd = TRUE; 1482 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end; 1483 } 1484 break; 1485 case R_SPARC_TLS_GD_LO10: 1486 case R_SPARC_TLS_GD_ADD: 1487 case R_SPARC_TLS_GD_CALL: 1488 checked_tlsgd = TRUE; 1489 _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE; 1490 break; 1491 } 1492 1493 r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL); 1494 eh = (struct _bfd_sparc_elf_link_hash_entry *) h; 1495 1496 switch (r_type) 1497 { 1498 case R_SPARC_TLS_LDM_HI22: 1499 case R_SPARC_TLS_LDM_LO10: 1500 htab->tls_ldm_got.refcount += 1; 1501 if (eh != NULL) 1502 eh->has_got_reloc = 1; 1503 break; 1504 1505 case R_SPARC_TLS_LE_HIX22: 1506 case R_SPARC_TLS_LE_LOX10: 1507 if (!bfd_link_executable (info)) 1508 goto r_sparc_plt32; 1509 break; 1510 1511 case R_SPARC_TLS_IE_HI22: 1512 case R_SPARC_TLS_IE_LO10: 1513 if (!bfd_link_executable (info)) 1514 info->flags |= DF_STATIC_TLS; 1515 /* Fall through */ 1516 1517 case R_SPARC_GOT10: 1518 case R_SPARC_GOT13: 1519 case R_SPARC_GOT22: 1520 case R_SPARC_GOTDATA_HIX22: 1521 case R_SPARC_GOTDATA_LOX10: 1522 case R_SPARC_GOTDATA_OP_HIX22: 1523 case R_SPARC_GOTDATA_OP_LOX10: 1524 case R_SPARC_TLS_GD_HI22: 1525 case R_SPARC_TLS_GD_LO10: 1526 /* This symbol requires a global offset table entry. */ 1527 { 1528 int tls_type, old_tls_type; 1529 1530 switch (r_type) 1531 { 1532 case R_SPARC_TLS_GD_HI22: 1533 case R_SPARC_TLS_GD_LO10: 1534 tls_type = GOT_TLS_GD; 1535 break; 1536 case R_SPARC_TLS_IE_HI22: 1537 case R_SPARC_TLS_IE_LO10: 1538 tls_type = GOT_TLS_IE; 1539 break; 1540 default: 1541 tls_type = GOT_NORMAL; 1542 break; 1543 } 1544 1545 if (h != NULL) 1546 { 1547 h->got.refcount += 1; 1548 old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type; 1549 } 1550 else 1551 { 1552 bfd_signed_vma *local_got_refcounts; 1553 1554 /* This is a global offset table entry for a local symbol. */ 1555 local_got_refcounts = elf_local_got_refcounts (abfd); 1556 if (local_got_refcounts == NULL) 1557 { 1558 bfd_size_type size; 1559 1560 size = symtab_hdr->sh_info; 1561 size *= (sizeof (bfd_signed_vma) + sizeof(char)); 1562 local_got_refcounts = ((bfd_signed_vma *) 1563 bfd_zalloc (abfd, size)); 1564 if (local_got_refcounts == NULL) 1565 return FALSE; 1566 elf_local_got_refcounts (abfd) = local_got_refcounts; 1567 _bfd_sparc_elf_local_got_tls_type (abfd) 1568 = (char *) (local_got_refcounts + symtab_hdr->sh_info); 1569 } 1570 1571 if (r_type != R_SPARC_GOTDATA_OP_HIX22 1572 && r_type != R_SPARC_GOTDATA_OP_LOX10) 1573 local_got_refcounts[r_symndx] += 1; 1574 1575 old_tls_type 1576 = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx]; 1577 } 1578 1579 /* If a TLS symbol is accessed using IE at least once, there is no 1580 point in using the dynamic model for it. */ 1581 if (old_tls_type != tls_type) 1582 { 1583 if (old_tls_type == GOT_UNKNOWN) 1584 ; 1585 else if (old_tls_type == GOT_TLS_GD && tls_type == GOT_TLS_IE) 1586 ; 1587 else if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD) 1588 tls_type = old_tls_type; 1589 else 1590 { 1591 _bfd_error_handler 1592 /* xgettext:c-format */ 1593 (_("%pB: `%s' accessed both as normal and thread local symbol"), 1594 abfd, h ? h->root.root.string : "<local>"); 1595 return FALSE; 1596 } 1597 1598 if (h != NULL) 1599 _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type; 1600 else 1601 _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type; 1602 } 1603 } 1604 1605 if (!htab->elf.sgot 1606 && !_bfd_elf_create_got_section (htab->elf.dynobj, info)) 1607 return FALSE; 1608 1609 if (eh != NULL) 1610 { 1611 eh->has_got_reloc = 1; 1612 if (r_type == R_SPARC_GOT10 1613 || r_type == R_SPARC_GOT13 1614 || r_type == R_SPARC_GOT22) 1615 eh->has_old_style_got_reloc = 1; 1616 } 1617 break; 1618 1619 case R_SPARC_TLS_GD_CALL: 1620 case R_SPARC_TLS_LDM_CALL: 1621 if (bfd_link_executable (info)) 1622 break; 1623 1624 /* Essentially R_SPARC_WPLT30 relocs against __tls_get_addr. */ 1625 h = (struct elf_link_hash_entry *) 1626 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE, 1627 FALSE, TRUE); 1628 BFD_ASSERT (h != NULL); 1629 /* Fall through */ 1630 1631 case R_SPARC_WPLT30: 1632 case R_SPARC_PLT32: 1633 case R_SPARC_PLT64: 1634 case R_SPARC_HIPLT22: 1635 case R_SPARC_LOPLT10: 1636 case R_SPARC_PCPLT32: 1637 case R_SPARC_PCPLT22: 1638 case R_SPARC_PCPLT10: 1639 /* This symbol requires a procedure linkage table entry. 1640 We actually build the entry in adjust_dynamic_symbol, 1641 because this might be a case of linking PIC code without 1642 linking in any dynamic objects, in which case we don't 1643 need to generate a procedure linkage table after all. */ 1644 1645 if (h == NULL) 1646 { 1647 if (! ABI_64_P (abfd)) 1648 { 1649 /* The Solaris native assembler will generate a WPLT30 1650 reloc for a local symbol if you assemble a call from 1651 one section to another when using -K pic. We treat 1652 it as WDISP30. */ 1653 if (r_type == R_SPARC_PLT32) 1654 goto r_sparc_plt32; 1655 break; 1656 } 1657 /* PR 7027: We need similar behaviour for 64-bit binaries. */ 1658 else if (r_type == R_SPARC_WPLT30) 1659 break; 1660 1661 /* It does not make sense to have a procedure linkage 1662 table entry for a local symbol. */ 1663 bfd_set_error (bfd_error_bad_value); 1664 return FALSE; 1665 } 1666 1667 h->needs_plt = 1; 1668 1669 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64) 1670 goto r_sparc_plt32; 1671 1672 h->plt.refcount += 1; 1673 1674 eh = (struct _bfd_sparc_elf_link_hash_entry *) h; 1675 eh->has_got_reloc = 1; 1676 break; 1677 1678 case R_SPARC_PC10: 1679 case R_SPARC_PC22: 1680 case R_SPARC_PC_HH22: 1681 case R_SPARC_PC_HM10: 1682 case R_SPARC_PC_LM22: 1683 if (h != NULL) 1684 h->non_got_ref = 1; 1685 1686 if (h != NULL 1687 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1688 break; 1689 /* Fall through. */ 1690 1691 case R_SPARC_DISP8: 1692 case R_SPARC_DISP16: 1693 case R_SPARC_DISP32: 1694 case R_SPARC_DISP64: 1695 case R_SPARC_WDISP30: 1696 case R_SPARC_WDISP22: 1697 case R_SPARC_WDISP19: 1698 case R_SPARC_WDISP16: 1699 case R_SPARC_WDISP10: 1700 case R_SPARC_8: 1701 case R_SPARC_16: 1702 case R_SPARC_32: 1703 case R_SPARC_HI22: 1704 case R_SPARC_22: 1705 case R_SPARC_13: 1706 case R_SPARC_LO10: 1707 case R_SPARC_UA16: 1708 case R_SPARC_UA32: 1709 case R_SPARC_10: 1710 case R_SPARC_11: 1711 case R_SPARC_64: 1712 case R_SPARC_OLO10: 1713 case R_SPARC_HH22: 1714 case R_SPARC_HM10: 1715 case R_SPARC_LM22: 1716 case R_SPARC_7: 1717 case R_SPARC_5: 1718 case R_SPARC_6: 1719 case R_SPARC_HIX22: 1720 case R_SPARC_LOX10: 1721 case R_SPARC_H44: 1722 case R_SPARC_M44: 1723 case R_SPARC_L44: 1724 case R_SPARC_H34: 1725 case R_SPARC_UA64: 1726 if (h != NULL) 1727 h->non_got_ref = 1; 1728 1729 if (eh != NULL && (sec->flags & SEC_CODE) != 0) 1730 eh->has_non_got_reloc = 1; 1731 1732 r_sparc_plt32: 1733 if (h != NULL && !bfd_link_pic (info)) 1734 { 1735 /* We may need a .plt entry if the function this reloc 1736 refers to is in a shared lib. */ 1737 h->plt.refcount += 1; 1738 } 1739 1740 /* If we are creating a shared library, and this is a reloc 1741 against a global symbol, or a non PC relative reloc 1742 against a local symbol, then we need to copy the reloc 1743 into the shared library. However, if we are linking with 1744 -Bsymbolic, we do not need to copy a reloc against a 1745 global symbol which is defined in an object we are 1746 including in the link (i.e., DEF_REGULAR is set). At 1747 this point we have not seen all the input files, so it is 1748 possible that DEF_REGULAR is not set now but will be set 1749 later (it is never cleared). In case of a weak definition, 1750 DEF_REGULAR may be cleared later by a strong definition in 1751 a shared library. We account for that possibility below by 1752 storing information in the relocs_copied field of the hash 1753 table entry. A similar situation occurs when creating 1754 shared libraries and symbol visibility changes render the 1755 symbol local. 1756 1757 If on the other hand, we are creating an executable, we 1758 may need to keep relocations for symbols satisfied by a 1759 dynamic library if we manage to avoid copy relocs for the 1760 symbol. */ 1761 if ((bfd_link_pic (info) 1762 && (sec->flags & SEC_ALLOC) != 0 1763 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative 1764 || (h != NULL 1765 && (! SYMBOLIC_BIND (info, h) 1766 || h->root.type == bfd_link_hash_defweak 1767 || !h->def_regular)))) 1768 || (!bfd_link_pic (info) 1769 && (sec->flags & SEC_ALLOC) != 0 1770 && h != NULL 1771 && (h->root.type == bfd_link_hash_defweak 1772 || !h->def_regular)) 1773 || (!bfd_link_pic (info) 1774 && h != NULL 1775 && h->type == STT_GNU_IFUNC)) 1776 { 1777 struct elf_dyn_relocs *p; 1778 struct elf_dyn_relocs **head; 1779 1780 /* When creating a shared object, we must copy these 1781 relocs into the output file. We create a reloc 1782 section in dynobj and make room for the reloc. */ 1783 if (sreloc == NULL) 1784 { 1785 sreloc = _bfd_elf_make_dynamic_reloc_section 1786 (sec, htab->elf.dynobj, htab->word_align_power, 1787 abfd, /*rela?*/ TRUE); 1788 1789 if (sreloc == NULL) 1790 return FALSE; 1791 } 1792 1793 /* If this is a global symbol, we count the number of 1794 relocations we need for this symbol. */ 1795 if (h != NULL) 1796 head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs; 1797 else 1798 { 1799 /* Track dynamic relocs needed for local syms too. 1800 We really need local syms available to do this 1801 easily. Oh well. */ 1802 asection *s; 1803 void *vpp; 1804 1805 BFD_ASSERT (isym != NULL); 1806 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 1807 if (s == NULL) 1808 s = sec; 1809 1810 vpp = &elf_section_data (s)->local_dynrel; 1811 head = (struct elf_dyn_relocs **) vpp; 1812 } 1813 1814 p = *head; 1815 if (p == NULL || p->sec != sec) 1816 { 1817 bfd_size_type amt = sizeof *p; 1818 p = ((struct elf_dyn_relocs *) 1819 bfd_alloc (htab->elf.dynobj, amt)); 1820 if (p == NULL) 1821 return FALSE; 1822 p->next = *head; 1823 *head = p; 1824 p->sec = sec; 1825 p->count = 0; 1826 p->pc_count = 0; 1827 } 1828 1829 p->count += 1; 1830 if (_bfd_sparc_elf_howto_table[r_type].pc_relative) 1831 p->pc_count += 1; 1832 } 1833 1834 break; 1835 1836 case R_SPARC_GNU_VTINHERIT: 1837 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 1838 return FALSE; 1839 break; 1840 1841 case R_SPARC_GNU_VTENTRY: 1842 BFD_ASSERT (h != NULL); 1843 if (h != NULL 1844 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 1845 return FALSE; 1846 break; 1847 1848 case R_SPARC_REGISTER: 1849 /* Nothing to do. */ 1850 break; 1851 1852 default: 1853 break; 1854 } 1855 } 1856 1857 return TRUE; 1858 } 1859 1860 asection * 1861 _bfd_sparc_elf_gc_mark_hook (asection *sec, 1862 struct bfd_link_info *info, 1863 Elf_Internal_Rela *rel, 1864 struct elf_link_hash_entry *h, 1865 Elf_Internal_Sym *sym) 1866 { 1867 if (h != NULL) 1868 switch (SPARC_ELF_R_TYPE (rel->r_info)) 1869 { 1870 case R_SPARC_GNU_VTINHERIT: 1871 case R_SPARC_GNU_VTENTRY: 1872 return NULL; 1873 } 1874 1875 if (!bfd_link_executable (info)) 1876 { 1877 switch (SPARC_ELF_R_TYPE (rel->r_info)) 1878 { 1879 case R_SPARC_TLS_GD_CALL: 1880 case R_SPARC_TLS_LDM_CALL: 1881 /* This reloc implicitly references __tls_get_addr. We know 1882 another reloc will reference the same symbol as the one 1883 on this reloc, so the real symbol and section will be 1884 gc marked when processing the other reloc. That lets 1885 us handle __tls_get_addr here. */ 1886 h = elf_link_hash_lookup (elf_hash_table (info), "__tls_get_addr", 1887 FALSE, FALSE, TRUE); 1888 BFD_ASSERT (h != NULL); 1889 h->mark = 1; 1890 if (h->is_weakalias) 1891 weakdef (h)->mark = 1; 1892 sym = NULL; 1893 } 1894 } 1895 1896 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 1897 } 1898 1899 static Elf_Internal_Rela * 1900 sparc_elf_find_reloc_at_ofs (Elf_Internal_Rela *rel, 1901 Elf_Internal_Rela *relend, 1902 bfd_vma offset) 1903 { 1904 while (rel < relend) 1905 { 1906 if (rel->r_offset == offset) 1907 return rel; 1908 rel++; 1909 } 1910 return NULL; 1911 } 1912 1913 /* Remove undefined weak symbol from the dynamic symbol table if it 1914 is resolved to 0. */ 1915 1916 bfd_boolean 1917 _bfd_sparc_elf_fixup_symbol (struct bfd_link_info *info, 1918 struct elf_link_hash_entry *h) 1919 { 1920 if (h->dynindx != -1 1921 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, 1922 _bfd_sparc_elf_hash_entry (h))) 1923 { 1924 h->dynindx = -1; 1925 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 1926 h->dynstr_index); 1927 } 1928 return TRUE; 1929 } 1930 1931 /* Find dynamic relocs for H that apply to read-only sections. */ 1932 1933 static asection * 1934 readonly_dynrelocs (struct elf_link_hash_entry *h) 1935 { 1936 struct elf_dyn_relocs *p; 1937 1938 for (p = _bfd_sparc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) 1939 { 1940 asection *s = p->sec->output_section; 1941 1942 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1943 return p->sec; 1944 } 1945 return NULL; 1946 } 1947 1948 /* Adjust a symbol defined by a dynamic object and referenced by a 1949 regular object. The current definition is in some section of the 1950 dynamic object, but we're not including those sections. We have to 1951 change the definition to something the rest of the link can 1952 understand. */ 1953 1954 bfd_boolean 1955 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 1956 struct elf_link_hash_entry *h) 1957 { 1958 struct _bfd_sparc_elf_link_hash_table *htab; 1959 asection *s, *srel; 1960 1961 htab = _bfd_sparc_elf_hash_table (info); 1962 BFD_ASSERT (htab != NULL); 1963 1964 /* Make sure we know what is going on here. */ 1965 BFD_ASSERT (htab->elf.dynobj != NULL 1966 && (h->needs_plt 1967 || h->type == STT_GNU_IFUNC 1968 || h->is_weakalias 1969 || (h->def_dynamic 1970 && h->ref_regular 1971 && !h->def_regular))); 1972 1973 /* If this is a function, put it in the procedure linkage table. We 1974 will fill in the contents of the procedure linkage table later 1975 (although we could actually do it here). The STT_NOTYPE 1976 condition is a hack specifically for the Oracle libraries 1977 delivered for Solaris; for some inexplicable reason, they define 1978 some of their functions as STT_NOTYPE when they really should be 1979 STT_FUNC. */ 1980 if (h->type == STT_FUNC 1981 || h->type == STT_GNU_IFUNC 1982 || h->needs_plt 1983 || (h->type == STT_NOTYPE 1984 && (h->root.type == bfd_link_hash_defined 1985 || h->root.type == bfd_link_hash_defweak) 1986 && (h->root.u.def.section->flags & SEC_CODE) != 0)) 1987 { 1988 if (h->plt.refcount <= 0 1989 || (h->type != STT_GNU_IFUNC 1990 && (SYMBOL_CALLS_LOCAL (info, h) 1991 || (h->root.type == bfd_link_hash_undefweak 1992 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)))) 1993 { 1994 /* This case can occur if we saw a WPLT30 reloc in an input 1995 file, but the symbol was never referred to by a dynamic 1996 object, or if all references were garbage collected. In 1997 such a case, we don't actually need to build a procedure 1998 linkage table, and we can just do a WDISP30 reloc instead. */ 1999 h->plt.offset = (bfd_vma) -1; 2000 h->needs_plt = 0; 2001 } 2002 2003 return TRUE; 2004 } 2005 else 2006 h->plt.offset = (bfd_vma) -1; 2007 2008 /* If this is a weak symbol, and there is a real definition, the 2009 processor independent code will have arranged for us to see the 2010 real definition first, and we can just use the same value. */ 2011 if (h->is_weakalias) 2012 { 2013 struct elf_link_hash_entry *def = weakdef (h); 2014 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 2015 h->root.u.def.section = def->root.u.def.section; 2016 h->root.u.def.value = def->root.u.def.value; 2017 return TRUE; 2018 } 2019 2020 /* This is a reference to a symbol defined by a dynamic object which 2021 is not a function. */ 2022 2023 /* If we are creating a shared library, we must presume that the 2024 only references to the symbol are via the global offset table. 2025 For such cases we need not do anything here; the relocations will 2026 be handled correctly by relocate_section. */ 2027 if (bfd_link_pic (info)) 2028 return TRUE; 2029 2030 /* If there are no references to this symbol that do not use the 2031 GOT, we don't need to generate a copy reloc. */ 2032 if (!h->non_got_ref) 2033 return TRUE; 2034 2035 /* If -z nocopyreloc was given, we won't generate them either. */ 2036 if (info->nocopyreloc) 2037 { 2038 h->non_got_ref = 0; 2039 return TRUE; 2040 } 2041 2042 /* If we don't find any dynamic relocs in read-only sections, then 2043 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 2044 if (!readonly_dynrelocs (h)) 2045 { 2046 h->non_got_ref = 0; 2047 return TRUE; 2048 } 2049 2050 /* We must allocate the symbol in our .dynbss section, which will 2051 become part of the .bss section of the executable. There will be 2052 an entry for this symbol in the .dynsym section. The dynamic 2053 object will contain position independent code, so all references 2054 from the dynamic object to this symbol will go through the global 2055 offset table. The dynamic linker will use the .dynsym entry to 2056 determine the address it must put in the global offset table, so 2057 both the dynamic object and the regular object will refer to the 2058 same memory location for the variable. */ 2059 2060 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker 2061 to copy the initial value out of the dynamic object and into the 2062 runtime process image. We need to remember the offset into the 2063 .rel.bss section we are going to use. */ 2064 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 2065 { 2066 s = htab->elf.sdynrelro; 2067 srel = htab->elf.sreldynrelro; 2068 } 2069 else 2070 { 2071 s = htab->elf.sdynbss; 2072 srel = htab->elf.srelbss; 2073 } 2074 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 2075 { 2076 srel->size += SPARC_ELF_RELA_BYTES (htab); 2077 h->needs_copy = 1; 2078 } 2079 2080 return _bfd_elf_adjust_dynamic_copy (info, h, s); 2081 } 2082 2083 /* Allocate space in .plt, .got and associated reloc sections for 2084 dynamic relocs. */ 2085 2086 static bfd_boolean 2087 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) 2088 { 2089 struct bfd_link_info *info; 2090 struct _bfd_sparc_elf_link_hash_table *htab; 2091 struct _bfd_sparc_elf_link_hash_entry *eh; 2092 struct elf_dyn_relocs *p; 2093 bfd_boolean resolved_to_zero; 2094 2095 if (h->root.type == bfd_link_hash_indirect) 2096 return TRUE; 2097 2098 info = (struct bfd_link_info *) inf; 2099 htab = _bfd_sparc_elf_hash_table (info); 2100 BFD_ASSERT (htab != NULL); 2101 2102 eh = (struct _bfd_sparc_elf_link_hash_entry *) h; 2103 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh); 2104 2105 if ((htab->elf.dynamic_sections_created 2106 && h->plt.refcount > 0) 2107 || (h->type == STT_GNU_IFUNC 2108 && h->def_regular 2109 && h->ref_regular)) 2110 { 2111 /* Undefined weak syms won't yet be marked as dynamic. */ 2112 if (h->root.type == bfd_link_hash_undefweak 2113 && !resolved_to_zero 2114 && h->dynindx == -1 2115 && !h->forced_local) 2116 { 2117 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2118 return FALSE; 2119 } 2120 2121 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h) 2122 || (h->type == STT_GNU_IFUNC 2123 && h->def_regular)) 2124 { 2125 asection *s = htab->elf.splt; 2126 2127 if (s == NULL) 2128 s = htab->elf.iplt; 2129 2130 /* Allocate room for the header. */ 2131 if (s->size == 0) 2132 { 2133 s->size = htab->plt_header_size; 2134 2135 /* Allocate space for the .rela.plt.unloaded relocations. */ 2136 if (htab->is_vxworks && !bfd_link_pic (info)) 2137 htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2; 2138 } 2139 2140 /* The procedure linkage table size is bounded by the magnitude 2141 of the offset we can describe in the entry. */ 2142 if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ? 2143 (((bfd_vma)1 << 31) << 1) : 0x400000)) 2144 { 2145 bfd_set_error (bfd_error_bad_value); 2146 return FALSE; 2147 } 2148 2149 if (SPARC_ELF_WORD_BYTES(htab) == 8 2150 && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE) 2151 { 2152 bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE; 2153 2154 2155 off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE; 2156 2157 h->plt.offset = (s->size - (off * 8)); 2158 } 2159 else 2160 h->plt.offset = s->size; 2161 2162 /* If this symbol is not defined in a regular file, and we are 2163 not generating a shared library, then set the symbol to this 2164 location in the .plt. This is required to make function 2165 pointers compare as equal between the normal executable and 2166 the shared library. */ 2167 if (! bfd_link_pic (info) 2168 && !h->def_regular) 2169 { 2170 h->root.u.def.section = s; 2171 h->root.u.def.value = h->plt.offset; 2172 } 2173 2174 /* Make room for this entry. */ 2175 s->size += htab->plt_entry_size; 2176 2177 /* There should be no PLT relocations against resolved undefined 2178 weak symbols in the executable. */ 2179 if (!resolved_to_zero) 2180 { 2181 /* We also need to make an entry in the .rela.plt section. */ 2182 if (s == htab->elf.splt) 2183 htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab); 2184 else 2185 htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab); 2186 } 2187 2188 if (htab->is_vxworks) 2189 { 2190 /* Allocate space for the .got.plt entry. */ 2191 htab->elf.sgotplt->size += 4; 2192 2193 /* ...and for the .rela.plt.unloaded relocations. */ 2194 if (!bfd_link_pic (info)) 2195 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3; 2196 } 2197 } 2198 else 2199 { 2200 h->plt.offset = (bfd_vma) -1; 2201 h->needs_plt = 0; 2202 } 2203 } 2204 else 2205 { 2206 h->plt.offset = (bfd_vma) -1; 2207 h->needs_plt = 0; 2208 } 2209 2210 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary, 2211 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */ 2212 if (h->got.refcount > 0 2213 && bfd_link_executable (info) 2214 && h->dynindx == -1 2215 && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE) 2216 h->got.offset = (bfd_vma) -1; 2217 else if (h->got.refcount > 0) 2218 { 2219 asection *s; 2220 bfd_boolean dyn; 2221 int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type; 2222 2223 /* Undefined weak syms won't yet be marked as dynamic. */ 2224 if (h->root.type == bfd_link_hash_undefweak 2225 && !resolved_to_zero 2226 && h->dynindx == -1 2227 && !h->forced_local) 2228 { 2229 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2230 return FALSE; 2231 } 2232 2233 s = htab->elf.sgot; 2234 h->got.offset = s->size; 2235 s->size += SPARC_ELF_WORD_BYTES (htab); 2236 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */ 2237 if (tls_type == GOT_TLS_GD) 2238 s->size += SPARC_ELF_WORD_BYTES (htab); 2239 dyn = htab->elf.dynamic_sections_created; 2240 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation, 2241 R_SPARC_TLS_GD_{HI22,LO10} needs one if local and two if global. */ 2242 if ((tls_type == GOT_TLS_GD && h->dynindx == -1) 2243 || tls_type == GOT_TLS_IE 2244 || h->type == STT_GNU_IFUNC) 2245 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab); 2246 else if (tls_type == GOT_TLS_GD) 2247 htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab); 2248 else if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h) 2249 /* Even if the symbol isn't dynamic, we may generate a 2250 reloc for the dynamic linker in PIC mode. */ 2251 || (h->dynindx == -1 2252 && !h->forced_local 2253 && h->root.type != bfd_link_hash_undefweak 2254 && bfd_link_pic (info))) 2255 /* No dynamic relocations are needed against resolved 2256 undefined weak symbols in an executable. */ 2257 && !(h->root.type == bfd_link_hash_undefweak 2258 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2259 || resolved_to_zero))) 2260 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab); 2261 } 2262 else 2263 h->got.offset = (bfd_vma) -1; 2264 2265 if (eh->dyn_relocs == NULL) 2266 return TRUE; 2267 2268 /* In the shared -Bsymbolic case, discard space allocated for 2269 dynamic pc-relative relocs against symbols which turn out to be 2270 defined in regular objects. For the normal shared case, discard 2271 space for pc-relative relocs that have become local due to symbol 2272 visibility changes. */ 2273 2274 if (bfd_link_pic (info)) 2275 { 2276 if (SYMBOL_CALLS_LOCAL (info, h)) 2277 { 2278 struct elf_dyn_relocs **pp; 2279 2280 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 2281 { 2282 p->count -= p->pc_count; 2283 p->pc_count = 0; 2284 if (p->count == 0) 2285 *pp = p->next; 2286 else 2287 pp = &p->next; 2288 } 2289 } 2290 2291 if (htab->is_vxworks) 2292 { 2293 struct elf_dyn_relocs **pp; 2294 2295 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 2296 { 2297 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0) 2298 *pp = p->next; 2299 else 2300 pp = &p->next; 2301 } 2302 } 2303 2304 /* Also discard relocs on undefined weak syms with non-default 2305 visibility or in PIE. */ 2306 if (eh->dyn_relocs != NULL 2307 && h->root.type == bfd_link_hash_undefweak) 2308 { 2309 /* An undefined weak symbol is never 2310 bound locally in a shared library. */ 2311 2312 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2313 || resolved_to_zero) 2314 { 2315 if (h->non_got_ref) 2316 { 2317 /* Keep dynamic non-GOT/non-PLT relocation so that we 2318 can branch to 0 without PLT. */ 2319 struct elf_dyn_relocs **pp; 2320 2321 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;) 2322 if (p->pc_count == 0) 2323 *pp = p->next; 2324 else 2325 { 2326 /* Remove other relocations. */ 2327 p->count = p->pc_count; 2328 pp = &p->next; 2329 } 2330 2331 if (eh->dyn_relocs != NULL) 2332 { 2333 /* Make sure undefined weak symbols are output 2334 as dynamic symbols in PIEs for dynamic non-GOT 2335 non-PLT reloations. */ 2336 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2337 return FALSE; 2338 } 2339 } 2340 else 2341 eh->dyn_relocs = NULL; 2342 } 2343 2344 /* Make sure undefined weak symbols are output as a dynamic 2345 symbol in PIEs. */ 2346 else if (h->dynindx == -1 2347 && !h->forced_local) 2348 { 2349 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2350 return FALSE; 2351 } 2352 } 2353 } 2354 else 2355 { 2356 /* For the non-shared case, discard space for relocs against 2357 symbols which turn out to need copy relocs or are not 2358 dynamic. */ 2359 2360 if ((!h->non_got_ref 2361 || (h->root.type == bfd_link_hash_undefweak 2362 && !resolved_to_zero)) 2363 && ((h->def_dynamic 2364 && !h->def_regular) 2365 || (htab->elf.dynamic_sections_created 2366 && (h->root.type == bfd_link_hash_undefweak 2367 || h->root.type == bfd_link_hash_undefined)))) 2368 { 2369 /* Undefined weak syms won't yet be marked as dynamic. */ 2370 if (h->root.type == bfd_link_hash_undefweak 2371 && !resolved_to_zero 2372 && h->dynindx == -1 2373 && !h->forced_local) 2374 { 2375 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2376 return FALSE; 2377 } 2378 2379 /* If that succeeded, we know we'll be keeping all the 2380 relocs. */ 2381 if (h->dynindx != -1) 2382 goto keep; 2383 } 2384 2385 eh->dyn_relocs = NULL; 2386 2387 keep: ; 2388 } 2389 2390 /* Finally, allocate space. */ 2391 for (p = eh->dyn_relocs; p != NULL; p = p->next) 2392 { 2393 asection *sreloc = elf_section_data (p->sec)->sreloc; 2394 sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab); 2395 } 2396 2397 return TRUE; 2398 } 2399 2400 /* Allocate space in .plt, .got and associated reloc sections for 2401 local dynamic relocs. */ 2402 2403 static bfd_boolean 2404 allocate_local_dynrelocs (void **slot, void *inf) 2405 { 2406 struct elf_link_hash_entry *h 2407 = (struct elf_link_hash_entry *) *slot; 2408 2409 if (h->type != STT_GNU_IFUNC 2410 || !h->def_regular 2411 || !h->ref_regular 2412 || !h->forced_local 2413 || h->root.type != bfd_link_hash_defined) 2414 abort (); 2415 2416 return allocate_dynrelocs (h, inf); 2417 } 2418 2419 /* Set DF_TEXTREL if we find any dynamic relocs that apply to 2420 read-only sections. */ 2421 2422 static bfd_boolean 2423 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p) 2424 { 2425 asection *sec; 2426 2427 if (h->root.type == bfd_link_hash_indirect) 2428 return TRUE; 2429 2430 sec = readonly_dynrelocs (h); 2431 if (sec != NULL) 2432 { 2433 struct bfd_link_info *info = (struct bfd_link_info *) info_p; 2434 2435 info->flags |= DF_TEXTREL; 2436 info->callbacks->minfo 2437 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"), 2438 sec->owner, h->root.root.string, sec); 2439 2440 /* Not an error, just cut short the traversal. */ 2441 return FALSE; 2442 } 2443 return TRUE; 2444 } 2445 2446 /* Return true if the dynamic symbol for a given section should be 2447 omitted when creating a shared library. */ 2448 2449 bfd_boolean 2450 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd, 2451 struct bfd_link_info *info, 2452 asection *p) 2453 { 2454 /* We keep the .got section symbol so that explicit relocations 2455 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode 2456 can be turned into relocations against the .got symbol. */ 2457 if (strcmp (p->name, ".got") == 0) 2458 return FALSE; 2459 2460 return _bfd_elf_omit_section_dynsym_default (output_bfd, info, p); 2461 } 2462 2463 /* Set the sizes of the dynamic sections. */ 2464 2465 bfd_boolean 2466 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd, 2467 struct bfd_link_info *info) 2468 { 2469 struct _bfd_sparc_elf_link_hash_table *htab; 2470 bfd *dynobj; 2471 asection *s; 2472 bfd *ibfd; 2473 2474 htab = _bfd_sparc_elf_hash_table (info); 2475 BFD_ASSERT (htab != NULL); 2476 dynobj = htab->elf.dynobj; 2477 BFD_ASSERT (dynobj != NULL); 2478 2479 if (elf_hash_table (info)->dynamic_sections_created) 2480 { 2481 /* Set the contents of the .interp section to the interpreter. */ 2482 if (bfd_link_executable (info) && !info->nointerp) 2483 { 2484 s = bfd_get_linker_section (dynobj, ".interp"); 2485 BFD_ASSERT (s != NULL); 2486 s->size = htab->dynamic_interpreter_size; 2487 s->contents = (unsigned char *) htab->dynamic_interpreter; 2488 htab->interp = s; 2489 } 2490 } 2491 2492 /* Set up .got offsets for local syms, and space for local dynamic 2493 relocs. */ 2494 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 2495 { 2496 bfd_signed_vma *local_got; 2497 bfd_signed_vma *end_local_got; 2498 char *local_tls_type; 2499 bfd_size_type locsymcount; 2500 Elf_Internal_Shdr *symtab_hdr; 2501 asection *srel; 2502 2503 if (! is_sparc_elf (ibfd)) 2504 continue; 2505 2506 for (s = ibfd->sections; s != NULL; s = s->next) 2507 { 2508 struct elf_dyn_relocs *p; 2509 2510 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next) 2511 { 2512 if (!bfd_is_abs_section (p->sec) 2513 && bfd_is_abs_section (p->sec->output_section)) 2514 { 2515 /* Input section has been discarded, either because 2516 it is a copy of a linkonce section or due to 2517 linker script /DISCARD/, so we'll be discarding 2518 the relocs too. */ 2519 } 2520 else if (htab->is_vxworks 2521 && strcmp (p->sec->output_section->name, 2522 ".tls_vars") == 0) 2523 { 2524 /* Relocations in vxworks .tls_vars sections are 2525 handled specially by the loader. */ 2526 } 2527 else if (p->count != 0) 2528 { 2529 srel = elf_section_data (p->sec)->sreloc; 2530 if (!htab->elf.dynamic_sections_created) 2531 srel = htab->elf.irelplt; 2532 srel->size += p->count * SPARC_ELF_RELA_BYTES (htab); 2533 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 2534 { 2535 info->flags |= DF_TEXTREL; 2536 info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"), 2537 p->sec->owner, p->sec); 2538 } 2539 } 2540 } 2541 } 2542 2543 local_got = elf_local_got_refcounts (ibfd); 2544 if (!local_got) 2545 continue; 2546 2547 symtab_hdr = &elf_symtab_hdr (ibfd); 2548 locsymcount = symtab_hdr->sh_info; 2549 end_local_got = local_got + locsymcount; 2550 local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd); 2551 s = htab->elf.sgot; 2552 srel = htab->elf.srelgot; 2553 for (; local_got < end_local_got; ++local_got, ++local_tls_type) 2554 { 2555 if (*local_got > 0) 2556 { 2557 *local_got = s->size; 2558 s->size += SPARC_ELF_WORD_BYTES (htab); 2559 if (*local_tls_type == GOT_TLS_GD) 2560 s->size += SPARC_ELF_WORD_BYTES (htab); 2561 if (bfd_link_pic (info) 2562 || *local_tls_type == GOT_TLS_GD 2563 || *local_tls_type == GOT_TLS_IE) 2564 srel->size += SPARC_ELF_RELA_BYTES (htab); 2565 } 2566 else 2567 *local_got = (bfd_vma) -1; 2568 } 2569 } 2570 2571 if (htab->tls_ldm_got.refcount > 0) 2572 { 2573 /* Allocate 2 got entries and 1 dynamic reloc for 2574 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */ 2575 htab->tls_ldm_got.offset = htab->elf.sgot->size; 2576 htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab)); 2577 htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab); 2578 } 2579 else 2580 htab->tls_ldm_got.offset = -1; 2581 2582 /* Allocate global sym .plt and .got entries, and space for global 2583 sym dynamic relocs. */ 2584 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info); 2585 2586 /* Allocate .plt and .got entries, and space for local symbols. */ 2587 htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info); 2588 2589 if (! ABI_64_P (output_bfd) 2590 && !htab->is_vxworks 2591 && elf_hash_table (info)->dynamic_sections_created) 2592 { 2593 /* Make space for the trailing nop in .plt. */ 2594 if (htab->elf.splt->size > 0) 2595 htab->elf.splt->size += 1 * SPARC_INSN_BYTES; 2596 2597 /* If the .got section is more than 0x1000 bytes, we add 2598 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13 2599 bit relocations have a greater chance of working. 2600 2601 FIXME: Make this optimization work for 64-bit too. */ 2602 if (htab->elf.sgot->size >= 0x1000 2603 && elf_hash_table (info)->hgot->root.u.def.value == 0) 2604 elf_hash_table (info)->hgot->root.u.def.value = 0x1000; 2605 } 2606 2607 /* The check_relocs and adjust_dynamic_symbol entry points have 2608 determined the sizes of the various dynamic sections. Allocate 2609 memory for them. */ 2610 for (s = dynobj->sections; s != NULL; s = s->next) 2611 { 2612 if ((s->flags & SEC_LINKER_CREATED) == 0) 2613 continue; 2614 2615 if (s == htab->elf.splt 2616 || s == htab->elf.sgot 2617 || s == htab->elf.sdynbss 2618 || s == htab->elf.sdynrelro 2619 || s == htab->elf.iplt 2620 || s == htab->elf.sgotplt) 2621 { 2622 /* Strip this section if we don't need it; see the 2623 comment below. */ 2624 } 2625 else if (CONST_STRNEQ (s->name, ".rela")) 2626 { 2627 if (s->size != 0) 2628 { 2629 /* We use the reloc_count field as a counter if we need 2630 to copy relocs into the output file. */ 2631 s->reloc_count = 0; 2632 } 2633 } 2634 else 2635 { 2636 /* It's not one of our sections. */ 2637 continue; 2638 } 2639 2640 if (s->size == 0) 2641 { 2642 /* If we don't need this section, strip it from the 2643 output file. This is mostly to handle .rela.bss and 2644 .rela.plt. We must create both sections in 2645 create_dynamic_sections, because they must be created 2646 before the linker maps input sections to output 2647 sections. The linker does that before 2648 adjust_dynamic_symbol is called, and it is that 2649 function which decides whether anything needs to go 2650 into these sections. */ 2651 s->flags |= SEC_EXCLUDE; 2652 continue; 2653 } 2654 2655 if ((s->flags & SEC_HAS_CONTENTS) == 0) 2656 continue; 2657 2658 /* Allocate memory for the section contents. Zero the memory 2659 for the benefit of .rela.plt, which has 4 unused entries 2660 at the beginning, and we don't want garbage. */ 2661 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 2662 if (s->contents == NULL) 2663 return FALSE; 2664 } 2665 2666 if (elf_hash_table (info)->dynamic_sections_created) 2667 { 2668 /* Add some entries to the .dynamic section. We fill in the 2669 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we 2670 must add the entries now so that we get the correct size for 2671 the .dynamic section. The DT_DEBUG entry is filled in by the 2672 dynamic linker and used by the debugger. */ 2673 #define add_dynamic_entry(TAG, VAL) \ 2674 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 2675 2676 if (bfd_link_executable (info)) 2677 { 2678 if (!add_dynamic_entry (DT_DEBUG, 0)) 2679 return FALSE; 2680 } 2681 2682 if (htab->elf.srelplt->size != 0) 2683 { 2684 if (!add_dynamic_entry (DT_PLTGOT, 0) 2685 || !add_dynamic_entry (DT_PLTRELSZ, 0) 2686 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 2687 || !add_dynamic_entry (DT_JMPREL, 0)) 2688 return FALSE; 2689 } 2690 2691 if (!add_dynamic_entry (DT_RELA, 0) 2692 || !add_dynamic_entry (DT_RELASZ, 0) 2693 || !add_dynamic_entry (DT_RELAENT, 2694 SPARC_ELF_RELA_BYTES (htab))) 2695 return FALSE; 2696 2697 /* If any dynamic relocs apply to a read-only section, 2698 then we need a DT_TEXTREL entry. */ 2699 if ((info->flags & DF_TEXTREL) == 0) 2700 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info); 2701 2702 if (info->flags & DF_TEXTREL) 2703 { 2704 if (!add_dynamic_entry (DT_TEXTREL, 0)) 2705 return FALSE; 2706 } 2707 2708 if (ABI_64_P (output_bfd)) 2709 { 2710 int reg; 2711 struct _bfd_sparc_elf_app_reg * app_regs; 2712 struct elf_strtab_hash *dynstr; 2713 struct elf_link_hash_table *eht = elf_hash_table (info); 2714 2715 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER 2716 entries if needed. */ 2717 app_regs = _bfd_sparc_elf_hash_table (info)->app_regs; 2718 dynstr = eht->dynstr; 2719 2720 for (reg = 0; reg < 4; reg++) 2721 if (app_regs [reg].name != NULL) 2722 { 2723 struct elf_link_local_dynamic_entry *entry, *e; 2724 2725 if (!add_dynamic_entry (DT_SPARC_REGISTER, 0)) 2726 return FALSE; 2727 2728 entry = (struct elf_link_local_dynamic_entry *) 2729 bfd_hash_allocate (&info->hash->table, sizeof (*entry)); 2730 if (entry == NULL) 2731 return FALSE; 2732 2733 /* We cheat here a little bit: the symbol will not be local, so we 2734 put it at the end of the dynlocal linked list. We will fix it 2735 later on, as we have to fix other fields anyway. */ 2736 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4; 2737 entry->isym.st_size = 0; 2738 if (*app_regs [reg].name != '\0') 2739 entry->isym.st_name 2740 = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE); 2741 else 2742 entry->isym.st_name = 0; 2743 entry->isym.st_other = 0; 2744 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind, 2745 STT_REGISTER); 2746 entry->isym.st_shndx = app_regs [reg].shndx; 2747 entry->isym.st_target_internal = 0; 2748 entry->next = NULL; 2749 entry->input_bfd = output_bfd; 2750 entry->input_indx = -1; 2751 2752 if (eht->dynlocal == NULL) 2753 eht->dynlocal = entry; 2754 else 2755 { 2756 for (e = eht->dynlocal; e->next; e = e->next) 2757 ; 2758 e->next = entry; 2759 } 2760 eht->dynsymcount++; 2761 } 2762 } 2763 if (htab->is_vxworks 2764 && !elf_vxworks_add_dynamic_entries (output_bfd, info)) 2765 return FALSE; 2766 } 2767 #undef add_dynamic_entry 2768 2769 return TRUE; 2770 } 2771 2772 bfd_boolean 2773 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec) 2774 { 2775 if (!sec->used_by_bfd) 2776 { 2777 struct _bfd_sparc_elf_section_data *sdata; 2778 bfd_size_type amt = sizeof (*sdata); 2779 2780 sdata = bfd_zalloc (abfd, amt); 2781 if (sdata == NULL) 2782 return FALSE; 2783 sec->used_by_bfd = sdata; 2784 } 2785 2786 return _bfd_elf_new_section_hook (abfd, sec); 2787 } 2788 2789 bfd_boolean 2790 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED, 2791 struct bfd_section *section, 2792 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 2793 bfd_boolean *again) 2794 { 2795 if (bfd_link_relocatable (link_info)) 2796 (*link_info->callbacks->einfo) 2797 (_("%P%F: --relax and -r may not be used together\n")); 2798 2799 *again = FALSE; 2800 sec_do_relax (section) = 1; 2801 return TRUE; 2802 } 2803 2804 /* Return the base VMA address which should be subtracted from real addresses 2805 when resolving @dtpoff relocation. 2806 This is PT_TLS segment p_vaddr. */ 2807 2808 static bfd_vma 2809 dtpoff_base (struct bfd_link_info *info) 2810 { 2811 /* If tls_sec is NULL, we should have signalled an error already. */ 2812 if (elf_hash_table (info)->tls_sec == NULL) 2813 return 0; 2814 return elf_hash_table (info)->tls_sec->vma; 2815 } 2816 2817 /* Return the relocation value for @tpoff relocation 2818 if STT_TLS virtual address is ADDRESS. */ 2819 2820 static bfd_vma 2821 tpoff (struct bfd_link_info *info, bfd_vma address) 2822 { 2823 struct elf_link_hash_table *htab = elf_hash_table (info); 2824 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd); 2825 bfd_vma static_tls_size; 2826 2827 /* If tls_sec is NULL, we should have signalled an error already. */ 2828 if (htab->tls_sec == NULL) 2829 return 0; 2830 2831 /* Consider special static TLS alignment requirements. */ 2832 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment); 2833 return address - static_tls_size - htab->tls_sec->vma; 2834 } 2835 2836 /* Return the relocation value for a %gdop relocation. */ 2837 2838 static bfd_vma 2839 gdopoff (struct bfd_link_info *info, bfd_vma address) 2840 { 2841 struct elf_link_hash_table *htab = elf_hash_table (info); 2842 bfd_vma got_base; 2843 2844 got_base = (htab->hgot->root.u.def.value 2845 + htab->hgot->root.u.def.section->output_offset 2846 + htab->hgot->root.u.def.section->output_section->vma); 2847 2848 return address - got_base; 2849 } 2850 2851 /* Return whether H is local and its ADDRESS is within 4G of 2852 _GLOBAL_OFFSET_TABLE_ and thus the offset may be calculated by a 2853 sethi, xor sequence. */ 2854 2855 static bfd_boolean 2856 gdop_relative_offset_ok (struct bfd_link_info *info, 2857 struct elf_link_hash_entry *h, 2858 bfd_vma address ATTRIBUTE_UNUSED) 2859 { 2860 if (!SYMBOL_REFERENCES_LOCAL (info, h)) 2861 return FALSE; 2862 /* If H is undefined, ADDRESS will be zero. We can't allow a 2863 relative offset to "zero" when producing PIEs or shared libs. 2864 Note that to get here with an undefined symbol it must also be 2865 hidden or internal visibility. */ 2866 if (bfd_link_pic (info) 2867 && h != NULL 2868 && (h->root.type == bfd_link_hash_undefweak 2869 || h->root.type == bfd_link_hash_undefined)) 2870 return FALSE; 2871 #ifdef BFD64 2872 return gdopoff (info, address) + ((bfd_vma) 1 << 32) < (bfd_vma) 2 << 32; 2873 #else 2874 return TRUE; 2875 #endif 2876 } 2877 2878 /* Relocate a SPARC ELF section. */ 2879 2880 bfd_boolean 2881 _bfd_sparc_elf_relocate_section (bfd *output_bfd, 2882 struct bfd_link_info *info, 2883 bfd *input_bfd, 2884 asection *input_section, 2885 bfd_byte *contents, 2886 Elf_Internal_Rela *relocs, 2887 Elf_Internal_Sym *local_syms, 2888 asection **local_sections) 2889 { 2890 struct _bfd_sparc_elf_link_hash_table *htab; 2891 Elf_Internal_Shdr *symtab_hdr; 2892 struct elf_link_hash_entry **sym_hashes; 2893 bfd_vma *local_got_offsets; 2894 bfd_vma got_base; 2895 asection *sreloc; 2896 Elf_Internal_Rela *rel; 2897 Elf_Internal_Rela *relend; 2898 int num_relocs; 2899 bfd_boolean is_vxworks_tls; 2900 2901 htab = _bfd_sparc_elf_hash_table (info); 2902 BFD_ASSERT (htab != NULL); 2903 symtab_hdr = &elf_symtab_hdr (input_bfd); 2904 sym_hashes = elf_sym_hashes (input_bfd); 2905 local_got_offsets = elf_local_got_offsets (input_bfd); 2906 2907 if (elf_hash_table (info)->hgot == NULL) 2908 got_base = 0; 2909 else 2910 got_base = elf_hash_table (info)->hgot->root.u.def.value; 2911 2912 sreloc = elf_section_data (input_section)->sreloc; 2913 /* We have to handle relocations in vxworks .tls_vars sections 2914 specially, because the dynamic loader is 'weird'. */ 2915 is_vxworks_tls = (htab->is_vxworks && bfd_link_pic (info) 2916 && !strcmp (input_section->output_section->name, 2917 ".tls_vars")); 2918 2919 rel = relocs; 2920 if (ABI_64_P (output_bfd)) 2921 num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section)); 2922 else 2923 num_relocs = input_section->reloc_count; 2924 relend = relocs + num_relocs; 2925 for (; rel < relend; rel++) 2926 { 2927 int r_type, tls_type; 2928 reloc_howto_type *howto; 2929 unsigned long r_symndx; 2930 struct elf_link_hash_entry *h; 2931 struct _bfd_sparc_elf_link_hash_entry *eh; 2932 Elf_Internal_Sym *sym; 2933 asection *sec; 2934 bfd_vma relocation, off; 2935 bfd_reloc_status_type r; 2936 bfd_boolean is_plt = FALSE; 2937 bfd_boolean unresolved_reloc; 2938 bfd_boolean resolved_to_zero; 2939 bfd_boolean relative_reloc; 2940 2941 r_type = SPARC_ELF_R_TYPE (rel->r_info); 2942 if (r_type == R_SPARC_GNU_VTINHERIT 2943 || r_type == R_SPARC_GNU_VTENTRY) 2944 continue; 2945 2946 if (r_type < 0 || r_type >= (int) R_SPARC_max_std) 2947 { 2948 bfd_set_error (bfd_error_bad_value); 2949 return FALSE; 2950 } 2951 2952 howto = _bfd_sparc_elf_howto_table + r_type; 2953 r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info); 2954 h = NULL; 2955 sym = NULL; 2956 sec = NULL; 2957 unresolved_reloc = FALSE; 2958 if (r_symndx < symtab_hdr->sh_info) 2959 { 2960 sym = local_syms + r_symndx; 2961 sec = local_sections[r_symndx]; 2962 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 2963 2964 if (!bfd_link_relocatable (info) 2965 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) 2966 { 2967 /* Relocate against local STT_GNU_IFUNC symbol. */ 2968 h = elf_sparc_get_local_sym_hash (htab, input_bfd, 2969 rel, FALSE); 2970 if (h == NULL) 2971 abort (); 2972 2973 /* Set STT_GNU_IFUNC symbol value. */ 2974 h->root.u.def.value = sym->st_value; 2975 h->root.u.def.section = sec; 2976 } 2977 } 2978 else 2979 { 2980 bfd_boolean warned, ignored; 2981 2982 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 2983 r_symndx, symtab_hdr, sym_hashes, 2984 h, sec, relocation, 2985 unresolved_reloc, warned, ignored); 2986 if (warned) 2987 { 2988 /* To avoid generating warning messages about truncated 2989 relocations, set the relocation's address to be the same as 2990 the start of this section. */ 2991 if (input_section->output_section != NULL) 2992 relocation = input_section->output_section->vma; 2993 else 2994 relocation = 0; 2995 } 2996 } 2997 2998 if (sec != NULL && discarded_section (sec)) 2999 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 3000 rel, 1, relend, howto, 0, contents); 3001 3002 if (bfd_link_relocatable (info)) 3003 continue; 3004 3005 if (h != NULL 3006 && h->type == STT_GNU_IFUNC 3007 && h->def_regular) 3008 { 3009 asection *plt_sec; 3010 const char *name; 3011 3012 if ((input_section->flags & SEC_ALLOC) == 0 3013 || h->plt.offset == (bfd_vma) -1) 3014 { 3015 /* If this is a SHT_NOTE section without SHF_ALLOC, treat 3016 STT_GNU_IFUNC symbol as STT_FUNC. */ 3017 if (elf_section_type (input_section) == SHT_NOTE) 3018 goto skip_ifunc; 3019 abort (); 3020 } 3021 3022 plt_sec = htab->elf.splt; 3023 if (! plt_sec) 3024 plt_sec =htab->elf.iplt; 3025 3026 switch (r_type) 3027 { 3028 case R_SPARC_GOTDATA_OP: 3029 continue; 3030 3031 case R_SPARC_GOTDATA_OP_HIX22: 3032 case R_SPARC_GOTDATA_OP_LOX10: 3033 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22 3034 ? R_SPARC_GOT22 3035 : R_SPARC_GOT10); 3036 howto = _bfd_sparc_elf_howto_table + r_type; 3037 /* Fall through. */ 3038 3039 case R_SPARC_GOT10: 3040 case R_SPARC_GOT13: 3041 case R_SPARC_GOT22: 3042 if (htab->elf.sgot == NULL) 3043 abort (); 3044 off = h->got.offset; 3045 if (off == (bfd_vma) -1) 3046 abort(); 3047 relocation = htab->elf.sgot->output_offset + off - got_base; 3048 goto do_relocation; 3049 3050 case R_SPARC_WPLT30: 3051 case R_SPARC_WDISP30: 3052 relocation = (plt_sec->output_section->vma 3053 + plt_sec->output_offset + h->plt.offset); 3054 goto do_relocation; 3055 3056 case R_SPARC_32: 3057 case R_SPARC_64: 3058 if (bfd_link_pic (info) && h->non_got_ref) 3059 { 3060 Elf_Internal_Rela outrel; 3061 bfd_vma offset; 3062 3063 offset = _bfd_elf_section_offset (output_bfd, info, 3064 input_section, 3065 rel->r_offset); 3066 if (offset == (bfd_vma) -1 3067 || offset == (bfd_vma) -2) 3068 abort(); 3069 3070 outrel.r_offset = (input_section->output_section->vma 3071 + input_section->output_offset 3072 + offset); 3073 3074 if (h->dynindx == -1 3075 || h->forced_local 3076 || bfd_link_executable (info)) 3077 { 3078 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 3079 0, R_SPARC_IRELATIVE); 3080 outrel.r_addend = relocation + rel->r_addend; 3081 } 3082 else 3083 { 3084 if (h->dynindx == -1) 3085 abort(); 3086 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type); 3087 outrel.r_addend = rel->r_addend; 3088 } 3089 3090 sparc_elf_append_rela (output_bfd, sreloc, &outrel); 3091 continue; 3092 } 3093 3094 relocation = (plt_sec->output_section->vma 3095 + plt_sec->output_offset + h->plt.offset); 3096 goto do_relocation; 3097 3098 case R_SPARC_HI22: 3099 case R_SPARC_LO10: 3100 /* We should only see such relocs in static links. */ 3101 if (bfd_link_pic (info)) 3102 abort(); 3103 relocation = (plt_sec->output_section->vma 3104 + plt_sec->output_offset + h->plt.offset); 3105 goto do_relocation; 3106 3107 default: 3108 if (h->root.root.string) 3109 name = h->root.root.string; 3110 else 3111 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 3112 NULL); 3113 _bfd_error_handler 3114 /* xgettext:c-format */ 3115 (_("%pB: relocation %s against STT_GNU_IFUNC " 3116 "symbol `%s' isn't handled by %s"), input_bfd, 3117 _bfd_sparc_elf_howto_table[r_type].name, 3118 name, __FUNCTION__); 3119 bfd_set_error (bfd_error_bad_value); 3120 return FALSE; 3121 } 3122 } 3123 3124 skip_ifunc: 3125 eh = (struct _bfd_sparc_elf_link_hash_entry *) h; 3126 resolved_to_zero = eh && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh); 3127 3128 switch (r_type) 3129 { 3130 case R_SPARC_GOTDATA_OP_HIX22: 3131 case R_SPARC_GOTDATA_OP_LOX10: 3132 if (gdop_relative_offset_ok (info, h, relocation)) 3133 { 3134 r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22 3135 ? R_SPARC_GOTDATA_HIX22 3136 : R_SPARC_GOTDATA_LOX10); 3137 howto = _bfd_sparc_elf_howto_table + r_type; 3138 } 3139 break; 3140 3141 case R_SPARC_GOTDATA_OP: 3142 if (gdop_relative_offset_ok (info, h, relocation)) 3143 { 3144 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3145 3146 /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */ 3147 relocation = 0x80000000 | (insn & 0x3e07c01f); 3148 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset); 3149 3150 /* If the symbol is global but not dynamic, an .rela.* slot has 3151 been allocated for it in the GOT so output R_SPARC_NONE here, 3152 if it isn't also subject to another, old-style GOT relocation. 3153 See also the handling of these GOT relocations just below. */ 3154 if (h != NULL 3155 && h->dynindx == -1 3156 && !h->forced_local 3157 && h->root.type != bfd_link_hash_undefweak 3158 && !eh->has_old_style_got_reloc 3159 && (h->got.offset & 1) == 0 3160 && bfd_link_pic (info)) 3161 { 3162 asection *s = htab->elf.srelgot; 3163 Elf_Internal_Rela outrel; 3164 3165 BFD_ASSERT (s != NULL); 3166 3167 memset (&outrel, 0, sizeof outrel); 3168 sparc_elf_append_rela (output_bfd, s, &outrel); 3169 h->got.offset |= 1; 3170 } 3171 } 3172 continue; 3173 } 3174 3175 switch (r_type) 3176 { 3177 case R_SPARC_GOTDATA_HIX22: 3178 case R_SPARC_GOTDATA_LOX10: 3179 relocation = gdopoff (info, relocation); 3180 break; 3181 3182 case R_SPARC_GOTDATA_OP_HIX22: 3183 case R_SPARC_GOTDATA_OP_LOX10: 3184 case R_SPARC_GOT10: 3185 case R_SPARC_GOT13: 3186 case R_SPARC_GOT22: 3187 /* Relocation is to the entry for this symbol in the global 3188 offset table. */ 3189 if (htab->elf.sgot == NULL) 3190 abort (); 3191 3192 relative_reloc = FALSE; 3193 if (h != NULL) 3194 { 3195 bfd_boolean dyn; 3196 3197 off = h->got.offset; 3198 BFD_ASSERT (off != (bfd_vma) -1); 3199 dyn = elf_hash_table (info)->dynamic_sections_created; 3200 3201 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 3202 bfd_link_pic (info), 3203 h) 3204 || (bfd_link_pic (info) 3205 && SYMBOL_REFERENCES_LOCAL (info, h))) 3206 { 3207 /* This is actually a static link, or it is a 3208 -Bsymbolic link and the symbol is defined 3209 locally, or the symbol was forced to be local 3210 because of a version file. We must initialize 3211 this entry in the global offset table. Since the 3212 offset must always be a multiple of 8 for 64-bit 3213 and 4 for 32-bit, we use the least significant bit 3214 to record whether we have initialized it already. 3215 3216 When doing a dynamic link, we create a .rela.got 3217 relocation entry to initialize the value. This 3218 is done in the finish_dynamic_symbol routine. */ 3219 if ((off & 1) != 0) 3220 off &= ~1; 3221 else 3222 { 3223 /* If this symbol isn't dynamic in PIC mode, treat it 3224 like a local symbol in PIC mode below. */ 3225 if (h->dynindx == -1 3226 && !h->forced_local 3227 && h->root.type != bfd_link_hash_undefweak 3228 && bfd_link_pic (info)) 3229 relative_reloc = TRUE; 3230 else 3231 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation, 3232 htab->elf.sgot->contents + off); 3233 h->got.offset |= 1; 3234 } 3235 } 3236 else 3237 unresolved_reloc = FALSE; 3238 } 3239 else 3240 { 3241 BFD_ASSERT (local_got_offsets != NULL 3242 && local_got_offsets[r_symndx] != (bfd_vma) -1); 3243 3244 off = local_got_offsets[r_symndx]; 3245 3246 /* The offset must always be a multiple of 8 on 64-bit and 3247 4 on 32-bit. We use the least significant bit to record 3248 whether we have already processed this entry. */ 3249 if ((off & 1) != 0) 3250 off &= ~1; 3251 else 3252 { 3253 /* For a local symbol in PIC mode, we need to generate a 3254 R_SPARC_RELATIVE reloc for the dynamic linker. */ 3255 if (bfd_link_pic (info)) 3256 relative_reloc = TRUE; 3257 else 3258 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation, 3259 htab->elf.sgot->contents + off); 3260 local_got_offsets[r_symndx] |= 1; 3261 } 3262 } 3263 3264 if (relative_reloc) 3265 { 3266 asection *s = htab->elf.srelgot; 3267 Elf_Internal_Rela outrel; 3268 3269 BFD_ASSERT (s != NULL); 3270 3271 outrel.r_offset = (htab->elf.sgot->output_section->vma 3272 + htab->elf.sgot->output_offset 3273 + off); 3274 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 3275 0, R_SPARC_RELATIVE); 3276 outrel.r_addend = relocation; 3277 sparc_elf_append_rela (output_bfd, s, &outrel); 3278 /* Versions of glibc ld.so at least up to 2.26 wrongly 3279 add the section contents to the value calculated for 3280 a RELATIVE reloc. Zero the contents to work around 3281 this bug. */ 3282 relocation = 0; 3283 SPARC_ELF_PUT_WORD (htab, output_bfd, relocation, 3284 htab->elf.sgot->contents + off); 3285 } 3286 3287 relocation = htab->elf.sgot->output_offset + off - got_base; 3288 break; 3289 3290 case R_SPARC_PLT32: 3291 case R_SPARC_PLT64: 3292 if (h == NULL || h->plt.offset == (bfd_vma) -1) 3293 { 3294 r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64; 3295 goto r_sparc_plt32; 3296 } 3297 /* Fall through. */ 3298 3299 case R_SPARC_WPLT30: 3300 case R_SPARC_HIPLT22: 3301 case R_SPARC_LOPLT10: 3302 case R_SPARC_PCPLT32: 3303 case R_SPARC_PCPLT22: 3304 case R_SPARC_PCPLT10: 3305 r_sparc_wplt30: 3306 /* Relocation is to the entry for this symbol in the 3307 procedure linkage table. */ 3308 3309 if (! ABI_64_P (output_bfd)) 3310 { 3311 /* The Solaris native assembler will generate a WPLT30 reloc 3312 for a local symbol if you assemble a call from one 3313 section to another when using -K pic. We treat it as 3314 WDISP30. */ 3315 if (h == NULL) 3316 break; 3317 } 3318 /* PR 7027: We need similar behaviour for 64-bit binaries. */ 3319 else if (r_type == R_SPARC_WPLT30 && h == NULL) 3320 break; 3321 else 3322 { 3323 BFD_ASSERT (h != NULL); 3324 } 3325 3326 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL) 3327 { 3328 /* We didn't make a PLT entry for this symbol. This 3329 happens when statically linking PIC code, or when 3330 using -Bsymbolic. */ 3331 break; 3332 } 3333 3334 relocation = (htab->elf.splt->output_section->vma 3335 + htab->elf.splt->output_offset 3336 + h->plt.offset); 3337 unresolved_reloc = FALSE; 3338 if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64) 3339 { 3340 r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64; 3341 is_plt = TRUE; 3342 goto r_sparc_plt32; 3343 } 3344 break; 3345 3346 case R_SPARC_PC10: 3347 case R_SPARC_PC22: 3348 case R_SPARC_PC_HH22: 3349 case R_SPARC_PC_HM10: 3350 case R_SPARC_PC_LM22: 3351 if (h != NULL 3352 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 3353 break; 3354 /* Fall through. */ 3355 case R_SPARC_DISP8: 3356 case R_SPARC_DISP16: 3357 case R_SPARC_DISP32: 3358 case R_SPARC_DISP64: 3359 case R_SPARC_WDISP30: 3360 case R_SPARC_WDISP22: 3361 case R_SPARC_WDISP19: 3362 case R_SPARC_WDISP16: 3363 case R_SPARC_WDISP10: 3364 case R_SPARC_8: 3365 case R_SPARC_16: 3366 case R_SPARC_32: 3367 case R_SPARC_HI22: 3368 case R_SPARC_22: 3369 case R_SPARC_13: 3370 case R_SPARC_LO10: 3371 case R_SPARC_UA16: 3372 case R_SPARC_UA32: 3373 case R_SPARC_10: 3374 case R_SPARC_11: 3375 case R_SPARC_64: 3376 case R_SPARC_OLO10: 3377 case R_SPARC_HH22: 3378 case R_SPARC_HM10: 3379 case R_SPARC_LM22: 3380 case R_SPARC_7: 3381 case R_SPARC_5: 3382 case R_SPARC_6: 3383 case R_SPARC_HIX22: 3384 case R_SPARC_LOX10: 3385 case R_SPARC_H44: 3386 case R_SPARC_M44: 3387 case R_SPARC_L44: 3388 case R_SPARC_H34: 3389 case R_SPARC_UA64: 3390 r_sparc_plt32: 3391 if ((input_section->flags & SEC_ALLOC) == 0 || is_vxworks_tls) 3392 break; 3393 3394 /* Copy dynamic function pointer relocations. Don't generate 3395 dynamic relocations against resolved undefined weak symbols 3396 in PIE. */ 3397 if ((bfd_link_pic (info) 3398 && (h == NULL 3399 || !(h->root.type == bfd_link_hash_undefweak 3400 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 3401 || resolved_to_zero))) 3402 && (! howto->pc_relative 3403 || !SYMBOL_CALLS_LOCAL (info, h))) 3404 || (!bfd_link_pic (info) 3405 && h != NULL 3406 && h->dynindx != -1 3407 && !h->non_got_ref 3408 && ((h->def_dynamic 3409 && !h->def_regular) 3410 || (h->root.type == bfd_link_hash_undefweak 3411 && !resolved_to_zero) 3412 || h->root.type == bfd_link_hash_undefined))) 3413 { 3414 Elf_Internal_Rela outrel; 3415 bfd_boolean skip, relocate = FALSE; 3416 3417 /* When generating a shared object, these relocations 3418 are copied into the output file to be resolved at run 3419 time. */ 3420 3421 BFD_ASSERT (sreloc != NULL); 3422 3423 skip = FALSE; 3424 3425 outrel.r_offset = 3426 _bfd_elf_section_offset (output_bfd, info, input_section, 3427 rel->r_offset); 3428 if (outrel.r_offset == (bfd_vma) -1) 3429 skip = TRUE; 3430 else if (outrel.r_offset == (bfd_vma) -2) 3431 skip = TRUE, relocate = TRUE; 3432 outrel.r_offset += (input_section->output_section->vma 3433 + input_section->output_offset); 3434 3435 /* Optimize unaligned reloc usage now that we know where 3436 it finally resides. */ 3437 switch (r_type) 3438 { 3439 case R_SPARC_16: 3440 if (outrel.r_offset & 1) 3441 r_type = R_SPARC_UA16; 3442 break; 3443 case R_SPARC_UA16: 3444 if (!(outrel.r_offset & 1)) 3445 r_type = R_SPARC_16; 3446 break; 3447 case R_SPARC_32: 3448 if (outrel.r_offset & 3) 3449 r_type = R_SPARC_UA32; 3450 break; 3451 case R_SPARC_UA32: 3452 if (!(outrel.r_offset & 3)) 3453 r_type = R_SPARC_32; 3454 break; 3455 case R_SPARC_64: 3456 if (outrel.r_offset & 7) 3457 r_type = R_SPARC_UA64; 3458 break; 3459 case R_SPARC_UA64: 3460 if (!(outrel.r_offset & 7)) 3461 r_type = R_SPARC_64; 3462 break; 3463 case R_SPARC_DISP8: 3464 case R_SPARC_DISP16: 3465 case R_SPARC_DISP32: 3466 case R_SPARC_DISP64: 3467 /* If the symbol is not dynamic, we should not keep 3468 a dynamic relocation. But an .rela.* slot has been 3469 allocated for it, output R_SPARC_NONE. 3470 FIXME: Add code tracking needed dynamic relocs as 3471 e.g. i386 has. */ 3472 if (h->dynindx == -1) 3473 skip = TRUE, relocate = TRUE; 3474 break; 3475 } 3476 3477 if (skip) 3478 memset (&outrel, 0, sizeof outrel); 3479 /* h->dynindx may be -1 if the symbol was marked to 3480 become local. */ 3481 else if (h != NULL 3482 && h->dynindx != -1 3483 && (_bfd_sparc_elf_howto_table[r_type].pc_relative 3484 || !bfd_link_pic (info) 3485 || !SYMBOLIC_BIND (info, h) 3486 || !h->def_regular)) 3487 { 3488 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type); 3489 outrel.r_addend = rel->r_addend; 3490 } 3491 else 3492 { 3493 if ( (!ABI_64_P (output_bfd) && r_type == R_SPARC_32) 3494 || (ABI_64_P (output_bfd) && r_type == R_SPARC_64)) 3495 { 3496 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 3497 0, R_SPARC_RELATIVE); 3498 outrel.r_addend = relocation + rel->r_addend; 3499 } 3500 else 3501 { 3502 long indx; 3503 3504 outrel.r_addend = relocation + rel->r_addend; 3505 3506 if (is_plt) 3507 sec = htab->elf.splt; 3508 3509 if (bfd_is_abs_section (sec)) 3510 indx = 0; 3511 else if (sec == NULL || sec->owner == NULL) 3512 { 3513 bfd_set_error (bfd_error_bad_value); 3514 return FALSE; 3515 } 3516 else 3517 { 3518 asection *osec; 3519 3520 /* We are turning this relocation into one 3521 against a section symbol. It would be 3522 proper to subtract the symbol's value, 3523 osec->vma, from the emitted reloc addend, 3524 but ld.so expects buggy relocs. */ 3525 osec = sec->output_section; 3526 indx = elf_section_data (osec)->dynindx; 3527 3528 if (indx == 0) 3529 { 3530 osec = htab->elf.text_index_section; 3531 indx = elf_section_data (osec)->dynindx; 3532 } 3533 3534 /* FIXME: we really should be able to link non-pic 3535 shared libraries. */ 3536 if (indx == 0) 3537 { 3538 BFD_FAIL (); 3539 _bfd_error_handler 3540 (_("%pB: probably compiled without -fPIC?"), 3541 input_bfd); 3542 bfd_set_error (bfd_error_bad_value); 3543 return FALSE; 3544 } 3545 } 3546 3547 outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx, 3548 r_type); 3549 } 3550 } 3551 3552 sparc_elf_append_rela (output_bfd, sreloc, &outrel); 3553 3554 /* This reloc will be computed at runtime, so there's no 3555 need to do anything now. */ 3556 if (! relocate) 3557 continue; 3558 } 3559 break; 3560 3561 case R_SPARC_TLS_GD_HI22: 3562 case R_SPARC_TLS_GD_LO10: 3563 case R_SPARC_TLS_IE_HI22: 3564 case R_SPARC_TLS_IE_LO10: 3565 r_type = sparc_elf_tls_transition (info, input_bfd, r_type, 3566 h == NULL || h->dynindx == -1); 3567 if (r_type == R_SPARC_REV32) 3568 break; 3569 if (h != NULL) 3570 tls_type = _bfd_sparc_elf_hash_entry (h)->tls_type; 3571 else if (local_got_offsets) 3572 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx]; 3573 else if (h != NULL) 3574 { 3575 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type; 3576 if (!bfd_link_dll (info) 3577 && h->dynindx == -1 3578 && tls_type == GOT_TLS_IE) 3579 switch (SPARC_ELF_R_TYPE (rel->r_info)) 3580 { 3581 case R_SPARC_TLS_GD_HI22: 3582 case R_SPARC_TLS_IE_HI22: 3583 r_type = R_SPARC_TLS_LE_HIX22; 3584 break; 3585 default: 3586 r_type = R_SPARC_TLS_LE_LOX10; 3587 break; 3588 } 3589 } 3590 else 3591 tls_type = GOT_UNKNOWN; 3592 if (tls_type == GOT_TLS_IE) 3593 switch (r_type) 3594 { 3595 case R_SPARC_TLS_GD_HI22: 3596 r_type = R_SPARC_TLS_IE_HI22; 3597 break; 3598 case R_SPARC_TLS_GD_LO10: 3599 r_type = R_SPARC_TLS_IE_LO10; 3600 break; 3601 } 3602 3603 if (r_type == R_SPARC_TLS_LE_HIX22) 3604 { 3605 relocation = tpoff (info, relocation); 3606 break; 3607 } 3608 if (r_type == R_SPARC_TLS_LE_LOX10) 3609 { 3610 /* Change add into xor. */ 3611 relocation = tpoff (info, relocation); 3612 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd, 3613 contents + rel->r_offset) 3614 | 0x80182000), contents + rel->r_offset); 3615 break; 3616 } 3617 3618 if (h != NULL) 3619 { 3620 off = h->got.offset; 3621 h->got.offset |= 1; 3622 } 3623 else 3624 { 3625 BFD_ASSERT (local_got_offsets != NULL); 3626 off = local_got_offsets[r_symndx]; 3627 local_got_offsets[r_symndx] |= 1; 3628 } 3629 3630 r_sparc_tlsldm: 3631 if (htab->elf.sgot == NULL) 3632 abort (); 3633 3634 if ((off & 1) != 0) 3635 off &= ~1; 3636 else 3637 { 3638 Elf_Internal_Rela outrel; 3639 int dr_type, indx; 3640 3641 if (htab->elf.srelgot == NULL) 3642 abort (); 3643 3644 SPARC_ELF_PUT_WORD (htab, output_bfd, 0, 3645 htab->elf.sgot->contents + off); 3646 outrel.r_offset = (htab->elf.sgot->output_section->vma 3647 + htab->elf.sgot->output_offset + off); 3648 indx = h && h->dynindx != -1 ? h->dynindx : 0; 3649 if (r_type == R_SPARC_TLS_IE_HI22 3650 || r_type == R_SPARC_TLS_IE_LO10) 3651 dr_type = SPARC_ELF_TPOFF_RELOC (htab); 3652 else 3653 dr_type = SPARC_ELF_DTPMOD_RELOC (htab); 3654 if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0) 3655 outrel.r_addend = relocation - dtpoff_base (info); 3656 else 3657 outrel.r_addend = 0; 3658 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type); 3659 sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 3660 3661 if (r_type == R_SPARC_TLS_GD_HI22 3662 || r_type == R_SPARC_TLS_GD_LO10) 3663 { 3664 if (indx == 0) 3665 { 3666 BFD_ASSERT (! unresolved_reloc); 3667 SPARC_ELF_PUT_WORD (htab, output_bfd, 3668 relocation - dtpoff_base (info), 3669 (htab->elf.sgot->contents + off 3670 + SPARC_ELF_WORD_BYTES (htab))); 3671 } 3672 else 3673 { 3674 SPARC_ELF_PUT_WORD (htab, output_bfd, 0, 3675 (htab->elf.sgot->contents + off 3676 + SPARC_ELF_WORD_BYTES (htab))); 3677 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, 3678 SPARC_ELF_DTPOFF_RELOC (htab)); 3679 outrel.r_offset += SPARC_ELF_WORD_BYTES (htab); 3680 sparc_elf_append_rela (output_bfd, htab->elf.srelgot, 3681 &outrel); 3682 } 3683 } 3684 else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab)) 3685 { 3686 SPARC_ELF_PUT_WORD (htab, output_bfd, 0, 3687 (htab->elf.sgot->contents + off 3688 + SPARC_ELF_WORD_BYTES (htab))); 3689 } 3690 } 3691 3692 if (off >= (bfd_vma) -2) 3693 abort (); 3694 3695 relocation = htab->elf.sgot->output_offset + off - got_base; 3696 unresolved_reloc = FALSE; 3697 howto = _bfd_sparc_elf_howto_table + r_type; 3698 break; 3699 3700 case R_SPARC_TLS_LDM_HI22: 3701 case R_SPARC_TLS_LDM_LO10: 3702 /* LD -> LE */ 3703 if (bfd_link_executable (info)) 3704 { 3705 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset); 3706 continue; 3707 } 3708 off = htab->tls_ldm_got.offset; 3709 htab->tls_ldm_got.offset |= 1; 3710 goto r_sparc_tlsldm; 3711 3712 case R_SPARC_TLS_LDO_HIX22: 3713 case R_SPARC_TLS_LDO_LOX10: 3714 /* LD -> LE */ 3715 if (bfd_link_executable (info)) 3716 { 3717 if (r_type == R_SPARC_TLS_LDO_HIX22) 3718 r_type = R_SPARC_TLS_LE_HIX22; 3719 else 3720 r_type = R_SPARC_TLS_LE_LOX10; 3721 } 3722 else 3723 { 3724 relocation -= dtpoff_base (info); 3725 break; 3726 } 3727 /* Fall through. */ 3728 3729 case R_SPARC_TLS_LE_HIX22: 3730 case R_SPARC_TLS_LE_LOX10: 3731 if (!bfd_link_executable (info)) 3732 { 3733 Elf_Internal_Rela outrel; 3734 bfd_vma offset 3735 = _bfd_elf_section_offset (output_bfd, info, input_section, 3736 rel->r_offset); 3737 if (offset == (bfd_vma) -1 || offset == (bfd_vma) -2) 3738 memset (&outrel, 0, sizeof outrel); 3739 else 3740 { 3741 outrel.r_offset = offset 3742 + input_section->output_section->vma 3743 + input_section->output_offset; 3744 outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type); 3745 outrel.r_addend 3746 = relocation - dtpoff_base (info) + rel->r_addend; 3747 } 3748 3749 BFD_ASSERT (sreloc != NULL); 3750 sparc_elf_append_rela (output_bfd, sreloc, &outrel); 3751 continue; 3752 } 3753 relocation = tpoff (info, relocation); 3754 break; 3755 3756 case R_SPARC_TLS_LDM_CALL: 3757 /* LD -> LE */ 3758 if (bfd_link_executable (info)) 3759 { 3760 /* mov %g0, %o0 */ 3761 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset); 3762 continue; 3763 } 3764 /* Fall through */ 3765 3766 case R_SPARC_TLS_GD_CALL: 3767 if (h != NULL) 3768 tls_type = _bfd_sparc_elf_hash_entry (h)->tls_type; 3769 else if (local_got_offsets) 3770 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx]; 3771 else if (h != NULL) 3772 tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type; 3773 else 3774 tls_type = GOT_UNKNOWN; 3775 /* GD -> IE or LE */ 3776 if (bfd_link_executable (info) 3777 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE)) 3778 { 3779 Elf_Internal_Rela *rel2; 3780 bfd_vma insn; 3781 3782 /* GD -> LE */ 3783 if (bfd_link_executable (info) && (h == NULL || h->dynindx == -1)) 3784 { 3785 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset); 3786 continue; 3787 } 3788 3789 /* GD -> IE */ 3790 if (rel + 1 < relend 3791 && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD 3792 && rel[1].r_offset == rel->r_offset + 4 3793 && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx 3794 && (((insn = bfd_get_32 (input_bfd, 3795 contents + rel[1].r_offset)) 3796 >> 25) & 0x1f) == 8) 3797 { 3798 /* We have 3799 call __tls_get_addr, %tgd_call(foo) 3800 add %reg1, %reg2, %o0, %tgd_add(foo) 3801 and change it into IE: 3802 {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo) 3803 add %g7, %o0, %o0, %tie_add(foo). 3804 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2, 3805 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2, 3806 ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2. */ 3807 bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000), 3808 contents + rel->r_offset); 3809 bfd_put_32 (output_bfd, 0x9001c008, 3810 contents + rel->r_offset + 4); 3811 rel++; 3812 continue; 3813 } 3814 3815 /* We cannot just overwrite the delay slot instruction, 3816 as it might be what puts the %o0 argument to 3817 __tls_get_addr into place. So we have to transpose 3818 the delay slot with the add we patch in. */ 3819 insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4); 3820 bfd_put_32 (output_bfd, insn, 3821 contents + rel->r_offset); 3822 bfd_put_32 (output_bfd, 0x9001c008, 3823 contents + rel->r_offset + 4); 3824 3825 rel2 = rel; 3826 while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend, 3827 rel->r_offset + 4)) 3828 != NULL) 3829 { 3830 /* If the instruction we moved has a relocation attached to 3831 it, adjust the offset so that it will apply to the correct 3832 instruction. */ 3833 rel2->r_offset -= 4; 3834 } 3835 continue; 3836 } 3837 3838 h = (struct elf_link_hash_entry *) 3839 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE, 3840 FALSE, TRUE); 3841 BFD_ASSERT (h != NULL); 3842 r_type = R_SPARC_WPLT30; 3843 howto = _bfd_sparc_elf_howto_table + r_type; 3844 goto r_sparc_wplt30; 3845 3846 case R_SPARC_TLS_GD_ADD: 3847 if (h != NULL) 3848 tls_type = _bfd_sparc_elf_hash_entry (h)->tls_type; 3849 else if (local_got_offsets) 3850 tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx]; 3851 else 3852 tls_type = GOT_UNKNOWN; 3853 /* GD -> IE or LE */ 3854 if (bfd_link_executable (info) || tls_type == GOT_TLS_IE) 3855 { 3856 /* add %reg1, %reg2, %reg3, %tgd_add(foo) 3857 changed into IE: 3858 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo) 3859 or LE: 3860 add %g7, %reg2, %reg3. */ 3861 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3862 if (bfd_link_executable (info) && (h == NULL || h->dynindx == -1)) 3863 relocation = (insn & ~0x7c000) | 0x1c000; 3864 else 3865 relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000); 3866 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset); 3867 } 3868 continue; 3869 3870 case R_SPARC_TLS_LDM_ADD: 3871 /* LD -> LE */ 3872 if (bfd_link_executable (info)) 3873 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset); 3874 continue; 3875 3876 case R_SPARC_TLS_LDO_ADD: 3877 /* LD -> LE */ 3878 if (bfd_link_executable (info)) 3879 { 3880 /* Change rs1 into %g7. */ 3881 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3882 insn = (insn & ~0x7c000) | 0x1c000; 3883 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 3884 } 3885 continue; 3886 3887 case R_SPARC_TLS_IE_LD: 3888 case R_SPARC_TLS_IE_LDX: 3889 /* IE -> LE */ 3890 if (bfd_link_executable (info) && (h == NULL || h->dynindx == -1)) 3891 { 3892 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3893 int rs2 = insn & 0x1f; 3894 int rd = (insn >> 25) & 0x1f; 3895 3896 if (rs2 == rd) 3897 relocation = SPARC_NOP; 3898 else 3899 relocation = 0x80100000 | (insn & 0x3e00001f); 3900 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset); 3901 } 3902 continue; 3903 3904 case R_SPARC_TLS_IE_ADD: 3905 /* Totally useless relocation. */ 3906 continue; 3907 3908 case R_SPARC_TLS_DTPOFF32: 3909 case R_SPARC_TLS_DTPOFF64: 3910 relocation -= dtpoff_base (info); 3911 break; 3912 3913 default: 3914 break; 3915 } 3916 3917 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 3918 because such sections are not SEC_ALLOC and thus ld.so will 3919 not process them. */ 3920 if (unresolved_reloc 3921 && !((input_section->flags & SEC_DEBUGGING) != 0 3922 && h->def_dynamic) 3923 && _bfd_elf_section_offset (output_bfd, info, input_section, 3924 rel->r_offset) != (bfd_vma) -1) 3925 _bfd_error_handler 3926 /* xgettext:c-format */ 3927 (_("%pB(%pA+%#" PRIx64 "): " 3928 "unresolvable %s relocation against symbol `%s'"), 3929 input_bfd, 3930 input_section, 3931 (uint64_t) rel->r_offset, 3932 howto->name, 3933 h->root.root.string); 3934 3935 r = bfd_reloc_continue; 3936 if (r_type == R_SPARC_OLO10) 3937 { 3938 bfd_vma x; 3939 3940 if (! ABI_64_P (output_bfd)) 3941 abort (); 3942 3943 relocation += rel->r_addend; 3944 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info); 3945 3946 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 3947 x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff); 3948 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 3949 3950 r = bfd_check_overflow (howto->complain_on_overflow, 3951 howto->bitsize, howto->rightshift, 3952 bfd_arch_bits_per_address (input_bfd), 3953 relocation); 3954 } 3955 else if (r_type == R_SPARC_WDISP16) 3956 { 3957 bfd_vma x; 3958 3959 relocation += rel->r_addend; 3960 relocation -= (input_section->output_section->vma 3961 + input_section->output_offset); 3962 relocation -= rel->r_offset; 3963 3964 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 3965 x |= ((((relocation >> 2) & 0xc000) << 6) 3966 | ((relocation >> 2) & 0x3fff)); 3967 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 3968 3969 r = bfd_check_overflow (howto->complain_on_overflow, 3970 howto->bitsize, howto->rightshift, 3971 bfd_arch_bits_per_address (input_bfd), 3972 relocation); 3973 } 3974 else if (r_type == R_SPARC_WDISP10) 3975 { 3976 bfd_vma x; 3977 3978 relocation += rel->r_addend; 3979 relocation -= (input_section->output_section->vma 3980 + input_section->output_offset); 3981 relocation -= rel->r_offset; 3982 3983 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 3984 x |= ((((relocation >> 2) & 0x300) << 11) 3985 | (((relocation >> 2) & 0xff) << 5)); 3986 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 3987 3988 r = bfd_check_overflow (howto->complain_on_overflow, 3989 howto->bitsize, howto->rightshift, 3990 bfd_arch_bits_per_address (input_bfd), 3991 relocation); 3992 } 3993 else if (r_type == R_SPARC_REV32) 3994 { 3995 bfd_vma x; 3996 3997 relocation = relocation + rel->r_addend; 3998 3999 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 4000 x = x + relocation; 4001 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset); 4002 r = bfd_reloc_ok; 4003 } 4004 else if (r_type == R_SPARC_TLS_LDO_HIX22 4005 || r_type == R_SPARC_TLS_LE_HIX22) 4006 { 4007 bfd_vma x; 4008 4009 relocation += rel->r_addend; 4010 if (r_type == R_SPARC_TLS_LE_HIX22) 4011 relocation ^= MINUS_ONE; 4012 4013 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 4014 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff); 4015 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 4016 r = bfd_reloc_ok; 4017 } 4018 else if (r_type == R_SPARC_TLS_LDO_LOX10 4019 || r_type == R_SPARC_TLS_LE_LOX10) 4020 { 4021 bfd_vma x; 4022 4023 relocation += rel->r_addend; 4024 relocation &= 0x3ff; 4025 if (r_type == R_SPARC_TLS_LE_LOX10) 4026 relocation |= 0x1c00; 4027 4028 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 4029 x = (x & ~(bfd_vma) 0x1fff) | relocation; 4030 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 4031 4032 r = bfd_reloc_ok; 4033 } 4034 else if (r_type == R_SPARC_HIX22 4035 || r_type == R_SPARC_GOTDATA_HIX22 4036 || r_type == R_SPARC_GOTDATA_OP_HIX22) 4037 { 4038 bfd_vma x; 4039 4040 relocation += rel->r_addend; 4041 if (r_type == R_SPARC_HIX22 4042 || (bfd_signed_vma) relocation < 0) 4043 relocation = relocation ^ MINUS_ONE; 4044 4045 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 4046 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff); 4047 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 4048 4049 r = bfd_check_overflow (howto->complain_on_overflow, 4050 howto->bitsize, howto->rightshift, 4051 bfd_arch_bits_per_address (input_bfd), 4052 relocation); 4053 } 4054 else if (r_type == R_SPARC_LOX10 4055 || r_type == R_SPARC_GOTDATA_LOX10 4056 || r_type == R_SPARC_GOTDATA_OP_LOX10) 4057 { 4058 bfd_vma x; 4059 4060 relocation += rel->r_addend; 4061 if (r_type == R_SPARC_LOX10 4062 || (bfd_signed_vma) relocation < 0) 4063 relocation = (relocation & 0x3ff) | 0x1c00; 4064 else 4065 relocation = (relocation & 0x3ff); 4066 4067 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 4068 x = (x & ~(bfd_vma) 0x1fff) | relocation; 4069 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 4070 4071 r = bfd_reloc_ok; 4072 } 4073 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30) 4074 && sec_do_relax (input_section) 4075 && rel->r_offset + 4 < input_section->size) 4076 { 4077 #define G0 0 4078 #define O7 15 4079 #define XCC (2 << 20) 4080 #define COND(x) (((x)&0xf)<<25) 4081 #define CONDA COND(0x8) 4082 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC) 4083 #define INSN_BA (F2(0,2) | CONDA) 4084 #define INSN_OR F3(2, 0x2, 0) 4085 #define INSN_NOP F2(0,4) 4086 4087 bfd_vma x, y; 4088 4089 /* If the instruction is a call with either: 4090 restore 4091 arithmetic instruction with rd == %o7 4092 where rs1 != %o7 and rs2 if it is register != %o7 4093 then we can optimize if the call destination is near 4094 by changing the call into a branch always. */ 4095 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 4096 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4); 4097 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2)) 4098 { 4099 if (((y & OP3(~0)) == OP3(0x3d) /* restore */ 4100 || ((y & OP3(0x28)) == 0 /* arithmetic */ 4101 && (y & RD(~0)) == RD(O7))) 4102 && (y & RS1(~0)) != RS1(O7) 4103 && ((y & F3I(~0)) 4104 || (y & RS2(~0)) != RS2(O7))) 4105 { 4106 bfd_vma reloc; 4107 4108 reloc = relocation + rel->r_addend - rel->r_offset; 4109 reloc -= (input_section->output_section->vma 4110 + input_section->output_offset); 4111 4112 /* Ensure the branch fits into simm22. */ 4113 if ((reloc & 3) == 0 4114 && ((reloc & ~(bfd_vma)0x7fffff) == 0 4115 || ((reloc | 0x7fffff) == ~(bfd_vma)0))) 4116 { 4117 reloc >>= 2; 4118 4119 /* Check whether it fits into simm19. */ 4120 if (((reloc & 0x3c0000) == 0 4121 || (reloc & 0x3c0000) == 0x3c0000) 4122 && (ABI_64_P (output_bfd) 4123 || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS)) 4124 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */ 4125 else 4126 x = INSN_BA | (reloc & 0x3fffff); /* ba */ 4127 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 4128 r = bfd_reloc_ok; 4129 if (rel->r_offset >= 4 4130 && (y & (0xffffffff ^ RS1(~0))) 4131 == (INSN_OR | RD(O7) | RS2(G0))) 4132 { 4133 bfd_vma z; 4134 unsigned int reg; 4135 4136 z = bfd_get_32 (input_bfd, 4137 contents + rel->r_offset - 4); 4138 if ((z & (0xffffffff ^ RD(~0))) 4139 != (INSN_OR | RS1(O7) | RS2(G0))) 4140 continue; 4141 4142 /* The sequence was 4143 or %o7, %g0, %rN 4144 call foo 4145 or %rN, %g0, %o7 4146 4147 If call foo was replaced with ba, replace 4148 or %rN, %g0, %o7 with nop. */ 4149 4150 reg = (y & RS1(~0)) >> 14; 4151 if (reg != ((z & RD(~0)) >> 25) 4152 || reg == G0 || reg == O7) 4153 continue; 4154 4155 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP, 4156 contents + rel->r_offset + 4); 4157 } 4158 4159 } 4160 } 4161 } 4162 } 4163 4164 if (r == bfd_reloc_continue) 4165 { 4166 do_relocation: 4167 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 4168 contents, rel->r_offset, 4169 relocation, rel->r_addend); 4170 } 4171 if (r != bfd_reloc_ok) 4172 { 4173 switch (r) 4174 { 4175 default: 4176 case bfd_reloc_outofrange: 4177 abort (); 4178 case bfd_reloc_overflow: 4179 { 4180 const char *name; 4181 4182 /* The Solaris native linker silently disregards overflows. 4183 We don't, but this breaks stabs debugging info, whose 4184 relocations are only 32-bits wide. Ignore overflows in 4185 this case and also for discarded entries. */ 4186 if ((r_type == R_SPARC_32 4187 || r_type == R_SPARC_UA32 4188 || r_type == R_SPARC_DISP32) 4189 && (((input_section->flags & SEC_DEBUGGING) != 0 4190 && strcmp (bfd_section_name (input_bfd, 4191 input_section), 4192 ".stab") == 0) 4193 || _bfd_elf_section_offset (output_bfd, info, 4194 input_section, 4195 rel->r_offset) 4196 == (bfd_vma)-1)) 4197 break; 4198 4199 if (h != NULL) 4200 { 4201 /* Assume this is a call protected by other code that 4202 detect the symbol is undefined. If this is the case, 4203 we can safely ignore the overflow. If not, the 4204 program is hosed anyway, and a little warning isn't 4205 going to help. */ 4206 if (h->root.type == bfd_link_hash_undefweak 4207 && howto->pc_relative) 4208 break; 4209 4210 name = NULL; 4211 } 4212 else 4213 { 4214 name = bfd_elf_string_from_elf_section (input_bfd, 4215 symtab_hdr->sh_link, 4216 sym->st_name); 4217 if (name == NULL) 4218 return FALSE; 4219 if (*name == '\0') 4220 name = bfd_section_name (input_bfd, sec); 4221 } 4222 (*info->callbacks->reloc_overflow) 4223 (info, (h ? &h->root : NULL), name, howto->name, 4224 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 4225 } 4226 break; 4227 } 4228 } 4229 } 4230 4231 return TRUE; 4232 } 4233 4234 /* Build a VxWorks PLT entry. PLT_INDEX is the index of the PLT entry 4235 and PLT_OFFSET is the byte offset from the start of .plt. GOT_OFFSET 4236 is the offset of the associated .got.plt entry from 4237 _GLOBAL_OFFSET_TABLE_. */ 4238 4239 static void 4240 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info, 4241 bfd_vma plt_offset, bfd_vma plt_index, 4242 bfd_vma got_offset) 4243 { 4244 bfd_vma got_base; 4245 const bfd_vma *plt_entry; 4246 struct _bfd_sparc_elf_link_hash_table *htab; 4247 bfd_byte *loc; 4248 Elf_Internal_Rela rela; 4249 4250 htab = _bfd_sparc_elf_hash_table (info); 4251 BFD_ASSERT (htab != NULL); 4252 4253 if (bfd_link_pic (info)) 4254 { 4255 plt_entry = sparc_vxworks_shared_plt_entry; 4256 got_base = 0; 4257 } 4258 else 4259 { 4260 plt_entry = sparc_vxworks_exec_plt_entry; 4261 got_base = (htab->elf.hgot->root.u.def.value 4262 + htab->elf.hgot->root.u.def.section->output_offset 4263 + htab->elf.hgot->root.u.def.section->output_section->vma); 4264 } 4265 4266 /* Fill in the entry in the procedure linkage table. */ 4267 bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10), 4268 htab->elf.splt->contents + plt_offset); 4269 bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff), 4270 htab->elf.splt->contents + plt_offset + 4); 4271 bfd_put_32 (output_bfd, plt_entry[2], 4272 htab->elf.splt->contents + plt_offset + 8); 4273 bfd_put_32 (output_bfd, plt_entry[3], 4274 htab->elf.splt->contents + plt_offset + 12); 4275 bfd_put_32 (output_bfd, plt_entry[4], 4276 htab->elf.splt->contents + plt_offset + 16); 4277 bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10), 4278 htab->elf.splt->contents + plt_offset + 20); 4279 /* PC-relative displacement for a branch to the start of 4280 the PLT section. */ 4281 bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2) 4282 & 0x003fffff), 4283 htab->elf.splt->contents + plt_offset + 24); 4284 bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff), 4285 htab->elf.splt->contents + plt_offset + 28); 4286 4287 /* Fill in the .got.plt entry, pointing initially at the 4288 second half of the PLT entry. */ 4289 BFD_ASSERT (htab->elf.sgotplt != NULL); 4290 bfd_put_32 (output_bfd, 4291 htab->elf.splt->output_section->vma 4292 + htab->elf.splt->output_offset 4293 + plt_offset + 20, 4294 htab->elf.sgotplt->contents + got_offset); 4295 4296 /* Add relocations to .rela.plt.unloaded. */ 4297 if (!bfd_link_pic (info)) 4298 { 4299 loc = (htab->srelplt2->contents 4300 + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela)); 4301 4302 /* Relocate the initial sethi. */ 4303 rela.r_offset = (htab->elf.splt->output_section->vma 4304 + htab->elf.splt->output_offset 4305 + plt_offset); 4306 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22); 4307 rela.r_addend = got_offset; 4308 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4309 loc += sizeof (Elf32_External_Rela); 4310 4311 /* Likewise the following or. */ 4312 rela.r_offset += 4; 4313 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10); 4314 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4315 loc += sizeof (Elf32_External_Rela); 4316 4317 /* Relocate the .got.plt entry. */ 4318 rela.r_offset = (htab->elf.sgotplt->output_section->vma 4319 + htab->elf.sgotplt->output_offset 4320 + got_offset); 4321 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32); 4322 rela.r_addend = plt_offset + 20; 4323 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4324 } 4325 } 4326 4327 /* Finish up dynamic symbol handling. We set the contents of various 4328 dynamic sections here. */ 4329 4330 bfd_boolean 4331 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd, 4332 struct bfd_link_info *info, 4333 struct elf_link_hash_entry *h, 4334 Elf_Internal_Sym *sym) 4335 { 4336 struct _bfd_sparc_elf_link_hash_table *htab; 4337 const struct elf_backend_data *bed; 4338 struct _bfd_sparc_elf_link_hash_entry *eh; 4339 bfd_boolean resolved_to_zero; 4340 4341 htab = _bfd_sparc_elf_hash_table (info); 4342 BFD_ASSERT (htab != NULL); 4343 bed = get_elf_backend_data (output_bfd); 4344 4345 eh = (struct _bfd_sparc_elf_link_hash_entry *) h; 4346 4347 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for 4348 resolved undefined weak symbols in executable so that their 4349 references have value 0 at run-time. */ 4350 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh); 4351 4352 if (h->plt.offset != (bfd_vma) -1) 4353 { 4354 asection *splt; 4355 asection *srela; 4356 Elf_Internal_Rela rela; 4357 bfd_byte *loc; 4358 bfd_vma r_offset, got_offset; 4359 int rela_index; 4360 4361 /* When building a static executable, use .iplt and 4362 .rela.iplt sections for STT_GNU_IFUNC symbols. */ 4363 if (htab->elf.splt != NULL) 4364 { 4365 splt = htab->elf.splt; 4366 srela = htab->elf.srelplt; 4367 } 4368 else 4369 { 4370 splt = htab->elf.iplt; 4371 srela = htab->elf.irelplt; 4372 } 4373 4374 if (splt == NULL || srela == NULL) 4375 abort (); 4376 4377 /* Fill in the entry in the .rela.plt section. */ 4378 if (htab->is_vxworks) 4379 { 4380 /* Work out the index of this PLT entry. */ 4381 rela_index = ((h->plt.offset - htab->plt_header_size) 4382 / htab->plt_entry_size); 4383 4384 /* Calculate the offset of the associated .got.plt entry. 4385 The first three entries are reserved. */ 4386 got_offset = (rela_index + 3) * 4; 4387 4388 sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset, 4389 rela_index, got_offset); 4390 4391 4392 /* On VxWorks, the relocation points to the .got.plt entry, 4393 not the .plt entry. */ 4394 rela.r_offset = (htab->elf.sgotplt->output_section->vma 4395 + htab->elf.sgotplt->output_offset 4396 + got_offset); 4397 rela.r_addend = 0; 4398 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, 4399 R_SPARC_JMP_SLOT); 4400 } 4401 else 4402 { 4403 bfd_boolean ifunc = FALSE; 4404 4405 /* Fill in the entry in the procedure linkage table. */ 4406 rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt, 4407 h->plt.offset, splt->size, 4408 &r_offset); 4409 4410 if (h == NULL 4411 || h->dynindx == -1 4412 || ((bfd_link_executable (info) 4413 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 4414 && h->def_regular 4415 && h->type == STT_GNU_IFUNC)) 4416 { 4417 ifunc = TRUE; 4418 BFD_ASSERT (h == NULL 4419 || (h->type == STT_GNU_IFUNC 4420 && h->def_regular 4421 && (h->root.type == bfd_link_hash_defined 4422 || h->root.type == bfd_link_hash_defweak))); 4423 } 4424 4425 rela.r_offset = r_offset 4426 + (splt->output_section->vma + splt->output_offset); 4427 if (ABI_64_P (output_bfd) 4428 && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)) 4429 { 4430 if (ifunc) 4431 { 4432 rela.r_addend = (h->root.u.def.section->output_section->vma 4433 + h->root.u.def.section->output_offset 4434 + h->root.u.def.value); 4435 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, 4436 R_SPARC_IRELATIVE); 4437 } 4438 else 4439 { 4440 rela.r_addend = (-(h->plt.offset + 4) 4441 - splt->output_section->vma 4442 - splt->output_offset); 4443 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, 4444 R_SPARC_JMP_SLOT); 4445 } 4446 } 4447 else 4448 { 4449 if (ifunc) 4450 { 4451 rela.r_addend = (h->root.u.def.section->output_section->vma 4452 + h->root.u.def.section->output_offset 4453 + h->root.u.def.value); 4454 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, 4455 R_SPARC_JMP_IREL); 4456 } 4457 else 4458 { 4459 rela.r_addend = 0; 4460 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, 4461 R_SPARC_JMP_SLOT); 4462 } 4463 } 4464 } 4465 4466 /* Adjust for the first 4 reserved elements in the .plt section 4467 when setting the offset in the .rela.plt section. 4468 Sun forgot to read their own ABI and copied elf32-sparc behaviour, 4469 thus .plt[4] has corresponding .rela.plt[0] and so on. */ 4470 4471 loc = srela->contents; 4472 loc += rela_index * bed->s->sizeof_rela; 4473 bed->s->swap_reloca_out (output_bfd, &rela, loc); 4474 4475 if (!resolved_to_zero && !h->def_regular) 4476 { 4477 /* Mark the symbol as undefined, rather than as defined in 4478 the .plt section. Leave the value alone. */ 4479 sym->st_shndx = SHN_UNDEF; 4480 /* If the symbol is weak, we do need to clear the value. 4481 Otherwise, the PLT entry would provide a definition for 4482 the symbol even if the symbol wasn't defined anywhere, 4483 and so the symbol would never be NULL. */ 4484 if (!h->ref_regular_nonweak) 4485 sym->st_value = 0; 4486 } 4487 } 4488 4489 /* Don't generate dynamic GOT relocation against resolved undefined weak 4490 symbols in an executable. */ 4491 if (h->got.offset != (bfd_vma) -1 4492 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD 4493 && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE 4494 && !(h->root.type == bfd_link_hash_undefweak 4495 && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 4496 || resolved_to_zero))) 4497 { 4498 asection *sgot; 4499 asection *srela; 4500 Elf_Internal_Rela rela; 4501 4502 /* This symbol has an entry in the GOT. Set it up. */ 4503 4504 sgot = htab->elf.sgot; 4505 srela = htab->elf.srelgot; 4506 BFD_ASSERT (sgot != NULL && srela != NULL); 4507 4508 rela.r_offset = (sgot->output_section->vma 4509 + sgot->output_offset 4510 + (h->got.offset &~ (bfd_vma) 1)); 4511 4512 /* If this is a -Bsymbolic link, and the symbol is defined 4513 locally, we just want to emit a RELATIVE reloc. Likewise if 4514 the symbol was forced to be local because of a version file. 4515 The entry in the global offset table will already have been 4516 initialized in the relocate_section function. */ 4517 if (! bfd_link_pic (info) 4518 && h->type == STT_GNU_IFUNC 4519 && h->def_regular) 4520 { 4521 asection *plt; 4522 4523 /* We load the GOT entry with the PLT entry. */ 4524 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt; 4525 SPARC_ELF_PUT_WORD (htab, output_bfd, 4526 (plt->output_section->vma 4527 + plt->output_offset + h->plt.offset), 4528 htab->elf.sgot->contents 4529 + (h->got.offset & ~(bfd_vma) 1)); 4530 return TRUE; 4531 } 4532 4533 if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h)) 4534 { 4535 asection *sec = h->root.u.def.section; 4536 if (h->type == STT_GNU_IFUNC) 4537 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE); 4538 else 4539 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE); 4540 rela.r_addend = (h->root.u.def.value 4541 + sec->output_section->vma 4542 + sec->output_offset); 4543 } 4544 else 4545 { 4546 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT); 4547 rela.r_addend = 0; 4548 } 4549 4550 SPARC_ELF_PUT_WORD (htab, output_bfd, 0, 4551 sgot->contents + (h->got.offset & ~(bfd_vma) 1)); 4552 sparc_elf_append_rela (output_bfd, srela, &rela); 4553 } 4554 4555 if (h->needs_copy) 4556 { 4557 asection *s; 4558 Elf_Internal_Rela rela; 4559 4560 /* This symbols needs a copy reloc. Set it up. */ 4561 BFD_ASSERT (h->dynindx != -1); 4562 4563 rela.r_offset = (h->root.u.def.value 4564 + h->root.u.def.section->output_section->vma 4565 + h->root.u.def.section->output_offset); 4566 rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY); 4567 rela.r_addend = 0; 4568 if (h->root.u.def.section == htab->elf.sdynrelro) 4569 s = htab->elf.sreldynrelro; 4570 else 4571 s = htab->elf.srelbss; 4572 sparc_elf_append_rela (output_bfd, s, &rela); 4573 } 4574 4575 /* Mark some specially defined symbols as absolute. On VxWorks, 4576 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the 4577 ".got" section. Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt". */ 4578 if (sym != NULL 4579 && (h == htab->elf.hdynamic 4580 || (!htab->is_vxworks 4581 && (h == htab->elf.hgot || h == htab->elf.hplt)))) 4582 sym->st_shndx = SHN_ABS; 4583 4584 return TRUE; 4585 } 4586 4587 /* Finish up the dynamic sections. */ 4588 4589 static bfd_boolean 4590 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info, 4591 bfd *dynobj, asection *sdyn, 4592 asection *splt ATTRIBUTE_UNUSED) 4593 { 4594 struct _bfd_sparc_elf_link_hash_table *htab; 4595 const struct elf_backend_data *bed; 4596 bfd_byte *dyncon, *dynconend; 4597 size_t dynsize; 4598 int stt_regidx = -1; 4599 bfd_boolean abi_64_p; 4600 4601 htab = _bfd_sparc_elf_hash_table (info); 4602 BFD_ASSERT (htab != NULL); 4603 bed = get_elf_backend_data (output_bfd); 4604 dynsize = bed->s->sizeof_dyn; 4605 dynconend = sdyn->contents + sdyn->size; 4606 abi_64_p = ABI_64_P (output_bfd); 4607 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize) 4608 { 4609 Elf_Internal_Dyn dyn; 4610 bfd_boolean size; 4611 4612 bed->s->swap_dyn_in (dynobj, dyncon, &dyn); 4613 4614 if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT) 4615 { 4616 /* On VxWorks, DT_PLTGOT should point to the start of the GOT, 4617 not to the start of the PLT. */ 4618 if (htab->elf.sgotplt) 4619 { 4620 dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma 4621 + htab->elf.sgotplt->output_offset); 4622 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon); 4623 } 4624 } 4625 else if (htab->is_vxworks 4626 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn)) 4627 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon); 4628 else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER) 4629 { 4630 if (stt_regidx == -1) 4631 { 4632 stt_regidx = 4633 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1); 4634 if (stt_regidx == -1) 4635 return FALSE; 4636 } 4637 dyn.d_un.d_val = stt_regidx++; 4638 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon); 4639 } 4640 else 4641 { 4642 asection *s; 4643 4644 switch (dyn.d_tag) 4645 { 4646 case DT_PLTGOT: 4647 s = htab->elf.splt; 4648 size = FALSE; 4649 break; 4650 case DT_PLTRELSZ: 4651 s = htab->elf.srelplt; 4652 size = TRUE; 4653 break; 4654 case DT_JMPREL: 4655 s = htab->elf.srelplt; 4656 size = FALSE; 4657 break; 4658 default: 4659 continue; 4660 } 4661 4662 if (s == NULL) 4663 dyn.d_un.d_val = 0; 4664 else 4665 { 4666 if (!size) 4667 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 4668 else 4669 dyn.d_un.d_val = s->size; 4670 } 4671 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon); 4672 } 4673 } 4674 return TRUE; 4675 } 4676 4677 /* Install the first PLT entry in a VxWorks executable and make sure that 4678 .rela.plt.unloaded relocations have the correct symbol indexes. */ 4679 4680 static void 4681 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info) 4682 { 4683 struct _bfd_sparc_elf_link_hash_table *htab; 4684 Elf_Internal_Rela rela; 4685 bfd_vma got_base; 4686 bfd_byte *loc; 4687 4688 htab = _bfd_sparc_elf_hash_table (info); 4689 BFD_ASSERT (htab != NULL); 4690 4691 /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_. */ 4692 got_base = (htab->elf.hgot->root.u.def.section->output_section->vma 4693 + htab->elf.hgot->root.u.def.section->output_offset 4694 + htab->elf.hgot->root.u.def.value); 4695 4696 /* Install the initial PLT entry. */ 4697 bfd_put_32 (output_bfd, 4698 sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10), 4699 htab->elf.splt->contents); 4700 bfd_put_32 (output_bfd, 4701 sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff), 4702 htab->elf.splt->contents + 4); 4703 bfd_put_32 (output_bfd, 4704 sparc_vxworks_exec_plt0_entry[2], 4705 htab->elf.splt->contents + 8); 4706 bfd_put_32 (output_bfd, 4707 sparc_vxworks_exec_plt0_entry[3], 4708 htab->elf.splt->contents + 12); 4709 bfd_put_32 (output_bfd, 4710 sparc_vxworks_exec_plt0_entry[4], 4711 htab->elf.splt->contents + 16); 4712 4713 loc = htab->srelplt2->contents; 4714 4715 /* Add an unloaded relocation for the initial entry's "sethi". */ 4716 rela.r_offset = (htab->elf.splt->output_section->vma 4717 + htab->elf.splt->output_offset); 4718 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22); 4719 rela.r_addend = 8; 4720 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4721 loc += sizeof (Elf32_External_Rela); 4722 4723 /* Likewise the following "or". */ 4724 rela.r_offset += 4; 4725 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10); 4726 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4727 loc += sizeof (Elf32_External_Rela); 4728 4729 /* Fix up the remaining .rela.plt.unloaded relocations. They may have 4730 the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order 4731 in which symbols were output. */ 4732 while (loc < htab->srelplt2->contents + htab->srelplt2->size) 4733 { 4734 Elf_Internal_Rela rel; 4735 4736 /* The entry's initial "sethi" (against _G_O_T_). */ 4737 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 4738 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22); 4739 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 4740 loc += sizeof (Elf32_External_Rela); 4741 4742 /* The following "or" (also against _G_O_T_). */ 4743 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 4744 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10); 4745 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 4746 loc += sizeof (Elf32_External_Rela); 4747 4748 /* The .got.plt entry (against _P_L_T_). */ 4749 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 4750 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32); 4751 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 4752 loc += sizeof (Elf32_External_Rela); 4753 } 4754 } 4755 4756 /* Install the first PLT entry in a VxWorks shared object. */ 4757 4758 static void 4759 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info) 4760 { 4761 struct _bfd_sparc_elf_link_hash_table *htab; 4762 unsigned int i; 4763 4764 htab = _bfd_sparc_elf_hash_table (info); 4765 BFD_ASSERT (htab != NULL); 4766 4767 for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++) 4768 bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i], 4769 htab->elf.splt->contents + i * 4); 4770 } 4771 4772 /* Finish up local dynamic symbol handling. We set the contents of 4773 various dynamic sections here. */ 4774 4775 static bfd_boolean 4776 finish_local_dynamic_symbol (void **slot, void *inf) 4777 { 4778 struct elf_link_hash_entry *h 4779 = (struct elf_link_hash_entry *) *slot; 4780 struct bfd_link_info *info 4781 = (struct bfd_link_info *) inf; 4782 4783 return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info, 4784 h, NULL); 4785 } 4786 4787 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry 4788 here since undefined weak symbol may not be dynamic and may not be 4789 called for _bfd_sparc_elf_finish_dynamic_symbol. */ 4790 4791 static bfd_boolean 4792 pie_finish_undefweak_symbol (struct bfd_hash_entry *bh, 4793 void *inf) 4794 { 4795 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh; 4796 struct bfd_link_info *info = (struct bfd_link_info *) inf; 4797 4798 if (h->root.type != bfd_link_hash_undefweak 4799 || h->dynindx != -1) 4800 return TRUE; 4801 4802 return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info, 4803 h, NULL); 4804 } 4805 4806 bfd_boolean 4807 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 4808 { 4809 bfd *dynobj; 4810 asection *sdyn; 4811 struct _bfd_sparc_elf_link_hash_table *htab; 4812 4813 htab = _bfd_sparc_elf_hash_table (info); 4814 BFD_ASSERT (htab != NULL); 4815 dynobj = htab->elf.dynobj; 4816 4817 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 4818 4819 if (elf_hash_table (info)->dynamic_sections_created) 4820 { 4821 asection *splt; 4822 4823 splt = htab->elf.splt; 4824 BFD_ASSERT (splt != NULL && sdyn != NULL); 4825 4826 if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt)) 4827 return FALSE; 4828 4829 /* Initialize the contents of the .plt section. */ 4830 if (splt->size > 0) 4831 { 4832 if (htab->is_vxworks) 4833 { 4834 if (bfd_link_pic (info)) 4835 sparc_vxworks_finish_shared_plt (output_bfd, info); 4836 else 4837 sparc_vxworks_finish_exec_plt (output_bfd, info); 4838 } 4839 else 4840 { 4841 memset (splt->contents, 0, htab->plt_header_size); 4842 if (!ABI_64_P (output_bfd)) 4843 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, 4844 splt->contents + splt->size - 4); 4845 } 4846 } 4847 4848 if (elf_section_data (splt->output_section) != NULL) 4849 elf_section_data (splt->output_section)->this_hdr.sh_entsize 4850 = ((htab->is_vxworks || !ABI_64_P (output_bfd)) 4851 ? 0 : htab->plt_entry_size); 4852 } 4853 4854 /* Set the first entry in the global offset table to the address of 4855 the dynamic section. */ 4856 if (htab->elf.sgot && htab->elf.sgot->size > 0) 4857 { 4858 bfd_vma val = (sdyn ? 4859 sdyn->output_section->vma + sdyn->output_offset : 4860 0); 4861 4862 SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents); 4863 } 4864 4865 if (htab->elf.sgot) 4866 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4867 SPARC_ELF_WORD_BYTES (htab); 4868 4869 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */ 4870 htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info); 4871 4872 /* Fill PLT entries for undefined weak symbols in PIE. */ 4873 if (bfd_link_pie (info)) 4874 bfd_hash_traverse (&info->hash->table, 4875 pie_finish_undefweak_symbol, 4876 info); 4877 return TRUE; 4878 } 4879 4880 4881 /* Set the right machine number for a SPARC ELF file. */ 4882 4883 bfd_boolean 4884 _bfd_sparc_elf_object_p (bfd *abfd) 4885 { 4886 obj_attribute *attrs = elf_known_obj_attributes (abfd)[OBJ_ATTR_GNU]; 4887 obj_attribute *hwcaps = &attrs[Tag_GNU_Sparc_HWCAPS]; 4888 obj_attribute *hwcaps2 = &attrs[Tag_GNU_Sparc_HWCAPS2]; 4889 4890 unsigned int v9c_hwcaps_mask = ELF_SPARC_HWCAP_ASI_BLK_INIT; 4891 unsigned int v9d_hwcaps_mask = (ELF_SPARC_HWCAP_FMAF 4892 | ELF_SPARC_HWCAP_VIS3 4893 | ELF_SPARC_HWCAP_HPC); 4894 unsigned int v9e_hwcaps_mask = (ELF_SPARC_HWCAP_AES 4895 | ELF_SPARC_HWCAP_DES 4896 | ELF_SPARC_HWCAP_KASUMI 4897 | ELF_SPARC_HWCAP_CAMELLIA 4898 | ELF_SPARC_HWCAP_MD5 4899 | ELF_SPARC_HWCAP_SHA1 4900 | ELF_SPARC_HWCAP_SHA256 4901 | ELF_SPARC_HWCAP_SHA512 4902 | ELF_SPARC_HWCAP_MPMUL 4903 | ELF_SPARC_HWCAP_MONT 4904 | ELF_SPARC_HWCAP_CRC32C 4905 | ELF_SPARC_HWCAP_CBCOND 4906 | ELF_SPARC_HWCAP_PAUSE); 4907 unsigned int v9v_hwcaps_mask = (ELF_SPARC_HWCAP_FJFMAU 4908 | ELF_SPARC_HWCAP_IMA); 4909 unsigned int v9m_hwcaps2_mask = (ELF_SPARC_HWCAP2_SPARC5 4910 | ELF_SPARC_HWCAP2_MWAIT 4911 | ELF_SPARC_HWCAP2_XMPMUL 4912 | ELF_SPARC_HWCAP2_XMONT); 4913 unsigned int m8_hwcaps2_mask = (ELF_SPARC_HWCAP2_SPARC6 4914 | ELF_SPARC_HWCAP2_ONADDSUB 4915 | ELF_SPARC_HWCAP2_ONMUL 4916 | ELF_SPARC_HWCAP2_ONDIV 4917 | ELF_SPARC_HWCAP2_DICTUNP 4918 | ELF_SPARC_HWCAP2_FPCMPSHL 4919 | ELF_SPARC_HWCAP2_RLE 4920 | ELF_SPARC_HWCAP2_SHA3); 4921 4922 if (ABI_64_P (abfd)) 4923 { 4924 unsigned long mach = bfd_mach_sparc_v9; 4925 4926 if (hwcaps2->i & m8_hwcaps2_mask) 4927 mach = bfd_mach_sparc_v9m8; 4928 else if (hwcaps2->i & v9m_hwcaps2_mask) 4929 mach = bfd_mach_sparc_v9m; 4930 else if (hwcaps->i & v9v_hwcaps_mask) 4931 mach = bfd_mach_sparc_v9v; 4932 else if (hwcaps->i & v9e_hwcaps_mask) 4933 mach = bfd_mach_sparc_v9e; 4934 else if (hwcaps->i & v9d_hwcaps_mask) 4935 mach = bfd_mach_sparc_v9d; 4936 else if (hwcaps->i & v9c_hwcaps_mask) 4937 mach = bfd_mach_sparc_v9c; 4938 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3) 4939 mach = bfd_mach_sparc_v9b; 4940 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1) 4941 mach = bfd_mach_sparc_v9a; 4942 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach); 4943 } 4944 else 4945 { 4946 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS) 4947 { 4948 if (hwcaps2->i & m8_hwcaps2_mask) 4949 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4950 bfd_mach_sparc_v8plusm8); 4951 else if (hwcaps2->i & v9m_hwcaps2_mask) 4952 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4953 bfd_mach_sparc_v8plusm); 4954 else if (hwcaps->i & v9v_hwcaps_mask) 4955 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4956 bfd_mach_sparc_v8plusv); 4957 else if (hwcaps->i & v9e_hwcaps_mask) 4958 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4959 bfd_mach_sparc_v8pluse); 4960 else if (hwcaps->i & v9d_hwcaps_mask) 4961 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4962 bfd_mach_sparc_v8plusd); 4963 else if (hwcaps->i & v9c_hwcaps_mask) 4964 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4965 bfd_mach_sparc_v8plusc); 4966 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3) 4967 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4968 bfd_mach_sparc_v8plusb); 4969 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1) 4970 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4971 bfd_mach_sparc_v8plusa); 4972 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS) 4973 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4974 bfd_mach_sparc_v8plus); 4975 else 4976 return FALSE; 4977 } 4978 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA) 4979 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 4980 bfd_mach_sparc_sparclite_le); 4981 else 4982 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc); 4983 } 4984 } 4985 4986 /* Return address for Ith PLT stub in section PLT, for relocation REL 4987 or (bfd_vma) -1 if it should not be included. */ 4988 4989 bfd_vma 4990 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel) 4991 { 4992 if (ABI_64_P (plt->owner)) 4993 { 4994 bfd_vma j; 4995 4996 i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE; 4997 if (i < PLT64_LARGE_THRESHOLD) 4998 return plt->vma + i * PLT64_ENTRY_SIZE; 4999 5000 j = (i - PLT64_LARGE_THRESHOLD) % 160; 5001 i -= j; 5002 return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6; 5003 } 5004 else 5005 return rel->address; 5006 } 5007 5008 /* Merge backend specific data from an object file to the output 5009 object file when linking. */ 5010 5011 bfd_boolean 5012 _bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 5013 { 5014 bfd *obfd = info->output_bfd; 5015 obj_attribute *in_attr, *in_attrs; 5016 obj_attribute *out_attr, *out_attrs; 5017 5018 if (!elf_known_obj_attributes_proc (obfd)[0].i) 5019 { 5020 /* This is the first object. Copy the attributes. */ 5021 _bfd_elf_copy_obj_attributes (ibfd, obfd); 5022 5023 /* Use the Tag_null value to indicate the attributes have been 5024 initialized. */ 5025 elf_known_obj_attributes_proc (obfd)[0].i = 1; 5026 5027 return TRUE; 5028 } 5029 5030 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU]; 5031 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU]; 5032 5033 in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS]; 5034 out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS]; 5035 5036 out_attr->i |= in_attr->i; 5037 out_attr->type = 1; 5038 5039 in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS2]; 5040 out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS2]; 5041 5042 out_attr->i |= in_attr->i; 5043 out_attr->type = 1; 5044 5045 /* Merge Tag_compatibility attributes and any common GNU ones. */ 5046 _bfd_elf_merge_object_attributes (ibfd, info); 5047 5048 return TRUE; 5049 } 5050