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