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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elfxx-sparc.c] - Blame information for rev 24

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

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

powered by: WebSVN 2.1.0

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