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