WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/bfd/elf32-i386.c

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

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/bfd/elf32-i386.c – Rev 8031