projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
elf_backend_dtrel_excludes_plt
[deliverable/binutils-gdb.git] / bfd / elf32-i386.c
CommitLineData
252b5132 1/* Intel 80386/80486-specific support for 32-bit ELF
6f2750fe 2 Copyright (C) 1993-2016 Free Software Foundation, Inc.
252b5132 3
571fe01f 4 This file is part of BFD, the Binary File Descriptor library.
252b5132 5
571fe01f
NC		 6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
cd123cb7 8 the Free Software Foundation; either version 3 of the License, or
571fe01f 9 (at your option) any later version.
252b5132 10
571fe01f
NC		 11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
252b5132 15
571fe01f
NC		 16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
cd123cb7
NC		 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
252b5132 20
252b5132 21#include "sysdep.h"
3db64b00 22#include "bfd.h"
252b5132
RH		 23#include "bfdlink.h"
24#include "libbfd.h"
25#include "elf-bfd.h"
5a68afcf 26#include "elf-nacl.h"
eac338cf 27#include "elf-vxworks.h"
142411ca 28#include "bfd_stdint.h"
c25bc9fc
L		 29#include "objalloc.h"
30#include "hashtab.h"
e41b3a13 31#include "dwarf2.h"
02a86693 32#include "opcode/i386.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{
6346d5ca 41 HOWTO(R_386_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
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),
1788fc08
L		 135 HOWTO(R_386_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
136 bfd_elf_generic_reloc, "R_386_SIZE32",
137 TRUE, 0xffffffff, 0xffffffff, FALSE),
67a4f2b7
AO		 138 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
139 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
140 TRUE, 0xffffffff, 0xffffffff, FALSE),
141 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
142 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
143 FALSE, 0, 0, FALSE),
144 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
145 bfd_elf_generic_reloc, "R_386_TLS_DESC",
146 TRUE, 0xffffffff, 0xffffffff, FALSE),
cbe950e9
L		 147 HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
148 bfd_elf_generic_reloc, "R_386_IRELATIVE",
149 TRUE, 0xffffffff, 0xffffffff, FALSE),
02a86693
L		 150 HOWTO(R_386_GOT32X, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
151 bfd_elf_generic_reloc, "R_386_GOT32X",
152 TRUE, 0xffffffff, 0xffffffff, FALSE),
13ae64f3
JJ		 153
154 /* Another gap. */
02a86693 155#define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
c74be520 156#define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
252b5132
RH		 157
158/* GNU extension to record C++ vtable hierarchy. */
252b5132
RH		 159 HOWTO (R_386_GNU_VTINHERIT, /* type */
160 0, /* rightshift */
161 2, /* size (0 = byte, 1 = short, 2 = long) */
162 0, /* bitsize */
b34976b6 163 FALSE, /* pc_relative */
252b5132
RH		 164 0, /* bitpos */
165 complain_overflow_dont, /* complain_on_overflow */
166 NULL, /* special_function */
167 "R_386_GNU_VTINHERIT", /* name */
b34976b6 168 FALSE, /* partial_inplace */
252b5132
RH		 169 0, /* src_mask */
170 0, /* dst_mask */
b34976b6 171 FALSE), /* pcrel_offset */
252b5132
RH		 172
173/* GNU extension to record C++ vtable member usage. */
252b5132
RH		 174 HOWTO (R_386_GNU_VTENTRY, /* type */
175 0, /* rightshift */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
177 0, /* bitsize */
b34976b6 178 FALSE, /* pc_relative */
252b5132
RH		 179 0, /* bitpos */
180 complain_overflow_dont, /* complain_on_overflow */
181 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
182 "R_386_GNU_VTENTRY", /* name */
b34976b6 183 FALSE, /* partial_inplace */
252b5132
RH		 184 0, /* src_mask */
185 0, /* dst_mask */
b34976b6 186 FALSE) /* pcrel_offset */
dc47f327 187
55fd94b0 188#define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
dc47f327
AM		 189
190};
191
252b5132 192#ifdef DEBUG_GEN_RELOC
55fd94b0
AM		 193#define TRACE(str) \
194 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
252b5132
RH		 195#else
196#define TRACE(str)
197#endif
198
199static reloc_howto_type *
55fd94b0
AM		 200elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
201 bfd_reloc_code_real_type code)
252b5132
RH		 202{
203 switch (code)
204 {
205 case BFD_RELOC_NONE:
206 TRACE ("BFD_RELOC_NONE");
55fd94b0 207 return &elf_howto_table[R_386_NONE];
252b5132
RH		 208
209 case BFD_RELOC_32:
210 TRACE ("BFD_RELOC_32");
55fd94b0 211 return &elf_howto_table[R_386_32];
252b5132
RH		 212
213 case BFD_RELOC_CTOR:
214 TRACE ("BFD_RELOC_CTOR");
55fd94b0 215 return &elf_howto_table[R_386_32];
252b5132
RH		 216
217 case BFD_RELOC_32_PCREL:
218 TRACE ("BFD_RELOC_PC32");
55fd94b0 219 return &elf_howto_table[R_386_PC32];
252b5132
RH		 220
221 case BFD_RELOC_386_GOT32:
222 TRACE ("BFD_RELOC_386_GOT32");
55fd94b0 223 return &elf_howto_table[R_386_GOT32];
252b5132
RH		 224
225 case BFD_RELOC_386_PLT32:
226 TRACE ("BFD_RELOC_386_PLT32");
55fd94b0 227 return &elf_howto_table[R_386_PLT32];
252b5132
RH		 228
229 case BFD_RELOC_386_COPY:
230 TRACE ("BFD_RELOC_386_COPY");
55fd94b0 231 return &elf_howto_table[R_386_COPY];
252b5132
RH		 232
233 case BFD_RELOC_386_GLOB_DAT:
234 TRACE ("BFD_RELOC_386_GLOB_DAT");
55fd94b0 235 return &elf_howto_table[R_386_GLOB_DAT];
252b5132
RH		 236
237 case BFD_RELOC_386_JUMP_SLOT:
238 TRACE ("BFD_RELOC_386_JUMP_SLOT");
55fd94b0 239 return &elf_howto_table[R_386_JUMP_SLOT];
252b5132
RH		 240
241 case BFD_RELOC_386_RELATIVE:
242 TRACE ("BFD_RELOC_386_RELATIVE");
55fd94b0 243 return &elf_howto_table[R_386_RELATIVE];
252b5132
RH		 244
245 case BFD_RELOC_386_GOTOFF:
246 TRACE ("BFD_RELOC_386_GOTOFF");
55fd94b0 247 return &elf_howto_table[R_386_GOTOFF];
252b5132
RH		 248
249 case BFD_RELOC_386_GOTPC:
250 TRACE ("BFD_RELOC_386_GOTPC");
55fd94b0 251 return &elf_howto_table[R_386_GOTPC];
252b5132 252
37e55690
JJ		 253 /* These relocs are a GNU extension. */
254 case BFD_RELOC_386_TLS_TPOFF:
255 TRACE ("BFD_RELOC_386_TLS_TPOFF");
55fd94b0 256 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
37e55690
JJ		 257
258 case BFD_RELOC_386_TLS_IE:
259 TRACE ("BFD_RELOC_386_TLS_IE");
55fd94b0 260 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
37e55690
JJ		 261
262 case BFD_RELOC_386_TLS_GOTIE:
263 TRACE ("BFD_RELOC_386_TLS_GOTIE");
55fd94b0 264 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
37e55690 265
13ae64f3
JJ		 266 case BFD_RELOC_386_TLS_LE:
267 TRACE ("BFD_RELOC_386_TLS_LE");
55fd94b0 268 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
13ae64f3
JJ		 269
270 case BFD_RELOC_386_TLS_GD:
271 TRACE ("BFD_RELOC_386_TLS_GD");
55fd94b0 272 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
13ae64f3
JJ		 273
274 case BFD_RELOC_386_TLS_LDM:
275 TRACE ("BFD_RELOC_386_TLS_LDM");
55fd94b0 276 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
13ae64f3 277
252b5132
RH		 278 case BFD_RELOC_16:
279 TRACE ("BFD_RELOC_16");
55fd94b0 280 return &elf_howto_table[R_386_16 - R_386_ext_offset];
252b5132
RH		 281
282 case BFD_RELOC_16_PCREL:
283 TRACE ("BFD_RELOC_16_PCREL");
55fd94b0 284 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
252b5132
RH		 285
286 case BFD_RELOC_8:
287 TRACE ("BFD_RELOC_8");
55fd94b0 288 return &elf_howto_table[R_386_8 - R_386_ext_offset];
252b5132
RH		 289
290 case BFD_RELOC_8_PCREL:
291 TRACE ("BFD_RELOC_8_PCREL");
55fd94b0 292 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
252b5132 293
13ae64f3
JJ		 294 /* Common with Sun TLS implementation. */
295 case BFD_RELOC_386_TLS_LDO_32:
296 TRACE ("BFD_RELOC_386_TLS_LDO_32");
55fd94b0 297 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
13ae64f3
JJ		 298
299 case BFD_RELOC_386_TLS_IE_32:
300 TRACE ("BFD_RELOC_386_TLS_IE_32");
55fd94b0 301 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
13ae64f3
JJ		 302
303 case BFD_RELOC_386_TLS_LE_32:
304 TRACE ("BFD_RELOC_386_TLS_LE_32");
55fd94b0 305 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
13ae64f3
JJ		 306
307 case BFD_RELOC_386_TLS_DTPMOD32:
308 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
55fd94b0 309 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
13ae64f3
JJ		 310
311 case BFD_RELOC_386_TLS_DTPOFF32:
312 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
55fd94b0 313 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
13ae64f3
JJ		 314
315 case BFD_RELOC_386_TLS_TPOFF32:
316 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
55fd94b0 317 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
13ae64f3 318
1788fc08
L		 319 case BFD_RELOC_SIZE32:
320 TRACE ("BFD_RELOC_SIZE32");
321 return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
322
67a4f2b7
AO		 323 case BFD_RELOC_386_TLS_GOTDESC:
324 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
325 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
326
327 case BFD_RELOC_386_TLS_DESC_CALL:
328 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
329 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
330
331 case BFD_RELOC_386_TLS_DESC:
332 TRACE ("BFD_RELOC_386_TLS_DESC");
333 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
334
cbe950e9
L		 335 case BFD_RELOC_386_IRELATIVE:
336 TRACE ("BFD_RELOC_386_IRELATIVE");
2a750708 337 return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
cbe950e9 338
02a86693
L		 339 case BFD_RELOC_386_GOT32X:
340 TRACE ("BFD_RELOC_386_GOT32X");
341 return &elf_howto_table[R_386_GOT32X - R_386_tls_offset];
342
252b5132
RH		 343 case BFD_RELOC_VTABLE_INHERIT:
344 TRACE ("BFD_RELOC_VTABLE_INHERIT");
55fd94b0 345 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
252b5132
RH		 346
347 case BFD_RELOC_VTABLE_ENTRY:
348 TRACE ("BFD_RELOC_VTABLE_ENTRY");
55fd94b0 349 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
252b5132
RH		 350
351 default:
352 break;
353 }
354
355 TRACE ("Unknown");
356 return 0;
357}
358
157090f7
AM		 359static reloc_howto_type *
360elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
361 const char *r_name)
362{
363 unsigned int i;
364
365 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
366 if (elf_howto_table[i].name != NULL
367 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
368 return &elf_howto_table[i];
369
370 return NULL;
371}
372
142411ca
L		 373static reloc_howto_type *
374elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
252b5132 375{
dc47f327
AM		 376 unsigned int indx;
377
378 if ((indx = r_type) >= R_386_standard
379 && ((indx = r_type - R_386_ext_offset) - R_386_standard
380 >= R_386_ext - R_386_standard)
13ae64f3 381 && ((indx = r_type - R_386_tls_offset) - R_386_ext
c74be520
L		 382 >= R_386_ext2 - R_386_ext)
383 && ((indx = r_type - R_386_vt_offset) - R_386_ext2
384 >= R_386_vt - R_386_ext2))
252b5132 385 {
695344c0 386 /* xgettext:c-format */
4eca0228
AM		 387 _bfd_error_handler (_("%B: invalid relocation type %d"),
388 abfd, (int) r_type);
55fd94b0 389 indx = R_386_NONE;
252b5132 390 }
06614111
NC		 391 /* PR 17512: file: 0f67f69d. */
392 if (elf_howto_table [indx].type != r_type)
393 return NULL;
142411ca
L		 394 return &elf_howto_table[indx];
395}
396
397static void
398elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
399 arelent *cache_ptr,
400 Elf_Internal_Rela *dst)
401{
402 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
403 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
252b5132
RH		 404}
405
406/* Return whether a symbol name implies a local label. The UnixWare
407 2.1 cc generates temporary symbols that start with .X, so we
408 recognize them here. FIXME: do other SVR4 compilers also use .X?.
409 If so, we should move the .X recognition into
410 _bfd_elf_is_local_label_name. */
411
b34976b6 412static bfd_boolean
55fd94b0 413elf_i386_is_local_label_name (bfd *abfd, const char *name)
252b5132
RH		 414{
415 if (name[0] == '.' && name[1] == 'X')
b34976b6 416 return TRUE;
252b5132
RH		 417
418 return _bfd_elf_is_local_label_name (abfd, name);
419}
420\f
38701953 421/* Support for core dump NOTE sections. */
61adc1a4 422
b34976b6 423static bfd_boolean
55fd94b0 424elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
38701953
AM		 425{
426 int offset;
eea6121a 427 size_t size;
38701953 428
61adc1a4 429 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 430 {
61adc1a4
NC		 431 int pr_version = bfd_get_32 (abfd, note->descdata);
432
433 if (pr_version != 1)
434 return FALSE;
435
436 /* pr_cursig */
228e534f 437 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
61adc1a4
NC		 438
439 /* pr_pid */
228e534f 440 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
61adc1a4
NC		 441
442 /* pr_reg */
443 offset = 28;
eea6121a 444 size = bfd_get_32 (abfd, note->descdata + 8);
61adc1a4
NC		 445 }
446 else
447 {
448 switch (note->descsz)
449 {
450 default:
451 return FALSE;
38701953 452
61adc1a4
NC		 453 case 144: /* Linux/i386 */
454 /* pr_cursig */
228e534f 455 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
38701953 456
61adc1a4 457 /* pr_pid */
228e534f 458 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
38701953 459
61adc1a4
NC		 460 /* pr_reg */
461 offset = 72;
eea6121a 462 size = 68;
38701953 463
61adc1a4
NC		 464 break;
465 }
38701953
AM		 466 }
467
468 /* Make a ".reg/999" section. */
469 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 470 size, note->descpos + offset);
38701953
AM		 471}
472
b34976b6 473static bfd_boolean
55fd94b0 474elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
38701953 475{
61adc1a4 476 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
38701953 477 {
61adc1a4
NC		 478 int pr_version = bfd_get_32 (abfd, note->descdata);
479
480 if (pr_version != 1)
b34976b6 481 return FALSE;
38701953 482
228e534f 483 elf_tdata (abfd)->core->program
61adc1a4 484 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
228e534f 485 elf_tdata (abfd)->core->command
61adc1a4
NC		 486 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
487 }
488 else
489 {
490 switch (note->descsz)
491 {
492 default:
493 return FALSE;
494
495 case 124: /* Linux/i386 elf_prpsinfo. */
228e534f 496 elf_tdata (abfd)->core->pid
261b8d08 497 = bfd_get_32 (abfd, note->descdata + 12);
228e534f 498 elf_tdata (abfd)->core->program
61adc1a4 499 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
228e534f 500 elf_tdata (abfd)->core->command
61adc1a4
NC		 501 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
502 }
38701953
AM		 503 }
504
505 /* Note that for some reason, a spurious space is tacked
506 onto the end of the args in some (at least one anyway)
507 implementations, so strip it off if it exists. */
38701953 508 {
228e534f 509 char *command = elf_tdata (abfd)->core->command;
38701953
AM		 510 int n = strlen (command);
511
512 if (0 < n && command[n - 1] == ' ')
513 command[n - 1] = '\0';
514 }
515
b34976b6 516 return TRUE;
38701953
AM		 517}
518\f
519/* Functions for the i386 ELF linker.
520
521 In order to gain some understanding of code in this file without
522 knowing all the intricate details of the linker, note the
523 following:
524
525 Functions named elf_i386_* are called by external routines, other
526 functions are only called locally. elf_i386_* functions appear
527 in this file more or less in the order in which they are called
528 from external routines. eg. elf_i386_check_relocs is called
529 early in the link process, elf_i386_finish_dynamic_sections is
530 one of the last functions. */
531
252b5132
RH		 532
533/* The name of the dynamic interpreter. This is put in the .interp
534 section. */
535
536#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
537
a23b6845
AM		 538/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
539 copying dynamic variables from a shared lib into an app's dynbss
540 section, and instead use a dynamic relocation to point into the
541 shared lib. */
542#define ELIMINATE_COPY_RELOCS 1
543
252b5132
RH		 544/* The size in bytes of an entry in the procedure linkage table. */
545
546#define PLT_ENTRY_SIZE 16
547
548/* The first entry in an absolute procedure linkage table looks like
eac338cf
PB		 549 this. See the SVR4 ABI i386 supplement to see how this works.
550 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
252b5132 551
eac338cf 552static const bfd_byte elf_i386_plt0_entry[12] =
252b5132
RH		 553{
554 0xff, 0x35, /* pushl contents of address */
555 0, 0, 0, 0, /* replaced with address of .got + 4. */
556 0xff, 0x25, /* jmp indirect */
eac338cf 557 0, 0, 0, 0 /* replaced with address of .got + 8. */
252b5132
RH		 558};
559
560/* Subsequent entries in an absolute procedure linkage table look like
561 this. */
562
563static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
564{
565 0xff, 0x25, /* jmp indirect */
566 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
567 0x68, /* pushl immediate */
568 0, 0, 0, 0, /* replaced with offset into relocation table. */
569 0xe9, /* jmp relative */
570 0, 0, 0, 0 /* replaced with offset to start of .plt. */
571};
572
eac338cf
PB		 573/* The first entry in a PIC procedure linkage table look like this.
574 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
252b5132 575
eac338cf 576static const bfd_byte elf_i386_pic_plt0_entry[12] =
252b5132
RH		 577{
578 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
eac338cf 579 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
252b5132
RH		 580};
581
582/* Subsequent entries in a PIC procedure linkage table look like this. */
583
584static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
585{
586 0xff, 0xa3, /* jmp *offset(%ebx) */
587 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
588 0x68, /* pushl immediate */
589 0, 0, 0, 0, /* replaced with offset into relocation table. */
590 0xe9, /* jmp relative */
591 0, 0, 0, 0 /* replaced with offset to start of .plt. */
592};
593
dd7e64d4
L		 594/* Entries in the GOT procedure linkage table look like this. */
595
596static const bfd_byte elf_i386_got_plt_entry[8] =
597{
598 0xff, 0x25, /* jmp indirect */
599 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
600 0x66, 0x90 /* xchg %ax,%ax */
601};
602
603/* Entries in the PIC GOT procedure linkage table look like this. */
604
605static const bfd_byte elf_i386_pic_got_plt_entry[8] =
606{
607 0xff, 0xa3, /* jmp *offset(%ebx) */
608 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
610};
611
e41b3a13
JJ		 612/* .eh_frame covering the .plt section. */
613
614static const bfd_byte elf_i386_eh_frame_plt[] =
615{
616#define PLT_CIE_LENGTH 20
617#define PLT_FDE_LENGTH 36
618#define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
619#define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
620 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
621 0, 0, 0, 0, /* CIE ID */
622 1, /* CIE version */
623 'z', 'R', 0, /* Augmentation string */
624 1, /* Code alignment factor */
625 0x7c, /* Data alignment factor */
626 8, /* Return address column */
627 1, /* Augmentation size */
628 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
629 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
630 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
631 DW_CFA_nop, DW_CFA_nop,
632
633 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
634 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
635 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
636 0, 0, 0, 0, /* .plt size goes here */
637 0, /* Augmentation size */
638 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
639 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
640 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
641 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
642 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
643 11, /* Block length */
644 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
645 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
646 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
28ede8be 647 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
e41b3a13
JJ		 648 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
649};
650
25e762b9
RM		 651struct elf_i386_plt_layout
652{
653 /* The first entry in an absolute procedure linkage table looks like this. */
654 const bfd_byte *plt0_entry;
655 unsigned int plt0_entry_size;
656
657 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
658 unsigned int plt0_got1_offset;
659 unsigned int plt0_got2_offset;
660
661 /* Later entries in an absolute procedure linkage table look like this. */
662 const bfd_byte *plt_entry;
663 unsigned int plt_entry_size;
664
665 /* Offsets into plt_entry that are to be replaced with... */
666 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
667 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
668 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
669
670 /* Offset into plt_entry where the initial value of the GOT entry points. */
671 unsigned int plt_lazy_offset;
672
673 /* The first entry in a PIC procedure linkage table looks like this. */
674 const bfd_byte *pic_plt0_entry;
675
676 /* Subsequent entries in a PIC procedure linkage table look like this. */
677 const bfd_byte *pic_plt_entry;
678
679 /* .eh_frame covering the .plt section. */
680 const bfd_byte *eh_frame_plt;
681 unsigned int eh_frame_plt_size;
682};
683
684#define GET_PLT_ENTRY_SIZE(abfd) \
685 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
686
687/* These are the standard parameters. */
688static const struct elf_i386_plt_layout elf_i386_plt =
689 {
690 elf_i386_plt0_entry, /* plt0_entry */
691 sizeof (elf_i386_plt0_entry), /* plt0_entry_size */
692 2, /* plt0_got1_offset */
693 8, /* plt0_got2_offset */
694 elf_i386_plt_entry, /* plt_entry */
695 PLT_ENTRY_SIZE, /* plt_entry_size */
696 2, /* plt_got_offset */
697 7, /* plt_reloc_offset */
698 12, /* plt_plt_offset */
699 6, /* plt_lazy_offset */
700 elf_i386_pic_plt0_entry, /* pic_plt0_entry */
701 elf_i386_pic_plt_entry, /* pic_plt_entry */
702 elf_i386_eh_frame_plt, /* eh_frame_plt */
703 sizeof (elf_i386_eh_frame_plt), /* eh_frame_plt_size */
704 };
705\f
706
eac338cf
PB		 707/* On VxWorks, the .rel.plt.unloaded section has absolute relocations
708 for the PLTResolve stub and then for each PLT entry. */
709#define PLTRESOLVE_RELOCS_SHLIB 0
710#define PLTRESOLVE_RELOCS 2
711#define PLT_NON_JUMP_SLOT_RELOCS 2
712
23209a78
RM		 713/* Architecture-specific backend data for i386. */
714
715struct elf_i386_backend_data
716{
25e762b9
RM		 717 /* Parameters describing PLT generation. */
718 const struct elf_i386_plt_layout *plt;
719
23209a78
RM		 720 /* Value used to fill the unused bytes of the first PLT entry. */
721 bfd_byte plt0_pad_byte;
722
723 /* True if the target system is VxWorks. */
724 int is_vxworks;
725};
726
727#define get_elf_i386_backend_data(abfd) \
728 ((const struct elf_i386_backend_data *) \
729 get_elf_backend_data (abfd)->arch_data)
730
731/* These are the standard parameters. */
732static const struct elf_i386_backend_data elf_i386_arch_bed =
733 {
25e762b9 734 &elf_i386_plt, /* plt */
23209a78
RM		 735 0, /* plt0_pad_byte */
736 0, /* is_vxworks */
737 };
738
739#define elf_backend_arch_data &elf_i386_arch_bed
740
aec6b87e
L		 741/* Is a undefined weak symbol which is resolved to 0. Reference to an
742 undefined weak symbol is resolved to 0 when building executable if
743 it isn't dynamic and
744 1. Has non-GOT/non-PLT relocations in text section. Or
745 2. Has no GOT/PLT relocation.
746 */
e62b9723 747#define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
aec6b87e
L		 748 ((EH)->elf.root.type == bfd_link_hash_undefweak \
749 && bfd_link_executable (INFO) \
750 && (elf_i386_hash_table (INFO)->interp == NULL \
e62b9723 751 || !(GOT_RELOC) \
aec6b87e
L		 752 || (EH)->has_non_got_reloc \
753 || !(INFO)->dynamic_undefined_weak))
754
252b5132
RH		 755/* i386 ELF linker hash entry. */
756
757struct elf_i386_link_hash_entry
758{
ebe50bae 759 struct elf_link_hash_entry elf;
252b5132 760
0c715baa 761 /* Track dynamic relocs copied for this symbol. */
e03a8ed8 762 struct elf_dyn_relocs *dyn_relocs;
13ae64f3 763
37e55690
JJ		 764#define GOT_UNKNOWN 0
765#define GOT_NORMAL 1
766#define GOT_TLS_GD 2
767#define GOT_TLS_IE 4
768#define GOT_TLS_IE_POS 5
769#define GOT_TLS_IE_NEG 6
770#define GOT_TLS_IE_BOTH 7
67a4f2b7
AO		 771#define GOT_TLS_GDESC 8
772#define GOT_TLS_GD_BOTH_P(type) \
773 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
774#define GOT_TLS_GD_P(type) \
775 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
776#define GOT_TLS_GDESC_P(type) \
777 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
778#define GOT_TLS_GD_ANY_P(type) \
779 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
37e55690 780 unsigned char tls_type;
67a4f2b7 781
d5597ebc
L		 782 /* Symbol is referenced by R_386_GOTOFF relocation. */
783 unsigned int gotoff_ref : 1;
784
aec6b87e
L		 785 /* Symbol has GOT or PLT relocations. */
786 unsigned int has_got_reloc : 1;
787
788 /* Symbol has non-GOT/non-PLT relocations in text sections. */
789 unsigned int has_non_got_reloc : 1;
790
6eaa7fb5
L		 791 /* 0: symbol isn't ___tls_get_addr.
792 1: symbol is ___tls_get_addr.
793 2: symbol is unknown. */
794 unsigned int tls_get_addr : 2;
795
04ebc307
L		 796 /* Reference count of C/C++ function pointer relocations in read-write
797 section which can be resolved at run-time. */
798 bfd_signed_vma func_pointer_refcount;
799
dd7e64d4
L		 800 /* Information about the GOT PLT entry. Filled when there are both
801 GOT and PLT relocations against the same function. */
802 union gotplt_union plt_got;
803
67a4f2b7
AO		 804 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
805 starting at the end of the jump table. */
806 bfd_vma tlsdesc_got;
13ae64f3
JJ		 807};
808
809#define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
810
811struct elf_i386_obj_tdata
812{
813 struct elf_obj_tdata root;
814
815 /* tls_type for each local got entry. */
816 char *local_got_tls_type;
67a4f2b7
AO		 817
818 /* GOTPLT entries for TLS descriptors. */
819 bfd_vma *local_tlsdesc_gotent;
252b5132
RH		 820};
821
13ae64f3
JJ		 822#define elf_i386_tdata(abfd) \
823 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
824
825#define elf_i386_local_got_tls_type(abfd) \
826 (elf_i386_tdata (abfd)->local_got_tls_type)
827
67a4f2b7
AO		 828#define elf_i386_local_tlsdesc_gotent(abfd) \
829 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
830
0ffa91dd
NC		 831#define is_i386_elf(bfd) \
832 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
833 && elf_tdata (bfd) != NULL \
4dfe6ac6 834 && elf_object_id (bfd) == I386_ELF_DATA)
0ffa91dd 835
b34976b6 836static bfd_boolean
55fd94b0 837elf_i386_mkobject (bfd *abfd)
13ae64f3 838{
0ffa91dd 839 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
4dfe6ac6 840 I386_ELF_DATA);
13ae64f3 841}
cedb70c5 842
252b5132
RH		 843/* i386 ELF linker hash table. */
844
845struct elf_i386_link_hash_table
846{
ebe50bae 847 struct elf_link_hash_table elf;
252b5132 848
6725bdbf 849 /* Short-cuts to get to dynamic linker sections. */
aec6b87e 850 asection *interp;
6725bdbf
AM		 851 asection *sdynbss;
852 asection *srelbss;
e41b3a13 853 asection *plt_eh_frame;
dd7e64d4 854 asection *plt_got;
9635fe29 855
4dfe6ac6
NC		 856 union
857 {
13ae64f3
JJ		 858 bfd_signed_vma refcount;
859 bfd_vma offset;
860 } tls_ldm_got;
861
67a4f2b7
AO		 862 /* The amount of space used by the reserved portion of the sgotplt
863 section, plus whatever space is used by the jump slots. */
864 bfd_vma sgotplt_jump_table_size;
865
87d72d41
AM		 866 /* Small local sym cache. */
867 struct sym_cache sym_cache;
9f03412a
AO		 868
869 /* _TLS_MODULE_BASE_ symbol. */
870 struct bfd_link_hash_entry *tls_module_base;
c25bc9fc
L		 871
872 /* Used by local STT_GNU_IFUNC symbols. */
873 htab_t loc_hash_table;
4dfe6ac6
NC		 874 void * loc_hash_memory;
875
876 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
877 asection *srelplt2;
878
4dfe6ac6
NC		 879 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
880 bfd_vma next_tls_desc_index;
e1f98742
L		 881
882 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
883 bfd_vma next_jump_slot_index;
884
885 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
886 bfd_vma next_irelative_index;
2df3368d
L		 887
888 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
889 to read-only sections. */
890 bfd_boolean readonly_dynrelocs_against_ifunc;
6725bdbf 891};
252b5132
RH		 892
893/* Get the i386 ELF linker hash table from a link_info structure. */
894
895#define elf_i386_hash_table(p) \
4dfe6ac6
NC		 896 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
897 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
252b5132 898
67a4f2b7 899#define elf_i386_compute_jump_table_size(htab) \
998d811a 900 ((htab)->elf.srelplt->reloc_count * 4)
67a4f2b7 901
252b5132
RH		 902/* Create an entry in an i386 ELF linker hash table. */
903
904static struct bfd_hash_entry *
eb4ff4d6
L		 905elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
906 struct bfd_hash_table *table,
907 const char *string)
252b5132 908{
252b5132
RH		 909 /* Allocate the structure if it has not already been allocated by a
910 subclass. */
ebe50bae
AM		 911 if (entry == NULL)
912 {
a50b1753
NC		 913 entry = (struct bfd_hash_entry *)
914 bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
ebe50bae
AM		 915 if (entry == NULL)
916 return entry;
917 }
252b5132
RH		 918
919 /* Call the allocation method of the superclass. */
ebe50bae
AM		 920 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
921 if (entry != NULL)
252b5132 922 {
ebe50bae
AM		 923 struct elf_i386_link_hash_entry *eh;
924
925 eh = (struct elf_i386_link_hash_entry *) entry;
926 eh->dyn_relocs = NULL;
13ae64f3 927 eh->tls_type = GOT_UNKNOWN;
d5597ebc 928 eh->gotoff_ref = 0;
aec6b87e
L		 929 eh->has_got_reloc = 0;
930 eh->has_non_got_reloc = 0;
6eaa7fb5 931 eh->tls_get_addr = 2;
04ebc307 932 eh->func_pointer_refcount = 0;
dd7e64d4 933 eh->plt_got.offset = (bfd_vma) -1;
67a4f2b7 934 eh->tlsdesc_got = (bfd_vma) -1;
252b5132
RH		 935 }
936
ebe50bae 937 return entry;
252b5132
RH		 938}
939
c25bc9fc
L		 940/* Compute a hash of a local hash entry. We use elf_link_hash_entry
941 for local symbol so that we can handle local STT_GNU_IFUNC symbols
942 as global symbol. We reuse indx and dynstr_index for local symbol
943 hash since they aren't used by global symbols in this backend. */
944
945static hashval_t
946elf_i386_local_htab_hash (const void *ptr)
947{
948 struct elf_link_hash_entry *h
949 = (struct elf_link_hash_entry *) ptr;
d2149d72 950 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
c25bc9fc
L		 951}
952
953/* Compare local hash entries. */
954
955static int
956elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
957{
958 struct elf_link_hash_entry *h1
959 = (struct elf_link_hash_entry *) ptr1;
960 struct elf_link_hash_entry *h2
961 = (struct elf_link_hash_entry *) ptr2;
962
963 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
964}
965
966/* Find and/or create a hash entry for local symbol. */
967
968static struct elf_link_hash_entry *
969elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
970 bfd *abfd, const Elf_Internal_Rela *rel,
971 bfd_boolean create)
972{
973 struct elf_i386_link_hash_entry e, *ret;
974 asection *sec = abfd->sections;
d2149d72
L		 975 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
976 ELF32_R_SYM (rel->r_info));
c25bc9fc
L		 977 void **slot;
978
979 e.elf.indx = sec->id;
980 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
981 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
982 create ? INSERT : NO_INSERT);
983
984 if (!slot)
985 return NULL;
986
987 if (*slot)
988 {
989 ret = (struct elf_i386_link_hash_entry *) *slot;
990 return &ret->elf;
991 }
992
993 ret = (struct elf_i386_link_hash_entry *)
994 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
995 sizeof (struct elf_i386_link_hash_entry));
996 if (ret)
997 {
998 memset (ret, 0, sizeof (*ret));
999 ret->elf.indx = sec->id;
1000 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
1001 ret->elf.dynindx = -1;
04ebc307 1002 ret->func_pointer_refcount = 0;
dd7e64d4 1003 ret->plt_got.offset = (bfd_vma) -1;
c25bc9fc
L		 1004 *slot = ret;
1005 }
1006 return &ret->elf;
1007}
1008
68faa637
AM		 1009/* Destroy an i386 ELF linker hash table. */
1010
1011static void
d495ab0d 1012elf_i386_link_hash_table_free (bfd *obfd)
68faa637
AM		 1013{
1014 struct elf_i386_link_hash_table *htab
d495ab0d 1015 = (struct elf_i386_link_hash_table *) obfd->link.hash;
68faa637
AM		 1016
1017 if (htab->loc_hash_table)
1018 htab_delete (htab->loc_hash_table);
1019 if (htab->loc_hash_memory)
1020 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
d495ab0d 1021 _bfd_elf_link_hash_table_free (obfd);
68faa637
AM		 1022}
1023
252b5132
RH		 1024/* Create an i386 ELF linker hash table. */
1025
1026static struct bfd_link_hash_table *
55fd94b0 1027elf_i386_link_hash_table_create (bfd *abfd)
252b5132
RH		 1028{
1029 struct elf_i386_link_hash_table *ret;
dc810e39 1030 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
252b5132 1031
7bf52ea2 1032 ret = (struct elf_i386_link_hash_table *) bfd_zmalloc (amt);
ebe50bae 1033 if (ret == NULL)
252b5132
RH		 1034 return NULL;
1035
eb4ff4d6
L		 1036 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1037 elf_i386_link_hash_newfunc,
4dfe6ac6
NC		 1038 sizeof (struct elf_i386_link_hash_entry),
1039 I386_ELF_DATA))
252b5132 1040 {
e2d34d7d 1041 free (ret);
252b5132
RH		 1042 return NULL;
1043 }
1044
c25bc9fc
L		 1045 ret->loc_hash_table = htab_try_create (1024,
1046 elf_i386_local_htab_hash,
1047 elf_i386_local_htab_eq,
1048 NULL);
1049 ret->loc_hash_memory = objalloc_create ();
1050 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1051 {
d495ab0d 1052 elf_i386_link_hash_table_free (abfd);
c25bc9fc
L		 1053 return NULL;
1054 }
d495ab0d 1055 ret->elf.root.hash_table_free = elf_i386_link_hash_table_free;
c25bc9fc 1056
ebe50bae 1057 return &ret->elf.root;
252b5132
RH		 1058}
1059
6725bdbf
AM		 1060/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1061 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1062 hash table. */
1063
b34976b6 1064static bfd_boolean
55fd94b0 1065elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
6725bdbf
AM		 1066{
1067 struct elf_i386_link_hash_table *htab;
1068
6725bdbf 1069 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 1070 return FALSE;
6725bdbf 1071
6de2ae4a 1072 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 1073 if (htab == NULL)
1074 return FALSE;
1075
493f652c
L		 1076 /* Set the contents of the .interp section to the interpreter. */
1077 if (bfd_link_executable (info) && !info->nointerp)
1078 {
1079 asection *s = bfd_get_linker_section (dynobj, ".interp");
1080 if (s == NULL)
1081 abort ();
1082 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1083 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1084 htab->interp = s;
1085 }
1086
3d4d4302 1087 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
d5597ebc 1088 if (!htab->sdynbss)
6725bdbf
AM		 1089 abort ();
1090
0e1862bb 1091 if (bfd_link_executable (info))
d5597ebc
L		 1092 {
1093 /* Always allow copy relocs for building executables. */
1094 asection *s = bfd_get_linker_section (dynobj, ".rel.bss");
1095 if (s == NULL)
1096 {
1097 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1098 s = bfd_make_section_anyway_with_flags (dynobj,
1099 ".rel.bss",
1100 (bed->dynamic_sec_flags
1101 | SEC_READONLY));
1102 if (s == NULL
1103 || ! bfd_set_section_alignment (dynobj, s,
1104 bed->s->log_file_align))
1105 return FALSE;
1106 }
1107 htab->srelbss = s;
1108 }
1109
23209a78 1110 if (get_elf_i386_backend_data (dynobj)->is_vxworks
6de2ae4a
L		 1111 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1112 &htab->srelplt2))
711de32c 1113 return FALSE;
eac338cf 1114
e41b3a13 1115 if (!info->no_ld_generated_unwind_info
2fe0fd06 1116 && htab->plt_eh_frame == NULL
e4de50d4 1117 && htab->elf.splt != NULL)
e41b3a13 1118 {
bbf96e4e
L		 1119 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1120 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1121 | SEC_LINKER_CREATED);
e41b3a13 1122 htab->plt_eh_frame
bbf96e4e 1123 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
e41b3a13
JJ		 1124 if (htab->plt_eh_frame == NULL
1125 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1126 return FALSE;
e41b3a13
JJ		 1127 }
1128
b34976b6 1129 return TRUE;
6725bdbf
AM		 1130}
1131
ebe50bae
AM		 1132/* Copy the extra info we tack onto an elf_link_hash_entry. */
1133
51b64d56 1134static void
fcfa13d2 1135elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
55fd94b0
AM		 1136 struct elf_link_hash_entry *dir,
1137 struct elf_link_hash_entry *ind)
ebe50bae
AM		 1138{
1139 struct elf_i386_link_hash_entry *edir, *eind;
1140
1141 edir = (struct elf_i386_link_hash_entry *) dir;
1142 eind = (struct elf_i386_link_hash_entry *) ind;
1143
bbd7ec4a 1144 if (eind->dyn_relocs != NULL)
ebe50bae 1145 {
bbd7ec4a
AM		 1146 if (edir->dyn_relocs != NULL)
1147 {
e03a8ed8
L		 1148 struct elf_dyn_relocs **pp;
1149 struct elf_dyn_relocs *p;
bbd7ec4a 1150
fcfa13d2 1151 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 1152 list. Merge any entries against the same section. */
1153 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1154 {
e03a8ed8 1155 struct elf_dyn_relocs *q;
bbd7ec4a
AM		 1156
1157 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1158 if (q->sec == p->sec)
1159 {
1160 q->pc_count += p->pc_count;
1161 q->count += p->count;
1162 *pp = p->next;
1163 break;
1164 }
1165 if (q == NULL)
1166 pp = &p->next;
1167 }
1168 *pp = edir->dyn_relocs;
1169 }
1170
ebe50bae
AM		 1171 edir->dyn_relocs = eind->dyn_relocs;
1172 eind->dyn_relocs = NULL;
1173 }
ebe50bae 1174
cd67d266
JJ		 1175 if (ind->root.type == bfd_link_hash_indirect
1176 && dir->got.refcount <= 0)
1177 {
1178 edir->tls_type = eind->tls_type;
1179 eind->tls_type = GOT_UNKNOWN;
1180 }
81848ca0 1181
d5597ebc
L		 1182 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1183 generate a R_386_COPY reloc. */
1184 edir->gotoff_ref |= eind->gotoff_ref;
1185
aec6b87e
L		 1186 edir->has_got_reloc |= eind->has_got_reloc;
1187 edir->has_non_got_reloc |= eind->has_non_got_reloc;
1188
81848ca0
AM		 1189 if (ELIMINATE_COPY_RELOCS
1190 && ind->root.type != bfd_link_hash_indirect
f5385ebf
AM		 1191 && dir->dynamic_adjusted)
1192 {
1193 /* If called to transfer flags for a weakdef during processing
1194 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1195 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1196 dir->ref_dynamic |= ind->ref_dynamic;
1197 dir->ref_regular |= ind->ref_regular;
1198 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1199 dir->needs_plt |= ind->needs_plt;
1200 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1201 }
81848ca0 1202 else
04ebc307
L		 1203 {
1204 if (eind->func_pointer_refcount > 0)
1205 {
1206 edir->func_pointer_refcount += eind->func_pointer_refcount;
1207 eind->func_pointer_refcount = 0;
1208 }
1209
1210 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1211 }
ebe50bae
AM		 1212}
1213
142411ca
L		 1214/* Return TRUE if the TLS access code sequence support transition
1215 from R_TYPE. */
1216
1217static bfd_boolean
bedfd056 1218elf_i386_check_tls_transition (asection *sec,
142411ca
L		 1219 bfd_byte *contents,
1220 Elf_Internal_Shdr *symtab_hdr,
1221 struct elf_link_hash_entry **sym_hashes,
1222 unsigned int r_type,
1223 const Elf_Internal_Rela *rel,
1224 const Elf_Internal_Rela *relend)
13ae64f3 1225{
6eaa7fb5 1226 unsigned int val, type, reg;
142411ca
L		 1227 unsigned long r_symndx;
1228 struct elf_link_hash_entry *h;
1229 bfd_vma offset;
6eaa7fb5
L		 1230 bfd_byte *call;
1231 bfd_boolean indirect_call, tls_get_addr;
142411ca 1232
142411ca 1233 offset = rel->r_offset;
13ae64f3 1234 switch (r_type)
142411ca
L		 1235 {
1236 case R_386_TLS_GD:
1237 case R_386_TLS_LDM:
1238 if (offset < 2 || (rel + 1) >= relend)
1239 return FALSE;
1240
6eaa7fb5
L		 1241 indirect_call = FALSE;
1242 call = contents + offset + 4;
1243 val = *(call - 5);
1244 type = *(call - 6);
142411ca
L		 1245 if (r_type == R_386_TLS_GD)
1246 {
09e8c3bf 1247 /* Check transition from GD access model. Only
6eaa7fb5
L		 1248 leal foo@tlsgd(,%ebx,1), %eax
1249 call ___tls_get_addr@PLT
1250 or
1251 leal foo@tlsgd(%ebx) %eax
1252 call ___tls_get_addr@PLT
1253 nop
1254 or
1255 leal foo@tlsgd(%reg), %eax
1256 call *___tls_get_addr@GOT(%reg)
1257 which may be converted to
1258 addr32 call ___tls_get_addr
142411ca 1259 can transit to different access model. */
6eaa7fb5
L		 1260 if ((offset + 10) > sec->size
1261 || (type != 0x8d && type != 0x04))
142411ca
L		 1262 return FALSE;
1263
142411ca
L		 1264 if (type == 0x04)
1265 {
6eaa7fb5
L		 1266 /* leal foo@tlsgd(,%ebx,1), %eax
1267 call ___tls_get_addr@PLT */
142411ca
L		 1268 if (offset < 3)
1269 return FALSE;
1270
6eaa7fb5
L		 1271 if (*(call - 7) != 0x8d
1272 || val != 0x1d
1273 || call[0] != 0xe8)
142411ca
L		 1274 return FALSE;
1275 }
1276 else
1277 {
6eaa7fb5
L		 1278 /* This must be
1279 leal foo@tlsgd(%ebx), %eax
1280 call ___tls_get_addr@PLT
1281 nop
1282 or
1283 leal foo@tlsgd(%reg), %eax
1284 call *___tls_get_addr@GOT(%reg)
1285 which may be converted to
1286 addr32 call ___tls_get_addr
1287
1288 %eax can't be used as the GOT base register since it
1289 is used to pass parameter to ___tls_get_addr. */
1290 reg = val & 7;
1291 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
142411ca
L		 1292 return FALSE;
1293
6eaa7fb5
L		 1294 indirect_call = call[0] == 0xff;
1295 if (!(reg == 3 && call[0] == 0xe8 && call[5] == 0x90)
1296 && !(call[0] == 0x67 && call[1] == 0xe8)
1297 && !(indirect_call
1298 && (call[1] & 0xf8) == 0x90
1299 && (call[1] & 0x7) == reg))
142411ca
L		 1300 return FALSE;
1301 }
1302 }
1303 else
1304 {
1305 /* Check transition from LD access model. Only
6eaa7fb5
L		 1306 leal foo@tlsldm(%ebx), %eax
1307 call ___tls_get_addr@PLT
1308 or
1309 leal foo@tlsldm(%reg), %eax
1310 call *___tls_get_addr@GOT(%reg)
1311 which may be converted to
1312 addr32 call ___tls_get_addr
142411ca
L		 1313 can transit to different access model. */
1314 if (type != 0x8d || (offset + 9) > sec->size)
1315 return FALSE;
1316
6eaa7fb5
L		 1317 /* %eax can't be used as the GOT base register since it is
1318 used to pass parameter to ___tls_get_addr. */
1319 reg = val & 7;
1320 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
142411ca 1321 return FALSE;
142411ca 1322
6eaa7fb5
L		 1323 indirect_call = call[0] == 0xff;
1324 if (!(reg == 3 && call[0] == 0xe8)
1325 && !(call[0] == 0x67 && call[1] == 0xe8)
1326 && !(indirect_call
1327 && (call[1] & 0xf8) == 0x90
1328 && (call[1] & 0x7) == reg))
1329 return FALSE;
1330 }
142411ca
L		 1331
1332 r_symndx = ELF32_R_SYM (rel[1].r_info);
1333 if (r_symndx < symtab_hdr->sh_info)
1334 return FALSE;
1335
6eaa7fb5 1336 tls_get_addr = FALSE;
142411ca 1337 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6eaa7fb5
L		 1338 if (h != NULL && h->root.root.string != NULL)
1339 {
1340 struct elf_i386_link_hash_entry *eh
1341 = (struct elf_i386_link_hash_entry *) h;
1342 tls_get_addr = eh->tls_get_addr == 1;
1343 if (eh->tls_get_addr > 1)
1344 {
1345 /* Use strncmp to check ___tls_get_addr since
1346 ___tls_get_addr may be versioned. */
1347 if (strncmp (h->root.root.string, "___tls_get_addr", 15)
1348 == 0)
1349 {
1350 eh->tls_get_addr = 1;
1351 tls_get_addr = TRUE;
1352 }
1353 else
1354 eh->tls_get_addr = 0;
1355 }
1356 }
1357
1358 if (!tls_get_addr)
1359 return FALSE;
1360 else if (indirect_call)
1361 return (ELF32_R_TYPE (rel[1].r_info) == R_386_GOT32X);
1362 else
1363 return (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1364 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
142411ca
L		 1365
1366 case R_386_TLS_IE:
1367 /* Check transition from IE access model:
1368 movl foo@indntpoff(%rip), %eax
1369 movl foo@indntpoff(%rip), %reg
1370 addl foo@indntpoff(%rip), %reg
1371 */
1372
1373 if (offset < 1 || (offset + 4) > sec->size)
1374 return FALSE;
1375
1376 /* Check "movl foo@tpoff(%rip), %eax" first. */
1377 val = bfd_get_8 (abfd, contents + offset - 1);
1378 if (val == 0xa1)
1379 return TRUE;
1380
1381 if (offset < 2)
1382 return FALSE;
1383
1384 /* Check movl|addl foo@tpoff(%rip), %reg. */
1385 type = bfd_get_8 (abfd, contents + offset - 2);
1386 return ((type == 0x8b || type == 0x03)
1387 && (val & 0xc7) == 0x05);
1388
1389 case R_386_TLS_GOTIE:
1390 case R_386_TLS_IE_32:
1391 /* Check transition from {IE_32,GOTIE} access model:
1392 subl foo@{tpoff,gontoff}(%reg1), %reg2
1393 movl foo@{tpoff,gontoff}(%reg1), %reg2
1394 addl foo@{tpoff,gontoff}(%reg1), %reg2
1395 */
1396
1397 if (offset < 2 || (offset + 4) > sec->size)
1398 return FALSE;
1399
1400 val = bfd_get_8 (abfd, contents + offset - 1);
1401 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1402 return FALSE;
1403
1404 type = bfd_get_8 (abfd, contents + offset - 2);
1405 return type == 0x8b || type == 0x2b || type == 0x03;
1406
1407 case R_386_TLS_GOTDESC:
1408 /* Check transition from GDesc access model:
1409 leal x@tlsdesc(%ebx), %eax
1410
1411 Make sure it's a leal adding ebx to a 32-bit offset
1412 into any register, although it's probably almost always
1413 going to be eax. */
1414
1415 if (offset < 2 || (offset + 4) > sec->size)
1416 return FALSE;
1417
1418 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1419 return FALSE;
1420
1421 val = bfd_get_8 (abfd, contents + offset - 1);
1422 return (val & 0xc7) == 0x83;
1423
1424 case R_386_TLS_DESC_CALL:
1425 /* Check transition from GDesc access model:
6eaa7fb5 1426 call *x@tlsdesc(%eax)
142411ca
L		 1427 */
1428 if (offset + 2 <= sec->size)
1429 {
6eaa7fb5
L		 1430 /* Make sure that it's a call *x@tlsdesc(%eax). */
1431 call = contents + offset;
1432 return call[0] == 0xff && call[1] == 0x10;
142411ca
L		 1433 }
1434
1435 return FALSE;
1436
1437 default:
1438 abort ();
1439 }
1440}
1441
1442/* Return TRUE if the TLS access transition is OK or no transition
1443 will be performed. Update R_TYPE if there is a transition. */
1444
1445static bfd_boolean
1446elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1447 asection *sec, bfd_byte *contents,
1448 Elf_Internal_Shdr *symtab_hdr,
1449 struct elf_link_hash_entry **sym_hashes,
1450 unsigned int *r_type, int tls_type,
1451 const Elf_Internal_Rela *rel,
1452 const Elf_Internal_Rela *relend,
4c544807 1453 struct elf_link_hash_entry *h,
bedfd056
L		 1454 unsigned long r_symndx,
1455 bfd_boolean from_relocate_section)
142411ca
L		 1456{
1457 unsigned int from_type = *r_type;
1458 unsigned int to_type = from_type;
1459 bfd_boolean check = TRUE;
1460
bb1cb422
L		 1461 /* Skip TLS transition for functions. */
1462 if (h != NULL
1463 && (h->type == STT_FUNC
1464 || h->type == STT_GNU_IFUNC))
1465 return TRUE;
1466
142411ca 1467 switch (from_type)
13ae64f3
JJ		 1468 {
1469 case R_386_TLS_GD:
67a4f2b7
AO		 1470 case R_386_TLS_GOTDESC:
1471 case R_386_TLS_DESC_CALL:
13ae64f3 1472 case R_386_TLS_IE_32:
37e55690
JJ		 1473 case R_386_TLS_IE:
1474 case R_386_TLS_GOTIE:
0e1862bb 1475 if (bfd_link_executable (info))
142411ca
L		 1476 {
1477 if (h == NULL)
1478 to_type = R_386_TLS_LE_32;
1479 else if (from_type != R_386_TLS_IE
1480 && from_type != R_386_TLS_GOTIE)
1481 to_type = R_386_TLS_IE_32;
1482 }
1483
bedfd056
L		 1484 /* When we are called from elf_i386_relocate_section, there may
1485 be additional transitions based on TLS_TYPE. */
1486 if (from_relocate_section)
142411ca
L		 1487 {
1488 unsigned int new_to_type = to_type;
1489
0e1862bb 1490 if (bfd_link_executable (info)
142411ca
L		 1491 && h != NULL
1492 && h->dynindx == -1
1493 && (tls_type & GOT_TLS_IE))
1494 new_to_type = R_386_TLS_LE_32;
1495
1496 if (to_type == R_386_TLS_GD
1497 || to_type == R_386_TLS_GOTDESC
1498 || to_type == R_386_TLS_DESC_CALL)
1499 {
1500 if (tls_type == GOT_TLS_IE_POS)
1501 new_to_type = R_386_TLS_GOTIE;
1502 else if (tls_type & GOT_TLS_IE)
1503 new_to_type = R_386_TLS_IE_32;
1504 }
1505
1506 /* We checked the transition before when we were called from
1507 elf_i386_check_relocs. We only want to check the new
1508 transition which hasn't been checked before. */
1509 check = new_to_type != to_type && from_type == to_type;
1510 to_type = new_to_type;
1511 }
1512
1513 break;
1514
13ae64f3 1515 case R_386_TLS_LDM:
0e1862bb 1516 if (bfd_link_executable (info))
142411ca
L		 1517 to_type = R_386_TLS_LE_32;
1518 break;
1519
1520 default:
1521 return TRUE;
1522 }
1523
1524 /* Return TRUE if there is no transition. */
1525 if (from_type == to_type)
1526 return TRUE;
1527
1528 /* Check if the transition can be performed. */
1529 if (check
bedfd056 1530 && ! elf_i386_check_tls_transition (sec, contents,
142411ca
L		 1531 symtab_hdr, sym_hashes,
1532 from_type, rel, relend))
1533 {
2f629d23 1534 reloc_howto_type *from, *to;
4c544807 1535 const char *name;
142411ca
L		 1536
1537 from = elf_i386_rtype_to_howto (abfd, from_type);
1538 to = elf_i386_rtype_to_howto (abfd, to_type);
1539
4c544807
L		 1540 if (h)
1541 name = h->root.root.string;
1542 else
1543 {
4c544807 1544 struct elf_i386_link_hash_table *htab;
4dfe6ac6 1545
4c544807 1546 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 1547 if (htab == NULL)
1548 name = "*unknown*";
1549 else
1550 {
1551 Elf_Internal_Sym *isym;
1552
1553 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1554 abfd, r_symndx);
1555 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1556 }
4c544807
L		 1557 }
1558
4eca0228 1559 _bfd_error_handler
695344c0 1560 /* xgettext:c-format */
142411ca
L		 1561 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1562 "in section `%A' failed"),
4c544807 1563 abfd, sec, from->name, to->name, name,
142411ca
L		 1564 (unsigned long) rel->r_offset);
1565 bfd_set_error (bfd_error_bad_value);
1566 return FALSE;
13ae64f3
JJ		 1567 }
1568
142411ca
L		 1569 *r_type = to_type;
1570 return TRUE;
13ae64f3
JJ		 1571}
1572
c175a657
L		 1573/* With the local symbol, foo, we convert
1574 mov foo@GOT[(%reg1)], %reg2
1575 to
1576 lea foo[@GOTOFF(%reg1)], %reg2
1577 and convert
1578 call/jmp *foo@GOT[(%reg)]
1579 to
1580 nop call foo/jmp foo nop
1581 When PIC is false, convert
1582 test %reg1, foo@GOT[(%reg2)]
1583 to
1584 test $foo, %reg1
1585 and convert
1586 binop foo@GOT[(%reg1)], %reg2
1587 to
1588 binop $foo, %reg2
1589 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1590 instructions. */
1591
1592static
1593bfd_boolean
1594elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
1595 bfd_byte *contents,
1596 Elf_Internal_Rela *irel,
1597 struct elf_link_hash_entry *h,
1598 bfd_boolean *converted,
1599 struct bfd_link_info *link_info)
1600{
1601 struct elf_i386_link_hash_table *htab;
1602 unsigned int opcode;
1603 unsigned int modrm;
1604 bfd_boolean baseless;
1605 Elf_Internal_Sym *isym;
1606 unsigned int addend;
1607 unsigned int nop;
1608 bfd_vma nop_offset;
1609 bfd_boolean is_pic;
1610 bfd_boolean to_reloc_32;
1611 unsigned int r_type;
1612 unsigned int r_symndx;
1613 bfd_vma roff = irel->r_offset;
1614
1615 if (roff < 2)
1616 return TRUE;
1617
7d4d9709 1618 /* Addend for R_386_GOT32X relocations must be 0. */
c175a657
L		 1619 addend = bfd_get_32 (abfd, contents + roff);
1620 if (addend != 0)
1621 return TRUE;
1622
1623 htab = elf_i386_hash_table (link_info);
1624 is_pic = bfd_link_pic (link_info);
1625
1626 r_type = ELF32_R_TYPE (irel->r_info);
1627 r_symndx = ELF32_R_SYM (irel->r_info);
1628
1629 modrm = bfd_get_8 (abfd, contents + roff - 1);
1630 baseless = (modrm & 0xc7) == 0x5;
1631
7d4d9709 1632 if (baseless && is_pic)
c175a657
L		 1633 {
1634 /* For PIC, disallow R_386_GOT32X without a base register
7d4d9709 1635 since we don't know what the GOT base is. */
c175a657
L		 1636 const char *name;
1637
1638 if (h == NULL)
1639 {
1640 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd,
1641 r_symndx);
1642 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1643 }
1644 else
1645 name = h->root.root.string;
1646
4eca0228 1647 _bfd_error_handler
695344c0 1648 /* xgettext:c-format */
c175a657
L		 1649 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1650 abfd, name);
1651 return FALSE;
1652 }
1653
1654 opcode = bfd_get_8 (abfd, contents + roff - 2);
1655
c175a657
L		 1656 /* Convert to R_386_32 if PIC is false or there is no base
1657 register. */
1658 to_reloc_32 = !is_pic || baseless;
1659
7d4d9709
L		 1660 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1661 reloc. */
c175a657
L		 1662 if (h == NULL)
1663 {
1664 if (opcode == 0x0ff)
1665 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1666 goto convert_branch;
1667 else
1668 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1669 "test %reg1, foo@GOT(%reg2)" and
1670 "binop foo@GOT[(%reg1)], %reg2". */
1671 goto convert_load;
1672 }
1673
1674 /* Undefined weak symbol is only bound locally in executable
1675 and its reference is resolved as 0. */
1676 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, TRUE,
1677 elf_i386_hash_entry (h)))
1678 {
1679 if (opcode == 0xff)
1680 {
1681 /* No direct branch to 0 for PIC. */
1682 if (is_pic)
1683 return TRUE;
1684 else
1685 goto convert_branch;
1686 }
1687 else
1688 {
1689 /* We can convert load of address 0 to R_386_32. */
1690 to_reloc_32 = TRUE;
1691 goto convert_load;
1692 }
1693 }
1694
1695 if (opcode == 0xff)
1696 {
1697 /* We have "call/jmp *foo@GOT[(%reg)]". */
1698 if ((h->root.type == bfd_link_hash_defined
1699 || h->root.type == bfd_link_hash_defweak)
1700 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1701 {
1702 /* The function is locally defined. */
1703convert_branch:
1704 /* Convert R_386_GOT32X to R_386_PC32. */
1705 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1706 {
6eaa7fb5
L		 1707 struct elf_i386_link_hash_entry *eh
1708 = (struct elf_i386_link_hash_entry *) h;
1709
c175a657
L		 1710 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1711 is a nop prefix. */
1712 modrm = 0xe8;
6eaa7fb5
L		 1713 /* To support TLS optimization, always use addr32 prefix
1714 for "call *___tls_get_addr@GOT(%reg)". */
1715 if (eh && eh->tls_get_addr == 1)
c175a657 1716 {
6eaa7fb5
L		 1717 nop = 0x67;
1718 nop_offset = irel->r_offset - 2;
c175a657
L		 1719 }
1720 else
6eaa7fb5
L		 1721 {
1722 nop = link_info->call_nop_byte;
1723 if (link_info->call_nop_as_suffix)
1724 {
1725 nop_offset = roff + 3;
1726 irel->r_offset -= 1;
1727 }
1728 else
1729 nop_offset = roff - 2;
1730 }
c175a657
L		 1731 }
1732 else
1733 {
1734 /* Convert to "jmp foo nop". */
1735 modrm = 0xe9;
1736 nop = NOP_OPCODE;
1737 nop_offset = roff + 3;
1738 irel->r_offset -= 1;
1739 }
1740
1741 bfd_put_8 (abfd, nop, contents + nop_offset);
1742 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1743 /* When converting to PC-relative relocation, we
1744 need to adjust addend by -4. */
1745 bfd_put_32 (abfd, -4, contents + irel->r_offset);
1746 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1747
1748 *converted = TRUE;
1749 }
1750 }
1751 else
1752 {
1753 /* We have "mov foo@GOT[(%re1g)], %reg2",
1754 "test %reg1, foo@GOT(%reg2)" and
1755 "binop foo@GOT[(%reg1)], %reg2".
1756
1757 Avoid optimizing _DYNAMIC since ld.so may use its
1758 link-time address. */
1759 if (h == htab->elf.hdynamic)
1760 return TRUE;
1761
1762 /* def_regular is set by an assignment in a linker script in
1763 bfd_elf_record_link_assignment. */
1764 if ((h->def_regular
1765 || h->root.type == bfd_link_hash_defined
1766 || h->root.type == bfd_link_hash_defweak)
1767 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1768 {
1769convert_load:
1770 if (opcode == 0x8b)
1771 {
1772 if (to_reloc_32)
1773 {
1774 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1775 "mov $foo, %reg2" with R_386_32. */
1776 r_type = R_386_32;
1777 modrm = 0xc0 | (modrm & 0x38) >> 3;
1778 bfd_put_8 (abfd, modrm, contents + roff - 1);
1779 opcode = 0xc7;
1780 }
1781 else
1782 {
1783 /* Convert "mov foo@GOT(%reg1), %reg2" to
1784 "lea foo@GOTOFF(%reg1), %reg2". */
1785 r_type = R_386_GOTOFF;
1786 opcode = 0x8d;
1787 }
1788 }
1789 else
1790 {
1791 /* Only R_386_32 is supported. */
1792 if (!to_reloc_32)
1793 return TRUE;
1794
1795 if (opcode == 0x85)
1796 {
1797 /* Convert "test %reg1, foo@GOT(%reg2)" to
1798 "test $foo, %reg1". */
1799 modrm = 0xc0 | (modrm & 0x38) >> 3;
1800 opcode = 0xf7;
1801 }
1802 else
1803 {
1804 /* Convert "binop foo@GOT(%reg1), %reg2" to
1805 "binop $foo, %reg2". */
1806 modrm = (0xc0
1807 | (modrm & 0x38) >> 3
1808 | (opcode & 0x3c));
1809 opcode = 0x81;
1810 }
1811 bfd_put_8 (abfd, modrm, contents + roff - 1);
1812 r_type = R_386_32;
1813 }
1814
1815 bfd_put_8 (abfd, opcode, contents + roff - 2);
1816 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1817
1818 *converted = TRUE;
1819 }
1820 }
1821
1822 return TRUE;
1823}
1824
c1d11331
L		 1825/* Rename some of the generic section flags to better document how they
1826 are used here. */
c337a162
L		 1827#define need_convert_load sec_flg0
1828#define check_relocs_failed sec_flg1
c1d11331 1829
252b5132 1830/* Look through the relocs for a section during the first phase, and
0ac8d2ca
AM		 1831 calculate needed space in the global offset table, procedure linkage
1832 table, and dynamic reloc sections. */
252b5132 1833
b34976b6 1834static bfd_boolean
55fd94b0
AM		 1835elf_i386_check_relocs (bfd *abfd,
1836 struct bfd_link_info *info,
1837 asection *sec,
1838 const Elf_Internal_Rela *relocs)
252b5132 1839{
6725bdbf 1840 struct elf_i386_link_hash_table *htab;
252b5132
RH		 1841 Elf_Internal_Shdr *symtab_hdr;
1842 struct elf_link_hash_entry **sym_hashes;
252b5132
RH		 1843 const Elf_Internal_Rela *rel;
1844 const Elf_Internal_Rela *rel_end;
252b5132 1845 asection *sreloc;
bedfd056 1846 bfd_byte *contents;
dd7e64d4 1847 bfd_boolean use_plt_got;
252b5132 1848
0e1862bb 1849 if (bfd_link_relocatable (info))
b34976b6 1850 return TRUE;
252b5132 1851
081b1afe
L		 1852 /* Don't do anything special with non-loaded, non-alloced sections.
1853 In particular, any relocs in such sections should not affect GOT
1854 and PLT reference counting (ie. we don't allow them to create GOT
1855 or PLT entries), there's no possibility or desire to optimize TLS
1856 relocs, and there's not much point in propagating relocs to shared
1857 libs that the dynamic linker won't relocate. */
1858 if ((sec->flags & SEC_ALLOC) == 0)
1859 return TRUE;
1860
0ffa91dd
NC		 1861 BFD_ASSERT (is_i386_elf (abfd));
1862
6725bdbf 1863 htab = elf_i386_hash_table (info);
4dfe6ac6 1864 if (htab == NULL)
c337a162
L		 1865 {
1866 sec->check_relocs_failed = 1;
1867 return FALSE;
1868 }
4dfe6ac6 1869
bedfd056
L		 1870 /* Get the section contents. */
1871 if (elf_section_data (sec)->this_hdr.contents != NULL)
1872 contents = elf_section_data (sec)->this_hdr.contents;
1873 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1874 {
1875 sec->check_relocs_failed = 1;
1876 return FALSE;
1877 }
1878
dd7e64d4
L		 1879 use_plt_got = (!get_elf_i386_backend_data (abfd)->is_vxworks
1880 && (get_elf_i386_backend_data (abfd)
1881 == &elf_i386_arch_bed));
1882
0ffa91dd 1883 symtab_hdr = &elf_symtab_hdr (abfd);
252b5132 1884 sym_hashes = elf_sym_hashes (abfd);
252b5132 1885
252b5132
RH		 1886 sreloc = NULL;
1887
1888 rel_end = relocs + sec->reloc_count;
1889 for (rel = relocs; rel < rel_end; rel++)
1890 {
13ae64f3 1891 unsigned int r_type;
252b5132
RH		 1892 unsigned long r_symndx;
1893 struct elf_link_hash_entry *h;
d5597ebc 1894 struct elf_i386_link_hash_entry *eh;
4c544807
L		 1895 Elf_Internal_Sym *isym;
1896 const char *name;
06a6a421 1897 bfd_boolean size_reloc;
252b5132
RH		 1898
1899 r_symndx = ELF32_R_SYM (rel->r_info);
13ae64f3 1900 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1901
d9bc7a44 1902 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
f5f31454 1903 {
695344c0 1904 /* xgettext:c-format */
4eca0228
AM		 1905 _bfd_error_handler (_("%B: bad symbol index: %d"),
1906 abfd, r_symndx);
c337a162 1907 goto error_return;
f5f31454
L		 1908 }
1909
252b5132 1910 if (r_symndx < symtab_hdr->sh_info)
c25bc9fc
L		 1911 {
1912 /* A local symbol. */
c2e61a4e
L		 1913 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1914 abfd, r_symndx);
1915 if (isym == NULL)
c337a162 1916 goto error_return;
c25bc9fc
L		 1917
1918 /* Check relocation against local STT_GNU_IFUNC symbol. */
c25bc9fc
L		 1919 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1920 {
9fff0c39 1921 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
c25bc9fc 1922 if (h == NULL)
c337a162 1923 goto error_return;
6bbec505 1924
c25bc9fc
L		 1925 /* Fake a STT_GNU_IFUNC symbol. */
1926 h->type = STT_GNU_IFUNC;
1927 h->def_regular = 1;
1928 h->ref_regular = 1;
1929 h->forced_local = 1;
1930 h->root.type = bfd_link_hash_defined;
1931 }
1932 else
1933 h = NULL;
1934 }
252b5132 1935 else
71cb9464 1936 {
4c544807 1937 isym = NULL;
71cb9464
L		 1938 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1939 while (h->root.type == bfd_link_hash_indirect
1940 || h->root.type == bfd_link_hash_warning)
1941 h = (struct elf_link_hash_entry *) h->root.u.i.link;
c25bc9fc 1942 }
cbe950e9 1943
d5597ebc 1944 eh = (struct elf_i386_link_hash_entry *) h;
c25bc9fc
L		 1945 if (h != NULL)
1946 {
cbe950e9
L		 1947 switch (r_type)
1948 {
1949 default:
1950 break;
1951
d5597ebc
L		 1952 case R_386_GOTOFF:
1953 eh->gotoff_ref = 1;
1a0670f3 1954 /* Fall through. */
cbe950e9
L		 1955 case R_386_32:
1956 case R_386_PC32:
1957 case R_386_PLT32:
1958 case R_386_GOT32:
02a86693 1959 case R_386_GOT32X:
9d4057ee
AM		 1960 if (htab->elf.dynobj == NULL)
1961 htab->elf.dynobj = abfd;
466ee2af
L		 1962 /* Create the ifunc sections for static executables. */
1963 if (h->type == STT_GNU_IFUNC
1964 && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj,
1965 info))
c337a162 1966 goto error_return;
cbe950e9
L		 1967 break;
1968 }
1969
ad1e85de
L		 1970 /* It is referenced by a non-shared object. */
1971 h->ref_regular = 1;
61315175 1972 h->root.non_ir_ref = 1;
13a2df29
L		 1973
1974 if (h->type == STT_GNU_IFUNC)
1975 elf_tdata (info->output_bfd)->has_gnu_symbols
1976 |= elf_gnu_symbol_ifunc;
71cb9464 1977 }
252b5132 1978
bedfd056 1979 if (! elf_i386_tls_transition (info, abfd, sec, contents,
142411ca
L		 1980 symtab_hdr, sym_hashes,
1981 &r_type, GOT_UNKNOWN,
bedfd056 1982 rel, rel_end, h, r_symndx, FALSE))
c337a162 1983 goto error_return;
13ae64f3
JJ		 1984
1985 switch (r_type)
252b5132 1986 {
37e55690
JJ		 1987 case R_386_TLS_LDM:
1988 htab->tls_ldm_got.refcount += 1;
1989 goto create_got;
1990
1991 case R_386_PLT32:
1992 /* This symbol requires a procedure linkage table entry. We
1993 actually build the entry in adjust_dynamic_symbol,
1994 because this might be a case of linking PIC code which is
1995 never referenced by a dynamic object, in which case we
1996 don't need to generate a procedure linkage table entry
1997 after all. */
1998
1999 /* If this is a local symbol, we resolve it directly without
2000 creating a procedure linkage table entry. */
2001 if (h == NULL)
2002 continue;
2003
aec6b87e 2004 eh->has_got_reloc = 1;
f5385ebf 2005 h->needs_plt = 1;
37e55690
JJ		 2006 h->plt.refcount += 1;
2007 break;
2008
6a3e1bae 2009 case R_386_SIZE32:
06a6a421 2010 size_reloc = TRUE;
6a3e1bae
L		 2011 goto do_size;
2012
13ae64f3 2013 case R_386_TLS_IE_32:
37e55690
JJ		 2014 case R_386_TLS_IE:
2015 case R_386_TLS_GOTIE:
0e1862bb 2016 if (!bfd_link_executable (info))
13ae64f3 2017 info->flags |= DF_STATIC_TLS;
37e55690
JJ		 2018 /* Fall through */
2019
252b5132 2020 case R_386_GOT32:
02a86693 2021 case R_386_GOT32X:
13ae64f3 2022 case R_386_TLS_GD:
67a4f2b7
AO		 2023 case R_386_TLS_GOTDESC:
2024 case R_386_TLS_DESC_CALL:
252b5132 2025 /* This symbol requires a global offset table entry. */
13ae64f3
JJ		 2026 {
2027 int tls_type, old_tls_type;
2028
2029 switch (r_type)
2030 {
2031 default:
02a86693
L		 2032 case R_386_GOT32:
2033 case R_386_GOT32X:
2034 tls_type = GOT_NORMAL;
2035 break;
13ae64f3 2036 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
67a4f2b7
AO		 2037 case R_386_TLS_GOTDESC:
2038 case R_386_TLS_DESC_CALL:
2039 tls_type = GOT_TLS_GDESC; break;
37e55690
JJ		 2040 case R_386_TLS_IE_32:
2041 if (ELF32_R_TYPE (rel->r_info) == r_type)
2042 tls_type = GOT_TLS_IE_NEG;
2043 else
ebcfb3c0
JJ		 2044 /* If this is a GD->IE transition, we may use either of
2045 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
37e55690
JJ		 2046 tls_type = GOT_TLS_IE;
2047 break;
2048 case R_386_TLS_IE:
2049 case R_386_TLS_GOTIE:
2050 tls_type = GOT_TLS_IE_POS; break;
13ae64f3
JJ		 2051 }
2052
2053 if (h != NULL)
2054 {
2055 h->got.refcount += 1;
2056 old_tls_type = elf_i386_hash_entry(h)->tls_type;
2057 }
2058 else
2059 {
2060 bfd_signed_vma *local_got_refcounts;
2061
2062 /* This is a global offset table entry for a local symbol. */
2063 local_got_refcounts = elf_local_got_refcounts (abfd);
2064 if (local_got_refcounts == NULL)
2065 {
2066 bfd_size_type size;
2067
2068 size = symtab_hdr->sh_info;
67a4f2b7
AO		 2069 size *= (sizeof (bfd_signed_vma)
2070 + sizeof (bfd_vma) + sizeof(char));
a50b1753
NC		 2071 local_got_refcounts = (bfd_signed_vma *)
2072 bfd_zalloc (abfd, size);
13ae64f3 2073 if (local_got_refcounts == NULL)
c337a162 2074 goto error_return;
13ae64f3 2075 elf_local_got_refcounts (abfd) = local_got_refcounts;
67a4f2b7
AO		 2076 elf_i386_local_tlsdesc_gotent (abfd)
2077 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
13ae64f3 2078 elf_i386_local_got_tls_type (abfd)
67a4f2b7 2079 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
13ae64f3
JJ		 2080 }
2081 local_got_refcounts[r_symndx] += 1;
2082 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
2083 }
2084
37e55690
JJ		 2085 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
2086 tls_type |= old_tls_type;
13ae64f3
JJ		 2087 /* If a TLS symbol is accessed using IE at least once,
2088 there is no point to use dynamic model for it. */
ebcfb3c0 2089 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
67a4f2b7 2090 && (! GOT_TLS_GD_ANY_P (old_tls_type)
37e55690 2091 || (tls_type & GOT_TLS_IE) == 0))
13ae64f3 2092 {
67a4f2b7 2093 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
37e55690 2094 tls_type = old_tls_type;
67a4f2b7
AO		 2095 else if (GOT_TLS_GD_ANY_P (old_tls_type)
2096 && GOT_TLS_GD_ANY_P (tls_type))
2097 tls_type |= old_tls_type;
13ae64f3
JJ		 2098 else
2099 {
09a24cbf 2100 if (h)
4c544807
L		 2101 name = h->root.root.string;
2102 else
2103 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
2104 NULL);
4eca0228 2105 _bfd_error_handler
695344c0 2106 /* xgettext:c-format */
d003868e 2107 (_("%B: `%s' accessed both as normal and "
55fd94b0 2108 "thread local symbol"),
4c544807 2109 abfd, name);
68c4a57e 2110 bfd_set_error (bfd_error_bad_value);
c337a162 2111 goto error_return;
13ae64f3
JJ		 2112 }
2113 }
2114
2115 if (old_tls_type != tls_type)
2116 {
2117 if (h != NULL)
2118 elf_i386_hash_entry (h)->tls_type = tls_type;
2119 else
2120 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
2121 }
2122 }
0ac8d2ca
AM		 2123 /* Fall through */
2124
2125 case R_386_GOTOFF:
2126 case R_386_GOTPC:
13ae64f3 2127 create_got:
6de2ae4a 2128 if (htab->elf.sgot == NULL)
0ac8d2ca
AM		 2129 {
2130 if (htab->elf.dynobj == NULL)
2131 htab->elf.dynobj = abfd;
6de2ae4a 2132 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
c337a162 2133 goto error_return;
0ac8d2ca 2134 }
37e55690 2135 if (r_type != R_386_TLS_IE)
aec6b87e
L		 2136 {
2137 if (eh != NULL)
2138 eh->has_got_reloc = 1;
2139 break;
2140 }
37e55690 2141 /* Fall through */
252b5132 2142
37e55690
JJ		 2143 case R_386_TLS_LE_32:
2144 case R_386_TLS_LE:
aec6b87e
L		 2145 if (eh != NULL)
2146 eh->has_got_reloc = 1;
0e1862bb 2147 if (bfd_link_executable (info))
37e55690 2148 break;
bffbf940 2149 info->flags |= DF_STATIC_TLS;
aec6b87e 2150 goto do_relocation;
252b5132
RH		 2151
2152 case R_386_32:
2153 case R_386_PC32:
aec6b87e
L		 2154 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2155 eh->has_non_got_reloc = 1;
2156do_relocation:
bf52d7c7
L		 2157 /* We are called after all symbols have been resolved. Only
2158 relocation against STT_GNU_IFUNC symbol must go through
2159 PLT. */
d1ed1c7d
L		 2160 if (h != NULL
2161 && (bfd_link_executable (info)
bf52d7c7 2162 || h->type == STT_GNU_IFUNC))
6725bdbf 2163 {
12d0ee4a 2164 /* If this reloc is in a read-only section, we might
ebe50bae
AM		 2165 need a copy reloc. We can't check reliably at this
2166 stage whether the section is read-only, as input
2167 sections have not yet been mapped to output sections.
2168 Tentatively set the flag for now, and correct in
2169 adjust_dynamic_symbol. */
f5385ebf 2170 h->non_got_ref = 1;
12d0ee4a 2171
233cc9c1
L		 2172 /* We may need a .plt entry if the symbol is a function
2173 defined in a shared lib or is a STT_GNU_IFUNC function
2174 referenced from the code or read-only section. */
2175 if (!h->def_regular
2176 || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
2177 h->plt.refcount += 1;
2178
4b627c18
L		 2179 if (r_type == R_386_PC32)
2180 {
2181 /* Since something like ".long foo - ." may be used
2182 as pointer, make sure that PLT is used if foo is
2183 a function defined in a shared library. */
2184 if ((sec->flags & SEC_CODE) == 0)
2185 h->pointer_equality_needed = 1;
74437ea2
L		 2186 else if (h->type == STT_GNU_IFUNC
2187 && bfd_link_pic (info))
2188 {
2189 if (isym == NULL)
2190 name = h->root.root.string;
2191 else
2192 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
2193 NULL);
4eca0228 2194 _bfd_error_handler
695344c0 2195 /* xgettext:c-format */
74437ea2
L		 2196 (_("%B: unsupported non-PIC call to IFUNC `%s'"),
2197 abfd, name);
2198 bfd_set_error (bfd_error_bad_value);
2199 goto error_return;
2200 }
4b627c18
L		 2201 }
2202 else
04ebc307
L		 2203 {
2204 h->pointer_equality_needed = 1;
2205 /* R_386_32 can be resolved at run-time. */
2206 if (r_type == R_386_32
2207 && (sec->flags & SEC_READONLY) == 0)
2208 eh->func_pointer_refcount += 1;
2209 }
6725bdbf 2210 }
7843f00e 2211
06a6a421 2212 size_reloc = FALSE;
6a3e1bae 2213do_size:
252b5132 2214 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 2215 against a global symbol, or a non PC relative reloc
2216 against a local symbol, then we need to copy the reloc
2217 into the shared library. However, if we are linking with
2218 -Bsymbolic, we do not need to copy a reloc against a
2219 global symbol which is defined in an object we are
2220 including in the link (i.e., DEF_REGULAR is set). At
2221 this point we have not seen all the input files, so it is
2222 possible that DEF_REGULAR is not set now but will be set
1f655a09
L		 2223 later (it is never cleared). In case of a weak definition,
2224 DEF_REGULAR may be cleared later by a strong definition in
ebe50bae 2225 a shared library. We account for that possibility below by
1f655a09
L		 2226 storing information in the relocs_copied field of the hash
2227 table entry. A similar situation occurs when creating
2228 shared libraries and symbol visibility changes render the
12d0ee4a 2229 symbol local.
56882138 2230
12d0ee4a
AM		 2231 If on the other hand, we are creating an executable, we
2232 may need to keep relocations for symbols satisfied by a
2233 dynamic library if we manage to avoid copy relocs for the
233cc9c1
L		 2234 symbol.
2235
2236 Generate dynamic pointer relocation against STT_GNU_IFUNC
2237 symbol in the non-code section. */
081b1afe
L		 2238 if ((bfd_link_pic (info)
2239 && (r_type != R_386_PC32
2240 || (h != NULL
2241 && (! (bfd_link_pie (info)
2242 || SYMBOLIC_BIND (info, h))
2243 || h->root.type == bfd_link_hash_defweak
2244 || !h->def_regular))))
233cc9c1
L		 2245 || (h != NULL
2246 && h->type == STT_GNU_IFUNC
2247 && r_type == R_386_32
2248 && (sec->flags & SEC_CODE) == 0)
081b1afe
L		 2249 || (ELIMINATE_COPY_RELOCS
2250 && !bfd_link_pic (info)
2251 && h != NULL
2252 && (h->root.type == bfd_link_hash_defweak
2253 || !h->def_regular)))
252b5132 2254 {
e03a8ed8
L		 2255 struct elf_dyn_relocs *p;
2256 struct elf_dyn_relocs **head;
ec338859 2257
12d0ee4a
AM		 2258 /* We must copy these reloc types into the output file.
2259 Create a reloc section in dynobj and make room for
2260 this reloc. */
252b5132
RH		 2261 if (sreloc == NULL)
2262 {
0ac8d2ca
AM		 2263 if (htab->elf.dynobj == NULL)
2264 htab->elf.dynobj = abfd;
2265
83bac4b0
NC		 2266 sreloc = _bfd_elf_make_dynamic_reloc_section
2267 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
2268
252b5132 2269 if (sreloc == NULL)
c337a162 2270 goto error_return;
252b5132
RH		 2271 }
2272
0c715baa
AM		 2273 /* If this is a global symbol, we count the number of
2274 relocations we need for this symbol. */
2275 if (h != NULL)
252b5132 2276 {
d5597ebc 2277 head = &eh->dyn_relocs;
0c715baa
AM		 2278 }
2279 else
2280 {
ec338859
AM		 2281 /* Track dynamic relocs needed for local syms too.
2282 We really need local syms available to do this
2283 easily. Oh well. */
87d72d41 2284 void **vpp;
ec338859 2285 asection *s;
87d72d41
AM		 2286
2287 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2288 abfd, r_symndx);
2289 if (isym == NULL)
c337a162 2290 goto error_return;
87d72d41
AM		 2291
2292 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
ec338859 2293 if (s == NULL)
87d72d41 2294 s = sec;
ec338859 2295
e81d3500 2296 vpp = &elf_section_data (s)->local_dynrel;
e03a8ed8 2297 head = (struct elf_dyn_relocs **)vpp;
ec338859
AM		 2298 }
2299
2300 p = *head;
2301 if (p == NULL || p->sec != sec)
2302 {
2303 bfd_size_type amt = sizeof *p;
a50b1753
NC		 2304 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
2305 amt);
ec338859 2306 if (p == NULL)
c337a162 2307 goto error_return;
ec338859
AM		 2308 p->next = *head;
2309 *head = p;
2310 p->sec = sec;
2311 p->count = 0;
2312 p->pc_count = 0;
252b5132 2313 }
ec338859
AM		 2314
2315 p->count += 1;
06a6a421
L		 2316 /* Count size relocation as PC-relative relocation. */
2317 if (r_type == R_386_PC32 || size_reloc)
ec338859 2318 p->pc_count += 1;
252b5132 2319 }
252b5132
RH		 2320 break;
2321
2322 /* This relocation describes the C++ object vtable hierarchy.
2323 Reconstruct it for later use during GC. */
2324 case R_386_GNU_VTINHERIT:
d17e0c6e 2325 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
c337a162 2326 goto error_return;
252b5132
RH		 2327 break;
2328
2329 /* This relocation describes which C++ vtable entries are actually
2330 used. Record for later use during GC. */
2331 case R_386_GNU_VTENTRY:
c6aa130f
MS		 2332 BFD_ASSERT (h != NULL);
2333 if (h != NULL
2334 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
c337a162 2335 goto error_return;
252b5132
RH		 2336 break;
2337
2338 default:
2339 break;
2340 }
dd7e64d4
L		 2341
2342 if (use_plt_got
2343 && h != NULL
2344 && h->plt.refcount > 0
8ded2ddc
L		 2345 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2346 || h->got.refcount > 0)
dd7e64d4
L		 2347 && htab->plt_got == NULL)
2348 {
2349 /* Create the GOT procedure linkage table. */
2350 unsigned int plt_got_align;
2351 const struct elf_backend_data *bed;
2352
2353 bed = get_elf_backend_data (info->output_bfd);
2354 BFD_ASSERT (sizeof (elf_i386_got_plt_entry) == 8
2355 && (sizeof (elf_i386_got_plt_entry)
2356 == sizeof (elf_i386_pic_got_plt_entry)));
2357 plt_got_align = 3;
2358
2359 if (htab->elf.dynobj == NULL)
2360 htab->elf.dynobj = abfd;
2361 htab->plt_got
2362 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2363 ".plt.got",
2364 (bed->dynamic_sec_flags
2365 | SEC_ALLOC
2366 | SEC_CODE
2367 | SEC_LOAD
2368 | SEC_READONLY));
2369 if (htab->plt_got == NULL
2370 || !bfd_set_section_alignment (htab->elf.dynobj,
2371 htab->plt_got,
2372 plt_got_align))
c337a162 2373 goto error_return;
dd7e64d4 2374 }
c1d11331 2375
52bf37dd 2376 if (r_type == R_386_GOT32X
c1d11331 2377 && (h == NULL || h->type != STT_GNU_IFUNC))
02a86693 2378 sec->need_convert_load = 1;
252b5132
RH		 2379 }
2380
bedfd056
L		 2381 if (elf_section_data (sec)->this_hdr.contents != contents)
2382 {
2383 if (!info->keep_memory)
2384 free (contents);
2385 else
2386 {
2387 /* Cache the section contents for elf_link_input_bfd. */
2388 elf_section_data (sec)->this_hdr.contents = contents;
2389 }
2390 }
2391
b34976b6 2392 return TRUE;
c337a162
L		 2393
2394error_return:
bedfd056
L		 2395 if (elf_section_data (sec)->this_hdr.contents != contents)
2396 free (contents);
c337a162
L		 2397 sec->check_relocs_failed = 1;
2398 return FALSE;
252b5132
RH		 2399}
2400
2401/* Return the section that should be marked against GC for a given
2402 relocation. */
2403
2404static asection *
55fd94b0 2405elf_i386_gc_mark_hook (asection *sec,
07adf181 2406 struct bfd_link_info *info,
55fd94b0
AM		 2407 Elf_Internal_Rela *rel,
2408 struct elf_link_hash_entry *h,
2409 Elf_Internal_Sym *sym)
252b5132
RH		 2410{
2411 if (h != NULL)
07adf181
AM		 2412 switch (ELF32_R_TYPE (rel->r_info))
2413 {
2414 case R_386_GNU_VTINHERIT:
2415 case R_386_GNU_VTENTRY:
2416 return NULL;
2417 }
2418
2419 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
252b5132
RH		 2420}
2421
aec6b87e
L		 2422/* Remove undefined weak symbol from the dynamic symbol table if it
2423 is resolved to 0. */
2424
2425static bfd_boolean
2426elf_i386_fixup_symbol (struct bfd_link_info *info,
2427 struct elf_link_hash_entry *h)
2428{
2429 if (h->dynindx != -1
2430 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
e62b9723 2431 elf_i386_hash_entry (h)->has_got_reloc,
aec6b87e
L		 2432 elf_i386_hash_entry (h)))
2433 {
2434 h->dynindx = -1;
2435 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2436 h->dynstr_index);
2437 }
2438 return TRUE;
2439}
2440
252b5132
RH		 2441/* Adjust a symbol defined by a dynamic object and referenced by a
2442 regular object. The current definition is in some section of the
2443 dynamic object, but we're not including those sections. We have to
2444 change the definition to something the rest of the link can
2445 understand. */
2446
b34976b6 2447static bfd_boolean
55fd94b0
AM		 2448elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2449 struct elf_link_hash_entry *h)
252b5132 2450{
6725bdbf 2451 struct elf_i386_link_hash_table *htab;
252b5132 2452 asection *s;
5ca5bb35
L		 2453 struct elf_i386_link_hash_entry *eh;
2454 struct elf_dyn_relocs *p;
252b5132 2455
cbe950e9
L		 2456 /* STT_GNU_IFUNC symbol must go through PLT. */
2457 if (h->type == STT_GNU_IFUNC)
2458 {
73bcf233
L		 2459 /* All local STT_GNU_IFUNC references must be treate as local
2460 calls via local PLT. */
5ca5bb35
L		 2461 if (h->ref_regular
2462 && SYMBOL_CALLS_LOCAL (info, h))
2463 {
73bcf233 2464 bfd_size_type pc_count = 0, count = 0;
5ca5bb35
L		 2465 struct elf_dyn_relocs **pp;
2466
2467 eh = (struct elf_i386_link_hash_entry *) h;
2468 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2469 {
2470 pc_count += p->pc_count;
2471 p->count -= p->pc_count;
2472 p->pc_count = 0;
73bcf233 2473 count += p->count;
5ca5bb35
L		 2474 if (p->count == 0)
2475 *pp = p->next;
2476 else
2477 pp = &p->next;
2478 }
2479
73bcf233 2480 if (pc_count || count)
5ca5bb35 2481 {
5ca5bb35 2482 h->non_got_ref = 1;
233cc9c1
L		 2483 if (pc_count)
2484 {
2485 /* Increment PLT reference count only for PC-relative
2486 references. */
2487 h->needs_plt = 1;
2488 if (h->plt.refcount <= 0)
2489 h->plt.refcount = 1;
2490 else
2491 h->plt.refcount += 1;
2492 }
5ca5bb35
L		 2493 }
2494 }
2495
cbe950e9
L		 2496 if (h->plt.refcount <= 0)
2497 {
2498 h->plt.offset = (bfd_vma) -1;
2499 h->needs_plt = 0;
2500 }
2501 return TRUE;
2502 }
2503
252b5132
RH		 2504 /* If this is a function, put it in the procedure linkage table. We
2505 will fill in the contents of the procedure linkage table later,
2506 when we know the address of the .got section. */
2507 if (h->type == STT_FUNC
f5385ebf 2508 || h->needs_plt)
252b5132 2509 {
6725bdbf 2510 if (h->plt.refcount <= 0
9c7a29a3
AM		 2511 || SYMBOL_CALLS_LOCAL (info, h)
2512 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2513 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 2514 {
2515 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 2516 file, but the symbol was never referred to by a dynamic
2517 object, or if all references were garbage collected. In
2518 such a case, we don't actually need to build a procedure
2519 linkage table, and we can just do a PC32 reloc instead. */
bbd7ec4a 2520 h->plt.offset = (bfd_vma) -1;
f5385ebf 2521 h->needs_plt = 0;
252b5132
RH		 2522 }
2523
b34976b6 2524 return TRUE;
252b5132 2525 }
6725bdbf
AM		 2526 else
2527 /* It's possible that we incorrectly decided a .plt reloc was
2528 needed for an R_386_PC32 reloc to a non-function sym in
2529 check_relocs. We can't decide accurately between function and
2530 non-function syms in check-relocs; Objects loaded later in
2531 the link may change h->type. So fix it now. */
bbd7ec4a 2532 h->plt.offset = (bfd_vma) -1;
252b5132
RH		 2533
2534 /* If this is a weak symbol, and there is a real definition, the
2535 processor independent code will have arranged for us to see the
2536 real definition first, and we can just use the same value. */
f6e332e6 2537 if (h->u.weakdef != NULL)
252b5132 2538 {
f6e332e6
AM		 2539 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2540 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2541 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2542 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 2543 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 2544 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 2545 return TRUE;
252b5132
RH		 2546 }
2547
2548 /* This is a reference to a symbol defined by a dynamic object which
2549 is not a function. */
2550
2551 /* If we are creating a shared library, we must presume that the
2552 only references to the symbol are via the global offset table.
2553 For such cases we need not do anything here; the relocations will
2554 be handled correctly by relocate_section. */
0e1862bb 2555 if (!bfd_link_executable (info))
b34976b6 2556 return TRUE;
252b5132 2557
7843f00e 2558 /* If there are no references to this symbol that do not use the
d5597ebc
L		 2559 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2560 reloc. */
2561 eh = (struct elf_i386_link_hash_entry *) h;
2562 if (!h->non_got_ref && !eh->gotoff_ref)
b34976b6 2563 return TRUE;
7843f00e 2564
8bd621d8
AM		 2565 /* If -z nocopyreloc was given, we won't generate them either. */
2566 if (info->nocopyreloc)
2567 {
f5385ebf 2568 h->non_got_ref = 0;
b34976b6 2569 return TRUE;
8bd621d8
AM		 2570 }
2571
643796e3 2572 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 2573 if (htab == NULL)
2574 return FALSE;
643796e3 2575
d5597ebc
L		 2576 /* If there aren't any dynamic relocs in read-only sections nor
2577 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2578 avoid the copy reloc. This doesn't work on VxWorks, where we can
2579 not have dynamic relocations (other than copy and jump slot
2580 relocations) in an executable. */
23209a78 2581 if (ELIMINATE_COPY_RELOCS
d5597ebc 2582 && !eh->gotoff_ref
23209a78 2583 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
ebe50bae 2584 {
a23b6845
AM		 2585 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2586 {
2587 s = p->sec->output_section;
2588 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2589 break;
2590 }
2591
a23b6845
AM		 2592 if (p == NULL)
2593 {
f5385ebf 2594 h->non_got_ref = 0;
a23b6845
AM		 2595 return TRUE;
2596 }
ebe50bae
AM		 2597 }
2598
252b5132
RH		 2599 /* We must allocate the symbol in our .dynbss section, which will
2600 become part of the .bss section of the executable. There will be
2601 an entry for this symbol in the .dynsym section. The dynamic
2602 object will contain position independent code, so all references
2603 from the dynamic object to this symbol will go through the global
2604 offset table. The dynamic linker will use the .dynsym entry to
2605 determine the address it must put in the global offset table, so
2606 both the dynamic object and the regular object will refer to the
2607 same memory location for the variable. */
2608
252b5132
RH		 2609 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2610 copy the initial value out of the dynamic object and into the
0ac8d2ca 2611 runtime process image. */
1d7e9d18 2612 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
252b5132 2613 {
eea6121a 2614 htab->srelbss->size += sizeof (Elf32_External_Rel);
f5385ebf 2615 h->needs_copy = 1;
252b5132
RH		 2616 }
2617
0ac8d2ca 2618 s = htab->sdynbss;
252b5132 2619
6cabe1ea 2620 return _bfd_elf_adjust_dynamic_copy (info, h, s);
252b5132
RH		 2621}
2622
6725bdbf 2623/* Allocate space in .plt, .got and associated reloc sections for
0c715baa 2624 dynamic relocs. */
6725bdbf 2625
b34976b6 2626static bfd_boolean
eb4ff4d6 2627elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
6725bdbf
AM		 2628{
2629 struct bfd_link_info *info;
2630 struct elf_i386_link_hash_table *htab;
5a15f56f 2631 struct elf_i386_link_hash_entry *eh;
e03a8ed8 2632 struct elf_dyn_relocs *p;
25e762b9 2633 unsigned plt_entry_size;
aec6b87e 2634 bfd_boolean resolved_to_zero;
6725bdbf 2635
e92d460e 2636 if (h->root.type == bfd_link_hash_indirect)
b34976b6 2637 return TRUE;
6725bdbf 2638
cbe950e9 2639 eh = (struct elf_i386_link_hash_entry *) h;
e92d460e 2640
6725bdbf
AM		 2641 info = (struct bfd_link_info *) inf;
2642 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 2643 if (htab == NULL)
2644 return FALSE;
6725bdbf 2645
25e762b9
RM		 2646 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2647
e62b9723
L		 2648 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2649 eh->has_got_reloc,
2650 eh);
aec6b87e 2651
04ebc307
L		 2652 /* Clear the reference count of function pointer relocations if
2653 symbol isn't a normal function. */
2654 if (h->type != STT_FUNC)
2655 eh->func_pointer_refcount = 0;
2656
dd7e64d4
L		 2657 /* We can't use the GOT PLT if pointer equality is needed since
2658 finish_dynamic_symbol won't clear symbol value and the dynamic
2659 linker won't update the GOT slot. We will get into an infinite
2660 loop at run-time. */
2661 if (htab->plt_got != NULL
2662 && h->type != STT_GNU_IFUNC
2663 && !h->pointer_equality_needed
2664 && h->plt.refcount > 0
2665 && h->got.refcount > 0)
2666 {
2667 /* Don't use the regular PLT if there are both GOT and GOTPLT
2668 reloctions. */
2669 h->plt.offset = (bfd_vma) -1;
2670
2671 /* Use the GOT PLT. */
2672 eh->plt_got.refcount = 1;
2673 }
2674
cbe950e9
L		 2675 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2676 here if it is defined and referenced in a non-shared object. */
2677 if (h->type == STT_GNU_IFUNC
2678 && h->def_regular)
25e762b9 2679 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2df3368d
L		 2680 &htab->readonly_dynrelocs_against_ifunc,
2681 plt_entry_size,
233cc9c1 2682 plt_entry_size, 4, TRUE);
04ebc307
L		 2683 /* Don't create the PLT entry if there are only function pointer
2684 relocations which can be resolved at run-time. */
cbe950e9 2685 else if (htab->elf.dynamic_sections_created
04ebc307
L		 2686 && (h->plt.refcount > eh->func_pointer_refcount
2687 || eh->plt_got.refcount > 0))
6725bdbf 2688 {
25070364
L		 2689 bfd_boolean use_plt_got;
2690
04ebc307
L		 2691 /* Clear the reference count of function pointer relocations
2692 if PLT is used. */
2693 eh->func_pointer_refcount = 0;
2694
8ded2ddc 2695 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
25070364
L		 2696 {
2697 /* Don't use the regular PLT for DF_BIND_NOW. */
2698 h->plt.offset = (bfd_vma) -1;
2699
2700 /* Use the GOT PLT. */
2701 h->got.refcount = 1;
2702 eh->plt_got.refcount = 1;
2703 }
2704
2705 use_plt_got = eh->plt_got.refcount > 0;
dd7e64d4 2706
5a15f56f
AM		 2707 /* Make sure this symbol is output as a dynamic symbol.
2708 Undefined weak syms won't yet be marked as dynamic. */
2709 if (h->dynindx == -1
aec6b87e
L		 2710 && !h->forced_local
2711 && !resolved_to_zero)
5a15f56f 2712 {
c152c796 2713 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2714 return FALSE;
5a15f56f
AM		 2715 }
2716
0e1862bb 2717 if (bfd_link_pic (info)
4e795f50 2718 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
ced53ee5 2719 {
6de2ae4a 2720 asection *s = htab->elf.splt;
dd7e64d4 2721 asection *got_s = htab->plt_got;
6725bdbf 2722
7c1e8d3e
L		 2723 /* If this is the first .plt entry, make room for the special
2724 first entry. The .plt section is used by prelink to undo
2725 prelinking for dynamic relocations. */
2726 if (s->size == 0)
2727 s->size = plt_entry_size;
2728
dd7e64d4
L		 2729 if (use_plt_got)
2730 eh->plt_got.offset = got_s->size;
2731 else
7c1e8d3e 2732 h->plt.offset = s->size;
6725bdbf 2733
ced53ee5
AM		 2734 /* If this symbol is not defined in a regular file, and we are
2735 not generating a shared library, then set the symbol to this
2736 location in the .plt. This is required to make function
2737 pointers compare as equal between the normal executable and
2738 the shared library. */
0e1862bb 2739 if (! bfd_link_pic (info)
f5385ebf 2740 && !h->def_regular)
ced53ee5 2741 {
dd7e64d4
L		 2742 if (use_plt_got)
2743 {
2744 /* We need to make a call to the entry of the GOT PLT
2745 instead of regular PLT entry. */
2746 h->root.u.def.section = got_s;
2747 h->root.u.def.value = eh->plt_got.offset;
2748 }
2749 else
2750 {
2751 h->root.u.def.section = s;
2752 h->root.u.def.value = h->plt.offset;
2753 }
ced53ee5 2754 }
6725bdbf 2755
ced53ee5 2756 /* Make room for this entry. */
dd7e64d4
L		 2757 if (use_plt_got)
2758 got_s->size += sizeof (elf_i386_got_plt_entry);
2759 else
2760 {
2761 s->size += plt_entry_size;
6725bdbf 2762
dd7e64d4
L		 2763 /* We also need to make an entry in the .got.plt section,
2764 which will be placed in the .got section by the linker
2765 script. */
2766 htab->elf.sgotplt->size += 4;
6725bdbf 2767
aec6b87e
L		 2768 /* There should be no PLT relocation against resolved
2769 undefined weak symbol in executable. */
2770 if (!resolved_to_zero)
2771 {
2772 /* We also need to make an entry in the .rel.plt
2773 section. */
2774 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2775 htab->elf.srelplt->reloc_count++;
2776 }
dd7e64d4 2777 }
eac338cf 2778
23209a78 2779 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
0e1862bb 2780 && !bfd_link_pic (info))
eac338cf
PB		 2781 {
2782 /* VxWorks has a second set of relocations for each PLT entry
2783 in executables. They go in a separate relocation section,
2784 which is processed by the kernel loader. */
2785
2786 /* There are two relocations for the initial PLT entry: an
2787 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2788 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2789
25e762b9 2790 if (h->plt.offset == plt_entry_size)
eac338cf
PB		 2791 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2792
2793 /* There are two extra relocations for each subsequent PLT entry:
2794 an R_386_32 relocation for the GOT entry, and an R_386_32
2795 relocation for the PLT entry. */
2796
2797 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2798 }
6725bdbf 2799 }
ced53ee5
AM		 2800 else
2801 {
13f42277 2802 eh->plt_got.offset = (bfd_vma) -1;
51b64d56 2803 h->plt.offset = (bfd_vma) -1;
f5385ebf 2804 h->needs_plt = 0;
ced53ee5 2805 }
6725bdbf
AM		 2806 }
2807 else
2808 {
13f42277 2809 eh->plt_got.offset = (bfd_vma) -1;
51b64d56 2810 h->plt.offset = (bfd_vma) -1;
f5385ebf 2811 h->needs_plt = 0;
6725bdbf
AM		 2812 }
2813
67a4f2b7
AO		 2814 eh->tlsdesc_got = (bfd_vma) -1;
2815
37e55690 2816 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
13ae64f3
JJ		 2817 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2818 if (h->got.refcount > 0
0e1862bb 2819 && bfd_link_executable (info)
13ae64f3 2820 && h->dynindx == -1
37e55690 2821 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
cedb70c5 2822 h->got.offset = (bfd_vma) -1;
13ae64f3 2823 else if (h->got.refcount > 0)
6725bdbf 2824 {
0ac8d2ca 2825 asection *s;
b34976b6 2826 bfd_boolean dyn;
13ae64f3 2827 int tls_type = elf_i386_hash_entry(h)->tls_type;
6725bdbf 2828
5a15f56f
AM		 2829 /* Make sure this symbol is output as a dynamic symbol.
2830 Undefined weak syms won't yet be marked as dynamic. */
2831 if (h->dynindx == -1
aec6b87e
L		 2832 && !h->forced_local
2833 && !resolved_to_zero)
5a15f56f 2834 {
c152c796 2835 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2836 return FALSE;
5a15f56f
AM		 2837 }
2838
6de2ae4a 2839 s = htab->elf.sgot;
67a4f2b7
AO		 2840 if (GOT_TLS_GDESC_P (tls_type))
2841 {
6de2ae4a 2842 eh->tlsdesc_got = htab->elf.sgotplt->size
67a4f2b7 2843 - elf_i386_compute_jump_table_size (htab);
6de2ae4a 2844 htab->elf.sgotplt->size += 8;
67a4f2b7
AO		 2845 h->got.offset = (bfd_vma) -2;
2846 }
2847 if (! GOT_TLS_GDESC_P (tls_type)
2848 || GOT_TLS_GD_P (tls_type))
2849 {
2850 h->got.offset = s->size;
2851 s->size += 4;
2852 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2853 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2854 s->size += 4;
2855 }
ebe50bae 2856 dyn = htab->elf.dynamic_sections_created;
13ae64f3 2857 /* R_386_TLS_IE_32 needs one dynamic relocation,
37e55690
JJ		 2858 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2859 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2860 need two), R_386_TLS_GD needs one if local symbol and two if
aec6b87e
L		 2861 global. No dynamic relocation against resolved undefined weak
2862 symbol in executable. */
37e55690 2863 if (tls_type == GOT_TLS_IE_BOTH)
6de2ae4a 2864 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 2865 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
37e55690 2866 || (tls_type & GOT_TLS_IE))
6de2ae4a 2867 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 2868 else if (GOT_TLS_GD_P (tls_type))
6de2ae4a 2869 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7 2870 else if (! GOT_TLS_GDESC_P (tls_type)
aec6b87e
L		 2871 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2872 && !resolved_to_zero)
67a4f2b7 2873 || h->root.type != bfd_link_hash_undefweak)
0e1862bb 2874 && (bfd_link_pic (info)
ef5aade5 2875 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6de2ae4a 2876 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
67a4f2b7 2877 if (GOT_TLS_GDESC_P (tls_type))
6de2ae4a 2878 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
6725bdbf
AM		 2879 }
2880 else
51b64d56 2881 h->got.offset = (bfd_vma) -1;
6725bdbf 2882
5a15f56f 2883 if (eh->dyn_relocs == NULL)
b34976b6 2884 return TRUE;
5a15f56f 2885
0c715baa
AM		 2886 /* In the shared -Bsymbolic case, discard space allocated for
2887 dynamic pc-relative relocs against symbols which turn out to be
2888 defined in regular objects. For the normal shared case, discard
0ac8d2ca
AM		 2889 space for pc-relative relocs that have become local due to symbol
2890 visibility changes. */
0c715baa 2891
0e1862bb 2892 if (bfd_link_pic (info))
5a15f56f 2893 {
09695f56
AM		 2894 /* The only reloc that uses pc_count is R_386_PC32, which will
2895 appear on a call or on something like ".long foo - .". We
2896 want calls to protected symbols to resolve directly to the
2897 function rather than going via the plt. If people want
2898 function pointer comparisons to work as expected then they
2899 should avoid writing assembly like ".long foo - .". */
2900 if (SYMBOL_CALLS_LOCAL (info, h))
5a15f56f 2901 {
e03a8ed8 2902 struct elf_dyn_relocs **pp;
0c715baa
AM		 2903
2904 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2905 {
c3ce498c
L		 2906 p->count -= p->pc_count;
2907 p->pc_count = 0;
0c715baa
AM		 2908 if (p->count == 0)
2909 *pp = p->next;
2910 else
2911 pp = &p->next;
2912 }
5a15f56f 2913 }
4e795f50 2914
23209a78 2915 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
3348747a 2916 {
e03a8ed8 2917 struct elf_dyn_relocs **pp;
3348747a
NS		 2918 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2919 {
2920 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2921 *pp = p->next;
2922 else
2923 pp = &p->next;
2924 }
2925 }
2926
4e795f50 2927 /* Also discard relocs on undefined weak syms with non-default
aec6b87e 2928 visibility or in PIE. */
22d606e9 2929 if (eh->dyn_relocs != NULL
c353e543 2930 && h->root.type == bfd_link_hash_undefweak)
22d606e9 2931 {
aec6b87e
L		 2932 /* Undefined weak symbol is never bound locally in shared
2933 library. */
2934 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2935 || resolved_to_zero)
2936 {
2937 if (h->non_got_ref)
2938 {
2939 /* Keep dynamic non-GOT/non-PLT relocation so that we
2940 can branch to 0 without PLT. */
2941 struct elf_dyn_relocs **pp;
2942
2943 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2944 if (p->pc_count == 0)
2945 *pp = p->next;
2946 else
2947 {
2948 /* Remove non-R_386_PC32 relocation. */
2949 p->count = p->pc_count;
2950 pp = &p->next;
2951 }
22d606e9 2952
aec6b87e
L		 2953 if (eh->dyn_relocs != NULL)
2954 {
2955 /* Make sure undefined weak symbols are output
2956 as dynamic symbols in PIEs for dynamic non-GOT
2957 non-PLT reloations. */
2958 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2959 return FALSE;
2960 }
2961 }
2962 else
2963 eh->dyn_relocs = NULL;
2964 }
22d606e9
AM		 2965 else if (h->dynindx == -1
2966 && !h->forced_local)
2967 {
2968 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2969 return FALSE;
2970 }
2971 }
0c715baa 2972 }
a23b6845 2973 else if (ELIMINATE_COPY_RELOCS)
0c715baa
AM		 2974 {
2975 /* For the non-shared case, discard space for relocs against
2976 symbols which turn out to need copy relocs or are not
04ebc307
L		 2977 dynamic. Keep dynamic relocations for run-time function
2978 pointer initialization. */
0c715baa 2979
aec6b87e
L		 2980 if ((!h->non_got_ref
2981 || eh->func_pointer_refcount > 0
2982 || (h->root.type == bfd_link_hash_undefweak
2983 && !resolved_to_zero))
f5385ebf
AM		 2984 && ((h->def_dynamic
2985 && !h->def_regular)
ebe50bae 2986 || (htab->elf.dynamic_sections_created
0c715baa
AM		 2987 && (h->root.type == bfd_link_hash_undefweak
2988 || h->root.type == bfd_link_hash_undefined))))
2989 {
2990 /* Make sure this symbol is output as a dynamic symbol.
2991 Undefined weak syms won't yet be marked as dynamic. */
2992 if (h->dynindx == -1
aec6b87e
L		 2993 && !h->forced_local
2994 && !resolved_to_zero)
0c715baa 2995 {
c152c796 2996 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 2997 return FALSE;
0c715baa 2998 }
5a15f56f 2999
0c715baa
AM		 3000 /* If that succeeded, we know we'll be keeping all the
3001 relocs. */
3002 if (h->dynindx != -1)
3003 goto keep;
3004 }
3005
3006 eh->dyn_relocs = NULL;
04ebc307 3007 eh->func_pointer_refcount = 0;
0c715baa 3008
ec338859 3009 keep: ;
5a15f56f
AM		 3010 }
3011
0c715baa
AM		 3012 /* Finally, allocate space. */
3013 for (p = eh->dyn_relocs; p != NULL; p = p->next)
12d0ee4a 3014 {
e7c33416
NC		 3015 asection *sreloc;
3016
cbe950e9 3017 sreloc = elf_section_data (p->sec)->sreloc;
e7c33416
NC		 3018
3019 BFD_ASSERT (sreloc != NULL);
eea6121a 3020 sreloc->size += p->count * sizeof (Elf32_External_Rel);
12d0ee4a
AM		 3021 }
3022
b34976b6 3023 return TRUE;
6725bdbf
AM		 3024}
3025
c25bc9fc
L		 3026/* Allocate space in .plt, .got and associated reloc sections for
3027 local dynamic relocs. */
3028
3029static bfd_boolean
3030elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
3031{
3032 struct elf_link_hash_entry *h
3033 = (struct elf_link_hash_entry *) *slot;
3034
3035 if (h->type != STT_GNU_IFUNC
3036 || !h->def_regular
3037 || !h->ref_regular
3038 || !h->forced_local
3039 || h->root.type != bfd_link_hash_defined)
3040 abort ();
3041
3042 return elf_i386_allocate_dynrelocs (h, inf);
3043}
3044
0c715baa
AM		 3045/* Find any dynamic relocs that apply to read-only sections. */
3046
b34976b6 3047static bfd_boolean
eb4ff4d6 3048elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
0c715baa
AM		 3049{
3050 struct elf_i386_link_hash_entry *eh;
e03a8ed8 3051 struct elf_dyn_relocs *p;
0c715baa 3052
aa715242
L		 3053 /* Skip local IFUNC symbols. */
3054 if (h->forced_local && h->type == STT_GNU_IFUNC)
3055 return TRUE;
3056
0c715baa
AM		 3057 eh = (struct elf_i386_link_hash_entry *) h;
3058 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3059 {
3060 asection *s = p->sec->output_section;
3061
3062 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3063 {
3064 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3065
3066 info->flags |= DF_TEXTREL;
3067
0e1862bb 3068 if ((info->warn_shared_textrel && bfd_link_pic (info))
1952c5cd 3069 || info->error_textrel)
695344c0 3070 /* xgettext:c-format */
1952c5cd 3071 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
b70321a2
L		 3072 p->sec->owner, h->root.root.string,
3073 p->sec);
3074
0c715baa 3075 /* Not an error, just cut short the traversal. */
b34976b6 3076 return FALSE;
0c715baa
AM		 3077 }
3078 }
b34976b6 3079 return TRUE;
0c715baa
AM		 3080}
3081
c175a657 3082/* Convert load via the GOT slot to load immediate. */
daa67607
L		 3083
3084static bfd_boolean
02a86693 3085elf_i386_convert_load (bfd *abfd, asection *sec,
a6af384b 3086 struct bfd_link_info *link_info)
daa67607 3087{
c175a657 3088 struct elf_i386_link_hash_table *htab;
daa67607
L		 3089 Elf_Internal_Shdr *symtab_hdr;
3090 Elf_Internal_Rela *internal_relocs;
3091 Elf_Internal_Rela *irel, *irelend;
3092 bfd_byte *contents;
c175a657 3093 bfd_boolean changed;
daa67607
L		 3094 bfd_signed_vma *local_got_refcounts;
3095
3096 /* Don't even try to convert non-ELF outputs. */
3097 if (!is_elf_hash_table (link_info->hash))
3098 return FALSE;
3099
c1d11331 3100 /* Nothing to do if there is no need or no output. */
daa67607 3101 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
02a86693 3102 || sec->need_convert_load == 0
c8831961 3103 || bfd_is_abs_section (sec->output_section))
daa67607
L		 3104 return TRUE;
3105
3106 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3107
3108 /* Load the relocations for this section. */
3109 internal_relocs = (_bfd_elf_link_read_relocs
3110 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3111 link_info->keep_memory));
3112 if (internal_relocs == NULL)
3113 return FALSE;
3114
c175a657 3115 changed = FALSE;
daa67607 3116 htab = elf_i386_hash_table (link_info);
daa67607
L		 3117 local_got_refcounts = elf_local_got_refcounts (abfd);
3118
3119 /* Get the section contents. */
3120 if (elf_section_data (sec)->this_hdr.contents != NULL)
3121 contents = elf_section_data (sec)->this_hdr.contents;
3122 else
3123 {
3124 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3125 goto error_return;
3126 }
3127
3128 irelend = internal_relocs + sec->reloc_count;
3129 for (irel = internal_relocs; irel < irelend; irel++)
3130 {
3131 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
c175a657 3132 unsigned int r_symndx;
daa67607 3133 struct elf_link_hash_entry *h;
c175a657 3134 bfd_boolean converted;
daa67607 3135
7d4d9709
L		 3136 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3137 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3138 if (r_type != R_386_GOT32X)
daa67607
L		 3139 continue;
3140
c175a657 3141 r_symndx = ELF32_R_SYM (irel->r_info);
02a86693 3142 if (r_symndx < symtab_hdr->sh_info)
c175a657
L		 3143 h = elf_i386_get_local_sym_hash (htab, sec->owner,
3144 (const Elf_Internal_Rela *) irel,
3145 FALSE);
3146 else
02a86693 3147 {
c175a657
L		 3148 h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info];
3149 while (h->root.type == bfd_link_hash_indirect
3150 || h->root.type == bfd_link_hash_warning)
3151 h = (struct elf_link_hash_entry *) h->root.u.i.link;
daa67607
L		 3152 }
3153
02a86693 3154 /* STT_GNU_IFUNC must keep GOT32 relocations. */
c175a657 3155 if (h != NULL && h->type == STT_GNU_IFUNC)
02a86693
L		 3156 continue;
3157
c175a657
L		 3158 converted = FALSE;
3159 if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
3160 irel, h, &converted, link_info))
3161 goto error_return;
bae420ef 3162
c175a657 3163 if (converted)
02a86693 3164 {
c175a657
L		 3165 changed = converted;
3166 if (h)
02a86693 3167 {
c175a657
L		 3168 if (h->got.refcount > 0)
3169 h->got.refcount -= 1;
02a86693 3170 }
c175a657 3171 else
02a86693 3172 {
c175a657
L		 3173 if (local_got_refcounts != NULL
3174 && local_got_refcounts[r_symndx] > 0)
3175 local_got_refcounts[r_symndx] -= 1;
02a86693 3176 }
daa67607
L		 3177 }
3178 }
3179
3180 if (contents != NULL
3181 && elf_section_data (sec)->this_hdr.contents != contents)
3182 {
c175a657 3183 if (!changed && !link_info->keep_memory)
daa67607
L		 3184 free (contents);
3185 else
3186 {
3187 /* Cache the section contents for elf_link_input_bfd. */
3188 elf_section_data (sec)->this_hdr.contents = contents;
3189 }
3190 }
3191
3192 if (elf_section_data (sec)->relocs != internal_relocs)
3193 {
c175a657 3194 if (!changed)
daa67607
L		 3195 free (internal_relocs);
3196 else
3197 elf_section_data (sec)->relocs = internal_relocs;
3198 }
3199
3200 return TRUE;
3201
3202 error_return:
3203 if (contents != NULL
3204 && elf_section_data (sec)->this_hdr.contents != contents)
3205 free (contents);
3206 if (internal_relocs != NULL
3207 && elf_section_data (sec)->relocs != internal_relocs)
3208 free (internal_relocs);
3209 return FALSE;
3210}
3211
252b5132
RH		 3212/* Set the sizes of the dynamic sections. */
3213
b34976b6 3214static bfd_boolean
23209a78 3215elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
252b5132 3216{
6725bdbf 3217 struct elf_i386_link_hash_table *htab;
252b5132
RH		 3218 bfd *dynobj;
3219 asection *s;
b34976b6 3220 bfd_boolean relocs;
0c715baa 3221 bfd *ibfd;
252b5132 3222
6725bdbf 3223 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 3224 if (htab == NULL)
3225 return FALSE;
ebe50bae 3226 dynobj = htab->elf.dynobj;
ffb2e45b
AM		 3227 if (dynobj == NULL)
3228 abort ();
252b5132 3229
0c715baa
AM		 3230 /* Set up .got offsets for local syms, and space for local dynamic
3231 relocs. */
c72f2fb2 3232 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
161d71a6
L		 3233 {
3234 bfd_signed_vma *local_got;
3235 bfd_signed_vma *end_local_got;
13ae64f3 3236 char *local_tls_type;
67a4f2b7 3237 bfd_vma *local_tlsdesc_gotent;
161d71a6
L		 3238 bfd_size_type locsymcount;
3239 Elf_Internal_Shdr *symtab_hdr;
3240 asection *srel;
6725bdbf 3241
0ffa91dd 3242 if (! is_i386_elf (ibfd))
161d71a6 3243 continue;
6725bdbf 3244
0c715baa
AM		 3245 for (s = ibfd->sections; s != NULL; s = s->next)
3246 {
e03a8ed8 3247 struct elf_dyn_relocs *p;
0c715baa 3248
02a86693 3249 if (!elf_i386_convert_load (ibfd, s, info))
daa67607
L		 3250 return FALSE;
3251
e03a8ed8 3252 for (p = ((struct elf_dyn_relocs *)
e81d3500 3253 elf_section_data (s)->local_dynrel);
ec338859
AM		 3254 p != NULL;
3255 p = p->next)
0c715baa 3256 {
ec338859
AM		 3257 if (!bfd_is_abs_section (p->sec)
3258 && bfd_is_abs_section (p->sec->output_section))
3259 {
3260 /* Input section has been discarded, either because
3261 it is a copy of a linkonce section or due to
3262 linker script /DISCARD/, so we'll be discarding
3263 the relocs too. */
3264 }
23209a78 3265 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3348747a
NS		 3266 && strcmp (p->sec->output_section->name,
3267 ".tls_vars") == 0)
3268 {
3269 /* Relocations in vxworks .tls_vars sections are
3270 handled specially by the loader. */
3271 }
248866a8 3272 else if (p->count != 0)
ec338859
AM		 3273 {
3274 srel = elf_section_data (p->sec)->sreloc;
eea6121a 3275 srel->size += p->count * sizeof (Elf32_External_Rel);
4b819e1f
L		 3276 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3277 && (info->flags & DF_TEXTREL) == 0)
b70321a2
L		 3278 {
3279 info->flags |= DF_TEXTREL;
0e1862bb 3280 if ((info->warn_shared_textrel && bfd_link_pic (info))
1952c5cd 3281 || info->error_textrel)
695344c0 3282 /* xgettext:c-format */
1952c5cd 3283 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
b70321a2 3284 p->sec->owner, p->sec);
b70321a2 3285 }
ec338859 3286 }
0c715baa
AM		 3287 }
3288 }
3289
3290 local_got = elf_local_got_refcounts (ibfd);
161d71a6
L		 3291 if (!local_got)
3292 continue;
6725bdbf 3293
0ffa91dd 3294 symtab_hdr = &elf_symtab_hdr (ibfd);
161d71a6
L		 3295 locsymcount = symtab_hdr->sh_info;
3296 end_local_got = local_got + locsymcount;
13ae64f3 3297 local_tls_type = elf_i386_local_got_tls_type (ibfd);
67a4f2b7 3298 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
6de2ae4a
L		 3299 s = htab->elf.sgot;
3300 srel = htab->elf.srelgot;
67a4f2b7
AO		 3301 for (; local_got < end_local_got;
3302 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
161d71a6 3303 {
67a4f2b7 3304 *local_tlsdesc_gotent = (bfd_vma) -1;
161d71a6 3305 if (*local_got > 0)
6725bdbf 3306 {
67a4f2b7
AO		 3307 if (GOT_TLS_GDESC_P (*local_tls_type))
3308 {
6de2ae4a 3309 *local_tlsdesc_gotent = htab->elf.sgotplt->size
67a4f2b7 3310 - elf_i386_compute_jump_table_size (htab);
6de2ae4a 3311 htab->elf.sgotplt->size += 8;
67a4f2b7
AO		 3312 *local_got = (bfd_vma) -2;
3313 }
3314 if (! GOT_TLS_GDESC_P (*local_tls_type)
3315 || GOT_TLS_GD_P (*local_tls_type))
3316 {
3317 *local_got = s->size;
3318 s->size += 4;
3319 if (GOT_TLS_GD_P (*local_tls_type)
3320 || *local_tls_type == GOT_TLS_IE_BOTH)
3321 s->size += 4;
3322 }
0e1862bb 3323 if (bfd_link_pic (info)
67a4f2b7 3324 || GOT_TLS_GD_ANY_P (*local_tls_type)
37e55690
JJ		 3325 || (*local_tls_type & GOT_TLS_IE))
3326 {
3327 if (*local_tls_type == GOT_TLS_IE_BOTH)
eea6121a 3328 srel->size += 2 * sizeof (Elf32_External_Rel);
67a4f2b7
AO		 3329 else if (GOT_TLS_GD_P (*local_tls_type)
3330 || ! GOT_TLS_GDESC_P (*local_tls_type))
eea6121a 3331 srel->size += sizeof (Elf32_External_Rel);
67a4f2b7 3332 if (GOT_TLS_GDESC_P (*local_tls_type))
6de2ae4a 3333 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
37e55690 3334 }
6725bdbf 3335 }
161d71a6
L		 3336 else
3337 *local_got = (bfd_vma) -1;
6725bdbf 3338 }
252b5132 3339 }
6725bdbf 3340
13ae64f3
JJ		 3341 if (htab->tls_ldm_got.refcount > 0)
3342 {
3343 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3344 relocs. */
6de2ae4a
L		 3345 htab->tls_ldm_got.offset = htab->elf.sgot->size;
3346 htab->elf.sgot->size += 8;
3347 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
13ae64f3
JJ		 3348 }
3349 else
3350 htab->tls_ldm_got.offset = -1;
3351
0c715baa
AM		 3352 /* Allocate global sym .plt and .got entries, and space for global
3353 sym dynamic relocs. */
eb4ff4d6 3354 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
252b5132 3355
c25bc9fc
L		 3356 /* Allocate .plt and .got entries, and space for local symbols. */
3357 htab_traverse (htab->loc_hash_table,
3358 elf_i386_allocate_local_dynrelocs,
3359 info);
3360
67a4f2b7
AO		 3361 /* For every jump slot reserved in the sgotplt, reloc_count is
3362 incremented. However, when we reserve space for TLS descriptors,
3363 it's not incremented, so in order to compute the space reserved
3364 for them, it suffices to multiply the reloc count by the jump
e1f98742 3365 slot size.
caa0075c 3366
e1f98742
L		 3367 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3368 so that R_386_IRELATIVE entries come last. */
6de2ae4a 3369 if (htab->elf.srelplt)
e1f98742
L		 3370 {
3371 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
3372 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
3373 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3374 }
3375 else if (htab->elf.irelplt)
3376 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3377
67a4f2b7 3378
a7b16ceb
L		 3379 if (htab->elf.sgotplt)
3380 {
3381 /* Don't allocate .got.plt section if there are no GOT nor PLT
9a2a56cc 3382 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
9d4b2dba
L		 3383 if ((htab->elf.hgot == NULL
3384 || !htab->elf.hgot->ref_regular_nonweak)
e28df02b
L		 3385 && (htab->elf.sgotplt->size
3386 == get_elf_backend_data (output_bfd)->got_header_size)
a7b16ceb
L		 3387 && (htab->elf.splt == NULL
3388 || htab->elf.splt->size == 0)
3389 && (htab->elf.sgot == NULL
3390 || htab->elf.sgot->size == 0)
3391 && (htab->elf.iplt == NULL
3392 || htab->elf.iplt->size == 0)
3393 && (htab->elf.igotplt == NULL
3394 || htab->elf.igotplt->size == 0))
3395 htab->elf.sgotplt->size = 0;
3396 }
3397
9a2a56cc
AM		 3398
3399 if (htab->plt_eh_frame != NULL
3400 && htab->elf.splt != NULL
3401 && htab->elf.splt->size != 0
3402 && !bfd_is_abs_section (htab->elf.splt->output_section)
3403 && _bfd_elf_eh_frame_present (info))
3404 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
3405
5a15f56f
AM		 3406 /* We now have determined the sizes of the various dynamic sections.
3407 Allocate memory for them. */
b34976b6 3408 relocs = FALSE;
252b5132
RH		 3409 for (s = dynobj->sections; s != NULL; s = s->next)
3410 {
eac338cf
PB		 3411 bfd_boolean strip_section = TRUE;
3412
252b5132
RH		 3413 if ((s->flags & SEC_LINKER_CREATED) == 0)
3414 continue;
3415
6de2ae4a 3416 if (s == htab->elf.splt
9a2a56cc 3417 || s == htab->elf.sgot)
252b5132 3418 {
6725bdbf
AM		 3419 /* Strip this section if we don't need it; see the
3420 comment below. */
eac338cf
PB		 3421 /* We'd like to strip these sections if they aren't needed, but if
3422 we've exported dynamic symbols from them we must leave them.
3423 It's too late to tell BFD to get rid of the symbols. */
3424
7325306f 3425 if (htab->elf.hplt != NULL)
eac338cf 3426 strip_section = FALSE;
252b5132 3427 }
9a2a56cc
AM		 3428 else if (s == htab->elf.sgotplt
3429 || s == htab->elf.iplt
3430 || s == htab->elf.igotplt
dd7e64d4 3431 || s == htab->plt_got
9a2a56cc
AM		 3432 || s == htab->plt_eh_frame
3433 || s == htab->sdynbss)
3434 {
3435 /* Strip these too. */
3436 }
0112cd26 3437 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
252b5132 3438 {
6de2ae4a
L		 3439 if (s->size != 0
3440 && s != htab->elf.srelplt
3441 && s != htab->srelplt2)
b34976b6 3442 relocs = TRUE;
252b5132 3443
0ac8d2ca
AM		 3444 /* We use the reloc_count field as a counter if we need
3445 to copy relocs into the output file. */
5ae0bfb6 3446 s->reloc_count = 0;
252b5132 3447 }
6725bdbf 3448 else
252b5132
RH		 3449 {
3450 /* It's not one of our sections, so don't allocate space. */
3451 continue;
3452 }
3453
c456f082 3454 if (s->size == 0)
252b5132 3455 {
0ac8d2ca
AM		 3456 /* If we don't need this section, strip it from the
3457 output file. This is mostly to handle .rel.bss and
3458 .rel.plt. We must create both sections in
3459 create_dynamic_sections, because they must be created
3460 before the linker maps input sections to output
3461 sections. The linker does that before
3462 adjust_dynamic_symbol is called, and it is that
3463 function which decides whether anything needs to go
3464 into these sections. */
c456f082
AM		 3465 if (strip_section)
3466 s->flags |= SEC_EXCLUDE;
252b5132
RH		 3467 continue;
3468 }
3469
c456f082
AM		 3470 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3471 continue;
3472
f69da49f
AM		 3473 /* Allocate memory for the section contents. We use bfd_zalloc
3474 here in case unused entries are not reclaimed before the
3475 section's contents are written out. This should not happen,
3476 but this way if it does, we get a R_386_NONE reloc instead
3477 of garbage. */
a50b1753 3478 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
6725bdbf 3479 if (s->contents == NULL)
b34976b6 3480 return FALSE;
252b5132
RH		 3481 }
3482
e41b3a13 3483 if (htab->plt_eh_frame != NULL
9a2a56cc
AM		 3484 && htab->plt_eh_frame->contents != NULL)
3485 {
3486 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
3487 sizeof (elf_i386_eh_frame_plt));
3488 bfd_put_32 (dynobj, htab->elf.splt->size,
3489 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3490 }
e41b3a13 3491
ebe50bae 3492 if (htab->elf.dynamic_sections_created)
252b5132
RH		 3493 {
3494 /* Add some entries to the .dynamic section. We fill in the
3495 values later, in elf_i386_finish_dynamic_sections, but we
3496 must add the entries now so that we get the correct size for
3497 the .dynamic section. The DT_DEBUG entry is filled in by the
3498 dynamic linker and used by the debugger. */
dc810e39 3499#define add_dynamic_entry(TAG, VAL) \
5a580b3a 3500 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 3501
0e1862bb 3502 if (bfd_link_executable (info))
252b5132 3503 {
dc810e39 3504 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 3505 return FALSE;
252b5132
RH		 3506 }
3507
6de2ae4a 3508 if (htab->elf.splt->size != 0)
252b5132 3509 {
7c1e8d3e
L		 3510 /* DT_PLTGOT is used by prelink even if there is no PLT
3511 relocation. */
3512 if (!add_dynamic_entry (DT_PLTGOT, 0))
b34976b6 3513 return FALSE;
7c1e8d3e
L		 3514
3515 if (htab->elf.srelplt->size != 0)
3516 {
3517 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3518 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3519 || !add_dynamic_entry (DT_JMPREL, 0))
3520 return FALSE;
3521 }
252b5132
RH		 3522 }
3523
3524 if (relocs)
3525 {
dc810e39
AM		 3526 if (!add_dynamic_entry (DT_REL, 0)
3527 || !add_dynamic_entry (DT_RELSZ, 0)
3528 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
b34976b6 3529 return FALSE;
252b5132 3530
0c715baa
AM		 3531 /* If any dynamic relocs apply to a read-only section,
3532 then we need a DT_TEXTREL entry. */
248866a8 3533 if ((info->flags & DF_TEXTREL) == 0)
eb4ff4d6
L		 3534 elf_link_hash_traverse (&htab->elf,
3535 elf_i386_readonly_dynrelocs, info);
0c715baa
AM		 3536
3537 if ((info->flags & DF_TEXTREL) != 0)
3538 {
2df3368d 3539 if (htab->readonly_dynrelocs_against_ifunc)
8efa2874
L		 3540 {
3541 info->callbacks->einfo
3542 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3543 bfd_set_error (bfd_error_bad_value);
3544 return FALSE;
3545 }
3546
0c715baa 3547 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 3548 return FALSE;
0c715baa 3549 }
252b5132 3550 }
23209a78 3551 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
7a2b07ff
NS		 3552 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3553 return FALSE;
252b5132 3554 }
dc810e39 3555#undef add_dynamic_entry
252b5132 3556
b34976b6 3557 return TRUE;
252b5132
RH		 3558}
3559
67a4f2b7
AO		 3560static bfd_boolean
3561elf_i386_always_size_sections (bfd *output_bfd,
3562 struct bfd_link_info *info)
3563{
3564 asection *tls_sec = elf_hash_table (info)->tls_sec;
3565
3566 if (tls_sec)
3567 {
3568 struct elf_link_hash_entry *tlsbase;
3569
3570 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3571 "_TLS_MODULE_BASE_",
3572 FALSE, FALSE, FALSE);
3573
3574 if (tlsbase && tlsbase->type == STT_TLS)
3575 {
4dfe6ac6 3576 struct elf_i386_link_hash_table *htab;
67a4f2b7
AO		 3577 struct bfd_link_hash_entry *bh = NULL;
3578 const struct elf_backend_data *bed
3579 = get_elf_backend_data (output_bfd);
3580
4dfe6ac6
NC		 3581 htab = elf_i386_hash_table (info);
3582 if (htab == NULL)
3583 return FALSE;
3584
67a4f2b7
AO		 3585 if (!(_bfd_generic_link_add_one_symbol
3586 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3587 tls_sec, 0, NULL, FALSE,
3588 bed->collect, &bh)))
3589 return FALSE;
9f03412a 3590
4dfe6ac6 3591 htab->tls_module_base = bh;
9f03412a 3592
67a4f2b7
AO		 3593 tlsbase = (struct elf_link_hash_entry *)bh;
3594 tlsbase->def_regular = 1;
3595 tlsbase->other = STV_HIDDEN;
576fa883 3596 tlsbase->root.linker_def = 1;
67a4f2b7
AO		 3597 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3598 }
3599 }
3600
3601 return TRUE;
3602}
3603
38701953
AM		 3604/* Set the correct type for an x86 ELF section. We do this by the
3605 section name, which is a hack, but ought to work. */
3606
b34976b6 3607static bfd_boolean
55fd94b0
AM		 3608elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3609 Elf_Internal_Shdr *hdr,
3610 asection *sec)
38701953 3611{
91d6fa6a 3612 const char *name;
38701953
AM		 3613
3614 name = bfd_get_section_name (abfd, sec);
3615
3616 /* This is an ugly, but unfortunately necessary hack that is
3617 needed when producing EFI binaries on x86. It tells
3618 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3619 containing ELF relocation info. We need this hack in order to
3620 be able to generate ELF binaries that can be translated into
3621 EFI applications (which are essentially COFF objects). Those
3622 files contain a COFF ".reloc" section inside an ELFNN object,
3623 which would normally cause BFD to segfault because it would
3624 attempt to interpret this section as containing relocation
3625 entries for section "oc". With this hack enabled, ".reloc"
3626 will be treated as a normal data section, which will avoid the
3627 segfault. However, you won't be able to create an ELFNN binary
3628 with a section named "oc" that needs relocations, but that's
3629 the kind of ugly side-effects you get when detecting section
3630 types based on their names... In practice, this limitation is
3631 unlikely to bite. */
3632 if (strcmp (name, ".reloc") == 0)
3633 hdr->sh_type = SHT_PROGBITS;
3634
b34976b6 3635 return TRUE;
38701953
AM		 3636}
3637
9f03412a
AO		 3638/* _TLS_MODULE_BASE_ needs to be treated especially when linking
3639 executables. Rather than setting it to the beginning of the TLS
3640 section, we have to set it to the end. This function may be called
3641 multiple times, it is idempotent. */
3642
3643static void
eb4ff4d6 3644elf_i386_set_tls_module_base (struct bfd_link_info *info)
9f03412a 3645{
4dfe6ac6 3646 struct elf_i386_link_hash_table *htab;
9f03412a
AO		 3647 struct bfd_link_hash_entry *base;
3648
0e1862bb 3649 if (!bfd_link_executable (info))
9f03412a
AO		 3650 return;
3651
4dfe6ac6
NC		 3652 htab = elf_i386_hash_table (info);
3653 if (htab == NULL)
3654 return;
9f03412a 3655
4dfe6ac6
NC		 3656 base = htab->tls_module_base;
3657 if (base == NULL)
9f03412a
AO		 3658 return;
3659
4dfe6ac6 3660 base->u.def.value = htab->elf.tls_size;
9f03412a
AO		 3661}
3662
13ae64f3
JJ		 3663/* Return the base VMA address which should be subtracted from real addresses
3664 when resolving @dtpoff relocation.
3665 This is PT_TLS segment p_vaddr. */
3666
3667static bfd_vma
eb4ff4d6 3668elf_i386_dtpoff_base (struct bfd_link_info *info)
13ae64f3 3669{
e1918d23
AM		 3670 /* If tls_sec is NULL, we should have signalled an error already. */
3671 if (elf_hash_table (info)->tls_sec == NULL)
6a30718d 3672 return 0;
e1918d23 3673 return elf_hash_table (info)->tls_sec->vma;
13ae64f3
JJ		 3674}
3675
3676/* Return the relocation value for @tpoff relocation
3677 if STT_TLS virtual address is ADDRESS. */
3678
3679static bfd_vma
eb4ff4d6 3680elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
13ae64f3 3681{
e1918d23 3682 struct elf_link_hash_table *htab = elf_hash_table (info);
7dc98aea
RO		 3683 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3684 bfd_vma static_tls_size;
13ae64f3 3685
e1918d23
AM		 3686 /* If tls_sec is NULL, we should have signalled an error already. */
3687 if (htab->tls_sec == NULL)
6a30718d 3688 return 0;
7dc98aea
RO		 3689
3690 /* Consider special static TLS alignment requirements. */
3691 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3692 return static_tls_size + htab->tls_sec->vma - address;
13ae64f3
JJ		 3693}
3694
252b5132
RH		 3695/* Relocate an i386 ELF section. */
3696
b34976b6 3697static bfd_boolean
55fd94b0
AM		 3698elf_i386_relocate_section (bfd *output_bfd,
3699 struct bfd_link_info *info,
3700 bfd *input_bfd,
3701 asection *input_section,
3702 bfd_byte *contents,
3703 Elf_Internal_Rela *relocs,
3704 Elf_Internal_Sym *local_syms,
3705 asection **local_sections)
252b5132 3706{
6725bdbf 3707 struct elf_i386_link_hash_table *htab;
252b5132
RH		 3708 Elf_Internal_Shdr *symtab_hdr;
3709 struct elf_link_hash_entry **sym_hashes;
3710 bfd_vma *local_got_offsets;
67a4f2b7 3711 bfd_vma *local_tlsdesc_gotents;
252b5132 3712 Elf_Internal_Rela *rel;
60f2e42e 3713 Elf_Internal_Rela *wrel;
252b5132 3714 Elf_Internal_Rela *relend;
3348747a 3715 bfd_boolean is_vxworks_tls;
25e762b9 3716 unsigned plt_entry_size;
252b5132 3717
0ffa91dd 3718 BFD_ASSERT (is_i386_elf (input_bfd));
6bbec505 3719
c337a162
L		 3720 /* Skip if check_relocs failed. */
3721 if (input_section->check_relocs_failed)
3722 return FALSE;
3723
6725bdbf 3724 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 3725 if (htab == NULL)
3726 return FALSE;
0ffa91dd 3727 symtab_hdr = &elf_symtab_hdr (input_bfd);
252b5132
RH		 3728 sym_hashes = elf_sym_hashes (input_bfd);
3729 local_got_offsets = elf_local_got_offsets (input_bfd);
67a4f2b7 3730 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3348747a
NS		 3731 /* We have to handle relocations in vxworks .tls_vars sections
3732 specially, because the dynamic loader is 'weird'. */
23209a78 3733 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
0e1862bb 3734 && bfd_link_pic (info)
3348747a
NS		 3735 && !strcmp (input_section->output_section->name,
3736 ".tls_vars"));
252b5132 3737
eb4ff4d6 3738 elf_i386_set_tls_module_base (info);
9f03412a 3739
25e762b9
RM		 3740 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3741
60f2e42e 3742 rel = wrel = relocs;
252b5132 3743 relend = relocs + input_section->reloc_count;
60f2e42e 3744 for (; rel < relend; wrel++, rel++)
252b5132 3745 {
13ae64f3 3746 unsigned int r_type;
252b5132
RH		 3747 reloc_howto_type *howto;
3748 unsigned long r_symndx;
3749 struct elf_link_hash_entry *h;
dd7e64d4 3750 struct elf_i386_link_hash_entry *eh;
252b5132
RH		 3751 Elf_Internal_Sym *sym;
3752 asection *sec;
dd7e64d4 3753 bfd_vma off, offplt, plt_offset;
252b5132 3754 bfd_vma relocation;
b34976b6 3755 bfd_boolean unresolved_reloc;
252b5132 3756 bfd_reloc_status_type r;
1b452ec6 3757 unsigned int indx;
13ae64f3 3758 int tls_type;
1788fc08 3759 bfd_vma st_size;
dd7e64d4 3760 asection *resolved_plt;
aec6b87e 3761 bfd_boolean resolved_to_zero;
252b5132
RH		 3762
3763 r_type = ELF32_R_TYPE (rel->r_info);
55fd94b0
AM		 3764 if (r_type == R_386_GNU_VTINHERIT
3765 || r_type == R_386_GNU_VTENTRY)
18954b29
L		 3766 {
3767 if (wrel != rel)
3768 *wrel = *rel;
3769 continue;
3770 }
dc47f327 3771
55fd94b0 3772 if ((indx = r_type) >= R_386_standard
13ae64f3
JJ		 3773 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3774 >= R_386_ext - R_386_standard)
3775 && ((indx = r_type - R_386_tls_offset) - R_386_ext
c74be520 3776 >= R_386_ext2 - R_386_ext))
252b5132 3777 {
4eca0228 3778 _bfd_error_handler
695344c0 3779 /* xgettext:c-format */
d003868e
AM		 3780 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3781 input_bfd, input_section, r_type);
252b5132 3782 bfd_set_error (bfd_error_bad_value);
b34976b6 3783 return FALSE;
252b5132 3784 }
1b452ec6 3785 howto = elf_howto_table + indx;
252b5132
RH		 3786
3787 r_symndx = ELF32_R_SYM (rel->r_info);
252b5132
RH		 3788 h = NULL;
3789 sym = NULL;
3790 sec = NULL;
b34976b6 3791 unresolved_reloc = FALSE;
252b5132
RH		 3792 if (r_symndx < symtab_hdr->sh_info)
3793 {
3794 sym = local_syms + r_symndx;
3795 sec = local_sections[r_symndx];
3796 relocation = (sec->output_section->vma
3797 + sec->output_offset
3798 + sym->st_value);
1788fc08 3799 st_size = sym->st_size;
ab96bf03
AM		 3800
3801 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3802 && ((sec->flags & SEC_MERGE) != 0
0e1862bb 3803 || (bfd_link_relocatable (info)
ab96bf03 3804 && sec->output_offset != 0)))
f8df10f4 3805 {
f8df10f4 3806 bfd_vma addend;
4a335f3d 3807 bfd_byte *where = contents + rel->r_offset;
f8df10f4 3808
4a335f3d 3809 switch (howto->size)
f8df10f4 3810 {
4a335f3d
AM		 3811 case 0:
3812 addend = bfd_get_8 (input_bfd, where);
3813 if (howto->pc_relative)
3814 {
3815 addend = (addend ^ 0x80) - 0x80;
3816 addend += 1;
3817 }
3818 break;
3819 case 1:
3820 addend = bfd_get_16 (input_bfd, where);
3821 if (howto->pc_relative)
3822 {
3823 addend = (addend ^ 0x8000) - 0x8000;
3824 addend += 2;
3825 }
3826 break;
3827 case 2:
3828 addend = bfd_get_32 (input_bfd, where);
3829 if (howto->pc_relative)
3830 {
3831 addend = (addend ^ 0x80000000) - 0x80000000;
3832 addend += 4;
3833 }
3834 break;
3835 default:
3836 abort ();
f8df10f4
JJ		 3837 }
3838
0e1862bb 3839 if (bfd_link_relocatable (info))
ab96bf03
AM		 3840 addend += sec->output_offset;
3841 else
3842 {
3843 asection *msec = sec;
3844 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3845 addend);
3846 addend -= relocation;
3847 addend += msec->output_section->vma + msec->output_offset;
3848 }
4a335f3d
AM		 3849
3850 switch (howto->size)
3851 {
3852 case 0:
16a10388 3853 /* FIXME: overflow checks. */
4a335f3d
AM		 3854 if (howto->pc_relative)
3855 addend -= 1;
3856 bfd_put_8 (input_bfd, addend, where);
4a335f3d
AM		 3857 break;
3858 case 1:
3859 if (howto->pc_relative)
3860 addend -= 2;
3861 bfd_put_16 (input_bfd, addend, where);
4a335f3d
AM		 3862 break;
3863 case 2:
3864 if (howto->pc_relative)
3865 addend -= 4;
3866 bfd_put_32 (input_bfd, addend, where);
3867 break;
3868 }
f8df10f4 3869 }
0e1862bb 3870 else if (!bfd_link_relocatable (info)
1f85278f 3871 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
c25bc9fc
L		 3872 {
3873 /* Relocate against local STT_GNU_IFUNC symbol. */
9fff0c39
L		 3874 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3875 FALSE);
c25bc9fc
L		 3876 if (h == NULL)
3877 abort ();
3878
23209a78 3879 /* Set STT_GNU_IFUNC symbol value. */
c25bc9fc
L		 3880 h->root.u.def.value = sym->st_value;
3881 h->root.u.def.section = sec;
3882 }
252b5132
RH		 3883 }
3884 else
3885 {
3d540e93 3886 bfd_boolean warned ATTRIBUTE_UNUSED;
62d887d4 3887 bfd_boolean ignored ATTRIBUTE_UNUSED;
ffb2e45b 3888
b2a8e766
AM		 3889 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3890 r_symndx, symtab_hdr, sym_hashes,
3891 h, sec, relocation,
62d887d4 3892 unresolved_reloc, warned, ignored);
1788fc08 3893 st_size = h->size;
252b5132
RH		 3894 }
3895
dbaa2011 3896 if (sec != NULL && discarded_section (sec))
60f2e42e
L		 3897 {
3898 _bfd_clear_contents (howto, input_bfd, input_section,
3899 contents + rel->r_offset);
3900 wrel->r_offset = rel->r_offset;
3901 wrel->r_info = 0;
3902 wrel->r_addend = 0;
3903
3904 /* For ld -r, remove relocations in debug sections against
3905 sections defined in discarded sections. Not done for
3906 eh_frame editing code expects to be present. */
3907 if (bfd_link_relocatable (info)
3908 && (input_section->flags & SEC_DEBUGGING))
3909 wrel--;
3910
3911 continue;
3912 }
9635fe29 3913
0e1862bb 3914 if (bfd_link_relocatable (info))
2d5da473
L		 3915 {
3916 if (wrel != rel)
3917 *wrel = *rel;
3918 continue;
3919 }
ab96bf03 3920
cbe950e9
L		 3921 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3922 it here if it is defined in a non-shared object. */
3923 if (h != NULL
3924 && h->type == STT_GNU_IFUNC
3925 && h->def_regular)
3926 {
3927 asection *plt, *gotplt, *base_got;
3928 bfd_vma plt_index;
4c544807 3929 const char *name;
cbe950e9 3930
97dc35c8
L		 3931 if ((input_section->flags & SEC_ALLOC) == 0)
3932 {
3933 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3934 sections because such sections are not SEC_ALLOC and
3935 thus ld.so will not process them. */
3936 if ((input_section->flags & SEC_DEBUGGING) != 0)
0eace210 3937 continue;
97dc35c8
L		 3938 abort ();
3939 }
cbe950e9
L		 3940
3941 /* STT_GNU_IFUNC symbol must go through PLT. */
6de2ae4a 3942 if (htab->elf.splt != NULL)
cbe950e9 3943 {
6de2ae4a
L		 3944 plt = htab->elf.splt;
3945 gotplt = htab->elf.sgotplt;
cbe950e9
L		 3946 }
3947 else
3948 {
6de2ae4a
L		 3949 plt = htab->elf.iplt;
3950 gotplt = htab->elf.igotplt;
cbe950e9
L		 3951 }
3952
cbe950e9
L		 3953 switch (r_type)
3954 {
3955 default:
233cc9c1 3956 break;
cbe950e9
L		 3957
3958 case R_386_GOT32:
02a86693 3959 case R_386_GOT32X:
6de2ae4a 3960 base_got = htab->elf.sgot;
cbe950e9
L		 3961 off = h->got.offset;
3962
7afd84dc 3963 if (base_got == NULL)
cbe950e9
L		 3964 abort ();
3965
7afd84dc 3966 if (off == (bfd_vma) -1)
cbe950e9 3967 {
7afd84dc
L		 3968 /* We can't use h->got.offset here to save state, or
3969 even just remember the offset, as finish_dynamic_symbol
3970 would use that as offset into .got. */
6bbec505 3971
233cc9c1
L		 3972 if (h->plt.offset == (bfd_vma) -1)
3973 abort ();
3974
6de2ae4a 3975 if (htab->elf.splt != NULL)
7afd84dc 3976 {
25e762b9 3977 plt_index = h->plt.offset / plt_entry_size - 1;
7afd84dc 3978 off = (plt_index + 3) * 4;
6de2ae4a 3979 base_got = htab->elf.sgotplt;
7afd84dc 3980 }
cbe950e9
L		 3981 else
3982 {
25e762b9 3983 plt_index = h->plt.offset / plt_entry_size;
7afd84dc 3984 off = plt_index * 4;
6de2ae4a 3985 base_got = htab->elf.igotplt;
7afd84dc
L		 3986 }
3987
3988 if (h->dynindx == -1
3989 || h->forced_local
3990 || info->symbolic)
3991 {
3992 /* This references the local defitionion. We must
3993 initialize this entry in the global offset table.
3994 Since the offset must always be a multiple of 8,
3995 we use the least significant bit to record
3996 whether we have initialized it already.
3997
3998 When doing a dynamic link, we create a .rela.got
3999 relocation entry to initialize the value. This
4000 is done in the finish_dynamic_symbol routine. */
4001 if ((off & 1) != 0)
4002 off &= ~1;
4003 else
4004 {
4005 bfd_put_32 (output_bfd, relocation,
4006 base_got->contents + off);
4007 h->got.offset |= 1;
4008 }
cbe950e9 4009 }
cbe950e9 4010
7afd84dc 4011 relocation = off;
7afd84dc
L		 4012 }
4013 else
ca8c86ef
L		 4014 relocation = (base_got->output_section->vma
4015 + base_got->output_offset + off
4016 - gotplt->output_section->vma
4017 - gotplt->output_offset);
4018
712ec279
L		 4019 if ((*(contents + rel->r_offset - 1) & 0xc7) == 0x5)
4020 {
4021 if (bfd_link_pic (info))
4022 goto disallow_got32;
4023
4024 /* Add the GOT base if there is no base register. */
4025 relocation += (gotplt->output_section->vma
4026 + gotplt->output_offset);
4027 }
4028 else if (htab->elf.splt == NULL)
4029 {
4030 /* Adjust for static executables. */
4031 relocation += gotplt->output_offset;
4032 }
0018b0a3 4033
cbe950e9 4034 goto do_relocation;
233cc9c1
L		 4035 }
4036
4037 if (h->plt.offset == (bfd_vma) -1)
4038 {
4039 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4040 if (r_type == R_386_32
4041 && (input_section->flags & SEC_CODE) == 0)
4042 goto do_ifunc_pointer;
4043 goto bad_ifunc_reloc;
4044 }
4045
4046 relocation = (plt->output_section->vma
4047 + plt->output_offset + h->plt.offset);
4048
4049 switch (r_type)
4050 {
4051 default:
4052bad_ifunc_reloc:
4053 if (h->root.root.string)
4054 name = h->root.root.string;
4055 else
4056 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4057 NULL);
4eca0228 4058 _bfd_error_handler
695344c0 4059 /* xgettext:c-format */
233cc9c1
L		 4060 (_("%B: relocation %s against STT_GNU_IFUNC "
4061 "symbol `%s' isn't supported"), input_bfd,
4062 howto->name, name);
4063 bfd_set_error (bfd_error_bad_value);
4064 return FALSE;
4065
4066 case R_386_32:
4067 /* Generate dynamic relcoation only when there is a
4068 non-GOT reference in a shared object. */
4069 if ((bfd_link_pic (info) && h->non_got_ref)
4070 || h->plt.offset == (bfd_vma) -1)
4071 {
4072 Elf_Internal_Rela outrel;
4073 asection *sreloc;
4074 bfd_vma offset;
4075
4076do_ifunc_pointer:
4077 /* Need a dynamic relocation to get the real function
4078 adddress. */
4079 offset = _bfd_elf_section_offset (output_bfd,
4080 info,
4081 input_section,
4082 rel->r_offset);
4083 if (offset == (bfd_vma) -1
4084 || offset == (bfd_vma) -2)
4085 abort ();
4086
4087 outrel.r_offset = (input_section->output_section->vma
4088 + input_section->output_offset
4089 + offset);
4090
4091 if (h->dynindx == -1
4092 || h->forced_local
4093 || bfd_link_executable (info))
4094 {
4095 /* This symbol is resolved locally. */
4096 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
4097 bfd_put_32 (output_bfd,
4098 (h->root.u.def.value
4099 + h->root.u.def.section->output_section->vma
4100 + h->root.u.def.section->output_offset),
4101 contents + offset);
4102 }
4103 else
4104 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4105
4106 /* Dynamic relocations are stored in
4107 1. .rel.ifunc section in PIC object.
4108 2. .rel.got section in dynamic executable.
4109 3. .rel.iplt section in static executable. */
4110 if (bfd_link_pic (info))
4111 sreloc = htab->elf.irelifunc;
4112 else if (htab->elf.splt != NULL)
4113 sreloc = htab->elf.srelgot;
4114 else
4115 sreloc = htab->elf.irelplt;
4116 elf_append_rel (output_bfd, sreloc, &outrel);
4117
4118 /* If this reloc is against an external symbol, we
4119 do not want to fiddle with the addend. Otherwise,
4120 we need to include the symbol value so that it
4121 becomes an addend for the dynamic reloc. For an
4122 internal symbol, we have updated addend. */
4123 continue;
4124 }
4125 /* FALLTHROUGH */
4126 case R_386_PC32:
4127 case R_386_PLT32:
4128 goto do_relocation;
cbe950e9
L		 4129
4130 case R_386_GOTOFF:
4131 relocation -= (gotplt->output_section->vma
4132 + gotplt->output_offset);
4133 goto do_relocation;
4134 }
4135 }
4136
04ebc307 4137 eh = (struct elf_i386_link_hash_entry *) h;
aec6b87e 4138 resolved_to_zero = (eh != NULL
e62b9723
L		 4139 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
4140 eh->has_got_reloc,
4141 eh));
aec6b87e 4142
252b5132
RH		 4143 switch (r_type)
4144 {
02a86693
L		 4145 case R_386_GOT32X:
4146 /* Avoid optimizing _DYNAMIC since ld.so may use its
4147 link-time address. */
4148 if (h == htab->elf.hdynamic)
4149 goto r_386_got32;
4150
4151 if (bfd_link_pic (info))
4152 {
4153 /* It is OK to convert mov to lea and convert indirect
4154 branch to direct branch. It is OK to convert adc,
4155 add, and, cmp, or, sbb, sub, test, xor only when PIC
4156 is false. */
02e2aef8
L		 4157 unsigned int opcode, addend;
4158 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4159 if (addend != 0)
4160 goto r_386_got32;
4161 opcode = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
02a86693
L		 4162 if (opcode != 0x8b && opcode != 0xff)
4163 goto r_386_got32;
4164 }
4165
4166 /* Resolve "mov GOT[(%reg)], %reg",
4167 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4168 and "binop foo@GOT[(%reg)], %reg". */
4169 if (h == NULL
4170 || (h->plt.offset == (bfd_vma) -1
4171 && h->got.offset == (bfd_vma) -1)
4172 || htab->elf.sgotplt == NULL)
4173 abort ();
4174
4175 offplt = (htab->elf.sgotplt->output_section->vma
4176 + htab->elf.sgotplt->output_offset);
4177
4178 /* It is relative to .got.plt section. */
4179 if (h->got.offset != (bfd_vma) -1)
32875eb1
L		 4180 /* Use GOT entry. Mask off the least significant bit in
4181 GOT offset which may be set by R_386_GOT32 processing
4182 below. */
02a86693
L		 4183 relocation = (htab->elf.sgot->output_section->vma
4184 + htab->elf.sgot->output_offset
32875eb1 4185 + (h->got.offset & ~1) - offplt);
02a86693
L		 4186 else
4187 /* Use GOTPLT entry. */
4188 relocation = (h->plt.offset / plt_entry_size - 1 + 3) * 4;
4189
4190 if (!bfd_link_pic (info))
4191 {
4192 /* If not PIC, add the .got.plt section address for
a3718e9e 4193 baseless addressing. */
02a86693 4194 unsigned int modrm;
02e2aef8 4195 modrm = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
02a86693
L		 4196 if ((modrm & 0xc7) == 0x5)
4197 relocation += offplt;
4198 }
4199
4200 unresolved_reloc = FALSE;
4201 break;
4202
252b5132 4203 case R_386_GOT32:
02a86693 4204r_386_got32:
252b5132
RH		 4205 /* Relocation is to the entry for this symbol in the global
4206 offset table. */
6de2ae4a 4207 if (htab->elf.sgot == NULL)
ffb2e45b 4208 abort ();
252b5132
RH		 4209
4210 if (h != NULL)
4211 {
b34976b6 4212 bfd_boolean dyn;
252b5132
RH		 4213
4214 off = h->got.offset;
ebe50bae 4215 dyn = htab->elf.dynamic_sections_created;
0e1862bb
L		 4216 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4217 bfd_link_pic (info),
4218 h)
4219 || (bfd_link_pic (info)
586119b3 4220 && SYMBOL_REFERENCES_LOCAL (info, h))
ef5aade5
L		 4221 || (ELF_ST_VISIBILITY (h->other)
4222 && h->root.type == bfd_link_hash_undefweak))
252b5132
RH		 4223 {
4224 /* This is actually a static link, or it is a
4225 -Bsymbolic link and the symbol is defined
4226 locally, or the symbol was forced to be local
4227 because of a version file. We must initialize
4228 this entry in the global offset table. Since the
4229 offset must always be a multiple of 4, we use the
4230 least significant bit to record whether we have
4231 initialized it already.
4232
4233 When doing a dynamic link, we create a .rel.got
4234 relocation entry to initialize the value. This
4235 is done in the finish_dynamic_symbol routine. */
4236 if ((off & 1) != 0)
4237 off &= ~1;
4238 else
4239 {
4240 bfd_put_32 (output_bfd, relocation,
6de2ae4a 4241 htab->elf.sgot->contents + off);
252b5132
RH		 4242 h->got.offset |= 1;
4243 }
4244 }
8c694914 4245 else
b34976b6 4246 unresolved_reloc = FALSE;
252b5132
RH		 4247 }
4248 else
4249 {
ffb2e45b
AM		 4250 if (local_got_offsets == NULL)
4251 abort ();
252b5132
RH		 4252
4253 off = local_got_offsets[r_symndx];
4254
4255 /* The offset must always be a multiple of 4. We use
83be169b
AM		 4256 the least significant bit to record whether we have
4257 already generated the necessary reloc. */
252b5132
RH		 4258 if ((off & 1) != 0)
4259 off &= ~1;
4260 else
4261 {
6725bdbf 4262 bfd_put_32 (output_bfd, relocation,
6de2ae4a 4263 htab->elf.sgot->contents + off);
252b5132 4264
0e1862bb 4265 if (bfd_link_pic (info))
252b5132 4266 {
947216bf
AM		 4267 asection *s;
4268 Elf_Internal_Rela outrel;
252b5132 4269
6de2ae4a 4270 s = htab->elf.srelgot;
947216bf 4271 if (s == NULL)
ffb2e45b 4272 abort ();
252b5132 4273
6de2ae4a
L		 4274 outrel.r_offset = (htab->elf.sgot->output_section->vma
4275 + htab->elf.sgot->output_offset
252b5132
RH		 4276 + off);
4277 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
59d6ffb2 4278 elf_append_rel (output_bfd, s, &outrel);
252b5132
RH		 4279 }
4280
4281 local_got_offsets[r_symndx] |= 1;
4282 }
252b5132
RH		 4283 }
4284
ffb2e45b
AM		 4285 if (off >= (bfd_vma) -2)
4286 abort ();
4287
74d7f0aa
L		 4288 relocation = (htab->elf.sgot->output_section->vma
4289 + htab->elf.sgot->output_offset + off);
4290 if ((*(contents + rel->r_offset - 1) & 0xc7) == 0x5)
4291 {
4292 if (bfd_link_pic (info))
4293 {
4294 /* For PIC, disallow R_386_GOT32 without a base
4295 register since we don't know what the GOT base
4296 is. */
4297 const char *name;
4298
712ec279 4299disallow_got32:
74d7f0aa
L		 4300 if (h == NULL)
4301 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4302 NULL);
4303 else
4304 name = h->root.root.string;
4305
4eca0228 4306 _bfd_error_handler
695344c0 4307 /* xgettext:c-format */
712ec279
L		 4308 (_("%B: direct GOT relocation %s against `%s' without base register can not be used when making a shared object"),
4309 input_bfd, howto->name, name);
74d7f0aa
L		 4310 bfd_set_error (bfd_error_bad_value);
4311 return FALSE;
4312 }
4313 }
4314 else
4315 {
4316 /* Subtract the .got.plt section address only with a base
4317 register. */
4318 relocation -= (htab->elf.sgotplt->output_section->vma
4319 + htab->elf.sgotplt->output_offset);
4320 }
4321
252b5132
RH		 4322 break;
4323
4324 case R_386_GOTOFF:
4325 /* Relocation is relative to the start of the global offset
4326 table. */
4327
3d949995
L		 4328 /* Check to make sure it isn't a protected function or data
4329 symbol for shared library since it may not be local when
4330 used as function address or with copy relocation. We also
e3c0e327 4331 need to make sure that a symbol is referenced locally. */
0e1862bb 4332 if (!bfd_link_executable (info) && h)
90f487df 4333 {
41bed6dd
L		 4334 if (!h->def_regular)
4335 {
4336 const char *v;
4337
4338 switch (ELF_ST_VISIBILITY (h->other))
4339 {
4340 case STV_HIDDEN:
4341 v = _("hidden symbol");
4342 break;
4343 case STV_INTERNAL:
4344 v = _("internal symbol");
4345 break;
4346 case STV_PROTECTED:
4347 v = _("protected symbol");
4348 break;
4349 default:
4350 v = _("symbol");
4351 break;
4352 }
4353
4eca0228 4354 _bfd_error_handler
695344c0 4355 /* xgettext:c-format */
41bed6dd
L		 4356 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4357 input_bfd, v, h->root.root.string);
4358 bfd_set_error (bfd_error_bad_value);
4359 return FALSE;
4360 }
d5597ebc 4361 else if (!SYMBOL_REFERENCES_LOCAL (info, h)
3d949995
L		 4362 && (h->type == STT_FUNC
4363 || h->type == STT_OBJECT)
41bed6dd
L		 4364 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4365 {
4eca0228 4366 _bfd_error_handler
695344c0 4367 /* xgettext:c-format */
3d949995
L		 4368 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4369 input_bfd,
4370 h->type == STT_FUNC ? "function" : "data",
4371 h->root.root.string);
41bed6dd
L		 4372 bfd_set_error (bfd_error_bad_value);
4373 return FALSE;
4374 }
90f487df
L		 4375 }
4376
8c37241b
JJ		 4377 /* Note that sgot is not involved in this
4378 calculation. We always want the start of .got.plt. If we
4379 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
252b5132
RH		 4380 permitted by the ABI, we might have to change this
4381 calculation. */
6de2ae4a
L		 4382 relocation -= htab->elf.sgotplt->output_section->vma
4383 + htab->elf.sgotplt->output_offset;
252b5132
RH		 4384 break;
4385
4386 case R_386_GOTPC:
4387 /* Use global offset table as symbol value. */
6de2ae4a
L		 4388 relocation = htab->elf.sgotplt->output_section->vma
4389 + htab->elf.sgotplt->output_offset;
b34976b6 4390 unresolved_reloc = FALSE;
252b5132
RH		 4391 break;
4392
4393 case R_386_PLT32:
4394 /* Relocation is to the entry for this symbol in the
4395 procedure linkage table. */
4396
dd5724d5 4397 /* Resolve a PLT32 reloc against a local symbol directly,
83be169b 4398 without using the procedure linkage table. */
252b5132
RH		 4399 if (h == NULL)
4400 break;
4401
dd7e64d4
L		 4402 if ((h->plt.offset == (bfd_vma) -1
4403 && eh->plt_got.offset == (bfd_vma) -1)
6de2ae4a 4404 || htab->elf.splt == NULL)
252b5132
RH		 4405 {
4406 /* We didn't make a PLT entry for this symbol. This
83be169b
AM		 4407 happens when statically linking PIC code, or when
4408 using -Bsymbolic. */
252b5132
RH		 4409 break;
4410 }
4411
dd7e64d4
L		 4412 if (h->plt.offset != (bfd_vma) -1)
4413 {
4414 resolved_plt = htab->elf.splt;
4415 plt_offset = h->plt.offset;
4416 }
4417 else
4418 {
4419 resolved_plt = htab->plt_got;
4420 plt_offset = eh->plt_got.offset;
4421 }
4422
4423 relocation = (resolved_plt->output_section->vma
4424 + resolved_plt->output_offset
4425 + plt_offset);
b34976b6 4426 unresolved_reloc = FALSE;
252b5132
RH		 4427 break;
4428
1788fc08 4429 case R_386_SIZE32:
1788fc08
L		 4430 /* Set to symbol size. */
4431 relocation = st_size;
4432 /* Fall through. */
4433
252b5132
RH		 4434 case R_386_32:
4435 case R_386_PC32:
3348747a
NS		 4436 if ((input_section->flags & SEC_ALLOC) == 0
4437 || is_vxworks_tls)
ec338859
AM		 4438 break;
4439
aec6b87e
L		 4440 /* Copy dynamic function pointer relocations. Don't generate
4441 dynamic relocations against resolved undefined weak symbols
4442 in PIE, except for R_386_PC32. */
0e1862bb 4443 if ((bfd_link_pic (info)
ef5aade5 4444 && (h == NULL
aec6b87e
L		 4445 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4446 && (!resolved_to_zero
4447 || r_type == R_386_PC32))
4448 || h->root.type != bfd_link_hash_undefweak))
1788fc08 4449 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
f6c52c13 4450 || !SYMBOL_CALLS_LOCAL (info, h)))
a23b6845 4451 || (ELIMINATE_COPY_RELOCS
0e1862bb 4452 && !bfd_link_pic (info)
12d0ee4a
AM		 4453 && h != NULL
4454 && h->dynindx != -1
aec6b87e
L		 4455 && (!h->non_got_ref
4456 || eh->func_pointer_refcount > 0
4457 || (h->root.type == bfd_link_hash_undefweak
4458 && !resolved_to_zero))
bae420ef
L		 4459 && ((h->def_dynamic && !h->def_regular)
4460 /* Undefined weak symbol is bound locally when
4461 PIC is false. */
4462 || h->root.type == bfd_link_hash_undefweak)))
252b5132 4463 {
947216bf 4464 Elf_Internal_Rela outrel;
b34976b6 4465 bfd_boolean skip, relocate;
0c715baa 4466 asection *sreloc;
252b5132
RH		 4467
4468 /* When generating a shared object, these relocations
4469 are copied into the output file to be resolved at run
4470 time. */
4471
b34976b6
AM		 4472 skip = FALSE;
4473 relocate = FALSE;
252b5132 4474
c629eae0
JJ		 4475 outrel.r_offset =
4476 _bfd_elf_section_offset (output_bfd, info, input_section,
4477 rel->r_offset);
4478 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 4479 skip = TRUE;
0bb2d96a 4480 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 4481 skip = TRUE, relocate = TRUE;
252b5132
RH		 4482 outrel.r_offset += (input_section->output_section->vma
4483 + input_section->output_offset);
4484
4485 if (skip)
0bb2d96a 4486 memset (&outrel, 0, sizeof outrel);
5a15f56f
AM		 4487 else if (h != NULL
4488 && h->dynindx != -1
4489 && (r_type == R_386_PC32
4e0c91e4
L		 4490 || !(bfd_link_executable (info)
4491 || SYMBOLIC_BIND (info, h))
f5385ebf 4492 || !h->def_regular))
0bb2d96a 4493 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
252b5132
RH		 4494 else
4495 {
5a15f56f 4496 /* This symbol is local, or marked to become local. */
b34976b6 4497 relocate = TRUE;
5a15f56f 4498 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
252b5132
RH		 4499 }
4500
cbe950e9 4501 sreloc = elf_section_data (input_section)->sreloc;
e7c33416 4502
62d78908
L		 4503 if (sreloc == NULL || sreloc->contents == NULL)
4504 {
4505 r = bfd_reloc_notsupported;
4506 goto check_relocation_error;
4507 }
0c715baa 4508
59d6ffb2 4509 elf_append_rel (output_bfd, sreloc, &outrel);
252b5132
RH		 4510
4511 /* If this reloc is against an external symbol, we do
4512 not want to fiddle with the addend. Otherwise, we
4513 need to include the symbol value so that it becomes
4514 an addend for the dynamic reloc. */
0f88be7a 4515 if (! relocate)
252b5132
RH		 4516 continue;
4517 }
252b5132
RH		 4518 break;
4519
37e55690 4520 case R_386_TLS_IE:
0e1862bb 4521 if (!bfd_link_executable (info))
37e55690 4522 {
947216bf 4523 Elf_Internal_Rela outrel;
37e55690 4524 asection *sreloc;
37e55690
JJ		 4525
4526 outrel.r_offset = rel->r_offset
4527 + input_section->output_section->vma
4528 + input_section->output_offset;
4529 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4530 sreloc = elf_section_data (input_section)->sreloc;
4531 if (sreloc == NULL)
4532 abort ();
59d6ffb2 4533 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690
JJ		 4534 }
4535 /* Fall through */
4536
13ae64f3 4537 case R_386_TLS_GD:
67a4f2b7
AO		 4538 case R_386_TLS_GOTDESC:
4539 case R_386_TLS_DESC_CALL:
13ae64f3 4540 case R_386_TLS_IE_32:
37e55690 4541 case R_386_TLS_GOTIE:
13ae64f3
JJ		 4542 tls_type = GOT_UNKNOWN;
4543 if (h == NULL && local_got_offsets)
4544 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
4545 else if (h != NULL)
142411ca 4546 tls_type = elf_i386_hash_entry(h)->tls_type;
37e55690
JJ		 4547 if (tls_type == GOT_TLS_IE)
4548 tls_type = GOT_TLS_IE_NEG;
142411ca
L		 4549
4550 if (! elf_i386_tls_transition (info, input_bfd,
4551 input_section, contents,
4552 symtab_hdr, sym_hashes,
4553 &r_type, tls_type, rel,
bedfd056 4554 relend, h, r_symndx, TRUE))
142411ca 4555 return FALSE;
13ae64f3
JJ		 4556
4557 if (r_type == R_386_TLS_LE_32)
4558 {
82e51918 4559 BFD_ASSERT (! unresolved_reloc);
13ae64f3
JJ		 4560 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4561 {
142411ca 4562 unsigned int type;
13ae64f3
JJ		 4563 bfd_vma roff;
4564
4565 /* GD->LE transition. */
6eaa7fb5 4566 type = *(contents + rel->r_offset - 2);
13ae64f3
JJ		 4567 if (type == 0x04)
4568 {
6eaa7fb5
L		 4569 /* Change
4570 leal foo@tlsgd(,%ebx,1), %eax
4571 call ___tls_get_addr@PLT
4572 into:
4573 movl %gs:0, %eax
4574 subl $foo@tpoff, %eax
13ae64f3 4575 (6 byte form of subl). */
142411ca 4576 roff = rel->r_offset + 5;
13ae64f3
JJ		 4577 }
4578 else
4579 {
6eaa7fb5
L		 4580 /* Change
4581 leal foo@tlsgd(%ebx), %eax
4582 call ___tls_get_addr@PLT
4583 nop
4584 or
4585 leal foo@tlsgd(%reg), %eax
4586 call *___tls_get_addr@GOT(%reg)
4587 which may be converted to
4588 addr32 call ___tls_get_addr
4589 into:
4590 movl %gs:0, %eax; subl $foo@tpoff, %eax
142411ca 4591 (6 byte form of subl). */
142411ca 4592 roff = rel->r_offset + 6;
13ae64f3 4593 }
6eaa7fb5
L		 4594 memcpy (contents + roff - 8,
4595 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
eb4ff4d6 4596 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
13ae64f3 4597 contents + roff);
6eaa7fb5 4598 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
13ae64f3 4599 rel++;
60f2e42e 4600 wrel++;
13ae64f3
JJ		 4601 continue;
4602 }
67a4f2b7
AO		 4603 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4604 {
4605 /* GDesc -> LE transition.
4606 It's originally something like:
4607 leal x@tlsdesc(%ebx), %eax
4608
4609 leal x@ntpoff, %eax
4610
4611 Registers other than %eax may be set up here. */
4612
142411ca 4613 unsigned int val;
67a4f2b7
AO		 4614 bfd_vma roff;
4615
67a4f2b7 4616 roff = rel->r_offset;
67a4f2b7 4617 val = bfd_get_8 (input_bfd, contents + roff - 1);
67a4f2b7
AO		 4618
4619 /* Now modify the instruction as appropriate. */
4620 /* aoliva FIXME: remove the above and xor the byte
4621 below with 0x86. */
4622 bfd_put_8 (output_bfd, val ^ 0x86,
4623 contents + roff - 1);
eb4ff4d6 4624 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
67a4f2b7
AO		 4625 contents + roff);
4626 continue;
4627 }
4628 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4629 {
4630 /* GDesc -> LE transition.
4631 It's originally:
4632 call *(%eax)
4633 Turn it into:
142411ca 4634 xchg %ax,%ax */
67a4f2b7 4635
67a4f2b7 4636 bfd_vma roff;
6bbec505 4637
67a4f2b7 4638 roff = rel->r_offset;
10efb593 4639 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 4640 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4641 continue;
4642 }
37e55690 4643 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
13ae64f3 4644 {
142411ca 4645 unsigned int val;
13ae64f3
JJ		 4646
4647 /* IE->LE transition:
37e55690
JJ		 4648 Originally it can be one of:
4649 movl foo, %eax
4650 movl foo, %reg
4651 addl foo, %reg
4652 We change it into:
4653 movl $foo, %eax
4654 movl $foo, %reg
4655 addl $foo, %reg. */
37e55690 4656 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
37e55690
JJ		 4657 if (val == 0xa1)
4658 {
4659 /* movl foo, %eax. */
55fd94b0
AM		 4660 bfd_put_8 (output_bfd, 0xb8,
4661 contents + rel->r_offset - 1);
37e55690 4662 }
299bf759 4663 else
37e55690 4664 {
142411ca
L		 4665 unsigned int type;
4666
55fd94b0
AM		 4667 type = bfd_get_8 (input_bfd,
4668 contents + rel->r_offset - 2);
299bf759 4669 switch (type)
26e41594 4670 {
299bf759
L		 4671 case 0x8b:
4672 /* movl */
299bf759
L		 4673 bfd_put_8 (output_bfd, 0xc7,
4674 contents + rel->r_offset - 2);
4675 bfd_put_8 (output_bfd,
4676 0xc0 | ((val >> 3) & 7),
4677 contents + rel->r_offset - 1);
4678 break;
4679 case 0x03:
4680 /* addl */
299bf759
L		 4681 bfd_put_8 (output_bfd, 0x81,
4682 contents + rel->r_offset - 2);
4683 bfd_put_8 (output_bfd,
4684 0xc0 | ((val >> 3) & 7),
4685 contents + rel->r_offset - 1);
4686 break;
4687 default:
4688 BFD_FAIL ();
4689 break;
26e41594 4690 }
37e55690 4691 }
eb4ff4d6 4692 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 4693 contents + rel->r_offset);
4694 continue;
4695 }
4696 else
4697 {
4698 unsigned int val, type;
4699
4700 /* {IE_32,GOTIE}->LE transition:
4701 Originally it can be one of:
13ae64f3 4702 subl foo(%reg1), %reg2
13ae64f3 4703 movl foo(%reg1), %reg2
37e55690 4704 addl foo(%reg1), %reg2
13ae64f3
JJ		 4705 We change it into:
4706 subl $foo, %reg2
37e55690
JJ		 4707 movl $foo, %reg2 (6 byte form)
4708 addl $foo, %reg2. */
13ae64f3
JJ		 4709 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4710 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
13ae64f3
JJ		 4711 if (type == 0x8b)
4712 {
4713 /* movl */
13ae64f3
JJ		 4714 bfd_put_8 (output_bfd, 0xc7,
4715 contents + rel->r_offset - 2);
4716 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4717 contents + rel->r_offset - 1);
4718 }
4719 else if (type == 0x2b)
4720 {
4721 /* subl */
13ae64f3
JJ		 4722 bfd_put_8 (output_bfd, 0x81,
4723 contents + rel->r_offset - 2);
4724 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4725 contents + rel->r_offset - 1);
4726 }
37e55690
JJ		 4727 else if (type == 0x03)
4728 {
4729 /* addl */
4730 bfd_put_8 (output_bfd, 0x81,
4731 contents + rel->r_offset - 2);
4732 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4733 contents + rel->r_offset - 1);
4734 }
13ae64f3
JJ		 4735 else
4736 BFD_FAIL ();
37e55690 4737 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
eb4ff4d6 4738 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
37e55690
JJ		 4739 contents + rel->r_offset);
4740 else
eb4ff4d6 4741 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
37e55690 4742 contents + rel->r_offset);
13ae64f3
JJ		 4743 continue;
4744 }
4745 }
4746
6de2ae4a 4747 if (htab->elf.sgot == NULL)
13ae64f3
JJ		 4748 abort ();
4749
4750 if (h != NULL)
67a4f2b7
AO		 4751 {
4752 off = h->got.offset;
4753 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4754 }
13ae64f3
JJ		 4755 else
4756 {
4757 if (local_got_offsets == NULL)
4758 abort ();
4759
4760 off = local_got_offsets[r_symndx];
67a4f2b7 4761 offplt = local_tlsdesc_gotents[r_symndx];
13ae64f3
JJ		 4762 }
4763
4764 if ((off & 1) != 0)
4765 off &= ~1;
26e41594 4766 else
13ae64f3 4767 {
947216bf 4768 Elf_Internal_Rela outrel;
91d6fa6a 4769 int dr_type;
67a4f2b7 4770 asection *sreloc;
13ae64f3 4771
6de2ae4a 4772 if (htab->elf.srelgot == NULL)
13ae64f3
JJ		 4773 abort ();
4774
67a4f2b7
AO		 4775 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4776
4777 if (GOT_TLS_GDESC_P (tls_type))
4778 {
59d6ffb2 4779 bfd_byte *loc;
67a4f2b7
AO		 4780 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4781 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
6de2ae4a
L		 4782 <= htab->elf.sgotplt->size);
4783 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4784 + htab->elf.sgotplt->output_offset
67a4f2b7
AO		 4785 + offplt
4786 + htab->sgotplt_jump_table_size);
6de2ae4a 4787 sreloc = htab->elf.srelplt;
67a4f2b7 4788 loc = sreloc->contents;
5ae0bfb6
RS		 4789 loc += (htab->next_tls_desc_index++
4790 * sizeof (Elf32_External_Rel));
67a4f2b7 4791 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
c3b02097 4792 <= sreloc->contents + sreloc->size);
67a4f2b7
AO		 4793 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4794 if (indx == 0)
4795 {
4796 BFD_ASSERT (! unresolved_reloc);
4797 bfd_put_32 (output_bfd,
eb4ff4d6 4798 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4799 htab->elf.sgotplt->contents + offplt
67a4f2b7
AO		 4800 + htab->sgotplt_jump_table_size + 4);
4801 }
4802 else
4803 {
4804 bfd_put_32 (output_bfd, 0,
6de2ae4a 4805 htab->elf.sgotplt->contents + offplt
67a4f2b7
AO		 4806 + htab->sgotplt_jump_table_size + 4);
4807 }
4808 }
4809
6de2ae4a 4810 sreloc = htab->elf.srelgot;
67a4f2b7 4811
6de2ae4a
L		 4812 outrel.r_offset = (htab->elf.sgot->output_section->vma
4813 + htab->elf.sgot->output_offset + off);
13ae64f3 4814
67a4f2b7 4815 if (GOT_TLS_GD_P (tls_type))
13ae64f3 4816 dr_type = R_386_TLS_DTPMOD32;
67a4f2b7
AO		 4817 else if (GOT_TLS_GDESC_P (tls_type))
4818 goto dr_done;
37e55690
JJ		 4819 else if (tls_type == GOT_TLS_IE_POS)
4820 dr_type = R_386_TLS_TPOFF;
13ae64f3
JJ		 4821 else
4822 dr_type = R_386_TLS_TPOFF32;
67a4f2b7 4823
37e55690 4824 if (dr_type == R_386_TLS_TPOFF && indx == 0)
eb4ff4d6
L		 4825 bfd_put_32 (output_bfd,
4826 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4827 htab->elf.sgot->contents + off);
37e55690 4828 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
23209a78 4829 bfd_put_32 (output_bfd,
eb4ff4d6 4830 elf_i386_dtpoff_base (info) - relocation,
6de2ae4a 4831 htab->elf.sgot->contents + off);
67a4f2b7 4832 else if (dr_type != R_386_TLS_DESC)
c366c25e 4833 bfd_put_32 (output_bfd, 0,
6de2ae4a 4834 htab->elf.sgot->contents + off);
13ae64f3 4835 outrel.r_info = ELF32_R_INFO (indx, dr_type);
67a4f2b7 4836
59d6ffb2 4837 elf_append_rel (output_bfd, sreloc, &outrel);
13ae64f3 4838
67a4f2b7 4839 if (GOT_TLS_GD_P (tls_type))
13ae64f3
JJ		 4840 {
4841 if (indx == 0)
4842 {
82e51918 4843 BFD_ASSERT (! unresolved_reloc);
13ae64f3 4844 bfd_put_32 (output_bfd,
eb4ff4d6 4845 relocation - elf_i386_dtpoff_base (info),
6de2ae4a 4846 htab->elf.sgot->contents + off + 4);
13ae64f3
JJ		 4847 }
4848 else
4849 {
4850 bfd_put_32 (output_bfd, 0,
6de2ae4a 4851 htab->elf.sgot->contents + off + 4);
13ae64f3
JJ		 4852 outrel.r_info = ELF32_R_INFO (indx,
4853 R_386_TLS_DTPOFF32);
4854 outrel.r_offset += 4;
59d6ffb2 4855 elf_append_rel (output_bfd, sreloc, &outrel);
13ae64f3
JJ		 4856 }
4857 }
37e55690
JJ		 4858 else if (tls_type == GOT_TLS_IE_BOTH)
4859 {
4860 bfd_put_32 (output_bfd,
eb4ff4d6
L		 4861 (indx == 0
4862 ? relocation - elf_i386_dtpoff_base (info)
4863 : 0),
6de2ae4a 4864 htab->elf.sgot->contents + off + 4);
37e55690
JJ		 4865 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4866 outrel.r_offset += 4;
59d6ffb2 4867 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690 4868 }
13ae64f3 4869
67a4f2b7 4870 dr_done:
13ae64f3
JJ		 4871 if (h != NULL)
4872 h->got.offset |= 1;
4873 else
4874 local_got_offsets[r_symndx] |= 1;
4875 }
4876
67a4f2b7
AO		 4877 if (off >= (bfd_vma) -2
4878 && ! GOT_TLS_GDESC_P (tls_type))
13ae64f3 4879 abort ();
67a4f2b7
AO		 4880 if (r_type == R_386_TLS_GOTDESC
4881 || r_type == R_386_TLS_DESC_CALL)
4882 {
4883 relocation = htab->sgotplt_jump_table_size + offplt;
4884 unresolved_reloc = FALSE;
4885 }
4886 else if (r_type == ELF32_R_TYPE (rel->r_info))
13ae64f3 4887 {
6de2ae4a
L		 4888 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4889 + htab->elf.sgotplt->output_offset;
4890 relocation = htab->elf.sgot->output_section->vma
4891 + htab->elf.sgot->output_offset + off - g_o_t;
37e55690
JJ		 4892 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4893 && tls_type == GOT_TLS_IE_BOTH)
4894 relocation += 4;
4895 if (r_type == R_386_TLS_IE)
8c37241b 4896 relocation += g_o_t;
b34976b6 4897 unresolved_reloc = FALSE;
13ae64f3 4898 }
67a4f2b7 4899 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
13ae64f3
JJ		 4900 {
4901 unsigned int val, type;
4902 bfd_vma roff;
4903
4904 /* GD->IE transition. */
6eaa7fb5
L		 4905 type = *(contents + rel->r_offset - 2);
4906 val = *(contents + rel->r_offset - 1);
13ae64f3
JJ		 4907 if (type == 0x04)
4908 {
6eaa7fb5
L		 4909 /* Change
4910 leal foo@tlsgd(,%ebx,1), %eax
4911 call ___tls_get_addr@PLT
4912 into:
4913 movl %gs:0, %eax
4914 subl $foo@gottpoff(%ebx), %eax. */
13ae64f3 4915 val >>= 3;
142411ca 4916 roff = rel->r_offset - 3;
13ae64f3
JJ		 4917 }
4918 else
4919 {
6eaa7fb5
L		 4920 /* Change
4921 leal foo@tlsgd(%ebx), %eax
4922 call ___tls_get_addr@PLT
4923 nop
4924 or
4925 leal foo@tlsgd(%reg), %eax
4926 call *___tls_get_addr@GOT(%reg)
4927 which may be converted to
4928 addr32 call ___tls_get_addr
4929 into:
4930 movl %gs:0, %eax;
4931 subl $foo@gottpoff(%reg), %eax. */
13ae64f3
JJ		 4932 roff = rel->r_offset - 2;
4933 }
4934 memcpy (contents + roff,
4935 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4936 contents[roff + 7] = 0x80 | (val & 7);
37e55690
JJ		 4937 /* If foo is used only with foo@gotntpoff(%reg) and
4938 foo@indntpoff, but not with foo@gottpoff(%reg), change
4939 subl $foo@gottpoff(%reg), %eax
4940 into:
4941 addl $foo@gotntpoff(%reg), %eax. */
ebcfb3c0
JJ		 4942 if (tls_type == GOT_TLS_IE_POS)
4943 contents[roff + 6] = 0x03;
8c37241b 4944 bfd_put_32 (output_bfd,
6de2ae4a
L		 4945 htab->elf.sgot->output_section->vma
4946 + htab->elf.sgot->output_offset + off
4947 - htab->elf.sgotplt->output_section->vma
4948 - htab->elf.sgotplt->output_offset,
13ae64f3 4949 contents + roff + 8);
6eaa7fb5 4950 /* Skip R_386_PLT32 and R_386_GOT32X. */
13ae64f3 4951 rel++;
60f2e42e 4952 wrel++;
13ae64f3
JJ		 4953 continue;
4954 }
67a4f2b7
AO		 4955 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4956 {
4957 /* GDesc -> IE transition.
4958 It's originally something like:
4959 leal x@tlsdesc(%ebx), %eax
4960
4961 Change it to:
142411ca 4962 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
67a4f2b7
AO		 4963 or:
4964 movl x@gottpoff(%ebx), %eax # before negl %eax
4965
4966 Registers other than %eax may be set up here. */
4967
67a4f2b7
AO		 4968 bfd_vma roff;
4969
4970 /* First, make sure it's a leal adding ebx to a 32-bit
4971 offset into any register, although it's probably
4972 almost always going to be eax. */
4973 roff = rel->r_offset;
67a4f2b7
AO		 4974
4975 /* Now modify the instruction as appropriate. */
4976 /* To turn a leal into a movl in the form we use it, it
4977 suffices to change the first byte from 0x8d to 0x8b.
4978 aoliva FIXME: should we decide to keep the leal, all
4979 we have to do is remove the statement below, and
4980 adjust the relaxation of R_386_TLS_DESC_CALL. */
4981 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4982
4983 if (tls_type == GOT_TLS_IE_BOTH)
4984 off += 4;
4985
4986 bfd_put_32 (output_bfd,
6de2ae4a
L		 4987 htab->elf.sgot->output_section->vma
4988 + htab->elf.sgot->output_offset + off
4989 - htab->elf.sgotplt->output_section->vma
4990 - htab->elf.sgotplt->output_offset,
67a4f2b7
AO		 4991 contents + roff);
4992 continue;
4993 }
4994 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4995 {
4996 /* GDesc -> IE transition.
4997 It's originally:
4998 call *(%eax)
4999
5000 Change it to:
142411ca 5001 xchg %ax,%ax
67a4f2b7
AO		 5002 or
5003 negl %eax
5004 depending on how we transformed the TLS_GOTDESC above.
5005 */
5006
67a4f2b7
AO		 5007 bfd_vma roff;
5008
67a4f2b7 5009 roff = rel->r_offset;
67a4f2b7
AO		 5010
5011 /* Now modify the instruction as appropriate. */
5012 if (tls_type != GOT_TLS_IE_NEG)
5013 {
10efb593
L		 5014 /* xchg %ax,%ax */
5015 bfd_put_8 (output_bfd, 0x66, contents + roff);
67a4f2b7
AO		 5016 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
5017 }
5018 else
5019 {
5020 /* negl %eax */
5021 bfd_put_8 (output_bfd, 0xf7, contents + roff);
5022 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
5023 }
5024
5025 continue;
5026 }
5027 else
5028 BFD_ASSERT (FALSE);
13ae64f3
JJ		 5029 break;
5030
5031 case R_386_TLS_LDM:
142411ca
L		 5032 if (! elf_i386_tls_transition (info, input_bfd,
5033 input_section, contents,
5034 symtab_hdr, sym_hashes,
5035 &r_type, GOT_UNKNOWN, rel,
bedfd056 5036 relend, h, r_symndx, TRUE))
142411ca 5037 return FALSE;
13ae64f3 5038
142411ca
L		 5039 if (r_type != R_386_TLS_LDM)
5040 {
6eaa7fb5
L		 5041 /* LD->LE transition. Change
5042 leal foo@tlsldm(%ebx) %eax
5043 call ___tls_get_addr@PLT
5044 into:
5045 movl %gs:0, %eax
5046 nop
5047 leal 0(%esi,1), %esi
5048 or change
5049 leal foo@tlsldm(%reg) %eax
5050 call *___tls_get_addr@GOT(%reg)
5051 which may be converted to
5052 addr32 call ___tls_get_addr
5053 into:
5054 movl %gs:0, %eax
5055 leal 0(%esi), %esi */
142411ca 5056 BFD_ASSERT (r_type == R_386_TLS_LE_32);
6eaa7fb5
L		 5057 if (*(contents + rel->r_offset + 4) == 0xff
5058 || *(contents + rel->r_offset + 4) == 0x67)
5059 memcpy (contents + rel->r_offset - 2,
5060 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
5061 else
5062 memcpy (contents + rel->r_offset - 2,
5063 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
a3fadc9a 5064 /* Skip R_386_PC32/R_386_PLT32. */
13ae64f3 5065 rel++;
60f2e42e 5066 wrel++;
13ae64f3
JJ		 5067 continue;
5068 }
5069
6de2ae4a 5070 if (htab->elf.sgot == NULL)
13ae64f3
JJ		 5071 abort ();
5072
5073 off = htab->tls_ldm_got.offset;
5074 if (off & 1)
5075 off &= ~1;
5076 else
5077 {
947216bf 5078 Elf_Internal_Rela outrel;
13ae64f3 5079
6de2ae4a 5080 if (htab->elf.srelgot == NULL)
13ae64f3
JJ		 5081 abort ();
5082
6de2ae4a
L		 5083 outrel.r_offset = (htab->elf.sgot->output_section->vma
5084 + htab->elf.sgot->output_offset + off);
13ae64f3
JJ		 5085
5086 bfd_put_32 (output_bfd, 0,
6de2ae4a 5087 htab->elf.sgot->contents + off);
13ae64f3 5088 bfd_put_32 (output_bfd, 0,
6de2ae4a 5089 htab->elf.sgot->contents + off + 4);
13ae64f3 5090 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
59d6ffb2 5091 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
13ae64f3
JJ		 5092 htab->tls_ldm_got.offset |= 1;
5093 }
6de2ae4a
L		 5094 relocation = htab->elf.sgot->output_section->vma
5095 + htab->elf.sgot->output_offset + off
5096 - htab->elf.sgotplt->output_section->vma
5097 - htab->elf.sgotplt->output_offset;
b34976b6 5098 unresolved_reloc = FALSE;
13ae64f3
JJ		 5099 break;
5100
5101 case R_386_TLS_LDO_32:
0e1862bb
L		 5102 if (!bfd_link_executable (info)
5103 || (input_section->flags & SEC_CODE) == 0)
eb4ff4d6 5104 relocation -= elf_i386_dtpoff_base (info);
13ae64f3
JJ		 5105 else
5106 /* When converting LDO to LE, we must negate. */
eb4ff4d6 5107 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 5108 break;
5109
5110 case R_386_TLS_LE_32:
13ae64f3 5111 case R_386_TLS_LE:
0e1862bb 5112 if (!bfd_link_executable (info))
37e55690 5113 {
947216bf 5114 Elf_Internal_Rela outrel;
37e55690 5115 asection *sreloc;
37e55690
JJ		 5116
5117 outrel.r_offset = rel->r_offset
5118 + input_section->output_section->vma
5119 + input_section->output_offset;
5120 if (h != NULL && h->dynindx != -1)
5121 indx = h->dynindx;
5122 else
5123 indx = 0;
5124 if (r_type == R_386_TLS_LE_32)
5125 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
5126 else
5127 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
5128 sreloc = elf_section_data (input_section)->sreloc;
5129 if (sreloc == NULL)
5130 abort ();
59d6ffb2 5131 elf_append_rel (output_bfd, sreloc, &outrel);
37e55690
JJ		 5132 if (indx)
5133 continue;
5134 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 5135 relocation = elf_i386_dtpoff_base (info) - relocation;
37e55690 5136 else
eb4ff4d6 5137 relocation -= elf_i386_dtpoff_base (info);
37e55690
JJ		 5138 }
5139 else if (r_type == R_386_TLS_LE_32)
eb4ff4d6 5140 relocation = elf_i386_tpoff (info, relocation);
37e55690 5141 else
eb4ff4d6 5142 relocation = -elf_i386_tpoff (info, relocation);
13ae64f3
JJ		 5143 break;
5144
252b5132
RH		 5145 default:
5146 break;
5147 }
5148
239e1f3a
AM		 5149 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5150 because such sections are not SEC_ALLOC and thus ld.so will
5151 not process them. */
8c694914 5152 if (unresolved_reloc
239e1f3a 5153 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 5154 && h->def_dynamic)
5155 && _bfd_elf_section_offset (output_bfd, info, input_section,
5156 rel->r_offset) != (bfd_vma) -1)
6a30718d 5157 {
4eca0228 5158 _bfd_error_handler
695344c0 5159 /* xgettext:c-format */
843fe662 5160 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
d003868e
AM		 5161 input_bfd,
5162 input_section,
6a30718d 5163 (long) rel->r_offset,
843fe662 5164 howto->name,
6a30718d 5165 h->root.root.string);
b34976b6 5166 return FALSE;
6a30718d 5167 }
83be169b 5168
cbe950e9 5169do_relocation:
252b5132
RH		 5170 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5171 contents, rel->r_offset,
55fd94b0 5172 relocation, 0);
252b5132 5173
62d78908 5174check_relocation_error:
cf5c0c5b 5175 if (r != bfd_reloc_ok)
252b5132 5176 {
cf5c0c5b 5177 const char *name;
ffb2e45b 5178
cf5c0c5b
AM		 5179 if (h != NULL)
5180 name = h->root.root.string;
5181 else
5182 {
5183 name = bfd_elf_string_from_elf_section (input_bfd,
5184 symtab_hdr->sh_link,
5185 sym->st_name);
5186 if (name == NULL)
b34976b6 5187 return FALSE;
cf5c0c5b
AM		 5188 if (*name == '\0')
5189 name = bfd_section_name (input_bfd, sec);
5190 }
ffb2e45b 5191
cf5c0c5b 5192 if (r == bfd_reloc_overflow)
1a72702b
AM		 5193 (*info->callbacks->reloc_overflow)
5194 (info, (h ? &h->root : NULL), name, howto->name,
5195 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
cf5c0c5b
AM		 5196 else
5197 {
4eca0228 5198 _bfd_error_handler
695344c0 5199 /* xgettext:c-format */
d003868e
AM		 5200 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5201 input_bfd, input_section,
cf5c0c5b 5202 (long) rel->r_offset, name, (int) r);
b34976b6 5203 return FALSE;
cf5c0c5b 5204 }
252b5132 5205 }
60f2e42e
L		 5206
5207 if (wrel != rel)
5208 *wrel = *rel;
5209 }
5210
5211 if (wrel != rel)
5212 {
5213 Elf_Internal_Shdr *rel_hdr;
5214 size_t deleted = rel - wrel;
5215
5216 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5217 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5218 if (rel_hdr->sh_size == 0)
5219 {
5220 /* It is too late to remove an empty reloc section. Leave
5221 one NONE reloc.
5222 ??? What is wrong with an empty section??? */
5223 rel_hdr->sh_size = rel_hdr->sh_entsize;
5224 deleted -= 1;
5225 }
5226 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5227 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5228 input_section->reloc_count -= deleted;
252b5132
RH		 5229 }
5230
b34976b6 5231 return TRUE;
252b5132
RH		 5232}
5233
5234/* Finish up dynamic symbol handling. We set the contents of various
5235 dynamic sections here. */
5236
b34976b6 5237static bfd_boolean
55fd94b0
AM		 5238elf_i386_finish_dynamic_symbol (bfd *output_bfd,
5239 struct bfd_link_info *info,
5240 struct elf_link_hash_entry *h,
5241 Elf_Internal_Sym *sym)
252b5132 5242{
6725bdbf 5243 struct elf_i386_link_hash_table *htab;
25e762b9
RM		 5244 unsigned plt_entry_size;
5245 const struct elf_i386_backend_data *abed;
dd7e64d4 5246 struct elf_i386_link_hash_entry *eh;
aec6b87e 5247 bfd_boolean local_undefweak;
252b5132 5248
6725bdbf 5249 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 5250 if (htab == NULL)
5251 return FALSE;
252b5132 5252
25e762b9
RM		 5253 abed = get_elf_i386_backend_data (output_bfd);
5254 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
5255
dd7e64d4
L		 5256 eh = (struct elf_i386_link_hash_entry *) h;
5257
aec6b87e
L		 5258 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5259 resolved undefined weak symbols in executable so that their
5260 references have value 0 at run-time. */
e62b9723
L		 5261 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
5262 eh->has_got_reloc,
5263 eh);
aec6b87e 5264
252b5132
RH		 5265 if (h->plt.offset != (bfd_vma) -1)
5266 {
252b5132
RH		 5267 bfd_vma plt_index;
5268 bfd_vma got_offset;
947216bf
AM		 5269 Elf_Internal_Rela rel;
5270 bfd_byte *loc;
cbe950e9
L		 5271 asection *plt, *gotplt, *relplt;
5272
5273 /* When building a static executable, use .iplt, .igot.plt and
5274 .rel.iplt sections for STT_GNU_IFUNC symbols. */
6de2ae4a 5275 if (htab->elf.splt != NULL)
cbe950e9 5276 {
6de2ae4a
L		 5277 plt = htab->elf.splt;
5278 gotplt = htab->elf.sgotplt;
5279 relplt = htab->elf.srelplt;
cbe950e9
L		 5280 }
5281 else
5282 {
6de2ae4a
L		 5283 plt = htab->elf.iplt;
5284 gotplt = htab->elf.igotplt;
5285 relplt = htab->elf.irelplt;
cbe950e9 5286 }
252b5132
RH		 5287
5288 /* This symbol has an entry in the procedure linkage table. Set
5289 it up. */
5290
cbe950e9 5291 if ((h->dynindx == -1
aec6b87e 5292 && !local_undefweak
0e1862bb 5293 && !((h->forced_local || bfd_link_executable (info))
cbe950e9
L		 5294 && h->def_regular
5295 && h->type == STT_GNU_IFUNC))
5296 || plt == NULL
5297 || gotplt == NULL
5298 || relplt == NULL)
cec7f46a 5299 abort ();
252b5132
RH		 5300
5301 /* Get the index in the procedure linkage table which
5302 corresponds to this symbol. This is the index of this symbol
5303 in all the symbols for which we are making plt entries. The
cbe950e9 5304 first entry in the procedure linkage table is reserved.
252b5132 5305
cbe950e9 5306 Get the offset into the .got table of the entry that
252b5132 5307 corresponds to this function. Each .got entry is 4 bytes.
cbe950e9 5308 The first three are reserved.
6bbec505 5309
cbe950e9
L		 5310 For static executables, we don't reserve anything. */
5311
6de2ae4a 5312 if (plt == htab->elf.splt)
cbe950e9 5313 {
e1f98742
L		 5314 got_offset = h->plt.offset / plt_entry_size - 1;
5315 got_offset = (got_offset + 3) * 4;
cbe950e9
L		 5316 }
5317 else
5318 {
e1f98742
L		 5319 got_offset = h->plt.offset / plt_entry_size;
5320 got_offset = got_offset * 4;
cbe950e9 5321 }
252b5132
RH		 5322
5323 /* Fill in the entry in the procedure linkage table. */
0e1862bb 5324 if (! bfd_link_pic (info))
252b5132 5325 {
25e762b9
RM		 5326 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
5327 abed->plt->plt_entry_size);
252b5132 5328 bfd_put_32 (output_bfd,
cbe950e9
L		 5329 (gotplt->output_section->vma
5330 + gotplt->output_offset
252b5132 5331 + got_offset),
25e762b9
RM		 5332 plt->contents + h->plt.offset
5333 + abed->plt->plt_got_offset);
eac338cf 5334
25e762b9 5335 if (abed->is_vxworks)
eac338cf
PB		 5336 {
5337 int s, k, reloc_index;
5338
5339 /* Create the R_386_32 relocation referencing the GOT
5340 for this PLT entry. */
5341
5342 /* S: Current slot number (zero-based). */
25e762b9
RM		 5343 s = ((h->plt.offset - abed->plt->plt_entry_size)
5344 / abed->plt->plt_entry_size);
eac338cf 5345 /* K: Number of relocations for PLTResolve. */
0e1862bb 5346 if (bfd_link_pic (info))
eac338cf
PB		 5347 k = PLTRESOLVE_RELOCS_SHLIB;
5348 else
5349 k = PLTRESOLVE_RELOCS;
5350 /* Skip the PLTresolve relocations, and the relocations for
5351 the other PLT slots. */
5352 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
5353 loc = (htab->srelplt2->contents + reloc_index
5354 * sizeof (Elf32_External_Rel));
5355
6de2ae4a
L		 5356 rel.r_offset = (htab->elf.splt->output_section->vma
5357 + htab->elf.splt->output_offset
eac338cf 5358 + h->plt.offset + 2),
7325306f 5359 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5360 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5361
5362 /* Create the R_386_32 relocation referencing the beginning of
5363 the PLT for this GOT entry. */
6de2ae4a
L		 5364 rel.r_offset = (htab->elf.sgotplt->output_section->vma
5365 + htab->elf.sgotplt->output_offset
eac338cf 5366 + got_offset);
7325306f 5367 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf 5368 bfd_elf32_swap_reloc_out (output_bfd, &rel,
13ca3149 5369 loc + sizeof (Elf32_External_Rel));
eac338cf 5370 }
252b5132
RH		 5371 }
5372 else
5373 {
25e762b9
RM		 5374 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
5375 abed->plt->plt_entry_size);
252b5132 5376 bfd_put_32 (output_bfd, got_offset,
25e762b9
RM		 5377 plt->contents + h->plt.offset
5378 + abed->plt->plt_got_offset);
252b5132
RH		 5379 }
5380
aec6b87e
L		 5381 /* Fill in the entry in the global offset table. Leave the entry
5382 as zero for undefined weak symbol in PIE. No PLT relocation
5383 against undefined weak symbol in PIE. */
5384 if (!local_undefweak)
cbe950e9 5385 {
cbe950e9 5386 bfd_put_32 (output_bfd,
aec6b87e
L		 5387 (plt->output_section->vma
5388 + plt->output_offset
5389 + h->plt.offset
5390 + abed->plt->plt_lazy_offset),
cbe950e9 5391 gotplt->contents + got_offset);
252b5132 5392
aec6b87e
L		 5393 /* Fill in the entry in the .rel.plt section. */
5394 rel.r_offset = (gotplt->output_section->vma
5395 + gotplt->output_offset
5396 + got_offset);
5397 if (h->dynindx == -1
5398 || ((bfd_link_executable (info)
5399 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5400 && h->def_regular
5401 && h->type == STT_GNU_IFUNC))
5402 {
5403 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5404 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5405 in the .got.plt section. */
5406 bfd_put_32 (output_bfd,
5407 (h->root.u.def.value
5408 + h->root.u.def.section->output_section->vma
5409 + h->root.u.def.section->output_offset),
5410 gotplt->contents + got_offset);
5411 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5412 /* R_386_IRELATIVE comes last. */
5413 plt_index = htab->next_irelative_index--;
5414 }
5415 else
5416 {
5417 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5418 plt_index = htab->next_jump_slot_index++;
5419 }
5420
5421 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5422 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5423
5424 /* Don't fill PLT entry for static executables. */
5425 if (plt == htab->elf.splt)
5426 {
5427 bfd_put_32 (output_bfd,
5428 plt_index * sizeof (Elf32_External_Rel),
5429 plt->contents + h->plt.offset
5430 + abed->plt->plt_reloc_offset);
5431 bfd_put_32 (output_bfd, - (h->plt.offset
5432 + abed->plt->plt_plt_offset + 4),
5433 plt->contents + h->plt.offset
5434 + abed->plt->plt_plt_offset);
5435 }
e1f98742 5436 }
dd7e64d4
L		 5437 }
5438 else if (eh->plt_got.offset != (bfd_vma) -1)
5439 {
5440 bfd_vma got_offset, plt_offset;
5441 asection *plt, *got, *gotplt;
5442 const bfd_byte *got_plt_entry;
5443
5444 /* Offset of displacement of the indirect jump. */
5445 bfd_vma plt_got_offset = 2;
e1f98742 5446
dd7e64d4
L		 5447 /* Set the entry in the GOT procedure linkage table. */
5448 plt = htab->plt_got;
5449 got = htab->elf.sgot;
5450 gotplt = htab->elf.sgotplt;
5451 got_offset = h->got.offset;
5452
5453 if (got_offset == (bfd_vma) -1
5454 || plt == NULL
5455 || got == NULL
5456 || gotplt == NULL)
5457 abort ();
5458
5459 /* Fill in the entry in the GOT procedure linkage table. */
0e1862bb 5460 if (! bfd_link_pic (info))
252b5132 5461 {
dd7e64d4
L		 5462 got_plt_entry = elf_i386_got_plt_entry;
5463 got_offset += got->output_section->vma + got->output_offset;
252b5132 5464 }
dd7e64d4
L		 5465 else
5466 {
5467 got_plt_entry = elf_i386_pic_got_plt_entry;
5468 got_offset += (got->output_section->vma
5469 + got->output_offset
5470 - gotplt->output_section->vma
5471 - gotplt->output_offset);
5472 }
5473
5474 plt_offset = eh->plt_got.offset;
5475 memcpy (plt->contents + plt_offset, got_plt_entry,
5476 sizeof (elf_i386_got_plt_entry));
5477 bfd_put_32 (output_bfd, got_offset,
5478 plt->contents + plt_offset + plt_got_offset);
5479 }
5480
aec6b87e
L		 5481 if (!local_undefweak
5482 && !h->def_regular
dd7e64d4
L		 5483 && (h->plt.offset != (bfd_vma) -1
5484 || eh->plt_got.offset != (bfd_vma) -1))
5485 {
5486 /* Mark the symbol as undefined, rather than as defined in
5487 the .plt section. Leave the value if there were any
5488 relocations where pointer equality matters (this is a clue
5489 for the dynamic linker, to make function pointer
5490 comparisons work between an application and shared
5491 library), otherwise set it to zero. If a function is only
5492 called from a binary, there is no need to slow down
5493 shared libraries because of that. */
5494 sym->st_shndx = SHN_UNDEF;
5495 if (!h->pointer_equality_needed)
5496 sym->st_value = 0;
252b5132
RH		 5497 }
5498
aec6b87e
L		 5499 /* Don't generate dynamic GOT relocation against undefined weak
5500 symbol in executable. */
13ae64f3 5501 if (h->got.offset != (bfd_vma) -1
67a4f2b7 5502 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
aec6b87e
L		 5503 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
5504 && !local_undefweak)
252b5132 5505 {
947216bf 5506 Elf_Internal_Rela rel;
233cc9c1 5507 asection *relgot = htab->elf.srelgot;
252b5132
RH		 5508
5509 /* This symbol has an entry in the global offset table. Set it
5510 up. */
5511
6de2ae4a 5512 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
ffb2e45b 5513 abort ();
252b5132 5514
6de2ae4a
L		 5515 rel.r_offset = (htab->elf.sgot->output_section->vma
5516 + htab->elf.sgot->output_offset
dc810e39 5517 + (h->got.offset & ~(bfd_vma) 1));
252b5132 5518
dd5724d5
AM		 5519 /* If this is a static link, or it is a -Bsymbolic link and the
5520 symbol is defined locally or was forced to be local because
5521 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 5522 The entry in the global offset table will already have been
5523 initialized in the relocate_section function. */
710ab287 5524 if (h->def_regular
0018b0a3
L		 5525 && h->type == STT_GNU_IFUNC)
5526 {
233cc9c1
L		 5527 if (h->plt.offset == (bfd_vma) -1)
5528 {
5529 /* STT_GNU_IFUNC is referenced without PLT. */
5530 if (htab->elf.splt == NULL)
5531 {
5532 /* use .rel[a].iplt section to store .got relocations
5533 in static executable. */
5534 relgot = htab->elf.irelplt;
5535 }
5536 if (SYMBOL_REFERENCES_LOCAL (info, h))
5537 {
5538 bfd_put_32 (output_bfd,
5539 (h->root.u.def.value
5540 + h->root.u.def.section->output_section->vma
5541 + h->root.u.def.section->output_offset),
5542 htab->elf.sgot->contents + h->got.offset);
5543 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5544 }
5545 else
5546 goto do_glob_dat;
5547 }
5548 else if (bfd_link_pic (info))
710ab287
L		 5549 {
5550 /* Generate R_386_GLOB_DAT. */
5551 goto do_glob_dat;
5552 }
5553 else
5554 {
cd2b2c10
L		 5555 asection *plt;
5556
710ab287
L		 5557 if (!h->pointer_equality_needed)
5558 abort ();
5559
5560 /* For non-shared object, we can't use .got.plt, which
5561 contains the real function addres if we need pointer
5562 equality. We load the GOT entry with the PLT entry. */
cd2b2c10 5563 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
710ab287
L		 5564 bfd_put_32 (output_bfd,
5565 (plt->output_section->vma
5566 + plt->output_offset + h->plt.offset),
6de2ae4a 5567 htab->elf.sgot->contents + h->got.offset);
710ab287
L		 5568 return TRUE;
5569 }
0018b0a3 5570 }
0e1862bb 5571 else if (bfd_link_pic (info)
0018b0a3 5572 && SYMBOL_REFERENCES_LOCAL (info, h))
dd5724d5 5573 {
6725bdbf 5574 BFD_ASSERT((h->got.offset & 1) != 0);
dd5724d5
AM		 5575 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5576 }
252b5132
RH		 5577 else
5578 {
dd5724d5 5579 BFD_ASSERT((h->got.offset & 1) == 0);
710ab287 5580do_glob_dat:
6725bdbf 5581 bfd_put_32 (output_bfd, (bfd_vma) 0,
6de2ae4a 5582 htab->elf.sgot->contents + h->got.offset);
252b5132
RH		 5583 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5584 }
5585
233cc9c1 5586 elf_append_rel (output_bfd, relgot, &rel);
252b5132
RH		 5587 }
5588
f5385ebf 5589 if (h->needs_copy)
252b5132 5590 {
947216bf 5591 Elf_Internal_Rela rel;
252b5132
RH		 5592
5593 /* This symbol needs a copy reloc. Set it up. */
5594
ffb2e45b
AM		 5595 if (h->dynindx == -1
5596 || (h->root.type != bfd_link_hash_defined
5597 && h->root.type != bfd_link_hash_defweak)
5598 || htab->srelbss == NULL)
5599 abort ();
252b5132
RH		 5600
5601 rel.r_offset = (h->root.u.def.value
5602 + h->root.u.def.section->output_section->vma
5603 + h->root.u.def.section->output_offset);
5604 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
59d6ffb2 5605 elf_append_rel (output_bfd, htab->srelbss, &rel);
252b5132
RH		 5606 }
5607
b34976b6 5608 return TRUE;
252b5132
RH		 5609}
5610
c25bc9fc
L		 5611/* Finish up local dynamic symbol handling. We set the contents of
5612 various dynamic sections here. */
5613
5614static bfd_boolean
5615elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5616{
5617 struct elf_link_hash_entry *h
5618 = (struct elf_link_hash_entry *) *slot;
5619 struct bfd_link_info *info
23209a78 5620 = (struct bfd_link_info *) inf;
c25bc9fc
L		 5621
5622 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5623 h, NULL);
5624}
5625
aec6b87e
L		 5626/* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5627 here since undefined weak symbol may not be dynamic and may not be
5628 called for elf_i386_finish_dynamic_symbol. */
5629
5630static bfd_boolean
5631elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5632 void *inf)
5633{
5634 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5635 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5636
5637 if (h->root.type != bfd_link_hash_undefweak
5638 || h->dynindx != -1)
5639 return TRUE;
5640
5641 return elf_i386_finish_dynamic_symbol (info->output_bfd,
5642 info, h, NULL);
5643}
5644
38701953
AM		 5645/* Used to decide how to sort relocs in an optimal manner for the
5646 dynamic linker, before writing them out. */
5647
5648static enum elf_reloc_type_class
cae1fbbb 5649elf_i386_reloc_type_class (const struct bfd_link_info *info,
7e612e98
AM		 5650 const asection *rel_sec ATTRIBUTE_UNUSED,
5651 const Elf_Internal_Rela *rela)
38701953 5652{
cae1fbbb
L		 5653 bfd *abfd = info->output_bfd;
5654 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5655 struct elf_link_hash_table *htab = elf_hash_table (info);
cae1fbbb 5656
d9e3b590
L		 5657 if (htab->dynsym != NULL
5658 && htab->dynsym->contents != NULL)
5659 {
5660 /* Check relocation against STT_GNU_IFUNC symbol if there are
5661 dynamic symbols. */
5662 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
c428ce9d
L		 5663 if (r_symndx != STN_UNDEF)
5664 {
5665 Elf_Internal_Sym sym;
5666 if (!bed->s->swap_symbol_in (abfd,
5667 (htab->dynsym->contents
5668 + r_symndx * sizeof (Elf32_External_Sym)),
5669 0, &sym))
5670 abort ();
d9e3b590 5671
c428ce9d
L		 5672 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5673 return reloc_class_ifunc;
5674 }
d9e3b590 5675 }
cae1fbbb 5676
55fd94b0 5677 switch (ELF32_R_TYPE (rela->r_info))
38701953 5678 {
c428ce9d
L		 5679 case R_386_IRELATIVE:
5680 return reloc_class_ifunc;
38701953
AM		 5681 case R_386_RELATIVE:
5682 return reloc_class_relative;
5683 case R_386_JUMP_SLOT:
5684 return reloc_class_plt;
5685 case R_386_COPY:
5686 return reloc_class_copy;
5687 default:
5688 return reloc_class_normal;
5689 }
5690}
5691
252b5132
RH		 5692/* Finish up the dynamic sections. */
5693
b34976b6 5694static bfd_boolean
55fd94b0
AM		 5695elf_i386_finish_dynamic_sections (bfd *output_bfd,
5696 struct bfd_link_info *info)
252b5132 5697{
6725bdbf 5698 struct elf_i386_link_hash_table *htab;
252b5132 5699 bfd *dynobj;
252b5132 5700 asection *sdyn;
25e762b9 5701 const struct elf_i386_backend_data *abed;
252b5132 5702
6725bdbf 5703 htab = elf_i386_hash_table (info);
4dfe6ac6
NC		 5704 if (htab == NULL)
5705 return FALSE;
5706
ebe50bae 5707 dynobj = htab->elf.dynobj;
3d4d4302 5708 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
25e762b9 5709 abed = get_elf_i386_backend_data (output_bfd);
252b5132 5710
ebe50bae 5711 if (htab->elf.dynamic_sections_created)
252b5132 5712 {
252b5132
RH		 5713 Elf32_External_Dyn *dyncon, *dynconend;
5714
6de2ae4a 5715 if (sdyn == NULL || htab->elf.sgot == NULL)
ffb2e45b 5716 abort ();
252b5132
RH		 5717
5718 dyncon = (Elf32_External_Dyn *) sdyn->contents;
eea6121a 5719 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
252b5132
RH		 5720 for (; dyncon < dynconend; dyncon++)
5721 {
5722 Elf_Internal_Dyn dyn;
51b64d56 5723 asection *s;
252b5132
RH		 5724
5725 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5726
5727 switch (dyn.d_tag)
5728 {
5729 default:
25e762b9
RM		 5730 if (abed->is_vxworks
5731 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
7a2b07ff 5732 break;
0ac8d2ca 5733 continue;
252b5132
RH		 5734
5735 case DT_PLTGOT:
6de2ae4a 5736 s = htab->elf.sgotplt;
8c37241b 5737 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
6725bdbf
AM		 5738 break;
5739
252b5132 5740 case DT_JMPREL:
6de2ae4a 5741 s = htab->elf.srelplt;
6348e046 5742 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
252b5132
RH		 5743 break;
5744
5745 case DT_PLTRELSZ:
6de2ae4a 5746 s = htab->elf.srelplt;
eea6121a 5747 dyn.d_un.d_val = s->size;
252b5132 5748 break;
252b5132 5749 }
0ac8d2ca
AM		 5750
5751 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
252b5132
RH		 5752 }
5753
5754 /* Fill in the first entry in the procedure linkage table. */
6de2ae4a 5755 if (htab->elf.splt && htab->elf.splt->size > 0)
252b5132 5756 {
0e1862bb 5757 if (bfd_link_pic (info))
eac338cf 5758 {
25e762b9
RM		 5759 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
5760 abed->plt->plt0_entry_size);
5761 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5762 abed->plt0_pad_byte,
5763 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
eac338cf 5764 }
252b5132
RH		 5765 else
5766 {
25e762b9
RM		 5767 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
5768 abed->plt->plt0_entry_size);
5769 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5770 abed->plt0_pad_byte,
5771 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
252b5132 5772 bfd_put_32 (output_bfd,
6de2ae4a
L		 5773 (htab->elf.sgotplt->output_section->vma
5774 + htab->elf.sgotplt->output_offset
6725bdbf 5775 + 4),
25e762b9
RM		 5776 htab->elf.splt->contents
5777 + abed->plt->plt0_got1_offset);
252b5132 5778 bfd_put_32 (output_bfd,
6de2ae4a
L		 5779 (htab->elf.sgotplt->output_section->vma
5780 + htab->elf.sgotplt->output_offset
6725bdbf 5781 + 8),
25e762b9
RM		 5782 htab->elf.splt->contents
5783 + abed->plt->plt0_got2_offset);
eac338cf 5784
25e762b9 5785 if (abed->is_vxworks)
eac338cf
PB		 5786 {
5787 Elf_Internal_Rela rel;
7325306f 5788
eac338cf
PB		 5789 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5790 On IA32 we use REL relocations so the addend goes in
5791 the PLT directly. */
6de2ae4a
L		 5792 rel.r_offset = (htab->elf.splt->output_section->vma
5793 + htab->elf.splt->output_offset
25e762b9 5794 + abed->plt->plt0_got1_offset);
7325306f 5795 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5796 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5797 htab->srelplt2->contents);
5798 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
6de2ae4a
L		 5799 rel.r_offset = (htab->elf.splt->output_section->vma
5800 + htab->elf.splt->output_offset
25e762b9 5801 + abed->plt->plt0_got2_offset);
7325306f 5802 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5803 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5804 htab->srelplt2->contents +
5805 sizeof (Elf32_External_Rel));
5806 }
252b5132
RH		 5807 }
5808
5809 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5810 really seem like the right value. */
6de2ae4a 5811 elf_section_data (htab->elf.splt->output_section)
6725bdbf 5812 ->this_hdr.sh_entsize = 4;
eac338cf
PB		 5813
5814 /* Correct the .rel.plt.unloaded relocations. */
0e1862bb 5815 if (abed->is_vxworks && !bfd_link_pic (info))
eac338cf 5816 {
25e762b9
RM		 5817 int num_plts = (htab->elf.splt->size
5818 / abed->plt->plt_entry_size) - 1;
4c9b0de6 5819 unsigned char *p;
eac338cf
PB		 5820
5821 p = htab->srelplt2->contents;
0e1862bb 5822 if (bfd_link_pic (info))
eac338cf
PB		 5823 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5824 else
5825 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5826
5827 for (; num_plts; num_plts--)
5828 {
5829 Elf_Internal_Rela rel;
5830 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 5831 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
eac338cf
PB		 5832 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5833 p += sizeof (Elf32_External_Rel);
5834
5835 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
7325306f 5836 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
eac338cf
PB		 5837 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5838 p += sizeof (Elf32_External_Rel);
5839 }
5840 }
252b5132
RH		 5841 }
5842 }
5843
6de2ae4a 5844 if (htab->elf.sgotplt)
252b5132 5845 {
56d4289c
L		 5846 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5847 {
4eca0228 5848 _bfd_error_handler
56d4289c
L		 5849 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5850 return FALSE;
5851 }
5852
12d0ee4a 5853 /* Fill in the first three entries in the global offset table. */
6de2ae4a 5854 if (htab->elf.sgotplt->size > 0)
12d0ee4a
AM		 5855 {
5856 bfd_put_32 (output_bfd,
55fd94b0 5857 (sdyn == NULL ? 0
12d0ee4a 5858 : sdyn->output_section->vma + sdyn->output_offset),
6de2ae4a
L		 5859 htab->elf.sgotplt->contents);
5860 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5861 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
12d0ee4a 5862 }
252b5132 5863
6de2ae4a 5864 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
12d0ee4a 5865 }
8c37241b 5866
e41b3a13 5867 /* Adjust .eh_frame for .plt section. */
9a2a56cc
AM		 5868 if (htab->plt_eh_frame != NULL
5869 && htab->plt_eh_frame->contents != NULL)
e41b3a13
JJ		 5870 {
5871 if (htab->elf.splt != NULL
5872 && htab->elf.splt->size != 0
5873 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5874 && htab->elf.splt->output_section != NULL
5875 && htab->plt_eh_frame->output_section != NULL)
5876 {
5877 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5878 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5879 + htab->plt_eh_frame->output_offset
5880 + PLT_FDE_START_OFFSET;
5881 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5882 htab->plt_eh_frame->contents
5883 + PLT_FDE_START_OFFSET);
5884 }
5885 if (htab->plt_eh_frame->sec_info_type
dbaa2011 5886 == SEC_INFO_TYPE_EH_FRAME)
e41b3a13
JJ		 5887 {
5888 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5889 htab->plt_eh_frame,
5890 htab->plt_eh_frame->contents))
5891 return FALSE;
5892 }
5893 }
5894
6de2ae4a
L		 5895 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5896 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
8c37241b 5897
aec6b87e
L		 5898 /* Fill PLT entries for undefined weak symbols in PIE. */
5899 if (bfd_link_pie (info))
5900 bfd_hash_traverse (&info->hash->table,
5901 elf_i386_pie_finish_undefweak_symbol,
5902 info);
5903
b34976b6 5904 return TRUE;
252b5132
RH		 5905}
5906
233cc9c1
L		 5907/* Fill PLT/GOT entries and allocate dynamic relocations for local
5908 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
5909 It has to be done before elf_link_sort_relocs is called so that
5910 dynamic relocations are properly sorted. */
5911
5912static bfd_boolean
5913elf_i386_output_arch_local_syms
5914 (bfd *output_bfd ATTRIBUTE_UNUSED,
5915 struct bfd_link_info *info,
5916 void *flaginfo ATTRIBUTE_UNUSED,
5917 int (*func) (void *, const char *,
5918 Elf_Internal_Sym *,
5919 asection *,
5920 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
5921{
5922 struct elf_i386_link_hash_table *htab = elf_i386_hash_table (info);
5923 if (htab == NULL)
5924 return FALSE;
5925
5926 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5927 htab_traverse (htab->loc_hash_table,
5928 elf_i386_finish_local_dynamic_symbol,
5929 info);
5930
5931 return TRUE;
5932}
5933
3972882e 5934/* Return an array of PLT entry symbol values. */
4c45e5c9 5935
3972882e
L		 5936static bfd_vma *
5937elf_i386_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5938 asection *relplt)
4c45e5c9 5939{
3972882e
L		 5940 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5941 arelent *p;
5942 long count, i;
5943 bfd_vma *plt_sym_val;
144bed8d 5944 bfd_vma plt_offset;
3972882e
L		 5945 bfd_byte *plt_contents;
5946 const struct elf_i386_backend_data *bed
5947 = get_elf_i386_backend_data (abfd);
5948 Elf_Internal_Shdr *hdr;
5949
5950 /* Get the .plt section contents. */
5951 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5952 if (plt_contents == NULL)
5953 return NULL;
5954 if (!bfd_get_section_contents (abfd, (asection *) plt,
5955 plt_contents, 0, plt->size))
5956 {
5957bad_return:
5958 free (plt_contents);
5959 return NULL;
5960 }
144bed8d 5961
3972882e
L		 5962 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5963 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5964 goto bad_return;
144bed8d 5965
3972882e
L		 5966 hdr = &elf_section_data (relplt)->this_hdr;
5967 count = relplt->size / hdr->sh_entsize;
5968
5969 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5970 if (plt_sym_val == NULL)
5971 goto bad_return;
cca5b8b6 5972
35181b3e 5973 for (i = 0; i < count; i++)
3972882e 5974 plt_sym_val[i] = -1;
cca5b8b6 5975
3972882e
L		 5976 plt_offset = bed->plt->plt_entry_size;
5977 p = relplt->relocation;
5978 for (i = 0; i < count; i++, p++)
144bed8d 5979 {
3972882e
L		 5980 long reloc_index;
5981
6f25f223 5982 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
533d0af0 5983 if (p->howto == NULL)
6f25f223 5984 continue;
533d0af0
L		 5985
5986 if (p->howto->type != R_386_JUMP_SLOT
5987 && p->howto->type != R_386_IRELATIVE)
3972882e
L		 5988 continue;
5989
5990 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5991 + bed->plt->plt_reloc_offset));
5992 reloc_index /= sizeof (Elf32_External_Rel);
ec1f73bb
AM		 5993 if (reloc_index < count)
5994 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5995
144bed8d 5996 plt_offset += bed->plt->plt_entry_size;
fca6ae69
L		 5997
5998 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5999 section. */
6000 if (plt_offset >= plt->size)
6001 break;
144bed8d
L		 6002 }
6003
3972882e
L		 6004 free (plt_contents);
6005
6006 return plt_sym_val;
6007}
6008
6009/* Similar to _bfd_elf_get_synthetic_symtab. */
6010
6011static long
6012elf_i386_get_synthetic_symtab (bfd *abfd,
6013 long symcount,
6014 asymbol **syms,
6015 long dynsymcount,
6016 asymbol **dynsyms,
6017 asymbol **ret)
6018{
6019 asection *plt = bfd_get_section_by_name (abfd, ".plt");
6020 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
6021 dynsymcount, dynsyms, ret,
6022 plt,
6023 elf_i386_get_plt_sym_val);
4c45e5c9
JJ		 6024}
6025
fdc90cb4
JJ		 6026/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6027
6028static bfd_boolean
6029elf_i386_hash_symbol (struct elf_link_hash_entry *h)
6030{
6031 if (h->plt.offset != (bfd_vma) -1
6032 && !h->def_regular
6033 && !h->pointer_equality_needed)
6034 return FALSE;
6035
6036 return _bfd_elf_hash_symbol (h);
6037}
4c45e5c9 6038
6d00b590 6039#define TARGET_LITTLE_SYM i386_elf32_vec
252b5132
RH		 6040#define TARGET_LITTLE_NAME "elf32-i386"
6041#define ELF_ARCH bfd_arch_i386
ae95ffa6 6042#define ELF_TARGET_ID I386_ELF_DATA
252b5132
RH		 6043#define ELF_MACHINE_CODE EM_386
6044#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 6045
6046#define elf_backend_can_gc_sections 1
51b64d56 6047#define elf_backend_can_refcount 1
252b5132
RH		 6048#define elf_backend_want_got_plt 1
6049#define elf_backend_plt_readonly 1
6050#define elf_backend_want_plt_sym 0
6051#define elf_backend_got_header_size 12
e41b3a13 6052#define elf_backend_plt_alignment 4
64f52338 6053#define elf_backend_dtrel_excludes_plt 1
f7483970 6054#define elf_backend_extern_protected_data 1
bedfd056 6055#define elf_backend_caches_rawsize 1
252b5132 6056
8c29f035
AM		 6057/* Support RELA for objdump of prelink objects. */
6058#define elf_info_to_howto elf_i386_info_to_howto_rel
dd5724d5
AM		 6059#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
6060
13ae64f3 6061#define bfd_elf32_mkobject elf_i386_mkobject
13ae64f3 6062
dd5724d5
AM		 6063#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
6064#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
6065#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
13285a1b 6066#define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
3972882e 6067#define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
dd5724d5
AM		 6068
6069#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
13285a1b 6070#define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
dd5724d5 6071#define elf_backend_check_relocs elf_i386_check_relocs
0ac8d2ca 6072#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6725bdbf 6073#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
0ac8d2ca 6074#define elf_backend_fake_sections elf_i386_fake_sections
dd5724d5
AM		 6075#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
6076#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
233cc9c1 6077#define elf_backend_output_arch_local_syms elf_i386_output_arch_local_syms
dd5724d5 6078#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
c5fccbec
DJ		 6079#define elf_backend_grok_prstatus elf_i386_grok_prstatus
6080#define elf_backend_grok_psinfo elf_i386_grok_psinfo
db6751f2 6081#define elf_backend_reloc_type_class elf_i386_reloc_type_class
0ac8d2ca
AM		 6082#define elf_backend_relocate_section elf_i386_relocate_section
6083#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
67a4f2b7 6084#define elf_backend_always_size_sections elf_i386_always_size_sections
74541ad4
AM		 6085#define elf_backend_omit_section_dynsym \
6086 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
fdc90cb4 6087#define elf_backend_hash_symbol elf_i386_hash_symbol
aec6b87e 6088#define elf_backend_fixup_symbol elf_i386_fixup_symbol
dd5724d5 6089
252b5132 6090#include "elf32-target.h"
2bc3c89a
AM		 6091
6092/* FreeBSD support. */
6093
6094#undef TARGET_LITTLE_SYM
6d00b590 6095#define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
2bc3c89a
AM		 6096#undef TARGET_LITTLE_NAME
6097#define TARGET_LITTLE_NAME "elf32-i386-freebsd"
d1036acb
L		 6098#undef ELF_OSABI
6099#define ELF_OSABI ELFOSABI_FREEBSD
2bc3c89a
AM		 6100
6101/* The kernel recognizes executables as valid only if they carry a
6102 "FreeBSD" label in the ELF header. So we put this label on all
6103 executables and (for simplicity) also all other object files. */
6104
2bc3c89a 6105static void
d8045f23 6106elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
2bc3c89a 6107{
78245035 6108 _bfd_elf_post_process_headers (abfd, info);
2bc3c89a 6109
2bc3c89a 6110#ifdef OLD_FREEBSD_ABI_LABEL
cf7363b4
L		 6111 {
6112 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
6113 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
6114 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
6115 }
caf47ea6 6116#endif
2bc3c89a
AM		 6117}
6118
6119#undef elf_backend_post_process_headers
d8045f23 6120#define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
571fe01f
NC		 6121#undef elf32_bed
6122#define elf32_bed elf32_i386_fbsd_bed
2bc3c89a 6123
d8045f23
NC		 6124#undef elf_backend_add_symbol_hook
6125
2bc3c89a 6126#include "elf32-target.h"
eac338cf 6127
a6cc6b3b
RO		 6128/* Solaris 2. */
6129
6130#undef TARGET_LITTLE_SYM
6d00b590 6131#define TARGET_LITTLE_SYM i386_elf32_sol2_vec
a6cc6b3b
RO		 6132#undef TARGET_LITTLE_NAME
6133#define TARGET_LITTLE_NAME "elf32-i386-sol2"
6134
914082d1
L		 6135#undef elf_backend_post_process_headers
6136
a6cc6b3b
RO		 6137/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6138 objects won't be recognized. */
6139#undef ELF_OSABI
6140
6141#undef elf32_bed
6142#define elf32_bed elf32_i386_sol2_bed
6143
7dc98aea
RO		 6144/* The 32-bit static TLS arena size is rounded to the nearest 8-byte
6145 boundary. */
84865015 6146#undef elf_backend_static_tls_alignment
7dc98aea
RO		 6147#define elf_backend_static_tls_alignment 8
6148
a6cc6b3b
RO		 6149/* The Solaris 2 ABI requires a plt symbol on all platforms.
6150
6151 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6152 File, p.63. */
84865015 6153#undef elf_backend_want_plt_sym
a6cc6b3b
RO		 6154#define elf_backend_want_plt_sym 1
6155
84865015
NC		 6156#undef elf_backend_strtab_flags
6157#define elf_backend_strtab_flags SHF_STRINGS
6158
5522f910
NC		 6159/* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
6160 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
6161 FALSE otherwise. ISECTION is the best guess matching section from the
6162 input bfd IBFD, but it might be NULL. */
6163
84865015 6164static bfd_boolean
5522f910
NC		 6165elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
6166 bfd *obfd ATTRIBUTE_UNUSED,
6167 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
6168 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
84865015
NC		 6169{
6170 /* PR 19938: FIXME: Need to add code for setting the sh_info
5522f910
NC		 6171 and sh_link fields of Solaris specific section types. */
6172 return FALSE;
84865015 6173
5522f910 6174 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
84865015
NC		 6175 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
6176
6177http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
6178
6179 The following values should be set:
6180
6181Type Link Info
6182-----------------------------------------------------------------------------
6183SHT_SUNW_ancillary The section header index of 0
6184 [0x6fffffee] the associated string table.
6185
6186SHT_SUNW_capinfo The section header index of For a dynamic object, the
6187 [0x6ffffff0] the associated symbol table. section header index of
6188 the associated
6189 SHT_SUNW_capchain table,
6190 otherwise 0.
6191
6192SHT_SUNW_symsort The section header index of 0
6193 [0x6ffffff1] the associated symbol table.
6194
6195SHT_SUNW_tlssort The section header index of 0
6196 [0x6ffffff2] the associated symbol table.
6197
6198SHT_SUNW_LDYNSYM The section header index of One greater than the
6199 [0x6ffffff3] the associated string table. symbol table index of the
6200 This index is the same string last local symbol,
6201 table used by the SHT_DYNSYM STB_LOCAL. Since
6202 section. SHT_SUNW_LDYNSYM only
6203 contains local symbols,
6204 sh_info is equivalent to
6205 the number of symbols in
6206 the table.
6207
6208SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
6209 [0x6ffffff5] the section header index of to named strings, the
6210 the associated section header index of
6211 SHT_SUNW_capinfo table, the associated string
6212 otherwise 0. table, otherwise 0.
6213
6214SHT_SUNW_move The section header index of 0
6215 [0x6ffffffa] the associated symbol table.
6216
6217SHT_SUNW_COMDAT 0 0
6218 [0x6ffffffb]
6219
6220SHT_SUNW_syminfo The section header index of The section header index
6221 [0x6ffffffc] the associated symbol table. of the associated
6222 .dynamic section.
6223
6224SHT_SUNW_verdef The section header index of The number of version
6225 [0x6ffffffd] the associated string table. definitions within the
6226 section.
6227
6228SHT_SUNW_verneed The section header index of The number of version
6229 [0x6ffffffe] the associated string table. dependencies within the
6230 section.
6231
6232SHT_SUNW_versym The section header index of 0
6233 [0x6fffffff] the associated symbol table. */
84865015
NC		 6234}
6235
5522f910
NC		 6236#undef elf_backend_copy_special_section_fields
6237#define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
84865015 6238
a6cc6b3b
RO		 6239#include "elf32-target.h"
6240
bf64a951
L		 6241/* Intel MCU support. */
6242
6243static bfd_boolean
6244elf32_iamcu_elf_object_p (bfd *abfd)
6245{
6246 /* Set the right machine number for an IAMCU elf32 file. */
6247 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
6248 return TRUE;
6249}
6250
6251#undef TARGET_LITTLE_SYM
6252#define TARGET_LITTLE_SYM iamcu_elf32_vec
6253#undef TARGET_LITTLE_NAME
6254#define TARGET_LITTLE_NAME "elf32-iamcu"
84865015 6255#undef ELF_ARCH
bf64a951
L		 6256#define ELF_ARCH bfd_arch_iamcu
6257
6258#undef ELF_MACHINE_CODE
6259#define ELF_MACHINE_CODE EM_IAMCU
6260
6261#undef ELF_OSABI
6262
6263#undef elf32_bed
6264#define elf32_bed elf32_iamcu_bed
6265
6266#undef elf_backend_object_p
6267#define elf_backend_object_p elf32_iamcu_elf_object_p
6268
6269#undef elf_backend_static_tls_alignment
6270
6271#undef elf_backend_want_plt_sym
6272#define elf_backend_want_plt_sym 0
6273
84865015 6274#undef elf_backend_strtab_flags
5522f910 6275#undef elf_backend_copy_special_section_fields
84865015 6276
bf64a951
L		 6277#include "elf32-target.h"
6278
6279/* Restore defaults. */
6280#undef ELF_ARCH
6281#define ELF_ARCH bfd_arch_i386
6282#undef ELF_MACHINE_CODE
6283#define ELF_MACHINE_CODE EM_386
6284
a27e4371
RM		 6285/* Native Client support. */
6286
6287#undef TARGET_LITTLE_SYM
6d00b590 6288#define TARGET_LITTLE_SYM i386_elf32_nacl_vec
a27e4371
RM		 6289#undef TARGET_LITTLE_NAME
6290#define TARGET_LITTLE_NAME "elf32-i386-nacl"
6291#undef elf32_bed
6292#define elf32_bed elf32_i386_nacl_bed
6293
6294#undef ELF_MAXPAGESIZE
6295#define ELF_MAXPAGESIZE 0x10000
6296
6297/* Restore defaults. */
6298#undef ELF_OSABI
6299#undef elf_backend_want_plt_sym
6300#define elf_backend_want_plt_sym 0
6301#undef elf_backend_post_process_headers
a27e4371
RM		 6302#undef elf_backend_static_tls_alignment
6303
6304/* NaCl uses substantially different PLT entries for the same effects. */
6305
6306#undef elf_backend_plt_alignment
6307#define elf_backend_plt_alignment 5
6308#define NACL_PLT_ENTRY_SIZE 64
6309#define NACLMASK 0xe0 /* 32-byte alignment mask. */
6310
6311static const bfd_byte elf_i386_nacl_plt0_entry[] =
6312 {
6313 0xff, 0x35, /* pushl contents of address */
6314 0, 0, 0, 0, /* replaced with address of .got + 4. */
6315 0x8b, 0x0d, /* movl contents of address, %ecx */
6316 0, 0, 0, 0, /* replaced with address of .got + 8. */
6317 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6318 0xff, 0xe1 /* jmp *%ecx */
6319 };
6320
6321static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6322 {
6323 0x8b, 0x0d, /* movl contents of address, %ecx */
6324 0, 0, 0, 0, /* replaced with GOT slot address. */
6325 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6326 0xff, 0xe1, /* jmp *%ecx */
6327
6328 /* Pad to the next 32-byte boundary with nop instructions. */
6329 0x90,
6330 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6331 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6332
6333 /* Lazy GOT entries point here (32-byte aligned). */
6334 0x68, /* pushl immediate */
6335 0, 0, 0, 0, /* replaced with reloc offset. */
6336 0xe9, /* jmp relative */
6337 0, 0, 0, 0, /* replaced with offset to .plt. */
6338
6339 /* Pad to the next 32-byte boundary with nop instructions. */
6340 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6341 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6342 0x90, 0x90
6343 };
6344
6345static const bfd_byte
6346elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
6347 {
6348 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6349 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6350 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6351 0xff, 0xe1, /* jmp *%ecx */
caa0075c
RM		 6352
6353 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6354 so pad to that size with nop instructions. */
6355 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
a27e4371
RM		 6356 };
6357
6358static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
6359 {
6360 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6361 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6362 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6363 0xff, 0xe1, /* jmp *%ecx */
6364
6365 /* Pad to the next 32-byte boundary with nop instructions. */
6366 0x90,
6367 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6368 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6369
6370 /* Lazy GOT entries point here (32-byte aligned). */
6371 0x68, /* pushl immediate */
6372 0, 0, 0, 0, /* replaced with offset into relocation table. */
6373 0xe9, /* jmp relative */
6374 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6375
6376 /* Pad to the next 32-byte boundary with nop instructions. */
6377 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6378 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6379 0x90, 0x90
6380 };
6381
6382static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6383 {
6384#if (PLT_CIE_LENGTH != 20 \
6385 || PLT_FDE_LENGTH != 36 \
6386 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6387 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6388# error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6389#endif
6390 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6391 0, 0, 0, 0, /* CIE ID */
6392 1, /* CIE version */
6393 'z', 'R', 0, /* Augmentation string */
6394 1, /* Code alignment factor */
6395 0x7c, /* Data alignment factor: -4 */
6396 8, /* Return address column */
6397 1, /* Augmentation size */
6398 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6399 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6400 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6401 DW_CFA_nop, DW_CFA_nop,
6402
6403 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6404 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6405 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6406 0, 0, 0, 0, /* .plt size goes here */
6407 0, /* Augmentation size */
6408 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
6409 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6410 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
6411 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6412 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6413 13, /* Block length */
6414 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
6415 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
6416 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6417 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6418 DW_CFA_nop, DW_CFA_nop
6419 };
6420
6421static const struct elf_i386_plt_layout elf_i386_nacl_plt =
6422 {
6423 elf_i386_nacl_plt0_entry, /* plt0_entry */
6424 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
6425 2, /* plt0_got1_offset */
6426 8, /* plt0_got2_offset */
6427 elf_i386_nacl_plt_entry, /* plt_entry */
6428 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6429 2, /* plt_got_offset */
6430 33, /* plt_reloc_offset */
6431 38, /* plt_plt_offset */
6432 32, /* plt_lazy_offset */
6433 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
6434 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
6435 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
6436 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
6437 };
6438
6439static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6440 {
6441 &elf_i386_nacl_plt, /* plt */
6442 0x90, /* plt0_pad_byte: nop insn */
6443 0, /* is_vxworks */
6444 };
6445
64b384e1
RM		 6446static bfd_boolean
6447elf32_i386_nacl_elf_object_p (bfd *abfd)
6448{
6449 /* Set the right machine number for a NaCl i386 ELF32 file. */
6450 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6451 return TRUE;
6452}
6453
a27e4371
RM		 6454#undef elf_backend_arch_data
6455#define elf_backend_arch_data &elf_i386_nacl_arch_bed
6456
64b384e1
RM		 6457#undef elf_backend_object_p
6458#define elf_backend_object_p elf32_i386_nacl_elf_object_p
5a68afcf
RM		 6459#undef elf_backend_modify_segment_map
6460#define elf_backend_modify_segment_map nacl_modify_segment_map
6461#undef elf_backend_modify_program_headers
6462#define elf_backend_modify_program_headers nacl_modify_program_headers
887badb3
RM		 6463#undef elf_backend_final_write_processing
6464#define elf_backend_final_write_processing nacl_final_write_processing
5a68afcf 6465
a27e4371
RM		 6466#include "elf32-target.h"
6467
5a68afcf 6468/* Restore defaults. */
64b384e1 6469#undef elf_backend_object_p
5a68afcf
RM		 6470#undef elf_backend_modify_segment_map
6471#undef elf_backend_modify_program_headers
887badb3 6472#undef elf_backend_final_write_processing
5a68afcf 6473
eac338cf
PB		 6474/* VxWorks support. */
6475
6476#undef TARGET_LITTLE_SYM
6d00b590 6477#define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
eac338cf
PB		 6478#undef TARGET_LITTLE_NAME
6479#define TARGET_LITTLE_NAME "elf32-i386-vxworks"
d1036acb 6480#undef ELF_OSABI
a27e4371
RM		 6481#undef elf_backend_plt_alignment
6482#define elf_backend_plt_alignment 4
eac338cf 6483
23209a78
RM		 6484static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6485 {
25e762b9 6486 &elf_i386_plt, /* plt */
23209a78
RM		 6487 0x90, /* plt0_pad_byte */
6488 1, /* is_vxworks */
6489 };
eac338cf 6490
23209a78
RM		 6491#undef elf_backend_arch_data
6492#define elf_backend_arch_data &elf_i386_vxworks_arch_bed
eac338cf 6493
13285a1b 6494#undef elf_backend_relocs_compatible
eac338cf
PB		 6495#undef elf_backend_add_symbol_hook
6496#define elf_backend_add_symbol_hook \
6497 elf_vxworks_add_symbol_hook
6498#undef elf_backend_link_output_symbol_hook
6499#define elf_backend_link_output_symbol_hook \
9c72ff84 6500 elf_vxworks_link_output_symbol_hook
eac338cf
PB		 6501#undef elf_backend_emit_relocs
6502#define elf_backend_emit_relocs elf_vxworks_emit_relocs
6503#undef elf_backend_final_write_processing
6504#define elf_backend_final_write_processing \
6505 elf_vxworks_final_write_processing
7dc98aea 6506#undef elf_backend_static_tls_alignment
eac338cf
PB		 6507
6508/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6509 define it. */
6510#undef elf_backend_want_plt_sym
6511#define elf_backend_want_plt_sym 1
6512
6513#undef elf32_bed
6514#define elf32_bed elf32_i386_vxworks_bed
6515
6516#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 1.422492 seconds and 4 git commands to generate.