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