projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
include/
[deliverable/binutils-gdb.git] / bfd / elf32-sparc.c
CommitLineData
252b5132 1/* SPARC-specific support for 32-bit ELF
f0abc2a1 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3eb128b2 3 2003, 2004, 2005 Free Software Foundation, Inc.
252b5132 4
ae9a127f 5 This file is part of BFD, the Binary File Descriptor library.
252b5132 6
ae9a127f
NC		 7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
252b5132 11
ae9a127f
NC		 12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
252b5132 16
ae9a127f
NC		 17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
252b5132
RH		 20
21#include "bfd.h"
22#include "sysdep.h"
23#include "bfdlink.h"
24#include "libbfd.h"
25#include "elf-bfd.h"
26#include "elf/sparc.h"
f7775d95 27#include "opcode/sparc.h"
252b5132
RH		 28
29static reloc_howto_type *elf32_sparc_reloc_type_lookup
30 PARAMS ((bfd *, bfd_reloc_code_real_type));
31static void elf32_sparc_info_to_howto
32 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
b34976b6 33static bfd_boolean elf32_sparc_check_relocs
252b5132
RH		 34 PARAMS ((bfd *, struct bfd_link_info *, asection *,
35 const Elf_Internal_Rela *));
b34976b6 36static bfd_boolean elf32_sparc_adjust_dynamic_symbol
252b5132 37 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
b9734f35
JJ		 38static bfd_boolean allocate_dynrelocs
39 PARAMS ((struct elf_link_hash_entry *, PTR));
40static bfd_boolean readonly_dynrelocs
41 PARAMS ((struct elf_link_hash_entry *, PTR));
151e5294
EB		 42static bfd_boolean elf32_sparc_omit_section_dynsym
43 PARAMS ((bfd *, struct bfd_link_info *, asection *));
b34976b6 44static bfd_boolean elf32_sparc_size_dynamic_sections
252b5132 45 PARAMS ((bfd *, struct bfd_link_info *));
f0abc2a1
AM		 46static bfd_boolean elf32_sparc_new_section_hook
47 PARAMS ((bfd *, asection *));
b34976b6
AM		 48static bfd_boolean elf32_sparc_relax_section
49 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
b9734f35
JJ		 50static bfd_vma dtpoff_base
51 PARAMS ((struct bfd_link_info *));
52static bfd_vma tpoff
53 PARAMS ((struct bfd_link_info *, bfd_vma));
b34976b6 54static bfd_boolean elf32_sparc_relocate_section
252b5132
RH		 55 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
56 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
b34976b6 57static bfd_boolean elf32_sparc_finish_dynamic_symbol
252b5132
RH		 58 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
59 Elf_Internal_Sym *));
b34976b6 60static bfd_boolean elf32_sparc_finish_dynamic_sections
252b5132 61 PARAMS ((bfd *, struct bfd_link_info *));
b34976b6
AM		 62static bfd_boolean elf32_sparc_merge_private_bfd_data
63 PARAMS ((bfd *, bfd *));
b9734f35
JJ		 64static struct bfd_hash_entry *link_hash_newfunc
65 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
66static struct bfd_link_hash_table *elf32_sparc_link_hash_table_create
67 PARAMS ((bfd *));
26e41594
AM		 68static bfd_boolean create_got_section
69 PARAMS ((bfd *, struct bfd_link_info *));
b9734f35
JJ		 70static bfd_boolean elf32_sparc_create_dynamic_sections
71 PARAMS ((bfd *, struct bfd_link_info *));
72static void elf32_sparc_copy_indirect_symbol
9c5bfbb7 73 PARAMS ((const struct elf_backend_data *, struct elf_link_hash_entry *,
b9734f35
JJ		 74 struct elf_link_hash_entry *));
75static int elf32_sparc_tls_transition
76 PARAMS ((struct bfd_link_info *, bfd *, int, int));
77
78static bfd_boolean elf32_sparc_mkobject
79 PARAMS ((bfd *));
b34976b6 80static bfd_boolean elf32_sparc_object_p
252b5132
RH		 81 PARAMS ((bfd *));
82static void elf32_sparc_final_write_processing
b34976b6 83 PARAMS ((bfd *, bfd_boolean));
db6751f2 84static enum elf_reloc_type_class elf32_sparc_reloc_type_class
f51e552e 85 PARAMS ((const Elf_Internal_Rela *));
917583ad 86static asection * elf32_sparc_gc_mark_hook
1e2f5b6e 87 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
917583ad 88 struct elf_link_hash_entry *, Elf_Internal_Sym *));
b34976b6 89static bfd_boolean elf32_sparc_gc_sweep_hook
917583ad
NC		 90 PARAMS ((bfd *, struct bfd_link_info *, asection *,
91 const Elf_Internal_Rela *));
252b5132
RH		 92\f
93/* The relocation "howto" table. */
94
95static bfd_reloc_status_type sparc_elf_notsupported_reloc
96 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
97static bfd_reloc_status_type sparc_elf_wdisp16_reloc
98 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
b9734f35
JJ		 99static bfd_reloc_status_type sparc_elf_hix22_reloc
100 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
101static bfd_reloc_status_type sparc_elf_lox10_reloc
102 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
252b5132
RH		 103
104reloc_howto_type _bfd_sparc_elf_howto_table[] =
105{
b34976b6
AM		 106 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
107 HOWTO(R_SPARC_8, 0,0, 8,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_8", FALSE,0,0x000000ff,TRUE),
108 HOWTO(R_SPARC_16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_16", FALSE,0,0x0000ffff,TRUE),
109 HOWTO(R_SPARC_32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_32", FALSE,0,0xffffffff,TRUE),
110 HOWTO(R_SPARC_DISP8, 0,0, 8,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP8", FALSE,0,0x000000ff,TRUE),
111 HOWTO(R_SPARC_DISP16, 0,1,16,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP16", FALSE,0,0x0000ffff,TRUE),
112 HOWTO(R_SPARC_DISP32, 0,2,32,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_DISP32", FALSE,0,0xffffffff,TRUE),
113 HOWTO(R_SPARC_WDISP30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP30", FALSE,0,0x3fffffff,TRUE),
114 HOWTO(R_SPARC_WDISP22, 2,2,22,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP22", FALSE,0,0x003fffff,TRUE),
115 HOWTO(R_SPARC_HI22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HI22", FALSE,0,0x003fffff,TRUE),
116 HOWTO(R_SPARC_22, 0,2,22,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_22", FALSE,0,0x003fffff,TRUE),
117 HOWTO(R_SPARC_13, 0,2,13,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_13", FALSE,0,0x00001fff,TRUE),
118 HOWTO(R_SPARC_LO10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LO10", FALSE,0,0x000003ff,TRUE),
119 HOWTO(R_SPARC_GOT10, 0,2,10,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT10", FALSE,0,0x000003ff,TRUE),
120 HOWTO(R_SPARC_GOT13, 0,2,13,FALSE,0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_GOT13", FALSE,0,0x00001fff,TRUE),
121 HOWTO(R_SPARC_GOT22, 10,2,22,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GOT22", FALSE,0,0x003fffff,TRUE),
122 HOWTO(R_SPARC_PC10, 0,2,10,TRUE, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_PC10", FALSE,0,0x000003ff,TRUE),
123 HOWTO(R_SPARC_PC22, 10,2,22,TRUE, 0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PC22", FALSE,0,0x003fffff,TRUE),
124 HOWTO(R_SPARC_WPLT30, 2,2,30,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WPLT30", FALSE,0,0x3fffffff,TRUE),
125 HOWTO(R_SPARC_COPY, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_COPY", FALSE,0,0x00000000,TRUE),
126 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),
127 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),
128 HOWTO(R_SPARC_RELATIVE, 0,0,00,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_RELATIVE",FALSE,0,0x00000000,TRUE),
129 HOWTO(R_SPARC_UA32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA32", FALSE,0,0xffffffff,TRUE),
130 HOWTO(R_SPARC_PLT32, 0,0,00,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_PLT32", FALSE,0,0xffffffff,TRUE),
131 HOWTO(R_SPARC_HIPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HIPLT22", FALSE,0,0x00000000,TRUE),
132 HOWTO(R_SPARC_LOPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LOPLT10", FALSE,0,0x00000000,TRUE),
133 HOWTO(R_SPARC_PCPLT32, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT32", FALSE,0,0x00000000,TRUE),
134 HOWTO(R_SPARC_PCPLT22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT22", FALSE,0,0x00000000,TRUE),
135 HOWTO(R_SPARC_PCPLT10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT10", FALSE,0,0x00000000,TRUE),
136 HOWTO(R_SPARC_10, 0,2,10,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", FALSE,0,0x000003ff,TRUE),
137 HOWTO(R_SPARC_11, 0,2,11,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", FALSE,0,0x000007ff,TRUE),
252b5132
RH		 138 /* These are for sparc64 in a 64 bit environment.
139 Values need to be here because the table is indexed by reloc number. */
b34976b6
AM		 140 HOWTO(R_SPARC_64, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_64", FALSE,0,0x00000000,TRUE),
141 HOWTO(R_SPARC_OLO10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_OLO10", FALSE,0,0x00000000,TRUE),
142 HOWTO(R_SPARC_HH22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HH22", FALSE,0,0x00000000,TRUE),
143 HOWTO(R_SPARC_HM10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HM10", FALSE,0,0x00000000,TRUE),
144 HOWTO(R_SPARC_LM22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LM22", FALSE,0,0x00000000,TRUE),
145 HOWTO(R_SPARC_PC_HH22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_HH22", FALSE,0,0x00000000,TRUE),
146 HOWTO(R_SPARC_PC_HM10, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_HM10", FALSE,0,0x00000000,TRUE),
147 HOWTO(R_SPARC_PC_LM22, 0,0,00,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_LM22", FALSE,0,0x00000000,TRUE),
252b5132
RH		 148 /* End sparc64 in 64 bit environment values.
149 The following are for sparc64 in a 32 bit environment. */
b34976b6
AM		 150 HOWTO(R_SPARC_WDISP16, 2,2,16,TRUE, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", FALSE,0,0x00000000,TRUE),
151 HOWTO(R_SPARC_WDISP19, 2,2,19,TRUE, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", FALSE,0,0x0007ffff,TRUE),
152 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),
153 HOWTO(R_SPARC_7, 0,2, 7,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", FALSE,0,0x0000007f,TRUE),
154 HOWTO(R_SPARC_5, 0,2, 5,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", FALSE,0,0x0000001f,TRUE),
155 HOWTO(R_SPARC_6, 0,2, 6,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", FALSE,0,0x0000003f,TRUE),
156 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
157 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
158 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
159 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
160 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
161 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
162 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
163 HOWTO(R_SPARC_NONE, 0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
164 HOWTO(R_SPARC_UA64, 0,0, 0,FALSE,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_UA64", FALSE,0,0x00000000,TRUE),
165 HOWTO(R_SPARC_UA16, 0,1,16,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_UA16", FALSE,0,0x0000ffff,TRUE),
b9734f35
JJ		 166 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),
167 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),
168 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),
169 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),
170 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),
171 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),
172 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),
173 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),
174 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),
175 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),
176 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),
177 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),
178 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),
179 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),
180 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),
181 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),
182 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),
183 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),
184 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),
185 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),
186 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),
187 HOWTO(R_SPARC_TLS_DTPOFF64,0,0, 0,FALSE,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_TLS_DTPOFF64",FALSE,0,0x00000000,TRUE),
188 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),
189 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)
252b5132
RH		 190};
191static reloc_howto_type elf32_sparc_vtinherit_howto =
b34976b6 192 HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", FALSE,0, 0, FALSE);
252b5132 193static reloc_howto_type elf32_sparc_vtentry_howto =
b34976b6 194 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);
b9734f35
JJ		 195static reloc_howto_type elf32_sparc_rev32_howto =
196 HOWTO(R_SPARC_REV32, 0,2,32,FALSE,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", FALSE,0,0xffffffff,TRUE);
252b5132 197
252b5132
RH		 198struct elf_reloc_map {
199 bfd_reloc_code_real_type bfd_reloc_val;
200 unsigned char elf_reloc_val;
201};
202
dc810e39 203static const struct elf_reloc_map sparc_reloc_map[] =
252b5132
RH		 204{
205 { BFD_RELOC_NONE, R_SPARC_NONE, },
206 { BFD_RELOC_16, R_SPARC_16, },
bd5e6e7e 207 { BFD_RELOC_16_PCREL, R_SPARC_DISP16 },
252b5132
RH		 208 { BFD_RELOC_8, R_SPARC_8 },
209 { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
210 { BFD_RELOC_CTOR, R_SPARC_32 },
211 { BFD_RELOC_32, R_SPARC_32 },
212 { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
213 { BFD_RELOC_HI22, R_SPARC_HI22 },
214 { BFD_RELOC_LO10, R_SPARC_LO10, },
215 { BFD_RELOC_32_PCREL_S2, R_SPARC_WDISP30 },
bd5e6e7e 216 { BFD_RELOC_SPARC_PLT32, R_SPARC_PLT32 },
252b5132
RH		 217 { BFD_RELOC_SPARC22, R_SPARC_22 },
218 { BFD_RELOC_SPARC13, R_SPARC_13 },
219 { BFD_RELOC_SPARC_GOT10, R_SPARC_GOT10 },
220 { BFD_RELOC_SPARC_GOT13, R_SPARC_GOT13 },
221 { BFD_RELOC_SPARC_GOT22, R_SPARC_GOT22 },
222 { BFD_RELOC_SPARC_PC10, R_SPARC_PC10 },
223 { BFD_RELOC_SPARC_PC22, R_SPARC_PC22 },
224 { BFD_RELOC_SPARC_WPLT30, R_SPARC_WPLT30 },
225 { BFD_RELOC_SPARC_COPY, R_SPARC_COPY },
226 { BFD_RELOC_SPARC_GLOB_DAT, R_SPARC_GLOB_DAT },
227 { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
228 { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
229 { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
0f2712ed
NC		 230 { BFD_RELOC_SPARC_UA16, R_SPARC_UA16 },
231 { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 },
232 { BFD_RELOC_SPARC_UA64, R_SPARC_UA64 },
233 { BFD_RELOC_SPARC_10, R_SPARC_10 },
234 { BFD_RELOC_SPARC_11, R_SPARC_11 },
235 { BFD_RELOC_SPARC_64, R_SPARC_64 },
236 { BFD_RELOC_SPARC_OLO10, R_SPARC_OLO10 },
237 { BFD_RELOC_SPARC_HH22, R_SPARC_HH22 },
238 { BFD_RELOC_SPARC_HM10, R_SPARC_HM10 },
239 { BFD_RELOC_SPARC_LM22, R_SPARC_LM22 },
240 { BFD_RELOC_SPARC_PC_HH22, R_SPARC_PC_HH22 },
241 { BFD_RELOC_SPARC_PC_HM10, R_SPARC_PC_HM10 },
242 { BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22 },
243 { BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16 },
244 { BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19 },
245 { BFD_RELOC_SPARC_7, R_SPARC_7 },
246 { BFD_RELOC_SPARC_5, R_SPARC_5 },
247 { BFD_RELOC_SPARC_6, R_SPARC_6 },
b9734f35
JJ		 248 { BFD_RELOC_SPARC_TLS_GD_HI22, R_SPARC_TLS_GD_HI22 },
249 { BFD_RELOC_SPARC_TLS_GD_LO10, R_SPARC_TLS_GD_LO10 },
250 { BFD_RELOC_SPARC_TLS_GD_ADD, R_SPARC_TLS_GD_ADD },
251 { BFD_RELOC_SPARC_TLS_GD_CALL, R_SPARC_TLS_GD_CALL },
252 { BFD_RELOC_SPARC_TLS_LDM_HI22, R_SPARC_TLS_LDM_HI22 },
253 { BFD_RELOC_SPARC_TLS_LDM_LO10, R_SPARC_TLS_LDM_LO10 },
254 { BFD_RELOC_SPARC_TLS_LDM_ADD, R_SPARC_TLS_LDM_ADD },
255 { BFD_RELOC_SPARC_TLS_LDM_CALL, R_SPARC_TLS_LDM_CALL },
256 { BFD_RELOC_SPARC_TLS_LDO_HIX22, R_SPARC_TLS_LDO_HIX22 },
257 { BFD_RELOC_SPARC_TLS_LDO_LOX10, R_SPARC_TLS_LDO_LOX10 },
258 { BFD_RELOC_SPARC_TLS_LDO_ADD, R_SPARC_TLS_LDO_ADD },
259 { BFD_RELOC_SPARC_TLS_IE_HI22, R_SPARC_TLS_IE_HI22 },
260 { BFD_RELOC_SPARC_TLS_IE_LO10, R_SPARC_TLS_IE_LO10 },
261 { BFD_RELOC_SPARC_TLS_IE_LD, R_SPARC_TLS_IE_LD },
262 { BFD_RELOC_SPARC_TLS_IE_LDX, R_SPARC_TLS_IE_LDX },
263 { BFD_RELOC_SPARC_TLS_IE_ADD, R_SPARC_TLS_IE_ADD },
264 { BFD_RELOC_SPARC_TLS_LE_HIX22, R_SPARC_TLS_LE_HIX22 },
265 { BFD_RELOC_SPARC_TLS_LE_LOX10, R_SPARC_TLS_LE_LOX10 },
266 { BFD_RELOC_SPARC_TLS_DTPMOD32, R_SPARC_TLS_DTPMOD32 },
267 { BFD_RELOC_SPARC_TLS_DTPMOD64, R_SPARC_TLS_DTPMOD64 },
268 { BFD_RELOC_SPARC_TLS_DTPOFF32, R_SPARC_TLS_DTPOFF32 },
269 { BFD_RELOC_SPARC_TLS_DTPOFF64, R_SPARC_TLS_DTPOFF64 },
270 { BFD_RELOC_SPARC_TLS_TPOFF32, R_SPARC_TLS_TPOFF32 },
271 { BFD_RELOC_SPARC_TLS_TPOFF64, R_SPARC_TLS_TPOFF64 },
0f2712ed
NC		 272 { BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT },
273 { BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY },
b9734f35 274 { BFD_RELOC_SPARC_REV32, R_SPARC_REV32 }
252b5132
RH		 275};
276
277static reloc_howto_type *
278elf32_sparc_reloc_type_lookup (abfd, code)
5f771d47 279 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 280 bfd_reloc_code_real_type code;
281{
282 unsigned int i;
435b1e90 283
252b5132
RH		 284 switch (code)
285 {
286 case BFD_RELOC_VTABLE_INHERIT:
287 return &elf32_sparc_vtinherit_howto;
288
289 case BFD_RELOC_VTABLE_ENTRY:
290 return &elf32_sparc_vtentry_howto;
291
b9734f35
JJ		 292 case BFD_RELOC_SPARC_REV32:
293 return &elf32_sparc_rev32_howto;
294
252b5132 295 default:
26e41594
AM		 296 for (i = 0;
297 i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map);
298 i++)
299 {
300 if (sparc_reloc_map[i].bfd_reloc_val == code)
301 return (_bfd_sparc_elf_howto_table
302 + (int) sparc_reloc_map[i].elf_reloc_val);
303 }
252b5132
RH		 304 }
305 bfd_set_error (bfd_error_bad_value);
306 return NULL;
307}
308
309/* We need to use ELF32_R_TYPE so we have our own copy of this function,
310 and elf64-sparc.c has its own copy. */
311
312static void
313elf32_sparc_info_to_howto (abfd, cache_ptr, dst)
5f771d47 314 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 315 arelent *cache_ptr;
316 Elf_Internal_Rela *dst;
317{
60dac299
RH		 318 switch (ELF32_R_TYPE(dst->r_info))
319 {
320 case R_SPARC_GNU_VTINHERIT:
321 cache_ptr->howto = &elf32_sparc_vtinherit_howto;
322 break;
323
324 case R_SPARC_GNU_VTENTRY:
325 cache_ptr->howto = &elf32_sparc_vtentry_howto;
326 break;
327
b9734f35
JJ		 328 case R_SPARC_REV32:
329 cache_ptr->howto = &elf32_sparc_rev32_howto;
330 break;
331
60dac299
RH		 332 default:
333 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std);
334 cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
335 }
252b5132
RH		 336}
337\f
338/* For unsupported relocs. */
339
340static bfd_reloc_status_type
341sparc_elf_notsupported_reloc (abfd,
342 reloc_entry,
343 symbol,
344 data,
345 input_section,
346 output_bfd,
347 error_message)
5f771d47
ILT		 348 bfd *abfd ATTRIBUTE_UNUSED;
349 arelent *reloc_entry ATTRIBUTE_UNUSED;
350 asymbol *symbol ATTRIBUTE_UNUSED;
351 PTR data ATTRIBUTE_UNUSED;
352 asection *input_section ATTRIBUTE_UNUSED;
353 bfd *output_bfd ATTRIBUTE_UNUSED;
354 char **error_message ATTRIBUTE_UNUSED;
252b5132
RH		 355{
356 return bfd_reloc_notsupported;
357}
358
359/* Handle the WDISP16 reloc. */
360
361static bfd_reloc_status_type
362sparc_elf_wdisp16_reloc (abfd,
363 reloc_entry,
364 symbol,
365 data,
366 input_section,
367 output_bfd,
368 error_message)
369 bfd *abfd;
370 arelent *reloc_entry;
371 asymbol *symbol;
372 PTR data;
373 asection *input_section;
374 bfd *output_bfd;
5f771d47 375 char **error_message ATTRIBUTE_UNUSED;
252b5132
RH		 376{
377 bfd_vma relocation;
378 bfd_vma x;
379
380 if (output_bfd != (bfd *) NULL
381 && (symbol->flags & BSF_SECTION_SYM) == 0
382 && (! reloc_entry->howto->partial_inplace
383 || reloc_entry->addend == 0))
384 {
385 reloc_entry->address += input_section->output_offset;
386 return bfd_reloc_ok;
387 }
388
389 if (output_bfd != NULL)
390 return bfd_reloc_continue;
391
07515404 392 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
252b5132
RH		 393 return bfd_reloc_outofrange;
394
395 relocation = (symbol->value
396 + symbol->section->output_section->vma
397 + symbol->section->output_offset);
398 relocation += reloc_entry->addend;
399 relocation -= (input_section->output_section->vma
400 + input_section->output_offset);
401 relocation -= reloc_entry->address;
402
403 x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
404 x |= ((((relocation >> 2) & 0xc000) << 6)
405 | ((relocation >> 2) & 0x3fff));
406 bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);
407
408 if ((bfd_signed_vma) relocation < - 0x40000
409 || (bfd_signed_vma) relocation > 0x3ffff)
410 return bfd_reloc_overflow;
411 else
412 return bfd_reloc_ok;
413}
b9734f35
JJ		 414
415/* Handle the HIX22 reloc. */
416
417static bfd_reloc_status_type
418sparc_elf_hix22_reloc (abfd,
419 reloc_entry,
420 symbol,
421 data,
422 input_section,
423 output_bfd,
424 error_message)
425 bfd *abfd;
426 arelent *reloc_entry;
427 asymbol *symbol;
428 PTR data;
429 asection *input_section;
430 bfd *output_bfd;
431 char **error_message ATTRIBUTE_UNUSED;
432{
433 bfd_vma relocation;
434 bfd_vma insn;
435
436 if (output_bfd != (bfd *) NULL
437 && (symbol->flags & BSF_SECTION_SYM) == 0)
438 {
439 reloc_entry->address += input_section->output_offset;
440 return bfd_reloc_ok;
441 }
442
443 if (output_bfd != NULL)
444 return bfd_reloc_continue;
445
07515404 446 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
b9734f35
JJ		 447 return bfd_reloc_outofrange;
448
449 relocation = (symbol->value
450 + symbol->section->output_section->vma
451 + symbol->section->output_offset);
452 relocation += reloc_entry->addend;
453 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
454
455 insn = (insn &~ (bfd_vma) 0x3fffff) | (((~relocation) >> 10) & 0x3fffff);
456 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
457
458 return bfd_reloc_ok;
459}
460
461/* Handle the LOX10 reloc. */
462
463static bfd_reloc_status_type
464sparc_elf_lox10_reloc (abfd,
465 reloc_entry,
466 symbol,
467 data,
468 input_section,
469 output_bfd,
470 error_message)
471 bfd *abfd;
472 arelent *reloc_entry;
473 asymbol *symbol;
474 PTR data;
475 asection *input_section;
476 bfd *output_bfd;
477 char **error_message ATTRIBUTE_UNUSED;
478{
479 bfd_vma relocation;
480 bfd_vma insn;
481
482 if (output_bfd != (bfd *) NULL
483 && (symbol->flags & BSF_SECTION_SYM) == 0)
484 {
485 reloc_entry->address += input_section->output_offset;
486 return bfd_reloc_ok;
487 }
488
489 if (output_bfd != NULL)
490 return bfd_reloc_continue;
491
07515404 492 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
b9734f35
JJ		 493 return bfd_reloc_outofrange;
494
495 relocation = (symbol->value
496 + symbol->section->output_section->vma
497 + symbol->section->output_offset);
498 relocation += reloc_entry->addend;
499 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
500
501 insn = (insn &~ (bfd_vma) 0x1fff) | 0x1c00 | (relocation & 0x3ff);
502 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
503
504 return bfd_reloc_ok;
505}
0647ed71
MK		 506\f
507/* Support for core dump NOTE sections. */
508
509static bfd_boolean
510elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
511{
512 switch (note->descsz)
513 {
514 default:
515 return FALSE;
516
517 case 260: /* Solaris prpsinfo_t. */
518 elf_tdata (abfd)->core_program
519 = _bfd_elfcore_strndup (abfd, note->descdata + 84, 16);
520 elf_tdata (abfd)->core_command
521 = _bfd_elfcore_strndup (abfd, note->descdata + 100, 80);
522 break;
523
524 case 336: /* Solaris psinfo_t. */
525 elf_tdata (abfd)->core_program
526 = _bfd_elfcore_strndup (abfd, note->descdata + 88, 16);
527 elf_tdata (abfd)->core_command
528 = _bfd_elfcore_strndup (abfd, note->descdata + 104, 80);
529 break;
530 }
531
532 return TRUE;
533}
534
252b5132
RH		 535\f
536/* Functions for the SPARC ELF linker. */
537
538/* The name of the dynamic interpreter. This is put in the .interp
539 section. */
540
541#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
542
543/* The nop opcode we use. */
544
545#define SPARC_NOP 0x01000000
546
547/* The size in bytes of an entry in the procedure linkage table. */
548
549#define PLT_ENTRY_SIZE 12
550
551/* The first four entries in a procedure linkage table are reserved,
552 and the initial contents are unimportant (we zero them out).
553 Subsequent entries look like this. See the SVR4 ABI SPARC
554 supplement to see how this works. */
555
556/* sethi %hi(.-.plt0),%g1. We fill in the address later. */
557#define PLT_ENTRY_WORD0 0x03000000
558/* b,a .plt0. We fill in the offset later. */
559#define PLT_ENTRY_WORD1 0x30800000
560/* nop. */
561#define PLT_ENTRY_WORD2 SPARC_NOP
562
b9734f35
JJ		 563/* The SPARC linker needs to keep track of the number of relocs that it
564 decides to copy as dynamic relocs in check_relocs for each symbol.
565 This is so that it can later discard them if they are found to be
566 unnecessary. We store the information in a field extending the
567 regular ELF linker hash table. */
568
569struct elf32_sparc_dyn_relocs
570{
571 struct elf32_sparc_dyn_relocs *next;
572
573 /* The input section of the reloc. */
574 asection *sec;
575
576 /* Total number of relocs copied for the input section. */
577 bfd_size_type count;
578
579 /* Number of pc-relative relocs copied for the input section. */
580 bfd_size_type pc_count;
581};
582
583/* SPARC ELF linker hash entry. */
584
585struct elf32_sparc_link_hash_entry
586{
587 struct elf_link_hash_entry elf;
588
589 /* Track dynamic relocs copied for this symbol. */
590 struct elf32_sparc_dyn_relocs *dyn_relocs;
591
592#define GOT_UNKNOWN 0
593#define GOT_NORMAL 1
594#define GOT_TLS_GD 2
595#define GOT_TLS_IE 3
596 unsigned char tls_type;
597};
598
599#define elf32_sparc_hash_entry(ent) ((struct elf32_sparc_link_hash_entry *)(ent))
600
601struct elf32_sparc_obj_tdata
602{
603 struct elf_obj_tdata root;
604
605 /* tls_type for each local got entry. */
606 char *local_got_tls_type;
607
608 /* TRUE if TLS GD relocs has been seen for this object. */
609 bfd_boolean has_tlsgd;
610};
611
612#define elf32_sparc_tdata(abfd) \
613 ((struct elf32_sparc_obj_tdata *) (abfd)->tdata.any)
614
615#define elf32_sparc_local_got_tls_type(abfd) \
616 (elf32_sparc_tdata (abfd)->local_got_tls_type)
617
618static bfd_boolean
619elf32_sparc_mkobject (abfd)
620 bfd *abfd;
621{
622 bfd_size_type amt = sizeof (struct elf32_sparc_obj_tdata);
623 abfd->tdata.any = bfd_zalloc (abfd, amt);
624 if (abfd->tdata.any == NULL)
625 return FALSE;
626 return TRUE;
627}
628
629/* SPARC ELF linker hash table. */
630
631struct elf32_sparc_link_hash_table
632{
633 struct elf_link_hash_table elf;
634
635 /* Short-cuts to get to dynamic linker sections. */
636 asection *sgot;
637 asection *srelgot;
638 asection *splt;
639 asection *srelplt;
640 asection *sdynbss;
641 asection *srelbss;
642
643 union {
644 bfd_signed_vma refcount;
645 bfd_vma offset;
646 } tls_ldm_got;
647
648 /* Small local sym to section mapping cache. */
649 struct sym_sec_cache sym_sec;
650};
651
652/* Get the SPARC ELF linker hash table from a link_info structure. */
653
654#define elf32_sparc_hash_table(p) \
655 ((struct elf32_sparc_link_hash_table *) ((p)->hash))
656
657/* Create an entry in an i386 ELF linker hash table. */
658
659static struct bfd_hash_entry *
660link_hash_newfunc (entry, table, string)
661 struct bfd_hash_entry *entry;
662 struct bfd_hash_table *table;
663 const char *string;
664{
665 /* Allocate the structure if it has not already been allocated by a
666 subclass. */
667 if (entry == NULL)
668 {
669 entry = bfd_hash_allocate (table,
26e41594 670 sizeof (struct elf32_sparc_link_hash_entry));
b9734f35 671 if (entry == NULL)
26e41594 672 return entry;
b9734f35
JJ		 673 }
674
675 /* Call the allocation method of the superclass. */
676 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
677 if (entry != NULL)
678 {
679 struct elf32_sparc_link_hash_entry *eh;
680
681 eh = (struct elf32_sparc_link_hash_entry *) entry;
682 eh->dyn_relocs = NULL;
683 eh->tls_type = GOT_UNKNOWN;
684 }
685
686 return entry;
687}
688
689/* Create a SPARC ELF linker hash table. */
690
691static struct bfd_link_hash_table *
692elf32_sparc_link_hash_table_create (abfd)
693 bfd *abfd;
694{
695 struct elf32_sparc_link_hash_table *ret;
696 bfd_size_type amt = sizeof (struct elf32_sparc_link_hash_table);
697
01aac484 698 ret = (struct elf32_sparc_link_hash_table *) bfd_zmalloc (amt);
b9734f35
JJ		 699 if (ret == NULL)
700 return NULL;
701
702 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
703 {
704 free (ret);
705 return NULL;
706 }
707
b9734f35
JJ		 708 return &ret->elf.root;
709}
710
711/* Create .got and .rela.got sections in DYNOBJ, and set up
712 shortcuts to them in our hash table. */
713
714static bfd_boolean
715create_got_section (dynobj, info)
716 bfd *dynobj;
717 struct bfd_link_info *info;
718{
719 struct elf32_sparc_link_hash_table *htab;
720
721 if (! _bfd_elf_create_got_section (dynobj, info))
722 return FALSE;
723
724 htab = elf32_sparc_hash_table (info);
725 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
01aac484 726 BFD_ASSERT (htab->sgot != NULL);
b9734f35
JJ		 727
728 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
729 if (htab->srelgot == NULL
01aac484
EB		 730 || ! bfd_set_section_flags (dynobj, htab->srelgot, SEC_ALLOC
731 | SEC_LOAD
732 | SEC_HAS_CONTENTS
733 | SEC_IN_MEMORY
734 | SEC_LINKER_CREATED
735 | SEC_READONLY)
b9734f35
JJ		 736 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
737 return FALSE;
738 return TRUE;
739}
740
741/* Create .plt, .rela.plt, .got, .rela.got, .dynbss, and
742 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
743 hash table. */
744
745static bfd_boolean
746elf32_sparc_create_dynamic_sections (dynobj, info)
747 bfd *dynobj;
748 struct bfd_link_info *info;
749{
750 struct elf32_sparc_link_hash_table *htab;
751
752 htab = elf32_sparc_hash_table (info);
753 if (!htab->sgot && !create_got_section (dynobj, info))
754 return FALSE;
755
756 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
757 return FALSE;
758
759 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
760 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
761 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
762 if (!info->shared)
763 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
764
765 if (!htab->splt || !htab->srelplt || !htab->sdynbss
766 || (!info->shared && !htab->srelbss))
767 abort ();
768
769 return TRUE;
770}
771
772/* Copy the extra info we tack onto an elf_link_hash_entry. */
773
774static void
775elf32_sparc_copy_indirect_symbol (bed, dir, ind)
9c5bfbb7 776 const struct elf_backend_data *bed;
b9734f35
JJ		 777 struct elf_link_hash_entry *dir, *ind;
778{
779 struct elf32_sparc_link_hash_entry *edir, *eind;
780
781 edir = (struct elf32_sparc_link_hash_entry *) dir;
782 eind = (struct elf32_sparc_link_hash_entry *) ind;
783
784 if (eind->dyn_relocs != NULL)
785 {
786 if (edir->dyn_relocs != NULL)
26e41594
AM		 787 {
788 struct elf32_sparc_dyn_relocs **pp;
789 struct elf32_sparc_dyn_relocs *p;
790
791 if (ind->root.type == bfd_link_hash_indirect)
792 abort ();
793
794 /* Add reloc counts against the weak sym to the strong sym
795 list. Merge any entries against the same section. */
796 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
797 {
798 struct elf32_sparc_dyn_relocs *q;
799
800 for (q = edir->dyn_relocs; q != NULL; q = q->next)
801 if (q->sec == p->sec)
802 {
803 q->pc_count += p->pc_count;
804 q->count += p->count;
805 *pp = p->next;
806 break;
807 }
808 if (q == NULL)
809 pp = &p->next;
810 }
811 *pp = edir->dyn_relocs;
812 }
b9734f35
JJ		 813
814 edir->dyn_relocs = eind->dyn_relocs;
815 eind->dyn_relocs = NULL;
816 }
817
818 if (ind->root.type == bfd_link_hash_indirect
819 && dir->got.refcount <= 0)
820 {
821 edir->tls_type = eind->tls_type;
822 eind->tls_type = GOT_UNKNOWN;
823 }
824 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
825}
826
827static int
828elf32_sparc_tls_transition (info, abfd, r_type, is_local)
829 struct bfd_link_info *info;
830 bfd *abfd;
831 int r_type;
832 int is_local;
833{
834 if (r_type == R_SPARC_TLS_GD_HI22
835 && ! elf32_sparc_tdata (abfd)->has_tlsgd)
836 r_type = R_SPARC_REV32;
837
838 if (info->shared)
839 return r_type;
840
841 switch (r_type)
842 {
843 case R_SPARC_TLS_GD_HI22:
844 if (is_local)
845 return R_SPARC_TLS_LE_HIX22;
846 return R_SPARC_TLS_IE_HI22;
847 case R_SPARC_TLS_GD_LO10:
848 if (is_local)
26e41594 849 return R_SPARC_TLS_LE_LOX10;
b9734f35
JJ		 850 return R_SPARC_TLS_IE_LO10;
851 case R_SPARC_TLS_IE_HI22:
852 if (is_local)
26e41594 853 return R_SPARC_TLS_LE_HIX22;
b9734f35
JJ		 854 return r_type;
855 case R_SPARC_TLS_IE_LO10:
856 if (is_local)
26e41594 857 return R_SPARC_TLS_LE_LOX10;
b9734f35
JJ		 858 return r_type;
859 case R_SPARC_TLS_LDM_HI22:
860 return R_SPARC_TLS_LE_HIX22;
861 case R_SPARC_TLS_LDM_LO10:
862 return R_SPARC_TLS_LE_LOX10;
863 }
864
865 return r_type;
866}
867
252b5132
RH		 868/* Look through the relocs for a section during the first phase, and
869 allocate space in the global offset table or procedure linkage
870 table. */
871
b34976b6 872static bfd_boolean
252b5132
RH		 873elf32_sparc_check_relocs (abfd, info, sec, relocs)
874 bfd *abfd;
875 struct bfd_link_info *info;
876 asection *sec;
877 const Elf_Internal_Rela *relocs;
878{
b9734f35 879 struct elf32_sparc_link_hash_table *htab;
252b5132
RH		 880 Elf_Internal_Shdr *symtab_hdr;
881 struct elf_link_hash_entry **sym_hashes;
882 bfd_vma *local_got_offsets;
883 const Elf_Internal_Rela *rel;
884 const Elf_Internal_Rela *rel_end;
252b5132 885 asection *sreloc;
b9734f35 886 bfd_boolean checked_tlsgd = FALSE;
252b5132 887
1049f94e 888 if (info->relocatable)
b34976b6 889 return TRUE;
252b5132 890
b9734f35 891 htab = elf32_sparc_hash_table (info);
252b5132
RH		 892 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
893 sym_hashes = elf_sym_hashes (abfd);
894 local_got_offsets = elf_local_got_offsets (abfd);
895
252b5132
RH		 896 sreloc = NULL;
897
898 rel_end = relocs + sec->reloc_count;
899 for (rel = relocs; rel < rel_end; rel++)
900 {
b9734f35 901 unsigned int r_type;
252b5132
RH		 902 unsigned long r_symndx;
903 struct elf_link_hash_entry *h;
904
905 r_symndx = ELF32_R_SYM (rel->r_info);
b9734f35
JJ		 906 r_type = ELF32_R_TYPE (rel->r_info);
907
908 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
26e41594 909 {
d003868e
AM		 910 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
911 abfd, r_symndx);
26e41594
AM		 912 return FALSE;
913 }
b9734f35 914
252b5132
RH		 915 if (r_symndx < symtab_hdr->sh_info)
916 h = NULL;
917 else
918 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
919
b9734f35
JJ		 920 /* Compatibility with old R_SPARC_REV32 reloc conflicting
921 with R_SPARC_TLS_GD_HI22. */
922 if (! checked_tlsgd)
923 switch (r_type)
924 {
925 case R_SPARC_TLS_GD_HI22:
926 {
927 const Elf_Internal_Rela *relt;
928
929 for (relt = rel + 1; relt < rel_end; relt++)
930 if (ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_LO10
931 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_ADD
932 || ELF32_R_TYPE (relt->r_info) == R_SPARC_TLS_GD_CALL)
933 break;
934 checked_tlsgd = TRUE;
935 elf32_sparc_tdata (abfd)->has_tlsgd = relt < rel_end;
936 }
937 break;
938 case R_SPARC_TLS_GD_LO10:
939 case R_SPARC_TLS_GD_ADD:
940 case R_SPARC_TLS_GD_CALL:
941 checked_tlsgd = TRUE;
942 elf32_sparc_tdata (abfd)->has_tlsgd = TRUE;
943 break;
944 }
945
946 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h == NULL);
947 switch (r_type)
252b5132 948 {
b9734f35
JJ		 949 case R_SPARC_TLS_LDM_HI22:
950 case R_SPARC_TLS_LDM_LO10:
951 htab->tls_ldm_got.refcount += 1;
952 break;
953
954 case R_SPARC_TLS_LE_HIX22:
955 case R_SPARC_TLS_LE_LOX10:
956 if (info->shared)
957 goto r_sparc_plt32;
958 break;
959
960 case R_SPARC_TLS_IE_HI22:
961 case R_SPARC_TLS_IE_LO10:
962 if (info->shared)
963 info->flags |= DF_STATIC_TLS;
964 /* Fall through */
965
252b5132
RH		 966 case R_SPARC_GOT10:
967 case R_SPARC_GOT13:
968 case R_SPARC_GOT22:
b9734f35
JJ		 969 case R_SPARC_TLS_GD_HI22:
970 case R_SPARC_TLS_GD_LO10:
252b5132 971 /* This symbol requires a global offset table entry. */
b9734f35
JJ		 972 {
973 int tls_type, old_tls_type;
252b5132 974
b9734f35
JJ		 975 switch (r_type)
976 {
977 default:
978 case R_SPARC_GOT10:
979 case R_SPARC_GOT13:
980 case R_SPARC_GOT22:
981 tls_type = GOT_NORMAL;
982 break;
983 case R_SPARC_TLS_GD_HI22:
984 case R_SPARC_TLS_GD_LO10:
985 tls_type = GOT_TLS_GD;
986 break;
987 case R_SPARC_TLS_IE_HI22:
988 case R_SPARC_TLS_IE_LO10:
989 tls_type = GOT_TLS_IE;
990 break;
991 }
252b5132 992
b9734f35
JJ		 993 if (h != NULL)
994 {
995 h->got.refcount += 1;
996 old_tls_type = elf32_sparc_hash_entry(h)->tls_type;
997 }
998 else
999 {
1000 bfd_signed_vma *local_got_refcounts;
252b5132 1001
b9734f35
JJ		 1002 /* This is a global offset table entry for a local symbol. */
1003 local_got_refcounts = elf_local_got_refcounts (abfd);
1004 if (local_got_refcounts == NULL)
1005 {
1006 bfd_size_type size;
252b5132 1007
b9734f35
JJ		 1008 size = symtab_hdr->sh_info;
1009 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1010 local_got_refcounts = ((bfd_signed_vma *)
1011 bfd_zalloc (abfd, size));
1012 if (local_got_refcounts == NULL)
1013 return FALSE;
1014 elf_local_got_refcounts (abfd) = local_got_refcounts;
1015 elf32_sparc_local_got_tls_type (abfd)
1016 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1017 }
1018 local_got_refcounts[r_symndx] += 1;
1019 old_tls_type = elf32_sparc_local_got_tls_type (abfd) [r_symndx];
1020 }
252b5132 1021
b9734f35
JJ		 1022 /* If a TLS symbol is accessed using IE at least once,
1023 there is no point to use dynamic model for it. */
1024 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1025 && (old_tls_type != GOT_TLS_GD
1026 || tls_type != GOT_TLS_IE))
1027 {
1028 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1029 tls_type = old_tls_type;
1030 else
1031 {
1032 (*_bfd_error_handler)
d003868e
AM		 1033 (_("%B: `%s' accessed both as normal and thread local symbol"),
1034 abfd, h ? h->root.root.string : "<local>");
b34976b6 1035 return FALSE;
b9734f35
JJ		 1036 }
1037 }
252b5132 1038
b9734f35
JJ		 1039 if (old_tls_type != tls_type)
1040 {
1041 if (h != NULL)
1042 elf32_sparc_hash_entry (h)->tls_type = tls_type;
1043 else
1044 elf32_sparc_local_got_tls_type (abfd) [r_symndx] = tls_type;
1045 }
1046 }
252b5132 1047
2293c499
AM		 1048 if (htab->sgot == NULL)
1049 {
1050 if (htab->elf.dynobj == NULL)
1051 htab->elf.dynobj = abfd;
1052 if (!create_got_section (htab->elf.dynobj, info))
1053 return FALSE;
1054 }
b9734f35 1055 break;
252b5132 1056
b9734f35
JJ		 1057 case R_SPARC_TLS_GD_CALL:
1058 case R_SPARC_TLS_LDM_CALL:
1059 if (info->shared)
1060 {
1061 /* These are basically R_SPARC_TLS_WPLT30 relocs against
1062 __tls_get_addr. */
1063 struct bfd_link_hash_entry *bh = NULL;
1064 if (! _bfd_generic_link_add_one_symbol (info, abfd,
1065 "__tls_get_addr", 0,
1066 bfd_und_section_ptr, 0,
1067 NULL, FALSE, FALSE,
1068 &bh))
1069 return FALSE;
1070 h = (struct elf_link_hash_entry *) bh;
252b5132 1071 }
b9734f35
JJ		 1072 else
1073 break;
1074 /* Fall through */
252b5132 1075
bd5e6e7e 1076 case R_SPARC_PLT32:
252b5132
RH		 1077 case R_SPARC_WPLT30:
1078 /* This symbol requires a procedure linkage table entry. We
26e41594
AM		 1079 actually build the entry in adjust_dynamic_symbol,
1080 because this might be a case of linking PIC code without
1081 linking in any dynamic objects, in which case we don't
1082 need to generate a procedure linkage table after all. */
252b5132
RH		 1083
1084 if (h == NULL)
1085 {
1086 /* The Solaris native assembler will generate a WPLT30
26e41594
AM		 1087 reloc for a local symbol if you assemble a call from
1088 one section to another when using -K pic. We treat
1089 it as WDISP30. */
b9734f35 1090 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
bd5e6e7e 1091 goto r_sparc_plt32;
252b5132
RH		 1092 break;
1093 }
1094
f5385ebf 1095 h->needs_plt = 1;
252b5132 1096
b9734f35 1097 if (ELF32_R_TYPE (rel->r_info) == R_SPARC_PLT32)
bd5e6e7e 1098 goto r_sparc_plt32;
b9734f35 1099 h->plt.refcount += 1;
252b5132
RH		 1100 break;
1101
1102 case R_SPARC_PC10:
1103 case R_SPARC_PC22:
7843f00e 1104 if (h != NULL)
f5385ebf 1105 h->non_got_ref = 1;
7843f00e 1106
252b5132
RH		 1107 if (h != NULL
1108 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1109 break;
1110 /* Fall through. */
b9734f35 1111
252b5132
RH		 1112 case R_SPARC_DISP8:
1113 case R_SPARC_DISP16:
1114 case R_SPARC_DISP32:
1115 case R_SPARC_WDISP30:
1116 case R_SPARC_WDISP22:
1117 case R_SPARC_WDISP19:
1118 case R_SPARC_WDISP16:
252b5132
RH		 1119 case R_SPARC_8:
1120 case R_SPARC_16:
1121 case R_SPARC_32:
1122 case R_SPARC_HI22:
1123 case R_SPARC_22:
1124 case R_SPARC_13:
1125 case R_SPARC_LO10:
0f2712ed 1126 case R_SPARC_UA16:
252b5132 1127 case R_SPARC_UA32:
7843f00e 1128 if (h != NULL)
f5385ebf 1129 h->non_got_ref = 1;
7843f00e 1130
bd5e6e7e 1131 r_sparc_plt32:
b9734f35
JJ		 1132 if (h != NULL && !info->shared)
1133 {
1134 /* We may need a .plt entry if the function this reloc
1135 refers to is in a shared lib. */
1136 h->plt.refcount += 1;
1137 }
1138
1139 /* If we are creating a shared library, and this is a reloc
1140 against a global symbol, or a non PC relative reloc
1141 against a local symbol, then we need to copy the reloc
1142 into the shared library. However, if we are linking with
1143 -Bsymbolic, we do not need to copy a reloc against a
1144 global symbol which is defined in an object we are
1145 including in the link (i.e., DEF_REGULAR is set). At
1146 this point we have not seen all the input files, so it is
1147 possible that DEF_REGULAR is not set now but will be set
1148 later (it is never cleared). In case of a weak definition,
1149 DEF_REGULAR may be cleared later by a strong definition in
1150 a shared library. We account for that possibility below by
1151 storing information in the relocs_copied field of the hash
1152 table entry. A similar situation occurs when creating
1153 shared libraries and symbol visibility changes render the
1154 symbol local.
1155
1156 If on the other hand, we are creating an executable, we
1157 may need to keep relocations for symbols satisfied by a
1158 dynamic library if we manage to avoid copy relocs for the
1159 symbol. */
1160 if ((info->shared
1161 && (sec->flags & SEC_ALLOC) != 0
1162 && (! _bfd_sparc_elf_howto_table[r_type].pc_relative
1163 || (h != NULL
1164 && (! info->symbolic
1165 || h->root.type == bfd_link_hash_defweak
f5385ebf 1166 || !h->def_regular))))
b9734f35
JJ		 1167 || (!info->shared
1168 && (sec->flags & SEC_ALLOC) != 0
1169 && h != NULL
1170 && (h->root.type == bfd_link_hash_defweak
f5385ebf 1171 || !h->def_regular)))
252b5132 1172 {
b9734f35
JJ		 1173 struct elf32_sparc_dyn_relocs *p;
1174 struct elf32_sparc_dyn_relocs **head;
1175
252b5132 1176 /* When creating a shared object, we must copy these
26e41594
AM		 1177 relocs into the output file. We create a reloc
1178 section in dynobj and make room for the reloc. */
252b5132
RH		 1179 if (sreloc == NULL)
1180 {
1181 const char *name;
b9734f35 1182 bfd *dynobj;
252b5132
RH		 1183
1184 name = (bfd_elf_string_from_elf_section
1185 (abfd,
1186 elf_elfheader (abfd)->e_shstrndx,
1187 elf_section_data (sec)->rel_hdr.sh_name));
1188 if (name == NULL)
b34976b6 1189 return FALSE;
252b5132
RH		 1190
1191 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1192 && strcmp (bfd_get_section_name (abfd, sec),
1193 name + 5) == 0);
1194
b9734f35
JJ		 1195 if (htab->elf.dynobj == NULL)
1196 htab->elf.dynobj = abfd;
1197 dynobj = htab->elf.dynobj;
1198
252b5132
RH		 1199 sreloc = bfd_get_section_by_name (dynobj, name);
1200 if (sreloc == NULL)
1201 {
1202 flagword flags;
1203
1204 sreloc = bfd_make_section (dynobj, name);
1205 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1206 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1207 if ((sec->flags & SEC_ALLOC) != 0)
1208 flags |= SEC_ALLOC | SEC_LOAD;
1209 if (sreloc == NULL
1210 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1211 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
b34976b6 1212 return FALSE;
252b5132 1213 }
b9734f35 1214 elf_section_data (sec)->sreloc = sreloc;
252b5132
RH		 1215 }
1216
b9734f35
JJ		 1217 /* If this is a global symbol, we count the number of
1218 relocations we need for this symbol. */
1219 if (h != NULL)
1220 head = &((struct elf32_sparc_link_hash_entry *) h)->dyn_relocs;
1221 else
1222 {
1223 /* Track dynamic relocs needed for local syms too.
1224 We really need local syms available to do this
1225 easily. Oh well. */
1226
1227 asection *s;
1228 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1229 sec, r_symndx);
1230 if (s == NULL)
1231 return FALSE;
1232
1233 head = ((struct elf32_sparc_dyn_relocs **)
1234 &elf_section_data (s)->local_dynrel);
1235 }
1236
1237 p = *head;
1238 if (p == NULL || p->sec != sec)
1239 {
1240 bfd_size_type amt = sizeof *p;
1241 p = ((struct elf32_sparc_dyn_relocs *)
1242 bfd_alloc (htab->elf.dynobj, amt));
1243 if (p == NULL)
1244 return FALSE;
1245 p->next = *head;
1246 *head = p;
1247 p->sec = sec;
1248 p->count = 0;
1249 p->pc_count = 0;
1250 }
1251
1252 p->count += 1;
1253 if (_bfd_sparc_elf_howto_table[r_type].pc_relative)
1254 p->pc_count += 1;
252b5132
RH		 1255 }
1256
1257 break;
1258
26e41594 1259 case R_SPARC_GNU_VTINHERIT:
c152c796 1260 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
26e41594
AM		 1261 return FALSE;
1262 break;
252b5132 1263
26e41594 1264 case R_SPARC_GNU_VTENTRY:
c152c796 1265 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
26e41594
AM		 1266 return FALSE;
1267 break;
252b5132
RH		 1268
1269 default:
1270 break;
1271 }
1272 }
1273
b34976b6 1274 return TRUE;
252b5132
RH		 1275}
1276
1277static asection *
1e2f5b6e
AM		 1278elf32_sparc_gc_mark_hook (sec, info, rel, h, sym)
1279 asection *sec;
5f771d47 1280 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 1281 Elf_Internal_Rela *rel;
1282 struct elf_link_hash_entry *h;
1283 Elf_Internal_Sym *sym;
1284{
252b5132
RH		 1285 if (h != NULL)
1286 {
1287 switch (ELF32_R_TYPE (rel->r_info))
1288 {
1289 case R_SPARC_GNU_VTINHERIT:
1290 case R_SPARC_GNU_VTENTRY:
26e41594 1291 break;
252b5132
RH		 1292
1293 default:
26e41594
AM		 1294 switch (h->root.type)
1295 {
1296 case bfd_link_hash_defined:
1297 case bfd_link_hash_defweak:
1298 return h->root.u.def.section;
252b5132 1299
26e41594
AM		 1300 case bfd_link_hash_common:
1301 return h->root.u.c.p->section;
e049a0de
ILT		 1302
1303 default:
1304 break;
26e41594 1305 }
252b5132
RH		 1306 }
1307 }
1308 else
1e2f5b6e 1309 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
252b5132
RH		 1310
1311 return NULL;
1312}
1313
1314/* Update the got entry reference counts for the section being removed. */
b34976b6 1315static bfd_boolean
252b5132
RH		 1316elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
1317 bfd *abfd;
5f771d47 1318 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 1319 asection *sec;
1320 const Elf_Internal_Rela *relocs;
1321{
252b5132
RH		 1322 Elf_Internal_Shdr *symtab_hdr;
1323 struct elf_link_hash_entry **sym_hashes;
1324 bfd_signed_vma *local_got_refcounts;
1325 const Elf_Internal_Rela *rel, *relend;
26e41594
AM		 1326
1327 elf_section_data (sec)->local_dynrel = NULL;
252b5132
RH		 1328
1329 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1330 sym_hashes = elf_sym_hashes (abfd);
1331 local_got_refcounts = elf_local_got_refcounts (abfd);
1332
1333 relend = relocs + sec->reloc_count;
1334 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 1335 {
1336 unsigned long r_symndx;
1337 unsigned int r_type;
1338 struct elf_link_hash_entry *h = NULL;
b9734f35 1339
26e41594
AM		 1340 r_symndx = ELF32_R_SYM (rel->r_info);
1341 if (r_symndx >= symtab_hdr->sh_info)
1342 {
1343 struct elf32_sparc_link_hash_entry *eh;
1344 struct elf32_sparc_dyn_relocs **pp;
1345 struct elf32_sparc_dyn_relocs *p;
b9734f35 1346
26e41594 1347 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 1348 while (h->root.type == bfd_link_hash_indirect
1349 || h->root.type == bfd_link_hash_warning)
1350 h = (struct elf_link_hash_entry *) h->root.u.i.link;
26e41594
AM		 1351 eh = (struct elf32_sparc_link_hash_entry *) h;
1352 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1353 if (p->sec == sec)
1354 {
1355 /* Everything must go for SEC. */
1356 *pp = p->next;
1357 break;
1358 }
1359 }
b9734f35 1360
26e41594
AM		 1361 r_type = ELF32_R_TYPE (rel->r_info);
1362 r_type = elf32_sparc_tls_transition (info, abfd, r_type, h != NULL);
1363 switch (r_type)
1364 {
1365 case R_SPARC_TLS_LDM_HI22:
1366 case R_SPARC_TLS_LDM_LO10:
1367 if (elf32_sparc_hash_table (info)->tls_ldm_got.refcount > 0)
1368 elf32_sparc_hash_table (info)->tls_ldm_got.refcount -= 1;
1369 break;
b9734f35 1370
26e41594
AM		 1371 case R_SPARC_TLS_GD_HI22:
1372 case R_SPARC_TLS_GD_LO10:
1373 case R_SPARC_TLS_IE_HI22:
1374 case R_SPARC_TLS_IE_LO10:
1375 case R_SPARC_GOT10:
1376 case R_SPARC_GOT13:
1377 case R_SPARC_GOT22:
1378 if (h != NULL)
1379 {
1380 if (h->got.refcount > 0)
1381 h->got.refcount--;
1382 }
1383 else
1384 {
1385 if (local_got_refcounts[r_symndx] > 0)
1386 local_got_refcounts[r_symndx]--;
1387 }
1388 break;
b9734f35 1389
26e41594
AM		 1390 case R_SPARC_PC10:
1391 case R_SPARC_PC22:
1392 if (h != NULL
1393 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1394 break;
1395 /* Fall through. */
b9734f35 1396
26e41594
AM		 1397 case R_SPARC_DISP8:
1398 case R_SPARC_DISP16:
1399 case R_SPARC_DISP32:
1400 case R_SPARC_WDISP30:
1401 case R_SPARC_WDISP22:
1402 case R_SPARC_WDISP19:
1403 case R_SPARC_WDISP16:
1404 case R_SPARC_8:
1405 case R_SPARC_16:
1406 case R_SPARC_32:
1407 case R_SPARC_HI22:
1408 case R_SPARC_22:
1409 case R_SPARC_13:
1410 case R_SPARC_LO10:
1411 case R_SPARC_UA16:
1412 case R_SPARC_UA32:
1413 case R_SPARC_PLT32:
1414 if (info->shared)
1415 break;
1416 /* Fall through. */
b9734f35 1417
26e41594
AM		 1418 case R_SPARC_WPLT30:
1419 if (h != NULL)
1420 {
1421 if (h->plt.refcount > 0)
1422 h->plt.refcount--;
1423 }
1424 break;
252b5132 1425
26e41594
AM		 1426 default:
1427 break;
1428 }
1429 }
252b5132 1430
b34976b6 1431 return TRUE;
252b5132
RH		 1432}
1433
1434/* Adjust a symbol defined by a dynamic object and referenced by a
1435 regular object. The current definition is in some section of the
1436 dynamic object, but we're not including those sections. We have to
1437 change the definition to something the rest of the link can
1438 understand. */
1439
b34976b6 1440static bfd_boolean
252b5132
RH		 1441elf32_sparc_adjust_dynamic_symbol (info, h)
1442 struct bfd_link_info *info;
1443 struct elf_link_hash_entry *h;
1444{
b9734f35
JJ		 1445 struct elf32_sparc_link_hash_table *htab;
1446 struct elf32_sparc_link_hash_entry * eh;
1447 struct elf32_sparc_dyn_relocs *p;
252b5132
RH		 1448 asection *s;
1449 unsigned int power_of_two;
1450
b9734f35 1451 htab = elf32_sparc_hash_table (info);
252b5132
RH		 1452
1453 /* Make sure we know what is going on here. */
b9734f35 1454 BFD_ASSERT (htab->elf.dynobj != NULL
f5385ebf 1455 && (h->needs_plt
f6e332e6 1456 || h->u.weakdef != NULL
f5385ebf
AM		 1457 || (h->def_dynamic
1458 && h->ref_regular
1459 && !h->def_regular)));
252b5132
RH		 1460
1461 /* If this is a function, put it in the procedure linkage table. We
1462 will fill in the contents of the procedure linkage table later
1463 (although we could actually do it here). The STT_NOTYPE
1464 condition is a hack specifically for the Oracle libraries
1465 delivered for Solaris; for some inexplicable reason, they define
1466 some of their functions as STT_NOTYPE when they really should be
1467 STT_FUNC. */
1468 if (h->type == STT_FUNC
f5385ebf 1469 || h->needs_plt
252b5132
RH		 1470 || (h->type == STT_NOTYPE
1471 && (h->root.type == bfd_link_hash_defined
1472 || h->root.type == bfd_link_hash_defweak)
1473 && (h->root.u.def.section->flags & SEC_CODE) != 0))
1474 {
b9734f35
JJ		 1475 if (h->plt.refcount <= 0
1476 || (! info->shared
f5385ebf
AM		 1477 && !h->def_dynamic
1478 && !h->ref_dynamic
b9734f35
JJ		 1479 && h->root.type != bfd_link_hash_undefweak
1480 && h->root.type != bfd_link_hash_undefined))
252b5132
RH		 1481 {
1482 /* This case can occur if we saw a WPLT30 reloc in an input
b9734f35
JJ		 1483 file, but the symbol was never referred to by a dynamic
1484 object, or if all references were garbage collected. In
1485 such a case, we don't actually need to build a procedure
1486 linkage table, and we can just do a WDISP30 reloc instead. */
1487 h->plt.offset = (bfd_vma) -1;
f5385ebf 1488 h->needs_plt = 0;
252b5132
RH		 1489 }
1490
b34976b6 1491 return TRUE;
252b5132 1492 }
b9734f35
JJ		 1493 else
1494 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 1495
1496 /* If this is a weak symbol, and there is a real definition, the
1497 processor independent code will have arranged for us to see the
1498 real definition first, and we can just use the same value. */
f6e332e6 1499 if (h->u.weakdef != NULL)
252b5132 1500 {
f6e332e6
AM		 1501 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1502 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1503 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1504 h->root.u.def.value = h->u.weakdef->root.u.def.value;
b34976b6 1505 return TRUE;
252b5132
RH		 1506 }
1507
1508 /* This is a reference to a symbol defined by a dynamic object which
1509 is not a function. */
1510
1511 /* If we are creating a shared library, we must presume that the
1512 only references to the symbol are via the global offset table.
1513 For such cases we need not do anything here; the relocations will
1514 be handled correctly by relocate_section. */
1515 if (info->shared)
b34976b6 1516 return TRUE;
252b5132 1517
7843f00e
ILT		 1518 /* If there are no references to this symbol that do not use the
1519 GOT, we don't need to generate a copy reloc. */
f5385ebf 1520 if (!h->non_got_ref)
b34976b6 1521 return TRUE;
7843f00e 1522
b9734f35
JJ		 1523 eh = (struct elf32_sparc_link_hash_entry *) h;
1524 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1525 {
1526 s = p->sec->output_section;
1527 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1528 break;
1529 }
1530
1531 /* If we didn't find any dynamic relocs in read-only sections, then
1532 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1533 if (p == NULL)
1534 {
f5385ebf 1535 h->non_got_ref = 0;
b9734f35
JJ		 1536 return TRUE;
1537 }
1538
252b5132
RH		 1539 /* We must allocate the symbol in our .dynbss section, which will
1540 become part of the .bss section of the executable. There will be
1541 an entry for this symbol in the .dynsym section. The dynamic
1542 object will contain position independent code, so all references
1543 from the dynamic object to this symbol will go through the global
1544 offset table. The dynamic linker will use the .dynsym entry to
1545 determine the address it must put in the global offset table, so
1546 both the dynamic object and the regular object will refer to the
1547 same memory location for the variable. */
1548
b9734f35
JJ		 1549 /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
1550 to copy the initial value out of the dynamic object and into the
1551 runtime process image. We need to remember the offset into the
1552 .rel.bss section we are going to use. */
1553 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1554 {
eea6121a 1555 htab->srelbss->size += sizeof (Elf32_External_Rela);
f5385ebf 1556 h->needs_copy = 1;
b9734f35
JJ		 1557 }
1558
1559 /* We need to figure out the alignment required for this symbol. I
1560 have no idea how ELF linkers handle this. */
1561 power_of_two = bfd_log2 (h->size);
1562 if (power_of_two > 3)
1563 power_of_two = 3;
1564
1565 /* Apply the required alignment. */
1566 s = htab->sdynbss;
eea6121a 1567 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
b9734f35
JJ		 1568 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1569 {
1570 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1571 return FALSE;
1572 }
1573
1574 /* Define the symbol as being at this point in the section. */
1575 h->root.u.def.section = s;
eea6121a 1576 h->root.u.def.value = s->size;
b9734f35
JJ		 1577
1578 /* Increment the section size to make room for the symbol. */
eea6121a 1579 s->size += h->size;
b9734f35
JJ		 1580
1581 return TRUE;
1582}
1583
b9734f35
JJ		 1584/* Allocate space in .plt, .got and associated reloc sections for
1585 dynamic relocs. */
1586
1587static bfd_boolean
1588allocate_dynrelocs (h, inf)
1589 struct elf_link_hash_entry *h;
1590 PTR inf;
1591{
1592 struct bfd_link_info *info;
1593 struct elf32_sparc_link_hash_table *htab;
1594 struct elf32_sparc_link_hash_entry *eh;
1595 struct elf32_sparc_dyn_relocs *p;
1596
1597 if (h->root.type == bfd_link_hash_indirect)
1598 return TRUE;
1599
1600 if (h->root.type == bfd_link_hash_warning)
1601 /* When warning symbols are created, they **replace** the "real"
1602 entry in the hash table, thus we never get to see the real
1603 symbol in a hash traversal. So look at it now. */
1604 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1605
1606 info = (struct bfd_link_info *) inf;
1607 htab = elf32_sparc_hash_table (info);
1608
1609 if (htab->elf.dynamic_sections_created
1610 && h->plt.refcount > 0)
1611 {
1612 /* Make sure this symbol is output as a dynamic symbol.
1613 Undefined weak syms won't yet be marked as dynamic. */
1614 if (h->dynindx == -1
f5385ebf 1615 && !h->forced_local)
b9734f35 1616 {
c152c796 1617 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b9734f35
JJ		 1618 return FALSE;
1619 }
1620
c152c796 1621 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
b9734f35
JJ		 1622 {
1623 asection *s = htab->splt;
1624
1625 /* The first four entries in .plt are reserved. */
eea6121a
AM		 1626 if (s->size == 0)
1627 s->size = 4 * PLT_ENTRY_SIZE;
26e41594 1628
b9734f35 1629 /* The procedure linkage table has a maximum size. */
eea6121a 1630 if (s->size >= 0x400000)
b9734f35
JJ		 1631 {
1632 bfd_set_error (bfd_error_bad_value);
1633 return FALSE;
1634 }
1635
eea6121a 1636 h->plt.offset = s->size;
b9734f35
JJ		 1637
1638 /* If this symbol is not defined in a regular file, and we are
1639 not generating a shared library, then set the symbol to this
1640 location in the .plt. This is required to make function
1641 pointers compare as equal between the normal executable and
1642 the shared library. */
1643 if (! info->shared
f5385ebf 1644 && !h->def_regular)
b9734f35
JJ		 1645 {
1646 h->root.u.def.section = s;
1647 h->root.u.def.value = h->plt.offset;
1648 }
1649
1650 /* Make room for this entry. */
eea6121a 1651 s->size += PLT_ENTRY_SIZE;
b9734f35
JJ		 1652
1653 /* We also need to make an entry in the .rela.plt section. */
eea6121a 1654 htab->srelplt->size += sizeof (Elf32_External_Rela);
b9734f35
JJ		 1655 }
1656 else
1657 {
1658 h->plt.offset = (bfd_vma) -1;
f5385ebf 1659 h->needs_plt = 0;
b9734f35
JJ		 1660 }
1661 }
1662 else
1663 {
1664 h->plt.offset = (bfd_vma) -1;
f5385ebf 1665 h->needs_plt = 0;
b9734f35
JJ		 1666 }
1667
1668 /* If R_SPARC_TLS_IE_{HI22,LO10} symbol is now local to the binary,
1669 make it a R_SPARC_TLS_LE_{HI22,LO10} requiring no TLS entry. */
1670 if (h->got.refcount > 0
1671 && !info->shared
1672 && h->dynindx == -1
1673 && elf32_sparc_hash_entry(h)->tls_type == GOT_TLS_IE)
1674 h->got.offset = (bfd_vma) -1;
1675 else if (h->got.refcount > 0)
1676 {
1677 asection *s;
1678 bfd_boolean dyn;
1679 int tls_type = elf32_sparc_hash_entry(h)->tls_type;
1680
1681 /* Make sure this symbol is output as a dynamic symbol.
1682 Undefined weak syms won't yet be marked as dynamic. */
1683 if (h->dynindx == -1
f5385ebf 1684 && !h->forced_local)
b9734f35 1685 {
c152c796 1686 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b9734f35
JJ		 1687 return FALSE;
1688 }
1689
1690 s = htab->sgot;
eea6121a
AM		 1691 h->got.offset = s->size;
1692 s->size += 4;
b9734f35
JJ		 1693 /* R_SPARC_TLS_GD_HI{22,LO10} needs 2 consecutive GOT slots. */
1694 if (tls_type == GOT_TLS_GD)
eea6121a 1695 s->size += 4;
b9734f35
JJ		 1696 dyn = htab->elf.dynamic_sections_created;
1697 /* R_SPARC_TLS_IE_{HI22,LO10} needs one dynamic relocation,
1698 R_SPARC_TLS_GD_{HI22,LO10} needs one if local symbol and two if
1699 global. */
1700 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1701 || tls_type == GOT_TLS_IE)
eea6121a 1702 htab->srelgot->size += sizeof (Elf32_External_Rela);
b9734f35 1703 else if (tls_type == GOT_TLS_GD)
eea6121a 1704 htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
c152c796 1705 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
eea6121a 1706 htab->srelgot->size += sizeof (Elf32_External_Rela);
b9734f35
JJ		 1707 }
1708 else
1709 h->got.offset = (bfd_vma) -1;
1710
1711 eh = (struct elf32_sparc_link_hash_entry *) h;
1712 if (eh->dyn_relocs == NULL)
1713 return TRUE;
1714
1715 /* In the shared -Bsymbolic case, discard space allocated for
1716 dynamic pc-relative relocs against symbols which turn out to be
1717 defined in regular objects. For the normal shared case, discard
1718 space for pc-relative relocs that have become local due to symbol
1719 visibility changes. */
1720
1721 if (info->shared)
1722 {
f5385ebf
AM		 1723 if (h->def_regular
1724 && (h->forced_local
b9734f35
JJ		 1725 || info->symbolic))
1726 {
1727 struct elf32_sparc_dyn_relocs **pp;
1728
1729 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1730 {
1731 p->count -= p->pc_count;
1732 p->pc_count = 0;
1733 if (p->count == 0)
1734 *pp = p->next;
1735 else
1736 pp = &p->next;
1737 }
1738 }
1739 }
1740 else
1741 {
1742 /* For the non-shared case, discard space for relocs against
1743 symbols which turn out to need copy relocs or are not
1744 dynamic. */
1745
f5385ebf
AM		 1746 if (!h->non_got_ref
1747 && ((h->def_dynamic
1748 && !h->def_regular)
b9734f35
JJ		 1749 || (htab->elf.dynamic_sections_created
1750 && (h->root.type == bfd_link_hash_undefweak
1751 || h->root.type == bfd_link_hash_undefined))))
1752 {
1753 /* Make sure this symbol is output as a dynamic symbol.
1754 Undefined weak syms won't yet be marked as dynamic. */
1755 if (h->dynindx == -1
f5385ebf 1756 && !h->forced_local)
b9734f35 1757 {
c152c796 1758 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b9734f35
JJ		 1759 return FALSE;
1760 }
1761
1762 /* If that succeeded, we know we'll be keeping all the
1763 relocs. */
1764 if (h->dynindx != -1)
1765 goto keep;
1766 }
252b5132 1767
b9734f35 1768 eh->dyn_relocs = NULL;
252b5132 1769
b9734f35 1770 keep: ;
252b5132
RH		 1771 }
1772
b9734f35
JJ		 1773 /* Finally, allocate space. */
1774 for (p = eh->dyn_relocs; p != NULL; p = p->next)
252b5132 1775 {
b9734f35 1776 asection *sreloc = elf_section_data (p->sec)->sreloc;
eea6121a 1777 sreloc->size += p->count * sizeof (Elf32_External_Rela);
252b5132
RH		 1778 }
1779
b9734f35
JJ		 1780 return TRUE;
1781}
252b5132 1782
b9734f35 1783/* Find any dynamic relocs that apply to read-only sections. */
252b5132 1784
b9734f35
JJ		 1785static bfd_boolean
1786readonly_dynrelocs (h, inf)
1787 struct elf_link_hash_entry *h;
1788 PTR inf;
1789{
1790 struct elf32_sparc_link_hash_entry *eh;
1791 struct elf32_sparc_dyn_relocs *p;
1792
1793 if (h->root.type == bfd_link_hash_warning)
1794 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1795
1796 eh = (struct elf32_sparc_link_hash_entry *) h;
1797 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1798 {
1799 asection *s = p->sec->output_section;
1800
1801 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1802 {
1803 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1804
1805 info->flags |= DF_TEXTREL;
1806
1807 /* Not an error, just cut short the traversal. */
1808 return FALSE;
1809 }
1810 }
b34976b6 1811 return TRUE;
252b5132
RH		 1812}
1813
151e5294
EB		 1814/* Return true if the dynamic symbol for a given section should be
1815 omitted when creating a shared library. */
1816
1817static bfd_boolean
1818elf32_sparc_omit_section_dynsym (bfd *output_bfd,
1819 struct bfd_link_info *info,
1820 asection *p)
1821{
1822 /* We keep the .got section symbol so that explicit relocations
1823 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
1824 can be turned into relocations against the .got symbol. */
1825 if (strcmp (p->name, ".got") == 0)
1826 return FALSE;
1827
1828 return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
1829}
1830
252b5132
RH		 1831/* Set the sizes of the dynamic sections. */
1832
b34976b6 1833static bfd_boolean
252b5132 1834elf32_sparc_size_dynamic_sections (output_bfd, info)
db6751f2 1835 bfd *output_bfd ATTRIBUTE_UNUSED;
252b5132
RH		 1836 struct bfd_link_info *info;
1837{
b9734f35 1838 struct elf32_sparc_link_hash_table *htab;
252b5132
RH		 1839 bfd *dynobj;
1840 asection *s;
b9734f35 1841 bfd *ibfd;
252b5132 1842
b9734f35
JJ		 1843 htab = elf32_sparc_hash_table (info);
1844 dynobj = htab->elf.dynobj;
252b5132
RH		 1845 BFD_ASSERT (dynobj != NULL);
1846
1847 if (elf_hash_table (info)->dynamic_sections_created)
1848 {
1849 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 1850 if (info->executable)
252b5132
RH		 1851 {
1852 s = bfd_get_section_by_name (dynobj, ".interp");
1853 BFD_ASSERT (s != NULL);
eea6121a 1854 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
252b5132
RH		 1855 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1856 }
b9734f35 1857 }
252b5132 1858
b9734f35
JJ		 1859 /* Set up .got offsets for local syms, and space for local dynamic
1860 relocs. */
1861 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1862 {
1863 bfd_signed_vma *local_got;
1864 bfd_signed_vma *end_local_got;
1865 char *local_tls_type;
1866 bfd_size_type locsymcount;
1867 Elf_Internal_Shdr *symtab_hdr;
1868 asection *srel;
1869
1870 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1871 continue;
1872
1873 for (s = ibfd->sections; s != NULL; s = s->next)
1874 {
1875 struct elf32_sparc_dyn_relocs *p;
1876
1877 for (p = *((struct elf32_sparc_dyn_relocs **)
1878 &elf_section_data (s)->local_dynrel);
1879 p != NULL;
1880 p = p->next)
1881 {
1882 if (!bfd_is_abs_section (p->sec)
1883 && bfd_is_abs_section (p->sec->output_section))
1884 {
1885 /* Input section has been discarded, either because
1886 it is a copy of a linkonce section or due to
1887 linker script /DISCARD/, so we'll be discarding
1888 the relocs too. */
1889 }
1890 else if (p->count != 0)
1891 {
1892 srel = elf_section_data (p->sec)->sreloc;
eea6121a 1893 srel->size += p->count * sizeof (Elf32_External_Rela);
b9734f35
JJ		 1894 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1895 info->flags |= DF_TEXTREL;
1896 }
1897 }
1898 }
1899
1900 local_got = elf_local_got_refcounts (ibfd);
1901 if (!local_got)
1902 continue;
1903
1904 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1905 locsymcount = symtab_hdr->sh_info;
1906 end_local_got = local_got + locsymcount;
1907 local_tls_type = elf32_sparc_local_got_tls_type (ibfd);
1908 s = htab->sgot;
1909 srel = htab->srelgot;
1910 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1911 {
1912 if (*local_got > 0)
1913 {
eea6121a
AM		 1914 *local_got = s->size;
1915 s->size += 4;
b9734f35 1916 if (*local_tls_type == GOT_TLS_GD)
eea6121a 1917 s->size += 4;
b9734f35
JJ		 1918 if (info->shared
1919 || *local_tls_type == GOT_TLS_GD
1920 || *local_tls_type == GOT_TLS_IE)
eea6121a 1921 srel->size += sizeof (Elf32_External_Rela);
b9734f35
JJ		 1922 }
1923 else
1924 *local_got = (bfd_vma) -1;
1925 }
1926 }
1927
1928 if (htab->tls_ldm_got.refcount > 0)
1929 {
1930 /* Allocate 2 got entries and 1 dynamic reloc for
1931 R_SPARC_TLS_LDM_{HI22,LO10} relocs. */
eea6121a
AM		 1932 htab->tls_ldm_got.offset = htab->sgot->size;
1933 htab->sgot->size += 8;
1934 htab->srelgot->size += sizeof (Elf32_External_Rela);
252b5132
RH		 1935 }
1936 else
b9734f35
JJ		 1937 htab->tls_ldm_got.offset = -1;
1938
1939 /* Allocate global sym .plt and .got entries, and space for global
1940 sym dynamic relocs. */
1941 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1942
1943 if (elf_hash_table (info)->dynamic_sections_created)
252b5132 1944 {
b9734f35 1945 /* Make space for the trailing nop in .plt. */
eea6121a
AM		 1946 if (htab->splt->size > 0)
1947 htab->splt->size += 4;
b9734f35
JJ		 1948
1949 /* If the .got section is more than 0x1000 bytes, we add
1950 0x1000 to the value of _GLOBAL_OFFSET_TABLE_, so that 13
1951 bit relocations have a greater chance of working. */
eea6121a 1952 if (htab->sgot->size >= 0x1000
b9734f35
JJ		 1953 && elf_hash_table (info)->hgot->root.u.def.value == 0)
1954 elf_hash_table (info)->hgot->root.u.def.value = 0x1000;
252b5132
RH		 1955 }
1956
1957 /* The check_relocs and adjust_dynamic_symbol entry points have
1958 determined the sizes of the various dynamic sections. Allocate
1959 memory for them. */
252b5132
RH		 1960 for (s = dynobj->sections; s != NULL; s = s->next)
1961 {
1962 const char *name;
b9734f35 1963 bfd_boolean strip = FALSE;
252b5132
RH		 1964
1965 if ((s->flags & SEC_LINKER_CREATED) == 0)
1966 continue;
1967
1968 /* It's OK to base decisions on the section name, because none
1969 of the dynobj section names depend upon the input files. */
1970 name = bfd_get_section_name (dynobj, s);
1971
252b5132
RH		 1972 if (strncmp (name, ".rela", 5) == 0)
1973 {
eea6121a 1974 if (s->size == 0)
252b5132
RH		 1975 {
1976 /* If we don't need this section, strip it from the
1977 output file. This is to handle .rela.bss and
1978 .rel.plt. We must create it in
1979 create_dynamic_sections, because it must be created
1980 before the linker maps input sections to output
1981 sections. The linker does that before
1982 adjust_dynamic_symbol is called, and it is that
1983 function which decides whether anything needs to go
1984 into these sections. */
b34976b6 1985 strip = TRUE;
252b5132
RH		 1986 }
1987 else
1988 {
252b5132
RH		 1989 /* We use the reloc_count field as a counter if we need
1990 to copy relocs into the output file. */
1991 s->reloc_count = 0;
1992 }
1993 }
b9734f35 1994 else if (s != htab->splt && s != htab->sgot)
252b5132
RH		 1995 {
1996 /* It's not one of our sections, so don't allocate space. */
1997 continue;
1998 }
1999
2000 if (strip)
2001 {
7f8d5fc9 2002 _bfd_strip_section_from_output (info, s);
252b5132
RH		 2003 continue;
2004 }
2005
2006 /* Allocate memory for the section contents. */
7a9af8c4
NC		 2007 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
2008 Unused entries should be reclaimed before the section's contents
2009 are written out, but at the moment this does not happen. Thus in
2010 order to prevent writing out garbage, we initialise the section's
2011 contents to zero. */
eea6121a
AM		 2012 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2013 if (s->contents == NULL && s->size != 0)
b34976b6 2014 return FALSE;
252b5132
RH		 2015 }
2016
2017 if (elf_hash_table (info)->dynamic_sections_created)
2018 {
2019 /* Add some entries to the .dynamic section. We fill in the
2020 values later, in elf32_sparc_finish_dynamic_sections, but we
2021 must add the entries now so that we get the correct size for
2022 the .dynamic section. The DT_DEBUG entry is filled in by the
2023 dynamic linker and used by the debugger. */
dc810e39 2024#define add_dynamic_entry(TAG, VAL) \
5a580b3a 2025 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 2026
36af4a4e 2027 if (info->executable)
252b5132 2028 {
dc810e39 2029 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 2030 return FALSE;
252b5132
RH		 2031 }
2032
eea6121a 2033 if (htab->srelplt->size != 0)
252b5132 2034 {
dc810e39
AM		 2035 if (!add_dynamic_entry (DT_PLTGOT, 0)
2036 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2037 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2038 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 2039 return FALSE;
252b5132
RH		 2040 }
2041
dc810e39
AM		 2042 if (!add_dynamic_entry (DT_RELA, 0)
2043 || !add_dynamic_entry (DT_RELASZ, 0)
2044 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
b34976b6 2045 return FALSE;
252b5132 2046
b9734f35
JJ		 2047 /* If any dynamic relocs apply to a read-only section,
2048 then we need a DT_TEXTREL entry. */
2049 if ((info->flags & DF_TEXTREL) == 0)
2050 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2051 (PTR) info);
2052
db6751f2 2053 if (info->flags & DF_TEXTREL)
252b5132 2054 {
dc810e39 2055 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 2056 return FALSE;
252b5132
RH		 2057 }
2058 }
dc810e39 2059#undef add_dynamic_entry
252b5132 2060
b34976b6 2061 return TRUE;
252b5132
RH		 2062}
2063
f0abc2a1
AM		 2064struct elf32_sparc_section_data
2065{
2066 struct bfd_elf_section_data elf;
2067 unsigned int do_relax;
2068};
2069
2070#define sec_do_relax(sec) \
68bfbfcc 2071 ((struct elf32_sparc_section_data *) elf_section_data (sec))->do_relax
f0abc2a1
AM		 2072
2073static bfd_boolean
2074elf32_sparc_new_section_hook (abfd, sec)
2075 bfd *abfd;
2076 asection *sec;
2077{
2078 struct elf32_sparc_section_data *sdata;
2079 bfd_size_type amt = sizeof (*sdata);
2080
2081 sdata = (struct elf32_sparc_section_data *) bfd_zalloc (abfd, amt);
2082 if (sdata == NULL)
2083 return FALSE;
2084 sec->used_by_bfd = (PTR) sdata;
2085
2086 return _bfd_elf_new_section_hook (abfd, sec);
2087}
f7775d95 2088
b34976b6 2089static bfd_boolean
f7775d95
JJ		 2090elf32_sparc_relax_section (abfd, section, link_info, again)
2091 bfd *abfd ATTRIBUTE_UNUSED;
2092 asection *section ATTRIBUTE_UNUSED;
2093 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
b34976b6 2094 bfd_boolean *again;
f7775d95 2095{
b34976b6 2096 *again = FALSE;
f0abc2a1 2097 sec_do_relax (section) = 1;
b34976b6 2098 return TRUE;
f7775d95
JJ		 2099}
2100
b9734f35
JJ		 2101/* Return the base VMA address which should be subtracted from real addresses
2102 when resolving @dtpoff relocation.
2103 This is PT_TLS segment p_vaddr. */
2104
2105static bfd_vma
2106dtpoff_base (info)
2107 struct bfd_link_info *info;
2108{
e1918d23
AM		 2109 /* If tls_sec is NULL, we should have signalled an error already. */
2110 if (elf_hash_table (info)->tls_sec == NULL)
b9734f35 2111 return 0;
e1918d23 2112 return elf_hash_table (info)->tls_sec->vma;
b9734f35
JJ		 2113}
2114
2115/* Return the relocation value for @tpoff relocation
2116 if STT_TLS virtual address is ADDRESS. */
2117
2118static bfd_vma
2119tpoff (info, address)
2120 struct bfd_link_info *info;
2121 bfd_vma address;
2122{
e1918d23 2123 struct elf_link_hash_table *htab = elf_hash_table (info);
b9734f35 2124
e1918d23
AM		 2125 /* If tls_sec is NULL, we should have signalled an error already. */
2126 if (htab->tls_sec == NULL)
b9734f35 2127 return 0;
e1918d23 2128 return address - htab->tls_size - htab->tls_sec->vma;
b9734f35 2129}
e36f7d53 2130
252b5132
RH		 2131/* Relocate a SPARC ELF section. */
2132
b34976b6 2133static bfd_boolean
252b5132
RH		 2134elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
2135 contents, relocs, local_syms, local_sections)
2136 bfd *output_bfd;
2137 struct bfd_link_info *info;
2138 bfd *input_bfd;
2139 asection *input_section;
2140 bfd_byte *contents;
2141 Elf_Internal_Rela *relocs;
2142 Elf_Internal_Sym *local_syms;
2143 asection **local_sections;
2144{
b9734f35 2145 struct elf32_sparc_link_hash_table *htab;
252b5132
RH		 2146 Elf_Internal_Shdr *symtab_hdr;
2147 struct elf_link_hash_entry **sym_hashes;
2148 bfd_vma *local_got_offsets;
2149 bfd_vma got_base;
252b5132
RH		 2150 asection *sreloc;
2151 Elf_Internal_Rela *rel;
2152 Elf_Internal_Rela *relend;
2153
1049f94e 2154 if (info->relocatable)
b34976b6 2155 return TRUE;
f0fe0e16 2156
b9734f35 2157 htab = elf32_sparc_hash_table (info);
252b5132
RH		 2158 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2159 sym_hashes = elf_sym_hashes (input_bfd);
2160 local_got_offsets = elf_local_got_offsets (input_bfd);
2161
2162 if (elf_hash_table (info)->hgot == NULL)
2163 got_base = 0;
2164 else
2165 got_base = elf_hash_table (info)->hgot->root.u.def.value;
2166
b9734f35 2167 sreloc = elf_section_data (input_section)->sreloc;
252b5132
RH		 2168
2169 rel = relocs;
2170 relend = relocs + input_section->reloc_count;
2171 for (; rel < relend; rel++)
2172 {
b9734f35 2173 int r_type, tls_type;
252b5132
RH		 2174 reloc_howto_type *howto;
2175 unsigned long r_symndx;
2176 struct elf_link_hash_entry *h;
2177 Elf_Internal_Sym *sym;
2178 asection *sec;
e36f7d53 2179 bfd_vma relocation, off;
252b5132 2180 bfd_reloc_status_type r;
b34976b6
AM		 2181 bfd_boolean is_plt = FALSE;
2182 bfd_boolean unresolved_reloc;
252b5132
RH		 2183
2184 r_type = ELF32_R_TYPE (rel->r_info);
2185
435b1e90 2186 if (r_type == R_SPARC_GNU_VTINHERIT
26e41594
AM		 2187 || r_type == R_SPARC_GNU_VTENTRY)
2188 continue;
252b5132 2189
60dac299 2190 if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
252b5132
RH		 2191 {
2192 bfd_set_error (bfd_error_bad_value);
b34976b6 2193 return FALSE;
252b5132
RH		 2194 }
2195 howto = _bfd_sparc_elf_howto_table + r_type;
2196
252b5132 2197 /* This is a final link. */
f0fe0e16 2198 r_symndx = ELF32_R_SYM (rel->r_info);
252b5132
RH		 2199 h = NULL;
2200 sym = NULL;
2201 sec = NULL;
b34976b6 2202 unresolved_reloc = FALSE;
252b5132
RH		 2203 if (r_symndx < symtab_hdr->sh_info)
2204 {
2205 sym = local_syms + r_symndx;
2206 sec = local_sections[r_symndx];
8517fae7 2207 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
252b5132
RH		 2208 }
2209 else
2210 {
560e09e9 2211 bfd_boolean warned ATTRIBUTE_UNUSED;
e36f7d53 2212
b2a8e766
AM		 2213 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2214 r_symndx, symtab_hdr, sym_hashes,
2215 h, sec, relocation,
2216 unresolved_reloc, warned);
252b5132
RH		 2217 }
2218
2219 switch (r_type)
2220 {
2221 case R_SPARC_GOT10:
2222 case R_SPARC_GOT13:
2223 case R_SPARC_GOT22:
2224 /* Relocation is to the entry for this symbol in the global
26e41594 2225 offset table. */
b9734f35
JJ		 2226 if (htab->sgot == NULL)
2227 abort ();
252b5132
RH		 2228
2229 if (h != NULL)
2230 {
b34976b6 2231 bfd_boolean dyn;
252b5132
RH		 2232
2233 off = h->got.offset;
2234 BFD_ASSERT (off != (bfd_vma) -1);
e36f7d53 2235 dyn = elf_hash_table (info)->dynamic_sections_created;
252b5132 2236
c152c796 2237 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
252b5132 2238 || (info->shared
e36f7d53
RH		 2239 && (info->symbolic
2240 || h->dynindx == -1
f5385ebf
AM		 2241 || h->forced_local)
2242 && h->def_regular))
252b5132
RH		 2243 {
2244 /* This is actually a static link, or it is a
26e41594
AM		 2245 -Bsymbolic link and the symbol is defined
2246 locally, or the symbol was forced to be local
2247 because of a version file. We must initialize
2248 this entry in the global offset table. Since the
2249 offset must always be a multiple of 4, we use the
2250 least significant bit to record whether we have
2251 initialized it already.
252b5132
RH		 2252
2253 When doing a dynamic link, we create a .rela.got
2254 relocation entry to initialize the value. This
2255 is done in the finish_dynamic_symbol routine. */
2256 if ((off & 1) != 0)
2257 off &= ~1;
2258 else
2259 {
2260 bfd_put_32 (output_bfd, relocation,
b9734f35 2261 htab->sgot->contents + off);
252b5132
RH		 2262 h->got.offset |= 1;
2263 }
2264 }
e36f7d53 2265 else
b34976b6 2266 unresolved_reloc = FALSE;
252b5132
RH		 2267 }
2268 else
2269 {
252b5132
RH		 2270 BFD_ASSERT (local_got_offsets != NULL
2271 && local_got_offsets[r_symndx] != (bfd_vma) -1);
2272
2273 off = local_got_offsets[r_symndx];
2274
2275 /* The offset must always be a multiple of 4. We use
2276 the least significant bit to record whether we have
2277 already processed this entry. */
2278 if ((off & 1) != 0)
2279 off &= ~1;
2280 else
2281 {
252b5132
RH		 2282
2283 if (info->shared)
2284 {
b34976b6 2285 asection *s;
252b5132 2286 Elf_Internal_Rela outrel;
b34976b6 2287 bfd_byte *loc;
252b5132
RH		 2288
2289 /* We need to generate a R_SPARC_RELATIVE reloc
2290 for the dynamic linker. */
b9734f35 2291 s = htab->srelgot;
b34976b6 2292 BFD_ASSERT (s != NULL);
252b5132 2293
b9734f35
JJ		 2294 outrel.r_offset = (htab->sgot->output_section->vma
2295 + htab->sgot->output_offset
252b5132
RH		 2296 + off);
2297 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
6b3ac709
JJ		 2298 outrel.r_addend = relocation;
2299 relocation = 0;
b34976b6
AM		 2300 loc = s->contents;
2301 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
2302 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
252b5132
RH		 2303 }
2304
b9734f35
JJ		 2305 bfd_put_32 (output_bfd, relocation,
2306 htab->sgot->contents + off);
252b5132
RH		 2307 local_got_offsets[r_symndx] |= 1;
2308 }
252b5132 2309 }
b9734f35 2310 relocation = htab->sgot->output_offset + off - got_base;
252b5132
RH		 2311 break;
2312
bd5e6e7e
JJ		 2313 case R_SPARC_PLT32:
2314 if (h == NULL || h->plt.offset == (bfd_vma) -1)
2315 {
2316 r_type = R_SPARC_32;
2317 goto r_sparc_plt32;
2318 }
2319 /* Fall through. */
252b5132 2320 case R_SPARC_WPLT30:
b9734f35 2321 r_sparc_wplt30:
252b5132 2322 /* Relocation is to the entry for this symbol in the
26e41594 2323 procedure linkage table. */
252b5132
RH		 2324
2325 /* The Solaris native assembler will generate a WPLT30 reloc
2326 for a local symbol if you assemble a call from one
2327 section to another when using -K pic. We treat it as
2328 WDISP30. */
2329 if (h == NULL)
2330 break;
2331
6de00a78 2332 if (h->plt.offset == (bfd_vma) -1 || htab->splt == NULL)
252b5132
RH		 2333 {
2334 /* We didn't make a PLT entry for this symbol. This
26e41594
AM		 2335 happens when statically linking PIC code, or when
2336 using -Bsymbolic. */
252b5132
RH		 2337 break;
2338 }
2339
b9734f35
JJ		 2340 relocation = (htab->splt->output_section->vma
2341 + htab->splt->output_offset
252b5132 2342 + h->plt.offset);
b34976b6 2343 unresolved_reloc = FALSE;
bd5e6e7e
JJ		 2344 if (r_type == R_SPARC_PLT32)
2345 {
2346 r_type = R_SPARC_32;
b34976b6 2347 is_plt = TRUE;
bd5e6e7e
JJ		 2348 goto r_sparc_plt32;
2349 }
252b5132
RH		 2350 break;
2351
2352 case R_SPARC_PC10:
2353 case R_SPARC_PC22:
2354 if (h != NULL
2355 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2356 break;
2357 /* Fall through. */
2358 case R_SPARC_DISP8:
2359 case R_SPARC_DISP16:
2360 case R_SPARC_DISP32:
2361 case R_SPARC_WDISP30:
2362 case R_SPARC_WDISP22:
2363 case R_SPARC_WDISP19:
2364 case R_SPARC_WDISP16:
252b5132
RH		 2365 case R_SPARC_8:
2366 case R_SPARC_16:
2367 case R_SPARC_32:
2368 case R_SPARC_HI22:
2369 case R_SPARC_22:
2370 case R_SPARC_13:
2371 case R_SPARC_LO10:
0f2712ed 2372 case R_SPARC_UA16:
252b5132 2373 case R_SPARC_UA32:
bd5e6e7e 2374 r_sparc_plt32:
b9734f35
JJ		 2375 /* r_symndx will be zero only for relocs against symbols
2376 from removed linkonce sections, or sections discarded by
2377 a linker script. */
2378 if (r_symndx == 0
2379 || (input_section->flags & SEC_ALLOC) == 0)
2380 break;
2381
2382 if ((info->shared
4dc570c2
JJ		 2383 && (h == NULL
2384 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2385 || h->root.type != bfd_link_hash_undefweak)
b9734f35
JJ		 2386 && (! howto->pc_relative
2387 || (h != NULL
2388 && h->dynindx != -1
2389 && (! info->symbolic
f5385ebf 2390 || !h->def_regular))))
b9734f35
JJ		 2391 || (!info->shared
2392 && h != NULL
2393 && h->dynindx != -1
f5385ebf
AM		 2394 && !h->non_got_ref
2395 && ((h->def_dynamic
2396 && !h->def_regular)
b9734f35
JJ		 2397 || h->root.type == bfd_link_hash_undefweak
2398 || h->root.type == bfd_link_hash_undefined)))
252b5132
RH		 2399 {
2400 Elf_Internal_Rela outrel;
b34976b6
AM		 2401 bfd_byte *loc;
2402 bfd_boolean skip, relocate = FALSE;
252b5132
RH		 2403
2404 /* When generating a shared object, these relocations
26e41594
AM		 2405 are copied into the output file to be resolved at run
2406 time. */
252b5132 2407
b9734f35 2408 BFD_ASSERT (sreloc != NULL);
252b5132 2409
b34976b6 2410 skip = FALSE;
252b5132 2411
c629eae0
JJ		 2412 outrel.r_offset =
2413 _bfd_elf_section_offset (output_bfd, info, input_section,
2414 rel->r_offset);
2415 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 2416 skip = TRUE;
0bb2d96a 2417 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 2418 skip = TRUE, relocate = TRUE;
252b5132
RH		 2419 outrel.r_offset += (input_section->output_section->vma
2420 + input_section->output_offset);
2421
20278fa3
JJ		 2422 /* Optimize unaligned reloc usage now that we know where
2423 it finally resides. */
2424 switch (r_type)
2425 {
2426 case R_SPARC_16:
2427 if (outrel.r_offset & 1)
2428 r_type = R_SPARC_UA16;
2429 break;
2430 case R_SPARC_UA16:
2431 if (!(outrel.r_offset & 1))
2432 r_type = R_SPARC_16;
2433 break;
2434 case R_SPARC_32:
2435 if (outrel.r_offset & 3)
2436 r_type = R_SPARC_UA32;
2437 break;
2438 case R_SPARC_UA32:
2439 if (!(outrel.r_offset & 3))
2440 r_type = R_SPARC_32;
2441 break;
b88a866a
JJ		 2442 case R_SPARC_DISP8:
2443 case R_SPARC_DISP16:
2444 case R_SPARC_DISP32:
2445 /* If the symbol is not dynamic, we should not keep
2446 a dynamic relocation. But an .rela.* slot has been
2447 allocated for it, output R_SPARC_NONE.
2448 FIXME: Add code tracking needed dynamic relocs as
2449 e.g. i386 has. */
2450 if (h->dynindx == -1)
b34976b6 2451 skip = TRUE, relocate = TRUE;
b88a866a 2452 break;
20278fa3
JJ		 2453 }
2454
252b5132
RH		 2455 if (skip)
2456 memset (&outrel, 0, sizeof outrel);
2457 /* h->dynindx may be -1 if the symbol was marked to
26e41594 2458 become local. */
bd5e6e7e 2459 else if (h != NULL && ! is_plt
252b5132 2460 && ((! info->symbolic && h->dynindx != -1)
f5385ebf 2461 || !h->def_regular))
252b5132
RH		 2462 {
2463 BFD_ASSERT (h->dynindx != -1);
2464 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2465 outrel.r_addend = rel->r_addend;
2466 }
2467 else
2468 {
1fbc4a84 2469 if (r_type == R_SPARC_32)
252b5132
RH		 2470 {
2471 outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
2472 outrel.r_addend = relocation + rel->r_addend;
2473 }
2474 else
2475 {
2476 long indx;
2477
bd5e6e7e 2478 if (is_plt)
b9734f35 2479 sec = htab->splt;
8517fae7
AM		 2480
2481 if (bfd_is_abs_section (sec))
252b5132
RH		 2482 indx = 0;
2483 else if (sec == NULL || sec->owner == NULL)
2484 {
2485 bfd_set_error (bfd_error_bad_value);
b34976b6 2486 return FALSE;
252b5132
RH		 2487 }
2488 else
2489 {
2490 asection *osec;
2491
2492 osec = sec->output_section;
2493 indx = elf_section_data (osec)->dynindx;
2494
2495 /* FIXME: we really should be able to link non-pic
2496 shared libraries. */
2497 if (indx == 0)
2498 {
2499 BFD_FAIL ();
2500 (*_bfd_error_handler)
d003868e
AM		 2501 (_("%B: probably compiled without -fPIC?"),
2502 input_bfd);
252b5132 2503 bfd_set_error (bfd_error_bad_value);
b34976b6 2504 return FALSE;
252b5132
RH		 2505 }
2506 }
2507
2508 outrel.r_info = ELF32_R_INFO (indx, r_type);
840a9995 2509 outrel.r_addend = relocation + rel->r_addend;
252b5132
RH		 2510 }
2511 }
2512
b34976b6
AM		 2513 loc = sreloc->contents;
2514 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2515 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
252b5132
RH		 2516
2517 /* This reloc will be computed at runtime, so there's no
26e41594 2518 need to do anything now. */
0bb2d96a
JJ		 2519 if (! relocate)
2520 continue;
252b5132
RH		 2521 }
2522 break;
2523
b9734f35
JJ		 2524 case R_SPARC_TLS_GD_HI22:
2525 if (! elf32_sparc_tdata (input_bfd)->has_tlsgd)
2526 {
2527 /* R_SPARC_REV32 used the same reloc number as
2528 R_SPARC_TLS_GD_HI22. */
2529 r_type = R_SPARC_REV32;
2530 break;
2531 }
2532 /* Fall through */
2533
2534 case R_SPARC_TLS_GD_LO10:
2535 case R_SPARC_TLS_IE_HI22:
2536 case R_SPARC_TLS_IE_LO10:
2537 r_type = elf32_sparc_tls_transition (info, input_bfd, r_type,
2538 h == NULL);
2539 tls_type = GOT_UNKNOWN;
2540 if (h == NULL && local_got_offsets)
2541 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2542 else if (h != NULL)
2543 {
2544 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2545 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2546 switch (ELF32_R_TYPE (rel->r_info))
2547 {
2548 case R_SPARC_TLS_GD_HI22:
2549 case R_SPARC_TLS_IE_HI22:
2550 r_type = R_SPARC_TLS_LE_HIX22;
2551 break;
2552 default:
2553 r_type = R_SPARC_TLS_LE_LOX10;
2554 break;
2555 }
2556 }
2557 if (tls_type == GOT_TLS_IE)
2558 switch (r_type)
2559 {
2560 case R_SPARC_TLS_GD_HI22:
2561 r_type = R_SPARC_TLS_IE_HI22;
2562 break;
2563 case R_SPARC_TLS_GD_LO10:
2564 r_type = R_SPARC_TLS_IE_LO10;
2565 break;
2566 }
2567
2568 if (r_type == R_SPARC_TLS_LE_HIX22)
2569 {
2570 relocation = tpoff (info, relocation);
2571 break;
2572 }
2573 if (r_type == R_SPARC_TLS_LE_LOX10)
2574 {
2575 /* Change add into xor. */
2576 relocation = tpoff (info, relocation);
2577 bfd_put_32 (output_bfd, (bfd_get_32 (input_bfd,
2578 contents + rel->r_offset)
2579 | 0x80182000), contents + rel->r_offset);
2580 break;
2581 }
2582
26e41594 2583 if (h != NULL)
b9734f35
JJ		 2584 {
2585 off = h->got.offset;
2586 h->got.offset |= 1;
2587 }
2588 else
2589 {
2590 BFD_ASSERT (local_got_offsets != NULL);
2591 off = local_got_offsets[r_symndx];
2592 local_got_offsets[r_symndx] |= 1;
2593 }
26e41594 2594
b9734f35
JJ		 2595 r_sparc_tlsldm:
2596 if (htab->sgot == NULL)
2597 abort ();
2598
2599 if ((off & 1) != 0)
2600 off &= ~1;
26e41594 2601 else
b9734f35
JJ		 2602 {
2603 Elf_Internal_Rela outrel;
2604 Elf32_External_Rela *loc;
2605 int dr_type, indx;
2606
2607 if (htab->srelgot == NULL)
2608 abort ();
2609
2610 bfd_put_32 (output_bfd, 0, htab->sgot->contents + off);
2611 outrel.r_offset = (htab->sgot->output_section->vma
2612 + htab->sgot->output_offset + off);
2613 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2614 if (r_type == R_SPARC_TLS_IE_HI22
2615 || r_type == R_SPARC_TLS_IE_LO10)
2616 dr_type = R_SPARC_TLS_TPOFF32;
2617 else
2618 dr_type = R_SPARC_TLS_DTPMOD32;
2619 if (dr_type == R_SPARC_TLS_TPOFF32 && indx == 0)
2620 outrel.r_addend = relocation - dtpoff_base (info);
2621 else
2622 outrel.r_addend = 0;
2623 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2624 loc = (Elf32_External_Rela *) htab->srelgot->contents;
2625 loc += htab->srelgot->reloc_count++;
2626 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2627 (bfd_byte *) loc);
2628
2629 if (r_type == R_SPARC_TLS_GD_HI22
2630 || r_type == R_SPARC_TLS_GD_LO10)
2631 {
2632 if (indx == 0)
2633 {
2634 BFD_ASSERT (! unresolved_reloc);
2635 bfd_put_32 (output_bfd,
2636 relocation - dtpoff_base (info),
2637 htab->sgot->contents + off + 4);
2638 }
2639 else
2640 {
2641 bfd_put_32 (output_bfd, 0,
2642 htab->sgot->contents + off + 4);
2643 outrel.r_info = ELF32_R_INFO (indx,
2644 R_SPARC_TLS_DTPOFF32);
2645 outrel.r_offset += 4;
2646 htab->srelgot->reloc_count++;
2647 loc++;
2648 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2649 (bfd_byte *) loc);
2650 }
2651 }
2652 else if (dr_type == R_SPARC_TLS_DTPMOD32)
2653 {
2654 bfd_put_32 (output_bfd, 0,
2655 htab->sgot->contents + off + 4);
2656 }
2657 }
2658
2659 if (off >= (bfd_vma) -2)
2660 abort ();
2661
2662 relocation = htab->sgot->output_offset + off - got_base;
2663 unresolved_reloc = FALSE;
2664 howto = _bfd_sparc_elf_howto_table + r_type;
2665 break;
2666
2667 case R_SPARC_TLS_LDM_HI22:
2668 case R_SPARC_TLS_LDM_LO10:
2669 if (! info->shared)
2670 {
2671 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2672 continue;
2673 }
2674 off = htab->tls_ldm_got.offset;
2675 htab->tls_ldm_got.offset |= 1;
2676 goto r_sparc_tlsldm;
2677
2678 case R_SPARC_TLS_LDO_HIX22:
2679 case R_SPARC_TLS_LDO_LOX10:
2680 if (info->shared)
2681 relocation -= dtpoff_base (info);
2682 else
2683 relocation = tpoff (info, relocation);
2684 break;
2685
2686 case R_SPARC_TLS_LE_HIX22:
2687 case R_SPARC_TLS_LE_LOX10:
2688 if (info->shared)
2689 {
2690 Elf_Internal_Rela outrel;
2691 bfd_boolean skip, relocate = FALSE;
2692
2693 BFD_ASSERT (sreloc != NULL);
2694 skip = FALSE;
2695 outrel.r_offset =
2696 _bfd_elf_section_offset (output_bfd, info, input_section,
2697 rel->r_offset);
2698 if (outrel.r_offset == (bfd_vma) -1)
2699 skip = TRUE;
2700 else if (outrel.r_offset == (bfd_vma) -2)
2701 skip = TRUE, relocate = TRUE;
2702 outrel.r_offset += (input_section->output_section->vma
2703 + input_section->output_offset);
2704 if (skip)
2705 memset (&outrel, 0, sizeof outrel);
2706 else
2707 {
2708 outrel.r_info = ELF32_R_INFO (0, r_type);
2709 outrel.r_addend = relocation - dtpoff_base (info)
2710 + rel->r_addend;
2711 }
2712
2713 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2714 (bfd_byte *) (((Elf32_External_Rela *)
2715 sreloc->contents)
2716 + sreloc->reloc_count));
2717 ++sreloc->reloc_count;
2718 continue;
2719 }
2720 relocation = tpoff (info, relocation);
2721 break;
2722
2723 case R_SPARC_TLS_LDM_CALL:
2724 if (! info->shared)
2725 {
2726 /* mov %g0, %o0 */
2727 bfd_put_32 (output_bfd, 0x90100000, contents + rel->r_offset);
2728 continue;
2729 }
2730 /* Fall through */
2731
2732 case R_SPARC_TLS_GD_CALL:
2733 tls_type = GOT_UNKNOWN;
2734 if (h == NULL && local_got_offsets)
2735 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2736 else if (h != NULL)
2737 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2738 if (! info->shared
2739 || (r_type == R_SPARC_TLS_GD_CALL && tls_type == GOT_TLS_IE))
2740 {
2741 bfd_vma insn;
2742
2743 if (!info->shared && (h == NULL || h->dynindx == -1))
2744 {
2745 /* GD -> LE */
2746 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2747 continue;
2748 }
2749
2750 /* GD -> IE */
2751 if (rel + 1 < relend
2752 && ELF32_R_TYPE (rel[1].r_info) == R_SPARC_TLS_GD_ADD
2753 && rel[1].r_offset == rel->r_offset + 4
2754 && ELF32_R_SYM (rel[1].r_info) == r_symndx
2755 && (((insn = bfd_get_32 (input_bfd,
2756 contents + rel[1].r_offset))
2757 >> 25) & 0x1f) == 8)
2758 {
2759 /* We have
2760 call __tls_get_addr, %tgd_call(foo)
2761 add %reg1, %reg2, %o0, %tgd_add(foo)
2762 and change it into IE:
2763 ld [%reg1 + %reg2], %o0, %tie_ld(foo)
2764 add %g7, %o0, %o0, %tie_add(foo).
2765 add is 0x80000000 | (rd << 25) | (rs1 << 14) | rs2,
2766 ld is 0xc0000000 | (rd << 25) | (rs1 << 14) | rs2. */
2767 bfd_put_32 (output_bfd, insn | 0xc0000000,
2768 contents + rel->r_offset);
2769 bfd_put_32 (output_bfd, 0x9001c008,
2770 contents + rel->r_offset + 4);
2771 rel++;
2772 continue;
2773 }
2774
2775 bfd_put_32 (output_bfd, 0x9001c008, contents + rel->r_offset);
2776 continue;
2777 }
2778
2779 h = (struct elf_link_hash_entry *)
2780 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
2781 FALSE, TRUE);
2782 BFD_ASSERT (h != NULL);
2783 r_type = R_SPARC_WPLT30;
2784 howto = _bfd_sparc_elf_howto_table + r_type;
2785 goto r_sparc_wplt30;
2786
2787 case R_SPARC_TLS_GD_ADD:
2788 tls_type = GOT_UNKNOWN;
2789 if (h == NULL && local_got_offsets)
2790 tls_type = elf32_sparc_local_got_tls_type (input_bfd) [r_symndx];
2791 else if (h != NULL)
2792 tls_type = elf32_sparc_hash_entry(h)->tls_type;
2793 if (! info->shared || tls_type == GOT_TLS_IE)
2794 {
2795 /* add %reg1, %reg2, %reg3, %tgd_add(foo)
2796 changed into IE:
2797 ld [%reg1 + %reg2], %reg3, %tie_ld(foo)
2798 or LE:
2799 add %g7, %reg2, %reg3. */
2800 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2801 if ((h != NULL && h->dynindx != -1) || info->shared)
2802 relocation = insn | 0xc0000000;
2803 else
2804 relocation = (insn & ~0x7c000) | 0x1c000;
2805 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2806 }
2807 continue;
2808
2809 case R_SPARC_TLS_LDM_ADD:
2810 if (! info->shared)
2811 bfd_put_32 (output_bfd, SPARC_NOP, contents + rel->r_offset);
2812 continue;
2813
2814 case R_SPARC_TLS_LDO_ADD:
2815 if (! info->shared)
2816 {
2817 /* Change rs1 into %g7. */
2818 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2819 insn = (insn & ~0x7c000) | 0x1c000;
2820 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
2821 }
2822 continue;
2823
2824 case R_SPARC_TLS_IE_LD:
2825 case R_SPARC_TLS_IE_LDX:
2826 if (! info->shared && (h == NULL || h->dynindx == -1))
2827 {
2828 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2829 int rs2 = insn & 0x1f;
2830 int rd = (insn >> 25) & 0x1f;
2831
2832 if (rs2 == rd)
2833 relocation = SPARC_NOP;
2834 else
2835 relocation = 0x80100000 | (insn & 0x3e00001f);
2836 bfd_put_32 (output_bfd, relocation, contents + rel->r_offset);
2837 }
2838 continue;
2839
2840 case R_SPARC_TLS_IE_ADD:
2841 /* Totally useless relocation. */
2842 continue;
2843
2844 case R_SPARC_TLS_DTPOFF32:
2845 relocation -= dtpoff_base (info);
2846 break;
2847
252b5132
RH		 2848 default:
2849 break;
2850 }
2851
239e1f3a
AM		 2852 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2853 because such sections are not SEC_ALLOC and thus ld.so will
2854 not process them. */
e36f7d53 2855 if (unresolved_reloc
239e1f3a 2856 && !((input_section->flags & SEC_DEBUGGING) != 0
f5385ebf 2857 && h->def_dynamic))
e36f7d53 2858 (*_bfd_error_handler)
d003868e
AM		 2859 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
2860 input_bfd,
2861 input_section,
e36f7d53
RH		 2862 (long) rel->r_offset,
2863 h->root.root.string);
2864
f7775d95 2865 r = bfd_reloc_continue;
252b5132
RH		 2866 if (r_type == R_SPARC_WDISP16)
2867 {
2868 bfd_vma x;
2869
2870 relocation += rel->r_addend;
2871 relocation -= (input_section->output_section->vma
2872 + input_section->output_offset);
2873 relocation -= rel->r_offset;
2874
2875 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2876 x |= ((((relocation >> 2) & 0xc000) << 6)
2877 | ((relocation >> 2) & 0x3fff));
2878 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2879
2880 if ((bfd_signed_vma) relocation < - 0x40000
2881 || (bfd_signed_vma) relocation > 0x3ffff)
2882 r = bfd_reloc_overflow;
2883 else
2884 r = bfd_reloc_ok;
2885 }
2886 else if (r_type == R_SPARC_REV32)
2887 {
2888 bfd_vma x;
2889
2890 relocation = relocation + rel->r_addend;
2891
2892 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2893 x = x + relocation;
2894 bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
b9734f35
JJ		 2895 r = bfd_reloc_ok;
2896 }
2897 else if (r_type == R_SPARC_TLS_LDO_HIX22
2898 || r_type == R_SPARC_TLS_LE_HIX22)
2899 {
2900 bfd_vma x;
2901
2902 relocation += rel->r_addend;
2903 relocation = relocation ^ 0xffffffff;
2904
2905 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2906 x = (x & ~(bfd_vma) 0x3fffff) | ((relocation >> 10) & 0x3fffff);
2907 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2908 r = bfd_reloc_ok;
2909 }
2910 else if (r_type == R_SPARC_TLS_LDO_LOX10
2911 || r_type == R_SPARC_TLS_LE_LOX10)
2912 {
2913 bfd_vma x;
2914
2915 relocation += rel->r_addend;
2916 relocation = (relocation & 0x3ff) | 0x1c00;
2917
2918 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2919 x = (x & ~(bfd_vma) 0x1fff) | relocation;
2920 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2921
252b5132
RH		 2922 r = bfd_reloc_ok;
2923 }
f7775d95 2924 else if ((r_type == R_SPARC_WDISP30 || r_type == R_SPARC_WPLT30)
f0abc2a1 2925 && sec_do_relax (input_section)
eea6121a 2926 && rel->r_offset + 4 < input_section->size)
f7775d95
JJ		 2927 {
2928#define G0 0
2929#define O7 15
2930#define XCC (2 << 20)
2931#define COND(x) (((x)&0xf)<<25)
2932#define CONDA COND(0x8)
2933#define INSN_BPA (F2(0,1) | CONDA | BPRED | XCC)
2934#define INSN_BA (F2(0,2) | CONDA)
2935#define INSN_OR F3(2, 0x2, 0)
2936#define INSN_NOP F2(0,4)
2937
2938 bfd_vma x, y;
2939
2940 /* If the instruction is a call with either:
2941 restore
2942 arithmetic instruction with rd == %o7
2943 where rs1 != %o7 and rs2 if it is register != %o7
2944 then we can optimize if the call destination is near
2945 by changing the call into a branch always. */
2946 x = bfd_get_32 (input_bfd, contents + rel->r_offset);
2947 y = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
2948 if ((x & OP(~0)) == OP(1) && (y & OP(~0)) == OP(2))
2949 {
2950 if (((y & OP3(~0)) == OP3(0x3d) /* restore */
2951 || ((y & OP3(0x28)) == 0 /* arithmetic */
2952 && (y & RD(~0)) == RD(O7)))
2953 && (y & RS1(~0)) != RS1(O7)
2954 && ((y & F3I(~0))
2955 || (y & RS2(~0)) != RS2(O7)))
2956 {
2957 bfd_vma reloc;
2958
2959 reloc = relocation + rel->r_addend - rel->r_offset;
2960 reloc -= (input_section->output_section->vma
2961 + input_section->output_offset);
2962
2963 /* Ensure the reloc fits into simm22. */
2964 if ((reloc & 3) == 0
2965 && ((reloc & ~(bfd_vma)0x7fffff) == 0
2966 || ((reloc | 0x7fffff) == ~(bfd_vma)0)))
2967 {
2968 reloc >>= 2;
435b1e90 2969
f7775d95
JJ		 2970 /* Check whether it fits into simm19 on v9. */
2971 if (((reloc & 0x3c0000) == 0
2972 || (reloc & 0x3c0000) == 0x3c0000)
2973 && (elf_elfheader (output_bfd)->e_flags & EF_SPARC_32PLUS))
2974 x = INSN_BPA | (reloc & 0x7ffff); /* ba,pt %xcc */
2975 else
2976 x = INSN_BA | (reloc & 0x3fffff); /* ba */
2977 bfd_put_32 (input_bfd, x, contents + rel->r_offset);
2978 r = bfd_reloc_ok;
2979 if (rel->r_offset >= 4
2980 && (y & (0xffffffff ^ RS1(~0)))
2981 == (INSN_OR | RD(O7) | RS2(G0)))
2982 {
2983 bfd_vma z;
2984 unsigned int reg;
2985
2986 z = bfd_get_32 (input_bfd,
2987 contents + rel->r_offset - 4);
2988 if ((z & (0xffffffff ^ RD(~0)))
2989 != (INSN_OR | RS1(O7) | RS2(G0)))
2990 break;
2991
2992 /* The sequence was
2993 or %o7, %g0, %rN
2994 call foo
2995 or %rN, %g0, %o7
2996
2997 If call foo was replaced with ba, replace
2998 or %rN, %g0, %o7 with nop. */
2999
3000 reg = (y & RS1(~0)) >> 14;
3001 if (reg != ((z & RD(~0)) >> 25)
3002 || reg == G0 || reg == O7)
3003 break;
3004
dc810e39 3005 bfd_put_32 (input_bfd, (bfd_vma) INSN_NOP,
f7775d95
JJ		 3006 contents + rel->r_offset + 4);
3007 }
3008
3009 }
3010 }
3011 }
3012 }
3013
3014 if (r == bfd_reloc_continue)
252b5132
RH		 3015 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3016 contents, rel->r_offset,
3017 relocation, rel->r_addend);
3018
252b5132
RH		 3019 if (r != bfd_reloc_ok)
3020 {
3021 switch (r)
3022 {
3023 default:
3024 case bfd_reloc_outofrange:
3025 abort ();
3026 case bfd_reloc_overflow:
3027 {
3028 const char *name;
3029
3030 if (h != NULL)
dfeffb9f 3031 name = NULL;
252b5132
RH		 3032 else
3033 {
3034 name = bfd_elf_string_from_elf_section (input_bfd,
3035 symtab_hdr->sh_link,
3036 sym->st_name);
3037 if (name == NULL)
b34976b6 3038 return FALSE;
252b5132
RH		 3039 if (*name == '\0')
3040 name = bfd_section_name (input_bfd, sec);
3041 }
3042 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 3043 (info, (h ? &h->root : NULL), name, howto->name,
3044 (bfd_vma) 0, input_bfd, input_section,
3045 rel->r_offset)))
b34976b6 3046 return FALSE;
252b5132
RH		 3047 }
3048 break;
3049 }
3050 }
3051 }
3052
b34976b6 3053 return TRUE;
252b5132
RH		 3054}
3055
3056/* Finish up dynamic symbol handling. We set the contents of various
3057 dynamic sections here. */
3058
b34976b6 3059static bfd_boolean
252b5132
RH		 3060elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
3061 bfd *output_bfd;
3062 struct bfd_link_info *info;
3063 struct elf_link_hash_entry *h;
3064 Elf_Internal_Sym *sym;
3065{
3066 bfd *dynobj;
b9734f35 3067 struct elf32_sparc_link_hash_table *htab;
26e41594 3068
b9734f35
JJ		 3069 htab = elf32_sparc_hash_table (info);
3070 dynobj = htab->elf.dynobj;
252b5132
RH		 3071
3072 if (h->plt.offset != (bfd_vma) -1)
3073 {
3074 asection *splt;
3075 asection *srela;
3076 Elf_Internal_Rela rela;
b34976b6 3077 bfd_byte *loc;
252b5132
RH		 3078
3079 /* This symbol has an entry in the procedure linkage table. Set
26e41594 3080 it up. */
252b5132
RH		 3081
3082 BFD_ASSERT (h->dynindx != -1);
3083
b9734f35
JJ		 3084 splt = htab->splt;
3085 srela = htab->srelplt;
252b5132
RH		 3086 BFD_ASSERT (splt != NULL && srela != NULL);
3087
3088 /* Fill in the entry in the procedure linkage table. */
3089 bfd_put_32 (output_bfd,
3090 PLT_ENTRY_WORD0 + h->plt.offset,
3091 splt->contents + h->plt.offset);
3092 bfd_put_32 (output_bfd,
3093 (PLT_ENTRY_WORD1
3094 + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
3095 splt->contents + h->plt.offset + 4);
dc810e39 3096 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
252b5132
RH		 3097 splt->contents + h->plt.offset + 8);
3098
3099 /* Fill in the entry in the .rela.plt section. */
3100 rela.r_offset = (splt->output_section->vma
3101 + splt->output_offset
3102 + h->plt.offset);
3103 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
3104 rela.r_addend = 0;
b34976b6
AM		 3105 loc = srela->contents;
3106 loc += (h->plt.offset / PLT_ENTRY_SIZE - 4) * sizeof (Elf32_External_Rela);
3107 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
252b5132 3108
f5385ebf 3109 if (!h->def_regular)
252b5132
RH		 3110 {
3111 /* Mark the symbol as undefined, rather than as defined in
3112 the .plt section. Leave the value alone. */
3113 sym->st_shndx = SHN_UNDEF;
8701c1bc
JJ		 3114 /* If the symbol is weak, we do need to clear the value.
3115 Otherwise, the PLT entry would provide a definition for
3116 the symbol even if the symbol wasn't defined anywhere,
3117 and so the symbol would never be NULL. */
f5385ebf 3118 if (!h->ref_regular_nonweak)
8701c1bc 3119 sym->st_value = 0;
252b5132
RH		 3120 }
3121 }
3122
b9734f35
JJ		 3123 if (h->got.offset != (bfd_vma) -1
3124 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_GD
3125 && elf32_sparc_hash_entry(h)->tls_type != GOT_TLS_IE)
252b5132
RH		 3126 {
3127 asection *sgot;
3128 asection *srela;
3129 Elf_Internal_Rela rela;
b34976b6 3130 bfd_byte *loc;
252b5132
RH		 3131
3132 /* This symbol has an entry in the global offset table. Set it
26e41594 3133 up. */
252b5132 3134
b9734f35
JJ		 3135 sgot = htab->sgot;
3136 srela = htab->srelgot;
252b5132
RH		 3137 BFD_ASSERT (sgot != NULL && srela != NULL);
3138
3139 rela.r_offset = (sgot->output_section->vma
3140 + sgot->output_offset
dc810e39 3141 + (h->got.offset &~ (bfd_vma) 1));
252b5132
RH		 3142
3143 /* If this is a -Bsymbolic link, and the symbol is defined
3144 locally, we just want to emit a RELATIVE reloc. Likewise if
3145 the symbol was forced to be local because of a version file.
3146 The entry in the global offset table will already have been
3147 initialized in the relocate_section function. */
3148 if (info->shared
3149 && (info->symbolic || h->dynindx == -1)
f5385ebf 3150 && h->def_regular)
6b3ac709
JJ		 3151 {
3152 asection *sec = h->root.u.def.section;
3153 rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
3154 rela.r_addend = (h->root.u.def.value
3155 + sec->output_section->vma
3156 + sec->output_offset);
3157 }
252b5132
RH		 3158 else
3159 {
252b5132 3160 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
6b3ac709 3161 rela.r_addend = 0;
252b5132
RH		 3162 }
3163
6b3ac709
JJ		 3164 bfd_put_32 (output_bfd, (bfd_vma) 0,
3165 sgot->contents + (h->got.offset &~ (bfd_vma) 1));
b34976b6
AM		 3166 loc = srela->contents;
3167 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3168 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
252b5132
RH		 3169 }
3170
f5385ebf 3171 if (h->needs_copy)
252b5132
RH		 3172 {
3173 asection *s;
3174 Elf_Internal_Rela rela;
b34976b6 3175 bfd_byte *loc;
252b5132
RH		 3176
3177 /* This symbols needs a copy reloc. Set it up. */
3178
3179 BFD_ASSERT (h->dynindx != -1);
3180
3181 s = bfd_get_section_by_name (h->root.u.def.section->owner,
3182 ".rela.bss");
3183 BFD_ASSERT (s != NULL);
3184
3185 rela.r_offset = (h->root.u.def.value
3186 + h->root.u.def.section->output_section->vma
3187 + h->root.u.def.section->output_offset);
3188 rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
3189 rela.r_addend = 0;
b34976b6
AM		 3190 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3191 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
252b5132
RH		 3192 }
3193
3194 /* Mark some specially defined symbols as absolute. */
3195 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3196 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3197 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3198 sym->st_shndx = SHN_ABS;
3199
b34976b6 3200 return TRUE;
252b5132
RH		 3201}
3202
3203/* Finish up the dynamic sections. */
3204
b34976b6 3205static bfd_boolean
252b5132
RH		 3206elf32_sparc_finish_dynamic_sections (output_bfd, info)
3207 bfd *output_bfd;
3208 struct bfd_link_info *info;
3209{
3210 bfd *dynobj;
3211 asection *sdyn;
b9734f35 3212 struct elf32_sparc_link_hash_table *htab;
26e41594 3213
b9734f35
JJ		 3214 htab = elf32_sparc_hash_table (info);
3215 dynobj = htab->elf.dynobj;
252b5132
RH		 3216
3217 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3218
3219 if (elf_hash_table (info)->dynamic_sections_created)
3220 {
3221 asection *splt;
3222 Elf32_External_Dyn *dyncon, *dynconend;
3223
3224 splt = bfd_get_section_by_name (dynobj, ".plt");
3225 BFD_ASSERT (splt != NULL && sdyn != NULL);
3226
3227 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 3228 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
252b5132
RH		 3229 for (; dyncon < dynconend; dyncon++)
3230 {
3231 Elf_Internal_Dyn dyn;
3232 const char *name;
b34976b6 3233 bfd_boolean size;
252b5132
RH		 3234
3235 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3236
3237 switch (dyn.d_tag)
3238 {
b34976b6
AM		 3239 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
3240 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
3241 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
3242 default: name = NULL; size = FALSE; break;
252b5132
RH		 3243 }
3244
3245 if (name != NULL)
3246 {
3247 asection *s;
3248
3249 s = bfd_get_section_by_name (output_bfd, name);
3250 if (s == NULL)
3251 dyn.d_un.d_val = 0;
3252 else
3253 {
3254 if (! size)
3255 dyn.d_un.d_ptr = s->vma;
3256 else
eea6121a 3257 dyn.d_un.d_val = s->size;
252b5132
RH		 3258 }
3259 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3260 }
3261 }
3262
3263 /* Clear the first four entries in the procedure linkage table,
3264 and put a nop in the last four bytes. */
eea6121a 3265 if (splt->size > 0)
252b5132
RH		 3266 {
3267 memset (splt->contents, 0, 4 * PLT_ENTRY_SIZE);
dc810e39 3268 bfd_put_32 (output_bfd, (bfd_vma) SPARC_NOP,
eea6121a 3269 splt->contents + splt->size - 4);
252b5132
RH		 3270 }
3271
a8a6d7ce 3272 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
252b5132
RH		 3273 }
3274
3275 /* Set the first entry in the global offset table to the address of
3276 the dynamic section. */
eea6121a 3277 if (htab->sgot && htab->sgot->size > 0)
252b5132
RH		 3278 {
3279 if (sdyn == NULL)
b9734f35 3280 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgot->contents);
252b5132
RH		 3281 else
3282 bfd_put_32 (output_bfd,
3283 sdyn->output_section->vma + sdyn->output_offset,
b9734f35 3284 htab->sgot->contents);
252b5132
RH		 3285 }
3286
b9734f35
JJ		 3287 if (htab->sgot)
3288 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
252b5132 3289
b34976b6 3290 return TRUE;
252b5132
RH		 3291}
3292\f
3293/* Functions for dealing with the e_flags field.
3294
3295 We don't define set_private_flags or copy_private_bfd_data because
3296 the only currently defined values are based on the bfd mach number,
3297 so we use the latter instead and defer setting e_flags until the
3298 file is written out. */
3299
3300/* Merge backend specific data from an object file to the output
3301 object file when linking. */
3302
b34976b6 3303static bfd_boolean
252b5132
RH		 3304elf32_sparc_merge_private_bfd_data (ibfd, obfd)
3305 bfd *ibfd;
3306 bfd *obfd;
3307{
b34976b6 3308 bfd_boolean error;
7946e94a 3309 unsigned long ibfd_mach;
5f771d47
ILT		 3310 /* FIXME: This should not be static. */
3311 static unsigned long previous_ibfd_e_flags = (unsigned long) -1;
252b5132
RH		 3312
3313 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3314 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 3315 return TRUE;
252b5132 3316
b34976b6 3317 error = FALSE;
252b5132 3318
7946e94a
JJ		 3319 ibfd_mach = bfd_get_mach (ibfd);
3320 if (bfd_mach_sparc_64bit_p (ibfd_mach))
252b5132 3321 {
b34976b6 3322 error = TRUE;
252b5132 3323 (*_bfd_error_handler)
d003868e 3324 (_("%B: compiled for a 64 bit system and target is 32 bit"), ibfd);
252b5132 3325 }
37fb6db1
ILT		 3326 else if ((ibfd->flags & DYNAMIC) == 0)
3327 {
7946e94a
JJ		 3328 if (bfd_get_mach (obfd) < ibfd_mach)
3329 bfd_set_arch_mach (obfd, bfd_arch_sparc, ibfd_mach);
37fb6db1 3330 }
252b5132
RH		 3331
3332 if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
3333 != previous_ibfd_e_flags)
5f771d47 3334 && previous_ibfd_e_flags != (unsigned long) -1)
252b5132
RH		 3335 {
3336 (*_bfd_error_handler)
d003868e 3337 (_("%B: linking little endian files with big endian files"), ibfd);
b34976b6 3338 error = TRUE;
252b5132
RH		 3339 }
3340 previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
3341
3342 if (error)
3343 {
3344 bfd_set_error (bfd_error_bad_value);
b34976b6 3345 return FALSE;
252b5132
RH		 3346 }
3347
b34976b6 3348 return TRUE;
252b5132
RH		 3349}
3350\f
3351/* Set the right machine number. */
3352
b34976b6 3353static bfd_boolean
252b5132
RH		 3354elf32_sparc_object_p (abfd)
3355 bfd *abfd;
3356{
3357 if (elf_elfheader (abfd)->e_machine == EM_SPARC32PLUS)
3358 {
19f7b010
JJ		 3359 if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US3)
3360 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3361 bfd_mach_sparc_v8plusb);
3362 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_SUN_US1)
252b5132
RH		 3363 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3364 bfd_mach_sparc_v8plusa);
3365 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_32PLUS)
3366 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
3367 bfd_mach_sparc_v8plus);
3368 else
b34976b6 3369 return FALSE;
252b5132
RH		 3370 }
3371 else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
3372 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
20278fa3 3373 bfd_mach_sparc_sparclite_le);
252b5132
RH		 3374 else
3375 return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
3376}
3377
3378/* The final processing done just before writing out the object file.
3379 We need to set the e_machine field appropriately. */
3380
3381static void
3382elf32_sparc_final_write_processing (abfd, linker)
3383 bfd *abfd;
b34976b6 3384 bfd_boolean linker ATTRIBUTE_UNUSED;
252b5132
RH		 3385{
3386 switch (bfd_get_mach (abfd))
3387 {
3388 case bfd_mach_sparc :
fca870e4
AM		 3389 case bfd_mach_sparc_sparclet :
3390 case bfd_mach_sparc_sparclite :
252b5132
RH		 3391 break; /* nothing to do */
3392 case bfd_mach_sparc_v8plus :
3393 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3394 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3395 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS;
3396 break;
3397 case bfd_mach_sparc_v8plusa :
3398 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3399 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3400 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
3401 break;
19f7b010
JJ		 3402 case bfd_mach_sparc_v8plusb :
3403 elf_elfheader (abfd)->e_machine = EM_SPARC32PLUS;
3404 elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
3405 elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1
3406 | EF_SPARC_SUN_US3;
3407 break;
252b5132 3408 case bfd_mach_sparc_sparclite_le :
252b5132
RH		 3409 elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
3410 break;
3411 default :
3412 abort ();
3413 break;
3414 }
3415}
db6751f2
JJ		 3416
3417static enum elf_reloc_type_class
f51e552e
AM		 3418elf32_sparc_reloc_type_class (rela)
3419 const Elf_Internal_Rela *rela;
db6751f2 3420{
f51e552e 3421 switch ((int) ELF32_R_TYPE (rela->r_info))
db6751f2
JJ		 3422 {
3423 case R_SPARC_RELATIVE:
3424 return reloc_class_relative;
3425 case R_SPARC_JMP_SLOT:
3426 return reloc_class_plt;
3427 case R_SPARC_COPY:
3428 return reloc_class_copy;
3429 default:
3430 return reloc_class_normal;
3431 }
3432}
4c45e5c9
JJ		 3433
3434/* Return address for Ith PLT stub in section PLT, for relocation REL
3435 or (bfd_vma) -1 if it should not be included. */
3436
3437static bfd_vma
3438elf32_sparc_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED,
3439 const asection *plt ATTRIBUTE_UNUSED,
3440 const arelent *rel)
3441{
3442 return rel->address;
3443}
252b5132
RH		 3444\f
3445#define TARGET_BIG_SYM bfd_elf32_sparc_vec
3446#define TARGET_BIG_NAME "elf32-sparc"
3447#define ELF_ARCH bfd_arch_sparc
3448#define ELF_MACHINE_CODE EM_SPARC
3449#define ELF_MACHINE_ALT1 EM_SPARC32PLUS
3450#define ELF_MAXPAGESIZE 0x10000
3451
3452#define bfd_elf32_bfd_reloc_type_lookup elf32_sparc_reloc_type_lookup
b9734f35
JJ		 3453#define bfd_elf32_bfd_link_hash_table_create \
3454 elf32_sparc_link_hash_table_create
f7775d95 3455#define bfd_elf32_bfd_relax_section elf32_sparc_relax_section
71e5db1c 3456#define bfd_elf32_new_section_hook elf32_sparc_new_section_hook
252b5132 3457#define elf_info_to_howto elf32_sparc_info_to_howto
b9734f35
JJ		 3458#define elf_backend_copy_indirect_symbol \
3459 elf32_sparc_copy_indirect_symbol
252b5132 3460#define elf_backend_create_dynamic_sections \
b9734f35 3461 elf32_sparc_create_dynamic_sections
252b5132
RH		 3462#define elf_backend_check_relocs elf32_sparc_check_relocs
3463#define elf_backend_adjust_dynamic_symbol \
3464 elf32_sparc_adjust_dynamic_symbol
151e5294 3465#define elf_backend_omit_section_dynsym elf32_sparc_omit_section_dynsym
252b5132
RH		 3466#define elf_backend_size_dynamic_sections \
3467 elf32_sparc_size_dynamic_sections
3468#define elf_backend_relocate_section elf32_sparc_relocate_section
3469#define elf_backend_finish_dynamic_symbol \
3470 elf32_sparc_finish_dynamic_symbol
3471#define elf_backend_finish_dynamic_sections \
3472 elf32_sparc_finish_dynamic_sections
3473#define bfd_elf32_bfd_merge_private_bfd_data \
3474 elf32_sparc_merge_private_bfd_data
b9734f35 3475#define bfd_elf32_mkobject elf32_sparc_mkobject
252b5132
RH		 3476#define elf_backend_object_p elf32_sparc_object_p
3477#define elf_backend_final_write_processing \
3478 elf32_sparc_final_write_processing
26e41594 3479#define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook
252b5132 3480#define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook
0647ed71 3481#define elf_backend_grok_psinfo elf32_sparc_grok_psinfo
db6751f2 3482#define elf_backend_reloc_type_class elf32_sparc_reloc_type_class
4c45e5c9 3483#define elf_backend_plt_sym_val elf32_sparc_plt_sym_val
252b5132
RH		 3484
3485#define elf_backend_can_gc_sections 1
b9734f35 3486#define elf_backend_can_refcount 1
252b5132
RH		 3487#define elf_backend_want_got_plt 0
3488#define elf_backend_plt_readonly 0
3489#define elf_backend_want_plt_sym 1
3490#define elf_backend_got_header_size 4
f0fe0e16 3491#define elf_backend_rela_normal 1
252b5132
RH		 3492
3493#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.589738 seconds and 4 git commands to generate.