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