elf32-sparc.c revision 107492
1/* SPARC-specific support for 32-bit ELF 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 3 Free Software Foundation, Inc. 4 5This file is part of BFD, the Binary File Descriptor library. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21#include "bfd.h" 22#include "sysdep.h" 23#include "bfdlink.h" 24#include "libbfd.h" 25#include "elf-bfd.h" 26#include "elf/sparc.h" 27#include "opcode/sparc.h" 28 29static reloc_howto_type *elf32_sparc_reloc_type_lookup 30 PARAMS ((bfd *, bfd_reloc_code_real_type)); 31static void elf32_sparc_info_to_howto 32 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 33static boolean elf32_sparc_check_relocs 34 PARAMS ((bfd *, struct bfd_link_info *, asection *, 35 const Elf_Internal_Rela *)); 36static boolean elf32_sparc_adjust_dynamic_symbol 37 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 38static boolean elf32_sparc_size_dynamic_sections 39 PARAMS ((bfd *, struct bfd_link_info *)); 40static boolean elf32_sparc_relax_section 41 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *)); 42static boolean elf32_sparc_relocate_section 43 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 44 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 45static boolean elf32_sparc_finish_dynamic_symbol 46 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 47 Elf_Internal_Sym *)); 48static boolean elf32_sparc_finish_dynamic_sections 49 PARAMS ((bfd *, struct bfd_link_info *)); 50static boolean elf32_sparc_merge_private_bfd_data PARAMS ((bfd *, bfd *)); 51static boolean elf32_sparc_object_p 52 PARAMS ((bfd *)); 53static void elf32_sparc_final_write_processing 54 PARAMS ((bfd *, boolean)); 55static enum elf_reloc_type_class elf32_sparc_reloc_type_class 56 PARAMS ((const Elf_Internal_Rela *)); 57static asection * elf32_sparc_gc_mark_hook 58 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *, 59 struct elf_link_hash_entry *, Elf_Internal_Sym *)); 60static boolean elf32_sparc_gc_sweep_hook 61 PARAMS ((bfd *, struct bfd_link_info *, asection *, 62 const Elf_Internal_Rela *)); 63 64/* The relocation "howto" table. */ 65 66static bfd_reloc_status_type sparc_elf_notsupported_reloc 67 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 68static bfd_reloc_status_type sparc_elf_wdisp16_reloc 69 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 70 71reloc_howto_type _bfd_sparc_elf_howto_table[] = 72{ 73 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 74 HOWTO(R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", false,0,0x000000ff,true), 75 HOWTO(R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", false,0,0x0000ffff,true), 76 HOWTO(R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", false,0,0xffffffff,true), 77 HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", false,0,0x000000ff,true), 78 HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", false,0,0x0000ffff,true), 79 HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", false,0,0xffffffff,true), 80 HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", false,0,0x3fffffff,true), 81 HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", false,0,0x003fffff,true), 82 HOWTO(R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", false,0,0x003fffff,true), 83 HOWTO(R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", false,0,0x003fffff,true), 84 HOWTO(R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", false,0,0x00001fff,true), 85 HOWTO(R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", false,0,0x000003ff,true), 86 HOWTO(R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", false,0,0x000003ff,true), 87 HOWTO(R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", false,0,0x00001fff,true), 88 HOWTO(R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", false,0,0x003fffff,true), 89 HOWTO(R_SPARC_PC10, 0,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", false,0,0x000003ff,true), 90 HOWTO(R_SPARC_PC22, 10,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", false,0,0x003fffff,true), 91 HOWTO(R_SPARC_WPLT30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", false,0,0x3fffffff,true), 92 HOWTO(R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", false,0,0x00000000,true), 93 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), 94 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), 95 HOWTO(R_SPARC_RELATIVE, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",false,0,0x00000000,true), 96 HOWTO(R_SPARC_UA32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", false,0,0xffffffff,true), 97 HOWTO(R_SPARC_PLT32, 0,0,00,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", false,0,0xffffffff,true), 98 HOWTO(R_SPARC_HIPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HIPLT22", false,0,0x00000000,true), 99 HOWTO(R_SPARC_LOPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LOPLT10", false,0,0x00000000,true), 100 HOWTO(R_SPARC_PCPLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT32", false,0,0x00000000,true), 101 HOWTO(R_SPARC_PCPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT22", false,0,0x00000000,true), 102 HOWTO(R_SPARC_PCPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT10", false,0,0x00000000,true), 103 HOWTO(R_SPARC_10, 0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", false,0,0x000003ff,true), 104 HOWTO(R_SPARC_11, 0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", false,0,0x000007ff,true), 105 /* These are for sparc64 in a 64 bit environment. 106 Values need to be here because the table is indexed by reloc number. */ 107 HOWTO(R_SPARC_64, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_64", false,0,0x00000000,true), 108 HOWTO(R_SPARC_OLO10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_OLO10", false,0,0x00000000,true), 109 HOWTO(R_SPARC_HH22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HH22", false,0,0x00000000,true), 110 HOWTO(R_SPARC_HM10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HM10", false,0,0x00000000,true), 111 HOWTO(R_SPARC_LM22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LM22", false,0,0x00000000,true), 112 HOWTO(R_SPARC_PC_HH22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_HH22", false,0,0x00000000,true), 113 HOWTO(R_SPARC_PC_HM10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_HM10", false,0,0x00000000,true), 114 HOWTO(R_SPARC_PC_LM22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_LM22", false,0,0x00000000,true), 115 /* End sparc64 in 64 bit environment values. 116 The following are for sparc64 in a 32 bit environment. */ 117 HOWTO(R_SPARC_WDISP16, 2,2,16,true, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true), 118 HOWTO(R_SPARC_WDISP19, 2,2,19,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true), 119 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), 120 HOWTO(R_SPARC_7, 0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", false,0,0x0000007f,true), 121 HOWTO(R_SPARC_5, 0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", false,0,0x0000001f,true), 122 HOWTO(R_SPARC_6, 0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", false,0,0x0000003f,true), 123 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 124 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 125 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 126 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 127 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 128 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 129 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 130 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), 131 HOWTO(R_SPARC_UA64, 0,0, 0,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_UA64", false,0,0x00000000,true), 132 HOWTO(R_SPARC_UA16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", false,0,0x0000ffff,true), 133 HOWTO(R_SPARC_REV32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", false,0,0xffffffff,true), 134}; 135static reloc_howto_type elf32_sparc_vtinherit_howto = 136 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,false,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", false,0, 0, false); 137static reloc_howto_type elf32_sparc_vtentry_howto = 138 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); 139 140struct elf_reloc_map { 141 bfd_reloc_code_real_type bfd_reloc_val; 142 unsigned char elf_reloc_val; 143}; 144 145static const struct elf_reloc_map sparc_reloc_map[] = 146{ 147 { BFD_RELOC_NONE, R_SPARC_NONE, }, 148 { BFD_RELOC_16, R_SPARC_16, }, 149 { BFD_RELOC_16_PCREL, R_SPARC_DISP16 }, 150 { BFD_RELOC_8, R_SPARC_8 }, 151 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 }, 152 { BFD_RELOC_CTOR, R_SPARC_32 }, 153 { BFD_RELOC_32, R_SPARC_32 }, 154 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 }, 155 { BFD_RELOC_HI22, R_SPARC_HI22 }, 156 { BFD_RELOC_LO10, R_SPARC_LO10, }, 157 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 }, 158 { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 }, 159 { BFD_RELOC_SPARC22, R_SPARC_22 }, 160 { BFD_RELOC_SPARC13, R_SPARC_13 }, 161 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 }, 162 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 }, 163 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 }, 164 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 }, 165 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 }, 166 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 }, 167 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY }, 168 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT }, 169 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT }, 170 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE }, 171 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 }, 172 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 }, 173 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, 174 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 }, 175 { BFD_RELOC_SPARC_10, R_SPARC_10 }, 176 { BFD_RELOC_SPARC_11, R_SPARC_11 }, 177 { BFD_RELOC_SPARC_64, R_SPARC_64 }, 178 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 }, 179 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 }, 180 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 }, 181 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 }, 182 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 }, 183 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 }, 184 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 }, 185 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 }, 186 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 }, 187 { BFD_RELOC_SPARC_7, R_SPARC_7 }, 188 { BFD_RELOC_SPARC_5, R_SPARC_5 }, 189 { BFD_RELOC_SPARC_6, R_SPARC_6 }, 190 { BFD_RELOC_SPARC_REV32, R_SPARC_REV32 }, 191 { BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT }, 192 { BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY }, 193}; 194 195static reloc_howto_type * 196elf32_sparc_reloc_type_lookup (abfd, code) 197 bfd *abfd ATTRIBUTE_UNUSED; 198 bfd_reloc_code_real_type code; 199{ 200 unsigned int i; 201 202 switch (code) 203 { 204 case BFD_RELOC_VTABLE_INHERIT: 205 return &elf32_sparc_vtinherit_howto; 206 207 case BFD_RELOC_VTABLE_ENTRY: 208 return &elf32_sparc_vtentry_howto; 209 210 default: 211 for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++) 212 { 213 if (sparc_reloc_map[i].bfd_reloc_val == code) 214 return &_bfd_sparc_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val]; 215 } 216 } 217 bfd_set_error (bfd_error_bad_value); 218 return NULL; 219} 220 221/* We need to use ELF32_R_TYPE so we have our own copy of this function, 222 and elf64-sparc.c has its own copy. */ 223 224static void 225elf32_sparc_info_to_howto (abfd, cache_ptr, dst) 226 bfd *abfd ATTRIBUTE_UNUSED; 227 arelent *cache_ptr; 228 Elf_Internal_Rela *dst; 229{ 230 switch (ELF32_R_TYPE(dst->r_info)) 231 { 232 case R_SPARC_GNU_VTINHERIT: 233 cache_ptr->howto = &elf32_sparc_vtinherit_howto; 234 break; 235 236 case R_SPARC_GNU_VTENTRY: 237 cache_ptr->howto = &elf32_sparc_vtentry_howto; 238 break; 239 240 default: 241 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std); 242 cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)]; 243 } 244} 245 246/* For unsupported relocs. */ 247 248static bfd_reloc_status_type 249sparc_elf_notsupported_reloc (abfd, 250 reloc_entry, 251 symbol, 252 data, 253 input_section, 254 output_bfd, 255 error_message) 256 bfd *abfd ATTRIBUTE_UNUSED; 257 arelent *reloc_entry ATTRIBUTE_UNUSED; 258 asymbol *symbol ATTRIBUTE_UNUSED; 259 PTR data ATTRIBUTE_UNUSED; 260 asection *input_section ATTRIBUTE_UNUSED; 261 bfd *output_bfd ATTRIBUTE_UNUSED; 262 char **error_message ATTRIBUTE_UNUSED; 263{ 264 return bfd_reloc_notsupported; 265} 266 267/* Handle the WDISP16 reloc. */ 268 269static bfd_reloc_status_type 270sparc_elf_wdisp16_reloc (abfd, 271 reloc_entry, 272 symbol, 273 data, 274 input_section, 275 output_bfd, 276 error_message) 277 bfd *abfd; 278 arelent *reloc_entry; 279 asymbol *symbol; 280 PTR data; 281 asection *input_section; 282 bfd *output_bfd; 283 char **error_message ATTRIBUTE_UNUSED; 284{ 285 bfd_vma relocation; 286 bfd_vma x; 287 288 if (output_bfd != (bfd *) NULL 289 && (symbol->flags & BSF_SECTION_SYM) == 0 290 && (! reloc_entry->howto->partial_inplace 291 || reloc_entry->addend == 0)) 292 { 293 reloc_entry->address += input_section->output_offset; 294 return bfd_reloc_ok; 295 } 296 297 if (output_bfd != NULL) 298 return bfd_reloc_continue; 299 300 if (reloc_entry->address > input_section->_cooked_size) 301 return bfd_reloc_outofrange; 302 303 relocation = (symbol->value 304 + symbol->section->output_section->vma 305 + symbol->section->output_offset); 306 relocation += reloc_entry->addend; 307 relocation -= (input_section->output_section->vma 308 + input_section->output_offset); 309 relocation -= reloc_entry->address; 310 311 x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 312 x |= ((((relocation >> 2) & 0xc000) << 6) 313 | ((relocation >> 2) & 0x3fff)); 314 bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address); 315 316 if ((bfd_signed_vma) relocation < - 0x40000 317 || (bfd_signed_vma) relocation > 0x3ffff) 318 return bfd_reloc_overflow; 319 else 320 return bfd_reloc_ok; 321} 322 323/* Functions for the SPARC ELF linker. */ 324 325/* The name of the dynamic interpreter. This is put in the .interp 326 section. */ 327 328#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 329 330/* The nop opcode we use. */ 331 332#define SPARC_NOP 0x01000000 333 334/* The size in bytes of an entry in the procedure linkage table. */ 335 336#define PLT_ENTRY_SIZE 12 337 338/* The first four entries in a procedure linkage table are reserved, 339 and the initial contents are unimportant (we zero them out). 340 Subsequent entries look like this. See the SVR4 ABI SPARC 341 supplement to see how this works. */ 342 343/* sethi %hi(.-.plt0),%g1. We fill in the address later. */ 344#define PLT_ENTRY_WORD0 0x03000000 345/* b,a .plt0. We fill in the offset later. */ 346#define PLT_ENTRY_WORD1 0x30800000 347/* nop. */ 348#define PLT_ENTRY_WORD2 SPARC_NOP 349 350/* Look through the relocs for a section during the first phase, and 351 allocate space in the global offset table or procedure linkage 352 table. */ 353 354static boolean 355elf32_sparc_check_relocs (abfd, info, sec, relocs) 356 bfd *abfd; 357 struct bfd_link_info *info; 358 asection *sec; 359 const Elf_Internal_Rela *relocs; 360{ 361 bfd *dynobj; 362 Elf_Internal_Shdr *symtab_hdr; 363 struct elf_link_hash_entry **sym_hashes; 364 bfd_vma *local_got_offsets; 365 const Elf_Internal_Rela *rel; 366 const Elf_Internal_Rela *rel_end; 367 asection *sgot; 368 asection *srelgot; 369 asection *sreloc; 370 371 if (info->relocateable) 372 return true; 373 374 dynobj = elf_hash_table (info)->dynobj; 375 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 376 sym_hashes = elf_sym_hashes (abfd); 377 local_got_offsets = elf_local_got_offsets (abfd); 378 379 sgot = NULL; 380 srelgot = NULL; 381 sreloc = NULL; 382 383 rel_end = relocs + sec->reloc_count; 384 for (rel = relocs; rel < rel_end; rel++) 385 { 386 unsigned long r_symndx; 387 struct elf_link_hash_entry *h; 388 389 r_symndx = ELF32_R_SYM (rel->r_info); 390 if (r_symndx < symtab_hdr->sh_info) 391 h = NULL; 392 else 393 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 394 395 switch (ELF32_R_TYPE (rel->r_info)) 396 { 397 case R_SPARC_GOT10: 398 case R_SPARC_GOT13: 399 case R_SPARC_GOT22: 400 /* This symbol requires a global offset table entry. */ 401 402 if (dynobj == NULL) 403 { 404 /* Create the .got section. */ 405 elf_hash_table (info)->dynobj = dynobj = abfd; 406 if (! _bfd_elf_create_got_section (dynobj, info)) 407 return false; 408 } 409 410 if (sgot == NULL) 411 { 412 sgot = bfd_get_section_by_name (dynobj, ".got"); 413 BFD_ASSERT (sgot != NULL); 414 } 415 416 if (srelgot == NULL 417 && (h != NULL || info->shared)) 418 { 419 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 420 if (srelgot == NULL) 421 { 422 srelgot = bfd_make_section (dynobj, ".rela.got"); 423 if (srelgot == NULL 424 || ! bfd_set_section_flags (dynobj, srelgot, 425 (SEC_ALLOC 426 | SEC_LOAD 427 | SEC_HAS_CONTENTS 428 | SEC_IN_MEMORY 429 | SEC_LINKER_CREATED 430 | SEC_READONLY)) 431 || ! bfd_set_section_alignment (dynobj, srelgot, 2)) 432 return false; 433 } 434 } 435 436 if (h != NULL) 437 { 438 if (h->got.offset != (bfd_vma) -1) 439 { 440 /* We have already allocated space in the .got. */ 441 break; 442 } 443 h->got.offset = sgot->_raw_size; 444 445 /* Make sure this symbol is output as a dynamic symbol. */ 446 if (h->dynindx == -1) 447 { 448 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 449 return false; 450 } 451 452 srelgot->_raw_size += sizeof (Elf32_External_Rela); 453 } 454 else 455 { 456 /* This is a global offset table entry for a local 457 symbol. */ 458 if (local_got_offsets == NULL) 459 { 460 bfd_size_type size; 461 register unsigned int i; 462 463 size = symtab_hdr->sh_info; 464 size *= sizeof (bfd_vma); 465 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size); 466 if (local_got_offsets == NULL) 467 return false; 468 elf_local_got_offsets (abfd) = local_got_offsets; 469 for (i = 0; i < symtab_hdr->sh_info; i++) 470 local_got_offsets[i] = (bfd_vma) -1; 471 } 472 if (local_got_offsets[r_symndx] != (bfd_vma) -1) 473 { 474 /* We have already allocated space in the .got. */ 475 break; 476 } 477 local_got_offsets[r_symndx] = sgot->_raw_size; 478 479 if (info->shared) 480 { 481 /* If we are generating a shared object, we need to 482 output a R_SPARC_RELATIVE reloc so that the 483 dynamic linker can adjust this GOT entry. */ 484 srelgot->_raw_size += sizeof (Elf32_External_Rela); 485 } 486 } 487 488 sgot->_raw_size += 4; 489 490 /* If the .got section is more than 0x1000 bytes, we add 491 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13 492 bit relocations have a greater chance of working. */ 493 if (sgot->_raw_size >= 0x1000 494 && elf_hash_table (info)->hgot->root.u.def.value == 0) 495 elf_hash_table (info)->hgot->root.u.def.value = 0x1000; 496 497 break; 498 499 case R_SPARC_PLT32: 500 case R_SPARC_WPLT30: 501 /* This symbol requires a procedure linkage table entry. We 502 actually build the entry in adjust_dynamic_symbol, 503 because this might be a case of linking PIC code without 504 linking in any dynamic objects, in which case we don't 505 need to generate a procedure linkage table after all. */ 506 507 if (h == NULL) 508 { 509 /* The Solaris native assembler will generate a WPLT30 510 reloc for a local symbol if you assemble a call from 511 one section to another when using -K pic. We treat 512 it as WDISP30. */ 513 if (ELF32_R_TYPE (rel->r_info) != R_SPARC_WPLT30) 514 goto r_sparc_plt32; 515 break; 516 } 517 518 /* Make sure this symbol is output as a dynamic symbol. */ 519 if (h->dynindx == -1) 520 { 521 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 522 return false; 523 } 524 525 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 526 527 if (ELF32_R_TYPE (rel->r_info) != R_SPARC_WPLT30) 528 goto r_sparc_plt32; 529 break; 530 531 case R_SPARC_PC10: 532 case R_SPARC_PC22: 533 if (h != NULL) 534 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF; 535 536 if (h != NULL 537 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 538 break; 539 /* Fall through. */ 540 case R_SPARC_DISP8: 541 case R_SPARC_DISP16: 542 case R_SPARC_DISP32: 543 case R_SPARC_WDISP30: 544 case R_SPARC_WDISP22: 545 case R_SPARC_WDISP19: 546 case R_SPARC_WDISP16: 547 if (h != NULL) 548 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF; 549 550 /* If we are linking with -Bsymbolic, we do not need to copy 551 a PC relative reloc against a global symbol which is 552 defined in an object we are including in the link (i.e., 553 DEF_REGULAR is set). FIXME: At this point we have not 554 seen all the input files, so it is possible that 555 DEF_REGULAR is not set now but will be set later (it is 556 never cleared). This needs to be handled as in 557 elf32-i386.c. */ 558 if (h == NULL 559 || (info->symbolic 560 && (h->elf_link_hash_flags 561 & ELF_LINK_HASH_DEF_REGULAR) != 0)) 562 break; 563 /* Fall through. */ 564 case R_SPARC_8: 565 case R_SPARC_16: 566 case R_SPARC_32: 567 case R_SPARC_HI22: 568 case R_SPARC_22: 569 case R_SPARC_13: 570 case R_SPARC_LO10: 571 case R_SPARC_UA16: 572 case R_SPARC_UA32: 573 if (h != NULL) 574 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF; 575 576 r_sparc_plt32: 577 if (info->shared && (sec->flags & SEC_ALLOC)) 578 { 579 /* When creating a shared object, we must copy these 580 relocs into the output file. We create a reloc 581 section in dynobj and make room for the reloc. */ 582 if (sreloc == NULL) 583 { 584 const char *name; 585 586 name = (bfd_elf_string_from_elf_section 587 (abfd, 588 elf_elfheader (abfd)->e_shstrndx, 589 elf_section_data (sec)->rel_hdr.sh_name)); 590 if (name == NULL) 591 return false; 592 593 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 594 && strcmp (bfd_get_section_name (abfd, sec), 595 name + 5) == 0); 596 597 sreloc = bfd_get_section_by_name (dynobj, name); 598 if (sreloc == NULL) 599 { 600 flagword flags; 601 602 sreloc = bfd_make_section (dynobj, name); 603 flags = (SEC_HAS_CONTENTS | SEC_READONLY 604 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 605 if ((sec->flags & SEC_ALLOC) != 0) 606 flags |= SEC_ALLOC | SEC_LOAD; 607 if (sreloc == NULL 608 || ! bfd_set_section_flags (dynobj, sreloc, flags) 609 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 610 return false; 611 } 612 if (sec->flags & SEC_READONLY) 613 info->flags |= DF_TEXTREL; 614 } 615 616 sreloc->_raw_size += sizeof (Elf32_External_Rela); 617 } 618 619 break; 620 621 case R_SPARC_GNU_VTINHERIT: 622 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 623 return false; 624 break; 625 626 case R_SPARC_GNU_VTENTRY: 627 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 628 return false; 629 break; 630 631 default: 632 break; 633 } 634 } 635 636 return true; 637} 638 639static asection * 640elf32_sparc_gc_mark_hook (sec, info, rel, h, sym) 641 asection *sec; 642 struct bfd_link_info *info ATTRIBUTE_UNUSED; 643 Elf_Internal_Rela *rel; 644 struct elf_link_hash_entry *h; 645 Elf_Internal_Sym *sym; 646{ 647 if (h != NULL) 648 { 649 switch (ELF32_R_TYPE (rel->r_info)) 650 { 651 case R_SPARC_GNU_VTINHERIT: 652 case R_SPARC_GNU_VTENTRY: 653 break; 654 655 default: 656 switch (h->root.type) 657 { 658 case bfd_link_hash_defined: 659 case bfd_link_hash_defweak: 660 return h->root.u.def.section; 661 662 case bfd_link_hash_common: 663 return h->root.u.c.p->section; 664 665 default: 666 break; 667 } 668 } 669 } 670 else 671 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 672 673 return NULL; 674} 675 676/* Update the got entry reference counts for the section being removed. */ 677static boolean 678elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs) 679 bfd *abfd; 680 struct bfd_link_info *info ATTRIBUTE_UNUSED; 681 asection *sec; 682 const Elf_Internal_Rela *relocs; 683{ 684 685 Elf_Internal_Shdr *symtab_hdr; 686 struct elf_link_hash_entry **sym_hashes; 687 bfd_signed_vma *local_got_refcounts; 688 const Elf_Internal_Rela *rel, *relend; 689 unsigned long r_symndx; 690 struct elf_link_hash_entry *h; 691 692 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 693 sym_hashes = elf_sym_hashes (abfd); 694 local_got_refcounts = elf_local_got_refcounts (abfd); 695 696 relend = relocs + sec->reloc_count; 697 for (rel = relocs; rel < relend; rel++) 698 switch (ELF32_R_TYPE (rel->r_info)) 699 { 700 case R_SPARC_GOT10: 701 case R_SPARC_GOT13: 702 case R_SPARC_GOT22: 703 r_symndx = ELF32_R_SYM (rel->r_info); 704 if (r_symndx >= symtab_hdr->sh_info) 705 { 706 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 707 if (h->got.refcount > 0) 708 h->got.refcount--; 709 } 710 else 711 { 712 if (local_got_refcounts[r_symndx] > 0) 713 local_got_refcounts[r_symndx]--; 714 } 715 break; 716 717 case R_SPARC_PLT32: 718 case R_SPARC_HIPLT22: 719 case R_SPARC_LOPLT10: 720 case R_SPARC_PCPLT32: 721 case R_SPARC_PCPLT10: 722 r_symndx = ELF32_R_SYM (rel->r_info); 723 if (r_symndx >= symtab_hdr->sh_info) 724 { 725 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 726 if (h->plt.refcount > 0) 727 h->plt.refcount--; 728 } 729 break; 730 731 default: 732 break; 733 } 734 735 return true; 736} 737 738/* Adjust a symbol defined by a dynamic object and referenced by a 739 regular object. The current definition is in some section of the 740 dynamic object, but we're not including those sections. We have to 741 change the definition to something the rest of the link can 742 understand. */ 743 744static boolean 745elf32_sparc_adjust_dynamic_symbol (info, h) 746 struct bfd_link_info *info; 747 struct elf_link_hash_entry *h; 748{ 749 bfd *dynobj; 750 asection *s; 751 unsigned int power_of_two; 752 753 dynobj = elf_hash_table (info)->dynobj; 754 755 /* Make sure we know what is going on here. */ 756 BFD_ASSERT (dynobj != NULL 757 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) 758 || h->weakdef != NULL 759 || ((h->elf_link_hash_flags 760 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 761 && (h->elf_link_hash_flags 762 & ELF_LINK_HASH_REF_REGULAR) != 0 763 && (h->elf_link_hash_flags 764 & ELF_LINK_HASH_DEF_REGULAR) == 0))); 765 766 /* If this is a function, put it in the procedure linkage table. We 767 will fill in the contents of the procedure linkage table later 768 (although we could actually do it here). The STT_NOTYPE 769 condition is a hack specifically for the Oracle libraries 770 delivered for Solaris; for some inexplicable reason, they define 771 some of their functions as STT_NOTYPE when they really should be 772 STT_FUNC. */ 773 if (h->type == STT_FUNC 774 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0 775 || (h->type == STT_NOTYPE 776 && (h->root.type == bfd_link_hash_defined 777 || h->root.type == bfd_link_hash_defweak) 778 && (h->root.u.def.section->flags & SEC_CODE) != 0)) 779 { 780 if (! elf_hash_table (info)->dynamic_sections_created 781 || ((!info->shared || info->symbolic || h->dynindx == -1) 782 && (h->elf_link_hash_flags 783 & ELF_LINK_HASH_DEF_REGULAR) != 0)) 784 { 785 /* This case can occur if we saw a WPLT30 reloc in an input 786 file, but none of the input files were dynamic objects. 787 Or, when linking the main application or a -Bsymbolic 788 shared library against PIC code. Or when a global symbol 789 has been made private, e.g. via versioning. 790 791 In these cases we know what value the symbol will resolve 792 to, so we don't actually need to build a procedure linkage 793 table, and we can just do a WDISP30 reloc instead. */ 794 795 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 796 return true; 797 } 798 799 s = bfd_get_section_by_name (dynobj, ".plt"); 800 BFD_ASSERT (s != NULL); 801 802 /* The first four entries in .plt are reserved. */ 803 if (s->_raw_size == 0) 804 s->_raw_size = 4 * PLT_ENTRY_SIZE; 805 806 /* The procedure linkage table has a maximum size. */ 807 if (s->_raw_size >= 0x400000) 808 { 809 bfd_set_error (bfd_error_bad_value); 810 return false; 811 } 812 813 /* If this symbol is not defined in a regular file, and we are 814 not generating a shared library, then set the symbol to this 815 location in the .plt. This is required to make function 816 pointers compare as equal between the normal executable and 817 the shared library. */ 818 if (! info->shared 819 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 820 { 821 h->root.u.def.section = s; 822 h->root.u.def.value = s->_raw_size; 823 } 824 825 h->plt.offset = s->_raw_size; 826 827 /* Make room for this entry. */ 828 s->_raw_size += PLT_ENTRY_SIZE; 829 830 /* We also need to make an entry in the .rela.plt section. */ 831 832 s = bfd_get_section_by_name (dynobj, ".rela.plt"); 833 BFD_ASSERT (s != NULL); 834 s->_raw_size += sizeof (Elf32_External_Rela); 835 836 return true; 837 } 838 839 /* If this is a weak symbol, and there is a real definition, the 840 processor independent code will have arranged for us to see the 841 real definition first, and we can just use the same value. */ 842 if (h->weakdef != NULL) 843 { 844 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 845 || h->weakdef->root.type == bfd_link_hash_defweak); 846 h->root.u.def.section = h->weakdef->root.u.def.section; 847 h->root.u.def.value = h->weakdef->root.u.def.value; 848 return true; 849 } 850 851 /* This is a reference to a symbol defined by a dynamic object which 852 is not a function. */ 853 854 /* If we are creating a shared library, we must presume that the 855 only references to the symbol are via the global offset table. 856 For such cases we need not do anything here; the relocations will 857 be handled correctly by relocate_section. */ 858 if (info->shared) 859 return true; 860 861 /* If there are no references to this symbol that do not use the 862 GOT, we don't need to generate a copy reloc. */ 863 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0) 864 return true; 865 866 /* We must allocate the symbol in our .dynbss section, which will 867 become part of the .bss section of the executable. There will be 868 an entry for this symbol in the .dynsym section. The dynamic 869 object will contain position independent code, so all references 870 from the dynamic object to this symbol will go through the global 871 offset table. The dynamic linker will use the .dynsym entry to 872 determine the address it must put in the global offset table, so 873 both the dynamic object and the regular object will refer to the 874 same memory location for the variable. */ 875 876 s = bfd_get_section_by_name (dynobj, ".dynbss"); 877 BFD_ASSERT (s != NULL); 878 879 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker 880 to copy the initial value out of the dynamic object and into the 881 runtime process image. We need to remember the offset into the 882 .rel.bss section we are going to use. */ 883 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 884 { 885 asection *srel; 886 887 srel = bfd_get_section_by_name (dynobj, ".rela.bss"); 888 BFD_ASSERT (srel != NULL); 889 srel->_raw_size += sizeof (Elf32_External_Rela); 890 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 891 } 892 893 /* We need to figure out the alignment required for this symbol. I 894 have no idea how ELF linkers handle this. */ 895 power_of_two = bfd_log2 (h->size); 896 if (power_of_two > 3) 897 power_of_two = 3; 898 899 /* Apply the required alignment. */ 900 s->_raw_size = BFD_ALIGN (s->_raw_size, 901 (bfd_size_type) (1 << power_of_two)); 902 if (power_of_two > bfd_get_section_alignment (dynobj, s)) 903 { 904 if (! bfd_set_section_alignment (dynobj, s, power_of_two)) 905 return false; 906 } 907 908 /* Define the symbol as being at this point in the section. */ 909 h->root.u.def.section = s; 910 h->root.u.def.value = s->_raw_size; 911 912 /* Increment the section size to make room for the symbol. */ 913 s->_raw_size += h->size; 914 915 return true; 916} 917 918/* Set the sizes of the dynamic sections. */ 919 920static boolean 921elf32_sparc_size_dynamic_sections (output_bfd, info) 922 bfd *output_bfd ATTRIBUTE_UNUSED; 923 struct bfd_link_info *info; 924{ 925 bfd *dynobj; 926 asection *s; 927 boolean relplt; 928 929 dynobj = elf_hash_table (info)->dynobj; 930 BFD_ASSERT (dynobj != NULL); 931 932 if (elf_hash_table (info)->dynamic_sections_created) 933 { 934 /* Set the contents of the .interp section to the interpreter. */ 935 if (! info->shared) 936 { 937 s = bfd_get_section_by_name (dynobj, ".interp"); 938 BFD_ASSERT (s != NULL); 939 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 940 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 941 } 942 943 /* Make space for the trailing nop in .plt. */ 944 s = bfd_get_section_by_name (dynobj, ".plt"); 945 BFD_ASSERT (s != NULL); 946 if (s->_raw_size > 0) 947 s->_raw_size += 4; 948 } 949 else 950 { 951 /* We may have created entries in the .rela.got section. 952 However, if we are not creating the dynamic sections, we will 953 not actually use these entries. Reset the size of .rela.got, 954 which will cause it to get stripped from the output file 955 below. */ 956 s = bfd_get_section_by_name (dynobj, ".rela.got"); 957 if (s != NULL) 958 s->_raw_size = 0; 959 } 960 961 /* The check_relocs and adjust_dynamic_symbol entry points have 962 determined the sizes of the various dynamic sections. Allocate 963 memory for them. */ 964 relplt = false; 965 for (s = dynobj->sections; s != NULL; s = s->next) 966 { 967 const char *name; 968 boolean strip; 969 970 if ((s->flags & SEC_LINKER_CREATED) == 0) 971 continue; 972 973 /* It's OK to base decisions on the section name, because none 974 of the dynobj section names depend upon the input files. */ 975 name = bfd_get_section_name (dynobj, s); 976 977 strip = false; 978 979 if (strncmp (name, ".rela", 5) == 0) 980 { 981 if (s->_raw_size == 0) 982 { 983 /* If we don't need this section, strip it from the 984 output file. This is to handle .rela.bss and 985 .rel.plt. We must create it in 986 create_dynamic_sections, because it must be created 987 before the linker maps input sections to output 988 sections. The linker does that before 989 adjust_dynamic_symbol is called, and it is that 990 function which decides whether anything needs to go 991 into these sections. */ 992 strip = true; 993 } 994 else 995 { 996 if (strcmp (name, ".rela.plt") == 0) 997 relplt = true; 998 999 /* We use the reloc_count field as a counter if we need 1000 to copy relocs into the output file. */ 1001 s->reloc_count = 0; 1002 } 1003 } 1004 else if (strcmp (name, ".plt") != 0 1005 && strcmp (name, ".got") != 0) 1006 { 1007 /* It's not one of our sections, so don't allocate space. */ 1008 continue; 1009 } 1010 1011 if (strip) 1012 { 1013 _bfd_strip_section_from_output (info, s); 1014 continue; 1015 } 1016 1017 /* Allocate memory for the section contents. */ 1018 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc. 1019 Unused entries should be reclaimed before the section's contents 1020 are written out, but at the moment this does not happen. Thus in 1021 order to prevent writing out garbage, we initialise the section's 1022 contents to zero. */ 1023 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 1024 if (s->contents == NULL && s->_raw_size != 0) 1025 return false; 1026 } 1027 1028 if (elf_hash_table (info)->dynamic_sections_created) 1029 { 1030 /* Add some entries to the .dynamic section. We fill in the 1031 values later, in elf32_sparc_finish_dynamic_sections, but we 1032 must add the entries now so that we get the correct size for 1033 the .dynamic section. The DT_DEBUG entry is filled in by the 1034 dynamic linker and used by the debugger. */ 1035#define add_dynamic_entry(TAG, VAL) \ 1036 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL)) 1037 1038 if (!info->shared) 1039 { 1040 if (!add_dynamic_entry (DT_DEBUG, 0)) 1041 return false; 1042 } 1043 1044 if (relplt) 1045 { 1046 if (!add_dynamic_entry (DT_PLTGOT, 0) 1047 || !add_dynamic_entry (DT_PLTRELSZ, 0) 1048 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 1049 || !add_dynamic_entry (DT_JMPREL, 0)) 1050 return false; 1051 } 1052 1053 if (!add_dynamic_entry (DT_RELA, 0) 1054 || !add_dynamic_entry (DT_RELASZ, 0) 1055 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 1056 return false; 1057 1058 if (info->flags & DF_TEXTREL) 1059 { 1060 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1061 return false; 1062 } 1063 } 1064#undef add_dynamic_entry 1065 1066 return true; 1067} 1068 1069#define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0) 1070#define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1) 1071 1072static boolean 1073elf32_sparc_relax_section (abfd, section, link_info, again) 1074 bfd *abfd ATTRIBUTE_UNUSED; 1075 asection *section ATTRIBUTE_UNUSED; 1076 struct bfd_link_info *link_info ATTRIBUTE_UNUSED; 1077 boolean *again; 1078{ 1079 *again = false; 1080 SET_SEC_DO_RELAX (section); 1081 return true; 1082} 1083 1084/* This is the condition under which finish_dynamic_symbol will be called 1085 from elflink.h. If elflink.h doesn't call our finish_dynamic_symbol 1086 routine, we'll need to do something about initializing any .plt and .got 1087 entries in relocate_section. */ 1088#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \ 1089 ((DYN) \ 1090 && ((INFO)->shared \ 1091 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \ 1092 && ((H)->dynindx != -1 \ 1093 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)) 1094 1095/* Relocate a SPARC ELF section. */ 1096 1097static boolean 1098elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, 1099 contents, relocs, local_syms, local_sections) 1100 bfd *output_bfd; 1101 struct bfd_link_info *info; 1102 bfd *input_bfd; 1103 asection *input_section; 1104 bfd_byte *contents; 1105 Elf_Internal_Rela *relocs; 1106 Elf_Internal_Sym *local_syms; 1107 asection **local_sections; 1108{ 1109 bfd *dynobj; 1110 Elf_Internal_Shdr *symtab_hdr; 1111 struct elf_link_hash_entry **sym_hashes; 1112 bfd_vma *local_got_offsets; 1113 bfd_vma got_base; 1114 asection *sgot; 1115 asection *splt; 1116 asection *sreloc; 1117 Elf_Internal_Rela *rel; 1118 Elf_Internal_Rela *relend; 1119 1120 dynobj = elf_hash_table (info)->dynobj; 1121 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1122 sym_hashes = elf_sym_hashes (input_bfd); 1123 local_got_offsets = elf_local_got_offsets (input_bfd); 1124 1125 if (elf_hash_table (info)->hgot == NULL) 1126 got_base = 0; 1127 else 1128 got_base = elf_hash_table (info)->hgot->root.u.def.value; 1129 1130 sgot = NULL; 1131 splt = NULL; 1132 sreloc = NULL; 1133 1134 rel = relocs; 1135 relend = relocs + input_section->reloc_count; 1136 for (; rel < relend; rel++) 1137 { 1138 int r_type; 1139 reloc_howto_type *howto; 1140 unsigned long r_symndx; 1141 struct elf_link_hash_entry *h; 1142 Elf_Internal_Sym *sym; 1143 asection *sec; 1144 bfd_vma relocation, off; 1145 bfd_reloc_status_type r; 1146 boolean is_plt = false; 1147 boolean unresolved_reloc; 1148 1149 r_type = ELF32_R_TYPE (rel->r_info); 1150 1151 if (r_type == R_SPARC_GNU_VTINHERIT 1152 || r_type == R_SPARC_GNU_VTENTRY) 1153 continue; 1154 1155 if (r_type < 0 || r_type >= (int) R_SPARC_max_std) 1156 { 1157 bfd_set_error (bfd_error_bad_value); 1158 return false; 1159 } 1160 howto = _bfd_sparc_elf_howto_table + r_type; 1161 1162 r_symndx = ELF32_R_SYM (rel->r_info); 1163 1164 if (info->relocateable) 1165 { 1166 /* This is a relocateable link. We don't have to change 1167 anything, unless the reloc is against a section symbol, 1168 in which case we have to adjust according to where the 1169 section symbol winds up in the output section. */ 1170 if (r_symndx < symtab_hdr->sh_info) 1171 { 1172 sym = local_syms + r_symndx; 1173 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1174 { 1175 sec = local_sections[r_symndx]; 1176 rel->r_addend += sec->output_offset + sym->st_value; 1177 } 1178 } 1179 1180 continue; 1181 } 1182 1183 /* This is a final link. */ 1184 h = NULL; 1185 sym = NULL; 1186 sec = NULL; 1187 unresolved_reloc = false; 1188 if (r_symndx < symtab_hdr->sh_info) 1189 { 1190 sym = local_syms + r_symndx; 1191 sec = local_sections[r_symndx]; 1192 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel); 1193 } 1194 else 1195 { 1196 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1197 while (h->root.type == bfd_link_hash_indirect 1198 || h->root.type == bfd_link_hash_warning) 1199 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1200 1201 relocation = 0; 1202 if (h->root.type == bfd_link_hash_defined 1203 || h->root.type == bfd_link_hash_defweak) 1204 { 1205 sec = h->root.u.def.section; 1206 if (sec->output_section == NULL) 1207 /* Set a flag that will be cleared later if we find a 1208 relocation value for this symbol. output_section 1209 is typically NULL for symbols satisfied by a shared 1210 library. */ 1211 unresolved_reloc = true; 1212 else 1213 relocation = (h->root.u.def.value 1214 + sec->output_section->vma 1215 + sec->output_offset); 1216 } 1217 else if (h->root.type == bfd_link_hash_undefweak) 1218 ; 1219 else if (info->shared 1220 && (!info->symbolic || info->allow_shlib_undefined) 1221 && !info->no_undefined 1222 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 1223 ; 1224 else 1225 { 1226 if (! ((*info->callbacks->undefined_symbol) 1227 (info, h->root.root.string, input_bfd, 1228 input_section, rel->r_offset, 1229 (!info->shared || info->no_undefined 1230 || ELF_ST_VISIBILITY (h->other))))) 1231 return false; 1232 } 1233 } 1234 1235 switch (r_type) 1236 { 1237 case R_SPARC_GOT10: 1238 case R_SPARC_GOT13: 1239 case R_SPARC_GOT22: 1240 /* Relocation is to the entry for this symbol in the global 1241 offset table. */ 1242 if (sgot == NULL) 1243 { 1244 sgot = bfd_get_section_by_name (dynobj, ".got"); 1245 BFD_ASSERT (sgot != NULL); 1246 } 1247 1248 if (h != NULL) 1249 { 1250 boolean dyn; 1251 1252 off = h->got.offset; 1253 BFD_ASSERT (off != (bfd_vma) -1); 1254 dyn = elf_hash_table (info)->dynamic_sections_created; 1255 1256 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h) 1257 || (info->shared 1258 && (info->symbolic 1259 || h->dynindx == -1 1260 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) 1261 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) 1262 { 1263 /* This is actually a static link, or it is a 1264 -Bsymbolic link and the symbol is defined 1265 locally, or the symbol was forced to be local 1266 because of a version file. We must initialize 1267 this entry in the global offset table. Since the 1268 offset must always be a multiple of 4, we use the 1269 least significant bit to record whether we have 1270 initialized it already. 1271 1272 When doing a dynamic link, we create a .rela.got 1273 relocation entry to initialize the value. This 1274 is done in the finish_dynamic_symbol routine. */ 1275 if ((off & 1) != 0) 1276 off &= ~1; 1277 else 1278 { 1279 bfd_put_32 (output_bfd, relocation, 1280 sgot->contents + off); 1281 h->got.offset |= 1; 1282 } 1283 } 1284 else 1285 unresolved_reloc = false; 1286 } 1287 else 1288 { 1289 BFD_ASSERT (local_got_offsets != NULL 1290 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1291 1292 off = local_got_offsets[r_symndx]; 1293 1294 /* The offset must always be a multiple of 4. We use 1295 the least significant bit to record whether we have 1296 already processed this entry. */ 1297 if ((off & 1) != 0) 1298 off &= ~1; 1299 else 1300 { 1301 1302 if (info->shared) 1303 { 1304 asection *srelgot; 1305 Elf_Internal_Rela outrel; 1306 1307 /* We need to generate a R_SPARC_RELATIVE reloc 1308 for the dynamic linker. */ 1309 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 1310 BFD_ASSERT (srelgot != NULL); 1311 1312 outrel.r_offset = (sgot->output_section->vma 1313 + sgot->output_offset 1314 + off); 1315 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); 1316 outrel.r_addend = relocation; 1317 relocation = 0; 1318 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 1319 (((Elf32_External_Rela *) 1320 srelgot->contents) 1321 + srelgot->reloc_count)); 1322 ++srelgot->reloc_count; 1323 } 1324 1325 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1326 local_got_offsets[r_symndx] |= 1; 1327 } 1328 } 1329 relocation = sgot->output_offset + off - got_base; 1330 break; 1331 1332 case R_SPARC_PLT32: 1333 if (h == NULL || h->plt.offset == (bfd_vma) -1) 1334 { 1335 r_type = R_SPARC_32; 1336 goto r_sparc_plt32; 1337 } 1338 /* Fall through. */ 1339 case R_SPARC_WPLT30: 1340 /* Relocation is to the entry for this symbol in the 1341 procedure linkage table. */ 1342 1343 /* The Solaris native assembler will generate a WPLT30 reloc 1344 for a local symbol if you assemble a call from one 1345 section to another when using -K pic. We treat it as 1346 WDISP30. */ 1347 if (h == NULL) 1348 break; 1349 1350 if (h->plt.offset == (bfd_vma) -1) 1351 { 1352 /* We didn't make a PLT entry for this symbol. This 1353 happens when statically linking PIC code, or when 1354 using -Bsymbolic. */ 1355 break; 1356 } 1357 1358 if (splt == NULL) 1359 { 1360 splt = bfd_get_section_by_name (dynobj, ".plt"); 1361 BFD_ASSERT (splt != NULL); 1362 } 1363 1364 relocation = (splt->output_section->vma 1365 + splt->output_offset 1366 + h->plt.offset); 1367 unresolved_reloc = false; 1368 if (r_type == R_SPARC_PLT32) 1369 { 1370 r_type = R_SPARC_32; 1371 is_plt = true; 1372 goto r_sparc_plt32; 1373 } 1374 break; 1375 1376 case R_SPARC_PC10: 1377 case R_SPARC_PC22: 1378 if (h != NULL 1379 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1380 break; 1381 /* Fall through. */ 1382 case R_SPARC_DISP8: 1383 case R_SPARC_DISP16: 1384 case R_SPARC_DISP32: 1385 case R_SPARC_WDISP30: 1386 case R_SPARC_WDISP22: 1387 case R_SPARC_WDISP19: 1388 case R_SPARC_WDISP16: 1389 if (h == NULL 1390 || (info->symbolic 1391 && (h->elf_link_hash_flags 1392 & ELF_LINK_HASH_DEF_REGULAR) != 0)) 1393 break; 1394 /* Fall through. */ 1395 case R_SPARC_8: 1396 case R_SPARC_16: 1397 case R_SPARC_32: 1398 case R_SPARC_HI22: 1399 case R_SPARC_22: 1400 case R_SPARC_13: 1401 case R_SPARC_LO10: 1402 case R_SPARC_UA16: 1403 case R_SPARC_UA32: 1404 r_sparc_plt32: 1405 if (info->shared 1406 && r_symndx != 0 1407 && (input_section->flags & SEC_ALLOC)) 1408 { 1409 Elf_Internal_Rela outrel; 1410 boolean skip, relocate = false; 1411 1412 /* When generating a shared object, these relocations 1413 are copied into the output file to be resolved at run 1414 time. */ 1415 1416 if (sreloc == NULL) 1417 { 1418 const char *name; 1419 1420 name = (bfd_elf_string_from_elf_section 1421 (input_bfd, 1422 elf_elfheader (input_bfd)->e_shstrndx, 1423 elf_section_data (input_section)->rel_hdr.sh_name)); 1424 if (name == NULL) 1425 return false; 1426 1427 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 1428 && strcmp (bfd_get_section_name (input_bfd, 1429 input_section), 1430 name + 5) == 0); 1431 1432 sreloc = bfd_get_section_by_name (dynobj, name); 1433 BFD_ASSERT (sreloc != NULL); 1434 } 1435 1436 skip = false; 1437 1438 outrel.r_offset = 1439 _bfd_elf_section_offset (output_bfd, info, input_section, 1440 rel->r_offset); 1441 if (outrel.r_offset == (bfd_vma) -1) 1442 skip = true; 1443 else if (outrel.r_offset == (bfd_vma) -2) 1444 skip = true, relocate = true; 1445 outrel.r_offset += (input_section->output_section->vma 1446 + input_section->output_offset); 1447 1448 /* Optimize unaligned reloc usage now that we know where 1449 it finally resides. */ 1450 switch (r_type) 1451 { 1452 case R_SPARC_16: 1453 if (outrel.r_offset & 1) 1454 r_type = R_SPARC_UA16; 1455 break; 1456 case R_SPARC_UA16: 1457 if (!(outrel.r_offset & 1)) 1458 r_type = R_SPARC_16; 1459 break; 1460 case R_SPARC_32: 1461 if (outrel.r_offset & 3) 1462 r_type = R_SPARC_UA32; 1463 break; 1464 case R_SPARC_UA32: 1465 if (!(outrel.r_offset & 3)) 1466 r_type = R_SPARC_32; 1467 break; 1468 case R_SPARC_DISP8: 1469 case R_SPARC_DISP16: 1470 case R_SPARC_DISP32: 1471 /* If the symbol is not dynamic, we should not keep 1472 a dynamic relocation. But an .rela.* slot has been 1473 allocated for it, output R_SPARC_NONE. 1474 FIXME: Add code tracking needed dynamic relocs as 1475 e.g. i386 has. */ 1476 if (h->dynindx == -1) 1477 skip = true, relocate = true; 1478 break; 1479 } 1480 1481 if (skip) 1482 memset (&outrel, 0, sizeof outrel); 1483 /* h->dynindx may be -1 if the symbol was marked to 1484 become local. */ 1485 else if (h != NULL && ! is_plt 1486 && ((! info->symbolic && h->dynindx != -1) 1487 || (h->elf_link_hash_flags 1488 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 1489 { 1490 BFD_ASSERT (h->dynindx != -1); 1491 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 1492 outrel.r_addend = rel->r_addend; 1493 } 1494 else 1495 { 1496 if (r_type == R_SPARC_32) 1497 { 1498 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); 1499 outrel.r_addend = relocation + rel->r_addend; 1500 } 1501 else 1502 { 1503 long indx; 1504 1505 if (is_plt) 1506 sec = splt; 1507 else if (h == NULL) 1508 sec = local_sections[r_symndx]; 1509 else 1510 { 1511 BFD_ASSERT (h->root.type == bfd_link_hash_defined 1512 || (h->root.type 1513 == bfd_link_hash_defweak)); 1514 sec = h->root.u.def.section; 1515 } 1516 if (sec != NULL && bfd_is_abs_section (sec)) 1517 indx = 0; 1518 else if (sec == NULL || sec->owner == NULL) 1519 { 1520 bfd_set_error (bfd_error_bad_value); 1521 return false; 1522 } 1523 else 1524 { 1525 asection *osec; 1526 1527 osec = sec->output_section; 1528 indx = elf_section_data (osec)->dynindx; 1529 1530 /* FIXME: we really should be able to link non-pic 1531 shared libraries. */ 1532 if (indx == 0) 1533 { 1534 BFD_FAIL (); 1535 (*_bfd_error_handler) 1536 (_("%s: probably compiled without -fPIC?"), 1537 bfd_archive_filename (input_bfd)); 1538 bfd_set_error (bfd_error_bad_value); 1539 return false; 1540 } 1541 } 1542 1543 outrel.r_info = ELF32_R_INFO (indx, r_type); 1544 outrel.r_addend = relocation + rel->r_addend; 1545 } 1546 } 1547 1548 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 1549 (((Elf32_External_Rela *) 1550 sreloc->contents) 1551 + sreloc->reloc_count)); 1552 ++sreloc->reloc_count; 1553 1554 /* This reloc will be computed at runtime, so there's no 1555 need to do anything now. */ 1556 if (! relocate) 1557 continue; 1558 } 1559 break; 1560 1561 default: 1562 break; 1563 } 1564 1565 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 1566 because such sections are not SEC_ALLOC and thus ld.so will 1567 not process them. */ 1568 if (unresolved_reloc 1569 && !((input_section->flags & SEC_DEBUGGING) != 0 1570 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)) 1571 (*_bfd_error_handler) 1572 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"), 1573 bfd_archive_filename (input_bfd), 1574 bfd_get_section_name (input_bfd, input_section), 1575 (long) rel->r_offset, 1576 h->root.root.string); 1577 1578 r = bfd_reloc_continue; 1579 if (r_type == R_SPARC_WDISP16) 1580 { 1581 bfd_vma x; 1582 1583 relocation += rel->r_addend; 1584 relocation -= (input_section->output_section->vma 1585 + input_section->output_offset); 1586 relocation -= rel->r_offset; 1587 1588 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 1589 x |= ((((relocation >> 2) & 0xc000) << 6) 1590 | ((relocation >> 2) & 0x3fff)); 1591 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 1592 1593 if ((bfd_signed_vma) relocation < - 0x40000 1594 || (bfd_signed_vma) relocation > 0x3ffff) 1595 r = bfd_reloc_overflow; 1596 else 1597 r = bfd_reloc_ok; 1598 } 1599 else if (r_type == R_SPARC_REV32) 1600 { 1601 bfd_vma x; 1602 1603 relocation = relocation + rel->r_addend; 1604 1605 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 1606 x = x + relocation; 1607 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset); 1608 r = bfd_reloc_ok; 1609 } 1610 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30) 1611 && SEC_DO_RELAX (input_section) 1612 && rel->r_offset + 4 < input_section->_raw_size) 1613 { 1614#define G0 0 1615#define O7 15 1616#define XCC (2 << 20) 1617#define COND(x) (((x)&0xf)<<25) 1618#define CONDA COND(0x8) 1619#define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC) 1620#define INSN_BA (F2(0,2) | CONDA) 1621#define INSN_OR F3(2, 0x2, 0) 1622#define INSN_NOP F2(0,4) 1623 1624 bfd_vma x, y; 1625 1626 /* If the instruction is a call with either: 1627 restore 1628 arithmetic instruction with rd == %o7 1629 where rs1 != %o7 and rs2 if it is register != %o7 1630 then we can optimize if the call destination is near 1631 by changing the call into a branch always. */ 1632 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 1633 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4); 1634 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2)) 1635 { 1636 if (((y & OP3(~0)) == OP3(0x3d) /* restore */ 1637 || ((y & OP3(0x28)) == 0 /* arithmetic */ 1638 && (y & RD(~0)) == RD(O7))) 1639 && (y & RS1(~0)) != RS1(O7) 1640 && ((y & F3I(~0)) 1641 || (y & RS2(~0)) != RS2(O7))) 1642 { 1643 bfd_vma reloc; 1644 1645 reloc = relocation + rel->r_addend - rel->r_offset; 1646 reloc -= (input_section->output_section->vma 1647 + input_section->output_offset); 1648 1649 /* Ensure the reloc fits into simm22. */ 1650 if ((reloc & 3) == 0 1651 && ((reloc & ~(bfd_vma)0x7fffff) == 0 1652 || ((reloc | 0x7fffff) == ~(bfd_vma)0))) 1653 { 1654 reloc >>= 2; 1655 1656 /* Check whether it fits into simm19 on v9. */ 1657 if (((reloc & 0x3c0000) == 0 1658 || (reloc & 0x3c0000) == 0x3c0000) 1659 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS)) 1660 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */ 1661 else 1662 x = INSN_BA | (reloc & 0x3fffff); /* ba */ 1663 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 1664 r = bfd_reloc_ok; 1665 if (rel->r_offset >= 4 1666 && (y & (0xffffffff ^ RS1(~0))) 1667 == (INSN_OR | RD(O7) | RS2(G0))) 1668 { 1669 bfd_vma z; 1670 unsigned int reg; 1671 1672 z = bfd_get_32 (input_bfd, 1673 contents + rel->r_offset - 4); 1674 if ((z & (0xffffffff ^ RD(~0))) 1675 != (INSN_OR | RS1(O7) | RS2(G0))) 1676 break; 1677 1678 /* The sequence was 1679 or %o7, %g0, %rN 1680 call foo 1681 or %rN, %g0, %o7 1682 1683 If call foo was replaced with ba, replace 1684 or %rN, %g0, %o7 with nop. */ 1685 1686 reg = (y & RS1(~0)) >> 14; 1687 if (reg != ((z & RD(~0)) >> 25) 1688 || reg == G0 || reg == O7) 1689 break; 1690 1691 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP, 1692 contents + rel->r_offset + 4); 1693 } 1694 1695 } 1696 } 1697 } 1698 } 1699 1700 if (r == bfd_reloc_continue) 1701 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1702 contents, rel->r_offset, 1703 relocation, rel->r_addend); 1704 1705 if (r != bfd_reloc_ok) 1706 { 1707 switch (r) 1708 { 1709 default: 1710 case bfd_reloc_outofrange: 1711 abort (); 1712 case bfd_reloc_overflow: 1713 { 1714 const char *name; 1715 1716 if (h != NULL) 1717 name = h->root.root.string; 1718 else 1719 { 1720 name = bfd_elf_string_from_elf_section (input_bfd, 1721 symtab_hdr->sh_link, 1722 sym->st_name); 1723 if (name == NULL) 1724 return false; 1725 if (*name == '\0') 1726 name = bfd_section_name (input_bfd, sec); 1727 } 1728 if (! ((*info->callbacks->reloc_overflow) 1729 (info, name, howto->name, (bfd_vma) 0, 1730 input_bfd, input_section, rel->r_offset))) 1731 return false; 1732 } 1733 break; 1734 } 1735 } 1736 } 1737 1738 return true; 1739} 1740 1741/* Finish up dynamic symbol handling. We set the contents of various 1742 dynamic sections here. */ 1743 1744static boolean 1745elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym) 1746 bfd *output_bfd; 1747 struct bfd_link_info *info; 1748 struct elf_link_hash_entry *h; 1749 Elf_Internal_Sym *sym; 1750{ 1751 bfd *dynobj; 1752 1753 dynobj = elf_hash_table (info)->dynobj; 1754 1755 if (h->plt.offset != (bfd_vma) -1) 1756 { 1757 asection *splt; 1758 asection *srela; 1759 Elf_Internal_Rela rela; 1760 1761 /* This symbol has an entry in the procedure linkage table. Set 1762 it up. */ 1763 1764 BFD_ASSERT (h->dynindx != -1); 1765 1766 splt = bfd_get_section_by_name (dynobj, ".plt"); 1767 srela = bfd_get_section_by_name (dynobj, ".rela.plt"); 1768 BFD_ASSERT (splt != NULL && srela != NULL); 1769 1770 /* Fill in the entry in the procedure linkage table. */ 1771 bfd_put_32 (output_bfd, 1772 PLT_ENTRY_WORD0 + h->plt.offset, 1773 splt->contents + h->plt.offset); 1774 bfd_put_32 (output_bfd, 1775 (PLT_ENTRY_WORD1 1776 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)), 1777 splt->contents + h->plt.offset + 4); 1778 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2, 1779 splt->contents + h->plt.offset + 8); 1780 1781 /* Fill in the entry in the .rela.plt section. */ 1782 rela.r_offset = (splt->output_section->vma 1783 + splt->output_offset 1784 + h->plt.offset); 1785 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT); 1786 rela.r_addend = 0; 1787 bfd_elf32_swap_reloca_out (output_bfd, &rela, 1788 ((Elf32_External_Rela *) srela->contents 1789 + h->plt.offset / PLT_ENTRY_SIZE - 4)); 1790 1791 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1792 { 1793 /* Mark the symbol as undefined, rather than as defined in 1794 the .plt section. Leave the value alone. */ 1795 sym->st_shndx = SHN_UNDEF; 1796 /* If the symbol is weak, we do need to clear the value. 1797 Otherwise, the PLT entry would provide a definition for 1798 the symbol even if the symbol wasn't defined anywhere, 1799 and so the symbol would never be NULL. */ 1800 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK) 1801 == 0) 1802 sym->st_value = 0; 1803 } 1804 } 1805 1806 if (h->got.offset != (bfd_vma) -1) 1807 { 1808 asection *sgot; 1809 asection *srela; 1810 Elf_Internal_Rela rela; 1811 1812 /* This symbol has an entry in the global offset table. Set it 1813 up. */ 1814 1815 sgot = bfd_get_section_by_name (dynobj, ".got"); 1816 srela = bfd_get_section_by_name (dynobj, ".rela.got"); 1817 BFD_ASSERT (sgot != NULL && srela != NULL); 1818 1819 rela.r_offset = (sgot->output_section->vma 1820 + sgot->output_offset 1821 + (h->got.offset &~ (bfd_vma) 1)); 1822 1823 /* If this is a -Bsymbolic link, and the symbol is defined 1824 locally, we just want to emit a RELATIVE reloc. Likewise if 1825 the symbol was forced to be local because of a version file. 1826 The entry in the global offset table will already have been 1827 initialized in the relocate_section function. */ 1828 if (info->shared 1829 && (info->symbolic || h->dynindx == -1) 1830 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 1831 { 1832 asection *sec = h->root.u.def.section; 1833 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); 1834 rela.r_addend = (h->root.u.def.value 1835 + sec->output_section->vma 1836 + sec->output_offset); 1837 } 1838 else 1839 { 1840 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT); 1841 rela.r_addend = 0; 1842 } 1843 1844 bfd_put_32 (output_bfd, (bfd_vma) 0, 1845 sgot->contents + (h->got.offset &~ (bfd_vma) 1)); 1846 bfd_elf32_swap_reloca_out (output_bfd, &rela, 1847 ((Elf32_External_Rela *) srela->contents 1848 + srela->reloc_count)); 1849 ++srela->reloc_count; 1850 } 1851 1852 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 1853 { 1854 asection *s; 1855 Elf_Internal_Rela rela; 1856 1857 /* This symbols needs a copy reloc. Set it up. */ 1858 1859 BFD_ASSERT (h->dynindx != -1); 1860 1861 s = bfd_get_section_by_name (h->root.u.def.section->owner, 1862 ".rela.bss"); 1863 BFD_ASSERT (s != NULL); 1864 1865 rela.r_offset = (h->root.u.def.value 1866 + h->root.u.def.section->output_section->vma 1867 + h->root.u.def.section->output_offset); 1868 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY); 1869 rela.r_addend = 0; 1870 bfd_elf32_swap_reloca_out (output_bfd, &rela, 1871 ((Elf32_External_Rela *) s->contents 1872 + s->reloc_count)); 1873 ++s->reloc_count; 1874 } 1875 1876 /* Mark some specially defined symbols as absolute. */ 1877 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 1878 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 1879 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0) 1880 sym->st_shndx = SHN_ABS; 1881 1882 return true; 1883} 1884 1885/* Finish up the dynamic sections. */ 1886 1887static boolean 1888elf32_sparc_finish_dynamic_sections (output_bfd, info) 1889 bfd *output_bfd; 1890 struct bfd_link_info *info; 1891{ 1892 bfd *dynobj; 1893 asection *sdyn; 1894 asection *sgot; 1895 1896 dynobj = elf_hash_table (info)->dynobj; 1897 1898 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 1899 1900 if (elf_hash_table (info)->dynamic_sections_created) 1901 { 1902 asection *splt; 1903 Elf32_External_Dyn *dyncon, *dynconend; 1904 1905 splt = bfd_get_section_by_name (dynobj, ".plt"); 1906 BFD_ASSERT (splt != NULL && sdyn != NULL); 1907 1908 dyncon = (Elf32_External_Dyn *) sdyn->contents; 1909 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 1910 for (; dyncon < dynconend; dyncon++) 1911 { 1912 Elf_Internal_Dyn dyn; 1913 const char *name; 1914 boolean size; 1915 1916 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 1917 1918 switch (dyn.d_tag) 1919 { 1920 case DT_PLTGOT: name = ".plt"; size = false; break; 1921 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break; 1922 case DT_JMPREL: name = ".rela.plt"; size = false; break; 1923 default: name = NULL; size = false; break; 1924 } 1925 1926 if (name != NULL) 1927 { 1928 asection *s; 1929 1930 s = bfd_get_section_by_name (output_bfd, name); 1931 if (s == NULL) 1932 dyn.d_un.d_val = 0; 1933 else 1934 { 1935 if (! size) 1936 dyn.d_un.d_ptr = s->vma; 1937 else 1938 { 1939 if (s->_cooked_size != 0) 1940 dyn.d_un.d_val = s->_cooked_size; 1941 else 1942 dyn.d_un.d_val = s->_raw_size; 1943 } 1944 } 1945 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1946 } 1947 } 1948 1949 /* Clear the first four entries in the procedure linkage table, 1950 and put a nop in the last four bytes. */ 1951 if (splt->_raw_size > 0) 1952 { 1953 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE); 1954 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, 1955 splt->contents + splt->_raw_size - 4); 1956 } 1957 1958 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 1959 PLT_ENTRY_SIZE; 1960 } 1961 1962 /* Set the first entry in the global offset table to the address of 1963 the dynamic section. */ 1964 sgot = bfd_get_section_by_name (dynobj, ".got"); 1965 BFD_ASSERT (sgot != NULL); 1966 if (sgot->_raw_size > 0) 1967 { 1968 if (sdyn == NULL) 1969 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 1970 else 1971 bfd_put_32 (output_bfd, 1972 sdyn->output_section->vma + sdyn->output_offset, 1973 sgot->contents); 1974 } 1975 1976 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 1977 1978 return true; 1979} 1980 1981/* Functions for dealing with the e_flags field. 1982 1983 We don't define set_private_flags or copy_private_bfd_data because 1984 the only currently defined values are based on the bfd mach number, 1985 so we use the latter instead and defer setting e_flags until the 1986 file is written out. */ 1987 1988/* Merge backend specific data from an object file to the output 1989 object file when linking. */ 1990 1991static boolean 1992elf32_sparc_merge_private_bfd_data (ibfd, obfd) 1993 bfd *ibfd; 1994 bfd *obfd; 1995{ 1996 boolean error; 1997 /* FIXME: This should not be static. */ 1998 static unsigned long previous_ibfd_e_flags = (unsigned long) -1; 1999 2000 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 2001 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 2002 return true; 2003 2004 error = false; 2005 2006 if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9) 2007 { 2008 error = true; 2009 (*_bfd_error_handler) 2010 (_("%s: compiled for a 64 bit system and target is 32 bit"), 2011 bfd_archive_filename (ibfd)); 2012 } 2013 else if ((ibfd->flags & DYNAMIC) == 0) 2014 { 2015 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd)) 2016 bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd)); 2017 } 2018 2019 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA) 2020 != previous_ibfd_e_flags) 2021 && previous_ibfd_e_flags != (unsigned long) -1) 2022 { 2023 (*_bfd_error_handler) 2024 (_("%s: linking little endian files with big endian files"), 2025 bfd_archive_filename (ibfd)); 2026 error = true; 2027 } 2028 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA; 2029 2030 if (error) 2031 { 2032 bfd_set_error (bfd_error_bad_value); 2033 return false; 2034 } 2035 2036 return true; 2037} 2038 2039/* Set the right machine number. */ 2040 2041static boolean 2042elf32_sparc_object_p (abfd) 2043 bfd *abfd; 2044{ 2045 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS) 2046 { 2047 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3) 2048 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 2049 bfd_mach_sparc_v8plusb); 2050 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1) 2051 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 2052 bfd_mach_sparc_v8plusa); 2053 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS) 2054 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 2055 bfd_mach_sparc_v8plus); 2056 else 2057 return false; 2058 } 2059 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA) 2060 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 2061 bfd_mach_sparc_sparclite_le); 2062 else 2063 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc); 2064} 2065 2066/* The final processing done just before writing out the object file. 2067 We need to set the e_machine field appropriately. */ 2068 2069static void 2070elf32_sparc_final_write_processing (abfd, linker) 2071 bfd *abfd; 2072 boolean linker ATTRIBUTE_UNUSED; 2073{ 2074 switch (bfd_get_mach (abfd)) 2075 { 2076 case bfd_mach_sparc : 2077 break; /* nothing to do */ 2078 case bfd_mach_sparc_v8plus : 2079 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; 2080 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; 2081 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS; 2082 break; 2083 case bfd_mach_sparc_v8plusa : 2084 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; 2085 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; 2086 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1; 2087 break; 2088 case bfd_mach_sparc_v8plusb : 2089 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; 2090 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; 2091 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1 2092 | EF_SPARC_SUN_US3; 2093 break; 2094 case bfd_mach_sparc_sparclite_le : 2095 elf_elfheader (abfd)->e_machine = EM_SPARC; 2096 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA; 2097 break; 2098 default : 2099 abort (); 2100 break; 2101 } 2102} 2103 2104static enum elf_reloc_type_class 2105elf32_sparc_reloc_type_class (rela) 2106 const Elf_Internal_Rela *rela; 2107{ 2108 switch ((int) ELF32_R_TYPE (rela->r_info)) 2109 { 2110 case R_SPARC_RELATIVE: 2111 return reloc_class_relative; 2112 case R_SPARC_JMP_SLOT: 2113 return reloc_class_plt; 2114 case R_SPARC_COPY: 2115 return reloc_class_copy; 2116 default: 2117 return reloc_class_normal; 2118 } 2119} 2120 2121#define TARGET_BIG_SYM bfd_elf32_sparc_vec 2122#define TARGET_BIG_NAME "elf32-sparc" 2123#define ELF_ARCH bfd_arch_sparc 2124#define ELF_MACHINE_CODE EM_SPARC 2125#define ELF_MACHINE_ALT1 EM_SPARC32PLUS 2126#define ELF_MAXPAGESIZE 0x10000 2127 2128#define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup 2129#define bfd_elf32_bfd_relax_section elf32_sparc_relax_section 2130#define elf_info_to_howto elf32_sparc_info_to_howto 2131#define elf_backend_create_dynamic_sections \ 2132 _bfd_elf_create_dynamic_sections 2133#define elf_backend_check_relocs elf32_sparc_check_relocs 2134#define elf_backend_adjust_dynamic_symbol \ 2135 elf32_sparc_adjust_dynamic_symbol 2136#define elf_backend_size_dynamic_sections \ 2137 elf32_sparc_size_dynamic_sections 2138#define elf_backend_relocate_section elf32_sparc_relocate_section 2139#define elf_backend_finish_dynamic_symbol \ 2140 elf32_sparc_finish_dynamic_symbol 2141#define elf_backend_finish_dynamic_sections \ 2142 elf32_sparc_finish_dynamic_sections 2143#define bfd_elf32_bfd_merge_private_bfd_data \ 2144 elf32_sparc_merge_private_bfd_data 2145#define elf_backend_object_p elf32_sparc_object_p 2146#define elf_backend_final_write_processing \ 2147 elf32_sparc_final_write_processing 2148#define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook 2149#define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook 2150#define elf_backend_reloc_type_class elf32_sparc_reloc_type_class 2151 2152#define elf_backend_can_gc_sections 1 2153#define elf_backend_want_got_plt 0 2154#define elf_backend_plt_readonly 0 2155#define elf_backend_want_plt_sym 1 2156#define elf_backend_got_header_size 4 2157#define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE) 2158 2159#include "elf32-target.h" 2160