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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [bfd/] [elfxx-sparc.c] - Blame information for rev 818

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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