elf32-sparc.c revision 94536
1/* SPARC-specific support for 32-bit ELF 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 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 ((bfd *, 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 (abfd, info, rel, h, sym) 641 bfd *abfd; 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 648 if (h != NULL) 649 { 650 switch (ELF32_R_TYPE (rel->r_info)) 651 { 652 case R_SPARC_GNU_VTINHERIT: 653 case R_SPARC_GNU_VTENTRY: 654 break; 655 656 default: 657 switch (h->root.type) 658 { 659 case bfd_link_hash_defined: 660 case bfd_link_hash_defweak: 661 return h->root.u.def.section; 662 663 case bfd_link_hash_common: 664 return h->root.u.c.p->section; 665 666 default: 667 break; 668 } 669 } 670 } 671 else 672 { 673 return bfd_section_from_elf_index (abfd, sym->st_shndx); 674 } 675 676 return NULL; 677} 678 679/* Update the got entry reference counts for the section being removed. */ 680static boolean 681elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs) 682 bfd *abfd; 683 struct bfd_link_info *info ATTRIBUTE_UNUSED; 684 asection *sec; 685 const Elf_Internal_Rela *relocs; 686{ 687 688 Elf_Internal_Shdr *symtab_hdr; 689 struct elf_link_hash_entry **sym_hashes; 690 bfd_signed_vma *local_got_refcounts; 691 const Elf_Internal_Rela *rel, *relend; 692 unsigned long r_symndx; 693 struct elf_link_hash_entry *h; 694 695 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 696 sym_hashes = elf_sym_hashes (abfd); 697 local_got_refcounts = elf_local_got_refcounts (abfd); 698 699 relend = relocs + sec->reloc_count; 700 for (rel = relocs; rel < relend; rel++) 701 switch (ELF32_R_TYPE (rel->r_info)) 702 { 703 case R_SPARC_GOT10: 704 case R_SPARC_GOT13: 705 case R_SPARC_GOT22: 706 r_symndx = ELF32_R_SYM (rel->r_info); 707 if (r_symndx >= symtab_hdr->sh_info) 708 { 709 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 710 if (h->got.refcount > 0) 711 h->got.refcount--; 712 } 713 else 714 { 715 if (local_got_refcounts[r_symndx] > 0) 716 local_got_refcounts[r_symndx]--; 717 } 718 break; 719 720 case R_SPARC_PLT32: 721 case R_SPARC_HIPLT22: 722 case R_SPARC_LOPLT10: 723 case R_SPARC_PCPLT32: 724 case R_SPARC_PCPLT10: 725 r_symndx = ELF32_R_SYM (rel->r_info); 726 if (r_symndx >= symtab_hdr->sh_info) 727 { 728 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 729 if (h->plt.refcount > 0) 730 h->plt.refcount--; 731 } 732 break; 733 734 default: 735 break; 736 } 737 738 return true; 739} 740 741/* Adjust a symbol defined by a dynamic object and referenced by a 742 regular object. The current definition is in some section of the 743 dynamic object, but we're not including those sections. We have to 744 change the definition to something the rest of the link can 745 understand. */ 746 747static boolean 748elf32_sparc_adjust_dynamic_symbol (info, h) 749 struct bfd_link_info *info; 750 struct elf_link_hash_entry *h; 751{ 752 bfd *dynobj; 753 asection *s; 754 unsigned int power_of_two; 755 756 dynobj = elf_hash_table (info)->dynobj; 757 758 /* Make sure we know what is going on here. */ 759 BFD_ASSERT (dynobj != NULL 760 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) 761 || h->weakdef != NULL 762 || ((h->elf_link_hash_flags 763 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 764 && (h->elf_link_hash_flags 765 & ELF_LINK_HASH_REF_REGULAR) != 0 766 && (h->elf_link_hash_flags 767 & ELF_LINK_HASH_DEF_REGULAR) == 0))); 768 769 /* If this is a function, put it in the procedure linkage table. We 770 will fill in the contents of the procedure linkage table later 771 (although we could actually do it here). The STT_NOTYPE 772 condition is a hack specifically for the Oracle libraries 773 delivered for Solaris; for some inexplicable reason, they define 774 some of their functions as STT_NOTYPE when they really should be 775 STT_FUNC. */ 776 if (h->type == STT_FUNC 777 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0 778 || (h->type == STT_NOTYPE 779 && (h->root.type == bfd_link_hash_defined 780 || h->root.type == bfd_link_hash_defweak) 781 && (h->root.u.def.section->flags & SEC_CODE) != 0)) 782 { 783 if (! elf_hash_table (info)->dynamic_sections_created 784 || ((!info->shared || info->symbolic || h->dynindx == -1) 785 && (h->elf_link_hash_flags 786 & ELF_LINK_HASH_DEF_REGULAR) != 0)) 787 { 788 /* This case can occur if we saw a WPLT30 reloc in an input 789 file, but none of the input files were dynamic objects. 790 Or, when linking the main application or a -Bsymbolic 791 shared library against PIC code. Or when a global symbol 792 has been made private, e.g. via versioning. 793 794 In these cases we know what value the symbol will resolve 795 to, so we don't actually need to build a procedure linkage 796 table, and we can just do a WDISP30 reloc instead. */ 797 798 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 799 return true; 800 } 801 802 s = bfd_get_section_by_name (dynobj, ".plt"); 803 BFD_ASSERT (s != NULL); 804 805 /* The first four entries in .plt are reserved. */ 806 if (s->_raw_size == 0) 807 s->_raw_size = 4 * PLT_ENTRY_SIZE; 808 809 /* The procedure linkage table has a maximum size. */ 810 if (s->_raw_size >= 0x400000) 811 { 812 bfd_set_error (bfd_error_bad_value); 813 return false; 814 } 815 816 /* If this symbol is not defined in a regular file, and we are 817 not generating a shared library, then set the symbol to this 818 location in the .plt. This is required to make function 819 pointers compare as equal between the normal executable and 820 the shared library. */ 821 if (! info->shared 822 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 823 { 824 h->root.u.def.section = s; 825 h->root.u.def.value = s->_raw_size; 826 } 827 828 h->plt.offset = s->_raw_size; 829 830 /* Make room for this entry. */ 831 s->_raw_size += PLT_ENTRY_SIZE; 832 833 /* We also need to make an entry in the .rela.plt section. */ 834 835 s = bfd_get_section_by_name (dynobj, ".rela.plt"); 836 BFD_ASSERT (s != NULL); 837 s->_raw_size += sizeof (Elf32_External_Rela); 838 839 return true; 840 } 841 842 /* If this is a weak symbol, and there is a real definition, the 843 processor independent code will have arranged for us to see the 844 real definition first, and we can just use the same value. */ 845 if (h->weakdef != NULL) 846 { 847 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 848 || h->weakdef->root.type == bfd_link_hash_defweak); 849 h->root.u.def.section = h->weakdef->root.u.def.section; 850 h->root.u.def.value = h->weakdef->root.u.def.value; 851 return true; 852 } 853 854 /* This is a reference to a symbol defined by a dynamic object which 855 is not a function. */ 856 857 /* If we are creating a shared library, we must presume that the 858 only references to the symbol are via the global offset table. 859 For such cases we need not do anything here; the relocations will 860 be handled correctly by relocate_section. */ 861 if (info->shared) 862 return true; 863 864 /* If there are no references to this symbol that do not use the 865 GOT, we don't need to generate a copy reloc. */ 866 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0) 867 return true; 868 869 /* We must allocate the symbol in our .dynbss section, which will 870 become part of the .bss section of the executable. There will be 871 an entry for this symbol in the .dynsym section. The dynamic 872 object will contain position independent code, so all references 873 from the dynamic object to this symbol will go through the global 874 offset table. The dynamic linker will use the .dynsym entry to 875 determine the address it must put in the global offset table, so 876 both the dynamic object and the regular object will refer to the 877 same memory location for the variable. */ 878 879 s = bfd_get_section_by_name (dynobj, ".dynbss"); 880 BFD_ASSERT (s != NULL); 881 882 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker 883 to copy the initial value out of the dynamic object and into the 884 runtime process image. We need to remember the offset into the 885 .rel.bss section we are going to use. */ 886 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 887 { 888 asection *srel; 889 890 srel = bfd_get_section_by_name (dynobj, ".rela.bss"); 891 BFD_ASSERT (srel != NULL); 892 srel->_raw_size += sizeof (Elf32_External_Rela); 893 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 894 } 895 896 /* We need to figure out the alignment required for this symbol. I 897 have no idea how ELF linkers handle this. */ 898 power_of_two = bfd_log2 (h->size); 899 if (power_of_two > 3) 900 power_of_two = 3; 901 902 /* Apply the required alignment. */ 903 s->_raw_size = BFD_ALIGN (s->_raw_size, 904 (bfd_size_type) (1 << power_of_two)); 905 if (power_of_two > bfd_get_section_alignment (dynobj, s)) 906 { 907 if (! bfd_set_section_alignment (dynobj, s, power_of_two)) 908 return false; 909 } 910 911 /* Define the symbol as being at this point in the section. */ 912 h->root.u.def.section = s; 913 h->root.u.def.value = s->_raw_size; 914 915 /* Increment the section size to make room for the symbol. */ 916 s->_raw_size += h->size; 917 918 return true; 919} 920 921/* Set the sizes of the dynamic sections. */ 922 923static boolean 924elf32_sparc_size_dynamic_sections (output_bfd, info) 925 bfd *output_bfd ATTRIBUTE_UNUSED; 926 struct bfd_link_info *info; 927{ 928 bfd *dynobj; 929 asection *s; 930 boolean relplt; 931 932 dynobj = elf_hash_table (info)->dynobj; 933 BFD_ASSERT (dynobj != NULL); 934 935 if (elf_hash_table (info)->dynamic_sections_created) 936 { 937 /* Set the contents of the .interp section to the interpreter. */ 938 if (! info->shared) 939 { 940 s = bfd_get_section_by_name (dynobj, ".interp"); 941 BFD_ASSERT (s != NULL); 942 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 943 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 944 } 945 946 /* Make space for the trailing nop in .plt. */ 947 s = bfd_get_section_by_name (dynobj, ".plt"); 948 BFD_ASSERT (s != NULL); 949 if (s->_raw_size > 0) 950 s->_raw_size += 4; 951 } 952 else 953 { 954 /* We may have created entries in the .rela.got section. 955 However, if we are not creating the dynamic sections, we will 956 not actually use these entries. Reset the size of .rela.got, 957 which will cause it to get stripped from the output file 958 below. */ 959 s = bfd_get_section_by_name (dynobj, ".rela.got"); 960 if (s != NULL) 961 s->_raw_size = 0; 962 } 963 964 /* The check_relocs and adjust_dynamic_symbol entry points have 965 determined the sizes of the various dynamic sections. Allocate 966 memory for them. */ 967 relplt = false; 968 for (s = dynobj->sections; s != NULL; s = s->next) 969 { 970 const char *name; 971 boolean strip; 972 973 if ((s->flags & SEC_LINKER_CREATED) == 0) 974 continue; 975 976 /* It's OK to base decisions on the section name, because none 977 of the dynobj section names depend upon the input files. */ 978 name = bfd_get_section_name (dynobj, s); 979 980 strip = false; 981 982 if (strncmp (name, ".rela", 5) == 0) 983 { 984 if (s->_raw_size == 0) 985 { 986 /* If we don't need this section, strip it from the 987 output file. This is to handle .rela.bss and 988 .rel.plt. We must create it in 989 create_dynamic_sections, because it must be created 990 before the linker maps input sections to output 991 sections. The linker does that before 992 adjust_dynamic_symbol is called, and it is that 993 function which decides whether anything needs to go 994 into these sections. */ 995 strip = true; 996 } 997 else 998 { 999 if (strcmp (name, ".rela.plt") == 0) 1000 relplt = true; 1001 1002 /* We use the reloc_count field as a counter if we need 1003 to copy relocs into the output file. */ 1004 s->reloc_count = 0; 1005 } 1006 } 1007 else if (strcmp (name, ".plt") != 0 1008 && strcmp (name, ".got") != 0) 1009 { 1010 /* It's not one of our sections, so don't allocate space. */ 1011 continue; 1012 } 1013 1014 if (strip) 1015 { 1016 _bfd_strip_section_from_output (info, s); 1017 continue; 1018 } 1019 1020 /* Allocate memory for the section contents. */ 1021 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc. 1022 Unused entries should be reclaimed before the section's contents 1023 are written out, but at the moment this does not happen. Thus in 1024 order to prevent writing out garbage, we initialise the section's 1025 contents to zero. */ 1026 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 1027 if (s->contents == NULL && s->_raw_size != 0) 1028 return false; 1029 } 1030 1031 if (elf_hash_table (info)->dynamic_sections_created) 1032 { 1033 /* Add some entries to the .dynamic section. We fill in the 1034 values later, in elf32_sparc_finish_dynamic_sections, but we 1035 must add the entries now so that we get the correct size for 1036 the .dynamic section. The DT_DEBUG entry is filled in by the 1037 dynamic linker and used by the debugger. */ 1038#define add_dynamic_entry(TAG, VAL) \ 1039 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL)) 1040 1041 if (!info->shared) 1042 { 1043 if (!add_dynamic_entry (DT_DEBUG, 0)) 1044 return false; 1045 } 1046 1047 if (relplt) 1048 { 1049 if (!add_dynamic_entry (DT_PLTGOT, 0) 1050 || !add_dynamic_entry (DT_PLTRELSZ, 0) 1051 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 1052 || !add_dynamic_entry (DT_JMPREL, 0)) 1053 return false; 1054 } 1055 1056 if (!add_dynamic_entry (DT_RELA, 0) 1057 || !add_dynamic_entry (DT_RELASZ, 0) 1058 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 1059 return false; 1060 1061 if (info->flags & DF_TEXTREL) 1062 { 1063 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1064 return false; 1065 } 1066 } 1067#undef add_dynamic_entry 1068 1069 return true; 1070} 1071 1072#define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0) 1073#define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1) 1074 1075static boolean 1076elf32_sparc_relax_section (abfd, section, link_info, again) 1077 bfd *abfd ATTRIBUTE_UNUSED; 1078 asection *section ATTRIBUTE_UNUSED; 1079 struct bfd_link_info *link_info ATTRIBUTE_UNUSED; 1080 boolean *again; 1081{ 1082 *again = false; 1083 SET_SEC_DO_RELAX (section); 1084 return true; 1085} 1086 1087/* This is the condition under which finish_dynamic_symbol will be called 1088 from elflink.h. If elflink.h doesn't call our finish_dynamic_symbol 1089 routine, we'll need to do something about initializing any .plt and .got 1090 entries in relocate_section. */ 1091#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \ 1092 ((DYN) \ 1093 && ((INFO)->shared \ 1094 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \ 1095 && ((H)->dynindx != -1 \ 1096 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)) 1097 1098/* Relocate a SPARC ELF section. */ 1099 1100static boolean 1101elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, 1102 contents, relocs, local_syms, local_sections) 1103 bfd *output_bfd; 1104 struct bfd_link_info *info; 1105 bfd *input_bfd; 1106 asection *input_section; 1107 bfd_byte *contents; 1108 Elf_Internal_Rela *relocs; 1109 Elf_Internal_Sym *local_syms; 1110 asection **local_sections; 1111{ 1112 bfd *dynobj; 1113 Elf_Internal_Shdr *symtab_hdr; 1114 struct elf_link_hash_entry **sym_hashes; 1115 bfd_vma *local_got_offsets; 1116 bfd_vma got_base; 1117 asection *sgot; 1118 asection *splt; 1119 asection *sreloc; 1120 Elf_Internal_Rela *rel; 1121 Elf_Internal_Rela *relend; 1122 1123 dynobj = elf_hash_table (info)->dynobj; 1124 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1125 sym_hashes = elf_sym_hashes (input_bfd); 1126 local_got_offsets = elf_local_got_offsets (input_bfd); 1127 1128 if (elf_hash_table (info)->hgot == NULL) 1129 got_base = 0; 1130 else 1131 got_base = elf_hash_table (info)->hgot->root.u.def.value; 1132 1133 sgot = NULL; 1134 splt = NULL; 1135 sreloc = NULL; 1136 1137 rel = relocs; 1138 relend = relocs + input_section->reloc_count; 1139 for (; rel < relend; rel++) 1140 { 1141 int r_type; 1142 reloc_howto_type *howto; 1143 unsigned long r_symndx; 1144 struct elf_link_hash_entry *h; 1145 Elf_Internal_Sym *sym; 1146 asection *sec; 1147 bfd_vma relocation, off; 1148 bfd_reloc_status_type r; 1149 boolean is_plt = false; 1150 boolean unresolved_reloc; 1151 1152 r_type = ELF32_R_TYPE (rel->r_info); 1153 1154 if (r_type == R_SPARC_GNU_VTINHERIT 1155 || r_type == R_SPARC_GNU_VTENTRY) 1156 continue; 1157 1158 if (r_type < 0 || r_type >= (int) R_SPARC_max_std) 1159 { 1160 bfd_set_error (bfd_error_bad_value); 1161 return false; 1162 } 1163 howto = _bfd_sparc_elf_howto_table + r_type; 1164 1165 r_symndx = ELF32_R_SYM (rel->r_info); 1166 1167 if (info->relocateable) 1168 { 1169 /* This is a relocateable link. We don't have to change 1170 anything, unless the reloc is against a section symbol, 1171 in which case we have to adjust according to where the 1172 section symbol winds up in the output section. */ 1173 if (r_symndx < symtab_hdr->sh_info) 1174 { 1175 sym = local_syms + r_symndx; 1176 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1177 { 1178 sec = local_sections[r_symndx]; 1179 rel->r_addend += sec->output_offset + sym->st_value; 1180 } 1181 } 1182 1183 continue; 1184 } 1185 1186 /* This is a final link. */ 1187 h = NULL; 1188 sym = NULL; 1189 sec = NULL; 1190 unresolved_reloc = false; 1191 if (r_symndx < symtab_hdr->sh_info) 1192 { 1193 sym = local_syms + r_symndx; 1194 sec = local_sections[r_symndx]; 1195 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel); 1196 } 1197 else 1198 { 1199 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1200 while (h->root.type == bfd_link_hash_indirect 1201 || h->root.type == bfd_link_hash_warning) 1202 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1203 1204 relocation = 0; 1205 if (h->root.type == bfd_link_hash_defined 1206 || h->root.type == bfd_link_hash_defweak) 1207 { 1208 sec = h->root.u.def.section; 1209 if (sec->output_section == NULL) 1210 /* Set a flag that will be cleared later if we find a 1211 relocation value for this symbol. output_section 1212 is typically NULL for symbols satisfied by a shared 1213 library. */ 1214 unresolved_reloc = true; 1215 else 1216 relocation = (h->root.u.def.value 1217 + sec->output_section->vma 1218 + sec->output_offset); 1219 } 1220 else if (h->root.type == bfd_link_hash_undefweak) 1221 ; 1222 else if (info->shared 1223 && (!info->symbolic || info->allow_shlib_undefined) 1224 && !info->no_undefined 1225 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 1226 ; 1227 else 1228 { 1229 if (! ((*info->callbacks->undefined_symbol) 1230 (info, h->root.root.string, input_bfd, 1231 input_section, rel->r_offset, 1232 (!info->shared || info->no_undefined 1233 || ELF_ST_VISIBILITY (h->other))))) 1234 return false; 1235 } 1236 } 1237 1238 switch (r_type) 1239 { 1240 case R_SPARC_GOT10: 1241 case R_SPARC_GOT13: 1242 case R_SPARC_GOT22: 1243 /* Relocation is to the entry for this symbol in the global 1244 offset table. */ 1245 if (sgot == NULL) 1246 { 1247 sgot = bfd_get_section_by_name (dynobj, ".got"); 1248 BFD_ASSERT (sgot != NULL); 1249 } 1250 1251 if (h != NULL) 1252 { 1253 boolean dyn; 1254 1255 off = h->got.offset; 1256 BFD_ASSERT (off != (bfd_vma) -1); 1257 dyn = elf_hash_table (info)->dynamic_sections_created; 1258 1259 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h) 1260 || (info->shared 1261 && (info->symbolic 1262 || h->dynindx == -1 1263 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) 1264 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) 1265 { 1266 /* This is actually a static link, or it is a 1267 -Bsymbolic link and the symbol is defined 1268 locally, or the symbol was forced to be local 1269 because of a version file. We must initialize 1270 this entry in the global offset table. Since the 1271 offset must always be a multiple of 4, we use the 1272 least significant bit to record whether we have 1273 initialized it already. 1274 1275 When doing a dynamic link, we create a .rela.got 1276 relocation entry to initialize the value. This 1277 is done in the finish_dynamic_symbol routine. */ 1278 if ((off & 1) != 0) 1279 off &= ~1; 1280 else 1281 { 1282 bfd_put_32 (output_bfd, relocation, 1283 sgot->contents + off); 1284 h->got.offset |= 1; 1285 } 1286 } 1287 else 1288 unresolved_reloc = false; 1289 } 1290 else 1291 { 1292 BFD_ASSERT (local_got_offsets != NULL 1293 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1294 1295 off = local_got_offsets[r_symndx]; 1296 1297 /* The offset must always be a multiple of 4. We use 1298 the least significant bit to record whether we have 1299 already processed this entry. */ 1300 if ((off & 1) != 0) 1301 off &= ~1; 1302 else 1303 { 1304 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1305 1306 if (info->shared) 1307 { 1308 asection *srelgot; 1309 Elf_Internal_Rela outrel; 1310 1311 /* We need to generate a R_SPARC_RELATIVE reloc 1312 for the dynamic linker. */ 1313 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 1314 BFD_ASSERT (srelgot != NULL); 1315 1316 outrel.r_offset = (sgot->output_section->vma 1317 + sgot->output_offset 1318 + off); 1319 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); 1320 outrel.r_addend = 0; 1321 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 1322 (((Elf32_External_Rela *) 1323 srelgot->contents) 1324 + srelgot->reloc_count)); 1325 ++srelgot->reloc_count; 1326 } 1327 1328 local_got_offsets[r_symndx] |= 1; 1329 } 1330 } 1331 relocation = sgot->output_offset + off - got_base; 1332 break; 1333 1334 case R_SPARC_PLT32: 1335 if (h == NULL || h->plt.offset == (bfd_vma) -1) 1336 { 1337 r_type = R_SPARC_32; 1338 goto r_sparc_plt32; 1339 } 1340 /* Fall through. */ 1341 case R_SPARC_WPLT30: 1342 /* Relocation is to the entry for this symbol in the 1343 procedure linkage table. */ 1344 1345 /* The Solaris native assembler will generate a WPLT30 reloc 1346 for a local symbol if you assemble a call from one 1347 section to another when using -K pic. We treat it as 1348 WDISP30. */ 1349 if (h == NULL) 1350 break; 1351 1352 if (h->plt.offset == (bfd_vma) -1) 1353 { 1354 /* We didn't make a PLT entry for this symbol. This 1355 happens when statically linking PIC code, or when 1356 using -Bsymbolic. */ 1357 break; 1358 } 1359 1360 if (splt == NULL) 1361 { 1362 splt = bfd_get_section_by_name (dynobj, ".plt"); 1363 BFD_ASSERT (splt != NULL); 1364 } 1365 1366 relocation = (splt->output_section->vma 1367 + splt->output_offset 1368 + h->plt.offset); 1369 unresolved_reloc = false; 1370 if (r_type == R_SPARC_PLT32) 1371 { 1372 r_type = R_SPARC_32; 1373 is_plt = true; 1374 goto r_sparc_plt32; 1375 } 1376 break; 1377 1378 case R_SPARC_PC10: 1379 case R_SPARC_PC22: 1380 if (h != NULL 1381 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1382 break; 1383 /* Fall through. */ 1384 case R_SPARC_DISP8: 1385 case R_SPARC_DISP16: 1386 case R_SPARC_DISP32: 1387 case R_SPARC_WDISP30: 1388 case R_SPARC_WDISP22: 1389 case R_SPARC_WDISP19: 1390 case R_SPARC_WDISP16: 1391 if (h == NULL 1392 || (info->symbolic 1393 && (h->elf_link_hash_flags 1394 & ELF_LINK_HASH_DEF_REGULAR) != 0)) 1395 break; 1396 /* Fall through. */ 1397 case R_SPARC_8: 1398 case R_SPARC_16: 1399 case R_SPARC_32: 1400 case R_SPARC_HI22: 1401 case R_SPARC_22: 1402 case R_SPARC_13: 1403 case R_SPARC_LO10: 1404 case R_SPARC_UA16: 1405 case R_SPARC_UA32: 1406 r_sparc_plt32: 1407 if (info->shared 1408 && r_symndx != 0 1409 && (input_section->flags & SEC_ALLOC)) 1410 { 1411 Elf_Internal_Rela outrel; 1412 boolean skip, relocate = false; 1413 1414 /* When generating a shared object, these relocations 1415 are copied into the output file to be resolved at run 1416 time. */ 1417 1418 if (sreloc == NULL) 1419 { 1420 const char *name; 1421 1422 name = (bfd_elf_string_from_elf_section 1423 (input_bfd, 1424 elf_elfheader (input_bfd)->e_shstrndx, 1425 elf_section_data (input_section)->rel_hdr.sh_name)); 1426 if (name == NULL) 1427 return false; 1428 1429 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 1430 && strcmp (bfd_get_section_name (input_bfd, 1431 input_section), 1432 name + 5) == 0); 1433 1434 sreloc = bfd_get_section_by_name (dynobj, name); 1435 BFD_ASSERT (sreloc != NULL); 1436 } 1437 1438 skip = false; 1439 1440 outrel.r_offset = 1441 _bfd_elf_section_offset (output_bfd, info, input_section, 1442 rel->r_offset); 1443 if (outrel.r_offset == (bfd_vma) -1) 1444 skip = true; 1445 else if (outrel.r_offset == (bfd_vma) -2) 1446 skip = true, relocate = true; 1447 outrel.r_offset += (input_section->output_section->vma 1448 + input_section->output_offset); 1449 1450 /* Optimize unaligned reloc usage now that we know where 1451 it finally resides. */ 1452 switch (r_type) 1453 { 1454 case R_SPARC_16: 1455 if (outrel.r_offset & 1) 1456 r_type = R_SPARC_UA16; 1457 break; 1458 case R_SPARC_UA16: 1459 if (!(outrel.r_offset & 1)) 1460 r_type = R_SPARC_16; 1461 break; 1462 case R_SPARC_32: 1463 if (outrel.r_offset & 3) 1464 r_type = R_SPARC_UA32; 1465 break; 1466 case R_SPARC_UA32: 1467 if (!(outrel.r_offset & 3)) 1468 r_type = R_SPARC_32; 1469 break; 1470 case R_SPARC_DISP8: 1471 case R_SPARC_DISP16: 1472 case R_SPARC_DISP32: 1473 /* If the symbol is not dynamic, we should not keep 1474 a dynamic relocation. But an .rela.* slot has been 1475 allocated for it, output R_SPARC_NONE. 1476 FIXME: Add code tracking needed dynamic relocs as 1477 e.g. i386 has. */ 1478 if (h->dynindx == -1) 1479 skip = true, relocate = true; 1480 break; 1481 } 1482 1483 if (skip) 1484 memset (&outrel, 0, sizeof outrel); 1485 /* h->dynindx may be -1 if the symbol was marked to 1486 become local. */ 1487 else if (h != NULL && ! is_plt 1488 && ((! info->symbolic && h->dynindx != -1) 1489 || (h->elf_link_hash_flags 1490 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 1491 { 1492 BFD_ASSERT (h->dynindx != -1); 1493 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 1494 outrel.r_addend = rel->r_addend; 1495 } 1496 else 1497 { 1498 if (r_type == R_SPARC_32) 1499 { 1500 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); 1501 outrel.r_addend = relocation + rel->r_addend; 1502 } 1503 else 1504 { 1505 long indx; 1506 1507 if (is_plt) 1508 sec = splt; 1509 else if (h == NULL) 1510 sec = local_sections[r_symndx]; 1511 else 1512 { 1513 BFD_ASSERT (h->root.type == bfd_link_hash_defined 1514 || (h->root.type 1515 == bfd_link_hash_defweak)); 1516 sec = h->root.u.def.section; 1517 } 1518 if (sec != NULL && bfd_is_abs_section (sec)) 1519 indx = 0; 1520 else if (sec == NULL || sec->owner == NULL) 1521 { 1522 bfd_set_error (bfd_error_bad_value); 1523 return false; 1524 } 1525 else 1526 { 1527 asection *osec; 1528 1529 osec = sec->output_section; 1530 indx = elf_section_data (osec)->dynindx; 1531 1532 /* FIXME: we really should be able to link non-pic 1533 shared libraries. */ 1534 if (indx == 0) 1535 { 1536 BFD_FAIL (); 1537 (*_bfd_error_handler) 1538 (_("%s: probably compiled without -fPIC?"), 1539 bfd_archive_filename (input_bfd)); 1540 bfd_set_error (bfd_error_bad_value); 1541 return false; 1542 } 1543 } 1544 1545 outrel.r_info = ELF32_R_INFO (indx, r_type); 1546 outrel.r_addend = relocation + rel->r_addend; 1547 } 1548 } 1549 1550 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 1551 (((Elf32_External_Rela *) 1552 sreloc->contents) 1553 + sreloc->reloc_count)); 1554 ++sreloc->reloc_count; 1555 1556 /* This reloc will be computed at runtime, so there's no 1557 need to do anything now. */ 1558 if (! relocate) 1559 continue; 1560 } 1561 break; 1562 1563 default: 1564 break; 1565 } 1566 1567 /* ??? Copied from elf32-i386.c, debugging section check and all. */ 1568 if (unresolved_reloc 1569 && !(info->shared 1570 && (input_section->flags & SEC_DEBUGGING) != 0 1571 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)) 1572 (*_bfd_error_handler) 1573 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"), 1574 bfd_archive_filename (input_bfd), 1575 bfd_get_section_name (input_bfd, input_section), 1576 (long) rel->r_offset, 1577 h->root.root.string); 1578 1579 r = bfd_reloc_continue; 1580 if (r_type == R_SPARC_WDISP16) 1581 { 1582 bfd_vma x; 1583 1584 relocation += rel->r_addend; 1585 relocation -= (input_section->output_section->vma 1586 + input_section->output_offset); 1587 relocation -= rel->r_offset; 1588 1589 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 1590 x |= ((((relocation >> 2) & 0xc000) << 6) 1591 | ((relocation >> 2) & 0x3fff)); 1592 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 1593 1594 if ((bfd_signed_vma) relocation < - 0x40000 1595 || (bfd_signed_vma) relocation > 0x3ffff) 1596 r = bfd_reloc_overflow; 1597 else 1598 r = bfd_reloc_ok; 1599 } 1600 else if (r_type == R_SPARC_REV32) 1601 { 1602 bfd_vma x; 1603 1604 relocation = relocation + rel->r_addend; 1605 1606 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 1607 x = x + relocation; 1608 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset); 1609 r = bfd_reloc_ok; 1610 } 1611 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30) 1612 && SEC_DO_RELAX (input_section) 1613 && rel->r_offset + 4 < input_section->_raw_size) 1614 { 1615#define G0 0 1616#define O7 15 1617#define XCC (2 << 20) 1618#define COND(x) (((x)&0xf)<<25) 1619#define CONDA COND(0x8) 1620#define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC) 1621#define INSN_BA (F2(0,2) | CONDA) 1622#define INSN_OR F3(2, 0x2, 0) 1623#define INSN_NOP F2(0,4) 1624 1625 bfd_vma x, y; 1626 1627 /* If the instruction is a call with either: 1628 restore 1629 arithmetic instruction with rd == %o7 1630 where rs1 != %o7 and rs2 if it is register != %o7 1631 then we can optimize if the call destination is near 1632 by changing the call into a branch always. */ 1633 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 1634 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4); 1635 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2)) 1636 { 1637 if (((y & OP3(~0)) == OP3(0x3d) /* restore */ 1638 || ((y & OP3(0x28)) == 0 /* arithmetic */ 1639 && (y & RD(~0)) == RD(O7))) 1640 && (y & RS1(~0)) != RS1(O7) 1641 && ((y & F3I(~0)) 1642 || (y & RS2(~0)) != RS2(O7))) 1643 { 1644 bfd_vma reloc; 1645 1646 reloc = relocation + rel->r_addend - rel->r_offset; 1647 reloc -= (input_section->output_section->vma 1648 + input_section->output_offset); 1649 1650 /* Ensure the reloc fits into simm22. */ 1651 if ((reloc & 3) == 0 1652 && ((reloc & ~(bfd_vma)0x7fffff) == 0 1653 || ((reloc | 0x7fffff) == ~(bfd_vma)0))) 1654 { 1655 reloc >>= 2; 1656 1657 /* Check whether it fits into simm19 on v9. */ 1658 if (((reloc & 0x3c0000) == 0 1659 || (reloc & 0x3c0000) == 0x3c0000) 1660 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS)) 1661 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */ 1662 else 1663 x = INSN_BA | (reloc & 0x3fffff); /* ba */ 1664 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 1665 r = bfd_reloc_ok; 1666 if (rel->r_offset >= 4 1667 && (y & (0xffffffff ^ RS1(~0))) 1668 == (INSN_OR | RD(O7) | RS2(G0))) 1669 { 1670 bfd_vma z; 1671 unsigned int reg; 1672 1673 z = bfd_get_32 (input_bfd, 1674 contents + rel->r_offset - 4); 1675 if ((z & (0xffffffff ^ RD(~0))) 1676 != (INSN_OR | RS1(O7) | RS2(G0))) 1677 break; 1678 1679 /* The sequence was 1680 or %o7, %g0, %rN 1681 call foo 1682 or %rN, %g0, %o7 1683 1684 If call foo was replaced with ba, replace 1685 or %rN, %g0, %o7 with nop. */ 1686 1687 reg = (y & RS1(~0)) >> 14; 1688 if (reg != ((z & RD(~0)) >> 25) 1689 || reg == G0 || reg == O7) 1690 break; 1691 1692 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP, 1693 contents + rel->r_offset + 4); 1694 } 1695 1696 } 1697 } 1698 } 1699 } 1700 1701 if (r == bfd_reloc_continue) 1702 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1703 contents, rel->r_offset, 1704 relocation, rel->r_addend); 1705 1706 if (r != bfd_reloc_ok) 1707 { 1708 switch (r) 1709 { 1710 default: 1711 case bfd_reloc_outofrange: 1712 abort (); 1713 case bfd_reloc_overflow: 1714 { 1715 const char *name; 1716 1717 if (h != NULL) 1718 name = h->root.root.string; 1719 else 1720 { 1721 name = bfd_elf_string_from_elf_section (input_bfd, 1722 symtab_hdr->sh_link, 1723 sym->st_name); 1724 if (name == NULL) 1725 return false; 1726 if (*name == '\0') 1727 name = bfd_section_name (input_bfd, sec); 1728 } 1729 if (! ((*info->callbacks->reloc_overflow) 1730 (info, name, howto->name, (bfd_vma) 0, 1731 input_bfd, input_section, rel->r_offset))) 1732 return false; 1733 } 1734 break; 1735 } 1736 } 1737 } 1738 1739 return true; 1740} 1741 1742/* Finish up dynamic symbol handling. We set the contents of various 1743 dynamic sections here. */ 1744 1745static boolean 1746elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym) 1747 bfd *output_bfd; 1748 struct bfd_link_info *info; 1749 struct elf_link_hash_entry *h; 1750 Elf_Internal_Sym *sym; 1751{ 1752 bfd *dynobj; 1753 1754 dynobj = elf_hash_table (info)->dynobj; 1755 1756 if (h->plt.offset != (bfd_vma) -1) 1757 { 1758 asection *splt; 1759 asection *srela; 1760 Elf_Internal_Rela rela; 1761 1762 /* This symbol has an entry in the procedure linkage table. Set 1763 it up. */ 1764 1765 BFD_ASSERT (h->dynindx != -1); 1766 1767 splt = bfd_get_section_by_name (dynobj, ".plt"); 1768 srela = bfd_get_section_by_name (dynobj, ".rela.plt"); 1769 BFD_ASSERT (splt != NULL && srela != NULL); 1770 1771 /* Fill in the entry in the procedure linkage table. */ 1772 bfd_put_32 (output_bfd, 1773 PLT_ENTRY_WORD0 + h->plt.offset, 1774 splt->contents + h->plt.offset); 1775 bfd_put_32 (output_bfd, 1776 (PLT_ENTRY_WORD1 1777 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)), 1778 splt->contents + h->plt.offset + 4); 1779 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2, 1780 splt->contents + h->plt.offset + 8); 1781 1782 /* Fill in the entry in the .rela.plt section. */ 1783 rela.r_offset = (splt->output_section->vma 1784 + splt->output_offset 1785 + h->plt.offset); 1786 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT); 1787 rela.r_addend = 0; 1788 bfd_elf32_swap_reloca_out (output_bfd, &rela, 1789 ((Elf32_External_Rela *) srela->contents 1790 + h->plt.offset / PLT_ENTRY_SIZE - 4)); 1791 1792 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1793 { 1794 /* Mark the symbol as undefined, rather than as defined in 1795 the .plt section. Leave the value alone. */ 1796 sym->st_shndx = SHN_UNDEF; 1797 /* If the symbol is weak, we do need to clear the value. 1798 Otherwise, the PLT entry would provide a definition for 1799 the symbol even if the symbol wasn't defined anywhere, 1800 and so the symbol would never be NULL. */ 1801 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK) 1802 == 0) 1803 sym->st_value = 0; 1804 } 1805 } 1806 1807 if (h->got.offset != (bfd_vma) -1) 1808 { 1809 asection *sgot; 1810 asection *srela; 1811 Elf_Internal_Rela rela; 1812 1813 /* This symbol has an entry in the global offset table. Set it 1814 up. */ 1815 1816 sgot = bfd_get_section_by_name (dynobj, ".got"); 1817 srela = bfd_get_section_by_name (dynobj, ".rela.got"); 1818 BFD_ASSERT (sgot != NULL && srela != NULL); 1819 1820 rela.r_offset = (sgot->output_section->vma 1821 + sgot->output_offset 1822 + (h->got.offset &~ (bfd_vma) 1)); 1823 1824 /* If this is a -Bsymbolic link, and the symbol is defined 1825 locally, we just want to emit a RELATIVE reloc. Likewise if 1826 the symbol was forced to be local because of a version file. 1827 The entry in the global offset table will already have been 1828 initialized in the relocate_section function. */ 1829 if (info->shared 1830 && (info->symbolic || h->dynindx == -1) 1831 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 1832 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); 1833 else 1834 { 1835 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 1836 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT); 1837 } 1838 1839 rela.r_addend = 0; 1840 bfd_elf32_swap_reloca_out (output_bfd, &rela, 1841 ((Elf32_External_Rela *) srela->contents 1842 + srela->reloc_count)); 1843 ++srela->reloc_count; 1844 } 1845 1846 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 1847 { 1848 asection *s; 1849 Elf_Internal_Rela rela; 1850 1851 /* This symbols needs a copy reloc. Set it up. */ 1852 1853 BFD_ASSERT (h->dynindx != -1); 1854 1855 s = bfd_get_section_by_name (h->root.u.def.section->owner, 1856 ".rela.bss"); 1857 BFD_ASSERT (s != NULL); 1858 1859 rela.r_offset = (h->root.u.def.value 1860 + h->root.u.def.section->output_section->vma 1861 + h->root.u.def.section->output_offset); 1862 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY); 1863 rela.r_addend = 0; 1864 bfd_elf32_swap_reloca_out (output_bfd, &rela, 1865 ((Elf32_External_Rela *) s->contents 1866 + s->reloc_count)); 1867 ++s->reloc_count; 1868 } 1869 1870 /* Mark some specially defined symbols as absolute. */ 1871 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 1872 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 1873 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0) 1874 sym->st_shndx = SHN_ABS; 1875 1876 return true; 1877} 1878 1879/* Finish up the dynamic sections. */ 1880 1881static boolean 1882elf32_sparc_finish_dynamic_sections (output_bfd, info) 1883 bfd *output_bfd; 1884 struct bfd_link_info *info; 1885{ 1886 bfd *dynobj; 1887 asection *sdyn; 1888 asection *sgot; 1889 1890 dynobj = elf_hash_table (info)->dynobj; 1891 1892 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 1893 1894 if (elf_hash_table (info)->dynamic_sections_created) 1895 { 1896 asection *splt; 1897 Elf32_External_Dyn *dyncon, *dynconend; 1898 1899 splt = bfd_get_section_by_name (dynobj, ".plt"); 1900 BFD_ASSERT (splt != NULL && sdyn != NULL); 1901 1902 dyncon = (Elf32_External_Dyn *) sdyn->contents; 1903 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 1904 for (; dyncon < dynconend; dyncon++) 1905 { 1906 Elf_Internal_Dyn dyn; 1907 const char *name; 1908 boolean size; 1909 1910 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 1911 1912 switch (dyn.d_tag) 1913 { 1914 case DT_PLTGOT: name = ".plt"; size = false; break; 1915 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break; 1916 case DT_JMPREL: name = ".rela.plt"; size = false; break; 1917 default: name = NULL; size = false; break; 1918 } 1919 1920 if (name != NULL) 1921 { 1922 asection *s; 1923 1924 s = bfd_get_section_by_name (output_bfd, name); 1925 if (s == NULL) 1926 dyn.d_un.d_val = 0; 1927 else 1928 { 1929 if (! size) 1930 dyn.d_un.d_ptr = s->vma; 1931 else 1932 { 1933 if (s->_cooked_size != 0) 1934 dyn.d_un.d_val = s->_cooked_size; 1935 else 1936 dyn.d_un.d_val = s->_raw_size; 1937 } 1938 } 1939 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1940 } 1941 } 1942 1943 /* Clear the first four entries in the procedure linkage table, 1944 and put a nop in the last four bytes. */ 1945 if (splt->_raw_size > 0) 1946 { 1947 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE); 1948 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, 1949 splt->contents + splt->_raw_size - 4); 1950 } 1951 1952 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 1953 PLT_ENTRY_SIZE; 1954 } 1955 1956 /* Set the first entry in the global offset table to the address of 1957 the dynamic section. */ 1958 sgot = bfd_get_section_by_name (dynobj, ".got"); 1959 BFD_ASSERT (sgot != NULL); 1960 if (sgot->_raw_size > 0) 1961 { 1962 if (sdyn == NULL) 1963 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 1964 else 1965 bfd_put_32 (output_bfd, 1966 sdyn->output_section->vma + sdyn->output_offset, 1967 sgot->contents); 1968 } 1969 1970 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 1971 1972 return true; 1973} 1974 1975/* Functions for dealing with the e_flags field. 1976 1977 We don't define set_private_flags or copy_private_bfd_data because 1978 the only currently defined values are based on the bfd mach number, 1979 so we use the latter instead and defer setting e_flags until the 1980 file is written out. */ 1981 1982/* Merge backend specific data from an object file to the output 1983 object file when linking. */ 1984 1985static boolean 1986elf32_sparc_merge_private_bfd_data (ibfd, obfd) 1987 bfd *ibfd; 1988 bfd *obfd; 1989{ 1990 boolean error; 1991 /* FIXME: This should not be static. */ 1992 static unsigned long previous_ibfd_e_flags = (unsigned long) -1; 1993 1994 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1995 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 1996 return true; 1997 1998 error = false; 1999 2000 if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9) 2001 { 2002 error = true; 2003 (*_bfd_error_handler) 2004 (_("%s: compiled for a 64 bit system and target is 32 bit"), 2005 bfd_archive_filename (ibfd)); 2006 } 2007 else if ((ibfd->flags & DYNAMIC) == 0) 2008 { 2009 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd)) 2010 bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd)); 2011 } 2012 2013 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA) 2014 != previous_ibfd_e_flags) 2015 && previous_ibfd_e_flags != (unsigned long) -1) 2016 { 2017 (*_bfd_error_handler) 2018 (_("%s: linking little endian files with big endian files"), 2019 bfd_archive_filename (ibfd)); 2020 error = true; 2021 } 2022 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA; 2023 2024 if (error) 2025 { 2026 bfd_set_error (bfd_error_bad_value); 2027 return false; 2028 } 2029 2030 return true; 2031} 2032 2033/* Set the right machine number. */ 2034 2035static boolean 2036elf32_sparc_object_p (abfd) 2037 bfd *abfd; 2038{ 2039 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS) 2040 { 2041 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3) 2042 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 2043 bfd_mach_sparc_v8plusb); 2044 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1) 2045 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 2046 bfd_mach_sparc_v8plusa); 2047 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS) 2048 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 2049 bfd_mach_sparc_v8plus); 2050 else 2051 return false; 2052 } 2053 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA) 2054 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 2055 bfd_mach_sparc_sparclite_le); 2056 else 2057 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc); 2058} 2059 2060/* The final processing done just before writing out the object file. 2061 We need to set the e_machine field appropriately. */ 2062 2063static void 2064elf32_sparc_final_write_processing (abfd, linker) 2065 bfd *abfd; 2066 boolean linker ATTRIBUTE_UNUSED; 2067{ 2068 switch (bfd_get_mach (abfd)) 2069 { 2070 case bfd_mach_sparc : 2071 break; /* nothing to do */ 2072 case bfd_mach_sparc_v8plus : 2073 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; 2074 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; 2075 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS; 2076 break; 2077 case bfd_mach_sparc_v8plusa : 2078 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; 2079 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; 2080 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1; 2081 break; 2082 case bfd_mach_sparc_v8plusb : 2083 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; 2084 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; 2085 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1 2086 | EF_SPARC_SUN_US3; 2087 break; 2088 case bfd_mach_sparc_sparclite_le : 2089 elf_elfheader (abfd)->e_machine = EM_SPARC; 2090 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA; 2091 break; 2092 default : 2093 abort (); 2094 break; 2095 } 2096} 2097 2098static enum elf_reloc_type_class 2099elf32_sparc_reloc_type_class (rela) 2100 const Elf_Internal_Rela *rela; 2101{ 2102 switch ((int) ELF32_R_TYPE (rela->r_info)) 2103 { 2104 case R_SPARC_RELATIVE: 2105 return reloc_class_relative; 2106 case R_SPARC_JMP_SLOT: 2107 return reloc_class_plt; 2108 case R_SPARC_COPY: 2109 return reloc_class_copy; 2110 default: 2111 return reloc_class_normal; 2112 } 2113} 2114 2115#define TARGET_BIG_SYM bfd_elf32_sparc_vec 2116#define TARGET_BIG_NAME "elf32-sparc" 2117#define ELF_ARCH bfd_arch_sparc 2118#define ELF_MACHINE_CODE EM_SPARC 2119#define ELF_MACHINE_ALT1 EM_SPARC32PLUS 2120#define ELF_MAXPAGESIZE 0x10000 2121 2122#define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup 2123#define bfd_elf32_bfd_relax_section elf32_sparc_relax_section 2124#define elf_info_to_howto elf32_sparc_info_to_howto 2125#define elf_backend_create_dynamic_sections \ 2126 _bfd_elf_create_dynamic_sections 2127#define elf_backend_check_relocs elf32_sparc_check_relocs 2128#define elf_backend_adjust_dynamic_symbol \ 2129 elf32_sparc_adjust_dynamic_symbol 2130#define elf_backend_size_dynamic_sections \ 2131 elf32_sparc_size_dynamic_sections 2132#define elf_backend_relocate_section elf32_sparc_relocate_section 2133#define elf_backend_finish_dynamic_symbol \ 2134 elf32_sparc_finish_dynamic_symbol 2135#define elf_backend_finish_dynamic_sections \ 2136 elf32_sparc_finish_dynamic_sections 2137#define bfd_elf32_bfd_merge_private_bfd_data \ 2138 elf32_sparc_merge_private_bfd_data 2139#define elf_backend_object_p elf32_sparc_object_p 2140#define elf_backend_final_write_processing \ 2141 elf32_sparc_final_write_processing 2142#define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook 2143#define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook 2144#define elf_backend_reloc_type_class elf32_sparc_reloc_type_class 2145 2146#define elf_backend_can_gc_sections 1 2147#define elf_backend_want_got_plt 0 2148#define elf_backend_plt_readonly 0 2149#define elf_backend_want_plt_sym 1 2150#define elf_backend_got_header_size 4 2151#define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE) 2152 2153#include "elf32-target.h" 2154