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