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