projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2009-06-13 H.J. Lu <hongjiu.lu@intel.com>
[deliverable/binutils-gdb.git] / bfd / elf32-i386.c
CommitLineData
252b5132 1/* Intel 80386/80486-specific support for 32-bit ELF
b2a8e766 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
0ffa91dd 3 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
252b5132 4
571fe01f 5 This file is part of BFD, the Binary File Descriptor library.
252b5132 6
571fe01f
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
cd123cb7 9 the Free Software Foundation; either version 3 of the License, or
571fe01f 10 (at your option) any later version.
252b5132 11
571fe01f
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
571fe01f
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
cd123cb7
NC		 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
252b5132 21
252b5132 22#include "sysdep.h"
3db64b00 23#include "bfd.h"
252b5132
RH		 24#include "bfdlink.h"
25#include "libbfd.h"
26#include "elf-bfd.h"
eac338cf 27#include "elf-vxworks.h"
142411ca 28#include "bfd_stdint.h"
c25bc9fc
L		 29#include "objalloc.h"
30#include "hashtab.h"
252b5132 31
55fd94b0
AM		 32/* 386 uses REL relocations instead of RELA. */
33#define USE_REL 1
252b5132
RH		 34
35#include "elf/i386.h"
36
37static reloc_howto_type elf_howto_table[]=
38{
b34976b6 39 HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
1b452ec6 40 bfd_elf_generic_reloc, "R_386_NONE",
b34976b6
AM		 41 TRUE, 0x00000000, 0x00000000, FALSE),
42 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 43 bfd_elf_generic_reloc, "R_386_32",
b34976b6
AM		 44 TRUE, 0xffffffff, 0xffffffff, FALSE),
45 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 46 bfd_elf_generic_reloc, "R_386_PC32",
b34976b6
AM		 47 TRUE, 0xffffffff, 0xffffffff, TRUE),
48 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 49 bfd_elf_generic_reloc, "R_386_GOT32",
b34976b6
AM		 50 TRUE, 0xffffffff, 0xffffffff, FALSE),
51 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 52 bfd_elf_generic_reloc, "R_386_PLT32",
b34976b6
AM		 53 TRUE, 0xffffffff, 0xffffffff, TRUE),
54 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 55 bfd_elf_generic_reloc, "R_386_COPY",
b34976b6
AM		 56 TRUE, 0xffffffff, 0xffffffff, FALSE),
57 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 58 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
b34976b6
AM		 59 TRUE, 0xffffffff, 0xffffffff, FALSE),
60 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 61 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
b34976b6
AM		 62 TRUE, 0xffffffff, 0xffffffff, FALSE),
63 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 64 bfd_elf_generic_reloc, "R_386_RELATIVE",
b34976b6
AM		 65 TRUE, 0xffffffff, 0xffffffff, FALSE),
66 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
1b452ec6 67 bfd_elf_generic_reloc, "R_386_GOTOFF",
b34976b6
AM		 68 TRUE, 0xffffffff, 0xffffffff, FALSE),
69 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
1b452ec6 70 bfd_elf_generic_reloc, "R_386_GOTPC",
b34976b6 71 TRUE, 0xffffffff, 0xffffffff, TRUE),
1b452ec6 72
dc47f327
AM		 73 /* We have a gap in the reloc numbers here.
74 R_386_standard counts the number up to this point, and
75 R_386_ext_offset is the value to subtract from a reloc type of
76 R_386_16 thru R_386_PC8 to form an index into this table. */
55fd94b0
AM		 77#define R_386_standard (R_386_GOTPC + 1)
78#define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
1b452ec6 79
37e55690 80 /* These relocs are a GNU extension. */
b34976b6 81 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 82 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
b34976b6
AM		 83 TRUE, 0xffffffff, 0xffffffff, FALSE),
84 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 85 bfd_elf_generic_reloc, "R_386_TLS_IE",
b34976b6
AM		 86 TRUE, 0xffffffff, 0xffffffff, FALSE),
87 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
37e55690 88 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
b34976b6
AM		 89 TRUE, 0xffffffff, 0xffffffff, FALSE),
90 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 91 bfd_elf_generic_reloc, "R_386_TLS_LE",
b34976b6
AM		 92 TRUE, 0xffffffff, 0xffffffff, FALSE),
93 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 94 bfd_elf_generic_reloc, "R_386_TLS_GD",
b34976b6
AM		 95 TRUE, 0xffffffff, 0xffffffff, FALSE),
96 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 97 bfd_elf_generic_reloc, "R_386_TLS_LDM",
b34976b6
AM		 98 TRUE, 0xffffffff, 0xffffffff, FALSE),
99 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
1b452ec6 100 bfd_elf_generic_reloc, "R_386_16",
b34976b6 101 TRUE, 0xffff, 0xffff, FALSE),
b0360d8c 102 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
1b452ec6 103 bfd_elf_generic_reloc, "R_386_PC16",
b34976b6
AM		 104 TRUE, 0xffff, 0xffff, TRUE),
105 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
1b452ec6 106 bfd_elf_generic_reloc, "R_386_8",
b34976b6
AM		 107 TRUE, 0xff, 0xff, FALSE),
108 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
1b452ec6 109 bfd_elf_generic_reloc, "R_386_PC8",
b34976b6 110 TRUE, 0xff, 0xff, TRUE),
dc47f327 111
55fd94b0
AM		 112#define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
113#define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
13ae64f3 114 /* These are common with Solaris TLS implementation. */
b34976b6 115 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 116 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
b34976b6
AM		 117 TRUE, 0xffffffff, 0xffffffff, FALSE),
118 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 119 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
b34976b6
AM		 120 TRUE, 0xffffffff, 0xffffffff, FALSE),
121 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 122 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
b34976b6
AM		 123 TRUE, 0xffffffff, 0xffffffff, FALSE),
124 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 125 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
b34976b6
AM		 126 TRUE, 0xffffffff, 0xffffffff, FALSE),
127 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 128 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
b34976b6
AM		 129 TRUE, 0xffffffff, 0xffffffff, FALSE),
130 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
13ae64f3 131 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
b34976b6 132 TRUE, 0xffffffff, 0xffffffff, FALSE),
67a4f2b7
AO		 133 EMPTY_HOWTO (38),
134 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
135 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
136 TRUE, 0xffffffff, 0xffffffff, FALSE),
137 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
138 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
139 FALSE, 0, 0, FALSE),
140 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
141 bfd_elf_generic_reloc, "R_386_TLS_DESC",
142 TRUE, 0xffffffff, 0xffffffff, FALSE),
cbe950e9
L		 143 HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
144 bfd_elf_generic_reloc, "R_386_IRELATIVE",
145 TRUE, 0xffffffff, 0xffffffff, FALSE),
13ae64f3
JJ		 146
147 /* Another gap. */
cbe950e9
L		 148#define R_386_irelative (R_386_IRELATIVE + 1 - R_386_tls_offset)
149#define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_irelative)
252b5132
RH		 150
151/* GNU extension to record C++ vtable hierarchy. */
252b5132
RH		 152 HOWTO (R_386_GNU_VTINHERIT, /* type */
153 0, /* rightshift */
154 2, /* size (0 = byte, 1 = short, 2 = long) */
155 0, /* bitsize */
b34976b6 156 FALSE, /* pc_relative */
252b5132
RH		 157 0, /* bitpos */
158 complain_overflow_dont, /* complain_on_overflow */
159 NULL, /* special_function */
160 "R_386_GNU_VTINHERIT", /* name */
b34976b6 161 FALSE, /* partial_inplace */
252b5132
RH		 162 0, /* src_mask */
163 0, /* dst_mask */
b34976b6 164 FALSE), /* pcrel_offset */
252b5132
RH		 165
166/* GNU extension to record C++ vtable member usage. */
252b5132
RH		 167 HOWTO (R_386_GNU_VTENTRY, /* type */
168 0, /* rightshift */
169 2, /* size (0 = byte, 1 = short, 2 = long) */
170 0, /* bitsize */
b34976b6 171 FALSE, /* pc_relative */
252b5132
RH		 172 0, /* bitpos */
173 complain_overflow_dont, /* complain_on_overflow */
174 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
175 "R_386_GNU_VTENTRY", /* name */
b34976b6 176 FALSE, /* partial_inplace */
252b5132
RH		 177 0, /* src_mask */
178 0, /* dst_mask */
b34976b6 179 FALSE) /* pcrel_offset */
dc47f327 180
55fd94b0 181#define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
dc47f327
AM		 182
183};
184
252b5132 185#ifdef DEBUG_GEN_RELOC
55fd94b0
AM		 186#define TRACE(str) \
187 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
252b5132
RH		 188#else
189#define TRACE(str)
190#endif
191
192static reloc_howto_type *
55fd94b0
AM		 193elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
194 bfd_reloc_code_real_type code)
252b5132
RH		 195{
196 switch (code)
197 {
198 case BFD_RELOC_NONE:
199 TRACE ("BFD_RELOC_NONE");
55fd94b0 200 return &elf_howto_table[R_386_NONE];
252b5132
RH		 201
202 case BFD_RELOC_32:
203 TRACE ("BFD_RELOC_32");
55fd94b0 204 return &elf_howto_table[R_386_32];
252b5132
RH		 205
206 case BFD_RELOC_CTOR:
207 TRACE ("BFD_RELOC_CTOR");
55fd94b0 208 return &elf_howto_table[R_386_32];
252b5132
RH		 209
210 case BFD_RELOC_32_PCREL:
211 TRACE ("BFD_RELOC_PC32");
55fd94b0 212 return &elf_howto_table[R_386_PC32];
252b5132
RH		 213
214 case BFD_RELOC_386_GOT32:
215 TRACE ("BFD_RELOC_386_GOT32");
55fd94b0 216 return &elf_howto_table[R_386_GOT32];
252b5132
RH		 217
218 case BFD_RELOC_386_PLT32:
219 TRACE ("BFD_RELOC_386_PLT32");
55fd94b0 220 return &elf_howto_table[R_386_PLT32];
252b5132
RH		 221
222 case BFD_RELOC_386_COPY:
223 TRACE ("BFD_RELOC_386_COPY");
55fd94b0 224 return &elf_howto_table[R_386_COPY];
252b5132
RH		 225
226 case BFD_RELOC_386_GLOB_DAT:
227 TRACE ("BFD_RELOC_386_GLOB_DAT");
55fd94b0 228 return &elf_howto_table[R_386_GLOB_DAT];
252b5132
RH		 229
230 case BFD_RELOC_386_JUMP_SLOT:
231 TRACE ("BFD_RELOC_386_JUMP_SLOT");
55fd94b0 232 return &elf_howto_table[R_386_JUMP_SLOT];
252b5132
RH		 233
234 case BFD_RELOC_386_RELATIVE:
235 TRACE ("BFD_RELOC_386_RELATIVE");
55fd94b0 236 return &elf_howto_table[R_386_RELATIVE];
252b5132
RH		 237
238 case BFD_RELOC_386_GOTOFF:
239 TRACE ("BFD_RELOC_386_GOTOFF");
55fd94b0 240 return &elf_howto_table[R_386_GOTOFF];
252b5132
RH		 241
242 case BFD_RELOC_386_GOTPC:
243 TRACE ("BFD_RELOC_386_GOTPC");
55fd94b0 244 return &elf_howto_table[R_386_GOTPC];
252b5132 245
37e55690
JJ		 246 /* These relocs are a GNU extension. */
247 case BFD_RELOC_386_TLS_TPOFF:
248 TRACE ("BFD_RELOC_386_TLS_TPOFF");
55fd94b0 249 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
37e55690
JJ		 250
251 case BFD_RELOC_386_TLS_IE:
252 TRACE ("BFD_RELOC_386_TLS_IE");
55fd94b0 253 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
37e55690
JJ		 254
255 case BFD_RELOC_386_TLS_GOTIE:
256 TRACE ("BFD_RELOC_386_TLS_GOTIE");
55fd94b0 257 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
37e55690 258
13ae64f3
JJ		 259 case BFD_RELOC_386_TLS_LE:
260 TRACE ("BFD_RELOC_386_TLS_LE");
55fd94b0 261 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
13ae64f3
JJ		 262
263 case BFD_RELOC_386_TLS_GD:
264 TRACE ("BFD_RELOC_386_TLS_GD");
55fd94b0 265 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
13ae64f3
JJ		 266
267 case BFD_RELOC_386_TLS_LDM:
268 TRACE ("BFD_RELOC_386_TLS_LDM");
55fd94b0 269 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
13ae64f3 270
252b5132
RH		 271 case BFD_RELOC_16:
272 TRACE ("BFD_RELOC_16");
55fd94b0 273 return &elf_howto_table[R_386_16 - R_386_ext_offset];
252b5132
RH		 274
275 case BFD_RELOC_16_PCREL:
276 TRACE ("BFD_RELOC_16_PCREL");
55fd94b0 277 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
252b5132
RH		 278
279 case BFD_RELOC_8:
280 TRACE ("BFD_RELOC_8");
55fd94b0 281 return &elf_howto_table[R_386_8 - R_386_ext_offset];
252b5132
RH		 282
283 case BFD_RELOC_8_PCREL:
284 TRACE ("BFD_RELOC_8_PCREL");
55fd94b0 285 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
252b5132 286
13ae64f3
JJ		 287 /* Common with Sun TLS implementation. */
288 case BFD_RELOC_386_TLS_LDO_32:
289 TRACE ("BFD_RELOC_386_TLS_LDO_32");
55fd94b0 290 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
13ae64f3
JJ		 291
292 case BFD_RELOC_386_TLS_IE_32:
293 TRACE ("BFD_RELOC_386_TLS_IE_32");
55fd94b0 294 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
13ae64f3
JJ		 295
296 case BFD_RELOC_386_TLS_LE_32:
297 TRACE ("BFD_RELOC_386_TLS_LE_32");
55fd94b0 298 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
13ae64f3
JJ		 299
300 case BFD_RELOC_386_TLS_DTPMOD32:
301 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
55fd94b0 302 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
13ae64f3
JJ		 303
304 case BFD_RELOC_386_TLS_DTPOFF32:
305 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
55fd94b0 306 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
13ae64f3
JJ		 307
308 case BFD_RELOC_386_TLS_TPOFF32:
309 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
55fd94b0 310 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
13ae64f3 311
67a4f2b7
AO		 312 case BFD_RELOC_386_TLS_GOTDESC:
313 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
314 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
315
316 case BFD_RELOC_386_TLS_DESC_CALL:
317 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
318 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
319
320 case BFD_RELOC_386_TLS_DESC:
321 TRACE ("BFD_RELOC_386_TLS_DESC");
322 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
323
cbe950e9
L		 324 case BFD_RELOC_386_IRELATIVE:
325 TRACE ("BFD_RELOC_386_IRELATIVE");
326 return &elf_howto_table[R_386_IRELATIVE];
327
252b5132
RH		 328 case BFD_RELOC_VTABLE_INHERIT:
329 TRACE ("BFD_RELOC_VTABLE_INHERIT");
55fd94b0 330 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
252b5132
RH		 331
332 case BFD_RELOC_VTABLE_ENTRY:
333 TRACE ("BFD_RELOC_VTABLE_ENTRY");
55fd94b0 334 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
252b5132
RH		 335
336 default:
337 break;
338 }
339
340 TRACE ("Unknown");
341 return 0;
342}
343
157090f7
AM		 344static reloc_howto_type *
345elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
346 const char *r_name)
347{
348 unsigned int i;
349
350 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
351 if (elf_howto_table[i].name != NULL
352 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
353 return &elf_howto_table[i];
354
355 return NULL;
356}
357
142411ca
L		 358static reloc_howto_type *
359elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
252b5132 360{
dc47f327
AM		 361 unsigned int indx;
362
363 if ((indx = r_type) >= R_386_standard
364 && ((indx = r_type - R_386_ext_offset) - R_386_standard
365 >= R_386_ext - R_386_standard)
13ae64f3 366 && ((indx = r_type - R_386_tls_offset) - R_386_ext
cbe950e9
L		 367 >= R_386_irelative - R_386_ext)
368 && ((indx = r_type - R_386_vt_offset) - R_386_irelative
369 >= R_386_vt - R_386_irelative))
252b5132 370 {
d003868e
AM		 371 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
372 abfd, (int) r_type);
55fd94b0 373 indx = R_386_NONE;
252b5132 374 }
142411ca
L		 375 BFD_ASSERT (elf_howto_table [indx].type == r_type);
376 return &elf_howto_table[indx];
377}
378
379static void
380elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
381 arelent *cache_ptr,
382 Elf_Internal_Rela *dst)
383{
384 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
385 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
252b5132
RH		 386}
387
388/* Return whether a symbol name implies a local label. The UnixWare
389 2.1 cc generates temporary symbols that start with .X, so we
390 recognize them here. FIXME: do other SVR4 compilers also use .X?.
391 If so, we should move the .X recognition into
392 _bfd_elf_is_local_label_name. */
393
b34976b6 394static bfd_boolean
55fd94b0 395elf_i386_is_local_label_name (bfd *abfd, const char *name)
252b5132
RH		 396{
397 if (name[0] == '.' && name[1] == 'X')
b34976b6 398 return TRUE;
252b5132
RH		 399
400 return _bfd_elf_is_local_label_name (abfd, name);
401}
402\f
38701953 403/* Support for core dump NOTE sections. */
61adc1a4 404
b34976b6 405static bfd_boolean
55fd94b0 406elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
38701953
AM		 407{
408 int offset;
eea6121a 409 size_t size;
38701953 410
61adc1a4 411 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 412 {
61adc1a4
NC		 413 int pr_version = bfd_get_32 (abfd, note->descdata);
414
415 if (pr_version != 1)
416 return FALSE;
417
418 /* pr_cursig */
419 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 20);
420
421 /* pr_pid */
422 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
423
424 /* pr_reg */
425 offset = 28;
eea6121a 426 size = bfd_get_32 (abfd, note->descdata + 8);
61adc1a4
NC		 427 }
428 else
429 {
430 switch (note->descsz)
431 {
432 default:
433 return FALSE;
38701953 434
61adc1a4
NC		 435 case 144: /* Linux/i386 */
436 /* pr_cursig */
437 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
38701953 438
61adc1a4
NC		 439 /* pr_pid */
440 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
38701953 441
61adc1a4
NC		 442 /* pr_reg */
443 offset = 72;
eea6121a 444 size = 68;
38701953 445
61adc1a4
NC		 446 break;
447 }
38701953
AM		 448 }
449
450 /* Make a ".reg/999" section. */
451 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 452 size, note->descpos + offset);
38701953
AM		 453}
454
b34976b6 455static bfd_boolean
55fd94b0 456elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
38701953 457{
61adc1a4 458 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 459 {
61adc1a4
NC		 460 int pr_version = bfd_get_32 (abfd, note->descdata);
461
462 if (pr_version != 1)
b34976b6 463 return FALSE;
38701953 464
61adc1a4
NC		 465 elf_tdata (abfd)->core_program
466 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
467 elf_tdata (abfd)->core_command
468 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
469 }
470 else
471 {
472 switch (note->descsz)
473 {
474 default:
475 return FALSE;
476
477 case 124: /* Linux/i386 elf_prpsinfo. */
478 elf_tdata (abfd)->core_program
479 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
480 elf_tdata (abfd)->core_command
481 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
482 }
38701953
AM		 483 }
484
485 /* Note that for some reason, a spurious space is tacked
486 onto the end of the args in some (at least one anyway)
487 implementations, so strip it off if it exists. */
38701953
AM		 488 {
489 char *command = elf_tdata (abfd)->core_command;
490 int n = strlen (command);
491
492 if (0 < n && command[n - 1] == ' ')
493 command[n - 1] = '\0';
494 }
495
b34976b6 496 return TRUE;
38701953
AM		 497}
498\f
499/* Functions for the i386 ELF linker.
500
501 In order to gain some understanding of code in this file without
502 knowing all the intricate details of the linker, note the
503 following:
504
505 Functions named elf_i386_* are called by external routines, other
506 functions are only called locally. elf_i386_* functions appear
507 in this file more or less in the order in which they are called
508 from external routines. eg. elf_i386_check_relocs is called
509 early in the link process, elf_i386_finish_dynamic_sections is
510 one of the last functions. */
511
252b5132
RH		 512
513/* The name of the dynamic interpreter. This is put in the .interp
514 section. */
515
516#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
517
a23b6845
AM		 518/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
519 copying dynamic variables from a shared lib into an app's dynbss
520 section, and instead use a dynamic relocation to point into the
521 shared lib. */
522#define ELIMINATE_COPY_RELOCS 1
523
252b5132
RH		 524/* The size in bytes of an entry in the procedure linkage table. */
525
526#define PLT_ENTRY_SIZE 16
527
528/* The first entry in an absolute procedure linkage table looks like
eac338cf
PB		 529 this. See the SVR4 ABI i386 supplement to see how this works.
530 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
252b5132 531
eac338cf 532static const bfd_byte elf_i386_plt0_entry[12] =
252b5132
RH		 533{
534 0xff, 0x35, /* pushl contents of address */
535 0, 0, 0, 0, /* replaced with address of .got + 4. */
536 0xff, 0x25, /* jmp indirect */
eac338cf 537 0, 0, 0, 0 /* replaced with address of .got + 8. */
252b5132
RH		 538};
539
540/* Subsequent entries in an absolute procedure linkage table look like
541 this. */
542
543static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
544{
545 0xff, 0x25, /* jmp indirect */
546 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
547 0x68, /* pushl immediate */
548 0, 0, 0, 0, /* replaced with offset into relocation table. */
549 0xe9, /* jmp relative */
550 0, 0, 0, 0 /* replaced with offset to start of .plt. */
551};
552
eac338cf
PB		 553/* The first entry in a PIC procedure linkage table look like this.
554 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
252b5132 555
eac338cf 556static const bfd_byte elf_i386_pic_plt0_entry[12] =
252b5132
RH		 557{
558 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
eac338cf 559 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
252b5132
RH		 560};
561
562/* Subsequent entries in a PIC procedure linkage table look like this. */
563
564static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
565{
566 0xff, 0xa3, /* jmp *offset(%ebx) */
567 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
568 0x68, /* pushl immediate */
569 0, 0, 0, 0, /* replaced with offset into relocation table. */
570 0xe9, /* jmp relative */
571 0, 0, 0, 0 /* replaced with offset to start of .plt. */
572};
573
eac338cf
PB		 574/* On VxWorks, the .rel.plt.unloaded section has absolute relocations
575 for the PLTResolve stub and then for each PLT entry. */
576#define PLTRESOLVE_RELOCS_SHLIB 0
577#define PLTRESOLVE_RELOCS 2
578#define PLT_NON_JUMP_SLOT_RELOCS 2
579
252b5132 580/* The i386 linker needs to keep track of the number of relocs that it
ffb2e45b
AM		 581 decides to copy as dynamic relocs in check_relocs for each symbol.
582 This is so that it can later discard them if they are found to be
583 unnecessary. We store the information in a field extending the
584 regular ELF linker hash table. */
252b5132 585
ffb2e45b 586struct elf_i386_dyn_relocs
252b5132 587{
ffb2e45b 588 struct elf_i386_dyn_relocs *next;
0c715baa
AM		 589
590 /* The input section of the reloc. */
591 asection *sec;
592
593 /* Total number of relocs copied for the input section. */
252b5132 594 bfd_size_type count;
0c715baa
AM		 595
596 /* Number of pc-relative relocs copied for the input section. */
597 bfd_size_type pc_count;
252b5132
RH		 598};
599
600/* i386 ELF linker hash entry. */
601
602struct elf_i386_link_hash_entry
603{
ebe50bae 604 struct elf_link_hash_entry elf;
252b5132 605
0c715baa 606 /* Track dynamic relocs copied for this symbol. */
ffb2e45b 607 struct elf_i386_dyn_relocs *dyn_relocs;
13ae64f3 608
37e55690
JJ		 609#define GOT_UNKNOWN 0
610#define GOT_NORMAL 1
611#define GOT_TLS_GD 2
612#define GOT_TLS_IE 4
613#define GOT_TLS_IE_POS 5
614#define GOT_TLS_IE_NEG 6
615#define GOT_TLS_IE_BOTH 7
67a4f2b7
AO		 616#define GOT_TLS_GDESC 8
617#define GOT_TLS_GD_BOTH_P(type) \
618 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
619#define GOT_TLS_GD_P(type) \
620 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
621#define GOT_TLS_GDESC_P(type) \
622 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
623#define GOT_TLS_GD_ANY_P(type) \
624 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
37e55690 625 unsigned char tls_type;
67a4f2b7
AO		 626
627 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
628 starting at the end of the jump table. */
629 bfd_vma tlsdesc_got;
13ae64f3
JJ		 630};
631
632#define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
633
634struct elf_i386_obj_tdata
635{
636 struct elf_obj_tdata root;
637
638 /* tls_type for each local got entry. */
639 char *local_got_tls_type;
67a4f2b7
AO		 640
641 /* GOTPLT entries for TLS descriptors. */
642 bfd_vma *local_tlsdesc_gotent;
252b5132
RH		 643};
644
13ae64f3
JJ		 645#define elf_i386_tdata(abfd) \
646 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
647
648#define elf_i386_local_got_tls_type(abfd) \
649 (elf_i386_tdata (abfd)->local_got_tls_type)
650
67a4f2b7
AO		 651#define elf_i386_local_tlsdesc_gotent(abfd) \
652 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
653
0ffa91dd
NC		 654#define is_i386_elf(bfd) \
655 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
656 && elf_tdata (bfd) != NULL \
657 && elf_object_id (bfd) == I386_ELF_TDATA)
658
b34976b6 659static bfd_boolean
55fd94b0 660elf_i386_mkobject (bfd *abfd)
13ae64f3 661{
0ffa91dd
NC		 662 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
663 I386_ELF_TDATA);
13ae64f3 664}
cedb70c5 665
252b5132
RH		 666/* i386 ELF linker hash table. */
667
668struct elf_i386_link_hash_table
669{
ebe50bae 670 struct elf_link_hash_table elf;
252b5132 671
6725bdbf
AM		 672 /* Short-cuts to get to dynamic linker sections. */
673 asection *sgot;
674 asection *sgotplt;
675 asection *srelgot;
676 asection *splt;
677 asection *srelplt;
678 asection *sdynbss;
679 asection *srelbss;
cbe950e9
L		 680 asection *igotplt;
681 asection *iplt;
682 asection *irelplt;
2a81c24a 683 asection *irelifunc;
9635fe29 684
eac338cf
PB		 685 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
686 asection *srelplt2;
687
eac338cf
PB		 688 /* True if the target system is VxWorks. */
689 int is_vxworks;
ec338859 690
eac338cf
PB		 691 /* Value used to fill the last word of the first plt entry. */
692 bfd_byte plt0_pad_byte;
9635fe29 693
5ae0bfb6
RS		 694 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
695 bfd_vma next_tls_desc_index;
696
13ae64f3
JJ		 697 union {
698 bfd_signed_vma refcount;
699 bfd_vma offset;
700 } tls_ldm_got;
701
67a4f2b7
AO		 702 /* The amount of space used by the reserved portion of the sgotplt
703 section, plus whatever space is used by the jump slots. */
704 bfd_vma sgotplt_jump_table_size;
705
ec338859
AM		 706 /* Small local sym to section mapping cache. */
707 struct sym_sec_cache sym_sec;
9f03412a
AO		 708
709 /* _TLS_MODULE_BASE_ symbol. */
710 struct bfd_link_hash_entry *tls_module_base;
c25bc9fc
L		 711
712 /* Used by local STT_GNU_IFUNC symbols. */
713 htab_t loc_hash_table;
714 void *loc_hash_memory;
6725bdbf 715};
252b5132
RH		 716
717/* Get the i386 ELF linker hash table from a link_info structure. */
718
719#define elf_i386_hash_table(p) \
720 ((struct elf_i386_link_hash_table *) ((p)->hash))
721
67a4f2b7 722#define elf_i386_compute_jump_table_size(htab) \
5ae0bfb6 723 ((htab)->next_tls_desc_index * 4)
67a4f2b7 724
252b5132
RH		 725/* Create an entry in an i386 ELF linker hash table. */
726
727static struct bfd_hash_entry *
eb4ff4d6
L		 728elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
729 struct bfd_hash_table *table,
730 const char *string)
252b5132 731{
252b5132
RH		 732 /* Allocate the structure if it has not already been allocated by a
733 subclass. */
ebe50bae
AM		 734 if (entry == NULL)
735 {
736 entry = bfd_hash_allocate (table,
737 sizeof (struct elf_i386_link_hash_entry));
738 if (entry == NULL)
739 return entry;
740 }
252b5132
RH		 741
742 /* Call the allocation method of the superclass. */
ebe50bae
AM		 743 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
744 if (entry != NULL)
252b5132 745 {
ebe50bae
AM		 746 struct elf_i386_link_hash_entry *eh;
747
748 eh = (struct elf_i386_link_hash_entry *) entry;
749 eh->dyn_relocs = NULL;
13ae64f3 750 eh->tls_type = GOT_UNKNOWN;
67a4f2b7 751 eh->tlsdesc_got = (bfd_vma) -1;
252b5132
RH		 752 }
753
ebe50bae 754 return entry;
252b5132
RH		 755}
756
c25bc9fc
L		 757static hashval_t
758elf_i386_local_hash (int id, int r_sym)
759{
760 return ((((id & 0xff) << 24) | ((id & 0xff00) << 8))
761 ^ r_sym ^ (id >> 16));
762}
763
764/* Compute a hash of a local hash entry. We use elf_link_hash_entry
765 for local symbol so that we can handle local STT_GNU_IFUNC symbols
766 as global symbol. We reuse indx and dynstr_index for local symbol
767 hash since they aren't used by global symbols in this backend. */
768
769static hashval_t
770elf_i386_local_htab_hash (const void *ptr)
771{
772 struct elf_link_hash_entry *h
773 = (struct elf_link_hash_entry *) ptr;
774 return elf_i386_local_hash (h->indx, h->dynstr_index);
775}
776
777/* Compare local hash entries. */
778
779static int
780elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
781{
782 struct elf_link_hash_entry *h1
783 = (struct elf_link_hash_entry *) ptr1;
784 struct elf_link_hash_entry *h2
785 = (struct elf_link_hash_entry *) ptr2;
786
787 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
788}
789
790/* Find and/or create a hash entry for local symbol. */
791
792static struct elf_link_hash_entry *
793elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
794 bfd *abfd, const Elf_Internal_Rela *rel,
795 bfd_boolean create)
796{
797 struct elf_i386_link_hash_entry e, *ret;
798 asection *sec = abfd->sections;
799 hashval_t h = elf_i386_local_hash (sec->id,
800 ELF32_R_SYM (rel->r_info));
801 void **slot;
802
803 e.elf.indx = sec->id;
804 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
805 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
806 create ? INSERT : NO_INSERT);
807
808 if (!slot)
809 return NULL;
810
811 if (*slot)
812 {
813 ret = (struct elf_i386_link_hash_entry *) *slot;
814 return &ret->elf;
815 }
816
817 ret = (struct elf_i386_link_hash_entry *)
818 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
819 sizeof (struct elf_i386_link_hash_entry));
820 if (ret)
821 {
822 memset (ret, 0, sizeof (*ret));
823 ret->elf.indx = sec->id;
824 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
825 ret->elf.dynindx = -1;
826 ret->elf.plt.offset = (bfd_vma) -1;
827 ret->elf.got.offset = (bfd_vma) -1;
828 *slot = ret;
829 }
830 return &ret->elf;
831}
832
252b5132
RH		 833/* Create an i386 ELF linker hash table. */
834
835static struct bfd_link_hash_table *
55fd94b0 836elf_i386_link_hash_table_create (bfd *abfd)
252b5132
RH		 837{
838 struct elf_i386_link_hash_table *ret;
dc810e39 839 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
252b5132 840
55fd94b0 841 ret = bfd_malloc (amt);
ebe50bae 842 if (ret == NULL)
252b5132
RH		 843 return NULL;
844
eb4ff4d6
L		 845 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
846 elf_i386_link_hash_newfunc,
66eb6687 847 sizeof (struct elf_i386_link_hash_entry)))
252b5132 848 {
e2d34d7d 849 free (ret);
252b5132
RH		 850 return NULL;
851 }
852
6725bdbf
AM		 853 ret->sgot = NULL;
854 ret->sgotplt = NULL;
855 ret->srelgot = NULL;
856 ret->splt = NULL;
857 ret->srelplt = NULL;
858 ret->sdynbss = NULL;
859 ret->srelbss = NULL;
cbe950e9
L		 860 ret->igotplt= NULL;
861 ret->iplt = NULL;
862 ret->irelplt= NULL;
2a81c24a 863 ret->irelifunc = NULL;
7a624474 864 ret->tls_ldm_got.refcount = 0;
5ae0bfb6 865 ret->next_tls_desc_index = 0;
67a4f2b7 866 ret->sgotplt_jump_table_size = 0;
ec338859 867 ret->sym_sec.abfd = NULL;
eac338cf
PB		 868 ret->is_vxworks = 0;
869 ret->srelplt2 = NULL;
eac338cf 870 ret->plt0_pad_byte = 0;
9f03412a 871 ret->tls_module_base = NULL;
6725bdbf 872
c25bc9fc
L		 873 ret->loc_hash_table = htab_try_create (1024,
874 elf_i386_local_htab_hash,
875 elf_i386_local_htab_eq,
876 NULL);
877 ret->loc_hash_memory = objalloc_create ();
878 if (!ret->loc_hash_table || !ret->loc_hash_memory)
879 {
880 free (ret);
881 return NULL;
882 }
883
ebe50bae 884 return &ret->elf.root;
252b5132
RH		 885}
886
c25bc9fc
L		 887/* Destroy an i386 ELF linker hash table. */
888
889static void
890elf_i386_link_hash_table_free (struct bfd_link_hash_table *hash)
891{
892 struct elf_i386_link_hash_table *htab
893 = (struct elf_i386_link_hash_table *) hash;
894
895 if (htab->loc_hash_table)
896 htab_delete (htab->loc_hash_table);
897 if (htab->loc_hash_memory)
898 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
899 _bfd_generic_link_hash_table_free (hash);
900}
901
902/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
903 shortcuts to them in our hash table. */
904
6725bdbf
AM		 905/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
906 shortcuts to them in our hash table. */
907
b34976b6 908static bfd_boolean
eb4ff4d6 909elf_i386_create_got_section (bfd *dynobj, struct bfd_link_info *info)
6725bdbf
AM		 910{
911 struct elf_i386_link_hash_table *htab;
912
913 if (! _bfd_elf_create_got_section (dynobj, info))
b34976b6 914 return FALSE;
6725bdbf
AM		 915
916 htab = elf_i386_hash_table (info);
917 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
918 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
919 if (!htab->sgot || !htab->sgotplt)
920 abort ();
921
3496cb2a
L		 922 htab->srelgot = bfd_make_section_with_flags (dynobj, ".rel.got",
923 (SEC_ALLOC | SEC_LOAD
924 | SEC_HAS_CONTENTS
925 | SEC_IN_MEMORY
926 | SEC_LINKER_CREATED
927 | SEC_READONLY));
6725bdbf 928 if (htab->srelgot == NULL
6725bdbf 929 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
b34976b6
AM		 930 return FALSE;
931 return TRUE;
6725bdbf
AM		 932}
933
934/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
935 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
936 hash table. */
937
b34976b6 938static bfd_boolean
55fd94b0 939elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
6725bdbf
AM		 940{
941 struct elf_i386_link_hash_table *htab;
942
943 htab = elf_i386_hash_table (info);
eb4ff4d6 944 if (!htab->sgot && !elf_i386_create_got_section (dynobj, info))
b34976b6 945 return FALSE;
6725bdbf
AM		 946
947 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 948 return FALSE;
6725bdbf
AM		 949
950 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
951 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
952 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
953 if (!info->shared)
954 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
955
956 if (!htab->splt || !htab->srelplt || !htab->sdynbss
957 || (!info->shared && !htab->srelbss))
958 abort ();
959
711de32c
RS		 960 if (htab->is_vxworks
961 && !elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
962 return FALSE;
eac338cf 963
b34976b6 964 return TRUE;
6725bdbf
AM		 965}
966
ebe50bae
AM		 967/* Copy the extra info we tack onto an elf_link_hash_entry. */
968
51b64d56 969static void
fcfa13d2 970elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
55fd94b0
AM		 971 struct elf_link_hash_entry *dir,
972 struct elf_link_hash_entry *ind)
ebe50bae
AM		 973{
974 struct elf_i386_link_hash_entry *edir, *eind;
975
976 edir = (struct elf_i386_link_hash_entry *) dir;
977 eind = (struct elf_i386_link_hash_entry *) ind;
978
bbd7ec4a 979 if (eind->dyn_relocs != NULL)
ebe50bae 980 {
bbd7ec4a
AM		 981 if (edir->dyn_relocs != NULL)
982 {
983 struct elf_i386_dyn_relocs **pp;
984 struct elf_i386_dyn_relocs *p;
985
fcfa13d2 986 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 987 list. Merge any entries against the same section. */
988 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
989 {
990 struct elf_i386_dyn_relocs *q;
991
992 for (q = edir->dyn_relocs; q != NULL; q = q->next)
993 if (q->sec == p->sec)
994 {
995 q->pc_count += p->pc_count;
996 q->count += p->count;
997 *pp = p->next;
998 break;
999 }
1000 if (q == NULL)
1001 pp = &p->next;
1002 }
1003 *pp = edir->dyn_relocs;
1004 }
1005
ebe50bae
AM		 1006 edir->dyn_relocs = eind->dyn_relocs;
1007 eind->dyn_relocs = NULL;
1008 }
ebe50bae 1009
cd67d266
JJ		 1010 if (ind->root.type == bfd_link_hash_indirect
1011 && dir->got.refcount <= 0)
1012 {
1013 edir->tls_type = eind->tls_type;
1014 eind->tls_type = GOT_UNKNOWN;
1015 }
81848ca0
AM		 1016
1017 if (ELIMINATE_COPY_RELOCS
1018 && ind->root.type != bfd_link_hash_indirect
f5385ebf
AM		 1019 && dir->dynamic_adjusted)
1020 {
1021 /* If called to transfer flags for a weakdef during processing
1022 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1023 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1024 dir->ref_dynamic |= ind->ref_dynamic;
1025 dir->ref_regular |= ind->ref_regular;
1026 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1027 dir->needs_plt |= ind->needs_plt;
1028 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1029 }
81848ca0 1030 else
fcfa13d2 1031 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
ebe50bae
AM		 1032}
1033
142411ca
L		 1034typedef union
1035 {
1036 unsigned char c[2];
1037 uint16_t i;
1038 }
1039i386_opcode16;
1040
1041/* Return TRUE if the TLS access code sequence support transition
1042 from R_TYPE. */
1043
1044static bfd_boolean
1045elf_i386_check_tls_transition (bfd *abfd, asection *sec,
1046 bfd_byte *contents,
1047 Elf_Internal_Shdr *symtab_hdr,
1048 struct elf_link_hash_entry **sym_hashes,
1049 unsigned int r_type,
1050 const Elf_Internal_Rela *rel,
1051 const Elf_Internal_Rela *relend)
13ae64f3 1052{
142411ca
L		 1053 unsigned int val, type;
1054 unsigned long r_symndx;
1055 struct elf_link_hash_entry *h;
1056 bfd_vma offset;
1057
1058 /* Get the section contents. */
1059 if (contents == NULL)
1060 {
1061 if (elf_section_data (sec)->this_hdr.contents != NULL)
1062 contents = elf_section_data (sec)->this_hdr.contents;
1063 else
1064 {
1065 /* FIXME: How to better handle error condition? */
1066 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1067 return FALSE;
13ae64f3 1068
142411ca
L		 1069 /* Cache the section contents for elf_link_input_bfd. */
1070 elf_section_data (sec)->this_hdr.contents = contents;
1071 }
1072 }
1073
1074 offset = rel->r_offset;
13ae64f3 1075 switch (r_type)
142411ca
L		 1076 {
1077 case R_386_TLS_GD:
1078 case R_386_TLS_LDM:
1079 if (offset < 2 || (rel + 1) >= relend)
1080 return FALSE;
1081
1082 type = bfd_get_8 (abfd, contents + offset - 2);
1083 if (r_type == R_386_TLS_GD)
1084 {
09e8c3bf 1085 /* Check transition from GD access model. Only
142411ca
L		 1086 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1087 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1088 can transit to different access model. */
1089 if ((offset + 10) > sec->size ||
1090 (type != 0x8d && type != 0x04))
1091 return FALSE;
1092
1093 val = bfd_get_8 (abfd, contents + offset - 1);
1094 if (type == 0x04)
1095 {
1096 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1097 if (offset < 3)
1098 return FALSE;
1099
1100 if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
1101 return FALSE;
1102
1103 if ((val & 0xc7) != 0x05 || val == (4 << 3))
1104 return FALSE;
1105 }
1106 else
1107 {
1108 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1109 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1110 return FALSE;
1111
1112 if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
1113 return FALSE;
1114 }
1115 }
1116 else
1117 {
1118 /* Check transition from LD access model. Only
1119 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1120 can transit to different access model. */
1121 if (type != 0x8d || (offset + 9) > sec->size)
1122 return FALSE;
1123
1124 val = bfd_get_8 (abfd, contents + offset - 1);
1125 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1126 return FALSE;
1127 }
1128
1129 if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1130 return FALSE;
1131
1132 r_symndx = ELF32_R_SYM (rel[1].r_info);
1133 if (r_symndx < symtab_hdr->sh_info)
1134 return FALSE;
1135
1136 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
c4fb387b
L		 1137 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1138 may be versioned. */
142411ca
L		 1139 return (h != NULL
1140 && h->root.root.string != NULL
1141 && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1142 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
c4fb387b
L		 1143 && (strncmp (h->root.root.string, "___tls_get_addr",
1144 15) == 0));
142411ca
L		 1145
1146 case R_386_TLS_IE:
1147 /* Check transition from IE access model:
1148 movl foo@indntpoff(%rip), %eax
1149 movl foo@indntpoff(%rip), %reg
1150 addl foo@indntpoff(%rip), %reg
1151 */
1152
1153 if (offset < 1 || (offset + 4) > sec->size)
1154 return FALSE;
1155
1156 /* Check "movl foo@tpoff(%rip), %eax" first. */
1157 val = bfd_get_8 (abfd, contents + offset - 1);
1158 if (val == 0xa1)
1159 return TRUE;
1160
1161 if (offset < 2)
1162 return FALSE;
1163
1164 /* Check movl|addl foo@tpoff(%rip), %reg. */
1165 type = bfd_get_8 (abfd, contents + offset - 2);
1166 return ((type == 0x8b || type == 0x03)
1167 && (val & 0xc7) == 0x05);
1168
1169 case R_386_TLS_GOTIE:
1170 case R_386_TLS_IE_32:
1171 /* Check transition from {IE_32,GOTIE} access model:
1172 subl foo@{tpoff,gontoff}(%reg1), %reg2
1173 movl foo@{tpoff,gontoff}(%reg1), %reg2
1174 addl foo@{tpoff,gontoff}(%reg1), %reg2
1175 */
1176
1177 if (offset < 2 || (offset + 4) > sec->size)
1178 return FALSE;
1179
1180 val = bfd_get_8 (abfd, contents + offset - 1);
1181 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1182 return FALSE;
1183
1184 type = bfd_get_8 (abfd, contents + offset - 2);
1185 return type == 0x8b || type == 0x2b || type == 0x03;
1186
1187 case R_386_TLS_GOTDESC:
1188 /* Check transition from GDesc access model:
1189 leal x@tlsdesc(%ebx), %eax
1190
1191 Make sure it's a leal adding ebx to a 32-bit offset
1192 into any register, although it's probably almost always
1193 going to be eax. */
1194
1195 if (offset < 2 || (offset + 4) > sec->size)
1196 return FALSE;
1197
1198 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1199 return FALSE;
1200
1201 val = bfd_get_8 (abfd, contents + offset - 1);
1202 return (val & 0xc7) == 0x83;
1203
1204 case R_386_TLS_DESC_CALL:
1205 /* Check transition from GDesc access model:
1206 call *x@tlsdesc(%rax)
1207 */
1208 if (offset + 2 <= sec->size)
1209 {
1210 /* Make sure that it's a call *x@tlsdesc(%rax). */
1211 static i386_opcode16 call = { { 0xff, 0x10 } };
1212 return bfd_get_16 (abfd, contents + offset) == call.i;
1213 }
1214
1215 return FALSE;
1216
1217 default:
1218 abort ();
1219 }
1220}
1221
1222/* Return TRUE if the TLS access transition is OK or no transition
1223 will be performed. Update R_TYPE if there is a transition. */
1224
1225static bfd_boolean
1226elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1227 asection *sec, bfd_byte *contents,
1228 Elf_Internal_Shdr *symtab_hdr,
1229 struct elf_link_hash_entry **sym_hashes,
1230 unsigned int *r_type, int tls_type,
1231 const Elf_Internal_Rela *rel,
1232 const Elf_Internal_Rela *relend,
1233 struct elf_link_hash_entry *h)
1234{
1235 unsigned int from_type = *r_type;
1236 unsigned int to_type = from_type;
1237 bfd_boolean check = TRUE;
1238
1239 switch (from_type)
13ae64f3
JJ		 1240 {
1241 case R_386_TLS_GD:
67a4f2b7
AO		 1242 case R_386_TLS_GOTDESC:
1243 case R_386_TLS_DESC_CALL:
13ae64f3 1244 case R_386_TLS_IE_32:
37e55690
JJ		 1245 case R_386_TLS_IE:
1246 case R_386_TLS_GOTIE:
142411ca
L		 1247 if (!info->shared)
1248 {
1249 if (h == NULL)
1250 to_type = R_386_TLS_LE_32;
1251 else if (from_type != R_386_TLS_IE
1252 && from_type != R_386_TLS_GOTIE)
1253 to_type = R_386_TLS_IE_32;
1254 }
1255
1256 /* When we are called from elf_i386_relocate_section, CONTENTS
1257 isn't NULL and there may be additional transitions based on
1258 TLS_TYPE. */
1259 if (contents != NULL)
1260 {
1261 unsigned int new_to_type = to_type;
1262
1263 if (!info->shared
1264 && h != NULL
1265 && h->dynindx == -1
1266 && (tls_type & GOT_TLS_IE))
1267 new_to_type = R_386_TLS_LE_32;
1268
1269 if (to_type == R_386_TLS_GD
1270 || to_type == R_386_TLS_GOTDESC
1271 || to_type == R_386_TLS_DESC_CALL)
1272 {
1273 if (tls_type == GOT_TLS_IE_POS)
1274 new_to_type = R_386_TLS_GOTIE;
1275 else if (tls_type & GOT_TLS_IE)
1276 new_to_type = R_386_TLS_IE_32;
1277 }
1278
1279 /* We checked the transition before when we were called from
1280 elf_i386_check_relocs. We only want to check the new
1281 transition which hasn't been checked before. */
1282 check = new_to_type != to_type && from_type == to_type;
1283 to_type = new_to_type;
1284 }
1285
1286 break;
1287
13ae64f3 1288 case R_386_TLS_LDM:
142411ca
L		 1289 if (!info->shared)
1290 to_type = R_386_TLS_LE_32;
1291 break;
1292
1293 default:
1294 return TRUE;
1295 }
1296
1297 /* Return TRUE if there is no transition. */
1298 if (from_type == to_type)
1299 return TRUE;
1300
1301 /* Check if the transition can be performed. */
1302 if (check
1303 && ! elf_i386_check_tls_transition (abfd, sec, contents,
1304 symtab_hdr, sym_hashes,
1305 from_type, rel, relend))
1306 {
2f629d23 1307 reloc_howto_type *from, *to;
142411ca
L		 1308
1309 from = elf_i386_rtype_to_howto (abfd, from_type);
1310 to = elf_i386_rtype_to_howto (abfd, to_type);
1311
1312 (*_bfd_error_handler)
1313 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1314 "in section `%A' failed"),
1315 abfd, sec, from->name, to->name,
1316 h ? h->root.root.string : "a local symbol",
1317 (unsigned long) rel->r_offset);
1318 bfd_set_error (bfd_error_bad_value);
1319 return FALSE;
13ae64f3
JJ		 1320 }
1321
142411ca
L		 1322 *r_type = to_type;
1323 return TRUE;
13ae64f3
JJ		 1324}
1325
252b5132 1326/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 1327 calculate needed space in the global offset table, procedure linkage
1328 table, and dynamic reloc sections. */
252b5132 1329
b34976b6 1330static bfd_boolean
55fd94b0
AM		 1331elf_i386_check_relocs (bfd *abfd,
1332 struct bfd_link_info *info,
1333 asection *sec,
1334 const Elf_Internal_Rela *relocs)
252b5132 1335{
6725bdbf 1336 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1337 Elf_Internal_Shdr *symtab_hdr;
1338 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 1339 const Elf_Internal_Rela *rel;
1340 const Elf_Internal_Rela *rel_end;
252b5132 1341 asection *sreloc;
c25bc9fc 1342 Elf_Internal_Sym *isymbuf;
252b5132 1343
1049f94e 1344 if (info->relocatable)
b34976b6 1345 return TRUE;
252b5132 1346
0ffa91dd
NC		 1347 BFD_ASSERT (is_i386_elf (abfd));
1348
6725bdbf 1349 htab = elf_i386_hash_table (info);
0ffa91dd 1350 symtab_hdr = &elf_symtab_hdr (abfd);
c25bc9fc 1351 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
252b5132 1352 sym_hashes = elf_sym_hashes (abfd);
252b5132 1353
252b5132
RH		 1354 sreloc = NULL;
1355
1356 rel_end = relocs + sec->reloc_count;
1357 for (rel = relocs; rel < rel_end; rel++)
1358 {
13ae64f3 1359 unsigned int r_type;
252b5132
RH		 1360 unsigned long r_symndx;
1361 struct elf_link_hash_entry *h;
1362
1363 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 1364 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1365
d9bc7a44 1366 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 1367 {
d003868e
AM		 1368 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1369 abfd,
8f615d07 1370 r_symndx);
b34976b6 1371 return FALSE;
f5f31454
L		 1372 }
1373
252b5132 1374 if (r_symndx < symtab_hdr->sh_info)
c25bc9fc
L		 1375 {
1376 /* A local symbol. */
1377 Elf_Internal_Sym *isym;
1378
1379 /* Read this BFD's local symbols. */
1380 if (isymbuf == NULL)
1381 {
1382 if (isymbuf == NULL)
1383 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1384 symtab_hdr->sh_info, 0,
1385 NULL, NULL, NULL);
1386 if (isymbuf == NULL)
1387 return FALSE;
1388 }
1389
1390 /* Check relocation against local STT_GNU_IFUNC symbol. */
1391 isym = isymbuf + r_symndx;
1392 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1393 {
1394 h = elf_i386_get_local_sym_hash (htab, abfd, rel,
1395 TRUE);
1396 if (h == NULL)
1397 return FALSE;
1398
1399 /* Fake a STT_GNU_IFUNC symbol. */
1400 h->type = STT_GNU_IFUNC;
1401 h->def_regular = 1;
1402 h->ref_regular = 1;
1403 h->forced_local = 1;
1404 h->root.type = bfd_link_hash_defined;
1405 }
1406 else
1407 h = NULL;
1408 }
252b5132 1409 else
71cb9464
L		 1410 {
1411 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1412 while (h->root.type == bfd_link_hash_indirect
1413 || h->root.type == bfd_link_hash_warning)
1414 h = (struct elf_link_hash_entry *) h->root.u.i.link;
c25bc9fc 1415 }
cbe950e9 1416
c25bc9fc
L		 1417 if (h != NULL)
1418 {
cbe950e9
L		 1419 /* Create the ifunc sections for static executables. If we
1420 never see an indirect function symbol nor we are building
1421 a static executable, those sections will be empty and
1422 won't appear in output. */
1423 switch (r_type)
1424 {
1425 default:
1426 break;
1427
1428 case R_386_32:
1429 case R_386_PC32:
1430 case R_386_PLT32:
1431 case R_386_GOT32:
1432 case R_386_GOTOFF:
2a81c24a 1433 if (htab->irelifunc == NULL && htab->iplt == NULL)
cbe950e9 1434 {
2a81c24a 1435 if (!_bfd_elf_create_ifunc_sections (abfd, info))
cbe950e9
L		 1436 return FALSE;
1437
2a81c24a
L		 1438 if (info->shared)
1439 {
1440 htab->irelifunc = bfd_get_section_by_name (abfd,
1441 ".rel.ifunc");
1442 if (!htab->irelifunc)
1443 abort ();
1444 }
1445 else
1446 {
1447 htab->iplt = bfd_get_section_by_name (abfd, ".iplt");
1448 htab->irelplt = bfd_get_section_by_name (abfd,
1449 ".rel.iplt");
1450 htab->igotplt = bfd_get_section_by_name (abfd,
1451 ".igot.plt");
1452 if (!htab->iplt
1453 || !htab->irelplt
1454 || !htab->igotplt)
1455 abort ();
1456 }
cbe950e9
L		 1457 }
1458 break;
1459 }
1460
1461 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1462 it here if it is defined in a non-shared object. */
1463 if (h->type == STT_GNU_IFUNC
1464 && h->def_regular)
1465 {
1466 /* It is referenced by a non-shared object. */
1467 h->ref_regular = 1;
1468
1469 /* STT_GNU_IFUNC symbol must go through PLT. */
1470 h->plt.refcount += 1;
1471
1472 /* STT_GNU_IFUNC needs dynamic sections. */
1473 if (htab->elf.dynobj == NULL)
1474 htab->elf.dynobj = abfd;
1475
1476 switch (r_type)
1477 {
1478 default:
1479 (*_bfd_error_handler)
1480 (_("%B: relocation %s against STT_GNU_IFUNC "
1481 "symbol `%s' isn't handled by %s"), abfd,
1482 elf_howto_table[r_type].name,
8b7e2992
L		 1483 (h->root.root.string
1484 ? h->root.root.string : "a local symbol"),
c25bc9fc 1485 __FUNCTION__);
cbe950e9
L		 1486 bfd_set_error (bfd_error_bad_value);
1487 return FALSE;
1488
1489 case R_386_32:
710ab287
L		 1490 h->non_got_ref = 1;
1491 h->pointer_equality_needed = 1;
1492 if (info->shared)
1493 {
1494 struct elf_i386_dyn_relocs *p;
1495 struct elf_i386_dyn_relocs **head;
1496
1497 /* We must copy these reloc types into the
1498 output file. Create a reloc section in
1499 dynobj and make room for this reloc. */
1500 if (sreloc == NULL)
1501 {
1502 if (htab->elf.dynobj == NULL)
1503 htab->elf.dynobj = abfd;
1504
1505 sreloc = _bfd_elf_make_dynamic_reloc_section
1506 (sec, htab->elf.dynobj, 2, abfd, FALSE);
1507
1508 if (sreloc == NULL)
1509 return FALSE;
1510 }
1511
1512 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1513 p = *head;
1514 if (p == NULL || p->sec != sec)
1515 {
1516 bfd_size_type amt = sizeof *p;
1517 p = bfd_alloc (htab->elf.dynobj, amt);
1518 if (p == NULL)
1519 return FALSE;
1520 p->next = *head;
1521 *head = p;
1522 p->sec = sec;
1523 p->count = 0;
1524 p->pc_count = 0;
1525 }
1526 p->count += 1;
1527 }
1528 break;
1529
cbe950e9
L		 1530 case R_386_PC32:
1531 h->non_got_ref = 1;
cbe950e9
L		 1532 break;
1533
1534 case R_386_PLT32:
1535 break;
1536
1537 case R_386_GOT32:
1538 case R_386_GOTOFF:
7afd84dc 1539 h->got.refcount += 1;
cbe950e9
L		 1540 if (htab->sgot == NULL
1541 && !elf_i386_create_got_section (htab->elf.dynobj,
1542 info))
1543 return FALSE;
1544 break;
1545 }
1546
1547 continue;
1548 }
71cb9464 1549 }
252b5132 1550
142411ca
L		 1551 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1552 symtab_hdr, sym_hashes,
1553 &r_type, GOT_UNKNOWN,
1554 rel, rel_end, h))
1555 return FALSE;
13ae64f3
JJ		 1556
1557 switch (r_type)
252b5132 1558 {
37e55690
JJ		 1559 case R_386_TLS_LDM:
1560 htab->tls_ldm_got.refcount += 1;
1561 goto create_got;
1562
1563 case R_386_PLT32:
1564 /* This symbol requires a procedure linkage table entry. We
1565 actually build the entry in adjust_dynamic_symbol,
1566 because this might be a case of linking PIC code which is
1567 never referenced by a dynamic object, in which case we
1568 don't need to generate a procedure linkage table entry
1569 after all. */
1570
1571 /* If this is a local symbol, we resolve it directly without
1572 creating a procedure linkage table entry. */
1573 if (h == NULL)
1574 continue;
1575
f5385ebf 1576 h->needs_plt = 1;
37e55690
JJ		 1577 h->plt.refcount += 1;
1578 break;
1579
13ae64f3 1580 case R_386_TLS_IE_32:
37e55690
JJ		 1581 case R_386_TLS_IE:
1582 case R_386_TLS_GOTIE:
13ae64f3
JJ		 1583 if (info->shared)
1584 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 1585 /* Fall through */
1586
252b5132 1587 case R_386_GOT32:
13ae64f3 1588 case R_386_TLS_GD:
67a4f2b7
AO		 1589 case R_386_TLS_GOTDESC:
1590 case R_386_TLS_DESC_CALL:
252b5132 1591 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 1592 {
1593 int tls_type, old_tls_type;
1594
1595 switch (r_type)
1596 {
1597 default:
1598 case R_386_GOT32: tls_type = GOT_NORMAL; break;
1599 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
67a4f2b7
AO		 1600 case R_386_TLS_GOTDESC:
1601 case R_386_TLS_DESC_CALL:
1602 tls_type = GOT_TLS_GDESC; break;
37e55690
JJ		 1603 case R_386_TLS_IE_32:
1604 if (ELF32_R_TYPE (rel->r_info) == r_type)
1605 tls_type = GOT_TLS_IE_NEG;
1606 else
ebcfb3c0
JJ		 1607 /* If this is a GD->IE transition, we may use either of
1608 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
37e55690
JJ		 1609 tls_type = GOT_TLS_IE;
1610 break;
1611 case R_386_TLS_IE:
1612 case R_386_TLS_GOTIE:
1613 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 1614 }
1615
1616 if (h != NULL)
1617 {
1618 h->got.refcount += 1;
1619 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1620 }
1621 else
1622 {
1623 bfd_signed_vma *local_got_refcounts;
1624
1625 /* This is a global offset table entry for a local symbol. */
1626 local_got_refcounts = elf_local_got_refcounts (abfd);
1627 if (local_got_refcounts == NULL)
1628 {
1629 bfd_size_type size;
1630
1631 size = symtab_hdr->sh_info;
67a4f2b7
AO		 1632 size *= (sizeof (bfd_signed_vma)
1633 + sizeof (bfd_vma) + sizeof(char));
55fd94b0 1634 local_got_refcounts = bfd_zalloc (abfd, size);
13ae64f3 1635 if (local_got_refcounts == NULL)
b34976b6 1636 return FALSE;
13ae64f3 1637 elf_local_got_refcounts (abfd) = local_got_refcounts;
67a4f2b7
AO		 1638 elf_i386_local_tlsdesc_gotent (abfd)
1639 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
13ae64f3 1640 elf_i386_local_got_tls_type (abfd)
67a4f2b7 1641 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
13ae64f3
JJ		 1642 }
1643 local_got_refcounts[r_symndx] += 1;
1644 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1645 }
1646
37e55690
JJ		 1647 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1648 tls_type |= old_tls_type;
13ae64f3
JJ		 1649 /* If a TLS symbol is accessed using IE at least once,
1650 there is no point to use dynamic model for it. */
ebcfb3c0 1651 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
67a4f2b7 1652 && (! GOT_TLS_GD_ANY_P (old_tls_type)
37e55690 1653 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 1654 {
67a4f2b7 1655 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
37e55690 1656 tls_type = old_tls_type;
67a4f2b7
AO		 1657 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1658 && GOT_TLS_GD_ANY_P (tls_type))
1659 tls_type |= old_tls_type;
13ae64f3
JJ		 1660 else
1661 {
1662 (*_bfd_error_handler)
d003868e 1663 (_("%B: `%s' accessed both as normal and "
55fd94b0 1664 "thread local symbol"),
d003868e 1665 abfd,
37e55690 1666 h ? h->root.root.string : "<local>");
b34976b6 1667 return FALSE;
13ae64f3
JJ		 1668 }
1669 }
1670
1671 if (old_tls_type != tls_type)
1672 {
1673 if (h != NULL)
1674 elf_i386_hash_entry (h)->tls_type = tls_type;
1675 else
1676 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1677 }
1678 }
0ac8d2ca
AM		 1679 /* Fall through */
1680
1681 case R_386_GOTOFF:
1682 case R_386_GOTPC:
13ae64f3 1683 create_got:
0ac8d2ca
AM		 1684 if (htab->sgot == NULL)
1685 {
1686 if (htab->elf.dynobj == NULL)
1687 htab->elf.dynobj = abfd;
eb4ff4d6 1688 if (!elf_i386_create_got_section (htab->elf.dynobj, info))
b34976b6 1689 return FALSE;
0ac8d2ca 1690 }
37e55690
JJ		 1691 if (r_type != R_386_TLS_IE)
1692 break;
1693 /* Fall through */
252b5132 1694
37e55690
JJ		 1695 case R_386_TLS_LE_32:
1696 case R_386_TLS_LE:
1697 if (!info->shared)
1698 break;
bffbf940 1699 info->flags |= DF_STATIC_TLS;
b34976b6 1700 /* Fall through */
252b5132
RH		 1701
1702 case R_386_32:
1703 case R_386_PC32:
710ab287 1704 if (h != NULL && info->executable)
6725bdbf 1705 {
12d0ee4a 1706 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 1707 need a copy reloc. We can't check reliably at this
1708 stage whether the section is read-only, as input
1709 sections have not yet been mapped to output sections.
1710 Tentatively set the flag for now, and correct in
1711 adjust_dynamic_symbol. */
f5385ebf 1712 h->non_got_ref = 1;
12d0ee4a
AM		 1713
1714 /* We may need a .plt entry if the function this reloc
1715 refers to is in a shared lib. */
51b64d56 1716 h->plt.refcount += 1;
c6585bbb 1717 if (r_type != R_386_PC32)
f5385ebf 1718 h->pointer_equality_needed = 1;
6725bdbf 1719 }
7843f00e 1720
252b5132 1721 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 1722 against a global symbol, or a non PC relative reloc
1723 against a local symbol, then we need to copy the reloc
1724 into the shared library. However, if we are linking with
1725 -Bsymbolic, we do not need to copy a reloc against a
1726 global symbol which is defined in an object we are
1727 including in the link (i.e., DEF_REGULAR is set). At
1728 this point we have not seen all the input files, so it is
1729 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 1730 later (it is never cleared). In case of a weak definition,
1731 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 1732 a shared library. We account for that possibility below by
1f655a09
L		 1733 storing information in the relocs_copied field of the hash
1734 table entry. A similar situation occurs when creating
1735 shared libraries and symbol visibility changes render the
12d0ee4a 1736 symbol local.
56882138 1737
12d0ee4a
AM		 1738 If on the other hand, we are creating an executable, we
1739 may need to keep relocations for symbols satisfied by a
1740 dynamic library if we manage to avoid copy relocs for the
1741 symbol. */
1742 if ((info->shared
1743 && (sec->flags & SEC_ALLOC) != 0
13ae64f3 1744 && (r_type != R_386_PC32
12d0ee4a 1745 || (h != NULL
55255dae 1746 && (! SYMBOLIC_BIND (info, h)
12d0ee4a 1747 || h->root.type == bfd_link_hash_defweak
f5385ebf 1748 || !h->def_regular))))
a23b6845
AM		 1749 || (ELIMINATE_COPY_RELOCS
1750 && !info->shared
12d0ee4a
AM		 1751 && (sec->flags & SEC_ALLOC) != 0
1752 && h != NULL
12d0ee4a 1753 && (h->root.type == bfd_link_hash_defweak
0f88be7a 1754 || !h->def_regular)))
252b5132 1755 {
ec338859
AM		 1756 struct elf_i386_dyn_relocs *p;
1757 struct elf_i386_dyn_relocs **head;
1758
12d0ee4a
AM		 1759 /* We must copy these reloc types into the output file.
1760 Create a reloc section in dynobj and make room for
1761 this reloc. */
252b5132
RH		 1762 if (sreloc == NULL)
1763 {
0ac8d2ca
AM		 1764 if (htab->elf.dynobj == NULL)
1765 htab->elf.dynobj = abfd;
1766
83bac4b0
NC		 1767 sreloc = _bfd_elf_make_dynamic_reloc_section
1768 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1769
252b5132 1770 if (sreloc == NULL)
83bac4b0 1771 return FALSE;
252b5132
RH		 1772 }
1773
0c715baa
AM		 1774 /* If this is a global symbol, we count the number of
1775 relocations we need for this symbol. */
1776 if (h != NULL)
252b5132 1777 {
ec338859 1778 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
0c715baa
AM		 1779 }
1780 else
1781 {
e81d3500 1782 void **vpp;
ec338859
AM		 1783 /* Track dynamic relocs needed for local syms too.
1784 We really need local syms available to do this
1785 easily. Oh well. */
1786
1787 asection *s;
1788 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1789 sec, r_symndx);
1790 if (s == NULL)
b34976b6 1791 return FALSE;
ec338859 1792
e81d3500
DD		 1793 vpp = &elf_section_data (s)->local_dynrel;
1794 head = (struct elf_i386_dyn_relocs **)vpp;
ec338859
AM		 1795 }
1796
1797 p = *head;
1798 if (p == NULL || p->sec != sec)
1799 {
1800 bfd_size_type amt = sizeof *p;
55fd94b0 1801 p = bfd_alloc (htab->elf.dynobj, amt);
ec338859 1802 if (p == NULL)
b34976b6 1803 return FALSE;
ec338859
AM		 1804 p->next = *head;
1805 *head = p;
1806 p->sec = sec;
1807 p->count = 0;
1808 p->pc_count = 0;
252b5132 1809 }
ec338859
AM		 1810
1811 p->count += 1;
13ae64f3 1812 if (r_type == R_386_PC32)
ec338859 1813 p->pc_count += 1;
252b5132 1814 }
252b5132
RH		 1815 break;
1816
1817 /* This relocation describes the C++ object vtable hierarchy.
1818 Reconstruct it for later use during GC. */
1819 case R_386_GNU_VTINHERIT:
d17e0c6e 1820 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 1821 return FALSE;
252b5132
RH		 1822 break;
1823
1824 /* This relocation describes which C++ vtable entries are actually
1825 used. Record for later use during GC. */
1826 case R_386_GNU_VTENTRY:
c6aa130f
MS		 1827 BFD_ASSERT (h != NULL);
1828 if (h != NULL
1829 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
b34976b6 1830 return FALSE;
252b5132
RH		 1831 break;
1832
1833 default:
1834 break;
1835 }
1836 }
1837
b34976b6 1838 return TRUE;
252b5132
RH		 1839}
1840
1841/* Return the section that should be marked against GC for a given
1842 relocation. */
1843
1844static asection *
55fd94b0 1845elf_i386_gc_mark_hook (asection *sec,
07adf181 1846 struct bfd_link_info *info,
55fd94b0
AM		 1847 Elf_Internal_Rela *rel,
1848 struct elf_link_hash_entry *h,
1849 Elf_Internal_Sym *sym)
252b5132
RH		 1850{
1851 if (h != NULL)
07adf181
AM		 1852 switch (ELF32_R_TYPE (rel->r_info))
1853 {
1854 case R_386_GNU_VTINHERIT:
1855 case R_386_GNU_VTENTRY:
1856 return NULL;
1857 }
1858
1859 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
252b5132
RH		 1860}
1861
1862/* Update the got entry reference counts for the section being removed. */
1863
b34976b6 1864static bfd_boolean
55fd94b0
AM		 1865elf_i386_gc_sweep_hook (bfd *abfd,
1866 struct bfd_link_info *info,
1867 asection *sec,
1868 const Elf_Internal_Rela *relocs)
252b5132 1869{
dd5724d5
AM		 1870 Elf_Internal_Shdr *symtab_hdr;
1871 struct elf_link_hash_entry **sym_hashes;
1872 bfd_signed_vma *local_got_refcounts;
1873 const Elf_Internal_Rela *rel, *relend;
dd5724d5 1874
7dda2462
TG		 1875 if (info->relocatable)
1876 return TRUE;
1877
ec338859 1878 elf_section_data (sec)->local_dynrel = NULL;
dd5724d5 1879
0ffa91dd 1880 symtab_hdr = &elf_symtab_hdr (abfd);
6725bdbf
AM		 1881 sym_hashes = elf_sym_hashes (abfd);
1882 local_got_refcounts = elf_local_got_refcounts (abfd);
dd5724d5
AM		 1883
1884 relend = relocs + sec->reloc_count;
1885 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 1886 {
1887 unsigned long r_symndx;
1888 unsigned int r_type;
1889 struct elf_link_hash_entry *h = NULL;
37e55690 1890
26e41594
AM		 1891 r_symndx = ELF32_R_SYM (rel->r_info);
1892 if (r_symndx >= symtab_hdr->sh_info)
1893 {
1894 struct elf_i386_link_hash_entry *eh;
1895 struct elf_i386_dyn_relocs **pp;
1896 struct elf_i386_dyn_relocs *p;
dd5724d5 1897
26e41594 1898 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 1899 while (h->root.type == bfd_link_hash_indirect
1900 || h->root.type == bfd_link_hash_warning)
1901 h = (struct elf_link_hash_entry *) h->root.u.i.link;
26e41594 1902 eh = (struct elf_i386_link_hash_entry *) h;
0c715baa 1903
26e41594
AM		 1904 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1905 if (p->sec == sec)
1906 {
1907 /* Everything must go for SEC. */
1908 *pp = p->next;
1909 break;
1910 }
1911 }
0c715baa 1912
26e41594 1913 r_type = ELF32_R_TYPE (rel->r_info);
142411ca
L		 1914 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1915 symtab_hdr, sym_hashes,
1916 &r_type, GOT_UNKNOWN,
1917 rel, relend, h))
1918 return FALSE;
1919
26e41594
AM		 1920 switch (r_type)
1921 {
1922 case R_386_TLS_LDM:
1923 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1924 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1925 break;
0c715baa 1926
26e41594 1927 case R_386_TLS_GD:
67a4f2b7
AO		 1928 case R_386_TLS_GOTDESC:
1929 case R_386_TLS_DESC_CALL:
26e41594
AM		 1930 case R_386_TLS_IE_32:
1931 case R_386_TLS_IE:
1932 case R_386_TLS_GOTIE:
1933 case R_386_GOT32:
1934 if (h != NULL)
1935 {
1936 if (h->got.refcount > 0)
1937 h->got.refcount -= 1;
1938 }
1939 else if (local_got_refcounts != NULL)
1940 {
1941 if (local_got_refcounts[r_symndx] > 0)
1942 local_got_refcounts[r_symndx] -= 1;
1943 }
1944 break;
0c715baa 1945
26e41594
AM		 1946 case R_386_32:
1947 case R_386_PC32:
1948 if (info->shared)
1949 break;
1950 /* Fall through */
6725bdbf 1951
26e41594
AM		 1952 case R_386_PLT32:
1953 if (h != NULL)
1954 {
1955 if (h->plt.refcount > 0)
1956 h->plt.refcount -= 1;
1957 }
1958 break;
dd5724d5 1959
26e41594
AM		 1960 default:
1961 break;
1962 }
1963 }
252b5132 1964
b34976b6 1965 return TRUE;
252b5132
RH		 1966}
1967
1968/* Adjust a symbol defined by a dynamic object and referenced by a
1969 regular object. The current definition is in some section of the
1970 dynamic object, but we're not including those sections. We have to
1971 change the definition to something the rest of the link can
1972 understand. */
1973
b34976b6 1974static bfd_boolean
55fd94b0
AM		 1975elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
1976 struct elf_link_hash_entry *h)
252b5132 1977{
6725bdbf 1978 struct elf_i386_link_hash_table *htab;
252b5132 1979 asection *s;
252b5132 1980
cbe950e9
L		 1981 /* STT_GNU_IFUNC symbol must go through PLT. */
1982 if (h->type == STT_GNU_IFUNC)
1983 {
1984 if (h->plt.refcount <= 0)
1985 {
1986 h->plt.offset = (bfd_vma) -1;
1987 h->needs_plt = 0;
1988 }
1989 return TRUE;
1990 }
1991
252b5132
RH		 1992 /* If this is a function, put it in the procedure linkage table. We
1993 will fill in the contents of the procedure linkage table later,
1994 when we know the address of the .got section. */
1995 if (h->type == STT_FUNC
f5385ebf 1996 || h->needs_plt)
252b5132 1997 {
6725bdbf 1998 if (h->plt.refcount <= 0
9c7a29a3
AM		 1999 || SYMBOL_CALLS_LOCAL (info, h)
2000 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2001 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2002 {
2003 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 2004 file, but the symbol was never referred to by a dynamic
2005 object, or if all references were garbage collected. In
2006 such a case, we don't actually need to build a procedure
2007 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 2008 h->plt.offset = (bfd_vma) -1;
f5385ebf 2009 h->needs_plt = 0;
252b5132
RH		 2010 }
2011
b34976b6 2012 return TRUE;
252b5132 2013 }
6725bdbf
AM		 2014 else
2015 /* It's possible that we incorrectly decided a .plt reloc was
2016 needed for an R_386_PC32 reloc to a non-function sym in
2017 check_relocs. We can't decide accurately between function and
2018 non-function syms in check-relocs; Objects loaded later in
2019 the link may change h->type. So fix it now. */
bbd7ec4a 2020 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 2021
2022 /* If this is a weak symbol, and there is a real definition, the
2023 processor independent code will have arranged for us to see the
2024 real definition first, and we can just use the same value. */
f6e332e6 2025 if (h->u.weakdef != NULL)
252b5132 2026 {
f6e332e6
AM		 2027 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2028 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2029 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2030 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 2031 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 2032 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 2033 return TRUE;
252b5132
RH		 2034 }
2035
2036 /* This is a reference to a symbol defined by a dynamic object which
2037 is not a function. */
2038
2039 /* If we are creating a shared library, we must presume that the
2040 only references to the symbol are via the global offset table.
2041 For such cases we need not do anything here; the relocations will
2042 be handled correctly by relocate_section. */
2043 if (info->shared)
b34976b6 2044 return TRUE;
252b5132 2045
7843f00e
ILT		 2046 /* If there are no references to this symbol that do not use the
2047 GOT, we don't need to generate a copy reloc. */
f5385ebf 2048 if (!h->non_got_ref)
b34976b6 2049 return TRUE;
7843f00e 2050
8bd621d8
AM		 2051 /* If -z nocopyreloc was given, we won't generate them either. */
2052 if (info->nocopyreloc)
2053 {
f5385ebf 2054 h->non_got_ref = 0;
b34976b6 2055 return TRUE;
8bd621d8
AM		 2056 }
2057
643796e3
DJ		 2058 htab = elf_i386_hash_table (info);
2059
2060 /* If there aren't any dynamic relocs in read-only sections, then
2061 we can keep the dynamic relocs and avoid the copy reloc. This
2062 doesn't work on VxWorks, where we can not have dynamic relocations
2063 (other than copy and jump slot relocations) in an executable. */
2064 if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks)
ebe50bae 2065 {
a23b6845
AM		 2066 struct elf_i386_link_hash_entry * eh;
2067 struct elf_i386_dyn_relocs *p;
ebe50bae 2068
a23b6845
AM		 2069 eh = (struct elf_i386_link_hash_entry *) h;
2070 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2071 {
2072 s = p->sec->output_section;
2073 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2074 break;
2075 }
2076
a23b6845
AM		 2077 if (p == NULL)
2078 {
f5385ebf 2079 h->non_got_ref = 0;
a23b6845
AM		 2080 return TRUE;
2081 }
ebe50bae
AM		 2082 }
2083
909272ee
AM		 2084 if (h->size == 0)
2085 {
2086 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2087 h->root.root.string);
2088 return TRUE;
2089 }
2090
252b5132
RH		 2091 /* We must allocate the symbol in our .dynbss section, which will
2092 become part of the .bss section of the executable. There will be
2093 an entry for this symbol in the .dynsym section. The dynamic
2094 object will contain position independent code, so all references
2095 from the dynamic object to this symbol will go through the global
2096 offset table. The dynamic linker will use the .dynsym entry to
2097 determine the address it must put in the global offset table, so
2098 both the dynamic object and the regular object will refer to the
2099 same memory location for the variable. */
2100
252b5132
RH		 2101 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2102 copy the initial value out of the dynamic object and into the
0ac8d2ca 2103 runtime process image. */
252b5132
RH		 2104 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2105 {
eea6121a 2106 htab->srelbss->size += sizeof (Elf32_External_Rel);
f5385ebf 2107 h->needs_copy = 1;
252b5132
RH		 2108 }
2109
0ac8d2ca 2110 s = htab->sdynbss;
252b5132 2111
027297b7 2112 return _bfd_elf_adjust_dynamic_copy (h, s);
252b5132
RH		 2113}
2114
6725bdbf 2115/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 2116 dynamic relocs. */
6725bdbf 2117
b34976b6 2118static bfd_boolean
eb4ff4d6 2119elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6725bdbf
AM		 2120{
2121 struct bfd_link_info *info;
2122 struct elf_i386_link_hash_table *htab;
5a15f56f 2123 struct elf_i386_link_hash_entry *eh;
0c715baa 2124 struct elf_i386_dyn_relocs *p;
6725bdbf 2125
e92d460e 2126 if (h->root.type == bfd_link_hash_indirect)
b34976b6 2127 return TRUE;
6725bdbf 2128
e92d460e
AM		 2129 if (h->root.type == bfd_link_hash_warning)
2130 /* When warning symbols are created, they **replace** the "real"
2131 entry in the hash table, thus we never get to see the real
2132 symbol in a hash traversal. So look at it now. */
2133 h = (struct elf_link_hash_entry *) h->root.u.i.link;
cbe950e9 2134 eh = (struct elf_i386_link_hash_entry *) h;
e92d460e 2135
6725bdbf
AM		 2136 info = (struct bfd_link_info *) inf;
2137 htab = elf_i386_hash_table (info);
2138
cbe950e9
L		 2139 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2140 here if it is defined and referenced in a non-shared object. */
2141 if (h->type == STT_GNU_IFUNC
2142 && h->def_regular)
2143 {
2144 asection *plt, *gotplt, *relplt;
2145
2146 /* Return and discard space for dynamic relocations against it if
2147 it is never referenced in a non-shared object. */
2148 if (!h->ref_regular)
2149 {
2150 if (h->plt.refcount > 0
2151 || h->got.refcount > 0)
2152 abort ();
2153 h->got.offset = (bfd_vma) -1;
2154 eh->dyn_relocs = NULL;
2155 return TRUE;
2156 }
2157
cbe950e9
L		 2158 /* When building a static executable, use .iplt, .igot.plt and
2159 .rel.iplt sections for STT_GNU_IFUNC symbols. */
710ab287 2160 if (htab->splt != NULL)
cbe950e9
L		 2161 {
2162 plt = htab->splt;
2163 gotplt = htab->sgotplt;
2164 relplt = htab->srelplt;
2165
2166 /* If this is the first .plt entry, make room for the special
2167 first entry. */
2168 if (plt->size == 0)
2169 plt->size += PLT_ENTRY_SIZE;
2170 }
2171 else
2172 {
2173 plt = htab->iplt;
2174 gotplt = htab->igotplt;
2175 relplt = htab->irelplt;
2176 }
2177
2178 /* Don't update value of STT_GNU_IFUNC symbol to PLT. We need
2179 the original value for R_386_IRELATIVE. */
2180 h->plt.offset = plt->size;
2181
2182 /* Make room for this entry in the .plt/.iplt section. */
2183 plt->size += PLT_ENTRY_SIZE;
2184
2185 /* We also need to make an entry in the .got.plt/.got.iplt
2186 section, which will be placed in the .got section by the
2187 linker script. */
2188 gotplt->size += 4;
2189
2190 /* We also need to make an entry in the .rela.plt/.rela.iplt
2191 section. */
2192 relplt->size += sizeof (Elf32_External_Rel);
2193 relplt->reloc_count++;
2194
710ab287
L		 2195 /* We need dynamic relocation for STT_GNU_IFUNC symbol only
2196 when there is a non-GOT reference in a shared object. */
2197 if (!info->shared
2198 || !h->non_got_ref)
cbe950e9
L		 2199 eh->dyn_relocs = NULL;
2200
710ab287
L		 2201 /* Finally, allocate space. */
2202 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2a81c24a 2203 htab->irelifunc->size += p->count * sizeof (Elf32_External_Rel);
710ab287
L		 2204
2205 /* For STT_GNU_IFUNC symbol, .got.plt has the real function
2206 addres and .got has the PLT entry adddress. We will load
2207 the GOT entry with the PLT entry in finish_dynamic_symbol if
2208 it is used. For branch, it uses .got.plt. For symbol value,
2209 1. Use .got.plt in a shared object if it is forced local or
2210 not dynamic.
2211 2. Use .got.plt in a non-shared object if pointer equality
2212 isn't needed.
2213 3. Use .got.plt if .got isn't used.
2214 4. Otherwise use .got so that it can be shared among different
2215 objects at run-time.
2216 We only need to relocate .got entry in shared object. */
2217 if ((info->shared
2218 && (h->dynindx == -1
2219 || h->forced_local))
2220 || (!info->shared
2221 && !h->pointer_equality_needed)
2222 || htab->sgot == NULL)
2223 {
2224 /* Use .got.plt. */
2225 h->got.offset = (bfd_vma) -1;
0018b0a3 2226 }
710ab287
L		 2227 else
2228 {
2229 h->got.offset = htab->sgot->size;
2230 htab->sgot->size += 4;
2231 if (info->shared)
2232 htab->srelgot->size += sizeof (Elf32_External_Rel);
2233 }
2234
2235 return TRUE;
cbe950e9
L		 2236 }
2237 else if (htab->elf.dynamic_sections_created
2238 && h->plt.refcount > 0)
6725bdbf 2239 {
5a15f56f
AM		 2240 /* Make sure this symbol is output as a dynamic symbol.
2241 Undefined weak syms won't yet be marked as dynamic. */
2242 if (h->dynindx == -1
f5385ebf 2243 && !h->forced_local)
5a15f56f 2244 {
c152c796 2245 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2246 return FALSE;
5a15f56f
AM		 2247 }
2248
4e795f50
AM		 2249 if (info->shared
2250 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
ced53ee5 2251 {
0ac8d2ca 2252 asection *s = htab->splt;
6725bdbf 2253
ced53ee5
AM		 2254 /* If this is the first .plt entry, make room for the special
2255 first entry. */
eea6121a
AM		 2256 if (s->size == 0)
2257 s->size += PLT_ENTRY_SIZE;
6725bdbf 2258
eea6121a 2259 h->plt.offset = s->size;
6725bdbf 2260
ced53ee5
AM		 2261 /* If this symbol is not defined in a regular file, and we are
2262 not generating a shared library, then set the symbol to this
2263 location in the .plt. This is required to make function
2264 pointers compare as equal between the normal executable and
2265 the shared library. */
2266 if (! info->shared
f5385ebf 2267 && !h->def_regular)
ced53ee5
AM		 2268 {
2269 h->root.u.def.section = s;
2270 h->root.u.def.value = h->plt.offset;
2271 }
6725bdbf 2272
ced53ee5 2273 /* Make room for this entry. */
eea6121a 2274 s->size += PLT_ENTRY_SIZE;
6725bdbf 2275
ced53ee5
AM		 2276 /* We also need to make an entry in the .got.plt section, which
2277 will be placed in the .got section by the linker script. */
eea6121a 2278 htab->sgotplt->size += 4;
6725bdbf 2279
6725bdbf 2280 /* We also need to make an entry in the .rel.plt section. */
eea6121a 2281 htab->srelplt->size += sizeof (Elf32_External_Rel);
5ae0bfb6 2282 htab->next_tls_desc_index++;
eac338cf
PB		 2283
2284 if (htab->is_vxworks && !info->shared)
2285 {
2286 /* VxWorks has a second set of relocations for each PLT entry
2287 in executables. They go in a separate relocation section,
2288 which is processed by the kernel loader. */
2289
2290 /* There are two relocations for the initial PLT entry: an
2291 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2292 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2293
2294 if (h->plt.offset == PLT_ENTRY_SIZE)
2295 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2296
2297 /* There are two extra relocations for each subsequent PLT entry:
2298 an R_386_32 relocation for the GOT entry, and an R_386_32
2299 relocation for the PLT entry. */
2300
2301 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2302 }
6725bdbf 2303 }
ced53ee5
AM		 2304 else
2305 {
51b64d56 2306 h->plt.offset = (bfd_vma) -1;
f5385ebf 2307 h->needs_plt = 0;
ced53ee5 2308 }
6725bdbf
AM		 2309 }
2310 else
2311 {
51b64d56 2312 h->plt.offset = (bfd_vma) -1;
f5385ebf 2313 h->needs_plt = 0;
6725bdbf
AM		 2314 }
2315
67a4f2b7
AO		 2316 eh->tlsdesc_got = (bfd_vma) -1;
2317
37e55690 2318 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 2319 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2320 if (h->got.refcount > 0
2321 && !info->shared
2322 && h->dynindx == -1
37e55690 2323 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 2324 h->got.offset = (bfd_vma) -1;
13ae64f3 2325 else if (h->got.refcount > 0)
6725bdbf 2326 {
0ac8d2ca 2327 asection *s;
b34976b6 2328 bfd_boolean dyn;
13ae64f3 2329 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 2330
5a15f56f
AM		 2331 /* Make sure this symbol is output as a dynamic symbol.
2332 Undefined weak syms won't yet be marked as dynamic. */
2333 if (h->dynindx == -1
f5385ebf 2334 && !h->forced_local)
5a15f56f 2335 {
c152c796 2336 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2337 return FALSE;
5a15f56f
AM		 2338 }
2339
6725bdbf 2340 s = htab->sgot;
67a4f2b7
AO		 2341 if (GOT_TLS_GDESC_P (tls_type))
2342 {
2343 eh->tlsdesc_got = htab->sgotplt->size
2344 - elf_i386_compute_jump_table_size (htab);
2345 htab->sgotplt->size += 8;
2346 h->got.offset = (bfd_vma) -2;
2347 }
2348 if (! GOT_TLS_GDESC_P (tls_type)
2349 || GOT_TLS_GD_P (tls_type))
2350 {
2351 h->got.offset = s->size;
2352 s->size += 4;
2353 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2354 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2355 s->size += 4;
2356 }
ebe50bae 2357 dyn = htab->elf.dynamic_sections_created;
13ae64f3 2358 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 2359 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2360 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2361 need two), R_386_TLS_GD needs one if local symbol and two if
2362 global. */
2363 if (tls_type == GOT_TLS_IE_BOTH)
eea6121a 2364 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 2365 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
37e55690 2366 || (tls_type & GOT_TLS_IE))
eea6121a 2367 htab->srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 2368 else if (GOT_TLS_GD_P (tls_type))
eea6121a 2369 htab->srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 2370 else if (! GOT_TLS_GDESC_P (tls_type)
2371 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2372 || h->root.type != bfd_link_hash_undefweak)
ef5aade5
L		 2373 && (info->shared
2374 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
eea6121a 2375 htab->srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7
AO		 2376 if (GOT_TLS_GDESC_P (tls_type))
2377 htab->srelplt->size += sizeof (Elf32_External_Rel);
6725bdbf
AM		 2378 }
2379 else
51b64d56 2380 h->got.offset = (bfd_vma) -1;
6725bdbf 2381
5a15f56f 2382 if (eh->dyn_relocs == NULL)
b34976b6 2383 return TRUE;
5a15f56f 2384
0c715baa
AM		 2385 /* In the shared -Bsymbolic case, discard space allocated for
2386 dynamic pc-relative relocs against symbols which turn out to be
2387 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 2388 space for pc-relative relocs that have become local due to symbol
2389 visibility changes. */
0c715baa
AM		 2390
2391 if (info->shared)
5a15f56f 2392 {
09695f56
AM		 2393 /* The only reloc that uses pc_count is R_386_PC32, which will
2394 appear on a call or on something like ".long foo - .". We
2395 want calls to protected symbols to resolve directly to the
2396 function rather than going via the plt. If people want
2397 function pointer comparisons to work as expected then they
2398 should avoid writing assembly like ".long foo - .". */
2399 if (SYMBOL_CALLS_LOCAL (info, h))
5a15f56f 2400 {
0c715baa
AM		 2401 struct elf_i386_dyn_relocs **pp;
2402
2403 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2404 {
2405 p->count -= p->pc_count;
2406 p->pc_count = 0;
2407 if (p->count == 0)
2408 *pp = p->next;
2409 else
2410 pp = &p->next;
2411 }
5a15f56f 2412 }
4e795f50 2413
3348747a
NS		 2414 if (htab->is_vxworks)
2415 {
2416 struct elf_i386_dyn_relocs **pp;
2417 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2418 {
2419 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2420 *pp = p->next;
2421 else
2422 pp = &p->next;
2423 }
2424 }
2425
4e795f50 2426 /* Also discard relocs on undefined weak syms with non-default
3348747a 2427 visibility. */
22d606e9 2428 if (eh->dyn_relocs != NULL
4e795f50 2429 && h->root.type == bfd_link_hash_undefweak)
22d606e9
AM		 2430 {
2431 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2432 eh->dyn_relocs = NULL;
2433
2434 /* Make sure undefined weak symbols are output as a dynamic
2435 symbol in PIEs. */
2436 else if (h->dynindx == -1
2437 && !h->forced_local)
2438 {
2439 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2440 return FALSE;
2441 }
2442 }
0c715baa 2443 }
a23b6845 2444 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 2445 {
2446 /* For the non-shared case, discard space for relocs against
2447 symbols which turn out to need copy relocs or are not
2448 dynamic. */
2449
f5385ebf
AM		 2450 if (!h->non_got_ref
2451 && ((h->def_dynamic
2452 && !h->def_regular)
ebe50bae 2453 || (htab->elf.dynamic_sections_created
0c715baa
AM		 2454 && (h->root.type == bfd_link_hash_undefweak
2455 || h->root.type == bfd_link_hash_undefined))))
2456 {
2457 /* Make sure this symbol is output as a dynamic symbol.
2458 Undefined weak syms won't yet be marked as dynamic. */
2459 if (h->dynindx == -1
f5385ebf 2460 && !h->forced_local)
0c715baa 2461 {
c152c796 2462 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2463 return FALSE;
0c715baa 2464 }
5a15f56f 2465
0c715baa
AM		 2466 /* If that succeeded, we know we'll be keeping all the
2467 relocs. */
2468 if (h->dynindx != -1)
2469 goto keep;
2470 }
2471
2472 eh->dyn_relocs = NULL;
2473
ec338859 2474 keep: ;
5a15f56f
AM		 2475 }
2476
0c715baa
AM		 2477 /* Finally, allocate space. */
2478 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 2479 {
e7c33416
NC		 2480 asection *sreloc;
2481
cbe950e9 2482 sreloc = elf_section_data (p->sec)->sreloc;
e7c33416
NC		 2483
2484 BFD_ASSERT (sreloc != NULL);
eea6121a 2485 sreloc->size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 2486 }
2487
b34976b6 2488 return TRUE;
6725bdbf
AM		 2489}
2490
c25bc9fc
L		 2491/* Allocate space in .plt, .got and associated reloc sections for
2492 local dynamic relocs. */
2493
2494static bfd_boolean
2495elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2496{
2497 struct elf_link_hash_entry *h
2498 = (struct elf_link_hash_entry *) *slot;
2499
2500 if (h->type != STT_GNU_IFUNC
2501 || !h->def_regular
2502 || !h->ref_regular
2503 || !h->forced_local
2504 || h->root.type != bfd_link_hash_defined)
2505 abort ();
2506
2507 return elf_i386_allocate_dynrelocs (h, inf);
2508}
2509
0c715baa
AM		 2510/* Find any dynamic relocs that apply to read-only sections. */
2511
b34976b6 2512static bfd_boolean
eb4ff4d6 2513elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
0c715baa
AM		 2514{
2515 struct elf_i386_link_hash_entry *eh;
2516 struct elf_i386_dyn_relocs *p;
2517
e92d460e
AM		 2518 if (h->root.type == bfd_link_hash_warning)
2519 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2520
0c715baa
AM		 2521 eh = (struct elf_i386_link_hash_entry *) h;
2522 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2523 {
2524 asection *s = p->sec->output_section;
2525
2526 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2527 {
2528 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2529
2530 info->flags |= DF_TEXTREL;
2531
2532 /* Not an error, just cut short the traversal. */
b34976b6 2533 return FALSE;
0c715baa
AM		 2534 }
2535 }
b34976b6 2536 return TRUE;
0c715baa
AM		 2537}
2538
252b5132
RH		 2539/* Set the sizes of the dynamic sections. */
2540
b34976b6 2541static bfd_boolean
55fd94b0
AM		 2542elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2543 struct bfd_link_info *info)
252b5132 2544{
6725bdbf 2545 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2546 bfd *dynobj;
2547 asection *s;
b34976b6 2548 bfd_boolean relocs;
0c715baa 2549 bfd *ibfd;
252b5132 2550
6725bdbf 2551 htab = elf_i386_hash_table (info);
ebe50bae 2552 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 2553 if (dynobj == NULL)
2554 abort ();
252b5132 2555
ebe50bae 2556 if (htab->elf.dynamic_sections_created)
252b5132
RH		 2557 {
2558 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 2559 if (info->executable)
252b5132
RH		 2560 {
2561 s = bfd_get_section_by_name (dynobj, ".interp");
ffb2e45b
AM		 2562 if (s == NULL)
2563 abort ();
eea6121a 2564 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
252b5132
RH		 2565 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2566 }
161d71a6 2567 }
6725bdbf 2568
0c715baa
AM		 2569 /* Set up .got offsets for local syms, and space for local dynamic
2570 relocs. */
2571 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
161d71a6
L		 2572 {
2573 bfd_signed_vma *local_got;
2574 bfd_signed_vma *end_local_got;
13ae64f3 2575 char *local_tls_type;
67a4f2b7 2576 bfd_vma *local_tlsdesc_gotent;
161d71a6
L		 2577 bfd_size_type locsymcount;
2578 Elf_Internal_Shdr *symtab_hdr;
2579 asection *srel;
6725bdbf 2580
0ffa91dd 2581 if (! is_i386_elf (ibfd))
161d71a6 2582 continue;
6725bdbf 2583
0c715baa
AM		 2584 for (s = ibfd->sections; s != NULL; s = s->next)
2585 {
ec338859 2586 struct elf_i386_dyn_relocs *p;
0c715baa 2587
e81d3500
DD		 2588 for (p = ((struct elf_i386_dyn_relocs *)
2589 elf_section_data (s)->local_dynrel);
ec338859
AM		 2590 p != NULL;
2591 p = p->next)
0c715baa 2592 {
ec338859
AM		 2593 if (!bfd_is_abs_section (p->sec)
2594 && bfd_is_abs_section (p->sec->output_section))
2595 {
2596 /* Input section has been discarded, either because
2597 it is a copy of a linkonce section or due to
2598 linker script /DISCARD/, so we'll be discarding
2599 the relocs too. */
2600 }
3348747a
NS		 2601 else if (htab->is_vxworks
2602 && strcmp (p->sec->output_section->name,
2603 ".tls_vars") == 0)
2604 {
2605 /* Relocations in vxworks .tls_vars sections are
2606 handled specially by the loader. */
2607 }
248866a8 2608 else if (p->count != 0)
ec338859
AM		 2609 {
2610 srel = elf_section_data (p->sec)->sreloc;
eea6121a 2611 srel->size += p->count * sizeof (Elf32_External_Rel);
248866a8
AM		 2612 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2613 info->flags |= DF_TEXTREL;
ec338859 2614 }
0c715baa
AM		 2615 }
2616 }
2617
2618 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 2619 if (!local_got)
2620 continue;
6725bdbf 2621
0ffa91dd 2622 symtab_hdr = &elf_symtab_hdr (ibfd);
161d71a6
L		 2623 locsymcount = symtab_hdr->sh_info;
2624 end_local_got = local_got + locsymcount;
13ae64f3 2625 local_tls_type = elf_i386_local_got_tls_type (ibfd);
67a4f2b7 2626 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
161d71a6
L		 2627 s = htab->sgot;
2628 srel = htab->srelgot;
67a4f2b7
AO		 2629 for (; local_got < end_local_got;
2630 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
161d71a6 2631 {
67a4f2b7 2632 *local_tlsdesc_gotent = (bfd_vma) -1;
161d71a6 2633 if (*local_got > 0)
6725bdbf 2634 {
67a4f2b7
AO		 2635 if (GOT_TLS_GDESC_P (*local_tls_type))
2636 {
2637 *local_tlsdesc_gotent = htab->sgotplt->size
2638 - elf_i386_compute_jump_table_size (htab);
2639 htab->sgotplt->size += 8;
2640 *local_got = (bfd_vma) -2;
2641 }
2642 if (! GOT_TLS_GDESC_P (*local_tls_type)
2643 || GOT_TLS_GD_P (*local_tls_type))
2644 {
2645 *local_got = s->size;
2646 s->size += 4;
2647 if (GOT_TLS_GD_P (*local_tls_type)
2648 || *local_tls_type == GOT_TLS_IE_BOTH)
2649 s->size += 4;
2650 }
13ae64f3 2651 if (info->shared
67a4f2b7 2652 || GOT_TLS_GD_ANY_P (*local_tls_type)
37e55690
JJ		 2653 || (*local_tls_type & GOT_TLS_IE))
2654 {
2655 if (*local_tls_type == GOT_TLS_IE_BOTH)
eea6121a 2656 srel->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 2657 else if (GOT_TLS_GD_P (*local_tls_type)
2658 || ! GOT_TLS_GDESC_P (*local_tls_type))
eea6121a 2659 srel->size += sizeof (Elf32_External_Rel);
67a4f2b7
AO		 2660 if (GOT_TLS_GDESC_P (*local_tls_type))
2661 htab->srelplt->size += sizeof (Elf32_External_Rel);
37e55690 2662 }
6725bdbf 2663 }
161d71a6
L		 2664 else
2665 *local_got = (bfd_vma) -1;
6725bdbf 2666 }
252b5132 2667 }
6725bdbf 2668
13ae64f3
JJ		 2669 if (htab->tls_ldm_got.refcount > 0)
2670 {
2671 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2672 relocs. */
eea6121a
AM		 2673 htab->tls_ldm_got.offset = htab->sgot->size;
2674 htab->sgot->size += 8;
2675 htab->srelgot->size += sizeof (Elf32_External_Rel);
13ae64f3
JJ		 2676 }
2677 else
2678 htab->tls_ldm_got.offset = -1;
2679
0c715baa
AM		 2680 /* Allocate global sym .plt and .got entries, and space for global
2681 sym dynamic relocs. */
eb4ff4d6 2682 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
252b5132 2683
c25bc9fc
L		 2684 /* Allocate .plt and .got entries, and space for local symbols. */
2685 htab_traverse (htab->loc_hash_table,
2686 elf_i386_allocate_local_dynrelocs,
2687 info);
2688
67a4f2b7
AO		 2689 /* For every jump slot reserved in the sgotplt, reloc_count is
2690 incremented. However, when we reserve space for TLS descriptors,
2691 it's not incremented, so in order to compute the space reserved
2692 for them, it suffices to multiply the reloc count by the jump
2693 slot size. */
2694 if (htab->srelplt)
5ae0bfb6 2695 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
67a4f2b7 2696
5a15f56f
AM		 2697 /* We now have determined the sizes of the various dynamic sections.
2698 Allocate memory for them. */
b34976b6 2699 relocs = FALSE;
252b5132
RH		 2700 for (s = dynobj->sections; s != NULL; s = s->next)
2701 {
eac338cf
PB		 2702 bfd_boolean strip_section = TRUE;
2703
252b5132
RH		 2704 if ((s->flags & SEC_LINKER_CREATED) == 0)
2705 continue;
2706
6725bdbf
AM		 2707 if (s == htab->splt
2708 || s == htab->sgot
75ff4589 2709 || s == htab->sgotplt
cbe950e9
L		 2710 || s == htab->iplt
2711 || s == htab->igotplt
75ff4589 2712 || s == htab->sdynbss)
252b5132 2713 {
6725bdbf
AM		 2714 /* Strip this section if we don't need it; see the
2715 comment below. */
eac338cf
PB		 2716 /* We'd like to strip these sections if they aren't needed, but if
2717 we've exported dynamic symbols from them we must leave them.
2718 It's too late to tell BFD to get rid of the symbols. */
2719
7325306f 2720 if (htab->elf.hplt != NULL)
eac338cf 2721 strip_section = FALSE;
252b5132 2722 }
0112cd26 2723 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
252b5132 2724 {
eac338cf 2725 if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2)
b34976b6 2726 relocs = TRUE;
252b5132 2727
0ac8d2ca
AM		 2728 /* We use the reloc_count field as a counter if we need
2729 to copy relocs into the output file. */
5ae0bfb6 2730 s->reloc_count = 0;
252b5132 2731 }
6725bdbf 2732 else
252b5132
RH		 2733 {
2734 /* It's not one of our sections, so don't allocate space. */
2735 continue;
2736 }
2737
c456f082 2738 if (s->size == 0)
252b5132 2739 {
0ac8d2ca
AM		 2740 /* If we don't need this section, strip it from the
2741 output file. This is mostly to handle .rel.bss and
2742 .rel.plt. We must create both sections in
2743 create_dynamic_sections, because they must be created
2744 before the linker maps input sections to output
2745 sections. The linker does that before
2746 adjust_dynamic_symbol is called, and it is that
2747 function which decides whether anything needs to go
2748 into these sections. */
c456f082
AM		 2749 if (strip_section)
2750 s->flags |= SEC_EXCLUDE;
252b5132
RH		 2751 continue;
2752 }
2753
c456f082
AM		 2754 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2755 continue;
2756
f69da49f
AM		 2757 /* Allocate memory for the section contents. We use bfd_zalloc
2758 here in case unused entries are not reclaimed before the
2759 section's contents are written out. This should not happen,
2760 but this way if it does, we get a R_386_NONE reloc instead
2761 of garbage. */
eea6121a 2762 s->contents = bfd_zalloc (dynobj, s->size);
6725bdbf 2763 if (s->contents == NULL)
b34976b6 2764 return FALSE;
252b5132
RH		 2765 }
2766
ebe50bae 2767 if (htab->elf.dynamic_sections_created)
252b5132
RH		 2768 {
2769 /* Add some entries to the .dynamic section. We fill in the
2770 values later, in elf_i386_finish_dynamic_sections, but we
2771 must add the entries now so that we get the correct size for
2772 the .dynamic section. The DT_DEBUG entry is filled in by the
2773 dynamic linker and used by the debugger. */
dc810e39 2774#define add_dynamic_entry(TAG, VAL) \
5a580b3a 2775 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 2776
36af4a4e 2777 if (info->executable)
252b5132 2778 {
dc810e39 2779 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 2780 return FALSE;
252b5132
RH		 2781 }
2782
eea6121a 2783 if (htab->splt->size != 0)
252b5132 2784 {
dc810e39
AM		 2785 if (!add_dynamic_entry (DT_PLTGOT, 0)
2786 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2787 || !add_dynamic_entry (DT_PLTREL, DT_REL)
2788 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 2789 return FALSE;
252b5132
RH		 2790 }
2791
2792 if (relocs)
2793 {
dc810e39
AM		 2794 if (!add_dynamic_entry (DT_REL, 0)
2795 || !add_dynamic_entry (DT_RELSZ, 0)
2796 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 2797 return FALSE;
252b5132 2798
0c715baa
AM		 2799 /* If any dynamic relocs apply to a read-only section,
2800 then we need a DT_TEXTREL entry. */
248866a8 2801 if ((info->flags & DF_TEXTREL) == 0)
eb4ff4d6
L		 2802 elf_link_hash_traverse (&htab->elf,
2803 elf_i386_readonly_dynrelocs, info);
0c715baa
AM		 2804
2805 if ((info->flags & DF_TEXTREL) != 0)
2806 {
2807 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 2808 return FALSE;
0c715baa 2809 }
252b5132 2810 }
7a2b07ff
NS		 2811 if (htab->is_vxworks
2812 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
2813 return FALSE;
252b5132 2814 }
dc810e39 2815#undef add_dynamic_entry
252b5132 2816
b34976b6 2817 return TRUE;
252b5132
RH		 2818}
2819
67a4f2b7
AO		 2820static bfd_boolean
2821elf_i386_always_size_sections (bfd *output_bfd,
2822 struct bfd_link_info *info)
2823{
2824 asection *tls_sec = elf_hash_table (info)->tls_sec;
2825
2826 if (tls_sec)
2827 {
2828 struct elf_link_hash_entry *tlsbase;
2829
2830 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2831 "_TLS_MODULE_BASE_",
2832 FALSE, FALSE, FALSE);
2833
2834 if (tlsbase && tlsbase->type == STT_TLS)
2835 {
2836 struct bfd_link_hash_entry *bh = NULL;
2837 const struct elf_backend_data *bed
2838 = get_elf_backend_data (output_bfd);
2839
2840 if (!(_bfd_generic_link_add_one_symbol
2841 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2842 tls_sec, 0, NULL, FALSE,
2843 bed->collect, &bh)))
2844 return FALSE;
9f03412a
AO		 2845
2846 elf_i386_hash_table (info)->tls_module_base = bh;
2847
67a4f2b7
AO		 2848 tlsbase = (struct elf_link_hash_entry *)bh;
2849 tlsbase->def_regular = 1;
2850 tlsbase->other = STV_HIDDEN;
2851 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2852 }
2853 }
2854
2855 return TRUE;
2856}
2857
38701953
AM		 2858/* Set the correct type for an x86 ELF section. We do this by the
2859 section name, which is a hack, but ought to work. */
2860
b34976b6 2861static bfd_boolean
55fd94b0
AM		 2862elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2863 Elf_Internal_Shdr *hdr,
2864 asection *sec)
38701953
AM		 2865{
2866 register const char *name;
2867
2868 name = bfd_get_section_name (abfd, sec);
2869
2870 /* This is an ugly, but unfortunately necessary hack that is
2871 needed when producing EFI binaries on x86. It tells
2872 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2873 containing ELF relocation info. We need this hack in order to
2874 be able to generate ELF binaries that can be translated into
2875 EFI applications (which are essentially COFF objects). Those
2876 files contain a COFF ".reloc" section inside an ELFNN object,
2877 which would normally cause BFD to segfault because it would
2878 attempt to interpret this section as containing relocation
2879 entries for section "oc". With this hack enabled, ".reloc"
2880 will be treated as a normal data section, which will avoid the
2881 segfault. However, you won't be able to create an ELFNN binary
2882 with a section named "oc" that needs relocations, but that's
2883 the kind of ugly side-effects you get when detecting section
2884 types based on their names... In practice, this limitation is
2885 unlikely to bite. */
2886 if (strcmp (name, ".reloc") == 0)
2887 hdr->sh_type = SHT_PROGBITS;
2888
b34976b6 2889 return TRUE;
38701953
AM		 2890}
2891
9f03412a
AO		 2892/* _TLS_MODULE_BASE_ needs to be treated especially when linking
2893 executables. Rather than setting it to the beginning of the TLS
2894 section, we have to set it to the end. This function may be called
2895 multiple times, it is idempotent. */
2896
2897static void
eb4ff4d6 2898elf_i386_set_tls_module_base (struct bfd_link_info *info)
9f03412a
AO		 2899{
2900 struct bfd_link_hash_entry *base;
2901
2902 if (!info->executable)
2903 return;
2904
2905 base = elf_i386_hash_table (info)->tls_module_base;
2906
2907 if (!base)
2908 return;
2909
2910 base->u.def.value = elf_hash_table (info)->tls_size;
2911}
2912
13ae64f3
JJ		 2913/* Return the base VMA address which should be subtracted from real addresses
2914 when resolving @dtpoff relocation.
2915 This is PT_TLS segment p_vaddr. */
2916
2917static bfd_vma
eb4ff4d6 2918elf_i386_dtpoff_base (struct bfd_link_info *info)
13ae64f3 2919{
e1918d23
AM		 2920 /* If tls_sec is NULL, we should have signalled an error already. */
2921 if (elf_hash_table (info)->tls_sec == NULL)
6a30718d 2922 return 0;
e1918d23 2923 return elf_hash_table (info)->tls_sec->vma;
13ae64f3
JJ		 2924}
2925
2926/* Return the relocation value for @tpoff relocation
2927 if STT_TLS virtual address is ADDRESS. */
2928
2929static bfd_vma
eb4ff4d6 2930elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
13ae64f3 2931{
e1918d23 2932 struct elf_link_hash_table *htab = elf_hash_table (info);
13ae64f3 2933
e1918d23
AM		 2934 /* If tls_sec is NULL, we should have signalled an error already. */
2935 if (htab->tls_sec == NULL)
6a30718d 2936 return 0;
e1918d23 2937 return htab->tls_size + htab->tls_sec->vma - address;
13ae64f3
JJ		 2938}
2939
252b5132
RH		 2940/* Relocate an i386 ELF section. */
2941
b34976b6 2942static bfd_boolean
55fd94b0
AM		 2943elf_i386_relocate_section (bfd *output_bfd,
2944 struct bfd_link_info *info,
2945 bfd *input_bfd,
2946 asection *input_section,
2947 bfd_byte *contents,
2948 Elf_Internal_Rela *relocs,
2949 Elf_Internal_Sym *local_syms,
2950 asection **local_sections)
252b5132 2951{
6725bdbf 2952 struct elf_i386_link_hash_table *htab;
252b5132
RH		 2953 Elf_Internal_Shdr *symtab_hdr;
2954 struct elf_link_hash_entry **sym_hashes;
2955 bfd_vma *local_got_offsets;
67a4f2b7 2956 bfd_vma *local_tlsdesc_gotents;
252b5132
RH		 2957 Elf_Internal_Rela *rel;
2958 Elf_Internal_Rela *relend;
3348747a 2959 bfd_boolean is_vxworks_tls;
252b5132 2960
0ffa91dd
NC		 2961 BFD_ASSERT (is_i386_elf (input_bfd));
2962
6725bdbf 2963 htab = elf_i386_hash_table (info);
0ffa91dd 2964 symtab_hdr = &elf_symtab_hdr (input_bfd);
252b5132
RH		 2965 sym_hashes = elf_sym_hashes (input_bfd);
2966 local_got_offsets = elf_local_got_offsets (input_bfd);
67a4f2b7 2967 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3348747a
NS		 2968 /* We have to handle relocations in vxworks .tls_vars sections
2969 specially, because the dynamic loader is 'weird'. */
2970 is_vxworks_tls = (htab->is_vxworks && info->shared
2971 && !strcmp (input_section->output_section->name,
2972 ".tls_vars"));
252b5132 2973
eb4ff4d6 2974 elf_i386_set_tls_module_base (info);
9f03412a 2975
252b5132
RH		 2976 rel = relocs;
2977 relend = relocs + input_section->reloc_count;
2978 for (; rel < relend; rel++)
2979 {
13ae64f3 2980 unsigned int r_type;
252b5132
RH		 2981 reloc_howto_type *howto;
2982 unsigned long r_symndx;
2983 struct elf_link_hash_entry *h;
2984 Elf_Internal_Sym *sym;
2985 asection *sec;
67a4f2b7 2986 bfd_vma off, offplt;
252b5132 2987 bfd_vma relocation;
b34976b6 2988 bfd_boolean unresolved_reloc;
252b5132 2989 bfd_reloc_status_type r;
1b452ec6 2990 unsigned int indx;
13ae64f3 2991 int tls_type;
252b5132
RH		 2992
2993 r_type = ELF32_R_TYPE (rel->r_info);
55fd94b0
AM		 2994 if (r_type == R_386_GNU_VTINHERIT
2995 || r_type == R_386_GNU_VTENTRY)
252b5132 2996 continue;
dc47f327 2997
55fd94b0 2998 if ((indx = r_type) >= R_386_standard
13ae64f3
JJ		 2999 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3000 >= R_386_ext - R_386_standard)
3001 && ((indx = r_type - R_386_tls_offset) - R_386_ext
cbe950e9 3002 >= R_386_irelative - R_386_ext))
252b5132 3003 {
6ba842b6 3004 (*_bfd_error_handler)
d003868e
AM		 3005 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3006 input_bfd, input_section, r_type);
252b5132 3007 bfd_set_error (bfd_error_bad_value);
b34976b6 3008 return FALSE;
252b5132 3009 }
1b452ec6 3010 howto = elf_howto_table + indx;
252b5132
RH		 3011
3012 r_symndx = ELF32_R_SYM (rel->r_info);
252b5132
RH		 3013 h = NULL;
3014 sym = NULL;
3015 sec = NULL;
b34976b6 3016 unresolved_reloc = FALSE;
252b5132
RH		 3017 if (r_symndx < symtab_hdr->sh_info)
3018 {
3019 sym = local_syms + r_symndx;
3020 sec = local_sections[r_symndx];
3021 relocation = (sec->output_section->vma
3022 + sec->output_offset
3023 + sym->st_value);
ab96bf03
AM		 3024
3025 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3026 && ((sec->flags & SEC_MERGE) != 0
3027 || (info->relocatable
3028 && sec->output_offset != 0)))
f8df10f4 3029 {
f8df10f4 3030 bfd_vma addend;
4a335f3d 3031 bfd_byte *where = contents + rel->r_offset;
f8df10f4 3032
4a335f3d 3033 switch (howto->size)
f8df10f4 3034 {
4a335f3d
AM		 3035 case 0:
3036 addend = bfd_get_8 (input_bfd, where);
3037 if (howto->pc_relative)
3038 {
3039 addend = (addend ^ 0x80) - 0x80;
3040 addend += 1;
3041 }
3042 break;
3043 case 1:
3044 addend = bfd_get_16 (input_bfd, where);
3045 if (howto->pc_relative)
3046 {
3047 addend = (addend ^ 0x8000) - 0x8000;
3048 addend += 2;
3049 }
3050 break;
3051 case 2:
3052 addend = bfd_get_32 (input_bfd, where);
3053 if (howto->pc_relative)
3054 {
3055 addend = (addend ^ 0x80000000) - 0x80000000;
3056 addend += 4;
3057 }
3058 break;
3059 default:
3060 abort ();
f8df10f4
JJ		 3061 }
3062
ab96bf03
AM		 3063 if (info->relocatable)
3064 addend += sec->output_offset;
3065 else
3066 {
3067 asection *msec = sec;
3068 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3069 addend);
3070 addend -= relocation;
3071 addend += msec->output_section->vma + msec->output_offset;
3072 }
4a335f3d
AM		 3073
3074 switch (howto->size)
3075 {
3076 case 0:
16a10388 3077 /* FIXME: overflow checks. */
4a335f3d
AM		 3078 if (howto->pc_relative)
3079 addend -= 1;
3080 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 3081 break;
3082 case 1:
3083 if (howto->pc_relative)
3084 addend -= 2;
3085 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 3086 break;
3087 case 2:
3088 if (howto->pc_relative)
3089 addend -= 4;
3090 bfd_put_32 (input_bfd, addend, where);
3091 break;
3092 }
f8df10f4 3093 }
c25bc9fc
L		 3094 else if (ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3095 {
3096 /* Relocate against local STT_GNU_IFUNC symbol. */
3097 h = elf_i386_get_local_sym_hash (htab, input_bfd,
3098 rel, FALSE);
3099 if (h == NULL)
3100 abort ();
3101
3102 /* Set STT_GNU_IFUNC symbol value. */
3103 h->root.u.def.value = sym->st_value;
3104 h->root.u.def.section = sec;
3105 }
252b5132
RH		 3106 }
3107 else
3108 {
560e09e9 3109 bfd_boolean warned;
ffb2e45b 3110
b2a8e766
AM		 3111 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3112 r_symndx, symtab_hdr, sym_hashes,
3113 h, sec, relocation,
3114 unresolved_reloc, warned);
252b5132
RH		 3115 }
3116
ab96bf03 3117 if (sec != NULL && elf_discarded_section (sec))
9635fe29 3118 {
ab96bf03
AM		 3119 /* For relocs against symbols from removed linkonce sections,
3120 or sections discarded by a linker script, we just want the
3121 section contents zeroed. Avoid any special processing. */
b1e24c02 3122 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
ab96bf03
AM		 3123 rel->r_info = 0;
3124 rel->r_addend = 0;
b1e24c02 3125 continue;
9635fe29
AM		 3126 }
3127
ab96bf03
AM		 3128 if (info->relocatable)
3129 continue;
3130
cbe950e9
L		 3131 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3132 it here if it is defined in a non-shared object. */
3133 if (h != NULL
3134 && h->type == STT_GNU_IFUNC
3135 && h->def_regular)
3136 {
3137 asection *plt, *gotplt, *base_got;
3138 bfd_vma plt_index;
3139
3140 if ((input_section->flags & SEC_ALLOC) == 0
3141 || h->plt.offset == (bfd_vma) -1)
3142 abort ();
3143
3144 /* STT_GNU_IFUNC symbol must go through PLT. */
3145 if (htab->splt != NULL)
3146 {
3147 plt = htab->splt;
3148 gotplt = htab->sgotplt;
3149 }
3150 else
3151 {
3152 plt = htab->iplt;
3153 gotplt = htab->igotplt;
3154 }
3155
3156 relocation = (plt->output_section->vma
3157 + plt->output_offset + h->plt.offset);
3158
3159 switch (r_type)
3160 {
3161 default:
3162 (*_bfd_error_handler)
3163 (_("%B: relocation %s against STT_GNU_IFUNC "
3164 "symbol `%s' isn't handled by %s"), input_bfd,
3165 elf_howto_table[r_type].name,
3166 h->root.root.string, __FUNCTION__);
3167 bfd_set_error (bfd_error_bad_value);
3168 return FALSE;
3169
3170 case R_386_32:
710ab287
L		 3171 /* Generate dynamic relcoation only when there is a
3172 non-GOF reference in a shared object. */
3173 if (info->shared && h->non_got_ref)
3174 {
3175 Elf_Internal_Rela outrel;
3176 bfd_byte *loc;
3177 asection *sreloc;
3178 bfd_vma offset;
3179
c25bc9fc
L		 3180 /* Need a dynamic relocation to get the real function
3181 adddress. */
710ab287
L		 3182 offset = _bfd_elf_section_offset (output_bfd,
3183 info,
3184 input_section,
3185 rel->r_offset);
3186 if (offset == (bfd_vma) -1
3187 || offset == (bfd_vma) -2)
3188 abort ();
3189
3190 outrel.r_offset = (input_section->output_section->vma
3191 + input_section->output_offset
3192 + offset);
3193
3194 if (h->dynindx == -1
3195 || h->forced_local)
3196 {
3197 /* This symbol is resolved locally. */
3198 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3199 bfd_put_32 (output_bfd,
3200 (h->root.u.def.value
3201 + h->root.u.def.section->output_section->vma
3202 + h->root.u.def.section->output_offset),
3203 contents + offset);
3204 }
3205 else
3206 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3207
2a81c24a 3208 sreloc = htab->irelifunc;
710ab287
L		 3209 loc = sreloc->contents;
3210 loc += (sreloc->reloc_count++
3211 * sizeof (Elf32_External_Rel));
3212 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3213
3214 /* If this reloc is against an external symbol, we
3215 do not want to fiddle with the addend. Otherwise,
3216 we need to include the symbol value so that it
3217 becomes an addend for the dynamic reloc. For an
3218 internal symbol, we have updated addend. */
3219 continue;
3220 }
3221
cbe950e9
L		 3222 case R_386_PC32:
3223 case R_386_PLT32:
3224 goto do_relocation;
3225
3226 case R_386_GOT32:
3227 base_got = htab->sgot;
3228 off = h->got.offset;
3229
7afd84dc 3230 if (base_got == NULL)
cbe950e9
L		 3231 abort ();
3232
7afd84dc 3233 if (off == (bfd_vma) -1)
cbe950e9 3234 {
7afd84dc
L		 3235 /* We can't use h->got.offset here to save state, or
3236 even just remember the offset, as finish_dynamic_symbol
3237 would use that as offset into .got. */
3238
3239 if (htab->splt != NULL)
3240 {
3241 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3242 off = (plt_index + 3) * 4;
3243 base_got = htab->sgotplt;
3244 }
cbe950e9
L		 3245 else
3246 {
7afd84dc
L		 3247 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
3248 off = plt_index * 4;
3249 base_got = htab->igotplt;
3250 }
3251
3252 if (h->dynindx == -1
3253 || h->forced_local
3254 || info->symbolic)
3255 {
3256 /* This references the local defitionion. We must
3257 initialize this entry in the global offset table.
3258 Since the offset must always be a multiple of 8,
3259 we use the least significant bit to record
3260 whether we have initialized it already.
3261
3262 When doing a dynamic link, we create a .rela.got
3263 relocation entry to initialize the value. This
3264 is done in the finish_dynamic_symbol routine. */
3265 if ((off & 1) != 0)
3266 off &= ~1;
3267 else
3268 {
3269 bfd_put_32 (output_bfd, relocation,
3270 base_got->contents + off);
3271 h->got.offset |= 1;
3272 }
cbe950e9 3273 }
cbe950e9 3274
7afd84dc 3275 relocation = off;
cbe950e9 3276
7afd84dc
L		 3277 /* Adjust for static executables. */
3278 if (htab->splt == NULL)
3279 relocation += gotplt->output_offset;
3280 }
3281 else
0018b0a3
L		 3282 {
3283 relocation = (base_got->output_section->vma
3284 + base_got->output_offset + off
3285 - gotplt->output_section->vma
3286 - gotplt->output_offset);
3287 /* Adjust for static executables. */
3288 if (htab->splt == NULL)
3289 relocation += gotplt->output_offset;
3290 }
3291
cbe950e9
L		 3292 goto do_relocation;
3293
3294 case R_386_GOTOFF:
3295 relocation -= (gotplt->output_section->vma
3296 + gotplt->output_offset);
3297 goto do_relocation;
3298 }
3299 }
3300
252b5132
RH		 3301 switch (r_type)
3302 {
3303 case R_386_GOT32:
3304 /* Relocation is to the entry for this symbol in the global
3305 offset table. */
ffb2e45b
AM		 3306 if (htab->sgot == NULL)
3307 abort ();
252b5132
RH		 3308
3309 if (h != NULL)
3310 {
b34976b6 3311 bfd_boolean dyn;
252b5132
RH		 3312
3313 off = h->got.offset;
ebe50bae 3314 dyn = htab->elf.dynamic_sections_created;
26e41594 3315 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
252b5132 3316 || (info->shared
586119b3 3317 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 3318 || (ELF_ST_VISIBILITY (h->other)
3319 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 3320 {
3321 /* This is actually a static link, or it is a
3322 -Bsymbolic link and the symbol is defined
3323 locally, or the symbol was forced to be local
3324 because of a version file. We must initialize
3325 this entry in the global offset table. Since the
3326 offset must always be a multiple of 4, we use the
3327 least significant bit to record whether we have
3328 initialized it already.
3329
3330 When doing a dynamic link, we create a .rel.got
3331 relocation entry to initialize the value. This
3332 is done in the finish_dynamic_symbol routine. */
3333 if ((off & 1) != 0)
3334 off &= ~1;
3335 else
3336 {
3337 bfd_put_32 (output_bfd, relocation,
6725bdbf 3338 htab->sgot->contents + off);
252b5132
RH		 3339 h->got.offset |= 1;
3340 }
3341 }
8c694914 3342 else
b34976b6 3343 unresolved_reloc = FALSE;
252b5132
RH		 3344 }
3345 else
3346 {
ffb2e45b
AM		 3347 if (local_got_offsets == NULL)
3348 abort ();
252b5132
RH		 3349
3350 off = local_got_offsets[r_symndx];
3351
3352 /* The offset must always be a multiple of 4. We use
83be169b
AM		 3353 the least significant bit to record whether we have
3354 already generated the necessary reloc. */
252b5132
RH		 3355 if ((off & 1) != 0)
3356 off &= ~1;
3357 else
3358 {
6725bdbf
AM		 3359 bfd_put_32 (output_bfd, relocation,
3360 htab->sgot->contents + off);
252b5132
RH		 3361
3362 if (info->shared)
3363 {
947216bf
AM		 3364 asection *s;
3365 Elf_Internal_Rela outrel;
3366 bfd_byte *loc;
252b5132 3367
947216bf
AM		 3368 s = htab->srelgot;
3369 if (s == NULL)
ffb2e45b 3370 abort ();
252b5132 3371
6725bdbf
AM		 3372 outrel.r_offset = (htab->sgot->output_section->vma
3373 + htab->sgot->output_offset
252b5132
RH		 3374 + off);
3375 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
947216bf
AM		 3376 loc = s->contents;
3377 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 3378 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 3379 }
3380
3381 local_got_offsets[r_symndx] |= 1;
3382 }
252b5132
RH		 3383 }
3384
ffb2e45b
AM		 3385 if (off >= (bfd_vma) -2)
3386 abort ();
3387
8c37241b
JJ		 3388 relocation = htab->sgot->output_section->vma
3389 + htab->sgot->output_offset + off
3390 - htab->sgotplt->output_section->vma
3391 - htab->sgotplt->output_offset;
252b5132
RH		 3392 break;
3393
3394 case R_386_GOTOFF:
3395 /* Relocation is relative to the start of the global offset
3396 table. */
3397
90f487df
L		 3398 /* Check to make sure it isn't a protected function symbol
3399 for shared library since it may not be local when used
41bed6dd
L		 3400 as function address. We also need to make sure that a
3401 symbol is defined locally. */
3402 if (info->shared && h)
90f487df 3403 {
41bed6dd
L		 3404 if (!h->def_regular)
3405 {
3406 const char *v;
3407
3408 switch (ELF_ST_VISIBILITY (h->other))
3409 {
3410 case STV_HIDDEN:
3411 v = _("hidden symbol");
3412 break;
3413 case STV_INTERNAL:
3414 v = _("internal symbol");
3415 break;
3416 case STV_PROTECTED:
3417 v = _("protected symbol");
3418 break;
3419 default:
3420 v = _("symbol");
3421 break;
3422 }
3423
3424 (*_bfd_error_handler)
3425 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
3426 input_bfd, v, h->root.root.string);
3427 bfd_set_error (bfd_error_bad_value);
3428 return FALSE;
3429 }
3430 else if (!info->executable
3431 && h->type == STT_FUNC
3432 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3433 {
3434 (*_bfd_error_handler)
3435 (_("%B: relocation R_386_GOTOFF against protected function `%s' can not be used when making a shared object"),
3436 input_bfd, h->root.root.string);
3437 bfd_set_error (bfd_error_bad_value);
3438 return FALSE;
3439 }
90f487df
L		 3440 }
3441
8c37241b
JJ		 3442 /* Note that sgot is not involved in this
3443 calculation. We always want the start of .got.plt. If we
3444 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
252b5132
RH		 3445 permitted by the ABI, we might have to change this
3446 calculation. */
8c37241b
JJ		 3447 relocation -= htab->sgotplt->output_section->vma
3448 + htab->sgotplt->output_offset;
252b5132
RH		 3449 break;
3450
3451 case R_386_GOTPC:
3452 /* Use global offset table as symbol value. */
8c37241b
JJ		 3453 relocation = htab->sgotplt->output_section->vma
3454 + htab->sgotplt->output_offset;
b34976b6 3455 unresolved_reloc = FALSE;
252b5132
RH		 3456 break;
3457
3458 case R_386_PLT32:
3459 /* Relocation is to the entry for this symbol in the
3460 procedure linkage table. */
3461
dd5724d5 3462 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 3463 without using the procedure linkage table. */
252b5132
RH		 3464 if (h == NULL)
3465 break;
3466
dd5724d5 3467 if (h->plt.offset == (bfd_vma) -1
6725bdbf 3468 || htab->splt == NULL)
252b5132
RH		 3469 {
3470 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 3471 happens when statically linking PIC code, or when
3472 using -Bsymbolic. */
252b5132
RH		 3473 break;
3474 }
3475
6725bdbf
AM		 3476 relocation = (htab->splt->output_section->vma
3477 + htab->splt->output_offset
252b5132 3478 + h->plt.offset);
b34976b6 3479 unresolved_reloc = FALSE;
252b5132
RH		 3480 break;
3481
3482 case R_386_32:
3483 case R_386_PC32:
3348747a
NS		 3484 if ((input_section->flags & SEC_ALLOC) == 0
3485 || is_vxworks_tls)
ec338859
AM		 3486 break;
3487
12d0ee4a 3488 if ((info->shared
ef5aade5
L		 3489 && (h == NULL
3490 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3491 || h->root.type != bfd_link_hash_undefweak)
12d0ee4a 3492 && (r_type != R_386_PC32
f6c52c13 3493 || !SYMBOL_CALLS_LOCAL (info, h)))
a23b6845
AM		 3494 || (ELIMINATE_COPY_RELOCS
3495 && !info->shared
12d0ee4a
AM		 3496 && h != NULL
3497 && h->dynindx != -1
f5385ebf
AM		 3498 && !h->non_got_ref
3499 && ((h->def_dynamic
3500 && !h->def_regular)
28d0b90e 3501 || h->root.type == bfd_link_hash_undefweak
0f88be7a 3502 || h->root.type == bfd_link_hash_undefined)))
252b5132 3503 {
947216bf
AM		 3504 Elf_Internal_Rela outrel;
3505 bfd_byte *loc;
b34976b6 3506 bfd_boolean skip, relocate;
0c715baa 3507 asection *sreloc;
252b5132
RH		 3508
3509 /* When generating a shared object, these relocations
3510 are copied into the output file to be resolved at run
3511 time. */
3512
b34976b6
AM		 3513 skip = FALSE;
3514 relocate = FALSE;
252b5132 3515
c629eae0
JJ		 3516 outrel.r_offset =
3517 _bfd_elf_section_offset (output_bfd, info, input_section,
3518 rel->r_offset);
3519 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 3520 skip = TRUE;
0bb2d96a 3521 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 3522 skip = TRUE, relocate = TRUE;
252b5132
RH		 3523 outrel.r_offset += (input_section->output_section->vma
3524 + input_section->output_offset);
3525
3526 if (skip)
0bb2d96a 3527 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 3528 else if (h != NULL
3529 && h->dynindx != -1
3530 && (r_type == R_386_PC32
3531 || !info->shared
55255dae 3532 || !SYMBOLIC_BIND (info, h)
f5385ebf 3533 || !h->def_regular))
0bb2d96a 3534 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 3535 else
3536 {
5a15f56f 3537 /* This symbol is local, or marked to become local. */
b34976b6 3538 relocate = TRUE;
5a15f56f 3539 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 3540 }
3541
cbe950e9 3542 sreloc = elf_section_data (input_section)->sreloc;
e7c33416
NC		 3543
3544 BFD_ASSERT (sreloc != NULL && sreloc->contents != NULL);
0c715baa 3545
947216bf
AM		 3546 loc = sreloc->contents;
3547 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
e7c33416 3548
0c715baa 3549 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
252b5132
RH		 3550
3551 /* If this reloc is against an external symbol, we do
3552 not want to fiddle with the addend. Otherwise, we
3553 need to include the symbol value so that it becomes
3554 an addend for the dynamic reloc. */
0f88be7a 3555 if (! relocate)
252b5132
RH		 3556 continue;
3557 }
252b5132
RH		 3558 break;
3559
37e55690
JJ		 3560 case R_386_TLS_IE:
3561 if (info->shared)
3562 {
947216bf
AM		 3563 Elf_Internal_Rela outrel;
3564 bfd_byte *loc;
37e55690 3565 asection *sreloc;
37e55690
JJ		 3566
3567 outrel.r_offset = rel->r_offset
3568 + input_section->output_section->vma
3569 + input_section->output_offset;
3570 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3571 sreloc = elf_section_data (input_section)->sreloc;
3572 if (sreloc == NULL)
3573 abort ();
947216bf
AM		 3574 loc = sreloc->contents;
3575 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 3576 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3577 }
3578 /* Fall through */
3579
13ae64f3 3580 case R_386_TLS_GD:
67a4f2b7
AO		 3581 case R_386_TLS_GOTDESC:
3582 case R_386_TLS_DESC_CALL:
13ae64f3 3583 case R_386_TLS_IE_32:
37e55690 3584 case R_386_TLS_GOTIE:
13ae64f3
JJ		 3585 tls_type = GOT_UNKNOWN;
3586 if (h == NULL && local_got_offsets)
3587 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
3588 else if (h != NULL)
142411ca 3589 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690
JJ		 3590 if (tls_type == GOT_TLS_IE)
3591 tls_type = GOT_TLS_IE_NEG;
142411ca
L		 3592
3593 if (! elf_i386_tls_transition (info, input_bfd,
3594 input_section, contents,
3595 symtab_hdr, sym_hashes,
3596 &r_type, tls_type, rel,
3597 relend, h))
3598 return FALSE;
13ae64f3
JJ		 3599
3600 if (r_type == R_386_TLS_LE_32)
3601 {
82e51918 3602 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 3603 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
3604 {
142411ca 3605 unsigned int type;
13ae64f3
JJ		 3606 bfd_vma roff;
3607
3608 /* GD->LE transition. */
13ae64f3 3609 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 3610 if (type == 0x04)
3611 {
3612 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3613 Change it into:
3614 movl %gs:0, %eax; subl $foo@tpoff, %eax
3615 (6 byte form of subl). */
13ae64f3
JJ		 3616 memcpy (contents + rel->r_offset - 3,
3617 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
142411ca 3618 roff = rel->r_offset + 5;
13ae64f3
JJ		 3619 }
3620 else
3621 {
142411ca
L		 3622 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3623 Change it into:
3624 movl %gs:0, %eax; subl $foo@tpoff, %eax
3625 (6 byte form of subl). */
3626 memcpy (contents + rel->r_offset - 2,
3627 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3628 roff = rel->r_offset + 6;
13ae64f3 3629 }
eb4ff4d6 3630 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
13ae64f3 3631 contents + roff);
a3fadc9a 3632 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3
JJ		 3633 rel++;
3634 continue;
3635 }
67a4f2b7
AO		 3636 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3637 {
3638 /* GDesc -> LE transition.
3639 It's originally something like:
3640 leal x@tlsdesc(%ebx), %eax
3641
3642 leal x@ntpoff, %eax
3643
3644 Registers other than %eax may be set up here. */
3645
142411ca 3646 unsigned int val;
67a4f2b7
AO		 3647 bfd_vma roff;
3648
67a4f2b7 3649 roff = rel->r_offset;
67a4f2b7 3650 val = bfd_get_8 (input_bfd, contents + roff - 1);
67a4f2b7
AO		 3651
3652 /* Now modify the instruction as appropriate. */
3653 /* aoliva FIXME: remove the above and xor the byte
3654 below with 0x86. */
3655 bfd_put_8 (output_bfd, val ^ 0x86,
3656 contents + roff - 1);
eb4ff4d6 3657 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
67a4f2b7
AO		 3658 contents + roff);
3659 continue;
3660 }
3661 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
3662 {
3663 /* GDesc -> LE transition.
3664 It's originally:
3665 call *(%eax)
3666 Turn it into:
142411ca 3667 xchg %ax,%ax */
67a4f2b7 3668
67a4f2b7 3669 bfd_vma roff;
142411ca 3670
67a4f2b7 3671 roff = rel->r_offset;
10efb593 3672 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 3673 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3674 continue;
3675 }
37e55690 3676 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3 3677 {
142411ca 3678 unsigned int val;
13ae64f3
JJ		 3679
3680 /* IE->LE transition:
37e55690
JJ		 3681 Originally it can be one of:
3682 movl foo, %eax
3683 movl foo, %reg
3684 addl foo, %reg
3685 We change it into:
3686 movl $foo, %eax
3687 movl $foo, %reg
3688 addl $foo, %reg. */
37e55690 3689 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
37e55690
JJ		 3690 if (val == 0xa1)
3691 {
3692 /* movl foo, %eax. */
55fd94b0
AM		 3693 bfd_put_8 (output_bfd, 0xb8,
3694 contents + rel->r_offset - 1);
37e55690 3695 }
299bf759 3696 else
37e55690 3697 {
142411ca
L		 3698 unsigned int type;
3699
55fd94b0
AM		 3700 type = bfd_get_8 (input_bfd,
3701 contents + rel->r_offset - 2);
299bf759 3702 switch (type)
26e41594 3703 {
299bf759
L		 3704 case 0x8b:
3705 /* movl */
299bf759
L		 3706 bfd_put_8 (output_bfd, 0xc7,
3707 contents + rel->r_offset - 2);
3708 bfd_put_8 (output_bfd,
3709 0xc0 | ((val >> 3) & 7),
3710 contents + rel->r_offset - 1);
3711 break;
3712 case 0x03:
3713 /* addl */
299bf759
L		 3714 bfd_put_8 (output_bfd, 0x81,
3715 contents + rel->r_offset - 2);
3716 bfd_put_8 (output_bfd,
3717 0xc0 | ((val >> 3) & 7),
3718 contents + rel->r_offset - 1);
3719 break;
3720 default:
3721 BFD_FAIL ();
3722 break;
26e41594 3723 }
37e55690 3724 }
eb4ff4d6 3725 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 3726 contents + rel->r_offset);
3727 continue;
3728 }
3729 else
3730 {
3731 unsigned int val, type;
3732
3733 /* {IE_32,GOTIE}->LE transition:
3734 Originally it can be one of:
13ae64f3 3735 subl foo(%reg1), %reg2
13ae64f3 3736 movl foo(%reg1), %reg2
37e55690 3737 addl foo(%reg1), %reg2
13ae64f3
JJ		 3738 We change it into:
3739 subl $foo, %reg2
37e55690
JJ		 3740 movl $foo, %reg2 (6 byte form)
3741 addl $foo, %reg2. */
13ae64f3
JJ		 3742 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3743 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
13ae64f3
JJ		 3744 if (type == 0x8b)
3745 {
3746 /* movl */
13ae64f3
JJ		 3747 bfd_put_8 (output_bfd, 0xc7,
3748 contents + rel->r_offset - 2);
3749 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3750 contents + rel->r_offset - 1);
3751 }
3752 else if (type == 0x2b)
3753 {
3754 /* subl */
13ae64f3
JJ		 3755 bfd_put_8 (output_bfd, 0x81,
3756 contents + rel->r_offset - 2);
3757 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
3758 contents + rel->r_offset - 1);
3759 }
37e55690
JJ		 3760 else if (type == 0x03)
3761 {
3762 /* addl */
3763 bfd_put_8 (output_bfd, 0x81,
3764 contents + rel->r_offset - 2);
3765 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3766 contents + rel->r_offset - 1);
3767 }
13ae64f3
JJ		 3768 else
3769 BFD_FAIL ();
37e55690 3770 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
eb4ff4d6 3771 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 3772 contents + rel->r_offset);
3773 else
eb4ff4d6 3774 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
37e55690 3775 contents + rel->r_offset);
13ae64f3
JJ		 3776 continue;
3777 }
3778 }
3779
3780 if (htab->sgot == NULL)
3781 abort ();
3782
3783 if (h != NULL)
67a4f2b7
AO		 3784 {
3785 off = h->got.offset;
3786 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
3787 }
13ae64f3
JJ		 3788 else
3789 {
3790 if (local_got_offsets == NULL)
3791 abort ();
3792
3793 off = local_got_offsets[r_symndx];
67a4f2b7 3794 offplt = local_tlsdesc_gotents[r_symndx];
13ae64f3
JJ		 3795 }
3796
3797 if ((off & 1) != 0)
3798 off &= ~1;
26e41594 3799 else
13ae64f3 3800 {
947216bf
AM		 3801 Elf_Internal_Rela outrel;
3802 bfd_byte *loc;
13ae64f3 3803 int dr_type, indx;
67a4f2b7 3804 asection *sreloc;
13ae64f3
JJ		 3805
3806 if (htab->srelgot == NULL)
3807 abort ();
3808
67a4f2b7
AO		 3809 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3810
3811 if (GOT_TLS_GDESC_P (tls_type))
3812 {
3813 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
3814 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
3815 <= htab->sgotplt->size);
3816 outrel.r_offset = (htab->sgotplt->output_section->vma
3817 + htab->sgotplt->output_offset
3818 + offplt
3819 + htab->sgotplt_jump_table_size);
3820 sreloc = htab->srelplt;
3821 loc = sreloc->contents;
5ae0bfb6
RS		 3822 loc += (htab->next_tls_desc_index++
3823 * sizeof (Elf32_External_Rel));
67a4f2b7
AO		 3824 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3825 <= sreloc->contents + sreloc->size);
3826 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3827 if (indx == 0)
3828 {
3829 BFD_ASSERT (! unresolved_reloc);
3830 bfd_put_32 (output_bfd,
eb4ff4d6 3831 relocation - elf_i386_dtpoff_base (info),
67a4f2b7
AO		 3832 htab->sgotplt->contents + offplt
3833 + htab->sgotplt_jump_table_size + 4);
3834 }
3835 else
3836 {
3837 bfd_put_32 (output_bfd, 0,
3838 htab->sgotplt->contents + offplt
3839 + htab->sgotplt_jump_table_size + 4);
3840 }
3841 }
3842
3843 sreloc = htab->srelgot;
3844
13ae64f3
JJ		 3845 outrel.r_offset = (htab->sgot->output_section->vma
3846 + htab->sgot->output_offset + off);
3847
67a4f2b7 3848 if (GOT_TLS_GD_P (tls_type))
13ae64f3 3849 dr_type = R_386_TLS_DTPMOD32;
67a4f2b7
AO		 3850 else if (GOT_TLS_GDESC_P (tls_type))
3851 goto dr_done;
37e55690
JJ		 3852 else if (tls_type == GOT_TLS_IE_POS)
3853 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 3854 else
3855 dr_type = R_386_TLS_TPOFF32;
67a4f2b7 3856
37e55690 3857 if (dr_type == R_386_TLS_TPOFF && indx == 0)
eb4ff4d6
L		 3858 bfd_put_32 (output_bfd,
3859 relocation - elf_i386_dtpoff_base (info),
37e55690
JJ		 3860 htab->sgot->contents + off);
3861 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
eb4ff4d6
L		 3862 bfd_put_32 (output_bfd,
3863 elf_i386_dtpoff_base (info) - relocation,
c366c25e 3864 htab->sgot->contents + off);
67a4f2b7 3865 else if (dr_type != R_386_TLS_DESC)
c366c25e
JJ		 3866 bfd_put_32 (output_bfd, 0,
3867 htab->sgot->contents + off);
13ae64f3 3868 outrel.r_info = ELF32_R_INFO (indx, dr_type);
67a4f2b7
AO		 3869
3870 loc = sreloc->contents;
3871 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3872 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3873 <= sreloc->contents + sreloc->size);
13ae64f3
JJ		 3874 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3875
67a4f2b7 3876 if (GOT_TLS_GD_P (tls_type))
13ae64f3
JJ		 3877 {
3878 if (indx == 0)
3879 {
82e51918 3880 BFD_ASSERT (! unresolved_reloc);
13ae64f3 3881 bfd_put_32 (output_bfd,
eb4ff4d6 3882 relocation - elf_i386_dtpoff_base (info),
13ae64f3
JJ		 3883 htab->sgot->contents + off + 4);
3884 }
3885 else
3886 {
3887 bfd_put_32 (output_bfd, 0,
3888 htab->sgot->contents + off + 4);
3889 outrel.r_info = ELF32_R_INFO (indx,
3890 R_386_TLS_DTPOFF32);
3891 outrel.r_offset += 4;
67a4f2b7 3892 sreloc->reloc_count++;
947216bf 3893 loc += sizeof (Elf32_External_Rel);
67a4f2b7
AO		 3894 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
3895 <= sreloc->contents + sreloc->size);
947216bf 3896 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
13ae64f3
JJ		 3897 }
3898 }
37e55690
JJ		 3899 else if (tls_type == GOT_TLS_IE_BOTH)
3900 {
3901 bfd_put_32 (output_bfd,
eb4ff4d6
L		 3902 (indx == 0
3903 ? relocation - elf_i386_dtpoff_base (info)
3904 : 0),
37e55690
JJ		 3905 htab->sgot->contents + off + 4);
3906 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
3907 outrel.r_offset += 4;
67a4f2b7 3908 sreloc->reloc_count++;
947216bf 3909 loc += sizeof (Elf32_External_Rel);
37e55690
JJ		 3910 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3911 }
13ae64f3 3912
67a4f2b7 3913 dr_done:
13ae64f3
JJ		 3914 if (h != NULL)
3915 h->got.offset |= 1;
3916 else
3917 local_got_offsets[r_symndx] |= 1;
3918 }
3919
67a4f2b7
AO		 3920 if (off >= (bfd_vma) -2
3921 && ! GOT_TLS_GDESC_P (tls_type))
13ae64f3 3922 abort ();
67a4f2b7
AO		 3923 if (r_type == R_386_TLS_GOTDESC
3924 || r_type == R_386_TLS_DESC_CALL)
3925 {
3926 relocation = htab->sgotplt_jump_table_size + offplt;
3927 unresolved_reloc = FALSE;
3928 }
3929 else if (r_type == ELF32_R_TYPE (rel->r_info))
13ae64f3 3930 {
8c37241b
JJ		 3931 bfd_vma g_o_t = htab->sgotplt->output_section->vma
3932 + htab->sgotplt->output_offset;
3933 relocation = htab->sgot->output_section->vma
67a4f2b7 3934 + htab->sgot->output_offset + off - g_o_t;
37e55690
JJ		 3935 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
3936 && tls_type == GOT_TLS_IE_BOTH)
3937 relocation += 4;
3938 if (r_type == R_386_TLS_IE)
8c37241b 3939 relocation += g_o_t;
b34976b6 3940 unresolved_reloc = FALSE;
13ae64f3 3941 }
67a4f2b7 3942 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
13ae64f3
JJ		 3943 {
3944 unsigned int val, type;
3945 bfd_vma roff;
3946
3947 /* GD->IE transition. */
13ae64f3 3948 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
13ae64f3
JJ		 3949 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3950 if (type == 0x04)
3951 {
3952 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3953 Change it into:
3954 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3 3955 val >>= 3;
142411ca 3956 roff = rel->r_offset - 3;
13ae64f3
JJ		 3957 }
3958 else
3959 {
3960 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3961 Change it into:
3962 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
13ae64f3
JJ		 3963 roff = rel->r_offset - 2;
3964 }
3965 memcpy (contents + roff,
3966 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
3967 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 3968 /* If foo is used only with foo@gotntpoff(%reg) and
3969 foo@indntpoff, but not with foo@gottpoff(%reg), change
3970 subl $foo@gottpoff(%reg), %eax
3971 into:
3972 addl $foo@gotntpoff(%reg), %eax. */
ebcfb3c0
JJ		 3973 if (tls_type == GOT_TLS_IE_POS)
3974 contents[roff + 6] = 0x03;
8c37241b
JJ		 3975 bfd_put_32 (output_bfd,
3976 htab->sgot->output_section->vma
3977 + htab->sgot->output_offset + off
3978 - htab->sgotplt->output_section->vma
3979 - htab->sgotplt->output_offset,
13ae64f3
JJ		 3980 contents + roff + 8);
3981 /* Skip R_386_PLT32. */
3982 rel++;
3983 continue;
3984 }
67a4f2b7
AO		 3985 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
3986 {
3987 /* GDesc -> IE transition.
3988 It's originally something like:
3989 leal x@tlsdesc(%ebx), %eax
3990
3991 Change it to:
142411ca 3992 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
67a4f2b7
AO		 3993 or:
3994 movl x@gottpoff(%ebx), %eax # before negl %eax
3995
3996 Registers other than %eax may be set up here. */
3997
67a4f2b7
AO		 3998 bfd_vma roff;
3999
4000 /* First, make sure it's a leal adding ebx to a 32-bit
4001 offset into any register, although it's probably
4002 almost always going to be eax. */
4003 roff = rel->r_offset;
67a4f2b7
AO		 4004
4005 /* Now modify the instruction as appropriate. */
4006 /* To turn a leal into a movl in the form we use it, it
4007 suffices to change the first byte from 0x8d to 0x8b.
4008 aoliva FIXME: should we decide to keep the leal, all
4009 we have to do is remove the statement below, and
4010 adjust the relaxation of R_386_TLS_DESC_CALL. */
4011 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4012
4013 if (tls_type == GOT_TLS_IE_BOTH)
4014 off += 4;
4015
4016 bfd_put_32 (output_bfd,
4017 htab->sgot->output_section->vma
4018 + htab->sgot->output_offset + off
4019 - htab->sgotplt->output_section->vma
4020 - htab->sgotplt->output_offset,
4021 contents + roff);
4022 continue;
4023 }
4024 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4025 {
4026 /* GDesc -> IE transition.
4027 It's originally:
4028 call *(%eax)
4029
4030 Change it to:
142411ca 4031 xchg %ax,%ax
67a4f2b7
AO		 4032 or
4033 negl %eax
4034 depending on how we transformed the TLS_GOTDESC above.
4035 */
4036
67a4f2b7
AO		 4037 bfd_vma roff;
4038
67a4f2b7 4039 roff = rel->r_offset;
67a4f2b7
AO		 4040
4041 /* Now modify the instruction as appropriate. */
4042 if (tls_type != GOT_TLS_IE_NEG)
4043 {
10efb593
L		 4044 /* xchg %ax,%ax */
4045 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 4046 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4047 }
4048 else
4049 {
4050 /* negl %eax */
4051 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4052 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4053 }
4054
4055 continue;
4056 }
4057 else
4058 BFD_ASSERT (FALSE);
13ae64f3
JJ		 4059 break;
4060
4061 case R_386_TLS_LDM:
142411ca
L		 4062 if (! elf_i386_tls_transition (info, input_bfd,
4063 input_section, contents,
4064 symtab_hdr, sym_hashes,
4065 &r_type, GOT_UNKNOWN, rel,
4066 relend, h))
4067 return FALSE;
13ae64f3 4068
142411ca
L		 4069 if (r_type != R_386_TLS_LDM)
4070 {
13ae64f3 4071 /* LD->LE transition:
13ae64f3
JJ		 4072 leal foo(%reg), %eax; call ___tls_get_addr.
4073 We change it into:
4074 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
142411ca 4075 BFD_ASSERT (r_type == R_386_TLS_LE_32);
13ae64f3
JJ		 4076 memcpy (contents + rel->r_offset - 2,
4077 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
a3fadc9a 4078 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3
JJ		 4079 rel++;
4080 continue;
4081 }
4082
4083 if (htab->sgot == NULL)
4084 abort ();
4085
4086 off = htab->tls_ldm_got.offset;
4087 if (off & 1)
4088 off &= ~1;
4089 else
4090 {
947216bf
AM		 4091 Elf_Internal_Rela outrel;
4092 bfd_byte *loc;
13ae64f3
JJ		 4093
4094 if (htab->srelgot == NULL)
4095 abort ();
4096
4097 outrel.r_offset = (htab->sgot->output_section->vma
4098 + htab->sgot->output_offset + off);
4099
4100 bfd_put_32 (output_bfd, 0,
4101 htab->sgot->contents + off);
4102 bfd_put_32 (output_bfd, 0,
4103 htab->sgot->contents + off + 4);
4104 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
947216bf
AM		 4105 loc = htab->srelgot->contents;
4106 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
13ae64f3
JJ		 4107 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4108 htab->tls_ldm_got.offset |= 1;
4109 }
8c37241b
JJ		 4110 relocation = htab->sgot->output_section->vma
4111 + htab->sgot->output_offset + off
4112 - htab->sgotplt->output_section->vma
4113 - htab->sgotplt->output_offset;
b34976b6 4114 unresolved_reloc = FALSE;
13ae64f3
JJ		 4115 break;
4116
4117 case R_386_TLS_LDO_32:
a45bb67d 4118 if (info->shared || (input_section->flags & SEC_CODE) == 0)
eb4ff4d6 4119 relocation -= elf_i386_dtpoff_base (info);
13ae64f3
JJ		 4120 else
4121 /* When converting LDO to LE, we must negate. */
eb4ff4d6 4122 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 4123 break;
4124
4125 case R_386_TLS_LE_32:
13ae64f3 4126 case R_386_TLS_LE:
37e55690
JJ		 4127 if (info->shared)
4128 {
947216bf 4129 Elf_Internal_Rela outrel;
37e55690 4130 asection *sreloc;
947216bf 4131 bfd_byte *loc;
37e55690
JJ		 4132 int indx;
4133
4134 outrel.r_offset = rel->r_offset
4135 + input_section->output_section->vma
4136 + input_section->output_offset;
4137 if (h != NULL && h->dynindx != -1)
4138 indx = h->dynindx;
4139 else
4140 indx = 0;
4141 if (r_type == R_386_TLS_LE_32)
4142 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4143 else
4144 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4145 sreloc = elf_section_data (input_section)->sreloc;
4146 if (sreloc == NULL)
4147 abort ();
947216bf
AM		 4148 loc = sreloc->contents;
4149 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
37e55690
JJ		 4150 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4151 if (indx)
4152 continue;
4153 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 4154 relocation = elf_i386_dtpoff_base (info) - relocation;
37e55690 4155 else
eb4ff4d6 4156 relocation -= elf_i386_dtpoff_base (info);
37e55690
JJ		 4157 }
4158 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 4159 relocation = elf_i386_tpoff (info, relocation);
37e55690 4160 else
eb4ff4d6 4161 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 4162 break;
4163
252b5132
RH		 4164 default:
4165 break;
4166 }
4167
239e1f3a
AM		 4168 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4169 because such sections are not SEC_ALLOC and thus ld.so will
4170 not process them. */
8c694914 4171 if (unresolved_reloc
239e1f3a 4172 && !((input_section->flags & SEC_DEBUGGING) != 0
f5385ebf 4173 && h->def_dynamic))
6a30718d
JJ		 4174 {
4175 (*_bfd_error_handler)
843fe662 4176 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
d003868e
AM		 4177 input_bfd,
4178 input_section,
6a30718d 4179 (long) rel->r_offset,
843fe662 4180 howto->name,
6a30718d 4181 h->root.root.string);
b34976b6 4182 return FALSE;
6a30718d 4183 }
83be169b 4184
cbe950e9 4185do_relocation:
252b5132
RH		 4186 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4187 contents, rel->r_offset,
55fd94b0 4188 relocation, 0);
252b5132 4189
cf5c0c5b 4190 if (r != bfd_reloc_ok)
252b5132 4191 {
cf5c0c5b 4192 const char *name;
ffb2e45b 4193
cf5c0c5b
AM		 4194 if (h != NULL)
4195 name = h->root.root.string;
4196 else
4197 {
4198 name = bfd_elf_string_from_elf_section (input_bfd,
4199 symtab_hdr->sh_link,
4200 sym->st_name);
4201 if (name == NULL)
b34976b6 4202 return FALSE;
cf5c0c5b
AM		 4203 if (*name == '\0')
4204 name = bfd_section_name (input_bfd, sec);
4205 }
ffb2e45b 4206
cf5c0c5b
AM		 4207 if (r == bfd_reloc_overflow)
4208 {
cf5c0c5b 4209 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 4210 (info, (h ? &h->root : NULL), name, howto->name,
4211 (bfd_vma) 0, input_bfd, input_section,
4212 rel->r_offset)))
b34976b6 4213 return FALSE;
cf5c0c5b
AM		 4214 }
4215 else
4216 {
4217 (*_bfd_error_handler)
d003868e
AM		 4218 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4219 input_bfd, input_section,
cf5c0c5b 4220 (long) rel->r_offset, name, (int) r);
b34976b6 4221 return FALSE;
cf5c0c5b 4222 }
252b5132
RH		 4223 }
4224 }
4225
b34976b6 4226 return TRUE;
252b5132
RH		 4227}
4228
4229/* Finish up dynamic symbol handling. We set the contents of various
4230 dynamic sections here. */
4231
b34976b6 4232static bfd_boolean
55fd94b0
AM		 4233elf_i386_finish_dynamic_symbol (bfd *output_bfd,
4234 struct bfd_link_info *info,
4235 struct elf_link_hash_entry *h,
4236 Elf_Internal_Sym *sym)
252b5132 4237{
6725bdbf 4238 struct elf_i386_link_hash_table *htab;
252b5132 4239
6725bdbf 4240 htab = elf_i386_hash_table (info);
252b5132
RH		 4241
4242 if (h->plt.offset != (bfd_vma) -1)
4243 {
252b5132
RH		 4244 bfd_vma plt_index;
4245 bfd_vma got_offset;
947216bf
AM		 4246 Elf_Internal_Rela rel;
4247 bfd_byte *loc;
cbe950e9
L		 4248 asection *plt, *gotplt, *relplt;
4249
4250 /* When building a static executable, use .iplt, .igot.plt and
4251 .rel.iplt sections for STT_GNU_IFUNC symbols. */
710ab287 4252 if (htab->splt != NULL)
cbe950e9
L		 4253 {
4254 plt = htab->splt;
4255 gotplt = htab->sgotplt;
4256 relplt = htab->srelplt;
4257 }
4258 else
4259 {
4260 plt = htab->iplt;
4261 gotplt = htab->igotplt;
4262 relplt = htab->irelplt;
4263 }
252b5132
RH		 4264
4265 /* This symbol has an entry in the procedure linkage table. Set
4266 it up. */
4267
cbe950e9
L		 4268 if ((h->dynindx == -1
4269 && !((h->forced_local || info->executable)
4270 && h->def_regular
4271 && h->type == STT_GNU_IFUNC))
4272 || plt == NULL
4273 || gotplt == NULL
4274 || relplt == NULL)
ffb2e45b 4275 abort ();
252b5132
RH		 4276
4277 /* Get the index in the procedure linkage table which
4278 corresponds to this symbol. This is the index of this symbol
4279 in all the symbols for which we are making plt entries. The
cbe950e9 4280 first entry in the procedure linkage table is reserved.
252b5132 4281
cbe950e9 4282 Get the offset into the .got table of the entry that
252b5132 4283 corresponds to this function. Each .got entry is 4 bytes.
cbe950e9
L		 4284 The first three are reserved.
4285
4286 For static executables, we don't reserve anything. */
4287
4288 if (plt == htab->splt)
4289 {
4290 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
4291 got_offset = (plt_index + 3) * 4;
4292 }
4293 else
4294 {
4295 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
4296 got_offset = plt_index * 4;
4297 }
252b5132
RH		 4298
4299 /* Fill in the entry in the procedure linkage table. */
4300 if (! info->shared)
4301 {
cbe950e9 4302 memcpy (plt->contents + h->plt.offset, elf_i386_plt_entry,
252b5132
RH		 4303 PLT_ENTRY_SIZE);
4304 bfd_put_32 (output_bfd,
cbe950e9
L		 4305 (gotplt->output_section->vma
4306 + gotplt->output_offset
252b5132 4307 + got_offset),
cbe950e9 4308 plt->contents + h->plt.offset + 2);
eac338cf
PB		 4309
4310 if (htab->is_vxworks)
4311 {
4312 int s, k, reloc_index;
4313
4314 /* Create the R_386_32 relocation referencing the GOT
4315 for this PLT entry. */
4316
4317 /* S: Current slot number (zero-based). */
4318 s = (h->plt.offset - PLT_ENTRY_SIZE) / PLT_ENTRY_SIZE;
4319 /* K: Number of relocations for PLTResolve. */
4320 if (info->shared)
4321 k = PLTRESOLVE_RELOCS_SHLIB;
4322 else
4323 k = PLTRESOLVE_RELOCS;
4324 /* Skip the PLTresolve relocations, and the relocations for
4325 the other PLT slots. */
4326 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
4327 loc = (htab->srelplt2->contents + reloc_index
4328 * sizeof (Elf32_External_Rel));
4329
4330 rel.r_offset = (htab->splt->output_section->vma
4331 + htab->splt->output_offset
4332 + h->plt.offset + 2),
7325306f 4333 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 4334 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4335
4336 /* Create the R_386_32 relocation referencing the beginning of
4337 the PLT for this GOT entry. */
4338 rel.r_offset = (htab->sgotplt->output_section->vma
4339 + htab->sgotplt->output_offset
4340 + got_offset);
7325306f 4341 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf
PB		 4342 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4343 loc + sizeof (Elf32_External_Rel));
4344 }
252b5132
RH		 4345 }
4346 else
4347 {
cbe950e9 4348 memcpy (plt->contents + h->plt.offset, elf_i386_pic_plt_entry,
252b5132
RH		 4349 PLT_ENTRY_SIZE);
4350 bfd_put_32 (output_bfd, got_offset,
cbe950e9 4351 plt->contents + h->plt.offset + 2);
252b5132
RH		 4352 }
4353
cbe950e9
L		 4354 /* Don't fill PLT entry for static executables. */
4355 if (plt == htab->splt)
4356 {
4357 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
4358 plt->contents + h->plt.offset + 7);
4359 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
4360 plt->contents + h->plt.offset + 12);
4361 }
252b5132
RH		 4362
4363 /* Fill in the entry in the global offset table. */
4364 bfd_put_32 (output_bfd,
cbe950e9
L		 4365 (plt->output_section->vma
4366 + plt->output_offset
252b5132
RH		 4367 + h->plt.offset
4368 + 6),
cbe950e9 4369 gotplt->contents + got_offset);
252b5132
RH		 4370
4371 /* Fill in the entry in the .rel.plt section. */
cbe950e9
L		 4372 rel.r_offset = (gotplt->output_section->vma
4373 + gotplt->output_offset
252b5132 4374 + got_offset);
cbe950e9
L		 4375 if (h->dynindx == -1
4376 || ((info->executable
4377 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4378 && h->def_regular
4379 && h->type == STT_GNU_IFUNC))
4380 {
4381 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4382 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
4383 in the .got.plt section. */
4384 bfd_put_32 (output_bfd,
4385 (h->root.u.def.value
4386 + h->root.u.def.section->output_section->vma
4387 + h->root.u.def.section->output_offset),
4388 gotplt->contents + got_offset);
4389 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
4390 }
4391 else
4392 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
4393 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
0ac8d2ca 4394 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132 4395
f5385ebf 4396 if (!h->def_regular)
252b5132
RH		 4397 {
4398 /* Mark the symbol as undefined, rather than as defined in
c6585bbb
JJ		 4399 the .plt section. Leave the value if there were any
4400 relocations where pointer equality matters (this is a clue
51b64d56
AM		 4401 for the dynamic linker, to make function pointer
4402 comparisons work between an application and shared
c6585bbb
JJ		 4403 library), otherwise set it to zero. If a function is only
4404 called from a binary, there is no need to slow down
4405 shared libraries because of that. */
252b5132 4406 sym->st_shndx = SHN_UNDEF;
f5385ebf 4407 if (!h->pointer_equality_needed)
c6585bbb 4408 sym->st_value = 0;
252b5132
RH		 4409 }
4410 }
4411
13ae64f3 4412 if (h->got.offset != (bfd_vma) -1
67a4f2b7 4413 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
37e55690 4414 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
252b5132 4415 {
947216bf
AM		 4416 Elf_Internal_Rela rel;
4417 bfd_byte *loc;
252b5132
RH		 4418
4419 /* This symbol has an entry in the global offset table. Set it
4420 up. */
4421
ffb2e45b
AM		 4422 if (htab->sgot == NULL || htab->srelgot == NULL)
4423 abort ();
252b5132 4424
6725bdbf
AM		 4425 rel.r_offset = (htab->sgot->output_section->vma
4426 + htab->sgot->output_offset
dc810e39 4427 + (h->got.offset & ~(bfd_vma) 1));
252b5132 4428
dd5724d5
AM		 4429 /* If this is a static link, or it is a -Bsymbolic link and the
4430 symbol is defined locally or was forced to be local because
4431 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 4432 The entry in the global offset table will already have been
4433 initialized in the relocate_section function. */
710ab287 4434 if (h->def_regular
0018b0a3
L		 4435 && h->type == STT_GNU_IFUNC)
4436 {
710ab287
L		 4437 if (info->shared)
4438 {
4439 /* Generate R_386_GLOB_DAT. */
4440 goto do_glob_dat;
4441 }
4442 else
4443 {
4444 if (!h->pointer_equality_needed)
4445 abort ();
4446
4447 /* For non-shared object, we can't use .got.plt, which
4448 contains the real function addres if we need pointer
4449 equality. We load the GOT entry with the PLT entry. */
4450 asection *plt = htab->splt ? htab->splt : htab->iplt;
4451 bfd_put_32 (output_bfd,
4452 (plt->output_section->vma
4453 + plt->output_offset + h->plt.offset),
4454 htab->sgot->contents + h->got.offset);
4455 return TRUE;
4456 }
0018b0a3
L		 4457 }
4458 else if (info->shared
4459 && SYMBOL_REFERENCES_LOCAL (info, h))
dd5724d5 4460 {
6725bdbf 4461 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 4462 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4463 }
252b5132
RH		 4464 else
4465 {
dd5724d5 4466 BFD_ASSERT((h->got.offset & 1) == 0);
710ab287 4467do_glob_dat:
6725bdbf
AM		 4468 bfd_put_32 (output_bfd, (bfd_vma) 0,
4469 htab->sgot->contents + h->got.offset);
252b5132
RH		 4470 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
4471 }
4472
947216bf
AM		 4473 loc = htab->srelgot->contents;
4474 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 4475 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 4476 }
4477
f5385ebf 4478 if (h->needs_copy)
252b5132 4479 {
947216bf
AM		 4480 Elf_Internal_Rela rel;
4481 bfd_byte *loc;
252b5132
RH		 4482
4483 /* This symbol needs a copy reloc. Set it up. */
4484
ffb2e45b
AM		 4485 if (h->dynindx == -1
4486 || (h->root.type != bfd_link_hash_defined
4487 && h->root.type != bfd_link_hash_defweak)
4488 || htab->srelbss == NULL)
4489 abort ();
252b5132
RH		 4490
4491 rel.r_offset = (h->root.u.def.value
4492 + h->root.u.def.section->output_section->vma
4493 + h->root.u.def.section->output_offset);
4494 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
947216bf
AM		 4495 loc = htab->srelbss->contents;
4496 loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
0ac8d2ca 4497 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
252b5132
RH		 4498 }
4499
c25bc9fc
L		 4500 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may
4501 be NULL for local symbols.
4502
eac338cf
PB		 4503 On VxWorks, the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it
4504 is relative to the ".got" section. */
c25bc9fc
L		 4505 if (sym != NULL
4506 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4507 || (!htab->is_vxworks && h == htab->elf.hgot)))
252b5132
RH		 4508 sym->st_shndx = SHN_ABS;
4509
b34976b6 4510 return TRUE;
252b5132
RH		 4511}
4512
c25bc9fc
L		 4513/* Finish up local dynamic symbol handling. We set the contents of
4514 various dynamic sections here. */
4515
4516static bfd_boolean
4517elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
4518{
4519 struct elf_link_hash_entry *h
4520 = (struct elf_link_hash_entry *) *slot;
4521 struct bfd_link_info *info
4522 = (struct bfd_link_info *) inf;
4523
4524 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
4525 h, NULL);
4526}
4527
38701953
AM		 4528/* Used to decide how to sort relocs in an optimal manner for the
4529 dynamic linker, before writing them out. */
4530
4531static enum elf_reloc_type_class
55fd94b0 4532elf_i386_reloc_type_class (const Elf_Internal_Rela *rela)
38701953 4533{
55fd94b0 4534 switch (ELF32_R_TYPE (rela->r_info))
38701953
AM		 4535 {
4536 case R_386_RELATIVE:
4537 return reloc_class_relative;
4538 case R_386_JUMP_SLOT:
4539 return reloc_class_plt;
4540 case R_386_COPY:
4541 return reloc_class_copy;
4542 default:
4543 return reloc_class_normal;
4544 }
4545}
4546
252b5132
RH		 4547/* Finish up the dynamic sections. */
4548
b34976b6 4549static bfd_boolean
55fd94b0
AM		 4550elf_i386_finish_dynamic_sections (bfd *output_bfd,
4551 struct bfd_link_info *info)
252b5132 4552{
6725bdbf 4553 struct elf_i386_link_hash_table *htab;
252b5132 4554 bfd *dynobj;
252b5132
RH		 4555 asection *sdyn;
4556
6725bdbf 4557 htab = elf_i386_hash_table (info);
ebe50bae 4558 dynobj = htab->elf.dynobj;
252b5132
RH		 4559 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4560
ebe50bae 4561 if (htab->elf.dynamic_sections_created)
252b5132 4562 {
252b5132
RH		 4563 Elf32_External_Dyn *dyncon, *dynconend;
4564
ffb2e45b
AM		 4565 if (sdyn == NULL || htab->sgot == NULL)
4566 abort ();
252b5132
RH		 4567
4568 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 4569 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
252b5132
RH		 4570 for (; dyncon < dynconend; dyncon++)
4571 {
4572 Elf_Internal_Dyn dyn;
51b64d56 4573 asection *s;
252b5132
RH		 4574
4575 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4576
4577 switch (dyn.d_tag)
4578 {
4579 default:
7a2b07ff
NS		 4580 if (htab->is_vxworks
4581 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
4582 break;
0ac8d2ca 4583 continue;
252b5132
RH		 4584
4585 case DT_PLTGOT:
8c37241b
JJ		 4586 s = htab->sgotplt;
4587 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
6725bdbf
AM		 4588 break;
4589
252b5132 4590 case DT_JMPREL:
6348e046
AM		 4591 s = htab->srelplt;
4592 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
252b5132
RH		 4593 break;
4594
4595 case DT_PLTRELSZ:
6348e046 4596 s = htab->srelplt;
eea6121a 4597 dyn.d_un.d_val = s->size;
252b5132
RH		 4598 break;
4599
4600 case DT_RELSZ:
4601 /* My reading of the SVR4 ABI indicates that the
4602 procedure linkage table relocs (DT_JMPREL) should be
4603 included in the overall relocs (DT_REL). This is
4604 what Solaris does. However, UnixWare can not handle
4605 that case. Therefore, we override the DT_RELSZ entry
6348e046
AM		 4606 here to make it not include the JMPREL relocs. */
4607 s = htab->srelplt;
4608 if (s == NULL)
4609 continue;
eea6121a 4610 dyn.d_un.d_val -= s->size;
6348e046
AM		 4611 break;
4612
4613 case DT_REL:
4614 /* We may not be using the standard ELF linker script.
4615 If .rel.plt is the first .rel section, we adjust
4616 DT_REL to not include it. */
4617 s = htab->srelplt;
4618 if (s == NULL)
4619 continue;
4620 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
4621 continue;
eea6121a 4622 dyn.d_un.d_ptr += s->size;
252b5132
RH		 4623 break;
4624 }
0ac8d2ca
AM		 4625
4626 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 4627 }
4628
4629 /* Fill in the first entry in the procedure linkage table. */
eea6121a 4630 if (htab->splt && htab->splt->size > 0)
252b5132
RH		 4631 {
4632 if (info->shared)
eac338cf
PB		 4633 {
4634 memcpy (htab->splt->contents, elf_i386_pic_plt0_entry,
4635 sizeof (elf_i386_pic_plt0_entry));
4636 memset (htab->splt->contents + sizeof (elf_i386_pic_plt0_entry),
4637 htab->plt0_pad_byte,
4638 PLT_ENTRY_SIZE - sizeof (elf_i386_pic_plt0_entry));
4639 }
252b5132
RH		 4640 else
4641 {
eac338cf
PB		 4642 memcpy (htab->splt->contents, elf_i386_plt0_entry,
4643 sizeof(elf_i386_plt0_entry));
4644 memset (htab->splt->contents + sizeof (elf_i386_plt0_entry),
4645 htab->plt0_pad_byte,
4646 PLT_ENTRY_SIZE - sizeof (elf_i386_plt0_entry));
252b5132 4647 bfd_put_32 (output_bfd,
6725bdbf
AM		 4648 (htab->sgotplt->output_section->vma
4649 + htab->sgotplt->output_offset
4650 + 4),
4651 htab->splt->contents + 2);
252b5132 4652 bfd_put_32 (output_bfd,
6725bdbf
AM		 4653 (htab->sgotplt->output_section->vma
4654 + htab->sgotplt->output_offset
4655 + 8),
4656 htab->splt->contents + 8);
eac338cf
PB		 4657
4658 if (htab->is_vxworks)
4659 {
4660 Elf_Internal_Rela rel;
7325306f 4661
eac338cf
PB		 4662 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
4663 On IA32 we use REL relocations so the addend goes in
4664 the PLT directly. */
4665 rel.r_offset = (htab->splt->output_section->vma
4666 + htab->splt->output_offset
4667 + 2);
7325306f 4668 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 4669 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4670 htab->srelplt2->contents);
4671 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
4672 rel.r_offset = (htab->splt->output_section->vma
4673 + htab->splt->output_offset
4674 + 8);
7325306f 4675 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 4676 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4677 htab->srelplt2->contents +
4678 sizeof (Elf32_External_Rel));
4679 }
252b5132
RH		 4680 }
4681
4682 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4683 really seem like the right value. */
6725bdbf
AM		 4684 elf_section_data (htab->splt->output_section)
4685 ->this_hdr.sh_entsize = 4;
eac338cf
PB		 4686
4687 /* Correct the .rel.plt.unloaded relocations. */
4688 if (htab->is_vxworks && !info->shared)
4689 {
4690 int num_plts = (htab->splt->size / PLT_ENTRY_SIZE) - 1;
4c9b0de6 4691 unsigned char *p;
eac338cf
PB		 4692
4693 p = htab->srelplt2->contents;
4694 if (info->shared)
4695 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
4696 else
4697 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
4698
4699 for (; num_plts; num_plts--)
4700 {
4701 Elf_Internal_Rela rel;
4702 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 4703 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 4704 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4705 p += sizeof (Elf32_External_Rel);
4706
4707 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 4708 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf
PB		 4709 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
4710 p += sizeof (Elf32_External_Rel);
4711 }
4712 }
252b5132
RH		 4713 }
4714 }
4715
12d0ee4a 4716 if (htab->sgotplt)
252b5132 4717 {
12d0ee4a 4718 /* Fill in the first three entries in the global offset table. */
eea6121a 4719 if (htab->sgotplt->size > 0)
12d0ee4a
AM		 4720 {
4721 bfd_put_32 (output_bfd,
55fd94b0 4722 (sdyn == NULL ? 0
12d0ee4a
AM		 4723 : sdyn->output_section->vma + sdyn->output_offset),
4724 htab->sgotplt->contents);
55fd94b0
AM		 4725 bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 4);
4726 bfd_put_32 (output_bfd, 0, htab->sgotplt->contents + 8);
12d0ee4a 4727 }
252b5132 4728
12d0ee4a
AM		 4729 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
4730 }
8c37241b 4731
eea6121a 4732 if (htab->sgot && htab->sgot->size > 0)
8c37241b
JJ		 4733 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
4734
c25bc9fc
L		 4735 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4736 htab_traverse (htab->loc_hash_table,
4737 elf_i386_finish_local_dynamic_symbol,
4738 info);
4739
b34976b6 4740 return TRUE;
252b5132
RH		 4741}
4742
4c45e5c9
JJ		 4743/* Return address for Ith PLT stub in section PLT, for relocation REL
4744 or (bfd_vma) -1 if it should not be included. */
4745
4746static bfd_vma
4747elf_i386_plt_sym_val (bfd_vma i, const asection *plt,
4748 const arelent *rel ATTRIBUTE_UNUSED)
4749{
4750 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4751}
4752
fdc90cb4
JJ		 4753/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4754
4755static bfd_boolean
4756elf_i386_hash_symbol (struct elf_link_hash_entry *h)
4757{
4758 if (h->plt.offset != (bfd_vma) -1
4759 && !h->def_regular
4760 && !h->pointer_equality_needed)
4761 return FALSE;
4762
4763 return _bfd_elf_hash_symbol (h);
4764}
4c45e5c9 4765
d8045f23
NC		 4766/* Hook called by the linker routine which adds symbols from an object
4767 file. */
4768
4769static bfd_boolean
4770elf_i386_add_symbol_hook (bfd * abfd ATTRIBUTE_UNUSED,
4771 struct bfd_link_info * info ATTRIBUTE_UNUSED,
4772 Elf_Internal_Sym * sym,
4773 const char ** namep ATTRIBUTE_UNUSED,
4774 flagword * flagsp ATTRIBUTE_UNUSED,
4775 asection ** secp ATTRIBUTE_UNUSED,
4776 bfd_vma * valp ATTRIBUTE_UNUSED)
4777{
4778 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
4779 elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4780
4781 return TRUE;
4782}
4783
252b5132
RH		 4784#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
4785#define TARGET_LITTLE_NAME "elf32-i386"
4786#define ELF_ARCH bfd_arch_i386
4787#define ELF_MACHINE_CODE EM_386
4788#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 4789
4790#define elf_backend_can_gc_sections 1
51b64d56 4791#define elf_backend_can_refcount 1
252b5132
RH		 4792#define elf_backend_want_got_plt 1
4793#define elf_backend_plt_readonly 1
4794#define elf_backend_want_plt_sym 0
4795#define elf_backend_got_header_size 12
252b5132 4796
8c29f035
AM		 4797/* Support RELA for objdump of prelink objects. */
4798#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 4799#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
4800
13ae64f3 4801#define bfd_elf32_mkobject elf_i386_mkobject
13ae64f3 4802
dd5724d5
AM		 4803#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
4804#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
c25bc9fc 4805#define bfd_elf32_bfd_link_hash_table_free elf_i386_link_hash_table_free
dd5724d5 4806#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
13285a1b 4807#define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
dd5724d5
AM		 4808
4809#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
13285a1b 4810#define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
dd5724d5 4811#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 4812#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 4813#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 4814#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 4815#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
4816#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
4817#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
4818#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
c5fccbec
DJ		 4819#define elf_backend_grok_prstatus elf_i386_grok_prstatus
4820#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 4821#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 4822#define elf_backend_relocate_section elf_i386_relocate_section
4823#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
67a4f2b7 4824#define elf_backend_always_size_sections elf_i386_always_size_sections
74541ad4
AM		 4825#define elf_backend_omit_section_dynsym \
4826 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4c45e5c9 4827#define elf_backend_plt_sym_val elf_i386_plt_sym_val
fdc90cb4 4828#define elf_backend_hash_symbol elf_i386_hash_symbol
d8045f23
NC		 4829#define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
4830#undef elf_backend_post_process_headers
4831#define elf_backend_post_process_headers _bfd_elf_set_osabi
dd5724d5 4832
252b5132 4833#include "elf32-target.h"
2bc3c89a
AM		 4834
4835/* FreeBSD support. */
4836
4837#undef TARGET_LITTLE_SYM
4838#define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
4839#undef TARGET_LITTLE_NAME
4840#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
d1036acb
L		 4841#undef ELF_OSABI
4842#define ELF_OSABI ELFOSABI_FREEBSD
2bc3c89a
AM		 4843
4844/* The kernel recognizes executables as valid only if they carry a
4845 "FreeBSD" label in the ELF header. So we put this label on all
4846 executables and (for simplicity) also all other object files. */
4847
2bc3c89a 4848static void
d8045f23 4849elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
2bc3c89a 4850{
d8045f23 4851 _bfd_elf_set_osabi (abfd, info);
2bc3c89a 4852
2bc3c89a
AM		 4853#ifdef OLD_FREEBSD_ABI_LABEL
4854 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
4855 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
caf47ea6 4856#endif
2bc3c89a
AM		 4857}
4858
4859#undef elf_backend_post_process_headers
d8045f23 4860#define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
571fe01f
NC		 4861#undef elf32_bed
4862#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a 4863
d8045f23
NC		 4864#undef elf_backend_add_symbol_hook
4865
2bc3c89a 4866#include "elf32-target.h"
eac338cf
PB		 4867
4868/* VxWorks support. */
4869
4870#undef TARGET_LITTLE_SYM
4871#define TARGET_LITTLE_SYM bfd_elf32_i386_vxworks_vec
4872#undef TARGET_LITTLE_NAME
4873#define TARGET_LITTLE_NAME "elf32-i386-vxworks"
d1036acb 4874#undef ELF_OSABI
eac338cf
PB		 4875
4876/* Like elf_i386_link_hash_table_create but with tweaks for VxWorks. */
4877
4878static struct bfd_link_hash_table *
4879elf_i386_vxworks_link_hash_table_create (bfd *abfd)
4880{
4881 struct bfd_link_hash_table *ret;
4882 struct elf_i386_link_hash_table *htab;
4883
4884 ret = elf_i386_link_hash_table_create (abfd);
4885 if (ret)
4886 {
4887 htab = (struct elf_i386_link_hash_table *) ret;
4888 htab->is_vxworks = 1;
4889 htab->plt0_pad_byte = 0x90;
4890 }
4891
4892 return ret;
4893}
4894
4895
13285a1b
AM		 4896#undef elf_backend_relocs_compatible
4897#undef elf_backend_post_process_headers
eac338cf
PB		 4898#undef bfd_elf32_bfd_link_hash_table_create
4899#define bfd_elf32_bfd_link_hash_table_create \
4900 elf_i386_vxworks_link_hash_table_create
4901#undef elf_backend_add_symbol_hook
4902#define elf_backend_add_symbol_hook \
4903 elf_vxworks_add_symbol_hook
4904#undef elf_backend_link_output_symbol_hook
4905#define elf_backend_link_output_symbol_hook \
9c72ff84 4906 elf_vxworks_link_output_symbol_hook
eac338cf
PB		 4907#undef elf_backend_emit_relocs
4908#define elf_backend_emit_relocs elf_vxworks_emit_relocs
4909#undef elf_backend_final_write_processing
4910#define elf_backend_final_write_processing \
4911 elf_vxworks_final_write_processing
4912
4913/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
4914 define it. */
4915#undef elf_backend_want_plt_sym
4916#define elf_backend_want_plt_sym 1
4917
4918#undef elf32_bed
4919#define elf32_bed elf32_i386_vxworks_bed
4920
4921#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.784736 seconds and 4 git commands to generate.