?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* bfd.c (bfd_archive_filename): New function.
[binutils.git] / bfd / elf32-sparc.c
blobc50e4458deb5b8c4358227f578c129af90fbd24d
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
1241 && (!info->symbolic || info->allow_shlib_undefined)
1242 && !info->no_undefined
1243 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1244 relocation = 0;
1245 else
1246 {
1247 if (! ((*info->callbacks->undefined_symbol)
1248 (info, h->root.root.string, input_bfd,
1249 input_section, rel->r_offset,
1250 (!info->shared || info->no_undefined
1251 || ELF_ST_VISIBILITY (h->other)))))
1252 return false;
1253 relocation = 0;
1254 }
1255 }
1256
1257 switch (r_type)
1258 {
1259 case R_SPARC_GOT10:
1260 case R_SPARC_GOT13:
1261 case R_SPARC_GOT22:
1262 /* Relocation is to the entry for this symbol in the global
1263 offset table. */
1264 if (sgot == NULL)
1265 {
1266 sgot = bfd_get_section_by_name (dynobj, ".got");
1267 BFD_ASSERT (sgot != NULL);
1268 }
1269
1270 if (h != NULL)
1271 {
1272 bfd_vma off;
1273
1274 off = h->got.offset;
1275 BFD_ASSERT (off != (bfd_vma) -1);
1276
1277 if (! elf_hash_table (info)->dynamic_sections_created
1278 || (info->shared
1279 && (info->symbolic || h->dynindx == -1)
1280 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1281 {
1282 /* This is actually a static link, or it is a
1283 -Bsymbolic link and the symbol is defined
1284 locally, or the symbol was forced to be local
1285 because of a version file. We must initialize
1286 this entry in the global offset table. Since the
1287 offset must always be a multiple of 4, we use the
1288 least significant bit to record whether we have
1289 initialized it already.
1290
1291 When doing a dynamic link, we create a .rela.got
1292 relocation entry to initialize the value. This
1293 is done in the finish_dynamic_symbol routine. */
1294 if ((off & 1) != 0)
1295 off &= ~1;
1296 else
1297 {
1298 bfd_put_32 (output_bfd, relocation,
1299 sgot->contents + off);
1300 h->got.offset |= 1;
1301 }
1302 }
1303
1304 relocation = sgot->output_offset + off - got_base;
1305 }
1306 else
1307 {
1308 bfd_vma off;
1309
1310 BFD_ASSERT (local_got_offsets != NULL
1311 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1312
1313 off = local_got_offsets[r_symndx];
1314
1315 /* The offset must always be a multiple of 4. We use
1316 the least significant bit to record whether we have
1317 already processed this entry. */
1318 if ((off & 1) != 0)
1319 off &= ~1;
1320 else
1321 {
1322 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1323
1324 if (info->shared)
1325 {
1326 asection *srelgot;
1327 Elf_Internal_Rela outrel;
1328
1329 /* We need to generate a R_SPARC_RELATIVE reloc
1330 for the dynamic linker. */
1331 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1332 BFD_ASSERT (srelgot != NULL);
1333
1334 outrel.r_offset = (sgot->output_section->vma
1335 + sgot->output_offset
1336 + off);
1337 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1338 outrel.r_addend = 0;
1339 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1340 (((Elf32_External_Rela *)
1341 srelgot->contents)
1342 + srelgot->reloc_count));
1343 ++srelgot->reloc_count;
1344 }
1345
1346 local_got_offsets[r_symndx] |= 1;
1347 }
1348
1349 relocation = sgot->output_offset + off - got_base;
1350 }
1351
1352 break;
1353
1354 case R_SPARC_WPLT30:
1355 /* Relocation is to the entry for this symbol in the
1356 procedure linkage table. */
1357
1358 /* The Solaris native assembler will generate a WPLT30 reloc
1359 for a local symbol if you assemble a call from one
1360 section to another when using -K pic. We treat it as
1361 WDISP30. */
1362 if (h == NULL)
1363 break;
1364
1365 if (h->plt.offset == (bfd_vma) -1)
1366 {
1367 /* We didn't make a PLT entry for this symbol. This
1368 happens when statically linking PIC code, or when
1369 using -Bsymbolic. */
1370 break;
1371 }
1372
1373 if (splt == NULL)
1374 {
1375 splt = bfd_get_section_by_name (dynobj, ".plt");
1376 BFD_ASSERT (splt != NULL);
1377 }
1378
1379 relocation = (splt->output_section->vma
1380 + splt->output_offset
1381 + h->plt.offset);
1382 break;
1383
1384 case R_SPARC_PC10:
1385 case R_SPARC_PC22:
1386 if (h != NULL
1387 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1388 break;
1389 /* Fall through. */
1390 case R_SPARC_DISP8:
1391 case R_SPARC_DISP16:
1392 case R_SPARC_DISP32:
1393 case R_SPARC_WDISP30:
1394 case R_SPARC_WDISP22:
1395 case R_SPARC_WDISP19:
1396 case R_SPARC_WDISP16:
1397 if (h == NULL
1398 || (info->symbolic
1399 && (h->elf_link_hash_flags
1400 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1401 break;
1402 /* Fall through. */
1403 case R_SPARC_8:
1404 case R_SPARC_16:
1405 case R_SPARC_32:
1406 case R_SPARC_HI22:
1407 case R_SPARC_22:
1408 case R_SPARC_13:
1409 case R_SPARC_LO10:
1410 case R_SPARC_UA16:
1411 case R_SPARC_UA32:
1412 if (info->shared && (input_section->flags & SEC_ALLOC))
1413 {
1414 Elf_Internal_Rela outrel;
1415 boolean skip;
1416
1417 /* When generating a shared object, these relocations
1418 are copied into the output file to be resolved at run
1419 time. */
1420
1421 if (sreloc == NULL)
1422 {
1423 const char *name;
1424
1425 name = (bfd_elf_string_from_elf_section
1426 (input_bfd,
1427 elf_elfheader (input_bfd)->e_shstrndx,
1428 elf_section_data (input_section)->rel_hdr.sh_name));
1429 if (name == NULL)
1430 return false;
1431
1432 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1433 && strcmp (bfd_get_section_name (input_bfd,
1434 input_section),
1435 name + 5) == 0);
1436
1437 sreloc = bfd_get_section_by_name (dynobj, name);
1438 BFD_ASSERT (sreloc != NULL);
1439 }
1440
1441 skip = false;
1442
1443 if (elf_section_data (input_section)->stab_info == NULL)
1444 outrel.r_offset = rel->r_offset;
1445 else
1446 {
1447 bfd_vma off;
1448
1449 off = (_bfd_stab_section_offset
1450 (output_bfd, &elf_hash_table (info)->stab_info,
1451 input_section,
1452 &elf_section_data (input_section)->stab_info,
1453 rel->r_offset));
1454 if (off == (bfd_vma) -1)
1455 skip = true;
1456 outrel.r_offset = off;
1457 }
1458
1459 outrel.r_offset += (input_section->output_section->vma
1460 + input_section->output_offset);
1461
1462 /* Optimize unaligned reloc usage now that we know where
1463 it finally resides. */
1464 switch (r_type)
1465 {
1466 case R_SPARC_16:
1467 if (outrel.r_offset & 1)
1468 r_type = R_SPARC_UA16;
1469 break;
1470 case R_SPARC_UA16:
1471 if (!(outrel.r_offset & 1))
1472 r_type = R_SPARC_16;
1473 break;
1474 case R_SPARC_32:
1475 if (outrel.r_offset & 3)
1476 r_type = R_SPARC_UA32;
1477 break;
1478 case R_SPARC_UA32:
1479 if (!(outrel.r_offset & 3))
1480 r_type = R_SPARC_32;
1481 break;
1482 }
1483
1484 if (skip)
1485 memset (&outrel, 0, sizeof outrel);
1486 /* h->dynindx may be -1 if the symbol was marked to
1487 become local. */
1488 else if (h != NULL
1489 && ((! info->symbolic && h->dynindx != -1)
1490 || (h->elf_link_hash_flags
1491 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1492 {
1493 BFD_ASSERT (h->dynindx != -1);
1494 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1495 outrel.r_addend = rel->r_addend;
1496 }
1497 else
1498 {
1499 if (r_type == R_SPARC_32 || r_type == R_SPARC_UA32)
1500 {
1501 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1502 outrel.r_addend = relocation + rel->r_addend;
1503 }
1504 else
1505 {
1506 long indx;
1507
1508 if (h == NULL)
1509 sec = local_sections[r_symndx];
1510 else
1511 {
1512 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1513 || (h->root.type
1514 == bfd_link_hash_defweak));
1515 sec = h->root.u.def.section;
1516 }
1517 if (sec != NULL && bfd_is_abs_section (sec))
1518 indx = 0;
1519 else if (sec == NULL || sec->owner == NULL)
1520 {
1521 bfd_set_error (bfd_error_bad_value);
1522 return false;
1523 }
1524 else
1525 {
1526 asection *osec;
1527
1528 osec = sec->output_section;
1529 indx = elf_section_data (osec)->dynindx;
1530
1531 /* FIXME: we really should be able to link non-pic
1532 shared libraries. */
1533 if (indx == 0)
1534 {
1535 BFD_FAIL ();
1536 (*_bfd_error_handler)
1537 (_("%s: probably compiled without -fPIC?"),
1538 bfd_archive_filename (input_bfd));
1539 bfd_set_error (bfd_error_bad_value);
1540 return false;
1541 }
1542 }
1543
1544 outrel.r_info = ELF32_R_INFO (indx, r_type);
1545 outrel.r_addend = relocation + rel->r_addend;
1546 }
1547 }
1548
1549 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1550 (((Elf32_External_Rela *)
1551 sreloc->contents)
1552 + sreloc->reloc_count));
1553 ++sreloc->reloc_count;
1554
1555 /* This reloc will be computed at runtime, so there's no
1556 need to do anything now. */
1557 continue;
1558 }
1559 break;
1560
1561 default:
1562 break;
1563 }
1564
1565 r = bfd_reloc_continue;
1566 if (r_type == R_SPARC_WDISP16)
1567 {
1568 bfd_vma x;
1569
1570 relocation += rel->r_addend;
1571 relocation -= (input_section->output_section->vma
1572 + input_section->output_offset);
1573 relocation -= rel->r_offset;
1574
1575 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1576 x |= ((((relocation >> 2) & 0xc000) << 6)
1577 | ((relocation >> 2) & 0x3fff));
1578 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1579
1580 if ((bfd_signed_vma) relocation < - 0x40000
1581 || (bfd_signed_vma) relocation > 0x3ffff)
1582 r = bfd_reloc_overflow;
1583 else
1584 r = bfd_reloc_ok;
1585 }
1586 else if (r_type == R_SPARC_REV32)
1587 {
1588 bfd_vma x;
1589
1590 relocation = relocation + rel->r_addend;
1591
1592 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1593 x = x + relocation;
1594 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
1595 r = bfd_reloc_ok;
1596 }
1597 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
1598 && SEC_DO_RELAX (input_section)
1599 && rel->r_offset + 4 < input_section->_raw_size)
1600 {
1601 #define G0 0
1602 #define O7 15
1603 #define XCC (2 << 20)
1604 #define COND(x) (((x)&0xf)<<25)
1605 #define CONDA COND(0x8)
1606 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
1607 #define INSN_BA (F2(0,2) | CONDA)
1608 #define INSN_OR F3(2, 0x2, 0)
1609 #define INSN_NOP F2(0,4)
1610
1611 bfd_vma x, y;
1612
1613 /* If the instruction is a call with either:
1614 restore
1615 arithmetic instruction with rd == %o7
1616 where rs1 != %o7 and rs2 if it is register != %o7
1617 then we can optimize if the call destination is near
1618 by changing the call into a branch always. */
1619 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1620 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
1621 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
1622 {
1623 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
1624 || ((y & OP3(0x28)) == 0 /* arithmetic */
1625 && (y & RD(~0)) == RD(O7)))
1626 && (y & RS1(~0)) != RS1(O7)
1627 && ((y & F3I(~0))
1628 || (y & RS2(~0)) != RS2(O7)))
1629 {
1630 bfd_vma reloc;
1631
1632 reloc = relocation + rel->r_addend - rel->r_offset;
1633 reloc -= (input_section->output_section->vma
1634 + input_section->output_offset);
1635
1636 /* Ensure the reloc fits into simm22. */
1637 if ((reloc & 3) == 0
1638 && ((reloc & ~(bfd_vma)0x7fffff) == 0
1639 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
1640 {
1641 reloc >>= 2;
1642
1643 /* Check whether it fits into simm19 on v9. */
1644 if (((reloc & 0x3c0000) == 0
1645 || (reloc & 0x3c0000) == 0x3c0000)
1646 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
1647 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
1648 else
1649 x = INSN_BA | (reloc & 0x3fffff); /* ba */
1650 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1651 r = bfd_reloc_ok;
1652 if (rel->r_offset >= 4
1653 && (y & (0xffffffff ^ RS1(~0)))
1654 == (INSN_OR | RD(O7) | RS2(G0)))
1655 {
1656 bfd_vma z;
1657 unsigned int reg;
1658
1659 z = bfd_get_32 (input_bfd,
1660 contents + rel->r_offset - 4);
1661 if ((z & (0xffffffff ^ RD(~0)))
1662 != (INSN_OR | RS1(O7) | RS2(G0)))
1663 break;
1664
1665 /* The sequence was
1666 or %o7, %g0, %rN
1667 call foo
1668 or %rN, %g0, %o7
1669
1670 If call foo was replaced with ba, replace
1671 or %rN, %g0, %o7 with nop. */
1672
1673 reg = (y & RS1(~0)) >> 14;
1674 if (reg != ((z & RD(~0)) >> 25)
1675 || reg == G0 || reg == O7)
1676 break;
1677
1678 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
1679 contents + rel->r_offset + 4);
1680 }
1681
1682 }
1683 }
1684 }
1685 }
1686
1687 if (r == bfd_reloc_continue)
1688 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1689 contents, rel->r_offset,
1690 relocation, rel->r_addend);
1691
1692 if (r != bfd_reloc_ok)
1693 {
1694 switch (r)
1695 {
1696 default:
1697 case bfd_reloc_outofrange:
1698 abort ();
1699 case bfd_reloc_overflow:
1700 {
1701 const char *name;
1702
1703 if (h != NULL)
1704 name = h->root.root.string;
1705 else
1706 {
1707 name = bfd_elf_string_from_elf_section (input_bfd,
1708 symtab_hdr->sh_link,
1709 sym->st_name);
1710 if (name == NULL)
1711 return false;
1712 if (*name == '\0')
1713 name = bfd_section_name (input_bfd, sec);
1714 }
1715 if (! ((*info->callbacks->reloc_overflow)
1716 (info, name, howto->name, (bfd_vma) 0,
1717 input_bfd, input_section, rel->r_offset)))
1718 return false;
1719 }
1720 break;
1721 }
1722 }
1723 }
1724
1725 return true;
1726 }
1727
1728 /* Finish up dynamic symbol handling. We set the contents of various
1729 dynamic sections here. */
1730
1731 static boolean
1732 elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
1733 bfd *output_bfd;
1734 struct bfd_link_info *info;
1735 struct elf_link_hash_entry *h;
1736 Elf_Internal_Sym *sym;
1737 {
1738 bfd *dynobj;
1739
1740 dynobj = elf_hash_table (info)->dynobj;
1741
1742 if (h->plt.offset != (bfd_vma) -1)
1743 {
1744 asection *splt;
1745 asection *srela;
1746 Elf_Internal_Rela rela;
1747
1748 /* This symbol has an entry in the procedure linkage table. Set
1749 it up. */
1750
1751 BFD_ASSERT (h->dynindx != -1);
1752
1753 splt = bfd_get_section_by_name (dynobj, ".plt");
1754 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1755 BFD_ASSERT (splt != NULL && srela != NULL);
1756
1757 /* Fill in the entry in the procedure linkage table. */
1758 bfd_put_32 (output_bfd,
1759 PLT_ENTRY_WORD0 + h->plt.offset,
1760 splt->contents + h->plt.offset);
1761 bfd_put_32 (output_bfd,
1762 (PLT_ENTRY_WORD1
1763 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
1764 splt->contents + h->plt.offset + 4);
1765 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
1766 splt->contents + h->plt.offset + 8);
1767
1768 /* Fill in the entry in the .rela.plt section. */
1769 rela.r_offset = (splt->output_section->vma
1770 + splt->output_offset
1771 + h->plt.offset);
1772 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
1773 rela.r_addend = 0;
1774 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1775 ((Elf32_External_Rela *) srela->contents
1776 + h->plt.offset / PLT_ENTRY_SIZE - 4));
1777
1778 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1779 {
1780 /* Mark the symbol as undefined, rather than as defined in
1781 the .plt section. Leave the value alone. */
1782 sym->st_shndx = SHN_UNDEF;
1783 /* If the symbol is weak, we do need to clear the value.
1784 Otherwise, the PLT entry would provide a definition for
1785 the symbol even if the symbol wasn't defined anywhere,
1786 and so the symbol would never be NULL. */
1787 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1788 == 0)
1789 sym->st_value = 0;
1790 }
1791 }
1792
1793 if (h->got.offset != (bfd_vma) -1)
1794 {
1795 asection *sgot;
1796 asection *srela;
1797 Elf_Internal_Rela rela;
1798
1799 /* This symbol has an entry in the global offset table. Set it
1800 up. */
1801
1802 sgot = bfd_get_section_by_name (dynobj, ".got");
1803 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1804 BFD_ASSERT (sgot != NULL && srela != NULL);
1805
1806 rela.r_offset = (sgot->output_section->vma
1807 + sgot->output_offset
1808 + (h->got.offset &~ (bfd_vma) 1));
1809
1810 /* If this is a -Bsymbolic link, and the symbol is defined
1811 locally, we just want to emit a RELATIVE reloc. Likewise if
1812 the symbol was forced to be local because of a version file.
1813 The entry in the global offset table will already have been
1814 initialized in the relocate_section function. */
1815 if (info->shared
1816 && (info->symbolic || h->dynindx == -1)
1817 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1818 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1819 else
1820 {
1821 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1822 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
1823 }
1824
1825 rela.r_addend = 0;
1826 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1827 ((Elf32_External_Rela *) srela->contents
1828 + srela->reloc_count));
1829 ++srela->reloc_count;
1830 }
1831
1832 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1833 {
1834 asection *s;
1835 Elf_Internal_Rela rela;
1836
1837 /* This symbols needs a copy reloc. Set it up. */
1838
1839 BFD_ASSERT (h->dynindx != -1);
1840
1841 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1842 ".rela.bss");
1843 BFD_ASSERT (s != NULL);
1844
1845 rela.r_offset = (h->root.u.def.value
1846 + h->root.u.def.section->output_section->vma
1847 + h->root.u.def.section->output_offset);
1848 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
1849 rela.r_addend = 0;
1850 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1851 ((Elf32_External_Rela *) s->contents
1852 + s->reloc_count));
1853 ++s->reloc_count;
1854 }
1855
1856 /* Mark some specially defined symbols as absolute. */
1857 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1858 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
1859 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1860 sym->st_shndx = SHN_ABS;
1861
1862 return true;
1863 }
1864
1865 /* Finish up the dynamic sections. */
1866
1867 static boolean
1868 elf32_sparc_finish_dynamic_sections (output_bfd, info)
1869 bfd *output_bfd;
1870 struct bfd_link_info *info;
1871 {
1872 bfd *dynobj;
1873 asection *sdyn;
1874 asection *sgot;
1875
1876 dynobj = elf_hash_table (info)->dynobj;
1877
1878 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1879
1880 if (elf_hash_table (info)->dynamic_sections_created)
1881 {
1882 asection *splt;
1883 Elf32_External_Dyn *dyncon, *dynconend;
1884
1885 splt = bfd_get_section_by_name (dynobj, ".plt");
1886 BFD_ASSERT (splt != NULL && sdyn != NULL);
1887
1888 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1889 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1890 for (; dyncon < dynconend; dyncon++)
1891 {
1892 Elf_Internal_Dyn dyn;
1893 const char *name;
1894 boolean size;
1895
1896 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1897
1898 switch (dyn.d_tag)
1899 {
1900 case DT_PLTGOT: name = ".plt"; size = false; break;
1901 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1902 case DT_JMPREL: name = ".rela.plt"; size = false; break;
1903 default: name = NULL; size = false; break;
1904 }
1905
1906 if (name != NULL)
1907 {
1908 asection *s;
1909
1910 s = bfd_get_section_by_name (output_bfd, name);
1911 if (s == NULL)
1912 dyn.d_un.d_val = 0;
1913 else
1914 {
1915 if (! size)
1916 dyn.d_un.d_ptr = s->vma;
1917 else
1918 {
1919 if (s->_cooked_size != 0)
1920 dyn.d_un.d_val = s->_cooked_size;
1921 else
1922 dyn.d_un.d_val = s->_raw_size;
1923 }
1924 }
1925 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1926 }
1927 }
1928
1929 /* Clear the first four entries in the procedure linkage table,
1930 and put a nop in the last four bytes. */
1931 if (splt->_raw_size > 0)
1932 {
1933 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
1934 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
1935 splt->contents + splt->_raw_size - 4);
1936 }
1937
1938 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1939 PLT_ENTRY_SIZE;
1940 }
1941
1942 /* Set the first entry in the global offset table to the address of
1943 the dynamic section. */
1944 sgot = bfd_get_section_by_name (dynobj, ".got");
1945 BFD_ASSERT (sgot != NULL);
1946 if (sgot->_raw_size > 0)
1947 {
1948 if (sdyn == NULL)
1949 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1950 else
1951 bfd_put_32 (output_bfd,
1952 sdyn->output_section->vma + sdyn->output_offset,
1953 sgot->contents);
1954 }
1955
1956 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1957
1958 return true;
1959 }
1960 \f
1961 /* Functions for dealing with the e_flags field.
1962
1963 We don't define set_private_flags or copy_private_bfd_data because
1964 the only currently defined values are based on the bfd mach number,
1965 so we use the latter instead and defer setting e_flags until the
1966 file is written out. */
1967
1968 /* Merge backend specific data from an object file to the output
1969 object file when linking. */
1970
1971 static boolean
1972 elf32_sparc_merge_private_bfd_data (ibfd, obfd)
1973 bfd *ibfd;
1974 bfd *obfd;
1975 {
1976 boolean error;
1977 /* FIXME: This should not be static. */
1978 static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
1979
1980 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1981 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1982 return true;
1983
1984 error = false;
1985
1986 if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
1987 {
1988 error = true;
1989 (*_bfd_error_handler)
1990 (_("%s: compiled for a 64 bit system and target is 32 bit"),
1991 bfd_archive_filename (ibfd));
1992 }
1993 else if ((ibfd->flags & DYNAMIC) == 0)
1994 {
1995 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
1996 bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
1997 }
1998
1999 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
2000 != previous_ibfd_e_flags)
2001 && previous_ibfd_e_flags != (unsigned long) -1)
2002 {
2003 (*_bfd_error_handler)
2004 (_("%s: linking little endian files with big endian files"),
2005 bfd_archive_filename (ibfd));
2006 error = true;
2007 }
2008 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
2009
2010 if (error)
2011 {
2012 bfd_set_error (bfd_error_bad_value);
2013 return false;
2014 }
2015
2016 return true;
2017 }
2018 \f
2019 /* Set the right machine number. */
2020
2021 static boolean
2022 elf32_sparc_object_p (abfd)
2023 bfd *abfd;
2024 {
2025 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
2026 {
2027 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
2028 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2029 bfd_mach_sparc_v8plusb);
2030 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
2031 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2032 bfd_mach_sparc_v8plusa);
2033 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
2034 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2035 bfd_mach_sparc_v8plus);
2036 else
2037 return false;
2038 }
2039 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
2040 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2041 bfd_mach_sparc_sparclite_le);
2042 else
2043 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
2044 }
2045
2046 /* The final processing done just before writing out the object file.
2047 We need to set the e_machine field appropriately. */
2048
2049 static void
2050 elf32_sparc_final_write_processing (abfd, linker)
2051 bfd *abfd;
2052 boolean linker ATTRIBUTE_UNUSED;
2053 {
2054 switch (bfd_get_mach (abfd))
2055 {
2056 case bfd_mach_sparc :
2057 break; /* nothing to do */
2058 case bfd_mach_sparc_v8plus :
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;
2062 break;
2063 case bfd_mach_sparc_v8plusa :
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 break;
2068 case bfd_mach_sparc_v8plusb :
2069 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2070 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2071 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
2072 | EF_SPARC_SUN_US3;
2073 break;
2074 case bfd_mach_sparc_sparclite_le :
2075 elf_elfheader (abfd)->e_machine = EM_SPARC;
2076 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
2077 break;
2078 default :
2079 abort ();
2080 break;
2081 }
2082 }
2083
2084 static enum elf_reloc_type_class
2085 elf32_sparc_reloc_type_class (type)
2086 int type;
2087 {
2088 switch (type)
2089 {
2090 case R_SPARC_RELATIVE:
2091 return reloc_class_relative;
2092 case R_SPARC_JMP_SLOT:
2093 return reloc_class_plt;
2094 case R_SPARC_COPY:
2095 return reloc_class_copy;
2096 default:
2097 return reloc_class_normal;
2098 }
2099 }
2100 \f
2101 #define TARGET_BIG_SYM bfd_elf32_sparc_vec
2102 #define TARGET_BIG_NAME "elf32-sparc"
2103 #define ELF_ARCH bfd_arch_sparc
2104 #define ELF_MACHINE_CODE EM_SPARC
2105 #define ELF_MACHINE_ALT1 EM_SPARC32PLUS
2106 #define ELF_MAXPAGESIZE 0x10000
2107
2108 #define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
2109 #define bfd_elf32_bfd_relax_section elf32_sparc_relax_section
2110 #define elf_info_to_howto elf32_sparc_info_to_howto
2111 #define elf_backend_create_dynamic_sections \
2112 _bfd_elf_create_dynamic_sections
2113 #define elf_backend_check_relocs elf32_sparc_check_relocs
2114 #define elf_backend_adjust_dynamic_symbol \
2115 elf32_sparc_adjust_dynamic_symbol
2116 #define elf_backend_size_dynamic_sections \
2117 elf32_sparc_size_dynamic_sections
2118 #define elf_backend_relocate_section elf32_sparc_relocate_section
2119 #define elf_backend_finish_dynamic_symbol \
2120 elf32_sparc_finish_dynamic_symbol
2121 #define elf_backend_finish_dynamic_sections \
2122 elf32_sparc_finish_dynamic_sections
2123 #define bfd_elf32_bfd_merge_private_bfd_data \
2124 elf32_sparc_merge_private_bfd_data
2125 #define elf_backend_object_p elf32_sparc_object_p
2126 #define elf_backend_final_write_processing \
2127 elf32_sparc_final_write_processing
2128 #define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook
2129 #define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook
2130 #define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
2131
2132 #define elf_backend_can_gc_sections 1
2133 #define elf_backend_want_got_plt 0
2134 #define elf_backend_plt_readonly 0
2135 #define elf_backend_want_plt_sym 1
2136 #define elf_backend_got_header_size 4
2137 #define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE)
2138
2139 #include "elf32-target.h"
git-cvsimport of binutils cvsroot