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