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