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

Subversion Repositories Kolibri OS

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