OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [elfxx-sparc.c] - Blame information for rev 139

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.