1 /* SPARC-specific support for ELF
2    Copyright 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
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 3 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., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21 
22 
23 /* This file handles functionality common to the different SPARC ABI's.  */
24 
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "libiberty.h"
30 #include "elf-bfd.h"
31 #include "elf/sparc.h"
32 #include "opcode/sparc.h"
33 #include "elfxx-sparc.h"
34 #include "elf-vxworks.h"
35 #include "objalloc.h"
36 #include "hashtab.h"
37 
38 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
39 #define MINUS_ONE (~ (bfd_vma) 0)
40 
41 #define ABI_64_P(abfd) \
42   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
43 
44 /* The relocation "howto" table.  */
45 
46 /* Utility for performing the standard initial work of an instruction
47    relocation.
48    *PRELOCATION will contain the relocated item.
49    *PINSN will contain the instruction from the input stream.
50    If the result is `bfd_reloc_other' the caller can continue with
51    performing the relocation.  Otherwise it must stop and return the
52    value to its caller.  */
53 
54 static bfd_reloc_status_type
init_insn_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,bfd_vma * prelocation,bfd_vma * pinsn)55 init_insn_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
56 		 void * data, asection *input_section, bfd *output_bfd,
57 		 bfd_vma *prelocation, bfd_vma *pinsn)
58 {
59   bfd_vma relocation;
60   reloc_howto_type *howto = reloc_entry->howto;
61 
62   if (output_bfd != (bfd *) NULL
63       && (symbol->flags & BSF_SECTION_SYM) == 0
64       && (! howto->partial_inplace
65 	  || reloc_entry->addend == 0))
66     {
67       reloc_entry->address += input_section->output_offset;
68       return bfd_reloc_ok;
69     }
70 
71   /* This works because partial_inplace is FALSE.  */
72   if (output_bfd != NULL)
73     return bfd_reloc_continue;
74 
75   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
76     return bfd_reloc_outofrange;
77 
78   relocation = (symbol->value
79 		+ symbol->section->output_section->vma
80 		+ symbol->section->output_offset);
81   relocation += reloc_entry->addend;
82   if (howto->pc_relative)
83     {
84       relocation -= (input_section->output_section->vma
85 		     + input_section->output_offset);
86       relocation -= reloc_entry->address;
87     }
88 
89   *prelocation = relocation;
90   *pinsn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
91   return bfd_reloc_other;
92 }
93 
94 /* For unsupported relocs.  */
95 
96 static bfd_reloc_status_type
sparc_elf_notsup_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry ATTRIBUTE_UNUSED,asymbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * input_section ATTRIBUTE_UNUSED,bfd * output_bfd ATTRIBUTE_UNUSED,char ** error_message ATTRIBUTE_UNUSED)97 sparc_elf_notsup_reloc (bfd *abfd ATTRIBUTE_UNUSED,
98 			arelent *reloc_entry ATTRIBUTE_UNUSED,
99 			asymbol *symbol ATTRIBUTE_UNUSED,
100 			void * data ATTRIBUTE_UNUSED,
101 			asection *input_section ATTRIBUTE_UNUSED,
102 			bfd *output_bfd ATTRIBUTE_UNUSED,
103 			char **error_message ATTRIBUTE_UNUSED)
104 {
105   return bfd_reloc_notsupported;
106 }
107 
108 /* Handle the WDISP16 reloc.  */
109 
110 static bfd_reloc_status_type
sparc_elf_wdisp16_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)111 sparc_elf_wdisp16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
112 			 void * data, asection *input_section, bfd *output_bfd,
113 			 char **error_message ATTRIBUTE_UNUSED)
114 {
115   bfd_vma relocation;
116   bfd_vma insn;
117   bfd_reloc_status_type status;
118 
119   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
120 			    input_section, output_bfd, &relocation, &insn);
121   if (status != bfd_reloc_other)
122     return status;
123 
124   insn &= ~ (bfd_vma) 0x303fff;
125   insn |= (((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff);
126   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
127 
128   if ((bfd_signed_vma) relocation < - 0x40000
129       || (bfd_signed_vma) relocation > 0x3ffff)
130     return bfd_reloc_overflow;
131   else
132     return bfd_reloc_ok;
133 }
134 
135 /* Handle the WDISP10 reloc.  */
136 
137 static bfd_reloc_status_type
sparc_elf_wdisp10_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)138 sparc_elf_wdisp10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
139 			 void * data, asection *input_section, bfd *output_bfd,
140 			 char **error_message ATTRIBUTE_UNUSED)
141 {
142   bfd_vma relocation;
143   bfd_vma insn;
144   bfd_reloc_status_type status;
145 
146   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
147 			    input_section, output_bfd, &relocation, &insn);
148   if (status != bfd_reloc_other)
149     return status;
150 
151   insn &= ~ (bfd_vma) 0x181fe0;
152   insn |= (((relocation >> 2) & 0x300) << 11)
153 	  | (((relocation >> 2) & 0xff) << 5);
154   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
155 
156   if ((bfd_signed_vma) relocation < - 0x1000
157       || (bfd_signed_vma) relocation > 0xfff)
158     return bfd_reloc_overflow;
159   else
160     return bfd_reloc_ok;
161 }
162 
163 /* Handle the HIX22 reloc.  */
164 
165 static bfd_reloc_status_type
sparc_elf_hix22_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)166 sparc_elf_hix22_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
167 		       void * data, asection *input_section, bfd *output_bfd,
168 		       char **error_message ATTRIBUTE_UNUSED)
169 {
170   bfd_vma relocation;
171   bfd_vma insn;
172   bfd_reloc_status_type status;
173 
174   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
175 			    input_section, output_bfd, &relocation, &insn);
176   if (status != bfd_reloc_other)
177     return status;
178 
179   relocation ^= MINUS_ONE;
180   insn = (insn &~ (bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
181   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
182 
183   if ((relocation & ~ (bfd_vma) 0xffffffff) != 0)
184     return bfd_reloc_overflow;
185   else
186     return bfd_reloc_ok;
187 }
188 
189 /* Handle the LOX10 reloc.  */
190 
191 static bfd_reloc_status_type
sparc_elf_lox10_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)192 sparc_elf_lox10_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
193 		       void * data, asection *input_section, bfd *output_bfd,
194 		       char **error_message ATTRIBUTE_UNUSED)
195 {
196   bfd_vma relocation;
197   bfd_vma insn;
198   bfd_reloc_status_type status;
199 
200   status = init_insn_reloc (abfd, reloc_entry, symbol, data,
201 			    input_section, output_bfd, &relocation, &insn);
202   if (status != bfd_reloc_other)
203     return status;
204 
205   insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
206   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
207 
208   return bfd_reloc_ok;
209 }
210 
211 static reloc_howto_type _bfd_sparc_elf_howto_table[] =
212 {
213   HOWTO(R_SPARC_NONE,      0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
214   HOWTO(R_SPARC_8,         0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_8",       FALSE,0,0x000000ff,TRUE),
215   HOWTO(R_SPARC_16,        0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_16",      FALSE,0,0x0000ffff,TRUE),
216   HOWTO(R_SPARC_32,        0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_32",      FALSE,0,0xffffffff,TRUE),
217   HOWTO(R_SPARC_DISP8,     0,0, 8,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP8",   FALSE,0,0x000000ff,TRUE),
218   HOWTO(R_SPARC_DISP16,    0,1,16,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP16",  FALSE,0,0x0000ffff,TRUE),
219   HOWTO(R_SPARC_DISP32,    0,2,32,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP32",  FALSE,0,0xffffffff,TRUE),
220   HOWTO(R_SPARC_WDISP30,   2,2,30,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
221   HOWTO(R_SPARC_WDISP22,   2,2,22,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
222   HOWTO(R_SPARC_HI22,     10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HI22",    FALSE,0,0x003fffff,TRUE),
223   HOWTO(R_SPARC_22,        0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_22",      FALSE,0,0x003fffff,TRUE),
224   HOWTO(R_SPARC_13,        0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_13",      FALSE,0,0x00001fff,TRUE),
225   HOWTO(R_SPARC_LO10,      0,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LO10",    FALSE,0,0x000003ff,TRUE),
226   HOWTO(R_SPARC_GOT10,     0,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT10",   FALSE,0,0x000003ff,TRUE),
227   HOWTO(R_SPARC_GOT13,     0,2,13,FALSE,0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_GOT13",   FALSE,0,0x00001fff,TRUE),
228   HOWTO(R_SPARC_GOT22,    10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GOT22",   FALSE,0,0x003fffff,TRUE),
229   HOWTO(R_SPARC_PC10,      0,2,10,TRUE, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_PC10",    FALSE,0,0x000003ff,TRUE),
230   HOWTO(R_SPARC_PC22,     10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PC22",    FALSE,0,0x003fffff,TRUE),
231   HOWTO(R_SPARC_WPLT30,    2,2,30,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WPLT30",  FALSE,0,0x3fffffff,TRUE),
232   HOWTO(R_SPARC_COPY,      0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_COPY",    FALSE,0,0x00000000,TRUE),
233   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),
234   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),
235   HOWTO(R_SPARC_RELATIVE,  0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
236   HOWTO(R_SPARC_UA32,      0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA32",    FALSE,0,0xffffffff,TRUE),
237   HOWTO(R_SPARC_PLT32,     0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PLT32",   FALSE,0,0xffffffff,TRUE),
238   HOWTO(R_SPARC_HIPLT22,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_HIPLT22",  FALSE,0,0x00000000,TRUE),
239   HOWTO(R_SPARC_LOPLT10,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_LOPLT10",  FALSE,0,0x00000000,TRUE),
240   HOWTO(R_SPARC_PCPLT32,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_PCPLT32",  FALSE,0,0x00000000,TRUE),
241   HOWTO(R_SPARC_PCPLT22,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_PCPLT22",  FALSE,0,0x00000000,TRUE),
242   HOWTO(R_SPARC_PCPLT10,   0,0,00,FALSE,0,complain_overflow_dont,    sparc_elf_notsup_reloc, "R_SPARC_PCPLT10",  FALSE,0,0x00000000,TRUE),
243   HOWTO(R_SPARC_10,        0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_10",      FALSE,0,0x000003ff,TRUE),
244   HOWTO(R_SPARC_11,        0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_11",      FALSE,0,0x000007ff,TRUE),
245   HOWTO(R_SPARC_64,        0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_64",      FALSE,0,MINUS_ONE, TRUE),
246   HOWTO(R_SPARC_OLO10,     0,2,13,FALSE,0,complain_overflow_signed,  sparc_elf_notsup_reloc, "R_SPARC_OLO10",   FALSE,0,0x00001fff,TRUE),
247   HOWTO(R_SPARC_HH22,     42,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,  "R_SPARC_HH22",    FALSE,0,0x003fffff,TRUE),
248   HOWTO(R_SPARC_HM10,     32,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HM10",    FALSE,0,0x000003ff,TRUE),
249   HOWTO(R_SPARC_LM22,     10,2,22,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LM22",    FALSE,0,0x003fffff,TRUE),
250   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),
251   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),
252   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),
253   HOWTO(R_SPARC_WDISP16,   2,2,16,TRUE, 0,complain_overflow_signed,  sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
254   HOWTO(R_SPARC_WDISP19,   2,2,19,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
255   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),
256   HOWTO(R_SPARC_7,         0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_7",       FALSE,0,0x0000007f,TRUE),
257   HOWTO(R_SPARC_5,         0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_5",       FALSE,0,0x0000001f,TRUE),
258   HOWTO(R_SPARC_6,         0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_6",       FALSE,0,0x0000003f,TRUE),
259   HOWTO(R_SPARC_DISP64,    0,4,64,TRUE, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_DISP64",  FALSE,0,MINUS_ONE, TRUE),
260   HOWTO(R_SPARC_PLT64,     0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_PLT64",   FALSE,0,MINUS_ONE, TRUE),
261   HOWTO(R_SPARC_HIX22,     0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,  "R_SPARC_HIX22",   FALSE,0,MINUS_ONE, FALSE),
262   HOWTO(R_SPARC_LOX10,     0,4, 0,FALSE,0,complain_overflow_dont,    sparc_elf_lox10_reloc,  "R_SPARC_LOX10",   FALSE,0,MINUS_ONE, FALSE),
263   HOWTO(R_SPARC_H44,      22,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,  "R_SPARC_H44",     FALSE,0,0x003fffff,FALSE),
264   HOWTO(R_SPARC_M44,      12,2,10,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_M44",     FALSE,0,0x000003ff,FALSE),
265   HOWTO(R_SPARC_L44,       0,2,13,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_L44",     FALSE,0,0x00000fff,FALSE),
266   HOWTO(R_SPARC_REGISTER,  0,4, 0,FALSE,0,complain_overflow_bitfield,sparc_elf_notsup_reloc, "R_SPARC_REGISTER",FALSE,0,MINUS_ONE, FALSE),
267   HOWTO(R_SPARC_UA64,        0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA64",      FALSE,0,MINUS_ONE, TRUE),
268   HOWTO(R_SPARC_UA16,        0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_UA16",      FALSE,0,0x0000ffff,TRUE),
269   HOWTO(R_SPARC_TLS_GD_HI22,10,2,22,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_HI22",FALSE,0,0x003fffff,TRUE),
270   HOWTO(R_SPARC_TLS_GD_LO10,0,2,10,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_LO10",FALSE,0,0x000003ff,TRUE),
271   HOWTO(R_SPARC_TLS_GD_ADD,0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_ADD",FALSE,0,0x00000000,TRUE),
272   HOWTO(R_SPARC_TLS_GD_CALL,2,2,30,TRUE,0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_TLS_GD_CALL",FALSE,0,0x3fffffff,TRUE),
273   HOWTO(R_SPARC_TLS_LDM_HI22,10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_HI22",FALSE,0,0x003fffff,TRUE),
274   HOWTO(R_SPARC_TLS_LDM_LO10,0,2,10,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_LO10",FALSE,0,0x000003ff,TRUE),
275   HOWTO(R_SPARC_TLS_LDM_ADD,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_ADD",FALSE,0,0x00000000,TRUE),
276   HOWTO(R_SPARC_TLS_LDM_CALL,2,2,30,TRUE,0,complain_overflow_signed, bfd_elf_generic_reloc,  "R_SPARC_TLS_LDM_CALL",FALSE,0,0x3fffffff,TRUE),
277   HOWTO(R_SPARC_TLS_LDO_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_TLS_LDO_HIX22",FALSE,0,0x003fffff, FALSE),
278   HOWTO(R_SPARC_TLS_LDO_LOX10,0,2,0,FALSE,0,complain_overflow_dont,  sparc_elf_lox10_reloc,  "R_SPARC_TLS_LDO_LOX10",FALSE,0,0x000003ff, FALSE),
279   HOWTO(R_SPARC_TLS_LDO_ADD,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_LDO_ADD",FALSE,0,0x00000000,TRUE),
280   HOWTO(R_SPARC_TLS_IE_HI22,10,2,22,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_HI22",FALSE,0,0x003fffff,TRUE),
281   HOWTO(R_SPARC_TLS_IE_LO10,0,2,10,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_LO10",FALSE,0,0x000003ff,TRUE),
282   HOWTO(R_SPARC_TLS_IE_LD,0,0, 0,FALSE,0,complain_overflow_dont,     bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_LD",FALSE,0,0x00000000,TRUE),
283   HOWTO(R_SPARC_TLS_IE_LDX,0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_LDX",FALSE,0,0x00000000,TRUE),
284   HOWTO(R_SPARC_TLS_IE_ADD,0,0, 0,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_TLS_IE_ADD",FALSE,0,0x00000000,TRUE),
285   HOWTO(R_SPARC_TLS_LE_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc, "R_SPARC_TLS_LE_HIX22",FALSE,0,0x003fffff, FALSE),
286   HOWTO(R_SPARC_TLS_LE_LOX10,0,2,0,FALSE,0,complain_overflow_dont,   sparc_elf_lox10_reloc,  "R_SPARC_TLS_LE_LOX10",FALSE,0,0x000003ff, FALSE),
287   HOWTO(R_SPARC_TLS_DTPMOD32,0,0, 0,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_DTPMOD32",FALSE,0,0x00000000,TRUE),
288   HOWTO(R_SPARC_TLS_DTPMOD64,0,0, 0,FALSE,0,complain_overflow_dont,  bfd_elf_generic_reloc,  "R_SPARC_TLS_DTPMOD64",FALSE,0,0x00000000,TRUE),
289   HOWTO(R_SPARC_TLS_DTPOFF32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF32",FALSE,0,0xffffffff,TRUE),
290   HOWTO(R_SPARC_TLS_DTPOFF64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_TLS_DTPOFF64",FALSE,0,MINUS_ONE,TRUE),
291   HOWTO(R_SPARC_TLS_TPOFF32,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_TPOFF32",FALSE,0,0x00000000,TRUE),
292   HOWTO(R_SPARC_TLS_TPOFF64,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_TLS_TPOFF64",FALSE,0,0x00000000,TRUE),
293   HOWTO(R_SPARC_GOTDATA_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_HIX22",FALSE,0,0x003fffff, FALSE),
294   HOWTO(R_SPARC_GOTDATA_LOX10,0,2,0,FALSE,0,complain_overflow_dont,  sparc_elf_lox10_reloc,  "R_SPARC_GOTDATA_LOX10",FALSE,0,0x000003ff, FALSE),
295   HOWTO(R_SPARC_GOTDATA_OP_HIX22,0,2,0,FALSE,0,complain_overflow_bitfield,sparc_elf_hix22_reloc,"R_SPARC_GOTDATA_OP_HIX22",FALSE,0,0x003fffff, FALSE),
296   HOWTO(R_SPARC_GOTDATA_OP_LOX10,0,2,0,FALSE,0,complain_overflow_dont,  sparc_elf_lox10_reloc,  "R_SPARC_GOTDATA_OP_LOX10",FALSE,0,0x000003ff, FALSE),
297   HOWTO(R_SPARC_GOTDATA_OP,0,0, 0,FALSE,0,complain_overflow_dont,   bfd_elf_generic_reloc,  "R_SPARC_GOTDATA_OP",FALSE,0,0x00000000,TRUE),
298   HOWTO(R_SPARC_H34,12,2,22,FALSE,0,complain_overflow_unsigned,bfd_elf_generic_reloc,"R_SPARC_H34",FALSE,0,0x003fffff,FALSE),
299   HOWTO(R_SPARC_SIZE32,0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_SIZE32",FALSE,0,0xffffffff,TRUE),
300   HOWTO(R_SPARC_SIZE64,0,4,64,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_SIZE64",FALSE,0,MINUS_ONE, TRUE),
301   HOWTO(R_SPARC_WDISP10,2,2,10,TRUE, 0,complain_overflow_signed,sparc_elf_wdisp10_reloc,"R_SPARC_WDISP10",FALSE,0,0x00000000,TRUE),
302 };
303 static reloc_howto_type sparc_jmp_irel_howto =
304   HOWTO(R_SPARC_JMP_IREL,  0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_JMP_IREL",FALSE,0,0x00000000,TRUE);
305 static reloc_howto_type sparc_irelative_howto =
306   HOWTO(R_SPARC_IRELATIVE,  0,0,00,FALSE,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_IRELATIVE",FALSE,0,0x00000000,TRUE);
307 static reloc_howto_type sparc_vtinherit_howto =
308   HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
309 static reloc_howto_type sparc_vtentry_howto =
310   HOWTO (R_SPARC_GNU_VTENTRY, 0,2,0,FALSE,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_SPARC_GNU_VTENTRY", FALSE,0,0, FALSE);
311 static reloc_howto_type sparc_rev32_howto =
312   HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
313 
314 reloc_howto_type *
_bfd_sparc_elf_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)315 _bfd_sparc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
316 				  bfd_reloc_code_real_type code)
317 {
318   /* We explicitly handle each relocation type in the switch
319      instead of using a lookup table for efficiency.  */
320   switch (code)
321     {
322     case BFD_RELOC_NONE:
323       return &_bfd_sparc_elf_howto_table[R_SPARC_NONE];
324 
325     case BFD_RELOC_8:
326       return &_bfd_sparc_elf_howto_table[R_SPARC_8];
327 
328     case BFD_RELOC_16:
329       return &_bfd_sparc_elf_howto_table[R_SPARC_16];
330 
331     case BFD_RELOC_32:
332       return &_bfd_sparc_elf_howto_table[R_SPARC_32];
333 
334     case BFD_RELOC_8_PCREL:
335       return &_bfd_sparc_elf_howto_table[R_SPARC_DISP8];
336 
337     case BFD_RELOC_16_PCREL:
338       return &_bfd_sparc_elf_howto_table[R_SPARC_DISP16];
339 
340     case BFD_RELOC_32_PCREL:
341       return &_bfd_sparc_elf_howto_table[R_SPARC_DISP32];
342 
343     case BFD_RELOC_32_PCREL_S2:
344       return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP30];
345 
346     case BFD_RELOC_SPARC_WDISP22:
347       return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP22];
348 
349     case BFD_RELOC_HI22:
350       return &_bfd_sparc_elf_howto_table[R_SPARC_HI22];
351 
352     case BFD_RELOC_SPARC22:
353       return &_bfd_sparc_elf_howto_table[R_SPARC_22];
354 
355     case BFD_RELOC_SPARC13:
356       return &_bfd_sparc_elf_howto_table[R_SPARC_13];
357 
358     case BFD_RELOC_LO10:
359       return &_bfd_sparc_elf_howto_table[R_SPARC_LO10];
360 
361     case BFD_RELOC_SPARC_GOT10:
362       return &_bfd_sparc_elf_howto_table[R_SPARC_GOT10];
363 
364     case BFD_RELOC_SPARC_GOT13:
365       return &_bfd_sparc_elf_howto_table[R_SPARC_GOT13];
366 
367     case BFD_RELOC_SPARC_GOT22:
368       return &_bfd_sparc_elf_howto_table[R_SPARC_GOT22];
369 
370     case BFD_RELOC_SPARC_PC10:
371       return &_bfd_sparc_elf_howto_table[R_SPARC_PC10];
372 
373     case BFD_RELOC_SPARC_PC22:
374       return &_bfd_sparc_elf_howto_table[R_SPARC_PC22];
375 
376     case BFD_RELOC_SPARC_WPLT30:
377       return &_bfd_sparc_elf_howto_table[R_SPARC_WPLT30];
378 
379     case BFD_RELOC_SPARC_COPY:
380       return &_bfd_sparc_elf_howto_table[R_SPARC_COPY];
381 
382     case BFD_RELOC_SPARC_GLOB_DAT:
383       return &_bfd_sparc_elf_howto_table[R_SPARC_GLOB_DAT];
384 
385     case BFD_RELOC_SPARC_JMP_SLOT:
386       return &_bfd_sparc_elf_howto_table[R_SPARC_JMP_SLOT];
387 
388     case BFD_RELOC_SPARC_RELATIVE:
389       return &_bfd_sparc_elf_howto_table[R_SPARC_RELATIVE];
390 
391     case BFD_RELOC_SPARC_UA32:
392       return &_bfd_sparc_elf_howto_table[R_SPARC_UA32];
393 
394     case BFD_RELOC_SPARC_PLT32:
395       return &_bfd_sparc_elf_howto_table[R_SPARC_PLT32];
396 
397     case BFD_RELOC_SPARC_10:
398       return &_bfd_sparc_elf_howto_table[R_SPARC_10];
399 
400     case BFD_RELOC_SPARC_11:
401       return &_bfd_sparc_elf_howto_table[R_SPARC_11];
402 
403     case BFD_RELOC_SPARC_64:
404       return &_bfd_sparc_elf_howto_table[R_SPARC_64];
405 
406     case BFD_RELOC_SPARC_OLO10:
407       return &_bfd_sparc_elf_howto_table[R_SPARC_OLO10];
408 
409     case BFD_RELOC_SPARC_HH22:
410       return &_bfd_sparc_elf_howto_table[R_SPARC_HH22];
411 
412     case BFD_RELOC_SPARC_HM10:
413       return &_bfd_sparc_elf_howto_table[R_SPARC_HM10];
414 
415     case BFD_RELOC_SPARC_LM22:
416       return &_bfd_sparc_elf_howto_table[R_SPARC_LM22];
417 
418     case BFD_RELOC_SPARC_PC_HH22:
419       return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HH22];
420 
421     case BFD_RELOC_SPARC_PC_HM10:
422       return &_bfd_sparc_elf_howto_table[R_SPARC_PC_HM10];
423 
424     case BFD_RELOC_SPARC_PC_LM22:
425       return &_bfd_sparc_elf_howto_table[R_SPARC_PC_LM22];
426 
427     case BFD_RELOC_SPARC_WDISP16:
428       return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP16];
429 
430     case BFD_RELOC_SPARC_WDISP19:
431       return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP19];
432 
433     case BFD_RELOC_SPARC_7:
434       return &_bfd_sparc_elf_howto_table[R_SPARC_7];
435 
436     case BFD_RELOC_SPARC_5:
437       return &_bfd_sparc_elf_howto_table[R_SPARC_5];
438 
439     case BFD_RELOC_SPARC_6:
440       return &_bfd_sparc_elf_howto_table[R_SPARC_6];
441 
442     case BFD_RELOC_SPARC_DISP64:
443       return &_bfd_sparc_elf_howto_table[R_SPARC_DISP64];
444 
445     case BFD_RELOC_SPARC_PLT64:
446       return &_bfd_sparc_elf_howto_table[R_SPARC_PLT64];
447 
448     case BFD_RELOC_SPARC_HIX22:
449       return &_bfd_sparc_elf_howto_table[R_SPARC_HIX22];
450 
451     case BFD_RELOC_SPARC_LOX10:
452       return &_bfd_sparc_elf_howto_table[R_SPARC_LOX10];
453 
454     case BFD_RELOC_SPARC_H44:
455       return &_bfd_sparc_elf_howto_table[R_SPARC_H44];
456 
457     case BFD_RELOC_SPARC_M44:
458       return &_bfd_sparc_elf_howto_table[R_SPARC_M44];
459 
460     case BFD_RELOC_SPARC_L44:
461       return &_bfd_sparc_elf_howto_table[R_SPARC_L44];
462 
463     case BFD_RELOC_SPARC_REGISTER:
464       return &_bfd_sparc_elf_howto_table[R_SPARC_REGISTER];
465 
466     case BFD_RELOC_SPARC_UA64:
467       return &_bfd_sparc_elf_howto_table[R_SPARC_UA64];
468 
469     case BFD_RELOC_SPARC_UA16:
470       return &_bfd_sparc_elf_howto_table[R_SPARC_UA16];
471 
472     case BFD_RELOC_SPARC_TLS_GD_HI22:
473       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_HI22];
474 
475     case BFD_RELOC_SPARC_TLS_GD_LO10:
476       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_LO10];
477 
478     case BFD_RELOC_SPARC_TLS_GD_ADD:
479       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_ADD];
480 
481     case BFD_RELOC_SPARC_TLS_GD_CALL:
482       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_GD_CALL];
483 
484     case BFD_RELOC_SPARC_TLS_LDM_HI22:
485       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_HI22];
486 
487     case BFD_RELOC_SPARC_TLS_LDM_LO10:
488       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_LO10];
489 
490     case BFD_RELOC_SPARC_TLS_LDM_ADD:
491       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_ADD];
492 
493     case BFD_RELOC_SPARC_TLS_LDM_CALL:
494       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDM_CALL];
495 
496     case BFD_RELOC_SPARC_TLS_LDO_HIX22:
497       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_HIX22];
498 
499     case BFD_RELOC_SPARC_TLS_LDO_LOX10:
500       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_LOX10];
501 
502     case BFD_RELOC_SPARC_TLS_LDO_ADD:
503       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LDO_ADD];
504 
505     case BFD_RELOC_SPARC_TLS_IE_HI22:
506       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_HI22];
507 
508     case BFD_RELOC_SPARC_TLS_IE_LO10:
509       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LO10];
510 
511     case BFD_RELOC_SPARC_TLS_IE_LD:
512       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LD];
513 
514     case BFD_RELOC_SPARC_TLS_IE_LDX:
515       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_LDX];
516 
517     case BFD_RELOC_SPARC_TLS_IE_ADD:
518       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_IE_ADD];
519 
520     case BFD_RELOC_SPARC_TLS_LE_HIX22:
521       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_HIX22];
522 
523     case BFD_RELOC_SPARC_TLS_LE_LOX10:
524       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_LE_LOX10];
525 
526     case BFD_RELOC_SPARC_TLS_DTPMOD32:
527       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD32];
528 
529     case BFD_RELOC_SPARC_TLS_DTPMOD64:
530       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPMOD64];
531 
532     case BFD_RELOC_SPARC_TLS_DTPOFF32:
533       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF32];
534 
535     case BFD_RELOC_SPARC_TLS_DTPOFF64:
536       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_DTPOFF64];
537 
538     case BFD_RELOC_SPARC_TLS_TPOFF32:
539       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF32];
540 
541     case BFD_RELOC_SPARC_TLS_TPOFF64:
542       return &_bfd_sparc_elf_howto_table[R_SPARC_TLS_TPOFF64];
543 
544     case BFD_RELOC_SPARC_GOTDATA_HIX22:
545       return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_HIX22];
546 
547     case BFD_RELOC_SPARC_GOTDATA_LOX10:
548       return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_LOX10];
549 
550     case BFD_RELOC_SPARC_GOTDATA_OP_HIX22:
551       return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_HIX22];
552 
553     case BFD_RELOC_SPARC_GOTDATA_OP_LOX10:
554       return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP_LOX10];
555 
556     case BFD_RELOC_SPARC_GOTDATA_OP:
557       return &_bfd_sparc_elf_howto_table[R_SPARC_GOTDATA_OP];
558 
559     case BFD_RELOC_SPARC_H34:
560       return &_bfd_sparc_elf_howto_table[R_SPARC_H34];
561 
562     case BFD_RELOC_SPARC_SIZE32:
563       return &_bfd_sparc_elf_howto_table[R_SPARC_SIZE32];
564 
565     case BFD_RELOC_SPARC_SIZE64:
566       return &_bfd_sparc_elf_howto_table[R_SPARC_SIZE64];
567 
568     case BFD_RELOC_SPARC_WDISP10:
569       return &_bfd_sparc_elf_howto_table[R_SPARC_WDISP10];
570 
571     case BFD_RELOC_SPARC_JMP_IREL:
572       return &sparc_jmp_irel_howto;
573 
574     case BFD_RELOC_SPARC_IRELATIVE:
575       return &sparc_irelative_howto;
576 
577     case BFD_RELOC_VTABLE_INHERIT:
578       return &sparc_vtinherit_howto;
579 
580     case BFD_RELOC_VTABLE_ENTRY:
581       return &sparc_vtentry_howto;
582 
583     case BFD_RELOC_SPARC_REV32:
584       return &sparc_rev32_howto;
585 
586     default:
587       break;
588     }
589     bfd_set_error (bfd_error_bad_value);
590     return NULL;
591 }
592 
593 reloc_howto_type *
_bfd_sparc_elf_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)594 _bfd_sparc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
595 				  const char *r_name)
596 {
597   unsigned int i;
598 
599   for (i = 0;
600        i < (sizeof (_bfd_sparc_elf_howto_table)
601 	    / sizeof (_bfd_sparc_elf_howto_table[0]));
602        i++)
603     if (_bfd_sparc_elf_howto_table[i].name != NULL
604 	&& strcasecmp (_bfd_sparc_elf_howto_table[i].name, r_name) == 0)
605       return &_bfd_sparc_elf_howto_table[i];
606 
607   if (strcasecmp (sparc_vtinherit_howto.name, r_name) == 0)
608     return &sparc_vtinherit_howto;
609   if (strcasecmp (sparc_vtentry_howto.name, r_name) == 0)
610     return &sparc_vtentry_howto;
611   if (strcasecmp (sparc_rev32_howto.name, r_name) == 0)
612     return &sparc_rev32_howto;
613 
614   return NULL;
615 }
616 
617 reloc_howto_type *
_bfd_sparc_elf_info_to_howto_ptr(unsigned int r_type)618 _bfd_sparc_elf_info_to_howto_ptr (unsigned int r_type)
619 {
620   switch (r_type)
621     {
622     case R_SPARC_JMP_IREL:
623       return &sparc_jmp_irel_howto;
624 
625     case R_SPARC_IRELATIVE:
626       return &sparc_irelative_howto;
627 
628     case R_SPARC_GNU_VTINHERIT:
629       return &sparc_vtinherit_howto;
630 
631     case R_SPARC_GNU_VTENTRY:
632       return &sparc_vtentry_howto;
633 
634     case R_SPARC_REV32:
635       return &sparc_rev32_howto;
636 
637     default:
638       if (r_type >= (unsigned int) R_SPARC_max_std)
639 	{
640 	  (*_bfd_error_handler) (_("invalid relocation type %d"),
641 				 (int) r_type);
642 	  r_type = R_SPARC_NONE;
643 	}
644       return &_bfd_sparc_elf_howto_table[r_type];
645     }
646 }
647 
648 /* Both 32-bit and 64-bit sparc encode this in an identical manner,
649    so just take advantage of that.  */
650 #define SPARC_ELF_R_TYPE(r_info)	\
651 	((r_info) & 0xff)
652 
653 void
_bfd_sparc_elf_info_to_howto(bfd * abfd ATTRIBUTE_UNUSED,arelent * cache_ptr,Elf_Internal_Rela * dst)654 _bfd_sparc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
655 			      Elf_Internal_Rela *dst)
656 {
657   unsigned int r_type = SPARC_ELF_R_TYPE (dst->r_info);
658 
659   cache_ptr->howto = _bfd_sparc_elf_info_to_howto_ptr (r_type);
660 }
661 
662 
663 /* The nop opcode we use.  */
664 #define SPARC_NOP 0x01000000
665 
666 #define SPARC_INSN_BYTES	4
667 
668 /* The SPARC linker needs to keep track of the number of relocs that it
669    decides to copy as dynamic relocs in check_relocs for each symbol.
670    This is so that it can later discard them if they are found to be
671    unnecessary.  We store the information in a field extending the
672    regular ELF linker hash table.  */
673 
674 struct _bfd_sparc_elf_dyn_relocs
675 {
676   struct _bfd_sparc_elf_dyn_relocs *next;
677 
678   /* The input section of the reloc.  */
679   asection *sec;
680 
681   /* Total number of relocs copied for the input section.  */
682   bfd_size_type count;
683 
684   /* Number of pc-relative relocs copied for the input section.  */
685   bfd_size_type pc_count;
686 };
687 
688 /* SPARC ELF linker hash entry.  */
689 
690 struct _bfd_sparc_elf_link_hash_entry
691 {
692   struct elf_link_hash_entry elf;
693 
694   /* Track dynamic relocs copied for this symbol.  */
695   struct _bfd_sparc_elf_dyn_relocs *dyn_relocs;
696 
697 #define GOT_UNKNOWN     0
698 #define GOT_NORMAL      1
699 #define GOT_TLS_GD      2
700 #define GOT_TLS_IE      3
701   unsigned char tls_type;
702 };
703 
704 #define _bfd_sparc_elf_hash_entry(ent) ((struct _bfd_sparc_elf_link_hash_entry *)(ent))
705 
706 struct _bfd_sparc_elf_obj_tdata
707 {
708   struct elf_obj_tdata root;
709 
710   /* tls_type for each local got entry.  */
711   char *local_got_tls_type;
712 
713   /* TRUE if TLS GD relocs has been seen for this object.  */
714   bfd_boolean has_tlsgd;
715 };
716 
717 #define _bfd_sparc_elf_tdata(abfd) \
718   ((struct _bfd_sparc_elf_obj_tdata *) (abfd)->tdata.any)
719 
720 #define _bfd_sparc_elf_local_got_tls_type(abfd) \
721   (_bfd_sparc_elf_tdata (abfd)->local_got_tls_type)
722 
723 #define is_sparc_elf(bfd)				\
724   (bfd_get_flavour (bfd) == bfd_target_elf_flavour	\
725    && elf_tdata (bfd) != NULL				\
726    && elf_object_id (bfd) == SPARC_ELF_DATA)
727 
728 bfd_boolean
_bfd_sparc_elf_mkobject(bfd * abfd)729 _bfd_sparc_elf_mkobject (bfd *abfd)
730 {
731   return bfd_elf_allocate_object (abfd, sizeof (struct _bfd_sparc_elf_obj_tdata),
732 				  SPARC_ELF_DATA);
733 }
734 
735 static void
sparc_put_word_32(bfd * abfd,bfd_vma val,void * ptr)736 sparc_put_word_32 (bfd *abfd, bfd_vma val, void *ptr)
737 {
738   bfd_put_32 (abfd, val, ptr);
739 }
740 
741 static void
sparc_put_word_64(bfd * abfd,bfd_vma val,void * ptr)742 sparc_put_word_64 (bfd *abfd, bfd_vma val, void *ptr)
743 {
744   bfd_put_64 (abfd, val, ptr);
745 }
746 
747 static void
sparc_elf_append_rela(bfd * abfd,asection * s,Elf_Internal_Rela * rel)748 sparc_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
749 {
750   const struct elf_backend_data *bed;
751   bfd_byte *loc;
752 
753   bed = get_elf_backend_data (abfd);
754   loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
755   bed->s->swap_reloca_out (abfd, rel, loc);
756 }
757 
758 static bfd_vma
sparc_elf_r_info_64(Elf_Internal_Rela * in_rel ATTRIBUTE_UNUSED,bfd_vma rel_index ATTRIBUTE_UNUSED,bfd_vma type ATTRIBUTE_UNUSED)759 sparc_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
760 		     bfd_vma rel_index ATTRIBUTE_UNUSED,
761 		     bfd_vma type ATTRIBUTE_UNUSED)
762 {
763   return ELF64_R_INFO (rel_index,
764 		       (in_rel ?
765 			ELF64_R_TYPE_INFO (ELF64_R_TYPE_DATA (in_rel->r_info),
766 					   type) : type));
767 }
768 
769 static bfd_vma
sparc_elf_r_info_32(Elf_Internal_Rela * in_rel ATTRIBUTE_UNUSED,bfd_vma rel_index,bfd_vma type)770 sparc_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED,
771 		     bfd_vma rel_index, bfd_vma type)
772 {
773   return ELF32_R_INFO (rel_index, type);
774 }
775 
776 static bfd_vma
sparc_elf_r_symndx_64(bfd_vma r_info)777 sparc_elf_r_symndx_64 (bfd_vma r_info)
778 {
779   bfd_vma r_symndx = ELF32_R_SYM (r_info);
780   return (r_symndx >> 24);
781 }
782 
783 static bfd_vma
sparc_elf_r_symndx_32(bfd_vma r_info)784 sparc_elf_r_symndx_32 (bfd_vma r_info)
785 {
786   return ELF32_R_SYM (r_info);
787 }
788 
789 /* PLT/GOT stuff */
790 
791 #define PLT32_ENTRY_SIZE 12
792 #define PLT32_HEADER_SIZE	(4 * PLT32_ENTRY_SIZE)
793 
794 /* The first four entries in a 32-bit procedure linkage table are reserved,
795    and the initial contents are unimportant (we zero them out).
796    Subsequent entries look like this.  See the SVR4 ABI SPARC
797    supplement to see how this works.  */
798 
799 /* sethi %hi(.-.plt0),%g1.  We fill in the address later.  */
800 #define PLT32_ENTRY_WORD0 0x03000000
801 /* b,a .plt0.  We fill in the offset later.  */
802 #define PLT32_ENTRY_WORD1 0x30800000
803 /* nop.  */
804 #define PLT32_ENTRY_WORD2 SPARC_NOP
805 
806 static int
sparc32_plt_entry_build(bfd * output_bfd,asection * splt,bfd_vma offset,bfd_vma max ATTRIBUTE_UNUSED,bfd_vma * r_offset)807 sparc32_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
808 			 bfd_vma max ATTRIBUTE_UNUSED,
809 			 bfd_vma *r_offset)
810 {
811       bfd_put_32 (output_bfd,
812 		  PLT32_ENTRY_WORD0 + offset,
813 		  splt->contents + offset);
814       bfd_put_32 (output_bfd,
815 		  (PLT32_ENTRY_WORD1
816 		   + (((- (offset + 4)) >> 2) & 0x3fffff)),
817 		  splt->contents + offset + 4);
818       bfd_put_32 (output_bfd, (bfd_vma) PLT32_ENTRY_WORD2,
819 		  splt->contents + offset + 8);
820 
821       *r_offset = offset;
822 
823       return offset / PLT32_ENTRY_SIZE - 4;
824 }
825 
826 /* Both the headers and the entries are icache aligned.  */
827 #define PLT64_ENTRY_SIZE	32
828 #define PLT64_HEADER_SIZE	(4 * PLT64_ENTRY_SIZE)
829 #define PLT64_LARGE_THRESHOLD	32768
830 
831 static int
sparc64_plt_entry_build(bfd * output_bfd,asection * splt,bfd_vma offset,bfd_vma max,bfd_vma * r_offset)832 sparc64_plt_entry_build (bfd *output_bfd, asection *splt, bfd_vma offset,
833 			 bfd_vma max, bfd_vma *r_offset)
834 {
835   unsigned char *entry = splt->contents + offset;
836   const unsigned int nop = SPARC_NOP;
837   int plt_index;
838 
839   if (offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
840     {
841       unsigned int sethi, ba;
842 
843       *r_offset = offset;
844 
845       plt_index = (offset / PLT64_ENTRY_SIZE);
846 
847       sethi = 0x03000000 | (plt_index * PLT64_ENTRY_SIZE);
848       ba = 0x30680000
849 	| (((splt->contents + PLT64_ENTRY_SIZE) - (entry + 4)) / 4 & 0x7ffff);
850 
851       bfd_put_32 (output_bfd, (bfd_vma) sethi, entry);
852       bfd_put_32 (output_bfd, (bfd_vma) ba,    entry + 4);
853       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 8);
854       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 12);
855       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 16);
856       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 20);
857       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 24);
858       bfd_put_32 (output_bfd, (bfd_vma) nop,   entry + 28);
859     }
860   else
861     {
862       unsigned char *ptr;
863       unsigned int ldx;
864       int block, last_block, ofs, last_ofs, chunks_this_block;
865       const int insn_chunk_size = (6 * 4);
866       const int ptr_chunk_size = (1 * 8);
867       const int entries_per_block = 160;
868       const int block_size = entries_per_block * (insn_chunk_size
869 						  + ptr_chunk_size);
870 
871       /* Entries 32768 and higher are grouped into blocks of 160.
872 	 The blocks are further subdivided into 160 sequences of
873 	 6 instructions and 160 pointers.  If a block does not require
874 	 the full 160 entries, let's say it requires N, then there
875 	 will be N sequences of 6 instructions and N pointers.  */
876 
877       offset -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
878       max -= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE);
879 
880       block = offset / block_size;
881       last_block = max / block_size;
882       if (block != last_block)
883 	{
884 	  chunks_this_block = 160;
885 	}
886       else
887 	{
888 	  last_ofs = max % block_size;
889 	  chunks_this_block = last_ofs / (insn_chunk_size + ptr_chunk_size);
890 	}
891 
892       ofs = offset % block_size;
893 
894       plt_index = (PLT64_LARGE_THRESHOLD +
895 	       (block * 160) +
896 	       (ofs / insn_chunk_size));
897 
898       ptr = splt->contents
899 	+ (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
900 	+ (block * block_size)
901 	+ (chunks_this_block * insn_chunk_size)
902 	+ (ofs / insn_chunk_size) * ptr_chunk_size;
903 
904       *r_offset = (bfd_vma) (ptr - splt->contents);
905 
906       ldx = 0xc25be000 | ((ptr - (entry+4)) & 0x1fff);
907 
908       /* mov %o7,%g5
909 	 call .+8
910 	 nop
911 	 ldx [%o7+P],%g1
912 	 jmpl %o7+%g1,%g1
913 	 mov %g5,%o7  */
914       bfd_put_32 (output_bfd, (bfd_vma) 0x8a10000f, entry);
915       bfd_put_32 (output_bfd, (bfd_vma) 0x40000002, entry + 4);
916       bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,  entry + 8);
917       bfd_put_32 (output_bfd, (bfd_vma) ldx,        entry + 12);
918       bfd_put_32 (output_bfd, (bfd_vma) 0x83c3c001, entry + 16);
919       bfd_put_32 (output_bfd, (bfd_vma) 0x9e100005, entry + 20);
920 
921       bfd_put_64 (output_bfd, (bfd_vma) (splt->contents - (entry + 4)), ptr);
922     }
923 
924   return plt_index - 4;
925 }
926 
927 /* The format of the first PLT entry in a VxWorks executable.  */
928 static const bfd_vma sparc_vxworks_exec_plt0_entry[] =
929   {
930     0x05000000,	/* sethi  %hi(_GLOBAL_OFFSET_TABLE_+8), %g2 */
931     0x8410a000,	/* or     %g2, %lo(_GLOBAL_OFFSET_TABLE_+8), %g2 */
932     0xc4008000,	/* ld     [ %g2 ], %g2 */
933     0x81c08000,	/* jmp    %g2 */
934     0x01000000	/* nop */
935   };
936 
937 /* The format of subsequent PLT entries.  */
938 static const bfd_vma sparc_vxworks_exec_plt_entry[] =
939   {
940     0x03000000,	/* sethi  %hi(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
941     0x82106000,	/* or     %g1, %lo(_GLOBAL_OFFSET_TABLE_+f@got), %g1 */
942     0xc2004000,	/* ld     [ %g1 ], %g1 */
943     0x81c04000,	/* jmp    %g1 */
944     0x01000000,	/* nop */
945     0x03000000,	/* sethi  %hi(f@pltindex), %g1 */
946     0x10800000,	/* b      _PLT_resolve */
947     0x82106000	/* or     %g1, %lo(f@pltindex), %g1 */
948   };
949 
950 /* The format of the first PLT entry in a VxWorks shared object.  */
951 static const bfd_vma sparc_vxworks_shared_plt0_entry[] =
952   {
953     0xc405e008,	/* ld     [ %l7 + 8 ], %g2 */
954     0x81c08000,	/* jmp    %g2 */
955     0x01000000	/* nop */
956   };
957 
958 /* The format of subsequent PLT entries.  */
959 static const bfd_vma sparc_vxworks_shared_plt_entry[] =
960   {
961     0x03000000,	/* sethi  %hi(f@got), %g1 */
962     0x82106000,	/* or     %g1, %lo(f@got), %g1 */
963     0xc205c001,	/* ld     [ %l7 + %g1 ], %g1 */
964     0x81c04000,	/* jmp    %g1 */
965     0x01000000,	/* nop */
966     0x03000000,	/* sethi  %hi(f@pltindex), %g1 */
967     0x10800000,	/* b      _PLT_resolve */
968     0x82106000	/* or     %g1, %lo(f@pltindex), %g1 */
969   };
970 
971 #define SPARC_ELF_PUT_WORD(htab, bfd, val, ptr)	\
972 	htab->put_word(bfd, val, ptr)
973 
974 #define SPARC_ELF_R_INFO(htab, in_rel, index, type)	\
975 	htab->r_info(in_rel, index, type)
976 
977 #define SPARC_ELF_R_SYMNDX(htab, r_info)	\
978 	htab->r_symndx(r_info)
979 
980 #define SPARC_ELF_WORD_BYTES(htab)	\
981 	htab->bytes_per_word
982 
983 #define SPARC_ELF_RELA_BYTES(htab)	\
984 	htab->bytes_per_rela
985 
986 #define SPARC_ELF_DTPOFF_RELOC(htab)	\
987 	htab->dtpoff_reloc
988 
989 #define SPARC_ELF_DTPMOD_RELOC(htab)	\
990 	htab->dtpmod_reloc
991 
992 #define SPARC_ELF_TPOFF_RELOC(htab)	\
993 	htab->tpoff_reloc
994 
995 #define SPARC_ELF_BUILD_PLT_ENTRY(htab, obfd, splt, off, max, r_off) \
996 	htab->build_plt_entry (obfd, splt, off, max, r_off)
997 
998 /* Create an entry in an SPARC ELF linker hash table.  */
999 
1000 static struct bfd_hash_entry *
link_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)1001 link_hash_newfunc (struct bfd_hash_entry *entry,
1002 		   struct bfd_hash_table *table, const char *string)
1003 {
1004   /* Allocate the structure if it has not already been allocated by a
1005      subclass.  */
1006   if (entry == NULL)
1007     {
1008       entry = bfd_hash_allocate (table,
1009 				 sizeof (struct _bfd_sparc_elf_link_hash_entry));
1010       if (entry == NULL)
1011 	return entry;
1012     }
1013 
1014   /* Call the allocation method of the superclass.  */
1015   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1016   if (entry != NULL)
1017     {
1018       struct _bfd_sparc_elf_link_hash_entry *eh;
1019 
1020       eh = (struct _bfd_sparc_elf_link_hash_entry *) entry;
1021       eh->dyn_relocs = NULL;
1022       eh->tls_type = GOT_UNKNOWN;
1023     }
1024 
1025   return entry;
1026 }
1027 
1028 /* The name of the dynamic interpreter.  This is put in the .interp
1029    section.  */
1030 
1031 #define ELF32_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1032 #define ELF64_DYNAMIC_INTERPRETER "/usr/lib/sparcv9/ld.so.1"
1033 
1034 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
1035    for local symbol so that we can handle local STT_GNU_IFUNC symbols
1036    as global symbol.  We reuse indx and dynstr_index for local symbol
1037    hash since they aren't used by global symbols in this backend.  */
1038 
1039 static hashval_t
elf_sparc_local_htab_hash(const void * ptr)1040 elf_sparc_local_htab_hash (const void *ptr)
1041 {
1042   struct elf_link_hash_entry *h
1043     = (struct elf_link_hash_entry *) ptr;
1044   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
1045 }
1046 
1047 /* Compare local hash entries.  */
1048 
1049 static int
elf_sparc_local_htab_eq(const void * ptr1,const void * ptr2)1050 elf_sparc_local_htab_eq (const void *ptr1, const void *ptr2)
1051 {
1052   struct elf_link_hash_entry *h1
1053      = (struct elf_link_hash_entry *) ptr1;
1054   struct elf_link_hash_entry *h2
1055     = (struct elf_link_hash_entry *) ptr2;
1056 
1057   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
1058 }
1059 
1060 /* Find and/or create a hash entry for local symbol.  */
1061 
1062 static struct elf_link_hash_entry *
elf_sparc_get_local_sym_hash(struct _bfd_sparc_elf_link_hash_table * htab,bfd * abfd,const Elf_Internal_Rela * rel,bfd_boolean create)1063 elf_sparc_get_local_sym_hash (struct _bfd_sparc_elf_link_hash_table *htab,
1064 			      bfd *abfd, const Elf_Internal_Rela *rel,
1065 			      bfd_boolean create)
1066 {
1067   struct _bfd_sparc_elf_link_hash_entry e, *ret;
1068   asection *sec = abfd->sections;
1069   unsigned long r_symndx;
1070   hashval_t h;
1071   void **slot;
1072 
1073   r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1074   h = ELF_LOCAL_SYMBOL_HASH (sec->id, r_symndx);
1075 
1076   e.elf.indx = sec->id;
1077   e.elf.dynstr_index = r_symndx;
1078   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
1079 				   create ? INSERT : NO_INSERT);
1080 
1081   if (!slot)
1082     return NULL;
1083 
1084   if (*slot)
1085     {
1086       ret = (struct _bfd_sparc_elf_link_hash_entry *) *slot;
1087       return &ret->elf;
1088     }
1089 
1090   ret = (struct _bfd_sparc_elf_link_hash_entry *)
1091 	objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
1092 			sizeof (struct _bfd_sparc_elf_link_hash_entry));
1093   if (ret)
1094     {
1095       memset (ret, 0, sizeof (*ret));
1096       ret->elf.indx = sec->id;
1097       ret->elf.dynstr_index = r_symndx;
1098       ret->elf.dynindx = -1;
1099       ret->elf.plt.offset = (bfd_vma) -1;
1100       ret->elf.got.offset = (bfd_vma) -1;
1101       *slot = ret;
1102     }
1103   return &ret->elf;
1104 }
1105 
1106 /* Create a SPARC ELF linker hash table.  */
1107 
1108 struct bfd_link_hash_table *
_bfd_sparc_elf_link_hash_table_create(bfd * abfd)1109 _bfd_sparc_elf_link_hash_table_create (bfd *abfd)
1110 {
1111   struct _bfd_sparc_elf_link_hash_table *ret;
1112   bfd_size_type amt = sizeof (struct _bfd_sparc_elf_link_hash_table);
1113 
1114   ret = (struct _bfd_sparc_elf_link_hash_table *) bfd_zmalloc (amt);
1115   if (ret == NULL)
1116     return NULL;
1117 
1118   if (ABI_64_P (abfd))
1119     {
1120       ret->put_word = sparc_put_word_64;
1121       ret->r_info = sparc_elf_r_info_64;
1122       ret->r_symndx = sparc_elf_r_symndx_64;
1123       ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF64;
1124       ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD64;
1125       ret->tpoff_reloc = R_SPARC_TLS_TPOFF64;
1126       ret->word_align_power = 3;
1127       ret->align_power_max = 4;
1128       ret->bytes_per_word = 8;
1129       ret->bytes_per_rela = sizeof (Elf64_External_Rela);
1130       ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1131       ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1132 
1133       ret->build_plt_entry = sparc64_plt_entry_build;
1134       ret->plt_header_size = PLT64_HEADER_SIZE;
1135       ret->plt_entry_size = PLT64_ENTRY_SIZE;
1136     }
1137   else
1138     {
1139       ret->put_word = sparc_put_word_32;
1140       ret->r_info = sparc_elf_r_info_32;
1141       ret->r_symndx = sparc_elf_r_symndx_32;
1142       ret->dtpoff_reloc = R_SPARC_TLS_DTPOFF32;
1143       ret->dtpmod_reloc = R_SPARC_TLS_DTPMOD32;
1144       ret->tpoff_reloc = R_SPARC_TLS_TPOFF32;
1145       ret->word_align_power = 2;
1146       ret->align_power_max = 3;
1147       ret->bytes_per_word = 4;
1148       ret->bytes_per_rela = sizeof (Elf32_External_Rela);
1149       ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1150       ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1151 
1152       ret->build_plt_entry = sparc32_plt_entry_build;
1153       ret->plt_header_size = PLT32_HEADER_SIZE;
1154       ret->plt_entry_size = PLT32_ENTRY_SIZE;
1155     }
1156 
1157   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
1158 				      sizeof (struct _bfd_sparc_elf_link_hash_entry),
1159 				      SPARC_ELF_DATA))
1160     {
1161       free (ret);
1162       return NULL;
1163     }
1164 
1165   ret->loc_hash_table = htab_try_create (1024,
1166 					 elf_sparc_local_htab_hash,
1167 					 elf_sparc_local_htab_eq,
1168 					 NULL);
1169   ret->loc_hash_memory = objalloc_create ();
1170   if (!ret->loc_hash_table || !ret->loc_hash_memory)
1171     {
1172       free (ret);
1173       return NULL;
1174     }
1175 
1176   return &ret->elf.root;
1177 }
1178 
1179 /* Destroy a SPARC ELF linker hash table.  */
1180 
1181 void
_bfd_sparc_elf_link_hash_table_free(struct bfd_link_hash_table * hash)1182 _bfd_sparc_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
1183 {
1184   struct _bfd_sparc_elf_link_hash_table *htab
1185     = (struct _bfd_sparc_elf_link_hash_table *) hash;
1186 
1187   if (htab->loc_hash_table)
1188     htab_delete (htab->loc_hash_table);
1189   if (htab->loc_hash_memory)
1190     objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1191   _bfd_generic_link_hash_table_free (hash);
1192 }
1193 
1194 /* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
1195    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1196    hash table.  */
1197 
1198 bfd_boolean
_bfd_sparc_elf_create_dynamic_sections(bfd * dynobj,struct bfd_link_info * info)1199 _bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
1200 					struct bfd_link_info *info)
1201 {
1202   struct _bfd_sparc_elf_link_hash_table *htab;
1203 
1204   htab = _bfd_sparc_elf_hash_table (info);
1205   BFD_ASSERT (htab != NULL);
1206 
1207   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1208     return FALSE;
1209 
1210   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1211   if (!info->shared)
1212     htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
1213 
1214   if (htab->is_vxworks)
1215     {
1216       if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1217 	return FALSE;
1218       if (info->shared)
1219 	{
1220 	  htab->plt_header_size
1221 	    = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
1222 	  htab->plt_entry_size
1223 	    = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
1224 	}
1225       else
1226 	{
1227 	  htab->plt_header_size
1228 	    = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
1229 	  htab->plt_entry_size
1230 	    = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
1231 	}
1232     }
1233 
1234   if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
1235       || (!info->shared && !htab->srelbss))
1236     abort ();
1237 
1238   return TRUE;
1239 }
1240 
1241 static bfd_boolean
create_ifunc_sections(bfd * abfd,struct bfd_link_info * info)1242 create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
1243 {
1244   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1245   struct elf_link_hash_table *htab = elf_hash_table (info);
1246   flagword flags, pltflags;
1247   asection *s;
1248 
1249   if (htab->irelifunc != NULL || htab->iplt != NULL)
1250     return TRUE;
1251 
1252   flags = bed->dynamic_sec_flags;
1253   pltflags = flags | SEC_ALLOC | SEC_CODE | SEC_LOAD;
1254 
1255   s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
1256   if (s == NULL
1257       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1258     return FALSE;
1259   htab->iplt = s;
1260 
1261   s = bfd_make_section_with_flags (abfd, ".rela.iplt",
1262 				   flags | SEC_READONLY);
1263   if (s == NULL
1264       || ! bfd_set_section_alignment (abfd, s,
1265 				      bed->s->log_file_align))
1266     return FALSE;
1267   htab->irelplt = s;
1268 
1269   return TRUE;
1270 }
1271 
1272 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1273 
1274 void
_bfd_sparc_elf_copy_indirect_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * dir,struct elf_link_hash_entry * ind)1275 _bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
1276 				     struct elf_link_hash_entry *dir,
1277 				     struct elf_link_hash_entry *ind)
1278 {
1279   struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
1280 
1281   edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
1282   eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
1283 
1284   if (eind->dyn_relocs != NULL)
1285     {
1286       if (edir->dyn_relocs != NULL)
1287 	{
1288 	  struct _bfd_sparc_elf_dyn_relocs **pp;
1289 	  struct _bfd_sparc_elf_dyn_relocs *p;
1290 
1291 	  /* Add reloc counts against the indirect sym to the direct sym
1292 	     list.  Merge any entries against the same section.  */
1293 	  for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1294 	    {
1295 	      struct _bfd_sparc_elf_dyn_relocs *q;
1296 
1297 	      for (q = edir->dyn_relocs; q != NULL; q = q->next)
1298 		if (q->sec == p->sec)
1299 		  {
1300 		    q->pc_count += p->pc_count;
1301 		    q->count += p->count;
1302 		    *pp = p->next;
1303 		    break;
1304 		  }
1305 	      if (q == NULL)
1306 		pp = &p->next;
1307 	    }
1308 	  *pp = edir->dyn_relocs;
1309 	}
1310 
1311       edir->dyn_relocs = eind->dyn_relocs;
1312       eind->dyn_relocs = NULL;
1313     }
1314 
1315   if (ind->root.type == bfd_link_hash_indirect
1316       && dir->got.refcount <= 0)
1317     {
1318       edir->tls_type = eind->tls_type;
1319       eind->tls_type = GOT_UNKNOWN;
1320     }
1321   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1322 }
1323 
1324 static int
sparc_elf_tls_transition(struct bfd_link_info * info,bfd * abfd,int r_type,int is_local)1325 sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1326 			  int r_type, int is_local)
1327 {
1328   if (! ABI_64_P (abfd)
1329       && r_type == R_SPARC_TLS_GD_HI22
1330       && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1331     r_type = R_SPARC_REV32;
1332 
1333   if (info->shared)
1334     return r_type;
1335 
1336   switch (r_type)
1337     {
1338     case R_SPARC_TLS_GD_HI22:
1339       if (is_local)
1340 	return R_SPARC_TLS_LE_HIX22;
1341       return R_SPARC_TLS_IE_HI22;
1342     case R_SPARC_TLS_GD_LO10:
1343       if (is_local)
1344 	return R_SPARC_TLS_LE_LOX10;
1345       return R_SPARC_TLS_IE_LO10;
1346     case R_SPARC_TLS_IE_HI22:
1347       if (is_local)
1348 	return R_SPARC_TLS_LE_HIX22;
1349       return r_type;
1350     case R_SPARC_TLS_IE_LO10:
1351       if (is_local)
1352 	return R_SPARC_TLS_LE_LOX10;
1353       return r_type;
1354     case R_SPARC_TLS_LDM_HI22:
1355       return R_SPARC_TLS_LE_HIX22;
1356     case R_SPARC_TLS_LDM_LO10:
1357       return R_SPARC_TLS_LE_LOX10;
1358     }
1359 
1360   return r_type;
1361 }
1362 
1363 /* Look through the relocs for a section during the first phase, and
1364    allocate space in the global offset table or procedure linkage
1365    table.  */
1366 
1367 bfd_boolean
_bfd_sparc_elf_check_relocs(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)1368 _bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1369 			     asection *sec, const Elf_Internal_Rela *relocs)
1370 {
1371   struct _bfd_sparc_elf_link_hash_table *htab;
1372   Elf_Internal_Shdr *symtab_hdr;
1373   struct elf_link_hash_entry **sym_hashes;
1374   const Elf_Internal_Rela *rel;
1375   const Elf_Internal_Rela *rel_end;
1376   asection *sreloc;
1377   int num_relocs;
1378   bfd_boolean checked_tlsgd = FALSE;
1379 
1380   if (info->relocatable)
1381     return TRUE;
1382 
1383   htab = _bfd_sparc_elf_hash_table (info);
1384   BFD_ASSERT (htab != NULL);
1385   symtab_hdr = &elf_symtab_hdr (abfd);
1386   sym_hashes = elf_sym_hashes (abfd);
1387 
1388   sreloc = NULL;
1389 
1390   if (ABI_64_P (abfd))
1391     num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (sec));
1392   else
1393     num_relocs = sec->reloc_count;
1394 
1395   BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1396 
1397   if (htab->elf.dynobj == NULL)
1398     htab->elf.dynobj = abfd;
1399   if (!create_ifunc_sections (htab->elf.dynobj, info))
1400     return FALSE;
1401 
1402   rel_end = relocs + num_relocs;
1403   for (rel = relocs; rel < rel_end; rel++)
1404     {
1405       unsigned int r_type;
1406       unsigned long r_symndx;
1407       struct elf_link_hash_entry *h;
1408       Elf_Internal_Sym *isym;
1409 
1410       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1411       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1412 
1413       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1414 	{
1415 	  (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1416 				 abfd, r_symndx);
1417 	  return FALSE;
1418 	}
1419 
1420       isym = NULL;
1421       if (r_symndx < symtab_hdr->sh_info)
1422 	{
1423 	  /* A local symbol.  */
1424 	  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1425 					abfd, r_symndx);
1426 	  if (isym == NULL)
1427 	    return FALSE;
1428 
1429 	  /* Check relocation against local STT_GNU_IFUNC symbol.  */
1430 	  if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1431 	    {
1432 	      h = elf_sparc_get_local_sym_hash (htab, abfd, rel,
1433 						TRUE);
1434 	      if (h == NULL)
1435 		return FALSE;
1436 
1437 	      /* Fake a STT_GNU_IFUNC symbol.  */
1438 	      h->type = STT_GNU_IFUNC;
1439 	      h->def_regular = 1;
1440 	      h->ref_regular = 1;
1441 	      h->forced_local = 1;
1442 	      h->root.type = bfd_link_hash_defined;
1443 	    }
1444 	  else
1445 	    h = NULL;
1446 	}
1447       else
1448 	{
1449 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1450 	  while (h->root.type == bfd_link_hash_indirect
1451 		 || h->root.type == bfd_link_hash_warning)
1452 	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
1453 	}
1454 
1455       if (h && h->type == STT_GNU_IFUNC)
1456 	{
1457 	  if (h->def_regular)
1458 	    {
1459 	      h->ref_regular = 1;
1460 	      h->plt.refcount += 1;
1461 	    }
1462 	}
1463 
1464       /* Compatibility with old R_SPARC_REV32 reloc conflicting
1465 	 with R_SPARC_TLS_GD_HI22.  */
1466       if (! ABI_64_P (abfd) && ! checked_tlsgd)
1467 	switch (r_type)
1468 	  {
1469 	  case R_SPARC_TLS_GD_HI22:
1470 	    {
1471 	      const Elf_Internal_Rela *relt;
1472 
1473 	      for (relt = rel + 1; relt < rel_end; relt++)
1474 		if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1475 		    || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1476 		    || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1477 		  break;
1478 	      checked_tlsgd = TRUE;
1479 	      _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1480 	    }
1481 	    break;
1482 	  case R_SPARC_TLS_GD_LO10:
1483 	  case R_SPARC_TLS_GD_ADD:
1484 	  case R_SPARC_TLS_GD_CALL:
1485 	    checked_tlsgd = TRUE;
1486 	    _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1487 	    break;
1488 	  }
1489 
1490       r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1491       switch (r_type)
1492 	{
1493 	case R_SPARC_TLS_LDM_HI22:
1494 	case R_SPARC_TLS_LDM_LO10:
1495 	  htab->tls_ldm_got.refcount += 1;
1496 	  break;
1497 
1498 	case R_SPARC_TLS_LE_HIX22:
1499 	case R_SPARC_TLS_LE_LOX10:
1500 	  if (info->shared)
1501 	    goto r_sparc_plt32;
1502 	  break;
1503 
1504 	case R_SPARC_TLS_IE_HI22:
1505 	case R_SPARC_TLS_IE_LO10:
1506 	  if (info->shared)
1507 	    info->flags |= DF_STATIC_TLS;
1508 	  /* Fall through */
1509 
1510 	case R_SPARC_GOT10:
1511 	case R_SPARC_GOT13:
1512 	case R_SPARC_GOT22:
1513 	case R_SPARC_GOTDATA_HIX22:
1514 	case R_SPARC_GOTDATA_LOX10:
1515 	case R_SPARC_GOTDATA_OP_HIX22:
1516 	case R_SPARC_GOTDATA_OP_LOX10:
1517 	case R_SPARC_TLS_GD_HI22:
1518 	case R_SPARC_TLS_GD_LO10:
1519 	  /* This symbol requires a global offset table entry.  */
1520 	  {
1521 	    int tls_type, old_tls_type;
1522 
1523 	    switch (r_type)
1524 	      {
1525 	      default:
1526 	      case R_SPARC_GOT10:
1527 	      case R_SPARC_GOT13:
1528 	      case R_SPARC_GOT22:
1529 	      case R_SPARC_GOTDATA_OP_HIX22:
1530 	      case R_SPARC_GOTDATA_OP_LOX10:
1531 		tls_type = GOT_NORMAL;
1532 		break;
1533 	      case R_SPARC_TLS_GD_HI22:
1534 	      case R_SPARC_TLS_GD_LO10:
1535 		tls_type = GOT_TLS_GD;
1536 		break;
1537 	      case R_SPARC_TLS_IE_HI22:
1538 	      case R_SPARC_TLS_IE_LO10:
1539 		tls_type = GOT_TLS_IE;
1540 		break;
1541 	      }
1542 
1543 	    if (h != NULL)
1544 	      {
1545 		h->got.refcount += 1;
1546 		old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1547 	      }
1548 	    else
1549 	      {
1550 		bfd_signed_vma *local_got_refcounts;
1551 
1552 		/* This is a global offset table entry for a local symbol.  */
1553 		local_got_refcounts = elf_local_got_refcounts (abfd);
1554 		if (local_got_refcounts == NULL)
1555 		  {
1556 		    bfd_size_type size;
1557 
1558 		    size = symtab_hdr->sh_info;
1559 		    size *= (sizeof (bfd_signed_vma) + sizeof(char));
1560 		    local_got_refcounts = ((bfd_signed_vma *)
1561 					   bfd_zalloc (abfd, size));
1562 		    if (local_got_refcounts == NULL)
1563 		      return FALSE;
1564 		    elf_local_got_refcounts (abfd) = local_got_refcounts;
1565 		    _bfd_sparc_elf_local_got_tls_type (abfd)
1566 		      = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1567 		  }
1568 		switch (r_type)
1569 		  {
1570 		  case R_SPARC_GOTDATA_OP_HIX22:
1571 		  case R_SPARC_GOTDATA_OP_LOX10:
1572 		    break;
1573 
1574 		  default:
1575 		    local_got_refcounts[r_symndx] += 1;
1576 		    break;
1577 		  }
1578 		old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1579 	      }
1580 
1581 	    /* If a TLS symbol is accessed using IE at least once,
1582 	       there is no point to use dynamic model for it.  */
1583 	    if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1584 		&& (old_tls_type != GOT_TLS_GD
1585 		    || tls_type != GOT_TLS_IE))
1586 	      {
1587 		if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1588 		  tls_type = old_tls_type;
1589 		else
1590 		  {
1591 		    (*_bfd_error_handler)
1592 		      (_("%B: `%s' accessed both as normal and thread local symbol"),
1593 		       abfd, h ? h->root.root.string : "<local>");
1594 		    return FALSE;
1595 		  }
1596 	      }
1597 
1598 	    if (old_tls_type != tls_type)
1599 	      {
1600 		if (h != NULL)
1601 		  _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1602 		else
1603 		  _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1604 	      }
1605 	  }
1606 
1607 	  if (htab->elf.sgot == NULL)
1608 	    {
1609 	      if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1610 		return FALSE;
1611 	    }
1612 	  break;
1613 
1614 	case R_SPARC_TLS_GD_CALL:
1615 	case R_SPARC_TLS_LDM_CALL:
1616 	  if (info->shared)
1617 	    {
1618 	      /* These are basically R_SPARC_TLS_WPLT30 relocs against
1619 		 __tls_get_addr.  */
1620 	      struct bfd_link_hash_entry *bh = NULL;
1621 	      if (! _bfd_generic_link_add_one_symbol (info, abfd,
1622 						      "__tls_get_addr", 0,
1623 						      bfd_und_section_ptr, 0,
1624 						      NULL, FALSE, FALSE,
1625 						      &bh))
1626 		return FALSE;
1627 	      h = (struct elf_link_hash_entry *) bh;
1628 	    }
1629 	  else
1630 	    break;
1631 	  /* Fall through */
1632 
1633 	case R_SPARC_PLT32:
1634 	case R_SPARC_WPLT30:
1635 	case R_SPARC_HIPLT22:
1636 	case R_SPARC_LOPLT10:
1637 	case R_SPARC_PCPLT32:
1638 	case R_SPARC_PCPLT22:
1639 	case R_SPARC_PCPLT10:
1640 	case R_SPARC_PLT64:
1641 	  /* This symbol requires a procedure linkage table entry.  We
1642 	     actually build the entry in adjust_dynamic_symbol,
1643 	     because this might be a case of linking PIC code without
1644 	     linking in any dynamic objects, in which case we don't
1645 	     need to generate a procedure linkage table after all.  */
1646 
1647 	  if (h == NULL)
1648 	    {
1649 	      if (! ABI_64_P (abfd))
1650 		{
1651 		  /* The Solaris native assembler will generate a WPLT30
1652 		     reloc for a local symbol if you assemble a call from
1653 		     one section to another when using -K pic.  We treat
1654 		     it as WDISP30.  */
1655 		  if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1656 		    goto r_sparc_plt32;
1657 		  break;
1658 		}
1659 	      /* PR 7027: We need similar behaviour for 64-bit binaries.  */
1660 	      else if (r_type == R_SPARC_WPLT30)
1661 		break;
1662 
1663 	      /* It does not make sense to have a procedure linkage
1664                  table entry for a local symbol.  */
1665 	      bfd_set_error (bfd_error_bad_value);
1666 	      return FALSE;
1667 	    }
1668 
1669 	  h->needs_plt = 1;
1670 
1671 	  {
1672 	    int this_r_type;
1673 
1674 	    this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1675 	    if (this_r_type == R_SPARC_PLT32
1676 		|| this_r_type == R_SPARC_PLT64)
1677 	      goto r_sparc_plt32;
1678 	  }
1679 	  h->plt.refcount += 1;
1680 	  break;
1681 
1682 	case R_SPARC_PC10:
1683 	case R_SPARC_PC22:
1684 	case R_SPARC_PC_HH22:
1685 	case R_SPARC_PC_HM10:
1686 	case R_SPARC_PC_LM22:
1687 	  if (h != NULL)
1688 	    h->non_got_ref = 1;
1689 
1690 	  if (h != NULL
1691 	      && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1692 	    break;
1693 	  /* Fall through.  */
1694 
1695 	case R_SPARC_DISP8:
1696 	case R_SPARC_DISP16:
1697 	case R_SPARC_DISP32:
1698 	case R_SPARC_DISP64:
1699 	case R_SPARC_WDISP30:
1700 	case R_SPARC_WDISP22:
1701 	case R_SPARC_WDISP19:
1702 	case R_SPARC_WDISP16:
1703 	case R_SPARC_WDISP10:
1704 	case R_SPARC_8:
1705 	case R_SPARC_16:
1706 	case R_SPARC_32:
1707 	case R_SPARC_HI22:
1708 	case R_SPARC_22:
1709 	case R_SPARC_13:
1710 	case R_SPARC_LO10:
1711 	case R_SPARC_UA16:
1712 	case R_SPARC_UA32:
1713 	case R_SPARC_10:
1714 	case R_SPARC_11:
1715 	case R_SPARC_64:
1716 	case R_SPARC_OLO10:
1717 	case R_SPARC_HH22:
1718 	case R_SPARC_HM10:
1719 	case R_SPARC_LM22:
1720 	case R_SPARC_7:
1721 	case R_SPARC_5:
1722 	case R_SPARC_6:
1723 	case R_SPARC_HIX22:
1724 	case R_SPARC_LOX10:
1725 	case R_SPARC_H44:
1726 	case R_SPARC_M44:
1727 	case R_SPARC_L44:
1728 	case R_SPARC_H34:
1729 	case R_SPARC_UA64:
1730 	  if (h != NULL)
1731 	    h->non_got_ref = 1;
1732 
1733 	r_sparc_plt32:
1734 	  if (h != NULL && !info->shared)
1735 	    {
1736 	      /* We may need a .plt entry if the function this reloc
1737 		 refers to is in a shared lib.  */
1738 	      h->plt.refcount += 1;
1739 	    }
1740 
1741 	  /* If we are creating a shared library, and this is a reloc
1742 	     against a global symbol, or a non PC relative reloc
1743 	     against a local symbol, then we need to copy the reloc
1744 	     into the shared library.  However, if we are linking with
1745 	     -Bsymbolic, we do not need to copy a reloc against a
1746 	     global symbol which is defined in an object we are
1747 	     including in the link (i.e., DEF_REGULAR is set).  At
1748 	     this point we have not seen all the input files, so it is
1749 	     possible that DEF_REGULAR is not set now but will be set
1750 	     later (it is never cleared).  In case of a weak definition,
1751 	     DEF_REGULAR may be cleared later by a strong definition in
1752 	     a shared library.  We account for that possibility below by
1753 	     storing information in the relocs_copied field of the hash
1754 	     table entry.  A similar situation occurs when creating
1755 	     shared libraries and symbol visibility changes render the
1756 	     symbol local.
1757 
1758 	     If on the other hand, we are creating an executable, we
1759 	     may need to keep relocations for symbols satisfied by a
1760 	     dynamic library if we manage to avoid copy relocs for the
1761 	     symbol.  */
1762 	  if ((info->shared
1763 	       && (sec->flags & SEC_ALLOC) != 0
1764 	       && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1765 		   || (h != NULL
1766 		       && (! SYMBOLIC_BIND (info, h)
1767 			   || h->root.type == bfd_link_hash_defweak
1768 			   || !h->def_regular))))
1769 	      || (!info->shared
1770 		  && (sec->flags & SEC_ALLOC) != 0
1771 		  && h != NULL
1772 		  && (h->root.type == bfd_link_hash_defweak
1773 		      || !h->def_regular))
1774 	      || (!info->shared
1775 		  && h != NULL
1776 		  && h->type == STT_GNU_IFUNC))
1777 	    {
1778 	      struct _bfd_sparc_elf_dyn_relocs *p;
1779 	      struct _bfd_sparc_elf_dyn_relocs **head;
1780 
1781 	      /* When creating a shared object, we must copy these
1782 		 relocs into the output file.  We create a reloc
1783 		 section in dynobj and make room for the reloc.  */
1784 	      if (sreloc == NULL)
1785 		{
1786 		  sreloc = _bfd_elf_make_dynamic_reloc_section
1787 		    (sec, htab->elf.dynobj, htab->word_align_power,
1788 		     abfd, /*rela?*/ TRUE);
1789 
1790 		  if (sreloc == NULL)
1791 		    return FALSE;
1792 		}
1793 
1794 	      /* If this is a global symbol, we count the number of
1795 		 relocations we need for this symbol.  */
1796 	      if (h != NULL)
1797 		head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1798 	      else
1799 		{
1800 		  /* Track dynamic relocs needed for local syms too.
1801 		     We really need local syms available to do this
1802 		     easily.  Oh well.  */
1803 		  asection *s;
1804 		  void *vpp;
1805 
1806 		  BFD_ASSERT (isym != NULL);
1807 		  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1808 		  if (s == NULL)
1809 		    s = sec;
1810 
1811 		  vpp = &elf_section_data (s)->local_dynrel;
1812 		  head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1813 		}
1814 
1815 	      p = *head;
1816 	      if (p == NULL || p->sec != sec)
1817 		{
1818 		  bfd_size_type amt = sizeof *p;
1819 		  p = ((struct _bfd_sparc_elf_dyn_relocs *)
1820 		       bfd_alloc (htab->elf.dynobj, amt));
1821 		  if (p == NULL)
1822 		    return FALSE;
1823 		  p->next = *head;
1824 		  *head = p;
1825 		  p->sec = sec;
1826 		  p->count = 0;
1827 		  p->pc_count = 0;
1828 		}
1829 
1830 	      p->count += 1;
1831 	      if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1832 		p->pc_count += 1;
1833 	    }
1834 
1835 	  break;
1836 
1837 	case R_SPARC_GNU_VTINHERIT:
1838 	  if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1839 	    return FALSE;
1840 	  break;
1841 
1842 	case R_SPARC_GNU_VTENTRY:
1843 	  BFD_ASSERT (h != NULL);
1844 	  if (h != NULL
1845 	      && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1846 	    return FALSE;
1847 	  break;
1848 
1849 	case R_SPARC_REGISTER:
1850 	  /* Nothing to do.  */
1851 	  break;
1852 
1853 	default:
1854 	  break;
1855 	}
1856     }
1857 
1858   return TRUE;
1859 }
1860 
1861 asection *
_bfd_sparc_elf_gc_mark_hook(asection * sec,struct bfd_link_info * info,Elf_Internal_Rela * rel,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)1862 _bfd_sparc_elf_gc_mark_hook (asection *sec,
1863 			     struct bfd_link_info *info,
1864 			     Elf_Internal_Rela *rel,
1865 			     struct elf_link_hash_entry *h,
1866 			     Elf_Internal_Sym *sym)
1867 {
1868   if (h != NULL)
1869     switch (SPARC_ELF_R_TYPE (rel->r_info))
1870       {
1871       case R_SPARC_GNU_VTINHERIT:
1872       case R_SPARC_GNU_VTENTRY:
1873 	return NULL;
1874       }
1875 
1876   /* FIXME: The test here, in check_relocs and in relocate_section
1877      dealing with TLS optimization, ought to be !info->executable.  */
1878   if (info->shared)
1879     {
1880       switch (SPARC_ELF_R_TYPE (rel->r_info))
1881 	{
1882 	case R_SPARC_TLS_GD_CALL:
1883 	case R_SPARC_TLS_LDM_CALL:
1884 	  /* This reloc implicitly references __tls_get_addr.  We know
1885 	     another reloc will reference the same symbol as the one
1886 	     on this reloc, so the real symbol and section will be
1887 	     gc marked when processing the other reloc.  That lets
1888 	     us handle __tls_get_addr here.  */
1889 	  h = elf_link_hash_lookup (elf_hash_table (info), "__tls_get_addr",
1890 				    FALSE, FALSE, TRUE);
1891 	  BFD_ASSERT (h != NULL);
1892 	  h->mark = 1;
1893 	  if (h->u.weakdef != NULL)
1894 	    h->u.weakdef->mark = 1;
1895 	  sym = NULL;
1896 	}
1897     }
1898 
1899   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1900 }
1901 
1902 static Elf_Internal_Rela *
sparc_elf_find_reloc_at_ofs(Elf_Internal_Rela * rel,Elf_Internal_Rela * relend,bfd_vma offset)1903 sparc_elf_find_reloc_at_ofs (Elf_Internal_Rela *rel,
1904 			     Elf_Internal_Rela *relend,
1905 			     bfd_vma offset)
1906 {
1907   while (rel < relend)
1908     {
1909       if (rel->r_offset == offset)
1910 	return rel;
1911       rel++;
1912     }
1913   return NULL;
1914 }
1915 
1916 /* Update the got entry reference counts for the section being removed.  */
1917 bfd_boolean
_bfd_sparc_elf_gc_sweep_hook(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)1918 _bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1919 			      asection *sec, const Elf_Internal_Rela *relocs)
1920 {
1921   struct _bfd_sparc_elf_link_hash_table *htab;
1922   Elf_Internal_Shdr *symtab_hdr;
1923   struct elf_link_hash_entry **sym_hashes;
1924   bfd_signed_vma *local_got_refcounts;
1925   const Elf_Internal_Rela *rel, *relend;
1926 
1927   if (info->relocatable)
1928     return TRUE;
1929 
1930   BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1931 
1932   elf_section_data (sec)->local_dynrel = NULL;
1933 
1934   htab = _bfd_sparc_elf_hash_table (info);
1935   BFD_ASSERT (htab != NULL);
1936   symtab_hdr = &elf_symtab_hdr (abfd);
1937   sym_hashes = elf_sym_hashes (abfd);
1938   local_got_refcounts = elf_local_got_refcounts (abfd);
1939 
1940   relend = relocs + sec->reloc_count;
1941   for (rel = relocs; rel < relend; rel++)
1942     {
1943       unsigned long r_symndx;
1944       unsigned int r_type;
1945       struct elf_link_hash_entry *h = NULL;
1946 
1947       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1948       if (r_symndx >= symtab_hdr->sh_info)
1949 	{
1950 	  struct _bfd_sparc_elf_link_hash_entry *eh;
1951 	  struct _bfd_sparc_elf_dyn_relocs **pp;
1952 	  struct _bfd_sparc_elf_dyn_relocs *p;
1953 
1954 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1955 	  while (h->root.type == bfd_link_hash_indirect
1956 		 || h->root.type == bfd_link_hash_warning)
1957 	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
1958 	  eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1959 	  for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1960 	    if (p->sec == sec)
1961 	      {
1962 		/* Everything must go for SEC.  */
1963 		*pp = p->next;
1964 		break;
1965 	      }
1966 	}
1967 
1968       r_type = SPARC_ELF_R_TYPE (rel->r_info);
1969       r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1970       switch (r_type)
1971 	{
1972 	case R_SPARC_TLS_LDM_HI22:
1973 	case R_SPARC_TLS_LDM_LO10:
1974 	  if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1975 	    _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1976 	  break;
1977 
1978 	case R_SPARC_TLS_GD_HI22:
1979 	case R_SPARC_TLS_GD_LO10:
1980 	case R_SPARC_TLS_IE_HI22:
1981 	case R_SPARC_TLS_IE_LO10:
1982 	case R_SPARC_GOT10:
1983 	case R_SPARC_GOT13:
1984 	case R_SPARC_GOT22:
1985 	case R_SPARC_GOTDATA_HIX22:
1986 	case R_SPARC_GOTDATA_LOX10:
1987 	case R_SPARC_GOTDATA_OP_HIX22:
1988 	case R_SPARC_GOTDATA_OP_LOX10:
1989 	  if (h != NULL)
1990 	    {
1991 	      if (h->got.refcount > 0)
1992 		h->got.refcount--;
1993 	    }
1994 	  else
1995 	    {
1996 	      switch (r_type)
1997 		{
1998 		case R_SPARC_GOTDATA_OP_HIX22:
1999 		case R_SPARC_GOTDATA_OP_LOX10:
2000 		  break;
2001 
2002 		default:
2003 		  if (local_got_refcounts[r_symndx] > 0)
2004 		    local_got_refcounts[r_symndx]--;
2005 		  break;
2006 		}
2007 	    }
2008 	  break;
2009 
2010 	case R_SPARC_PC10:
2011 	case R_SPARC_PC22:
2012 	case R_SPARC_PC_HH22:
2013 	case R_SPARC_PC_HM10:
2014 	case R_SPARC_PC_LM22:
2015 	  if (h != NULL
2016 	      && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2017 	    break;
2018 	  /* Fall through.  */
2019 
2020 	case R_SPARC_DISP8:
2021 	case R_SPARC_DISP16:
2022 	case R_SPARC_DISP32:
2023 	case R_SPARC_DISP64:
2024 	case R_SPARC_WDISP30:
2025 	case R_SPARC_WDISP22:
2026 	case R_SPARC_WDISP19:
2027 	case R_SPARC_WDISP16:
2028 	case R_SPARC_WDISP10:
2029 	case R_SPARC_8:
2030 	case R_SPARC_16:
2031 	case R_SPARC_32:
2032 	case R_SPARC_HI22:
2033 	case R_SPARC_22:
2034 	case R_SPARC_13:
2035 	case R_SPARC_LO10:
2036 	case R_SPARC_UA16:
2037 	case R_SPARC_UA32:
2038 	case R_SPARC_PLT32:
2039 	case R_SPARC_10:
2040 	case R_SPARC_11:
2041 	case R_SPARC_64:
2042 	case R_SPARC_OLO10:
2043 	case R_SPARC_HH22:
2044 	case R_SPARC_HM10:
2045 	case R_SPARC_LM22:
2046 	case R_SPARC_7:
2047 	case R_SPARC_5:
2048 	case R_SPARC_6:
2049 	case R_SPARC_HIX22:
2050 	case R_SPARC_LOX10:
2051 	case R_SPARC_H44:
2052 	case R_SPARC_M44:
2053 	case R_SPARC_L44:
2054 	case R_SPARC_H34:
2055 	case R_SPARC_UA64:
2056 	  if (info->shared)
2057 	    break;
2058 	  /* Fall through.  */
2059 
2060 	case R_SPARC_WPLT30:
2061 	  if (h != NULL)
2062 	    {
2063 	      if (h->plt.refcount > 0)
2064 		h->plt.refcount--;
2065 	    }
2066 	  break;
2067 
2068 	default:
2069 	  break;
2070 	}
2071     }
2072 
2073   return TRUE;
2074 }
2075 
2076 /* Adjust a symbol defined by a dynamic object and referenced by a
2077    regular object.  The current definition is in some section of the
2078    dynamic object, but we're not including those sections.  We have to
2079    change the definition to something the rest of the link can
2080    understand.  */
2081 
2082 bfd_boolean
_bfd_sparc_elf_adjust_dynamic_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * h)2083 _bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2084 				     struct elf_link_hash_entry *h)
2085 {
2086   struct _bfd_sparc_elf_link_hash_table *htab;
2087   struct _bfd_sparc_elf_link_hash_entry * eh;
2088   struct _bfd_sparc_elf_dyn_relocs *p;
2089   asection *s;
2090 
2091   htab = _bfd_sparc_elf_hash_table (info);
2092   BFD_ASSERT (htab != NULL);
2093 
2094   /* Make sure we know what is going on here.  */
2095   BFD_ASSERT (htab->elf.dynobj != NULL
2096 	      && (h->needs_plt
2097 		  || h->type == STT_GNU_IFUNC
2098 		  || h->u.weakdef != NULL
2099 		  || (h->def_dynamic
2100 		      && h->ref_regular
2101 		      && !h->def_regular)));
2102 
2103   /* If this is a function, put it in the procedure linkage table.  We
2104      will fill in the contents of the procedure linkage table later
2105      (although we could actually do it here).  The STT_NOTYPE
2106      condition is a hack specifically for the Oracle libraries
2107      delivered for Solaris; for some inexplicable reason, they define
2108      some of their functions as STT_NOTYPE when they really should be
2109      STT_FUNC.  */
2110   if (h->type == STT_FUNC
2111       || h->type == STT_GNU_IFUNC
2112       || h->needs_plt
2113       || (h->type == STT_NOTYPE
2114 	  && (h->root.type == bfd_link_hash_defined
2115 	      || h->root.type == bfd_link_hash_defweak)
2116 	  && (h->root.u.def.section->flags & SEC_CODE) != 0))
2117     {
2118       if (h->plt.refcount <= 0
2119 	  || (h->type != STT_GNU_IFUNC
2120 	      && (SYMBOL_CALLS_LOCAL (info, h)
2121 		  || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2122 		      && h->root.type == bfd_link_hash_undefweak))))
2123 	{
2124 	  /* This case can occur if we saw a WPLT30 reloc in an input
2125 	     file, but the symbol was never referred to by a dynamic
2126 	     object, or if all references were garbage collected.  In
2127 	     such a case, we don't actually need to build a procedure
2128 	     linkage table, and we can just do a WDISP30 reloc instead.  */
2129 	  h->plt.offset = (bfd_vma) -1;
2130 	  h->needs_plt = 0;
2131 	}
2132 
2133       return TRUE;
2134     }
2135   else
2136     h->plt.offset = (bfd_vma) -1;
2137 
2138   /* If this is a weak symbol, and there is a real definition, the
2139      processor independent code will have arranged for us to see the
2140      real definition first, and we can just use the same value.  */
2141   if (h->u.weakdef != NULL)
2142     {
2143       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2144 		  || h->u.weakdef->root.type == bfd_link_hash_defweak);
2145       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2146       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2147       return TRUE;
2148     }
2149 
2150   /* This is a reference to a symbol defined by a dynamic object which
2151      is not a function.  */
2152 
2153   /* If we are creating a shared library, we must presume that the
2154      only references to the symbol are via the global offset table.
2155      For such cases we need not do anything here; the relocations will
2156      be handled correctly by relocate_section.  */
2157   if (info->shared)
2158     return TRUE;
2159 
2160   /* If there are no references to this symbol that do not use the
2161      GOT, we don't need to generate a copy reloc.  */
2162   if (!h->non_got_ref)
2163     return TRUE;
2164 
2165   /* If -z nocopyreloc was given, we won't generate them either.  */
2166   if (info->nocopyreloc)
2167     {
2168       h->non_got_ref = 0;
2169       return TRUE;
2170     }
2171 
2172   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2173   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2174     {
2175       s = p->sec->output_section;
2176       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2177 	break;
2178     }
2179 
2180   /* If we didn't find any dynamic relocs in read-only sections, then
2181      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2182   if (p == NULL)
2183     {
2184       h->non_got_ref = 0;
2185       return TRUE;
2186     }
2187 
2188   /* We must allocate the symbol in our .dynbss section, which will
2189      become part of the .bss section of the executable.  There will be
2190      an entry for this symbol in the .dynsym section.  The dynamic
2191      object will contain position independent code, so all references
2192      from the dynamic object to this symbol will go through the global
2193      offset table.  The dynamic linker will use the .dynsym entry to
2194      determine the address it must put in the global offset table, so
2195      both the dynamic object and the regular object will refer to the
2196      same memory location for the variable.  */
2197 
2198   /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
2199      to copy the initial value out of the dynamic object and into the
2200      runtime process image.  We need to remember the offset into the
2201      .rel.bss section we are going to use.  */
2202   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2203     {
2204       htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
2205       h->needs_copy = 1;
2206     }
2207 
2208   s = htab->sdynbss;
2209 
2210   return _bfd_elf_adjust_dynamic_copy (h, s);
2211 }
2212 
2213 /* Allocate space in .plt, .got and associated reloc sections for
2214    dynamic relocs.  */
2215 
2216 static bfd_boolean
allocate_dynrelocs(struct elf_link_hash_entry * h,void * inf)2217 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2218 {
2219   struct bfd_link_info *info;
2220   struct _bfd_sparc_elf_link_hash_table *htab;
2221   struct _bfd_sparc_elf_link_hash_entry *eh;
2222   struct _bfd_sparc_elf_dyn_relocs *p;
2223 
2224   if (h->root.type == bfd_link_hash_indirect)
2225     return TRUE;
2226 
2227   info = (struct bfd_link_info *) inf;
2228   htab = _bfd_sparc_elf_hash_table (info);
2229   BFD_ASSERT (htab != NULL);
2230 
2231   if ((htab->elf.dynamic_sections_created
2232        && h->plt.refcount > 0)
2233       || (h->type == STT_GNU_IFUNC
2234 	  && h->def_regular
2235 	  && h->ref_regular))
2236     {
2237       /* Make sure this symbol is output as a dynamic symbol.
2238 	 Undefined weak syms won't yet be marked as dynamic.  */
2239       if (h->dynindx == -1
2240 	  && !h->forced_local)
2241 	{
2242 	  if (! bfd_elf_link_record_dynamic_symbol (info, h))
2243 	    return FALSE;
2244 	}
2245 
2246       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h)
2247 	  || (h->type == STT_GNU_IFUNC
2248 	      && h->def_regular))
2249 	{
2250 	  asection *s = htab->elf.splt;
2251 
2252 	  if (s == NULL)
2253 	    s = htab->elf.iplt;
2254 
2255 	  /* Allocate room for the header.  */
2256 	  if (s->size == 0)
2257 	    {
2258 	      s->size = htab->plt_header_size;
2259 
2260 	      /* Allocate space for the .rela.plt.unloaded relocations.  */
2261 	      if (htab->is_vxworks && !info->shared)
2262 		htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
2263 	    }
2264 
2265 	  /* The procedure linkage table size is bounded by the magnitude
2266 	     of the offset we can describe in the entry.  */
2267 	  if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
2268 			  (((bfd_vma)1 << 31) << 1) : 0x400000))
2269 	    {
2270 	      bfd_set_error (bfd_error_bad_value);
2271 	      return FALSE;
2272 	    }
2273 
2274 	  if (SPARC_ELF_WORD_BYTES(htab) == 8
2275 	      && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
2276 	    {
2277 	      bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
2278 
2279 
2280 	      off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
2281 
2282 	      h->plt.offset = (s->size - (off * 8));
2283 	    }
2284 	  else
2285 	    h->plt.offset = s->size;
2286 
2287 	  /* If this symbol is not defined in a regular file, and we are
2288 	     not generating a shared library, then set the symbol to this
2289 	     location in the .plt.  This is required to make function
2290 	     pointers compare as equal between the normal executable and
2291 	     the shared library.  */
2292 	  if (! info->shared
2293 	      && !h->def_regular)
2294 	    {
2295 	      h->root.u.def.section = s;
2296 	      h->root.u.def.value = h->plt.offset;
2297 	    }
2298 
2299 	  /* Make room for this entry.  */
2300 	  s->size += htab->plt_entry_size;
2301 
2302 	  /* We also need to make an entry in the .rela.plt section.  */
2303 	  if (s == htab->elf.splt)
2304 	    htab->elf.srelplt->size += SPARC_ELF_RELA_BYTES (htab);
2305 	  else
2306 	    htab->elf.irelplt->size += SPARC_ELF_RELA_BYTES (htab);
2307 
2308 	  if (htab->is_vxworks)
2309 	    {
2310 	      /* Allocate space for the .got.plt entry.  */
2311 	      htab->elf.sgotplt->size += 4;
2312 
2313 	      /* ...and for the .rela.plt.unloaded relocations.  */
2314 	      if (!info->shared)
2315 		htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
2316 	    }
2317 	}
2318       else
2319 	{
2320 	  h->plt.offset = (bfd_vma) -1;
2321 	  h->needs_plt = 0;
2322 	}
2323     }
2324   else
2325     {
2326       h->plt.offset = (bfd_vma) -1;
2327       h->needs_plt = 0;
2328     }
2329 
2330   /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
2331      make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry.  */
2332   if (h->got.refcount > 0
2333       && !info->shared
2334       && h->dynindx == -1
2335       && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2336     h->got.offset = (bfd_vma) -1;
2337   else if (h->got.refcount > 0)
2338     {
2339       asection *s;
2340       bfd_boolean dyn;
2341       int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
2342 
2343       /* Make sure this symbol is output as a dynamic symbol.
2344 	 Undefined weak syms won't yet be marked as dynamic.  */
2345       if (h->dynindx == -1
2346 	  && !h->forced_local)
2347 	{
2348 	  if (! bfd_elf_link_record_dynamic_symbol (info, h))
2349 	    return FALSE;
2350 	}
2351 
2352       s = htab->elf.sgot;
2353       h->got.offset = s->size;
2354       s->size += SPARC_ELF_WORD_BYTES (htab);
2355       /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots.  */
2356       if (tls_type == GOT_TLS_GD)
2357 	s->size += SPARC_ELF_WORD_BYTES (htab);
2358       dyn = htab->elf.dynamic_sections_created;
2359       /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
2360 	 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2361 	 global.  */
2362       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2363 	  || tls_type == GOT_TLS_IE
2364 	  || h->type == STT_GNU_IFUNC)
2365 	htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2366       else if (tls_type == GOT_TLS_GD)
2367 	htab->elf.srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2368       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2369 	htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2370     }
2371   else
2372     h->got.offset = (bfd_vma) -1;
2373 
2374   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2375   if (eh->dyn_relocs == NULL)
2376     return TRUE;
2377 
2378   /* In the shared -Bsymbolic case, discard space allocated for
2379      dynamic pc-relative relocs against symbols which turn out to be
2380      defined in regular objects.  For the normal shared case, discard
2381      space for pc-relative relocs that have become local due to symbol
2382      visibility changes.  */
2383 
2384   if (info->shared)
2385     {
2386       if (SYMBOL_CALLS_LOCAL (info, h))
2387 	{
2388 	  struct _bfd_sparc_elf_dyn_relocs **pp;
2389 
2390 	  for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2391 	    {
2392 	      p->count -= p->pc_count;
2393 	      p->pc_count = 0;
2394 	      if (p->count == 0)
2395 		*pp = p->next;
2396 	      else
2397 		pp = &p->next;
2398 	    }
2399 	}
2400 
2401       if (htab->is_vxworks)
2402 	{
2403 	  struct _bfd_sparc_elf_dyn_relocs **pp;
2404 
2405 	  for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2406 	    {
2407 	      if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2408 		*pp = p->next;
2409 	      else
2410 		pp = &p->next;
2411 	    }
2412 	}
2413 
2414       /* Also discard relocs on undefined weak syms with non-default
2415 	 visibility.  */
2416       if (eh->dyn_relocs != NULL
2417 	  && h->root.type == bfd_link_hash_undefweak)
2418 	{
2419 	  if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2420 	    eh->dyn_relocs = NULL;
2421 
2422 	  /* Make sure undefined weak symbols are output as a dynamic
2423 	     symbol in PIEs.  */
2424 	  else if (h->dynindx == -1
2425 		   && !h->forced_local)
2426 	    {
2427 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
2428 		return FALSE;
2429 	    }
2430 	}
2431     }
2432   else
2433     {
2434       /* For the non-shared case, discard space for relocs against
2435 	 symbols which turn out to need copy relocs or are not
2436 	 dynamic.  */
2437 
2438       if (!h->non_got_ref
2439 	  && ((h->def_dynamic
2440 	       && !h->def_regular)
2441 	      || (htab->elf.dynamic_sections_created
2442 		  && (h->root.type == bfd_link_hash_undefweak
2443 		      || h->root.type == bfd_link_hash_undefined))))
2444 	{
2445 	  /* Make sure this symbol is output as a dynamic symbol.
2446 	     Undefined weak syms won't yet be marked as dynamic.  */
2447 	  if (h->dynindx == -1
2448 	      && !h->forced_local)
2449 	    {
2450 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
2451 		return FALSE;
2452 	    }
2453 
2454 	  /* If that succeeded, we know we'll be keeping all the
2455 	     relocs.  */
2456 	  if (h->dynindx != -1)
2457 	    goto keep;
2458 	}
2459 
2460       eh->dyn_relocs = NULL;
2461 
2462     keep: ;
2463     }
2464 
2465   /* Finally, allocate space.  */
2466   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2467     {
2468       asection *sreloc = elf_section_data (p->sec)->sreloc;
2469       sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2470     }
2471 
2472   return TRUE;
2473 }
2474 
2475 /* Allocate space in .plt, .got and associated reloc sections for
2476    local dynamic relocs.  */
2477 
2478 static bfd_boolean
allocate_local_dynrelocs(void ** slot,void * inf)2479 allocate_local_dynrelocs (void **slot, void *inf)
2480 {
2481   struct elf_link_hash_entry *h
2482     = (struct elf_link_hash_entry *) *slot;
2483 
2484   if (h->type != STT_GNU_IFUNC
2485       || !h->def_regular
2486       || !h->ref_regular
2487       || !h->forced_local
2488       || h->root.type != bfd_link_hash_defined)
2489     abort ();
2490 
2491   return allocate_dynrelocs (h, inf);
2492 }
2493 
2494 /* Find any dynamic relocs that apply to read-only sections.  */
2495 
2496 static bfd_boolean
readonly_dynrelocs(struct elf_link_hash_entry * h,void * inf)2497 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2498 {
2499   struct _bfd_sparc_elf_link_hash_entry *eh;
2500   struct _bfd_sparc_elf_dyn_relocs *p;
2501 
2502   eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2503   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2504     {
2505       asection *s = p->sec->output_section;
2506 
2507       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2508 	{
2509 	  struct bfd_link_info *info = (struct bfd_link_info *) inf;
2510 
2511 	  info->flags |= DF_TEXTREL;
2512 
2513 	  /* Not an error, just cut short the traversal.  */
2514 	  return FALSE;
2515 	}
2516     }
2517   return TRUE;
2518 }
2519 
2520 /* Return true if the dynamic symbol for a given section should be
2521    omitted when creating a shared library.  */
2522 
2523 bfd_boolean
_bfd_sparc_elf_omit_section_dynsym(bfd * output_bfd,struct bfd_link_info * info,asection * p)2524 _bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2525 				    struct bfd_link_info *info,
2526 				    asection *p)
2527 {
2528   /* We keep the .got section symbol so that explicit relocations
2529      against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2530      can be turned into relocations against the .got symbol.  */
2531   if (strcmp (p->name, ".got") == 0)
2532     return FALSE;
2533 
2534   return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2535 }
2536 
2537 /* Set the sizes of the dynamic sections.  */
2538 
2539 bfd_boolean
_bfd_sparc_elf_size_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)2540 _bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2541 				      struct bfd_link_info *info)
2542 {
2543   struct _bfd_sparc_elf_link_hash_table *htab;
2544   bfd *dynobj;
2545   asection *s;
2546   bfd *ibfd;
2547 
2548   htab = _bfd_sparc_elf_hash_table (info);
2549   BFD_ASSERT (htab != NULL);
2550   dynobj = htab->elf.dynobj;
2551   BFD_ASSERT (dynobj != NULL);
2552 
2553   if (elf_hash_table (info)->dynamic_sections_created)
2554     {
2555       /* Set the contents of the .interp section to the interpreter.  */
2556       if (info->executable)
2557 	{
2558 	  s = bfd_get_linker_section (dynobj, ".interp");
2559 	  BFD_ASSERT (s != NULL);
2560 	  s->size = htab->dynamic_interpreter_size;
2561 	  s->contents = (unsigned char *) htab->dynamic_interpreter;
2562 	}
2563     }
2564 
2565   /* Set up .got offsets for local syms, and space for local dynamic
2566      relocs.  */
2567   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2568     {
2569       bfd_signed_vma *local_got;
2570       bfd_signed_vma *end_local_got;
2571       char *local_tls_type;
2572       bfd_size_type locsymcount;
2573       Elf_Internal_Shdr *symtab_hdr;
2574       asection *srel;
2575 
2576       if (! is_sparc_elf (ibfd))
2577 	continue;
2578 
2579       for (s = ibfd->sections; s != NULL; s = s->next)
2580 	{
2581 	  struct _bfd_sparc_elf_dyn_relocs *p;
2582 
2583 	  for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2584 	    {
2585 	      if (!bfd_is_abs_section (p->sec)
2586 		  && bfd_is_abs_section (p->sec->output_section))
2587 		{
2588 		  /* Input section has been discarded, either because
2589 		     it is a copy of a linkonce section or due to
2590 		     linker script /DISCARD/, so we'll be discarding
2591 		     the relocs too.  */
2592 		}
2593 	      else if (htab->is_vxworks
2594 		       && strcmp (p->sec->output_section->name,
2595 				  ".tls_vars") == 0)
2596 		{
2597 		  /* Relocations in vxworks .tls_vars sections are
2598 		     handled specially by the loader.  */
2599 		}
2600 	      else if (p->count != 0)
2601 		{
2602 		  srel = elf_section_data (p->sec)->sreloc;
2603 		  if (!htab->elf.dynamic_sections_created)
2604 		    srel = htab->elf.irelplt;
2605 		  srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2606 		  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2607 		    info->flags |= DF_TEXTREL;
2608 		}
2609 	    }
2610 	}
2611 
2612       local_got = elf_local_got_refcounts (ibfd);
2613       if (!local_got)
2614 	continue;
2615 
2616       symtab_hdr = &elf_symtab_hdr (ibfd);
2617       locsymcount = symtab_hdr->sh_info;
2618       end_local_got = local_got + locsymcount;
2619       local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2620       s = htab->elf.sgot;
2621       srel = htab->elf.srelgot;
2622       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2623 	{
2624 	  if (*local_got > 0)
2625 	    {
2626 	      *local_got = s->size;
2627 	      s->size += SPARC_ELF_WORD_BYTES (htab);
2628 	      if (*local_tls_type == GOT_TLS_GD)
2629 		s->size += SPARC_ELF_WORD_BYTES (htab);
2630 	      if (info->shared
2631 		  || *local_tls_type == GOT_TLS_GD
2632 		  || *local_tls_type == GOT_TLS_IE)
2633 		srel->size += SPARC_ELF_RELA_BYTES (htab);
2634 	    }
2635 	  else
2636 	    *local_got = (bfd_vma) -1;
2637 	}
2638     }
2639 
2640   if (htab->tls_ldm_got.refcount > 0)
2641     {
2642       /* Allocate 2 got entries and 1 dynamic reloc for
2643 	 R_SPARC_TLS_LDM_{HI22,LO10} relocs.  */
2644       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2645       htab->elf.sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2646       htab->elf.srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2647     }
2648   else
2649     htab->tls_ldm_got.offset = -1;
2650 
2651   /* Allocate global sym .plt and .got entries, and space for global
2652      sym dynamic relocs.  */
2653   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2654 
2655   /* Allocate .plt and .got entries, and space for local symbols.  */
2656   htab_traverse (htab->loc_hash_table, allocate_local_dynrelocs, info);
2657 
2658   if (! ABI_64_P (output_bfd)
2659       && !htab->is_vxworks
2660       && elf_hash_table (info)->dynamic_sections_created)
2661     {
2662       /* Make space for the trailing nop in .plt.  */
2663       if (htab->elf.splt->size > 0)
2664 	htab->elf.splt->size += 1 * SPARC_INSN_BYTES;
2665 
2666       /* If the .got section is more than 0x1000 bytes, we add
2667 	 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2668 	 bit relocations have a greater chance of working.
2669 
2670 	 FIXME: Make this optimization work for 64-bit too.  */
2671       if (htab->elf.sgot->size >= 0x1000
2672 	  && elf_hash_table (info)->hgot->root.u.def.value == 0)
2673 	elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2674     }
2675 
2676   /* The check_relocs and adjust_dynamic_symbol entry points have
2677      determined the sizes of the various dynamic sections.  Allocate
2678      memory for them.  */
2679   for (s = dynobj->sections; s != NULL; s = s->next)
2680     {
2681       if ((s->flags & SEC_LINKER_CREATED) == 0)
2682 	continue;
2683 
2684       if (s == htab->elf.splt
2685 	  || s == htab->elf.sgot
2686 	  || s == htab->sdynbss
2687 	  || s == htab->elf.iplt
2688 	  || s == htab->elf.sgotplt)
2689 	{
2690 	  /* Strip this section if we don't need it; see the
2691 	     comment below.  */
2692 	}
2693       else if (CONST_STRNEQ (s->name, ".rela"))
2694 	{
2695 	  if (s->size != 0)
2696 	    {
2697 	      /* We use the reloc_count field as a counter if we need
2698 		 to copy relocs into the output file.  */
2699 	      s->reloc_count = 0;
2700 	    }
2701 	}
2702       else
2703 	{
2704 	  /* It's not one of our sections.  */
2705 	  continue;
2706 	}
2707 
2708       if (s->size == 0)
2709 	{
2710 	  /* If we don't need this section, strip it from the
2711 	     output file.  This is mostly to handle .rela.bss and
2712 	     .rela.plt.  We must create both sections in
2713 	     create_dynamic_sections, because they must be created
2714 	     before the linker maps input sections to output
2715 	     sections.  The linker does that before
2716 	     adjust_dynamic_symbol is called, and it is that
2717 	     function which decides whether anything needs to go
2718 	     into these sections.  */
2719 	  s->flags |= SEC_EXCLUDE;
2720 	  continue;
2721 	}
2722 
2723       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2724 	continue;
2725 
2726       /* Allocate memory for the section contents.  Zero the memory
2727 	 for the benefit of .rela.plt, which has 4 unused entries
2728 	 at the beginning, and we don't want garbage.  */
2729       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2730       if (s->contents == NULL)
2731 	return FALSE;
2732     }
2733 
2734   if (elf_hash_table (info)->dynamic_sections_created)
2735     {
2736       /* Add some entries to the .dynamic section.  We fill in the
2737 	 values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2738 	 must add the entries now so that we get the correct size for
2739 	 the .dynamic section.  The DT_DEBUG entry is filled in by the
2740 	 dynamic linker and used by the debugger.  */
2741 #define add_dynamic_entry(TAG, VAL) \
2742   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2743 
2744       if (info->executable)
2745 	{
2746 	  if (!add_dynamic_entry (DT_DEBUG, 0))
2747 	    return FALSE;
2748 	}
2749 
2750       if (htab->elf.srelplt->size != 0)
2751 	{
2752 	  if (!add_dynamic_entry (DT_PLTGOT, 0)
2753 	      || !add_dynamic_entry (DT_PLTRELSZ, 0)
2754 	      || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2755 	      || !add_dynamic_entry (DT_JMPREL, 0))
2756 	    return FALSE;
2757 	}
2758 
2759       if (!add_dynamic_entry (DT_RELA, 0)
2760 	  || !add_dynamic_entry (DT_RELASZ, 0)
2761 	  || !add_dynamic_entry (DT_RELAENT,
2762 				 SPARC_ELF_RELA_BYTES (htab)))
2763 	return FALSE;
2764 
2765       /* If any dynamic relocs apply to a read-only section,
2766 	 then we need a DT_TEXTREL entry.  */
2767       if ((info->flags & DF_TEXTREL) == 0)
2768 	elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
2769 
2770       if (info->flags & DF_TEXTREL)
2771 	{
2772 	  if (!add_dynamic_entry (DT_TEXTREL, 0))
2773 	    return FALSE;
2774 	}
2775 
2776       if (ABI_64_P (output_bfd))
2777 	{
2778 	  int reg;
2779 	  struct _bfd_sparc_elf_app_reg * app_regs;
2780 	  struct elf_strtab_hash *dynstr;
2781 	  struct elf_link_hash_table *eht = elf_hash_table (info);
2782 
2783 	  /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2784 	     entries if needed.  */
2785 	  app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2786 	  dynstr = eht->dynstr;
2787 
2788 	  for (reg = 0; reg < 4; reg++)
2789 	    if (app_regs [reg].name != NULL)
2790 	      {
2791 		struct elf_link_local_dynamic_entry *entry, *e;
2792 
2793 		if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2794 		  return FALSE;
2795 
2796 		entry = (struct elf_link_local_dynamic_entry *)
2797 		  bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2798 		if (entry == NULL)
2799 		  return FALSE;
2800 
2801 		/* We cheat here a little bit: the symbol will not be local, so we
2802 		   put it at the end of the dynlocal linked list.  We will fix it
2803 		   later on, as we have to fix other fields anyway.  */
2804 		entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2805 		entry->isym.st_size = 0;
2806 		if (*app_regs [reg].name != '\0')
2807 		  entry->isym.st_name
2808 		    = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2809 		else
2810 		  entry->isym.st_name = 0;
2811 		entry->isym.st_other = 0;
2812 		entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2813 						   STT_REGISTER);
2814 		entry->isym.st_shndx = app_regs [reg].shndx;
2815 		entry->isym.st_target_internal = 0;
2816 		entry->next = NULL;
2817 		entry->input_bfd = output_bfd;
2818 		entry->input_indx = -1;
2819 
2820 		if (eht->dynlocal == NULL)
2821 		  eht->dynlocal = entry;
2822 		else
2823 		  {
2824 		    for (e = eht->dynlocal; e->next; e = e->next)
2825 		      ;
2826 		    e->next = entry;
2827 		  }
2828 		eht->dynsymcount++;
2829 	      }
2830 	}
2831       if (htab->is_vxworks
2832 	  && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2833 	return FALSE;
2834     }
2835 #undef add_dynamic_entry
2836 
2837   return TRUE;
2838 }
2839 
2840 bfd_boolean
_bfd_sparc_elf_new_section_hook(bfd * abfd,asection * sec)2841 _bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2842 {
2843   if (!sec->used_by_bfd)
2844     {
2845       struct _bfd_sparc_elf_section_data *sdata;
2846       bfd_size_type amt = sizeof (*sdata);
2847 
2848       sdata = bfd_zalloc (abfd, amt);
2849       if (sdata == NULL)
2850 	return FALSE;
2851       sec->used_by_bfd = sdata;
2852     }
2853 
2854   return _bfd_elf_new_section_hook (abfd, sec);
2855 }
2856 
2857 bfd_boolean
_bfd_sparc_elf_relax_section(bfd * abfd ATTRIBUTE_UNUSED,struct bfd_section * section,struct bfd_link_info * link_info ATTRIBUTE_UNUSED,bfd_boolean * again)2858 _bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2859 			      struct bfd_section *section,
2860 			      struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2861 			      bfd_boolean *again)
2862 {
2863   if (link_info->relocatable)
2864     (*link_info->callbacks->einfo)
2865       (_("%P%F: --relax and -r may not be used together\n"));
2866 
2867   *again = FALSE;
2868   sec_do_relax (section) = 1;
2869   return TRUE;
2870 }
2871 
2872 /* Return the base VMA address which should be subtracted from real addresses
2873    when resolving @dtpoff relocation.
2874    This is PT_TLS segment p_vaddr.  */
2875 
2876 static bfd_vma
dtpoff_base(struct bfd_link_info * info)2877 dtpoff_base (struct bfd_link_info *info)
2878 {
2879   /* If tls_sec is NULL, we should have signalled an error already.  */
2880   if (elf_hash_table (info)->tls_sec == NULL)
2881     return 0;
2882   return elf_hash_table (info)->tls_sec->vma;
2883 }
2884 
2885 /* Return the relocation value for @tpoff relocation
2886    if STT_TLS virtual address is ADDRESS.  */
2887 
2888 static bfd_vma
tpoff(struct bfd_link_info * info,bfd_vma address)2889 tpoff (struct bfd_link_info *info, bfd_vma address)
2890 {
2891   struct elf_link_hash_table *htab = elf_hash_table (info);
2892   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2893   bfd_vma static_tls_size;
2894 
2895   /* If tls_sec is NULL, we should have signalled an error already.  */
2896   if (htab->tls_sec == NULL)
2897     return 0;
2898 
2899   /* Consider special static TLS alignment requirements.  */
2900   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2901   return address - static_tls_size - htab->tls_sec->vma;
2902 }
2903 
2904 /* Return the relocation value for a %gdop relocation.  */
2905 
2906 static bfd_vma
gdopoff(struct bfd_link_info * info,bfd_vma address)2907 gdopoff (struct bfd_link_info *info, bfd_vma address)
2908 {
2909   struct elf_link_hash_table *htab = elf_hash_table (info);
2910   bfd_vma got_base;
2911 
2912   got_base = (htab->hgot->root.u.def.value
2913 	      + htab->hgot->root.u.def.section->output_offset
2914 	      + htab->hgot->root.u.def.section->output_section->vma);
2915 
2916   return address - got_base;
2917 }
2918 
2919 /* Relocate a SPARC ELF section.  */
2920 
2921 bfd_boolean
_bfd_sparc_elf_relocate_section(bfd * output_bfd,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,Elf_Internal_Rela * relocs,Elf_Internal_Sym * local_syms,asection ** local_sections)2922 _bfd_sparc_elf_relocate_section (bfd *output_bfd,
2923 				 struct bfd_link_info *info,
2924 				 bfd *input_bfd,
2925 				 asection *input_section,
2926 				 bfd_byte *contents,
2927 				 Elf_Internal_Rela *relocs,
2928 				 Elf_Internal_Sym *local_syms,
2929 				 asection **local_sections)
2930 {
2931   struct _bfd_sparc_elf_link_hash_table *htab;
2932   Elf_Internal_Shdr *symtab_hdr;
2933   struct elf_link_hash_entry **sym_hashes;
2934   bfd_vma *local_got_offsets;
2935   bfd_vma got_base;
2936   asection *sreloc;
2937   Elf_Internal_Rela *rel;
2938   Elf_Internal_Rela *relend;
2939   int num_relocs;
2940   bfd_boolean is_vxworks_tls;
2941 
2942   htab = _bfd_sparc_elf_hash_table (info);
2943   BFD_ASSERT (htab != NULL);
2944   symtab_hdr = &elf_symtab_hdr (input_bfd);
2945   sym_hashes = elf_sym_hashes (input_bfd);
2946   local_got_offsets = elf_local_got_offsets (input_bfd);
2947 
2948   if (elf_hash_table (info)->hgot == NULL)
2949     got_base = 0;
2950   else
2951     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2952 
2953   sreloc = elf_section_data (input_section)->sreloc;
2954   /* We have to handle relocations in vxworks .tls_vars sections
2955      specially, because the dynamic loader is 'weird'.  */
2956   is_vxworks_tls = (htab->is_vxworks && info->shared
2957 		    && !strcmp (input_section->output_section->name,
2958 				".tls_vars"));
2959 
2960   rel = relocs;
2961   if (ABI_64_P (output_bfd))
2962     num_relocs = NUM_SHDR_ENTRIES (_bfd_elf_single_rel_hdr (input_section));
2963   else
2964     num_relocs = input_section->reloc_count;
2965   relend = relocs + num_relocs;
2966   for (; rel < relend; rel++)
2967     {
2968       int r_type, tls_type;
2969       reloc_howto_type *howto;
2970       unsigned long r_symndx;
2971       struct elf_link_hash_entry *h;
2972       Elf_Internal_Sym *sym;
2973       asection *sec;
2974       bfd_vma relocation, off;
2975       bfd_reloc_status_type r;
2976       bfd_boolean is_plt = FALSE;
2977       bfd_boolean unresolved_reloc;
2978 
2979       r_type = SPARC_ELF_R_TYPE (rel->r_info);
2980       if (r_type == R_SPARC_GNU_VTINHERIT
2981 	  || r_type == R_SPARC_GNU_VTENTRY)
2982 	continue;
2983 
2984       if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2985 	{
2986 	  bfd_set_error (bfd_error_bad_value);
2987 	  return FALSE;
2988 	}
2989       howto = _bfd_sparc_elf_howto_table + r_type;
2990 
2991       r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2992       h = NULL;
2993       sym = NULL;
2994       sec = NULL;
2995       unresolved_reloc = FALSE;
2996       if (r_symndx < symtab_hdr->sh_info)
2997 	{
2998 	  sym = local_syms + r_symndx;
2999 	  sec = local_sections[r_symndx];
3000 	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3001 
3002 	  if (!info->relocatable
3003 	      && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3004 	    {
3005 	      /* Relocate against local STT_GNU_IFUNC symbol.  */
3006 	      h = elf_sparc_get_local_sym_hash (htab, input_bfd,
3007 						rel, FALSE);
3008 	      if (h == NULL)
3009 		abort ();
3010 
3011 	      /* Set STT_GNU_IFUNC symbol value.  */
3012 	      h->root.u.def.value = sym->st_value;
3013 	      h->root.u.def.section = sec;
3014 	    }
3015 	}
3016       else
3017 	{
3018 	  bfd_boolean warned;
3019 
3020 	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3021 				   r_symndx, symtab_hdr, sym_hashes,
3022 				   h, sec, relocation,
3023 				   unresolved_reloc, warned);
3024 	  if (warned)
3025 	    {
3026 	      /* To avoid generating warning messages about truncated
3027 		 relocations, set the relocation's address to be the same as
3028 		 the start of this section.  */
3029 	      if (input_section->output_section != NULL)
3030 		relocation = input_section->output_section->vma;
3031 	      else
3032 		relocation = 0;
3033 	    }
3034 	}
3035 
3036       if (sec != NULL && discarded_section (sec))
3037 	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3038 					 rel, 1, relend, howto, 0, contents);
3039 
3040       if (info->relocatable)
3041 	continue;
3042 
3043       if (h != NULL
3044 	  && h->type == STT_GNU_IFUNC
3045 	  && h->def_regular)
3046 	{
3047 	  asection *plt_sec;
3048 	  const char *name;
3049 
3050 	  if ((input_section->flags & SEC_ALLOC) == 0
3051 	      || h->plt.offset == (bfd_vma) -1)
3052 	    abort ();
3053 
3054 	  plt_sec = htab->elf.splt;
3055 	  if (! plt_sec)
3056 	    plt_sec =htab->elf.iplt;
3057 
3058 	  switch (r_type)
3059 	    {
3060 	    case R_SPARC_GOTDATA_OP:
3061 	      continue;
3062 
3063 	    case R_SPARC_GOTDATA_OP_HIX22:
3064 	    case R_SPARC_GOTDATA_OP_LOX10:
3065 	      r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3066 			? R_SPARC_GOT22
3067 			: R_SPARC_GOT10);
3068 	      howto = _bfd_sparc_elf_howto_table + r_type;
3069 	      /* Fall through.  */
3070 
3071 	    case R_SPARC_GOT10:
3072 	    case R_SPARC_GOT13:
3073 	    case R_SPARC_GOT22:
3074 	      if (htab->elf.sgot == NULL)
3075 		abort ();
3076 	      off = h->got.offset;
3077 	      if (off == (bfd_vma) -1)
3078 		abort();
3079 	      relocation = htab->elf.sgot->output_offset + off - got_base;
3080 	      goto do_relocation;
3081 
3082 	    case R_SPARC_WPLT30:
3083 	    case R_SPARC_WDISP30:
3084 	      relocation = (plt_sec->output_section->vma
3085 			    + plt_sec->output_offset + h->plt.offset);
3086 	      goto do_relocation;
3087 
3088 	    case R_SPARC_32:
3089 	    case R_SPARC_64:
3090 	      if (info->shared && h->non_got_ref)
3091 		{
3092 		  Elf_Internal_Rela outrel;
3093 		  bfd_vma offset;
3094 
3095 		  offset = _bfd_elf_section_offset (output_bfd, info,
3096 						    input_section,
3097 						    rel->r_offset);
3098 		  if (offset == (bfd_vma) -1
3099 		      || offset == (bfd_vma) -2)
3100 		    abort();
3101 
3102 		  outrel.r_offset = (input_section->output_section->vma
3103 				     + input_section->output_offset
3104 				     + offset);
3105 
3106 		  if (h->dynindx == -1
3107 		      || h->forced_local
3108 		      || info->executable)
3109 		    {
3110 		      outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3111 							0, R_SPARC_IRELATIVE);
3112 		      outrel.r_addend = relocation + rel->r_addend;
3113 		    }
3114 		  else
3115 		    {
3116 		      if (h->dynindx == -1)
3117 			abort();
3118 		      outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3119 		      outrel.r_addend = rel->r_addend;
3120 		    }
3121 
3122 		  sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3123 		  continue;
3124 		}
3125 
3126 	      relocation = (plt_sec->output_section->vma
3127 			    + plt_sec->output_offset + h->plt.offset);
3128 	      goto do_relocation;
3129 
3130 	    case R_SPARC_HI22:
3131 	    case R_SPARC_LO10:
3132 	      /* We should only see such relocs in static links.  */
3133 	      if (info->shared)
3134 		abort();
3135 	      relocation = (plt_sec->output_section->vma
3136 			    + plt_sec->output_offset + h->plt.offset);
3137 	      goto do_relocation;
3138 
3139 	    default:
3140 	      if (h->root.root.string)
3141 		name = h->root.root.string;
3142 	      else
3143 		name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3144 					 NULL);
3145 	      (*_bfd_error_handler)
3146 		(_("%B: relocation %s against STT_GNU_IFUNC "
3147 		   "symbol `%s' isn't handled by %s"), input_bfd,
3148 		 _bfd_sparc_elf_howto_table[r_type].name,
3149 		 name, __FUNCTION__);
3150 	      bfd_set_error (bfd_error_bad_value);
3151 	      return FALSE;
3152 	    }
3153 	}
3154 
3155       switch (r_type)
3156 	{
3157 	case R_SPARC_GOTDATA_OP_HIX22:
3158 	case R_SPARC_GOTDATA_OP_LOX10:
3159 	  if (SYMBOL_REFERENCES_LOCAL (info, h))
3160 	    r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3161 		      ? R_SPARC_GOTDATA_HIX22
3162 		      : R_SPARC_GOTDATA_LOX10);
3163 	  else
3164 	    r_type = (r_type == R_SPARC_GOTDATA_OP_HIX22
3165 		      ? R_SPARC_GOT22
3166 		      : R_SPARC_GOT10);
3167 	  howto = _bfd_sparc_elf_howto_table + r_type;
3168 	  break;
3169 
3170 	case R_SPARC_GOTDATA_OP:
3171 	  if (SYMBOL_REFERENCES_LOCAL (info, h))
3172 	    {
3173 	      bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3174 
3175 	      /* {ld,ldx} [%rs1 + %rs2], %rd --> add %rs1, %rs2, %rd */
3176 	      relocation = 0x80000000 | (insn & 0x3e07c01f);
3177 	      bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3178 	    }
3179 	  continue;
3180 	}
3181 
3182       switch (r_type)
3183 	{
3184 	case R_SPARC_GOTDATA_HIX22:
3185 	case R_SPARC_GOTDATA_LOX10:
3186 	  relocation = gdopoff (info, relocation);
3187 	  break;
3188 
3189 	case R_SPARC_GOT10:
3190 	case R_SPARC_GOT13:
3191 	case R_SPARC_GOT22:
3192 	  /* Relocation is to the entry for this symbol in the global
3193 	     offset table.  */
3194 	  if (htab->elf.sgot == NULL)
3195 	    abort ();
3196 
3197 	  if (h != NULL)
3198 	    {
3199 	      bfd_boolean dyn;
3200 
3201 	      off = h->got.offset;
3202 	      BFD_ASSERT (off != (bfd_vma) -1);
3203 	      dyn = elf_hash_table (info)->dynamic_sections_created;
3204 
3205 	      if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3206 		  || (info->shared
3207 		      && SYMBOL_REFERENCES_LOCAL (info, h)))
3208 		{
3209 		  /* This is actually a static link, or it is a
3210 		     -Bsymbolic link and the symbol is defined
3211 		     locally, or the symbol was forced to be local
3212 		     because of a version file.  We must initialize
3213 		     this entry in the global offset table.  Since the
3214 		     offset must always be a multiple of 8 for 64-bit
3215 		     and 4 for 32-bit, we use the least significant bit
3216 		     to record whether we have initialized it already.
3217 
3218 		     When doing a dynamic link, we create a .rela.got
3219 		     relocation entry to initialize the value.  This
3220 		     is done in the finish_dynamic_symbol routine.  */
3221 		  if ((off & 1) != 0)
3222 		    off &= ~1;
3223 		  else
3224 		    {
3225 		      SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3226 					  htab->elf.sgot->contents + off);
3227 		      h->got.offset |= 1;
3228 		    }
3229 		}
3230 	      else
3231 		unresolved_reloc = FALSE;
3232 	    }
3233 	  else
3234 	    {
3235 	      BFD_ASSERT (local_got_offsets != NULL
3236 			  && local_got_offsets[r_symndx] != (bfd_vma) -1);
3237 
3238 	      off = local_got_offsets[r_symndx];
3239 
3240 	      /* The offset must always be a multiple of 8 on 64-bit and
3241 		 4 on 32-bit.  We use the least significant bit to record
3242 		 whether we have already processed this entry.  */
3243 	      if ((off & 1) != 0)
3244 		off &= ~1;
3245 	      else
3246 		{
3247 
3248 		  if (info->shared)
3249 		    {
3250 		      asection *s;
3251 		      Elf_Internal_Rela outrel;
3252 
3253 		      /* We need to generate a R_SPARC_RELATIVE reloc
3254 			 for the dynamic linker.  */
3255 		      s = htab->elf.srelgot;
3256 		      BFD_ASSERT (s != NULL);
3257 
3258 		      outrel.r_offset = (htab->elf.sgot->output_section->vma
3259 					 + htab->elf.sgot->output_offset
3260 					 + off);
3261 		      outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3262 							0, R_SPARC_RELATIVE);
3263 		      outrel.r_addend = relocation;
3264 		      relocation = 0;
3265 		      sparc_elf_append_rela (output_bfd, s, &outrel);
3266 		    }
3267 
3268 		  SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
3269 				      htab->elf.sgot->contents + off);
3270 		  local_got_offsets[r_symndx] |= 1;
3271 		}
3272 	    }
3273 	  relocation = htab->elf.sgot->output_offset + off - got_base;
3274 	  break;
3275 
3276 	case R_SPARC_PLT32:
3277 	case R_SPARC_PLT64:
3278 	  if (h == NULL || h->plt.offset == (bfd_vma) -1)
3279 	    {
3280 	      r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
3281 	      goto r_sparc_plt32;
3282 	    }
3283 	  /* Fall through.  */
3284 
3285 	case R_SPARC_WPLT30:
3286 	case R_SPARC_HIPLT22:
3287 	case R_SPARC_LOPLT10:
3288 	case R_SPARC_PCPLT32:
3289 	case R_SPARC_PCPLT22:
3290 	case R_SPARC_PCPLT10:
3291 	r_sparc_wplt30:
3292 	  /* Relocation is to the entry for this symbol in the
3293 	     procedure linkage table.  */
3294 
3295 	  if (! ABI_64_P (output_bfd))
3296 	    {
3297 	      /* The Solaris native assembler will generate a WPLT30 reloc
3298 		 for a local symbol if you assemble a call from one
3299 		 section to another when using -K pic.  We treat it as
3300 		 WDISP30.  */
3301 	      if (h == NULL)
3302 		break;
3303 	    }
3304 	  /* PR 7027: We need similar behaviour for 64-bit binaries.  */
3305 	  else if (r_type == R_SPARC_WPLT30 && h == NULL)
3306 	    break;
3307 	  else
3308 	    {
3309 	      BFD_ASSERT (h != NULL);
3310 	    }
3311 
3312 	  if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3313 	    {
3314 	      /* We didn't make a PLT entry for this symbol.  This
3315 		 happens when statically linking PIC code, or when
3316 		 using -Bsymbolic.  */
3317 	      break;
3318 	    }
3319 
3320 	  relocation = (htab->elf.splt->output_section->vma
3321 			+ htab->elf.splt->output_offset
3322 			+ h->plt.offset);
3323 	  unresolved_reloc = FALSE;
3324 	  if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
3325 	    {
3326 	      r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
3327 	      is_plt = TRUE;
3328 	      goto r_sparc_plt32;
3329 	    }
3330 	  break;
3331 
3332 	case R_SPARC_PC10:
3333 	case R_SPARC_PC22:
3334 	case R_SPARC_PC_HH22:
3335 	case R_SPARC_PC_HM10:
3336 	case R_SPARC_PC_LM22:
3337 	  if (h != NULL
3338 	      && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3339 	    break;
3340 	  /* Fall through.  */
3341 	case R_SPARC_DISP8:
3342 	case R_SPARC_DISP16:
3343 	case R_SPARC_DISP32:
3344 	case R_SPARC_DISP64:
3345 	case R_SPARC_WDISP30:
3346 	case R_SPARC_WDISP22:
3347 	case R_SPARC_WDISP19:
3348 	case R_SPARC_WDISP16:
3349 	case R_SPARC_WDISP10:
3350 	case R_SPARC_8:
3351 	case R_SPARC_16:
3352 	case R_SPARC_32:
3353 	case R_SPARC_HI22:
3354 	case R_SPARC_22:
3355 	case R_SPARC_13:
3356 	case R_SPARC_LO10:
3357 	case R_SPARC_UA16:
3358 	case R_SPARC_UA32:
3359 	case R_SPARC_10:
3360 	case R_SPARC_11:
3361 	case R_SPARC_64:
3362 	case R_SPARC_OLO10:
3363 	case R_SPARC_HH22:
3364 	case R_SPARC_HM10:
3365 	case R_SPARC_LM22:
3366 	case R_SPARC_7:
3367 	case R_SPARC_5:
3368 	case R_SPARC_6:
3369 	case R_SPARC_HIX22:
3370 	case R_SPARC_LOX10:
3371 	case R_SPARC_H44:
3372 	case R_SPARC_M44:
3373 	case R_SPARC_L44:
3374 	case R_SPARC_H34:
3375 	case R_SPARC_UA64:
3376 	r_sparc_plt32:
3377 	  if ((input_section->flags & SEC_ALLOC) == 0
3378 	      || is_vxworks_tls)
3379 	    break;
3380 
3381 	  if ((info->shared
3382 	       && (h == NULL
3383 		   || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3384 		   || h->root.type != bfd_link_hash_undefweak)
3385 	       && (! howto->pc_relative
3386 		   || !SYMBOL_CALLS_LOCAL (info, h)))
3387 	      || (!info->shared
3388 		  && h != NULL
3389 		  && h->dynindx != -1
3390 		  && !h->non_got_ref
3391 		  && ((h->def_dynamic
3392 		       && !h->def_regular)
3393 		      || h->root.type == bfd_link_hash_undefweak
3394 		      || h->root.type == bfd_link_hash_undefined)))
3395 	    {
3396 	      Elf_Internal_Rela outrel;
3397 	      bfd_boolean skip, relocate = FALSE;
3398 
3399 	      /* When generating a shared object, these relocations
3400 		 are copied into the output file to be resolved at run
3401 		 time.  */
3402 
3403 	      BFD_ASSERT (sreloc != NULL);
3404 
3405 	      skip = FALSE;
3406 
3407 	      outrel.r_offset =
3408 		_bfd_elf_section_offset (output_bfd, info, input_section,
3409 					 rel->r_offset);
3410 	      if (outrel.r_offset == (bfd_vma) -1)
3411 		skip = TRUE;
3412 	      else if (outrel.r_offset == (bfd_vma) -2)
3413 		skip = TRUE, relocate = TRUE;
3414 	      outrel.r_offset += (input_section->output_section->vma
3415 				  + input_section->output_offset);
3416 
3417 	      /* Optimize unaligned reloc usage now that we know where
3418 		 it finally resides.  */
3419 	      switch (r_type)
3420 		{
3421 		case R_SPARC_16:
3422 		  if (outrel.r_offset & 1)
3423 		    r_type = R_SPARC_UA16;
3424 		  break;
3425 		case R_SPARC_UA16:
3426 		  if (!(outrel.r_offset & 1))
3427 		    r_type = R_SPARC_16;
3428 		  break;
3429 		case R_SPARC_32:
3430 		  if (outrel.r_offset & 3)
3431 		    r_type = R_SPARC_UA32;
3432 		  break;
3433 		case R_SPARC_UA32:
3434 		  if (!(outrel.r_offset & 3))
3435 		    r_type = R_SPARC_32;
3436 		  break;
3437 		case R_SPARC_64:
3438 		  if (outrel.r_offset & 7)
3439 		    r_type = R_SPARC_UA64;
3440 		  break;
3441 		case R_SPARC_UA64:
3442 		  if (!(outrel.r_offset & 7))
3443 		    r_type = R_SPARC_64;
3444 		  break;
3445 	  	case R_SPARC_DISP8:
3446 		case R_SPARC_DISP16:
3447 	  	case R_SPARC_DISP32:
3448 	  	case R_SPARC_DISP64:
3449 		  /* If the symbol is not dynamic, we should not keep
3450 		     a dynamic relocation.  But an .rela.* slot has been
3451 		     allocated for it, output R_SPARC_NONE.
3452 		     FIXME: Add code tracking needed dynamic relocs as
3453 		     e.g. i386 has.  */
3454 		  if (h->dynindx == -1)
3455 		    skip = TRUE, relocate = TRUE;
3456 		  break;
3457 		}
3458 
3459 	      if (skip)
3460 		memset (&outrel, 0, sizeof outrel);
3461 	      /* h->dynindx may be -1 if the symbol was marked to
3462 		 become local.  */
3463 	      else if (h != NULL &&
3464 		       h->dynindx != -1
3465 		       && (! is_plt
3466 			   || !info->shared
3467 			   || !SYMBOLIC_BIND (info, h)
3468 			   || !h->def_regular))
3469 		{
3470 		  BFD_ASSERT (h->dynindx != -1);
3471 		  outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
3472 		  outrel.r_addend = rel->r_addend;
3473 		}
3474 	      else
3475 		{
3476 		  if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
3477 		    {
3478 		      outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
3479 							0, R_SPARC_RELATIVE);
3480 		      outrel.r_addend = relocation + rel->r_addend;
3481 		    }
3482 		  else
3483 		    {
3484 		      long indx;
3485 
3486 		      outrel.r_addend = relocation + rel->r_addend;
3487 
3488 		      if (is_plt)
3489 			sec = htab->elf.splt;
3490 
3491 		      if (bfd_is_abs_section (sec))
3492 			indx = 0;
3493 		      else if (sec == NULL || sec->owner == NULL)
3494 			{
3495 			  bfd_set_error (bfd_error_bad_value);
3496 			  return FALSE;
3497 			}
3498 		      else
3499 			{
3500 			  asection *osec;
3501 
3502 			  /* We are turning this relocation into one
3503 			     against a section symbol.  It would be
3504 			     proper to subtract the symbol's value,
3505 			     osec->vma, from the emitted reloc addend,
3506 			     but ld.so expects buggy relocs.  */
3507 			  osec = sec->output_section;
3508 			  indx = elf_section_data (osec)->dynindx;
3509 
3510 			  if (indx == 0)
3511 			    {
3512 			      osec = htab->elf.text_index_section;
3513 			      indx = elf_section_data (osec)->dynindx;
3514 			    }
3515 
3516 			  /* FIXME: we really should be able to link non-pic
3517 			     shared libraries.  */
3518 			  if (indx == 0)
3519 			    {
3520 			      BFD_FAIL ();
3521 			      (*_bfd_error_handler)
3522 				(_("%B: probably compiled without -fPIC?"),
3523 				 input_bfd);
3524 			      bfd_set_error (bfd_error_bad_value);
3525 			      return FALSE;
3526 			    }
3527 			}
3528 
3529 		      outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
3530 							r_type);
3531 		    }
3532 		}
3533 
3534 	      sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3535 
3536 	      /* This reloc will be computed at runtime, so there's no
3537 		 need to do anything now.  */
3538 	      if (! relocate)
3539 		continue;
3540 	    }
3541 	  break;
3542 
3543 	case R_SPARC_TLS_GD_HI22:
3544 	  if (! ABI_64_P (input_bfd)
3545 	      && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3546 	    {
3547 	      /* R_SPARC_REV32 used the same reloc number as
3548 		 R_SPARC_TLS_GD_HI22.  */
3549 	      r_type = R_SPARC_REV32;
3550 	      break;
3551 	    }
3552 	  /* Fall through */
3553 
3554 	case R_SPARC_TLS_GD_LO10:
3555 	case R_SPARC_TLS_IE_HI22:
3556 	case R_SPARC_TLS_IE_LO10:
3557 	  r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3558 	  tls_type = GOT_UNKNOWN;
3559 	  if (h == NULL && local_got_offsets)
3560 	    tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3561 	  else if (h != NULL)
3562 	    {
3563 	      tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3564 	      if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3565 		switch (SPARC_ELF_R_TYPE (rel->r_info))
3566 		  {
3567 		  case R_SPARC_TLS_GD_HI22:
3568 		  case R_SPARC_TLS_IE_HI22:
3569 		    r_type = R_SPARC_TLS_LE_HIX22;
3570 		    break;
3571 		  default:
3572 		    r_type = R_SPARC_TLS_LE_LOX10;
3573 		    break;
3574 		  }
3575 	    }
3576 	  if (tls_type == GOT_TLS_IE)
3577 	    switch (r_type)
3578 	      {
3579 	      case R_SPARC_TLS_GD_HI22:
3580 		r_type = R_SPARC_TLS_IE_HI22;
3581 		break;
3582 	      case R_SPARC_TLS_GD_LO10:
3583 		r_type = R_SPARC_TLS_IE_LO10;
3584 		break;
3585 	      }
3586 
3587 	  if (r_type == R_SPARC_TLS_LE_HIX22)
3588 	    {
3589 	      relocation = tpoff (info, relocation);
3590 	      break;
3591 	    }
3592 	  if (r_type == R_SPARC_TLS_LE_LOX10)
3593 	    {
3594 	      /* Change add into xor.  */
3595 	      relocation = tpoff (info, relocation);
3596 	      bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3597 						   contents + rel->r_offset)
3598 				       | 0x80182000), contents + rel->r_offset);
3599 	      break;
3600 	    }
3601 
3602 	  if (h != NULL)
3603 	    {
3604 	      off = h->got.offset;
3605 	      h->got.offset |= 1;
3606 	    }
3607 	  else
3608 	    {
3609 	      BFD_ASSERT (local_got_offsets != NULL);
3610 	      off = local_got_offsets[r_symndx];
3611 	      local_got_offsets[r_symndx] |= 1;
3612 	    }
3613 
3614 	r_sparc_tlsldm:
3615 	  if (htab->elf.sgot == NULL)
3616 	    abort ();
3617 
3618 	  if ((off & 1) != 0)
3619 	    off &= ~1;
3620 	  else
3621 	    {
3622 	      Elf_Internal_Rela outrel;
3623 	      int dr_type, indx;
3624 
3625 	      if (htab->elf.srelgot == NULL)
3626 		abort ();
3627 
3628 	      SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3629 				  htab->elf.sgot->contents + off);
3630 	      outrel.r_offset = (htab->elf.sgot->output_section->vma
3631 				 + htab->elf.sgot->output_offset + off);
3632 	      indx = h && h->dynindx != -1 ? h->dynindx : 0;
3633 	      if (r_type == R_SPARC_TLS_IE_HI22
3634 		  || r_type == R_SPARC_TLS_IE_LO10)
3635 		dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3636 	      else
3637 		dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3638 	      if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3639 		outrel.r_addend = relocation - dtpoff_base (info);
3640 	      else
3641 		outrel.r_addend = 0;
3642 	      outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3643 	      sparc_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
3644 
3645 	      if (r_type == R_SPARC_TLS_GD_HI22
3646 		  || r_type == R_SPARC_TLS_GD_LO10)
3647 		{
3648 		  if (indx == 0)
3649 		    {
3650 	    	      BFD_ASSERT (! unresolved_reloc);
3651 		      SPARC_ELF_PUT_WORD (htab, output_bfd,
3652 					  relocation - dtpoff_base (info),
3653 					  (htab->elf.sgot->contents + off
3654 					   + SPARC_ELF_WORD_BYTES (htab)));
3655 		    }
3656 		  else
3657 		    {
3658 		      SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3659 					  (htab->elf.sgot->contents + off
3660 					   + SPARC_ELF_WORD_BYTES (htab)));
3661 		      outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3662 							SPARC_ELF_DTPOFF_RELOC (htab));
3663 		      outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3664 		      sparc_elf_append_rela (output_bfd, htab->elf.srelgot,
3665 					     &outrel);
3666 		    }
3667 		}
3668 	      else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3669 		{
3670 		  SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3671 				      (htab->elf.sgot->contents + off
3672 				       + SPARC_ELF_WORD_BYTES (htab)));
3673 		}
3674 	    }
3675 
3676 	  if (off >= (bfd_vma) -2)
3677 	    abort ();
3678 
3679 	  relocation = htab->elf.sgot->output_offset + off - got_base;
3680 	  unresolved_reloc = FALSE;
3681 	  howto = _bfd_sparc_elf_howto_table + r_type;
3682 	  break;
3683 
3684 	case R_SPARC_TLS_LDM_HI22:
3685 	case R_SPARC_TLS_LDM_LO10:
3686 	  if (! info->shared)
3687 	    {
3688 	      bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3689 	      continue;
3690 	    }
3691 	  off = htab->tls_ldm_got.offset;
3692 	  htab->tls_ldm_got.offset |= 1;
3693 	  goto r_sparc_tlsldm;
3694 
3695 	case R_SPARC_TLS_LDO_HIX22:
3696 	case R_SPARC_TLS_LDO_LOX10:
3697 	  if (info->shared)
3698 	    {
3699 	      relocation -= dtpoff_base (info);
3700 	      break;
3701 	    }
3702 
3703 	  r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3704 		    ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3705 	  /* Fall through.  */
3706 
3707 	case R_SPARC_TLS_LE_HIX22:
3708 	case R_SPARC_TLS_LE_LOX10:
3709 	  if (info->shared)
3710 	    {
3711 	      Elf_Internal_Rela outrel;
3712 	      bfd_boolean skip;
3713 
3714 	      BFD_ASSERT (sreloc != NULL);
3715 	      skip = FALSE;
3716 	      outrel.r_offset =
3717 		_bfd_elf_section_offset (output_bfd, info, input_section,
3718 					 rel->r_offset);
3719 	      if (outrel.r_offset == (bfd_vma) -1)
3720 		skip = TRUE;
3721 	      else if (outrel.r_offset == (bfd_vma) -2)
3722 		skip = TRUE;
3723 	      outrel.r_offset += (input_section->output_section->vma
3724 				  + input_section->output_offset);
3725 	      if (skip)
3726 		memset (&outrel, 0, sizeof outrel);
3727 	      else
3728 		{
3729 		  outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3730 		  outrel.r_addend = relocation - dtpoff_base (info)
3731 				    + rel->r_addend;
3732 		}
3733 
3734 	      sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3735 	      continue;
3736 	    }
3737 	  relocation = tpoff (info, relocation);
3738 	  break;
3739 
3740 	case R_SPARC_TLS_LDM_CALL:
3741 	  if (! info->shared)
3742 	    {
3743 	      /* mov %g0, %o0 */
3744 	      bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3745 	      continue;
3746 	    }
3747 	  /* Fall through */
3748 
3749 	case R_SPARC_TLS_GD_CALL:
3750 	  tls_type = GOT_UNKNOWN;
3751 	  if (h == NULL && local_got_offsets)
3752 	    tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3753 	  else if (h != NULL)
3754 	    tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3755 	  if (! info->shared
3756 	      || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3757 	    {
3758 	      Elf_Internal_Rela *rel2;
3759 	      bfd_vma insn;
3760 
3761 	      if (!info->shared && (h == NULL || h->dynindx == -1))
3762 		{
3763 		  /* GD -> LE */
3764 		  bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3765 		  continue;
3766 		}
3767 
3768 	      /* GD -> IE */
3769 	      if (rel + 1 < relend
3770 		  && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3771 		  && rel[1].r_offset == rel->r_offset + 4
3772 		  && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3773 		  && (((insn = bfd_get_32 (input_bfd,
3774 					   contents + rel[1].r_offset))
3775 		       >> 25) & 0x1f) == 8)
3776 		{
3777 		  /* We have
3778 		     call __tls_get_addr, %tgd_call(foo)
3779 		      add %reg1, %reg2, %o0, %tgd_add(foo)
3780 		     and change it into IE:
3781 		     {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3782 		     add %g7, %o0, %o0, %tie_add(foo).
3783 		     add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3784 		     ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3785 		     ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3786 		  bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3787 			      contents + rel->r_offset);
3788 		  bfd_put_32 (output_bfd, 0x9001c008,
3789 			      contents + rel->r_offset + 4);
3790 		  rel++;
3791 		  continue;
3792 		}
3793 
3794 	      /* We cannot just overwrite the delay slot instruction,
3795 		 as it might be what puts the %o0 argument to
3796 		 __tls_get_addr into place.  So we have to transpose
3797 		 the delay slot with the add we patch in.  */
3798 	      insn = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3799 	      bfd_put_32 (output_bfd, insn,
3800 			  contents + rel->r_offset);
3801 	      bfd_put_32 (output_bfd, 0x9001c008,
3802 			  contents + rel->r_offset + 4);
3803 
3804 	      rel2 = rel;
3805 	      while ((rel2 = sparc_elf_find_reloc_at_ofs (rel2 + 1, relend,
3806 							  rel->r_offset + 4))
3807 		     != NULL)
3808 		{
3809 		  /* If the instruction we moved has a relocation attached to
3810 		     it, adjust the offset so that it will apply to the correct
3811 		     instruction.  */
3812 		  rel2->r_offset -= 4;
3813 		}
3814 	      continue;
3815 	    }
3816 
3817 	  h = (struct elf_link_hash_entry *)
3818 	      bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3819 				    FALSE, TRUE);
3820 	  BFD_ASSERT (h != NULL);
3821 	  r_type = R_SPARC_WPLT30;
3822 	  howto = _bfd_sparc_elf_howto_table + r_type;
3823 	  goto r_sparc_wplt30;
3824 
3825 	case R_SPARC_TLS_GD_ADD:
3826 	  tls_type = GOT_UNKNOWN;
3827 	  if (h == NULL && local_got_offsets)
3828 	    tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3829 	  else if (h != NULL)
3830 	    tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3831 	  if (! info->shared || tls_type == GOT_TLS_IE)
3832 	    {
3833 	      /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3834 		 changed into IE:
3835 		 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3836 		 or LE:
3837 		 add %g7, %reg2, %reg3.  */
3838 	      bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3839 	      if ((h != NULL && h->dynindx != -1) || info->shared)
3840 		relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3841 	      else
3842 		relocation = (insn & ~0x7c000) | 0x1c000;
3843 	      bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3844 	    }
3845 	  continue;
3846 
3847 	case R_SPARC_TLS_LDM_ADD:
3848 	  if (! info->shared)
3849 	    bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3850 	  continue;
3851 
3852 	case R_SPARC_TLS_LDO_ADD:
3853 	  if (! info->shared)
3854 	    {
3855 	      /* Change rs1 into %g7.  */
3856 	      bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3857 	      insn = (insn & ~0x7c000) | 0x1c000;
3858 	      bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3859 	    }
3860 	  continue;
3861 
3862 	case R_SPARC_TLS_IE_LD:
3863 	case R_SPARC_TLS_IE_LDX:
3864 	  if (! info->shared && (h == NULL || h->dynindx == -1))
3865 	    {
3866 	      bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3867 	      int rs2 = insn & 0x1f;
3868 	      int rd = (insn >> 25) & 0x1f;
3869 
3870 	      if (rs2 == rd)
3871 		relocation = SPARC_NOP;
3872 	      else
3873 		relocation = 0x80100000 | (insn & 0x3e00001f);
3874 	      bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3875 	    }
3876 	  continue;
3877 
3878 	case R_SPARC_TLS_IE_ADD:
3879 	  /* Totally useless relocation.  */
3880 	  continue;
3881 
3882 	case R_SPARC_TLS_DTPOFF32:
3883 	case R_SPARC_TLS_DTPOFF64:
3884 	  relocation -= dtpoff_base (info);
3885 	  break;
3886 
3887 	default:
3888 	  break;
3889 	}
3890 
3891       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3892 	 because such sections are not SEC_ALLOC and thus ld.so will
3893 	 not process them.  */
3894       if (unresolved_reloc
3895 	  && !((input_section->flags & SEC_DEBUGGING) != 0
3896 	       && h->def_dynamic)
3897 	  && _bfd_elf_section_offset (output_bfd, info, input_section,
3898 				      rel->r_offset) != (bfd_vma) -1)
3899 	(*_bfd_error_handler)
3900 	  (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3901 	   input_bfd,
3902 	   input_section,
3903 	   (long) rel->r_offset,
3904 	   howto->name,
3905 	   h->root.root.string);
3906 
3907       r = bfd_reloc_continue;
3908       if (r_type == R_SPARC_OLO10)
3909 	{
3910 	    bfd_vma x;
3911 
3912 	    if (! ABI_64_P (output_bfd))
3913 	      abort ();
3914 
3915 	    relocation += rel->r_addend;
3916 	    relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3917 
3918 	    x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3919 	    x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
3920 	    bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3921 
3922 	    r = bfd_check_overflow (howto->complain_on_overflow,
3923 				    howto->bitsize, howto->rightshift,
3924 				    bfd_arch_bits_per_address (input_bfd),
3925 				    relocation);
3926 	}
3927       else if (r_type == R_SPARC_WDISP16)
3928 	{
3929 	  bfd_vma x;
3930 
3931 	  relocation += rel->r_addend;
3932 	  relocation -= (input_section->output_section->vma
3933 			 + input_section->output_offset);
3934 	  relocation -= rel->r_offset;
3935 
3936 	  x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3937 	  x |= ((((relocation >> 2) & 0xc000) << 6)
3938 		| ((relocation >> 2) & 0x3fff));
3939 	  bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3940 
3941 	  r = bfd_check_overflow (howto->complain_on_overflow,
3942 				  howto->bitsize, howto->rightshift,
3943 				  bfd_arch_bits_per_address (input_bfd),
3944 				  relocation);
3945 	}
3946       else if (r_type == R_SPARC_WDISP10)
3947 	{
3948 	  bfd_vma x;
3949 
3950 	  relocation += rel->r_addend;
3951 	  relocation -= (input_section->output_section->vma
3952 			 + input_section->output_offset);
3953 	  relocation -= rel->r_offset;
3954 
3955 	  x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3956 	  x |= ((((relocation >> 2) & 0x300) << 11)
3957 		| (((relocation >> 2) & 0xff) << 5));
3958 	  bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3959 
3960 	  r = bfd_check_overflow (howto->complain_on_overflow,
3961 				  howto->bitsize, howto->rightshift,
3962 				  bfd_arch_bits_per_address (input_bfd),
3963 				  relocation);
3964 	}
3965       else if (r_type == R_SPARC_REV32)
3966 	{
3967 	  bfd_vma x;
3968 
3969 	  relocation = relocation + rel->r_addend;
3970 
3971 	  x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3972 	  x = x + relocation;
3973 	  bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3974 	  r = bfd_reloc_ok;
3975 	}
3976       else if (r_type == R_SPARC_TLS_LDO_HIX22
3977 	       || r_type == R_SPARC_TLS_LE_HIX22)
3978 	{
3979 	  bfd_vma x;
3980 
3981 	  relocation += rel->r_addend;
3982 	  if (r_type == R_SPARC_TLS_LE_HIX22)
3983 	    relocation ^= MINUS_ONE;
3984 
3985 	  x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3986 	  x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3987 	  bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3988 	  r = bfd_reloc_ok;
3989 	}
3990       else if (r_type == R_SPARC_TLS_LDO_LOX10
3991 	       || r_type == R_SPARC_TLS_LE_LOX10)
3992 	{
3993 	  bfd_vma x;
3994 
3995 	  relocation += rel->r_addend;
3996 	  relocation &= 0x3ff;
3997 	  if (r_type == R_SPARC_TLS_LE_LOX10)
3998 	    relocation |= 0x1c00;
3999 
4000 	  x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4001 	  x = (x & ~(bfd_vma) 0x1fff) | relocation;
4002 	  bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4003 
4004 	  r = bfd_reloc_ok;
4005 	}
4006       else if (r_type == R_SPARC_HIX22
4007 	       || r_type == R_SPARC_GOTDATA_HIX22)
4008 	{
4009 	  bfd_vma x;
4010 
4011 	  relocation += rel->r_addend;
4012 	  if (r_type == R_SPARC_HIX22
4013 	      || (bfd_signed_vma) relocation < 0)
4014 	    relocation = relocation ^ MINUS_ONE;
4015 
4016 	  x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4017 	  x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
4018 	  bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4019 
4020 	  r = bfd_check_overflow (howto->complain_on_overflow,
4021 				  howto->bitsize, howto->rightshift,
4022 				  bfd_arch_bits_per_address (input_bfd),
4023 				  relocation);
4024 	}
4025       else if (r_type == R_SPARC_LOX10
4026 	       || r_type == R_SPARC_GOTDATA_LOX10)
4027 	{
4028 	  bfd_vma x;
4029 
4030 	  relocation += rel->r_addend;
4031 	  if (r_type == R_SPARC_LOX10
4032 	      || (bfd_signed_vma) relocation < 0)
4033 	    relocation = (relocation & 0x3ff) | 0x1c00;
4034 	  else
4035 	    relocation = (relocation & 0x3ff);
4036 
4037 	  x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4038 	  x = (x & ~(bfd_vma) 0x1fff) | relocation;
4039 	  bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4040 
4041 	  r = bfd_reloc_ok;
4042 	}
4043       else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
4044 	       && sec_do_relax (input_section)
4045 	       && rel->r_offset + 4 < input_section->size)
4046 	{
4047 #define G0		0
4048 #define O7		15
4049 #define XCC		(2 << 20)
4050 #define COND(x)		(((x)&0xf)<<25)
4051 #define CONDA		COND(0x8)
4052 #define INSN_BPA	(F2(0,1) | CONDA | BPRED | XCC)
4053 #define INSN_BA		(F2(0,2) | CONDA)
4054 #define INSN_OR		F3(2, 0x2, 0)
4055 #define INSN_NOP	F2(0,4)
4056 
4057 	  bfd_vma x, y;
4058 
4059 	  /* If the instruction is a call with either:
4060 	     restore
4061 	     arithmetic instruction with rd == %o7
4062 	     where rs1 != %o7 and rs2 if it is register != %o7
4063 	     then we can optimize if the call destination is near
4064 	     by changing the call into a branch always.  */
4065 	  x = bfd_get_32 (input_bfd, contents + rel->r_offset);
4066 	  y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
4067 	  if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
4068 	    {
4069 	      if (((y & OP3(~0)) == OP3(0x3d) /* restore */
4070 		   || ((y & OP3(0x28)) == 0 /* arithmetic */
4071 		       && (y & RD(~0)) == RD(O7)))
4072 		  && (y & RS1(~0)) != RS1(O7)
4073 		  && ((y & F3I(~0))
4074 		      || (y & RS2(~0)) != RS2(O7)))
4075 		{
4076 		  bfd_vma reloc;
4077 
4078 		  reloc = relocation + rel->r_addend - rel->r_offset;
4079 		  reloc -= (input_section->output_section->vma
4080 			    + input_section->output_offset);
4081 
4082 		  /* Ensure the branch fits into simm22.  */
4083 		  if ((reloc & 3) == 0
4084 		      && ((reloc & ~(bfd_vma)0x7fffff) == 0
4085 			  || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
4086 		    {
4087 		      reloc >>= 2;
4088 
4089 		      /* Check whether it fits into simm19.  */
4090 		      if (((reloc & 0x3c0000) == 0
4091 			   || (reloc & 0x3c0000) == 0x3c0000)
4092 			  && (ABI_64_P (output_bfd)
4093 			      || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
4094 			x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
4095 		      else
4096 			x = INSN_BA | (reloc & 0x3fffff); /* ba */
4097 		      bfd_put_32 (input_bfd, x, contents + rel->r_offset);
4098 		      r = bfd_reloc_ok;
4099 		      if (rel->r_offset >= 4
4100 			  && (y & (0xffffffff ^ RS1(~0)))
4101 			     == (INSN_OR | RD(O7) | RS2(G0)))
4102 			{
4103 			  bfd_vma z;
4104 			  unsigned int reg;
4105 
4106 			  z = bfd_get_32 (input_bfd,
4107 					  contents + rel->r_offset - 4);
4108 			  if ((z & (0xffffffff ^ RD(~0)))
4109 			      != (INSN_OR | RS1(O7) | RS2(G0)))
4110 			    break;
4111 
4112 			  /* The sequence was
4113 			     or %o7, %g0, %rN
4114 			     call foo
4115 			     or %rN, %g0, %o7
4116 
4117 			     If call foo was replaced with ba, replace
4118 			     or %rN, %g0, %o7 with nop.  */
4119 
4120 			  reg = (y & RS1(~0)) >> 14;
4121 			  if (reg != ((z & RD(~0)) >> 25)
4122 			      || reg == G0 || reg == O7)
4123 			    break;
4124 
4125 			  bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
4126 				      contents + rel->r_offset + 4);
4127 			}
4128 
4129 		    }
4130 		}
4131 	    }
4132 	}
4133 
4134       if (r == bfd_reloc_continue)
4135 	{
4136 do_relocation:
4137 	  r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4138 					contents, rel->r_offset,
4139 					relocation, rel->r_addend);
4140 	}
4141       if (r != bfd_reloc_ok)
4142 	{
4143 	  switch (r)
4144 	    {
4145 	    default:
4146 	    case bfd_reloc_outofrange:
4147 	      abort ();
4148 	    case bfd_reloc_overflow:
4149 	      {
4150 		const char *name;
4151 
4152 		/* The Solaris native linker silently disregards overflows.
4153 		   We don't, but this breaks stabs debugging info, whose
4154 		   relocations are only 32-bits wide.  Ignore overflows in
4155 		   this case and also for discarded entries.  */
4156 		if ((r_type == R_SPARC_32
4157 		     || r_type == R_SPARC_UA32
4158 		     || r_type == R_SPARC_DISP32)
4159 		    && (((input_section->flags & SEC_DEBUGGING) != 0
4160 			 && strcmp (bfd_section_name (input_bfd,
4161 						      input_section),
4162 				    ".stab") == 0)
4163 			|| _bfd_elf_section_offset (output_bfd, info,
4164 						    input_section,
4165 						    rel->r_offset)
4166 			     == (bfd_vma)-1))
4167 		  break;
4168 
4169 		if (h != NULL)
4170 		  {
4171 		    /* Assume this is a call protected by other code that
4172 		       detect the symbol is undefined.  If this is the case,
4173 		       we can safely ignore the overflow.  If not, the
4174 		       program is hosed anyway, and a little warning isn't
4175 		       going to help.  */
4176 		    if (h->root.type == bfd_link_hash_undefweak
4177 			&& howto->pc_relative)
4178 		      break;
4179 
4180 	            name = NULL;
4181 		  }
4182 		else
4183 		  {
4184 		    name = bfd_elf_string_from_elf_section (input_bfd,
4185 							    symtab_hdr->sh_link,
4186 							    sym->st_name);
4187 		    if (name == NULL)
4188 		      return FALSE;
4189 		    if (*name == '\0')
4190 		      name = bfd_section_name (input_bfd, sec);
4191 		  }
4192 		if (! ((*info->callbacks->reloc_overflow)
4193 		       (info, (h ? &h->root : NULL), name, howto->name,
4194 			(bfd_vma) 0, input_bfd, input_section,
4195 			rel->r_offset)))
4196 		  return FALSE;
4197 	      }
4198 	      break;
4199 	    }
4200 	}
4201     }
4202 
4203   return TRUE;
4204 }
4205 
4206 /* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
4207    and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
4208    is the offset of the associated .got.plt entry from
4209    _GLOBAL_OFFSET_TABLE_.  */
4210 
4211 static void
sparc_vxworks_build_plt_entry(bfd * output_bfd,struct bfd_link_info * info,bfd_vma plt_offset,bfd_vma plt_index,bfd_vma got_offset)4212 sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
4213 			       bfd_vma plt_offset, bfd_vma plt_index,
4214 			       bfd_vma got_offset)
4215 {
4216   bfd_vma got_base;
4217   const bfd_vma *plt_entry;
4218   struct _bfd_sparc_elf_link_hash_table *htab;
4219   bfd_byte *loc;
4220   Elf_Internal_Rela rela;
4221 
4222   htab = _bfd_sparc_elf_hash_table (info);
4223   BFD_ASSERT (htab != NULL);
4224 
4225   if (info->shared)
4226     {
4227       plt_entry = sparc_vxworks_shared_plt_entry;
4228       got_base = 0;
4229     }
4230   else
4231     {
4232       plt_entry = sparc_vxworks_exec_plt_entry;
4233       got_base = (htab->elf.hgot->root.u.def.value
4234 		  + htab->elf.hgot->root.u.def.section->output_offset
4235 		  + htab->elf.hgot->root.u.def.section->output_section->vma);
4236     }
4237 
4238   /* Fill in the entry in the procedure linkage table.  */
4239   bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
4240 	      htab->elf.splt->contents + plt_offset);
4241   bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
4242 	      htab->elf.splt->contents + plt_offset + 4);
4243   bfd_put_32 (output_bfd, plt_entry[2],
4244 	      htab->elf.splt->contents + plt_offset + 8);
4245   bfd_put_32 (output_bfd, plt_entry[3],
4246 	      htab->elf.splt->contents + plt_offset + 12);
4247   bfd_put_32 (output_bfd, plt_entry[4],
4248 	      htab->elf.splt->contents + plt_offset + 16);
4249   bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
4250 	      htab->elf.splt->contents + plt_offset + 20);
4251   /* PC-relative displacement for a branch to the start of
4252      the PLT section.  */
4253   bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
4254 					  & 0x003fffff),
4255 	      htab->elf.splt->contents + plt_offset + 24);
4256   bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
4257 	      htab->elf.splt->contents + plt_offset + 28);
4258 
4259   /* Fill in the .got.plt entry, pointing initially at the
4260      second half of the PLT entry.  */
4261   BFD_ASSERT (htab->elf.sgotplt != NULL);
4262   bfd_put_32 (output_bfd,
4263 	      htab->elf.splt->output_section->vma
4264 	      + htab->elf.splt->output_offset
4265 	      + plt_offset + 20,
4266 	      htab->elf.sgotplt->contents + got_offset);
4267 
4268   /* Add relocations to .rela.plt.unloaded.  */
4269   if (!info->shared)
4270     {
4271       loc = (htab->srelplt2->contents
4272 	     + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
4273 
4274       /* Relocate the initial sethi.  */
4275       rela.r_offset = (htab->elf.splt->output_section->vma
4276 		       + htab->elf.splt->output_offset
4277 		       + plt_offset);
4278       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4279       rela.r_addend = got_offset;
4280       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4281       loc += sizeof (Elf32_External_Rela);
4282 
4283       /* Likewise the following or.  */
4284       rela.r_offset += 4;
4285       rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4286       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4287       loc += sizeof (Elf32_External_Rela);
4288 
4289       /* Relocate the .got.plt entry.  */
4290       rela.r_offset = (htab->elf.sgotplt->output_section->vma
4291 		       + htab->elf.sgotplt->output_offset
4292 		       + got_offset);
4293       rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4294       rela.r_addend = plt_offset + 20;
4295       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4296     }
4297 }
4298 
4299 /* Finish up dynamic symbol handling.  We set the contents of various
4300    dynamic sections here.  */
4301 
4302 bfd_boolean
_bfd_sparc_elf_finish_dynamic_symbol(bfd * output_bfd,struct bfd_link_info * info,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)4303 _bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
4304 				      struct bfd_link_info *info,
4305 				      struct elf_link_hash_entry *h,
4306 				      Elf_Internal_Sym *sym)
4307 {
4308   struct _bfd_sparc_elf_link_hash_table *htab;
4309   const struct elf_backend_data *bed;
4310 
4311   htab = _bfd_sparc_elf_hash_table (info);
4312   BFD_ASSERT (htab != NULL);
4313   bed = get_elf_backend_data (output_bfd);
4314 
4315   if (h->plt.offset != (bfd_vma) -1)
4316     {
4317       asection *splt;
4318       asection *srela;
4319       Elf_Internal_Rela rela;
4320       bfd_byte *loc;
4321       bfd_vma r_offset, got_offset;
4322       int rela_index;
4323 
4324       /* When building a static executable, use .iplt and
4325 	 .rela.iplt sections for STT_GNU_IFUNC symbols.  */
4326       if (htab->elf.splt != NULL)
4327 	{
4328 	  splt = htab->elf.splt;
4329 	  srela = htab->elf.srelplt;
4330 	}
4331       else
4332 	{
4333 	  splt = htab->elf.iplt;
4334 	  srela = htab->elf.irelplt;
4335 	}
4336 
4337       if (splt == NULL || srela == NULL)
4338 	abort ();
4339 
4340       /* Fill in the entry in the .rela.plt section.  */
4341       if (htab->is_vxworks)
4342 	{
4343 	  /* Work out the index of this PLT entry.  */
4344 	  rela_index = ((h->plt.offset - htab->plt_header_size)
4345 			/ htab->plt_entry_size);
4346 
4347 	  /* Calculate the offset of the associated .got.plt entry.
4348 	     The first three entries are reserved.  */
4349 	  got_offset = (rela_index + 3) * 4;
4350 
4351 	  sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
4352 					 rela_index, got_offset);
4353 
4354 
4355 	  /* On VxWorks, the relocation points to the .got.plt entry,
4356 	     not the .plt entry.  */
4357 	  rela.r_offset = (htab->elf.sgotplt->output_section->vma
4358 			   + htab->elf.sgotplt->output_offset
4359 			   + got_offset);
4360 	  rela.r_addend = 0;
4361 	  rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4362 					  R_SPARC_JMP_SLOT);
4363 	}
4364       else
4365 	{
4366 	  bfd_boolean ifunc = FALSE;
4367 
4368 	  /* Fill in the entry in the procedure linkage table.  */
4369 	  rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
4370 						  h->plt.offset, splt->size,
4371 						  &r_offset);
4372 
4373 	  if (h == NULL
4374 	      || h->dynindx == -1
4375 	      || ((info->executable
4376 		   || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4377 		  && h->def_regular
4378 		  && h->type == STT_GNU_IFUNC))
4379 	    {
4380 	      ifunc = TRUE;
4381 	      BFD_ASSERT (h == NULL
4382 			  || (h->type == STT_GNU_IFUNC
4383 			      && h->def_regular
4384 			      && (h->root.type == bfd_link_hash_defined
4385 				  || h->root.type == bfd_link_hash_defweak)));
4386 	    }
4387 
4388 	  rela.r_offset = r_offset
4389 	    + (splt->output_section->vma + splt->output_offset);
4390 	  if (ABI_64_P (output_bfd)
4391 	      && h->plt.offset >= (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
4392 	    {
4393 	      if (ifunc)
4394 		{
4395 		  rela.r_addend = (h->root.u.def.section->output_section->vma
4396 				   + h->root.u.def.section->output_offset
4397 				   + h->root.u.def.value);
4398 		  rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4399 						  R_SPARC_IRELATIVE);
4400 		}
4401 	      else
4402 		{
4403 		  rela.r_addend = (-(h->plt.offset + 4)
4404 				   - splt->output_section->vma
4405 				   - splt->output_offset);
4406 		  rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4407 						  R_SPARC_JMP_SLOT);
4408 		}
4409 	    }
4410 	  else
4411 	    {
4412 	      if (ifunc)
4413 		{
4414 		  rela.r_addend = (h->root.u.def.section->output_section->vma
4415 				   + h->root.u.def.section->output_offset
4416 				   + h->root.u.def.value);
4417 		  rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0,
4418 						  R_SPARC_JMP_IREL);
4419 		}
4420 	      else
4421 		{
4422 		  rela.r_addend = 0;
4423 		  rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx,
4424 						  R_SPARC_JMP_SLOT);
4425 		}
4426 	    }
4427 	}
4428 
4429       /* Adjust for the first 4 reserved elements in the .plt section
4430 	 when setting the offset in the .rela.plt section.
4431 	 Sun forgot to read their own ABI and copied elf32-sparc behaviour,
4432 	 thus .plt[4] has corresponding .rela.plt[0] and so on.  */
4433 
4434       loc = srela->contents;
4435       loc += rela_index * bed->s->sizeof_rela;
4436       bed->s->swap_reloca_out (output_bfd, &rela, loc);
4437 
4438       if (!h->def_regular)
4439 	{
4440 	  /* Mark the symbol as undefined, rather than as defined in
4441 	     the .plt section.  Leave the value alone.  */
4442 	  sym->st_shndx = SHN_UNDEF;
4443 	  /* If the symbol is weak, we do need to clear the value.
4444 	     Otherwise, the PLT entry would provide a definition for
4445 	     the symbol even if the symbol wasn't defined anywhere,
4446 	     and so the symbol would never be NULL.  */
4447 	  if (!h->ref_regular_nonweak)
4448 	    sym->st_value = 0;
4449 	}
4450     }
4451 
4452   if (h->got.offset != (bfd_vma) -1
4453       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
4454       && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
4455     {
4456       asection *sgot;
4457       asection *srela;
4458       Elf_Internal_Rela rela;
4459 
4460       /* This symbol has an entry in the GOT.  Set it up.  */
4461 
4462       sgot = htab->elf.sgot;
4463       srela = htab->elf.srelgot;
4464       BFD_ASSERT (sgot != NULL && srela != NULL);
4465 
4466       rela.r_offset = (sgot->output_section->vma
4467 		       + sgot->output_offset
4468 		       + (h->got.offset &~ (bfd_vma) 1));
4469 
4470       /* If this is a -Bsymbolic link, and the symbol is defined
4471 	 locally, we just want to emit a RELATIVE reloc.  Likewise if
4472 	 the symbol was forced to be local because of a version file.
4473 	 The entry in the global offset table will already have been
4474 	 initialized in the relocate_section function.  */
4475       if (! info->shared
4476 	  && h->type == STT_GNU_IFUNC
4477 	  && h->def_regular)
4478 	{
4479 	  asection *plt;
4480 
4481 	  /* We load the GOT entry with the PLT entry.  */
4482 	  plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4483 	  SPARC_ELF_PUT_WORD (htab, output_bfd,
4484 			      (plt->output_section->vma
4485 			       + plt->output_offset + h->plt.offset),
4486 			      htab->elf.sgot->contents
4487 			      + (h->got.offset & ~(bfd_vma) 1));
4488 	  return TRUE;
4489 	}
4490       else if (info->shared
4491 	       && SYMBOL_REFERENCES_LOCAL (info, h))
4492 	{
4493 	  asection *sec = h->root.u.def.section;
4494 	  if (h->type == STT_GNU_IFUNC)
4495 	    rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_IRELATIVE);
4496 	  else
4497 	    rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
4498 	  rela.r_addend = (h->root.u.def.value
4499 			   + sec->output_section->vma
4500 			   + sec->output_offset);
4501 	}
4502       else
4503 	{
4504 	  rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
4505 	  rela.r_addend = 0;
4506 	}
4507 
4508       SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
4509 			  sgot->contents + (h->got.offset & ~(bfd_vma) 1));
4510       sparc_elf_append_rela (output_bfd, srela, &rela);
4511     }
4512 
4513   if (h->needs_copy)
4514     {
4515       asection *s;
4516       Elf_Internal_Rela rela;
4517 
4518       /* This symbols needs a copy reloc.  Set it up.  */
4519       BFD_ASSERT (h->dynindx != -1);
4520 
4521       s = bfd_get_linker_section (h->root.u.def.section->owner,
4522 				  ".rela.bss");
4523       BFD_ASSERT (s != NULL);
4524 
4525       rela.r_offset = (h->root.u.def.value
4526 		       + h->root.u.def.section->output_section->vma
4527 		       + h->root.u.def.section->output_offset);
4528       rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
4529       rela.r_addend = 0;
4530       sparc_elf_append_rela (output_bfd, s, &rela);
4531     }
4532 
4533   /* Mark some specially defined symbols as absolute.  On VxWorks,
4534      _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
4535      ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
4536   if (sym != NULL
4537       && (h == htab->elf.hdynamic
4538 	  || (!htab->is_vxworks
4539 	      && (h == htab->elf.hgot || h == htab->elf.hplt))))
4540     sym->st_shndx = SHN_ABS;
4541 
4542   return TRUE;
4543 }
4544 
4545 /* Finish up the dynamic sections.  */
4546 
4547 static bfd_boolean
sparc_finish_dyn(bfd * output_bfd,struct bfd_link_info * info,bfd * dynobj,asection * sdyn,asection * splt ATTRIBUTE_UNUSED)4548 sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
4549 		  bfd *dynobj, asection *sdyn,
4550 		  asection *splt ATTRIBUTE_UNUSED)
4551 {
4552   struct _bfd_sparc_elf_link_hash_table *htab;
4553   const struct elf_backend_data *bed;
4554   bfd_byte *dyncon, *dynconend;
4555   size_t dynsize;
4556   int stt_regidx = -1;
4557   bfd_boolean abi_64_p;
4558 
4559   htab = _bfd_sparc_elf_hash_table (info);
4560   BFD_ASSERT (htab != NULL);
4561   bed = get_elf_backend_data (output_bfd);
4562   dynsize = bed->s->sizeof_dyn;
4563   dynconend = sdyn->contents + sdyn->size;
4564   abi_64_p = ABI_64_P (output_bfd);
4565   for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
4566     {
4567       Elf_Internal_Dyn dyn;
4568       const char *name;
4569       bfd_boolean size;
4570 
4571       bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
4572 
4573       if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
4574 	{
4575 	  /* On VxWorks, DT_RELASZ should not include the relocations
4576 	     in .rela.plt.  */
4577 	  if (htab->elf.srelplt)
4578 	    {
4579 	      dyn.d_un.d_val -= htab->elf.srelplt->size;
4580 	      bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4581 	    }
4582 	}
4583       else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
4584 	{
4585 	  /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
4586 	     not to the start of the PLT.  */
4587 	  if (htab->elf.sgotplt)
4588 	    {
4589 	      dyn.d_un.d_val = (htab->elf.sgotplt->output_section->vma
4590 				+ htab->elf.sgotplt->output_offset);
4591 	      bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4592 	    }
4593 	}
4594       else if (htab->is_vxworks
4595 	       && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4596 	bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4597       else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
4598 	{
4599 	  if (stt_regidx == -1)
4600 	    {
4601 	      stt_regidx =
4602 		_bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
4603 	      if (stt_regidx == -1)
4604 		return FALSE;
4605 	    }
4606 	  dyn.d_un.d_val = stt_regidx++;
4607 	  bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4608 	}
4609       else
4610 	{
4611 	  switch (dyn.d_tag)
4612 	    {
4613 	    case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
4614 	    case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
4615 	    case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
4616 	    default:	      name = NULL; size = FALSE; break;
4617 	    }
4618 
4619 	  if (name != NULL)
4620 	    {
4621 	      asection *s;
4622 
4623 	      s = bfd_get_section_by_name (output_bfd, name);
4624 	      if (s == NULL)
4625 		dyn.d_un.d_val = 0;
4626 	      else
4627 		{
4628 		  if (! size)
4629 		    dyn.d_un.d_ptr = s->vma;
4630 		  else
4631 		    dyn.d_un.d_val = s->size;
4632 		}
4633 	      bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
4634 	    }
4635 	}
4636     }
4637   return TRUE;
4638 }
4639 
4640 /* Install the first PLT entry in a VxWorks executable and make sure that
4641    .rela.plt.unloaded relocations have the correct symbol indexes.  */
4642 
4643 static void
sparc_vxworks_finish_exec_plt(bfd * output_bfd,struct bfd_link_info * info)4644 sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
4645 {
4646   struct _bfd_sparc_elf_link_hash_table *htab;
4647   Elf_Internal_Rela rela;
4648   bfd_vma got_base;
4649   bfd_byte *loc;
4650 
4651   htab = _bfd_sparc_elf_hash_table (info);
4652   BFD_ASSERT (htab != NULL);
4653 
4654   /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
4655   got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
4656 	      + htab->elf.hgot->root.u.def.section->output_offset
4657 	      + htab->elf.hgot->root.u.def.value);
4658 
4659   /* Install the initial PLT entry.  */
4660   bfd_put_32 (output_bfd,
4661 	      sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
4662 	      htab->elf.splt->contents);
4663   bfd_put_32 (output_bfd,
4664 	      sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
4665 	      htab->elf.splt->contents + 4);
4666   bfd_put_32 (output_bfd,
4667 	      sparc_vxworks_exec_plt0_entry[2],
4668 	      htab->elf.splt->contents + 8);
4669   bfd_put_32 (output_bfd,
4670 	      sparc_vxworks_exec_plt0_entry[3],
4671 	      htab->elf.splt->contents + 12);
4672   bfd_put_32 (output_bfd,
4673 	      sparc_vxworks_exec_plt0_entry[4],
4674 	      htab->elf.splt->contents + 16);
4675 
4676   loc = htab->srelplt2->contents;
4677 
4678   /* Add an unloaded relocation for the initial entry's "sethi".  */
4679   rela.r_offset = (htab->elf.splt->output_section->vma
4680 		   + htab->elf.splt->output_offset);
4681   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4682   rela.r_addend = 8;
4683   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4684   loc += sizeof (Elf32_External_Rela);
4685 
4686   /* Likewise the following "or".  */
4687   rela.r_offset += 4;
4688   rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4689   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4690   loc += sizeof (Elf32_External_Rela);
4691 
4692   /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
4693      the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4694      in which symbols were output.  */
4695   while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4696     {
4697       Elf_Internal_Rela rel;
4698 
4699       /* The entry's initial "sethi" (against _G_O_T_).  */
4700       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4701       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4702       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4703       loc += sizeof (Elf32_External_Rela);
4704 
4705       /* The following "or" (also against _G_O_T_).  */
4706       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4707       rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4708       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4709       loc += sizeof (Elf32_External_Rela);
4710 
4711       /* The .got.plt entry (against _P_L_T_).  */
4712       bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4713       rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4714       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4715       loc += sizeof (Elf32_External_Rela);
4716     }
4717 }
4718 
4719 /* Install the first PLT entry in a VxWorks shared object.  */
4720 
4721 static void
sparc_vxworks_finish_shared_plt(bfd * output_bfd,struct bfd_link_info * info)4722 sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4723 {
4724   struct _bfd_sparc_elf_link_hash_table *htab;
4725   unsigned int i;
4726 
4727   htab = _bfd_sparc_elf_hash_table (info);
4728   BFD_ASSERT (htab != NULL);
4729 
4730   for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4731     bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4732 		htab->elf.splt->contents + i * 4);
4733 }
4734 
4735 /* Finish up local dynamic symbol handling.  We set the contents of
4736    various dynamic sections here.  */
4737 
4738 static bfd_boolean
finish_local_dynamic_symbol(void ** slot,void * inf)4739 finish_local_dynamic_symbol (void **slot, void *inf)
4740 {
4741   struct elf_link_hash_entry *h
4742     = (struct elf_link_hash_entry *) *slot;
4743   struct bfd_link_info *info
4744     = (struct bfd_link_info *) inf;
4745 
4746   return _bfd_sparc_elf_finish_dynamic_symbol (info->output_bfd, info,
4747 					       h, NULL);
4748 }
4749 
4750 bfd_boolean
_bfd_sparc_elf_finish_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)4751 _bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4752 {
4753   bfd *dynobj;
4754   asection *sdyn;
4755   struct _bfd_sparc_elf_link_hash_table *htab;
4756 
4757   htab = _bfd_sparc_elf_hash_table (info);
4758   BFD_ASSERT (htab != NULL);
4759   dynobj = htab->elf.dynobj;
4760 
4761   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4762 
4763   if (elf_hash_table (info)->dynamic_sections_created)
4764     {
4765       asection *splt;
4766 
4767       splt = htab->elf.splt;
4768       BFD_ASSERT (splt != NULL && sdyn != NULL);
4769 
4770       if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4771 	return FALSE;
4772 
4773       /* Initialize the contents of the .plt section.  */
4774       if (splt->size > 0)
4775 	{
4776 	  if (htab->is_vxworks)
4777 	    {
4778 	      if (info->shared)
4779 		sparc_vxworks_finish_shared_plt (output_bfd, info);
4780 	      else
4781 		sparc_vxworks_finish_exec_plt (output_bfd, info);
4782 	    }
4783 	  else
4784 	    {
4785 	      memset (splt->contents, 0, htab->plt_header_size);
4786 	      if (!ABI_64_P (output_bfd))
4787 		bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4788 			    splt->contents + splt->size - 4);
4789 	    }
4790 	}
4791 
4792       elf_section_data (splt->output_section)->this_hdr.sh_entsize
4793 	= (htab->is_vxworks || !ABI_64_P (output_bfd))
4794 	  ? 0 : htab->plt_entry_size;
4795     }
4796 
4797   /* Set the first entry in the global offset table to the address of
4798      the dynamic section.  */
4799   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4800     {
4801       bfd_vma val = (sdyn ?
4802 		     sdyn->output_section->vma + sdyn->output_offset :
4803 		     0);
4804 
4805       SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->elf.sgot->contents);
4806     }
4807 
4808   if (htab->elf.sgot)
4809     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize =
4810       SPARC_ELF_WORD_BYTES (htab);
4811 
4812   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4813   htab_traverse (htab->loc_hash_table, finish_local_dynamic_symbol, info);
4814 
4815   return TRUE;
4816 }
4817 
4818 
4819 /* Set the right machine number for a SPARC ELF file.  */
4820 
4821 bfd_boolean
_bfd_sparc_elf_object_p(bfd * abfd)4822 _bfd_sparc_elf_object_p (bfd *abfd)
4823 {
4824   if (ABI_64_P (abfd))
4825     {
4826       unsigned long mach = bfd_mach_sparc_v9;
4827 
4828       if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4829 	mach = bfd_mach_sparc_v9b;
4830       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4831 	mach = bfd_mach_sparc_v9a;
4832       return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4833     }
4834   else
4835     {
4836       if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4837 	{
4838 	  if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4839 	    return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4840 					      bfd_mach_sparc_v8plusb);
4841 	  else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4842 	    return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4843 					      bfd_mach_sparc_v8plusa);
4844 	  else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4845 	    return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4846 					      bfd_mach_sparc_v8plus);
4847 	  else
4848 	    return FALSE;
4849 	}
4850       else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4851 	return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4852 					  bfd_mach_sparc_sparclite_le);
4853       else
4854 	return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4855     }
4856 }
4857 
4858 /* Return address for Ith PLT stub in section PLT, for relocation REL
4859    or (bfd_vma) -1 if it should not be included.  */
4860 
4861 bfd_vma
_bfd_sparc_elf_plt_sym_val(bfd_vma i,const asection * plt,const arelent * rel)4862 _bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4863 {
4864   if (ABI_64_P (plt->owner))
4865     {
4866       bfd_vma j;
4867 
4868       i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4869       if (i < PLT64_LARGE_THRESHOLD)
4870 	return plt->vma + i * PLT64_ENTRY_SIZE;
4871 
4872       j = (i - PLT64_LARGE_THRESHOLD) % 160;
4873       i -= j;
4874       return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4875     }
4876   else
4877     return rel->address;
4878 }
4879 
4880 /* Merge backend specific data from an object file to the output
4881    object file when linking.  */
4882 
4883 bfd_boolean
_bfd_sparc_elf_merge_private_bfd_data(bfd * ibfd,bfd * obfd)4884 _bfd_sparc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4885 {
4886   obj_attribute *in_attr, *in_attrs;
4887   obj_attribute *out_attr, *out_attrs;
4888 
4889   if (!elf_known_obj_attributes_proc (obfd)[0].i)
4890     {
4891       /* This is the first object.  Copy the attributes.  */
4892       _bfd_elf_copy_obj_attributes (ibfd, obfd);
4893 
4894       /* Use the Tag_null value to indicate the attributes have been
4895 	 initialized.  */
4896       elf_known_obj_attributes_proc (obfd)[0].i = 1;
4897 
4898       return TRUE;
4899     }
4900 
4901   in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
4902   out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
4903 
4904   in_attr = &in_attrs[Tag_GNU_Sparc_HWCAPS];
4905   out_attr = &out_attrs[Tag_GNU_Sparc_HWCAPS];
4906 
4907   out_attr->i |= in_attr->i;
4908 
4909   /* Merge Tag_compatibility attributes and any common GNU ones.  */
4910   _bfd_elf_merge_object_attributes (ibfd, obfd);
4911 
4912   return TRUE;
4913 }
4914