projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
oops - omitted from previous delta!
[deliverable/binutils-gdb.git] / bfd / elf64-sparc.c
1 /* SPARC-specific support for 64-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "opcode/sparc.h"
26
27 /* This is defined if one wants to build upward compatible binaries
28 with the original sparc64-elf toolchain. The support is kept in for
29 now but is turned off by default. dje 970930 */
30 /*#define SPARC64_OLD_RELOCS*/
31
32 #include "elf/sparc.h"
33
34 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
35 #define MINUS_ONE (~ (bfd_vma) 0)
36
37 static struct bfd_link_hash_table * sparc64_elf_bfd_link_hash_table_create
38 PARAMS ((bfd *));
39 static bfd_reloc_status_type init_insn_reloc
40 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *,
41 bfd *, bfd_vma *, bfd_vma *));
42 static reloc_howto_type *sparc64_elf_reloc_type_lookup
43 PARAMS ((bfd *, bfd_reloc_code_real_type));
44 static void sparc64_elf_info_to_howto
45 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
46
47 static void sparc64_elf_build_plt
48 PARAMS ((bfd *, unsigned char *, int));
49 static bfd_vma sparc64_elf_plt_entry_offset
50 PARAMS ((int));
51 static bfd_vma sparc64_elf_plt_ptr_offset
52 PARAMS ((int, int));
53
54 static boolean sparc64_elf_check_relocs
55 PARAMS ((bfd *, struct bfd_link_info *, asection *sec,
56 const Elf_Internal_Rela *));
57 static boolean sparc64_elf_adjust_dynamic_symbol
58 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
59 static boolean sparc64_elf_size_dynamic_sections
60 PARAMS ((bfd *, struct bfd_link_info *));
61 static int sparc64_elf_get_symbol_type
62 PARAMS (( Elf_Internal_Sym *, int));
63 static boolean sparc64_elf_add_symbol_hook
64 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
65 const char **, flagword *, asection **, bfd_vma *));
66 static void sparc64_elf_symbol_processing
67 PARAMS ((bfd *, asymbol *));
68
69 static boolean sparc64_elf_copy_private_bfd_data
70 PARAMS ((bfd *, bfd *));
71 static boolean sparc64_elf_merge_private_bfd_data
72 PARAMS ((bfd *, bfd *));
73
74 static const char *sparc64_elf_print_symbol_all
75 PARAMS ((bfd *, PTR, asymbol *));
76 static boolean sparc64_elf_relax_section
77 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
78 static boolean sparc64_elf_relocate_section
79 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
80 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
81 static boolean sparc64_elf_finish_dynamic_symbol
82 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
83 Elf_Internal_Sym *));
84 static boolean sparc64_elf_finish_dynamic_sections
85 PARAMS ((bfd *, struct bfd_link_info *));
86 static boolean sparc64_elf_object_p PARAMS ((bfd *));
87 static long sparc64_elf_get_reloc_upper_bound PARAMS ((bfd *, asection *));
88 static long sparc64_elf_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
89 static boolean sparc64_elf_slurp_one_reloc_table
90 PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, asymbol **, boolean));
91 static boolean sparc64_elf_slurp_reloc_table
92 PARAMS ((bfd *, asection *, asymbol **, boolean));
93 static long sparc64_elf_canonicalize_dynamic_reloc
94 PARAMS ((bfd *, arelent **, asymbol **));
95 static void sparc64_elf_write_relocs PARAMS ((bfd *, asection *, PTR));
96 \f
97 /* The relocation "howto" table. */
98
99 static bfd_reloc_status_type sparc_elf_notsup_reloc
100 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
101 static bfd_reloc_status_type sparc_elf_wdisp16_reloc
102 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
103 static bfd_reloc_status_type sparc_elf_hix22_reloc
104 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
105 static bfd_reloc_status_type sparc_elf_lox10_reloc
106 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
107
108 static reloc_howto_type sparc64_elf_howto_table[] =
109 {
110 HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true),
111 HOWTO(R_SPARC_8, 0,0, 8,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", false,0,0x000000ff,true),
112 HOWTO(R_SPARC_16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", false,0,0x0000ffff,true),
113 HOWTO(R_SPARC_32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", false,0,0xffffffff,true),
114 HOWTO(R_SPARC_DISP8, 0,0, 8,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", false,0,0x000000ff,true),
115 HOWTO(R_SPARC_DISP16, 0,1,16,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", false,0,0x0000ffff,true),
116 HOWTO(R_SPARC_DISP32, 0,2,32,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", false,0,0x00ffffff,true),
117 HOWTO(R_SPARC_WDISP30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", false,0,0x3fffffff,true),
118 HOWTO(R_SPARC_WDISP22, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", false,0,0x003fffff,true),
119 HOWTO(R_SPARC_HI22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", false,0,0x003fffff,true),
120 HOWTO(R_SPARC_22, 0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", false,0,0x003fffff,true),
121 HOWTO(R_SPARC_13, 0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", false,0,0x00001fff,true),
122 HOWTO(R_SPARC_LO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", false,0,0x000003ff,true),
123 HOWTO(R_SPARC_GOT10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", false,0,0x000003ff,true),
124 HOWTO(R_SPARC_GOT13, 0,2,13,false,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", false,0,0x00001fff,true),
125 HOWTO(R_SPARC_GOT22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", false,0,0x003fffff,true),
126 HOWTO(R_SPARC_PC10, 0,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", false,0,0x000003ff,true),
127 HOWTO(R_SPARC_PC22, 10,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", false,0,0x003fffff,true),
128 HOWTO(R_SPARC_WPLT30, 2,2,30,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", false,0,0x3fffffff,true),
129 HOWTO(R_SPARC_COPY, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", false,0,0x00000000,true),
130 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),
131 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),
132 HOWTO(R_SPARC_RELATIVE, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",false,0,0x00000000,true),
133 HOWTO(R_SPARC_UA32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", false,0,0xffffffff,true),
134 #ifndef SPARC64_OLD_RELOCS
135 /* These aren't implemented yet. */
136 HOWTO(R_SPARC_PLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PLT32", false,0,0x00000000,true),
137 HOWTO(R_SPARC_HIPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_HIPLT22", false,0,0x00000000,true),
138 HOWTO(R_SPARC_LOPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_LOPLT10", false,0,0x00000000,true),
139 HOWTO(R_SPARC_PCPLT32, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT32", false,0,0x00000000,true),
140 HOWTO(R_SPARC_PCPLT22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT22", false,0,0x00000000,true),
141 HOWTO(R_SPARC_PCPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsup_reloc, "R_SPARC_PCPLT10", false,0,0x00000000,true),
142 #endif
143 HOWTO(R_SPARC_10, 0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", false,0,0x000003ff,true),
144 HOWTO(R_SPARC_11, 0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", false,0,0x000007ff,true),
145 HOWTO(R_SPARC_64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", false,0,MINUS_ONE, true),
146 HOWTO(R_SPARC_OLO10, 0,2,13,false,0,complain_overflow_signed, sparc_elf_notsup_reloc, "R_SPARC_OLO10", false,0,0x00001fff,true),
147 HOWTO(R_SPARC_HH22, 42,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true),
148 HOWTO(R_SPARC_HM10, 32,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true),
149 HOWTO(R_SPARC_LM22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true),
150 HOWTO(R_SPARC_PC_HH22, 42,2,22,true, 0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_PC_HH22", false,0,0x003fffff,true),
151 HOWTO(R_SPARC_PC_HM10, 32,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_HM10", false,0,0x000003ff,true),
152 HOWTO(R_SPARC_PC_LM22, 10,2,22,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC_LM22", false,0,0x003fffff,true),
153 HOWTO(R_SPARC_WDISP16, 2,2,16,true, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true),
154 HOWTO(R_SPARC_WDISP19, 2,2,19,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true),
155 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),
156 HOWTO(R_SPARC_7, 0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", false,0,0x0000007f,true),
157 HOWTO(R_SPARC_5, 0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", false,0,0x0000001f,true),
158 HOWTO(R_SPARC_6, 0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", false,0,0x0000003f,true),
159 HOWTO(R_SPARC_DISP64, 0,4,64,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP64", false,0,MINUS_ONE, true),
160 HOWTO(R_SPARC_PLT64, 0,4,64,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_PLT64", false,0,MINUS_ONE, false),
161 HOWTO(R_SPARC_HIX22, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_HIX22", false,0,MINUS_ONE, false),
162 HOWTO(R_SPARC_LOX10, 0,4, 0,false,0,complain_overflow_dont, sparc_elf_lox10_reloc, "R_SPARC_LOX10", false,0,MINUS_ONE, false),
163 HOWTO(R_SPARC_H44, 22,2,22,false,0,complain_overflow_unsigned,bfd_elf_generic_reloc, "R_SPARC_H44", false,0,0x003fffff,false),
164 HOWTO(R_SPARC_M44, 12,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_M44", false,0,0x000003ff,false),
165 HOWTO(R_SPARC_L44, 0,2,13,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_L44", false,0,0x00000fff,false),
166 HOWTO(R_SPARC_REGISTER, 0,4, 0,false,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",false,0,MINUS_ONE, false),
167 HOWTO(R_SPARC_UA64, 0,4,64,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA64", false,0,MINUS_ONE, true),
168 HOWTO(R_SPARC_UA16, 0,1,16,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", false,0,0x0000ffff,true)
169 };
170
171 struct elf_reloc_map {
172 bfd_reloc_code_real_type bfd_reloc_val;
173 unsigned char elf_reloc_val;
174 };
175
176 static CONST struct elf_reloc_map sparc_reloc_map[] =
177 {
178 { BFD_RELOC_NONE, R_SPARC_NONE, },
179 { BFD_RELOC_16, R_SPARC_16, },
180 { BFD_RELOC_8, R_SPARC_8 },
181 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
182 { BFD_RELOC_CTOR, R_SPARC_64 },
183 { BFD_RELOC_32, R_SPARC_32 },
184 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
185 { BFD_RELOC_HI22, R_SPARC_HI22 },
186 { BFD_RELOC_LO10, R_SPARC_LO10, },
187 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
188 { BFD_RELOC_SPARC22, R_SPARC_22 },
189 { BFD_RELOC_SPARC13, R_SPARC_13 },
190 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
191 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
192 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
193 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
194 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
195 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
196 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
197 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
198 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
199 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
200 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
201 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
202 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
203 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
204 { BFD_RELOC_SPARC_10, R_SPARC_10 },
205 { BFD_RELOC_SPARC_11, R_SPARC_11 },
206 { BFD_RELOC_SPARC_64, R_SPARC_64 },
207 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
208 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
209 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
210 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
211 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
212 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
213 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
214 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
215 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
216 { BFD_RELOC_SPARC_7, R_SPARC_7 },
217 { BFD_RELOC_SPARC_5, R_SPARC_5 },
218 { BFD_RELOC_SPARC_6, R_SPARC_6 },
219 { BFD_RELOC_SPARC_DISP64, R_SPARC_DISP64 },
220 { BFD_RELOC_SPARC_PLT64, R_SPARC_PLT64 },
221 { BFD_RELOC_SPARC_HIX22, R_SPARC_HIX22 },
222 { BFD_RELOC_SPARC_LOX10, R_SPARC_LOX10 },
223 { BFD_RELOC_SPARC_H44, R_SPARC_H44 },
224 { BFD_RELOC_SPARC_M44, R_SPARC_M44 },
225 { BFD_RELOC_SPARC_L44, R_SPARC_L44 },
226 { BFD_RELOC_SPARC_REGISTER, R_SPARC_REGISTER }
227 };
228
229 static reloc_howto_type *
230 sparc64_elf_reloc_type_lookup (abfd, code)
231 bfd *abfd ATTRIBUTE_UNUSED;
232 bfd_reloc_code_real_type code;
233 {
234 unsigned int i;
235 for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
236 {
237 if (sparc_reloc_map[i].bfd_reloc_val == code)
238 return &sparc64_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
239 }
240 return 0;
241 }
242
243 static void
244 sparc64_elf_info_to_howto (abfd, cache_ptr, dst)
245 bfd *abfd ATTRIBUTE_UNUSED;
246 arelent *cache_ptr;
247 Elf64_Internal_Rela *dst;
248 {
249 BFD_ASSERT (ELF64_R_TYPE_ID (dst->r_info) < (unsigned int) R_SPARC_max_std);
250 cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (dst->r_info)];
251 }
252 \f
253 /* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
254 section can represent up to two relocs, we must tell the user to allocate
255 more space. */
256
257 static long
258 sparc64_elf_get_reloc_upper_bound (abfd, sec)
259 bfd *abfd ATTRIBUTE_UNUSED;
260 asection *sec;
261 {
262 return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
263 }
264
265 static long
266 sparc64_elf_get_dynamic_reloc_upper_bound (abfd)
267 bfd *abfd;
268 {
269 return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2;
270 }
271
272 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
273 them. We cannot use generic elf routines for this, because R_SPARC_OLO10
274 has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
275 for the same location, R_SPARC_LO10 and R_SPARC_13. */
276
277 static boolean
278 sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, dynamic)
279 bfd *abfd;
280 asection *asect;
281 Elf_Internal_Shdr *rel_hdr;
282 asymbol **symbols;
283 boolean dynamic;
284 {
285 PTR allocated = NULL;
286 bfd_byte *native_relocs;
287 arelent *relent;
288 unsigned int i;
289 int entsize;
290 bfd_size_type count;
291 arelent *relents;
292
293 allocated = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
294 if (allocated == NULL)
295 goto error_return;
296
297 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
298 || (bfd_read (allocated, 1, rel_hdr->sh_size, abfd)
299 != rel_hdr->sh_size))
300 goto error_return;
301
302 native_relocs = (bfd_byte *) allocated;
303
304 relents = asect->relocation + asect->reloc_count;
305
306 entsize = rel_hdr->sh_entsize;
307 BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
308
309 count = rel_hdr->sh_size / entsize;
310
311 for (i = 0, relent = relents; i < count;
312 i++, relent++, native_relocs += entsize)
313 {
314 Elf_Internal_Rela rela;
315
316 bfd_elf64_swap_reloca_in (abfd, (Elf64_External_Rela *) native_relocs, &rela);
317
318 /* The address of an ELF reloc is section relative for an object
319 file, and absolute for an executable file or shared library.
320 The address of a normal BFD reloc is always section relative,
321 and the address of a dynamic reloc is absolute.. */
322 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
323 relent->address = rela.r_offset;
324 else
325 relent->address = rela.r_offset - asect->vma;
326
327 if (ELF64_R_SYM (rela.r_info) == 0)
328 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
329 else
330 {
331 asymbol **ps, *s;
332
333 ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
334 s = *ps;
335
336 /* Canonicalize ELF section symbols. FIXME: Why? */
337 if ((s->flags & BSF_SECTION_SYM) == 0)
338 relent->sym_ptr_ptr = ps;
339 else
340 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
341 }
342
343 relent->addend = rela.r_addend;
344
345 BFD_ASSERT (ELF64_R_TYPE_ID (rela.r_info) < (unsigned int) R_SPARC_max_std);
346 if (ELF64_R_TYPE_ID (rela.r_info) == R_SPARC_OLO10)
347 {
348 relent->howto = &sparc64_elf_howto_table[R_SPARC_LO10];
349 relent[1].address = relent->address;
350 relent++;
351 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
352 relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
353 relent->howto = &sparc64_elf_howto_table[R_SPARC_13];
354 }
355 else
356 relent->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (rela.r_info)];
357 }
358
359 asect->reloc_count += relent - relents;
360
361 if (allocated != NULL)
362 free (allocated);
363
364 return true;
365
366 error_return:
367 if (allocated != NULL)
368 free (allocated);
369 return false;
370 }
371
372 /* Read in and swap the external relocs. */
373
374 static boolean
375 sparc64_elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
376 bfd *abfd;
377 asection *asect;
378 asymbol **symbols;
379 boolean dynamic;
380 {
381 struct bfd_elf_section_data * const d = elf_section_data (asect);
382 Elf_Internal_Shdr *rel_hdr;
383 Elf_Internal_Shdr *rel_hdr2;
384
385 if (asect->relocation != NULL)
386 return true;
387
388 if (! dynamic)
389 {
390 if ((asect->flags & SEC_RELOC) == 0
391 || asect->reloc_count == 0)
392 return true;
393
394 rel_hdr = &d->rel_hdr;
395 rel_hdr2 = d->rel_hdr2;
396
397 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
398 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
399 }
400 else
401 {
402 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
403 case because relocations against this section may use the
404 dynamic symbol table, and in that case bfd_section_from_shdr
405 in elf.c does not update the RELOC_COUNT. */
406 if (asect->_raw_size == 0)
407 return true;
408
409 rel_hdr = &d->this_hdr;
410 asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
411 rel_hdr2 = NULL;
412 }
413
414 asect->relocation = ((arelent *)
415 bfd_alloc (abfd,
416 asect->reloc_count * 2 * sizeof (arelent)));
417 if (asect->relocation == NULL)
418 return false;
419
420 /* The sparc64_elf_slurp_one_reloc_table routine increments reloc_count. */
421 asect->reloc_count = 0;
422
423 if (!sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
424 dynamic))
425 return false;
426
427 if (rel_hdr2
428 && !sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
429 dynamic))
430 return false;
431
432 return true;
433 }
434
435 /* Canonicalize the dynamic relocation entries. Note that we return
436 the dynamic relocations as a single block, although they are
437 actually associated with particular sections; the interface, which
438 was designed for SunOS style shared libraries, expects that there
439 is only one set of dynamic relocs. Any section that was actually
440 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
441 the dynamic symbol table, is considered to be a dynamic reloc
442 section. */
443
444 static long
445 sparc64_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
446 bfd *abfd;
447 arelent **storage;
448 asymbol **syms;
449 {
450 asection *s;
451 long ret;
452
453 if (elf_dynsymtab (abfd) == 0)
454 {
455 bfd_set_error (bfd_error_invalid_operation);
456 return -1;
457 }
458
459 ret = 0;
460 for (s = abfd->sections; s != NULL; s = s->next)
461 {
462 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
463 && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
464 {
465 arelent *p;
466 long count, i;
467
468 if (! sparc64_elf_slurp_reloc_table (abfd, s, syms, true))
469 return -1;
470 count = s->reloc_count;
471 p = s->relocation;
472 for (i = 0; i < count; i++)
473 *storage++ = p++;
474 ret += count;
475 }
476 }
477
478 *storage = NULL;
479
480 return ret;
481 }
482
483 /* Write out the relocs. */
484
485 static void
486 sparc64_elf_write_relocs (abfd, sec, data)
487 bfd *abfd;
488 asection *sec;
489 PTR data;
490 {
491 boolean *failedp = (boolean *) data;
492 Elf_Internal_Shdr *rela_hdr;
493 Elf64_External_Rela *outbound_relocas, *src_rela;
494 unsigned int idx, count;
495 asymbol *last_sym = 0;
496 int last_sym_idx = 0;
497
498 /* If we have already failed, don't do anything. */
499 if (*failedp)
500 return;
501
502 if ((sec->flags & SEC_RELOC) == 0)
503 return;
504
505 /* The linker backend writes the relocs out itself, and sets the
506 reloc_count field to zero to inhibit writing them here. Also,
507 sometimes the SEC_RELOC flag gets set even when there aren't any
508 relocs. */
509 if (sec->reloc_count == 0)
510 return;
511
512 /* We can combine two relocs that refer to the same address
513 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
514 latter is R_SPARC_13 with no associated symbol. */
515 count = 0;
516 for (idx = 0; idx < sec->reloc_count; idx++)
517 {
518 bfd_vma addr;
519
520 ++count;
521
522 addr = sec->orelocation[idx]->address;
523 if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
524 && idx < sec->reloc_count - 1)
525 {
526 arelent *r = sec->orelocation[idx + 1];
527
528 if (r->howto->type == R_SPARC_13
529 && r->address == addr
530 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
531 && (*r->sym_ptr_ptr)->value == 0)
532 ++idx;
533 }
534 }
535
536 rela_hdr = &elf_section_data (sec)->rel_hdr;
537
538 rela_hdr->sh_size = rela_hdr->sh_entsize * count;
539 rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
540 if (rela_hdr->contents == NULL)
541 {
542 *failedp = true;
543 return;
544 }
545
546 /* Figure out whether the relocations are RELA or REL relocations. */
547 if (rela_hdr->sh_type != SHT_RELA)
548 abort ();
549
550 /* orelocation has the data, reloc_count has the count... */
551 outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
552 src_rela = outbound_relocas;
553
554 for (idx = 0; idx < sec->reloc_count; idx++)
555 {
556 Elf_Internal_Rela dst_rela;
557 arelent *ptr;
558 asymbol *sym;
559 int n;
560
561 ptr = sec->orelocation[idx];
562
563 /* The address of an ELF reloc is section relative for an object
564 file, and absolute for an executable file or shared library.
565 The address of a BFD reloc is always section relative. */
566 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
567 dst_rela.r_offset = ptr->address;
568 else
569 dst_rela.r_offset = ptr->address + sec->vma;
570
571 sym = *ptr->sym_ptr_ptr;
572 if (sym == last_sym)
573 n = last_sym_idx;
574 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
575 n = STN_UNDEF;
576 else
577 {
578 last_sym = sym;
579 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
580 if (n < 0)
581 {
582 *failedp = true;
583 return;
584 }
585 last_sym_idx = n;
586 }
587
588 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
589 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
590 && ! _bfd_elf_validate_reloc (abfd, ptr))
591 {
592 *failedp = true;
593 return;
594 }
595
596 if (ptr->howto->type == R_SPARC_LO10
597 && idx < sec->reloc_count - 1)
598 {
599 arelent *r = sec->orelocation[idx + 1];
600
601 if (r->howto->type == R_SPARC_13
602 && r->address == ptr->address
603 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
604 && (*r->sym_ptr_ptr)->value == 0)
605 {
606 idx++;
607 dst_rela.r_info
608 = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
609 R_SPARC_OLO10));
610 }
611 else
612 dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
613 }
614 else
615 dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
616
617 dst_rela.r_addend = ptr->addend;
618 bfd_elf64_swap_reloca_out (abfd, &dst_rela, src_rela);
619 ++src_rela;
620 }
621 }
622 \f
623 /* Sparc64 ELF linker hash table. */
624
625 struct sparc64_elf_app_reg
626 {
627 unsigned char bind;
628 unsigned short shndx;
629 bfd *abfd;
630 char *name;
631 };
632
633 struct sparc64_elf_link_hash_table
634 {
635 struct elf_link_hash_table root;
636
637 struct sparc64_elf_app_reg app_regs [4];
638 };
639
640 /* Get the Sparc64 ELF linker hash table from a link_info structure. */
641
642 #define sparc64_elf_hash_table(p) \
643 ((struct sparc64_elf_link_hash_table *) ((p)->hash))
644
645 /* Create a Sparc64 ELF linker hash table. */
646
647 static struct bfd_link_hash_table *
648 sparc64_elf_bfd_link_hash_table_create (abfd)
649 bfd *abfd;
650 {
651 struct sparc64_elf_link_hash_table *ret;
652
653 ret = ((struct sparc64_elf_link_hash_table *)
654 bfd_zalloc (abfd, sizeof (struct sparc64_elf_link_hash_table)));
655 if (ret == (struct sparc64_elf_link_hash_table *) NULL)
656 return NULL;
657
658 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
659 _bfd_elf_link_hash_newfunc))
660 {
661 bfd_release (abfd, ret);
662 return NULL;
663 }
664
665 return &ret->root.root;
666 }
667 \f
668 /* Utility for performing the standard initial work of an instruction
669 relocation.
670 *PRELOCATION will contain the relocated item.
671 *PINSN will contain the instruction from the input stream.
672 If the result is `bfd_reloc_other' the caller can continue with
673 performing the relocation. Otherwise it must stop and return the
674 value to its caller. */
675
676 static bfd_reloc_status_type
677 init_insn_reloc (abfd,
678 reloc_entry,
679 symbol,
680 data,
681 input_section,
682 output_bfd,
683 prelocation,
684 pinsn)
685 bfd *abfd;
686 arelent *reloc_entry;
687 asymbol *symbol;
688 PTR data;
689 asection *input_section;
690 bfd *output_bfd;
691 bfd_vma *prelocation;
692 bfd_vma *pinsn;
693 {
694 bfd_vma relocation;
695 reloc_howto_type *howto = reloc_entry->howto;
696
697 if (output_bfd != (bfd *) NULL
698 && (symbol->flags & BSF_SECTION_SYM) == 0
699 && (! howto->partial_inplace
700 || reloc_entry->addend == 0))
701 {
702 reloc_entry->address += input_section->output_offset;
703 return bfd_reloc_ok;
704 }
705
706 /* This works because partial_inplace == false. */
707 if (output_bfd != NULL)
708 return bfd_reloc_continue;
709
710 if (reloc_entry->address > input_section->_cooked_size)
711 return bfd_reloc_outofrange;
712
713 relocation = (symbol->value
714 + symbol->section->output_section->vma
715 + symbol->section->output_offset);
716 relocation += reloc_entry->addend;
717 if (howto->pc_relative)
718 {
719 relocation -= (input_section->output_section->vma
720 + input_section->output_offset);
721 relocation -= reloc_entry->address;
722 }
723
724 *prelocation = relocation;
725 *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
726 return bfd_reloc_other;
727 }
728
729 /* For unsupported relocs. */
730
731 static bfd_reloc_status_type
732 sparc_elf_notsup_reloc (abfd,
733 reloc_entry,
734 symbol,
735 data,
736 input_section,
737 output_bfd,
738 error_message)
739 bfd *abfd ATTRIBUTE_UNUSED;
740 arelent *reloc_entry ATTRIBUTE_UNUSED;
741 asymbol *symbol ATTRIBUTE_UNUSED;
742 PTR data ATTRIBUTE_UNUSED;
743 asection *input_section ATTRIBUTE_UNUSED;
744 bfd *output_bfd ATTRIBUTE_UNUSED;
745 char **error_message ATTRIBUTE_UNUSED;
746 {
747 return bfd_reloc_notsupported;
748 }
749
750 /* Handle the WDISP16 reloc. */
751
752 static bfd_reloc_status_type
753 sparc_elf_wdisp16_reloc (abfd, reloc_entry, symbol, data, input_section,
754 output_bfd, error_message)
755 bfd *abfd;
756 arelent *reloc_entry;
757 asymbol *symbol;
758 PTR data;
759 asection *input_section;
760 bfd *output_bfd;
761 char **error_message ATTRIBUTE_UNUSED;
762 {
763 bfd_vma relocation;
764 bfd_vma insn;
765 bfd_reloc_status_type status;
766
767 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
768 input_section, output_bfd, &relocation, &insn);
769 if (status != bfd_reloc_other)
770 return status;
771
772 insn = (insn & ~0x303fff) | ((((relocation >> 2) & 0xc000) << 6)
773 | ((relocation >> 2) & 0x3fff));
774 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
775
776 if ((bfd_signed_vma) relocation < - 0x40000
777 || (bfd_signed_vma) relocation > 0x3ffff)
778 return bfd_reloc_overflow;
779 else
780 return bfd_reloc_ok;
781 }
782
783 /* Handle the HIX22 reloc. */
784
785 static bfd_reloc_status_type
786 sparc_elf_hix22_reloc (abfd,
787 reloc_entry,
788 symbol,
789 data,
790 input_section,
791 output_bfd,
792 error_message)
793 bfd *abfd;
794 arelent *reloc_entry;
795 asymbol *symbol;
796 PTR data;
797 asection *input_section;
798 bfd *output_bfd;
799 char **error_message ATTRIBUTE_UNUSED;
800 {
801 bfd_vma relocation;
802 bfd_vma insn;
803 bfd_reloc_status_type status;
804
805 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
806 input_section, output_bfd, &relocation, &insn);
807 if (status != bfd_reloc_other)
808 return status;
809
810 relocation ^= MINUS_ONE;
811 insn = (insn & ~0x3fffff) | ((relocation >> 10) & 0x3fffff);
812 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
813
814 if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
815 return bfd_reloc_overflow;
816 else
817 return bfd_reloc_ok;
818 }
819
820 /* Handle the LOX10 reloc. */
821
822 static bfd_reloc_status_type
823 sparc_elf_lox10_reloc (abfd,
824 reloc_entry,
825 symbol,
826 data,
827 input_section,
828 output_bfd,
829 error_message)
830 bfd *abfd;
831 arelent *reloc_entry;
832 asymbol *symbol;
833 PTR data;
834 asection *input_section;
835 bfd *output_bfd;
836 char **error_message ATTRIBUTE_UNUSED;
837 {
838 bfd_vma relocation;
839 bfd_vma insn;
840 bfd_reloc_status_type status;
841
842 status = init_insn_reloc (abfd, reloc_entry, symbol, data,
843 input_section, output_bfd, &relocation, &insn);
844 if (status != bfd_reloc_other)
845 return status;
846
847 insn = (insn & ~0x1fff) | 0x1c00 | (relocation & 0x3ff);
848 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
849
850 return bfd_reloc_ok;
851 }
852 \f
853 /* PLT/GOT stuff */
854
855 /* Both the headers and the entries are icache aligned. */
856 #define PLT_ENTRY_SIZE 32
857 #define PLT_HEADER_SIZE (4 * PLT_ENTRY_SIZE)
858 #define LARGE_PLT_THRESHOLD 32768
859 #define GOT_RESERVED_ENTRIES 1
860
861 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
862
863 /* Fill in the .plt section. */
864
865 static void
866 sparc64_elf_build_plt (output_bfd, contents, nentries)
867 bfd *output_bfd;
868 unsigned char *contents;
869 int nentries;
870 {
871 const unsigned int nop = 0x01000000;
872 int i, j;
873
874 /* The first four entries are reserved, and are initially undefined.
875 We fill them with `illtrap 0' to force ld.so to do something. */
876
877 for (i = 0; i < PLT_HEADER_SIZE/4; ++i)
878 bfd_put_32 (output_bfd, 0, contents+i*4);
879
880 /* The first 32768 entries are close enough to plt1 to get there via
881 a straight branch. */
882
883 for (i = 4; i < LARGE_PLT_THRESHOLD && i < nentries; ++i)
884 {
885 unsigned char *entry = contents + i * PLT_ENTRY_SIZE;
886 unsigned int sethi, ba;
887
888 /* sethi (. - plt0), %g1 */
889 sethi = 0x03000000 | (i * PLT_ENTRY_SIZE);
890
891 /* ba,a,pt %xcc, plt1 */
892 ba = 0x30680000 | (((contents+PLT_ENTRY_SIZE) - (entry+4)) / 4 & 0x7ffff);
893
894 bfd_put_32 (output_bfd, sethi, entry);
895 bfd_put_32 (output_bfd, ba, entry+4);
896 bfd_put_32 (output_bfd, nop, entry+8);
897 bfd_put_32 (output_bfd, nop, entry+12);
898 bfd_put_32 (output_bfd, nop, entry+16);
899 bfd_put_32 (output_bfd, nop, entry+20);
900 bfd_put_32 (output_bfd, nop, entry+24);
901 bfd_put_32 (output_bfd, nop, entry+28);
902 }
903
904 /* Now the tricky bit. Entries 32768 and higher are grouped in blocks of
905 160: 160 entries and 160 pointers. This is to separate code from data,
906 which is much friendlier on the cache. */
907
908 for (; i < nentries; i += 160)
909 {
910 int block = (i + 160 <= nentries ? 160 : nentries - i);
911 for (j = 0; j < block; ++j)
912 {
913 unsigned char *entry, *ptr;
914 unsigned int ldx;
915
916 entry = contents + i*PLT_ENTRY_SIZE + j*4*6;
917 ptr = contents + i*PLT_ENTRY_SIZE + block*4*6 + j*8;
918
919 /* ldx [%o7 + ptr - entry+4], %g1 */
920 ldx = 0xc25be000 | ((ptr - entry+4) & 0x1fff);
921
922 bfd_put_32 (output_bfd, 0x8a10000f, entry); /* mov %o7,%g5 */
923 bfd_put_32 (output_bfd, 0x40000002, entry+4); /* call .+8 */
924 bfd_put_32 (output_bfd, nop, entry+8); /* nop */
925 bfd_put_32 (output_bfd, ldx, entry+12); /* ldx [%o7+P],%g1 */
926 bfd_put_32 (output_bfd, 0x83c3c001, entry+16); /* jmpl %o7+%g1,%g1 */
927 bfd_put_32 (output_bfd, 0x9e100005, entry+20); /* mov %g5,%o7 */
928
929 bfd_put_64 (output_bfd, contents - (entry+4), ptr);
930 }
931 }
932 }
933
934 /* Return the offset of a particular plt entry within the .plt section. */
935
936 static bfd_vma
937 sparc64_elf_plt_entry_offset (index)
938 int index;
939 {
940 int block, ofs;
941
942 if (index < LARGE_PLT_THRESHOLD)
943 return index * PLT_ENTRY_SIZE;
944
945 /* See above for details. */
946
947 block = (index - LARGE_PLT_THRESHOLD) / 160;
948 ofs = (index - LARGE_PLT_THRESHOLD) % 160;
949
950 return ((bfd_vma) (LARGE_PLT_THRESHOLD + block*160) * PLT_ENTRY_SIZE
951 + ofs * 6*4);
952 }
953
954 static bfd_vma
955 sparc64_elf_plt_ptr_offset (index, max)
956 int index, max;
957 {
958 int block, ofs, last;
959
960 BFD_ASSERT(index >= LARGE_PLT_THRESHOLD);
961
962 /* See above for details. */
963
964 block = (((index - LARGE_PLT_THRESHOLD) / 160) * 160)
965 + LARGE_PLT_THRESHOLD;
966 ofs = index - block;
967 if (block + 160 > max)
968 last = (max - LARGE_PLT_THRESHOLD) % 160;
969 else
970 last = 160;
971
972 return (block * PLT_ENTRY_SIZE
973 + last * 6*4
974 + ofs * 8);
975 }
976 \f
977 /* Look through the relocs for a section during the first phase, and
978 allocate space in the global offset table or procedure linkage
979 table. */
980
981 static boolean
982 sparc64_elf_check_relocs (abfd, info, sec, relocs)
983 bfd *abfd;
984 struct bfd_link_info *info;
985 asection *sec;
986 const Elf_Internal_Rela *relocs;
987 {
988 bfd *dynobj;
989 Elf_Internal_Shdr *symtab_hdr;
990 struct elf_link_hash_entry **sym_hashes;
991 bfd_vma *local_got_offsets;
992 const Elf_Internal_Rela *rel;
993 const Elf_Internal_Rela *rel_end;
994 asection *sgot;
995 asection *srelgot;
996 asection *sreloc;
997
998 if (info->relocateable || !(sec->flags & SEC_ALLOC))
999 return true;
1000
1001 dynobj = elf_hash_table (info)->dynobj;
1002 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1003 sym_hashes = elf_sym_hashes (abfd);
1004 local_got_offsets = elf_local_got_offsets (abfd);
1005
1006 sgot = NULL;
1007 srelgot = NULL;
1008 sreloc = NULL;
1009
1010 rel_end = relocs + NUM_SHDR_ENTRIES (& elf_section_data (sec)->rel_hdr);
1011 for (rel = relocs; rel < rel_end; rel++)
1012 {
1013 unsigned long r_symndx;
1014 struct elf_link_hash_entry *h;
1015
1016 r_symndx = ELF64_R_SYM (rel->r_info);
1017 if (r_symndx < symtab_hdr->sh_info)
1018 h = NULL;
1019 else
1020 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1021
1022 switch (ELF64_R_TYPE_ID (rel->r_info))
1023 {
1024 case R_SPARC_GOT10:
1025 case R_SPARC_GOT13:
1026 case R_SPARC_GOT22:
1027 /* This symbol requires a global offset table entry. */
1028
1029 if (dynobj == NULL)
1030 {
1031 /* Create the .got section. */
1032 elf_hash_table (info)->dynobj = dynobj = abfd;
1033 if (! _bfd_elf_create_got_section (dynobj, info))
1034 return false;
1035 }
1036
1037 if (sgot == NULL)
1038 {
1039 sgot = bfd_get_section_by_name (dynobj, ".got");
1040 BFD_ASSERT (sgot != NULL);
1041 }
1042
1043 if (srelgot == NULL && (h != NULL || info->shared))
1044 {
1045 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1046 if (srelgot == NULL)
1047 {
1048 srelgot = bfd_make_section (dynobj, ".rela.got");
1049 if (srelgot == NULL
1050 || ! bfd_set_section_flags (dynobj, srelgot,
1051 (SEC_ALLOC
1052 | SEC_LOAD
1053 | SEC_HAS_CONTENTS
1054 | SEC_IN_MEMORY
1055 | SEC_LINKER_CREATED
1056 | SEC_READONLY))
1057 || ! bfd_set_section_alignment (dynobj, srelgot, 3))
1058 return false;
1059 }
1060 }
1061
1062 if (h != NULL)
1063 {
1064 if (h->got.offset != (bfd_vma) -1)
1065 {
1066 /* We have already allocated space in the .got. */
1067 break;
1068 }
1069 h->got.offset = sgot->_raw_size;
1070
1071 /* Make sure this symbol is output as a dynamic symbol. */
1072 if (h->dynindx == -1)
1073 {
1074 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1075 return false;
1076 }
1077
1078 srelgot->_raw_size += sizeof (Elf64_External_Rela);
1079 }
1080 else
1081 {
1082 /* This is a global offset table entry for a local
1083 symbol. */
1084 if (local_got_offsets == NULL)
1085 {
1086 size_t size;
1087 register unsigned int i;
1088
1089 size = symtab_hdr->sh_info * sizeof (bfd_vma);
1090 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1091 if (local_got_offsets == NULL)
1092 return false;
1093 elf_local_got_offsets (abfd) = local_got_offsets;
1094 for (i = 0; i < symtab_hdr->sh_info; i++)
1095 local_got_offsets[i] = (bfd_vma) -1;
1096 }
1097 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
1098 {
1099 /* We have already allocated space in the .got. */
1100 break;
1101 }
1102 local_got_offsets[r_symndx] = sgot->_raw_size;
1103
1104 if (info->shared)
1105 {
1106 /* If we are generating a shared object, we need to
1107 output a R_SPARC_RELATIVE reloc so that the
1108 dynamic linker can adjust this GOT entry. */
1109 srelgot->_raw_size += sizeof (Elf64_External_Rela);
1110 }
1111 }
1112
1113 sgot->_raw_size += 8;
1114
1115 #if 0
1116 /* Doesn't work for 64-bit -fPIC, since sethi/or builds
1117 unsigned numbers. If we permit ourselves to modify
1118 code so we get sethi/xor, this could work.
1119 Question: do we consider conditionally re-enabling
1120 this for -fpic, once we know about object code models? */
1121 /* If the .got section is more than 0x1000 bytes, we add
1122 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1123 bit relocations have a greater chance of working. */
1124 if (sgot->_raw_size >= 0x1000
1125 && elf_hash_table (info)->hgot->root.u.def.value == 0)
1126 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
1127 #endif
1128
1129 break;
1130
1131 case R_SPARC_WPLT30:
1132 case R_SPARC_PLT32:
1133 case R_SPARC_HIPLT22:
1134 case R_SPARC_LOPLT10:
1135 case R_SPARC_PCPLT32:
1136 case R_SPARC_PCPLT22:
1137 case R_SPARC_PCPLT10:
1138 case R_SPARC_PLT64:
1139 /* This symbol requires a procedure linkage table entry. We
1140 actually build the entry in adjust_dynamic_symbol,
1141 because this might be a case of linking PIC code without
1142 linking in any dynamic objects, in which case we don't
1143 need to generate a procedure linkage table after all. */
1144
1145 if (h == NULL)
1146 {
1147 /* It does not make sense to have a procedure linkage
1148 table entry for a local symbol. */
1149 bfd_set_error (bfd_error_bad_value);
1150 return false;
1151 }
1152
1153 /* Make sure this symbol is output as a dynamic symbol. */
1154 if (h->dynindx == -1)
1155 {
1156 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1157 return false;
1158 }
1159
1160 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1161 break;
1162
1163 case R_SPARC_PC10:
1164 case R_SPARC_PC22:
1165 case R_SPARC_PC_HH22:
1166 case R_SPARC_PC_HM10:
1167 case R_SPARC_PC_LM22:
1168 if (h != NULL
1169 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1170 break;
1171 /* Fall through. */
1172 case R_SPARC_DISP8:
1173 case R_SPARC_DISP16:
1174 case R_SPARC_DISP32:
1175 case R_SPARC_DISP64:
1176 case R_SPARC_WDISP30:
1177 case R_SPARC_WDISP22:
1178 case R_SPARC_WDISP19:
1179 case R_SPARC_WDISP16:
1180 if (h == NULL)
1181 break;
1182 /* Fall through. */
1183 case R_SPARC_8:
1184 case R_SPARC_16:
1185 case R_SPARC_32:
1186 case R_SPARC_HI22:
1187 case R_SPARC_22:
1188 case R_SPARC_13:
1189 case R_SPARC_LO10:
1190 case R_SPARC_UA32:
1191 case R_SPARC_10:
1192 case R_SPARC_11:
1193 case R_SPARC_64:
1194 case R_SPARC_OLO10:
1195 case R_SPARC_HH22:
1196 case R_SPARC_HM10:
1197 case R_SPARC_LM22:
1198 case R_SPARC_7:
1199 case R_SPARC_5:
1200 case R_SPARC_6:
1201 case R_SPARC_HIX22:
1202 case R_SPARC_LOX10:
1203 case R_SPARC_H44:
1204 case R_SPARC_M44:
1205 case R_SPARC_L44:
1206 case R_SPARC_UA64:
1207 case R_SPARC_UA16:
1208 /* When creating a shared object, we must copy these relocs
1209 into the output file. We create a reloc section in
1210 dynobj and make room for the reloc.
1211
1212 But don't do this for debugging sections -- this shows up
1213 with DWARF2 -- first because they are not loaded, and
1214 second because DWARF sez the debug info is not to be
1215 biased by the load address. */
1216 if (info->shared && (sec->flags & SEC_ALLOC))
1217 {
1218 if (sreloc == NULL)
1219 {
1220 const char *name;
1221
1222 name = (bfd_elf_string_from_elf_section
1223 (abfd,
1224 elf_elfheader (abfd)->e_shstrndx,
1225 elf_section_data (sec)->rel_hdr.sh_name));
1226 if (name == NULL)
1227 return false;
1228
1229 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1230 && strcmp (bfd_get_section_name (abfd, sec),
1231 name + 5) == 0);
1232
1233 sreloc = bfd_get_section_by_name (dynobj, name);
1234 if (sreloc == NULL)
1235 {
1236 flagword flags;
1237
1238 sreloc = bfd_make_section (dynobj, name);
1239 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1240 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1241 if ((sec->flags & SEC_ALLOC) != 0)
1242 flags |= SEC_ALLOC | SEC_LOAD;
1243 if (sreloc == NULL
1244 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1245 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
1246 return false;
1247 }
1248 }
1249
1250 sreloc->_raw_size += sizeof (Elf64_External_Rela);
1251 }
1252 break;
1253
1254 case R_SPARC_REGISTER:
1255 /* Nothing to do. */
1256 break;
1257
1258 default:
1259 (*_bfd_error_handler) (_("%s: check_relocs: unhandled reloc type %d"),
1260 bfd_get_filename(abfd),
1261 ELF64_R_TYPE_ID (rel->r_info));
1262 return false;
1263 }
1264 }
1265
1266 return true;
1267 }
1268
1269 /* Hook called by the linker routine which adds symbols from an object
1270 file. We use it for STT_REGISTER symbols. */
1271
1272 static boolean
1273 sparc64_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1274 bfd *abfd;
1275 struct bfd_link_info *info;
1276 const Elf_Internal_Sym *sym;
1277 const char **namep;
1278 flagword *flagsp ATTRIBUTE_UNUSED;
1279 asection **secp ATTRIBUTE_UNUSED;
1280 bfd_vma *valp ATTRIBUTE_UNUSED;
1281 {
1282 static char *stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
1283
1284 if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
1285 {
1286 int reg;
1287 struct sparc64_elf_app_reg *p;
1288
1289 reg = (int)sym->st_value;
1290 switch (reg & ~1)
1291 {
1292 case 2: reg -= 2; break;
1293 case 6: reg -= 4; break;
1294 default:
1295 (*_bfd_error_handler)
1296 (_("%s: Only registers %%g[2367] can be declared using STT_REGISTER"),
1297 bfd_get_filename (abfd));
1298 return false;
1299 }
1300
1301 if (info->hash->creator != abfd->xvec
1302 || (abfd->flags & DYNAMIC) != 0)
1303 {
1304 /* STT_REGISTER only works when linking an elf64_sparc object.
1305 If STT_REGISTER comes from a dynamic object, don't put it into
1306 the output bfd. The dynamic linker will recheck it. */
1307 *namep = NULL;
1308 return true;
1309 }
1310
1311 p = sparc64_elf_hash_table(info)->app_regs + reg;
1312
1313 if (p->name != NULL && strcmp (p->name, *namep))
1314 {
1315 (*_bfd_error_handler)
1316 (_("Register %%g%d used incompatibly: "
1317 "previously declared in %s to %s, in %s redefined to %s"),
1318 (int)sym->st_value,
1319 bfd_get_filename (p->abfd), *p->name ? p->name : "#scratch",
1320 bfd_get_filename (abfd), **namep ? *namep : "#scratch");
1321 return false;
1322 }
1323
1324 if (p->name == NULL)
1325 {
1326 if (**namep)
1327 {
1328 struct elf_link_hash_entry *h;
1329
1330 h = (struct elf_link_hash_entry *)
1331 bfd_link_hash_lookup (info->hash, *namep, false, false, false);
1332
1333 if (h != NULL)
1334 {
1335 unsigned char type = h->type;
1336
1337 if (type > STT_FUNC) type = 0;
1338 (*_bfd_error_handler)
1339 (_("Symbol `%s' has differing types: "
1340 "previously %s, REGISTER in %s"),
1341 *namep, stt_types [type], bfd_get_filename (abfd));
1342 return false;
1343 }
1344
1345 p->name = bfd_hash_allocate (&info->hash->table,
1346 strlen (*namep) + 1);
1347 if (!p->name)
1348 return false;
1349
1350 strcpy (p->name, *namep);
1351 }
1352 else
1353 p->name = "";
1354 p->bind = ELF_ST_BIND (sym->st_info);
1355 p->abfd = abfd;
1356 p->shndx = sym->st_shndx;
1357 }
1358 else
1359 {
1360 if (p->bind == STB_WEAK
1361 && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
1362 {
1363 p->bind = STB_GLOBAL;
1364 p->abfd = abfd;
1365 }
1366 }
1367 *namep = NULL;
1368 return true;
1369 }
1370 else if (! *namep || ! **namep)
1371 return true;
1372 else
1373 {
1374 int i;
1375 struct sparc64_elf_app_reg *p;
1376
1377 p = sparc64_elf_hash_table(info)->app_regs;
1378 for (i = 0; i < 4; i++, p++)
1379 if (p->name != NULL && ! strcmp (p->name, *namep))
1380 {
1381 unsigned char type = ELF_ST_TYPE (sym->st_info);
1382
1383 if (type > STT_FUNC) type = 0;
1384 (*_bfd_error_handler)
1385 (_("Symbol `%s' has differing types: "
1386 "REGISTER in %s, %s in %s"),
1387 *namep, bfd_get_filename (p->abfd), stt_types [type],
1388 bfd_get_filename (abfd));
1389 return false;
1390 }
1391 }
1392 return true;
1393 }
1394
1395 /* This function takes care of emiting STT_REGISTER symbols
1396 which we cannot easily keep in the symbol hash table. */
1397
1398 static boolean
1399 sparc64_elf_output_arch_syms (output_bfd, info, finfo, func)
1400 bfd *output_bfd ATTRIBUTE_UNUSED;
1401 struct bfd_link_info *info;
1402 PTR finfo;
1403 boolean (*func) PARAMS ((PTR, const char *,
1404 Elf_Internal_Sym *, asection *));
1405 {
1406 int reg;
1407 struct sparc64_elf_app_reg *app_regs =
1408 sparc64_elf_hash_table(info)->app_regs;
1409 Elf_Internal_Sym sym;
1410
1411 /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
1412 at the end of the dynlocal list, so they came at the end of the local
1413 symbols in the symtab. Except that they aren't STB_LOCAL, so we need
1414 to back up symtab->sh_info. */
1415 if (elf_hash_table (info)->dynlocal)
1416 {
1417 bfd * dynobj = elf_hash_table (info)->dynobj;
1418 asection *dynsymsec = bfd_get_section_by_name (dynobj, ".dynsym");
1419 struct elf_link_local_dynamic_entry *e;
1420
1421 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
1422 if (e->input_indx == -1)
1423 break;
1424 if (e)
1425 {
1426 elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
1427 = e->dynindx;
1428 }
1429 }
1430
1431 if (info->strip == strip_all)
1432 return true;
1433
1434 for (reg = 0; reg < 4; reg++)
1435 if (app_regs [reg].name != NULL)
1436 {
1437 if (info->strip == strip_some
1438 && bfd_hash_lookup (info->keep_hash,
1439 app_regs [reg].name,
1440 false, false) == NULL)
1441 continue;
1442
1443 sym.st_value = reg < 2 ? reg + 2 : reg + 4;
1444 sym.st_size = 0;
1445 sym.st_other = 0;
1446 sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
1447 sym.st_shndx = app_regs [reg].shndx;
1448 if (! (*func) (finfo, app_regs [reg].name, &sym,
1449 sym.st_shndx == SHN_ABS
1450 ? bfd_abs_section_ptr : bfd_und_section_ptr))
1451 return false;
1452 }
1453
1454 return true;
1455 }
1456
1457 static int
1458 sparc64_elf_get_symbol_type (elf_sym, type)
1459 Elf_Internal_Sym * elf_sym;
1460 int type;
1461 {
1462 if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
1463 return STT_REGISTER;
1464 else
1465 return type;
1466 }
1467
1468 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
1469 even in SHN_UNDEF section. */
1470
1471 static void
1472 sparc64_elf_symbol_processing (abfd, asym)
1473 bfd *abfd ATTRIBUTE_UNUSED;
1474 asymbol *asym;
1475 {
1476 elf_symbol_type *elfsym;
1477
1478 elfsym = (elf_symbol_type *) asym;
1479 if (elfsym->internal_elf_sym.st_info
1480 == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
1481 {
1482 asym->flags |= BSF_GLOBAL;
1483 }
1484 }
1485
1486 /* Adjust a symbol defined by a dynamic object and referenced by a
1487 regular object. The current definition is in some section of the
1488 dynamic object, but we're not including those sections. We have to
1489 change the definition to something the rest of the link can
1490 understand. */
1491
1492 static boolean
1493 sparc64_elf_adjust_dynamic_symbol (info, h)
1494 struct bfd_link_info *info;
1495 struct elf_link_hash_entry *h;
1496 {
1497 bfd *dynobj;
1498 asection *s;
1499 unsigned int power_of_two;
1500
1501 dynobj = elf_hash_table (info)->dynobj;
1502
1503 /* Make sure we know what is going on here. */
1504 BFD_ASSERT (dynobj != NULL
1505 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1506 || h->weakdef != NULL
1507 || ((h->elf_link_hash_flags
1508 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1509 && (h->elf_link_hash_flags
1510 & ELF_LINK_HASH_REF_REGULAR) != 0
1511 && (h->elf_link_hash_flags
1512 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1513
1514 /* If this is a function, put it in the procedure linkage table. We
1515 will fill in the contents of the procedure linkage table later
1516 (although we could actually do it here). The STT_NOTYPE
1517 condition is a hack specifically for the Oracle libraries
1518 delivered for Solaris; for some inexplicable reason, they define
1519 some of their functions as STT_NOTYPE when they really should be
1520 STT_FUNC. */
1521 if (h->type == STT_FUNC
1522 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
1523 || (h->type == STT_NOTYPE
1524 && (h->root.type == bfd_link_hash_defined
1525 || h->root.type == bfd_link_hash_defweak)
1526 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1527 {
1528 if (! elf_hash_table (info)->dynamic_sections_created)
1529 {
1530 /* This case can occur if we saw a WPLT30 reloc in an input
1531 file, but none of the input files were dynamic objects.
1532 In such a case, we don't actually need to build a
1533 procedure linkage table, and we can just do a WDISP30
1534 reloc instead. */
1535 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
1536 return true;
1537 }
1538
1539 s = bfd_get_section_by_name (dynobj, ".plt");
1540 BFD_ASSERT (s != NULL);
1541
1542 /* The first four bit in .plt is reserved. */
1543 if (s->_raw_size == 0)
1544 s->_raw_size = PLT_HEADER_SIZE;
1545
1546 /* If this symbol is not defined in a regular file, and we are
1547 not generating a shared library, then set the symbol to this
1548 location in the .plt. This is required to make function
1549 pointers compare as equal between the normal executable and
1550 the shared library. */
1551 if (! info->shared
1552 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1553 {
1554 h->root.u.def.section = s;
1555 h->root.u.def.value = s->_raw_size;
1556 }
1557
1558 /* To simplify matters later, just store the plt index here. */
1559 h->plt.offset = s->_raw_size / PLT_ENTRY_SIZE;
1560
1561 /* Make room for this entry. */
1562 s->_raw_size += PLT_ENTRY_SIZE;
1563
1564 /* We also need to make an entry in the .rela.plt section. */
1565
1566 s = bfd_get_section_by_name (dynobj, ".rela.plt");
1567 BFD_ASSERT (s != NULL);
1568
1569 s->_raw_size += sizeof (Elf64_External_Rela);
1570
1571 /* The procedure linkage table size is bounded by the magnitude
1572 of the offset we can describe in the entry. */
1573 if (s->_raw_size >= (bfd_vma)1 << 32)
1574 {
1575 bfd_set_error (bfd_error_bad_value);
1576 return false;
1577 }
1578
1579 return true;
1580 }
1581
1582 /* If this is a weak symbol, and there is a real definition, the
1583 processor independent code will have arranged for us to see the
1584 real definition first, and we can just use the same value. */
1585 if (h->weakdef != NULL)
1586 {
1587 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1588 || h->weakdef->root.type == bfd_link_hash_defweak);
1589 h->root.u.def.section = h->weakdef->root.u.def.section;
1590 h->root.u.def.value = h->weakdef->root.u.def.value;
1591 return true;
1592 }
1593
1594 /* This is a reference to a symbol defined by a dynamic object which
1595 is not a function. */
1596
1597 /* If we are creating a shared library, we must presume that the
1598 only references to the symbol are via the global offset table.
1599 For such cases we need not do anything here; the relocations will
1600 be handled correctly by relocate_section. */
1601 if (info->shared)
1602 return true;
1603
1604 /* We must allocate the symbol in our .dynbss section, which will
1605 become part of the .bss section of the executable. There will be
1606 an entry for this symbol in the .dynsym section. The dynamic
1607 object will contain position independent code, so all references
1608 from the dynamic object to this symbol will go through the global
1609 offset table. The dynamic linker will use the .dynsym entry to
1610 determine the address it must put in the global offset table, so
1611 both the dynamic object and the regular object will refer to the
1612 same memory location for the variable. */
1613
1614 s = bfd_get_section_by_name (dynobj, ".dynbss");
1615 BFD_ASSERT (s != NULL);
1616
1617 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1618 to copy the initial value out of the dynamic object and into the
1619 runtime process image. We need to remember the offset into the
1620 .rel.bss section we are going to use. */
1621 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1622 {
1623 asection *srel;
1624
1625 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1626 BFD_ASSERT (srel != NULL);
1627 srel->_raw_size += sizeof (Elf64_External_Rela);
1628 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1629 }
1630
1631 /* We need to figure out the alignment required for this symbol. I
1632 have no idea how ELF linkers handle this. 16-bytes is the size
1633 of the largest type that requires hard alignment -- long double. */
1634 power_of_two = bfd_log2 (h->size);
1635 if (power_of_two > 4)
1636 power_of_two = 4;
1637
1638 /* Apply the required alignment. */
1639 s->_raw_size = BFD_ALIGN (s->_raw_size,
1640 (bfd_size_type) (1 << power_of_two));
1641 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1642 {
1643 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1644 return false;
1645 }
1646
1647 /* Define the symbol as being at this point in the section. */
1648 h->root.u.def.section = s;
1649 h->root.u.def.value = s->_raw_size;
1650
1651 /* Increment the section size to make room for the symbol. */
1652 s->_raw_size += h->size;
1653
1654 return true;
1655 }
1656
1657 /* Set the sizes of the dynamic sections. */
1658
1659 static boolean
1660 sparc64_elf_size_dynamic_sections (output_bfd, info)
1661 bfd *output_bfd;
1662 struct bfd_link_info *info;
1663 {
1664 bfd *dynobj;
1665 asection *s;
1666 boolean reltext;
1667 boolean relplt;
1668
1669 dynobj = elf_hash_table (info)->dynobj;
1670 BFD_ASSERT (dynobj != NULL);
1671
1672 if (elf_hash_table (info)->dynamic_sections_created)
1673 {
1674 /* Set the contents of the .interp section to the interpreter. */
1675 if (! info->shared)
1676 {
1677 s = bfd_get_section_by_name (dynobj, ".interp");
1678 BFD_ASSERT (s != NULL);
1679 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1680 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1681 }
1682 }
1683 else
1684 {
1685 /* We may have created entries in the .rela.got section.
1686 However, if we are not creating the dynamic sections, we will
1687 not actually use these entries. Reset the size of .rela.got,
1688 which will cause it to get stripped from the output file
1689 below. */
1690 s = bfd_get_section_by_name (dynobj, ".rela.got");
1691 if (s != NULL)
1692 s->_raw_size = 0;
1693 }
1694
1695 /* The check_relocs and adjust_dynamic_symbol entry points have
1696 determined the sizes of the various dynamic sections. Allocate
1697 memory for them. */
1698 reltext = false;
1699 relplt = false;
1700 for (s = dynobj->sections; s != NULL; s = s->next)
1701 {
1702 const char *name;
1703 boolean strip;
1704
1705 if ((s->flags & SEC_LINKER_CREATED) == 0)
1706 continue;
1707
1708 /* It's OK to base decisions on the section name, because none
1709 of the dynobj section names depend upon the input files. */
1710 name = bfd_get_section_name (dynobj, s);
1711
1712 strip = false;
1713
1714 if (strncmp (name, ".rela", 5) == 0)
1715 {
1716 if (s->_raw_size == 0)
1717 {
1718 /* If we don't need this section, strip it from the
1719 output file. This is to handle .rela.bss and
1720 .rel.plt. We must create it in
1721 create_dynamic_sections, because it must be created
1722 before the linker maps input sections to output
1723 sections. The linker does that before
1724 adjust_dynamic_symbol is called, and it is that
1725 function which decides whether anything needs to go
1726 into these sections. */
1727 strip = true;
1728 }
1729 else
1730 {
1731 const char *outname;
1732 asection *target;
1733
1734 /* If this relocation section applies to a read only
1735 section, then we probably need a DT_TEXTREL entry. */
1736 outname = bfd_get_section_name (output_bfd,
1737 s->output_section);
1738 target = bfd_get_section_by_name (output_bfd, outname + 5);
1739 if (target != NULL
1740 && (target->flags & SEC_READONLY) != 0)
1741 reltext = true;
1742
1743 if (strcmp (name, ".rela.plt") == 0)
1744 relplt = true;
1745
1746 /* We use the reloc_count field as a counter if we need
1747 to copy relocs into the output file. */
1748 s->reloc_count = 0;
1749 }
1750 }
1751 else if (strcmp (name, ".plt") != 0
1752 && strncmp (name, ".got", 4) != 0)
1753 {
1754 /* It's not one of our sections, so don't allocate space. */
1755 continue;
1756 }
1757
1758 if (strip)
1759 {
1760 _bfd_strip_section_from_output (info, s);
1761 continue;
1762 }
1763
1764 /* Allocate memory for the section contents. Zero the memory
1765 for the benefit of .rela.plt, which has 4 unused entries
1766 at the beginning, and we don't want garbage. */
1767 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1768 if (s->contents == NULL && s->_raw_size != 0)
1769 return false;
1770 }
1771
1772 if (elf_hash_table (info)->dynamic_sections_created)
1773 {
1774 /* Add some entries to the .dynamic section. We fill in the
1775 values later, in sparc64_elf_finish_dynamic_sections, but we
1776 must add the entries now so that we get the correct size for
1777 the .dynamic section. The DT_DEBUG entry is filled in by the
1778 dynamic linker and used by the debugger. */
1779 int reg;
1780 struct sparc64_elf_app_reg * app_regs;
1781 struct bfd_strtab_hash *dynstr;
1782 struct elf_link_hash_table *eht = elf_hash_table (info);
1783
1784 if (! info->shared)
1785 {
1786 if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
1787 return false;
1788 }
1789
1790 if (relplt)
1791 {
1792 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0)
1793 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1794 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
1795 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
1796 return false;
1797 }
1798
1799 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
1800 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
1801 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
1802 sizeof (Elf64_External_Rela)))
1803 return false;
1804
1805 if (reltext)
1806 {
1807 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
1808 return false;
1809 info->flags |= DF_TEXTREL;
1810 }
1811
1812 /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
1813 entries if needed. */
1814 app_regs = sparc64_elf_hash_table (info)->app_regs;
1815 dynstr = eht->dynstr;
1816
1817 for (reg = 0; reg < 4; reg++)
1818 if (app_regs [reg].name != NULL)
1819 {
1820 struct elf_link_local_dynamic_entry *entry, *e;
1821
1822 if (! bfd_elf64_add_dynamic_entry (info, DT_SPARC_REGISTER, 0))
1823 return false;
1824
1825 entry = (struct elf_link_local_dynamic_entry *)
1826 bfd_hash_allocate (&info->hash->table, sizeof (*entry));
1827 if (entry == NULL)
1828 return false;
1829
1830 /* We cheat here a little bit: the symbol will not be local, so we
1831 put it at the end of the dynlocal linked list. We will fix it
1832 later on, as we have to fix other fields anyway. */
1833 entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
1834 entry->isym.st_size = 0;
1835 if (*app_regs [reg].name != '\0')
1836 entry->isym.st_name
1837 = _bfd_stringtab_add (dynstr, app_regs[reg].name, true, false);
1838 else
1839 entry->isym.st_name = 0;
1840 entry->isym.st_other = 0;
1841 entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
1842 STT_REGISTER);
1843 entry->isym.st_shndx = app_regs [reg].shndx;
1844 entry->next = NULL;
1845 entry->input_bfd = output_bfd;
1846 entry->input_indx = -1;
1847
1848 if (eht->dynlocal == NULL)
1849 eht->dynlocal = entry;
1850 else
1851 {
1852 for (e = eht->dynlocal; e->next; e = e->next)
1853 ;
1854 e->next = entry;
1855 }
1856 eht->dynsymcount++;
1857 }
1858 }
1859
1860 return true;
1861 }
1862 \f
1863 #define SET_SEC_DO_RELAX(section) do { elf_section_data(section)->tdata = (void *)1; } while (0)
1864 #define SEC_DO_RELAX(section) (elf_section_data(section)->tdata == (void *)1)
1865
1866 static boolean
1867 sparc64_elf_relax_section (abfd, section, link_info, again)
1868 bfd *abfd ATTRIBUTE_UNUSED;
1869 asection *section ATTRIBUTE_UNUSED;
1870 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
1871 boolean *again;
1872 {
1873 *again = false;
1874 SET_SEC_DO_RELAX (section);
1875 return true;
1876 }
1877 \f
1878 /* Relocate a SPARC64 ELF section. */
1879
1880 static boolean
1881 sparc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1882 contents, relocs, local_syms, local_sections)
1883 bfd *output_bfd;
1884 struct bfd_link_info *info;
1885 bfd *input_bfd;
1886 asection *input_section;
1887 bfd_byte *contents;
1888 Elf_Internal_Rela *relocs;
1889 Elf_Internal_Sym *local_syms;
1890 asection **local_sections;
1891 {
1892 bfd *dynobj;
1893 Elf_Internal_Shdr *symtab_hdr;
1894 struct elf_link_hash_entry **sym_hashes;
1895 bfd_vma *local_got_offsets;
1896 bfd_vma got_base;
1897 asection *sgot;
1898 asection *splt;
1899 asection *sreloc;
1900 Elf_Internal_Rela *rel;
1901 Elf_Internal_Rela *relend;
1902
1903 dynobj = elf_hash_table (info)->dynobj;
1904 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1905 sym_hashes = elf_sym_hashes (input_bfd);
1906 local_got_offsets = elf_local_got_offsets (input_bfd);
1907
1908 if (elf_hash_table(info)->hgot == NULL)
1909 got_base = 0;
1910 else
1911 got_base = elf_hash_table (info)->hgot->root.u.def.value;
1912
1913 sgot = splt = sreloc = NULL;
1914
1915 rel = relocs;
1916 relend = relocs + NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
1917 for (; rel < relend; rel++)
1918 {
1919 int r_type;
1920 reloc_howto_type *howto;
1921 unsigned long r_symndx;
1922 struct elf_link_hash_entry *h;
1923 Elf_Internal_Sym *sym;
1924 asection *sec;
1925 bfd_vma relocation;
1926 bfd_reloc_status_type r;
1927
1928 r_type = ELF64_R_TYPE_ID (rel->r_info);
1929 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
1930 {
1931 bfd_set_error (bfd_error_bad_value);
1932 return false;
1933 }
1934 howto = sparc64_elf_howto_table + r_type;
1935
1936 r_symndx = ELF64_R_SYM (rel->r_info);
1937
1938 if (info->relocateable)
1939 {
1940 /* This is a relocateable link. We don't have to change
1941 anything, unless the reloc is against a section symbol,
1942 in which case we have to adjust according to where the
1943 section symbol winds up in the output section. */
1944 if (r_symndx < symtab_hdr->sh_info)
1945 {
1946 sym = local_syms + r_symndx;
1947 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1948 {
1949 sec = local_sections[r_symndx];
1950 rel->r_addend += sec->output_offset + sym->st_value;
1951 }
1952 }
1953
1954 continue;
1955 }
1956
1957 /* This is a final link. */
1958 h = NULL;
1959 sym = NULL;
1960 sec = NULL;
1961 if (r_symndx < symtab_hdr->sh_info)
1962 {
1963 sym = local_syms + r_symndx;
1964 sec = local_sections[r_symndx];
1965 relocation = (sec->output_section->vma
1966 + sec->output_offset
1967 + sym->st_value);
1968 }
1969 else
1970 {
1971 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1972 while (h->root.type == bfd_link_hash_indirect
1973 || h->root.type == bfd_link_hash_warning)
1974 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1975 if (h->root.type == bfd_link_hash_defined
1976 || h->root.type == bfd_link_hash_defweak)
1977 {
1978 boolean skip_it = false;
1979 sec = h->root.u.def.section;
1980
1981 switch (r_type)
1982 {
1983 case R_SPARC_WPLT30:
1984 case R_SPARC_PLT32:
1985 case R_SPARC_HIPLT22:
1986 case R_SPARC_LOPLT10:
1987 case R_SPARC_PCPLT32:
1988 case R_SPARC_PCPLT22:
1989 case R_SPARC_PCPLT10:
1990 case R_SPARC_PLT64:
1991 if (h->plt.offset != (bfd_vma) -1)
1992 skip_it = true;
1993 break;
1994
1995 case R_SPARC_GOT10:
1996 case R_SPARC_GOT13:
1997 case R_SPARC_GOT22:
1998 if (elf_hash_table(info)->dynamic_sections_created
1999 && (!info->shared
2000 || (!info->symbolic && h->dynindx != -1)
2001 || !(h->elf_link_hash_flags
2002 & ELF_LINK_HASH_DEF_REGULAR)))
2003 skip_it = true;
2004 break;
2005
2006 case R_SPARC_PC10:
2007 case R_SPARC_PC22:
2008 case R_SPARC_PC_HH22:
2009 case R_SPARC_PC_HM10:
2010 case R_SPARC_PC_LM22:
2011 if (!strcmp(h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
2012 break;
2013 /* FALLTHRU */
2014
2015 case R_SPARC_8:
2016 case R_SPARC_16:
2017 case R_SPARC_32:
2018 case R_SPARC_DISP8:
2019 case R_SPARC_DISP16:
2020 case R_SPARC_DISP32:
2021 case R_SPARC_WDISP30:
2022 case R_SPARC_WDISP22:
2023 case R_SPARC_HI22:
2024 case R_SPARC_22:
2025 case R_SPARC_13:
2026 case R_SPARC_LO10:
2027 case R_SPARC_UA32:
2028 case R_SPARC_10:
2029 case R_SPARC_11:
2030 case R_SPARC_64:
2031 case R_SPARC_OLO10:
2032 case R_SPARC_HH22:
2033 case R_SPARC_HM10:
2034 case R_SPARC_LM22:
2035 case R_SPARC_WDISP19:
2036 case R_SPARC_WDISP16:
2037 case R_SPARC_7:
2038 case R_SPARC_5:
2039 case R_SPARC_6:
2040 case R_SPARC_DISP64:
2041 case R_SPARC_HIX22:
2042 case R_SPARC_LOX10:
2043 case R_SPARC_H44:
2044 case R_SPARC_M44:
2045 case R_SPARC_L44:
2046 case R_SPARC_UA64:
2047 case R_SPARC_UA16:
2048 if (info->shared
2049 && ((!info->symbolic && h->dynindx != -1)
2050 || !(h->elf_link_hash_flags
2051 & ELF_LINK_HASH_DEF_REGULAR)))
2052 skip_it = true;
2053 break;
2054 }
2055
2056 if (skip_it)
2057 {
2058 /* In these cases, we don't need the relocation
2059 value. We check specially because in some
2060 obscure cases sec->output_section will be NULL. */
2061 relocation = 0;
2062 }
2063 else
2064 {
2065 relocation = (h->root.u.def.value
2066 + sec->output_section->vma
2067 + sec->output_offset);
2068 }
2069 }
2070 else if (h->root.type == bfd_link_hash_undefweak)
2071 relocation = 0;
2072 else if (info->shared && !info->symbolic
2073 && !info->no_undefined
2074 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2075 relocation = 0;
2076 else
2077 {
2078 if (! ((*info->callbacks->undefined_symbol)
2079 (info, h->root.root.string, input_bfd,
2080 input_section, rel->r_offset,
2081 (!info->shared || info->no_undefined
2082 || ELF_ST_VISIBILITY (h->other)))))
2083 return false;
2084
2085 /* To avoid generating warning messages about truncated
2086 relocations, set the relocation's address to be the same as
2087 the start of this section. */
2088
2089 if (input_section->output_section != NULL)
2090 relocation = input_section->output_section->vma;
2091 else
2092 relocation = 0;
2093 }
2094 }
2095
2096 /* When generating a shared object, these relocations are copied
2097 into the output file to be resolved at run time. */
2098 if (info->shared && (input_section->flags & SEC_ALLOC))
2099 {
2100 switch (r_type)
2101 {
2102 case R_SPARC_PC10:
2103 case R_SPARC_PC22:
2104 case R_SPARC_PC_HH22:
2105 case R_SPARC_PC_HM10:
2106 case R_SPARC_PC_LM22:
2107 if (h != NULL
2108 && !strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_"))
2109 break;
2110 /* Fall through. */
2111 case R_SPARC_DISP8:
2112 case R_SPARC_DISP16:
2113 case R_SPARC_DISP32:
2114 case R_SPARC_WDISP30:
2115 case R_SPARC_WDISP22:
2116 case R_SPARC_WDISP19:
2117 case R_SPARC_WDISP16:
2118 case R_SPARC_DISP64:
2119 if (h == NULL)
2120 break;
2121 /* Fall through. */
2122 case R_SPARC_8:
2123 case R_SPARC_16:
2124 case R_SPARC_32:
2125 case R_SPARC_HI22:
2126 case R_SPARC_22:
2127 case R_SPARC_13:
2128 case R_SPARC_LO10:
2129 case R_SPARC_UA32:
2130 case R_SPARC_10:
2131 case R_SPARC_11:
2132 case R_SPARC_64:
2133 case R_SPARC_OLO10:
2134 case R_SPARC_HH22:
2135 case R_SPARC_HM10:
2136 case R_SPARC_LM22:
2137 case R_SPARC_7:
2138 case R_SPARC_5:
2139 case R_SPARC_6:
2140 case R_SPARC_HIX22:
2141 case R_SPARC_LOX10:
2142 case R_SPARC_H44:
2143 case R_SPARC_M44:
2144 case R_SPARC_L44:
2145 case R_SPARC_UA64:
2146 case R_SPARC_UA16:
2147 {
2148 Elf_Internal_Rela outrel;
2149 boolean skip;
2150
2151 if (sreloc == NULL)
2152 {
2153 const char *name =
2154 (bfd_elf_string_from_elf_section
2155 (input_bfd,
2156 elf_elfheader (input_bfd)->e_shstrndx,
2157 elf_section_data (input_section)->rel_hdr.sh_name));
2158
2159 if (name == NULL)
2160 return false;
2161
2162 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2163 && strcmp (bfd_get_section_name(input_bfd,
2164 input_section),
2165 name + 5) == 0);
2166
2167 sreloc = bfd_get_section_by_name (dynobj, name);
2168 BFD_ASSERT (sreloc != NULL);
2169 }
2170
2171 skip = false;
2172
2173 if (elf_section_data (input_section)->stab_info == NULL)
2174 outrel.r_offset = rel->r_offset;
2175 else
2176 {
2177 bfd_vma off;
2178
2179 off = (_bfd_stab_section_offset
2180 (output_bfd, &elf_hash_table (info)->stab_info,
2181 input_section,
2182 &elf_section_data (input_section)->stab_info,
2183 rel->r_offset));
2184 if (off == MINUS_ONE)
2185 skip = true;
2186 outrel.r_offset = off;
2187 }
2188
2189 outrel.r_offset += (input_section->output_section->vma
2190 + input_section->output_offset);
2191
2192 /* Optimize unaligned reloc usage now that we know where
2193 it finally resides. */
2194 switch (r_type)
2195 {
2196 case R_SPARC_16:
2197 if (outrel.r_offset & 1) r_type = R_SPARC_UA16;
2198 break;
2199 case R_SPARC_UA16:
2200 if (!(outrel.r_offset & 1)) r_type = R_SPARC_16;
2201 break;
2202 case R_SPARC_32:
2203 if (outrel.r_offset & 3) r_type = R_SPARC_UA32;
2204 break;
2205 case R_SPARC_UA32:
2206 if (!(outrel.r_offset & 3)) r_type = R_SPARC_32;
2207 break;
2208 case R_SPARC_64:
2209 if (outrel.r_offset & 7) r_type = R_SPARC_UA64;
2210 break;
2211 case R_SPARC_UA64:
2212 if (!(outrel.r_offset & 7)) r_type = R_SPARC_64;
2213 break;
2214 }
2215
2216 if (skip)
2217 memset (&outrel, 0, sizeof outrel);
2218 /* h->dynindx may be -1 if the symbol was marked to
2219 become local. */
2220 else if (h != NULL
2221 && ((! info->symbolic && h->dynindx != -1)
2222 || (h->elf_link_hash_flags
2223 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2224 {
2225 BFD_ASSERT (h->dynindx != -1);
2226 outrel.r_info
2227 = ELF64_R_INFO (h->dynindx,
2228 ELF64_R_TYPE_INFO (
2229 ELF64_R_TYPE_DATA (rel->r_info),
2230 r_type));
2231 outrel.r_addend = rel->r_addend;
2232 }
2233 else
2234 {
2235 if (r_type == R_SPARC_64)
2236 {
2237 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2238 outrel.r_addend = relocation + rel->r_addend;
2239 }
2240 else
2241 {
2242 long indx;
2243
2244 if (h == NULL)
2245 sec = local_sections[r_symndx];
2246 else
2247 {
2248 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2249 || (h->root.type
2250 == bfd_link_hash_defweak));
2251 sec = h->root.u.def.section;
2252 }
2253 if (sec != NULL && bfd_is_abs_section (sec))
2254 indx = 0;
2255 else if (sec == NULL || sec->owner == NULL)
2256 {
2257 bfd_set_error (bfd_error_bad_value);
2258 return false;
2259 }
2260 else
2261 {
2262 asection *osec;
2263
2264 osec = sec->output_section;
2265 indx = elf_section_data (osec)->dynindx;
2266
2267 /* FIXME: we really should be able to link non-pic
2268 shared libraries. */
2269 if (indx == 0)
2270 {
2271 BFD_FAIL ();
2272 (*_bfd_error_handler)
2273 (_("%s: probably compiled without -fPIC?"),
2274 bfd_get_filename (input_bfd));
2275 bfd_set_error (bfd_error_bad_value);
2276 return false;
2277 }
2278 }
2279
2280 outrel.r_info
2281 = ELF64_R_INFO (indx,
2282 ELF64_R_TYPE_INFO (
2283 ELF64_R_TYPE_DATA (rel->r_info),
2284 r_type));
2285 outrel.r_addend = relocation + rel->r_addend;
2286 }
2287 }
2288
2289 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
2290 (((Elf64_External_Rela *)
2291 sreloc->contents)
2292 + sreloc->reloc_count));
2293 ++sreloc->reloc_count;
2294
2295 /* This reloc will be computed at runtime, so there's no
2296 need to do anything now. */
2297 continue;
2298 }
2299 break;
2300 }
2301 }
2302
2303 switch (r_type)
2304 {
2305 case R_SPARC_GOT10:
2306 case R_SPARC_GOT13:
2307 case R_SPARC_GOT22:
2308 /* Relocation is to the entry for this symbol in the global
2309 offset table. */
2310 if (sgot == NULL)
2311 {
2312 sgot = bfd_get_section_by_name (dynobj, ".got");
2313 BFD_ASSERT (sgot != NULL);
2314 }
2315
2316 if (h != NULL)
2317 {
2318 bfd_vma off = h->got.offset;
2319 BFD_ASSERT (off != (bfd_vma) -1);
2320
2321 if (! elf_hash_table (info)->dynamic_sections_created
2322 || (info->shared
2323 && (info->symbolic || h->dynindx == -1)
2324 && (h->elf_link_hash_flags
2325 & ELF_LINK_HASH_DEF_REGULAR)))
2326 {
2327 /* This is actually a static link, or it is a -Bsymbolic
2328 link and the symbol is defined locally, or the symbol
2329 was forced to be local because of a version file. We
2330 must initialize this entry in the global offset table.
2331 Since the offset must always be a multiple of 8, we
2332 use the least significant bit to record whether we
2333 have initialized it already.
2334
2335 When doing a dynamic link, we create a .rela.got
2336 relocation entry to initialize the value. This is
2337 done in the finish_dynamic_symbol routine. */
2338
2339 if ((off & 1) != 0)
2340 off &= ~1;
2341 else
2342 {
2343 bfd_put_64 (output_bfd, relocation,
2344 sgot->contents + off);
2345 h->got.offset |= 1;
2346 }
2347 }
2348 relocation = sgot->output_offset + off - got_base;
2349 }
2350 else
2351 {
2352 bfd_vma off;
2353
2354 BFD_ASSERT (local_got_offsets != NULL);
2355 off = local_got_offsets[r_symndx];
2356 BFD_ASSERT (off != (bfd_vma) -1);
2357
2358 /* The offset must always be a multiple of 8. We use
2359 the least significant bit to record whether we have
2360 already processed this entry. */
2361 if ((off & 1) != 0)
2362 off &= ~1;
2363 else
2364 {
2365 local_got_offsets[r_symndx] |= 1;
2366
2367 if (info->shared)
2368 {
2369 asection *srelgot;
2370 Elf_Internal_Rela outrel;
2371
2372 /* The Solaris 2.7 64-bit linker adds the contents
2373 of the location to the value of the reloc.
2374 Note this is different behaviour to the
2375 32-bit linker, which both adds the contents
2376 and ignores the addend. So clear the location. */
2377 bfd_put_64 (output_bfd, 0, sgot->contents + off);
2378
2379 /* We need to generate a R_SPARC_RELATIVE reloc
2380 for the dynamic linker. */
2381 srelgot = bfd_get_section_by_name(dynobj, ".rela.got");
2382 BFD_ASSERT (srelgot != NULL);
2383
2384 outrel.r_offset = (sgot->output_section->vma
2385 + sgot->output_offset
2386 + off);
2387 outrel.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2388 outrel.r_addend = relocation;
2389 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
2390 (((Elf64_External_Rela *)
2391 srelgot->contents)
2392 + srelgot->reloc_count));
2393 ++srelgot->reloc_count;
2394 }
2395 else
2396 bfd_put_64 (output_bfd, relocation, sgot->contents + off);
2397 }
2398 relocation = sgot->output_offset + off - got_base;
2399 }
2400 goto do_default;
2401
2402 case R_SPARC_WPLT30:
2403 case R_SPARC_PLT32:
2404 case R_SPARC_HIPLT22:
2405 case R_SPARC_LOPLT10:
2406 case R_SPARC_PCPLT32:
2407 case R_SPARC_PCPLT22:
2408 case R_SPARC_PCPLT10:
2409 case R_SPARC_PLT64:
2410 /* Relocation is to the entry for this symbol in the
2411 procedure linkage table. */
2412 BFD_ASSERT (h != NULL);
2413
2414 if (h->plt.offset == (bfd_vma) -1)
2415 {
2416 /* We didn't make a PLT entry for this symbol. This
2417 happens when statically linking PIC code, or when
2418 using -Bsymbolic. */
2419 goto do_default;
2420 }
2421
2422 if (splt == NULL)
2423 {
2424 splt = bfd_get_section_by_name (dynobj, ".plt");
2425 BFD_ASSERT (splt != NULL);
2426 }
2427
2428 relocation = (splt->output_section->vma
2429 + splt->output_offset
2430 + sparc64_elf_plt_entry_offset (h->plt.offset));
2431 if (r_type == R_SPARC_WPLT30)
2432 goto do_wplt30;
2433 goto do_default;
2434
2435 case R_SPARC_OLO10:
2436 {
2437 bfd_vma x;
2438
2439 relocation += rel->r_addend;
2440 relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
2441
2442 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2443 x = (x & ~0x1fff) | (relocation & 0x1fff);
2444 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2445
2446 r = bfd_check_overflow (howto->complain_on_overflow,
2447 howto->bitsize, howto->rightshift,
2448 bfd_arch_bits_per_address (input_bfd),
2449 relocation);
2450 }
2451 break;
2452
2453 case R_SPARC_WDISP16:
2454 {
2455 bfd_vma x;
2456
2457 relocation += rel->r_addend;
2458 /* Adjust for pc-relative-ness. */
2459 relocation -= (input_section->output_section->vma
2460 + input_section->output_offset);
2461 relocation -= rel->r_offset;
2462
2463 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2464 x = (x & ~0x303fff) | ((((relocation >> 2) & 0xc000) << 6)
2465 | ((relocation >> 2) & 0x3fff));
2466 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2467
2468 r = bfd_check_overflow (howto->complain_on_overflow,
2469 howto->bitsize, howto->rightshift,
2470 bfd_arch_bits_per_address (input_bfd),
2471 relocation);
2472 }
2473 break;
2474
2475 case R_SPARC_HIX22:
2476 {
2477 bfd_vma x;
2478
2479 relocation += rel->r_addend;
2480 relocation = relocation ^ MINUS_ONE;
2481
2482 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2483 x = (x & ~0x3fffff) | ((relocation >> 10) & 0x3fffff);
2484 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2485
2486 r = bfd_check_overflow (howto->complain_on_overflow,
2487 howto->bitsize, howto->rightshift,
2488 bfd_arch_bits_per_address (input_bfd),
2489 relocation);
2490 }
2491 break;
2492
2493 case R_SPARC_LOX10:
2494 {
2495 bfd_vma x;
2496
2497 relocation += rel->r_addend;
2498 relocation = (relocation & 0x3ff) | 0x1c00;
2499
2500 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2501 x = (x & ~0x1fff) | relocation;
2502 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2503
2504 r = bfd_reloc_ok;
2505 }
2506 break;
2507
2508 case R_SPARC_WDISP30:
2509 do_wplt30:
2510 if (SEC_DO_RELAX (input_section)
2511 && rel->r_offset + 4 < input_section->_raw_size)
2512 {
2513 #define G0 0
2514 #define O7 15
2515 #define XCC (2 << 20)
2516 #define COND(x) (((x)&0xf)<<25)
2517 #define CONDA COND(0x8)
2518 #define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
2519 #define INSN_BA (F2(0,2) | CONDA)
2520 #define INSN_OR F3(2, 0x2, 0)
2521 #define INSN_NOP F2(0,4)
2522
2523 bfd_vma x, y;
2524
2525 /* If the instruction is a call with either:
2526 restore
2527 arithmetic instruction with rd == %o7
2528 where rs1 != %o7 and rs2 if it is register != %o7
2529 then we can optimize if the call destination is near
2530 by changing the call into a branch always. */
2531 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2532 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2533 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2534 {
2535 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2536 || ((y & OP3(0x28)) == 0 /* arithmetic */
2537 && (y & RD(~0)) == RD(O7)))
2538 && (y & RS1(~0)) != RS1(O7)
2539 && ((y & F3I(~0))
2540 || (y & RS2(~0)) != RS2(O7)))
2541 {
2542 bfd_vma reloc;
2543
2544 reloc = relocation + rel->r_addend - rel->r_offset;
2545 reloc -= (input_section->output_section->vma
2546 + input_section->output_offset);
2547 if (reloc & 3)
2548 goto do_default;
2549
2550 /* Ensure the branch fits into simm22. */
2551 if ((reloc & ~(bfd_vma)0x7fffff)
2552 && ((reloc | 0x7fffff) != MINUS_ONE))
2553 goto do_default;
2554 reloc >>= 2;
2555
2556 /* Check whether it fits into simm19. */
2557 if ((reloc & 0x3c0000) == 0
2558 || (reloc & 0x3c0000) == 0x3c0000)
2559 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2560 else
2561 x = INSN_BA | (reloc & 0x3fffff); /* ba */
2562 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2563 r = bfd_reloc_ok;
2564 if (rel->r_offset >= 4
2565 && (y & (0xffffffff ^ RS1(~0)))
2566 == (INSN_OR | RD(O7) | RS2(G0)))
2567 {
2568 bfd_vma z;
2569 unsigned int reg;
2570
2571 z = bfd_get_32 (input_bfd,
2572 contents + rel->r_offset - 4);
2573 if ((z & (0xffffffff ^ RD(~0)))
2574 != (INSN_OR | RS1(O7) | RS2(G0)))
2575 break;
2576
2577 /* The sequence was
2578 or %o7, %g0, %rN
2579 call foo
2580 or %rN, %g0, %o7
2581
2582 If call foo was replaced with ba, replace
2583 or %rN, %g0, %o7 with nop. */
2584
2585 reg = (y & RS1(~0)) >> 14;
2586 if (reg != ((z & RD(~0)) >> 25)
2587 || reg == G0 || reg == O7)
2588 break;
2589
2590 bfd_put_32 (input_bfd, INSN_NOP,
2591 contents + rel->r_offset + 4);
2592 }
2593 break;
2594 }
2595 }
2596 }
2597 /* FALLTHROUGH */
2598
2599 default:
2600 do_default:
2601 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2602 contents, rel->r_offset,
2603 relocation, rel->r_addend);
2604 break;
2605 }
2606
2607 switch (r)
2608 {
2609 case bfd_reloc_ok:
2610 break;
2611
2612 default:
2613 case bfd_reloc_outofrange:
2614 abort ();
2615
2616 case bfd_reloc_overflow:
2617 {
2618 const char *name;
2619
2620 if (h != NULL)
2621 {
2622 if (h->root.type == bfd_link_hash_undefweak
2623 && howto->pc_relative)
2624 {
2625 /* Assume this is a call protected by other code that
2626 detect the symbol is undefined. If this is the case,
2627 we can safely ignore the overflow. If not, the
2628 program is hosed anyway, and a little warning isn't
2629 going to help. */
2630 break;
2631 }
2632
2633 name = h->root.root.string;
2634 }
2635 else
2636 {
2637 name = (bfd_elf_string_from_elf_section
2638 (input_bfd,
2639 symtab_hdr->sh_link,
2640 sym->st_name));
2641 if (name == NULL)
2642 return false;
2643 if (*name == '\0')
2644 name = bfd_section_name (input_bfd, sec);
2645 }
2646 if (! ((*info->callbacks->reloc_overflow)
2647 (info, name, howto->name, (bfd_vma) 0,
2648 input_bfd, input_section, rel->r_offset)))
2649 return false;
2650 }
2651 break;
2652 }
2653 }
2654
2655 return true;
2656 }
2657
2658 /* Finish up dynamic symbol handling. We set the contents of various
2659 dynamic sections here. */
2660
2661 static boolean
2662 sparc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
2663 bfd *output_bfd;
2664 struct bfd_link_info *info;
2665 struct elf_link_hash_entry *h;
2666 Elf_Internal_Sym *sym;
2667 {
2668 bfd *dynobj;
2669
2670 dynobj = elf_hash_table (info)->dynobj;
2671
2672 if (h->plt.offset != (bfd_vma) -1)
2673 {
2674 asection *splt;
2675 asection *srela;
2676 Elf_Internal_Rela rela;
2677
2678 /* This symbol has an entry in the PLT. Set it up. */
2679
2680 BFD_ASSERT (h->dynindx != -1);
2681
2682 splt = bfd_get_section_by_name (dynobj, ".plt");
2683 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2684 BFD_ASSERT (splt != NULL && srela != NULL);
2685
2686 /* Fill in the entry in the .rela.plt section. */
2687
2688 if (h->plt.offset < LARGE_PLT_THRESHOLD)
2689 {
2690 rela.r_offset = sparc64_elf_plt_entry_offset (h->plt.offset);
2691 rela.r_addend = 0;
2692 }
2693 else
2694 {
2695 int max = splt->_raw_size / PLT_ENTRY_SIZE;
2696 rela.r_offset = sparc64_elf_plt_ptr_offset (h->plt.offset, max);
2697 rela.r_addend = -(sparc64_elf_plt_entry_offset (h->plt.offset) + 4)
2698 -(splt->output_section->vma + splt->output_offset);
2699 }
2700 rela.r_offset += (splt->output_section->vma + splt->output_offset);
2701 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
2702
2703 /* Adjust for the first 4 reserved elements in the .plt section
2704 when setting the offset in the .rela.plt section.
2705 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
2706 thus .plt[4] has corresponding .rela.plt[0] and so on. */
2707
2708 bfd_elf64_swap_reloca_out (output_bfd, &rela,
2709 ((Elf64_External_Rela *) srela->contents
2710 + (h->plt.offset - 4)));
2711
2712 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2713 {
2714 /* Mark the symbol as undefined, rather than as defined in
2715 the .plt section. Leave the value alone. */
2716 sym->st_shndx = SHN_UNDEF;
2717 /* If the symbol is weak, we do need to clear the value.
2718 Otherwise, the PLT entry would provide a definition for
2719 the symbol even if the symbol wasn't defined anywhere,
2720 and so the symbol would never be NULL. */
2721 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
2722 == 0)
2723 sym->st_value = 0;
2724 }
2725 }
2726
2727 if (h->got.offset != (bfd_vma) -1)
2728 {
2729 asection *sgot;
2730 asection *srela;
2731 Elf_Internal_Rela rela;
2732
2733 /* This symbol has an entry in the GOT. Set it up. */
2734
2735 sgot = bfd_get_section_by_name (dynobj, ".got");
2736 srela = bfd_get_section_by_name (dynobj, ".rela.got");
2737 BFD_ASSERT (sgot != NULL && srela != NULL);
2738
2739 rela.r_offset = (sgot->output_section->vma
2740 + sgot->output_offset
2741 + (h->got.offset &~ 1));
2742
2743 /* If this is a -Bsymbolic link, and the symbol is defined
2744 locally, we just want to emit a RELATIVE reloc. Likewise if
2745 the symbol was forced to be local because of a version file.
2746 The entry in the global offset table will already have been
2747 initialized in the relocate_section function. */
2748 if (info->shared
2749 && (info->symbolic || h->dynindx == -1)
2750 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2751 {
2752 asection *sec = h->root.u.def.section;
2753 rela.r_info = ELF64_R_INFO (0, R_SPARC_RELATIVE);
2754 rela.r_addend = (h->root.u.def.value
2755 + sec->output_section->vma
2756 + sec->output_offset);
2757 }
2758 else
2759 {
2760 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2761 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
2762 rela.r_addend = 0;
2763 }
2764
2765 bfd_elf64_swap_reloca_out (output_bfd, &rela,
2766 ((Elf64_External_Rela *) srela->contents
2767 + srela->reloc_count));
2768 ++srela->reloc_count;
2769 }
2770
2771 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2772 {
2773 asection *s;
2774 Elf_Internal_Rela rela;
2775
2776 /* This symbols needs a copy reloc. Set it up. */
2777
2778 BFD_ASSERT (h->dynindx != -1);
2779
2780 s = bfd_get_section_by_name (h->root.u.def.section->owner,
2781 ".rela.bss");
2782 BFD_ASSERT (s != NULL);
2783
2784 rela.r_offset = (h->root.u.def.value
2785 + h->root.u.def.section->output_section->vma
2786 + h->root.u.def.section->output_offset);
2787 rela.r_info = ELF64_R_INFO (h->dynindx, R_SPARC_COPY);
2788 rela.r_addend = 0;
2789 bfd_elf64_swap_reloca_out (output_bfd, &rela,
2790 ((Elf64_External_Rela *) s->contents
2791 + s->reloc_count));
2792 ++s->reloc_count;
2793 }
2794
2795 /* Mark some specially defined symbols as absolute. */
2796 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2797 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2798 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2799 sym->st_shndx = SHN_ABS;
2800
2801 return true;
2802 }
2803
2804 /* Finish up the dynamic sections. */
2805
2806 static boolean
2807 sparc64_elf_finish_dynamic_sections (output_bfd, info)
2808 bfd *output_bfd;
2809 struct bfd_link_info *info;
2810 {
2811 bfd *dynobj;
2812 int stt_regidx = -1;
2813 asection *sdyn;
2814 asection *sgot;
2815
2816 dynobj = elf_hash_table (info)->dynobj;
2817
2818 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2819
2820 if (elf_hash_table (info)->dynamic_sections_created)
2821 {
2822 asection *splt;
2823 Elf64_External_Dyn *dyncon, *dynconend;
2824
2825 splt = bfd_get_section_by_name (dynobj, ".plt");
2826 BFD_ASSERT (splt != NULL && sdyn != NULL);
2827
2828 dyncon = (Elf64_External_Dyn *) sdyn->contents;
2829 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2830 for (; dyncon < dynconend; dyncon++)
2831 {
2832 Elf_Internal_Dyn dyn;
2833 const char *name;
2834 boolean size;
2835
2836 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2837
2838 switch (dyn.d_tag)
2839 {
2840 case DT_PLTGOT: name = ".plt"; size = false; break;
2841 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
2842 case DT_JMPREL: name = ".rela.plt"; size = false; break;
2843 case DT_SPARC_REGISTER:
2844 if (stt_regidx == -1)
2845 {
2846 stt_regidx =
2847 _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
2848 if (stt_regidx == -1)
2849 return false;
2850 }
2851 dyn.d_un.d_val = stt_regidx++;
2852 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2853 /* fallthrough */
2854 default: name = NULL; size = false; break;
2855 }
2856
2857 if (name != NULL)
2858 {
2859 asection *s;
2860
2861 s = bfd_get_section_by_name (output_bfd, name);
2862 if (s == NULL)
2863 dyn.d_un.d_val = 0;
2864 else
2865 {
2866 if (! size)
2867 dyn.d_un.d_ptr = s->vma;
2868 else
2869 {
2870 if (s->_cooked_size != 0)
2871 dyn.d_un.d_val = s->_cooked_size;
2872 else
2873 dyn.d_un.d_val = s->_raw_size;
2874 }
2875 }
2876 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2877 }
2878 }
2879
2880 /* Initialize the contents of the .plt section. */
2881 if (splt->_raw_size > 0)
2882 {
2883 sparc64_elf_build_plt(output_bfd, splt->contents,
2884 splt->_raw_size / PLT_ENTRY_SIZE);
2885 }
2886
2887 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
2888 PLT_ENTRY_SIZE;
2889 }
2890
2891 /* Set the first entry in the global offset table to the address of
2892 the dynamic section. */
2893 sgot = bfd_get_section_by_name (dynobj, ".got");
2894 BFD_ASSERT (sgot != NULL);
2895 if (sgot->_raw_size > 0)
2896 {
2897 if (sdyn == NULL)
2898 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
2899 else
2900 bfd_put_64 (output_bfd,
2901 sdyn->output_section->vma + sdyn->output_offset,
2902 sgot->contents);
2903 }
2904
2905 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
2906
2907 return true;
2908 }
2909 \f
2910 /* Functions for dealing with the e_flags field. */
2911
2912 /* Copy backend specific data from one object module to another */
2913 static boolean
2914 sparc64_elf_copy_private_bfd_data (ibfd, obfd)
2915 bfd *ibfd, *obfd;
2916 {
2917 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2918 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2919 return true;
2920
2921 BFD_ASSERT (!elf_flags_init (obfd)
2922 || (elf_elfheader (obfd)->e_flags
2923 == elf_elfheader (ibfd)->e_flags));
2924
2925 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2926 elf_flags_init (obfd) = true;
2927 return true;
2928 }
2929
2930 /* Merge backend specific data from an object file to the output
2931 object file when linking. */
2932
2933 static boolean
2934 sparc64_elf_merge_private_bfd_data (ibfd, obfd)
2935 bfd *ibfd;
2936 bfd *obfd;
2937 {
2938 boolean error;
2939 flagword new_flags, old_flags;
2940 int new_mm, old_mm;
2941
2942 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2943 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2944 return true;
2945
2946 new_flags = elf_elfheader (ibfd)->e_flags;
2947 old_flags = elf_elfheader (obfd)->e_flags;
2948
2949 if (!elf_flags_init (obfd)) /* First call, no flags set */
2950 {
2951 elf_flags_init (obfd) = true;
2952 elf_elfheader (obfd)->e_flags = new_flags;
2953 }
2954
2955 else if (new_flags == old_flags) /* Compatible flags are ok */
2956 ;
2957
2958 else /* Incompatible flags */
2959 {
2960 error = false;
2961
2962 #define EF_SPARC_ISA_EXTENSIONS \
2963 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
2964
2965 if ((ibfd->flags & DYNAMIC) != 0)
2966 {
2967 /* We don't want dynamic objects memory ordering and
2968 architecture to have any role. That's what dynamic linker
2969 should do. */
2970 new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
2971 new_flags |= (old_flags
2972 & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
2973 }
2974 else
2975 {
2976 /* Choose the highest architecture requirements. */
2977 old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
2978 new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
2979 if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
2980 && (old_flags & EF_SPARC_HAL_R1))
2981 {
2982 error = true;
2983 (*_bfd_error_handler)
2984 (_("%s: linking UltraSPARC specific with HAL specific code"),
2985 bfd_get_filename (ibfd));
2986 }
2987 /* Choose the most restrictive memory ordering. */
2988 old_mm = (old_flags & EF_SPARCV9_MM);
2989 new_mm = (new_flags & EF_SPARCV9_MM);
2990 old_flags &= ~EF_SPARCV9_MM;
2991 new_flags &= ~EF_SPARCV9_MM;
2992 if (new_mm < old_mm)
2993 old_mm = new_mm;
2994 old_flags |= old_mm;
2995 new_flags |= old_mm;
2996 }
2997
2998 /* Warn about any other mismatches */
2999 if (new_flags != old_flags)
3000 {
3001 error = true;
3002 (*_bfd_error_handler)
3003 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
3004 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
3005 }
3006
3007 elf_elfheader (obfd)->e_flags = old_flags;
3008
3009 if (error)
3010 {
3011 bfd_set_error (bfd_error_bad_value);
3012 return false;
3013 }
3014 }
3015 return true;
3016 }
3017 \f
3018 /* Print a STT_REGISTER symbol to file FILE. */
3019
3020 static const char *
3021 sparc64_elf_print_symbol_all (abfd, filep, symbol)
3022 bfd *abfd ATTRIBUTE_UNUSED;
3023 PTR filep;
3024 asymbol *symbol;
3025 {
3026 FILE *file = (FILE *) filep;
3027 int reg, type;
3028
3029 if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
3030 != STT_REGISTER)
3031 return NULL;
3032
3033 reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
3034 type = symbol->flags;
3035 fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "",
3036 ((type & BSF_LOCAL)
3037 ? (type & BSF_GLOBAL) ? '!' : 'l'
3038 : (type & BSF_GLOBAL) ? 'g' : ' '),
3039 (type & BSF_WEAK) ? 'w' : ' ');
3040 if (symbol->name == NULL || symbol->name [0] == '\0')
3041 return "#scratch";
3042 else
3043 return symbol->name;
3044 }
3045 \f
3046 /* Set the right machine number for a SPARC64 ELF file. */
3047
3048 static boolean
3049 sparc64_elf_object_p (abfd)
3050 bfd *abfd;
3051 {
3052 unsigned long mach = bfd_mach_sparc_v9;
3053
3054 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3055 mach = bfd_mach_sparc_v9b;
3056 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
3057 mach = bfd_mach_sparc_v9a;
3058 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
3059 }
3060
3061 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
3062 standard ELF, because R_SPARC_OLO10 has secondary addend in
3063 ELF64_R_TYPE_DATA field. This structure is used to redirect the
3064 relocation handling routines. */
3065
3066 const struct elf_size_info sparc64_elf_size_info =
3067 {
3068 sizeof (Elf64_External_Ehdr),
3069 sizeof (Elf64_External_Phdr),
3070 sizeof (Elf64_External_Shdr),
3071 sizeof (Elf64_External_Rel),
3072 sizeof (Elf64_External_Rela),
3073 sizeof (Elf64_External_Sym),
3074 sizeof (Elf64_External_Dyn),
3075 sizeof (Elf_External_Note),
3076 4, /* hash-table entry size */
3077 /* internal relocations per external relocations.
3078 For link purposes we use just 1 internal per
3079 1 external, for assembly and slurp symbol table
3080 we use 2. */
3081 1,
3082 64, /* arch_size */
3083 8, /* file_align */
3084 ELFCLASS64,
3085 EV_CURRENT,
3086 bfd_elf64_write_out_phdrs,
3087 bfd_elf64_write_shdrs_and_ehdr,
3088 sparc64_elf_write_relocs,
3089 bfd_elf64_swap_symbol_out,
3090 sparc64_elf_slurp_reloc_table,
3091 bfd_elf64_slurp_symbol_table,
3092 bfd_elf64_swap_dyn_in,
3093 bfd_elf64_swap_dyn_out,
3094 NULL,
3095 NULL,
3096 NULL,
3097 NULL
3098 };
3099
3100 #define TARGET_BIG_SYM bfd_elf64_sparc_vec
3101 #define TARGET_BIG_NAME "elf64-sparc"
3102 #define ELF_ARCH bfd_arch_sparc
3103 #define ELF_MAXPAGESIZE 0x100000
3104
3105 /* This is the official ABI value. */
3106 #define ELF_MACHINE_CODE EM_SPARCV9
3107
3108 /* This is the value that we used before the ABI was released. */
3109 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
3110
3111 #define bfd_elf64_bfd_link_hash_table_create \
3112 sparc64_elf_bfd_link_hash_table_create
3113
3114 #define elf_info_to_howto \
3115 sparc64_elf_info_to_howto
3116 #define bfd_elf64_get_reloc_upper_bound \
3117 sparc64_elf_get_reloc_upper_bound
3118 #define bfd_elf64_get_dynamic_reloc_upper_bound \
3119 sparc64_elf_get_dynamic_reloc_upper_bound
3120 #define bfd_elf64_canonicalize_dynamic_reloc \
3121 sparc64_elf_canonicalize_dynamic_reloc
3122 #define bfd_elf64_bfd_reloc_type_lookup \
3123 sparc64_elf_reloc_type_lookup
3124 #define bfd_elf64_bfd_relax_section \
3125 sparc64_elf_relax_section
3126
3127 #define elf_backend_create_dynamic_sections \
3128 _bfd_elf_create_dynamic_sections
3129 #define elf_backend_add_symbol_hook \
3130 sparc64_elf_add_symbol_hook
3131 #define elf_backend_get_symbol_type \
3132 sparc64_elf_get_symbol_type
3133 #define elf_backend_symbol_processing \
3134 sparc64_elf_symbol_processing
3135 #define elf_backend_check_relocs \
3136 sparc64_elf_check_relocs
3137 #define elf_backend_adjust_dynamic_symbol \
3138 sparc64_elf_adjust_dynamic_symbol
3139 #define elf_backend_size_dynamic_sections \
3140 sparc64_elf_size_dynamic_sections
3141 #define elf_backend_relocate_section \
3142 sparc64_elf_relocate_section
3143 #define elf_backend_finish_dynamic_symbol \
3144 sparc64_elf_finish_dynamic_symbol
3145 #define elf_backend_finish_dynamic_sections \
3146 sparc64_elf_finish_dynamic_sections
3147 #define elf_backend_print_symbol_all \
3148 sparc64_elf_print_symbol_all
3149 #define elf_backend_output_arch_syms \
3150 sparc64_elf_output_arch_syms
3151 #define bfd_elf64_bfd_copy_private_bfd_data \
3152 sparc64_elf_copy_private_bfd_data
3153 #define bfd_elf64_bfd_merge_private_bfd_data \
3154 sparc64_elf_merge_private_bfd_data
3155
3156 #define elf_backend_size_info \
3157 sparc64_elf_size_info
3158 #define elf_backend_object_p \
3159 sparc64_elf_object_p
3160
3161 #define elf_backend_want_got_plt 0
3162 #define elf_backend_plt_readonly 0
3163 #define elf_backend_want_plt_sym 1
3164
3165 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
3166 #define elf_backend_plt_alignment 8
3167
3168 #define elf_backend_got_header_size 8
3169 #define elf_backend_plt_header_size PLT_HEADER_SIZE
3170
3171 #include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.123873 seconds and 4 git commands to generate.