Tue Jun 25 11:41:24 1996 Richard Henderson <rth@tamu.edu>
[deliverable/binutils-gdb.git] / bfd / elf32-sparc.c
CommitLineData
32090b8e 1/* SPARC-specific support for 32-bit ELF
904ae083 2 Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
32090b8e
KR
3
4This file is part of BFD, the Binary File Descriptor library.
5
6This program is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2 of the License, or
9(at your option) any later version.
10
11This program is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with this program; if not, write to the Free Software
943fbd5b 18Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
32090b8e
KR
19
20#include "bfd.h"
21#include "sysdep.h"
013dec1a 22#include "bfdlink.h"
32090b8e 23#include "libbfd.h"
3b3f7625 24#include "elf-bfd.h"
5bc513b4 25#include "elf/sparc.h"
32090b8e 26
19bfbcbe 27static reloc_howto_type *elf32_sparc_reloc_type_lookup
013dec1a
ILT
28 PARAMS ((bfd *, bfd_reloc_code_real_type));
29static void elf_info_to_howto
30 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
4fbc96ad
KR
31static boolean elf32_sparc_check_relocs
32 PARAMS ((bfd *, struct bfd_link_info *, asection *,
33 const Elf_Internal_Rela *));
013dec1a
ILT
34static boolean elf32_sparc_adjust_dynamic_symbol
35 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
14cac507
ILT
36static boolean elf32_sparc_adjust_dynindx
37 PARAMS ((struct elf_link_hash_entry *, PTR));
013dec1a
ILT
38static boolean elf32_sparc_size_dynamic_sections
39 PARAMS ((bfd *, struct bfd_link_info *));
40static boolean elf32_sparc_relocate_section
41 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
12662be4 42 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
013dec1a
ILT
43static boolean elf32_sparc_finish_dynamic_symbol
44 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
45 Elf_Internal_Sym *));
46static boolean elf32_sparc_finish_dynamic_sections
47 PARAMS ((bfd *, struct bfd_link_info *));
5bc513b4
DE
48static boolean elf32_sparc_merge_private_bfd_data PARAMS ((bfd *, bfd *));
49static boolean elf32_sparc_object_p
50 PARAMS ((bfd *));
51static void elf32_sparc_final_write_processing
52 PARAMS ((bfd *, boolean));
19bfbcbe
ILT
53\f
54/* The howto table and associated functions.
55 ??? elf64-sparc.c has its own copy for the moment to ease transition
56 since some of the relocation values have changed. At some point we'll
57 want elf64-sparc.c to switch over and use this table.
58 ??? Do we want to recognize (or flag as errors) some of the 64 bit entries
59 if the target is elf32-sparc.
60*/
61
62static bfd_reloc_status_type sparc_elf_notsupported_reloc
63 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
64static bfd_reloc_status_type sparc_elf_wdisp16_reloc
65 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
66
67reloc_howto_type _bfd_sparc_elf_howto_table[] =
32090b8e 68{
19bfbcbe
ILT
69 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true),
70 HOWTO(R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", false,0,0x000000ff,true),
71 HOWTO(R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", false,0,0x0000ffff,true),
72 HOWTO(R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", false,0,0xffffffff,true),
73 HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", false,0,0x000000ff,true),
74 HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", false,0,0x0000ffff,true),
75 HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", false,0,0x00ffffff,true),
76 HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", false,0,0x3fffffff,true),
77 HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", false,0,0x003fffff,true),
78 HOWTO(R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", false,0,0x003fffff,true),
79 HOWTO(R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", false,0,0x003fffff,true),
80 HOWTO(R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", false,0,0x00001fff,true),
81 HOWTO(R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", false,0,0x000003ff,true),
82 HOWTO(R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", false,0,0x000003ff,true),
83 HOWTO(R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", false,0,0x00001fff,true),
84 HOWTO(R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", false,0,0x003fffff,true),
85 HOWTO(R_SPARC_PC10, 0,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", false,0,0x000003ff,true),
86 HOWTO(R_SPARC_PC22, 10,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", false,0,0x003fffff,true),
87 HOWTO(R_SPARC_WPLT30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", false,0,0x3fffffff,true),
88 HOWTO(R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", false,0,0x00000000,true),
89 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),
90 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),
91 HOWTO(R_SPARC_RELATIVE, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",false,0,0x00000000,true),
92 HOWTO(R_SPARC_UA32, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_UA32", false,0,0x00000000,true),
93 HOWTO(R_SPARC_PLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PLT32", false,0,0x00000000,true),
94 HOWTO(R_SPARC_HIPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HIPLT22", false,0,0x00000000,true),
95 HOWTO(R_SPARC_LOPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LOPLT10", false,0,0x00000000,true),
96 HOWTO(R_SPARC_PCPLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT32", false,0,0x00000000,true),
97 HOWTO(R_SPARC_PCPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT22", false,0,0x00000000,true),
98 HOWTO(R_SPARC_PCPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT10", false,0,0x00000000,true),
99 HOWTO(R_SPARC_10, 0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", false,0,0x000003ff,true),
100 HOWTO(R_SPARC_11, 0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", false,0,0x000007ff,true),
101 /* ??? If we need to handle R_SPARC_64 then we need (figuratively)
102 --enable-64-bit-bfd. That causes objdump to print address as 64 bits
103 which we really don't want on an elf32-sparc system. There may be other
104 consequences which we may not want (at least not until it's proven they're
105 necessary) so for now these are only enabled ifdef BFD64. */
106#ifdef BFD64
107 HOWTO(R_SPARC_64, 0,4,00,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", false,0,~ (bfd_vma) 0, true),
108 /* ??? These don't make sense except in 64 bit systems so they're disabled
109 ifndef BFD64 too (for now). */
110 HOWTO(R_SPARC_OLO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_OLO10", false,0,0x000003ff,true),
111 HOWTO(R_SPARC_HH22, 42,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true),
112 HOWTO(R_SPARC_HM10, 32,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true),
113 HOWTO(R_SPARC_LM22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true),
114 HOWTO(R_SPARC_PC_HH22, 42,2,22,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true),
115 HOWTO(R_SPARC_PC_HM10, 32,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true),
116 HOWTO(R_SPARC_PC_LM22, 10,2,22,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true),
117#else
118 HOWTO(R_SPARC_64, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_64", false,0,0x00000000,true),
119 HOWTO(R_SPARC_OLO10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_OLO10", false,0,0x00000000,true),
120 HOWTO(R_SPARC_HH22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HH22", false,0,0x00000000,true),
121 HOWTO(R_SPARC_HM10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HM10", false,0,0x00000000,true),
122 HOWTO(R_SPARC_LM22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LM22", false,0,0x00000000,true),
123 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),
124 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),
125 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),
32090b8e 126#endif
19bfbcbe
ILT
127 HOWTO(R_SPARC_WDISP16, 2,2,16,true, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true),
128 HOWTO(R_SPARC_WDISP19, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true),
129 HOWTO(R_SPARC_GLOB_JMP, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GLOB_DAT",false,0,0x00000000,true),
130 HOWTO(R_SPARC_7, 0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", false,0,0x0000007f,true),
131 HOWTO(R_SPARC_5, 0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", false,0,0x0000001f,true),
132 HOWTO(R_SPARC_6, 0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", false,0,0x0000003f,true),
32090b8e
KR
133};
134
135struct elf_reloc_map {
136 unsigned char bfd_reloc_val;
137 unsigned char elf_reloc_val;
138};
139
140static CONST struct elf_reloc_map sparc_reloc_map[] =
141{
142 { BFD_RELOC_NONE, R_SPARC_NONE, },
143 { BFD_RELOC_16, R_SPARC_16, },
144 { BFD_RELOC_8, R_SPARC_8 },
145 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
19bfbcbe
ILT
146 /* ??? This might cause us to need separate functions in elf{32,64}-sparc.c
147 (we could still have just one table), but is this reloc ever used? */
32090b8e
KR
148 { BFD_RELOC_CTOR, R_SPARC_32 }, /* @@ Assumes 32 bits. */
149 { BFD_RELOC_32, R_SPARC_32 },
150 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
151 { BFD_RELOC_HI22, R_SPARC_HI22 },
152 { BFD_RELOC_LO10, R_SPARC_LO10, },
153 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
154 { BFD_RELOC_SPARC22, R_SPARC_22 },
155 { BFD_RELOC_SPARC13, R_SPARC_13 },
156 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
157 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
158 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
159 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
160 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
161 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
162 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
163 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
164 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
165 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
166 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
19bfbcbe 167 /* ??? Doesn't dwarf use this? */
4fbc96ad 168/*{ BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, not used?? */
19bfbcbe
ILT
169 {BFD_RELOC_SPARC_10, R_SPARC_10},
170 {BFD_RELOC_SPARC_11, R_SPARC_11},
171 {BFD_RELOC_SPARC_64, R_SPARC_64},
172 {BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10},
173 {BFD_RELOC_SPARC_HH22, R_SPARC_HH22},
174 {BFD_RELOC_SPARC_HM10, R_SPARC_HM10},
175 {BFD_RELOC_SPARC_LM22, R_SPARC_LM22},
176 {BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22},
177 {BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10},
178 {BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22},
179 {BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16},
180 {BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19},
181 {BFD_RELOC_SPARC_GLOB_JMP, R_SPARC_GLOB_JMP},
182 {BFD_RELOC_SPARC_7, R_SPARC_7},
183 {BFD_RELOC_SPARC_5, R_SPARC_5},
184 {BFD_RELOC_SPARC_6, R_SPARC_6},
32090b8e
KR
185};
186
f786a73f 187static reloc_howto_type *
19bfbcbe 188elf32_sparc_reloc_type_lookup (abfd, code)
013dec1a
ILT
189 bfd *abfd;
190 bfd_reloc_code_real_type code;
32090b8e 191{
3b3f7625 192 unsigned int i;
32090b8e
KR
193 for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
194 {
195 if (sparc_reloc_map[i].bfd_reloc_val == code)
19bfbcbe 196 return &_bfd_sparc_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
32090b8e
KR
197 }
198 return 0;
199}
200
19bfbcbe
ILT
201/* We need to use ELF32_R_TYPE so we have our own copy of this function,
202 and elf64-sparc.c has its own copy. */
203
32090b8e 204static void
013dec1a
ILT
205elf_info_to_howto (abfd, cache_ptr, dst)
206 bfd *abfd;
207 arelent *cache_ptr;
208 Elf_Internal_Rela *dst;
32090b8e
KR
209{
210 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max);
19bfbcbe 211 cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
32090b8e 212}
19bfbcbe
ILT
213\f
214/* For unsupported relocs. */
215
216static bfd_reloc_status_type
217sparc_elf_notsupported_reloc (abfd,
218 reloc_entry,
219 symbol,
220 data,
221 input_section,
222 output_bfd,
223 error_message)
224 bfd *abfd;
225 arelent *reloc_entry;
226 asymbol *symbol;
227 PTR data;
228 asection *input_section;
229 bfd *output_bfd;
230 char **error_message;
231{
232 return bfd_reloc_notsupported;
233}
234
235/* Handle the WDISP16 reloc. */
236
237static bfd_reloc_status_type
238sparc_elf_wdisp16_reloc (abfd,
239 reloc_entry,
240 symbol,
241 data,
242 input_section,
243 output_bfd,
244 error_message)
245 bfd *abfd;
246 arelent *reloc_entry;
247 asymbol *symbol;
248 PTR data;
249 asection *input_section;
250 bfd *output_bfd;
251 char **error_message;
252{
253 bfd_vma relocation;
254 bfd_vma x;
32090b8e 255
19bfbcbe
ILT
256 if (output_bfd != (bfd *) NULL
257 && (symbol->flags & BSF_SECTION_SYM) == 0
258 && (! reloc_entry->howto->partial_inplace
259 || reloc_entry->addend == 0))
260 {
261 reloc_entry->address += input_section->output_offset;
262 return bfd_reloc_ok;
263 }
264
265 if (output_bfd != NULL)
266 return bfd_reloc_continue;
267
268 if (reloc_entry->address > input_section->_cooked_size)
269 return bfd_reloc_outofrange;
270
271 relocation = (symbol->value
272 + symbol->section->output_section->vma
273 + symbol->section->output_offset);
274 relocation += reloc_entry->addend;
275 relocation -= (input_section->output_section->vma
276 + input_section->output_offset);
277 relocation -= reloc_entry->address;
278
279 x = bfd_get_32 (abfd, (char *) data + reloc_entry->address);
280 x |= ((((relocation >> 2) & 0xc000) << 6)
281 | ((relocation >> 2) & 0x3fff));
282 bfd_put_32 (abfd, x, (char *) data + reloc_entry->address);
283
284 if ((bfd_signed_vma) relocation < - 0x40000
285 || (bfd_signed_vma) relocation > 0x3ffff)
286 return bfd_reloc_overflow;
287 else
288 return bfd_reloc_ok;
289}
013dec1a
ILT
290\f
291/* Functions for the SPARC ELF linker. */
292
293/* The name of the dynamic interpreter. This is put in the .interp
294 section. */
295
296#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
297
298/* The nop opcode we use. */
299
300#define SPARC_NOP 0x01000000
301
302/* The size in bytes of an entry in the procedure linkage table. */
303
304#define PLT_ENTRY_SIZE 12
305
306/* The first four entries in a procedure linkage table are reserved,
307 and the initial contents are unimportant (we zero them out).
308 Subsequent entries look like this. See the SVR4 ABI SPARC
309 supplement to see how this works. */
310
311/* sethi %hi(.-.plt0),%g1. We fill in the address later. */
312#define PLT_ENTRY_WORD0 0x03000000
313/* b,a .plt0. We fill in the offset later. */
314#define PLT_ENTRY_WORD1 0x30800000
315/* nop. */
316#define PLT_ENTRY_WORD2 SPARC_NOP
317
4fbc96ad
KR
318/* Look through the relocs for a section during the first phase, and
319 allocate space in the global offset table or procedure linkage
320 table. */
321
322static boolean
323elf32_sparc_check_relocs (abfd, info, sec, relocs)
324 bfd *abfd;
325 struct bfd_link_info *info;
326 asection *sec;
327 const Elf_Internal_Rela *relocs;
328{
329 bfd *dynobj;
330 Elf_Internal_Shdr *symtab_hdr;
331 struct elf_link_hash_entry **sym_hashes;
332 bfd_vma *local_got_offsets;
333 const Elf_Internal_Rela *rel;
334 const Elf_Internal_Rela *rel_end;
335 asection *sgot;
336 asection *srelgot;
4fbc96ad
KR
337 asection *sreloc;
338
339 if (info->relocateable)
340 return true;
341
342 dynobj = elf_hash_table (info)->dynobj;
343 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
344 sym_hashes = elf_sym_hashes (abfd);
345 local_got_offsets = elf_local_got_offsets (abfd);
346
347 sgot = NULL;
348 srelgot = NULL;
4fbc96ad
KR
349 sreloc = NULL;
350
351 rel_end = relocs + sec->reloc_count;
352 for (rel = relocs; rel < rel_end; rel++)
353 {
3b3f7625 354 unsigned long r_symndx;
4fbc96ad
KR
355 struct elf_link_hash_entry *h;
356
357 r_symndx = ELF32_R_SYM (rel->r_info);
358 if (r_symndx < symtab_hdr->sh_info)
359 h = NULL;
360 else
361 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
362
4fbc96ad
KR
363 switch (ELF32_R_TYPE (rel->r_info))
364 {
365 case R_SPARC_GOT10:
366 case R_SPARC_GOT13:
367 case R_SPARC_GOT22:
368 /* This symbol requires a global offset table entry. */
369
12662be4
ILT
370 if (dynobj == NULL)
371 {
372 /* Create the .got section. */
373 elf_hash_table (info)->dynobj = dynobj = abfd;
ede4eed4 374 if (! _bfd_elf_create_got_section (dynobj, info))
12662be4
ILT
375 return false;
376 }
377
4fbc96ad
KR
378 if (sgot == NULL)
379 {
380 sgot = bfd_get_section_by_name (dynobj, ".got");
12662be4
ILT
381 BFD_ASSERT (sgot != NULL);
382 }
383
384 if (srelgot == NULL
385 && (h != NULL || info->shared))
386 {
4fbc96ad
KR
387 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
388 if (srelgot == NULL)
389 {
390 srelgot = bfd_make_section (dynobj, ".rela.got");
391 if (srelgot == NULL
392 || ! bfd_set_section_flags (dynobj, srelgot,
393 (SEC_ALLOC
394 | SEC_LOAD
395 | SEC_HAS_CONTENTS
396 | SEC_IN_MEMORY
12662be4
ILT
397 | SEC_READONLY))
398 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
4fbc96ad
KR
399 return false;
400 }
4fbc96ad
KR
401 }
402
403 if (h != NULL)
404 {
405 if (h->got_offset != (bfd_vma) -1)
406 {
407 /* We have already allocated space in the .got. */
408 break;
409 }
410 h->got_offset = sgot->_raw_size;
12662be4
ILT
411
412 /* Make sure this symbol is output as a dynamic symbol. */
413 if (h->dynindx == -1)
414 {
415 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
416 return false;
417 }
418
419 srelgot->_raw_size += sizeof (Elf32_External_Rela);
4fbc96ad
KR
420 }
421 else
422 {
423 /* This is a global offset table entry for a local
424 symbol. */
425 if (local_got_offsets == NULL)
426 {
427 size_t size;
3b3f7625 428 register unsigned int i;
4fbc96ad
KR
429
430 size = symtab_hdr->sh_info * sizeof (bfd_vma);
431 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
432 if (local_got_offsets == NULL)
a9713b91 433 return false;
4fbc96ad
KR
434 elf_local_got_offsets (abfd) = local_got_offsets;
435 for (i = 0; i < symtab_hdr->sh_info; i++)
436 local_got_offsets[i] = (bfd_vma) -1;
437 }
438 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
439 {
440 /* We have already allocated space in the .got. */
441 break;
442 }
443 local_got_offsets[r_symndx] = sgot->_raw_size;
12662be4
ILT
444
445 if (info->shared)
446 {
447 /* If we are generating a shared object, we need to
448 output a R_SPARC_RELATIVE reloc so that the
449 dynamic linker can adjust this GOT entry. */
450 srelgot->_raw_size += sizeof (Elf32_External_Rela);
451 }
4fbc96ad
KR
452 }
453
454 sgot->_raw_size += 4;
4fbc96ad 455
19bfbcbe
ILT
456 /* If the .got section is more than 0x1000 bytes, we add
457 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
458 bit relocations have a greater chance of working. */
459 if (sgot->_raw_size >= 0x1000
460 && elf_hash_table (info)->hgot->root.u.def.value == 0)
461 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
462
4fbc96ad
KR
463 break;
464
465 case R_SPARC_WPLT30:
12662be4
ILT
466 /* This symbol requires a procedure linkage table entry. We
467 actually build the entry in adjust_dynamic_symbol,
468 because this might be a case of linking PIC code without
469 linking in any dynamic objects, in which case we don't
470 need to generate a procedure linkage table after all. */
4fbc96ad
KR
471
472 if (h == NULL)
473 {
474 /* It does not make sense to have a procedure linkage
475 table entry for a local symbol. */
476 bfd_set_error (bfd_error_bad_value);
477 return false;
478 }
479
12662be4
ILT
480 /* Make sure this symbol is output as a dynamic symbol. */
481 if (h->dynindx == -1)
4fbc96ad 482 {
12662be4
ILT
483 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
484 return false;
4fbc96ad
KR
485 }
486
12662be4 487 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
4fbc96ad
KR
488
489 break;
490
491 case R_SPARC_PC10:
492 case R_SPARC_PC22:
493 if (h != NULL
494 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
495 break;
496 /* Fall through. */
4fbc96ad
KR
497 case R_SPARC_DISP8:
498 case R_SPARC_DISP16:
499 case R_SPARC_DISP32:
500 case R_SPARC_WDISP30:
501 case R_SPARC_WDISP22:
19bfbcbe
ILT
502 case R_SPARC_WDISP19:
503 case R_SPARC_WDISP16:
3b3f7625
ILT
504 if (h == NULL)
505 break;
506 /* Fall through. */
507 case R_SPARC_8:
508 case R_SPARC_16:
509 case R_SPARC_32:
4fbc96ad
KR
510 case R_SPARC_HI22:
511 case R_SPARC_22:
512 case R_SPARC_13:
513 case R_SPARC_LO10:
514 case R_SPARC_UA32:
515 if (info->shared
516 && (sec->flags & SEC_ALLOC) != 0)
517 {
518 /* When creating a shared object, we must copy these
519 relocs into the output file. We create a reloc
520 section in dynobj and make room for the reloc. */
521 if (sreloc == NULL)
522 {
523 const char *name;
524
ede4eed4 525 name = (bfd_elf_string_from_elf_section
4fbc96ad
KR
526 (abfd,
527 elf_elfheader (abfd)->e_shstrndx,
528 elf_section_data (sec)->rel_hdr.sh_name));
529 if (name == NULL)
530 return false;
531
532 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
533 && strcmp (bfd_get_section_name (abfd, sec),
534 name + 5) == 0);
535
536 sreloc = bfd_get_section_by_name (dynobj, name);
537 if (sreloc == NULL)
538 {
539 sreloc = bfd_make_section (dynobj, name);
540 if (sreloc == NULL
541 || ! bfd_set_section_flags (dynobj, sreloc,
542 (SEC_ALLOC
543 | SEC_LOAD
544 | SEC_HAS_CONTENTS
545 | SEC_IN_MEMORY
546 | SEC_READONLY))
547 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
548 return false;
549 }
550 }
551
552 sreloc->_raw_size += sizeof (Elf32_External_Rela);
553 }
554
555 break;
556
557 default:
558 break;
559 }
560 }
013dec1a
ILT
561
562 return true;
563}
564
565/* Adjust a symbol defined by a dynamic object and referenced by a
566 regular object. The current definition is in some section of the
567 dynamic object, but we're not including those sections. We have to
568 change the definition to something the rest of the link can
569 understand. */
570
571static boolean
572elf32_sparc_adjust_dynamic_symbol (info, h)
573 struct bfd_link_info *info;
574 struct elf_link_hash_entry *h;
575{
576 bfd *dynobj;
577 asection *s;
578 unsigned int power_of_two;
013dec1a
ILT
579
580 dynobj = elf_hash_table (info)->dynobj;
581
582 /* Make sure we know what is going on here. */
3004a68c
ILT
583 BFD_ASSERT (dynobj != NULL
584 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
3b3f7625 585 || h->weakdef != NULL
3004a68c
ILT
586 || ((h->elf_link_hash_flags
587 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
588 && (h->elf_link_hash_flags
589 & ELF_LINK_HASH_REF_REGULAR) != 0
590 && (h->elf_link_hash_flags
591 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
013dec1a
ILT
592
593 /* If this is a function, put it in the procedure linkage table. We
594 will fill in the contents of the procedure linkage table later
595 (although we could actually do it here). */
12662be4
ILT
596 if (h->type == STT_FUNC
597 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
013dec1a 598 {
12662be4 599 if (! elf_hash_table (info)->dynamic_sections_created)
013dec1a 600 {
12662be4
ILT
601 /* This case can occur if we saw a WPLT30 reloc in an input
602 file, but none of the input files were dynamic objects.
603 In such a case, we don't actually need to build a
604 procedure linkage table, and we can just do a WDISP30
605 reloc instead. */
606 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
607 return true;
608 }
4fbc96ad 609
12662be4
ILT
610 s = bfd_get_section_by_name (dynobj, ".plt");
611 BFD_ASSERT (s != NULL);
013dec1a 612
12662be4
ILT
613 /* The first four entries in .plt are reserved. */
614 if (s->_raw_size == 0)
615 s->_raw_size = 4 * PLT_ENTRY_SIZE;
013dec1a 616
12662be4
ILT
617 /* The procedure linkage table has a maximum size. */
618 if (s->_raw_size >= 0x400000)
619 {
620 bfd_set_error (bfd_error_bad_value);
621 return false;
622 }
013dec1a 623
9b09a015
ILT
624 /* If this symbol is not defined in a regular file, and we are
625 not generating a shared library, then set the symbol to this
626 location in the .plt. This is required to make function
627 pointers compare as equal between the normal executable and
628 the shared library. */
629 if (! info->shared
630 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
14cac507
ILT
631 {
632 h->root.u.def.section = s;
633 h->root.u.def.value = s->_raw_size;
634 }
013dec1a 635
12662be4 636 h->plt_offset = s->_raw_size;
4fbc96ad 637
12662be4
ILT
638 /* Make room for this entry. */
639 s->_raw_size += PLT_ENTRY_SIZE;
640
641 /* We also need to make an entry in the .rela.plt section. */
642
643 s = bfd_get_section_by_name (dynobj, ".rela.plt");
644 BFD_ASSERT (s != NULL);
645 s->_raw_size += sizeof (Elf32_External_Rela);
013dec1a
ILT
646
647 return true;
648 }
649
650 /* If this is a weak symbol, and there is a real definition, the
651 processor independent code will have arranged for us to see the
652 real definition first, and we can just use the same value. */
653 if (h->weakdef != NULL)
654 {
f786a73f
ILT
655 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
656 || h->weakdef->root.type == bfd_link_hash_defweak);
013dec1a
ILT
657 h->root.u.def.section = h->weakdef->root.u.def.section;
658 h->root.u.def.value = h->weakdef->root.u.def.value;
013dec1a
ILT
659 return true;
660 }
661
662 /* This is a reference to a symbol defined by a dynamic object which
4fbc96ad
KR
663 is not a function. */
664
665 /* If we are creating a shared library, we must presume that the
666 only references to the symbol are via the global offset table.
667 For such cases we need not do anything here; the relocations will
668 be handled correctly by relocate_section. */
669 if (info->shared)
670 return true;
671
672 /* We must allocate the symbol in our .dynbss section, which will
673 become part of the .bss section of the executable. There will be
674 an entry for this symbol in the .dynsym section. The dynamic
675 object will contain position independent code, so all references
676 from the dynamic object to this symbol will go through the global
677 offset table. The dynamic linker will use the .dynsym entry to
678 determine the address it must put in the global offset table, so
679 both the dynamic object and the regular object will refer to the
680 same memory location for the variable. */
013dec1a
ILT
681
682 s = bfd_get_section_by_name (dynobj, ".dynbss");
683 BFD_ASSERT (s != NULL);
684
685 /* If the symbol is currently defined in the .bss section of the
686 dynamic object, then it is OK to simply initialize it to zero.
687 If the symbol is in some other section, we must generate a
688 R_SPARC_COPY reloc to tell the dynamic linker to copy the initial
689 value out of the dynamic object and into the runtime process
690 image. We need to remember the offset into the .rel.bss section
7c6da9ca 691 we are going to use. */
4fbc96ad 692 if ((h->root.u.def.section->flags & SEC_LOAD) != 0)
013dec1a
ILT
693 {
694 asection *srel;
695
696 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
697 BFD_ASSERT (srel != NULL);
013dec1a 698 srel->_raw_size += sizeof (Elf32_External_Rela);
4fbc96ad 699 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
013dec1a
ILT
700 }
701
702 /* We need to figure out the alignment required for this symbol. I
703 have no idea how ELF linkers handle this. */
7c6da9ca
ILT
704 power_of_two = bfd_log2 (h->size);
705 if (power_of_two > 3)
706 power_of_two = 3;
013dec1a
ILT
707
708 /* Apply the required alignment. */
7c6da9ca
ILT
709 s->_raw_size = BFD_ALIGN (s->_raw_size,
710 (bfd_size_type) (1 << power_of_two));
013dec1a
ILT
711 if (power_of_two > bfd_get_section_alignment (dynobj, s))
712 {
713 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
714 return false;
715 }
716
717 /* Define the symbol as being at this point in the section. */
718 h->root.u.def.section = s;
719 h->root.u.def.value = s->_raw_size;
720
721 /* Increment the section size to make room for the symbol. */
722 s->_raw_size += h->size;
723
724 return true;
725}
726
013dec1a
ILT
727/* Set the sizes of the dynamic sections. */
728
729static boolean
730elf32_sparc_size_dynamic_sections (output_bfd, info)
731 bfd *output_bfd;
732 struct bfd_link_info *info;
733{
734 bfd *dynobj;
735 asection *s;
4fbc96ad 736 boolean reltext;
f786a73f 737 boolean relplt;
013dec1a
ILT
738
739 dynobj = elf_hash_table (info)->dynobj;
740 BFD_ASSERT (dynobj != NULL);
741
12662be4 742 if (elf_hash_table (info)->dynamic_sections_created)
8af74670 743 {
12662be4
ILT
744 /* Set the contents of the .interp section to the interpreter. */
745 if (! info->shared)
746 {
747 s = bfd_get_section_by_name (dynobj, ".interp");
748 BFD_ASSERT (s != NULL);
749 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
750 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
751 }
752
753 /* Make space for the trailing nop in .plt. */
754 s = bfd_get_section_by_name (dynobj, ".plt");
8af74670 755 BFD_ASSERT (s != NULL);
12662be4
ILT
756 if (s->_raw_size > 0)
757 s->_raw_size += 4;
758 }
759 else
760 {
761 /* We may have created entries in the .rela.got section.
762 However, if we are not creating the dynamic sections, we will
763 not actually use these entries. Reset the size of .rela.got,
764 which will cause it to get stripped from the output file
765 below. */
766 s = bfd_get_section_by_name (dynobj, ".rela.got");
767 if (s != NULL)
768 s->_raw_size = 0;
8af74670 769 }
013dec1a 770
4fbc96ad
KR
771 /* The check_relocs and adjust_dynamic_symbol entry points have
772 determined the sizes of the various dynamic sections. Allocate
773 memory for them. */
774 reltext = false;
f786a73f 775 relplt = false;
4fbc96ad
KR
776 for (s = dynobj->sections; s != NULL; s = s->next)
777 {
778 const char *name;
12662be4 779 boolean strip;
4fbc96ad
KR
780
781 if ((s->flags & SEC_IN_MEMORY) == 0)
782 continue;
783
784 /* It's OK to base decisions on the section name, because none
785 of the dynobj section names depend upon the input files. */
786 name = bfd_get_section_name (dynobj, s);
787
12662be4
ILT
788 strip = false;
789
790 if (strncmp (name, ".rela", 5) == 0)
4fbc96ad 791 {
12662be4
ILT
792 if (s->_raw_size == 0)
793 {
794 /* If we don't need this section, strip it from the
795 output file. This is to handle .rela.bss and
796 .rel.plt. We must create it in
797 create_dynamic_sections, because it must be created
798 before the linker maps input sections to output
799 sections. The linker does that before
800 adjust_dynamic_symbol is called, and it is that
801 function which decides whether anything needs to go
802 into these sections. */
803 strip = true;
804 }
805 else
806 {
807 asection *target;
808
809 /* If this relocation section applies to a read only
810 section, then we probably need a DT_TEXTREL entry. */
811 target = bfd_get_section_by_name (output_bfd, name + 5);
812 if (target != NULL
813 && (target->flags & SEC_READONLY) != 0)
814 reltext = true;
815
f786a73f
ILT
816 if (strcmp (name, ".rela.plt") == 0)
817 relplt = true;
818
12662be4
ILT
819 /* We use the reloc_count field as a counter if we need
820 to copy relocs into the output file. */
821 s->reloc_count = 0;
822 }
4fbc96ad
KR
823 }
824 else if (strcmp (name, ".plt") != 0
825 && strcmp (name, ".got") != 0)
826 {
827 /* It's not one of our sections, so don't allocate space. */
828 continue;
829 }
12662be4
ILT
830
831 if (strip)
832 {
833 asection **spp;
834
835 for (spp = &s->output_section->owner->sections;
836 *spp != s->output_section;
837 spp = &(*spp)->next)
838 ;
839 *spp = s->output_section->next;
840 --s->output_section->owner->section_count;
841
842 continue;
843 }
844
4fbc96ad
KR
845 /* Allocate memory for the section contents. */
846 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
847 if (s->contents == NULL && s->_raw_size != 0)
a9713b91 848 return false;
4fbc96ad 849 }
013dec1a 850
12662be4 851 if (elf_hash_table (info)->dynamic_sections_created)
4fbc96ad 852 {
12662be4
ILT
853 /* Add some entries to the .dynamic section. We fill in the
854 values later, in elf32_sparc_finish_dynamic_sections, but we
855 must add the entries now so that we get the correct size for
856 the .dynamic section. The DT_DEBUG entry is filled in by the
857 dynamic linker and used by the debugger. */
858 if (! info->shared)
859 {
860 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
861 return false;
862 }
013dec1a 863
f786a73f
ILT
864 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0))
865 return false;
866
867 if (relplt)
868 {
869 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
870 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
871 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
872 return false;
873 }
874
875 if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
12662be4
ILT
876 || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
877 || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
878 sizeof (Elf32_External_Rela)))
4fbc96ad 879 return false;
12662be4
ILT
880
881 if (reltext)
882 {
883 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
884 return false;
885 }
4fbc96ad
KR
886 }
887
14cac507
ILT
888 /* If we are generating a shared library, we generate a section
889 symbol for each output section. These are local symbols, which
890 means that they must come first in the dynamic symbol table.
891 That means we must increment the dynamic symbol index of every
892 other dynamic symbol. */
893 if (info->shared)
894 {
895 int c, i;
896
897 c = bfd_count_sections (output_bfd);
898 elf_link_hash_traverse (elf_hash_table (info),
899 elf32_sparc_adjust_dynindx,
900 (PTR) &c);
901 elf_hash_table (info)->dynsymcount += c;
902
903 for (i = 1, s = output_bfd->sections; s != NULL; s = s->next, i++)
904 {
905 elf_section_data (s)->dynindx = i;
906 /* These symbols will have no names, so we don't need to
907 fiddle with dynstr_index. */
908 }
909 }
910
911 return true;
912}
913
914/* Increment the index of a dynamic symbol by a given amount. Called
915 via elf_link_hash_traverse. */
916
917static boolean
918elf32_sparc_adjust_dynindx (h, cparg)
919 struct elf_link_hash_entry *h;
920 PTR cparg;
921{
922 int *cp = (int *) cparg;
923
924 if (h->dynindx != -1)
925 h->dynindx += *cp;
013dec1a
ILT
926 return true;
927}
928
929/* Relocate a SPARC ELF section. */
930
931static boolean
932elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
12662be4 933 contents, relocs, local_syms, local_sections)
013dec1a
ILT
934 bfd *output_bfd;
935 struct bfd_link_info *info;
936 bfd *input_bfd;
937 asection *input_section;
938 bfd_byte *contents;
939 Elf_Internal_Rela *relocs;
940 Elf_Internal_Sym *local_syms;
941 asection **local_sections;
942{
4fbc96ad 943 bfd *dynobj;
013dec1a
ILT
944 Elf_Internal_Shdr *symtab_hdr;
945 struct elf_link_hash_entry **sym_hashes;
4fbc96ad 946 bfd_vma *local_got_offsets;
19bfbcbe 947 bfd_vma got_base;
4fbc96ad
KR
948 asection *sgot;
949 asection *splt;
950 asection *sreloc;
013dec1a
ILT
951 Elf_Internal_Rela *rel;
952 Elf_Internal_Rela *relend;
953
4fbc96ad 954 dynobj = elf_hash_table (info)->dynobj;
013dec1a
ILT
955 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
956 sym_hashes = elf_sym_hashes (input_bfd);
4fbc96ad
KR
957 local_got_offsets = elf_local_got_offsets (input_bfd);
958
19bfbcbe
ILT
959 if (elf_hash_table (info)->hgot == NULL)
960 got_base = 0;
961 else
962 got_base = elf_hash_table (info)->hgot->root.u.def.value;
963
4fbc96ad
KR
964 sgot = NULL;
965 splt = NULL;
966 sreloc = NULL;
013dec1a
ILT
967
968 rel = relocs;
969 relend = relocs + input_section->reloc_count;
970 for (; rel < relend; rel++)
971 {
972 int r_type;
82b1edf7 973 reloc_howto_type *howto;
3b3f7625 974 unsigned long r_symndx;
013dec1a
ILT
975 struct elf_link_hash_entry *h;
976 Elf_Internal_Sym *sym;
977 asection *sec;
978 bfd_vma relocation;
979 bfd_reloc_status_type r;
980
981 r_type = ELF32_R_TYPE (rel->r_info);
982 if (r_type < 0 || r_type >= (int) R_SPARC_max)
983 {
984 bfd_set_error (bfd_error_bad_value);
985 return false;
986 }
19bfbcbe 987 howto = _bfd_sparc_elf_howto_table + r_type;
013dec1a
ILT
988
989 r_symndx = ELF32_R_SYM (rel->r_info);
990
991 if (info->relocateable)
992 {
993 /* This is a relocateable link. We don't have to change
994 anything, unless the reloc is against a section symbol,
995 in which case we have to adjust according to where the
996 section symbol winds up in the output section. */
997 if (r_symndx < symtab_hdr->sh_info)
998 {
999 sym = local_syms + r_symndx;
1000 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1001 {
1002 sec = local_sections[r_symndx];
1003 rel->r_addend += sec->output_offset + sym->st_value;
1004 }
1005 }
1006
1007 continue;
1008 }
1009
1010 /* This is a final link. */
1011 h = NULL;
1012 sym = NULL;
1013 sec = NULL;
1014 if (r_symndx < symtab_hdr->sh_info)
1015 {
1016 sym = local_syms + r_symndx;
1017 sec = local_sections[r_symndx];
1018 relocation = (sec->output_section->vma
1019 + sec->output_offset
1020 + sym->st_value);
1021 }
1022 else
1023 {
4fbc96ad 1024 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
19bfbcbe
ILT
1025 while (h->root.type == bfd_link_hash_indirect
1026 || h->root.type == bfd_link_hash_warning)
1027 h = (struct elf_link_hash_entry *) h->root.u.i.link;
f786a73f
ILT
1028 if (h->root.type == bfd_link_hash_defined
1029 || h->root.type == bfd_link_hash_defweak)
013dec1a
ILT
1030 {
1031 sec = h->root.u.def.section;
9b09a015
ILT
1032 if ((r_type == R_SPARC_WPLT30
1033 && h->plt_offset != (bfd_vma) -1)
1034 || ((r_type == R_SPARC_GOT10
1035 || r_type == R_SPARC_GOT13
1036 || r_type == R_SPARC_GOT22)
3b3f7625
ILT
1037 && elf_hash_table (info)->dynamic_sections_created
1038 && (! info->shared
1039 || ! info->symbolic
1040 || (h->elf_link_hash_flags
1041 & ELF_LINK_HASH_DEF_REGULAR) == 0))
9b09a015 1042 || (info->shared
53787b23
ILT
1043 && (! info->symbolic
1044 || (h->elf_link_hash_flags
1045 & ELF_LINK_HASH_DEF_REGULAR) == 0)
9b09a015
ILT
1046 && (input_section->flags & SEC_ALLOC) != 0
1047 && (r_type == R_SPARC_8
1048 || r_type == R_SPARC_16
1049 || r_type == R_SPARC_32
1050 || r_type == R_SPARC_DISP8
1051 || r_type == R_SPARC_DISP16
1052 || r_type == R_SPARC_DISP32
1053 || r_type == R_SPARC_WDISP30
1054 || r_type == R_SPARC_WDISP22
19bfbcbe
ILT
1055 || r_type == R_SPARC_WDISP19
1056 || r_type == R_SPARC_WDISP16
9b09a015
ILT
1057 || r_type == R_SPARC_HI22
1058 || r_type == R_SPARC_22
1059 || r_type == R_SPARC_13
1060 || r_type == R_SPARC_LO10
1061 || r_type == R_SPARC_UA32
1062 || ((r_type == R_SPARC_PC10
1063 || r_type == R_SPARC_PC22)
1064 && strcmp (h->root.root.string,
1065 "_GLOBAL_OFFSET_TABLE_") != 0))))
1066 {
1067 /* In these cases, we don't need the relocation
1068 value. We check specially because in some
1069 obscure cases sec->output_section will be NULL. */
1070 relocation = 0;
1071 }
1072 else
1073 relocation = (h->root.u.def.value
1074 + sec->output_section->vma
1075 + sec->output_offset);
013dec1a 1076 }
f786a73f 1077 else if (h->root.type == bfd_link_hash_undefweak)
013dec1a 1078 relocation = 0;
3b3f7625 1079 else if (info->shared && !info->symbolic)
4fbc96ad 1080 relocation = 0;
013dec1a
ILT
1081 else
1082 {
1083 if (! ((*info->callbacks->undefined_symbol)
1084 (info, h->root.root.string, input_bfd,
1085 input_section, rel->r_offset)))
1086 return false;
1087 relocation = 0;
1088 }
1089 }
1090
4fbc96ad
KR
1091 switch (r_type)
1092 {
1093 case R_SPARC_GOT10:
1094 case R_SPARC_GOT13:
1095 case R_SPARC_GOT22:
1096 /* Relocation is to the entry for this symbol in the global
1097 offset table. */
1098 if (sgot == NULL)
1099 {
1100 sgot = bfd_get_section_by_name (dynobj, ".got");
1101 BFD_ASSERT (sgot != NULL);
1102 }
1103
1104 if (h != NULL)
1105 {
12662be4
ILT
1106 bfd_vma off;
1107
1108 off = h->got_offset;
1109 BFD_ASSERT (off != (bfd_vma) -1);
1110
3b3f7625
ILT
1111 if (! elf_hash_table (info)->dynamic_sections_created
1112 || (info->shared
1113 && info->symbolic
1114 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
12662be4 1115 {
3b3f7625
ILT
1116 /* This is actually a static link, or it is a
1117 -Bsymbolic link and the symbol is defined
1118 locally. We must initialize this entry in the
1119 global offset table. Since the offset must
1120 always be a multiple of 4, we use the least
1121 significant bit to record whether we have
1122 initialized it already.
12662be4
ILT
1123
1124 When doing a dynamic link, we create a .rela.got
1125 relocation entry to initialize the value. This
1126 is done in the finish_dynamic_symbol routine. */
1127 if ((off & 1) != 0)
1128 off &= ~1;
1129 else
1130 {
1131 bfd_put_32 (output_bfd, relocation,
1132 sgot->contents + off);
1133 h->got_offset |= 1;
1134 }
1135 }
1136
19bfbcbe 1137 relocation = sgot->output_offset + off - got_base;
4fbc96ad
KR
1138 }
1139 else
1140 {
1141 bfd_vma off;
1142
1143 BFD_ASSERT (local_got_offsets != NULL
1144 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1145
1146 off = local_got_offsets[r_symndx];
1147
1148 /* The offset must always be a multiple of 4. We use
12662be4
ILT
1149 the least significant bit to record whether we have
1150 already processed this entry. */
4fbc96ad
KR
1151 if ((off & 1) != 0)
1152 off &= ~1;
1153 else
1154 {
4fbc96ad
KR
1155 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1156
12662be4
ILT
1157 if (info->shared)
1158 {
1159 asection *srelgot;
1160 Elf_Internal_Rela outrel;
1161
1162 /* We need to generate a R_SPARC_RELATIVE reloc
1163 for the dynamic linker. */
1164 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1165 BFD_ASSERT (srelgot != NULL);
1166
1167 outrel.r_offset = (sgot->output_section->vma
1168 + sgot->output_offset
1169 + off);
1170 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1171 outrel.r_addend = 0;
1172 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1173 (((Elf32_External_Rela *)
1174 srelgot->contents)
1175 + srelgot->reloc_count));
1176 ++srelgot->reloc_count;
1177 }
4fbc96ad
KR
1178
1179 local_got_offsets[r_symndx] |= 1;
1180 }
1181
19bfbcbe 1182 relocation = sgot->output_offset + off - got_base;
4fbc96ad
KR
1183 }
1184
1185 break;
1186
1187 case R_SPARC_WPLT30:
1188 /* Relocation is to the entry for this symbol in the
1189 procedure linkage table. */
12662be4
ILT
1190 BFD_ASSERT (h != NULL);
1191
1192 if (h->plt_offset == (bfd_vma) -1)
1193 {
1194 /* We didn't make a PLT entry for this symbol. This
3b3f7625
ILT
1195 happens when statically linking PIC code, or when
1196 using -Bsymbolic. */
12662be4
ILT
1197 break;
1198 }
1199
4fbc96ad
KR
1200 if (splt == NULL)
1201 {
1202 splt = bfd_get_section_by_name (dynobj, ".plt");
1203 BFD_ASSERT (splt != NULL);
1204 }
1205
4fbc96ad
KR
1206 relocation = (splt->output_section->vma
1207 + splt->output_offset
1208 + h->plt_offset);
1209 break;
1210
1211 case R_SPARC_PC10:
1212 case R_SPARC_PC22:
1213 if (h != NULL
1214 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1215 break;
1216 /* Fall through. */
4fbc96ad
KR
1217 case R_SPARC_DISP8:
1218 case R_SPARC_DISP16:
1219 case R_SPARC_DISP32:
1220 case R_SPARC_WDISP30:
1221 case R_SPARC_WDISP22:
19bfbcbe
ILT
1222 case R_SPARC_WDISP19:
1223 case R_SPARC_WDISP16:
3b3f7625
ILT
1224 if (h == NULL)
1225 break;
1226 /* Fall through. */
1227 case R_SPARC_8:
1228 case R_SPARC_16:
1229 case R_SPARC_32:
4fbc96ad
KR
1230 case R_SPARC_HI22:
1231 case R_SPARC_22:
1232 case R_SPARC_13:
1233 case R_SPARC_LO10:
1234 case R_SPARC_UA32:
1235 if (info->shared
1236 && (input_section->flags & SEC_ALLOC) != 0)
1237 {
1238 Elf_Internal_Rela outrel;
1239
1240 /* When generating a shared object, these relocations
1241 are copied into the output file to be resolved at run
1242 time. */
1243
1244 if (sreloc == NULL)
1245 {
1246 const char *name;
1247
ede4eed4 1248 name = (bfd_elf_string_from_elf_section
4fbc96ad
KR
1249 (input_bfd,
1250 elf_elfheader (input_bfd)->e_shstrndx,
1251 elf_section_data (input_section)->rel_hdr.sh_name));
1252 if (name == NULL)
1253 return false;
1254
1255 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1256 && strcmp (bfd_get_section_name (input_bfd,
1257 input_section),
1258 name + 5) == 0);
1259
1260 sreloc = bfd_get_section_by_name (dynobj, name);
1261 BFD_ASSERT (sreloc != NULL);
1262 }
1263
1264 outrel.r_offset = (rel->r_offset
1265 + input_section->output_section->vma
1266 + input_section->output_offset);
53787b23
ILT
1267 if (h != NULL
1268 && (! info->symbolic
1269 || (h->elf_link_hash_flags
1270 & ELF_LINK_HASH_DEF_REGULAR) == 0))
4fbc96ad 1271 {
12662be4 1272 BFD_ASSERT (h->dynindx != -1);
4fbc96ad 1273 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
14cac507 1274 outrel.r_addend = rel->r_addend;
4fbc96ad
KR
1275 }
1276 else
1277 {
14cac507 1278 if (r_type == R_SPARC_32)
4fbc96ad 1279 {
14cac507
ILT
1280 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1281 outrel.r_addend = relocation + rel->r_addend;
4fbc96ad
KR
1282 }
1283 else
1284 {
14cac507
ILT
1285 long indx;
1286
53787b23
ILT
1287 if (h == NULL)
1288 sec = local_sections[r_symndx];
1289 else
1290 {
1291 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1292 || (h->root.type
1293 == bfd_link_hash_defweak));
1294 sec = h->root.u.def.section;
1295 }
14cac507
ILT
1296 if (sec != NULL && bfd_is_abs_section (sec))
1297 indx = 0;
1298 else if (sec == NULL || sec->owner == NULL)
1299 {
1300 bfd_set_error (bfd_error_bad_value);
1301 return false;
1302 }
1303 else
1304 {
1305 asection *osec;
1306
1307 osec = sec->output_section;
1308 indx = elf_section_data (osec)->dynindx;
1309 if (indx == 0)
1310 abort ();
1311 }
1312
1313 outrel.r_info = ELF32_R_INFO (indx, r_type);
1314 outrel.r_addend = relocation + rel->r_addend;
4fbc96ad 1315 }
4fbc96ad
KR
1316 }
1317
1318 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1319 (((Elf32_External_Rela *)
1320 sreloc->contents)
1321 + sreloc->reloc_count));
1322 ++sreloc->reloc_count;
1323
1324 /* This reloc will be computed at runtime, so there's no
1325 need to do anything now. */
1326 continue;
1327 }
1328
1329 default:
1330 break;
1331 }
1332
19bfbcbe
ILT
1333 if (r_type != R_SPARC_WDISP16)
1334 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1335 contents, rel->r_offset,
1336 relocation, rel->r_addend);
1337 else
1338 {
1339 bfd_vma x;
1340
1341 relocation += rel->r_addend;
1342 relocation -= (input_section->output_section->vma
1343 + input_section->output_offset);
1344 relocation -= rel->r_offset;
1345
1346 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
1347 x |= ((((relocation >> 2) & 0xc000) << 6)
1348 | ((relocation >> 2) & 0x3fff));
1349 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
1350
1351 if ((bfd_signed_vma) relocation < - 0x40000
1352 || (bfd_signed_vma) relocation > 0x3ffff)
1353 r = bfd_reloc_overflow;
1354 else
1355 r = bfd_reloc_ok;
1356 }
013dec1a
ILT
1357
1358 if (r != bfd_reloc_ok)
1359 {
1360 switch (r)
1361 {
1362 default:
1363 case bfd_reloc_outofrange:
1364 abort ();
1365 case bfd_reloc_overflow:
1366 {
1367 const char *name;
1368
1369 if (h != NULL)
1370 name = h->root.root.string;
1371 else
1372 {
ede4eed4
KR
1373 name = bfd_elf_string_from_elf_section (input_bfd,
1374 symtab_hdr->sh_link,
1375 sym->st_name);
013dec1a
ILT
1376 if (name == NULL)
1377 return false;
1378 if (*name == '\0')
1379 name = bfd_section_name (input_bfd, sec);
1380 }
1381 if (! ((*info->callbacks->reloc_overflow)
1382 (info, name, howto->name, (bfd_vma) 0,
1383 input_bfd, input_section, rel->r_offset)))
1384 return false;
1385 }
1386 break;
1387 }
1388 }
1389 }
1390
1391 return true;
1392}
1393
1394/* Finish up dynamic symbol handling. We set the contents of various
1395 dynamic sections here. */
1396
1397static boolean
1398elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
1399 bfd *output_bfd;
1400 struct bfd_link_info *info;
1401 struct elf_link_hash_entry *h;
1402 Elf_Internal_Sym *sym;
1403{
4fbc96ad 1404 bfd *dynobj;
013dec1a 1405
4fbc96ad 1406 dynobj = elf_hash_table (info)->dynobj;
013dec1a 1407
4fbc96ad 1408 if (h->plt_offset != (bfd_vma) -1)
013dec1a
ILT
1409 {
1410 asection *splt;
1411 asection *srela;
1412 Elf_Internal_Rela rela;
1413
4fbc96ad
KR
1414 /* This symbol has an entry in the procedure linkage table. Set
1415 it up. */
1416
1417 BFD_ASSERT (h->dynindx != -1);
1418
1419 splt = bfd_get_section_by_name (dynobj, ".plt");
1420 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1421 BFD_ASSERT (splt != NULL && srela != NULL);
013dec1a
ILT
1422
1423 /* Fill in the entry in the procedure linkage table. */
1424 bfd_put_32 (output_bfd,
4fbc96ad
KR
1425 PLT_ENTRY_WORD0 + h->plt_offset,
1426 splt->contents + h->plt_offset);
013dec1a
ILT
1427 bfd_put_32 (output_bfd,
1428 (PLT_ENTRY_WORD1
4fbc96ad
KR
1429 + (((- (h->plt_offset + 4)) >> 2) & 0x3fffff)),
1430 splt->contents + h->plt_offset + 4);
013dec1a 1431 bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
4fbc96ad 1432 splt->contents + h->plt_offset + 8);
013dec1a
ILT
1433
1434 /* Fill in the entry in the .rela.plt section. */
1435 rela.r_offset = (splt->output_section->vma
1436 + splt->output_offset
4fbc96ad 1437 + h->plt_offset);
013dec1a
ILT
1438 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
1439 rela.r_addend = 0;
1440 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1441 ((Elf32_External_Rela *) srela->contents
4fbc96ad
KR
1442 + h->plt_offset / PLT_ENTRY_SIZE - 4));
1443
1444 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1445 {
1446 /* Mark the symbol as undefined, rather than as defined in
1447 the .plt section. Leave the value alone. */
1448 sym->st_shndx = SHN_UNDEF;
1449 }
1450 }
1451
1452 if (h->got_offset != (bfd_vma) -1)
1453 {
1454 asection *sgot;
1455 asection *srela;
1456 Elf_Internal_Rela rela;
1457
1458 /* This symbol has an entry in the global offset table. Set it
1459 up. */
013dec1a 1460
4fbc96ad
KR
1461 BFD_ASSERT (h->dynindx != -1);
1462
1463 sgot = bfd_get_section_by_name (dynobj, ".got");
1464 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1465 BFD_ASSERT (sgot != NULL && srela != NULL);
1466
4fbc96ad
KR
1467 rela.r_offset = (sgot->output_section->vma
1468 + sgot->output_offset
3b3f7625
ILT
1469 + (h->got_offset &~ 1));
1470
1471 /* If this is a -Bsymbolic link, and the symbol is defined
1472 locally, we just want to emit a RELATIVE reloc. The entry in
1473 the global offset table will already have been initialized in
1474 the relocate_section function. */
1475 if (info->shared
1476 && info->symbolic
1477 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1478 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
1479 else
1480 {
1481 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset);
1482 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
1483 }
1484
4fbc96ad
KR
1485 rela.r_addend = 0;
1486 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1487 ((Elf32_External_Rela *) srela->contents
1488 + srela->reloc_count));
1489 ++srela->reloc_count;
013dec1a 1490 }
4fbc96ad
KR
1491
1492 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
013dec1a 1493 {
4fbc96ad
KR
1494 asection *s;
1495 Elf_Internal_Rela rela;
013dec1a 1496
4fbc96ad 1497 /* This symbols needs a copy reloc. Set it up. */
013dec1a 1498
4fbc96ad
KR
1499 BFD_ASSERT (h->dynindx != -1);
1500
1501 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1502 ".rela.bss");
1503 BFD_ASSERT (s != NULL);
1504
1505 rela.r_offset = (h->root.u.def.value
1506 + h->root.u.def.section->output_section->vma
1507 + h->root.u.def.section->output_offset);
1508 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
1509 rela.r_addend = 0;
1510 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1511 ((Elf32_External_Rela *) s->contents
1512 + s->reloc_count));
1513 ++s->reloc_count;
013dec1a
ILT
1514 }
1515
4fbc96ad
KR
1516 /* Mark some specially defined symbols as absolute. */
1517 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1518 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
1519 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
1520 sym->st_shndx = SHN_ABS;
1521
013dec1a
ILT
1522 return true;
1523}
1524
1525/* Finish up the dynamic sections. */
1526
1527static boolean
1528elf32_sparc_finish_dynamic_sections (output_bfd, info)
1529 bfd *output_bfd;
1530 struct bfd_link_info *info;
1531{
4fbc96ad 1532 bfd *dynobj;
013dec1a 1533 asection *sdyn;
12662be4 1534 asection *sgot;
013dec1a 1535
4fbc96ad
KR
1536 dynobj = elf_hash_table (info)->dynobj;
1537
4fbc96ad 1538 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
013dec1a 1539
12662be4 1540 if (elf_hash_table (info)->dynamic_sections_created)
013dec1a 1541 {
12662be4
ILT
1542 asection *splt;
1543 Elf32_External_Dyn *dyncon, *dynconend;
013dec1a 1544
12662be4
ILT
1545 splt = bfd_get_section_by_name (dynobj, ".plt");
1546 BFD_ASSERT (splt != NULL && sdyn != NULL);
013dec1a 1547
12662be4
ILT
1548 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1549 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1550 for (; dyncon < dynconend; dyncon++)
013dec1a 1551 {
12662be4
ILT
1552 Elf_Internal_Dyn dyn;
1553 const char *name;
1554 boolean size;
013dec1a 1555
12662be4 1556 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
013dec1a 1557
12662be4
ILT
1558 switch (dyn.d_tag)
1559 {
1560 case DT_PLTGOT: name = ".plt"; size = false; break;
1561 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1562 case DT_JMPREL: name = ".rela.plt"; size = false; break;
1563 default: name = NULL; size = false; break;
1564 }
1565
1566 if (name != NULL)
013dec1a 1567 {
12662be4
ILT
1568 asection *s;
1569
1570 s = bfd_get_section_by_name (output_bfd, name);
14cac507
ILT
1571 if (s == NULL)
1572 dyn.d_un.d_val = 0;
013dec1a 1573 else
12662be4 1574 {
14cac507
ILT
1575 if (! size)
1576 dyn.d_un.d_ptr = s->vma;
12662be4 1577 else
14cac507
ILT
1578 {
1579 if (s->_cooked_size != 0)
1580 dyn.d_un.d_val = s->_cooked_size;
1581 else
1582 dyn.d_un.d_val = s->_raw_size;
1583 }
12662be4
ILT
1584 }
1585 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
013dec1a 1586 }
013dec1a 1587 }
013dec1a 1588
12662be4
ILT
1589 /* Clear the first four entries in the procedure linkage table,
1590 and put a nop in the last four bytes. */
1591 if (splt->_raw_size > 0)
1592 {
1593 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
1594 bfd_put_32 (output_bfd, SPARC_NOP,
1595 splt->contents + splt->_raw_size - 4);
1596 }
1597
1598 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1599 PLT_ENTRY_SIZE;
013dec1a
ILT
1600 }
1601
1602 /* Set the first entry in the global offset table to the address of
1603 the dynamic section. */
12662be4
ILT
1604 sgot = bfd_get_section_by_name (dynobj, ".got");
1605 BFD_ASSERT (sgot != NULL);
013dec1a 1606 if (sgot->_raw_size > 0)
12662be4
ILT
1607 {
1608 if (sdyn == NULL)
1609 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1610 else
1611 bfd_put_32 (output_bfd,
1612 sdyn->output_section->vma + sdyn->output_offset,
1613 sgot->contents);
1614 }
013dec1a
ILT
1615
1616 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
013dec1a 1617
14cac507
ILT
1618 if (info->shared)
1619 {
1620 asection *sdynsym;
1621 asection *s;
1622 Elf_Internal_Sym sym;
1623
1624 /* Set up the section symbols for the output sections. */
1625
1626 sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
1627 BFD_ASSERT (sdynsym != NULL);
1628
1629 sym.st_size = 0;
1630 sym.st_name = 0;
1631 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1632 sym.st_other = 0;
1633
1634 for (s = output_bfd->sections; s != NULL; s = s->next)
1635 {
1636 int indx;
1637
1638 sym.st_value = s->vma;
1639
1640 indx = elf_section_data (s)->this_idx;
1641 BFD_ASSERT (indx > 0);
1642 sym.st_shndx = indx;
1643
1644 bfd_elf32_swap_symbol_out (output_bfd, &sym,
3b3f7625
ILT
1645 (PTR) (((Elf32_External_Sym *)
1646 sdynsym->contents)
1647 + elf_section_data (s)->dynindx));
14cac507
ILT
1648 }
1649
1650 /* Set the sh_info field of the output .dynsym section to the
1651 index of the first global symbol. */
1652 elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1653 bfd_count_sections (output_bfd) + 1;
1654 }
1655
013dec1a
ILT
1656 return true;
1657}
5bc513b4 1658\f
53787b23 1659/* Functions for dealing with the e_flags field.
5bc513b4 1660
53787b23
ILT
1661 We don't define set_private_flags or copy_private_bfd_data because
1662 the only currently defined values are based on the bfd mach number,
1663 so we use the latter instead and defer setting e_flags until the
1664 file is written out. */
5bc513b4
DE
1665
1666/* Merge backend specific data from an object file to the output
1667 object file when linking. */
1668
1669static boolean
1670elf32_sparc_merge_private_bfd_data (ibfd, obfd)
1671 bfd *ibfd;
1672 bfd *obfd;
1673{
5bc513b4
DE
1674 boolean error;
1675
1676 /* This function is selected based on the input vector. We only
1677 want to copy information over if the output BFD also uses Elf
1678 format. */
1679 if (bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1680 return true;
1681
1682 error = false;
1683
53787b23
ILT
1684#if 0
1685 /* ??? The native linker doesn't do this so we can't (otherwise gcc would
1686 have to know which linker is being used). Instead, the native linker
1687 bumps up the architecture level when it has to. However, I still think
1688 warnings like these are good, so it would be nice to have them turned on
1689 by some option. */
1690
5bc513b4
DE
1691 /* If the output machine is normal sparc, we can't allow v9 input files. */
1692 if (bfd_get_mach (obfd) == bfd_mach_sparc
1693 && (bfd_get_mach (ibfd) == bfd_mach_sparc_v8plus
1694 || bfd_get_mach (ibfd) == bfd_mach_sparc_v8plusa))
1695 {
1696 error = true;
1697 (*_bfd_error_handler)
1698 ("%s: compiled for a v8plus system and target is v8",
1699 bfd_get_filename (ibfd));
1700 }
1701 /* If the output machine is v9, we can't allow v9+vis input files. */
1702 if (bfd_get_mach (obfd) == bfd_mach_sparc_v8plus
1703 && bfd_get_mach (ibfd) == bfd_mach_sparc_v8plusa)
1704 {
1705 error = true;
1706 (*_bfd_error_handler)
1707 ("%s: compiled for a v8plusa system and target is v8plus",
1708 bfd_get_filename (ibfd));
1709 }
53787b23
ILT
1710#else
1711 if (bfd_get_mach (ibfd) >= bfd_mach_sparc_v9)
5bc513b4 1712 {
53787b23
ILT
1713 error = true;
1714 (*_bfd_error_handler)
1715 ("%s: compiled for a 64 bit system and target is 32 bit",
1716 bfd_get_filename (ibfd));
5bc513b4 1717 }
53787b23
ILT
1718 else if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
1719 bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
1720#endif
5bc513b4
DE
1721
1722 if (error)
1723 {
1724 bfd_set_error (bfd_error_bad_value);
1725 return false;
1726 }
1727
1728 return true;
1729}
1730\f
1731/* Set the right machine number. */
013dec1a 1732
5bc513b4
DE
1733static boolean
1734elf32_sparc_object_p (abfd)
1735 bfd *abfd;
1736{
1737 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
53787b23
ILT
1738 {
1739 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
1740 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
1741 bfd_mach_sparc_v8plusa);
1742 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
1743 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
1744 bfd_mach_sparc_v8plus);
1745 else
1746 return false;
1747 }
5bc513b4
DE
1748 else
1749 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
1750}
1751
1752/* The final processing done just before writing out the object file.
1753 We need to set the e_machine field appropriately. */
1754
1755static void
1756elf32_sparc_final_write_processing (abfd, linker)
1757 bfd *abfd;
1758 boolean linker;
1759{
53787b23 1760 switch (bfd_get_mach (abfd))
5bc513b4 1761 {
53787b23
ILT
1762 case bfd_mach_sparc :
1763 break; /* nothing to do */
1764 case bfd_mach_sparc_v8plus :
5bc513b4 1765 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
5bc513b4 1766 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
5bc513b4 1767 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
53787b23
ILT
1768 break;
1769 case bfd_mach_sparc_v8plusa :
1770 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
1771 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
1772 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
1773 break;
1774 default :
1775 abort ();
5bc513b4
DE
1776 }
1777}
5bc513b4 1778\f
32090b8e
KR
1779#define TARGET_BIG_SYM bfd_elf32_sparc_vec
1780#define TARGET_BIG_NAME "elf32-sparc"
1781#define ELF_ARCH bfd_arch_sparc
013dec1a 1782#define ELF_MACHINE_CODE EM_SPARC
6b3eb07e 1783#define ELF_MACHINE_ALT1 EM_SPARC32PLUS
013dec1a 1784#define ELF_MAXPAGESIZE 0x10000
19bfbcbe
ILT
1785
1786#define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
013dec1a 1787#define elf_backend_create_dynamic_sections \
ede4eed4 1788 _bfd_elf_create_dynamic_sections
4fbc96ad 1789#define elf_backend_check_relocs elf32_sparc_check_relocs
013dec1a
ILT
1790#define elf_backend_adjust_dynamic_symbol \
1791 elf32_sparc_adjust_dynamic_symbol
1792#define elf_backend_size_dynamic_sections \
1793 elf32_sparc_size_dynamic_sections
1794#define elf_backend_relocate_section elf32_sparc_relocate_section
1795#define elf_backend_finish_dynamic_symbol \
1796 elf32_sparc_finish_dynamic_symbol
1797#define elf_backend_finish_dynamic_sections \
1798 elf32_sparc_finish_dynamic_sections
5bc513b4
DE
1799#define bfd_elf32_bfd_merge_private_bfd_data \
1800 elf32_sparc_merge_private_bfd_data
1801#define elf_backend_object_p elf32_sparc_object_p
1802#define elf_backend_final_write_processing \
1803 elf32_sparc_final_write_processing
ede4eed4 1804#define elf_backend_want_got_plt 0
3b3f7625 1805#define elf_backend_plt_readonly 0
ede4eed4 1806#define elf_backend_want_plt_sym 1
32090b8e
KR
1807
1808#include "elf32-target.h"
This page took 0.241198 seconds and 4 git commands to generate.