1/* SPARC-specific support for 32-bit ELF 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004 Free Software Foundation, Inc. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, 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 bfd_boolean elf32_sparc_check_relocs 34 PARAMS ((bfd *, struct bfd_link_info *, asection *, 35 const Elf_Internal_Rela *)); 36static bfd_boolean elf32_sparc_adjust_dynamic_symbol 37 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 38static bfd_boolean allocate_dynrelocs 39 PARAMS ((struct elf_link_hash_entry *, PTR)); 40static bfd_boolean readonly_dynrelocs 41 PARAMS ((struct elf_link_hash_entry *, PTR)); 42static bfd_boolean elf32_sparc_size_dynamic_sections 43 PARAMS ((bfd *, struct bfd_link_info *)); 44static bfd_boolean elf32_sparc_new_section_hook 45 PARAMS ((bfd *, asection *)); 46static bfd_boolean elf32_sparc_relax_section 47 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *)); 48static bfd_vma dtpoff_base 49 PARAMS ((struct bfd_link_info *)); 50static bfd_vma tpoff 51 PARAMS ((struct bfd_link_info *, bfd_vma)); 52static bfd_boolean elf32_sparc_relocate_section 53 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 54 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 55static bfd_boolean elf32_sparc_finish_dynamic_symbol 56 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 57 Elf_Internal_Sym *)); 58static bfd_boolean elf32_sparc_finish_dynamic_sections 59 PARAMS ((bfd *, struct bfd_link_info *)); 60static bfd_boolean elf32_sparc_merge_private_bfd_data 61 PARAMS ((bfd *, bfd *)); 62static struct bfd_hash_entry *link_hash_newfunc 63 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 64static struct bfd_link_hash_table *elf32_sparc_link_hash_table_create 65 PARAMS ((bfd *)); 66static bfd_boolean create_got_section 67 PARAMS ((bfd *, struct bfd_link_info *)); 68static bfd_boolean elf32_sparc_create_dynamic_sections 69 PARAMS ((bfd *, struct bfd_link_info *)); 70static void elf32_sparc_copy_indirect_symbol 71 PARAMS ((const struct elf_backend_data *, struct elf_link_hash_entry *, 72 struct elf_link_hash_entry *)); 73static int elf32_sparc_tls_transition 74 PARAMS ((struct bfd_link_info *, bfd *, int, int)); 75 76static bfd_boolean elf32_sparc_mkobject 77 PARAMS ((bfd *)); 78static bfd_boolean elf32_sparc_object_p 79 PARAMS ((bfd *)); 80static void elf32_sparc_final_write_processing 81 PARAMS ((bfd *, bfd_boolean)); 82static enum elf_reloc_type_class elf32_sparc_reloc_type_class 83 PARAMS ((const Elf_Internal_Rela *)); 84static asection * elf32_sparc_gc_mark_hook 85 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *, 86 struct elf_link_hash_entry *, Elf_Internal_Sym *)); 87static bfd_boolean elf32_sparc_gc_sweep_hook 88 PARAMS ((bfd *, struct bfd_link_info *, asection *, 89 const Elf_Internal_Rela *)); 90 91/* The relocation "howto" table. */ 92 93static bfd_reloc_status_type sparc_elf_notsupported_reloc 94 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 95static bfd_reloc_status_type sparc_elf_wdisp16_reloc 96 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 97static bfd_reloc_status_type sparc_elf_hix22_reloc 98 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 99static bfd_reloc_status_type sparc_elf_lox10_reloc 100 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 101 102reloc_howto_type _bfd_sparc_elf_howto_table[] = 103{ 104 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 105 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE), 106 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE), 107 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE), 108 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE), 109 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE), 110 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE), 111 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE), 112 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE), 113 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE), 114 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE), 115 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE), 116 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE), 117 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE), 118 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE), 119 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE), 120 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE), 121 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE), 122 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE), 123 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE), 124 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), 125 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), 126 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE), 127 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE), 128 HOWTO(R_SPARC_PLT32, 0,0,00,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE), 129 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE), 130 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE), 131 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE), 132 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE), 133 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE), 134 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE), 135 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE), 136 /* These are for sparc64 in a 64 bit environment. 137 Values need to be here because the table is indexed by reloc number. */ 138 HOWTO(R_SPARC_64, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_64", FALSE,0,0x00000000,TRUE), 139 HOWTO(R_SPARC_OLO10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_OLO10", FALSE,0,0x00000000,TRUE), 140 HOWTO(R_SPARC_HH22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HH22", FALSE,0,0x00000000,TRUE), 141 HOWTO(R_SPARC_HM10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HM10", FALSE,0,0x00000000,TRUE), 142 HOWTO(R_SPARC_LM22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LM22", FALSE,0,0x00000000,TRUE), 143 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), 144 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), 145 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), 146 /* End sparc64 in 64 bit environment values. 147 The following are for sparc64 in a 32 bit environment. */ 148 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE), 149 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE), 150 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), 151 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE), 152 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE), 153 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE), 154 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 155 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 156 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 157 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 158 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 159 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 160 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 161 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE), 162 HOWTO(R_SPARC_UA64, 0,0, 0,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_UA64", FALSE,0,0x00000000,TRUE), 163 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE), 164 HOWTO(R_SPARC_TLS_GD_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_HI22",FALSE,0,0x003fffff,TRUE), 165 HOWTO(R_SPARC_TLS_GD_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_LO10",FALSE,0,0x000003ff,TRUE), 166 HOWTO(R_SPARC_TLS_GD_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_ADD",FALSE,0,0x00000000,TRUE), 167 HOWTO(R_SPARC_TLS_GD_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_GD_CALL",FALSE,0,0x3fffffff,TRUE), 168 HOWTO(R_SPARC_TLS_LDM_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_HI22",FALSE,0,0x003fffff,TRUE), 169 HOWTO(R_SPARC_TLS_LDM_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_LO10",FALSE,0,0x000003ff,TRUE), 170 HOWTO(R_SPARC_TLS_LDM_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_ADD",FALSE,0,0x00000000,TRUE), 171 HOWTO(R_SPARC_TLS_LDM_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_TLS_LDM_CALL",FALSE,0,0x3fffffff,TRUE), 172 HOWTO(R_SPARC_TLS_LDO_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_TLS_LDO_HIX22",FALSE,0,0x003fffff, FALSE), 173 HOWTO(R_SPARC_TLS_LDO_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LDO_LOX10",FALSE,0,0x000003ff, FALSE), 174 HOWTO(R_SPARC_TLS_LDO_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_LDO_ADD",FALSE,0,0x00000000,TRUE), 175 HOWTO(R_SPARC_TLS_IE_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_HI22",FALSE,0,0x003fffff,TRUE), 176 HOWTO(R_SPARC_TLS_IE_LO10,0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LO10",FALSE,0,0x000003ff,TRUE), 177 HOWTO(R_SPARC_TLS_IE_LD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LD",FALSE,0,0x00000000,TRUE), 178 HOWTO(R_SPARC_TLS_IE_LDX,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_LDX",FALSE,0,0x00000000,TRUE), 179 HOWTO(R_SPARC_TLS_IE_ADD,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_IE_ADD",FALSE,0,0x00000000,TRUE), 180 HOWTO(R_SPARC_TLS_LE_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_TLS_LE_HIX22",FALSE,0,0x003fffff, FALSE), 181 HOWTO(R_SPARC_TLS_LE_LOX10,0,2,0,FALSE,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_TLS_LE_LOX10",FALSE,0,0x000003ff, FALSE), 182 HOWTO(R_SPARC_TLS_DTPMOD32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD32",FALSE,0,0x00000000,TRUE), 183 HOWTO(R_SPARC_TLS_DTPMOD64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPMOD64",FALSE,0,0x00000000,TRUE), 184 HOWTO(R_SPARC_TLS_DTPOFF32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF32",FALSE,0,0xffffffff,TRUE), 185 HOWTO(R_SPARC_TLS_DTPOFF64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPOFF64",FALSE,0,0x00000000,TRUE), 186 HOWTO(R_SPARC_TLS_TPOFF32,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF32",FALSE,0,0x00000000,TRUE), 187 HOWTO(R_SPARC_TLS_TPOFF64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_TPOFF64",FALSE,0,0x00000000,TRUE) 188}; 189static reloc_howto_type elf32_sparc_vtinherit_howto = 190 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE); 191static reloc_howto_type elf32_sparc_vtentry_howto = 192 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); 193static reloc_howto_type elf32_sparc_rev32_howto = 194 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE); 195 196struct elf_reloc_map { 197 bfd_reloc_code_real_type bfd_reloc_val; 198 unsigned char elf_reloc_val; 199}; 200 201static const struct elf_reloc_map sparc_reloc_map[] = 202{ 203 { BFD_RELOC_NONE, R_SPARC_NONE, }, 204 { BFD_RELOC_16, R_SPARC_16, }, 205 { BFD_RELOC_16_PCREL, R_SPARC_DISP16 }, 206 { BFD_RELOC_8, R_SPARC_8 }, 207 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 }, 208 { BFD_RELOC_CTOR, R_SPARC_32 }, 209 { BFD_RELOC_32, R_SPARC_32 }, 210 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 }, 211 { BFD_RELOC_HI22, R_SPARC_HI22 }, 212 { BFD_RELOC_LO10, R_SPARC_LO10, }, 213 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 }, 214 { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 }, 215 { BFD_RELOC_SPARC22, R_SPARC_22 }, 216 { BFD_RELOC_SPARC13, R_SPARC_13 }, 217 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 }, 218 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 }, 219 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 }, 220 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 }, 221 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 }, 222 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 }, 223 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY }, 224 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT }, 225 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT }, 226 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE }, 227 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 }, 228 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 }, 229 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, 230 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 }, 231 { BFD_RELOC_SPARC_10, R_SPARC_10 }, 232 { BFD_RELOC_SPARC_11, R_SPARC_11 }, 233 { BFD_RELOC_SPARC_64, R_SPARC_64 }, 234 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 }, 235 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 }, 236 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 }, 237 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 }, 238 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 }, 239 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 }, 240 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 }, 241 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 }, 242 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 }, 243 { BFD_RELOC_SPARC_7, R_SPARC_7 }, 244 { BFD_RELOC_SPARC_5, R_SPARC_5 }, 245 { BFD_RELOC_SPARC_6, R_SPARC_6 }, 246 { BFD_RELOC_SPARC_TLS_GD_HI22, R_SPARC_TLS_GD_HI22 }, 247 { BFD_RELOC_SPARC_TLS_GD_LO10, R_SPARC_TLS_GD_LO10 }, 248 { BFD_RELOC_SPARC_TLS_GD_ADD, R_SPARC_TLS_GD_ADD }, 249 { BFD_RELOC_SPARC_TLS_GD_CALL, R_SPARC_TLS_GD_CALL }, 250 { BFD_RELOC_SPARC_TLS_LDM_HI22, R_SPARC_TLS_LDM_HI22 }, 251 { BFD_RELOC_SPARC_TLS_LDM_LO10, R_SPARC_TLS_LDM_LO10 }, 252 { BFD_RELOC_SPARC_TLS_LDM_ADD, R_SPARC_TLS_LDM_ADD }, 253 { BFD_RELOC_SPARC_TLS_LDM_CALL, R_SPARC_TLS_LDM_CALL }, 254 { BFD_RELOC_SPARC_TLS_LDO_HIX22, R_SPARC_TLS_LDO_HIX22 }, 255 { BFD_RELOC_SPARC_TLS_LDO_LOX10, R_SPARC_TLS_LDO_LOX10 }, 256 { BFD_RELOC_SPARC_TLS_LDO_ADD, R_SPARC_TLS_LDO_ADD }, 257 { BFD_RELOC_SPARC_TLS_IE_HI22, R_SPARC_TLS_IE_HI22 }, 258 { BFD_RELOC_SPARC_TLS_IE_LO10, R_SPARC_TLS_IE_LO10 }, 259 { BFD_RELOC_SPARC_TLS_IE_LD, R_SPARC_TLS_IE_LD }, 260 { BFD_RELOC_SPARC_TLS_IE_LDX, R_SPARC_TLS_IE_LDX }, 261 { BFD_RELOC_SPARC_TLS_IE_ADD, R_SPARC_TLS_IE_ADD }, 262 { BFD_RELOC_SPARC_TLS_LE_HIX22, R_SPARC_TLS_LE_HIX22 }, 263 { BFD_RELOC_SPARC_TLS_LE_LOX10, R_SPARC_TLS_LE_LOX10 }, 264 { BFD_RELOC_SPARC_TLS_DTPMOD32, R_SPARC_TLS_DTPMOD32 }, 265 { BFD_RELOC_SPARC_TLS_DTPMOD64, R_SPARC_TLS_DTPMOD64 }, 266 { BFD_RELOC_SPARC_TLS_DTPOFF32, R_SPARC_TLS_DTPOFF32 }, 267 { BFD_RELOC_SPARC_TLS_DTPOFF64, R_SPARC_TLS_DTPOFF64 }, 268 { BFD_RELOC_SPARC_TLS_TPOFF32, R_SPARC_TLS_TPOFF32 }, 269 { BFD_RELOC_SPARC_TLS_TPOFF64, R_SPARC_TLS_TPOFF64 }, 270 { BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT }, 271 { BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY }, 272 { BFD_RELOC_SPARC_REV32, R_SPARC_REV32 } 273}; 274 275static reloc_howto_type * 276elf32_sparc_reloc_type_lookup (abfd, code) 277 bfd *abfd ATTRIBUTE_UNUSED; 278 bfd_reloc_code_real_type code; 279{ 280 unsigned int i; 281 282 switch (code) 283 { 284 case BFD_RELOC_VTABLE_INHERIT: 285 return &elf32_sparc_vtinherit_howto; 286 287 case BFD_RELOC_VTABLE_ENTRY: 288 return &elf32_sparc_vtentry_howto; 289 290 case BFD_RELOC_SPARC_REV32: 291 return &elf32_sparc_rev32_howto; 292 293 default: 294 for (i = 0; 295 i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); 296 i++) 297 { 298 if (sparc_reloc_map[i].bfd_reloc_val == code) 299 return (_bfd_sparc_elf_howto_table 300 + (int) sparc_reloc_map[i].elf_reloc_val); 301 } 302 } 303 bfd_set_error (bfd_error_bad_value); 304 return NULL; 305} 306 307/* We need to use ELF32_R_TYPE so we have our own copy of this function, 308 and elf64-sparc.c has its own copy. */ 309 310static void 311elf32_sparc_info_to_howto (abfd, cache_ptr, dst) 312 bfd *abfd ATTRIBUTE_UNUSED; 313 arelent *cache_ptr; 314 Elf_Internal_Rela *dst; 315{ 316 switch (ELF32_R_TYPE(dst->r_info)) 317 { 318 case R_SPARC_GNU_VTINHERIT: 319 cache_ptr->howto = &elf32_sparc_vtinherit_howto; 320 break; 321 322 case R_SPARC_GNU_VTENTRY: 323 cache_ptr->howto = &elf32_sparc_vtentry_howto; 324 break; 325 326 case R_SPARC_REV32: 327 cache_ptr->howto = &elf32_sparc_rev32_howto; 328 break; 329 330 default: 331 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std); 332 cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)]; 333 } 334} 335 336/* For unsupported relocs. */ 337 338static bfd_reloc_status_type 339sparc_elf_notsupported_reloc (abfd, 340 reloc_entry, 341 symbol, 342 data, 343 input_section, 344 output_bfd, 345 error_message) 346 bfd *abfd ATTRIBUTE_UNUSED; 347 arelent *reloc_entry ATTRIBUTE_UNUSED; 348 asymbol *symbol ATTRIBUTE_UNUSED; 349 PTR data ATTRIBUTE_UNUSED; 350 asection *input_section ATTRIBUTE_UNUSED; 351 bfd *output_bfd ATTRIBUTE_UNUSED; 352 char **error_message ATTRIBUTE_UNUSED; 353{ 354 return bfd_reloc_notsupported; 355} 356 357/* Handle the WDISP16 reloc. */ 358 359static bfd_reloc_status_type 360sparc_elf_wdisp16_reloc (abfd, 361 reloc_entry, 362 symbol, 363 data, 364 input_section, 365 output_bfd, 366 error_message) 367 bfd *abfd; 368 arelent *reloc_entry; 369 asymbol *symbol; 370 PTR data; 371 asection *input_section; 372 bfd *output_bfd; 373 char **error_message ATTRIBUTE_UNUSED; 374{ 375 bfd_vma relocation; 376 bfd_vma x; 377 378 if (output_bfd != (bfd *) NULL 379 && (symbol->flags & BSF_SECTION_SYM) == 0 380 && (! reloc_entry->howto->partial_inplace 381 || reloc_entry->addend == 0)) 382 { 383 reloc_entry->address += input_section->output_offset; 384 return bfd_reloc_ok; 385 } 386 387 if (output_bfd != NULL) 388 return bfd_reloc_continue; 389 390 if (reloc_entry->address > input_section->_cooked_size) 391 return bfd_reloc_outofrange; 392 393 relocation = (symbol->value 394 + symbol->section->output_section->vma 395 + symbol->section->output_offset); 396 relocation += reloc_entry->addend; 397 relocation -= (input_section->output_section->vma 398 + input_section->output_offset); 399 relocation -= reloc_entry->address; 400 401 x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 402 x |= ((((relocation >> 2) & 0xc000) << 6) 403 | ((relocation >> 2) & 0x3fff)); 404 bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address); 405 406 if ((bfd_signed_vma) relocation < - 0x40000 407 || (bfd_signed_vma) relocation > 0x3ffff) 408 return bfd_reloc_overflow; 409 else 410 return bfd_reloc_ok; 411} 412 413/* Handle the HIX22 reloc. */ 414 415static bfd_reloc_status_type 416sparc_elf_hix22_reloc (abfd, 417 reloc_entry, 418 symbol, 419 data, 420 input_section, 421 output_bfd, 422 error_message) 423 bfd *abfd; 424 arelent *reloc_entry; 425 asymbol *symbol; 426 PTR data; 427 asection *input_section; 428 bfd *output_bfd; 429 char **error_message ATTRIBUTE_UNUSED; 430{ 431 bfd_vma relocation; 432 bfd_vma insn; 433 434 if (output_bfd != (bfd *) NULL 435 && (symbol->flags & BSF_SECTION_SYM) == 0) 436 { 437 reloc_entry->address += input_section->output_offset; 438 return bfd_reloc_ok; 439 } 440 441 if (output_bfd != NULL) 442 return bfd_reloc_continue; 443 444 if (reloc_entry->address > input_section->_cooked_size) 445 return bfd_reloc_outofrange; 446 447 relocation = (symbol->value 448 + symbol->section->output_section->vma 449 + symbol->section->output_offset); 450 relocation += reloc_entry->addend; 451 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 452 453 insn = (insn &~ (bfd_vma) 0x3fffff) | (((~relocation) >> 10) & 0x3fffff); 454 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 455 456 return bfd_reloc_ok; 457} 458 459/* Handle the LOX10 reloc. */ 460 461static bfd_reloc_status_type 462sparc_elf_lox10_reloc (abfd, 463 reloc_entry, 464 symbol, 465 data, 466 input_section, 467 output_bfd, 468 error_message) 469 bfd *abfd; 470 arelent *reloc_entry; 471 asymbol *symbol; 472 PTR data; 473 asection *input_section; 474 bfd *output_bfd; 475 char **error_message ATTRIBUTE_UNUSED; 476{ 477 bfd_vma relocation; 478 bfd_vma insn; 479 480 if (output_bfd != (bfd *) NULL 481 && (symbol->flags & BSF_SECTION_SYM) == 0) 482 { 483 reloc_entry->address += input_section->output_offset; 484 return bfd_reloc_ok; 485 } 486 487 if (output_bfd != NULL) 488 return bfd_reloc_continue; 489 490 if (reloc_entry->address > input_section->_cooked_size) 491 return bfd_reloc_outofrange; 492 493 relocation = (symbol->value 494 + symbol->section->output_section->vma 495 + symbol->section->output_offset); 496 relocation += reloc_entry->addend; 497 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 498 499 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff); 500 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 501 502 return bfd_reloc_ok; 503} 504 505/* Support for core dump NOTE sections. */ 506 507static bfd_boolean 508elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 509{ 510 switch (note->descsz) 511 { 512 default: 513 return FALSE; 514 515 case 260: /* Solaris prpsinfo_t. */ 516 elf_tdata (abfd)->core_program 517 = _bfd_elfcore_strndup (abfd, note->descdata + 84, 16); 518 elf_tdata (abfd)->core_command 519 = _bfd_elfcore_strndup (abfd, note->descdata + 100, 80); 520 break; 521 522 case 336: /* Solaris psinfo_t. */ 523 elf_tdata (abfd)->core_program 524 = _bfd_elfcore_strndup (abfd, note->descdata + 88, 16); 525 elf_tdata (abfd)->core_command 526 = _bfd_elfcore_strndup (abfd, note->descdata + 104, 80); 527 break; 528 } 529 530 return TRUE; 531} 532 533 534/* Functions for the SPARC ELF linker. */ 535 536/* The name of the dynamic interpreter. This is put in the .interp 537 section. */ 538 539#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 540 541/* The nop opcode we use. */ 542 543#define SPARC_NOP 0x01000000 544 545/* The size in bytes of an entry in the procedure linkage table. */ 546 547#define PLT_ENTRY_SIZE 12 548 549/* The first four entries in a procedure linkage table are reserved, 550 and the initial contents are unimportant (we zero them out). 551 Subsequent entries look like this. See the SVR4 ABI SPARC 552 supplement to see how this works. */ 553 554/* sethi %hi(.-.plt0),%g1. We fill in the address later. */ 555#define PLT_ENTRY_WORD0 0x03000000 556/* b,a .plt0. We fill in the offset later. */ 557#define PLT_ENTRY_WORD1 0x30800000 558/* nop. */ 559#define PLT_ENTRY_WORD2 SPARC_NOP 560 561/* The SPARC linker needs to keep track of the number of relocs that it 562 decides to copy as dynamic relocs in check_relocs for each symbol. 563 This is so that it can later discard them if they are found to be 564 unnecessary. We store the information in a field extending the 565 regular ELF linker hash table. */ 566 567struct elf32_sparc_dyn_relocs 568{ 569 struct elf32_sparc_dyn_relocs *next; 570 571 /* The input section of the reloc. */ 572 asection *sec; 573 574 /* Total number of relocs copied for the input section. */ 575 bfd_size_type count; 576 577 /* Number of pc-relative relocs copied for the input section. */ 578 bfd_size_type pc_count; 579}; 580 581/* SPARC ELF linker hash entry. */ 582 583struct elf32_sparc_link_hash_entry 584{ 585 struct elf_link_hash_entry elf; 586 587 /* Track dynamic relocs copied for this symbol. */ 588 struct elf32_sparc_dyn_relocs *dyn_relocs; 589 590#define GOT_UNKNOWN 0 591#define GOT_NORMAL 1 592#define GOT_TLS_GD 2 593#define GOT_TLS_IE 3 594 unsigned char tls_type; 595}; 596 597#define elf32_sparc_hash_entry(ent) ((struct elf32_sparc_link_hash_entry *)(ent)) 598 599struct elf32_sparc_obj_tdata 600{ 601 struct elf_obj_tdata root; 602 603 /* tls_type for each local got entry. */ 604 char *local_got_tls_type; 605 606 /* TRUE if TLS GD relocs has been seen for this object. */ 607 bfd_boolean has_tlsgd; 608}; 609 610#define elf32_sparc_tdata(abfd) \ 611 ((struct elf32_sparc_obj_tdata *) (abfd)->tdata.any) 612 613#define elf32_sparc_local_got_tls_type(abfd) \ 614 (elf32_sparc_tdata (abfd)->local_got_tls_type) 615 616static bfd_boolean 617elf32_sparc_mkobject (abfd) 618 bfd *abfd; 619{ 620 bfd_size_type amt = sizeof (struct elf32_sparc_obj_tdata); 621 abfd->tdata.any = bfd_zalloc (abfd, amt); 622 if (abfd->tdata.any == NULL) 623 return FALSE; 624 return TRUE; 625} 626 627/* SPARC ELF linker hash table. */ 628 629struct elf32_sparc_link_hash_table 630{ 631 struct elf_link_hash_table elf; 632 633 /* Short-cuts to get to dynamic linker sections. */ 634 asection *sgot; 635 asection *srelgot; 636 asection *splt; 637 asection *srelplt; 638 asection *sdynbss; 639 asection *srelbss; 640 641 union { 642 bfd_signed_vma refcount; 643 bfd_vma offset; 644 } tls_ldm_got; 645 646 /* Small local sym to section mapping cache. */ 647 struct sym_sec_cache sym_sec; 648}; 649 650/* Get the SPARC ELF linker hash table from a link_info structure. */ 651 652#define elf32_sparc_hash_table(p) \ 653 ((struct elf32_sparc_link_hash_table *) ((p)->hash)) 654 655/* Create an entry in an i386 ELF linker hash table. */ 656 657static struct bfd_hash_entry * 658link_hash_newfunc (entry, table, string) 659 struct bfd_hash_entry *entry; 660 struct bfd_hash_table *table; 661 const char *string; 662{ 663 /* Allocate the structure if it has not already been allocated by a 664 subclass. */ 665 if (entry == NULL) 666 { 667 entry = bfd_hash_allocate (table, 668 sizeof (struct elf32_sparc_link_hash_entry)); 669 if (entry == NULL) 670 return entry; 671 } 672 673 /* Call the allocation method of the superclass. */ 674 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 675 if (entry != NULL) 676 { 677 struct elf32_sparc_link_hash_entry *eh; 678 679 eh = (struct elf32_sparc_link_hash_entry *) entry; 680 eh->dyn_relocs = NULL; 681 eh->tls_type = GOT_UNKNOWN; 682 } 683 684 return entry; 685} 686 687/* Create a SPARC ELF linker hash table. */ 688 689static struct bfd_link_hash_table * 690elf32_sparc_link_hash_table_create (abfd) 691 bfd *abfd; 692{ 693 struct elf32_sparc_link_hash_table *ret; 694 bfd_size_type amt = sizeof (struct elf32_sparc_link_hash_table); 695 696 ret = (struct elf32_sparc_link_hash_table *) bfd_malloc (amt); 697 if (ret == NULL) 698 return NULL; 699 700 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc)) 701 { 702 free (ret); 703 return NULL; 704 } 705 706 ret->sgot = NULL; 707 ret->srelgot = NULL; 708 ret->splt = NULL; 709 ret->srelplt = NULL; 710 ret->sdynbss = NULL; 711 ret->srelbss = NULL; 712 ret->tls_ldm_got.refcount = 0; 713 ret->sym_sec.abfd = NULL; 714 715 return &ret->elf.root; 716} 717 718/* Create .got and .rela.got sections in DYNOBJ, and set up 719 shortcuts to them in our hash table. */ 720 721static bfd_boolean 722create_got_section (dynobj, info) 723 bfd *dynobj; 724 struct bfd_link_info *info; 725{ 726 struct elf32_sparc_link_hash_table *htab; 727 728 if (! _bfd_elf_create_got_section (dynobj, info)) 729 return FALSE; 730 731 htab = elf32_sparc_hash_table (info); 732 htab->sgot = bfd_get_section_by_name (dynobj, ".got"); 733 if (!htab->sgot) 734 abort (); 735 736 htab->srelgot = bfd_make_section (dynobj, ".rela.got"); 737 if (htab->srelgot == NULL 738 || ! bfd_set_section_flags (dynobj, htab->srelgot, 739 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 740 | SEC_IN_MEMORY | SEC_LINKER_CREATED 741 | SEC_READONLY)) 742 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2)) 743 return FALSE; 744 return TRUE; 745} 746 747/* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and 748 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our 749 hash table. */ 750 751static bfd_boolean 752elf32_sparc_create_dynamic_sections (dynobj, info) 753 bfd *dynobj; 754 struct bfd_link_info *info; 755{ 756 struct elf32_sparc_link_hash_table *htab; 757 758 htab = elf32_sparc_hash_table (info); 759 if (!htab->sgot && !create_got_section (dynobj, info)) 760 return FALSE; 761 762 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 763 return FALSE; 764 765 htab->splt = bfd_get_section_by_name (dynobj, ".plt"); 766 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt"); 767 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss"); 768 if (!info->shared) 769 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss"); 770 771 if (!htab->splt || !htab->srelplt || !htab->sdynbss 772 || (!info->shared && !htab->srelbss)) 773 abort (); 774 775 return TRUE; 776} 777 778/* Copy the extra info we tack onto an elf_link_hash_entry. */ 779 780static void 781elf32_sparc_copy_indirect_symbol (bed, dir, ind) 782 const struct elf_backend_data *bed; 783 struct elf_link_hash_entry *dir, *ind; 784{ 785 struct elf32_sparc_link_hash_entry *edir, *eind; 786 787 edir = (struct elf32_sparc_link_hash_entry *) dir; 788 eind = (struct elf32_sparc_link_hash_entry *) ind; 789 790 if (eind->dyn_relocs != NULL) 791 { 792 if (edir->dyn_relocs != NULL) 793 { 794 struct elf32_sparc_dyn_relocs **pp; 795 struct elf32_sparc_dyn_relocs *p; 796 797 if (ind->root.type == bfd_link_hash_indirect) 798 abort (); 799 800 /* Add reloc counts against the weak sym to the strong sym 801 list. Merge any entries against the same section. */ 802 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 803 { 804 struct elf32_sparc_dyn_relocs *q; 805 806 for (q = edir->dyn_relocs; q != NULL; q = q->next) 807 if (q->sec == p->sec) 808 { 809 q->pc_count += p->pc_count; 810 q->count += p->count; 811 *pp = p->next; 812 break; 813 } 814 if (q == NULL) 815 pp = &p->next; 816 } 817 *pp = edir->dyn_relocs; 818 } 819 820 edir->dyn_relocs = eind->dyn_relocs; 821 eind->dyn_relocs = NULL; 822 } 823 824 if (ind->root.type == bfd_link_hash_indirect 825 && dir->got.refcount <= 0) 826 { 827 edir->tls_type = eind->tls_type; 828 eind->tls_type = GOT_UNKNOWN; 829 } 830 _bfd_elf_link_hash_copy_indirect (bed, dir, ind); 831} 832 833static int 834elf32_sparc_tls_transition (info, abfd, r_type, is_local) 835 struct bfd_link_info *info; 836 bfd *abfd; 837 int r_type; 838 int is_local; 839{ 840 if (r_type == R_SPARC_TLS_GD_HI22 841 && ! elf32_sparc_tdata (abfd)->has_tlsgd) 842 r_type = R_SPARC_REV32; 843 844 if (info->shared) 845 return r_type; 846 847 switch (r_type) 848 { 849 case R_SPARC_TLS_GD_HI22: 850 if (is_local) 851 return R_SPARC_TLS_LE_HIX22; 852 return R_SPARC_TLS_IE_HI22; 853 case R_SPARC_TLS_GD_LO10: 854 if (is_local) 855 return R_SPARC_TLS_LE_LOX10; 856 return R_SPARC_TLS_IE_LO10; 857 case R_SPARC_TLS_IE_HI22: 858 if (is_local) 859 return R_SPARC_TLS_LE_HIX22; 860 return r_type; 861 case R_SPARC_TLS_IE_LO10: 862 if (is_local) 863 return R_SPARC_TLS_LE_LOX10; 864 return r_type; 865 case R_SPARC_TLS_LDM_HI22: 866 return R_SPARC_TLS_LE_HIX22; 867 case R_SPARC_TLS_LDM_LO10: 868 return R_SPARC_TLS_LE_LOX10; 869 } 870 871 return r_type; 872} 873 874/* Look through the relocs for a section during the first phase, and 875 allocate space in the global offset table or procedure linkage 876 table. */ 877 878static bfd_boolean 879elf32_sparc_check_relocs (abfd, info, sec, relocs) 880 bfd *abfd; 881 struct bfd_link_info *info; 882 asection *sec; 883 const Elf_Internal_Rela *relocs; 884{ 885 struct elf32_sparc_link_hash_table *htab; 886 Elf_Internal_Shdr *symtab_hdr; 887 struct elf_link_hash_entry **sym_hashes; 888 bfd_vma *local_got_offsets; 889 const Elf_Internal_Rela *rel; 890 const Elf_Internal_Rela *rel_end; 891 asection *sreloc; 892 bfd_boolean checked_tlsgd = FALSE; 893 894 if (info->relocatable) 895 return TRUE; 896 897 htab = elf32_sparc_hash_table (info); 898 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 899 sym_hashes = elf_sym_hashes (abfd); 900 local_got_offsets = elf_local_got_offsets (abfd); 901 902 sreloc = NULL; 903 904 rel_end = relocs + sec->reloc_count; 905 for (rel = relocs; rel < rel_end; rel++) 906 { 907 unsigned int r_type; 908 unsigned long r_symndx; 909 struct elf_link_hash_entry *h; 910 911 r_symndx = ELF32_R_SYM (rel->r_info); 912 r_type = ELF32_R_TYPE (rel->r_info); 913 914 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 915 { 916 (*_bfd_error_handler) (_("%s: bad symbol index: %d"), 917 bfd_archive_filename (abfd), 918 r_symndx); 919 return FALSE; 920 } 921 922 if (r_symndx < symtab_hdr->sh_info) 923 h = NULL; 924 else 925 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 926 927 /* Compatibility with old R_SPARC_REV32 reloc conflicting 928 with R_SPARC_TLS_GD_HI22. */ 929 if (! checked_tlsgd) 930 switch (r_type) 931 { 932 case R_SPARC_TLS_GD_HI22: 933 { 934 const Elf_Internal_Rela *relt; 935 936 for (relt = rel + 1; relt < rel_end; relt++) 937 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10 938 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD 939 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL) 940 break; 941 checked_tlsgd = TRUE; 942 elf32_sparc_tdata (abfd)->has_tlsgd = relt < rel_end; 943 } 944 break; 945 case R_SPARC_TLS_GD_LO10: 946 case R_SPARC_TLS_GD_ADD: 947 case R_SPARC_TLS_GD_CALL: 948 checked_tlsgd = TRUE; 949 elf32_sparc_tdata (abfd)->has_tlsgd = TRUE; 950 break; 951 } 952 953 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h == NULL); 954 switch (r_type) 955 { 956 case R_SPARC_TLS_LDM_HI22: 957 case R_SPARC_TLS_LDM_LO10: 958 htab->tls_ldm_got.refcount += 1; 959 break; 960 961 case R_SPARC_TLS_LE_HIX22: 962 case R_SPARC_TLS_LE_LOX10: 963 if (info->shared) 964 goto r_sparc_plt32; 965 break; 966 967 case R_SPARC_TLS_IE_HI22: 968 case R_SPARC_TLS_IE_LO10: 969 if (info->shared) 970 info->flags |= DF_STATIC_TLS; 971 /* Fall through */ 972 973 case R_SPARC_GOT10: 974 case R_SPARC_GOT13: 975 case R_SPARC_GOT22: 976 case R_SPARC_TLS_GD_HI22: 977 case R_SPARC_TLS_GD_LO10: 978 /* This symbol requires a global offset table entry. */ 979 { 980 int tls_type, old_tls_type; 981 982 switch (r_type) 983 { 984 default: 985 case R_SPARC_GOT10: 986 case R_SPARC_GOT13: 987 case R_SPARC_GOT22: 988 tls_type = GOT_NORMAL; 989 break; 990 case R_SPARC_TLS_GD_HI22: 991 case R_SPARC_TLS_GD_LO10: 992 tls_type = GOT_TLS_GD; 993 break; 994 case R_SPARC_TLS_IE_HI22: 995 case R_SPARC_TLS_IE_LO10: 996 tls_type = GOT_TLS_IE; 997 break; 998 } 999 1000 if (h != NULL) 1001 { 1002 h->got.refcount += 1; 1003 old_tls_type = elf32_sparc_hash_entry(h)->tls_type; 1004 } 1005 else 1006 { 1007 bfd_signed_vma *local_got_refcounts; 1008 1009 /* This is a global offset table entry for a local symbol. */ 1010 local_got_refcounts = elf_local_got_refcounts (abfd); 1011 if (local_got_refcounts == NULL) 1012 { 1013 bfd_size_type size; 1014 1015 size = symtab_hdr->sh_info; 1016 size *= (sizeof (bfd_signed_vma) + sizeof(char)); 1017 local_got_refcounts = ((bfd_signed_vma *) 1018 bfd_zalloc (abfd, size)); 1019 if (local_got_refcounts == NULL) 1020 return FALSE; 1021 elf_local_got_refcounts (abfd) = local_got_refcounts; 1022 elf32_sparc_local_got_tls_type (abfd) 1023 = (char *) (local_got_refcounts + symtab_hdr->sh_info); 1024 } 1025 local_got_refcounts[r_symndx] += 1; 1026 old_tls_type = elf32_sparc_local_got_tls_type (abfd) [r_symndx]; 1027 } 1028 1029 /* If a TLS symbol is accessed using IE at least once, 1030 there is no point to use dynamic model for it. */ 1031 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN 1032 && (old_tls_type != GOT_TLS_GD 1033 || tls_type != GOT_TLS_IE)) 1034 { 1035 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD) 1036 tls_type = old_tls_type; 1037 else 1038 { 1039 (*_bfd_error_handler) 1040 (_("%s: `%s' accessed both as normal and thread local symbol"), 1041 bfd_archive_filename (abfd), 1042 h ? h->root.root.string : "<local>"); 1043 return FALSE; 1044 } 1045 } 1046 1047 if (old_tls_type != tls_type) 1048 { 1049 if (h != NULL) 1050 elf32_sparc_hash_entry (h)->tls_type = tls_type; 1051 else 1052 elf32_sparc_local_got_tls_type (abfd) [r_symndx] = tls_type; 1053 } 1054 } 1055 1056 if (htab->sgot == NULL) 1057 { 1058 if (htab->elf.dynobj == NULL) 1059 htab->elf.dynobj = abfd; 1060 if (!create_got_section (htab->elf.dynobj, info)) 1061 return FALSE; 1062 } 1063 break; 1064 1065 case R_SPARC_TLS_GD_CALL: 1066 case R_SPARC_TLS_LDM_CALL: 1067 if (info->shared) 1068 { 1069 /* These are basically R_SPARC_TLS_WPLT30 relocs against 1070 __tls_get_addr. */ 1071 struct bfd_link_hash_entry *bh = NULL; 1072 if (! _bfd_generic_link_add_one_symbol (info, abfd, 1073 "__tls_get_addr", 0, 1074 bfd_und_section_ptr, 0, 1075 NULL, FALSE, FALSE, 1076 &bh)) 1077 return FALSE; 1078 h = (struct elf_link_hash_entry *) bh; 1079 } 1080 else 1081 break; 1082 /* Fall through */ 1083 1084 case R_SPARC_PLT32: 1085 case R_SPARC_WPLT30: 1086 /* This symbol requires a procedure linkage table entry. We 1087 actually build the entry in adjust_dynamic_symbol, 1088 because this might be a case of linking PIC code without 1089 linking in any dynamic objects, in which case we don't 1090 need to generate a procedure linkage table after all. */ 1091 1092 if (h == NULL) 1093 { 1094 /* The Solaris native assembler will generate a WPLT30 1095 reloc for a local symbol if you assemble a call from 1096 one section to another when using -K pic. We treat 1097 it as WDISP30. */ 1098 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32) 1099 goto r_sparc_plt32; 1100 break; 1101 } 1102 1103 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 1104 1105 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32) 1106 goto r_sparc_plt32; 1107 h->plt.refcount += 1; 1108 break; 1109 1110 case R_SPARC_PC10: 1111 case R_SPARC_PC22: 1112 if (h != NULL) 1113 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF; 1114 1115 if (h != NULL 1116 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1117 break; 1118 /* Fall through. */ 1119 1120 case R_SPARC_DISP8: 1121 case R_SPARC_DISP16: 1122 case R_SPARC_DISP32: 1123 case R_SPARC_WDISP30: 1124 case R_SPARC_WDISP22: 1125 case R_SPARC_WDISP19: 1126 case R_SPARC_WDISP16: 1127 case R_SPARC_8: 1128 case R_SPARC_16: 1129 case R_SPARC_32: 1130 case R_SPARC_HI22: 1131 case R_SPARC_22: 1132 case R_SPARC_13: 1133 case R_SPARC_LO10: 1134 case R_SPARC_UA16: 1135 case R_SPARC_UA32: 1136 if (h != NULL) 1137 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF; 1138 1139 r_sparc_plt32: 1140 if (h != NULL && !info->shared) 1141 { 1142 /* We may need a .plt entry if the function this reloc 1143 refers to is in a shared lib. */ 1144 h->plt.refcount += 1; 1145 } 1146 1147 /* If we are creating a shared library, and this is a reloc 1148 against a global symbol, or a non PC relative reloc 1149 against a local symbol, then we need to copy the reloc 1150 into the shared library. However, if we are linking with 1151 -Bsymbolic, we do not need to copy a reloc against a 1152 global symbol which is defined in an object we are 1153 including in the link (i.e., DEF_REGULAR is set). At 1154 this point we have not seen all the input files, so it is 1155 possible that DEF_REGULAR is not set now but will be set 1156 later (it is never cleared). In case of a weak definition, 1157 DEF_REGULAR may be cleared later by a strong definition in 1158 a shared library. We account for that possibility below by 1159 storing information in the relocs_copied field of the hash 1160 table entry. A similar situation occurs when creating 1161 shared libraries and symbol visibility changes render the 1162 symbol local. 1163 1164 If on the other hand, we are creating an executable, we 1165 may need to keep relocations for symbols satisfied by a 1166 dynamic library if we manage to avoid copy relocs for the 1167 symbol. */ 1168 if ((info->shared 1169 && (sec->flags & SEC_ALLOC) != 0 1170 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative 1171 || (h != NULL 1172 && (! info->symbolic 1173 || h->root.type == bfd_link_hash_defweak 1174 || (h->elf_link_hash_flags 1175 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 1176 || (!info->shared 1177 && (sec->flags & SEC_ALLOC) != 0 1178 && h != NULL 1179 && (h->root.type == bfd_link_hash_defweak 1180 || (h->elf_link_hash_flags 1181 & ELF_LINK_HASH_DEF_REGULAR) == 0))) 1182 { 1183 struct elf32_sparc_dyn_relocs *p; 1184 struct elf32_sparc_dyn_relocs **head; 1185 1186 /* When creating a shared object, we must copy these 1187 relocs into the output file. We create a reloc 1188 section in dynobj and make room for the reloc. */ 1189 if (sreloc == NULL) 1190 { 1191 const char *name; 1192 bfd *dynobj; 1193 1194 name = (bfd_elf_string_from_elf_section 1195 (abfd, 1196 elf_elfheader (abfd)->e_shstrndx, 1197 elf_section_data (sec)->rel_hdr.sh_name)); 1198 if (name == NULL) 1199 return FALSE; 1200 1201 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 1202 && strcmp (bfd_get_section_name (abfd, sec), 1203 name + 5) == 0); 1204 1205 if (htab->elf.dynobj == NULL) 1206 htab->elf.dynobj = abfd; 1207 dynobj = htab->elf.dynobj; 1208 1209 sreloc = bfd_get_section_by_name (dynobj, name); 1210 if (sreloc == NULL) 1211 { 1212 flagword flags; 1213 1214 sreloc = bfd_make_section (dynobj, name); 1215 flags = (SEC_HAS_CONTENTS | SEC_READONLY 1216 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 1217 if ((sec->flags & SEC_ALLOC) != 0) 1218 flags |= SEC_ALLOC | SEC_LOAD; 1219 if (sreloc == NULL 1220 || ! bfd_set_section_flags (dynobj, sreloc, flags) 1221 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 1222 return FALSE; 1223 } 1224 elf_section_data (sec)->sreloc = sreloc; 1225 } 1226 1227 /* If this is a global symbol, we count the number of 1228 relocations we need for this symbol. */ 1229 if (h != NULL) 1230 head = &((struct elf32_sparc_link_hash_entry *) h)->dyn_relocs; 1231 else 1232 { 1233 /* Track dynamic relocs needed for local syms too. 1234 We really need local syms available to do this 1235 easily. Oh well. */ 1236 1237 asection *s; 1238 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, 1239 sec, r_symndx); 1240 if (s == NULL) 1241 return FALSE; 1242 1243 head = ((struct elf32_sparc_dyn_relocs **) 1244 &elf_section_data (s)->local_dynrel); 1245 } 1246 1247 p = *head; 1248 if (p == NULL || p->sec != sec) 1249 { 1250 bfd_size_type amt = sizeof *p; 1251 p = ((struct elf32_sparc_dyn_relocs *) 1252 bfd_alloc (htab->elf.dynobj, amt)); 1253 if (p == NULL) 1254 return FALSE; 1255 p->next = *head; 1256 *head = p; 1257 p->sec = sec; 1258 p->count = 0; 1259 p->pc_count = 0; 1260 } 1261 1262 p->count += 1; 1263 if (_bfd_sparc_elf_howto_table[r_type].pc_relative) 1264 p->pc_count += 1; 1265 } 1266 1267 break; 1268 1269 case R_SPARC_GNU_VTINHERIT: 1270 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 1271 return FALSE; 1272 break; 1273 1274 case R_SPARC_GNU_VTENTRY: 1275 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 1276 return FALSE; 1277 break; 1278 1279 default: 1280 break; 1281 } 1282 } 1283 1284 return TRUE; 1285} 1286 1287static asection * 1288elf32_sparc_gc_mark_hook (sec, info, rel, h, sym) 1289 asection *sec; 1290 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1291 Elf_Internal_Rela *rel; 1292 struct elf_link_hash_entry *h; 1293 Elf_Internal_Sym *sym; 1294{ 1295 if (h != NULL) 1296 { 1297 switch (ELF32_R_TYPE (rel->r_info)) 1298 { 1299 case R_SPARC_GNU_VTINHERIT: 1300 case R_SPARC_GNU_VTENTRY: 1301 break; 1302 1303 default: 1304 switch (h->root.type) 1305 { 1306 case bfd_link_hash_defined: 1307 case bfd_link_hash_defweak: 1308 return h->root.u.def.section; 1309 1310 case bfd_link_hash_common: 1311 return h->root.u.c.p->section; 1312 1313 default: 1314 break; 1315 } 1316 } 1317 } 1318 else 1319 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 1320 1321 return NULL; 1322} 1323 1324/* Update the got entry reference counts for the section being removed. */ 1325static bfd_boolean 1326elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs) 1327 bfd *abfd; 1328 struct bfd_link_info *info ATTRIBUTE_UNUSED; 1329 asection *sec; 1330 const Elf_Internal_Rela *relocs; 1331{ 1332 Elf_Internal_Shdr *symtab_hdr; 1333 struct elf_link_hash_entry **sym_hashes; 1334 bfd_signed_vma *local_got_refcounts; 1335 const Elf_Internal_Rela *rel, *relend; 1336 1337 elf_section_data (sec)->local_dynrel = NULL; 1338 1339 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1340 sym_hashes = elf_sym_hashes (abfd); 1341 local_got_refcounts = elf_local_got_refcounts (abfd); 1342 1343 relend = relocs + sec->reloc_count; 1344 for (rel = relocs; rel < relend; rel++) 1345 { 1346 unsigned long r_symndx; 1347 unsigned int r_type; 1348 struct elf_link_hash_entry *h = NULL; 1349 1350 r_symndx = ELF32_R_SYM (rel->r_info); 1351 if (r_symndx >= symtab_hdr->sh_info) 1352 { 1353 struct elf32_sparc_link_hash_entry *eh; 1354 struct elf32_sparc_dyn_relocs **pp; 1355 struct elf32_sparc_dyn_relocs *p; 1356 1357 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1358 eh = (struct elf32_sparc_link_hash_entry *) h; 1359 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 1360 if (p->sec == sec) 1361 { 1362 /* Everything must go for SEC. */ 1363 *pp = p->next; 1364 break; 1365 } 1366 } 1367 1368 r_type = ELF32_R_TYPE (rel->r_info); 1369 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h != NULL); 1370 switch (r_type) 1371 { 1372 case R_SPARC_TLS_LDM_HI22: 1373 case R_SPARC_TLS_LDM_LO10: 1374 if (elf32_sparc_hash_table (info)->tls_ldm_got.refcount > 0) 1375 elf32_sparc_hash_table (info)->tls_ldm_got.refcount -= 1; 1376 break; 1377 1378 case R_SPARC_TLS_GD_HI22: 1379 case R_SPARC_TLS_GD_LO10: 1380 case R_SPARC_TLS_IE_HI22: 1381 case R_SPARC_TLS_IE_LO10: 1382 case R_SPARC_GOT10: 1383 case R_SPARC_GOT13: 1384 case R_SPARC_GOT22: 1385 if (h != NULL) 1386 { 1387 if (h->got.refcount > 0) 1388 h->got.refcount--; 1389 } 1390 else 1391 { 1392 if (local_got_refcounts[r_symndx] > 0) 1393 local_got_refcounts[r_symndx]--; 1394 } 1395 break; 1396 1397 case R_SPARC_PC10: 1398 case R_SPARC_PC22: 1399 if (h != NULL 1400 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1401 break; 1402 /* Fall through. */ 1403 1404 case R_SPARC_DISP8: 1405 case R_SPARC_DISP16: 1406 case R_SPARC_DISP32: 1407 case R_SPARC_WDISP30: 1408 case R_SPARC_WDISP22: 1409 case R_SPARC_WDISP19: 1410 case R_SPARC_WDISP16: 1411 case R_SPARC_8: 1412 case R_SPARC_16: 1413 case R_SPARC_32: 1414 case R_SPARC_HI22: 1415 case R_SPARC_22: 1416 case R_SPARC_13: 1417 case R_SPARC_LO10: 1418 case R_SPARC_UA16: 1419 case R_SPARC_UA32: 1420 case R_SPARC_PLT32: 1421 if (info->shared) 1422 break; 1423 /* Fall through. */ 1424 1425 case R_SPARC_WPLT30: 1426 if (h != NULL) 1427 { 1428 if (h->plt.refcount > 0) 1429 h->plt.refcount--; 1430 } 1431 break; 1432 1433 default: 1434 break; 1435 } 1436 } 1437 1438 return TRUE; 1439} 1440 1441/* Adjust a symbol defined by a dynamic object and referenced by a 1442 regular object. The current definition is in some section of the 1443 dynamic object, but we're not including those sections. We have to 1444 change the definition to something the rest of the link can 1445 understand. */ 1446 1447static bfd_boolean 1448elf32_sparc_adjust_dynamic_symbol (info, h) 1449 struct bfd_link_info *info; 1450 struct elf_link_hash_entry *h; 1451{ 1452 struct elf32_sparc_link_hash_table *htab; 1453 struct elf32_sparc_link_hash_entry * eh; 1454 struct elf32_sparc_dyn_relocs *p; 1455 asection *s; 1456 unsigned int power_of_two; 1457 1458 htab = elf32_sparc_hash_table (info); 1459 1460 /* Make sure we know what is going on here. */ 1461 BFD_ASSERT (htab->elf.dynobj != NULL 1462 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) 1463 || h->weakdef != NULL 1464 || ((h->elf_link_hash_flags 1465 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 1466 && (h->elf_link_hash_flags 1467 & ELF_LINK_HASH_REF_REGULAR) != 0 1468 && (h->elf_link_hash_flags 1469 & ELF_LINK_HASH_DEF_REGULAR) == 0))); 1470 1471 /* If this is a function, put it in the procedure linkage table. We 1472 will fill in the contents of the procedure linkage table later 1473 (although we could actually do it here). The STT_NOTYPE 1474 condition is a hack specifically for the Oracle libraries 1475 delivered for Solaris; for some inexplicable reason, they define 1476 some of their functions as STT_NOTYPE when they really should be 1477 STT_FUNC. */ 1478 if (h->type == STT_FUNC 1479 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0 1480 || (h->type == STT_NOTYPE 1481 && (h->root.type == bfd_link_hash_defined 1482 || h->root.type == bfd_link_hash_defweak) 1483 && (h->root.u.def.section->flags & SEC_CODE) != 0)) 1484 { 1485 if (h->plt.refcount <= 0 1486 || (! info->shared 1487 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0 1488 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0 1489 && h->root.type != bfd_link_hash_undefweak 1490 && h->root.type != bfd_link_hash_undefined)) 1491 { 1492 /* This case can occur if we saw a WPLT30 reloc in an input 1493 file, but the symbol was never referred to by a dynamic 1494 object, or if all references were garbage collected. In 1495 such a case, we don't actually need to build a procedure 1496 linkage table, and we can just do a WDISP30 reloc instead. */ 1497 h->plt.offset = (bfd_vma) -1; 1498 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1499 } 1500 1501 return TRUE; 1502 } 1503 else 1504 h->plt.offset = (bfd_vma) -1; 1505 1506 /* If this is a weak symbol, and there is a real definition, the 1507 processor independent code will have arranged for us to see the 1508 real definition first, and we can just use the same value. */ 1509 if (h->weakdef != NULL) 1510 { 1511 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 1512 || h->weakdef->root.type == bfd_link_hash_defweak); 1513 h->root.u.def.section = h->weakdef->root.u.def.section; 1514 h->root.u.def.value = h->weakdef->root.u.def.value; 1515 return TRUE; 1516 } 1517 1518 /* This is a reference to a symbol defined by a dynamic object which 1519 is not a function. */ 1520 1521 /* If we are creating a shared library, we must presume that the 1522 only references to the symbol are via the global offset table. 1523 For such cases we need not do anything here; the relocations will 1524 be handled correctly by relocate_section. */ 1525 if (info->shared) 1526 return TRUE; 1527 1528 /* If there are no references to this symbol that do not use the 1529 GOT, we don't need to generate a copy reloc. */ 1530 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0) 1531 return TRUE; 1532 1533 eh = (struct elf32_sparc_link_hash_entry *) h; 1534 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1535 { 1536 s = p->sec->output_section; 1537 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1538 break; 1539 } 1540 1541 /* If we didn't find any dynamic relocs in read-only sections, then 1542 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 1543 if (p == NULL) 1544 { 1545 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF; 1546 return TRUE; 1547 } 1548 1549 /* We must allocate the symbol in our .dynbss section, which will 1550 become part of the .bss section of the executable. There will be 1551 an entry for this symbol in the .dynsym section. The dynamic 1552 object will contain position independent code, so all references 1553 from the dynamic object to this symbol will go through the global 1554 offset table. The dynamic linker will use the .dynsym entry to 1555 determine the address it must put in the global offset table, so 1556 both the dynamic object and the regular object will refer to the 1557 same memory location for the variable. */ 1558 1559 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker 1560 to copy the initial value out of the dynamic object and into the 1561 runtime process image. We need to remember the offset into the 1562 .rel.bss section we are going to use. */ 1563 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 1564 { 1565 htab->srelbss->_raw_size += sizeof (Elf32_External_Rela); 1566 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 1567 } 1568 1569 /* We need to figure out the alignment required for this symbol. I 1570 have no idea how ELF linkers handle this. */ 1571 power_of_two = bfd_log2 (h->size); 1572 if (power_of_two > 3) 1573 power_of_two = 3; 1574 1575 /* Apply the required alignment. */ 1576 s = htab->sdynbss; 1577 s->_raw_size = BFD_ALIGN (s->_raw_size, 1578 (bfd_size_type) (1 << power_of_two)); 1579 if (power_of_two > bfd_get_section_alignment (dynobj, s)) 1580 { 1581 if (! bfd_set_section_alignment (dynobj, s, power_of_two)) 1582 return FALSE; 1583 } 1584 1585 /* Define the symbol as being at this point in the section. */ 1586 h->root.u.def.section = s; 1587 h->root.u.def.value = s->_raw_size; 1588 1589 /* Increment the section size to make room for the symbol. */ 1590 s->_raw_size += h->size; 1591 1592 return TRUE; 1593} 1594 1595/* Allocate space in .plt, .got and associated reloc sections for 1596 dynamic relocs. */ 1597 1598static bfd_boolean 1599allocate_dynrelocs (h, inf) 1600 struct elf_link_hash_entry *h; 1601 PTR inf; 1602{ 1603 struct bfd_link_info *info; 1604 struct elf32_sparc_link_hash_table *htab; 1605 struct elf32_sparc_link_hash_entry *eh; 1606 struct elf32_sparc_dyn_relocs *p; 1607 1608 if (h->root.type == bfd_link_hash_indirect) 1609 return TRUE; 1610 1611 if (h->root.type == bfd_link_hash_warning) 1612 /* When warning symbols are created, they **replace** the "real" 1613 entry in the hash table, thus we never get to see the real 1614 symbol in a hash traversal. So look at it now. */ 1615 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1616 1617 info = (struct bfd_link_info *) inf; 1618 htab = elf32_sparc_hash_table (info); 1619 1620 if (htab->elf.dynamic_sections_created 1621 && h->plt.refcount > 0) 1622 { 1623 /* Make sure this symbol is output as a dynamic symbol. 1624 Undefined weak syms won't yet be marked as dynamic. */ 1625 if (h->dynindx == -1 1626 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) 1627 { 1628 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1629 return FALSE; 1630 } 1631 1632 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)) 1633 { 1634 asection *s = htab->splt; 1635 1636 /* The first four entries in .plt are reserved. */ 1637 if (s->_raw_size == 0) 1638 s->_raw_size = 4 * PLT_ENTRY_SIZE; 1639 1640 /* The procedure linkage table has a maximum size. */ 1641 if (s->_raw_size >= 0x400000) 1642 { 1643 bfd_set_error (bfd_error_bad_value); 1644 return FALSE; 1645 } 1646 1647 h->plt.offset = s->_raw_size; 1648 1649 /* If this symbol is not defined in a regular file, and we are 1650 not generating a shared library, then set the symbol to this 1651 location in the .plt. This is required to make function 1652 pointers compare as equal between the normal executable and 1653 the shared library. */ 1654 if (! info->shared 1655 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1656 { 1657 h->root.u.def.section = s; 1658 h->root.u.def.value = h->plt.offset; 1659 } 1660 1661 /* Make room for this entry. */ 1662 s->_raw_size += PLT_ENTRY_SIZE; 1663 1664 /* We also need to make an entry in the .rela.plt section. */ 1665 htab->srelplt->_raw_size += sizeof (Elf32_External_Rela); 1666 } 1667 else 1668 { 1669 h->plt.offset = (bfd_vma) -1; 1670 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1671 } 1672 } 1673 else 1674 { 1675 h->plt.offset = (bfd_vma) -1; 1676 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1677 } 1678 1679 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary, 1680 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */ 1681 if (h->got.refcount > 0 1682 && !info->shared 1683 && h->dynindx == -1 1684 && elf32_sparc_hash_entry(h)->tls_type == GOT_TLS_IE) 1685 h->got.offset = (bfd_vma) -1; 1686 else if (h->got.refcount > 0) 1687 { 1688 asection *s; 1689 bfd_boolean dyn; 1690 int tls_type = elf32_sparc_hash_entry(h)->tls_type; 1691 1692 /* Make sure this symbol is output as a dynamic symbol. 1693 Undefined weak syms won't yet be marked as dynamic. */ 1694 if (h->dynindx == -1 1695 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) 1696 { 1697 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1698 return FALSE; 1699 } 1700 1701 s = htab->sgot; 1702 h->got.offset = s->_raw_size; 1703 s->_raw_size += 4; 1704 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */ 1705 if (tls_type == GOT_TLS_GD) 1706 s->_raw_size += 4; 1707 dyn = htab->elf.dynamic_sections_created; 1708 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation, 1709 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if 1710 global. */ 1711 if ((tls_type == GOT_TLS_GD && h->dynindx == -1) 1712 || tls_type == GOT_TLS_IE) 1713 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela); 1714 else if (tls_type == GOT_TLS_GD) 1715 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela); 1716 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)) 1717 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela); 1718 } 1719 else 1720 h->got.offset = (bfd_vma) -1; 1721 1722 eh = (struct elf32_sparc_link_hash_entry *) h; 1723 if (eh->dyn_relocs == NULL) 1724 return TRUE; 1725 1726 /* In the shared -Bsymbolic case, discard space allocated for 1727 dynamic pc-relative relocs against symbols which turn out to be 1728 defined in regular objects. For the normal shared case, discard 1729 space for pc-relative relocs that have become local due to symbol 1730 visibility changes. */ 1731 1732 if (info->shared) 1733 { 1734 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0 1735 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0 1736 || info->symbolic)) 1737 { 1738 struct elf32_sparc_dyn_relocs **pp; 1739 1740 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 1741 { 1742 p->count -= p->pc_count; 1743 p->pc_count = 0; 1744 if (p->count == 0) 1745 *pp = p->next; 1746 else 1747 pp = &p->next; 1748 } 1749 } 1750 } 1751 else 1752 { 1753 /* For the non-shared case, discard space for relocs against 1754 symbols which turn out to need copy relocs or are not 1755 dynamic. */ 1756 1757 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0 1758 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0 1759 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1760 || (htab->elf.dynamic_sections_created 1761 && (h->root.type == bfd_link_hash_undefweak 1762 || h->root.type == bfd_link_hash_undefined)))) 1763 { 1764 /* Make sure this symbol is output as a dynamic symbol. 1765 Undefined weak syms won't yet be marked as dynamic. */ 1766 if (h->dynindx == -1 1767 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) 1768 { 1769 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1770 return FALSE; 1771 } 1772 1773 /* If that succeeded, we know we'll be keeping all the 1774 relocs. */ 1775 if (h->dynindx != -1) 1776 goto keep; 1777 } 1778 1779 eh->dyn_relocs = NULL; 1780 1781 keep: ; 1782 } 1783 1784 /* Finally, allocate space. */ 1785 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1786 { 1787 asection *sreloc = elf_section_data (p->sec)->sreloc; 1788 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela); 1789 } 1790 1791 return TRUE; 1792} 1793 1794/* Find any dynamic relocs that apply to read-only sections. */ 1795 1796static bfd_boolean 1797readonly_dynrelocs (h, inf) 1798 struct elf_link_hash_entry *h; 1799 PTR inf; 1800{ 1801 struct elf32_sparc_link_hash_entry *eh; 1802 struct elf32_sparc_dyn_relocs *p; 1803 1804 if (h->root.type == bfd_link_hash_warning) 1805 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1806 1807 eh = (struct elf32_sparc_link_hash_entry *) h; 1808 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1809 { 1810 asection *s = p->sec->output_section; 1811 1812 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1813 { 1814 struct bfd_link_info *info = (struct bfd_link_info *) inf; 1815 1816 info->flags |= DF_TEXTREL; 1817 1818 /* Not an error, just cut short the traversal. */ 1819 return FALSE; 1820 } 1821 } 1822 return TRUE; 1823} 1824 1825/* Set the sizes of the dynamic sections. */ 1826 1827static bfd_boolean 1828elf32_sparc_size_dynamic_sections (output_bfd, info) 1829 bfd *output_bfd ATTRIBUTE_UNUSED; 1830 struct bfd_link_info *info; 1831{ 1832 struct elf32_sparc_link_hash_table *htab; 1833 bfd *dynobj; 1834 asection *s; 1835 bfd *ibfd; 1836 1837 htab = elf32_sparc_hash_table (info); 1838 dynobj = htab->elf.dynobj; 1839 BFD_ASSERT (dynobj != NULL); 1840 1841 if (elf_hash_table (info)->dynamic_sections_created) 1842 { 1843 /* Set the contents of the .interp section to the interpreter. */ 1844 if (info->executable && !info->static_link) 1845 { 1846 s = bfd_get_section_by_name (dynobj, ".interp"); 1847 BFD_ASSERT (s != NULL); 1848 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 1849 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1850 } 1851 } 1852 1853 /* Set up .got offsets for local syms, and space for local dynamic 1854 relocs. */ 1855 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 1856 { 1857 bfd_signed_vma *local_got; 1858 bfd_signed_vma *end_local_got; 1859 char *local_tls_type; 1860 bfd_size_type locsymcount; 1861 Elf_Internal_Shdr *symtab_hdr; 1862 asection *srel; 1863 1864 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 1865 continue; 1866 1867 for (s = ibfd->sections; s != NULL; s = s->next) 1868 { 1869 struct elf32_sparc_dyn_relocs *p; 1870 1871 for (p = *((struct elf32_sparc_dyn_relocs **) 1872 &elf_section_data (s)->local_dynrel); 1873 p != NULL; 1874 p = p->next) 1875 { 1876 if (!bfd_is_abs_section (p->sec) 1877 && bfd_is_abs_section (p->sec->output_section)) 1878 { 1879 /* Input section has been discarded, either because 1880 it is a copy of a linkonce section or due to 1881 linker script /DISCARD/, so we'll be discarding 1882 the relocs too. */ 1883 } 1884 else if (p->count != 0) 1885 { 1886 srel = elf_section_data (p->sec)->sreloc; 1887 srel->_raw_size += p->count * sizeof (Elf32_External_Rela); 1888 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 1889 info->flags |= DF_TEXTREL; 1890 } 1891 } 1892 } 1893 1894 local_got = elf_local_got_refcounts (ibfd); 1895 if (!local_got) 1896 continue; 1897 1898 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 1899 locsymcount = symtab_hdr->sh_info; 1900 end_local_got = local_got + locsymcount; 1901 local_tls_type = elf32_sparc_local_got_tls_type (ibfd); 1902 s = htab->sgot; 1903 srel = htab->srelgot; 1904 for (; local_got < end_local_got; ++local_got, ++local_tls_type) 1905 { 1906 if (*local_got > 0) 1907 { 1908 *local_got = s->_raw_size; 1909 s->_raw_size += 4; 1910 if (*local_tls_type == GOT_TLS_GD) 1911 s->_raw_size += 4; 1912 if (info->shared 1913 || *local_tls_type == GOT_TLS_GD 1914 || *local_tls_type == GOT_TLS_IE) 1915 srel->_raw_size += sizeof (Elf32_External_Rela); 1916 } 1917 else 1918 *local_got = (bfd_vma) -1; 1919 } 1920 } 1921 1922 if (htab->tls_ldm_got.refcount > 0) 1923 { 1924 /* Allocate 2 got entries and 1 dynamic reloc for 1925 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */ 1926 htab->tls_ldm_got.offset = htab->sgot->_raw_size; 1927 htab->sgot->_raw_size += 8; 1928 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela); 1929 } 1930 else 1931 htab->tls_ldm_got.offset = -1; 1932 1933 /* Allocate global sym .plt and .got entries, and space for global 1934 sym dynamic relocs. */ 1935 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info); 1936 1937 if (elf_hash_table (info)->dynamic_sections_created) 1938 { 1939 /* Make space for the trailing nop in .plt. */ 1940 if (htab->splt->_raw_size > 0) 1941 htab->splt->_raw_size += 4; 1942 1943 /* If the .got section is more than 0x1000 bytes, we add 1944 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13 1945 bit relocations have a greater chance of working. */ 1946 if (htab->sgot->_raw_size >= 0x1000 1947 && elf_hash_table (info)->hgot->root.u.def.value == 0) 1948 elf_hash_table (info)->hgot->root.u.def.value = 0x1000; 1949 } 1950 1951 /* The check_relocs and adjust_dynamic_symbol entry points have 1952 determined the sizes of the various dynamic sections. Allocate 1953 memory for them. */ 1954 for (s = dynobj->sections; s != NULL; s = s->next) 1955 { 1956 const char *name; 1957 bfd_boolean strip = FALSE; 1958 1959 if ((s->flags & SEC_LINKER_CREATED) == 0) 1960 continue; 1961 1962 /* It's OK to base decisions on the section name, because none 1963 of the dynobj section names depend upon the input files. */ 1964 name = bfd_get_section_name (dynobj, s); 1965 1966 if (strncmp (name, ".rela", 5) == 0) 1967 { 1968 if (s->_raw_size == 0) 1969 { 1970 /* If we don't need this section, strip it from the 1971 output file. This is to handle .rela.bss and 1972 .rel.plt. We must create it in 1973 create_dynamic_sections, because it must be created 1974 before the linker maps input sections to output 1975 sections. The linker does that before 1976 adjust_dynamic_symbol is called, and it is that 1977 function which decides whether anything needs to go 1978 into these sections. */ 1979 strip = TRUE; 1980 } 1981 else 1982 { 1983 /* We use the reloc_count field as a counter if we need 1984 to copy relocs into the output file. */ 1985 s->reloc_count = 0; 1986 } 1987 } 1988 else if (s != htab->splt && s != htab->sgot) 1989 { 1990 /* It's not one of our sections, so don't allocate space. */ 1991 continue; 1992 } 1993 1994 if (strip) 1995 { 1996 _bfd_strip_section_from_output (info, s); 1997 continue; 1998 } 1999 2000 /* Allocate memory for the section contents. */ 2001 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc. 2002 Unused entries should be reclaimed before the section's contents 2003 are written out, but at the moment this does not happen. Thus in 2004 order to prevent writing out garbage, we initialise the section's 2005 contents to zero. */ 2006 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 2007 if (s->contents == NULL && s->_raw_size != 0) 2008 return FALSE; 2009 } 2010 2011 if (elf_hash_table (info)->dynamic_sections_created) 2012 { 2013 /* Add some entries to the .dynamic section. We fill in the 2014 values later, in elf32_sparc_finish_dynamic_sections, but we 2015 must add the entries now so that we get the correct size for 2016 the .dynamic section. The DT_DEBUG entry is filled in by the 2017 dynamic linker and used by the debugger. */ 2018#define add_dynamic_entry(TAG, VAL) \ 2019 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 2020 2021 if (info->executable) 2022 { 2023 if (!add_dynamic_entry (DT_DEBUG, 0)) 2024 return FALSE; 2025 } 2026 2027 if (htab->srelplt->_raw_size != 0) 2028 { 2029 if (!add_dynamic_entry (DT_PLTGOT, 0) 2030 || !add_dynamic_entry (DT_PLTRELSZ, 0) 2031 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 2032 || !add_dynamic_entry (DT_JMPREL, 0)) 2033 return FALSE; 2034 } 2035 2036 if (!add_dynamic_entry (DT_RELA, 0) 2037 || !add_dynamic_entry (DT_RELASZ, 0) 2038 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 2039 return FALSE; 2040 2041 /* If any dynamic relocs apply to a read-only section, 2042 then we need a DT_TEXTREL entry. */ 2043 if ((info->flags & DF_TEXTREL) == 0) 2044 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, 2045 (PTR) info); 2046 2047 if (info->flags & DF_TEXTREL) 2048 { 2049 if (!add_dynamic_entry (DT_TEXTREL, 0)) 2050 return FALSE; 2051 } 2052 } 2053#undef add_dynamic_entry 2054 2055 return TRUE; 2056} 2057 2058struct elf32_sparc_section_data 2059{ 2060 struct bfd_elf_section_data elf; 2061 unsigned int do_relax; 2062}; 2063 2064#define sec_do_relax(sec) \ 2065 ((struct elf32_sparc_section_data *) elf_section_data (sec))->do_relax 2066 2067static bfd_boolean 2068elf32_sparc_new_section_hook (abfd, sec) 2069 bfd *abfd; 2070 asection *sec; 2071{ 2072 struct elf32_sparc_section_data *sdata; 2073 bfd_size_type amt = sizeof (*sdata); 2074 2075 sdata = (struct elf32_sparc_section_data *) bfd_zalloc (abfd, amt); 2076 if (sdata == NULL) 2077 return FALSE; 2078 sec->used_by_bfd = (PTR) sdata; 2079 2080 return _bfd_elf_new_section_hook (abfd, sec); 2081} 2082 2083static bfd_boolean 2084elf32_sparc_relax_section (abfd, section, link_info, again) 2085 bfd *abfd ATTRIBUTE_UNUSED; 2086 asection *section ATTRIBUTE_UNUSED; 2087 struct bfd_link_info *link_info ATTRIBUTE_UNUSED; 2088 bfd_boolean *again; 2089{ 2090 *again = FALSE; 2091 sec_do_relax (section) = 1; 2092 return TRUE; 2093} 2094 2095/* Return the base VMA address which should be subtracted from real addresses 2096 when resolving @dtpoff relocation. 2097 This is PT_TLS segment p_vaddr. */ 2098 2099static bfd_vma 2100dtpoff_base (info) 2101 struct bfd_link_info *info; 2102{ 2103 /* If tls_sec is NULL, we should have signalled an error already. */ 2104 if (elf_hash_table (info)->tls_sec == NULL) 2105 return 0; 2106 return elf_hash_table (info)->tls_sec->vma; 2107} 2108 2109/* Return the relocation value for @tpoff relocation 2110 if STT_TLS virtual address is ADDRESS. */ 2111 2112static bfd_vma 2113tpoff (info, address) 2114 struct bfd_link_info *info; 2115 bfd_vma address; 2116{ 2117 struct elf_link_hash_table *htab = elf_hash_table (info); 2118 2119 /* If tls_sec is NULL, we should have signalled an error already. */ 2120 if (htab->tls_sec == NULL) 2121 return 0; 2122 return address - htab->tls_size - htab->tls_sec->vma; 2123} 2124 2125/* Relocate a SPARC ELF section. */ 2126 2127static bfd_boolean 2128elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, 2129 contents, relocs, local_syms, local_sections) 2130 bfd *output_bfd; 2131 struct bfd_link_info *info; 2132 bfd *input_bfd; 2133 asection *input_section; 2134 bfd_byte *contents; 2135 Elf_Internal_Rela *relocs; 2136 Elf_Internal_Sym *local_syms; 2137 asection **local_sections; 2138{ 2139 struct elf32_sparc_link_hash_table *htab; 2140 Elf_Internal_Shdr *symtab_hdr; 2141 struct elf_link_hash_entry **sym_hashes; 2142 bfd_vma *local_got_offsets; 2143 bfd_vma got_base; 2144 asection *sreloc; 2145 Elf_Internal_Rela *rel; 2146 Elf_Internal_Rela *relend; 2147 2148 if (info->relocatable) 2149 return TRUE; 2150 2151 htab = elf32_sparc_hash_table (info); 2152 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2153 sym_hashes = elf_sym_hashes (input_bfd); 2154 local_got_offsets = elf_local_got_offsets (input_bfd); 2155 2156 if (elf_hash_table (info)->hgot == NULL) 2157 got_base = 0; 2158 else 2159 got_base = elf_hash_table (info)->hgot->root.u.def.value; 2160 2161 sreloc = elf_section_data (input_section)->sreloc; 2162 2163 rel = relocs; 2164 relend = relocs + input_section->reloc_count; 2165 for (; rel < relend; rel++) 2166 { 2167 int r_type, tls_type; 2168 reloc_howto_type *howto; 2169 unsigned long r_symndx; 2170 struct elf_link_hash_entry *h; 2171 Elf_Internal_Sym *sym; 2172 asection *sec; 2173 bfd_vma relocation, off; 2174 bfd_reloc_status_type r; 2175 bfd_boolean is_plt = FALSE; 2176 bfd_boolean unresolved_reloc; 2177 2178 r_type = ELF32_R_TYPE (rel->r_info); 2179 2180 if (r_type == R_SPARC_GNU_VTINHERIT 2181 || r_type == R_SPARC_GNU_VTENTRY) 2182 continue; 2183 2184 if (r_type < 0 || r_type >= (int) R_SPARC_max_std) 2185 { 2186 bfd_set_error (bfd_error_bad_value); 2187 return FALSE; 2188 } 2189 howto = _bfd_sparc_elf_howto_table + r_type; 2190 2191 /* This is a final link. */ 2192 r_symndx = ELF32_R_SYM (rel->r_info); 2193 h = NULL; 2194 sym = NULL; 2195 sec = NULL; 2196 unresolved_reloc = FALSE; 2197 if (r_symndx < symtab_hdr->sh_info) 2198 { 2199 sym = local_syms + r_symndx; 2200 sec = local_sections[r_symndx]; 2201 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 2202 } 2203 else 2204 { 2205 bfd_boolean warned ATTRIBUTE_UNUSED; 2206 2207 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 2208 r_symndx, symtab_hdr, sym_hashes, 2209 h, sec, relocation, 2210 unresolved_reloc, warned); 2211 } 2212 2213 switch (r_type) 2214 { 2215 case R_SPARC_GOT10: 2216 case R_SPARC_GOT13: 2217 case R_SPARC_GOT22: 2218 /* Relocation is to the entry for this symbol in the global 2219 offset table. */ 2220 if (htab->sgot == NULL) 2221 abort (); 2222 2223 if (h != NULL) 2224 { 2225 bfd_boolean dyn; 2226 2227 off = h->got.offset; 2228 BFD_ASSERT (off != (bfd_vma) -1); 2229 dyn = elf_hash_table (info)->dynamic_sections_created; 2230 2231 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 2232 || (info->shared 2233 && (info->symbolic 2234 || h->dynindx == -1 2235 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) 2236 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) 2237 { 2238 /* This is actually a static link, or it is a 2239 -Bsymbolic link and the symbol is defined 2240 locally, or the symbol was forced to be local 2241 because of a version file. We must initialize 2242 this entry in the global offset table. Since the 2243 offset must always be a multiple of 4, we use the 2244 least significant bit to record whether we have 2245 initialized it already. 2246 2247 When doing a dynamic link, we create a .rela.got 2248 relocation entry to initialize the value. This 2249 is done in the finish_dynamic_symbol routine. */ 2250 if ((off & 1) != 0) 2251 off &= ~1; 2252 else 2253 { 2254 bfd_put_32 (output_bfd, relocation, 2255 htab->sgot->contents + off); 2256 h->got.offset |= 1; 2257 } 2258 } 2259 else 2260 unresolved_reloc = FALSE; 2261 } 2262 else 2263 { 2264 BFD_ASSERT (local_got_offsets != NULL 2265 && local_got_offsets[r_symndx] != (bfd_vma) -1); 2266 2267 off = local_got_offsets[r_symndx]; 2268 2269 /* The offset must always be a multiple of 4. We use 2270 the least significant bit to record whether we have 2271 already processed this entry. */ 2272 if ((off & 1) != 0) 2273 off &= ~1; 2274 else 2275 { 2276 2277 if (info->shared) 2278 { 2279 asection *s; 2280 Elf_Internal_Rela outrel; 2281 bfd_byte *loc; 2282 2283 /* We need to generate a R_SPARC_RELATIVE reloc 2284 for the dynamic linker. */ 2285 s = htab->srelgot; 2286 BFD_ASSERT (s != NULL); 2287 2288 outrel.r_offset = (htab->sgot->output_section->vma 2289 + htab->sgot->output_offset 2290 + off); 2291 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); 2292 outrel.r_addend = relocation; 2293 relocation = 0; 2294 loc = s->contents; 2295 loc += s->reloc_count++ * sizeof (Elf32_External_Rela); 2296 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 2297 } 2298 2299 bfd_put_32 (output_bfd, relocation, 2300 htab->sgot->contents + off); 2301 local_got_offsets[r_symndx] |= 1; 2302 } 2303 } 2304 relocation = htab->sgot->output_offset + off - got_base; 2305 break; 2306 2307 case R_SPARC_PLT32: 2308 if (h == NULL || h->plt.offset == (bfd_vma) -1) 2309 { 2310 r_type = R_SPARC_32; 2311 goto r_sparc_plt32; 2312 } 2313 /* Fall through. */ 2314 case R_SPARC_WPLT30: 2315 r_sparc_wplt30: 2316 /* Relocation is to the entry for this symbol in the 2317 procedure linkage table. */ 2318 2319 /* The Solaris native assembler will generate a WPLT30 reloc 2320 for a local symbol if you assemble a call from one 2321 section to another when using -K pic. We treat it as 2322 WDISP30. */ 2323 if (h == NULL) 2324 break; 2325 2326 if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL) 2327 { 2328 /* We didn't make a PLT entry for this symbol. This 2329 happens when statically linking PIC code, or when 2330 using -Bsymbolic. */ 2331 break; 2332 } 2333 2334 relocation = (htab->splt->output_section->vma 2335 + htab->splt->output_offset 2336 + h->plt.offset); 2337 unresolved_reloc = FALSE; 2338 if (r_type == R_SPARC_PLT32) 2339 { 2340 r_type = R_SPARC_32; 2341 is_plt = TRUE; 2342 goto r_sparc_plt32; 2343 } 2344 break; 2345 2346 case R_SPARC_PC10: 2347 case R_SPARC_PC22: 2348 if (h != NULL 2349 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 2350 break; 2351 /* Fall through. */ 2352 case R_SPARC_DISP8: 2353 case R_SPARC_DISP16: 2354 case R_SPARC_DISP32: 2355 case R_SPARC_WDISP30: 2356 case R_SPARC_WDISP22: 2357 case R_SPARC_WDISP19: 2358 case R_SPARC_WDISP16: 2359 case R_SPARC_8: 2360 case R_SPARC_16: 2361 case R_SPARC_32: 2362 case R_SPARC_HI22: 2363 case R_SPARC_22: 2364 case R_SPARC_13: 2365 case R_SPARC_LO10: 2366 case R_SPARC_UA16: 2367 case R_SPARC_UA32: 2368 r_sparc_plt32: 2369 /* r_symndx will be zero only for relocs against symbols 2370 from removed linkonce sections, or sections discarded by 2371 a linker script. */ 2372 if (r_symndx == 0 2373 || (input_section->flags & SEC_ALLOC) == 0) 2374 break; 2375 2376 if ((info->shared 2377 && (! howto->pc_relative 2378 || (h != NULL 2379 && h->dynindx != -1 2380 && (! info->symbolic 2381 || (h->elf_link_hash_flags 2382 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 2383 || (!info->shared 2384 && h != NULL 2385 && h->dynindx != -1 2386 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0 2387 && (((h->elf_link_hash_flags 2388 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 2389 && (h->elf_link_hash_flags 2390 & ELF_LINK_HASH_DEF_REGULAR) == 0) 2391 || h->root.type == bfd_link_hash_undefweak 2392 || h->root.type == bfd_link_hash_undefined))) 2393 { 2394 Elf_Internal_Rela outrel; 2395 bfd_byte *loc; 2396 bfd_boolean skip, relocate = FALSE; 2397 2398 /* When generating a shared object, these relocations 2399 are copied into the output file to be resolved at run 2400 time. */ 2401 2402 BFD_ASSERT (sreloc != NULL); 2403 2404 skip = FALSE; 2405 2406 outrel.r_offset = 2407 _bfd_elf_section_offset (output_bfd, info, input_section, 2408 rel->r_offset); 2409 if (outrel.r_offset == (bfd_vma) -1) 2410 skip = TRUE; 2411 else if (outrel.r_offset == (bfd_vma) -2) 2412 skip = TRUE, relocate = TRUE; 2413 outrel.r_offset += (input_section->output_section->vma 2414 + input_section->output_offset); 2415 2416 /* Optimize unaligned reloc usage now that we know where 2417 it finally resides. */ 2418 switch (r_type) 2419 { 2420 case R_SPARC_16: 2421 if (outrel.r_offset & 1) 2422 r_type = R_SPARC_UA16; 2423 break; 2424 case R_SPARC_UA16: 2425 if (!(outrel.r_offset & 1)) 2426 r_type = R_SPARC_16; 2427 break; 2428 case R_SPARC_32: 2429 if (outrel.r_offset & 3) 2430 r_type = R_SPARC_UA32; 2431 break; 2432 case R_SPARC_UA32: 2433 if (!(outrel.r_offset & 3)) 2434 r_type = R_SPARC_32; 2435 break; 2436 case R_SPARC_DISP8: 2437 case R_SPARC_DISP16: 2438 case R_SPARC_DISP32: 2439 /* If the symbol is not dynamic, we should not keep 2440 a dynamic relocation. But an .rela.* slot has been 2441 allocated for it, output R_SPARC_NONE. 2442 FIXME: Add code tracking needed dynamic relocs as 2443 e.g. i386 has. */ 2444 if (h->dynindx == -1) 2445 skip = TRUE, relocate = TRUE; 2446 break; 2447 } 2448 2449 if (skip) 2450 memset (&outrel, 0, sizeof outrel); 2451 /* h->dynindx may be -1 if the symbol was marked to 2452 become local. */ 2453 else if (h != NULL && ! is_plt 2454 && ((! info->symbolic && h->dynindx != -1) 2455 || (h->elf_link_hash_flags 2456 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 2457 { 2458 BFD_ASSERT (h->dynindx != -1); 2459 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 2460 outrel.r_addend = rel->r_addend; 2461 } 2462 else 2463 { 2464 if (r_type == R_SPARC_32) 2465 { 2466 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); 2467 outrel.r_addend = relocation + rel->r_addend; 2468 } 2469 else 2470 { 2471 long indx; 2472 2473 if (is_plt) 2474 sec = htab->splt; 2475 2476 if (bfd_is_abs_section (sec)) 2477 indx = 0; 2478 else if (sec == NULL || sec->owner == NULL) 2479 { 2480 bfd_set_error (bfd_error_bad_value); 2481 return FALSE; 2482 } 2483 else 2484 { 2485 asection *osec; 2486 2487 osec = sec->output_section; 2488 indx = elf_section_data (osec)->dynindx; 2489 2490 /* FIXME: we really should be able to link non-pic 2491 shared libraries. */ 2492 if (indx == 0) 2493 { 2494 BFD_FAIL (); 2495 (*_bfd_error_handler) 2496 (_("%s: probably compiled without -fPIC?"), 2497 bfd_archive_filename (input_bfd)); 2498 bfd_set_error (bfd_error_bad_value); 2499 return FALSE; 2500 } 2501 } 2502 2503 outrel.r_info = ELF32_R_INFO (indx, r_type); 2504 outrel.r_addend = relocation + rel->r_addend; 2505 } 2506 } 2507 2508 loc = sreloc->contents; 2509 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 2510 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 2511 2512 /* This reloc will be computed at runtime, so there's no 2513 need to do anything now. */ 2514 if (! relocate) 2515 continue; 2516 } 2517 break; 2518 2519 case R_SPARC_TLS_GD_HI22: 2520 if (! elf32_sparc_tdata (input_bfd)->has_tlsgd) 2521 { 2522 /* R_SPARC_REV32 used the same reloc number as 2523 R_SPARC_TLS_GD_HI22. */ 2524 r_type = R_SPARC_REV32; 2525 break; 2526 } 2527 /* Fall through */ 2528 2529 case R_SPARC_TLS_GD_LO10: 2530 case R_SPARC_TLS_IE_HI22: 2531 case R_SPARC_TLS_IE_LO10: 2532 r_type = elf32_sparc_tls_transition (info, input_bfd, r_type, 2533 h == NULL); 2534 tls_type = GOT_UNKNOWN; 2535 if (h == NULL && local_got_offsets) 2536 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx]; 2537 else if (h != NULL) 2538 { 2539 tls_type = elf32_sparc_hash_entry(h)->tls_type; 2540 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE) 2541 switch (ELF32_R_TYPE (rel->r_info)) 2542 { 2543 case R_SPARC_TLS_GD_HI22: 2544 case R_SPARC_TLS_IE_HI22: 2545 r_type = R_SPARC_TLS_LE_HIX22; 2546 break; 2547 default: 2548 r_type = R_SPARC_TLS_LE_LOX10; 2549 break; 2550 } 2551 } 2552 if (tls_type == GOT_TLS_IE) 2553 switch (r_type) 2554 { 2555 case R_SPARC_TLS_GD_HI22: 2556 r_type = R_SPARC_TLS_IE_HI22; 2557 break; 2558 case R_SPARC_TLS_GD_LO10: 2559 r_type = R_SPARC_TLS_IE_LO10; 2560 break; 2561 } 2562 2563 if (r_type == R_SPARC_TLS_LE_HIX22) 2564 { 2565 relocation = tpoff (info, relocation); 2566 break; 2567 } 2568 if (r_type == R_SPARC_TLS_LE_LOX10) 2569 { 2570 /* Change add into xor. */ 2571 relocation = tpoff (info, relocation); 2572 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd, 2573 contents + rel->r_offset) 2574 | 0x80182000), contents + rel->r_offset); 2575 break; 2576 } 2577 2578 if (h != NULL) 2579 { 2580 off = h->got.offset; 2581 h->got.offset |= 1; 2582 } 2583 else 2584 { 2585 BFD_ASSERT (local_got_offsets != NULL); 2586 off = local_got_offsets[r_symndx]; 2587 local_got_offsets[r_symndx] |= 1; 2588 } 2589 2590 r_sparc_tlsldm: 2591 if (htab->sgot == NULL) 2592 abort (); 2593 2594 if ((off & 1) != 0) 2595 off &= ~1; 2596 else 2597 { 2598 Elf_Internal_Rela outrel; 2599 Elf32_External_Rela *loc; 2600 int dr_type, indx; 2601 2602 if (htab->srelgot == NULL) 2603 abort (); 2604 2605 bfd_put_32 (output_bfd, 0, htab->sgot->contents + off); 2606 outrel.r_offset = (htab->sgot->output_section->vma 2607 + htab->sgot->output_offset + off); 2608 indx = h && h->dynindx != -1 ? h->dynindx : 0; 2609 if (r_type == R_SPARC_TLS_IE_HI22 2610 || r_type == R_SPARC_TLS_IE_LO10) 2611 dr_type = R_SPARC_TLS_TPOFF32; 2612 else 2613 dr_type = R_SPARC_TLS_DTPMOD32; 2614 if (dr_type == R_SPARC_TLS_TPOFF32 && indx == 0) 2615 outrel.r_addend = relocation - dtpoff_base (info); 2616 else 2617 outrel.r_addend = 0; 2618 outrel.r_info = ELF32_R_INFO (indx, dr_type); 2619 loc = (Elf32_External_Rela *) htab->srelgot->contents; 2620 loc += htab->srelgot->reloc_count++; 2621 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 2622 (bfd_byte *) loc); 2623 2624 if (r_type == R_SPARC_TLS_GD_HI22 2625 || r_type == R_SPARC_TLS_GD_LO10) 2626 { 2627 if (indx == 0) 2628 { 2629 BFD_ASSERT (! unresolved_reloc); 2630 bfd_put_32 (output_bfd, 2631 relocation - dtpoff_base (info), 2632 htab->sgot->contents + off + 4); 2633 } 2634 else 2635 { 2636 bfd_put_32 (output_bfd, 0, 2637 htab->sgot->contents + off + 4); 2638 outrel.r_info = ELF32_R_INFO (indx, 2639 R_SPARC_TLS_DTPOFF32); 2640 outrel.r_offset += 4; 2641 htab->srelgot->reloc_count++; 2642 loc++; 2643 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 2644 (bfd_byte *) loc); 2645 } 2646 } 2647 else if (dr_type == R_SPARC_TLS_DTPMOD32) 2648 { 2649 bfd_put_32 (output_bfd, 0, 2650 htab->sgot->contents + off + 4); 2651 } 2652 } 2653 2654 if (off >= (bfd_vma) -2) 2655 abort (); 2656 2657 relocation = htab->sgot->output_offset + off - got_base; 2658 unresolved_reloc = FALSE; 2659 howto = _bfd_sparc_elf_howto_table + r_type; 2660 break; 2661 2662 case R_SPARC_TLS_LDM_HI22: 2663 case R_SPARC_TLS_LDM_LO10: 2664 if (! info->shared) 2665 { 2666 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset); 2667 continue; 2668 } 2669 off = htab->tls_ldm_got.offset; 2670 htab->tls_ldm_got.offset |= 1; 2671 goto r_sparc_tlsldm; 2672 2673 case R_SPARC_TLS_LDO_HIX22: 2674 case R_SPARC_TLS_LDO_LOX10: 2675 if (info->shared) 2676 relocation -= dtpoff_base (info); 2677 else 2678 relocation = tpoff (info, relocation); 2679 break; 2680 2681 case R_SPARC_TLS_LE_HIX22: 2682 case R_SPARC_TLS_LE_LOX10: 2683 if (info->shared) 2684 { 2685 Elf_Internal_Rela outrel; 2686 bfd_boolean skip, relocate = FALSE; 2687 2688 BFD_ASSERT (sreloc != NULL); 2689 skip = FALSE; 2690 outrel.r_offset = 2691 _bfd_elf_section_offset (output_bfd, info, input_section, 2692 rel->r_offset); 2693 if (outrel.r_offset == (bfd_vma) -1) 2694 skip = TRUE; 2695 else if (outrel.r_offset == (bfd_vma) -2) 2696 skip = TRUE, relocate = TRUE; 2697 outrel.r_offset += (input_section->output_section->vma 2698 + input_section->output_offset); 2699 if (skip) 2700 memset (&outrel, 0, sizeof outrel); 2701 else 2702 { 2703 outrel.r_info = ELF32_R_INFO (0, r_type); 2704 outrel.r_addend = relocation - dtpoff_base (info) 2705 + rel->r_addend; 2706 } 2707 2708 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 2709 (bfd_byte *) (((Elf32_External_Rela *) 2710 sreloc->contents) 2711 + sreloc->reloc_count)); 2712 ++sreloc->reloc_count; 2713 continue; 2714 } 2715 relocation = tpoff (info, relocation); 2716 break; 2717 2718 case R_SPARC_TLS_LDM_CALL: 2719 if (! info->shared) 2720 { 2721 /* mov %g0, %o0 */ 2722 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset); 2723 continue; 2724 } 2725 /* Fall through */ 2726 2727 case R_SPARC_TLS_GD_CALL: 2728 tls_type = GOT_UNKNOWN; 2729 if (h == NULL && local_got_offsets) 2730 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx]; 2731 else if (h != NULL) 2732 tls_type = elf32_sparc_hash_entry(h)->tls_type; 2733 if (! info->shared 2734 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE)) 2735 { 2736 bfd_vma insn; 2737 2738 if (!info->shared && (h == NULL || h->dynindx == -1)) 2739 { 2740 /* GD -> LE */ 2741 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset); 2742 continue; 2743 } 2744 2745 /* GD -> IE */ 2746 if (rel + 1 < relend 2747 && ELF32_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD 2748 && rel[1].r_offset == rel->r_offset + 4 2749 && ELF32_R_SYM (rel[1].r_info) == r_symndx 2750 && (((insn = bfd_get_32 (input_bfd, 2751 contents + rel[1].r_offset)) 2752 >> 25) & 0x1f) == 8) 2753 { 2754 /* We have 2755 call __tls_get_addr, %tgd_call(foo) 2756 add %reg1, %reg2, %o0, %tgd_add(foo) 2757 and change it into IE: 2758 ld [%reg1 + %reg2], %o0, %tie_ld(foo) 2759 add %g7, %o0, %o0, %tie_add(foo). 2760 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2, 2761 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2. */ 2762 bfd_put_32 (output_bfd, insn | 0xc0000000, 2763 contents + rel->r_offset); 2764 bfd_put_32 (output_bfd, 0x9001c008, 2765 contents + rel->r_offset + 4); 2766 rel++; 2767 continue; 2768 } 2769 2770 bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset); 2771 continue; 2772 } 2773 2774 h = (struct elf_link_hash_entry *) 2775 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE, 2776 FALSE, TRUE); 2777 BFD_ASSERT (h != NULL); 2778 r_type = R_SPARC_WPLT30; 2779 howto = _bfd_sparc_elf_howto_table + r_type; 2780 goto r_sparc_wplt30; 2781 2782 case R_SPARC_TLS_GD_ADD: 2783 tls_type = GOT_UNKNOWN; 2784 if (h == NULL && local_got_offsets) 2785 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx]; 2786 else if (h != NULL) 2787 tls_type = elf32_sparc_hash_entry(h)->tls_type; 2788 if (! info->shared || tls_type == GOT_TLS_IE) 2789 { 2790 /* add %reg1, %reg2, %reg3, %tgd_add(foo) 2791 changed into IE: 2792 ld [%reg1 + %reg2], %reg3, %tie_ld(foo) 2793 or LE: 2794 add %g7, %reg2, %reg3. */ 2795 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 2796 if ((h != NULL && h->dynindx != -1) || info->shared) 2797 relocation = insn | 0xc0000000; 2798 else 2799 relocation = (insn & ~0x7c000) | 0x1c000; 2800 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset); 2801 } 2802 continue; 2803 2804 case R_SPARC_TLS_LDM_ADD: 2805 if (! info->shared) 2806 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset); 2807 continue; 2808 2809 case R_SPARC_TLS_LDO_ADD: 2810 if (! info->shared) 2811 { 2812 /* Change rs1 into %g7. */ 2813 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 2814 insn = (insn & ~0x7c000) | 0x1c000; 2815 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 2816 } 2817 continue; 2818 2819 case R_SPARC_TLS_IE_LD: 2820 case R_SPARC_TLS_IE_LDX: 2821 if (! info->shared && (h == NULL || h->dynindx == -1)) 2822 { 2823 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 2824 int rs2 = insn & 0x1f; 2825 int rd = (insn >> 25) & 0x1f; 2826 2827 if (rs2 == rd) 2828 relocation = SPARC_NOP; 2829 else 2830 relocation = 0x80100000 | (insn & 0x3e00001f); 2831 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset); 2832 } 2833 continue; 2834 2835 case R_SPARC_TLS_IE_ADD: 2836 /* Totally useless relocation. */ 2837 continue; 2838 2839 case R_SPARC_TLS_DTPOFF32: 2840 relocation -= dtpoff_base (info); 2841 break; 2842 2843 default: 2844 break; 2845 } 2846 2847 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 2848 because such sections are not SEC_ALLOC and thus ld.so will 2849 not process them. */ 2850 if (unresolved_reloc 2851 && !((input_section->flags & SEC_DEBUGGING) != 0 2852 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)) 2853 (*_bfd_error_handler) 2854 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"), 2855 bfd_archive_filename (input_bfd), 2856 bfd_get_section_name (input_bfd, input_section), 2857 (long) rel->r_offset, 2858 h->root.root.string); 2859 2860 r = bfd_reloc_continue; 2861 if (r_type == R_SPARC_WDISP16) 2862 { 2863 bfd_vma x; 2864 2865 relocation += rel->r_addend; 2866 relocation -= (input_section->output_section->vma 2867 + input_section->output_offset); 2868 relocation -= rel->r_offset; 2869 2870 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2871 x |= ((((relocation >> 2) & 0xc000) << 6) 2872 | ((relocation >> 2) & 0x3fff)); 2873 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 2874 2875 if ((bfd_signed_vma) relocation < - 0x40000 2876 || (bfd_signed_vma) relocation > 0x3ffff) 2877 r = bfd_reloc_overflow; 2878 else 2879 r = bfd_reloc_ok; 2880 } 2881 else if (r_type == R_SPARC_REV32) 2882 { 2883 bfd_vma x; 2884 2885 relocation = relocation + rel->r_addend; 2886 2887 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2888 x = x + relocation; 2889 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset); 2890 r = bfd_reloc_ok; 2891 } 2892 else if (r_type == R_SPARC_TLS_LDO_HIX22 2893 || r_type == R_SPARC_TLS_LE_HIX22) 2894 { 2895 bfd_vma x; 2896 2897 relocation += rel->r_addend; 2898 relocation = relocation ^ 0xffffffff; 2899 2900 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2901 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff); 2902 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 2903 r = bfd_reloc_ok; 2904 } 2905 else if (r_type == R_SPARC_TLS_LDO_LOX10 2906 || r_type == R_SPARC_TLS_LE_LOX10) 2907 { 2908 bfd_vma x; 2909 2910 relocation += rel->r_addend; 2911 relocation = (relocation & 0x3ff) | 0x1c00; 2912 2913 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2914 x = (x & ~(bfd_vma) 0x1fff) | relocation; 2915 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 2916 2917 r = bfd_reloc_ok; 2918 } 2919 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30) 2920 && sec_do_relax (input_section) 2921 && rel->r_offset + 4 < input_section->_raw_size) 2922 { 2923#define G0 0 2924#define O7 15 2925#define XCC (2 << 20) 2926#define COND(x) (((x)&0xf)<<25) 2927#define CONDA COND(0x8) 2928#define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC) 2929#define INSN_BA (F2(0,2) | CONDA) 2930#define INSN_OR F3(2, 0x2, 0) 2931#define INSN_NOP F2(0,4) 2932 2933 bfd_vma x, y; 2934 2935 /* If the instruction is a call with either: 2936 restore 2937 arithmetic instruction with rd == %o7 2938 where rs1 != %o7 and rs2 if it is register != %o7 2939 then we can optimize if the call destination is near 2940 by changing the call into a branch always. */ 2941 x = bfd_get_32 (input_bfd, contents + rel->r_offset); 2942 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4); 2943 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2)) 2944 { 2945 if (((y & OP3(~0)) == OP3(0x3d) /* restore */ 2946 || ((y & OP3(0x28)) == 0 /* arithmetic */ 2947 && (y & RD(~0)) == RD(O7))) 2948 && (y & RS1(~0)) != RS1(O7) 2949 && ((y & F3I(~0)) 2950 || (y & RS2(~0)) != RS2(O7))) 2951 { 2952 bfd_vma reloc; 2953 2954 reloc = relocation + rel->r_addend - rel->r_offset; 2955 reloc -= (input_section->output_section->vma 2956 + input_section->output_offset); 2957 2958 /* Ensure the reloc fits into simm22. */ 2959 if ((reloc & 3) == 0 2960 && ((reloc & ~(bfd_vma)0x7fffff) == 0 2961 || ((reloc | 0x7fffff) == ~(bfd_vma)0))) 2962 { 2963 reloc >>= 2; 2964 2965 /* Check whether it fits into simm19 on v9. */ 2966 if (((reloc & 0x3c0000) == 0 2967 || (reloc & 0x3c0000) == 0x3c0000) 2968 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS)) 2969 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */ 2970 else 2971 x = INSN_BA | (reloc & 0x3fffff); /* ba */ 2972 bfd_put_32 (input_bfd, x, contents + rel->r_offset); 2973 r = bfd_reloc_ok; 2974 if (rel->r_offset >= 4 2975 && (y & (0xffffffff ^ RS1(~0))) 2976 == (INSN_OR | RD(O7) | RS2(G0))) 2977 { 2978 bfd_vma z; 2979 unsigned int reg; 2980 2981 z = bfd_get_32 (input_bfd, 2982 contents + rel->r_offset - 4); 2983 if ((z & (0xffffffff ^ RD(~0))) 2984 != (INSN_OR | RS1(O7) | RS2(G0))) 2985 break; 2986 2987 /* The sequence was 2988 or %o7, %g0, %rN 2989 call foo 2990 or %rN, %g0, %o7 2991 2992 If call foo was replaced with ba, replace 2993 or %rN, %g0, %o7 with nop. */ 2994 2995 reg = (y & RS1(~0)) >> 14; 2996 if (reg != ((z & RD(~0)) >> 25) 2997 || reg == G0 || reg == O7) 2998 break; 2999 3000 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP, 3001 contents + rel->r_offset + 4); 3002 } 3003 3004 } 3005 } 3006 } 3007 } 3008 3009 if (r == bfd_reloc_continue) 3010 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 3011 contents, rel->r_offset, 3012 relocation, rel->r_addend); 3013 3014 if (r != bfd_reloc_ok) 3015 { 3016 switch (r) 3017 { 3018 default: 3019 case bfd_reloc_outofrange: 3020 abort (); 3021 case bfd_reloc_overflow: 3022 { 3023 const char *name; 3024 3025 if (h != NULL) 3026 name = h->root.root.string; 3027 else 3028 { 3029 name = bfd_elf_string_from_elf_section (input_bfd, 3030 symtab_hdr->sh_link, 3031 sym->st_name); 3032 if (name == NULL) 3033 return FALSE; 3034 if (*name == '\0') 3035 name = bfd_section_name (input_bfd, sec); 3036 } 3037 if (! ((*info->callbacks->reloc_overflow) 3038 (info, name, howto->name, (bfd_vma) 0, 3039 input_bfd, input_section, rel->r_offset))) 3040 return FALSE; 3041 } 3042 break; 3043 } 3044 } 3045 } 3046 3047 return TRUE; 3048} 3049 3050/* Finish up dynamic symbol handling. We set the contents of various 3051 dynamic sections here. */ 3052 3053static bfd_boolean 3054elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym) 3055 bfd *output_bfd; 3056 struct bfd_link_info *info; 3057 struct elf_link_hash_entry *h; 3058 Elf_Internal_Sym *sym; 3059{ 3060 bfd *dynobj; 3061 struct elf32_sparc_link_hash_table *htab; 3062 3063 htab = elf32_sparc_hash_table (info); 3064 dynobj = htab->elf.dynobj; 3065 3066 if (h->plt.offset != (bfd_vma) -1) 3067 { 3068 asection *splt; 3069 asection *srela; 3070 Elf_Internal_Rela rela; 3071 bfd_byte *loc; 3072 3073 /* This symbol has an entry in the procedure linkage table. Set 3074 it up. */ 3075 3076 BFD_ASSERT (h->dynindx != -1); 3077 3078 splt = htab->splt; 3079 srela = htab->srelplt; 3080 BFD_ASSERT (splt != NULL && srela != NULL); 3081 3082 /* Fill in the entry in the procedure linkage table. */ 3083 bfd_put_32 (output_bfd, 3084 PLT_ENTRY_WORD0 + h->plt.offset, 3085 splt->contents + h->plt.offset); 3086 bfd_put_32 (output_bfd, 3087 (PLT_ENTRY_WORD1 3088 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)), 3089 splt->contents + h->plt.offset + 4); 3090 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2, 3091 splt->contents + h->plt.offset + 8); 3092 3093 /* Fill in the entry in the .rela.plt section. */ 3094 rela.r_offset = (splt->output_section->vma 3095 + splt->output_offset 3096 + h->plt.offset); 3097 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT); 3098 rela.r_addend = 0; 3099 loc = srela->contents; 3100 loc += (h->plt.offset / PLT_ENTRY_SIZE - 4) * sizeof (Elf32_External_Rela); 3101 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 3102 3103 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 3104 { 3105 /* Mark the symbol as undefined, rather than as defined in 3106 the .plt section. Leave the value alone. */ 3107 sym->st_shndx = SHN_UNDEF; 3108 /* If the symbol is weak, we do need to clear the value. 3109 Otherwise, the PLT entry would provide a definition for 3110 the symbol even if the symbol wasn't defined anywhere, 3111 and so the symbol would never be NULL. */ 3112 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK) 3113 == 0) 3114 sym->st_value = 0; 3115 } 3116 } 3117 3118 if (h->got.offset != (bfd_vma) -1 3119 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_GD 3120 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_IE) 3121 { 3122 asection *sgot; 3123 asection *srela; 3124 Elf_Internal_Rela rela; 3125 bfd_byte *loc; 3126 3127 /* This symbol has an entry in the global offset table. Set it 3128 up. */ 3129 3130 sgot = htab->sgot; 3131 srela = htab->srelgot; 3132 BFD_ASSERT (sgot != NULL && srela != NULL); 3133 3134 rela.r_offset = (sgot->output_section->vma 3135 + sgot->output_offset 3136 + (h->got.offset &~ (bfd_vma) 1)); 3137 3138 /* If this is a -Bsymbolic link, and the symbol is defined 3139 locally, we just want to emit a RELATIVE reloc. Likewise if 3140 the symbol was forced to be local because of a version file. 3141 The entry in the global offset table will already have been 3142 initialized in the relocate_section function. */ 3143 if (info->shared 3144 && (info->symbolic || h->dynindx == -1) 3145 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 3146 { 3147 asection *sec = h->root.u.def.section; 3148 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); 3149 rela.r_addend = (h->root.u.def.value 3150 + sec->output_section->vma 3151 + sec->output_offset); 3152 } 3153 else 3154 { 3155 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT); 3156 rela.r_addend = 0; 3157 } 3158 3159 bfd_put_32 (output_bfd, (bfd_vma) 0, 3160 sgot->contents + (h->got.offset &~ (bfd_vma) 1)); 3161 loc = srela->contents; 3162 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela); 3163 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 3164 } 3165 3166 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 3167 { 3168 asection *s; 3169 Elf_Internal_Rela rela; 3170 bfd_byte *loc; 3171 3172 /* This symbols needs a copy reloc. Set it up. */ 3173 3174 BFD_ASSERT (h->dynindx != -1); 3175 3176 s = bfd_get_section_by_name (h->root.u.def.section->owner, 3177 ".rela.bss"); 3178 BFD_ASSERT (s != NULL); 3179 3180 rela.r_offset = (h->root.u.def.value 3181 + h->root.u.def.section->output_section->vma 3182 + h->root.u.def.section->output_offset); 3183 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY); 3184 rela.r_addend = 0; 3185 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 3186 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 3187 } 3188 3189 /* Mark some specially defined symbols as absolute. */ 3190 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 3191 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 3192 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0) 3193 sym->st_shndx = SHN_ABS; 3194 3195 return TRUE; 3196} 3197 3198/* Finish up the dynamic sections. */ 3199 3200static bfd_boolean 3201elf32_sparc_finish_dynamic_sections (output_bfd, info) 3202 bfd *output_bfd; 3203 struct bfd_link_info *info; 3204{ 3205 bfd *dynobj; 3206 asection *sdyn; 3207 struct elf32_sparc_link_hash_table *htab; 3208 3209 htab = elf32_sparc_hash_table (info); 3210 dynobj = htab->elf.dynobj; 3211 3212 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 3213 3214 if (elf_hash_table (info)->dynamic_sections_created) 3215 { 3216 asection *splt; 3217 Elf32_External_Dyn *dyncon, *dynconend; 3218 3219 splt = bfd_get_section_by_name (dynobj, ".plt"); 3220 BFD_ASSERT (splt != NULL && sdyn != NULL); 3221 3222 dyncon = (Elf32_External_Dyn *) sdyn->contents; 3223 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 3224 for (; dyncon < dynconend; dyncon++) 3225 { 3226 Elf_Internal_Dyn dyn; 3227 const char *name; 3228 bfd_boolean size; 3229 3230 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 3231 3232 switch (dyn.d_tag) 3233 { 3234 case DT_PLTGOT: name = ".plt"; size = FALSE; break; 3235 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break; 3236 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break; 3237 default: name = NULL; size = FALSE; break; 3238 } 3239 3240 if (name != NULL) 3241 { 3242 asection *s; 3243 3244 s = bfd_get_section_by_name (output_bfd, name); 3245 if (s == NULL) 3246 dyn.d_un.d_val = 0; 3247 else 3248 { 3249 if (! size) 3250 dyn.d_un.d_ptr = s->vma; 3251 else 3252 { 3253 if (s->_cooked_size != 0) 3254 dyn.d_un.d_val = s->_cooked_size; 3255 else 3256 dyn.d_un.d_val = s->_raw_size; 3257 } 3258 } 3259 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 3260 } 3261 } 3262 3263 /* Clear the first four entries in the procedure linkage table, 3264 and put a nop in the last four bytes. */ 3265 if (splt->_raw_size > 0) 3266 { 3267 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE); 3268 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP, 3269 splt->contents + splt->_raw_size - 4); 3270 } 3271 3272 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0; 3273 } 3274 3275 /* Set the first entry in the global offset table to the address of 3276 the dynamic section. */ 3277 if (htab->sgot && htab->sgot->_raw_size > 0) 3278 { 3279 if (sdyn == NULL) 3280 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgot->contents); 3281 else 3282 bfd_put_32 (output_bfd, 3283 sdyn->output_section->vma + sdyn->output_offset, 3284 htab->sgot->contents); 3285 } 3286 3287 if (htab->sgot) 3288 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4; 3289 3290 return TRUE; 3291} 3292 3293/* Functions for dealing with the e_flags field. 3294 3295 We don't define set_private_flags or copy_private_bfd_data because 3296 the only currently defined values are based on the bfd mach number, 3297 so we use the latter instead and defer setting e_flags until the 3298 file is written out. */ 3299 3300/* Merge backend specific data from an object file to the output 3301 object file when linking. */ 3302 3303static bfd_boolean 3304elf32_sparc_merge_private_bfd_data (ibfd, obfd) 3305 bfd *ibfd; 3306 bfd *obfd; 3307{ 3308 bfd_boolean error; 3309 /* FIXME: This should not be static. */ 3310 static unsigned long previous_ibfd_e_flags = (unsigned long) -1; 3311 3312 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 3313 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 3314 return TRUE; 3315 3316 error = FALSE; 3317 3318 if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9) 3319 { 3320 error = TRUE; 3321 (*_bfd_error_handler) 3322 (_("%s: compiled for a 64 bit system and target is 32 bit"), 3323 bfd_archive_filename (ibfd)); 3324 } 3325 else if ((ibfd->flags & DYNAMIC) == 0) 3326 { 3327 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd)) 3328 bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd)); 3329 } 3330 3331 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA) 3332 != previous_ibfd_e_flags) 3333 && previous_ibfd_e_flags != (unsigned long) -1) 3334 { 3335 (*_bfd_error_handler) 3336 (_("%s: linking little endian files with big endian files"), 3337 bfd_archive_filename (ibfd)); 3338 error = TRUE; 3339 } 3340 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA; 3341 3342 if (error) 3343 { 3344 bfd_set_error (bfd_error_bad_value); 3345 return FALSE; 3346 } 3347 3348 return TRUE; 3349} 3350 3351/* Set the right machine number. */ 3352 3353static bfd_boolean 3354elf32_sparc_object_p (abfd) 3355 bfd *abfd; 3356{ 3357 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS) 3358 { 3359 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3) 3360 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 3361 bfd_mach_sparc_v8plusb); 3362 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1) 3363 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 3364 bfd_mach_sparc_v8plusa); 3365 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS) 3366 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 3367 bfd_mach_sparc_v8plus); 3368 else 3369 return FALSE; 3370 } 3371 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA) 3372 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, 3373 bfd_mach_sparc_sparclite_le); 3374 else 3375 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc); 3376} 3377 3378/* The final processing done just before writing out the object file. 3379 We need to set the e_machine field appropriately. */ 3380 3381static void 3382elf32_sparc_final_write_processing (abfd, linker) 3383 bfd *abfd; 3384 bfd_boolean linker ATTRIBUTE_UNUSED; 3385{ 3386 switch (bfd_get_mach (abfd)) 3387 { 3388 case bfd_mach_sparc : 3389 break; /* nothing to do */ 3390 case bfd_mach_sparc_v8plus : 3391 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; 3392 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; 3393 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS; 3394 break; 3395 case bfd_mach_sparc_v8plusa : 3396 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; 3397 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; 3398 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1; 3399 break; 3400 case bfd_mach_sparc_v8plusb : 3401 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS; 3402 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; 3403 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1 3404 | EF_SPARC_SUN_US3; 3405 break; 3406 case bfd_mach_sparc_sparclite_le : 3407 elf_elfheader (abfd)->e_machine = EM_SPARC; 3408 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA; 3409 break; 3410 default : 3411 abort (); 3412 break; 3413 } 3414} 3415 3416static enum elf_reloc_type_class 3417elf32_sparc_reloc_type_class (rela) 3418 const Elf_Internal_Rela *rela; 3419{ 3420 switch ((int) ELF32_R_TYPE (rela->r_info)) 3421 { 3422 case R_SPARC_RELATIVE: 3423 return reloc_class_relative; 3424 case R_SPARC_JMP_SLOT: 3425 return reloc_class_plt; 3426 case R_SPARC_COPY: 3427 return reloc_class_copy; 3428 default: 3429 return reloc_class_normal; 3430 } 3431} 3432 3433#define TARGET_BIG_SYM bfd_elf32_sparc_vec 3434#define TARGET_BIG_NAME "elf32-sparc" 3435#define ELF_ARCH bfd_arch_sparc 3436#define ELF_MACHINE_CODE EM_SPARC 3437#define ELF_MACHINE_ALT1 EM_SPARC32PLUS 3438#define ELF_MAXPAGESIZE 0x10000 3439 3440#define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup 3441#define bfd_elf32_bfd_link_hash_table_create \ 3442 elf32_sparc_link_hash_table_create 3443#define bfd_elf32_bfd_relax_section elf32_sparc_relax_section 3444#define bfd_elf32_new_section_hook elf32_sparc_new_section_hook 3445#define elf_info_to_howto elf32_sparc_info_to_howto 3446#define elf_backend_copy_indirect_symbol \ 3447 elf32_sparc_copy_indirect_symbol 3448#define elf_backend_create_dynamic_sections \ 3449 elf32_sparc_create_dynamic_sections 3450#define elf_backend_check_relocs elf32_sparc_check_relocs 3451#define elf_backend_adjust_dynamic_symbol \ 3452 elf32_sparc_adjust_dynamic_symbol 3453#define elf_backend_size_dynamic_sections \ 3454 elf32_sparc_size_dynamic_sections 3455#define elf_backend_relocate_section elf32_sparc_relocate_section 3456#define elf_backend_finish_dynamic_symbol \ 3457 elf32_sparc_finish_dynamic_symbol 3458#define elf_backend_finish_dynamic_sections \ 3459 elf32_sparc_finish_dynamic_sections 3460#define bfd_elf32_bfd_merge_private_bfd_data \ 3461 elf32_sparc_merge_private_bfd_data 3462#define bfd_elf32_mkobject elf32_sparc_mkobject 3463#define elf_backend_object_p elf32_sparc_object_p 3464#define elf_backend_final_write_processing \ 3465 elf32_sparc_final_write_processing 3466#define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook 3467#define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook 3468#define elf_backend_grok_psinfo elf32_sparc_grok_psinfo 3469#define elf_backend_reloc_type_class elf32_sparc_reloc_type_class 3470 3471#define elf_backend_can_gc_sections 1 3472#define elf_backend_can_refcount 1 3473#define elf_backend_want_got_plt 0 3474#define elf_backend_plt_readonly 0 3475#define elf_backend_want_plt_sym 1 3476#define elf_backend_got_header_size 4 3477#define elf_backend_rela_normal 1 3478 3479#include "elf32-target.h" 3480