projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Oops, changelog for last patch.
[deliverable/binutils-gdb.git] / bfd / elf32-sparc.c
CommitLineData
252b5132 1/* SPARC-specific support for 32-bit ELF
7898deda 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
37fb6db1 3 Free Software Foundation, Inc.
252b5132
RH		 4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, 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"
f7775d95 27#include "opcode/sparc.h"
252b5132
RH		 28
29static reloc_howto_type *elf32_sparc_reloc_type_lookup
30 PARAMS ((bfd *, bfd_reloc_code_real_type));
31static void elf32_sparc_info_to_howto
32 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
33static boolean elf32_sparc_check_relocs
34 PARAMS ((bfd *, struct bfd_link_info *, asection *,
35 const Elf_Internal_Rela *));
36static boolean elf32_sparc_adjust_dynamic_symbol
37 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
252b5132
RH		 38static boolean elf32_sparc_size_dynamic_sections
39 PARAMS ((bfd *, struct bfd_link_info *));
f7775d95
JJ		 40static boolean elf32_sparc_relax_section
41 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
252b5132
RH		 42static boolean elf32_sparc_relocate_section
43 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
44 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
45static boolean elf32_sparc_finish_dynamic_symbol
46 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
47 Elf_Internal_Sym *));
48static boolean elf32_sparc_finish_dynamic_sections
49 PARAMS ((bfd *, struct bfd_link_info *));
50static boolean elf32_sparc_merge_private_bfd_data PARAMS ((bfd *, bfd *));
51static boolean elf32_sparc_object_p
52 PARAMS ((bfd *));
53static void elf32_sparc_final_write_processing
54 PARAMS ((bfd *, boolean));
db6751f2 55static enum elf_reloc_type_class elf32_sparc_reloc_type_class
f51e552e 56 PARAMS ((const Elf_Internal_Rela *));
917583ad
NC		 57static 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 *));
60static boolean elf32_sparc_gc_sweep_hook
61 PARAMS ((bfd *, struct bfd_link_info *, asection *,
62 const Elf_Internal_Rela *));
252b5132
RH		 63\f
64/* The relocation "howto" table. */
65
66static bfd_reloc_status_type sparc_elf_notsupported_reloc
67 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
68static bfd_reloc_status_type sparc_elf_wdisp16_reloc
69 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
70
71reloc_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),
9fc54e19 96 HOWTO(R_SPARC_UA32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", false,0,0xffffffff,true),
252b5132
RH		 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),
20278fa3 131 HOWTO(R_SPARC_UA64, 0,0, 0,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_UA64", false,0,0x00000000,true),
0f2712ed
NC		 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),
252b5132
RH		 134};
135static 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);
137static 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
252b5132
RH		 140struct elf_reloc_map {
141 bfd_reloc_code_real_type bfd_reloc_val;
142 unsigned char elf_reloc_val;
143};
144
dc810e39 145static const struct elf_reloc_map sparc_reloc_map[] =
252b5132
RH		 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 },
0f2712ed
NC		 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 },
252b5132
RH		 191};
192
193static reloc_howto_type *
194elf32_sparc_reloc_type_lookup (abfd, code)
5f771d47 195 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 196 bfd_reloc_code_real_type code;
197{
198 unsigned int i;
435b1e90 199
252b5132
RH		 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
222static void
223elf32_sparc_info_to_howto (abfd, cache_ptr, dst)
5f771d47 224 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 225 arelent *cache_ptr;
226 Elf_Internal_Rela *dst;
227{
60dac299
RH		 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 }
252b5132
RH		 242}
243\f
244/* For unsupported relocs. */
245
246static bfd_reloc_status_type
247sparc_elf_notsupported_reloc (abfd,
248 reloc_entry,
249 symbol,
250 data,
251 input_section,
252 output_bfd,
253 error_message)
5f771d47
ILT		 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;
252b5132
RH		 261{
262 return bfd_reloc_notsupported;
263}
264
265/* Handle the WDISP16 reloc. */
266
267static bfd_reloc_status_type
268sparc_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;
5f771d47 281 char **error_message ATTRIBUTE_UNUSED;
252b5132
RH		 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
352static boolean
353elf32_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 {
dc810e39 458 bfd_size_type size;
252b5132
RH		 459 register unsigned int i;
460
dc810e39
AM		 461 size = symtab_hdr->sh_info;
462 size *= sizeof (bfd_vma);
252b5132
RH		 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:
7843f00e
ILT		 526 if (h != NULL)
527 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
528
252b5132
RH		 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:
7843f00e
ILT		 540 if (h != NULL)
541 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
542
252b5132
RH		 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:
0f2712ed 564 case R_SPARC_UA16:
252b5132 565 case R_SPARC_UA32:
7843f00e
ILT		 566 if (h != NULL)
567 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
568
20278fa3 569 if (info->shared && (sec->flags & SEC_ALLOC))
252b5132
RH		 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 }
db6751f2
JJ		 604 if (sec->flags & SEC_READONLY)
605 info->flags |= DF_TEXTREL;
252b5132
RH		 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
631static asection *
632elf32_sparc_gc_mark_hook (abfd, info, rel, h, sym)
633 bfd *abfd;
5f771d47 634 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 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;
e049a0de
ILT		 657
658 default:
659 break;
252b5132
RH		 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. */
678static boolean
679elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
680 bfd *abfd;
5f771d47 681 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 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
745static boolean
746elf32_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
7843f00e
ILT		 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
252b5132
RH		 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
921static boolean
922elf32_sparc_size_dynamic_sections (output_bfd, info)
db6751f2 923 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 924 struct bfd_link_info *info;
925{
926 bfd *dynobj;
927 asection *s;
252b5132
RH		 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. */
252b5132
RH		 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 {
252b5132
RH		 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 {
7f8d5fc9 1014 _bfd_strip_section_from_output (info, s);
252b5132
RH		 1015 continue;
1016 }
1017
1018 /* Allocate memory for the section contents. */
7a9af8c4
NC		 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);
252b5132
RH		 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. */
dc810e39
AM		 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)
252b5132 1040 {
dc810e39 1041 if (!add_dynamic_entry (DT_DEBUG, 0))
252b5132
RH		 1042 return false;
1043 }
1044
1045 if (relplt)
1046 {
dc810e39
AM		 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))
252b5132
RH		 1051 return false;
1052 }
1053
dc810e39
AM		 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)))
252b5132
RH		 1057 return false;
1058
db6751f2 1059 if (info->flags & DF_TEXTREL)
252b5132 1060 {
dc810e39 1061 if (!add_dynamic_entry (DT_TEXTREL, 0))
252b5132
RH		 1062 return false;
1063 }
1064 }
dc810e39 1065#undef add_dynamic_entry
252b5132 1066
252b5132
RH		 1067 return true;
1068}
1069
f7775d95
JJ		 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
f7775d95
JJ		 1073static boolean
1074elf32_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
252b5132
RH		 1085/* Relocate a SPARC ELF section. */
1086
1087static boolean
1088elf32_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
435b1e90 1139 if (r_type == R_SPARC_GNU_VTINHERIT
252b5132
RH		 1140 || r_type == R_SPARC_GNU_VTENTRY)
1141 continue;
1142
60dac299 1143 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
252b5132
RH		 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];
f8df10f4 1179 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
252b5132
RH		 1180 }
1181 else
1182 {
1183 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1184 while (h->root.type == bfd_link_hash_indirect
1185 || h->root.type == bfd_link_hash_warning)
1186 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1187 if (h->root.type == bfd_link_hash_defined
1188 || h->root.type == bfd_link_hash_defweak)
1189 {
1190 sec = h->root.u.def.section;
1191 if ((r_type == R_SPARC_WPLT30
1192 && h->plt.offset != (bfd_vma) -1)
1193 || ((r_type == R_SPARC_GOT10
1194 || r_type == R_SPARC_GOT13
1195 || r_type == R_SPARC_GOT22)
1196 && elf_hash_table (info)->dynamic_sections_created
1197 && (! info->shared
1198 || (! info->symbolic && h->dynindx != -1)
1199 || (h->elf_link_hash_flags
1200 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1201 || (info->shared
1202 && ((! info->symbolic && h->dynindx != -1)
1203 || (h->elf_link_hash_flags
1204 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1205 && (r_type == R_SPARC_8
1206 || r_type == R_SPARC_16
1207 || r_type == R_SPARC_32
1208 || r_type == R_SPARC_DISP8
1209 || r_type == R_SPARC_DISP16
1210 || r_type == R_SPARC_DISP32
1211 || r_type == R_SPARC_WDISP30
1212 || r_type == R_SPARC_WDISP22
1213 || r_type == R_SPARC_WDISP19
1214 || r_type == R_SPARC_WDISP16
1215 || r_type == R_SPARC_HI22
1216 || r_type == R_SPARC_22
1217 || r_type == R_SPARC_13
1218 || r_type == R_SPARC_LO10
0f2712ed 1219 || r_type == R_SPARC_UA16
252b5132
RH		 1220 || r_type == R_SPARC_UA32
1221 || ((r_type == R_SPARC_PC10
1222 || r_type == R_SPARC_PC22)
1223 && strcmp (h->root.root.string,
2e549b45
JJ		 1224 "_GLOBAL_OFFSET_TABLE_") != 0))
1225 && ((input_section->flags & SEC_ALLOC) != 0
1226 /* DWARF will emit R_SPARC_32 relocations in its
1227 sections against symbols defined externally
1228 in shared libraries. We can't do anything
1229 with them here. */
1230 || ((input_section->flags & SEC_DEBUGGING) != 0
1231 && (h->elf_link_hash_flags
1232 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
252b5132
RH		 1233 {
1234 /* In these cases, we don't need the relocation
1235 value. We check specially because in some
1236 obscure cases sec->output_section will be NULL. */
1237 relocation = 0;
1238 }
1239 else
1240 relocation = (h->root.u.def.value
1241 + sec->output_section->vma
1242 + sec->output_offset);
1243 }
1244 else if (h->root.type == bfd_link_hash_undefweak)
1245 relocation = 0;
671bae9c
NC		 1246 else if (info->shared
1247 && (!info->symbolic || info->allow_shlib_undefined)
3a27a730
L		 1248 && !info->no_undefined
1249 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
252b5132
RH		 1250 relocation = 0;
1251 else
1252 {
1253 if (! ((*info->callbacks->undefined_symbol)
1254 (info, h->root.root.string, input_bfd,
5cc7c785 1255 input_section, rel->r_offset,
3a27a730
L		 1256 (!info->shared || info->no_undefined
1257 || ELF_ST_VISIBILITY (h->other)))))
252b5132
RH		 1258 return false;
1259 relocation = 0;
1260 }
1261 }
1262
1263 switch (r_type)
1264 {
1265 case R_SPARC_GOT10:
1266 case R_SPARC_GOT13:
1267 case R_SPARC_GOT22:
1268 /* Relocation is to the entry for this symbol in the global
1269 offset table. */
1270 if (sgot == NULL)
1271 {
1272 sgot = bfd_get_section_by_name (dynobj, ".got");
1273 BFD_ASSERT (sgot != NULL);
1274 }
1275
1276 if (h != NULL)
1277 {
1278 bfd_vma off;
1279
1280 off = h->got.offset;
1281 BFD_ASSERT (off != (bfd_vma) -1);
1282
1283 if (! elf_hash_table (info)->dynamic_sections_created
1284 || (info->shared
1285 && (info->symbolic || h->dynindx == -1)
1286 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1287 {
1288 /* This is actually a static link, or it is a
1289 -Bsymbolic link and the symbol is defined
1290 locally, or the symbol was forced to be local
1291 because of a version file. We must initialize
1292 this entry in the global offset table. Since the
1293 offset must always be a multiple of 4, we use the
1294 least significant bit to record whether we have
1295 initialized it already.
1296
1297 When doing a dynamic link, we create a .rela.got
1298 relocation entry to initialize the value. This
1299 is done in the finish_dynamic_symbol routine. */
1300 if ((off & 1) != 0)
1301 off &= ~1;
1302 else
1303 {
1304 bfd_put_32 (output_bfd, relocation,
1305 sgot->contents + off);
1306 h->got.offset |= 1;
1307 }
1308 }
1309
1310 relocation = sgot->output_offset + off - got_base;
1311 }
1312 else
1313 {
1314 bfd_vma off;
1315
1316 BFD_ASSERT (local_got_offsets != NULL
1317 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1318
1319 off = local_got_offsets[r_symndx];
1320
1321 /* The offset must always be a multiple of 4. We use
1322 the least significant bit to record whether we have
1323 already processed this entry. */
1324 if ((off & 1) != 0)
1325 off &= ~1;
1326 else
1327 {
1328 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1329
1330 if (info->shared)
1331 {
1332 asection *srelgot;
1333 Elf_Internal_Rela outrel;
1334
1335 /* We need to generate a R_SPARC_RELATIVE reloc
1336 for the dynamic linker. */
1337 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1338 BFD_ASSERT (srelgot != NULL);
1339
1340 outrel.r_offset = (sgot->output_section->vma
1341 + sgot->output_offset
1342 + off);
1343 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1344 outrel.r_addend = 0;
1345 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1346 (((Elf32_External_Rela *)
1347 srelgot->contents)
1348 + srelgot->reloc_count));
1349 ++srelgot->reloc_count;
1350 }
1351
1352 local_got_offsets[r_symndx] |= 1;
1353 }
1354
1355 relocation = sgot->output_offset + off - got_base;
1356 }
1357
1358 break;
1359
1360 case R_SPARC_WPLT30:
1361 /* Relocation is to the entry for this symbol in the
1362 procedure linkage table. */
1363
1364 /* The Solaris native assembler will generate a WPLT30 reloc
1365 for a local symbol if you assemble a call from one
1366 section to another when using -K pic. We treat it as
1367 WDISP30. */
1368 if (h == NULL)
1369 break;
1370
1371 if (h->plt.offset == (bfd_vma) -1)
1372 {
1373 /* We didn't make a PLT entry for this symbol. This
1374 happens when statically linking PIC code, or when
1375 using -Bsymbolic. */
1376 break;
1377 }
1378
1379 if (splt == NULL)
1380 {
1381 splt = bfd_get_section_by_name (dynobj, ".plt");
1382 BFD_ASSERT (splt != NULL);
1383 }
1384
1385 relocation = (splt->output_section->vma
1386 + splt->output_offset
1387 + h->plt.offset);
1388 break;
1389
1390 case R_SPARC_PC10:
1391 case R_SPARC_PC22:
1392 if (h != NULL
1393 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1394 break;
1395 /* Fall through. */
1396 case R_SPARC_DISP8:
1397 case R_SPARC_DISP16:
1398 case R_SPARC_DISP32:
1399 case R_SPARC_WDISP30:
1400 case R_SPARC_WDISP22:
1401 case R_SPARC_WDISP19:
1402 case R_SPARC_WDISP16:
1403 if (h == NULL
1404 || (info->symbolic
1405 && (h->elf_link_hash_flags
1406 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1407 break;
1408 /* Fall through. */
1409 case R_SPARC_8:
1410 case R_SPARC_16:
1411 case R_SPARC_32:
1412 case R_SPARC_HI22:
1413 case R_SPARC_22:
1414 case R_SPARC_13:
1415 case R_SPARC_LO10:
0f2712ed 1416 case R_SPARC_UA16:
252b5132 1417 case R_SPARC_UA32:
ec338859
AM		 1418 if (info->shared
1419 && r_symndx != 0
1420 && (input_section->flags & SEC_ALLOC))
252b5132
RH		 1421 {
1422 Elf_Internal_Rela outrel;
1423 boolean skip;
1424
1425 /* When generating a shared object, these relocations
1426 are copied into the output file to be resolved at run
1427 time. */
1428
1429 if (sreloc == NULL)
1430 {
1431 const char *name;
1432
1433 name = (bfd_elf_string_from_elf_section
1434 (input_bfd,
1435 elf_elfheader (input_bfd)->e_shstrndx,
1436 elf_section_data (input_section)->rel_hdr.sh_name));
1437 if (name == NULL)
1438 return false;
1439
1440 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1441 && strcmp (bfd_get_section_name (input_bfd,
1442 input_section),
1443 name + 5) == 0);
1444
1445 sreloc = bfd_get_section_by_name (dynobj, name);
1446 BFD_ASSERT (sreloc != NULL);
1447 }
1448
1449 skip = false;
1450
c629eae0
JJ		 1451 outrel.r_offset =
1452 _bfd_elf_section_offset (output_bfd, info, input_section,
1453 rel->r_offset);
1454 if (outrel.r_offset == (bfd_vma) -1)
1455 skip = true;
252b5132
RH		 1456 outrel.r_offset += (input_section->output_section->vma
1457 + input_section->output_offset);
1458
20278fa3
JJ		 1459 /* Optimize unaligned reloc usage now that we know where
1460 it finally resides. */
1461 switch (r_type)
1462 {
1463 case R_SPARC_16:
1464 if (outrel.r_offset & 1)
1465 r_type = R_SPARC_UA16;
1466 break;
1467 case R_SPARC_UA16:
1468 if (!(outrel.r_offset & 1))
1469 r_type = R_SPARC_16;
1470 break;
1471 case R_SPARC_32:
1472 if (outrel.r_offset & 3)
1473 r_type = R_SPARC_UA32;
1474 break;
1475 case R_SPARC_UA32:
1476 if (!(outrel.r_offset & 3))
1477 r_type = R_SPARC_32;
1478 break;
1479 }
1480
252b5132
RH		 1481 if (skip)
1482 memset (&outrel, 0, sizeof outrel);
1483 /* h->dynindx may be -1 if the symbol was marked to
1484 become local. */
1485 else if (h != NULL
1486 && ((! info->symbolic && h->dynindx != -1)
1487 || (h->elf_link_hash_flags
1488 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1489 {
1490 BFD_ASSERT (h->dynindx != -1);
1491 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1492 outrel.r_addend = rel->r_addend;
1493 }
1494 else
1495 {
1fbc4a84 1496 if (r_type == R_SPARC_32)
252b5132
RH		 1497 {
1498 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1499 outrel.r_addend = relocation + rel->r_addend;
1500 }
1501 else
1502 {
1503 long indx;
1504
1505 if (h == NULL)
1506 sec = local_sections[r_symndx];
1507 else
1508 {
1509 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1510 || (h->root.type
1511 == bfd_link_hash_defweak));
1512 sec = h->root.u.def.section;
1513 }
1514 if (sec != NULL && bfd_is_abs_section (sec))
1515 indx = 0;
1516 else if (sec == NULL || sec->owner == NULL)
1517 {
1518 bfd_set_error (bfd_error_bad_value);
1519 return false;
1520 }
1521 else
1522 {
1523 asection *osec;
1524
1525 osec = sec->output_section;
1526 indx = elf_section_data (osec)->dynindx;
1527
1528 /* FIXME: we really should be able to link non-pic
1529 shared libraries. */
1530 if (indx == 0)
1531 {
1532 BFD_FAIL ();
1533 (*_bfd_error_handler)
1534 (_("%s: probably compiled without -fPIC?"),
8f615d07 1535 bfd_archive_filename (input_bfd));
252b5132
RH		 1536 bfd_set_error (bfd_error_bad_value);
1537 return false;
1538 }
1539 }
1540
1541 outrel.r_info = ELF32_R_INFO (indx, r_type);
840a9995 1542 outrel.r_addend = relocation + rel->r_addend;
252b5132
RH		 1543 }
1544 }
1545
1546 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1547 (((Elf32_External_Rela *)
1548 sreloc->contents)
1549 + sreloc->reloc_count));
1550 ++sreloc->reloc_count;
1551
1552 /* This reloc will be computed at runtime, so there's no
20278fa3
JJ		 1553 need to do anything now. */
1554 continue;
252b5132
RH		 1555 }
1556 break;
1557
1558 default:
1559 break;
1560 }
1561
f7775d95 1562 r = bfd_reloc_continue;
252b5132
RH		 1563 if (r_type == R_SPARC_WDISP16)
1564 {
1565 bfd_vma x;
1566
1567 relocation += rel->r_addend;
1568 relocation -= (input_section->output_section->vma
1569 + input_section->output_offset);
1570 relocation -= rel->r_offset;
1571
1572 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1573 x |= ((((relocation >> 2) & 0xc000) << 6)
1574 | ((relocation >> 2) & 0x3fff));
1575 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1576
1577 if ((bfd_signed_vma) relocation < - 0x40000
1578 || (bfd_signed_vma) relocation > 0x3ffff)
1579 r = bfd_reloc_overflow;
1580 else
1581 r = bfd_reloc_ok;
1582 }
1583 else if (r_type == R_SPARC_REV32)
1584 {
1585 bfd_vma x;
1586
1587 relocation = relocation + rel->r_addend;
1588
1589 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1590 x = x + relocation;
1591 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
1592 r = bfd_reloc_ok;
1593 }
f7775d95
JJ		 1594 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
1595 && SEC_DO_RELAX (input_section)
1596 && rel->r_offset + 4 < input_section->_raw_size)
1597 {
1598#define G0 0
1599#define O7 15
1600#define XCC (2 << 20)
1601#define COND(x) (((x)&0xf)<<25)
1602#define CONDA COND(0x8)
1603#define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
1604#define INSN_BA (F2(0,2) | CONDA)
1605#define INSN_OR F3(2, 0x2, 0)
1606#define INSN_NOP F2(0,4)
1607
1608 bfd_vma x, y;
1609
1610 /* If the instruction is a call with either:
1611 restore
1612 arithmetic instruction with rd == %o7
1613 where rs1 != %o7 and rs2 if it is register != %o7
1614 then we can optimize if the call destination is near
1615 by changing the call into a branch always. */
1616 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1617 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
1618 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
1619 {
1620 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
1621 || ((y & OP3(0x28)) == 0 /* arithmetic */
1622 && (y & RD(~0)) == RD(O7)))
1623 && (y & RS1(~0)) != RS1(O7)
1624 && ((y & F3I(~0))
1625 || (y & RS2(~0)) != RS2(O7)))
1626 {
1627 bfd_vma reloc;
1628
1629 reloc = relocation + rel->r_addend - rel->r_offset;
1630 reloc -= (input_section->output_section->vma
1631 + input_section->output_offset);
1632
1633 /* Ensure the reloc fits into simm22. */
1634 if ((reloc & 3) == 0
1635 && ((reloc & ~(bfd_vma)0x7fffff) == 0
1636 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
1637 {
1638 reloc >>= 2;
435b1e90 1639
f7775d95
JJ		 1640 /* Check whether it fits into simm19 on v9. */
1641 if (((reloc & 0x3c0000) == 0
1642 || (reloc & 0x3c0000) == 0x3c0000)
1643 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
1644 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
1645 else
1646 x = INSN_BA | (reloc & 0x3fffff); /* ba */
1647 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1648 r = bfd_reloc_ok;
1649 if (rel->r_offset >= 4
1650 && (y & (0xffffffff ^ RS1(~0)))
1651 == (INSN_OR | RD(O7) | RS2(G0)))
1652 {
1653 bfd_vma z;
1654 unsigned int reg;
1655
1656 z = bfd_get_32 (input_bfd,
1657 contents + rel->r_offset - 4);
1658 if ((z & (0xffffffff ^ RD(~0)))
1659 != (INSN_OR | RS1(O7) | RS2(G0)))
1660 break;
1661
1662 /* The sequence was
1663 or %o7, %g0, %rN
1664 call foo
1665 or %rN, %g0, %o7
1666
1667 If call foo was replaced with ba, replace
1668 or %rN, %g0, %o7 with nop. */
1669
1670 reg = (y & RS1(~0)) >> 14;
1671 if (reg != ((z & RD(~0)) >> 25)
1672 || reg == G0 || reg == O7)
1673 break;
1674
dc810e39 1675 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
f7775d95
JJ		 1676 contents + rel->r_offset + 4);
1677 }
1678
1679 }
1680 }
1681 }
1682 }
1683
1684 if (r == bfd_reloc_continue)
252b5132
RH		 1685 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1686 contents, rel->r_offset,
1687 relocation, rel->r_addend);
1688
252b5132
RH		 1689 if (r != bfd_reloc_ok)
1690 {
1691 switch (r)
1692 {
1693 default:
1694 case bfd_reloc_outofrange:
1695 abort ();
1696 case bfd_reloc_overflow:
1697 {
1698 const char *name;
1699
1700 if (h != NULL)
1701 name = h->root.root.string;
1702 else
1703 {
1704 name = bfd_elf_string_from_elf_section (input_bfd,
1705 symtab_hdr->sh_link,
1706 sym->st_name);
1707 if (name == NULL)
1708 return false;
1709 if (*name == '\0')
1710 name = bfd_section_name (input_bfd, sec);
1711 }
1712 if (! ((*info->callbacks->reloc_overflow)
1713 (info, name, howto->name, (bfd_vma) 0,
1714 input_bfd, input_section, rel->r_offset)))
1715 return false;
1716 }
1717 break;
1718 }
1719 }
1720 }
1721
1722 return true;
1723}
1724
1725/* Finish up dynamic symbol handling. We set the contents of various
1726 dynamic sections here. */
1727
1728static boolean
1729elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
1730 bfd *output_bfd;
1731 struct bfd_link_info *info;
1732 struct elf_link_hash_entry *h;
1733 Elf_Internal_Sym *sym;
1734{
1735 bfd *dynobj;
1736
1737 dynobj = elf_hash_table (info)->dynobj;
1738
1739 if (h->plt.offset != (bfd_vma) -1)
1740 {
1741 asection *splt;
1742 asection *srela;
1743 Elf_Internal_Rela rela;
1744
1745 /* This symbol has an entry in the procedure linkage table. Set
1746 it up. */
1747
1748 BFD_ASSERT (h->dynindx != -1);
1749
1750 splt = bfd_get_section_by_name (dynobj, ".plt");
1751 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1752 BFD_ASSERT (splt != NULL && srela != NULL);
1753
1754 /* Fill in the entry in the procedure linkage table. */
1755 bfd_put_32 (output_bfd,
1756 PLT_ENTRY_WORD0 + h->plt.offset,
1757 splt->contents + h->plt.offset);
1758 bfd_put_32 (output_bfd,
1759 (PLT_ENTRY_WORD1
1760 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
1761 splt->contents + h->plt.offset + 4);
dc810e39 1762 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
252b5132
RH		 1763 splt->contents + h->plt.offset + 8);
1764
1765 /* Fill in the entry in the .rela.plt section. */
1766 rela.r_offset = (splt->output_section->vma
1767 + splt->output_offset
1768 + h->plt.offset);
1769 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
1770 rela.r_addend = 0;
1771 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1772 ((Elf32_External_Rela *) srela->contents
1773 + h->plt.offset / PLT_ENTRY_SIZE - 4));
1774
1775 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1776 {
1777 /* Mark the symbol as undefined, rather than as defined in
1778 the .plt section. Leave the value alone. */
1779 sym->st_shndx = SHN_UNDEF;
8701c1bc
JJ		 1780 /* If the symbol is weak, we do need to clear the value.
1781 Otherwise, the PLT entry would provide a definition for
1782 the symbol even if the symbol wasn't defined anywhere,
1783 and so the symbol would never be NULL. */
1784 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1785 == 0)
1786 sym->st_value = 0;
252b5132
RH		 1787 }
1788 }
1789
1790 if (h->got.offset != (bfd_vma) -1)
1791 {
1792 asection *sgot;
1793 asection *srela;
1794 Elf_Internal_Rela rela;
1795
1796 /* This symbol has an entry in the global offset table. Set it
1797 up. */
1798
1799 sgot = bfd_get_section_by_name (dynobj, ".got");
1800 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1801 BFD_ASSERT (sgot != NULL && srela != NULL);
1802
1803 rela.r_offset = (sgot->output_section->vma
1804 + sgot->output_offset
dc810e39 1805 + (h->got.offset &~ (bfd_vma) 1));
252b5132
RH		 1806
1807 /* If this is a -Bsymbolic link, and the symbol is defined
1808 locally, we just want to emit a RELATIVE reloc. Likewise if
1809 the symbol was forced to be local because of a version file.
1810 The entry in the global offset table will already have been
1811 initialized in the relocate_section function. */
1812 if (info->shared
1813 && (info->symbolic || h->dynindx == -1)
1814 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1815 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1816 else
1817 {
1818 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1819 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
1820 }
1821
1822 rela.r_addend = 0;
1823 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1824 ((Elf32_External_Rela *) srela->contents
1825 + srela->reloc_count));
1826 ++srela->reloc_count;
1827 }
1828
1829 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1830 {
1831 asection *s;
1832 Elf_Internal_Rela rela;
1833
1834 /* This symbols needs a copy reloc. Set it up. */
1835
1836 BFD_ASSERT (h->dynindx != -1);
1837
1838 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1839 ".rela.bss");
1840 BFD_ASSERT (s != NULL);
1841
1842 rela.r_offset = (h->root.u.def.value
1843 + h->root.u.def.section->output_section->vma
1844 + h->root.u.def.section->output_offset);
1845 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
1846 rela.r_addend = 0;
1847 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1848 ((Elf32_External_Rela *) s->contents
1849 + s->reloc_count));
1850 ++s->reloc_count;
1851 }
1852
1853 /* Mark some specially defined symbols as absolute. */
1854 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1855 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
1856 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1857 sym->st_shndx = SHN_ABS;
1858
1859 return true;
1860}
1861
1862/* Finish up the dynamic sections. */
1863
1864static boolean
1865elf32_sparc_finish_dynamic_sections (output_bfd, info)
1866 bfd *output_bfd;
1867 struct bfd_link_info *info;
1868{
1869 bfd *dynobj;
1870 asection *sdyn;
1871 asection *sgot;
1872
1873 dynobj = elf_hash_table (info)->dynobj;
1874
1875 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1876
1877 if (elf_hash_table (info)->dynamic_sections_created)
1878 {
1879 asection *splt;
1880 Elf32_External_Dyn *dyncon, *dynconend;
1881
1882 splt = bfd_get_section_by_name (dynobj, ".plt");
1883 BFD_ASSERT (splt != NULL && sdyn != NULL);
1884
1885 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1886 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1887 for (; dyncon < dynconend; dyncon++)
1888 {
1889 Elf_Internal_Dyn dyn;
1890 const char *name;
1891 boolean size;
1892
1893 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1894
1895 switch (dyn.d_tag)
1896 {
1897 case DT_PLTGOT: name = ".plt"; size = false; break;
1898 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1899 case DT_JMPREL: name = ".rela.plt"; size = false; break;
1900 default: name = NULL; size = false; break;
1901 }
1902
1903 if (name != NULL)
1904 {
1905 asection *s;
1906
1907 s = bfd_get_section_by_name (output_bfd, name);
1908 if (s == NULL)
1909 dyn.d_un.d_val = 0;
1910 else
1911 {
1912 if (! size)
1913 dyn.d_un.d_ptr = s->vma;
1914 else
1915 {
1916 if (s->_cooked_size != 0)
1917 dyn.d_un.d_val = s->_cooked_size;
1918 else
1919 dyn.d_un.d_val = s->_raw_size;
1920 }
1921 }
1922 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1923 }
1924 }
1925
1926 /* Clear the first four entries in the procedure linkage table,
1927 and put a nop in the last four bytes. */
1928 if (splt->_raw_size > 0)
1929 {
1930 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
dc810e39 1931 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
252b5132
RH		 1932 splt->contents + splt->_raw_size - 4);
1933 }
1934
1935 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1936 PLT_ENTRY_SIZE;
1937 }
1938
1939 /* Set the first entry in the global offset table to the address of
1940 the dynamic section. */
1941 sgot = bfd_get_section_by_name (dynobj, ".got");
1942 BFD_ASSERT (sgot != NULL);
1943 if (sgot->_raw_size > 0)
1944 {
1945 if (sdyn == NULL)
1946 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1947 else
1948 bfd_put_32 (output_bfd,
1949 sdyn->output_section->vma + sdyn->output_offset,
1950 sgot->contents);
1951 }
1952
1953 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1954
252b5132
RH		 1955 return true;
1956}
1957\f
1958/* Functions for dealing with the e_flags field.
1959
1960 We don't define set_private_flags or copy_private_bfd_data because
1961 the only currently defined values are based on the bfd mach number,
1962 so we use the latter instead and defer setting e_flags until the
1963 file is written out. */
1964
1965/* Merge backend specific data from an object file to the output
1966 object file when linking. */
1967
1968static boolean
1969elf32_sparc_merge_private_bfd_data (ibfd, obfd)
1970 bfd *ibfd;
1971 bfd *obfd;
1972{
1973 boolean error;
5f771d47
ILT		 1974 /* FIXME: This should not be static. */
1975 static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
252b5132
RH		 1976
1977 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1978 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1979 return true;
1980
1981 error = false;
1982
252b5132
RH		 1983 if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
1984 {
1985 error = true;
1986 (*_bfd_error_handler)
1987 (_("%s: compiled for a 64 bit system and target is 32 bit"),
8f615d07 1988 bfd_archive_filename (ibfd));
252b5132 1989 }
37fb6db1
ILT		 1990 else if ((ibfd->flags & DYNAMIC) == 0)
1991 {
1992 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
1993 bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
1994 }
252b5132
RH		 1995
1996 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
1997 != previous_ibfd_e_flags)
5f771d47 1998 && previous_ibfd_e_flags != (unsigned long) -1)
252b5132
RH		 1999 {
2000 (*_bfd_error_handler)
2001 (_("%s: linking little endian files with big endian files"),
8f615d07 2002 bfd_archive_filename (ibfd));
252b5132
RH		 2003 error = true;
2004 }
2005 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
2006
2007 if (error)
2008 {
2009 bfd_set_error (bfd_error_bad_value);
2010 return false;
2011 }
2012
2013 return true;
2014}
2015\f
2016/* Set the right machine number. */
2017
2018static boolean
2019elf32_sparc_object_p (abfd)
2020 bfd *abfd;
2021{
2022 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
2023 {
19f7b010
JJ		 2024 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
2025 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2026 bfd_mach_sparc_v8plusb);
2027 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
252b5132
RH		 2028 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2029 bfd_mach_sparc_v8plusa);
2030 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
2031 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
2032 bfd_mach_sparc_v8plus);
2033 else
2034 return false;
2035 }
2036 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
2037 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
20278fa3 2038 bfd_mach_sparc_sparclite_le);
252b5132
RH		 2039 else
2040 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
2041}
2042
2043/* The final processing done just before writing out the object file.
2044 We need to set the e_machine field appropriately. */
2045
2046static void
2047elf32_sparc_final_write_processing (abfd, linker)
2048 bfd *abfd;
5f771d47 2049 boolean linker ATTRIBUTE_UNUSED;
252b5132
RH		 2050{
2051 switch (bfd_get_mach (abfd))
2052 {
2053 case bfd_mach_sparc :
2054 break; /* nothing to do */
2055 case bfd_mach_sparc_v8plus :
2056 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2057 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2058 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
2059 break;
2060 case bfd_mach_sparc_v8plusa :
2061 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2062 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2063 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
2064 break;
19f7b010
JJ		 2065 case bfd_mach_sparc_v8plusb :
2066 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
2067 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
2068 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
2069 | EF_SPARC_SUN_US3;
2070 break;
252b5132
RH		 2071 case bfd_mach_sparc_sparclite_le :
2072 elf_elfheader (abfd)->e_machine = EM_SPARC;
2073 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
2074 break;
2075 default :
2076 abort ();
2077 break;
2078 }
2079}
db6751f2
JJ		 2080
2081static enum elf_reloc_type_class
f51e552e
AM		 2082elf32_sparc_reloc_type_class (rela)
2083 const Elf_Internal_Rela *rela;
db6751f2 2084{
f51e552e 2085 switch ((int) ELF32_R_TYPE (rela->r_info))
db6751f2
JJ		 2086 {
2087 case R_SPARC_RELATIVE:
2088 return reloc_class_relative;
2089 case R_SPARC_JMP_SLOT:
2090 return reloc_class_plt;
2091 case R_SPARC_COPY:
2092 return reloc_class_copy;
2093 default:
2094 return reloc_class_normal;
2095 }
2096}
252b5132
RH		 2097\f
2098#define TARGET_BIG_SYM bfd_elf32_sparc_vec
2099#define TARGET_BIG_NAME "elf32-sparc"
2100#define ELF_ARCH bfd_arch_sparc
2101#define ELF_MACHINE_CODE EM_SPARC
2102#define ELF_MACHINE_ALT1 EM_SPARC32PLUS
2103#define ELF_MAXPAGESIZE 0x10000
2104
2105#define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
f7775d95 2106#define bfd_elf32_bfd_relax_section elf32_sparc_relax_section
252b5132
RH		 2107#define elf_info_to_howto elf32_sparc_info_to_howto
2108#define elf_backend_create_dynamic_sections \
2109 _bfd_elf_create_dynamic_sections
2110#define elf_backend_check_relocs elf32_sparc_check_relocs
2111#define elf_backend_adjust_dynamic_symbol \
2112 elf32_sparc_adjust_dynamic_symbol
2113#define elf_backend_size_dynamic_sections \
2114 elf32_sparc_size_dynamic_sections
2115#define elf_backend_relocate_section elf32_sparc_relocate_section
2116#define elf_backend_finish_dynamic_symbol \
2117 elf32_sparc_finish_dynamic_symbol
2118#define elf_backend_finish_dynamic_sections \
2119 elf32_sparc_finish_dynamic_sections
2120#define bfd_elf32_bfd_merge_private_bfd_data \
2121 elf32_sparc_merge_private_bfd_data
2122#define elf_backend_object_p elf32_sparc_object_p
2123#define elf_backend_final_write_processing \
2124 elf32_sparc_final_write_processing
2125#define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook
2126#define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook
db6751f2 2127#define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
252b5132
RH		 2128
2129#define elf_backend_can_gc_sections 1
2130#define elf_backend_want_got_plt 0
2131#define elf_backend_plt_readonly 0
2132#define elf_backend_want_plt_sym 1
2133#define elf_backend_got_header_size 4
2134#define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE)
2135
2136#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.197411 seconds and 4 git commands to generate.