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