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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [elfxx-sparc.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* SPARC-specific support for ELF
2
   Copyright 2005, 2006, 2007, 2008 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_make_section_with_flags (dynobj, ".rela.got",
903
                                               SEC_ALLOC
904
                                               | SEC_LOAD
905
                                               | SEC_HAS_CONTENTS
906
                                               | SEC_IN_MEMORY
907
                                               | SEC_LINKER_CREATED
908
                                               | SEC_READONLY);
909
  if (htab->srelgot == NULL
910
      || ! bfd_set_section_alignment (dynobj, htab->srelgot,
911
                                      htab->word_align_power))
912
    return FALSE;
913
 
914
  if (htab->is_vxworks)
915
    {
916
      htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
917
      if (!htab->sgotplt)
918
        return FALSE;
919
    }
920
 
921
  return TRUE;
922
}
923
 
924
/* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
925
   .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
926
   hash table.  */
927
 
928
bfd_boolean
929
_bfd_sparc_elf_create_dynamic_sections (bfd *dynobj,
930
                                        struct bfd_link_info *info)
931
{
932
  struct _bfd_sparc_elf_link_hash_table *htab;
933
 
934
  htab = _bfd_sparc_elf_hash_table (info);
935
  if (!htab->sgot && !create_got_section (dynobj, info))
936
    return FALSE;
937
 
938
  if (!_bfd_elf_create_dynamic_sections (dynobj, info))
939
    return FALSE;
940
 
941
  htab->splt = bfd_get_section_by_name (dynobj, ".plt");
942
  htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
943
  htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
944
  if (!info->shared)
945
    htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
946
 
947
  if (htab->is_vxworks)
948
    {
949
      if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
950
        return FALSE;
951
      if (info->shared)
952
        {
953
          htab->plt_header_size
954
            = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt0_entry);
955
          htab->plt_entry_size
956
            = 4 * ARRAY_SIZE (sparc_vxworks_shared_plt_entry);
957
        }
958
      else
959
        {
960
          htab->plt_header_size
961
            = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt0_entry);
962
          htab->plt_entry_size
963
            = 4 * ARRAY_SIZE (sparc_vxworks_exec_plt_entry);
964
        }
965
    }
966
  else
967
    {
968
      if (ABI_64_P (dynobj))
969
        {
970
          htab->build_plt_entry = sparc64_plt_entry_build;
971
          htab->plt_header_size = PLT64_HEADER_SIZE;
972
          htab->plt_entry_size = PLT64_ENTRY_SIZE;
973
        }
974
      else
975
        {
976
          htab->build_plt_entry = sparc32_plt_entry_build;
977
          htab->plt_header_size = PLT32_HEADER_SIZE;
978
          htab->plt_entry_size = PLT32_ENTRY_SIZE;
979
        }
980
    }
981
 
982
  if (!htab->splt || !htab->srelplt || !htab->sdynbss
983
      || (!info->shared && !htab->srelbss))
984
    abort ();
985
 
986
  return TRUE;
987
}
988
 
989
/* Copy the extra info we tack onto an elf_link_hash_entry.  */
990
 
991
void
992
_bfd_sparc_elf_copy_indirect_symbol (struct bfd_link_info *info,
993
                                     struct elf_link_hash_entry *dir,
994
                                     struct elf_link_hash_entry *ind)
995
{
996
  struct _bfd_sparc_elf_link_hash_entry *edir, *eind;
997
 
998
  edir = (struct _bfd_sparc_elf_link_hash_entry *) dir;
999
  eind = (struct _bfd_sparc_elf_link_hash_entry *) ind;
1000
 
1001
  if (eind->dyn_relocs != NULL)
1002
    {
1003
      if (edir->dyn_relocs != NULL)
1004
        {
1005
          struct _bfd_sparc_elf_dyn_relocs **pp;
1006
          struct _bfd_sparc_elf_dyn_relocs *p;
1007
 
1008
          /* Add reloc counts against the indirect sym to the direct sym
1009
             list.  Merge any entries against the same section.  */
1010
          for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1011
            {
1012
              struct _bfd_sparc_elf_dyn_relocs *q;
1013
 
1014
              for (q = edir->dyn_relocs; q != NULL; q = q->next)
1015
                if (q->sec == p->sec)
1016
                  {
1017
                    q->pc_count += p->pc_count;
1018
                    q->count += p->count;
1019
                    *pp = p->next;
1020
                    break;
1021
                  }
1022
              if (q == NULL)
1023
                pp = &p->next;
1024
            }
1025
          *pp = edir->dyn_relocs;
1026
        }
1027
 
1028
      edir->dyn_relocs = eind->dyn_relocs;
1029
      eind->dyn_relocs = NULL;
1030
    }
1031
 
1032
  if (ind->root.type == bfd_link_hash_indirect
1033
      && dir->got.refcount <= 0)
1034
    {
1035
      edir->tls_type = eind->tls_type;
1036
      eind->tls_type = GOT_UNKNOWN;
1037
    }
1038
  _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1039
}
1040
 
1041
static int
1042
sparc_elf_tls_transition (struct bfd_link_info *info, bfd *abfd,
1043
                          int r_type, int is_local)
1044
{
1045
  if (! ABI_64_P (abfd)
1046
      && r_type == R_SPARC_TLS_GD_HI22
1047
      && ! _bfd_sparc_elf_tdata (abfd)->has_tlsgd)
1048
    r_type = R_SPARC_REV32;
1049
 
1050
  if (info->shared)
1051
    return r_type;
1052
 
1053
  switch (r_type)
1054
    {
1055
    case R_SPARC_TLS_GD_HI22:
1056
      if (is_local)
1057
        return R_SPARC_TLS_LE_HIX22;
1058
      return R_SPARC_TLS_IE_HI22;
1059
    case R_SPARC_TLS_GD_LO10:
1060
      if (is_local)
1061
        return R_SPARC_TLS_LE_LOX10;
1062
      return R_SPARC_TLS_IE_LO10;
1063
    case R_SPARC_TLS_IE_HI22:
1064
      if (is_local)
1065
        return R_SPARC_TLS_LE_HIX22;
1066
      return r_type;
1067
    case R_SPARC_TLS_IE_LO10:
1068
      if (is_local)
1069
        return R_SPARC_TLS_LE_LOX10;
1070
      return r_type;
1071
    case R_SPARC_TLS_LDM_HI22:
1072
      return R_SPARC_TLS_LE_HIX22;
1073
    case R_SPARC_TLS_LDM_LO10:
1074
      return R_SPARC_TLS_LE_LOX10;
1075
    }
1076
 
1077
  return r_type;
1078
}
1079
 
1080
/* Look through the relocs for a section during the first phase, and
1081
   allocate space in the global offset table or procedure linkage
1082
   table.  */
1083
 
1084
bfd_boolean
1085
_bfd_sparc_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1086
                             asection *sec, const Elf_Internal_Rela *relocs)
1087
{
1088
  struct _bfd_sparc_elf_link_hash_table *htab;
1089
  Elf_Internal_Shdr *symtab_hdr;
1090
  struct elf_link_hash_entry **sym_hashes;
1091
  bfd_vma *local_got_offsets;
1092
  const Elf_Internal_Rela *rel;
1093
  const Elf_Internal_Rela *rel_end;
1094
  asection *sreloc;
1095
  int num_relocs;
1096
  bfd_boolean checked_tlsgd = FALSE;
1097
 
1098
  if (info->relocatable)
1099
    return TRUE;
1100
 
1101
  htab = _bfd_sparc_elf_hash_table (info);
1102
  symtab_hdr = &elf_symtab_hdr (abfd);
1103
  sym_hashes = elf_sym_hashes (abfd);
1104
  local_got_offsets = elf_local_got_offsets (abfd);
1105
 
1106
  sreloc = NULL;
1107
 
1108
  if (ABI_64_P (abfd))
1109
    num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (sec)->rel_hdr);
1110
  else
1111
    num_relocs = sec->reloc_count;
1112
 
1113
  BFD_ASSERT (is_sparc_elf (abfd) || num_relocs == 0);
1114
 
1115
  rel_end = relocs + num_relocs;
1116
  for (rel = relocs; rel < rel_end; rel++)
1117
    {
1118
      unsigned int r_type;
1119
      unsigned long r_symndx;
1120
      struct elf_link_hash_entry *h;
1121
 
1122
      r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1123
      r_type = SPARC_ELF_R_TYPE (rel->r_info);
1124
 
1125
      if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1126
        {
1127
          (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1128
                                 abfd, r_symndx);
1129
          return FALSE;
1130
        }
1131
 
1132
      if (r_symndx < symtab_hdr->sh_info)
1133
        h = NULL;
1134
      else
1135
        {
1136
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1137
          while (h->root.type == bfd_link_hash_indirect
1138
                 || h->root.type == bfd_link_hash_warning)
1139
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1140
        }
1141
 
1142
      /* Compatibility with old R_SPARC_REV32 reloc conflicting
1143
         with R_SPARC_TLS_GD_HI22.  */
1144
      if (! ABI_64_P (abfd) && ! checked_tlsgd)
1145
        switch (r_type)
1146
          {
1147
          case R_SPARC_TLS_GD_HI22:
1148
            {
1149
              const Elf_Internal_Rela *relt;
1150
 
1151
              for (relt = rel + 1; relt < rel_end; relt++)
1152
                if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
1153
                    || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
1154
                    || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
1155
                  break;
1156
              checked_tlsgd = TRUE;
1157
              _bfd_sparc_elf_tdata (abfd)->has_tlsgd = relt < rel_end;
1158
            }
1159
            break;
1160
          case R_SPARC_TLS_GD_LO10:
1161
          case R_SPARC_TLS_GD_ADD:
1162
          case R_SPARC_TLS_GD_CALL:
1163
            checked_tlsgd = TRUE;
1164
            _bfd_sparc_elf_tdata (abfd)->has_tlsgd = TRUE;
1165
            break;
1166
          }
1167
 
1168
      r_type = sparc_elf_tls_transition (info, abfd, r_type, h == NULL);
1169
      switch (r_type)
1170
        {
1171
        case R_SPARC_TLS_LDM_HI22:
1172
        case R_SPARC_TLS_LDM_LO10:
1173
          htab->tls_ldm_got.refcount += 1;
1174
          break;
1175
 
1176
        case R_SPARC_TLS_LE_HIX22:
1177
        case R_SPARC_TLS_LE_LOX10:
1178
          if (info->shared)
1179
            goto r_sparc_plt32;
1180
          break;
1181
 
1182
        case R_SPARC_TLS_IE_HI22:
1183
        case R_SPARC_TLS_IE_LO10:
1184
          if (info->shared)
1185
            info->flags |= DF_STATIC_TLS;
1186
          /* Fall through */
1187
 
1188
        case R_SPARC_GOT10:
1189
        case R_SPARC_GOT13:
1190
        case R_SPARC_GOT22:
1191
        case R_SPARC_GOTDATA_HIX22:
1192
        case R_SPARC_GOTDATA_LOX10:
1193
        case R_SPARC_GOTDATA_OP_HIX22:
1194
        case R_SPARC_GOTDATA_OP_LOX10:
1195
        case R_SPARC_TLS_GD_HI22:
1196
        case R_SPARC_TLS_GD_LO10:
1197
          /* This symbol requires a global offset table entry.  */
1198
          {
1199
            int tls_type, old_tls_type;
1200
 
1201
            switch (r_type)
1202
              {
1203
              default:
1204
              case R_SPARC_GOT10:
1205
              case R_SPARC_GOT13:
1206
              case R_SPARC_GOT22:
1207
              case R_SPARC_GOTDATA_HIX22:
1208
              case R_SPARC_GOTDATA_LOX10:
1209
              case R_SPARC_GOTDATA_OP_HIX22:
1210
              case R_SPARC_GOTDATA_OP_LOX10:
1211
                tls_type = GOT_NORMAL;
1212
                break;
1213
              case R_SPARC_TLS_GD_HI22:
1214
              case R_SPARC_TLS_GD_LO10:
1215
                tls_type = GOT_TLS_GD;
1216
                break;
1217
              case R_SPARC_TLS_IE_HI22:
1218
              case R_SPARC_TLS_IE_LO10:
1219
                tls_type = GOT_TLS_IE;
1220
                break;
1221
              }
1222
 
1223
            if (h != NULL)
1224
              {
1225
                h->got.refcount += 1;
1226
                old_tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1227
              }
1228
            else
1229
              {
1230
                bfd_signed_vma *local_got_refcounts;
1231
 
1232
                /* This is a global offset table entry for a local symbol.  */
1233
                local_got_refcounts = elf_local_got_refcounts (abfd);
1234
                if (local_got_refcounts == NULL)
1235
                  {
1236
                    bfd_size_type size;
1237
 
1238
                    size = symtab_hdr->sh_info;
1239
                    size *= (sizeof (bfd_signed_vma) + sizeof(char));
1240
                    local_got_refcounts = ((bfd_signed_vma *)
1241
                                           bfd_zalloc (abfd, size));
1242
                    if (local_got_refcounts == NULL)
1243
                      return FALSE;
1244
                    elf_local_got_refcounts (abfd) = local_got_refcounts;
1245
                    _bfd_sparc_elf_local_got_tls_type (abfd)
1246
                      = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1247
                  }
1248
                local_got_refcounts[r_symndx] += 1;
1249
                old_tls_type = _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx];
1250
              }
1251
 
1252
            /* If a TLS symbol is accessed using IE at least once,
1253
               there is no point to use dynamic model for it.  */
1254
            if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1255
                && (old_tls_type != GOT_TLS_GD
1256
                    || tls_type != GOT_TLS_IE))
1257
              {
1258
                if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1259
                  tls_type = old_tls_type;
1260
                else
1261
                  {
1262
                    (*_bfd_error_handler)
1263
                      (_("%B: `%s' accessed both as normal and thread local symbol"),
1264
                       abfd, h ? h->root.root.string : "<local>");
1265
                    return FALSE;
1266
                  }
1267
              }
1268
 
1269
            if (old_tls_type != tls_type)
1270
              {
1271
                if (h != NULL)
1272
                  _bfd_sparc_elf_hash_entry (h)->tls_type = tls_type;
1273
                else
1274
                  _bfd_sparc_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1275
              }
1276
          }
1277
 
1278
          if (htab->sgot == NULL)
1279
            {
1280
              if (htab->elf.dynobj == NULL)
1281
                htab->elf.dynobj = abfd;
1282
              if (!create_got_section (htab->elf.dynobj, info))
1283
                return FALSE;
1284
            }
1285
          break;
1286
 
1287
        case R_SPARC_TLS_GD_CALL:
1288
        case R_SPARC_TLS_LDM_CALL:
1289
          if (info->shared)
1290
            {
1291
              /* These are basically R_SPARC_TLS_WPLT30 relocs against
1292
                 __tls_get_addr.  */
1293
              struct bfd_link_hash_entry *bh = NULL;
1294
              if (! _bfd_generic_link_add_one_symbol (info, abfd,
1295
                                                      "__tls_get_addr", 0,
1296
                                                      bfd_und_section_ptr, 0,
1297
                                                      NULL, FALSE, FALSE,
1298
                                                      &bh))
1299
                return FALSE;
1300
              h = (struct elf_link_hash_entry *) bh;
1301
            }
1302
          else
1303
            break;
1304
          /* Fall through */
1305
 
1306
        case R_SPARC_PLT32:
1307
        case R_SPARC_WPLT30:
1308
        case R_SPARC_HIPLT22:
1309
        case R_SPARC_LOPLT10:
1310
        case R_SPARC_PCPLT32:
1311
        case R_SPARC_PCPLT22:
1312
        case R_SPARC_PCPLT10:
1313
        case R_SPARC_PLT64:
1314
          /* This symbol requires a procedure linkage table entry.  We
1315
             actually build the entry in adjust_dynamic_symbol,
1316
             because this might be a case of linking PIC code without
1317
             linking in any dynamic objects, in which case we don't
1318
             need to generate a procedure linkage table after all.  */
1319
 
1320
          if (h == NULL)
1321
            {
1322
              if (! ABI_64_P (abfd))
1323
                {
1324
                  /* The Solaris native assembler will generate a WPLT30
1325
                     reloc for a local symbol if you assemble a call from
1326
                     one section to another when using -K pic.  We treat
1327
                     it as WDISP30.  */
1328
                  if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
1329
                    goto r_sparc_plt32;
1330
                  break;
1331
                }
1332
 
1333
              /* It does not make sense to have a procedure linkage
1334
                 table entry for a local symbol.  */
1335
              bfd_set_error (bfd_error_bad_value);
1336
              return FALSE;
1337
            }
1338
 
1339
          h->needs_plt = 1;
1340
 
1341
          {
1342
            int this_r_type;
1343
 
1344
            this_r_type = SPARC_ELF_R_TYPE (rel->r_info);
1345
            if (this_r_type == R_SPARC_PLT32
1346
                || this_r_type == R_SPARC_PLT64)
1347
              goto r_sparc_plt32;
1348
          }
1349
          h->plt.refcount += 1;
1350
          break;
1351
 
1352
        case R_SPARC_PC10:
1353
        case R_SPARC_PC22:
1354
        case R_SPARC_PC_HH22:
1355
        case R_SPARC_PC_HM10:
1356
        case R_SPARC_PC_LM22:
1357
          if (h != NULL)
1358
            h->non_got_ref = 1;
1359
 
1360
          if (h != NULL
1361
              && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1362
            break;
1363
          /* Fall through.  */
1364
 
1365
        case R_SPARC_DISP8:
1366
        case R_SPARC_DISP16:
1367
        case R_SPARC_DISP32:
1368
        case R_SPARC_DISP64:
1369
        case R_SPARC_WDISP30:
1370
        case R_SPARC_WDISP22:
1371
        case R_SPARC_WDISP19:
1372
        case R_SPARC_WDISP16:
1373
        case R_SPARC_8:
1374
        case R_SPARC_16:
1375
        case R_SPARC_32:
1376
        case R_SPARC_HI22:
1377
        case R_SPARC_22:
1378
        case R_SPARC_13:
1379
        case R_SPARC_LO10:
1380
        case R_SPARC_UA16:
1381
        case R_SPARC_UA32:
1382
        case R_SPARC_10:
1383
        case R_SPARC_11:
1384
        case R_SPARC_64:
1385
        case R_SPARC_OLO10:
1386
        case R_SPARC_HH22:
1387
        case R_SPARC_HM10:
1388
        case R_SPARC_LM22:
1389
        case R_SPARC_7:
1390
        case R_SPARC_5:
1391
        case R_SPARC_6:
1392
        case R_SPARC_HIX22:
1393
        case R_SPARC_LOX10:
1394
        case R_SPARC_H44:
1395
        case R_SPARC_M44:
1396
        case R_SPARC_L44:
1397
        case R_SPARC_UA64:
1398
          if (h != NULL)
1399
            h->non_got_ref = 1;
1400
 
1401
        r_sparc_plt32:
1402
          if (h != NULL && !info->shared)
1403
            {
1404
              /* We may need a .plt entry if the function this reloc
1405
                 refers to is in a shared lib.  */
1406
              h->plt.refcount += 1;
1407
            }
1408
 
1409
          /* If we are creating a shared library, and this is a reloc
1410
             against a global symbol, or a non PC relative reloc
1411
             against a local symbol, then we need to copy the reloc
1412
             into the shared library.  However, if we are linking with
1413
             -Bsymbolic, we do not need to copy a reloc against a
1414
             global symbol which is defined in an object we are
1415
             including in the link (i.e., DEF_REGULAR is set).  At
1416
             this point we have not seen all the input files, so it is
1417
             possible that DEF_REGULAR is not set now but will be set
1418
             later (it is never cleared).  In case of a weak definition,
1419
             DEF_REGULAR may be cleared later by a strong definition in
1420
             a shared library.  We account for that possibility below by
1421
             storing information in the relocs_copied field of the hash
1422
             table entry.  A similar situation occurs when creating
1423
             shared libraries and symbol visibility changes render the
1424
             symbol local.
1425
 
1426
             If on the other hand, we are creating an executable, we
1427
             may need to keep relocations for symbols satisfied by a
1428
             dynamic library if we manage to avoid copy relocs for the
1429
             symbol.  */
1430
          if ((info->shared
1431
               && (sec->flags & SEC_ALLOC) != 0
1432
               && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1433
                   || (h != NULL
1434
                       && (! info->symbolic
1435
                           || h->root.type == bfd_link_hash_defweak
1436
                           || !h->def_regular))))
1437
              || (!info->shared
1438
                  && (sec->flags & SEC_ALLOC) != 0
1439
                  && h != NULL
1440
                  && (h->root.type == bfd_link_hash_defweak
1441
                      || !h->def_regular)))
1442
            {
1443
              struct _bfd_sparc_elf_dyn_relocs *p;
1444
              struct _bfd_sparc_elf_dyn_relocs **head;
1445
 
1446
              /* When creating a shared object, we must copy these
1447
                 relocs into the output file.  We create a reloc
1448
                 section in dynobj and make room for the reloc.  */
1449
              if (sreloc == NULL)
1450
                {
1451
                  const char *name;
1452
                  bfd *dynobj;
1453
 
1454
                  name = (bfd_elf_string_from_elf_section
1455
                          (abfd,
1456
                           elf_elfheader (abfd)->e_shstrndx,
1457
                           elf_section_data (sec)->rel_hdr.sh_name));
1458
                  if (name == NULL)
1459
                    return FALSE;
1460
 
1461
                  BFD_ASSERT (CONST_STRNEQ (name, ".rela")
1462
                              && strcmp (bfd_get_section_name (abfd, sec),
1463
                                         name + 5) == 0);
1464
 
1465
                  if (htab->elf.dynobj == NULL)
1466
                    htab->elf.dynobj = abfd;
1467
                  dynobj = htab->elf.dynobj;
1468
 
1469
                  sreloc = bfd_get_section_by_name (dynobj, name);
1470
                  if (sreloc == NULL)
1471
                    {
1472
                      flagword flags;
1473
 
1474
                      flags = (SEC_HAS_CONTENTS | SEC_READONLY
1475
                               | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1476
                      if ((sec->flags & SEC_ALLOC) != 0)
1477
                        flags |= SEC_ALLOC | SEC_LOAD;
1478
                      sreloc = bfd_make_section_with_flags (dynobj,
1479
                                                            name,
1480
                                                            flags);
1481
                      if (sreloc == NULL
1482
                          || ! bfd_set_section_alignment (dynobj, sreloc,
1483
                                                          htab->word_align_power))
1484
                        return FALSE;
1485
                    }
1486
                  elf_section_data (sec)->sreloc = sreloc;
1487
                }
1488
 
1489
              /* If this is a global symbol, we count the number of
1490
                 relocations we need for this symbol.  */
1491
              if (h != NULL)
1492
                head = &((struct _bfd_sparc_elf_link_hash_entry *) h)->dyn_relocs;
1493
              else
1494
                {
1495
                  /* Track dynamic relocs needed for local syms too.
1496
                     We really need local syms available to do this
1497
                     easily.  Oh well.  */
1498
 
1499
                  asection *s;
1500
                  void *vpp;
1501
 
1502
                  s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1503
                                                 sec, r_symndx);
1504
                  if (s == NULL)
1505
                    return FALSE;
1506
 
1507
                  vpp = &elf_section_data (s)->local_dynrel;
1508
                  head = (struct _bfd_sparc_elf_dyn_relocs **) vpp;
1509
                }
1510
 
1511
              p = *head;
1512
              if (p == NULL || p->sec != sec)
1513
                {
1514
                  bfd_size_type amt = sizeof *p;
1515
                  p = ((struct _bfd_sparc_elf_dyn_relocs *)
1516
                       bfd_alloc (htab->elf.dynobj, amt));
1517
                  if (p == NULL)
1518
                    return FALSE;
1519
                  p->next = *head;
1520
                  *head = p;
1521
                  p->sec = sec;
1522
                  p->count = 0;
1523
                  p->pc_count = 0;
1524
                }
1525
 
1526
              p->count += 1;
1527
              if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1528
                p->pc_count += 1;
1529
            }
1530
 
1531
          break;
1532
 
1533
        case R_SPARC_GNU_VTINHERIT:
1534
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1535
            return FALSE;
1536
          break;
1537
 
1538
        case R_SPARC_GNU_VTENTRY:
1539
          BFD_ASSERT (h != NULL);
1540
          if (h != NULL
1541
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1542
            return FALSE;
1543
          break;
1544
 
1545
        case R_SPARC_REGISTER:
1546
          /* Nothing to do.  */
1547
          break;
1548
 
1549
        default:
1550
          break;
1551
        }
1552
    }
1553
 
1554
  return TRUE;
1555
}
1556
 
1557
asection *
1558
_bfd_sparc_elf_gc_mark_hook (asection *sec,
1559
                             struct bfd_link_info *info,
1560
                             Elf_Internal_Rela *rel,
1561
                             struct elf_link_hash_entry *h,
1562
                             Elf_Internal_Sym *sym)
1563
{
1564
  if (h != NULL)
1565
    switch (SPARC_ELF_R_TYPE (rel->r_info))
1566
      {
1567
      case R_SPARC_GNU_VTINHERIT:
1568
      case R_SPARC_GNU_VTENTRY:
1569
        return NULL;
1570
      }
1571
 
1572
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1573
}
1574
 
1575
/* Update the got entry reference counts for the section being removed.  */
1576
bfd_boolean
1577
_bfd_sparc_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1578
                              asection *sec, const Elf_Internal_Rela *relocs)
1579
{
1580
  struct _bfd_sparc_elf_link_hash_table *htab;
1581
  Elf_Internal_Shdr *symtab_hdr;
1582
  struct elf_link_hash_entry **sym_hashes;
1583
  bfd_signed_vma *local_got_refcounts;
1584
  const Elf_Internal_Rela *rel, *relend;
1585
 
1586
  if (info->relocatable)
1587
    return TRUE;
1588
 
1589
  BFD_ASSERT (is_sparc_elf (abfd) || sec->reloc_count == 0);
1590
 
1591
  elf_section_data (sec)->local_dynrel = NULL;
1592
 
1593
  htab = _bfd_sparc_elf_hash_table (info);
1594
  symtab_hdr = &elf_symtab_hdr (abfd);
1595
  sym_hashes = elf_sym_hashes (abfd);
1596
  local_got_refcounts = elf_local_got_refcounts (abfd);
1597
 
1598
  relend = relocs + sec->reloc_count;
1599
  for (rel = relocs; rel < relend; rel++)
1600
    {
1601
      unsigned long r_symndx;
1602
      unsigned int r_type;
1603
      struct elf_link_hash_entry *h = NULL;
1604
 
1605
      r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
1606
      if (r_symndx >= symtab_hdr->sh_info)
1607
        {
1608
          struct _bfd_sparc_elf_link_hash_entry *eh;
1609
          struct _bfd_sparc_elf_dyn_relocs **pp;
1610
          struct _bfd_sparc_elf_dyn_relocs *p;
1611
 
1612
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1613
          while (h->root.type == bfd_link_hash_indirect
1614
                 || h->root.type == bfd_link_hash_warning)
1615
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
1616
          eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1617
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1618
            if (p->sec == sec)
1619
              {
1620
                /* Everything must go for SEC.  */
1621
                *pp = p->next;
1622
                break;
1623
              }
1624
        }
1625
 
1626
      r_type = SPARC_ELF_R_TYPE (rel->r_info);
1627
      r_type = sparc_elf_tls_transition (info, abfd, r_type, h != NULL);
1628
      switch (r_type)
1629
        {
1630
        case R_SPARC_TLS_LDM_HI22:
1631
        case R_SPARC_TLS_LDM_LO10:
1632
          if (_bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount > 0)
1633
            _bfd_sparc_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
1634
          break;
1635
 
1636
        case R_SPARC_TLS_GD_HI22:
1637
        case R_SPARC_TLS_GD_LO10:
1638
        case R_SPARC_TLS_IE_HI22:
1639
        case R_SPARC_TLS_IE_LO10:
1640
        case R_SPARC_GOT10:
1641
        case R_SPARC_GOT13:
1642
        case R_SPARC_GOT22:
1643
        case R_SPARC_GOTDATA_HIX22:
1644
        case R_SPARC_GOTDATA_LOX10:
1645
        case R_SPARC_GOTDATA_OP_HIX22:
1646
        case R_SPARC_GOTDATA_OP_LOX10:
1647
          if (h != NULL)
1648
            {
1649
              if (h->got.refcount > 0)
1650
                h->got.refcount--;
1651
            }
1652
          else
1653
            {
1654
              if (local_got_refcounts[r_symndx] > 0)
1655
                local_got_refcounts[r_symndx]--;
1656
            }
1657
          break;
1658
 
1659
        case R_SPARC_PC10:
1660
        case R_SPARC_PC22:
1661
        case R_SPARC_PC_HH22:
1662
        case R_SPARC_PC_HM10:
1663
        case R_SPARC_PC_LM22:
1664
          if (h != NULL
1665
              && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1666
            break;
1667
          /* Fall through.  */
1668
 
1669
        case R_SPARC_DISP8:
1670
        case R_SPARC_DISP16:
1671
        case R_SPARC_DISP32:
1672
        case R_SPARC_DISP64:
1673
        case R_SPARC_WDISP30:
1674
        case R_SPARC_WDISP22:
1675
        case R_SPARC_WDISP19:
1676
        case R_SPARC_WDISP16:
1677
        case R_SPARC_8:
1678
        case R_SPARC_16:
1679
        case R_SPARC_32:
1680
        case R_SPARC_HI22:
1681
        case R_SPARC_22:
1682
        case R_SPARC_13:
1683
        case R_SPARC_LO10:
1684
        case R_SPARC_UA16:
1685
        case R_SPARC_UA32:
1686
        case R_SPARC_PLT32:
1687
        case R_SPARC_10:
1688
        case R_SPARC_11:
1689
        case R_SPARC_64:
1690
        case R_SPARC_OLO10:
1691
        case R_SPARC_HH22:
1692
        case R_SPARC_HM10:
1693
        case R_SPARC_LM22:
1694
        case R_SPARC_7:
1695
        case R_SPARC_5:
1696
        case R_SPARC_6:
1697
        case R_SPARC_HIX22:
1698
        case R_SPARC_LOX10:
1699
        case R_SPARC_H44:
1700
        case R_SPARC_M44:
1701
        case R_SPARC_L44:
1702
        case R_SPARC_UA64:
1703
          if (info->shared)
1704
            break;
1705
          /* Fall through.  */
1706
 
1707
        case R_SPARC_WPLT30:
1708
          if (h != NULL)
1709
            {
1710
              if (h->plt.refcount > 0)
1711
                h->plt.refcount--;
1712
            }
1713
          break;
1714
 
1715
        default:
1716
          break;
1717
        }
1718
    }
1719
 
1720
  return TRUE;
1721
}
1722
 
1723
/* Adjust a symbol defined by a dynamic object and referenced by a
1724
   regular object.  The current definition is in some section of the
1725
   dynamic object, but we're not including those sections.  We have to
1726
   change the definition to something the rest of the link can
1727
   understand.  */
1728
 
1729
bfd_boolean
1730
_bfd_sparc_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1731
                                     struct elf_link_hash_entry *h)
1732
{
1733
  struct _bfd_sparc_elf_link_hash_table *htab;
1734
  struct _bfd_sparc_elf_link_hash_entry * eh;
1735
  struct _bfd_sparc_elf_dyn_relocs *p;
1736
  asection *s;
1737
 
1738
  htab = _bfd_sparc_elf_hash_table (info);
1739
 
1740
  /* Make sure we know what is going on here.  */
1741
  BFD_ASSERT (htab->elf.dynobj != NULL
1742
              && (h->needs_plt
1743
                  || h->u.weakdef != NULL
1744
                  || (h->def_dynamic
1745
                      && h->ref_regular
1746
                      && !h->def_regular)));
1747
 
1748
  /* If this is a function, put it in the procedure linkage table.  We
1749
     will fill in the contents of the procedure linkage table later
1750
     (although we could actually do it here).  The STT_NOTYPE
1751
     condition is a hack specifically for the Oracle libraries
1752
     delivered for Solaris; for some inexplicable reason, they define
1753
     some of their functions as STT_NOTYPE when they really should be
1754
     STT_FUNC.  */
1755
  if (h->type == STT_FUNC
1756
      || h->needs_plt
1757
      || (h->type == STT_NOTYPE
1758
          && (h->root.type == bfd_link_hash_defined
1759
              || h->root.type == bfd_link_hash_defweak)
1760
          && (h->root.u.def.section->flags & SEC_CODE) != 0))
1761
    {
1762
      if (h->plt.refcount <= 0
1763
          || (! info->shared
1764
              && !h->def_dynamic
1765
              && !h->ref_dynamic
1766
              && h->root.type != bfd_link_hash_undefweak
1767
              && h->root.type != bfd_link_hash_undefined))
1768
        {
1769
          /* This case can occur if we saw a WPLT30 reloc in an input
1770
             file, but the symbol was never referred to by a dynamic
1771
             object, or if all references were garbage collected.  In
1772
             such a case, we don't actually need to build a procedure
1773
             linkage table, and we can just do a WDISP30 reloc instead.  */
1774
          h->plt.offset = (bfd_vma) -1;
1775
          h->needs_plt = 0;
1776
        }
1777
 
1778
      return TRUE;
1779
    }
1780
  else
1781
    h->plt.offset = (bfd_vma) -1;
1782
 
1783
  /* If this is a weak symbol, and there is a real definition, the
1784
     processor independent code will have arranged for us to see the
1785
     real definition first, and we can just use the same value.  */
1786
  if (h->u.weakdef != NULL)
1787
    {
1788
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1789
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
1790
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
1791
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
1792
      return TRUE;
1793
    }
1794
 
1795
  /* This is a reference to a symbol defined by a dynamic object which
1796
     is not a function.  */
1797
 
1798
  /* If we are creating a shared library, we must presume that the
1799
     only references to the symbol are via the global offset table.
1800
     For such cases we need not do anything here; the relocations will
1801
     be handled correctly by relocate_section.  */
1802
  if (info->shared)
1803
    return TRUE;
1804
 
1805
  /* If there are no references to this symbol that do not use the
1806
     GOT, we don't need to generate a copy reloc.  */
1807
  if (!h->non_got_ref)
1808
    return TRUE;
1809
 
1810
  eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
1811
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
1812
    {
1813
      s = p->sec->output_section;
1814
      if (s != NULL && (s->flags & SEC_READONLY) != 0)
1815
        break;
1816
    }
1817
 
1818
  /* If we didn't find any dynamic relocs in read-only sections, then
1819
     we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1820
  if (p == NULL)
1821
    {
1822
      h->non_got_ref = 0;
1823
      return TRUE;
1824
    }
1825
 
1826
  if (h->size == 0)
1827
    {
1828
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1829
                             h->root.root.string);
1830
      return TRUE;
1831
    }
1832
 
1833
  /* We must allocate the symbol in our .dynbss section, which will
1834
     become part of the .bss section of the executable.  There will be
1835
     an entry for this symbol in the .dynsym section.  The dynamic
1836
     object will contain position independent code, so all references
1837
     from the dynamic object to this symbol will go through the global
1838
     offset table.  The dynamic linker will use the .dynsym entry to
1839
     determine the address it must put in the global offset table, so
1840
     both the dynamic object and the regular object will refer to the
1841
     same memory location for the variable.  */
1842
 
1843
  /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1844
     to copy the initial value out of the dynamic object and into the
1845
     runtime process image.  We need to remember the offset into the
1846
     .rel.bss section we are going to use.  */
1847
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1848
    {
1849
      htab->srelbss->size += SPARC_ELF_RELA_BYTES (htab);
1850
      h->needs_copy = 1;
1851
    }
1852
 
1853
  s = htab->sdynbss;
1854
 
1855
  return _bfd_elf_adjust_dynamic_copy (h, s);
1856
}
1857
 
1858
/* Allocate space in .plt, .got and associated reloc sections for
1859
   dynamic relocs.  */
1860
 
1861
static bfd_boolean
1862
allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
1863
{
1864
  struct bfd_link_info *info;
1865
  struct _bfd_sparc_elf_link_hash_table *htab;
1866
  struct _bfd_sparc_elf_link_hash_entry *eh;
1867
  struct _bfd_sparc_elf_dyn_relocs *p;
1868
 
1869
  if (h->root.type == bfd_link_hash_indirect)
1870
    return TRUE;
1871
 
1872
  if (h->root.type == bfd_link_hash_warning)
1873
    /* When warning symbols are created, they **replace** the "real"
1874
       entry in the hash table, thus we never get to see the real
1875
       symbol in a hash traversal.  So look at it now.  */
1876
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
1877
 
1878
  info = (struct bfd_link_info *) inf;
1879
  htab = _bfd_sparc_elf_hash_table (info);
1880
 
1881
  if (htab->elf.dynamic_sections_created
1882
      && h->plt.refcount > 0)
1883
    {
1884
      /* Make sure this symbol is output as a dynamic symbol.
1885
         Undefined weak syms won't yet be marked as dynamic.  */
1886
      if (h->dynindx == -1
1887
          && !h->forced_local)
1888
        {
1889
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
1890
            return FALSE;
1891
        }
1892
 
1893
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1894
        {
1895
          asection *s = htab->splt;
1896
 
1897
          /* Allocate room for the header.  */
1898
          if (s->size == 0)
1899
            {
1900
              s->size = htab->plt_header_size;
1901
 
1902
              /* Allocate space for the .rela.plt.unloaded relocations.  */
1903
              if (htab->is_vxworks && !info->shared)
1904
                htab->srelplt2->size = sizeof (Elf32_External_Rela) * 2;
1905
            }
1906
 
1907
          /* The procedure linkage table size is bounded by the magnitude
1908
             of the offset we can describe in the entry.  */
1909
          if (s->size >= (SPARC_ELF_WORD_BYTES(htab) == 8 ?
1910
                          (((bfd_vma)1 << 31) << 1) : 0x400000))
1911
            {
1912
              bfd_set_error (bfd_error_bad_value);
1913
              return FALSE;
1914
            }
1915
 
1916
          if (SPARC_ELF_WORD_BYTES(htab) == 8
1917
              && s->size >= PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE)
1918
            {
1919
              bfd_vma off = s->size - PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE;
1920
 
1921
 
1922
              off = (off % (160 * PLT64_ENTRY_SIZE)) / PLT64_ENTRY_SIZE;
1923
 
1924
              h->plt.offset = (s->size - (off * 8));
1925
            }
1926
          else
1927
            h->plt.offset = s->size;
1928
 
1929
          /* If this symbol is not defined in a regular file, and we are
1930
             not generating a shared library, then set the symbol to this
1931
             location in the .plt.  This is required to make function
1932
             pointers compare as equal between the normal executable and
1933
             the shared library.  */
1934
          if (! info->shared
1935
              && !h->def_regular)
1936
            {
1937
              h->root.u.def.section = s;
1938
              h->root.u.def.value = h->plt.offset;
1939
            }
1940
 
1941
          /* Make room for this entry.  */
1942
          s->size += htab->plt_entry_size;
1943
 
1944
          /* We also need to make an entry in the .rela.plt section.  */
1945
          htab->srelplt->size += SPARC_ELF_RELA_BYTES (htab);
1946
 
1947
          if (htab->is_vxworks)
1948
            {
1949
              /* Allocate space for the .got.plt entry.  */
1950
              htab->sgotplt->size += 4;
1951
 
1952
              /* ...and for the .rela.plt.unloaded relocations.  */
1953
              if (!info->shared)
1954
                htab->srelplt2->size += sizeof (Elf32_External_Rela) * 3;
1955
            }
1956
        }
1957
      else
1958
        {
1959
          h->plt.offset = (bfd_vma) -1;
1960
          h->needs_plt = 0;
1961
        }
1962
    }
1963
  else
1964
    {
1965
      h->plt.offset = (bfd_vma) -1;
1966
      h->needs_plt = 0;
1967
    }
1968
 
1969
  /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1970
     make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry.  */
1971
  if (h->got.refcount > 0
1972
      && !info->shared
1973
      && h->dynindx == -1
1974
      && _bfd_sparc_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
1975
    h->got.offset = (bfd_vma) -1;
1976
  else if (h->got.refcount > 0)
1977
    {
1978
      asection *s;
1979
      bfd_boolean dyn;
1980
      int tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
1981
 
1982
      /* Make sure this symbol is output as a dynamic symbol.
1983
         Undefined weak syms won't yet be marked as dynamic.  */
1984
      if (h->dynindx == -1
1985
          && !h->forced_local)
1986
        {
1987
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
1988
            return FALSE;
1989
        }
1990
 
1991
      s = htab->sgot;
1992
      h->got.offset = s->size;
1993
      s->size += SPARC_ELF_WORD_BYTES (htab);
1994
      /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots.  */
1995
      if (tls_type == GOT_TLS_GD)
1996
        s->size += SPARC_ELF_WORD_BYTES (htab);
1997
      dyn = htab->elf.dynamic_sections_created;
1998
      /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1999
         R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
2000
         global.  */
2001
      if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
2002
          || tls_type == GOT_TLS_IE)
2003
        htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2004
      else if (tls_type == GOT_TLS_GD)
2005
        htab->srelgot->size += 2 * SPARC_ELF_RELA_BYTES (htab);
2006
      else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2007
        htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2008
    }
2009
  else
2010
    h->got.offset = (bfd_vma) -1;
2011
 
2012
  eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2013
  if (eh->dyn_relocs == NULL)
2014
    return TRUE;
2015
 
2016
  /* In the shared -Bsymbolic case, discard space allocated for
2017
     dynamic pc-relative relocs against symbols which turn out to be
2018
     defined in regular objects.  For the normal shared case, discard
2019
     space for pc-relative relocs that have become local due to symbol
2020
     visibility changes.  */
2021
 
2022
  if (info->shared)
2023
    {
2024
      if (h->def_regular
2025
          && (h->forced_local
2026
              || info->symbolic))
2027
        {
2028
          struct _bfd_sparc_elf_dyn_relocs **pp;
2029
 
2030
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2031
            {
2032
              p->count -= p->pc_count;
2033
              p->pc_count = 0;
2034
              if (p->count == 0)
2035
                *pp = p->next;
2036
              else
2037
                pp = &p->next;
2038
            }
2039
        }
2040
 
2041
      if (htab->is_vxworks)
2042
        {
2043
          struct _bfd_sparc_elf_dyn_relocs **pp;
2044
 
2045
          for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2046
            {
2047
              if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2048
                *pp = p->next;
2049
              else
2050
                pp = &p->next;
2051
            }
2052
        }
2053
 
2054
      /* Also discard relocs on undefined weak syms with non-default
2055
         visibility.  */
2056
      if (eh->dyn_relocs != NULL
2057
          && h->root.type == bfd_link_hash_undefweak)
2058
        {
2059
          if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2060
            eh->dyn_relocs = NULL;
2061
 
2062
          /* Make sure undefined weak symbols are output as a dynamic
2063
             symbol in PIEs.  */
2064
          else if (h->dynindx == -1
2065
                   && !h->forced_local)
2066
            {
2067
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
2068
                return FALSE;
2069
            }
2070
        }
2071
    }
2072
  else
2073
    {
2074
      /* For the non-shared case, discard space for relocs against
2075
         symbols which turn out to need copy relocs or are not
2076
         dynamic.  */
2077
 
2078
      if (!h->non_got_ref
2079
          && ((h->def_dynamic
2080
               && !h->def_regular)
2081
              || (htab->elf.dynamic_sections_created
2082
                  && (h->root.type == bfd_link_hash_undefweak
2083
                      || h->root.type == bfd_link_hash_undefined))))
2084
        {
2085
          /* Make sure this symbol is output as a dynamic symbol.
2086
             Undefined weak syms won't yet be marked as dynamic.  */
2087
          if (h->dynindx == -1
2088
              && !h->forced_local)
2089
            {
2090
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
2091
                return FALSE;
2092
            }
2093
 
2094
          /* If that succeeded, we know we'll be keeping all the
2095
             relocs.  */
2096
          if (h->dynindx != -1)
2097
            goto keep;
2098
        }
2099
 
2100
      eh->dyn_relocs = NULL;
2101
 
2102
    keep: ;
2103
    }
2104
 
2105
  /* Finally, allocate space.  */
2106
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
2107
    {
2108
      asection *sreloc = elf_section_data (p->sec)->sreloc;
2109
      sreloc->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2110
    }
2111
 
2112
  return TRUE;
2113
}
2114
 
2115
/* Find any dynamic relocs that apply to read-only sections.  */
2116
 
2117
static bfd_boolean
2118
readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
2119
{
2120
  struct _bfd_sparc_elf_link_hash_entry *eh;
2121
  struct _bfd_sparc_elf_dyn_relocs *p;
2122
 
2123
  if (h->root.type == bfd_link_hash_warning)
2124
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
2125
 
2126
  eh = (struct _bfd_sparc_elf_link_hash_entry *) h;
2127
  for (p = eh->dyn_relocs; p != NULL; p = p->next)
2128
    {
2129
      asection *s = p->sec->output_section;
2130
 
2131
      if (s != NULL && (s->flags & SEC_READONLY) != 0)
2132
        {
2133
          struct bfd_link_info *info = (struct bfd_link_info *) inf;
2134
 
2135
          info->flags |= DF_TEXTREL;
2136
 
2137
          /* Not an error, just cut short the traversal.  */
2138
          return FALSE;
2139
        }
2140
    }
2141
  return TRUE;
2142
}
2143
 
2144
/* Return true if the dynamic symbol for a given section should be
2145
   omitted when creating a shared library.  */
2146
 
2147
bfd_boolean
2148
_bfd_sparc_elf_omit_section_dynsym (bfd *output_bfd,
2149
                                    struct bfd_link_info *info,
2150
                                    asection *p)
2151
{
2152
  /* We keep the .got section symbol so that explicit relocations
2153
     against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2154
     can be turned into relocations against the .got symbol.  */
2155
  if (strcmp (p->name, ".got") == 0)
2156
    return FALSE;
2157
 
2158
  return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2159
}
2160
 
2161
/* Set the sizes of the dynamic sections.  */
2162
 
2163
bfd_boolean
2164
_bfd_sparc_elf_size_dynamic_sections (bfd *output_bfd,
2165
                                      struct bfd_link_info *info)
2166
{
2167
  struct _bfd_sparc_elf_link_hash_table *htab;
2168
  bfd *dynobj;
2169
  asection *s;
2170
  bfd *ibfd;
2171
 
2172
  htab = _bfd_sparc_elf_hash_table (info);
2173
  dynobj = htab->elf.dynobj;
2174
  BFD_ASSERT (dynobj != NULL);
2175
 
2176
  if (elf_hash_table (info)->dynamic_sections_created)
2177
    {
2178
      /* Set the contents of the .interp section to the interpreter.  */
2179
      if (info->executable)
2180
        {
2181
          s = bfd_get_section_by_name (dynobj, ".interp");
2182
          BFD_ASSERT (s != NULL);
2183
          s->size = htab->dynamic_interpreter_size;
2184
          s->contents = (unsigned char *) htab->dynamic_interpreter;
2185
        }
2186
    }
2187
 
2188
  /* Set up .got offsets for local syms, and space for local dynamic
2189
     relocs.  */
2190
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2191
    {
2192
      bfd_signed_vma *local_got;
2193
      bfd_signed_vma *end_local_got;
2194
      char *local_tls_type;
2195
      bfd_size_type locsymcount;
2196
      Elf_Internal_Shdr *symtab_hdr;
2197
      asection *srel;
2198
 
2199
      if (! is_sparc_elf (ibfd))
2200
        continue;
2201
 
2202
      for (s = ibfd->sections; s != NULL; s = s->next)
2203
        {
2204
          struct _bfd_sparc_elf_dyn_relocs *p;
2205
 
2206
          for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2207
            {
2208
              if (!bfd_is_abs_section (p->sec)
2209
                  && bfd_is_abs_section (p->sec->output_section))
2210
                {
2211
                  /* Input section has been discarded, either because
2212
                     it is a copy of a linkonce section or due to
2213
                     linker script /DISCARD/, so we'll be discarding
2214
                     the relocs too.  */
2215
                }
2216
              else if (htab->is_vxworks
2217
                       && strcmp (p->sec->output_section->name,
2218
                                  ".tls_vars") == 0)
2219
                {
2220
                  /* Relocations in vxworks .tls_vars sections are
2221
                     handled specially by the loader.  */
2222
                }
2223
              else if (p->count != 0)
2224
                {
2225
                  srel = elf_section_data (p->sec)->sreloc;
2226
                  srel->size += p->count * SPARC_ELF_RELA_BYTES (htab);
2227
                  if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2228
                    info->flags |= DF_TEXTREL;
2229
                }
2230
            }
2231
        }
2232
 
2233
      local_got = elf_local_got_refcounts (ibfd);
2234
      if (!local_got)
2235
        continue;
2236
 
2237
      symtab_hdr = &elf_symtab_hdr (ibfd);
2238
      locsymcount = symtab_hdr->sh_info;
2239
      end_local_got = local_got + locsymcount;
2240
      local_tls_type = _bfd_sparc_elf_local_got_tls_type (ibfd);
2241
      s = htab->sgot;
2242
      srel = htab->srelgot;
2243
      for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2244
        {
2245
          if (*local_got > 0)
2246
            {
2247
              *local_got = s->size;
2248
              s->size += SPARC_ELF_WORD_BYTES (htab);
2249
              if (*local_tls_type == GOT_TLS_GD)
2250
                s->size += SPARC_ELF_WORD_BYTES (htab);
2251
              if (info->shared
2252
                  || *local_tls_type == GOT_TLS_GD
2253
                  || *local_tls_type == GOT_TLS_IE)
2254
                srel->size += SPARC_ELF_RELA_BYTES (htab);
2255
            }
2256
          else
2257
            *local_got = (bfd_vma) -1;
2258
        }
2259
    }
2260
 
2261
  if (htab->tls_ldm_got.refcount > 0)
2262
    {
2263
      /* Allocate 2 got entries and 1 dynamic reloc for
2264
         R_SPARC_TLS_LDM_{HI22,LO10} relocs.  */
2265
      htab->tls_ldm_got.offset = htab->sgot->size;
2266
      htab->sgot->size += (2 * SPARC_ELF_WORD_BYTES (htab));
2267
      htab->srelgot->size += SPARC_ELF_RELA_BYTES (htab);
2268
    }
2269
  else
2270
    htab->tls_ldm_got.offset = -1;
2271
 
2272
  /* Allocate global sym .plt and .got entries, and space for global
2273
     sym dynamic relocs.  */
2274
  elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2275
 
2276
  if (! ABI_64_P (output_bfd)
2277
      && !htab->is_vxworks
2278
      && elf_hash_table (info)->dynamic_sections_created)
2279
    {
2280
      /* Make space for the trailing nop in .plt.  */
2281
      if (htab->splt->size > 0)
2282
        htab->splt->size += 1 * SPARC_INSN_BYTES;
2283
 
2284
      /* If the .got section is more than 0x1000 bytes, we add
2285
         0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
2286
         bit relocations have a greater chance of working.
2287
 
2288
         FIXME: Make this optimization work for 64-bit too.  */
2289
      if (htab->sgot->size >= 0x1000
2290
          && elf_hash_table (info)->hgot->root.u.def.value == 0)
2291
        elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
2292
    }
2293
 
2294
  /* The check_relocs and adjust_dynamic_symbol entry points have
2295
     determined the sizes of the various dynamic sections.  Allocate
2296
     memory for them.  */
2297
  for (s = dynobj->sections; s != NULL; s = s->next)
2298
    {
2299
      if ((s->flags & SEC_LINKER_CREATED) == 0)
2300
        continue;
2301
 
2302
      if (s == htab->splt
2303
          || s == htab->sgot
2304
          || s == htab->sdynbss
2305
          || s == htab->sgotplt)
2306
        {
2307
          /* Strip this section if we don't need it; see the
2308
             comment below.  */
2309
        }
2310
      else if (CONST_STRNEQ (s->name, ".rela"))
2311
        {
2312
          if (s->size != 0)
2313
            {
2314
              /* We use the reloc_count field as a counter if we need
2315
                 to copy relocs into the output file.  */
2316
              s->reloc_count = 0;
2317
            }
2318
        }
2319
      else
2320
        {
2321
          /* It's not one of our sections.  */
2322
          continue;
2323
        }
2324
 
2325
      if (s->size == 0)
2326
        {
2327
          /* If we don't need this section, strip it from the
2328
             output file.  This is mostly to handle .rela.bss and
2329
             .rela.plt.  We must create both sections in
2330
             create_dynamic_sections, because they must be created
2331
             before the linker maps input sections to output
2332
             sections.  The linker does that before
2333
             adjust_dynamic_symbol is called, and it is that
2334
             function which decides whether anything needs to go
2335
             into these sections.  */
2336
          s->flags |= SEC_EXCLUDE;
2337
          continue;
2338
        }
2339
 
2340
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
2341
        continue;
2342
 
2343
      /* Allocate memory for the section contents.  Zero the memory
2344
         for the benefit of .rela.plt, which has 4 unused entries
2345
         at the beginning, and we don't want garbage.  */
2346
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2347
      if (s->contents == NULL)
2348
        return FALSE;
2349
    }
2350
 
2351
  if (elf_hash_table (info)->dynamic_sections_created)
2352
    {
2353
      /* Add some entries to the .dynamic section.  We fill in the
2354
         values later, in _bfd_sparc_elf_finish_dynamic_sections, but we
2355
         must add the entries now so that we get the correct size for
2356
         the .dynamic section.  The DT_DEBUG entry is filled in by the
2357
         dynamic linker and used by the debugger.  */
2358
#define add_dynamic_entry(TAG, VAL) \
2359
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2360
 
2361
      if (info->executable)
2362
        {
2363
          if (!add_dynamic_entry (DT_DEBUG, 0))
2364
            return FALSE;
2365
        }
2366
 
2367
      if (htab->srelplt->size != 0)
2368
        {
2369
          if (!add_dynamic_entry (DT_PLTGOT, 0)
2370
              || !add_dynamic_entry (DT_PLTRELSZ, 0)
2371
              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2372
              || !add_dynamic_entry (DT_JMPREL, 0))
2373
            return FALSE;
2374
        }
2375
 
2376
      if (!add_dynamic_entry (DT_RELA, 0)
2377
          || !add_dynamic_entry (DT_RELASZ, 0)
2378
          || !add_dynamic_entry (DT_RELAENT,
2379
                                 SPARC_ELF_RELA_BYTES (htab)))
2380
        return FALSE;
2381
 
2382
      /* If any dynamic relocs apply to a read-only section,
2383
         then we need a DT_TEXTREL entry.  */
2384
      if ((info->flags & DF_TEXTREL) == 0)
2385
        elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2386
                                (PTR) info);
2387
 
2388
      if (info->flags & DF_TEXTREL)
2389
        {
2390
          if (!add_dynamic_entry (DT_TEXTREL, 0))
2391
            return FALSE;
2392
        }
2393
 
2394
      if (ABI_64_P (output_bfd))
2395
        {
2396
          int reg;
2397
          struct _bfd_sparc_elf_app_reg * app_regs;
2398
          struct elf_strtab_hash *dynstr;
2399
          struct elf_link_hash_table *eht = elf_hash_table (info);
2400
 
2401
          /* Add dynamic STT_REGISTER symbols and corresponding DT_SPARC_REGISTER
2402
             entries if needed.  */
2403
          app_regs = _bfd_sparc_elf_hash_table (info)->app_regs;
2404
          dynstr = eht->dynstr;
2405
 
2406
          for (reg = 0; reg < 4; reg++)
2407
            if (app_regs [reg].name != NULL)
2408
              {
2409
                struct elf_link_local_dynamic_entry *entry, *e;
2410
 
2411
                if (!add_dynamic_entry (DT_SPARC_REGISTER, 0))
2412
                  return FALSE;
2413
 
2414
                entry = (struct elf_link_local_dynamic_entry *)
2415
                  bfd_hash_allocate (&info->hash->table, sizeof (*entry));
2416
                if (entry == NULL)
2417
                  return FALSE;
2418
 
2419
                /* We cheat here a little bit: the symbol will not be local, so we
2420
                   put it at the end of the dynlocal linked list.  We will fix it
2421
                   later on, as we have to fix other fields anyway.  */
2422
                entry->isym.st_value = reg < 2 ? reg + 2 : reg + 4;
2423
                entry->isym.st_size = 0;
2424
                if (*app_regs [reg].name != '\0')
2425
                  entry->isym.st_name
2426
                    = _bfd_elf_strtab_add (dynstr, app_regs[reg].name, FALSE);
2427
                else
2428
                  entry->isym.st_name = 0;
2429
                entry->isym.st_other = 0;
2430
                entry->isym.st_info = ELF_ST_INFO (app_regs [reg].bind,
2431
                                                   STT_REGISTER);
2432
                entry->isym.st_shndx = app_regs [reg].shndx;
2433
                entry->next = NULL;
2434
                entry->input_bfd = output_bfd;
2435
                entry->input_indx = -1;
2436
 
2437
                if (eht->dynlocal == NULL)
2438
                  eht->dynlocal = entry;
2439
                else
2440
                  {
2441
                    for (e = eht->dynlocal; e->next; e = e->next)
2442
                      ;
2443
                    e->next = entry;
2444
                  }
2445
                eht->dynsymcount++;
2446
              }
2447
        }
2448
      if (htab->is_vxworks
2449
          && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2450
        return FALSE;
2451
    }
2452
#undef add_dynamic_entry
2453
 
2454
  return TRUE;
2455
}
2456
 
2457
bfd_boolean
2458
_bfd_sparc_elf_new_section_hook (bfd *abfd, asection *sec)
2459
{
2460
  if (!sec->used_by_bfd)
2461
    {
2462
      struct _bfd_sparc_elf_section_data *sdata;
2463
      bfd_size_type amt = sizeof (*sdata);
2464
 
2465
      sdata = bfd_zalloc (abfd, amt);
2466
      if (sdata == NULL)
2467
        return FALSE;
2468
      sec->used_by_bfd = sdata;
2469
    }
2470
 
2471
  return _bfd_elf_new_section_hook (abfd, sec);
2472
}
2473
 
2474
bfd_boolean
2475
_bfd_sparc_elf_relax_section (bfd *abfd ATTRIBUTE_UNUSED,
2476
                              struct bfd_section *section,
2477
                              struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2478
                              bfd_boolean *again)
2479
{
2480
  *again = FALSE;
2481
  sec_do_relax (section) = 1;
2482
  return TRUE;
2483
}
2484
 
2485
/* Return the base VMA address which should be subtracted from real addresses
2486
   when resolving @dtpoff relocation.
2487
   This is PT_TLS segment p_vaddr.  */
2488
 
2489
static bfd_vma
2490
dtpoff_base (struct bfd_link_info *info)
2491
{
2492
  /* If tls_sec is NULL, we should have signalled an error already.  */
2493
  if (elf_hash_table (info)->tls_sec == NULL)
2494
    return 0;
2495
  return elf_hash_table (info)->tls_sec->vma;
2496
}
2497
 
2498
/* Return the relocation value for @tpoff relocation
2499
   if STT_TLS virtual address is ADDRESS.  */
2500
 
2501
static bfd_vma
2502
tpoff (struct bfd_link_info *info, bfd_vma address)
2503
{
2504
  struct elf_link_hash_table *htab = elf_hash_table (info);
2505
 
2506
  /* If tls_sec is NULL, we should have signalled an error already.  */
2507
  if (htab->tls_sec == NULL)
2508
    return 0;
2509
  return address - htab->tls_size - htab->tls_sec->vma;
2510
}
2511
 
2512
/* Relocate a SPARC ELF section.  */
2513
 
2514
bfd_boolean
2515
_bfd_sparc_elf_relocate_section (bfd *output_bfd,
2516
                                 struct bfd_link_info *info,
2517
                                 bfd *input_bfd,
2518
                                 asection *input_section,
2519
                                 bfd_byte *contents,
2520
                                 Elf_Internal_Rela *relocs,
2521
                                 Elf_Internal_Sym *local_syms,
2522
                                 asection **local_sections)
2523
{
2524
  struct _bfd_sparc_elf_link_hash_table *htab;
2525
  Elf_Internal_Shdr *symtab_hdr;
2526
  struct elf_link_hash_entry **sym_hashes;
2527
  bfd_vma *local_got_offsets;
2528
  bfd_vma got_base;
2529
  asection *sreloc;
2530
  Elf_Internal_Rela *rel;
2531
  Elf_Internal_Rela *relend;
2532
  int num_relocs;
2533
  bfd_boolean is_vxworks_tls;
2534
 
2535
  htab = _bfd_sparc_elf_hash_table (info);
2536
  symtab_hdr = &elf_symtab_hdr (input_bfd);
2537
  sym_hashes = elf_sym_hashes (input_bfd);
2538
  local_got_offsets = elf_local_got_offsets (input_bfd);
2539
 
2540
  if (elf_hash_table (info)->hgot == NULL)
2541
    got_base = 0;
2542
  else
2543
    got_base = elf_hash_table (info)->hgot->root.u.def.value;
2544
 
2545
  sreloc = elf_section_data (input_section)->sreloc;
2546
  /* We have to handle relocations in vxworks .tls_vars sections
2547
     specially, because the dynamic loader is 'weird'.  */
2548
  is_vxworks_tls = (htab->is_vxworks && info->shared
2549
                    && !strcmp (input_section->output_section->name,
2550
                                ".tls_vars"));
2551
 
2552
  rel = relocs;
2553
  if (ABI_64_P (output_bfd))
2554
    num_relocs = NUM_SHDR_ENTRIES (& elf_section_data (input_section)->rel_hdr);
2555
  else
2556
    num_relocs = input_section->reloc_count;
2557
  relend = relocs + num_relocs;
2558
  for (; rel < relend; rel++)
2559
    {
2560
      int r_type, tls_type;
2561
      reloc_howto_type *howto;
2562
      unsigned long r_symndx;
2563
      struct elf_link_hash_entry *h;
2564
      Elf_Internal_Sym *sym;
2565
      asection *sec;
2566
      bfd_vma relocation, off;
2567
      bfd_reloc_status_type r;
2568
      bfd_boolean is_plt = FALSE;
2569
      bfd_boolean unresolved_reloc;
2570
 
2571
      r_type = SPARC_ELF_R_TYPE (rel->r_info);
2572
      if (r_type == R_SPARC_GNU_VTINHERIT
2573
          || r_type == R_SPARC_GNU_VTENTRY)
2574
        continue;
2575
 
2576
      if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
2577
        {
2578
          bfd_set_error (bfd_error_bad_value);
2579
          return FALSE;
2580
        }
2581
      howto = _bfd_sparc_elf_howto_table + r_type;
2582
 
2583
      r_symndx = SPARC_ELF_R_SYMNDX (htab, rel->r_info);
2584
      h = NULL;
2585
      sym = NULL;
2586
      sec = NULL;
2587
      unresolved_reloc = FALSE;
2588
      if (r_symndx < symtab_hdr->sh_info)
2589
        {
2590
          sym = local_syms + r_symndx;
2591
          sec = local_sections[r_symndx];
2592
          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2593
        }
2594
      else
2595
        {
2596
          bfd_boolean warned;
2597
 
2598
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2599
                                   r_symndx, symtab_hdr, sym_hashes,
2600
                                   h, sec, relocation,
2601
                                   unresolved_reloc, warned);
2602
          if (warned)
2603
            {
2604
              /* To avoid generating warning messages about truncated
2605
                 relocations, set the relocation's address to be the same as
2606
                 the start of this section.  */
2607
              if (input_section->output_section != NULL)
2608
                relocation = input_section->output_section->vma;
2609
              else
2610
                relocation = 0;
2611
            }
2612
        }
2613
 
2614
      if (sec != NULL && elf_discarded_section (sec))
2615
        {
2616
          /* For relocs against symbols from removed linkonce
2617
             sections, or sections discarded by a linker script, we
2618
             just want the section contents zeroed.  Avoid any
2619
             special processing.  */
2620
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2621
          rel->r_info = 0;
2622
          rel->r_addend = 0;
2623
          continue;
2624
        }
2625
 
2626
      if (info->relocatable)
2627
        continue;
2628
 
2629
      switch (r_type)
2630
        {
2631
        case R_SPARC_GOTDATA_HIX22:
2632
        case R_SPARC_GOTDATA_LOX10:
2633
        case R_SPARC_GOTDATA_OP_HIX22:
2634
        case R_SPARC_GOTDATA_OP_LOX10:
2635
          /* We don't support these code transformation optimizations
2636
             yet, so just leave the sequence alone and treat as
2637
             GOT22/GOT10.  */
2638
          if (r_type == R_SPARC_GOTDATA_HIX22
2639
              || r_type == R_SPARC_GOTDATA_OP_HIX22)
2640
            r_type = R_SPARC_GOT22;
2641
          else
2642
            r_type = R_SPARC_GOT10;
2643
          /* Fall through. */
2644
 
2645
        case R_SPARC_GOT10:
2646
        case R_SPARC_GOT13:
2647
        case R_SPARC_GOT22:
2648
          /* Relocation is to the entry for this symbol in the global
2649
             offset table.  */
2650
          if (htab->sgot == NULL)
2651
            abort ();
2652
 
2653
          if (h != NULL)
2654
            {
2655
              bfd_boolean dyn;
2656
 
2657
              off = h->got.offset;
2658
              BFD_ASSERT (off != (bfd_vma) -1);
2659
              dyn = elf_hash_table (info)->dynamic_sections_created;
2660
 
2661
              if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2662
                  || (info->shared
2663
                      && (info->symbolic
2664
                          || h->dynindx == -1
2665
                          || h->forced_local)
2666
                      && h->def_regular))
2667
                {
2668
                  /* This is actually a static link, or it is a
2669
                     -Bsymbolic link and the symbol is defined
2670
                     locally, or the symbol was forced to be local
2671
                     because of a version file.  We must initialize
2672
                     this entry in the global offset table.  Since the
2673
                     offset must always be a multiple of 8 for 64-bit
2674
                     and 4 for 32-bit, we use the least significant bit
2675
                     to record whether we have initialized it already.
2676
 
2677
                     When doing a dynamic link, we create a .rela.got
2678
                     relocation entry to initialize the value.  This
2679
                     is done in the finish_dynamic_symbol routine.  */
2680
                  if ((off & 1) != 0)
2681
                    off &= ~1;
2682
                  else
2683
                    {
2684
                      SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2685
                                          htab->sgot->contents + off);
2686
                      h->got.offset |= 1;
2687
                    }
2688
                }
2689
              else
2690
                unresolved_reloc = FALSE;
2691
            }
2692
          else
2693
            {
2694
              BFD_ASSERT (local_got_offsets != NULL
2695
                          && local_got_offsets[r_symndx] != (bfd_vma) -1);
2696
 
2697
              off = local_got_offsets[r_symndx];
2698
 
2699
              /* The offset must always be a multiple of 8 on 64-bit and
2700
                 4 on 32-bit.  We use the least significant bit to record
2701
                 whether we have already processed this entry.  */
2702
              if ((off & 1) != 0)
2703
                off &= ~1;
2704
              else
2705
                {
2706
 
2707
                  if (info->shared)
2708
                    {
2709
                      asection *s;
2710
                      Elf_Internal_Rela outrel;
2711
 
2712
                      /* We need to generate a R_SPARC_RELATIVE reloc
2713
                         for the dynamic linker.  */
2714
                      s = htab->srelgot;
2715
                      BFD_ASSERT (s != NULL);
2716
 
2717
                      outrel.r_offset = (htab->sgot->output_section->vma
2718
                                         + htab->sgot->output_offset
2719
                                         + off);
2720
                      outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2721
                                                        0, R_SPARC_RELATIVE);
2722
                      outrel.r_addend = relocation;
2723
                      relocation = 0;
2724
                      sparc_elf_append_rela (output_bfd, s, &outrel);
2725
                    }
2726
 
2727
                  SPARC_ELF_PUT_WORD (htab, output_bfd, relocation,
2728
                                      htab->sgot->contents + off);
2729
                  local_got_offsets[r_symndx] |= 1;
2730
                }
2731
            }
2732
          relocation = htab->sgot->output_offset + off - got_base;
2733
          break;
2734
 
2735
        case R_SPARC_PLT32:
2736
        case R_SPARC_PLT64:
2737
          if (h == NULL || h->plt.offset == (bfd_vma) -1)
2738
            {
2739
              r_type = (r_type == R_SPARC_PLT32) ? R_SPARC_32 : R_SPARC_64;
2740
              goto r_sparc_plt32;
2741
            }
2742
          /* Fall through.  */
2743
 
2744
        case R_SPARC_WPLT30:
2745
        case R_SPARC_HIPLT22:
2746
        case R_SPARC_LOPLT10:
2747
        case R_SPARC_PCPLT32:
2748
        case R_SPARC_PCPLT22:
2749
        case R_SPARC_PCPLT10:
2750
        r_sparc_wplt30:
2751
          /* Relocation is to the entry for this symbol in the
2752
             procedure linkage table.  */
2753
 
2754
          if (! ABI_64_P (output_bfd))
2755
            {
2756
              /* The Solaris native assembler will generate a WPLT30 reloc
2757
                 for a local symbol if you assemble a call from one
2758
                 section to another when using -K pic.  We treat it as
2759
                 WDISP30.  */
2760
              if (h == NULL)
2761
                break;
2762
            }
2763
          else
2764
            {
2765
              BFD_ASSERT (h != NULL);
2766
            }
2767
 
2768
          if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
2769
            {
2770
              /* We didn't make a PLT entry for this symbol.  This
2771
                 happens when statically linking PIC code, or when
2772
                 using -Bsymbolic.  */
2773
              break;
2774
            }
2775
 
2776
          relocation = (htab->splt->output_section->vma
2777
                        + htab->splt->output_offset
2778
                        + h->plt.offset);
2779
          unresolved_reloc = FALSE;
2780
          if (r_type == R_SPARC_PLT32 || r_type == R_SPARC_PLT64)
2781
            {
2782
              r_type = r_type == R_SPARC_PLT32 ? R_SPARC_32 : R_SPARC_64;
2783
              is_plt = TRUE;
2784
              goto r_sparc_plt32;
2785
            }
2786
          break;
2787
 
2788
        case R_SPARC_PC10:
2789
        case R_SPARC_PC22:
2790
        case R_SPARC_PC_HH22:
2791
        case R_SPARC_PC_HM10:
2792
        case R_SPARC_PC_LM22:
2793
          if (h != NULL
2794
              && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2795
            break;
2796
          /* Fall through.  */
2797
        case R_SPARC_DISP8:
2798
        case R_SPARC_DISP16:
2799
        case R_SPARC_DISP32:
2800
        case R_SPARC_DISP64:
2801
        case R_SPARC_WDISP30:
2802
        case R_SPARC_WDISP22:
2803
        case R_SPARC_WDISP19:
2804
        case R_SPARC_WDISP16:
2805
        case R_SPARC_8:
2806
        case R_SPARC_16:
2807
        case R_SPARC_32:
2808
        case R_SPARC_HI22:
2809
        case R_SPARC_22:
2810
        case R_SPARC_13:
2811
        case R_SPARC_LO10:
2812
        case R_SPARC_UA16:
2813
        case R_SPARC_UA32:
2814
        case R_SPARC_10:
2815
        case R_SPARC_11:
2816
        case R_SPARC_64:
2817
        case R_SPARC_OLO10:
2818
        case R_SPARC_HH22:
2819
        case R_SPARC_HM10:
2820
        case R_SPARC_LM22:
2821
        case R_SPARC_7:
2822
        case R_SPARC_5:
2823
        case R_SPARC_6:
2824
        case R_SPARC_HIX22:
2825
        case R_SPARC_LOX10:
2826
        case R_SPARC_H44:
2827
        case R_SPARC_M44:
2828
        case R_SPARC_L44:
2829
        case R_SPARC_UA64:
2830
        r_sparc_plt32:
2831
          if ((input_section->flags & SEC_ALLOC) == 0
2832
              || is_vxworks_tls)
2833
            break;
2834
 
2835
          if ((info->shared
2836
               && (h == NULL
2837
                   || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2838
                   || h->root.type != bfd_link_hash_undefweak)
2839
               && (! howto->pc_relative
2840
                   || (h != NULL
2841
                       && h->dynindx != -1
2842
                       && (! info->symbolic
2843
                           || !h->def_regular))))
2844
              || (!info->shared
2845
                  && h != NULL
2846
                  && h->dynindx != -1
2847
                  && !h->non_got_ref
2848
                  && ((h->def_dynamic
2849
                       && !h->def_regular)
2850
                      || h->root.type == bfd_link_hash_undefweak
2851
                      || h->root.type == bfd_link_hash_undefined)))
2852
            {
2853
              Elf_Internal_Rela outrel;
2854
              bfd_boolean skip, relocate = FALSE;
2855
 
2856
              /* When generating a shared object, these relocations
2857
                 are copied into the output file to be resolved at run
2858
                 time.  */
2859
 
2860
              BFD_ASSERT (sreloc != NULL);
2861
 
2862
              skip = FALSE;
2863
 
2864
              outrel.r_offset =
2865
                _bfd_elf_section_offset (output_bfd, info, input_section,
2866
                                         rel->r_offset);
2867
              if (outrel.r_offset == (bfd_vma) -1)
2868
                skip = TRUE;
2869
              else if (outrel.r_offset == (bfd_vma) -2)
2870
                skip = TRUE, relocate = TRUE;
2871
              outrel.r_offset += (input_section->output_section->vma
2872
                                  + input_section->output_offset);
2873
 
2874
              /* Optimize unaligned reloc usage now that we know where
2875
                 it finally resides.  */
2876
              switch (r_type)
2877
                {
2878
                case R_SPARC_16:
2879
                  if (outrel.r_offset & 1)
2880
                    r_type = R_SPARC_UA16;
2881
                  break;
2882
                case R_SPARC_UA16:
2883
                  if (!(outrel.r_offset & 1))
2884
                    r_type = R_SPARC_16;
2885
                  break;
2886
                case R_SPARC_32:
2887
                  if (outrel.r_offset & 3)
2888
                    r_type = R_SPARC_UA32;
2889
                  break;
2890
                case R_SPARC_UA32:
2891
                  if (!(outrel.r_offset & 3))
2892
                    r_type = R_SPARC_32;
2893
                  break;
2894
                case R_SPARC_64:
2895
                  if (outrel.r_offset & 7)
2896
                    r_type = R_SPARC_UA64;
2897
                  break;
2898
                case R_SPARC_UA64:
2899
                  if (!(outrel.r_offset & 7))
2900
                    r_type = R_SPARC_64;
2901
                  break;
2902
                case R_SPARC_DISP8:
2903
                case R_SPARC_DISP16:
2904
                case R_SPARC_DISP32:
2905
                case R_SPARC_DISP64:
2906
                  /* If the symbol is not dynamic, we should not keep
2907
                     a dynamic relocation.  But an .rela.* slot has been
2908
                     allocated for it, output R_SPARC_NONE.
2909
                     FIXME: Add code tracking needed dynamic relocs as
2910
                     e.g. i386 has.  */
2911
                  if (h->dynindx == -1)
2912
                    skip = TRUE, relocate = TRUE;
2913
                  break;
2914
                }
2915
 
2916
              if (skip)
2917
                memset (&outrel, 0, sizeof outrel);
2918
              /* h->dynindx may be -1 if the symbol was marked to
2919
                 become local.  */
2920
              else if (h != NULL && ! is_plt
2921
                       && ((! info->symbolic && h->dynindx != -1)
2922
                           || !h->def_regular))
2923
                {
2924
                  BFD_ASSERT (h->dynindx != -1);
2925
                  outrel.r_info = SPARC_ELF_R_INFO (htab, rel, h->dynindx, r_type);
2926
                  outrel.r_addend = rel->r_addend;
2927
                }
2928
              else
2929
                {
2930
                  if (r_type == R_SPARC_32 || r_type == R_SPARC_64)
2931
                    {
2932
                      outrel.r_info = SPARC_ELF_R_INFO (htab, NULL,
2933
                                                        0, R_SPARC_RELATIVE);
2934
                      outrel.r_addend = relocation + rel->r_addend;
2935
                    }
2936
                  else
2937
                    {
2938
                      long indx;
2939
 
2940
                      outrel.r_addend = relocation + rel->r_addend;
2941
 
2942
                      if (is_plt)
2943
                        sec = htab->splt;
2944
 
2945
                      if (bfd_is_abs_section (sec))
2946
                        indx = 0;
2947
                      else if (sec == NULL || sec->owner == NULL)
2948
                        {
2949
                          bfd_set_error (bfd_error_bad_value);
2950
                          return FALSE;
2951
                        }
2952
                      else
2953
                        {
2954
                          asection *osec;
2955
 
2956
                          /* We are turning this relocation into one
2957
                             against a section symbol.  It would be
2958
                             proper to subtract the symbol's value,
2959
                             osec->vma, from the emitted reloc addend,
2960
                             but ld.so expects buggy relocs.  */
2961
                          osec = sec->output_section;
2962
                          indx = elf_section_data (osec)->dynindx;
2963
 
2964
                          if (indx == 0)
2965
                            {
2966
                              osec = htab->elf.text_index_section;
2967
                              indx = elf_section_data (osec)->dynindx;
2968
                            }
2969
 
2970
                          /* FIXME: we really should be able to link non-pic
2971
                             shared libraries.  */
2972
                          if (indx == 0)
2973
                            {
2974
                              BFD_FAIL ();
2975
                              (*_bfd_error_handler)
2976
                                (_("%B: probably compiled without -fPIC?"),
2977
                                 input_bfd);
2978
                              bfd_set_error (bfd_error_bad_value);
2979
                              return FALSE;
2980
                            }
2981
                        }
2982
 
2983
                      outrel.r_info = SPARC_ELF_R_INFO (htab, rel, indx,
2984
                                                        r_type);
2985
                    }
2986
                }
2987
 
2988
              sparc_elf_append_rela (output_bfd, sreloc, &outrel);
2989
 
2990
              /* This reloc will be computed at runtime, so there's no
2991
                 need to do anything now.  */
2992
              if (! relocate)
2993
                continue;
2994
            }
2995
          break;
2996
 
2997
        case R_SPARC_TLS_GD_HI22:
2998
          if (! ABI_64_P (input_bfd)
2999
              && ! _bfd_sparc_elf_tdata (input_bfd)->has_tlsgd)
3000
            {
3001
              /* R_SPARC_REV32 used the same reloc number as
3002
                 R_SPARC_TLS_GD_HI22.  */
3003
              r_type = R_SPARC_REV32;
3004
              break;
3005
            }
3006
          /* Fall through */
3007
 
3008
        case R_SPARC_TLS_GD_LO10:
3009
        case R_SPARC_TLS_IE_HI22:
3010
        case R_SPARC_TLS_IE_LO10:
3011
          r_type = sparc_elf_tls_transition (info, input_bfd, r_type, h == NULL);
3012
          tls_type = GOT_UNKNOWN;
3013
          if (h == NULL && local_got_offsets)
3014
            tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3015
          else if (h != NULL)
3016
            {
3017
              tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3018
              if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3019
                switch (SPARC_ELF_R_TYPE (rel->r_info))
3020
                  {
3021
                  case R_SPARC_TLS_GD_HI22:
3022
                  case R_SPARC_TLS_IE_HI22:
3023
                    r_type = R_SPARC_TLS_LE_HIX22;
3024
                    break;
3025
                  default:
3026
                    r_type = R_SPARC_TLS_LE_LOX10;
3027
                    break;
3028
                  }
3029
            }
3030
          if (tls_type == GOT_TLS_IE)
3031
            switch (r_type)
3032
              {
3033
              case R_SPARC_TLS_GD_HI22:
3034
                r_type = R_SPARC_TLS_IE_HI22;
3035
                break;
3036
              case R_SPARC_TLS_GD_LO10:
3037
                r_type = R_SPARC_TLS_IE_LO10;
3038
                break;
3039
              }
3040
 
3041
          if (r_type == R_SPARC_TLS_LE_HIX22)
3042
            {
3043
              relocation = tpoff (info, relocation);
3044
              break;
3045
            }
3046
          if (r_type == R_SPARC_TLS_LE_LOX10)
3047
            {
3048
              /* Change add into xor.  */
3049
              relocation = tpoff (info, relocation);
3050
              bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
3051
                                                   contents + rel->r_offset)
3052
                                       | 0x80182000), contents + rel->r_offset);
3053
              break;
3054
            }
3055
 
3056
          if (h != NULL)
3057
            {
3058
              off = h->got.offset;
3059
              h->got.offset |= 1;
3060
            }
3061
          else
3062
            {
3063
              BFD_ASSERT (local_got_offsets != NULL);
3064
              off = local_got_offsets[r_symndx];
3065
              local_got_offsets[r_symndx] |= 1;
3066
            }
3067
 
3068
        r_sparc_tlsldm:
3069
          if (htab->sgot == NULL)
3070
            abort ();
3071
 
3072
          if ((off & 1) != 0)
3073
            off &= ~1;
3074
          else
3075
            {
3076
              Elf_Internal_Rela outrel;
3077
              int dr_type, indx;
3078
 
3079
              if (htab->srelgot == NULL)
3080
                abort ();
3081
 
3082
              SPARC_ELF_PUT_WORD (htab, output_bfd, 0, htab->sgot->contents + off);
3083
              outrel.r_offset = (htab->sgot->output_section->vma
3084
                                 + htab->sgot->output_offset + off);
3085
              indx = h && h->dynindx != -1 ? h->dynindx : 0;
3086
              if (r_type == R_SPARC_TLS_IE_HI22
3087
                  || r_type == R_SPARC_TLS_IE_LO10)
3088
                dr_type = SPARC_ELF_TPOFF_RELOC (htab);
3089
              else
3090
                dr_type = SPARC_ELF_DTPMOD_RELOC (htab);
3091
              if (dr_type == SPARC_ELF_TPOFF_RELOC (htab) && indx == 0)
3092
                outrel.r_addend = relocation - dtpoff_base (info);
3093
              else
3094
                outrel.r_addend = 0;
3095
              outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx, dr_type);
3096
              sparc_elf_append_rela (output_bfd, htab->srelgot, &outrel);
3097
 
3098
              if (r_type == R_SPARC_TLS_GD_HI22
3099
                  || r_type == R_SPARC_TLS_GD_LO10)
3100
                {
3101
                  if (indx == 0)
3102
                    {
3103
                      BFD_ASSERT (! unresolved_reloc);
3104
                      SPARC_ELF_PUT_WORD (htab, output_bfd,
3105
                                          relocation - dtpoff_base (info),
3106
                                          (htab->sgot->contents + off
3107
                                           + SPARC_ELF_WORD_BYTES (htab)));
3108
                    }
3109
                  else
3110
                    {
3111
                      SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3112
                                          (htab->sgot->contents + off
3113
                                           + SPARC_ELF_WORD_BYTES (htab)));
3114
                      outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, indx,
3115
                                                        SPARC_ELF_DTPOFF_RELOC (htab));
3116
                      outrel.r_offset += SPARC_ELF_WORD_BYTES (htab);
3117
                      sparc_elf_append_rela (output_bfd, htab->srelgot,
3118
                                             &outrel);
3119
                    }
3120
                }
3121
              else if (dr_type == SPARC_ELF_DTPMOD_RELOC (htab))
3122
                {
3123
                  SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3124
                                      (htab->sgot->contents + off
3125
                                       + SPARC_ELF_WORD_BYTES (htab)));
3126
                }
3127
            }
3128
 
3129
          if (off >= (bfd_vma) -2)
3130
            abort ();
3131
 
3132
          relocation = htab->sgot->output_offset + off - got_base;
3133
          unresolved_reloc = FALSE;
3134
          howto = _bfd_sparc_elf_howto_table + r_type;
3135
          break;
3136
 
3137
        case R_SPARC_TLS_LDM_HI22:
3138
        case R_SPARC_TLS_LDM_LO10:
3139
          if (! info->shared)
3140
            {
3141
              bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3142
              continue;
3143
            }
3144
          off = htab->tls_ldm_got.offset;
3145
          htab->tls_ldm_got.offset |= 1;
3146
          goto r_sparc_tlsldm;
3147
 
3148
        case R_SPARC_TLS_LDO_HIX22:
3149
        case R_SPARC_TLS_LDO_LOX10:
3150
          if (info->shared)
3151
            {
3152
              relocation -= dtpoff_base (info);
3153
              break;
3154
            }
3155
 
3156
          r_type = (r_type == R_SPARC_TLS_LDO_HIX22
3157
                    ? R_SPARC_TLS_LE_HIX22 : R_SPARC_TLS_LE_LOX10);
3158
          /* Fall through.  */
3159
 
3160
        case R_SPARC_TLS_LE_HIX22:
3161
        case R_SPARC_TLS_LE_LOX10:
3162
          if (info->shared)
3163
            {
3164
              Elf_Internal_Rela outrel;
3165
              bfd_boolean skip, relocate = FALSE;
3166
 
3167
              BFD_ASSERT (sreloc != NULL);
3168
              skip = FALSE;
3169
              outrel.r_offset =
3170
                _bfd_elf_section_offset (output_bfd, info, input_section,
3171
                                         rel->r_offset);
3172
              if (outrel.r_offset == (bfd_vma) -1)
3173
                skip = TRUE;
3174
              else if (outrel.r_offset == (bfd_vma) -2)
3175
                skip = TRUE, relocate = TRUE;
3176
              outrel.r_offset += (input_section->output_section->vma
3177
                                  + input_section->output_offset);
3178
              if (skip)
3179
                memset (&outrel, 0, sizeof outrel);
3180
              else
3181
                {
3182
                  outrel.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, r_type);
3183
                  outrel.r_addend = relocation - dtpoff_base (info)
3184
                                    + rel->r_addend;
3185
                }
3186
 
3187
              sparc_elf_append_rela (output_bfd, sreloc, &outrel);
3188
              continue;
3189
            }
3190
          relocation = tpoff (info, relocation);
3191
          break;
3192
 
3193
        case R_SPARC_TLS_LDM_CALL:
3194
          if (! info->shared)
3195
            {
3196
              /* mov %g0, %o0 */
3197
              bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
3198
              continue;
3199
            }
3200
          /* Fall through */
3201
 
3202
        case R_SPARC_TLS_GD_CALL:
3203
          tls_type = GOT_UNKNOWN;
3204
          if (h == NULL && local_got_offsets)
3205
            tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3206
          else if (h != NULL)
3207
            tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3208
          if (! info->shared
3209
              || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
3210
            {
3211
              bfd_vma insn;
3212
 
3213
              if (!info->shared && (h == NULL || h->dynindx == -1))
3214
                {
3215
                  /* GD -> LE */
3216
                  bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3217
                  continue;
3218
                }
3219
 
3220
              /* GD -> IE */
3221
              if (rel + 1 < relend
3222
                  && SPARC_ELF_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
3223
                  && rel[1].r_offset == rel->r_offset + 4
3224
                  && SPARC_ELF_R_SYMNDX (htab, rel[1].r_info) == r_symndx
3225
                  && (((insn = bfd_get_32 (input_bfd,
3226
                                           contents + rel[1].r_offset))
3227
                       >> 25) & 0x1f) == 8)
3228
                {
3229
                  /* We have
3230
                     call __tls_get_addr, %tgd_call(foo)
3231
                      add %reg1, %reg2, %o0, %tgd_add(foo)
3232
                     and change it into IE:
3233
                     {ld,ldx} [%reg1 + %reg2], %o0, %tie_ldx(foo)
3234
                     add %g7, %o0, %o0, %tie_add(foo).
3235
                     add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
3236
                     ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2,
3237
                     ldx is 0xc0580000 | (rd << 25) | (rs1 << 14) | rs2.  */
3238
                  bfd_put_32 (output_bfd, insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000),
3239
                              contents + rel->r_offset);
3240
                  bfd_put_32 (output_bfd, 0x9001c008,
3241
                              contents + rel->r_offset + 4);
3242
                  rel++;
3243
                  continue;
3244
                }
3245
 
3246
              bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
3247
              continue;
3248
            }
3249
 
3250
          h = (struct elf_link_hash_entry *)
3251
              bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
3252
                                    FALSE, TRUE);
3253
          BFD_ASSERT (h != NULL);
3254
          r_type = R_SPARC_WPLT30;
3255
          howto = _bfd_sparc_elf_howto_table + r_type;
3256
          goto r_sparc_wplt30;
3257
 
3258
        case R_SPARC_TLS_GD_ADD:
3259
          tls_type = GOT_UNKNOWN;
3260
          if (h == NULL && local_got_offsets)
3261
            tls_type = _bfd_sparc_elf_local_got_tls_type (input_bfd) [r_symndx];
3262
          else if (h != NULL)
3263
            tls_type = _bfd_sparc_elf_hash_entry(h)->tls_type;
3264
          if (! info->shared || tls_type == GOT_TLS_IE)
3265
            {
3266
              /* add %reg1, %reg2, %reg3, %tgd_add(foo)
3267
                 changed into IE:
3268
                 {ld,ldx} [%reg1 + %reg2], %reg3, %tie_ldx(foo)
3269
                 or LE:
3270
                 add %g7, %reg2, %reg3.  */
3271
              bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3272
              if ((h != NULL && h->dynindx != -1) || info->shared)
3273
                relocation = insn | (ABI_64_P (output_bfd) ? 0xc0580000 : 0xc0000000);
3274
              else
3275
                relocation = (insn & ~0x7c000) | 0x1c000;
3276
              bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3277
            }
3278
          continue;
3279
 
3280
        case R_SPARC_TLS_LDM_ADD:
3281
          if (! info->shared)
3282
            bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
3283
          continue;
3284
 
3285
        case R_SPARC_TLS_LDO_ADD:
3286
          if (! info->shared)
3287
            {
3288
              /* Change rs1 into %g7.  */
3289
              bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3290
              insn = (insn & ~0x7c000) | 0x1c000;
3291
              bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3292
            }
3293
          continue;
3294
 
3295
        case R_SPARC_GOTDATA_OP:
3296
          /* We don't support gotdata code transformation optimizations
3297
             yet, so simply leave the sequence as-is.  */
3298
          continue;
3299
 
3300
        case R_SPARC_TLS_IE_LD:
3301
        case R_SPARC_TLS_IE_LDX:
3302
          if (! info->shared && (h == NULL || h->dynindx == -1))
3303
            {
3304
              bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3305
              int rs2 = insn & 0x1f;
3306
              int rd = (insn >> 25) & 0x1f;
3307
 
3308
              if (rs2 == rd)
3309
                relocation = SPARC_NOP;
3310
              else
3311
                relocation = 0x80100000 | (insn & 0x3e00001f);
3312
              bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
3313
            }
3314
          continue;
3315
 
3316
        case R_SPARC_TLS_IE_ADD:
3317
          /* Totally useless relocation.  */
3318
          continue;
3319
 
3320
        case R_SPARC_TLS_DTPOFF32:
3321
        case R_SPARC_TLS_DTPOFF64:
3322
          relocation -= dtpoff_base (info);
3323
          break;
3324
 
3325
        default:
3326
          break;
3327
        }
3328
 
3329
      /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3330
         because such sections are not SEC_ALLOC and thus ld.so will
3331
         not process them.  */
3332
      if (unresolved_reloc
3333
          && !((input_section->flags & SEC_DEBUGGING) != 0
3334
               && h->def_dynamic))
3335
        (*_bfd_error_handler)
3336
          (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3337
           input_bfd,
3338
           input_section,
3339
           (long) rel->r_offset,
3340
           howto->name,
3341
           h->root.root.string);
3342
 
3343
      r = bfd_reloc_continue;
3344
      if (r_type == R_SPARC_OLO10)
3345
        {
3346
            bfd_vma x;
3347
 
3348
            if (! ABI_64_P (output_bfd))
3349
              abort ();
3350
 
3351
            relocation += rel->r_addend;
3352
            relocation = (relocation & 0x3ff) + ELF64_R_TYPE_DATA (rel->r_info);
3353
 
3354
            x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3355
            x = (x & ~(bfd_vma) 0x1fff) | (relocation & 0x1fff);
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_WDISP16)
3364
        {
3365
          bfd_vma x;
3366
 
3367
          relocation += rel->r_addend;
3368
          relocation -= (input_section->output_section->vma
3369
                         + input_section->output_offset);
3370
          relocation -= rel->r_offset;
3371
 
3372
          x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3373
          x |= ((((relocation >> 2) & 0xc000) << 6)
3374
                | ((relocation >> 2) & 0x3fff));
3375
          bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3376
 
3377
          r = bfd_check_overflow (howto->complain_on_overflow,
3378
                                  howto->bitsize, howto->rightshift,
3379
                                  bfd_arch_bits_per_address (input_bfd),
3380
                                  relocation);
3381
        }
3382
      else if (r_type == R_SPARC_REV32)
3383
        {
3384
          bfd_vma x;
3385
 
3386
          relocation = relocation + rel->r_addend;
3387
 
3388
          x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3389
          x = x + relocation;
3390
          bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
3391
          r = bfd_reloc_ok;
3392
        }
3393
      else if (r_type == R_SPARC_TLS_LDO_HIX22
3394
               || r_type == R_SPARC_TLS_LE_HIX22)
3395
        {
3396
          bfd_vma x;
3397
 
3398
          relocation += rel->r_addend;
3399
          if (r_type == R_SPARC_TLS_LE_HIX22)
3400
            relocation ^= MINUS_ONE;
3401
 
3402
          x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3403
          x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3404
          bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3405
          r = bfd_reloc_ok;
3406
        }
3407
      else if (r_type == R_SPARC_TLS_LDO_LOX10
3408
               || r_type == R_SPARC_TLS_LE_LOX10)
3409
        {
3410
          bfd_vma x;
3411
 
3412
          relocation += rel->r_addend;
3413
          relocation &= 0x3ff;
3414
          if (r_type == R_SPARC_TLS_LE_LOX10)
3415
            relocation |= 0x1c00;
3416
 
3417
          x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3418
          x = (x & ~(bfd_vma) 0x1fff) | relocation;
3419
          bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3420
 
3421
          r = bfd_reloc_ok;
3422
        }
3423
      else if (r_type == R_SPARC_HIX22)
3424
        {
3425
          bfd_vma x;
3426
 
3427
          relocation += rel->r_addend;
3428
          relocation = relocation ^ MINUS_ONE;
3429
 
3430
          x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3431
          x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
3432
          bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3433
 
3434
          r = bfd_check_overflow (howto->complain_on_overflow,
3435
                                  howto->bitsize, howto->rightshift,
3436
                                  bfd_arch_bits_per_address (input_bfd),
3437
                                  relocation);
3438
        }
3439
      else if (r_type == R_SPARC_LOX10)
3440
        {
3441
          bfd_vma x;
3442
 
3443
          relocation += rel->r_addend;
3444
          relocation = (relocation & 0x3ff) | 0x1c00;
3445
 
3446
          x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3447
          x = (x & ~(bfd_vma) 0x1fff) | relocation;
3448
          bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3449
 
3450
          r = bfd_reloc_ok;
3451
        }
3452
      else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
3453
               && sec_do_relax (input_section)
3454
               && rel->r_offset + 4 < input_section->size)
3455
        {
3456
#define G0              0
3457
#define O7              15
3458
#define XCC             (2 << 20)
3459
#define COND(x)         (((x)&0xf)<<25)
3460
#define CONDA           COND(0x8)
3461
#define INSN_BPA        (F2(0,1) | CONDA | BPRED | XCC)
3462
#define INSN_BA         (F2(0,2) | CONDA)
3463
#define INSN_OR         F3(2, 0x2, 0)
3464
#define INSN_NOP        F2(0,4)
3465
 
3466
          bfd_vma x, y;
3467
 
3468
          /* If the instruction is a call with either:
3469
             restore
3470
             arithmetic instruction with rd == %o7
3471
             where rs1 != %o7 and rs2 if it is register != %o7
3472
             then we can optimize if the call destination is near
3473
             by changing the call into a branch always.  */
3474
          x = bfd_get_32 (input_bfd, contents + rel->r_offset);
3475
          y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
3476
          if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
3477
            {
3478
              if (((y & OP3(~0)) == OP3(0x3d) /* restore */
3479
                   || ((y & OP3(0x28)) == 0 /* arithmetic */
3480
                       && (y & RD(~0)) == RD(O7)))
3481
                  && (y & RS1(~0)) != RS1(O7)
3482
                  && ((y & F3I(~0))
3483
                      || (y & RS2(~0)) != RS2(O7)))
3484
                {
3485
                  bfd_vma reloc;
3486
 
3487
                  reloc = relocation + rel->r_addend - rel->r_offset;
3488
                  reloc -= (input_section->output_section->vma
3489
                            + input_section->output_offset);
3490
 
3491
                  /* Ensure the branch fits into simm22.  */
3492
                  if ((reloc & 3) == 0
3493
                      && ((reloc & ~(bfd_vma)0x7fffff) == 0
3494
                          || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
3495
                    {
3496
                      reloc >>= 2;
3497
 
3498
                      /* Check whether it fits into simm19.  */
3499
                      if (((reloc & 0x3c0000) == 0
3500
                           || (reloc & 0x3c0000) == 0x3c0000)
3501
                          && (ABI_64_P (output_bfd)
3502
                              || elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
3503
                        x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
3504
                      else
3505
                        x = INSN_BA | (reloc & 0x3fffff); /* ba */
3506
                      bfd_put_32 (input_bfd, x, contents + rel->r_offset);
3507
                      r = bfd_reloc_ok;
3508
                      if (rel->r_offset >= 4
3509
                          && (y & (0xffffffff ^ RS1(~0)))
3510
                             == (INSN_OR | RD(O7) | RS2(G0)))
3511
                        {
3512
                          bfd_vma z;
3513
                          unsigned int reg;
3514
 
3515
                          z = bfd_get_32 (input_bfd,
3516
                                          contents + rel->r_offset - 4);
3517
                          if ((z & (0xffffffff ^ RD(~0)))
3518
                              != (INSN_OR | RS1(O7) | RS2(G0)))
3519
                            break;
3520
 
3521
                          /* The sequence was
3522
                             or %o7, %g0, %rN
3523
                             call foo
3524
                             or %rN, %g0, %o7
3525
 
3526
                             If call foo was replaced with ba, replace
3527
                             or %rN, %g0, %o7 with nop.  */
3528
 
3529
                          reg = (y & RS1(~0)) >> 14;
3530
                          if (reg != ((z & RD(~0)) >> 25)
3531
                              || reg == G0 || reg == O7)
3532
                            break;
3533
 
3534
                          bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
3535
                                      contents + rel->r_offset + 4);
3536
                        }
3537
 
3538
                    }
3539
                }
3540
            }
3541
        }
3542
 
3543
      if (r == bfd_reloc_continue)
3544
        r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3545
                                      contents, rel->r_offset,
3546
                                      relocation, rel->r_addend);
3547
 
3548
      if (r != bfd_reloc_ok)
3549
        {
3550
          switch (r)
3551
            {
3552
            default:
3553
            case bfd_reloc_outofrange:
3554
              abort ();
3555
            case bfd_reloc_overflow:
3556
              {
3557
                const char *name;
3558
 
3559
                /* The Solaris native linker silently disregards overflows.
3560
                   We don't, but this breaks stabs debugging info, whose
3561
                   relocations are only 32-bits wide.  Ignore overflows in
3562
                   this case and also for discarded entries.  */
3563
                if ((r_type == R_SPARC_32 || r_type == R_SPARC_DISP32)
3564
                    && (((input_section->flags & SEC_DEBUGGING) != 0
3565
                         && strcmp (bfd_section_name (input_bfd,
3566
                                                      input_section),
3567
                                    ".stab") == 0)
3568
                        || _bfd_elf_section_offset (output_bfd, info,
3569
                                                    input_section,
3570
                                                    rel->r_offset)
3571
                             == (bfd_vma)-1))
3572
                  break;
3573
 
3574
                if (h != NULL)
3575
                  {
3576
                    /* Assume this is a call protected by other code that
3577
                       detect the symbol is undefined.  If this is the case,
3578
                       we can safely ignore the overflow.  If not, the
3579
                       program is hosed anyway, and a little warning isn't
3580
                       going to help.  */
3581
                    if (h->root.type == bfd_link_hash_undefweak
3582
                        && howto->pc_relative)
3583
                      break;
3584
 
3585
                    name = NULL;
3586
                  }
3587
                else
3588
                  {
3589
                    name = bfd_elf_string_from_elf_section (input_bfd,
3590
                                                            symtab_hdr->sh_link,
3591
                                                            sym->st_name);
3592
                    if (name == NULL)
3593
                      return FALSE;
3594
                    if (*name == '\0')
3595
                      name = bfd_section_name (input_bfd, sec);
3596
                  }
3597
                if (! ((*info->callbacks->reloc_overflow)
3598
                       (info, (h ? &h->root : NULL), name, howto->name,
3599
                        (bfd_vma) 0, input_bfd, input_section,
3600
                        rel->r_offset)))
3601
                  return FALSE;
3602
              }
3603
              break;
3604
            }
3605
        }
3606
    }
3607
 
3608
  return TRUE;
3609
}
3610
 
3611
/* Build a VxWorks PLT entry.  PLT_INDEX is the index of the PLT entry
3612
   and PLT_OFFSET is the byte offset from the start of .plt.  GOT_OFFSET
3613
   is the offset of the associated .got.plt entry from
3614
   _GLOBAL_OFFSET_TABLE_.  */
3615
 
3616
static void
3617
sparc_vxworks_build_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
3618
                               bfd_vma plt_offset, bfd_vma plt_index,
3619
                               bfd_vma got_offset)
3620
{
3621
  bfd_vma got_base;
3622
  const bfd_vma *plt_entry;
3623
  struct _bfd_sparc_elf_link_hash_table *htab;
3624
  bfd_byte *loc;
3625
  Elf_Internal_Rela rela;
3626
 
3627
  htab = _bfd_sparc_elf_hash_table (info);
3628
  if (info->shared)
3629
    {
3630
      plt_entry = sparc_vxworks_shared_plt_entry;
3631
      got_base = 0;
3632
    }
3633
  else
3634
    {
3635
      plt_entry = sparc_vxworks_exec_plt_entry;
3636
      got_base = (htab->elf.hgot->root.u.def.value
3637
                  + htab->elf.hgot->root.u.def.section->output_offset
3638
                  + htab->elf.hgot->root.u.def.section->output_section->vma);
3639
    }
3640
 
3641
  /* Fill in the entry in the procedure linkage table.  */
3642
  bfd_put_32 (output_bfd, plt_entry[0] + ((got_base + got_offset) >> 10),
3643
              htab->splt->contents + plt_offset);
3644
  bfd_put_32 (output_bfd, plt_entry[1] + ((got_base + got_offset) & 0x3ff),
3645
              htab->splt->contents + plt_offset + 4);
3646
  bfd_put_32 (output_bfd, plt_entry[2],
3647
              htab->splt->contents + plt_offset + 8);
3648
  bfd_put_32 (output_bfd, plt_entry[3],
3649
              htab->splt->contents + plt_offset + 12);
3650
  bfd_put_32 (output_bfd, plt_entry[4],
3651
              htab->splt->contents + plt_offset + 16);
3652
  bfd_put_32 (output_bfd, plt_entry[5] + (plt_index >> 10),
3653
              htab->splt->contents + plt_offset + 20);
3654
  /* PC-relative displacement for a branch to the start of
3655
     the PLT section.  */
3656
  bfd_put_32 (output_bfd, plt_entry[6] + (((-plt_offset - 24) >> 2)
3657
                                          & 0x003fffff),
3658
              htab->splt->contents + plt_offset + 24);
3659
  bfd_put_32 (output_bfd, plt_entry[7] + (plt_index & 0x3ff),
3660
              htab->splt->contents + plt_offset + 28);
3661
 
3662
  /* Fill in the .got.plt entry, pointing initially at the
3663
     second half of the PLT entry.  */
3664
  BFD_ASSERT (htab->sgotplt != NULL);
3665
  bfd_put_32 (output_bfd,
3666
              htab->splt->output_section->vma
3667
              + htab->splt->output_offset
3668
              + plt_offset + 20,
3669
              htab->sgotplt->contents + got_offset);
3670
 
3671
  /* Add relocations to .rela.plt.unloaded.  */
3672
  if (!info->shared)
3673
    {
3674
      loc = (htab->srelplt2->contents
3675
             + (2 + 3 * plt_index) * sizeof (Elf32_External_Rela));
3676
 
3677
      /* Relocate the initial sethi.  */
3678
      rela.r_offset = (htab->splt->output_section->vma
3679
                       + htab->splt->output_offset
3680
                       + plt_offset);
3681
      rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
3682
      rela.r_addend = got_offset;
3683
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3684
      loc += sizeof (Elf32_External_Rela);
3685
 
3686
      /* Likewise the following or.  */
3687
      rela.r_offset += 4;
3688
      rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
3689
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3690
      loc += sizeof (Elf32_External_Rela);
3691
 
3692
      /* Relocate the .got.plt entry.  */
3693
      rela.r_offset = (htab->sgotplt->output_section->vma
3694
                       + htab->sgotplt->output_offset
3695
                       + got_offset);
3696
      rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
3697
      rela.r_addend = plt_offset + 20;
3698
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3699
    }
3700
}
3701
 
3702
/* Finish up dynamic symbol handling.  We set the contents of various
3703
   dynamic sections here.  */
3704
 
3705
bfd_boolean
3706
_bfd_sparc_elf_finish_dynamic_symbol (bfd *output_bfd,
3707
                                      struct bfd_link_info *info,
3708
                                      struct elf_link_hash_entry *h,
3709
                                      Elf_Internal_Sym *sym)
3710
{
3711
  bfd *dynobj;
3712
  struct _bfd_sparc_elf_link_hash_table *htab;
3713
  const struct elf_backend_data *bed;
3714
 
3715
  htab = _bfd_sparc_elf_hash_table (info);
3716
  dynobj = htab->elf.dynobj;
3717
  bed = get_elf_backend_data (output_bfd);
3718
 
3719
  if (h->plt.offset != (bfd_vma) -1)
3720
    {
3721
      asection *splt;
3722
      asection *srela;
3723
      Elf_Internal_Rela rela;
3724
      bfd_byte *loc;
3725
      bfd_vma r_offset, got_offset;
3726
      int rela_index;
3727
 
3728
      /* This symbol has an entry in the PLT.  Set it up.  */
3729
 
3730
      BFD_ASSERT (h->dynindx != -1);
3731
 
3732
      splt = htab->splt;
3733
      srela = htab->srelplt;
3734
      BFD_ASSERT (splt != NULL && srela != NULL);
3735
 
3736
      /* Fill in the entry in the .rela.plt section.  */
3737
      if (htab->is_vxworks)
3738
        {
3739
          /* Work out the index of this PLT entry.  */
3740
          rela_index = ((h->plt.offset - htab->plt_header_size)
3741
                        / htab->plt_entry_size);
3742
 
3743
          /* Calculate the offset of the associated .got.plt entry.
3744
             The first three entries are reserved.  */
3745
          got_offset = (rela_index + 3) * 4;
3746
 
3747
          sparc_vxworks_build_plt_entry (output_bfd, info, h->plt.offset,
3748
                                         rela_index, got_offset);
3749
 
3750
 
3751
          /* On VxWorks, the relocation points to the .got.plt entry,
3752
             not the .plt entry.  */
3753
          rela.r_offset = (htab->sgotplt->output_section->vma
3754
                           + htab->sgotplt->output_offset
3755
                           + got_offset);
3756
          rela.r_addend = 0;
3757
        }
3758
      else
3759
        {
3760
          /* Fill in the entry in the procedure linkage table.  */
3761
          rela_index = SPARC_ELF_BUILD_PLT_ENTRY (htab, output_bfd, splt,
3762
                                                  h->plt.offset, splt->size,
3763
                                                  &r_offset);
3764
 
3765
          rela.r_offset = r_offset
3766
            + (splt->output_section->vma + splt->output_offset);
3767
          if (! ABI_64_P (output_bfd)
3768
              || h->plt.offset < (PLT64_LARGE_THRESHOLD * PLT64_ENTRY_SIZE))
3769
            {
3770
              rela.r_addend = 0;
3771
            }
3772
          else
3773
            {
3774
              rela.r_addend = (-(h->plt.offset + 4)
3775
                               - splt->output_section->vma
3776
                               - splt->output_offset);
3777
            }
3778
        }
3779
      rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_JMP_SLOT);
3780
 
3781
      /* Adjust for the first 4 reserved elements in the .plt section
3782
         when setting the offset in the .rela.plt section.
3783
         Sun forgot to read their own ABI and copied elf32-sparc behaviour,
3784
         thus .plt[4] has corresponding .rela.plt[0] and so on.  */
3785
 
3786
      loc = srela->contents;
3787
      loc += rela_index * bed->s->sizeof_rela;
3788
      bed->s->swap_reloca_out (output_bfd, &rela, loc);
3789
 
3790
      if (!h->def_regular)
3791
        {
3792
          /* Mark the symbol as undefined, rather than as defined in
3793
             the .plt section.  Leave the value alone.  */
3794
          sym->st_shndx = SHN_UNDEF;
3795
          /* If the symbol is weak, we do need to clear the value.
3796
             Otherwise, the PLT entry would provide a definition for
3797
             the symbol even if the symbol wasn't defined anywhere,
3798
             and so the symbol would never be NULL.  */
3799
          if (!h->ref_regular_nonweak)
3800
            sym->st_value = 0;
3801
        }
3802
    }
3803
 
3804
  if (h->got.offset != (bfd_vma) -1
3805
      && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3806
      && _bfd_sparc_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3807
    {
3808
      asection *sgot;
3809
      asection *srela;
3810
      Elf_Internal_Rela rela;
3811
 
3812
      /* This symbol has an entry in the GOT.  Set it up.  */
3813
 
3814
      sgot = htab->sgot;
3815
      srela = htab->srelgot;
3816
      BFD_ASSERT (sgot != NULL && srela != NULL);
3817
 
3818
      rela.r_offset = (sgot->output_section->vma
3819
                       + sgot->output_offset
3820
                       + (h->got.offset &~ (bfd_vma) 1));
3821
 
3822
      /* If this is a -Bsymbolic link, and the symbol is defined
3823
         locally, we just want to emit a RELATIVE reloc.  Likewise if
3824
         the symbol was forced to be local because of a version file.
3825
         The entry in the global offset table will already have been
3826
         initialized in the relocate_section function.  */
3827
      if (info->shared
3828
          && (info->symbolic || h->dynindx == -1)
3829
          && h->def_regular)
3830
        {
3831
          asection *sec = h->root.u.def.section;
3832
          rela.r_info = SPARC_ELF_R_INFO (htab, NULL, 0, R_SPARC_RELATIVE);
3833
          rela.r_addend = (h->root.u.def.value
3834
                           + sec->output_section->vma
3835
                           + sec->output_offset);
3836
        }
3837
      else
3838
        {
3839
          rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_GLOB_DAT);
3840
          rela.r_addend = 0;
3841
        }
3842
 
3843
      SPARC_ELF_PUT_WORD (htab, output_bfd, 0,
3844
                          sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3845
      sparc_elf_append_rela (output_bfd, srela, &rela);
3846
    }
3847
 
3848
  if (h->needs_copy)
3849
    {
3850
      asection *s;
3851
      Elf_Internal_Rela rela;
3852
 
3853
      /* This symbols needs a copy reloc.  Set it up.  */
3854
      BFD_ASSERT (h->dynindx != -1);
3855
 
3856
      s = bfd_get_section_by_name (h->root.u.def.section->owner,
3857
                                   ".rela.bss");
3858
      BFD_ASSERT (s != NULL);
3859
 
3860
      rela.r_offset = (h->root.u.def.value
3861
                       + h->root.u.def.section->output_section->vma
3862
                       + h->root.u.def.section->output_offset);
3863
      rela.r_info = SPARC_ELF_R_INFO (htab, NULL, h->dynindx, R_SPARC_COPY);
3864
      rela.r_addend = 0;
3865
      sparc_elf_append_rela (output_bfd, s, &rela);
3866
    }
3867
 
3868
  /* Mark some specially defined symbols as absolute.  On VxWorks,
3869
     _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the
3870
     ".got" section.  Likewise _PROCEDURE_LINKAGE_TABLE_ and ".plt".  */
3871
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3872
      || (!htab->is_vxworks
3873
          && (h == htab->elf.hgot || h == htab->elf.hplt)))
3874
    sym->st_shndx = SHN_ABS;
3875
 
3876
  return TRUE;
3877
}
3878
 
3879
/* Finish up the dynamic sections.  */
3880
 
3881
static bfd_boolean
3882
sparc_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3883
                  bfd *dynobj, asection *sdyn,
3884
                  asection *splt ATTRIBUTE_UNUSED)
3885
{
3886
  struct _bfd_sparc_elf_link_hash_table *htab;
3887
  const struct elf_backend_data *bed;
3888
  bfd_byte *dyncon, *dynconend;
3889
  size_t dynsize;
3890
  int stt_regidx = -1;
3891
  bfd_boolean abi_64_p;
3892
 
3893
  htab = _bfd_sparc_elf_hash_table (info);
3894
  bed = get_elf_backend_data (output_bfd);
3895
  dynsize = bed->s->sizeof_dyn;
3896
  dynconend = sdyn->contents + sdyn->size;
3897
  abi_64_p = ABI_64_P (output_bfd);
3898
  for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
3899
    {
3900
      Elf_Internal_Dyn dyn;
3901
      const char *name;
3902
      bfd_boolean size;
3903
 
3904
      bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
3905
 
3906
      if (htab->is_vxworks && dyn.d_tag == DT_RELASZ)
3907
        {
3908
          /* On VxWorks, DT_RELASZ should not include the relocations
3909
             in .rela.plt.  */
3910
          if (htab->srelplt)
3911
            {
3912
              dyn.d_un.d_val -= htab->srelplt->size;
3913
              bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3914
            }
3915
        }
3916
      else if (htab->is_vxworks && dyn.d_tag == DT_PLTGOT)
3917
        {
3918
          /* On VxWorks, DT_PLTGOT should point to the start of the GOT,
3919
             not to the start of the PLT.  */
3920
          if (htab->sgotplt)
3921
            {
3922
              dyn.d_un.d_val = (htab->sgotplt->output_section->vma
3923
                                + htab->sgotplt->output_offset);
3924
              bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3925
            }
3926
        }
3927
      else if (htab->is_vxworks
3928
               && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
3929
        bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3930
      else if (abi_64_p && dyn.d_tag == DT_SPARC_REGISTER)
3931
        {
3932
          if (stt_regidx == -1)
3933
            {
3934
              stt_regidx =
3935
                _bfd_elf_link_lookup_local_dynindx (info, output_bfd, -1);
3936
              if (stt_regidx == -1)
3937
                return FALSE;
3938
            }
3939
          dyn.d_un.d_val = stt_regidx++;
3940
          bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3941
        }
3942
      else
3943
        {
3944
          switch (dyn.d_tag)
3945
            {
3946
            case DT_PLTGOT:   name = ".plt"; size = FALSE; break;
3947
            case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3948
            case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
3949
            default:          name = NULL; size = FALSE; break;
3950
            }
3951
 
3952
          if (name != NULL)
3953
            {
3954
              asection *s;
3955
 
3956
              s = bfd_get_section_by_name (output_bfd, name);
3957
              if (s == NULL)
3958
                dyn.d_un.d_val = 0;
3959
              else
3960
                {
3961
                  if (! size)
3962
                    dyn.d_un.d_ptr = s->vma;
3963
                  else
3964
                    dyn.d_un.d_val = s->size;
3965
                }
3966
              bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
3967
            }
3968
        }
3969
    }
3970
  return TRUE;
3971
}
3972
 
3973
/* Install the first PLT entry in a VxWorks executable and make sure that
3974
   .rela.plt.unloaded relocations have the correct symbol indexes.  */
3975
 
3976
static void
3977
sparc_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
3978
{
3979
  struct _bfd_sparc_elf_link_hash_table *htab;
3980
  Elf_Internal_Rela rela;
3981
  bfd_vma got_base;
3982
  bfd_byte *loc;
3983
 
3984
  htab = _bfd_sparc_elf_hash_table (info);
3985
 
3986
  /* Calculate the absolute value of _GLOBAL_OFFSET_TABLE_.  */
3987
  got_base = (htab->elf.hgot->root.u.def.section->output_section->vma
3988
              + htab->elf.hgot->root.u.def.section->output_offset
3989
              + htab->elf.hgot->root.u.def.value);
3990
 
3991
  /* Install the initial PLT entry.  */
3992
  bfd_put_32 (output_bfd,
3993
              sparc_vxworks_exec_plt0_entry[0] + ((got_base + 8) >> 10),
3994
              htab->splt->contents);
3995
  bfd_put_32 (output_bfd,
3996
              sparc_vxworks_exec_plt0_entry[1] + ((got_base + 8) & 0x3ff),
3997
              htab->splt->contents + 4);
3998
  bfd_put_32 (output_bfd,
3999
              sparc_vxworks_exec_plt0_entry[2],
4000
              htab->splt->contents + 8);
4001
  bfd_put_32 (output_bfd,
4002
              sparc_vxworks_exec_plt0_entry[3],
4003
              htab->splt->contents + 12);
4004
  bfd_put_32 (output_bfd,
4005
              sparc_vxworks_exec_plt0_entry[4],
4006
              htab->splt->contents + 16);
4007
 
4008
  loc = htab->srelplt2->contents;
4009
 
4010
  /* Add an unloaded relocation for the initial entry's "sethi".  */
4011
  rela.r_offset = (htab->splt->output_section->vma
4012
                   + htab->splt->output_offset);
4013
  rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4014
  rela.r_addend = 8;
4015
  bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4016
  loc += sizeof (Elf32_External_Rela);
4017
 
4018
  /* Likewise the following "or".  */
4019
  rela.r_offset += 4;
4020
  rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4021
  bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4022
  loc += sizeof (Elf32_External_Rela);
4023
 
4024
  /* Fix up the remaining .rela.plt.unloaded relocations.  They may have
4025
     the wrong symbol index for _G_O_T_ or _P_L_T_ depending on the order
4026
     in which symbols were output.  */
4027
  while (loc < htab->srelplt2->contents + htab->srelplt2->size)
4028
    {
4029
      Elf_Internal_Rela rel;
4030
 
4031
      /* The entry's initial "sethi" (against _G_O_T_).  */
4032
      bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4033
      rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_HI22);
4034
      bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4035
      loc += sizeof (Elf32_External_Rela);
4036
 
4037
      /* The following "or" (also against _G_O_T_).  */
4038
      bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4039
      rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_SPARC_LO10);
4040
      bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4041
      loc += sizeof (Elf32_External_Rela);
4042
 
4043
      /* The .got.plt entry (against _P_L_T_).  */
4044
      bfd_elf32_swap_reloc_in (output_bfd, loc, &rel);
4045
      rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_SPARC_32);
4046
      bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4047
      loc += sizeof (Elf32_External_Rela);
4048
    }
4049
}
4050
 
4051
/* Install the first PLT entry in a VxWorks shared object.  */
4052
 
4053
static void
4054
sparc_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
4055
{
4056
  struct _bfd_sparc_elf_link_hash_table *htab;
4057
  unsigned int i;
4058
 
4059
  htab = _bfd_sparc_elf_hash_table (info);
4060
  for (i = 0; i < ARRAY_SIZE (sparc_vxworks_shared_plt0_entry); i++)
4061
    bfd_put_32 (output_bfd, sparc_vxworks_shared_plt0_entry[i],
4062
                htab->splt->contents + i * 4);
4063
}
4064
 
4065
bfd_boolean
4066
_bfd_sparc_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4067
{
4068
  bfd *dynobj;
4069
  asection *sdyn;
4070
  struct _bfd_sparc_elf_link_hash_table *htab;
4071
 
4072
  htab = _bfd_sparc_elf_hash_table (info);
4073
  dynobj = htab->elf.dynobj;
4074
 
4075
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4076
 
4077
  if (elf_hash_table (info)->dynamic_sections_created)
4078
    {
4079
      asection *splt;
4080
 
4081
      splt = bfd_get_section_by_name (dynobj, ".plt");
4082
      BFD_ASSERT (splt != NULL && sdyn != NULL);
4083
 
4084
      if (!sparc_finish_dyn (output_bfd, info, dynobj, sdyn, splt))
4085
        return FALSE;
4086
 
4087
      /* Initialize the contents of the .plt section.  */
4088
      if (splt->size > 0)
4089
        {
4090
          if (htab->is_vxworks)
4091
            {
4092
              if (info->shared)
4093
                sparc_vxworks_finish_shared_plt (output_bfd, info);
4094
              else
4095
                sparc_vxworks_finish_exec_plt (output_bfd, info);
4096
            }
4097
          else
4098
            {
4099
              memset (splt->contents, 0, htab->plt_header_size);
4100
              if (!ABI_64_P (output_bfd))
4101
                bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
4102
                            splt->contents + splt->size - 4);
4103
            }
4104
        }
4105
 
4106
      elf_section_data (splt->output_section)->this_hdr.sh_entsize
4107
        = (htab->is_vxworks || !ABI_64_P (output_bfd))
4108
          ? 0 : htab->plt_entry_size;
4109
    }
4110
 
4111
  /* Set the first entry in the global offset table to the address of
4112
     the dynamic section.  */
4113
  if (htab->sgot && htab->sgot->size > 0)
4114
    {
4115
      bfd_vma val = (sdyn ?
4116
                     sdyn->output_section->vma + sdyn->output_offset :
4117
                     0);
4118
 
4119
      SPARC_ELF_PUT_WORD (htab, output_bfd, val, htab->sgot->contents);
4120
    }
4121
 
4122
  if (htab->sgot)
4123
    elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize =
4124
      SPARC_ELF_WORD_BYTES (htab);
4125
 
4126
  return TRUE;
4127
}
4128
 
4129
 
4130
/* Set the right machine number for a SPARC ELF file.  */
4131
 
4132
bfd_boolean
4133
_bfd_sparc_elf_object_p (bfd *abfd)
4134
{
4135
  if (ABI_64_P (abfd))
4136
    {
4137
      unsigned long mach = bfd_mach_sparc_v9;
4138
 
4139
      if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4140
        mach = bfd_mach_sparc_v9b;
4141
      else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4142
        mach = bfd_mach_sparc_v9a;
4143
      return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach);
4144
    }
4145
  else
4146
    {
4147
      if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
4148
        {
4149
          if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
4150
            return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4151
                                              bfd_mach_sparc_v8plusb);
4152
          else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
4153
            return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4154
                                              bfd_mach_sparc_v8plusa);
4155
          else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
4156
            return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4157
                                              bfd_mach_sparc_v8plus);
4158
          else
4159
            return FALSE;
4160
        }
4161
      else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
4162
        return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
4163
                                          bfd_mach_sparc_sparclite_le);
4164
      else
4165
        return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
4166
    }
4167
}
4168
 
4169
/* Return address for Ith PLT stub in section PLT, for relocation REL
4170
   or (bfd_vma) -1 if it should not be included.  */
4171
 
4172
bfd_vma
4173
_bfd_sparc_elf_plt_sym_val (bfd_vma i, const asection *plt, const arelent *rel)
4174
{
4175
  if (ABI_64_P (plt->owner))
4176
    {
4177
      bfd_vma j;
4178
 
4179
      i += PLT64_HEADER_SIZE / PLT64_ENTRY_SIZE;
4180
      if (i < PLT64_LARGE_THRESHOLD)
4181
        return plt->vma + i * PLT64_ENTRY_SIZE;
4182
 
4183
      j = (i - PLT64_LARGE_THRESHOLD) % 160;
4184
      i -= j;
4185
      return plt->vma + i * PLT64_ENTRY_SIZE + j * 4 * 6;
4186
    }
4187
  else
4188
    return rel->address;
4189
}

powered by: WebSVN 2.1.0

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