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