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