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