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