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