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.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
26 #include "elf/sparc.h"
27 #include "opcode/sparc.h"
29 static reloc_howto_type *elf32_sparc_reloc_type_lookup
30 PARAMS ((bfd *, bfd_reloc_code_real_type));
31 static void elf32_sparc_info_to_howto
32 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
33 static bfd_boolean elf32_sparc_check_relocs
34 PARAMS ((bfd *, struct bfd_link_info *, asection *,
35 const Elf_Internal_Rela *));
36 static bfd_boolean elf32_sparc_adjust_dynamic_symbol
37 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
38 static bfd_boolean allocate_dynrelocs
39 PARAMS ((struct elf_link_hash_entry *, PTR));
40 static bfd_boolean readonly_dynrelocs
41 PARAMS ((struct elf_link_hash_entry *, PTR));
42 static bfd_boolean elf32_sparc_omit_section_dynsym
43 PARAMS ((bfd *, struct bfd_link_info *, asection *));
44 static bfd_boolean elf32_sparc_size_dynamic_sections
45 PARAMS ((bfd *, struct bfd_link_info *));
46 static bfd_boolean elf32_sparc_new_section_hook
47 PARAMS ((bfd *, asection *));
48 static bfd_boolean elf32_sparc_relax_section
49 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
50 static bfd_vma dtpoff_base
51 PARAMS ((struct bfd_link_info *));
53 PARAMS ((struct bfd_link_info *, bfd_vma));
54 static bfd_boolean elf32_sparc_relocate_section
55 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
56 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
57 static bfd_boolean elf32_sparc_finish_dynamic_symbol
58 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
60 static bfd_boolean elf32_sparc_finish_dynamic_sections
61 PARAMS ((bfd *, struct bfd_link_info *));
62 static bfd_boolean elf32_sparc_merge_private_bfd_data
63 PARAMS ((bfd *, bfd *));
64 static struct bfd_hash_entry *link_hash_newfunc
65 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
66 static struct bfd_link_hash_table *elf32_sparc_link_hash_table_create
68 static bfd_boolean create_got_section
69 PARAMS ((bfd *, struct bfd_link_info *));
70 static bfd_boolean elf32_sparc_create_dynamic_sections
71 PARAMS ((bfd *, struct bfd_link_info *));
72 static void elf32_sparc_copy_indirect_symbol
73 PARAMS ((const struct elf_backend_data *, struct elf_link_hash_entry *,
74 struct elf_link_hash_entry *));
75 static int elf32_sparc_tls_transition
76 PARAMS ((struct bfd_link_info *, bfd *, int, int));
78 static bfd_boolean elf32_sparc_mkobject
80 static bfd_boolean elf32_sparc_object_p
82 static void elf32_sparc_final_write_processing
83 PARAMS ((bfd *, bfd_boolean));
84 static enum elf_reloc_type_class elf32_sparc_reloc_type_class
85 PARAMS ((const Elf_Internal_Rela *));
86 static asection * elf32_sparc_gc_mark_hook
87 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
88 struct elf_link_hash_entry *, Elf_Internal_Sym *));
89 static bfd_boolean elf32_sparc_gc_sweep_hook
90 PARAMS ((bfd *, struct bfd_link_info *, asection *,
91 const Elf_Internal_Rela *));
93 /* The relocation "howto" table. */
95 static bfd_reloc_status_type sparc_elf_notsupported_reloc
96 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
97 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
98 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
99 static bfd_reloc_status_type sparc_elf_hix22_reloc
100 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
101 static bfd_reloc_status_type sparc_elf_lox10_reloc
102 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
104 reloc_howto_type _bfd_sparc_elf_howto_table[] =
106 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
107 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE),
108 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE),
109 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE),
110 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE),
111 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE),
112 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE),
113 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
114 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
115 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE),
116 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE),
117 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE),
118 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE),
119 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE),
120 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE),
121 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE),
122 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE),
123 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE),
124 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE),
125 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE),
126 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),
127 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),
128 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
129 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE),
130 HOWTO(R_SPARC_PLT32, 0,0,00,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE),
131 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE),
132 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE),
133 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE),
134 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE),
135 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE),
136 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE),
137 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE),
138 /* These are for sparc64 in a 64 bit environment.
139 Values need to be here because the table is indexed by reloc number. */
140 HOWTO(R_SPARC_64, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_64", FALSE,0,0x00000000,TRUE),
141 HOWTO(R_SPARC_OLO10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_OLO10", FALSE,0,0x00000000,TRUE),
142 HOWTO(R_SPARC_HH22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HH22", FALSE,0,0x00000000,TRUE),
143 HOWTO(R_SPARC_HM10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HM10", FALSE,0,0x00000000,TRUE),
144 HOWTO(R_SPARC_LM22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LM22", FALSE,0,0x00000000,TRUE),
145 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),
146 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),
147 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),
148 /* End sparc64 in 64 bit environment values.
149 The following are for sparc64 in a 32 bit environment. */
150 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
151 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
152 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),
153 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE),
154 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE),
155 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,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_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
163 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
164 HOWTO(R_SPARC_UA64, 0,0, 0,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_UA64", FALSE,0,0x00000000,TRUE),
165 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE),
166 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),
167 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),
168 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),
169 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),
170 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),
171 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),
172 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),
173 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),
174 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),
175 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),
176 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),
177 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),
178 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),
179 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),
180 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),
181 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),
182 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),
183 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),
184 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),
185 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),
186 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),
187 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),
188 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),
189 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)
191 static reloc_howto_type elf32_sparc_vtinherit_howto =
192 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
193 static reloc_howto_type elf32_sparc_vtentry_howto =
194 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);
195 static reloc_howto_type elf32_sparc_rev32_howto =
196 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
198 struct elf_reloc_map {
199 bfd_reloc_code_real_type bfd_reloc_val;
200 unsigned char elf_reloc_val;
203 static const struct elf_reloc_map sparc_reloc_map[] =
205 { BFD_RELOC_NONE, R_SPARC_NONE, },
206 { BFD_RELOC_16, R_SPARC_16, },
207 { BFD_RELOC_16_PCREL, R_SPARC_DISP16 },
208 { BFD_RELOC_8, R_SPARC_8 },
209 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
210 { BFD_RELOC_CTOR, R_SPARC_32 },
211 { BFD_RELOC_32, R_SPARC_32 },
212 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
213 { BFD_RELOC_HI22, R_SPARC_HI22 },
214 { BFD_RELOC_LO10, R_SPARC_LO10, },
215 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
216 { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 },
217 { BFD_RELOC_SPARC22, R_SPARC_22 },
218 { BFD_RELOC_SPARC13, R_SPARC_13 },
219 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
220 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
221 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
222 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
223 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
224 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
225 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
226 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
227 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
228 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
229 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
230 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
231 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
232 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
233 { BFD_RELOC_SPARC_10, R_SPARC_10 },
234 { BFD_RELOC_SPARC_11, R_SPARC_11 },
235 { BFD_RELOC_SPARC_64, R_SPARC_64 },
236 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
237 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
238 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
239 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
240 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
241 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
242 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
243 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
244 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
245 { BFD_RELOC_SPARC_7, R_SPARC_7 },
246 { BFD_RELOC_SPARC_5, R_SPARC_5 },
247 { BFD_RELOC_SPARC_6, R_SPARC_6 },
248 { BFD_RELOC_SPARC_TLS_GD_HI22, R_SPARC_TLS_GD_HI22 },
249 { BFD_RELOC_SPARC_TLS_GD_LO10, R_SPARC_TLS_GD_LO10 },
250 { BFD_RELOC_SPARC_TLS_GD_ADD, R_SPARC_TLS_GD_ADD },
251 { BFD_RELOC_SPARC_TLS_GD_CALL, R_SPARC_TLS_GD_CALL },
252 { BFD_RELOC_SPARC_TLS_LDM_HI22, R_SPARC_TLS_LDM_HI22 },
253 { BFD_RELOC_SPARC_TLS_LDM_LO10, R_SPARC_TLS_LDM_LO10 },
254 { BFD_RELOC_SPARC_TLS_LDM_ADD, R_SPARC_TLS_LDM_ADD },
255 { BFD_RELOC_SPARC_TLS_LDM_CALL, R_SPARC_TLS_LDM_CALL },
256 { BFD_RELOC_SPARC_TLS_LDO_HIX22, R_SPARC_TLS_LDO_HIX22 },
257 { BFD_RELOC_SPARC_TLS_LDO_LOX10, R_SPARC_TLS_LDO_LOX10 },
258 { BFD_RELOC_SPARC_TLS_LDO_ADD, R_SPARC_TLS_LDO_ADD },
259 { BFD_RELOC_SPARC_TLS_IE_HI22, R_SPARC_TLS_IE_HI22 },
260 { BFD_RELOC_SPARC_TLS_IE_LO10, R_SPARC_TLS_IE_LO10 },
261 { BFD_RELOC_SPARC_TLS_IE_LD, R_SPARC_TLS_IE_LD },
262 { BFD_RELOC_SPARC_TLS_IE_LDX, R_SPARC_TLS_IE_LDX },
263 { BFD_RELOC_SPARC_TLS_IE_ADD, R_SPARC_TLS_IE_ADD },
264 { BFD_RELOC_SPARC_TLS_LE_HIX22, R_SPARC_TLS_LE_HIX22 },
265 { BFD_RELOC_SPARC_TLS_LE_LOX10, R_SPARC_TLS_LE_LOX10 },
266 { BFD_RELOC_SPARC_TLS_DTPMOD32, R_SPARC_TLS_DTPMOD32 },
267 { BFD_RELOC_SPARC_TLS_DTPMOD64, R_SPARC_TLS_DTPMOD64 },
268 { BFD_RELOC_SPARC_TLS_DTPOFF32, R_SPARC_TLS_DTPOFF32 },
269 { BFD_RELOC_SPARC_TLS_DTPOFF64, R_SPARC_TLS_DTPOFF64 },
270 { BFD_RELOC_SPARC_TLS_TPOFF32, R_SPARC_TLS_TPOFF32 },
271 { BFD_RELOC_SPARC_TLS_TPOFF64, R_SPARC_TLS_TPOFF64 },
272 { BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT },
273 { BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY },
274 { BFD_RELOC_SPARC_REV32, R_SPARC_REV32 }
277 static reloc_howto_type *
278 elf32_sparc_reloc_type_lookup (abfd, code)
279 bfd *abfd ATTRIBUTE_UNUSED;
280 bfd_reloc_code_real_type code;
286 case BFD_RELOC_VTABLE_INHERIT:
287 return &elf32_sparc_vtinherit_howto;
289 case BFD_RELOC_VTABLE_ENTRY:
290 return &elf32_sparc_vtentry_howto;
292 case BFD_RELOC_SPARC_REV32:
293 return &elf32_sparc_rev32_howto;
297 i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map);
300 if (sparc_reloc_map[i].bfd_reloc_val == code)
301 return (_bfd_sparc_elf_howto_table
302 + (int) sparc_reloc_map[i].elf_reloc_val);
305 bfd_set_error (bfd_error_bad_value);
309 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
310 and elf64-sparc.c has its own copy. */
313 elf32_sparc_info_to_howto (abfd, cache_ptr, dst)
314 bfd *abfd ATTRIBUTE_UNUSED;
316 Elf_Internal_Rela *dst;
318 switch (ELF32_R_TYPE(dst->r_info))
320 case R_SPARC_GNU_VTINHERIT:
321 cache_ptr->howto = &elf32_sparc_vtinherit_howto;
324 case R_SPARC_GNU_VTENTRY:
325 cache_ptr->howto = &elf32_sparc_vtentry_howto;
329 cache_ptr->howto = &elf32_sparc_rev32_howto;
333 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std);
334 cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
338 /* For unsupported relocs. */
340 static bfd_reloc_status_type
341 sparc_elf_notsupported_reloc (abfd,
348 bfd *abfd ATTRIBUTE_UNUSED;
349 arelent *reloc_entry ATTRIBUTE_UNUSED;
350 asymbol *symbol ATTRIBUTE_UNUSED;
351 PTR data ATTRIBUTE_UNUSED;
352 asection *input_section ATTRIBUTE_UNUSED;
353 bfd *output_bfd ATTRIBUTE_UNUSED;
354 char **error_message ATTRIBUTE_UNUSED;
356 return bfd_reloc_notsupported;
359 /* Handle the WDISP16 reloc. */
361 static bfd_reloc_status_type
362 sparc_elf_wdisp16_reloc (abfd,
370 arelent *reloc_entry;
373 asection *input_section;
375 char **error_message ATTRIBUTE_UNUSED;
380 if (output_bfd != (bfd *) NULL
381 && (symbol->flags & BSF_SECTION_SYM) == 0
382 && (! reloc_entry->howto->partial_inplace
383 || reloc_entry->addend == 0))
385 reloc_entry->address += input_section->output_offset;
389 if (output_bfd != NULL)
390 return bfd_reloc_continue;
392 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
393 return bfd_reloc_outofrange;
395 relocation = (symbol->value
396 + symbol->section->output_section->vma
397 + symbol->section->output_offset);
398 relocation += reloc_entry->addend;
399 relocation -= (input_section->output_section->vma
400 + input_section->output_offset);
401 relocation -= reloc_entry->address;
403 x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
404 x |= ((((relocation >> 2) & 0xc000) << 6)
405 | ((relocation >> 2) & 0x3fff));
406 bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);
408 if ((bfd_signed_vma) relocation < - 0x40000
409 || (bfd_signed_vma) relocation > 0x3ffff)
410 return bfd_reloc_overflow;
415 /* Handle the HIX22 reloc. */
417 static bfd_reloc_status_type
418 sparc_elf_hix22_reloc (abfd,
426 arelent *reloc_entry;
429 asection *input_section;
431 char **error_message ATTRIBUTE_UNUSED;
436 if (output_bfd != (bfd *) NULL
437 && (symbol->flags & BSF_SECTION_SYM) == 0)
439 reloc_entry->address += input_section->output_offset;
443 if (output_bfd != NULL)
444 return bfd_reloc_continue;
446 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
447 return bfd_reloc_outofrange;
449 relocation = (symbol->value
450 + symbol->section->output_section->vma
451 + symbol->section->output_offset);
452 relocation += reloc_entry->addend;
453 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
455 insn = (insn &~ (bfd_vma) 0x3fffff) | (((~relocation) >> 10) & 0x3fffff);
456 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
461 /* Handle the LOX10 reloc. */
463 static bfd_reloc_status_type
464 sparc_elf_lox10_reloc (abfd,
472 arelent *reloc_entry;
475 asection *input_section;
477 char **error_message ATTRIBUTE_UNUSED;
482 if (output_bfd != (bfd *) NULL
483 && (symbol->flags & BSF_SECTION_SYM) == 0)
485 reloc_entry->address += input_section->output_offset;
489 if (output_bfd != NULL)
490 return bfd_reloc_continue;
492 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
493 return bfd_reloc_outofrange;
495 relocation = (symbol->value
496 + symbol->section->output_section->vma
497 + symbol->section->output_offset);
498 relocation += reloc_entry->addend;
499 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
501 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
502 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
507 /* Support for core dump NOTE sections. */
510 elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
512 switch (note->descsz)
517 case 260: /* Solaris prpsinfo_t. */
518 elf_tdata (abfd)->core_program
519 = _bfd_elfcore_strndup (abfd, note->descdata + 84, 16);
520 elf_tdata (abfd)->core_command
521 = _bfd_elfcore_strndup (abfd, note->descdata + 100, 80);
524 case 336: /* Solaris psinfo_t. */
525 elf_tdata (abfd)->core_program
526 = _bfd_elfcore_strndup (abfd, note->descdata + 88, 16);
527 elf_tdata (abfd)->core_command
528 = _bfd_elfcore_strndup (abfd, note->descdata + 104, 80);
536 /* Functions for the SPARC ELF linker. */
538 /* The name of the dynamic interpreter. This is put in the .interp
541 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
543 /* The nop opcode we use. */
545 #define SPARC_NOP 0x01000000
547 /* The size in bytes of an entry in the procedure linkage table. */
549 #define PLT_ENTRY_SIZE 12
551 /* The first four entries in a procedure linkage table are reserved,
552 and the initial contents are unimportant (we zero them out).
553 Subsequent entries look like this. See the SVR4 ABI SPARC
554 supplement to see how this works. */
556 /* sethi %hi(.-.plt0),%g1. We fill in the address later. */
557 #define PLT_ENTRY_WORD0 0x03000000
558 /* b,a .plt0. We fill in the offset later. */
559 #define PLT_ENTRY_WORD1 0x30800000
561 #define PLT_ENTRY_WORD2 SPARC_NOP
563 /* The SPARC linker needs to keep track of the number of relocs that it
564 decides to copy as dynamic relocs in check_relocs for each symbol.
565 This is so that it can later discard them if they are found to be
566 unnecessary. We store the information in a field extending the
567 regular ELF linker hash table. */
569 struct elf32_sparc_dyn_relocs
571 struct elf32_sparc_dyn_relocs *next;
573 /* The input section of the reloc. */
576 /* Total number of relocs copied for the input section. */
579 /* Number of pc-relative relocs copied for the input section. */
580 bfd_size_type pc_count;
583 /* SPARC ELF linker hash entry. */
585 struct elf32_sparc_link_hash_entry
587 struct elf_link_hash_entry elf;
589 /* Track dynamic relocs copied for this symbol. */
590 struct elf32_sparc_dyn_relocs *dyn_relocs;
592 #define GOT_UNKNOWN 0
596 unsigned char tls_type;
599 #define elf32_sparc_hash_entry(ent) ((struct elf32_sparc_link_hash_entry *)(ent))
601 struct elf32_sparc_obj_tdata
603 struct elf_obj_tdata root;
605 /* tls_type for each local got entry. */
606 char *local_got_tls_type;
608 /* TRUE if TLS GD relocs has been seen for this object. */
609 bfd_boolean has_tlsgd;
612 #define elf32_sparc_tdata(abfd) \
613 ((struct elf32_sparc_obj_tdata *) (abfd)->tdata.any)
615 #define elf32_sparc_local_got_tls_type(abfd) \
616 (elf32_sparc_tdata (abfd)->local_got_tls_type)
619 elf32_sparc_mkobject (abfd)
622 bfd_size_type amt = sizeof (struct elf32_sparc_obj_tdata);
623 abfd->tdata.any = bfd_zalloc (abfd, amt);
624 if (abfd->tdata.any == NULL)
629 /* SPARC ELF linker hash table. */
631 struct elf32_sparc_link_hash_table
633 struct elf_link_hash_table elf;
635 /* Short-cuts to get to dynamic linker sections. */
644 bfd_signed_vma refcount;
648 /* Small local sym to section mapping cache. */
649 struct sym_sec_cache sym_sec;
652 /* Get the SPARC ELF linker hash table from a link_info structure. */
654 #define elf32_sparc_hash_table(p) \
655 ((struct elf32_sparc_link_hash_table *) ((p)->hash))
657 /* Create an entry in an i386 ELF linker hash table. */
659 static struct bfd_hash_entry *
660 link_hash_newfunc (entry, table, string)
661 struct bfd_hash_entry *entry;
662 struct bfd_hash_table *table;
665 /* Allocate the structure if it has not already been allocated by a
669 entry = bfd_hash_allocate (table,
670 sizeof (struct elf32_sparc_link_hash_entry));
675 /* Call the allocation method of the superclass. */
676 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
679 struct elf32_sparc_link_hash_entry *eh;
681 eh = (struct elf32_sparc_link_hash_entry *) entry;
682 eh->dyn_relocs = NULL;
683 eh->tls_type = GOT_UNKNOWN;
689 /* Create a SPARC ELF linker hash table. */
691 static struct bfd_link_hash_table *
692 elf32_sparc_link_hash_table_create (abfd)
695 struct elf32_sparc_link_hash_table *ret;
696 bfd_size_type amt = sizeof (struct elf32_sparc_link_hash_table);
698 ret = (struct elf32_sparc_link_hash_table *) bfd_zmalloc (amt);
702 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
708 return &ret->elf.root;
711 /* Create .got and .rela.got sections in DYNOBJ, and set up
712 shortcuts to them in our hash table. */
715 create_got_section (dynobj, info)
717 struct bfd_link_info *info;
719 struct elf32_sparc_link_hash_table *htab;
721 if (! _bfd_elf_create_got_section (dynobj, info))
724 htab = elf32_sparc_hash_table (info);
725 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
726 BFD_ASSERT (htab->sgot != NULL);
728 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
729 if (htab->srelgot == NULL
730 || ! bfd_set_section_flags (dynobj, htab->srelgot, SEC_ALLOC
736 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
741 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
742 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
746 elf32_sparc_create_dynamic_sections (dynobj, info)
748 struct bfd_link_info *info;
750 struct elf32_sparc_link_hash_table *htab;
752 htab = elf32_sparc_hash_table (info);
753 if (!htab->sgot && !create_got_section (dynobj, info))
756 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
759 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
760 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
761 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
763 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
765 if (!htab->splt || !htab->srelplt || !htab->sdynbss
766 || (!info->shared && !htab->srelbss))
772 /* Copy the extra info we tack onto an elf_link_hash_entry. */
775 elf32_sparc_copy_indirect_symbol (bed, dir, ind)
776 const struct elf_backend_data *bed;
777 struct elf_link_hash_entry *dir, *ind;
779 struct elf32_sparc_link_hash_entry *edir, *eind;
781 edir = (struct elf32_sparc_link_hash_entry *) dir;
782 eind = (struct elf32_sparc_link_hash_entry *) ind;
784 if (eind->dyn_relocs != NULL)
786 if (edir->dyn_relocs != NULL)
788 struct elf32_sparc_dyn_relocs **pp;
789 struct elf32_sparc_dyn_relocs *p;
791 if (ind->root.type == bfd_link_hash_indirect)
794 /* Add reloc counts against the weak sym to the strong sym
795 list. Merge any entries against the same section. */
796 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
798 struct elf32_sparc_dyn_relocs *q;
800 for (q = edir->dyn_relocs; q != NULL; q = q->next)
801 if (q->sec == p->sec)
803 q->pc_count += p->pc_count;
804 q->count += p->count;
811 *pp = edir->dyn_relocs;
814 edir->dyn_relocs = eind->dyn_relocs;
815 eind->dyn_relocs = NULL;
818 if (ind->root.type == bfd_link_hash_indirect
819 && dir->got.refcount <= 0)
821 edir->tls_type = eind->tls_type;
822 eind->tls_type = GOT_UNKNOWN;
824 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
828 elf32_sparc_tls_transition (info, abfd, r_type, is_local)
829 struct bfd_link_info *info;
834 if (r_type == R_SPARC_TLS_GD_HI22
835 && ! elf32_sparc_tdata (abfd)->has_tlsgd)
836 r_type = R_SPARC_REV32;
843 case R_SPARC_TLS_GD_HI22:
845 return R_SPARC_TLS_LE_HIX22;
846 return R_SPARC_TLS_IE_HI22;
847 case R_SPARC_TLS_GD_LO10:
849 return R_SPARC_TLS_LE_LOX10;
850 return R_SPARC_TLS_IE_LO10;
851 case R_SPARC_TLS_IE_HI22:
853 return R_SPARC_TLS_LE_HIX22;
855 case R_SPARC_TLS_IE_LO10:
857 return R_SPARC_TLS_LE_LOX10;
859 case R_SPARC_TLS_LDM_HI22:
860 return R_SPARC_TLS_LE_HIX22;
861 case R_SPARC_TLS_LDM_LO10:
862 return R_SPARC_TLS_LE_LOX10;
868 /* Look through the relocs for a section during the first phase, and
869 allocate space in the global offset table or procedure linkage
873 elf32_sparc_check_relocs (abfd, info, sec, relocs)
875 struct bfd_link_info *info;
877 const Elf_Internal_Rela *relocs;
879 struct elf32_sparc_link_hash_table *htab;
880 Elf_Internal_Shdr *symtab_hdr;
881 struct elf_link_hash_entry **sym_hashes;
882 bfd_vma *local_got_offsets;
883 const Elf_Internal_Rela *rel;
884 const Elf_Internal_Rela *rel_end;
886 bfd_boolean checked_tlsgd = FALSE;
888 if (info->relocatable)
891 htab = elf32_sparc_hash_table (info);
892 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
893 sym_hashes = elf_sym_hashes (abfd);
894 local_got_offsets = elf_local_got_offsets (abfd);
898 rel_end = relocs + sec->reloc_count;
899 for (rel = relocs; rel < rel_end; rel++)
902 unsigned long r_symndx;
903 struct elf_link_hash_entry *h;
905 r_symndx = ELF32_R_SYM (rel->r_info);
906 r_type = ELF32_R_TYPE (rel->r_info);
908 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
910 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
915 if (r_symndx < symtab_hdr->sh_info)
918 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
920 /* Compatibility with old R_SPARC_REV32 reloc conflicting
921 with R_SPARC_TLS_GD_HI22. */
925 case R_SPARC_TLS_GD_HI22:
927 const Elf_Internal_Rela *relt;
929 for (relt = rel + 1; relt < rel_end; relt++)
930 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
931 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
932 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
934 checked_tlsgd = TRUE;
935 elf32_sparc_tdata (abfd)->has_tlsgd = relt < rel_end;
938 case R_SPARC_TLS_GD_LO10:
939 case R_SPARC_TLS_GD_ADD:
940 case R_SPARC_TLS_GD_CALL:
941 checked_tlsgd = TRUE;
942 elf32_sparc_tdata (abfd)->has_tlsgd = TRUE;
946 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h == NULL);
949 case R_SPARC_TLS_LDM_HI22:
950 case R_SPARC_TLS_LDM_LO10:
951 htab->tls_ldm_got.refcount += 1;
954 case R_SPARC_TLS_LE_HIX22:
955 case R_SPARC_TLS_LE_LOX10:
960 case R_SPARC_TLS_IE_HI22:
961 case R_SPARC_TLS_IE_LO10:
963 info->flags |= DF_STATIC_TLS;
969 case R_SPARC_TLS_GD_HI22:
970 case R_SPARC_TLS_GD_LO10:
971 /* This symbol requires a global offset table entry. */
973 int tls_type, old_tls_type;
981 tls_type = GOT_NORMAL;
983 case R_SPARC_TLS_GD_HI22:
984 case R_SPARC_TLS_GD_LO10:
985 tls_type = GOT_TLS_GD;
987 case R_SPARC_TLS_IE_HI22:
988 case R_SPARC_TLS_IE_LO10:
989 tls_type = GOT_TLS_IE;
995 h->got.refcount += 1;
996 old_tls_type = elf32_sparc_hash_entry(h)->tls_type;
1000 bfd_signed_vma *local_got_refcounts;
1002 /* This is a global offset table entry for a local symbol. */
1003 local_got_refcounts = elf_local_got_refcounts (abfd);
1004 if (local_got_refcounts == NULL)
1008 size = symtab_hdr->sh_info;
1009 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1010 local_got_refcounts = ((bfd_signed_vma *)
1011 bfd_zalloc (abfd, size));
1012 if (local_got_refcounts == NULL)
1014 elf_local_got_refcounts (abfd) = local_got_refcounts;
1015 elf32_sparc_local_got_tls_type (abfd)
1016 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1018 local_got_refcounts[r_symndx] += 1;
1019 old_tls_type = elf32_sparc_local_got_tls_type (abfd) [r_symndx];
1022 /* If a TLS symbol is accessed using IE at least once,
1023 there is no point to use dynamic model for it. */
1024 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1025 && (old_tls_type != GOT_TLS_GD
1026 || tls_type != GOT_TLS_IE))
1028 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1029 tls_type = old_tls_type;
1032 (*_bfd_error_handler)
1033 (_("%B: `%s' accessed both as normal and thread local symbol"),
1034 abfd, h ? h->root.root.string : "<local>");
1039 if (old_tls_type != tls_type)
1042 elf32_sparc_hash_entry (h)->tls_type = tls_type;
1044 elf32_sparc_local_got_tls_type (abfd) [r_symndx] = tls_type;
1048 if (htab->sgot == NULL)
1050 if (htab->elf.dynobj == NULL)
1051 htab->elf.dynobj = abfd;
1052 if (!create_got_section (htab->elf.dynobj, info))
1057 case R_SPARC_TLS_GD_CALL:
1058 case R_SPARC_TLS_LDM_CALL:
1061 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1063 struct bfd_link_hash_entry *bh = NULL;
1064 if (! _bfd_generic_link_add_one_symbol (info, abfd,
1065 "__tls_get_addr", 0,
1066 bfd_und_section_ptr, 0,
1070 h = (struct elf_link_hash_entry *) bh;
1077 case R_SPARC_WPLT30:
1078 /* This symbol requires a procedure linkage table entry. We
1079 actually build the entry in adjust_dynamic_symbol,
1080 because this might be a case of linking PIC code without
1081 linking in any dynamic objects, in which case we don't
1082 need to generate a procedure linkage table after all. */
1086 /* The Solaris native assembler will generate a WPLT30
1087 reloc for a local symbol if you assemble a call from
1088 one section to another when using -K pic. We treat
1090 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1097 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1099 h->plt.refcount += 1;
1108 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1113 case R_SPARC_DISP16:
1114 case R_SPARC_DISP32:
1115 case R_SPARC_WDISP30:
1116 case R_SPARC_WDISP22:
1117 case R_SPARC_WDISP19:
1118 case R_SPARC_WDISP16:
1132 if (h != NULL && !info->shared)
1134 /* We may need a .plt entry if the function this reloc
1135 refers to is in a shared lib. */
1136 h->plt.refcount += 1;
1139 /* If we are creating a shared library, and this is a reloc
1140 against a global symbol, or a non PC relative reloc
1141 against a local symbol, then we need to copy the reloc
1142 into the shared library. However, if we are linking with
1143 -Bsymbolic, we do not need to copy a reloc against a
1144 global symbol which is defined in an object we are
1145 including in the link (i.e., DEF_REGULAR is set). At
1146 this point we have not seen all the input files, so it is
1147 possible that DEF_REGULAR is not set now but will be set
1148 later (it is never cleared). In case of a weak definition,
1149 DEF_REGULAR may be cleared later by a strong definition in
1150 a shared library. We account for that possibility below by
1151 storing information in the relocs_copied field of the hash
1152 table entry. A similar situation occurs when creating
1153 shared libraries and symbol visibility changes render the
1156 If on the other hand, we are creating an executable, we
1157 may need to keep relocations for symbols satisfied by a
1158 dynamic library if we manage to avoid copy relocs for the
1161 && (sec->flags & SEC_ALLOC) != 0
1162 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1164 && (! info->symbolic
1165 || h->root.type == bfd_link_hash_defweak
1166 || !h->def_regular))))
1168 && (sec->flags & SEC_ALLOC) != 0
1170 && (h->root.type == bfd_link_hash_defweak
1171 || !h->def_regular)))
1173 struct elf32_sparc_dyn_relocs *p;
1174 struct elf32_sparc_dyn_relocs **head;
1176 /* When creating a shared object, we must copy these
1177 relocs into the output file. We create a reloc
1178 section in dynobj and make room for the reloc. */
1184 name = (bfd_elf_string_from_elf_section
1186 elf_elfheader (abfd)->e_shstrndx,
1187 elf_section_data (sec)->rel_hdr.sh_name));
1191 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1192 && strcmp (bfd_get_section_name (abfd, sec),
1195 if (htab->elf.dynobj == NULL)
1196 htab->elf.dynobj = abfd;
1197 dynobj = htab->elf.dynobj;
1199 sreloc = bfd_get_section_by_name (dynobj, name);
1204 sreloc = bfd_make_section (dynobj, name);
1205 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1206 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1207 if ((sec->flags & SEC_ALLOC) != 0)
1208 flags |= SEC_ALLOC | SEC_LOAD;
1210 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1211 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1214 elf_section_data (sec)->sreloc = sreloc;
1217 /* If this is a global symbol, we count the number of
1218 relocations we need for this symbol. */
1220 head = &((struct elf32_sparc_link_hash_entry *) h)->dyn_relocs;
1223 /* Track dynamic relocs needed for local syms too.
1224 We really need local syms available to do this
1228 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1233 head = ((struct elf32_sparc_dyn_relocs **)
1234 &elf_section_data (s)->local_dynrel);
1238 if (p == NULL || p->sec != sec)
1240 bfd_size_type amt = sizeof *p;
1241 p = ((struct elf32_sparc_dyn_relocs *)
1242 bfd_alloc (htab->elf.dynobj, amt));
1253 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1259 case R_SPARC_GNU_VTINHERIT:
1260 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1264 case R_SPARC_GNU_VTENTRY:
1265 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1278 elf32_sparc_gc_mark_hook (sec, info, rel, h, sym)
1280 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1281 Elf_Internal_Rela *rel;
1282 struct elf_link_hash_entry *h;
1283 Elf_Internal_Sym *sym;
1287 switch (ELF32_R_TYPE (rel->r_info))
1289 case R_SPARC_GNU_VTINHERIT:
1290 case R_SPARC_GNU_VTENTRY:
1294 switch (h->root.type)
1296 case bfd_link_hash_defined:
1297 case bfd_link_hash_defweak:
1298 return h->root.u.def.section;
1300 case bfd_link_hash_common:
1301 return h->root.u.c.p->section;
1309 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1314 /* Update the got entry reference counts for the section being removed. */
1316 elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
1318 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1320 const Elf_Internal_Rela *relocs;
1322 Elf_Internal_Shdr *symtab_hdr;
1323 struct elf_link_hash_entry **sym_hashes;
1324 bfd_signed_vma *local_got_refcounts;
1325 const Elf_Internal_Rela *rel, *relend;
1327 elf_section_data (sec)->local_dynrel = NULL;
1329 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1330 sym_hashes = elf_sym_hashes (abfd);
1331 local_got_refcounts = elf_local_got_refcounts (abfd);
1333 relend = relocs + sec->reloc_count;
1334 for (rel = relocs; rel < relend; rel++)
1336 unsigned long r_symndx;
1337 unsigned int r_type;
1338 struct elf_link_hash_entry *h = NULL;
1340 r_symndx = ELF32_R_SYM (rel->r_info);
1341 if (r_symndx >= symtab_hdr->sh_info)
1343 struct elf32_sparc_link_hash_entry *eh;
1344 struct elf32_sparc_dyn_relocs **pp;
1345 struct elf32_sparc_dyn_relocs *p;
1347 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1348 eh = (struct elf32_sparc_link_hash_entry *) h;
1349 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1352 /* Everything must go for SEC. */
1358 r_type = ELF32_R_TYPE (rel->r_info);
1359 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h != NULL);
1362 case R_SPARC_TLS_LDM_HI22:
1363 case R_SPARC_TLS_LDM_LO10:
1364 if (elf32_sparc_hash_table (info)->tls_ldm_got.refcount > 0)
1365 elf32_sparc_hash_table (info)->tls_ldm_got.refcount -= 1;
1368 case R_SPARC_TLS_GD_HI22:
1369 case R_SPARC_TLS_GD_LO10:
1370 case R_SPARC_TLS_IE_HI22:
1371 case R_SPARC_TLS_IE_LO10:
1377 if (h->got.refcount > 0)
1382 if (local_got_refcounts[r_symndx] > 0)
1383 local_got_refcounts[r_symndx]--;
1390 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1395 case R_SPARC_DISP16:
1396 case R_SPARC_DISP32:
1397 case R_SPARC_WDISP30:
1398 case R_SPARC_WDISP22:
1399 case R_SPARC_WDISP19:
1400 case R_SPARC_WDISP16:
1415 case R_SPARC_WPLT30:
1418 if (h->plt.refcount > 0)
1431 /* Adjust a symbol defined by a dynamic object and referenced by a
1432 regular object. The current definition is in some section of the
1433 dynamic object, but we're not including those sections. We have to
1434 change the definition to something the rest of the link can
1438 elf32_sparc_adjust_dynamic_symbol (info, h)
1439 struct bfd_link_info *info;
1440 struct elf_link_hash_entry *h;
1442 struct elf32_sparc_link_hash_table *htab;
1443 struct elf32_sparc_link_hash_entry * eh;
1444 struct elf32_sparc_dyn_relocs *p;
1446 unsigned int power_of_two;
1448 htab = elf32_sparc_hash_table (info);
1450 /* Make sure we know what is going on here. */
1451 BFD_ASSERT (htab->elf.dynobj != NULL
1453 || h->u.weakdef != NULL
1456 && !h->def_regular)));
1458 /* If this is a function, put it in the procedure linkage table. We
1459 will fill in the contents of the procedure linkage table later
1460 (although we could actually do it here). The STT_NOTYPE
1461 condition is a hack specifically for the Oracle libraries
1462 delivered for Solaris; for some inexplicable reason, they define
1463 some of their functions as STT_NOTYPE when they really should be
1465 if (h->type == STT_FUNC
1467 || (h->type == STT_NOTYPE
1468 && (h->root.type == bfd_link_hash_defined
1469 || h->root.type == bfd_link_hash_defweak)
1470 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1472 if (h->plt.refcount <= 0
1476 && h->root.type != bfd_link_hash_undefweak
1477 && h->root.type != bfd_link_hash_undefined))
1479 /* This case can occur if we saw a WPLT30 reloc in an input
1480 file, but the symbol was never referred to by a dynamic
1481 object, or if all references were garbage collected. In
1482 such a case, we don't actually need to build a procedure
1483 linkage table, and we can just do a WDISP30 reloc instead. */
1484 h->plt.offset = (bfd_vma) -1;
1491 h->plt.offset = (bfd_vma) -1;
1493 /* If this is a weak symbol, and there is a real definition, the
1494 processor independent code will have arranged for us to see the
1495 real definition first, and we can just use the same value. */
1496 if (h->u.weakdef != NULL)
1498 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1499 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1500 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1501 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1505 /* This is a reference to a symbol defined by a dynamic object which
1506 is not a function. */
1508 /* If we are creating a shared library, we must presume that the
1509 only references to the symbol are via the global offset table.
1510 For such cases we need not do anything here; the relocations will
1511 be handled correctly by relocate_section. */
1515 /* If there are no references to this symbol that do not use the
1516 GOT, we don't need to generate a copy reloc. */
1517 if (!h->non_got_ref)
1520 eh = (struct elf32_sparc_link_hash_entry *) h;
1521 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1523 s = p->sec->output_section;
1524 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1528 /* If we didn't find any dynamic relocs in read-only sections, then
1529 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1536 /* We must allocate the symbol in our .dynbss section, which will
1537 become part of the .bss section of the executable. There will be
1538 an entry for this symbol in the .dynsym section. The dynamic
1539 object will contain position independent code, so all references
1540 from the dynamic object to this symbol will go through the global
1541 offset table. The dynamic linker will use the .dynsym entry to
1542 determine the address it must put in the global offset table, so
1543 both the dynamic object and the regular object will refer to the
1544 same memory location for the variable. */
1546 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1547 to copy the initial value out of the dynamic object and into the
1548 runtime process image. We need to remember the offset into the
1549 .rel.bss section we are going to use. */
1550 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1552 htab->srelbss->size += sizeof (Elf32_External_Rela);
1556 /* We need to figure out the alignment required for this symbol. I
1557 have no idea how ELF linkers handle this. */
1558 power_of_two = bfd_log2 (h->size);
1559 if (power_of_two > 3)
1562 /* Apply the required alignment. */
1564 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1565 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1567 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1571 /* Define the symbol as being at this point in the section. */
1572 h->root.u.def.section = s;
1573 h->root.u.def.value = s->size;
1575 /* Increment the section size to make room for the symbol. */
1581 /* Allocate space in .plt, .got and associated reloc sections for
1585 allocate_dynrelocs (h, inf)
1586 struct elf_link_hash_entry *h;
1589 struct bfd_link_info *info;
1590 struct elf32_sparc_link_hash_table *htab;
1591 struct elf32_sparc_link_hash_entry *eh;
1592 struct elf32_sparc_dyn_relocs *p;
1594 if (h->root.type == bfd_link_hash_indirect)
1597 if (h->root.type == bfd_link_hash_warning)
1598 /* When warning symbols are created, they **replace** the "real"
1599 entry in the hash table, thus we never get to see the real
1600 symbol in a hash traversal. So look at it now. */
1601 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1603 info = (struct bfd_link_info *) inf;
1604 htab = elf32_sparc_hash_table (info);
1606 if (htab->elf.dynamic_sections_created
1607 && h->plt.refcount > 0)
1609 /* Make sure this symbol is output as a dynamic symbol.
1610 Undefined weak syms won't yet be marked as dynamic. */
1611 if (h->dynindx == -1
1612 && !h->forced_local)
1614 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1618 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1620 asection *s = htab->splt;
1622 /* The first four entries in .plt are reserved. */
1624 s->size = 4 * PLT_ENTRY_SIZE;
1626 /* The procedure linkage table has a maximum size. */
1627 if (s->size >= 0x400000)
1629 bfd_set_error (bfd_error_bad_value);
1633 h->plt.offset = s->size;
1635 /* If this symbol is not defined in a regular file, and we are
1636 not generating a shared library, then set the symbol to this
1637 location in the .plt. This is required to make function
1638 pointers compare as equal between the normal executable and
1639 the shared library. */
1643 h->root.u.def.section = s;
1644 h->root.u.def.value = h->plt.offset;
1647 /* Make room for this entry. */
1648 s->size += PLT_ENTRY_SIZE;
1650 /* We also need to make an entry in the .rela.plt section. */
1651 htab->srelplt->size += sizeof (Elf32_External_Rela);
1655 h->plt.offset = (bfd_vma) -1;
1661 h->plt.offset = (bfd_vma) -1;
1665 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1666 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1667 if (h->got.refcount > 0
1670 && elf32_sparc_hash_entry(h)->tls_type == GOT_TLS_IE)
1671 h->got.offset = (bfd_vma) -1;
1672 else if (h->got.refcount > 0)
1676 int tls_type = elf32_sparc_hash_entry(h)->tls_type;
1678 /* Make sure this symbol is output as a dynamic symbol.
1679 Undefined weak syms won't yet be marked as dynamic. */
1680 if (h->dynindx == -1
1681 && !h->forced_local)
1683 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1688 h->got.offset = s->size;
1690 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1691 if (tls_type == GOT_TLS_GD)
1693 dyn = htab->elf.dynamic_sections_created;
1694 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1695 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1697 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1698 || tls_type == GOT_TLS_IE)
1699 htab->srelgot->size += sizeof (Elf32_External_Rela);
1700 else if (tls_type == GOT_TLS_GD)
1701 htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
1702 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
1703 htab->srelgot->size += sizeof (Elf32_External_Rela);
1706 h->got.offset = (bfd_vma) -1;
1708 eh = (struct elf32_sparc_link_hash_entry *) h;
1709 if (eh->dyn_relocs == NULL)
1712 /* In the shared -Bsymbolic case, discard space allocated for
1713 dynamic pc-relative relocs against symbols which turn out to be
1714 defined in regular objects. For the normal shared case, discard
1715 space for pc-relative relocs that have become local due to symbol
1716 visibility changes. */
1724 struct elf32_sparc_dyn_relocs **pp;
1726 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1728 p->count -= p->pc_count;
1739 /* For the non-shared case, discard space for relocs against
1740 symbols which turn out to need copy relocs or are not
1746 || (htab->elf.dynamic_sections_created
1747 && (h->root.type == bfd_link_hash_undefweak
1748 || h->root.type == bfd_link_hash_undefined))))
1750 /* Make sure this symbol is output as a dynamic symbol.
1751 Undefined weak syms won't yet be marked as dynamic. */
1752 if (h->dynindx == -1
1753 && !h->forced_local)
1755 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1759 /* If that succeeded, we know we'll be keeping all the
1761 if (h->dynindx != -1)
1765 eh->dyn_relocs = NULL;
1770 /* Finally, allocate space. */
1771 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1773 asection *sreloc = elf_section_data (p->sec)->sreloc;
1774 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1780 /* Find any dynamic relocs that apply to read-only sections. */
1783 readonly_dynrelocs (h, inf)
1784 struct elf_link_hash_entry *h;
1787 struct elf32_sparc_link_hash_entry *eh;
1788 struct elf32_sparc_dyn_relocs *p;
1790 if (h->root.type == bfd_link_hash_warning)
1791 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1793 eh = (struct elf32_sparc_link_hash_entry *) h;
1794 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1796 asection *s = p->sec->output_section;
1798 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1800 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1802 info->flags |= DF_TEXTREL;
1804 /* Not an error, just cut short the traversal. */
1811 /* Return true if the dynamic symbol for a given section should be
1812 omitted when creating a shared library. */
1815 elf32_sparc_omit_section_dynsym (bfd *output_bfd,
1816 struct bfd_link_info *info,
1819 /* We keep the .got section symbol so that explicit relocations
1820 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
1821 can be turned into relocations against the .got symbol. */
1822 if (strcmp (p->name, ".got") == 0)
1825 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
1828 /* Set the sizes of the dynamic sections. */
1831 elf32_sparc_size_dynamic_sections (output_bfd, info)
1832 bfd *output_bfd ATTRIBUTE_UNUSED;
1833 struct bfd_link_info *info;
1835 struct elf32_sparc_link_hash_table *htab;
1840 htab = elf32_sparc_hash_table (info);
1841 dynobj = htab->elf.dynobj;
1842 BFD_ASSERT (dynobj != NULL);
1844 if (elf_hash_table (info)->dynamic_sections_created)
1846 /* Set the contents of the .interp section to the interpreter. */
1847 if (info->executable)
1849 s = bfd_get_section_by_name (dynobj, ".interp");
1850 BFD_ASSERT (s != NULL);
1851 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1852 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1856 /* Set up .got offsets for local syms, and space for local dynamic
1858 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1860 bfd_signed_vma *local_got;
1861 bfd_signed_vma *end_local_got;
1862 char *local_tls_type;
1863 bfd_size_type locsymcount;
1864 Elf_Internal_Shdr *symtab_hdr;
1867 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1870 for (s = ibfd->sections; s != NULL; s = s->next)
1872 struct elf32_sparc_dyn_relocs *p;
1874 for (p = *((struct elf32_sparc_dyn_relocs **)
1875 &elf_section_data (s)->local_dynrel);
1879 if (!bfd_is_abs_section (p->sec)
1880 && bfd_is_abs_section (p->sec->output_section))
1882 /* Input section has been discarded, either because
1883 it is a copy of a linkonce section or due to
1884 linker script /DISCARD/, so we'll be discarding
1887 else if (p->count != 0)
1889 srel = elf_section_data (p->sec)->sreloc;
1890 srel->size += p->count * sizeof (Elf32_External_Rela);
1891 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1892 info->flags |= DF_TEXTREL;
1897 local_got = elf_local_got_refcounts (ibfd);
1901 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1902 locsymcount = symtab_hdr->sh_info;
1903 end_local_got = local_got + locsymcount;
1904 local_tls_type = elf32_sparc_local_got_tls_type (ibfd);
1906 srel = htab->srelgot;
1907 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1911 *local_got = s->size;
1913 if (*local_tls_type == GOT_TLS_GD)
1916 || *local_tls_type == GOT_TLS_GD
1917 || *local_tls_type == GOT_TLS_IE)
1918 srel->size += sizeof (Elf32_External_Rela);
1921 *local_got = (bfd_vma) -1;
1925 if (htab->tls_ldm_got.refcount > 0)
1927 /* Allocate 2 got entries and 1 dynamic reloc for
1928 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
1929 htab->tls_ldm_got.offset = htab->sgot->size;
1930 htab->sgot->size += 8;
1931 htab->srelgot->size += sizeof (Elf32_External_Rela);
1934 htab->tls_ldm_got.offset = -1;
1936 /* Allocate global sym .plt and .got entries, and space for global
1937 sym dynamic relocs. */
1938 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1940 if (elf_hash_table (info)->dynamic_sections_created)
1942 /* Make space for the trailing nop in .plt. */
1943 if (htab->splt->size > 0)
1944 htab->splt->size += 4;
1946 /* If the .got section is more than 0x1000 bytes, we add
1947 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1948 bit relocations have a greater chance of working. */
1949 if (htab->sgot->size >= 0x1000
1950 && elf_hash_table (info)->hgot->root.u.def.value == 0)
1951 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
1954 /* The check_relocs and adjust_dynamic_symbol entry points have
1955 determined the sizes of the various dynamic sections. Allocate
1957 for (s = dynobj->sections; s != NULL; s = s->next)
1960 bfd_boolean strip = FALSE;
1962 if ((s->flags & SEC_LINKER_CREATED) == 0)
1965 /* It's OK to base decisions on the section name, because none
1966 of the dynobj section names depend upon the input files. */
1967 name = bfd_get_section_name (dynobj, s);
1969 if (strncmp (name, ".rela", 5) == 0)
1973 /* If we don't need this section, strip it from the
1974 output file. This is to handle .rela.bss and
1975 .rel.plt. We must create it in
1976 create_dynamic_sections, because it must be created
1977 before the linker maps input sections to output
1978 sections. The linker does that before
1979 adjust_dynamic_symbol is called, and it is that
1980 function which decides whether anything needs to go
1981 into these sections. */
1986 /* We use the reloc_count field as a counter if we need
1987 to copy relocs into the output file. */
1991 else if (s != htab->splt && s != htab->sgot)
1993 /* It's not one of our sections, so don't allocate space. */
1999 _bfd_strip_section_from_output (info, s);
2003 /* Allocate memory for the section contents. */
2004 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
2005 Unused entries should be reclaimed before the section's contents
2006 are written out, but at the moment this does not happen. Thus in
2007 order to prevent writing out garbage, we initialise the section's
2008 contents to zero. */
2009 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2010 if (s->contents == NULL && s->size != 0)
2014 if (elf_hash_table (info)->dynamic_sections_created)
2016 /* Add some entries to the .dynamic section. We fill in the
2017 values later, in elf32_sparc_finish_dynamic_sections, but we
2018 must add the entries now so that we get the correct size for
2019 the .dynamic section. The DT_DEBUG entry is filled in by the
2020 dynamic linker and used by the debugger. */
2021 #define add_dynamic_entry(TAG, VAL) \
2022 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2024 if (info->executable)
2026 if (!add_dynamic_entry (DT_DEBUG, 0))
2030 if (htab->srelplt->size != 0)
2032 if (!add_dynamic_entry (DT_PLTGOT, 0)
2033 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2034 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2035 || !add_dynamic_entry (DT_JMPREL, 0))
2039 if (!add_dynamic_entry (DT_RELA, 0)
2040 || !add_dynamic_entry (DT_RELASZ, 0)
2041 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2044 /* If any dynamic relocs apply to a read-only section,
2045 then we need a DT_TEXTREL entry. */
2046 if ((info->flags & DF_TEXTREL) == 0)
2047 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2050 if (info->flags & DF_TEXTREL)
2052 if (!add_dynamic_entry (DT_TEXTREL, 0))
2056 #undef add_dynamic_entry
2061 struct elf32_sparc_section_data
2063 struct bfd_elf_section_data elf;
2064 unsigned int do_relax;
2067 #define sec_do_relax(sec) \
2068 ((struct elf32_sparc_section_data *) elf_section_data (sec))->do_relax
2071 elf32_sparc_new_section_hook (abfd, sec)
2075 struct elf32_sparc_section_data *sdata;
2076 bfd_size_type amt = sizeof (*sdata);
2078 sdata = (struct elf32_sparc_section_data *) bfd_zalloc (abfd, amt);
2081 sec->used_by_bfd = (PTR) sdata;
2083 return _bfd_elf_new_section_hook (abfd, sec);
2087 elf32_sparc_relax_section (abfd, section, link_info, again)
2088 bfd *abfd ATTRIBUTE_UNUSED;
2089 asection *section ATTRIBUTE_UNUSED;
2090 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
2094 sec_do_relax (section) = 1;
2098 /* Return the base VMA address which should be subtracted from real addresses
2099 when resolving @dtpoff relocation.
2100 This is PT_TLS segment p_vaddr. */
2104 struct bfd_link_info *info;
2106 /* If tls_sec is NULL, we should have signalled an error already. */
2107 if (elf_hash_table (info)->tls_sec == NULL)
2109 return elf_hash_table (info)->tls_sec->vma;
2112 /* Return the relocation value for @tpoff relocation
2113 if STT_TLS virtual address is ADDRESS. */
2116 tpoff (info, address)
2117 struct bfd_link_info *info;
2120 struct elf_link_hash_table *htab = elf_hash_table (info);
2122 /* If tls_sec is NULL, we should have signalled an error already. */
2123 if (htab->tls_sec == NULL)
2125 return address - htab->tls_size - htab->tls_sec->vma;
2128 /* Relocate a SPARC ELF section. */
2131 elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
2132 contents, relocs, local_syms, local_sections)
2134 struct bfd_link_info *info;
2136 asection *input_section;
2138 Elf_Internal_Rela *relocs;
2139 Elf_Internal_Sym *local_syms;
2140 asection **local_sections;
2142 struct elf32_sparc_link_hash_table *htab;
2143 Elf_Internal_Shdr *symtab_hdr;
2144 struct elf_link_hash_entry **sym_hashes;
2145 bfd_vma *local_got_offsets;
2148 Elf_Internal_Rela *rel;
2149 Elf_Internal_Rela *relend;
2151 if (info->relocatable)
2154 htab = elf32_sparc_hash_table (info);
2155 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2156 sym_hashes = elf_sym_hashes (input_bfd);
2157 local_got_offsets = elf_local_got_offsets (input_bfd);
2159 if (elf_hash_table (info)->hgot == NULL)
2162 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2164 sreloc = elf_section_data (input_section)->sreloc;
2167 relend = relocs + input_section->reloc_count;
2168 for (; rel < relend; rel++)
2170 int r_type, tls_type;
2171 reloc_howto_type *howto;
2172 unsigned long r_symndx;
2173 struct elf_link_hash_entry *h;
2174 Elf_Internal_Sym *sym;
2176 bfd_vma relocation, off;
2177 bfd_reloc_status_type r;
2178 bfd_boolean is_plt = FALSE;
2179 bfd_boolean unresolved_reloc;
2181 r_type = ELF32_R_TYPE (rel->r_info);
2183 if (r_type == R_SPARC_GNU_VTINHERIT
2184 || r_type == R_SPARC_GNU_VTENTRY)
2187 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2189 bfd_set_error (bfd_error_bad_value);
2192 howto = _bfd_sparc_elf_howto_table + r_type;
2194 /* This is a final link. */
2195 r_symndx = ELF32_R_SYM (rel->r_info);
2199 unresolved_reloc = FALSE;
2200 if (r_symndx < symtab_hdr->sh_info)
2202 sym = local_syms + r_symndx;
2203 sec = local_sections[r_symndx];
2204 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2208 bfd_boolean warned ATTRIBUTE_UNUSED;
2210 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2211 r_symndx, symtab_hdr, sym_hashes,
2213 unresolved_reloc, warned);
2221 /* Relocation is to the entry for this symbol in the global
2223 if (htab->sgot == NULL)
2230 off = h->got.offset;
2231 BFD_ASSERT (off != (bfd_vma) -1);
2232 dyn = elf_hash_table (info)->dynamic_sections_created;
2234 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2241 /* This is actually a static link, or it is a
2242 -Bsymbolic link and the symbol is defined
2243 locally, or the symbol was forced to be local
2244 because of a version file. We must initialize
2245 this entry in the global offset table. Since the
2246 offset must always be a multiple of 4, we use the
2247 least significant bit to record whether we have
2248 initialized it already.
2250 When doing a dynamic link, we create a .rela.got
2251 relocation entry to initialize the value. This
2252 is done in the finish_dynamic_symbol routine. */
2257 bfd_put_32 (output_bfd, relocation,
2258 htab->sgot->contents + off);
2263 unresolved_reloc = FALSE;
2267 BFD_ASSERT (local_got_offsets != NULL
2268 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2270 off = local_got_offsets[r_symndx];
2272 /* The offset must always be a multiple of 4. We use
2273 the least significant bit to record whether we have
2274 already processed this entry. */
2283 Elf_Internal_Rela outrel;
2286 /* We need to generate a R_SPARC_RELATIVE reloc
2287 for the dynamic linker. */
2289 BFD_ASSERT (s != NULL);
2291 outrel.r_offset = (htab->sgot->output_section->vma
2292 + htab->sgot->output_offset
2294 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2295 outrel.r_addend = relocation;
2298 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
2299 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2302 bfd_put_32 (output_bfd, relocation,
2303 htab->sgot->contents + off);
2304 local_got_offsets[r_symndx] |= 1;
2307 relocation = htab->sgot->output_offset + off - got_base;
2311 if (h == NULL || h->plt.offset == (bfd_vma) -1)
2313 r_type = R_SPARC_32;
2317 case R_SPARC_WPLT30:
2319 /* Relocation is to the entry for this symbol in the
2320 procedure linkage table. */
2322 /* The Solaris native assembler will generate a WPLT30 reloc
2323 for a local symbol if you assemble a call from one
2324 section to another when using -K pic. We treat it as
2329 if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2331 /* We didn't make a PLT entry for this symbol. This
2332 happens when statically linking PIC code, or when
2333 using -Bsymbolic. */
2337 relocation = (htab->splt->output_section->vma
2338 + htab->splt->output_offset
2340 unresolved_reloc = FALSE;
2341 if (r_type == R_SPARC_PLT32)
2343 r_type = R_SPARC_32;
2352 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2356 case R_SPARC_DISP16:
2357 case R_SPARC_DISP32:
2358 case R_SPARC_WDISP30:
2359 case R_SPARC_WDISP22:
2360 case R_SPARC_WDISP19:
2361 case R_SPARC_WDISP16:
2372 /* r_symndx will be zero only for relocs against symbols
2373 from removed linkonce sections, or sections discarded by
2376 || (input_section->flags & SEC_ALLOC) == 0)
2381 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2382 || h->root.type != bfd_link_hash_undefweak)
2383 && (! howto->pc_relative
2386 && (! info->symbolic
2387 || !h->def_regular))))
2394 || h->root.type == bfd_link_hash_undefweak
2395 || h->root.type == bfd_link_hash_undefined)))
2397 Elf_Internal_Rela outrel;
2399 bfd_boolean skip, relocate = FALSE;
2401 /* When generating a shared object, these relocations
2402 are copied into the output file to be resolved at run
2405 BFD_ASSERT (sreloc != NULL);
2410 _bfd_elf_section_offset (output_bfd, info, input_section,
2412 if (outrel.r_offset == (bfd_vma) -1)
2414 else if (outrel.r_offset == (bfd_vma) -2)
2415 skip = TRUE, relocate = TRUE;
2416 outrel.r_offset += (input_section->output_section->vma
2417 + input_section->output_offset);
2419 /* Optimize unaligned reloc usage now that we know where
2420 it finally resides. */
2424 if (outrel.r_offset & 1)
2425 r_type = R_SPARC_UA16;
2428 if (!(outrel.r_offset & 1))
2429 r_type = R_SPARC_16;
2432 if (outrel.r_offset & 3)
2433 r_type = R_SPARC_UA32;
2436 if (!(outrel.r_offset & 3))
2437 r_type = R_SPARC_32;
2440 case R_SPARC_DISP16:
2441 case R_SPARC_DISP32:
2442 /* If the symbol is not dynamic, we should not keep
2443 a dynamic relocation. But an .rela.* slot has been
2444 allocated for it, output R_SPARC_NONE.
2445 FIXME: Add code tracking needed dynamic relocs as
2447 if (h->dynindx == -1)
2448 skip = TRUE, relocate = TRUE;
2453 memset (&outrel, 0, sizeof outrel);
2454 /* h->dynindx may be -1 if the symbol was marked to
2456 else if (h != NULL && ! is_plt
2457 && ((! info->symbolic && h->dynindx != -1)
2458 || !h->def_regular))
2460 BFD_ASSERT (h->dynindx != -1);
2461 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2462 outrel.r_addend = rel->r_addend;
2466 if (r_type == R_SPARC_32)
2468 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2469 outrel.r_addend = relocation + rel->r_addend;
2478 if (bfd_is_abs_section (sec))
2480 else if (sec == NULL || sec->owner == NULL)
2482 bfd_set_error (bfd_error_bad_value);
2489 osec = sec->output_section;
2490 indx = elf_section_data (osec)->dynindx;
2492 /* FIXME: we really should be able to link non-pic
2493 shared libraries. */
2497 (*_bfd_error_handler)
2498 (_("%B: probably compiled without -fPIC?"),
2500 bfd_set_error (bfd_error_bad_value);
2505 outrel.r_info = ELF32_R_INFO (indx, r_type);
2506 outrel.r_addend = relocation + rel->r_addend;
2510 loc = sreloc->contents;
2511 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2512 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2514 /* This reloc will be computed at runtime, so there's no
2515 need to do anything now. */
2521 case R_SPARC_TLS_GD_HI22:
2522 if (! elf32_sparc_tdata (input_bfd)->has_tlsgd)
2524 /* R_SPARC_REV32 used the same reloc number as
2525 R_SPARC_TLS_GD_HI22. */
2526 r_type = R_SPARC_REV32;
2531 case R_SPARC_TLS_GD_LO10:
2532 case R_SPARC_TLS_IE_HI22:
2533 case R_SPARC_TLS_IE_LO10:
2534 r_type = elf32_sparc_tls_transition (info, input_bfd, r_type,
2536 tls_type = GOT_UNKNOWN;
2537 if (h == NULL && local_got_offsets)
2538 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2541 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2542 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2543 switch (ELF32_R_TYPE (rel->r_info))
2545 case R_SPARC_TLS_GD_HI22:
2546 case R_SPARC_TLS_IE_HI22:
2547 r_type = R_SPARC_TLS_LE_HIX22;
2550 r_type = R_SPARC_TLS_LE_LOX10;
2554 if (tls_type == GOT_TLS_IE)
2557 case R_SPARC_TLS_GD_HI22:
2558 r_type = R_SPARC_TLS_IE_HI22;
2560 case R_SPARC_TLS_GD_LO10:
2561 r_type = R_SPARC_TLS_IE_LO10;
2565 if (r_type == R_SPARC_TLS_LE_HIX22)
2567 relocation = tpoff (info, relocation);
2570 if (r_type == R_SPARC_TLS_LE_LOX10)
2572 /* Change add into xor. */
2573 relocation = tpoff (info, relocation);
2574 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2575 contents + rel->r_offset)
2576 | 0x80182000), contents + rel->r_offset);
2582 off = h->got.offset;
2587 BFD_ASSERT (local_got_offsets != NULL);
2588 off = local_got_offsets[r_symndx];
2589 local_got_offsets[r_symndx] |= 1;
2593 if (htab->sgot == NULL)
2600 Elf_Internal_Rela outrel;
2601 Elf32_External_Rela *loc;
2604 if (htab->srelgot == NULL)
2607 bfd_put_32 (output_bfd, 0, htab->sgot->contents + off);
2608 outrel.r_offset = (htab->sgot->output_section->vma
2609 + htab->sgot->output_offset + off);
2610 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2611 if (r_type == R_SPARC_TLS_IE_HI22
2612 || r_type == R_SPARC_TLS_IE_LO10)
2613 dr_type = R_SPARC_TLS_TPOFF32;
2615 dr_type = R_SPARC_TLS_DTPMOD32;
2616 if (dr_type == R_SPARC_TLS_TPOFF32 && indx == 0)
2617 outrel.r_addend = relocation - dtpoff_base (info);
2619 outrel.r_addend = 0;
2620 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2621 loc = (Elf32_External_Rela *) htab->srelgot->contents;
2622 loc += htab->srelgot->reloc_count++;
2623 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2626 if (r_type == R_SPARC_TLS_GD_HI22
2627 || r_type == R_SPARC_TLS_GD_LO10)
2631 BFD_ASSERT (! unresolved_reloc);
2632 bfd_put_32 (output_bfd,
2633 relocation - dtpoff_base (info),
2634 htab->sgot->contents + off + 4);
2638 bfd_put_32 (output_bfd, 0,
2639 htab->sgot->contents + off + 4);
2640 outrel.r_info = ELF32_R_INFO (indx,
2641 R_SPARC_TLS_DTPOFF32);
2642 outrel.r_offset += 4;
2643 htab->srelgot->reloc_count++;
2645 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2649 else if (dr_type == R_SPARC_TLS_DTPMOD32)
2651 bfd_put_32 (output_bfd, 0,
2652 htab->sgot->contents + off + 4);
2656 if (off >= (bfd_vma) -2)
2659 relocation = htab->sgot->output_offset + off - got_base;
2660 unresolved_reloc = FALSE;
2661 howto = _bfd_sparc_elf_howto_table + r_type;
2664 case R_SPARC_TLS_LDM_HI22:
2665 case R_SPARC_TLS_LDM_LO10:
2668 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2671 off = htab->tls_ldm_got.offset;
2672 htab->tls_ldm_got.offset |= 1;
2673 goto r_sparc_tlsldm;
2675 case R_SPARC_TLS_LDO_HIX22:
2676 case R_SPARC_TLS_LDO_LOX10:
2678 relocation -= dtpoff_base (info);
2680 relocation = tpoff (info, relocation);
2683 case R_SPARC_TLS_LE_HIX22:
2684 case R_SPARC_TLS_LE_LOX10:
2687 Elf_Internal_Rela outrel;
2688 bfd_boolean skip, relocate = FALSE;
2690 BFD_ASSERT (sreloc != NULL);
2693 _bfd_elf_section_offset (output_bfd, info, input_section,
2695 if (outrel.r_offset == (bfd_vma) -1)
2697 else if (outrel.r_offset == (bfd_vma) -2)
2698 skip = TRUE, relocate = TRUE;
2699 outrel.r_offset += (input_section->output_section->vma
2700 + input_section->output_offset);
2702 memset (&outrel, 0, sizeof outrel);
2705 outrel.r_info = ELF32_R_INFO (0, r_type);
2706 outrel.r_addend = relocation - dtpoff_base (info)
2710 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2711 (bfd_byte *) (((Elf32_External_Rela *)
2713 + sreloc->reloc_count));
2714 ++sreloc->reloc_count;
2717 relocation = tpoff (info, relocation);
2720 case R_SPARC_TLS_LDM_CALL:
2724 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
2729 case R_SPARC_TLS_GD_CALL:
2730 tls_type = GOT_UNKNOWN;
2731 if (h == NULL && local_got_offsets)
2732 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2734 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2736 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
2740 if (!info->shared && (h == NULL || h->dynindx == -1))
2743 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2748 if (rel + 1 < relend
2749 && ELF32_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
2750 && rel[1].r_offset == rel->r_offset + 4
2751 && ELF32_R_SYM (rel[1].r_info) == r_symndx
2752 && (((insn = bfd_get_32 (input_bfd,
2753 contents + rel[1].r_offset))
2754 >> 25) & 0x1f) == 8)
2757 call __tls_get_addr, %tgd_call(foo)
2758 add %reg1, %reg2, %o0, %tgd_add(foo)
2759 and change it into IE:
2760 ld [%reg1 + %reg2], %o0, %tie_ld(foo)
2761 add %g7, %o0, %o0, %tie_add(foo).
2762 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
2763 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2. */
2764 bfd_put_32 (output_bfd, insn | 0xc0000000,
2765 contents + rel->r_offset);
2766 bfd_put_32 (output_bfd, 0x9001c008,
2767 contents + rel->r_offset + 4);
2772 bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
2776 h = (struct elf_link_hash_entry *)
2777 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
2779 BFD_ASSERT (h != NULL);
2780 r_type = R_SPARC_WPLT30;
2781 howto = _bfd_sparc_elf_howto_table + r_type;
2782 goto r_sparc_wplt30;
2784 case R_SPARC_TLS_GD_ADD:
2785 tls_type = GOT_UNKNOWN;
2786 if (h == NULL && local_got_offsets)
2787 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2789 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2790 if (! info->shared || tls_type == GOT_TLS_IE)
2792 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
2794 ld [%reg1 + %reg2], %reg3, %tie_ld(foo)
2796 add %g7, %reg2, %reg3. */
2797 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2798 if ((h != NULL && h->dynindx != -1) || info->shared)
2799 relocation = insn | 0xc0000000;
2801 relocation = (insn & ~0x7c000) | 0x1c000;
2802 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2806 case R_SPARC_TLS_LDM_ADD:
2808 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2811 case R_SPARC_TLS_LDO_ADD:
2814 /* Change rs1 into %g7. */
2815 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2816 insn = (insn & ~0x7c000) | 0x1c000;
2817 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
2821 case R_SPARC_TLS_IE_LD:
2822 case R_SPARC_TLS_IE_LDX:
2823 if (! info->shared && (h == NULL || h->dynindx == -1))
2825 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2826 int rs2 = insn & 0x1f;
2827 int rd = (insn >> 25) & 0x1f;
2830 relocation = SPARC_NOP;
2832 relocation = 0x80100000 | (insn & 0x3e00001f);
2833 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2837 case R_SPARC_TLS_IE_ADD:
2838 /* Totally useless relocation. */
2841 case R_SPARC_TLS_DTPOFF32:
2842 relocation -= dtpoff_base (info);
2849 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2850 because such sections are not SEC_ALLOC and thus ld.so will
2851 not process them. */
2852 if (unresolved_reloc
2853 && !((input_section->flags & SEC_DEBUGGING) != 0
2855 (*_bfd_error_handler)
2856 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
2859 (long) rel->r_offset,
2860 h->root.root.string);
2862 r = bfd_reloc_continue;
2863 if (r_type == R_SPARC_WDISP16)
2867 relocation += rel->r_addend;
2868 relocation -= (input_section->output_section->vma
2869 + input_section->output_offset);
2870 relocation -= rel->r_offset;
2872 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2873 x |= ((((relocation >> 2) & 0xc000) << 6)
2874 | ((relocation >> 2) & 0x3fff));
2875 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2877 if ((bfd_signed_vma) relocation < - 0x40000
2878 || (bfd_signed_vma) relocation > 0x3ffff)
2879 r = bfd_reloc_overflow;
2883 else if (r_type == R_SPARC_REV32)
2887 relocation = relocation + rel->r_addend;
2889 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2891 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
2894 else if (r_type == R_SPARC_TLS_LDO_HIX22
2895 || r_type == R_SPARC_TLS_LE_HIX22)
2899 relocation += rel->r_addend;
2900 relocation = relocation ^ 0xffffffff;
2902 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2903 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2904 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2907 else if (r_type == R_SPARC_TLS_LDO_LOX10
2908 || r_type == R_SPARC_TLS_LE_LOX10)
2912 relocation += rel->r_addend;
2913 relocation = (relocation & 0x3ff) | 0x1c00;
2915 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2916 x = (x & ~(bfd_vma) 0x1fff) | relocation;
2917 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2921 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
2922 && sec_do_relax (input_section)
2923 && rel->r_offset + 4 < input_section->size)
2927 #define XCC (2 << 20)
2928 #define COND(x) (((x)&0xf)<<25)
2929 #define CONDA COND(0x8)
2930 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
2931 #define INSN_BA (F2(0,2) | CONDA)
2932 #define INSN_OR F3(2, 0x2, 0)
2933 #define INSN_NOP F2(0,4)
2937 /* If the instruction is a call with either:
2939 arithmetic instruction with rd == %o7
2940 where rs1 != %o7 and rs2 if it is register != %o7
2941 then we can optimize if the call destination is near
2942 by changing the call into a branch always. */
2943 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2944 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2945 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2947 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2948 || ((y & OP3(0x28)) == 0 /* arithmetic */
2949 && (y & RD(~0)) == RD(O7)))
2950 && (y & RS1(~0)) != RS1(O7)
2952 || (y & RS2(~0)) != RS2(O7)))
2956 reloc = relocation + rel->r_addend - rel->r_offset;
2957 reloc -= (input_section->output_section->vma
2958 + input_section->output_offset);
2960 /* Ensure the reloc fits into simm22. */
2961 if ((reloc & 3) == 0
2962 && ((reloc & ~(bfd_vma)0x7fffff) == 0
2963 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
2967 /* Check whether it fits into simm19 on v9. */
2968 if (((reloc & 0x3c0000) == 0
2969 || (reloc & 0x3c0000) == 0x3c0000)
2970 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
2971 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2973 x = INSN_BA | (reloc & 0x3fffff); /* ba */
2974 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2976 if (rel->r_offset >= 4
2977 && (y & (0xffffffff ^ RS1(~0)))
2978 == (INSN_OR | RD(O7) | RS2(G0)))
2983 z = bfd_get_32 (input_bfd,
2984 contents + rel->r_offset - 4);
2985 if ((z & (0xffffffff ^ RD(~0)))
2986 != (INSN_OR | RS1(O7) | RS2(G0)))
2994 If call foo was replaced with ba, replace
2995 or %rN, %g0, %o7 with nop. */
2997 reg = (y & RS1(~0)) >> 14;
2998 if (reg != ((z & RD(~0)) >> 25)
2999 || reg == G0 || reg == O7)
3002 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3003 contents + rel->r_offset + 4);
3011 if (r == bfd_reloc_continue)
3012 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3013 contents, rel->r_offset,
3014 relocation, rel->r_addend);
3016 if (r != bfd_reloc_ok)
3021 case bfd_reloc_outofrange:
3023 case bfd_reloc_overflow:
3031 name = bfd_elf_string_from_elf_section (input_bfd,
3032 symtab_hdr->sh_link,
3037 name = bfd_section_name (input_bfd, sec);
3039 if (! ((*info->callbacks->reloc_overflow)
3040 (info, (h ? &h->root : NULL), name, howto->name,
3041 (bfd_vma) 0, input_bfd, input_section,
3053 /* Finish up dynamic symbol handling. We set the contents of various
3054 dynamic sections here. */
3057 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
3059 struct bfd_link_info *info;
3060 struct elf_link_hash_entry *h;
3061 Elf_Internal_Sym *sym;
3064 struct elf32_sparc_link_hash_table *htab;
3066 htab = elf32_sparc_hash_table (info);
3067 dynobj = htab->elf.dynobj;
3069 if (h->plt.offset != (bfd_vma) -1)
3073 Elf_Internal_Rela rela;
3076 /* This symbol has an entry in the procedure linkage table. Set
3079 BFD_ASSERT (h->dynindx != -1);
3082 srela = htab->srelplt;
3083 BFD_ASSERT (splt != NULL && srela != NULL);
3085 /* Fill in the entry in the procedure linkage table. */
3086 bfd_put_32 (output_bfd,
3087 PLT_ENTRY_WORD0 + h->plt.offset,
3088 splt->contents + h->plt.offset);
3089 bfd_put_32 (output_bfd,
3091 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
3092 splt->contents + h->plt.offset + 4);
3093 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
3094 splt->contents + h->plt.offset + 8);
3096 /* Fill in the entry in the .rela.plt section. */
3097 rela.r_offset = (splt->output_section->vma
3098 + splt->output_offset
3100 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
3102 loc = srela->contents;
3103 loc += (h->plt.offset / PLT_ENTRY_SIZE - 4) * sizeof (Elf32_External_Rela);
3104 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3106 if (!h->def_regular)
3108 /* Mark the symbol as undefined, rather than as defined in
3109 the .plt section. Leave the value alone. */
3110 sym->st_shndx = SHN_UNDEF;
3111 /* If the symbol is weak, we do need to clear the value.
3112 Otherwise, the PLT entry would provide a definition for
3113 the symbol even if the symbol wasn't defined anywhere,
3114 and so the symbol would never be NULL. */
3115 if (!h->ref_regular_nonweak)
3120 if (h->got.offset != (bfd_vma) -1
3121 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_GD
3122 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_IE)
3126 Elf_Internal_Rela rela;
3129 /* This symbol has an entry in the global offset table. Set it
3133 srela = htab->srelgot;
3134 BFD_ASSERT (sgot != NULL && srela != NULL);
3136 rela.r_offset = (sgot->output_section->vma
3137 + sgot->output_offset
3138 + (h->got.offset &~ (bfd_vma) 1));
3140 /* If this is a -Bsymbolic link, and the symbol is defined
3141 locally, we just want to emit a RELATIVE reloc. Likewise if
3142 the symbol was forced to be local because of a version file.
3143 The entry in the global offset table will already have been
3144 initialized in the relocate_section function. */
3146 && (info->symbolic || h->dynindx == -1)
3149 asection *sec = h->root.u.def.section;
3150 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
3151 rela.r_addend = (h->root.u.def.value
3152 + sec->output_section->vma
3153 + sec->output_offset);
3157 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
3161 bfd_put_32 (output_bfd, (bfd_vma) 0,
3162 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
3163 loc = srela->contents;
3164 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3165 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3171 Elf_Internal_Rela rela;
3174 /* This symbols needs a copy reloc. Set it up. */
3176 BFD_ASSERT (h->dynindx != -1);
3178 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3180 BFD_ASSERT (s != NULL);
3182 rela.r_offset = (h->root.u.def.value
3183 + h->root.u.def.section->output_section->vma
3184 + h->root.u.def.section->output_offset);
3185 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
3187 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3188 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3191 /* Mark some specially defined symbols as absolute. */
3192 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3193 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3194 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3195 sym->st_shndx = SHN_ABS;
3200 /* Finish up the dynamic sections. */
3203 elf32_sparc_finish_dynamic_sections (output_bfd, info)
3205 struct bfd_link_info *info;
3209 struct elf32_sparc_link_hash_table *htab;
3211 htab = elf32_sparc_hash_table (info);
3212 dynobj = htab->elf.dynobj;
3214 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3216 if (elf_hash_table (info)->dynamic_sections_created)
3219 Elf32_External_Dyn *dyncon, *dynconend;
3221 splt = bfd_get_section_by_name (dynobj, ".plt");
3222 BFD_ASSERT (splt != NULL && sdyn != NULL);
3224 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3225 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3226 for (; dyncon < dynconend; dyncon++)
3228 Elf_Internal_Dyn dyn;
3232 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3236 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
3237 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3238 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
3239 default: name = NULL; size = FALSE; break;
3246 s = bfd_get_section_by_name (output_bfd, name);
3252 dyn.d_un.d_ptr = s->vma;
3254 dyn.d_un.d_val = s->size;
3256 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3260 /* Clear the first four entries in the procedure linkage table,
3261 and put a nop in the last four bytes. */
3264 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
3265 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
3266 splt->contents + splt->size - 4);
3269 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
3272 /* Set the first entry in the global offset table to the address of
3273 the dynamic section. */
3274 if (htab->sgot && htab->sgot->size > 0)
3277 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgot->contents);
3279 bfd_put_32 (output_bfd,
3280 sdyn->output_section->vma + sdyn->output_offset,
3281 htab->sgot->contents);
3285 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
3290 /* Functions for dealing with the e_flags field.
3292 We don't define set_private_flags or copy_private_bfd_data because
3293 the only currently defined values are based on the bfd mach number,
3294 so we use the latter instead and defer setting e_flags until the
3295 file is written out. */
3297 /* Merge backend specific data from an object file to the output
3298 object file when linking. */
3301 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
3306 unsigned long ibfd_mach;
3307 /* FIXME: This should not be static. */
3308 static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
3310 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3311 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3316 ibfd_mach = bfd_get_mach (ibfd);
3317 if (bfd_mach_sparc_64bit_p (ibfd_mach))
3320 (*_bfd_error_handler)
3321 (_("%B: compiled for a 64 bit system and target is 32 bit"), ibfd);
3323 else if ((ibfd->flags & DYNAMIC) == 0)
3325 if (bfd_get_mach (obfd) < ibfd_mach)
3326 bfd_set_arch_mach (obfd, bfd_arch_sparc, ibfd_mach);
3329 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
3330 != previous_ibfd_e_flags)
3331 && previous_ibfd_e_flags != (unsigned long) -1)
3333 (*_bfd_error_handler)
3334 (_("%B: linking little endian files with big endian files"), ibfd);
3337 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
3341 bfd_set_error (bfd_error_bad_value);
3348 /* Set the right machine number. */
3351 elf32_sparc_object_p (abfd)
3354 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
3356 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3357 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3358 bfd_mach_sparc_v8plusb);
3359 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3360 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3361 bfd_mach_sparc_v8plusa);
3362 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
3363 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3364 bfd_mach_sparc_v8plus);
3368 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
3369 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3370 bfd_mach_sparc_sparclite_le);
3372 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
3375 /* The final processing done just before writing out the object file.
3376 We need to set the e_machine field appropriately. */
3379 elf32_sparc_final_write_processing (abfd, linker)
3381 bfd_boolean linker ATTRIBUTE_UNUSED;
3383 switch (bfd_get_mach (abfd))
3385 case bfd_mach_sparc :
3386 case bfd_mach_sparc_sparclet :
3387 case bfd_mach_sparc_sparclite :
3388 break; /* nothing to do */
3389 case bfd_mach_sparc_v8plus :
3390 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3391 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3392 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
3394 case bfd_mach_sparc_v8plusa :
3395 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3396 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3397 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
3399 case bfd_mach_sparc_v8plusb :
3400 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3401 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3402 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
3405 case bfd_mach_sparc_sparclite_le :
3406 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
3414 static enum elf_reloc_type_class
3415 elf32_sparc_reloc_type_class (rela)
3416 const Elf_Internal_Rela *rela;
3418 switch ((int) ELF32_R_TYPE (rela->r_info))
3420 case R_SPARC_RELATIVE:
3421 return reloc_class_relative;
3422 case R_SPARC_JMP_SLOT:
3423 return reloc_class_plt;
3425 return reloc_class_copy;
3427 return reloc_class_normal;
3431 /* Return address for Ith PLT stub in section PLT, for relocation REL
3432 or (bfd_vma) -1 if it should not be included. */
3435 elf32_sparc_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED,
3436 const asection *plt ATTRIBUTE_UNUSED,
3439 return rel->address;
3442 #define TARGET_BIG_SYM bfd_elf32_sparc_vec
3443 #define TARGET_BIG_NAME "elf32-sparc"
3444 #define ELF_ARCH bfd_arch_sparc
3445 #define ELF_MACHINE_CODE EM_SPARC
3446 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
3447 #define ELF_MAXPAGESIZE 0x10000
3449 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
3450 #define bfd_elf32_bfd_link_hash_table_create \
3451 elf32_sparc_link_hash_table_create
3452 #define bfd_elf32_bfd_relax_section elf32_sparc_relax_section
3453 #define bfd_elf32_new_section_hook elf32_sparc_new_section_hook
3454 #define elf_info_to_howto elf32_sparc_info_to_howto
3455 #define elf_backend_copy_indirect_symbol \
3456 elf32_sparc_copy_indirect_symbol
3457 #define elf_backend_create_dynamic_sections \
3458 elf32_sparc_create_dynamic_sections
3459 #define elf_backend_check_relocs elf32_sparc_check_relocs
3460 #define elf_backend_adjust_dynamic_symbol \
3461 elf32_sparc_adjust_dynamic_symbol
3462 #define elf_backend_omit_section_dynsym elf32_sparc_omit_section_dynsym
3463 #define elf_backend_size_dynamic_sections \
3464 elf32_sparc_size_dynamic_sections
3465 #define elf_backend_relocate_section elf32_sparc_relocate_section
3466 #define elf_backend_finish_dynamic_symbol \
3467 elf32_sparc_finish_dynamic_symbol
3468 #define elf_backend_finish_dynamic_sections \
3469 elf32_sparc_finish_dynamic_sections
3470 #define bfd_elf32_bfd_merge_private_bfd_data \
3471 elf32_sparc_merge_private_bfd_data
3472 #define bfd_elf32_mkobject elf32_sparc_mkobject
3473 #define elf_backend_object_p elf32_sparc_object_p
3474 #define elf_backend_final_write_processing \
3475 elf32_sparc_final_write_processing
3476 #define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook
3477 #define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook
3478 #define elf_backend_grok_psinfo elf32_sparc_grok_psinfo
3479 #define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
3480 #define elf_backend_plt_sym_val elf32_sparc_plt_sym_val
3482 #define elf_backend_can_gc_sections 1
3483 #define elf_backend_can_refcount 1
3484 #define elf_backend_want_got_plt 0
3485 #define elf_backend_plt_readonly 0
3486 #define elf_backend_want_plt_sym 1
3487 #define elf_backend_got_header_size 4
3488 #define elf_backend_rela_normal 1
3490 #include "elf32-target.h"