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