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