WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/bfd/elflink.c

Rev	Author	Line No.	Line
5197	serge	1	/* ELF linking support for BFD.
		2	Copyright 1995-2013 Free Software Foundation, Inc.
		3
		4	This file is part of BFD, the Binary File Descriptor library.
		5
		6	This program is free software; you can redistribute it and/or modify
		7	it under the terms of the GNU General Public License as published by
		8	the Free Software Foundation; either version 3 of the License, or
		9	(at your option) any later version.
		10
		11	This program is distributed in the hope that it will be useful,
		12	but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		14	GNU General Public License for more details.
		15
		16	You should have received a copy of the GNU General Public License
		17	along with this program; if not, write to the Free Software
		18	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
		19	MA 02110-1301, USA. */
		20
		21	#include "sysdep.h"
		22	#include "bfd.h"
		23	#include "bfdlink.h"
		24	#include "libbfd.h"
		25	#define ARCH_SIZE 0
		26	#include "elf-bfd.h"
		27	#include "safe-ctype.h"
		28	#include "libiberty.h"
		29	#include "objalloc.h"
		30
		31	/* This struct is used to pass information to routines called via
		32	elf_link_hash_traverse which must return failure. */
		33
		34	struct elf_info_failed
		35	{
		36	struct bfd_link_info *info;
		37	bfd_boolean failed;
		38	};
		39
		40	/* This structure is used to pass information to
		41	_bfd_elf_link_find_version_dependencies. */
		42
		43	struct elf_find_verdep_info
		44	{
		45	/* General link information. */
		46	struct bfd_link_info *info;
		47	/* The number of dependencies. */
		48	unsigned int vers;
		49	/* Whether we had a failure. */
		50	bfd_boolean failed;
		51	};
		52
		53	static bfd_boolean _bfd_elf_fix_symbol_flags
		54	(struct elf_link_hash_entry , struct elf_info_failed );
		55
		56	/* Define a symbol in a dynamic linkage section. */
		57
		58	struct elf_link_hash_entry *
		59	_bfd_elf_define_linkage_sym (bfd *abfd,
		60	struct bfd_link_info *info,
		61	asection *sec,
		62	const char *name)
		63	{
		64	struct elf_link_hash_entry *h;
		65	struct bfd_link_hash_entry *bh;
		66	const struct elf_backend_data *bed;
		67
		68	h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
		69	if (h != NULL)
		70	{
		71	/* Zap symbol defined in an as-needed lib that wasn't linked.
		72	This is a symptom of a larger problem: Absolute symbols
		73	defined in shared libraries can't be overridden, because we
		74	lose the link to the bfd which is via the symbol section. */
		75	h->root.type = bfd_link_hash_new;
		76	}
		77
		78	bh = &h->root;
		79	if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
		80	sec, 0, NULL, FALSE,
		81	get_elf_backend_data (abfd)->collect,
		82	&bh))
		83	return NULL;
		84	h = (struct elf_link_hash_entry *) bh;
		85	h->def_regular = 1;
		86	h->non_elf = 0;
		87	h->type = STT_OBJECT;
		88	if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
		89	h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) \| STV_HIDDEN;
		90
		91	bed = get_elf_backend_data (abfd);
		92	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
		93	return h;
		94	}
		95
		96	bfd_boolean
		97	_bfd_elf_create_got_section (bfd abfd, struct bfd_link_info info)
		98	{
		99	flagword flags;
		100	asection *s;
		101	struct elf_link_hash_entry *h;
		102	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		103	struct elf_link_hash_table *htab = elf_hash_table (info);
		104
		105	/* This function may be called more than once. */
		106	s = bfd_get_linker_section (abfd, ".got");
		107	if (s != NULL)
		108	return TRUE;
		109
		110	flags = bed->dynamic_sec_flags;
		111
		112	s = bfd_make_section_anyway_with_flags (abfd,
		113	(bed->rela_plts_and_copies_p
		114	? ".rela.got" : ".rel.got"),
		115	(bed->dynamic_sec_flags
		116	\| SEC_READONLY));
		117	if (s == NULL
		118	\|\| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		119	return FALSE;
		120	htab->srelgot = s;
		121
		122	s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
		123	if (s == NULL
		124	\|\| !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		125	return FALSE;
		126	htab->sgot = s;
		127
		128	if (bed->want_got_plt)
		129	{
		130	s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
		131	if (s == NULL
		132	\|\| !bfd_set_section_alignment (abfd, s,
		133	bed->s->log_file_align))
		134	return FALSE;
		135	htab->sgotplt = s;
		136	}
		137
		138	/* The first bit of the global offset table is the header. */
		139	s->size += bed->got_header_size;
		140
		141	if (bed->want_got_sym)
		142	{
		143	/* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
		144	(or .got.plt) section. We don't do this in the linker script
		145	because we don't want to define the symbol if we are not creating
		146	a global offset table. */
		147	h = _bfd_elf_define_linkage_sym (abfd, info, s,
		148	"_GLOBAL_OFFSET_TABLE_");
		149	elf_hash_table (info)->hgot = h;
		150	if (h == NULL)
		151	return FALSE;
		152	}
		153
		154	return TRUE;
		155	}
		156
		157	/* Create a strtab to hold the dynamic symbol names. */
		158	static bfd_boolean
		159	_bfd_elf_link_create_dynstrtab (bfd abfd, struct bfd_link_info info)
		160	{
		161	struct elf_link_hash_table *hash_table;
		162
		163	hash_table = elf_hash_table (info);
		164	if (hash_table->dynobj == NULL)
		165	hash_table->dynobj = abfd;
		166
		167	if (hash_table->dynstr == NULL)
		168	{
		169	hash_table->dynstr = _bfd_elf_strtab_init ();
		170	if (hash_table->dynstr == NULL)
		171	return FALSE;
		172	}
		173	return TRUE;
		174	}
		175
		176	/* Create some sections which will be filled in with dynamic linking
		177	information. ABFD is an input file which requires dynamic sections
		178	to be created. The dynamic sections take up virtual memory space
		179	when the final executable is run, so we need to create them before
		180	addresses are assigned to the output sections. We work out the
		181	actual contents and size of these sections later. */
		182
		183	bfd_boolean
		184	_bfd_elf_link_create_dynamic_sections (bfd abfd, struct bfd_link_info info)
		185	{
		186	flagword flags;
		187	asection *s;
		188	const struct elf_backend_data *bed;
		189	struct elf_link_hash_entry *h;
		190
		191	if (! is_elf_hash_table (info->hash))
		192	return FALSE;
		193
		194	if (elf_hash_table (info)->dynamic_sections_created)
		195	return TRUE;
		196
		197	if (!_bfd_elf_link_create_dynstrtab (abfd, info))
		198	return FALSE;
		199
		200	abfd = elf_hash_table (info)->dynobj;
		201	bed = get_elf_backend_data (abfd);
		202
		203	flags = bed->dynamic_sec_flags;
		204
		205	/* A dynamically linked executable has a .interp section, but a
		206	shared library does not. */
		207	if (info->executable)
		208	{
		209	s = bfd_make_section_anyway_with_flags (abfd, ".interp",
		210	flags \| SEC_READONLY);
		211	if (s == NULL)
		212	return FALSE;
		213	}
		214
		215	/* Create sections to hold version informations. These are removed
		216	if they are not needed. */
		217	s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_d",
		218	flags \| SEC_READONLY);
		219	if (s == NULL
		220	\|\| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		221	return FALSE;
		222
		223	s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version",
		224	flags \| SEC_READONLY);
		225	if (s == NULL
		226	\|\| ! bfd_set_section_alignment (abfd, s, 1))
		227	return FALSE;
		228
		229	s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r",
		230	flags \| SEC_READONLY);
		231	if (s == NULL
		232	\|\| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		233	return FALSE;
		234
		235	s = bfd_make_section_anyway_with_flags (abfd, ".dynsym",
		236	flags \| SEC_READONLY);
		237	if (s == NULL
		238	\|\| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		239	return FALSE;
		240
		241	s = bfd_make_section_anyway_with_flags (abfd, ".dynstr",
		242	flags \| SEC_READONLY);
		243	if (s == NULL)
		244	return FALSE;
		245
		246	s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags);
		247	if (s == NULL
		248	\|\| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		249	return FALSE;
		250
		251	/* The special symbol _DYNAMIC is always set to the start of the
		252	.dynamic section. We could set _DYNAMIC in a linker script, but we
		253	only want to define it if we are, in fact, creating a .dynamic
		254	section. We don't want to define it if there is no .dynamic
		255	section, since on some ELF platforms the start up code examines it
		256	to decide how to initialize the process. */
		257	h = _bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC");
		258	elf_hash_table (info)->hdynamic = h;
		259	if (h == NULL)
		260	return FALSE;
		261
		262	if (info->emit_hash)
		263	{
		264	s = bfd_make_section_anyway_with_flags (abfd, ".hash",
		265	flags \| SEC_READONLY);
		266	if (s == NULL
		267	\|\| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		268	return FALSE;
		269	elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
		270	}
		271
		272	if (info->emit_gnu_hash)
		273	{
		274	s = bfd_make_section_anyway_with_flags (abfd, ".gnu.hash",
		275	flags \| SEC_READONLY);
		276	if (s == NULL
		277	\|\| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		278	return FALSE;
		279	/* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
		280	4 32-bit words followed by variable count of 64-bit words, then
		281	variable count of 32-bit words. */
		282	if (bed->s->arch_size == 64)
		283	elf_section_data (s)->this_hdr.sh_entsize = 0;
		284	else
		285	elf_section_data (s)->this_hdr.sh_entsize = 4;
		286	}
		287
		288	/* Let the backend create the rest of the sections. This lets the
		289	backend set the right flags. The backend will normally create
		290	the .got and .plt sections. */
		291	if (bed->elf_backend_create_dynamic_sections == NULL
		292	\|\| ! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
		293	return FALSE;
		294
		295	elf_hash_table (info)->dynamic_sections_created = TRUE;
		296
		297	return TRUE;
		298	}
		299
		300	/* Create dynamic sections when linking against a dynamic object. */
		301
		302	bfd_boolean
		303	_bfd_elf_create_dynamic_sections (bfd abfd, struct bfd_link_info info)
		304	{
		305	flagword flags, pltflags;
		306	struct elf_link_hash_entry *h;
		307	asection *s;
		308	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		309	struct elf_link_hash_table *htab = elf_hash_table (info);
		310
		311	/* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
		312	.rel[a].bss sections. */
		313	flags = bed->dynamic_sec_flags;
		314
		315	pltflags = flags;
		316	if (bed->plt_not_loaded)
		317	/* We do not clear SEC_ALLOC here because we still want the OS to
		318	allocate space for the section; it's just that there's nothing
		319	to read in from the object file. */
		320	pltflags &= ~ (SEC_CODE \| SEC_LOAD \| SEC_HAS_CONTENTS);
		321	else
		322	pltflags \|= SEC_ALLOC \| SEC_CODE \| SEC_LOAD;
		323	if (bed->plt_readonly)
		324	pltflags \|= SEC_READONLY;
		325
		326	s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
		327	if (s == NULL
		328	\|\| ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
		329	return FALSE;
		330	htab->splt = s;
		331
		332	/* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
		333	.plt section. */
		334	if (bed->want_plt_sym)
		335	{
		336	h = _bfd_elf_define_linkage_sym (abfd, info, s,
		337	"_PROCEDURE_LINKAGE_TABLE_");
		338	elf_hash_table (info)->hplt = h;
		339	if (h == NULL)
		340	return FALSE;
		341	}
		342
		343	s = bfd_make_section_anyway_with_flags (abfd,
		344	(bed->rela_plts_and_copies_p
		345	? ".rela.plt" : ".rel.plt"),
		346	flags \| SEC_READONLY);
		347	if (s == NULL
		348	\|\| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		349	return FALSE;
		350	htab->srelplt = s;
		351
		352	if (! _bfd_elf_create_got_section (abfd, info))
		353	return FALSE;
		354
		355	if (bed->want_dynbss)
		356	{
		357	/* The .dynbss section is a place to put symbols which are defined
		358	by dynamic objects, are referenced by regular objects, and are
		359	not functions. We must allocate space for them in the process
		360	image and use a R_*_COPY reloc to tell the dynamic linker to
		361	initialize them at run time. The linker script puts the .dynbss
		362	section into the .bss section of the final image. */
		363	s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
		364	(SEC_ALLOC \| SEC_LINKER_CREATED));
		365	if (s == NULL)
		366	return FALSE;
		367
		368	/* The .rel[a].bss section holds copy relocs. This section is not
		369	normally needed. We need to create it here, though, so that the
		370	linker will map it to an output section. We can't just create it
		371	only if we need it, because we will not know whether we need it
		372	until we have seen all the input files, and the first time the
		373	main linker code calls BFD after examining all the input files
		374	(size_dynamic_sections) the input sections have already been
		375	mapped to the output sections. If the section turns out not to
		376	be needed, we can discard it later. We will never need this
		377	section when generating a shared object, since they do not use
		378	copy relocs. */
		379	if (! info->shared)
		380	{
		381	s = bfd_make_section_anyway_with_flags (abfd,
		382	(bed->rela_plts_and_copies_p
		383	? ".rela.bss" : ".rel.bss"),
		384	flags \| SEC_READONLY);
		385	if (s == NULL
		386	\|\| ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
		387	return FALSE;
		388	}
		389	}
		390
		391	return TRUE;
		392	}
		393
		394	/* Record a new dynamic symbol. We record the dynamic symbols as we
		395	read the input files, since we need to have a list of all of them
		396	before we can determine the final sizes of the output sections.
		397	Note that we may actually call this function even though we are not
		398	going to output any dynamic symbols; in some cases we know that a
		399	symbol should be in the dynamic symbol table, but only if there is
		400	one. */
		401
		402	bfd_boolean
		403	bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
		404	struct elf_link_hash_entry *h)
		405	{
		406	if (h->dynindx == -1)
		407	{
		408	struct elf_strtab_hash *dynstr;
		409	char *p;
		410	const char *name;
		411	bfd_size_type indx;
		412
		413	/* XXX: The ABI draft says the linker must turn hidden and
		414	internal symbols into STB_LOCAL symbols when producing the
		415	DSO. However, if ld.so honors st_other in the dynamic table,
		416	this would not be necessary. */
		417	switch (ELF_ST_VISIBILITY (h->other))
		418	{
		419	case STV_INTERNAL:
		420	case STV_HIDDEN:
		421	if (h->root.type != bfd_link_hash_undefined
		422	&& h->root.type != bfd_link_hash_undefweak)
		423	{
		424	h->forced_local = 1;
		425	if (!elf_hash_table (info)->is_relocatable_executable)
		426	return TRUE;
		427	}
		428
		429	default:
		430	break;
		431	}
		432
		433	h->dynindx = elf_hash_table (info)->dynsymcount;
		434	++elf_hash_table (info)->dynsymcount;
		435
		436	dynstr = elf_hash_table (info)->dynstr;
		437	if (dynstr == NULL)
		438	{
		439	/* Create a strtab to hold the dynamic symbol names. */
		440	elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
		441	if (dynstr == NULL)
		442	return FALSE;
		443	}
		444
		445	/* We don't put any version information in the dynamic string
		446	table. */
		447	name = h->root.root.string;
		448	p = strchr (name, ELF_VER_CHR);
		449	if (p != NULL)
		450	/* We know that the p points into writable memory. In fact,
		451	there are only a few symbols that have read-only names, being
		452	those like _GLOBAL_OFFSET_TABLE_ that are created specially
		453	by the backends. Most symbols will have names pointing into
		454	an ELF string table read from a file, or to objalloc memory. */
		455	*p = 0;
		456
		457	indx = _bfd_elf_strtab_add (dynstr, name, p != NULL);
		458
		459	if (p != NULL)
		460	*p = ELF_VER_CHR;
		461
		462	if (indx == (bfd_size_type) -1)
		463	return FALSE;
		464	h->dynstr_index = indx;
		465	}
		466
		467	return TRUE;
		468	}
		469
		470	/* Mark a symbol dynamic. */
		471
		472	static void
		473	bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
		474	struct elf_link_hash_entry *h,
		475	Elf_Internal_Sym *sym)
		476	{
		477	struct bfd_elf_dynamic_list *d = info->dynamic_list;
		478
		479	/* It may be called more than once on the same H. */
		480	if(h->dynamic \|\| info->relocatable)
		481	return;
		482
		483	if ((info->dynamic_data
		484	&& (h->type == STT_OBJECT
		485	\|\| (sym != NULL
		486	&& ELF_ST_TYPE (sym->st_info) == STT_OBJECT)))
		487	\|\| (d != NULL
		488	&& h->root.type == bfd_link_hash_new
		489	&& (*d->match) (&d->head, NULL, h->root.root.string)))
		490	h->dynamic = 1;
		491	}
		492
		493	/* Record an assignment to a symbol made by a linker script. We need
		494	this in case some dynamic object refers to this symbol. */
		495
		496	bfd_boolean
		497	bfd_elf_record_link_assignment (bfd *output_bfd,
		498	struct bfd_link_info *info,
		499	const char *name,
		500	bfd_boolean provide,
		501	bfd_boolean hidden)
		502	{
		503	struct elf_link_hash_entry h, hv;
		504	struct elf_link_hash_table *htab;
		505	const struct elf_backend_data *bed;
		506
		507	if (!is_elf_hash_table (info->hash))
		508	return TRUE;
		509
		510	htab = elf_hash_table (info);
		511	h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
		512	if (h == NULL)
		513	return provide;
		514
		515	switch (h->root.type)
		516	{
		517	case bfd_link_hash_defined:
		518	case bfd_link_hash_defweak:
		519	case bfd_link_hash_common:
		520	break;
		521	case bfd_link_hash_undefweak:
		522	case bfd_link_hash_undefined:
		523	/* Since we're defining the symbol, don't let it seem to have not
		524	been defined. record_dynamic_symbol and size_dynamic_sections
		525	may depend on this. */
		526	h->root.type = bfd_link_hash_new;
		527	if (h->root.u.undef.next != NULL \|\| htab->root.undefs_tail == &h->root)
		528	bfd_link_repair_undef_list (&htab->root);
		529	break;
		530	case bfd_link_hash_new:
		531	bfd_elf_link_mark_dynamic_symbol (info, h, NULL);
		532	h->non_elf = 0;
		533	break;
		534	case bfd_link_hash_indirect:
		535	/* We had a versioned symbol in a dynamic library. We make the
		536	the versioned symbol point to this one. */
		537	bed = get_elf_backend_data (output_bfd);
		538	hv = h;
		539	while (hv->root.type == bfd_link_hash_indirect
		540	\|\| hv->root.type == bfd_link_hash_warning)
		541	hv = (struct elf_link_hash_entry *) hv->root.u.i.link;
		542	/* We don't need to update h->root.u since linker will set them
		543	later. */
		544	h->root.type = bfd_link_hash_undefined;
		545	hv->root.type = bfd_link_hash_indirect;
		546	hv->root.u.i.link = (struct bfd_link_hash_entry *) h;
		547	(*bed->elf_backend_copy_indirect_symbol) (info, h, hv);
		548	break;
		549	case bfd_link_hash_warning:
		550	abort ();
		551	break;
		552	}
		553
		554	/* If this symbol is being provided by the linker script, and it is
		555	currently defined by a dynamic object, but not by a regular
		556	object, then mark it as undefined so that the generic linker will
		557	force the correct value. */
		558	if (provide
		559	&& h->def_dynamic
		560	&& !h->def_regular)
		561	h->root.type = bfd_link_hash_undefined;
		562
		563	/* If this symbol is not being provided by the linker script, and it is
		564	currently defined by a dynamic object, but not by a regular object,
		565	then clear out any version information because the symbol will not be
		566	associated with the dynamic object any more. */
		567	if (!provide
		568	&& h->def_dynamic
		569	&& !h->def_regular)
		570	h->verinfo.verdef = NULL;
		571
		572	h->def_regular = 1;
		573
		574	if (hidden)
		575	{
		576	bed = get_elf_backend_data (output_bfd);
		577	if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
		578	h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) \| STV_HIDDEN;
		579	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
		580	}
		581
		582	/* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
		583	and executables. */
		584	if (!info->relocatable
		585	&& h->dynindx != -1
		586	&& (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
		587	\|\| ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
		588	h->forced_local = 1;
		589
		590	if ((h->def_dynamic
		591	\|\| h->ref_dynamic
		592	\|\| info->shared
		593	\|\| (info->executable && elf_hash_table (info)->is_relocatable_executable))
		594	&& h->dynindx == -1)
		595	{
		596	if (! bfd_elf_link_record_dynamic_symbol (info, h))
		597	return FALSE;
		598
		599	/* If this is a weak defined symbol, and we know a corresponding
		600	real symbol from the same dynamic object, make sure the real
		601	symbol is also made into a dynamic symbol. */
		602	if (h->u.weakdef != NULL
		603	&& h->u.weakdef->dynindx == -1)
		604	{
		605	if (! bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
		606	return FALSE;
		607	}
		608	}
		609
		610	return TRUE;
		611	}
		612
		613	/* Record a new local dynamic symbol. Returns 0 on failure, 1 on
		614	success, and 2 on a failure caused by attempting to record a symbol
		615	in a discarded section, eg. a discarded link-once section symbol. */
		616
		617	int
		618	bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
		619	bfd *input_bfd,
		620	long input_indx)
		621	{
		622	bfd_size_type amt;
		623	struct elf_link_local_dynamic_entry *entry;
		624	struct elf_link_hash_table *eht;
		625	struct elf_strtab_hash *dynstr;
		626	unsigned long dynstr_index;
		627	char *name;
		628	Elf_External_Sym_Shndx eshndx;
		629	char esym[sizeof (Elf64_External_Sym)];
		630
		631	if (! is_elf_hash_table (info->hash))
		632	return 0;
		633
		634	/* See if the entry exists already. */
		635	for (entry = elf_hash_table (info)->dynlocal; entry ; entry = entry->next)
		636	if (entry->input_bfd == input_bfd && entry->input_indx == input_indx)
		637	return 1;
		638
		639	amt = sizeof (*entry);
		640	entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
		641	if (entry == NULL)
		642	return 0;
		643
		644	/* Go find the symbol, so that we can find it's name. */
		645	if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
		646	1, input_indx, &entry->isym, esym, &eshndx))
		647	{
		648	bfd_release (input_bfd, entry);
		649	return 0;
		650	}
		651
		652	if (entry->isym.st_shndx != SHN_UNDEF
		653	&& entry->isym.st_shndx < SHN_LORESERVE)
		654	{
		655	asection *s;
		656
		657	s = bfd_section_from_elf_index (input_bfd, entry->isym.st_shndx);
		658	if (s == NULL \|\| bfd_is_abs_section (s->output_section))
		659	{
		660	/* We can still bfd_release here as nothing has done another
		661	bfd_alloc. We can't do this later in this function. */
		662	bfd_release (input_bfd, entry);
		663	return 2;
		664	}
		665	}
		666
		667	name = (bfd_elf_string_from_elf_section
		668	(input_bfd, elf_tdata (input_bfd)->symtab_hdr.sh_link,
		669	entry->isym.st_name));
		670
		671	dynstr = elf_hash_table (info)->dynstr;
		672	if (dynstr == NULL)
		673	{
		674	/* Create a strtab to hold the dynamic symbol names. */
		675	elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
		676	if (dynstr == NULL)
		677	return 0;
		678	}
		679
		680	dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
		681	if (dynstr_index == (unsigned long) -1)
		682	return 0;
		683	entry->isym.st_name = dynstr_index;
		684
		685	eht = elf_hash_table (info);
		686
		687	entry->next = eht->dynlocal;
		688	eht->dynlocal = entry;
		689	entry->input_bfd = input_bfd;
		690	entry->input_indx = input_indx;
		691	eht->dynsymcount++;
		692
		693	/* Whatever binding the symbol had before, it's now local. */
		694	entry->isym.st_info
		695	= ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (entry->isym.st_info));
		696
		697	/* The dynindx will be set at the end of size_dynamic_sections. */
		698
		699	return 1;
		700	}
		701
		702	/* Return the dynindex of a local dynamic symbol. */
		703
		704	long
		705	_bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
		706	bfd *input_bfd,
		707	long input_indx)
		708	{
		709	struct elf_link_local_dynamic_entry *e;
		710
		711	for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
		712	if (e->input_bfd == input_bfd && e->input_indx == input_indx)
		713	return e->dynindx;
		714	return -1;
		715	}
		716
		717	/* This function is used to renumber the dynamic symbols, if some of
		718	them are removed because they are marked as local. This is called
		719	via elf_link_hash_traverse. */
		720
		721	static bfd_boolean
		722	elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
		723	void *data)
		724	{
		725	size_t count = (size_t ) data;
		726
		727	if (h->forced_local)
		728	return TRUE;
		729
		730	if (h->dynindx != -1)
		731	h->dynindx = ++(*count);
		732
		733	return TRUE;
		734	}
		735
		736
		737	/* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
		738	STB_LOCAL binding. */
		739
		740	static bfd_boolean
		741	elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
		742	void *data)
		743	{
		744	size_t count = (size_t ) data;
		745
		746	if (!h->forced_local)
		747	return TRUE;
		748
		749	if (h->dynindx != -1)
		750	h->dynindx = ++(*count);
		751
		752	return TRUE;
		753	}
		754
		755	/* Return true if the dynamic symbol for a given section should be
		756	omitted when creating a shared library. */
		757	bfd_boolean
		758	_bfd_elf_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
		759	struct bfd_link_info *info,
		760	asection *p)
		761	{
		762	struct elf_link_hash_table *htab;
		763
		764	switch (elf_section_data (p)->this_hdr.sh_type)
		765	{
		766	case SHT_PROGBITS:
		767	case SHT_NOBITS:
		768	/* If sh_type is yet undecided, assume it could be
		769	SHT_PROGBITS/SHT_NOBITS. */
		770	case SHT_NULL:
		771	htab = elf_hash_table (info);
		772	if (p == htab->tls_sec)
		773	return FALSE;
		774
		775	if (htab->text_index_section != NULL)
		776	return p != htab->text_index_section && p != htab->data_index_section;
		777
		778	if (strcmp (p->name, ".got") == 0
		779	\|\| strcmp (p->name, ".got.plt") == 0
		780	\|\| strcmp (p->name, ".plt") == 0)
		781	{
		782	asection *ip;
		783
		784	if (htab->dynobj != NULL
		785	&& (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL
		786	&& ip->output_section == p)
		787	return TRUE;
		788	}
		789	return FALSE;
		790
		791	/* There shouldn't be section relative relocations
		792	against any other section. */
		793	default:
		794	return TRUE;
		795	}
		796	}
		797
		798	/* Assign dynsym indices. In a shared library we generate a section
		799	symbol for each output section, which come first. Next come symbols
		800	which have been forced to local binding. Then all of the back-end
		801	allocated local dynamic syms, followed by the rest of the global
		802	symbols. */
		803
		804	static unsigned long
		805	_bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
		806	struct bfd_link_info *info,
		807	unsigned long *section_sym_count)
		808	{
		809	unsigned long dynsymcount = 0;
		810
		811	if (info->shared \|\| elf_hash_table (info)->is_relocatable_executable)
		812	{
		813	const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
		814	asection *p;
		815	for (p = output_bfd->sections; p ; p = p->next)
		816	if ((p->flags & SEC_EXCLUDE) == 0
		817	&& (p->flags & SEC_ALLOC) != 0
		818	&& !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
		819	elf_section_data (p)->dynindx = ++dynsymcount;
		820	else
		821	elf_section_data (p)->dynindx = 0;
		822	}
		823	*section_sym_count = dynsymcount;
		824
		825	elf_link_hash_traverse (elf_hash_table (info),
		826	elf_link_renumber_local_hash_table_dynsyms,
		827	&dynsymcount);
		828
		829	if (elf_hash_table (info)->dynlocal)
		830	{
		831	struct elf_link_local_dynamic_entry *p;
		832	for (p = elf_hash_table (info)->dynlocal; p ; p = p->next)
		833	p->dynindx = ++dynsymcount;
		834	}
		835
		836	elf_link_hash_traverse (elf_hash_table (info),
		837	elf_link_renumber_hash_table_dynsyms,
		838	&dynsymcount);
		839
		840	/* There is an unused NULL entry at the head of the table which
		841	we must account for in our count. Unless there weren't any
		842	symbols, which means we'll have no table at all. */
		843	if (dynsymcount != 0)
		844	++dynsymcount;
		845
		846	elf_hash_table (info)->dynsymcount = dynsymcount;
		847	return dynsymcount;
		848	}
		849
		850	/* Merge st_other field. */
		851
		852	static void
		853	elf_merge_st_other (bfd abfd, struct elf_link_hash_entry h,
		854	Elf_Internal_Sym *isym, bfd_boolean definition,
		855	bfd_boolean dynamic)
		856	{
		857	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		858
		859	/* If st_other has a processor-specific meaning, specific
		860	code might be needed here. We never merge the visibility
		861	attribute with the one from a dynamic object. */
		862	if (bed->elf_backend_merge_symbol_attribute)
		863	(*bed->elf_backend_merge_symbol_attribute) (h, isym, definition,
		864	dynamic);
		865
		866	/* If this symbol has default visibility and the user has requested
		867	we not re-export it, then mark it as hidden. */
		868	if (definition
		869	&& !dynamic
		870	&& (abfd->no_export
		871	\|\| (abfd->my_archive && abfd->my_archive->no_export))
		872	&& ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
		873	isym->st_other = (STV_HIDDEN
		874	\| (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
		875
		876	if (!dynamic && ELF_ST_VISIBILITY (isym->st_other) != 0)
		877	{
		878	unsigned char hvis, symvis, other, nvis;
		879
		880	/* Only merge the visibility. Leave the remainder of the
		881	st_other field to elf_backend_merge_symbol_attribute. */
		882	other = h->other & ~ELF_ST_VISIBILITY (-1);
		883
		884	/* Combine visibilities, using the most constraining one. */
		885	hvis = ELF_ST_VISIBILITY (h->other);
		886	symvis = ELF_ST_VISIBILITY (isym->st_other);
		887	if (! hvis)
		888	nvis = symvis;
		889	else if (! symvis)
		890	nvis = hvis;
		891	else
		892	nvis = hvis < symvis ? hvis : symvis;
		893
		894	h->other = other \| nvis;
		895	}
		896	}
		897
		898	/* This function is called when we want to merge a new symbol with an
		899	existing symbol. It handles the various cases which arise when we
		900	find a definition in a dynamic object, or when there is already a
		901	definition in a dynamic object. The new symbol is described by
		902	NAME, SYM, PSEC, and PVALUE. We set SYM_HASH to the hash table
		903	entry. We set POLDBFD to the old symbol's BFD. We set POLD_WEAK
		904	if the old symbol was weak. We set POLD_ALIGNMENT to the alignment
		905	of an old common symbol. We set OVERRIDE if the old symbol is
		906	overriding a new definition. We set TYPE_CHANGE_OK if it is OK for
		907	the type to change. We set SIZE_CHANGE_OK if it is OK for the size
		908	to change. By OK to change, we mean that we shouldn't warn if the
		909	type or size does change. */
		910
		911	static bfd_boolean
		912	_bfd_elf_merge_symbol (bfd *abfd,
		913	struct bfd_link_info *info,
		914	const char *name,
		915	Elf_Internal_Sym *sym,
		916	asection **psec,
		917	bfd_vma *pvalue,
		918	struct elf_link_hash_entry **sym_hash,
		919	bfd **poldbfd,
		920	bfd_boolean *pold_weak,
		921	unsigned int *pold_alignment,
		922	bfd_boolean *skip,
		923	bfd_boolean *override,
		924	bfd_boolean *type_change_ok,
		925	bfd_boolean *size_change_ok)
		926	{
		927	asection sec, oldsec;
		928	struct elf_link_hash_entry *h;
		929	struct elf_link_hash_entry *hi;
		930	struct elf_link_hash_entry *flip;
		931	int bind;
		932	bfd *oldbfd;
		933	bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
		934	bfd_boolean newweak, oldweak, newfunc, oldfunc;
		935	const struct elf_backend_data *bed;
		936
		937	*skip = FALSE;
		938	*override = FALSE;
		939
		940	sec = *psec;
		941	bind = ELF_ST_BIND (sym->st_info);
		942
		943	if (! bfd_is_und_section (sec))
		944	h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
		945	else
		946	h = ((struct elf_link_hash_entry *)
		947	bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
		948	if (h == NULL)
		949	return FALSE;
		950	*sym_hash = h;
		951
		952	bed = get_elf_backend_data (abfd);
		953
		954	/* For merging, we only care about real symbols. But we need to make
		955	sure that indirect symbol dynamic flags are updated. */
		956	hi = h;
		957	while (h->root.type == bfd_link_hash_indirect
		958	\|\| h->root.type == bfd_link_hash_warning)
		959	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		960
		961	/* OLDBFD and OLDSEC are a BFD and an ASECTION associated with the
		962	existing symbol. */
		963
		964	oldbfd = NULL;
		965	oldsec = NULL;
		966	switch (h->root.type)
		967	{
		968	default:
		969	break;
		970
		971	case bfd_link_hash_undefined:
		972	case bfd_link_hash_undefweak:
		973	oldbfd = h->root.u.undef.abfd;
		974	break;
		975
		976	case bfd_link_hash_defined:
		977	case bfd_link_hash_defweak:
		978	oldbfd = h->root.u.def.section->owner;
		979	oldsec = h->root.u.def.section;
		980	break;
		981
		982	case bfd_link_hash_common:
		983	oldbfd = h->root.u.c.p->section->owner;
		984	oldsec = h->root.u.c.p->section;
		985	if (pold_alignment)
		986	*pold_alignment = h->root.u.c.p->alignment_power;
		987	break;
		988	}
		989	if (poldbfd && *poldbfd == NULL)
		990	*poldbfd = oldbfd;
		991
		992	/* Differentiate strong and weak symbols. */
		993	newweak = bind == STB_WEAK;
		994	oldweak = (h->root.type == bfd_link_hash_defweak
		995	\|\| h->root.type == bfd_link_hash_undefweak);
		996	if (pold_weak)
		997	*pold_weak = oldweak;
		998
		999	/* This code is for coping with dynamic objects, and is only useful
		1000	if we are doing an ELF link. */
		1001	if (!(*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
		1002	return TRUE;
		1003
		1004	/* We have to check it for every instance since the first few may be
		1005	references and not all compilers emit symbol type for undefined
		1006	symbols. */
		1007	bfd_elf_link_mark_dynamic_symbol (info, h, sym);
		1008
		1009	/* NEWDYN and OLDDYN indicate whether the new or old symbol,
		1010	respectively, is from a dynamic object. */
		1011
		1012	newdyn = (abfd->flags & DYNAMIC) != 0;
		1013
		1014	/* ref_dynamic_nonweak and dynamic_def flags track actual undefined
		1015	syms and defined syms in dynamic libraries respectively.
		1016	ref_dynamic on the other hand can be set for a symbol defined in
		1017	a dynamic library, and def_dynamic may not be set; When the
		1018	definition in a dynamic lib is overridden by a definition in the
		1019	executable use of the symbol in the dynamic lib becomes a
		1020	reference to the executable symbol. */
		1021	if (newdyn)
		1022	{
		1023	if (bfd_is_und_section (sec))
		1024	{
		1025	if (bind != STB_WEAK)
		1026	{
		1027	h->ref_dynamic_nonweak = 1;
		1028	hi->ref_dynamic_nonweak = 1;
		1029	}
		1030	}
		1031	else
		1032	{
		1033	h->dynamic_def = 1;
		1034	hi->dynamic_def = 1;
		1035	}
		1036	}
		1037
		1038	/* If we just created the symbol, mark it as being an ELF symbol.
		1039	Other than that, there is nothing to do--there is no merge issue
		1040	with a newly defined symbol--so we just return. */
		1041
		1042	if (h->root.type == bfd_link_hash_new)
		1043	{
		1044	h->non_elf = 0;
		1045	return TRUE;
		1046	}
		1047
		1048	/* In cases involving weak versioned symbols, we may wind up trying
		1049	to merge a symbol with itself. Catch that here, to avoid the
		1050	confusion that results if we try to override a symbol with
		1051	itself. The additional tests catch cases like
		1052	_GLOBAL_OFFSET_TABLE_, which are regular symbols defined in a
		1053	dynamic object, which we do want to handle here. */
		1054	if (abfd == oldbfd
		1055	&& (newweak \|\| oldweak)
		1056	&& ((abfd->flags & DYNAMIC) == 0
		1057	\|\| !h->def_regular))
		1058	return TRUE;
		1059
		1060	olddyn = FALSE;
		1061	if (oldbfd != NULL)
		1062	olddyn = (oldbfd->flags & DYNAMIC) != 0;
		1063	else if (oldsec != NULL)
		1064	{
		1065	/* This handles the special SHN_MIPS_{TEXT,DATA} section
		1066	indices used by MIPS ELF. */
		1067	olddyn = (oldsec->symbol->flags & BSF_DYNAMIC) != 0;
		1068	}
		1069
		1070	/* NEWDEF and OLDDEF indicate whether the new or old symbol,
		1071	respectively, appear to be a definition rather than reference. */
		1072
		1073	newdef = !bfd_is_und_section (sec) && !bfd_is_com_section (sec);
		1074
		1075	olddef = (h->root.type != bfd_link_hash_undefined
		1076	&& h->root.type != bfd_link_hash_undefweak
		1077	&& h->root.type != bfd_link_hash_common);
		1078
		1079	/* NEWFUNC and OLDFUNC indicate whether the new or old symbol,
		1080	respectively, appear to be a function. */
		1081
		1082	newfunc = (ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
		1083	&& bed->is_function_type (ELF_ST_TYPE (sym->st_info)));
		1084
		1085	oldfunc = (h->type != STT_NOTYPE
		1086	&& bed->is_function_type (h->type));
		1087
		1088	/* When we try to create a default indirect symbol from the dynamic
		1089	definition with the default version, we skip it if its type and
		1090	the type of existing regular definition mismatch. We only do it
		1091	if the existing regular definition won't be dynamic. */
		1092	if (pold_alignment == NULL
		1093	&& !info->shared
		1094	&& !info->export_dynamic
		1095	&& !h->ref_dynamic
		1096	&& newdyn
		1097	&& newdef
		1098	&& !olddyn
		1099	&& (olddef \|\| h->root.type == bfd_link_hash_common)
		1100	&& ELF_ST_TYPE (sym->st_info) != h->type
		1101	&& ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
		1102	&& h->type != STT_NOTYPE
		1103	&& !(newfunc && oldfunc))
		1104	{
		1105	*skip = TRUE;
		1106	return TRUE;
		1107	}
		1108
		1109	/* Plugin symbol type isn't currently set. Stop bogus errors. */
		1110	if (oldbfd != NULL && (oldbfd->flags & BFD_PLUGIN) != 0)
		1111	*type_change_ok = TRUE;
		1112
		1113	/* Check TLS symbol. We don't check undefined symbol introduced by
		1114	"ld -u". */
		1115	else if (oldbfd != NULL
		1116	&& ELF_ST_TYPE (sym->st_info) != h->type
		1117	&& (ELF_ST_TYPE (sym->st_info) == STT_TLS \|\| h->type == STT_TLS))
		1118	{
		1119	bfd ntbfd, tbfd;
		1120	bfd_boolean ntdef, tdef;
		1121	asection ntsec, tsec;
		1122
		1123	if (h->type == STT_TLS)
		1124	{
		1125	ntbfd = abfd;
		1126	ntsec = sec;
		1127	ntdef = newdef;
		1128	tbfd = oldbfd;
		1129	tsec = oldsec;
		1130	tdef = olddef;
		1131	}
		1132	else
		1133	{
		1134	ntbfd = oldbfd;
		1135	ntsec = oldsec;
		1136	ntdef = olddef;
		1137	tbfd = abfd;
		1138	tsec = sec;
		1139	tdef = newdef;
		1140	}
		1141
		1142	if (tdef && ntdef)
		1143	(*_bfd_error_handler)
		1144	(_("%s: TLS definition in %B section %A "
		1145	"mismatches non-TLS definition in %B section %A"),
		1146	tbfd, tsec, ntbfd, ntsec, h->root.root.string);
		1147	else if (!tdef && !ntdef)
		1148	(*_bfd_error_handler)
		1149	(_("%s: TLS reference in %B "
		1150	"mismatches non-TLS reference in %B"),
		1151	tbfd, ntbfd, h->root.root.string);
		1152	else if (tdef)
		1153	(*_bfd_error_handler)
		1154	(_("%s: TLS definition in %B section %A "
		1155	"mismatches non-TLS reference in %B"),
		1156	tbfd, tsec, ntbfd, h->root.root.string);
		1157	else
		1158	(*_bfd_error_handler)
		1159	(_("%s: TLS reference in %B "
		1160	"mismatches non-TLS definition in %B section %A"),
		1161	tbfd, ntbfd, ntsec, h->root.root.string);
		1162
		1163	bfd_set_error (bfd_error_bad_value);
		1164	return FALSE;
		1165	}
		1166
		1167	/* If the old symbol has non-default visibility, we ignore the new
		1168	definition from a dynamic object. */
		1169	if (newdyn
		1170	&& ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
		1171	&& !bfd_is_und_section (sec))
		1172	{
		1173	*skip = TRUE;
		1174	/* Make sure this symbol is dynamic. */
		1175	h->ref_dynamic = 1;
		1176	hi->ref_dynamic = 1;
		1177	/* A protected symbol has external availability. Make sure it is
		1178	recorded as dynamic.
		1179
		1180	FIXME: Should we check type and size for protected symbol? */
		1181	if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
		1182	return bfd_elf_link_record_dynamic_symbol (info, h);
		1183	else
		1184	return TRUE;
		1185	}
		1186	else if (!newdyn
		1187	&& ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
		1188	&& h->def_dynamic)
		1189	{
		1190	/* If the new symbol with non-default visibility comes from a
		1191	relocatable file and the old definition comes from a dynamic
		1192	object, we remove the old definition. */
		1193	if (hi->root.type == bfd_link_hash_indirect)
		1194	{
		1195	/* Handle the case where the old dynamic definition is
		1196	default versioned. We need to copy the symbol info from
		1197	the symbol with default version to the normal one if it
		1198	was referenced before. */
		1199	if (h->ref_regular)
		1200	{
		1201	hi->root.type = h->root.type;
		1202	h->root.type = bfd_link_hash_indirect;
		1203	(*bed->elf_backend_copy_indirect_symbol) (info, hi, h);
		1204
		1205	h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
		1206	if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
		1207	{
		1208	/* If the new symbol is hidden or internal, completely undo
		1209	any dynamic link state. */
		1210	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
		1211	h->forced_local = 0;
		1212	h->ref_dynamic = 0;
		1213	}
		1214	else
		1215	h->ref_dynamic = 1;
		1216
		1217	h->def_dynamic = 0;
		1218	/* FIXME: Should we check type and size for protected symbol? */
		1219	h->size = 0;
		1220	h->type = 0;
		1221
		1222	h = hi;
		1223	}
		1224	else
		1225	h = hi;
		1226	}
		1227
		1228	/* If the old symbol was undefined before, then it will still be
		1229	on the undefs list. If the new symbol is undefined or
		1230	common, we can't make it bfd_link_hash_new here, because new
		1231	undefined or common symbols will be added to the undefs list
		1232	by _bfd_generic_link_add_one_symbol. Symbols may not be
		1233	added twice to the undefs list. Also, if the new symbol is
		1234	undefweak then we don't want to lose the strong undef. */
		1235	if (h->root.u.undef.next \|\| info->hash->undefs_tail == &h->root)
		1236	{
		1237	h->root.type = bfd_link_hash_undefined;
		1238	h->root.u.undef.abfd = abfd;
		1239	}
		1240	else
		1241	{
		1242	h->root.type = bfd_link_hash_new;
		1243	h->root.u.undef.abfd = NULL;
		1244	}
		1245
		1246	if (ELF_ST_VISIBILITY (sym->st_other) != STV_PROTECTED)
		1247	{
		1248	/* If the new symbol is hidden or internal, completely undo
		1249	any dynamic link state. */
		1250	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
		1251	h->forced_local = 0;
		1252	h->ref_dynamic = 0;
		1253	}
		1254	else
		1255	h->ref_dynamic = 1;
		1256	h->def_dynamic = 0;
		1257	/* FIXME: Should we check type and size for protected symbol? */
		1258	h->size = 0;
		1259	h->type = 0;
		1260	return TRUE;
		1261	}
		1262
		1263	/* If a new weak symbol definition comes from a regular file and the
		1264	old symbol comes from a dynamic library, we treat the new one as
		1265	strong. Similarly, an old weak symbol definition from a regular
		1266	file is treated as strong when the new symbol comes from a dynamic
		1267	library. Further, an old weak symbol from a dynamic library is
		1268	treated as strong if the new symbol is from a dynamic library.
		1269	This reflects the way glibc's ld.so works.
		1270
		1271	Do this before setting type_change_ok or size_change_ok so that
		1272	we warn properly when dynamic library symbols are overridden. */
		1273
		1274	if (newdef && !newdyn && olddyn)
		1275	newweak = FALSE;
		1276	if (olddef && newdyn)
		1277	oldweak = FALSE;
		1278
		1279	/* Allow changes between different types of function symbol. */
		1280	if (newfunc && oldfunc)
		1281	*type_change_ok = TRUE;
		1282
		1283	/* It's OK to change the type if either the existing symbol or the
		1284	new symbol is weak. A type change is also OK if the old symbol
		1285	is undefined and the new symbol is defined. */
		1286
		1287	if (oldweak
		1288	\|\| newweak
		1289	\|\| (newdef
		1290	&& h->root.type == bfd_link_hash_undefined))
		1291	*type_change_ok = TRUE;
		1292
		1293	/* It's OK to change the size if either the existing symbol or the
		1294	new symbol is weak, or if the old symbol is undefined. */
		1295
		1296	if (*type_change_ok
		1297	\|\| h->root.type == bfd_link_hash_undefined)
		1298	*size_change_ok = TRUE;
		1299
		1300	/* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
		1301	symbol, respectively, appears to be a common symbol in a dynamic
		1302	object. If a symbol appears in an uninitialized section, and is
		1303	not weak, and is not a function, then it may be a common symbol
		1304	which was resolved when the dynamic object was created. We want
		1305	to treat such symbols specially, because they raise special
		1306	considerations when setting the symbol size: if the symbol
		1307	appears as a common symbol in a regular object, and the size in
		1308	the regular object is larger, we must make sure that we use the
		1309	larger size. This problematic case can always be avoided in C,
		1310	but it must be handled correctly when using Fortran shared
		1311	libraries.
		1312
		1313	Note that if NEWDYNCOMMON is set, NEWDEF will be set, and
		1314	likewise for OLDDYNCOMMON and OLDDEF.
		1315
		1316	Note that this test is just a heuristic, and that it is quite
		1317	possible to have an uninitialized symbol in a shared object which
		1318	is really a definition, rather than a common symbol. This could
		1319	lead to some minor confusion when the symbol really is a common
		1320	symbol in some regular object. However, I think it will be
		1321	harmless. */
		1322
		1323	if (newdyn
		1324	&& newdef
		1325	&& !newweak
		1326	&& (sec->flags & SEC_ALLOC) != 0
		1327	&& (sec->flags & SEC_LOAD) == 0
		1328	&& sym->st_size > 0
		1329	&& !newfunc)
		1330	newdyncommon = TRUE;
		1331	else
		1332	newdyncommon = FALSE;
		1333
		1334	if (olddyn
		1335	&& olddef
		1336	&& h->root.type == bfd_link_hash_defined
		1337	&& h->def_dynamic
		1338	&& (h->root.u.def.section->flags & SEC_ALLOC) != 0
		1339	&& (h->root.u.def.section->flags & SEC_LOAD) == 0
		1340	&& h->size > 0
		1341	&& !oldfunc)
		1342	olddyncommon = TRUE;
		1343	else
		1344	olddyncommon = FALSE;
		1345
		1346	/* We now know everything about the old and new symbols. We ask the
		1347	backend to check if we can merge them. */
		1348	if (bed->merge_symbol != NULL)
		1349	{
		1350	if (!bed->merge_symbol (h, sym, psec, newdef, olddef, oldbfd, oldsec))
		1351	return FALSE;
		1352	sec = *psec;
		1353	}
		1354
		1355	/* If both the old and the new symbols look like common symbols in a
		1356	dynamic object, set the size of the symbol to the larger of the
		1357	two. */
		1358
		1359	if (olddyncommon
		1360	&& newdyncommon
		1361	&& sym->st_size != h->size)
		1362	{
		1363	/* Since we think we have two common symbols, issue a multiple
		1364	common warning if desired. Note that we only warn if the
		1365	size is different. If the size is the same, we simply let
		1366	the old symbol override the new one as normally happens with
		1367	symbols defined in dynamic objects. */
		1368
		1369	if (! ((*info->callbacks->multiple_common)
		1370	(info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
		1371	return FALSE;
		1372
		1373	if (sym->st_size > h->size)
		1374	h->size = sym->st_size;
		1375
		1376	*size_change_ok = TRUE;
		1377	}
		1378
		1379	/* If we are looking at a dynamic object, and we have found a
		1380	definition, we need to see if the symbol was already defined by
		1381	some other object. If so, we want to use the existing
		1382	definition, and we do not want to report a multiple symbol
		1383	definition error; we do this by clobbering *PSEC to be
		1384	bfd_und_section_ptr.
		1385
		1386	We treat a common symbol as a definition if the symbol in the
		1387	shared library is a function, since common symbols always
		1388	represent variables; this can cause confusion in principle, but
		1389	any such confusion would seem to indicate an erroneous program or
		1390	shared library. We also permit a common symbol in a regular
		1391	object to override a weak symbol in a shared object. */
		1392
		1393	if (newdyn
		1394	&& newdef
		1395	&& (olddef
		1396	\|\| (h->root.type == bfd_link_hash_common
		1397	&& (newweak \|\| newfunc))))
		1398	{
		1399	*override = TRUE;
		1400	newdef = FALSE;
		1401	newdyncommon = FALSE;
		1402
		1403	*psec = sec = bfd_und_section_ptr;
		1404	*size_change_ok = TRUE;
		1405
		1406	/* If we get here when the old symbol is a common symbol, then
		1407	we are explicitly letting it override a weak symbol or
		1408	function in a dynamic object, and we don't want to warn about
		1409	a type change. If the old symbol is a defined symbol, a type
		1410	change warning may still be appropriate. */
		1411
		1412	if (h->root.type == bfd_link_hash_common)
		1413	*type_change_ok = TRUE;
		1414	}
		1415
		1416	/* Handle the special case of an old common symbol merging with a
		1417	new symbol which looks like a common symbol in a shared object.
		1418	We change PSEC and PVALUE to make the new symbol look like a
		1419	common symbol, and let _bfd_generic_link_add_one_symbol do the
		1420	right thing. */
		1421
		1422	if (newdyncommon
		1423	&& h->root.type == bfd_link_hash_common)
		1424	{
		1425	*override = TRUE;
		1426	newdef = FALSE;
		1427	newdyncommon = FALSE;
		1428	*pvalue = sym->st_size;
		1429	*psec = sec = bed->common_section (oldsec);
		1430	*size_change_ok = TRUE;
		1431	}
		1432
		1433	/* Skip weak definitions of symbols that are already defined. */
		1434	if (newdef && olddef && newweak)
		1435	{
		1436	/* Don't skip new non-IR weak syms. */
		1437	if (!(oldbfd != NULL
		1438	&& (oldbfd->flags & BFD_PLUGIN) != 0
		1439	&& (abfd->flags & BFD_PLUGIN) == 0))
		1440	*skip = TRUE;
		1441
		1442	/* Merge st_other. If the symbol already has a dynamic index,
		1443	but visibility says it should not be visible, turn it into a
		1444	local symbol. */
		1445	elf_merge_st_other (abfd, h, sym, newdef, newdyn);
		1446	if (h->dynindx != -1)
		1447	switch (ELF_ST_VISIBILITY (h->other))
		1448	{
		1449	case STV_INTERNAL:
		1450	case STV_HIDDEN:
		1451	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
		1452	break;
		1453	}
		1454	}
		1455
		1456	/* If the old symbol is from a dynamic object, and the new symbol is
		1457	a definition which is not from a dynamic object, then the new
		1458	symbol overrides the old symbol. Symbols from regular files
		1459	always take precedence over symbols from dynamic objects, even if
		1460	they are defined after the dynamic object in the link.
		1461
		1462	As above, we again permit a common symbol in a regular object to
		1463	override a definition in a shared object if the shared object
		1464	symbol is a function or is weak. */
		1465
		1466	flip = NULL;
		1467	if (!newdyn
		1468	&& (newdef
		1469	\|\| (bfd_is_com_section (sec)
		1470	&& (oldweak \|\| oldfunc)))
		1471	&& olddyn
		1472	&& olddef
		1473	&& h->def_dynamic)
		1474	{
		1475	/* Change the hash table entry to undefined, and let
		1476	_bfd_generic_link_add_one_symbol do the right thing with the
		1477	new definition. */
		1478
		1479	h->root.type = bfd_link_hash_undefined;
		1480	h->root.u.undef.abfd = h->root.u.def.section->owner;
		1481	*size_change_ok = TRUE;
		1482
		1483	olddef = FALSE;
		1484	olddyncommon = FALSE;
		1485
		1486	/* We again permit a type change when a common symbol may be
		1487	overriding a function. */
		1488
		1489	if (bfd_is_com_section (sec))
		1490	{
		1491	if (oldfunc)
		1492	{
		1493	/* If a common symbol overrides a function, make sure
		1494	that it isn't defined dynamically nor has type
		1495	function. */
		1496	h->def_dynamic = 0;
		1497	h->type = STT_NOTYPE;
		1498	}
		1499	*type_change_ok = TRUE;
		1500	}
		1501
		1502	if (hi->root.type == bfd_link_hash_indirect)
		1503	flip = hi;
		1504	else
		1505	/* This union may have been set to be non-NULL when this symbol
		1506	was seen in a dynamic object. We must force the union to be
		1507	NULL, so that it is correct for a regular symbol. */
		1508	h->verinfo.vertree = NULL;
		1509	}
		1510
		1511	/* Handle the special case of a new common symbol merging with an
		1512	old symbol that looks like it might be a common symbol defined in
		1513	a shared object. Note that we have already handled the case in
		1514	which a new common symbol should simply override the definition
		1515	in the shared library. */
		1516
		1517	if (! newdyn
		1518	&& bfd_is_com_section (sec)
		1519	&& olddyncommon)
		1520	{
		1521	/* It would be best if we could set the hash table entry to a
		1522	common symbol, but we don't know what to use for the section
		1523	or the alignment. */
		1524	if (! ((*info->callbacks->multiple_common)
		1525	(info, &h->root, abfd, bfd_link_hash_common, sym->st_size)))
		1526	return FALSE;
		1527
		1528	/* If the presumed common symbol in the dynamic object is
		1529	larger, pretend that the new symbol has its size. */
		1530
		1531	if (h->size > *pvalue)
		1532	*pvalue = h->size;
		1533
		1534	/* We need to remember the alignment required by the symbol
		1535	in the dynamic object. */
		1536	BFD_ASSERT (pold_alignment);
		1537	*pold_alignment = h->root.u.def.section->alignment_power;
		1538
		1539	olddef = FALSE;
		1540	olddyncommon = FALSE;
		1541
		1542	h->root.type = bfd_link_hash_undefined;
		1543	h->root.u.undef.abfd = h->root.u.def.section->owner;
		1544
		1545	*size_change_ok = TRUE;
		1546	*type_change_ok = TRUE;
		1547
		1548	if (hi->root.type == bfd_link_hash_indirect)
		1549	flip = hi;
		1550	else
		1551	h->verinfo.vertree = NULL;
		1552	}
		1553
		1554	if (flip != NULL)
		1555	{
		1556	/* Handle the case where we had a versioned symbol in a dynamic
		1557	library and now find a definition in a normal object. In this
		1558	case, we make the versioned symbol point to the normal one. */
		1559	flip->root.type = h->root.type;
		1560	flip->root.u.undef.abfd = h->root.u.undef.abfd;
		1561	h->root.type = bfd_link_hash_indirect;
		1562	h->root.u.i.link = (struct bfd_link_hash_entry *) flip;
		1563	(*bed->elf_backend_copy_indirect_symbol) (info, flip, h);
		1564	if (h->def_dynamic)
		1565	{
		1566	h->def_dynamic = 0;
		1567	flip->ref_dynamic = 1;
		1568	}
		1569	}
		1570
		1571	return TRUE;
		1572	}
		1573
		1574	/* This function is called to create an indirect symbol from the
		1575	default for the symbol with the default version if needed. The
		1576	symbol is described by H, NAME, SYM, SEC, and VALUE. We
		1577	set DYNSYM if the new indirect symbol is dynamic. */
		1578
		1579	static bfd_boolean
		1580	_bfd_elf_add_default_symbol (bfd *abfd,
		1581	struct bfd_link_info *info,
		1582	struct elf_link_hash_entry *h,
		1583	const char *name,
		1584	Elf_Internal_Sym *sym,
		1585	asection *sec,
		1586	bfd_vma value,
		1587	bfd **poldbfd,
		1588	bfd_boolean *dynsym)
		1589	{
		1590	bfd_boolean type_change_ok;
		1591	bfd_boolean size_change_ok;
		1592	bfd_boolean skip;
		1593	char *shortname;
		1594	struct elf_link_hash_entry *hi;
		1595	struct bfd_link_hash_entry *bh;
		1596	const struct elf_backend_data *bed;
		1597	bfd_boolean collect;
		1598	bfd_boolean dynamic;
		1599	bfd_boolean override;
		1600	char *p;
		1601	size_t len, shortlen;
		1602	asection *tmp_sec;
		1603
		1604	/* If this symbol has a version, and it is the default version, we
		1605	create an indirect symbol from the default name to the fully
		1606	decorated name. This will cause external references which do not
		1607	specify a version to be bound to this version of the symbol. */
		1608	p = strchr (name, ELF_VER_CHR);
		1609	if (p == NULL \|\| p[1] != ELF_VER_CHR)
		1610	return TRUE;
		1611
		1612	bed = get_elf_backend_data (abfd);
		1613	collect = bed->collect;
		1614	dynamic = (abfd->flags & DYNAMIC) != 0;
		1615
		1616	shortlen = p - name;
		1617	shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
		1618	if (shortname == NULL)
		1619	return FALSE;
		1620	memcpy (shortname, name, shortlen);
		1621	shortname[shortlen] = '\0';
		1622
		1623	/* We are going to create a new symbol. Merge it with any existing
		1624	symbol with this name. For the purposes of the merge, act as
		1625	though we were defining the symbol we just defined, although we
		1626	actually going to define an indirect symbol. */
		1627	type_change_ok = FALSE;
		1628	size_change_ok = FALSE;
		1629	tmp_sec = sec;
		1630	if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
		1631	&hi, poldbfd, NULL, NULL, &skip, &override,
		1632	&type_change_ok, &size_change_ok))
		1633	return FALSE;
		1634
		1635	if (skip)
		1636	goto nondefault;
		1637
		1638	if (! override)
		1639	{
		1640	bh = &hi->root;
		1641	if (! (_bfd_generic_link_add_one_symbol
		1642	(info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
		1643	0, name, FALSE, collect, &bh)))
		1644	return FALSE;
		1645	hi = (struct elf_link_hash_entry *) bh;
		1646	}
		1647	else
		1648	{
		1649	/* In this case the symbol named SHORTNAME is overriding the
		1650	indirect symbol we want to add. We were planning on making
		1651	SHORTNAME an indirect symbol referring to NAME. SHORTNAME
		1652	is the name without a version. NAME is the fully versioned
		1653	name, and it is the default version.
		1654
		1655	Overriding means that we already saw a definition for the
		1656	symbol SHORTNAME in a regular object, and it is overriding
		1657	the symbol defined in the dynamic object.
		1658
		1659	When this happens, we actually want to change NAME, the
		1660	symbol we just added, to refer to SHORTNAME. This will cause
		1661	references to NAME in the shared object to become references
		1662	to SHORTNAME in the regular object. This is what we expect
		1663	when we override a function in a shared object: that the
		1664	references in the shared object will be mapped to the
		1665	definition in the regular object. */
		1666
		1667	while (hi->root.type == bfd_link_hash_indirect
		1668	\|\| hi->root.type == bfd_link_hash_warning)
		1669	hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
		1670
		1671	h->root.type = bfd_link_hash_indirect;
		1672	h->root.u.i.link = (struct bfd_link_hash_entry *) hi;
		1673	if (h->def_dynamic)
		1674	{
		1675	h->def_dynamic = 0;
		1676	hi->ref_dynamic = 1;
		1677	if (hi->ref_regular
		1678	\|\| hi->def_regular)
		1679	{
		1680	if (! bfd_elf_link_record_dynamic_symbol (info, hi))
		1681	return FALSE;
		1682	}
		1683	}
		1684
		1685	/* Now set HI to H, so that the following code will set the
		1686	other fields correctly. */
		1687	hi = h;
		1688	}
		1689
		1690	/* Check if HI is a warning symbol. */
		1691	if (hi->root.type == bfd_link_hash_warning)
		1692	hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
		1693
		1694	/* If there is a duplicate definition somewhere, then HI may not
		1695	point to an indirect symbol. We will have reported an error to
		1696	the user in that case. */
		1697
		1698	if (hi->root.type == bfd_link_hash_indirect)
		1699	{
		1700	struct elf_link_hash_entry *ht;
		1701
		1702	ht = (struct elf_link_hash_entry *) hi->root.u.i.link;
		1703	(*bed->elf_backend_copy_indirect_symbol) (info, ht, hi);
		1704
		1705	/* See if the new flags lead us to realize that the symbol must
		1706	be dynamic. */
		1707	if (! *dynsym)
		1708	{
		1709	if (! dynamic)
		1710	{
		1711	if (! info->executable
		1712	\|\| hi->def_dynamic
		1713	\|\| hi->ref_dynamic)
		1714	*dynsym = TRUE;
		1715	}
		1716	else
		1717	{
		1718	if (hi->ref_regular)
		1719	*dynsym = TRUE;
		1720	}
		1721	}
		1722	}
		1723
		1724	/* We also need to define an indirection from the nondefault version
		1725	of the symbol. */
		1726
		1727	nondefault:
		1728	len = strlen (name);
		1729	shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
		1730	if (shortname == NULL)
		1731	return FALSE;
		1732	memcpy (shortname, name, shortlen);
		1733	memcpy (shortname + shortlen, p + 1, len - shortlen);
		1734
		1735	/* Once again, merge with any existing symbol. */
		1736	type_change_ok = FALSE;
		1737	size_change_ok = FALSE;
		1738	tmp_sec = sec;
		1739	if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
		1740	&hi, NULL, NULL, NULL, &skip, &override,
		1741	&type_change_ok, &size_change_ok))
		1742	return FALSE;
		1743
		1744	if (skip)
		1745	return TRUE;
		1746
		1747	if (override)
		1748	{
		1749	/* Here SHORTNAME is a versioned name, so we don't expect to see
		1750	the type of override we do in the case above unless it is
		1751	overridden by a versioned definition. */
		1752	if (hi->root.type != bfd_link_hash_defined
		1753	&& hi->root.type != bfd_link_hash_defweak)
		1754	(*_bfd_error_handler)
		1755	(_("%B: unexpected redefinition of indirect versioned symbol `%s'"),
		1756	abfd, shortname);
		1757	}
		1758	else
		1759	{
		1760	bh = &hi->root;
		1761	if (! (_bfd_generic_link_add_one_symbol
		1762	(info, abfd, shortname, BSF_INDIRECT,
		1763	bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
		1764	return FALSE;
		1765	hi = (struct elf_link_hash_entry *) bh;
		1766
		1767	/* If there is a duplicate definition somewhere, then HI may not
		1768	point to an indirect symbol. We will have reported an error
		1769	to the user in that case. */
		1770
		1771	if (hi->root.type == bfd_link_hash_indirect)
		1772	{
		1773	(*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
		1774
		1775	/* See if the new flags lead us to realize that the symbol
		1776	must be dynamic. */
		1777	if (! *dynsym)
		1778	{
		1779	if (! dynamic)
		1780	{
		1781	if (! info->executable
		1782	\|\| hi->ref_dynamic)
		1783	*dynsym = TRUE;
		1784	}
		1785	else
		1786	{
		1787	if (hi->ref_regular)
		1788	*dynsym = TRUE;
		1789	}
		1790	}
		1791	}
		1792	}
		1793
		1794	return TRUE;
		1795	}
		1796
		1797	/* This routine is used to export all defined symbols into the dynamic
		1798	symbol table. It is called via elf_link_hash_traverse. */
		1799
		1800	static bfd_boolean
		1801	_bfd_elf_export_symbol (struct elf_link_hash_entry h, void data)
		1802	{
		1803	struct elf_info_failed eif = (struct elf_info_failed ) data;
		1804
		1805	/* Ignore indirect symbols. These are added by the versioning code. */
		1806	if (h->root.type == bfd_link_hash_indirect)
		1807	return TRUE;
		1808
		1809	/* Ignore this if we won't export it. */
		1810	if (!eif->info->export_dynamic && !h->dynamic)
		1811	return TRUE;
		1812
		1813	if (h->dynindx == -1
		1814	&& (h->def_regular \|\| h->ref_regular)
		1815	&& ! bfd_hide_sym_by_version (eif->info->version_info,
		1816	h->root.root.string))
		1817	{
		1818	if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
		1819	{
		1820	eif->failed = TRUE;
		1821	return FALSE;
		1822	}
		1823	}
		1824
		1825	return TRUE;
		1826	}
		1827
		1828	/* Look through the symbols which are defined in other shared
		1829	libraries and referenced here. Update the list of version
		1830	dependencies. This will be put into the .gnu.version_r section.
		1831	This function is called via elf_link_hash_traverse. */
		1832
		1833	static bfd_boolean
		1834	_bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
		1835	void *data)
		1836	{
		1837	struct elf_find_verdep_info rinfo = (struct elf_find_verdep_info ) data;
		1838	Elf_Internal_Verneed *t;
		1839	Elf_Internal_Vernaux *a;
		1840	bfd_size_type amt;
		1841
		1842	/* We only care about symbols defined in shared objects with version
		1843	information. */
		1844	if (!h->def_dynamic
		1845	\|\| h->def_regular
		1846	\|\| h->dynindx == -1
		1847	\|\| h->verinfo.verdef == NULL)
		1848	return TRUE;
		1849
		1850	/* See if we already know about this version. */
		1851	for (t = elf_tdata (rinfo->info->output_bfd)->verref;
		1852	t != NULL;
		1853	t = t->vn_nextref)
		1854	{
		1855	if (t->vn_bfd != h->verinfo.verdef->vd_bfd)
		1856	continue;
		1857
		1858	for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
		1859	if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
		1860	return TRUE;
		1861
		1862	break;
		1863	}
		1864
		1865	/* This is a new version. Add it to tree we are building. */
		1866
		1867	if (t == NULL)
		1868	{
		1869	amt = sizeof *t;
		1870	t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
		1871	if (t == NULL)
		1872	{
		1873	rinfo->failed = TRUE;
		1874	return FALSE;
		1875	}
		1876
		1877	t->vn_bfd = h->verinfo.verdef->vd_bfd;
		1878	t->vn_nextref = elf_tdata (rinfo->info->output_bfd)->verref;
		1879	elf_tdata (rinfo->info->output_bfd)->verref = t;
		1880	}
		1881
		1882	amt = sizeof *a;
		1883	a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
		1884	if (a == NULL)
		1885	{
		1886	rinfo->failed = TRUE;
		1887	return FALSE;
		1888	}
		1889
		1890	/* Note that we are copying a string pointer here, and testing it
		1891	above. If bfd_elf_string_from_elf_section is ever changed to
		1892	discard the string data when low in memory, this will have to be
		1893	fixed. */
		1894	a->vna_nodename = h->verinfo.verdef->vd_nodename;
		1895
		1896	a->vna_flags = h->verinfo.verdef->vd_flags;
		1897	a->vna_nextptr = t->vn_auxptr;
		1898
		1899	h->verinfo.verdef->vd_exp_refno = rinfo->vers;
		1900	++rinfo->vers;
		1901
		1902	a->vna_other = h->verinfo.verdef->vd_exp_refno + 1;
		1903
		1904	t->vn_auxptr = a;
		1905
		1906	return TRUE;
		1907	}
		1908
		1909	/* Figure out appropriate versions for all the symbols. We may not
		1910	have the version number script until we have read all of the input
		1911	files, so until that point we don't know which symbols should be
		1912	local. This function is called via elf_link_hash_traverse. */
		1913
		1914	static bfd_boolean
		1915	_bfd_elf_link_assign_sym_version (struct elf_link_hash_entry h, void data)
		1916	{
		1917	struct elf_info_failed *sinfo;
		1918	struct bfd_link_info *info;
		1919	const struct elf_backend_data *bed;
		1920	struct elf_info_failed eif;
		1921	char *p;
		1922	bfd_size_type amt;
		1923
		1924	sinfo = (struct elf_info_failed *) data;
		1925	info = sinfo->info;
		1926
		1927	/* Fix the symbol flags. */
		1928	eif.failed = FALSE;
		1929	eif.info = info;
		1930	if (! _bfd_elf_fix_symbol_flags (h, &eif))
		1931	{
		1932	if (eif.failed)
		1933	sinfo->failed = TRUE;
		1934	return FALSE;
		1935	}
		1936
		1937	/* We only need version numbers for symbols defined in regular
		1938	objects. */
		1939	if (!h->def_regular)
		1940	return TRUE;
		1941
		1942	bed = get_elf_backend_data (info->output_bfd);
		1943	p = strchr (h->root.root.string, ELF_VER_CHR);
		1944	if (p != NULL && h->verinfo.vertree == NULL)
		1945	{
		1946	struct bfd_elf_version_tree *t;
		1947	bfd_boolean hidden;
		1948
		1949	hidden = TRUE;
		1950
		1951	/* There are two consecutive ELF_VER_CHR characters if this is
		1952	not a hidden symbol. */
		1953	++p;
		1954	if (*p == ELF_VER_CHR)
		1955	{
		1956	hidden = FALSE;
		1957	++p;
		1958	}
		1959
		1960	/* If there is no version string, we can just return out. */
		1961	if (*p == '\0')
		1962	{
		1963	if (hidden)
		1964	h->hidden = 1;
		1965	return TRUE;
		1966	}
		1967
		1968	/* Look for the version. If we find it, it is no longer weak. */
		1969	for (t = sinfo->info->version_info; t != NULL; t = t->next)
		1970	{
		1971	if (strcmp (t->name, p) == 0)
		1972	{
		1973	size_t len;
		1974	char *alc;
		1975	struct bfd_elf_version_expr *d;
		1976
		1977	len = p - h->root.root.string;
		1978	alc = (char *) bfd_malloc (len);
		1979	if (alc == NULL)
		1980	{
		1981	sinfo->failed = TRUE;
		1982	return FALSE;
		1983	}
		1984	memcpy (alc, h->root.root.string, len - 1);
		1985	alc[len - 1] = '\0';
		1986	if (alc[len - 2] == ELF_VER_CHR)
		1987	alc[len - 2] = '\0';
		1988
		1989	h->verinfo.vertree = t;
		1990	t->used = TRUE;
		1991	d = NULL;
		1992
		1993	if (t->globals.list != NULL)
		1994	d = (*t->match) (&t->globals, NULL, alc);
		1995
		1996	/* See if there is anything to force this symbol to
		1997	local scope. */
		1998	if (d == NULL && t->locals.list != NULL)
		1999	{
		2000	d = (*t->match) (&t->locals, NULL, alc);
		2001	if (d != NULL
		2002	&& h->dynindx != -1
		2003	&& ! info->export_dynamic)
		2004	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
		2005	}
		2006
		2007	free (alc);
		2008	break;
		2009	}
		2010	}
		2011
		2012	/* If we are building an application, we need to create a
		2013	version node for this version. */
		2014	if (t == NULL && info->executable)
		2015	{
		2016	struct bfd_elf_version_tree **pp;
		2017	int version_index;
		2018
		2019	/* If we aren't going to export this symbol, we don't need
		2020	to worry about it. */
		2021	if (h->dynindx == -1)
		2022	return TRUE;
		2023
		2024	amt = sizeof *t;
		2025	t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd, amt);
		2026	if (t == NULL)
		2027	{
		2028	sinfo->failed = TRUE;
		2029	return FALSE;
		2030	}
		2031
		2032	t->name = p;
		2033	t->name_indx = (unsigned int) -1;
		2034	t->used = TRUE;
		2035
		2036	version_index = 1;
		2037	/* Don't count anonymous version tag. */
		2038	if (sinfo->info->version_info != NULL
		2039	&& sinfo->info->version_info->vernum == 0)
		2040	version_index = 0;
		2041	for (pp = &sinfo->info->version_info;
		2042	*pp != NULL;
		2043	pp = &(*pp)->next)
		2044	++version_index;
		2045	t->vernum = version_index;
		2046
		2047	*pp = t;
		2048
		2049	h->verinfo.vertree = t;
		2050	}
		2051	else if (t == NULL)
		2052	{
		2053	/* We could not find the version for a symbol when
		2054	generating a shared archive. Return an error. */
		2055	(*_bfd_error_handler)
		2056	(_("%B: version node not found for symbol %s"),
		2057	info->output_bfd, h->root.root.string);
		2058	bfd_set_error (bfd_error_bad_value);
		2059	sinfo->failed = TRUE;
		2060	return FALSE;
		2061	}
		2062
		2063	if (hidden)
		2064	h->hidden = 1;
		2065	}
		2066
		2067	/* If we don't have a version for this symbol, see if we can find
		2068	something. */
		2069	if (h->verinfo.vertree == NULL && sinfo->info->version_info != NULL)
		2070	{
		2071	bfd_boolean hide;
		2072
		2073	h->verinfo.vertree
		2074	= bfd_find_version_for_sym (sinfo->info->version_info,
		2075	h->root.root.string, &hide);
		2076	if (h->verinfo.vertree != NULL && hide)
		2077	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
		2078	}
		2079
		2080	return TRUE;
		2081	}
		2082
		2083	/* Read and swap the relocs from the section indicated by SHDR. This
		2084	may be either a REL or a RELA section. The relocations are
		2085	translated into RELA relocations and stored in INTERNAL_RELOCS,
		2086	which should have already been allocated to contain enough space.
		2087	The EXTERNAL_RELOCS are a buffer where the external form of the
		2088	relocations should be stored.
		2089
		2090	Returns FALSE if something goes wrong. */
		2091
		2092	static bfd_boolean
		2093	elf_link_read_relocs_from_section (bfd *abfd,
		2094	asection *sec,
		2095	Elf_Internal_Shdr *shdr,
		2096	void *external_relocs,
		2097	Elf_Internal_Rela *internal_relocs)
		2098	{
		2099	const struct elf_backend_data *bed;
		2100	void (swap_in) (bfd , const bfd_byte , Elf_Internal_Rela );
		2101	const bfd_byte *erela;
		2102	const bfd_byte *erelaend;
		2103	Elf_Internal_Rela *irela;
		2104	Elf_Internal_Shdr *symtab_hdr;
		2105	size_t nsyms;
		2106
		2107	/* Position ourselves at the start of the section. */
		2108	if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
		2109	return FALSE;
		2110
		2111	/* Read the relocations. */
		2112	if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
		2113	return FALSE;
		2114
		2115	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
		2116	nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
		2117
		2118	bed = get_elf_backend_data (abfd);
		2119
		2120	/* Convert the external relocations to the internal format. */
		2121	if (shdr->sh_entsize == bed->s->sizeof_rel)
		2122	swap_in = bed->s->swap_reloc_in;
		2123	else if (shdr->sh_entsize == bed->s->sizeof_rela)
		2124	swap_in = bed->s->swap_reloca_in;
		2125	else
		2126	{
		2127	bfd_set_error (bfd_error_wrong_format);
		2128	return FALSE;
		2129	}
		2130
		2131	erela = (const bfd_byte *) external_relocs;
		2132	erelaend = erela + shdr->sh_size;
		2133	irela = internal_relocs;
		2134	while (erela < erelaend)
		2135	{
		2136	bfd_vma r_symndx;
		2137
		2138	(*swap_in) (abfd, erela, irela);
		2139	r_symndx = ELF32_R_SYM (irela->r_info);
		2140	if (bed->s->arch_size == 64)
		2141	r_symndx >>= 24;
		2142	if (nsyms > 0)
		2143	{
		2144	if ((size_t) r_symndx >= nsyms)
		2145	{
		2146	(*_bfd_error_handler)
		2147	(_("%B: bad reloc symbol index (0x%lx >= 0x%lx)"
		2148	" for offset 0x%lx in section `%A'"),
		2149	abfd, sec,
		2150	(unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
		2151	bfd_set_error (bfd_error_bad_value);
		2152	return FALSE;
		2153	}
		2154	}
		2155	else if (r_symndx != STN_UNDEF)
		2156	{
		2157	(*_bfd_error_handler)
		2158	(_("%B: non-zero symbol index (0x%lx) for offset 0x%lx in section `%A'"
		2159	" when the object file has no symbol table"),
		2160	abfd, sec,
		2161	(unsigned long) r_symndx, (unsigned long) nsyms, irela->r_offset);
		2162	bfd_set_error (bfd_error_bad_value);
		2163	return FALSE;
		2164	}
		2165	irela += bed->s->int_rels_per_ext_rel;
		2166	erela += shdr->sh_entsize;
		2167	}
		2168
		2169	return TRUE;
		2170	}
		2171
		2172	/* Read and swap the relocs for a section O. They may have been
		2173	cached. If the EXTERNAL_RELOCS and INTERNAL_RELOCS arguments are
		2174	not NULL, they are used as buffers to read into. They are known to
		2175	be large enough. If the INTERNAL_RELOCS relocs argument is NULL,
		2176	the return value is allocated using either malloc or bfd_alloc,
		2177	according to the KEEP_MEMORY argument. If O has two relocation
		2178	sections (both REL and RELA relocations), then the REL_HDR
		2179	relocations will appear first in INTERNAL_RELOCS, followed by the
		2180	RELA_HDR relocations. */
		2181
		2182	Elf_Internal_Rela *
		2183	_bfd_elf_link_read_relocs (bfd *abfd,
		2184	asection *o,
		2185	void *external_relocs,
		2186	Elf_Internal_Rela *internal_relocs,
		2187	bfd_boolean keep_memory)
		2188	{
		2189	void *alloc1 = NULL;
		2190	Elf_Internal_Rela *alloc2 = NULL;
		2191	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		2192	struct bfd_elf_section_data *esdo = elf_section_data (o);
		2193	Elf_Internal_Rela *internal_rela_relocs;
		2194
		2195	if (esdo->relocs != NULL)
		2196	return esdo->relocs;
		2197
		2198	if (o->reloc_count == 0)
		2199	return NULL;
		2200
		2201	if (internal_relocs == NULL)
		2202	{
		2203	bfd_size_type size;
		2204
		2205	size = o->reloc_count;
		2206	size = bed->s->int_rels_per_ext_rel sizeof (Elf_Internal_Rela);
		2207	if (keep_memory)
		2208	internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
		2209	else
		2210	internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
		2211	if (internal_relocs == NULL)
		2212	goto error_return;
		2213	}
		2214
		2215	if (external_relocs == NULL)
		2216	{
		2217	bfd_size_type size = 0;
		2218
		2219	if (esdo->rel.hdr)
		2220	size += esdo->rel.hdr->sh_size;
		2221	if (esdo->rela.hdr)
		2222	size += esdo->rela.hdr->sh_size;
		2223
		2224	alloc1 = bfd_malloc (size);
		2225	if (alloc1 == NULL)
		2226	goto error_return;
		2227	external_relocs = alloc1;
		2228	}
		2229
		2230	internal_rela_relocs = internal_relocs;
		2231	if (esdo->rel.hdr)
		2232	{
		2233	if (!elf_link_read_relocs_from_section (abfd, o, esdo->rel.hdr,
		2234	external_relocs,
		2235	internal_relocs))
		2236	goto error_return;
		2237	external_relocs = (((bfd_byte *) external_relocs)
		2238	+ esdo->rel.hdr->sh_size);
		2239	internal_rela_relocs += (NUM_SHDR_ENTRIES (esdo->rel.hdr)
		2240	* bed->s->int_rels_per_ext_rel);
		2241	}
		2242
		2243	if (esdo->rela.hdr
		2244	&& (!elf_link_read_relocs_from_section (abfd, o, esdo->rela.hdr,
		2245	external_relocs,
		2246	internal_rela_relocs)))
		2247	goto error_return;
		2248
		2249	/* Cache the results for next time, if we can. */
		2250	if (keep_memory)
		2251	esdo->relocs = internal_relocs;
		2252
		2253	if (alloc1 != NULL)
		2254	free (alloc1);
		2255
		2256	/* Don't free alloc2, since if it was allocated we are passing it
		2257	back (under the name of internal_relocs). */
		2258
		2259	return internal_relocs;
		2260
		2261	error_return:
		2262	if (alloc1 != NULL)
		2263	free (alloc1);
		2264	if (alloc2 != NULL)
		2265	{
		2266	if (keep_memory)
		2267	bfd_release (abfd, alloc2);
		2268	else
		2269	free (alloc2);
		2270	}
		2271	return NULL;
		2272	}
		2273
		2274	/* Compute the size of, and allocate space for, REL_HDR which is the
		2275	section header for a section containing relocations for O. */
		2276
		2277	static bfd_boolean
		2278	_bfd_elf_link_size_reloc_section (bfd *abfd,
		2279	struct bfd_elf_section_reloc_data *reldata)
		2280	{
		2281	Elf_Internal_Shdr *rel_hdr = reldata->hdr;
		2282
		2283	/* That allows us to calculate the size of the section. */
		2284	rel_hdr->sh_size = rel_hdr->sh_entsize * reldata->count;
		2285
		2286	/* The contents field must last into write_object_contents, so we
		2287	allocate it with bfd_alloc rather than malloc. Also since we
		2288	cannot be sure that the contents will actually be filled in,
		2289	we zero the allocated space. */
		2290	rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
		2291	if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
		2292	return FALSE;
		2293
		2294	if (reldata->hashes == NULL && reldata->count)
		2295	{
		2296	struct elf_link_hash_entry **p;
		2297
		2298	p = (struct elf_link_hash_entry **)
		2299	bfd_zmalloc (reldata->count * sizeof (struct elf_link_hash_entry *));
		2300	if (p == NULL)
		2301	return FALSE;
		2302
		2303	reldata->hashes = p;
		2304	}
		2305
		2306	return TRUE;
		2307	}
		2308
		2309	/* Copy the relocations indicated by the INTERNAL_RELOCS (which
		2310	originated from the section given by INPUT_REL_HDR) to the
		2311	OUTPUT_BFD. */
		2312
		2313	bfd_boolean
		2314	_bfd_elf_link_output_relocs (bfd *output_bfd,
		2315	asection *input_section,
		2316	Elf_Internal_Shdr *input_rel_hdr,
		2317	Elf_Internal_Rela *internal_relocs,
		2318	struct elf_link_hash_entry **rel_hash
		2319	ATTRIBUTE_UNUSED)
		2320	{
		2321	Elf_Internal_Rela *irela;
		2322	Elf_Internal_Rela *irelaend;
		2323	bfd_byte *erel;
		2324	struct bfd_elf_section_reloc_data *output_reldata;
		2325	asection *output_section;
		2326	const struct elf_backend_data *bed;
		2327	void (swap_out) (bfd , const Elf_Internal_Rela , bfd_byte );
		2328	struct bfd_elf_section_data *esdo;
		2329
		2330	output_section = input_section->output_section;
		2331
		2332	bed = get_elf_backend_data (output_bfd);
		2333	esdo = elf_section_data (output_section);
		2334	if (esdo->rel.hdr && esdo->rel.hdr->sh_entsize == input_rel_hdr->sh_entsize)
		2335	{
		2336	output_reldata = &esdo->rel;
		2337	swap_out = bed->s->swap_reloc_out;
		2338	}
		2339	else if (esdo->rela.hdr
		2340	&& esdo->rela.hdr->sh_entsize == input_rel_hdr->sh_entsize)
		2341	{
		2342	output_reldata = &esdo->rela;
		2343	swap_out = bed->s->swap_reloca_out;
		2344	}
		2345	else
		2346	{
		2347	(*_bfd_error_handler)
		2348	(_("%B: relocation size mismatch in %B section %A"),
		2349	output_bfd, input_section->owner, input_section);
		2350	bfd_set_error (bfd_error_wrong_format);
		2351	return FALSE;
		2352	}
		2353
		2354	erel = output_reldata->hdr->contents;
		2355	erel += output_reldata->count * input_rel_hdr->sh_entsize;
		2356	irela = internal_relocs;
		2357	irelaend = irela + (NUM_SHDR_ENTRIES (input_rel_hdr)
		2358	* bed->s->int_rels_per_ext_rel);
		2359	while (irela < irelaend)
		2360	{
		2361	(*swap_out) (output_bfd, irela, erel);
		2362	irela += bed->s->int_rels_per_ext_rel;
		2363	erel += input_rel_hdr->sh_entsize;
		2364	}
		2365
		2366	/* Bump the counter, so that we know where to add the next set of
		2367	relocations. */
		2368	output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
		2369
		2370	return TRUE;
		2371	}
		2372
		2373	/* Make weak undefined symbols in PIE dynamic. */
		2374
		2375	bfd_boolean
		2376	_bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
		2377	struct elf_link_hash_entry *h)
		2378	{
		2379	if (info->pie
		2380	&& h->dynindx == -1
		2381	&& h->root.type == bfd_link_hash_undefweak)
		2382	return bfd_elf_link_record_dynamic_symbol (info, h);
		2383
		2384	return TRUE;
		2385	}
		2386
		2387	/* Fix up the flags for a symbol. This handles various cases which
		2388	can only be fixed after all the input files are seen. This is
		2389	currently called by both adjust_dynamic_symbol and
		2390	assign_sym_version, which is unnecessary but perhaps more robust in
		2391	the face of future changes. */
		2392
		2393	static bfd_boolean
		2394	_bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
		2395	struct elf_info_failed *eif)
		2396	{
		2397	const struct elf_backend_data *bed;
		2398
		2399	/* If this symbol was mentioned in a non-ELF file, try to set
		2400	DEF_REGULAR and REF_REGULAR correctly. This is the only way to
		2401	permit a non-ELF file to correctly refer to a symbol defined in
		2402	an ELF dynamic object. */
		2403	if (h->non_elf)
		2404	{
		2405	while (h->root.type == bfd_link_hash_indirect)
		2406	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		2407
		2408	if (h->root.type != bfd_link_hash_defined
		2409	&& h->root.type != bfd_link_hash_defweak)
		2410	{
		2411	h->ref_regular = 1;
		2412	h->ref_regular_nonweak = 1;
		2413	}
		2414	else
		2415	{
		2416	if (h->root.u.def.section->owner != NULL
		2417	&& (bfd_get_flavour (h->root.u.def.section->owner)
		2418	== bfd_target_elf_flavour))
		2419	{
		2420	h->ref_regular = 1;
		2421	h->ref_regular_nonweak = 1;
		2422	}
		2423	else
		2424	h->def_regular = 1;
		2425	}
		2426
		2427	if (h->dynindx == -1
		2428	&& (h->def_dynamic
		2429	\|\| h->ref_dynamic))
		2430	{
		2431	if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
		2432	{
		2433	eif->failed = TRUE;
		2434	return FALSE;
		2435	}
		2436	}
		2437	}
		2438	else
		2439	{
		2440	/* Unfortunately, NON_ELF is only correct if the symbol
		2441	was first seen in a non-ELF file. Fortunately, if the symbol
		2442	was first seen in an ELF file, we're probably OK unless the
		2443	symbol was defined in a non-ELF file. Catch that case here.
		2444	FIXME: We're still in trouble if the symbol was first seen in
		2445	a dynamic object, and then later in a non-ELF regular object. */
		2446	if ((h->root.type == bfd_link_hash_defined
		2447	\|\| h->root.type == bfd_link_hash_defweak)
		2448	&& !h->def_regular
		2449	&& (h->root.u.def.section->owner != NULL
		2450	? (bfd_get_flavour (h->root.u.def.section->owner)
		2451	!= bfd_target_elf_flavour)
		2452	: (bfd_is_abs_section (h->root.u.def.section)
		2453	&& !h->def_dynamic)))
		2454	h->def_regular = 1;
		2455	}
		2456
		2457	/* Backend specific symbol fixup. */
		2458	bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
		2459	if (bed->elf_backend_fixup_symbol
		2460	&& !(*bed->elf_backend_fixup_symbol) (eif->info, h))
		2461	return FALSE;
		2462
		2463	/* If this is a final link, and the symbol was defined as a common
		2464	symbol in a regular object file, and there was no definition in
		2465	any dynamic object, then the linker will have allocated space for
		2466	the symbol in a common section but the DEF_REGULAR
		2467	flag will not have been set. */
		2468	if (h->root.type == bfd_link_hash_defined
		2469	&& !h->def_regular
		2470	&& h->ref_regular
		2471	&& !h->def_dynamic
		2472	&& (h->root.u.def.section->owner->flags & (DYNAMIC \| BFD_PLUGIN)) == 0)
		2473	h->def_regular = 1;
		2474
		2475	/* If -Bsymbolic was used (which means to bind references to global
		2476	symbols to the definition within the shared object), and this
		2477	symbol was defined in a regular object, then it actually doesn't
		2478	need a PLT entry. Likewise, if the symbol has non-default
		2479	visibility. If the symbol has hidden or internal visibility, we
		2480	will force it local. */
		2481	if (h->needs_plt
		2482	&& eif->info->shared
		2483	&& is_elf_hash_table (eif->info->hash)
		2484	&& (SYMBOLIC_BIND (eif->info, h)
		2485	\|\| ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
		2486	&& h->def_regular)
		2487	{
		2488	bfd_boolean force_local;
		2489
		2490	force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
		2491	\|\| ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
		2492	(*bed->elf_backend_hide_symbol) (eif->info, h, force_local);
		2493	}
		2494
		2495	/* If a weak undefined symbol has non-default visibility, we also
		2496	hide it from the dynamic linker. */
		2497	if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
		2498	&& h->root.type == bfd_link_hash_undefweak)
		2499	(*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
		2500
		2501	/* If this is a weak defined symbol in a dynamic object, and we know
		2502	the real definition in the dynamic object, copy interesting flags
		2503	over to the real definition. */
		2504	if (h->u.weakdef != NULL)
		2505	{
		2506	/* If the real definition is defined by a regular object file,
		2507	don't do anything special. See the longer description in
		2508	_bfd_elf_adjust_dynamic_symbol, below. */
		2509	if (h->u.weakdef->def_regular)
		2510	h->u.weakdef = NULL;
		2511	else
		2512	{
		2513	struct elf_link_hash_entry *weakdef = h->u.weakdef;
		2514
		2515	while (h->root.type == bfd_link_hash_indirect)
		2516	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		2517
		2518	BFD_ASSERT (h->root.type == bfd_link_hash_defined
		2519	\|\| h->root.type == bfd_link_hash_defweak);
		2520	BFD_ASSERT (weakdef->def_dynamic);
		2521	BFD_ASSERT (weakdef->root.type == bfd_link_hash_defined
		2522	\|\| weakdef->root.type == bfd_link_hash_defweak);
		2523	(*bed->elf_backend_copy_indirect_symbol) (eif->info, weakdef, h);
		2524	}
		2525	}
		2526
		2527	return TRUE;
		2528	}
		2529
		2530	/* Make the backend pick a good value for a dynamic symbol. This is
		2531	called via elf_link_hash_traverse, and also calls itself
		2532	recursively. */
		2533
		2534	static bfd_boolean
		2535	_bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry h, void data)
		2536	{
		2537	struct elf_info_failed eif = (struct elf_info_failed ) data;
		2538	bfd *dynobj;
		2539	const struct elf_backend_data *bed;
		2540
		2541	if (! is_elf_hash_table (eif->info->hash))
		2542	return FALSE;
		2543
		2544	/* Ignore indirect symbols. These are added by the versioning code. */
		2545	if (h->root.type == bfd_link_hash_indirect)
		2546	return TRUE;
		2547
		2548	/* Fix the symbol flags. */
		2549	if (! _bfd_elf_fix_symbol_flags (h, eif))
		2550	return FALSE;
		2551
		2552	/* If this symbol does not require a PLT entry, and it is not
		2553	defined by a dynamic object, or is not referenced by a regular
		2554	object, ignore it. We do have to handle a weak defined symbol,
		2555	even if no regular object refers to it, if we decided to add it
		2556	to the dynamic symbol table. FIXME: Do we normally need to worry
		2557	about symbols which are defined by one dynamic object and
		2558	referenced by another one? */
		2559	if (!h->needs_plt
		2560	&& h->type != STT_GNU_IFUNC
		2561	&& (h->def_regular
		2562	\|\| !h->def_dynamic
		2563	\|\| (!h->ref_regular
		2564	&& (h->u.weakdef == NULL \|\| h->u.weakdef->dynindx == -1))))
		2565	{
		2566	h->plt = elf_hash_table (eif->info)->init_plt_offset;
		2567	return TRUE;
		2568	}
		2569
		2570	/* If we've already adjusted this symbol, don't do it again. This
		2571	can happen via a recursive call. */
		2572	if (h->dynamic_adjusted)
		2573	return TRUE;
		2574
		2575	/* Don't look at this symbol again. Note that we must set this
		2576	after checking the above conditions, because we may look at a
		2577	symbol once, decide not to do anything, and then get called
		2578	recursively later after REF_REGULAR is set below. */
		2579	h->dynamic_adjusted = 1;
		2580
		2581	/* If this is a weak definition, and we know a real definition, and
		2582	the real symbol is not itself defined by a regular object file,
		2583	then get a good value for the real definition. We handle the
		2584	real symbol first, for the convenience of the backend routine.
		2585
		2586	Note that there is a confusing case here. If the real definition
		2587	is defined by a regular object file, we don't get the real symbol
		2588	from the dynamic object, but we do get the weak symbol. If the
		2589	processor backend uses a COPY reloc, then if some routine in the
		2590	dynamic object changes the real symbol, we will not see that
		2591	change in the corresponding weak symbol. This is the way other
		2592	ELF linkers work as well, and seems to be a result of the shared
		2593	library model.
		2594
		2595	I will clarify this issue. Most SVR4 shared libraries define the
		2596	variable _timezone and define timezone as a weak synonym. The
		2597	tzset call changes _timezone. If you write
		2598	extern int timezone;
		2599	int _timezone = 5;
		2600	int main () { tzset (); printf ("%d %d\n", timezone, _timezone); }
		2601	you might expect that, since timezone is a synonym for _timezone,
		2602	the same number will print both times. However, if the processor
		2603	backend uses a COPY reloc, then actually timezone will be copied
		2604	into your process image, and, since you define _timezone
		2605	yourself, _timezone will not. Thus timezone and _timezone will
		2606	wind up at different memory locations. The tzset call will set
		2607	_timezone, leaving timezone unchanged. */
		2608
		2609	if (h->u.weakdef != NULL)
		2610	{
		2611	/* If we get to this point, there is an implicit reference to
		2612	H->U.WEAKDEF by a regular object file via the weak symbol H. */
		2613	h->u.weakdef->ref_regular = 1;
		2614
		2615	/* Ensure that the backend adjust_dynamic_symbol function sees
		2616	H->U.WEAKDEF before H by recursively calling ourselves. */
		2617	if (! _bfd_elf_adjust_dynamic_symbol (h->u.weakdef, eif))
		2618	return FALSE;
		2619	}
		2620
		2621	/* If a symbol has no type and no size and does not require a PLT
		2622	entry, then we are probably about to do the wrong thing here: we
		2623	are probably going to create a COPY reloc for an empty object.
		2624	This case can arise when a shared object is built with assembly
		2625	code, and the assembly code fails to set the symbol type. */
		2626	if (h->size == 0
		2627	&& h->type == STT_NOTYPE
		2628	&& !h->needs_plt)
		2629	(*_bfd_error_handler)
		2630	(_("warning: type and size of dynamic symbol `%s' are not defined"),
		2631	h->root.root.string);
		2632
		2633	dynobj = elf_hash_table (eif->info)->dynobj;
		2634	bed = get_elf_backend_data (dynobj);
		2635
		2636	if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
		2637	{
		2638	eif->failed = TRUE;
		2639	return FALSE;
		2640	}
		2641
		2642	return TRUE;
		2643	}
		2644
		2645	/* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
		2646	DYNBSS. */
		2647
		2648	bfd_boolean
		2649	_bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
		2650	asection *dynbss)
		2651	{
		2652	unsigned int power_of_two;
		2653	bfd_vma mask;
		2654	asection *sec = h->root.u.def.section;
		2655
		2656	/* The section aligment of definition is the maximum alignment
		2657	requirement of symbols defined in the section. Since we don't
		2658	know the symbol alignment requirement, we start with the
		2659	maximum alignment and check low bits of the symbol address
		2660	for the minimum alignment. */
		2661	power_of_two = bfd_get_section_alignment (sec->owner, sec);
		2662	mask = ((bfd_vma) 1 << power_of_two) - 1;
		2663	while ((h->root.u.def.value & mask) != 0)
		2664	{
		2665	mask >>= 1;
		2666	--power_of_two;
		2667	}
		2668
		2669	if (power_of_two > bfd_get_section_alignment (dynbss->owner,
		2670	dynbss))
		2671	{
		2672	/* Adjust the section alignment if needed. */
		2673	if (! bfd_set_section_alignment (dynbss->owner, dynbss,
		2674	power_of_two))
		2675	return FALSE;
		2676	}
		2677
		2678	/* We make sure that the symbol will be aligned properly. */
		2679	dynbss->size = BFD_ALIGN (dynbss->size, mask + 1);
		2680
		2681	/* Define the symbol as being at this point in DYNBSS. */
		2682	h->root.u.def.section = dynbss;
		2683	h->root.u.def.value = dynbss->size;
		2684
		2685	/* Increment the size of DYNBSS to make room for the symbol. */
		2686	dynbss->size += h->size;
		2687
		2688	return TRUE;
		2689	}
		2690
		2691	/* Adjust all external symbols pointing into SEC_MERGE sections
		2692	to reflect the object merging within the sections. */
		2693
		2694	static bfd_boolean
		2695	_bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry h, void data)
		2696	{
		2697	asection *sec;
		2698
		2699	if ((h->root.type == bfd_link_hash_defined
		2700	\|\| h->root.type == bfd_link_hash_defweak)
		2701	&& ((sec = h->root.u.def.section)->flags & SEC_MERGE)
		2702	&& sec->sec_info_type == SEC_INFO_TYPE_MERGE)
		2703	{
		2704	bfd output_bfd = (bfd ) data;
		2705
		2706	h->root.u.def.value =
		2707	_bfd_merged_section_offset (output_bfd,
		2708	&h->root.u.def.section,
		2709	elf_section_data (sec)->sec_info,
		2710	h->root.u.def.value);
		2711	}
		2712
		2713	return TRUE;
		2714	}
		2715
		2716	/* Returns false if the symbol referred to by H should be considered
		2717	to resolve local to the current module, and true if it should be
		2718	considered to bind dynamically. */
		2719
		2720	bfd_boolean
		2721	_bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
		2722	struct bfd_link_info *info,
		2723	bfd_boolean not_local_protected)
		2724	{
		2725	bfd_boolean binding_stays_local_p;
		2726	const struct elf_backend_data *bed;
		2727	struct elf_link_hash_table *hash_table;
		2728
		2729	if (h == NULL)
		2730	return FALSE;
		2731
		2732	while (h->root.type == bfd_link_hash_indirect
		2733	\|\| h->root.type == bfd_link_hash_warning)
		2734	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		2735
		2736	/* If it was forced local, then clearly it's not dynamic. */
		2737	if (h->dynindx == -1)
		2738	return FALSE;
		2739	if (h->forced_local)
		2740	return FALSE;
		2741
		2742	/* Identify the cases where name binding rules say that a
		2743	visible symbol resolves locally. */
		2744	binding_stays_local_p = info->executable \|\| SYMBOLIC_BIND (info, h);
		2745
		2746	switch (ELF_ST_VISIBILITY (h->other))
		2747	{
		2748	case STV_INTERNAL:
		2749	case STV_HIDDEN:
		2750	return FALSE;
		2751
		2752	case STV_PROTECTED:
		2753	hash_table = elf_hash_table (info);
		2754	if (!is_elf_hash_table (hash_table))
		2755	return FALSE;
		2756
		2757	bed = get_elf_backend_data (hash_table->dynobj);
		2758
		2759	/* Proper resolution for function pointer equality may require
		2760	that these symbols perhaps be resolved dynamically, even though
		2761	we should be resolving them to the current module. */
		2762	if (!not_local_protected \|\| !bed->is_function_type (h->type))
		2763	binding_stays_local_p = TRUE;
		2764	break;
		2765
		2766	default:
		2767	break;
		2768	}
		2769
		2770	/* If it isn't defined locally, then clearly it's dynamic. */
		2771	if (!h->def_regular && !ELF_COMMON_DEF_P (h))
		2772	return TRUE;
		2773
		2774	/* Otherwise, the symbol is dynamic if binding rules don't tell
		2775	us that it remains local. */
		2776	return !binding_stays_local_p;
		2777	}
		2778
		2779	/* Return true if the symbol referred to by H should be considered
		2780	to resolve local to the current module, and false otherwise. Differs
		2781	from (the inverse of) _bfd_elf_dynamic_symbol_p in the treatment of
		2782	undefined symbols. The two functions are virtually identical except
		2783	for the place where forced_local and dynindx == -1 are tested. If
		2784	either of those tests are true, _bfd_elf_dynamic_symbol_p will say
		2785	the symbol is local, while _bfd_elf_symbol_refs_local_p will say
		2786	the symbol is local only for defined symbols.
		2787	It might seem that _bfd_elf_dynamic_symbol_p could be rewritten as
		2788	!_bfd_elf_symbol_refs_local_p, except that targets differ in their
		2789	treatment of undefined weak symbols. For those that do not make
		2790	undefined weak symbols dynamic, both functions may return false. */
		2791
		2792	bfd_boolean
		2793	_bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
		2794	struct bfd_link_info *info,
		2795	bfd_boolean local_protected)
		2796	{
		2797	const struct elf_backend_data *bed;
		2798	struct elf_link_hash_table *hash_table;
		2799
		2800	/* If it's a local sym, of course we resolve locally. */
		2801	if (h == NULL)
		2802	return TRUE;
		2803
		2804	/* STV_HIDDEN or STV_INTERNAL ones must be local. */
		2805	if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
		2806	\|\| ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
		2807	return TRUE;
		2808
		2809	/* Common symbols that become definitions don't get the DEF_REGULAR
		2810	flag set, so test it first, and don't bail out. */
		2811	if (ELF_COMMON_DEF_P (h))
		2812	/* Do nothing. */;
		2813	/* If we don't have a definition in a regular file, then we can't
		2814	resolve locally. The sym is either undefined or dynamic. */
		2815	else if (!h->def_regular)
		2816	return FALSE;
		2817
		2818	/* Forced local symbols resolve locally. */
		2819	if (h->forced_local)
		2820	return TRUE;
		2821
		2822	/* As do non-dynamic symbols. */
		2823	if (h->dynindx == -1)
		2824	return TRUE;
		2825
		2826	/* At this point, we know the symbol is defined and dynamic. In an
		2827	executable it must resolve locally, likewise when building symbolic
		2828	shared libraries. */
		2829	if (info->executable \|\| SYMBOLIC_BIND (info, h))
		2830	return TRUE;
		2831
		2832	/* Now deal with defined dynamic symbols in shared libraries. Ones
		2833	with default visibility might not resolve locally. */
		2834	if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
		2835	return FALSE;
		2836
		2837	hash_table = elf_hash_table (info);
		2838	if (!is_elf_hash_table (hash_table))
		2839	return TRUE;
		2840
		2841	bed = get_elf_backend_data (hash_table->dynobj);
		2842
		2843	/* STV_PROTECTED non-function symbols are local. */
		2844	if (!bed->is_function_type (h->type))
		2845	return TRUE;
		2846
		2847	/* Function pointer equality tests may require that STV_PROTECTED
		2848	symbols be treated as dynamic symbols. If the address of a
		2849	function not defined in an executable is set to that function's
		2850	plt entry in the executable, then the address of the function in
		2851	a shared library must also be the plt entry in the executable. */
		2852	return local_protected;
		2853	}
		2854
		2855	/* Caches some TLS segment info, and ensures that the TLS segment vma is
		2856	aligned. Returns the first TLS output section. */
		2857
		2858	struct bfd_section *
		2859	_bfd_elf_tls_setup (bfd obfd, struct bfd_link_info info)
		2860	{
		2861	struct bfd_section sec, tls;
		2862	unsigned int align = 0;
		2863
		2864	for (sec = obfd->sections; sec != NULL; sec = sec->next)
		2865	if ((sec->flags & SEC_THREAD_LOCAL) != 0)
		2866	break;
		2867	tls = sec;
		2868
		2869	for (; sec != NULL && (sec->flags & SEC_THREAD_LOCAL) != 0; sec = sec->next)
		2870	if (sec->alignment_power > align)
		2871	align = sec->alignment_power;
		2872
		2873	elf_hash_table (info)->tls_sec = tls;
		2874
		2875	/* Ensure the alignment of the first section is the largest alignment,
		2876	so that the tls segment starts aligned. */
		2877	if (tls != NULL)
		2878	tls->alignment_power = align;
		2879
		2880	return tls;
		2881	}
		2882
		2883	/* Return TRUE iff this is a non-common, definition of a non-function symbol. */
		2884	static bfd_boolean
		2885	is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
		2886	Elf_Internal_Sym *sym)
		2887	{
		2888	const struct elf_backend_data *bed;
		2889
		2890	/* Local symbols do not count, but target specific ones might. */
		2891	if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
		2892	&& ELF_ST_BIND (sym->st_info) < STB_LOOS)
		2893	return FALSE;
		2894
		2895	bed = get_elf_backend_data (abfd);
		2896	/* Function symbols do not count. */
		2897	if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
		2898	return FALSE;
		2899
		2900	/* If the section is undefined, then so is the symbol. */
		2901	if (sym->st_shndx == SHN_UNDEF)
		2902	return FALSE;
		2903
		2904	/* If the symbol is defined in the common section, then
		2905	it is a common definition and so does not count. */
		2906	if (bed->common_definition (sym))
		2907	return FALSE;
		2908
		2909	/* If the symbol is in a target specific section then we
		2910	must rely upon the backend to tell us what it is. */
		2911	if (sym->st_shndx >= SHN_LORESERVE && sym->st_shndx < SHN_ABS)
		2912	/* FIXME - this function is not coded yet:
		2913
		2914	return _bfd_is_global_symbol_definition (abfd, sym);
		2915
		2916	Instead for now assume that the definition is not global,
		2917	Even if this is wrong, at least the linker will behave
		2918	in the same way that it used to do. */
		2919	return FALSE;
		2920
		2921	return TRUE;
		2922	}
		2923
		2924	/* Search the symbol table of the archive element of the archive ABFD
		2925	whose archive map contains a mention of SYMDEF, and determine if
		2926	the symbol is defined in this element. */
		2927	static bfd_boolean
		2928	elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
		2929	{
		2930	Elf_Internal_Shdr * hdr;
		2931	bfd_size_type symcount;
		2932	bfd_size_type extsymcount;
		2933	bfd_size_type extsymoff;
		2934	Elf_Internal_Sym *isymbuf;
		2935	Elf_Internal_Sym *isym;
		2936	Elf_Internal_Sym *isymend;
		2937	bfd_boolean result;
		2938
		2939	abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
		2940	if (abfd == NULL)
		2941	return FALSE;
		2942
		2943	if (! bfd_check_format (abfd, bfd_object))
		2944	return FALSE;
		2945
		2946	/* If we have already included the element containing this symbol in the
		2947	link then we do not need to include it again. Just claim that any symbol
		2948	it contains is not a definition, so that our caller will not decide to
		2949	(re)include this element. */
		2950	if (abfd->archive_pass)
		2951	return FALSE;
		2952
		2953	/* Select the appropriate symbol table. */
		2954	if ((abfd->flags & DYNAMIC) == 0 \|\| elf_dynsymtab (abfd) == 0)
		2955	hdr = &elf_tdata (abfd)->symtab_hdr;
		2956	else
		2957	hdr = &elf_tdata (abfd)->dynsymtab_hdr;
		2958
		2959	symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
		2960
		2961	/* The sh_info field of the symtab header tells us where the
		2962	external symbols start. We don't care about the local symbols. */
		2963	if (elf_bad_symtab (abfd))
		2964	{
		2965	extsymcount = symcount;
		2966	extsymoff = 0;
		2967	}
		2968	else
		2969	{
		2970	extsymcount = symcount - hdr->sh_info;
		2971	extsymoff = hdr->sh_info;
		2972	}
		2973
		2974	if (extsymcount == 0)
		2975	return FALSE;
		2976
		2977	/* Read in the symbol table. */
		2978	isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
		2979	NULL, NULL, NULL);
		2980	if (isymbuf == NULL)
		2981	return FALSE;
		2982
		2983	/* Scan the symbol table looking for SYMDEF. */
		2984	result = FALSE;
		2985	for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
		2986	{
		2987	const char *name;
		2988
		2989	name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
		2990	isym->st_name);
		2991	if (name == NULL)
		2992	break;
		2993
		2994	if (strcmp (name, symdef->name) == 0)
		2995	{
		2996	result = is_global_data_symbol_definition (abfd, isym);
		2997	break;
		2998	}
		2999	}
		3000
		3001	free (isymbuf);
		3002
		3003	return result;
		3004	}
		3005
		3006	/* Add an entry to the .dynamic table. */
		3007
		3008	bfd_boolean
		3009	_bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
		3010	bfd_vma tag,
		3011	bfd_vma val)
		3012	{
		3013	struct elf_link_hash_table *hash_table;
		3014	const struct elf_backend_data *bed;
		3015	asection *s;
		3016	bfd_size_type newsize;
		3017	bfd_byte *newcontents;
		3018	Elf_Internal_Dyn dyn;
		3019
		3020	hash_table = elf_hash_table (info);
		3021	if (! is_elf_hash_table (hash_table))
		3022	return FALSE;
		3023
		3024	bed = get_elf_backend_data (hash_table->dynobj);
		3025	s = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
		3026	BFD_ASSERT (s != NULL);
		3027
		3028	newsize = s->size + bed->s->sizeof_dyn;
		3029	newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
		3030	if (newcontents == NULL)
		3031	return FALSE;
		3032
		3033	dyn.d_tag = tag;
		3034	dyn.d_un.d_val = val;
		3035	bed->s->swap_dyn_out (hash_table->dynobj, &dyn, newcontents + s->size);
		3036
		3037	s->size = newsize;
		3038	s->contents = newcontents;
		3039
		3040	return TRUE;
		3041	}
		3042
		3043	/* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
		3044	otherwise just check whether one already exists. Returns -1 on error,
		3045	1 if a DT_NEEDED tag already exists, and 0 on success. */
		3046
		3047	static int
		3048	elf_add_dt_needed_tag (bfd *abfd,
		3049	struct bfd_link_info *info,
		3050	const char *soname,
		3051	bfd_boolean do_it)
		3052	{
		3053	struct elf_link_hash_table *hash_table;
		3054	bfd_size_type strindex;
		3055
		3056	if (!_bfd_elf_link_create_dynstrtab (abfd, info))
		3057	return -1;
		3058
		3059	hash_table = elf_hash_table (info);
		3060	strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
		3061	if (strindex == (bfd_size_type) -1)
		3062	return -1;
		3063
		3064	if (_bfd_elf_strtab_refcount (hash_table->dynstr, strindex) != 1)
		3065	{
		3066	asection *sdyn;
		3067	const struct elf_backend_data *bed;
		3068	bfd_byte *extdyn;
		3069
		3070	bed = get_elf_backend_data (hash_table->dynobj);
		3071	sdyn = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
		3072	if (sdyn != NULL)
		3073	for (extdyn = sdyn->contents;
		3074	extdyn < sdyn->contents + sdyn->size;
		3075	extdyn += bed->s->sizeof_dyn)
		3076	{
		3077	Elf_Internal_Dyn dyn;
		3078
		3079	bed->s->swap_dyn_in (hash_table->dynobj, extdyn, &dyn);
		3080	if (dyn.d_tag == DT_NEEDED
		3081	&& dyn.d_un.d_val == strindex)
		3082	{
		3083	_bfd_elf_strtab_delref (hash_table->dynstr, strindex);
		3084	return 1;
		3085	}
		3086	}
		3087	}
		3088
		3089	if (do_it)
		3090	{
		3091	if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info))
		3092	return -1;
		3093
		3094	if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
		3095	return -1;
		3096	}
		3097	else
		3098	/* We were just checking for existence of the tag. */
		3099	_bfd_elf_strtab_delref (hash_table->dynstr, strindex);
		3100
		3101	return 0;
		3102	}
		3103
		3104	static bfd_boolean
		3105	on_needed_list (const char soname, struct bfd_link_needed_list needed)
		3106	{
		3107	for (; needed != NULL; needed = needed->next)
		3108	if (strcmp (soname, needed->name) == 0)
		3109	return TRUE;
		3110
		3111	return FALSE;
		3112	}
		3113
		3114	/* Sort symbol by value, section, and size. */
		3115	static int
		3116	elf_sort_symbol (const void arg1, const void arg2)
		3117	{
		3118	const struct elf_link_hash_entry *h1;
		3119	const struct elf_link_hash_entry *h2;
		3120	bfd_signed_vma vdiff;
		3121
		3122	h1 = (const struct elf_link_hash_entry *) arg1;
		3123	h2 = (const struct elf_link_hash_entry *) arg2;
		3124	vdiff = h1->root.u.def.value - h2->root.u.def.value;
		3125	if (vdiff != 0)
		3126	return vdiff > 0 ? 1 : -1;
		3127	else
		3128	{
		3129	long sdiff = h1->root.u.def.section->id - h2->root.u.def.section->id;
		3130	if (sdiff != 0)
		3131	return sdiff > 0 ? 1 : -1;
		3132	}
		3133	vdiff = h1->size - h2->size;
		3134	return vdiff == 0 ? 0 : vdiff > 0 ? 1 : -1;
		3135	}
		3136
		3137	/* This function is used to adjust offsets into .dynstr for
		3138	dynamic symbols. This is called via elf_link_hash_traverse. */
		3139
		3140	static bfd_boolean
		3141	elf_adjust_dynstr_offsets (struct elf_link_hash_entry h, void data)
		3142	{
		3143	struct elf_strtab_hash dynstr = (struct elf_strtab_hash ) data;
		3144
		3145	if (h->dynindx != -1)
		3146	h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
		3147	return TRUE;
		3148	}
		3149
		3150	/* Assign string offsets in .dynstr, update all structures referencing
		3151	them. */
		3152
		3153	static bfd_boolean
		3154	elf_finalize_dynstr (bfd output_bfd, struct bfd_link_info info)
		3155	{
		3156	struct elf_link_hash_table *hash_table = elf_hash_table (info);
		3157	struct elf_link_local_dynamic_entry *entry;
		3158	struct elf_strtab_hash *dynstr = hash_table->dynstr;
		3159	bfd *dynobj = hash_table->dynobj;
		3160	asection *sdyn;
		3161	bfd_size_type size;
		3162	const struct elf_backend_data *bed;
		3163	bfd_byte *extdyn;
		3164
		3165	_bfd_elf_strtab_finalize (dynstr);
		3166	size = _bfd_elf_strtab_size (dynstr);
		3167
		3168	bed = get_elf_backend_data (dynobj);
		3169	sdyn = bfd_get_linker_section (dynobj, ".dynamic");
		3170	BFD_ASSERT (sdyn != NULL);
		3171
		3172	/* Update all .dynamic entries referencing .dynstr strings. */
		3173	for (extdyn = sdyn->contents;
		3174	extdyn < sdyn->contents + sdyn->size;
		3175	extdyn += bed->s->sizeof_dyn)
		3176	{
		3177	Elf_Internal_Dyn dyn;
		3178
		3179	bed->s->swap_dyn_in (dynobj, extdyn, &dyn);
		3180	switch (dyn.d_tag)
		3181	{
		3182	case DT_STRSZ:
		3183	dyn.d_un.d_val = size;
		3184	break;
		3185	case DT_NEEDED:
		3186	case DT_SONAME:
		3187	case DT_RPATH:
		3188	case DT_RUNPATH:
		3189	case DT_FILTER:
		3190	case DT_AUXILIARY:
		3191	case DT_AUDIT:
		3192	case DT_DEPAUDIT:
		3193	dyn.d_un.d_val = _bfd_elf_strtab_offset (dynstr, dyn.d_un.d_val);
		3194	break;
		3195	default:
		3196	continue;
		3197	}
		3198	bed->s->swap_dyn_out (dynobj, &dyn, extdyn);
		3199	}
		3200
		3201	/* Now update local dynamic symbols. */
		3202	for (entry = hash_table->dynlocal; entry ; entry = entry->next)
		3203	entry->isym.st_name = _bfd_elf_strtab_offset (dynstr,
		3204	entry->isym.st_name);
		3205
		3206	/* And the rest of dynamic symbols. */
		3207	elf_link_hash_traverse (hash_table, elf_adjust_dynstr_offsets, dynstr);
		3208
		3209	/* Adjust version definitions. */
		3210	if (elf_tdata (output_bfd)->cverdefs)
		3211	{
		3212	asection *s;
		3213	bfd_byte *p;
		3214	bfd_size_type i;
		3215	Elf_Internal_Verdef def;
		3216	Elf_Internal_Verdaux defaux;
		3217
		3218	s = bfd_get_linker_section (dynobj, ".gnu.version_d");
		3219	p = s->contents;
		3220	do
		3221	{
		3222	_bfd_elf_swap_verdef_in (output_bfd, (Elf_External_Verdef *) p,
		3223	&def);
		3224	p += sizeof (Elf_External_Verdef);
		3225	if (def.vd_aux != sizeof (Elf_External_Verdef))
		3226	continue;
		3227	for (i = 0; i < def.vd_cnt; ++i)
		3228	{
		3229	_bfd_elf_swap_verdaux_in (output_bfd,
		3230	(Elf_External_Verdaux *) p, &defaux);
		3231	defaux.vda_name = _bfd_elf_strtab_offset (dynstr,
		3232	defaux.vda_name);
		3233	_bfd_elf_swap_verdaux_out (output_bfd,
		3234	&defaux, (Elf_External_Verdaux *) p);
		3235	p += sizeof (Elf_External_Verdaux);
		3236	}
		3237	}
		3238	while (def.vd_next);
		3239	}
		3240
		3241	/* Adjust version references. */
		3242	if (elf_tdata (output_bfd)->verref)
		3243	{
		3244	asection *s;
		3245	bfd_byte *p;
		3246	bfd_size_type i;
		3247	Elf_Internal_Verneed need;
		3248	Elf_Internal_Vernaux needaux;
		3249
		3250	s = bfd_get_linker_section (dynobj, ".gnu.version_r");
		3251	p = s->contents;
		3252	do
		3253	{
		3254	_bfd_elf_swap_verneed_in (output_bfd, (Elf_External_Verneed *) p,
		3255	&need);
		3256	need.vn_file = _bfd_elf_strtab_offset (dynstr, need.vn_file);
		3257	_bfd_elf_swap_verneed_out (output_bfd, &need,
		3258	(Elf_External_Verneed *) p);
		3259	p += sizeof (Elf_External_Verneed);
		3260	for (i = 0; i < need.vn_cnt; ++i)
		3261	{
		3262	_bfd_elf_swap_vernaux_in (output_bfd,
		3263	(Elf_External_Vernaux *) p, &needaux);
		3264	needaux.vna_name = _bfd_elf_strtab_offset (dynstr,
		3265	needaux.vna_name);
		3266	_bfd_elf_swap_vernaux_out (output_bfd,
		3267	&needaux,
		3268	(Elf_External_Vernaux *) p);
		3269	p += sizeof (Elf_External_Vernaux);
		3270	}
		3271	}
		3272	while (need.vn_next);
		3273	}
		3274
		3275	return TRUE;
		3276	}
		3277
		3278	/* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
		3279	The default is to only match when the INPUT and OUTPUT are exactly
		3280	the same target. */
		3281
		3282	bfd_boolean
		3283	_bfd_elf_default_relocs_compatible (const bfd_target *input,
		3284	const bfd_target *output)
		3285	{
		3286	return input == output;
		3287	}
		3288
		3289	/* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
		3290	This version is used when different targets for the same architecture
		3291	are virtually identical. */
		3292
		3293	bfd_boolean
		3294	_bfd_elf_relocs_compatible (const bfd_target *input,
		3295	const bfd_target *output)
		3296	{
		3297	const struct elf_backend_data obed, ibed;
		3298
		3299	if (input == output)
		3300	return TRUE;
		3301
		3302	ibed = xvec_get_elf_backend_data (input);
		3303	obed = xvec_get_elf_backend_data (output);
		3304
		3305	if (ibed->arch != obed->arch)
		3306	return FALSE;
		3307
		3308	/* If both backends are using this function, deem them compatible. */
		3309	return ibed->relocs_compatible == obed->relocs_compatible;
		3310	}
		3311
		3312	/* Make a special call to the linker "notice" function to tell it that
		3313	we are about to handle an as-needed lib, or have finished
		3314	processing the lib. */
		3315
		3316	bfd_boolean
		3317	_bfd_elf_notice_as_needed (bfd *ibfd,
		3318	struct bfd_link_info *info,
		3319	enum notice_asneeded_action act)
		3320	{
		3321	return (*info->callbacks->notice) (info, NULL, ibfd, NULL, act, 0, NULL);
		3322	}
		3323
		3324	/* Add symbols from an ELF object file to the linker hash table. */
		3325
		3326	static bfd_boolean
		3327	elf_link_add_object_symbols (bfd abfd, struct bfd_link_info info)
		3328	{
		3329	Elf_Internal_Ehdr *ehdr;
		3330	Elf_Internal_Shdr *hdr;
		3331	bfd_size_type symcount;
		3332	bfd_size_type extsymcount;
		3333	bfd_size_type extsymoff;
		3334	struct elf_link_hash_entry **sym_hash;
		3335	bfd_boolean dynamic;
		3336	Elf_External_Versym *extversym = NULL;
		3337	Elf_External_Versym *ever;
		3338	struct elf_link_hash_entry *weaks;
		3339	struct elf_link_hash_entry **nondeflt_vers = NULL;
		3340	bfd_size_type nondeflt_vers_cnt = 0;
		3341	Elf_Internal_Sym *isymbuf = NULL;
		3342	Elf_Internal_Sym *isym;
		3343	Elf_Internal_Sym *isymend;
		3344	const struct elf_backend_data *bed;
		3345	bfd_boolean add_needed;
		3346	struct elf_link_hash_table *htab;
		3347	bfd_size_type amt;
		3348	void *alloc_mark = NULL;
		3349	struct bfd_hash_entry **old_table = NULL;
		3350	unsigned int old_size = 0;
		3351	unsigned int old_count = 0;
		3352	void *old_tab = NULL;
		3353	void *old_ent;
		3354	struct bfd_link_hash_entry *old_undefs = NULL;
		3355	struct bfd_link_hash_entry *old_undefs_tail = NULL;
		3356	long old_dynsymcount = 0;
		3357	bfd_size_type old_dynstr_size = 0;
		3358	size_t tabsize = 0;
		3359	asection *s;
		3360
		3361	htab = elf_hash_table (info);
		3362	bed = get_elf_backend_data (abfd);
		3363
		3364	if ((abfd->flags & DYNAMIC) == 0)
		3365	dynamic = FALSE;
		3366	else
		3367	{
		3368	dynamic = TRUE;
		3369
		3370	/* You can't use -r against a dynamic object. Also, there's no
		3371	hope of using a dynamic object which does not exactly match
		3372	the format of the output file. */
		3373	if (info->relocatable
		3374	\|\| !is_elf_hash_table (htab)
		3375	\|\| info->output_bfd->xvec != abfd->xvec)
		3376	{
		3377	if (info->relocatable)
		3378	bfd_set_error (bfd_error_invalid_operation);
		3379	else
		3380	bfd_set_error (bfd_error_wrong_format);
		3381	goto error_return;
		3382	}
		3383	}
		3384
		3385	ehdr = elf_elfheader (abfd);
		3386	if (info->warn_alternate_em
		3387	&& bed->elf_machine_code != ehdr->e_machine
		3388	&& ((bed->elf_machine_alt1 != 0
		3389	&& ehdr->e_machine == bed->elf_machine_alt1)
		3390	\|\| (bed->elf_machine_alt2 != 0
		3391	&& ehdr->e_machine == bed->elf_machine_alt2)))
		3392	info->callbacks->einfo
		3393	(_("%P: alternate ELF machine code found (%d) in %B, expecting %d\n"),
		3394	ehdr->e_machine, abfd, bed->elf_machine_code);
		3395
		3396	/* As a GNU extension, any input sections which are named
		3397	.gnu.warning.SYMBOL are treated as warning symbols for the given
		3398	symbol. This differs from .gnu.warning sections, which generate
		3399	warnings when they are included in an output file. */
		3400	/* PR 12761: Also generate this warning when building shared libraries. */
		3401	for (s = abfd->sections; s != NULL; s = s->next)
		3402	{
		3403	const char *name;
		3404
		3405	name = bfd_get_section_name (abfd, s);
		3406	if (CONST_STRNEQ (name, ".gnu.warning."))
		3407	{
		3408	char *msg;
		3409	bfd_size_type sz;
		3410
		3411	name += sizeof ".gnu.warning." - 1;
		3412
		3413	/* If this is a shared object, then look up the symbol
		3414	in the hash table. If it is there, and it is already
		3415	been defined, then we will not be using the entry
		3416	from this shared object, so we don't need to warn.
		3417	FIXME: If we see the definition in a regular object
		3418	later on, we will warn, but we shouldn't. The only
		3419	fix is to keep track of what warnings we are supposed
		3420	to emit, and then handle them all at the end of the
		3421	link. */
		3422	if (dynamic)
		3423	{
		3424	struct elf_link_hash_entry *h;
		3425
		3426	h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
		3427
		3428	/* FIXME: What about bfd_link_hash_common? */
		3429	if (h != NULL
		3430	&& (h->root.type == bfd_link_hash_defined
		3431	\|\| h->root.type == bfd_link_hash_defweak))
		3432	continue;
		3433	}
		3434
		3435	sz = s->size;
		3436	msg = (char *) bfd_alloc (abfd, sz + 1);
		3437	if (msg == NULL)
		3438	goto error_return;
		3439
		3440	if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
		3441	goto error_return;
		3442
		3443	msg[sz] = '\0';
		3444
		3445	if (! (_bfd_generic_link_add_one_symbol
		3446	(info, abfd, name, BSF_WARNING, s, 0, msg,
		3447	FALSE, bed->collect, NULL)))
		3448	goto error_return;
		3449
		3450	if (!info->relocatable && info->executable)
		3451	{
		3452	/* Clobber the section size so that the warning does
		3453	not get copied into the output file. */
		3454	s->size = 0;
		3455
		3456	/* Also set SEC_EXCLUDE, so that symbols defined in
		3457	the warning section don't get copied to the output. */
		3458	s->flags \|= SEC_EXCLUDE;
		3459	}
		3460	}
		3461	}
		3462
		3463	add_needed = TRUE;
		3464	if (! dynamic)
		3465	{
		3466	/* If we are creating a shared library, create all the dynamic
		3467	sections immediately. We need to attach them to something,
		3468	so we attach them to this BFD, provided it is the right
		3469	format. FIXME: If there are no input BFD's of the same
		3470	format as the output, we can't make a shared library. */
		3471	if (info->shared
		3472	&& is_elf_hash_table (htab)
		3473	&& info->output_bfd->xvec == abfd->xvec
		3474	&& !htab->dynamic_sections_created)
		3475	{
		3476	if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
		3477	goto error_return;
		3478	}
		3479	}
		3480	else if (!is_elf_hash_table (htab))
		3481	goto error_return;
		3482	else
		3483	{
		3484	const char *soname = NULL;
		3485	char *audit = NULL;
		3486	struct bfd_link_needed_list rpath = NULL, runpath = NULL;
		3487	int ret;
		3488
		3489	/* ld --just-symbols and dynamic objects don't mix very well.
		3490	ld shouldn't allow it. */
		3491	if ((s = abfd->sections) != NULL
		3492	&& s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
		3493	abort ();
		3494
		3495	/* If this dynamic lib was specified on the command line with
		3496	--as-needed in effect, then we don't want to add a DT_NEEDED
		3497	tag unless the lib is actually used. Similary for libs brought
		3498	in by another lib's DT_NEEDED. When --no-add-needed is used
		3499	on a dynamic lib, we don't want to add a DT_NEEDED entry for
		3500	any dynamic library in DT_NEEDED tags in the dynamic lib at
		3501	all. */
		3502	add_needed = (elf_dyn_lib_class (abfd)
		3503	& (DYN_AS_NEEDED \| DYN_DT_NEEDED
		3504	\| DYN_NO_NEEDED)) == 0;
		3505
		3506	s = bfd_get_section_by_name (abfd, ".dynamic");
		3507	if (s != NULL)
		3508	{
		3509	bfd_byte *dynbuf;
		3510	bfd_byte *extdyn;
		3511	unsigned int elfsec;
		3512	unsigned long shlink;
		3513
		3514	if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
		3515	{
		3516	error_free_dyn:
		3517	free (dynbuf);
		3518	goto error_return;
		3519	}
		3520
		3521	elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
		3522	if (elfsec == SHN_BAD)
		3523	goto error_free_dyn;
		3524	shlink = elf_elfsections (abfd)[elfsec]->sh_link;
		3525
		3526	for (extdyn = dynbuf;
		3527	extdyn < dynbuf + s->size;
		3528	extdyn += bed->s->sizeof_dyn)
		3529	{
		3530	Elf_Internal_Dyn dyn;
		3531
		3532	bed->s->swap_dyn_in (abfd, extdyn, &dyn);
		3533	if (dyn.d_tag == DT_SONAME)
		3534	{
		3535	unsigned int tagv = dyn.d_un.d_val;
		3536	soname = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
		3537	if (soname == NULL)
		3538	goto error_free_dyn;
		3539	}
		3540	if (dyn.d_tag == DT_NEEDED)
		3541	{
		3542	struct bfd_link_needed_list n, *pn;
		3543	char fnm, anm;
		3544	unsigned int tagv = dyn.d_un.d_val;
		3545
		3546	amt = sizeof (struct bfd_link_needed_list);
		3547	n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
		3548	fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
		3549	if (n == NULL \|\| fnm == NULL)
		3550	goto error_free_dyn;
		3551	amt = strlen (fnm) + 1;
		3552	anm = (char *) bfd_alloc (abfd, amt);
		3553	if (anm == NULL)
		3554	goto error_free_dyn;
		3555	memcpy (anm, fnm, amt);
		3556	n->name = anm;
		3557	n->by = abfd;
		3558	n->next = NULL;
		3559	for (pn = &htab->needed; pn != NULL; pn = &(pn)->next)
		3560	;
		3561	*pn = n;
		3562	}
		3563	if (dyn.d_tag == DT_RUNPATH)
		3564	{
		3565	struct bfd_link_needed_list n, *pn;
		3566	char fnm, anm;
		3567	unsigned int tagv = dyn.d_un.d_val;
		3568
		3569	amt = sizeof (struct bfd_link_needed_list);
		3570	n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
		3571	fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
		3572	if (n == NULL \|\| fnm == NULL)
		3573	goto error_free_dyn;
		3574	amt = strlen (fnm) + 1;
		3575	anm = (char *) bfd_alloc (abfd, amt);
		3576	if (anm == NULL)
		3577	goto error_free_dyn;
		3578	memcpy (anm, fnm, amt);
		3579	n->name = anm;
		3580	n->by = abfd;
		3581	n->next = NULL;
		3582	for (pn = & runpath;
		3583	*pn != NULL;
		3584	pn = &(*pn)->next)
		3585	;
		3586	*pn = n;
		3587	}
		3588	/* Ignore DT_RPATH if we have seen DT_RUNPATH. */
		3589	if (!runpath && dyn.d_tag == DT_RPATH)
		3590	{
		3591	struct bfd_link_needed_list n, *pn;
		3592	char fnm, anm;
		3593	unsigned int tagv = dyn.d_un.d_val;
		3594
		3595	amt = sizeof (struct bfd_link_needed_list);
		3596	n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
		3597	fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
		3598	if (n == NULL \|\| fnm == NULL)
		3599	goto error_free_dyn;
		3600	amt = strlen (fnm) + 1;
		3601	anm = (char *) bfd_alloc (abfd, amt);
		3602	if (anm == NULL)
		3603	goto error_free_dyn;
		3604	memcpy (anm, fnm, amt);
		3605	n->name = anm;
		3606	n->by = abfd;
		3607	n->next = NULL;
		3608	for (pn = & rpath;
		3609	*pn != NULL;
		3610	pn = &(*pn)->next)
		3611	;
		3612	*pn = n;
		3613	}
		3614	if (dyn.d_tag == DT_AUDIT)
		3615	{
		3616	unsigned int tagv = dyn.d_un.d_val;
		3617	audit = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
		3618	}
		3619	}
		3620
		3621	free (dynbuf);
		3622	}
		3623
		3624	/* DT_RUNPATH overrides DT_RPATH. Do _NOT_ bfd_release, as that
		3625	frees all more recently bfd_alloc'd blocks as well. */
		3626	if (runpath)
		3627	rpath = runpath;
		3628
		3629	if (rpath)
		3630	{
		3631	struct bfd_link_needed_list **pn;
		3632	for (pn = &htab->runpath; pn != NULL; pn = &(pn)->next)
		3633	;
		3634	*pn = rpath;
		3635	}
		3636
		3637	/* We do not want to include any of the sections in a dynamic
		3638	object in the output file. We hack by simply clobbering the
		3639	list of sections in the BFD. This could be handled more
		3640	cleanly by, say, a new section flag; the existing
		3641	SEC_NEVER_LOAD flag is not the one we want, because that one
		3642	still implies that the section takes up space in the output
		3643	file. */
		3644	bfd_section_list_clear (abfd);
		3645
		3646	/* Find the name to use in a DT_NEEDED entry that refers to this
		3647	object. If the object has a DT_SONAME entry, we use it.
		3648	Otherwise, if the generic linker stuck something in
		3649	elf_dt_name, we use that. Otherwise, we just use the file
		3650	name. */
		3651	if (soname == NULL \|\| *soname == '\0')
		3652	{
		3653	soname = elf_dt_name (abfd);
		3654	if (soname == NULL \|\| *soname == '\0')
		3655	soname = bfd_get_filename (abfd);
		3656	}
		3657
		3658	/* Save the SONAME because sometimes the linker emulation code
		3659	will need to know it. */
		3660	elf_dt_name (abfd) = soname;
		3661
		3662	ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
		3663	if (ret < 0)
		3664	goto error_return;
		3665
		3666	/* If we have already included this dynamic object in the
		3667	link, just ignore it. There is no reason to include a
		3668	particular dynamic object more than once. */
		3669	if (ret > 0)
		3670	return TRUE;
		3671
		3672	/* Save the DT_AUDIT entry for the linker emulation code. */
		3673	elf_dt_audit (abfd) = audit;
		3674	}
		3675
		3676	/* If this is a dynamic object, we always link against the .dynsym
		3677	symbol table, not the .symtab symbol table. The dynamic linker
		3678	will only see the .dynsym symbol table, so there is no reason to
		3679	look at .symtab for a dynamic object. */
		3680
		3681	if (! dynamic \|\| elf_dynsymtab (abfd) == 0)
		3682	hdr = &elf_tdata (abfd)->symtab_hdr;
		3683	else
		3684	hdr = &elf_tdata (abfd)->dynsymtab_hdr;
		3685
		3686	symcount = hdr->sh_size / bed->s->sizeof_sym;
		3687
		3688	/* The sh_info field of the symtab header tells us where the
		3689	external symbols start. We don't care about the local symbols at
		3690	this point. */
		3691	if (elf_bad_symtab (abfd))
		3692	{
		3693	extsymcount = symcount;
		3694	extsymoff = 0;
		3695	}
		3696	else
		3697	{
		3698	extsymcount = symcount - hdr->sh_info;
		3699	extsymoff = hdr->sh_info;
		3700	}
		3701
		3702	sym_hash = elf_sym_hashes (abfd);
		3703	if (extsymcount != 0)
		3704	{
		3705	isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
		3706	NULL, NULL, NULL);
		3707	if (isymbuf == NULL)
		3708	goto error_return;
		3709
		3710	if (sym_hash == NULL)
		3711	{
		3712	/* We store a pointer to the hash table entry for each
		3713	external symbol. */
		3714	amt = extsymcount * sizeof (struct elf_link_hash_entry *);
		3715	sym_hash = (struct elf_link_hash_entry **) bfd_zalloc (abfd, amt);
		3716	if (sym_hash == NULL)
		3717	goto error_free_sym;
		3718	elf_sym_hashes (abfd) = sym_hash;
		3719	}
		3720	}
		3721
		3722	if (dynamic)
		3723	{
		3724	/* Read in any version definitions. */
		3725	if (!_bfd_elf_slurp_version_tables (abfd,
		3726	info->default_imported_symver))
		3727	goto error_free_sym;
		3728
		3729	/* Read in the symbol versions, but don't bother to convert them
		3730	to internal format. */
		3731	if (elf_dynversym (abfd) != 0)
		3732	{
		3733	Elf_Internal_Shdr *versymhdr;
		3734
		3735	versymhdr = &elf_tdata (abfd)->dynversym_hdr;
		3736	extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
		3737	if (extversym == NULL)
		3738	goto error_free_sym;
		3739	amt = versymhdr->sh_size;
		3740	if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
		3741	\|\| bfd_bread (extversym, amt, abfd) != amt)
		3742	goto error_free_vers;
		3743	}
		3744	}
		3745
		3746	/* If we are loading an as-needed shared lib, save the symbol table
		3747	state before we start adding symbols. If the lib turns out
		3748	to be unneeded, restore the state. */
		3749	if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
		3750	{
		3751	unsigned int i;
		3752	size_t entsize;
		3753
		3754	for (entsize = 0, i = 0; i < htab->root.table.size; i++)
		3755	{
		3756	struct bfd_hash_entry *p;
		3757	struct elf_link_hash_entry *h;
		3758
		3759	for (p = htab->root.table.table[i]; p != NULL; p = p->next)
		3760	{
		3761	h = (struct elf_link_hash_entry *) p;
		3762	entsize += htab->root.table.entsize;
		3763	if (h->root.type == bfd_link_hash_warning)
		3764	entsize += htab->root.table.entsize;
		3765	}
		3766	}
		3767
		3768	tabsize = htab->root.table.size * sizeof (struct bfd_hash_entry *);
		3769	old_tab = bfd_malloc (tabsize + entsize);
		3770	if (old_tab == NULL)
		3771	goto error_free_vers;
		3772
		3773	/* Remember the current objalloc pointer, so that all mem for
		3774	symbols added can later be reclaimed. */
		3775	alloc_mark = bfd_hash_allocate (&htab->root.table, 1);
		3776	if (alloc_mark == NULL)
		3777	goto error_free_vers;
		3778
		3779	/* Make a special call to the linker "notice" function to
		3780	tell it that we are about to handle an as-needed lib. */
		3781	if (!(*bed->notice_as_needed) (abfd, info, notice_as_needed))
		3782	goto error_free_vers;
		3783
		3784	/* Clone the symbol table. Remember some pointers into the
		3785	symbol table, and dynamic symbol count. */
		3786	old_ent = (char *) old_tab + tabsize;
		3787	memcpy (old_tab, htab->root.table.table, tabsize);
		3788	old_undefs = htab->root.undefs;
		3789	old_undefs_tail = htab->root.undefs_tail;
		3790	old_table = htab->root.table.table;
		3791	old_size = htab->root.table.size;
		3792	old_count = htab->root.table.count;
		3793	old_dynsymcount = htab->dynsymcount;
		3794	old_dynstr_size = _bfd_elf_strtab_size (htab->dynstr);
		3795
		3796	for (i = 0; i < htab->root.table.size; i++)
		3797	{
		3798	struct bfd_hash_entry *p;
		3799	struct elf_link_hash_entry *h;
		3800
		3801	for (p = htab->root.table.table[i]; p != NULL; p = p->next)
		3802	{
		3803	memcpy (old_ent, p, htab->root.table.entsize);
		3804	old_ent = (char *) old_ent + htab->root.table.entsize;
		3805	h = (struct elf_link_hash_entry *) p;
		3806	if (h->root.type == bfd_link_hash_warning)
		3807	{
		3808	memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
		3809	old_ent = (char *) old_ent + htab->root.table.entsize;
		3810	}
		3811	}
		3812	}
		3813	}
		3814
		3815	weaks = NULL;
		3816	ever = extversym != NULL ? extversym + extsymoff : NULL;
		3817	for (isym = isymbuf, isymend = isymbuf + extsymcount;
		3818	isym < isymend;
		3819	isym++, sym_hash++, ever = (ever != NULL ? ever + 1 : NULL))
		3820	{
		3821	int bind;
		3822	bfd_vma value;
		3823	asection sec, new_sec;
		3824	flagword flags;
		3825	const char *name;
		3826	struct elf_link_hash_entry *h;
		3827	struct elf_link_hash_entry *hi;
		3828	bfd_boolean definition;
		3829	bfd_boolean size_change_ok;
		3830	bfd_boolean type_change_ok;
		3831	bfd_boolean new_weakdef;
		3832	bfd_boolean new_weak;
		3833	bfd_boolean old_weak;
		3834	bfd_boolean override;
		3835	bfd_boolean common;
		3836	unsigned int old_alignment;
		3837	bfd *old_bfd;
		3838
		3839	override = FALSE;
		3840
		3841	flags = BSF_NO_FLAGS;
		3842	sec = NULL;
		3843	value = isym->st_value;
		3844	common = bed->common_definition (isym);
		3845
		3846	bind = ELF_ST_BIND (isym->st_info);
		3847	switch (bind)
		3848	{
		3849	case STB_LOCAL:
		3850	/* This should be impossible, since ELF requires that all
		3851	global symbols follow all local symbols, and that sh_info
		3852	point to the first global symbol. Unfortunately, Irix 5
		3853	screws this up. */
		3854	continue;
		3855
		3856	case STB_GLOBAL:
		3857	if (isym->st_shndx != SHN_UNDEF && !common)
		3858	flags = BSF_GLOBAL;
		3859	break;
		3860
		3861	case STB_WEAK:
		3862	flags = BSF_WEAK;
		3863	break;
		3864
		3865	case STB_GNU_UNIQUE:
		3866	flags = BSF_GNU_UNIQUE;
		3867	break;
		3868
		3869	default:
		3870	/* Leave it up to the processor backend. */
		3871	break;
		3872	}
		3873
		3874	if (isym->st_shndx == SHN_UNDEF)
		3875	sec = bfd_und_section_ptr;
		3876	else if (isym->st_shndx == SHN_ABS)
		3877	sec = bfd_abs_section_ptr;
		3878	else if (isym->st_shndx == SHN_COMMON)
		3879	{
		3880	sec = bfd_com_section_ptr;
		3881	/* What ELF calls the size we call the value. What ELF
		3882	calls the value we call the alignment. */
		3883	value = isym->st_size;
		3884	}
		3885	else
		3886	{
		3887	sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
		3888	if (sec == NULL)
		3889	sec = bfd_abs_section_ptr;
		3890	else if (discarded_section (sec))
		3891	{
		3892	/* Symbols from discarded section are undefined. We keep
		3893	its visibility. */
		3894	sec = bfd_und_section_ptr;
		3895	isym->st_shndx = SHN_UNDEF;
		3896	}
		3897	else if ((abfd->flags & (EXEC_P \| DYNAMIC)) != 0)
		3898	value -= sec->vma;
		3899	}
		3900
		3901	name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
		3902	isym->st_name);
		3903	if (name == NULL)
		3904	goto error_free_vers;
		3905
		3906	if (isym->st_shndx == SHN_COMMON
		3907	&& (abfd->flags & BFD_PLUGIN) != 0)
		3908	{
		3909	asection *xc = bfd_get_section_by_name (abfd, "COMMON");
		3910
		3911	if (xc == NULL)
		3912	{
		3913	flagword sflags = (SEC_ALLOC \| SEC_IS_COMMON \| SEC_KEEP
		3914	\| SEC_EXCLUDE);
		3915	xc = bfd_make_section_with_flags (abfd, "COMMON", sflags);
		3916	if (xc == NULL)
		3917	goto error_free_vers;
		3918	}
		3919	sec = xc;
		3920	}
		3921	else if (isym->st_shndx == SHN_COMMON
		3922	&& ELF_ST_TYPE (isym->st_info) == STT_TLS
		3923	&& !info->relocatable)
		3924	{
		3925	asection *tcomm = bfd_get_section_by_name (abfd, ".tcommon");
		3926
		3927	if (tcomm == NULL)
		3928	{
		3929	flagword sflags = (SEC_ALLOC \| SEC_THREAD_LOCAL \| SEC_IS_COMMON
		3930	\| SEC_LINKER_CREATED);
		3931	tcomm = bfd_make_section_with_flags (abfd, ".tcommon", sflags);
		3932	if (tcomm == NULL)
		3933	goto error_free_vers;
		3934	}
		3935	sec = tcomm;
		3936	}
		3937	else if (bed->elf_add_symbol_hook)
		3938	{
		3939	if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
		3940	&sec, &value))
		3941	goto error_free_vers;
		3942
		3943	/* The hook function sets the name to NULL if this symbol
		3944	should be skipped for some reason. */
		3945	if (name == NULL)
		3946	continue;
		3947	}
		3948
		3949	/* Sanity check that all possibilities were handled. */
		3950	if (sec == NULL)
		3951	{
		3952	bfd_set_error (bfd_error_bad_value);
		3953	goto error_free_vers;
		3954	}
		3955
		3956	/* Silently discard TLS symbols from --just-syms. There's
		3957	no way to combine a static TLS block with a new TLS block
		3958	for this executable. */
		3959	if (ELF_ST_TYPE (isym->st_info) == STT_TLS
		3960	&& sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
		3961	continue;
		3962
		3963	if (bfd_is_und_section (sec)
		3964	\|\| bfd_is_com_section (sec))
		3965	definition = FALSE;
		3966	else
		3967	definition = TRUE;
		3968
		3969	size_change_ok = FALSE;
		3970	type_change_ok = bed->type_change_ok;
		3971	old_weak = FALSE;
		3972	old_alignment = 0;
		3973	old_bfd = NULL;
		3974	new_sec = sec;
		3975
		3976	if (is_elf_hash_table (htab))
		3977	{
		3978	Elf_Internal_Versym iver;
		3979	unsigned int vernum = 0;
		3980	bfd_boolean skip;
		3981
		3982	if (ever == NULL)
		3983	{
		3984	if (info->default_imported_symver)
		3985	/* Use the default symbol version created earlier. */
		3986	iver.vs_vers = elf_tdata (abfd)->cverdefs;
		3987	else
		3988	iver.vs_vers = 0;
		3989	}
		3990	else
		3991	_bfd_elf_swap_versym_in (abfd, ever, &iver);
		3992
		3993	vernum = iver.vs_vers & VERSYM_VERSION;
		3994
		3995	/* If this is a hidden symbol, or if it is not version
		3996	1, we append the version name to the symbol name.
		3997	However, we do not modify a non-hidden absolute symbol
		3998	if it is not a function, because it might be the version
		3999	symbol itself. FIXME: What if it isn't? */
		4000	if ((iver.vs_vers & VERSYM_HIDDEN) != 0
		4001	\|\| (vernum > 1
		4002	&& (!bfd_is_abs_section (sec)
		4003	\|\| bed->is_function_type (ELF_ST_TYPE (isym->st_info)))))
		4004	{
		4005	const char *verstr;
		4006	size_t namelen, verlen, newlen;
		4007	char newname, p;
		4008
		4009	if (isym->st_shndx != SHN_UNDEF)
		4010	{
		4011	if (vernum > elf_tdata (abfd)->cverdefs)
		4012	verstr = NULL;
		4013	else if (vernum > 1)
		4014	verstr =
		4015	elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
		4016	else
		4017	verstr = "";
		4018
		4019	if (verstr == NULL)
		4020	{
		4021	(*_bfd_error_handler)
		4022	(_("%B: %s: invalid version %u (max %d)"),
		4023	abfd, name, vernum,
		4024	elf_tdata (abfd)->cverdefs);
		4025	bfd_set_error (bfd_error_bad_value);
		4026	goto error_free_vers;
		4027	}
		4028	}
		4029	else
		4030	{
		4031	/* We cannot simply test for the number of
		4032	entries in the VERNEED section since the
		4033	numbers for the needed versions do not start
		4034	at 0. */
		4035	Elf_Internal_Verneed *t;
		4036
		4037	verstr = NULL;
		4038	for (t = elf_tdata (abfd)->verref;
		4039	t != NULL;
		4040	t = t->vn_nextref)
		4041	{
		4042	Elf_Internal_Vernaux *a;
		4043
		4044	for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
		4045	{
		4046	if (a->vna_other == vernum)
		4047	{
		4048	verstr = a->vna_nodename;
		4049	break;
		4050	}
		4051	}
		4052	if (a != NULL)
		4053	break;
		4054	}
		4055	if (verstr == NULL)
		4056	{
		4057	(*_bfd_error_handler)
		4058	(_("%B: %s: invalid needed version %d"),
		4059	abfd, name, vernum);
		4060	bfd_set_error (bfd_error_bad_value);
		4061	goto error_free_vers;
		4062	}
		4063	}
		4064
		4065	namelen = strlen (name);
		4066	verlen = strlen (verstr);
		4067	newlen = namelen + verlen + 2;
		4068	if ((iver.vs_vers & VERSYM_HIDDEN) == 0
		4069	&& isym->st_shndx != SHN_UNDEF)
		4070	++newlen;
		4071
		4072	newname = (char *) bfd_hash_allocate (&htab->root.table, newlen);
		4073	if (newname == NULL)
		4074	goto error_free_vers;
		4075	memcpy (newname, name, namelen);
		4076	p = newname + namelen;
		4077	*p++ = ELF_VER_CHR;
		4078	/* If this is a defined non-hidden version symbol,
		4079	we add another @ to the name. This indicates the
		4080	default version of the symbol. */
		4081	if ((iver.vs_vers & VERSYM_HIDDEN) == 0
		4082	&& isym->st_shndx != SHN_UNDEF)
		4083	*p++ = ELF_VER_CHR;
		4084	memcpy (p, verstr, verlen + 1);
		4085
		4086	name = newname;
		4087	}
		4088
		4089	if (!_bfd_elf_merge_symbol (abfd, info, name, isym, &sec, &value,
		4090	sym_hash, &old_bfd, &old_weak,
		4091	&old_alignment, &skip, &override,
		4092	&type_change_ok, &size_change_ok))
		4093	goto error_free_vers;
		4094
		4095	if (skip)
		4096	continue;
		4097
		4098	if (override)
		4099	definition = FALSE;
		4100
		4101	h = *sym_hash;
		4102	while (h->root.type == bfd_link_hash_indirect
		4103	\|\| h->root.type == bfd_link_hash_warning)
		4104	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		4105
		4106	if (elf_tdata (abfd)->verdef != NULL
		4107	&& vernum > 1
		4108	&& definition)
		4109	h->verinfo.verdef = &elf_tdata (abfd)->verdef[vernum - 1];
		4110	}
		4111
		4112	if (! (_bfd_generic_link_add_one_symbol
		4113	(info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
		4114	(struct bfd_link_hash_entry **) sym_hash)))
		4115	goto error_free_vers;
		4116
		4117	h = *sym_hash;
		4118	/* We need to make sure that indirect symbol dynamic flags are
		4119	updated. */
		4120	hi = h;
		4121	while (h->root.type == bfd_link_hash_indirect
		4122	\|\| h->root.type == bfd_link_hash_warning)
		4123	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		4124
		4125	*sym_hash = h;
		4126
		4127	new_weak = (flags & BSF_WEAK) != 0;
		4128	new_weakdef = FALSE;
		4129	if (dynamic
		4130	&& definition
		4131	&& new_weak
		4132	&& !bed->is_function_type (ELF_ST_TYPE (isym->st_info))
		4133	&& is_elf_hash_table (htab)
		4134	&& h->u.weakdef == NULL)
		4135	{
		4136	/* Keep a list of all weak defined non function symbols from
		4137	a dynamic object, using the weakdef field. Later in this
		4138	function we will set the weakdef field to the correct
		4139	value. We only put non-function symbols from dynamic
		4140	objects on this list, because that happens to be the only
		4141	time we need to know the normal symbol corresponding to a
		4142	weak symbol, and the information is time consuming to
		4143	figure out. If the weakdef field is not already NULL,
		4144	then this symbol was already defined by some previous
		4145	dynamic object, and we will be using that previous
		4146	definition anyhow. */
		4147
		4148	h->u.weakdef = weaks;
		4149	weaks = h;
		4150	new_weakdef = TRUE;
		4151	}
		4152
		4153	/* Set the alignment of a common symbol. */
		4154	if ((common \|\| bfd_is_com_section (sec))
		4155	&& h->root.type == bfd_link_hash_common)
		4156	{
		4157	unsigned int align;
		4158
		4159	if (common)
		4160	align = bfd_log2 (isym->st_value);
		4161	else
		4162	{
		4163	/* The new symbol is a common symbol in a shared object.
		4164	We need to get the alignment from the section. */
		4165	align = new_sec->alignment_power;
		4166	}
		4167	if (align > old_alignment)
		4168	h->root.u.c.p->alignment_power = align;
		4169	else
		4170	h->root.u.c.p->alignment_power = old_alignment;
		4171	}
		4172
		4173	if (is_elf_hash_table (htab))
		4174	{
		4175	/* Set a flag in the hash table entry indicating the type of
		4176	reference or definition we just found. A dynamic symbol
		4177	is one which is referenced or defined by both a regular
		4178	object and a shared object. */
		4179	bfd_boolean dynsym = FALSE;
		4180
		4181	/* Plugin symbols aren't normal. Don't set def_regular or
		4182	ref_regular for them, or make them dynamic. */
		4183	if ((abfd->flags & BFD_PLUGIN) != 0)
		4184	;
		4185	else if (! dynamic)
		4186	{
		4187	if (! definition)
		4188	{
		4189	h->ref_regular = 1;
		4190	if (bind != STB_WEAK)
		4191	h->ref_regular_nonweak = 1;
		4192	}
		4193	else
		4194	{
		4195	h->def_regular = 1;
		4196	if (h->def_dynamic)
		4197	{
		4198	h->def_dynamic = 0;
		4199	h->ref_dynamic = 1;
		4200	}
		4201	}
		4202
		4203	/* If the indirect symbol has been forced local, don't
		4204	make the real symbol dynamic. */
		4205	if ((h == hi \|\| !hi->forced_local)
		4206	&& (! info->executable
		4207	\|\| h->def_dynamic
		4208	\|\| h->ref_dynamic))
		4209	dynsym = TRUE;
		4210	}
		4211	else
		4212	{
		4213	if (! definition)
		4214	{
		4215	h->ref_dynamic = 1;
		4216	hi->ref_dynamic = 1;
		4217	}
		4218	else
		4219	{
		4220	h->def_dynamic = 1;
		4221	hi->def_dynamic = 1;
		4222	}
		4223
		4224	/* If the indirect symbol has been forced local, don't
		4225	make the real symbol dynamic. */
		4226	if ((h == hi \|\| !hi->forced_local)
		4227	&& (h->def_regular
		4228	\|\| h->ref_regular
		4229	\|\| (h->u.weakdef != NULL
		4230	&& ! new_weakdef
		4231	&& h->u.weakdef->dynindx != -1)))
		4232	dynsym = TRUE;
		4233	}
		4234
		4235	/* Check to see if we need to add an indirect symbol for
		4236	the default name. */
		4237	if (definition
		4238	\|\| (!override && h->root.type == bfd_link_hash_common))
		4239	if (!_bfd_elf_add_default_symbol (abfd, info, h, name, isym,
		4240	sec, value, &old_bfd, &dynsym))
		4241	goto error_free_vers;
		4242
		4243	/* Check the alignment when a common symbol is involved. This
		4244	can change when a common symbol is overridden by a normal
		4245	definition or a common symbol is ignored due to the old
		4246	normal definition. We need to make sure the maximum
		4247	alignment is maintained. */
		4248	if ((old_alignment \|\| common)
		4249	&& h->root.type != bfd_link_hash_common)
		4250	{
		4251	unsigned int common_align;
		4252	unsigned int normal_align;
		4253	unsigned int symbol_align;
		4254	bfd *normal_bfd;
		4255	bfd *common_bfd;
		4256
		4257	BFD_ASSERT (h->root.type == bfd_link_hash_defined
		4258	\|\| h->root.type == bfd_link_hash_defweak);
		4259
		4260	symbol_align = ffs (h->root.u.def.value) - 1;
		4261	if (h->root.u.def.section->owner != NULL
		4262	&& (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
		4263	{
		4264	normal_align = h->root.u.def.section->alignment_power;
		4265	if (normal_align > symbol_align)
		4266	normal_align = symbol_align;
		4267	}
		4268	else
		4269	normal_align = symbol_align;
		4270
		4271	if (old_alignment)
		4272	{
		4273	common_align = old_alignment;
		4274	common_bfd = old_bfd;
		4275	normal_bfd = abfd;
		4276	}
		4277	else
		4278	{
		4279	common_align = bfd_log2 (isym->st_value);
		4280	common_bfd = abfd;
		4281	normal_bfd = old_bfd;
		4282	}
		4283
		4284	if (normal_align < common_align)
		4285	{
		4286	/* PR binutils/2735 */
		4287	if (normal_bfd == NULL)
		4288	(*_bfd_error_handler)
		4289	(_("Warning: alignment %u of common symbol `%s' in %B is"
		4290	" greater than the alignment (%u) of its section %A"),
		4291	common_bfd, h->root.u.def.section,
		4292	1 << common_align, name, 1 << normal_align);
		4293	else
		4294	(*_bfd_error_handler)
		4295	(_("Warning: alignment %u of symbol `%s' in %B"
		4296	" is smaller than %u in %B"),
		4297	normal_bfd, common_bfd,
		4298	1 << normal_align, name, 1 << common_align);
		4299	}
		4300	}
		4301
		4302	/* Remember the symbol size if it isn't undefined. */
		4303	if (isym->st_size != 0
		4304	&& isym->st_shndx != SHN_UNDEF
		4305	&& (definition \|\| h->size == 0))
		4306	{
		4307	if (h->size != 0
		4308	&& h->size != isym->st_size
		4309	&& ! size_change_ok)
		4310	(*_bfd_error_handler)
		4311	(_("Warning: size of symbol `%s' changed"
		4312	" from %lu in %B to %lu in %B"),
		4313	old_bfd, abfd,
		4314	name, (unsigned long) h->size,
		4315	(unsigned long) isym->st_size);
		4316
		4317	h->size = isym->st_size;
		4318	}
		4319
		4320	/* If this is a common symbol, then we always want H->SIZE
		4321	to be the size of the common symbol. The code just above
		4322	won't fix the size if a common symbol becomes larger. We
		4323	don't warn about a size change here, because that is
		4324	covered by --warn-common. Allow changes between different
		4325	function types. */
		4326	if (h->root.type == bfd_link_hash_common)
		4327	h->size = h->root.u.c.size;
		4328
		4329	if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
		4330	&& ((definition && !new_weak)
		4331	\|\| (old_weak && h->root.type == bfd_link_hash_common)
		4332	\|\| h->type == STT_NOTYPE))
		4333	{
		4334	unsigned int type = ELF_ST_TYPE (isym->st_info);
		4335
		4336	/* Turn an IFUNC symbol from a DSO into a normal FUNC
		4337	symbol. */
		4338	if (type == STT_GNU_IFUNC
		4339	&& (abfd->flags & DYNAMIC) != 0)
		4340	type = STT_FUNC;
		4341
		4342	if (h->type != type)
		4343	{
		4344	if (h->type != STT_NOTYPE && ! type_change_ok)
		4345	(*_bfd_error_handler)
		4346	(_("Warning: type of symbol `%s' changed"
		4347	" from %d to %d in %B"),
		4348	abfd, name, h->type, type);
		4349
		4350	h->type = type;
		4351	}
		4352	}
		4353
		4354	/* Merge st_other field. */
		4355	elf_merge_st_other (abfd, h, isym, definition, dynamic);
		4356
		4357	/* We don't want to make debug symbol dynamic. */
		4358	if (definition && (sec->flags & SEC_DEBUGGING) && !info->relocatable)
		4359	dynsym = FALSE;
		4360
		4361	/* Nor should we make plugin symbols dynamic. */
		4362	if ((abfd->flags & BFD_PLUGIN) != 0)
		4363	dynsym = FALSE;
		4364
		4365	if (definition)
		4366	{
		4367	h->target_internal = isym->st_target_internal;
		4368	h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
		4369	}
		4370
		4371	if (definition && !dynamic)
		4372	{
		4373	char *p = strchr (name, ELF_VER_CHR);
		4374	if (p != NULL && p[1] != ELF_VER_CHR)
		4375	{
		4376	/* Queue non-default versions so that .symver x, x@FOO
		4377	aliases can be checked. */
		4378	if (!nondeflt_vers)
		4379	{
		4380	amt = ((isymend - isym + 1)
		4381	* sizeof (struct elf_link_hash_entry *));
		4382	nondeflt_vers =
		4383	(struct elf_link_hash_entry **) bfd_malloc (amt);
		4384	if (!nondeflt_vers)
		4385	goto error_free_vers;
		4386	}
		4387	nondeflt_vers[nondeflt_vers_cnt++] = h;
		4388	}
		4389	}
		4390
		4391	if (dynsym && h->dynindx == -1)
		4392	{
		4393	if (! bfd_elf_link_record_dynamic_symbol (info, h))
		4394	goto error_free_vers;
		4395	if (h->u.weakdef != NULL
		4396	&& ! new_weakdef
		4397	&& h->u.weakdef->dynindx == -1)
		4398	{
		4399	if (!bfd_elf_link_record_dynamic_symbol (info, h->u.weakdef))
		4400	goto error_free_vers;
		4401	}
		4402	}
		4403	else if (dynsym && h->dynindx != -1)
		4404	/* If the symbol already has a dynamic index, but
		4405	visibility says it should not be visible, turn it into
		4406	a local symbol. */
		4407	switch (ELF_ST_VISIBILITY (h->other))
		4408	{
		4409	case STV_INTERNAL:
		4410	case STV_HIDDEN:
		4411	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
		4412	dynsym = FALSE;
		4413	break;
		4414	}
		4415
		4416	/* Don't add DT_NEEDED for references from the dummy bfd. */
		4417	if (!add_needed
		4418	&& definition
		4419	&& ((dynsym
		4420	&& h->ref_regular_nonweak
		4421	&& (old_bfd == NULL
		4422	\|\| (old_bfd->flags & BFD_PLUGIN) == 0))
		4423	\|\| (h->ref_dynamic_nonweak
		4424	&& (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
		4425	&& !on_needed_list (elf_dt_name (abfd), htab->needed))))
		4426	{
		4427	int ret;
		4428	const char *soname = elf_dt_name (abfd);
		4429
		4430	/* A symbol from a library loaded via DT_NEEDED of some
		4431	other library is referenced by a regular object.
		4432	Add a DT_NEEDED entry for it. Issue an error if
		4433	--no-add-needed is used and the reference was not
		4434	a weak one. */
		4435	if (old_bfd != NULL
		4436	&& (elf_dyn_lib_class (abfd) & DYN_NO_NEEDED) != 0)
		4437	{
		4438	(*_bfd_error_handler)
		4439	(_("%B: undefined reference to symbol '%s'"),
		4440	old_bfd, name);
		4441	bfd_set_error (bfd_error_missing_dso);
		4442	goto error_free_vers;
		4443	}
		4444
		4445	elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
		4446	(elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
		4447
		4448	add_needed = TRUE;
		4449	ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
		4450	if (ret < 0)
		4451	goto error_free_vers;
		4452
		4453	BFD_ASSERT (ret == 0);
		4454	}
		4455	}
		4456	}
		4457
		4458	if (extversym != NULL)
		4459	{
		4460	free (extversym);
		4461	extversym = NULL;
		4462	}
		4463
		4464	if (isymbuf != NULL)
		4465	{
		4466	free (isymbuf);
		4467	isymbuf = NULL;
		4468	}
		4469
		4470	if ((elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)
		4471	{
		4472	unsigned int i;
		4473
		4474	/* Restore the symbol table. */
		4475	old_ent = (char *) old_tab + tabsize;
		4476	memset (elf_sym_hashes (abfd), 0,
		4477	extsymcount * sizeof (struct elf_link_hash_entry *));
		4478	htab->root.table.table = old_table;
		4479	htab->root.table.size = old_size;
		4480	htab->root.table.count = old_count;
		4481	memcpy (htab->root.table.table, old_tab, tabsize);
		4482	htab->root.undefs = old_undefs;
		4483	htab->root.undefs_tail = old_undefs_tail;
		4484	_bfd_elf_strtab_restore_size (htab->dynstr, old_dynstr_size);
		4485	for (i = 0; i < htab->root.table.size; i++)
		4486	{
		4487	struct bfd_hash_entry *p;
		4488	struct elf_link_hash_entry *h;
		4489	bfd_size_type size;
		4490	unsigned int alignment_power;
		4491
		4492	for (p = htab->root.table.table[i]; p != NULL; p = p->next)
		4493	{
		4494	h = (struct elf_link_hash_entry *) p;
		4495	if (h->root.type == bfd_link_hash_warning)
		4496	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		4497	if (h->dynindx >= old_dynsymcount
		4498	&& h->dynstr_index < old_dynstr_size)
		4499	_bfd_elf_strtab_delref (htab->dynstr, h->dynstr_index);
		4500
		4501	/* Preserve the maximum alignment and size for common
		4502	symbols even if this dynamic lib isn't on DT_NEEDED
		4503	since it can still be loaded at run time by another
		4504	dynamic lib. */
		4505	if (h->root.type == bfd_link_hash_common)
		4506	{
		4507	size = h->root.u.c.size;
		4508	alignment_power = h->root.u.c.p->alignment_power;
		4509	}
		4510	else
		4511	{
		4512	size = 0;
		4513	alignment_power = 0;
		4514	}
		4515	memcpy (p, old_ent, htab->root.table.entsize);
		4516	old_ent = (char *) old_ent + htab->root.table.entsize;
		4517	h = (struct elf_link_hash_entry *) p;
		4518	if (h->root.type == bfd_link_hash_warning)
		4519	{
		4520	memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
		4521	old_ent = (char *) old_ent + htab->root.table.entsize;
		4522	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		4523	}
		4524	if (h->root.type == bfd_link_hash_common)
		4525	{
		4526	if (size > h->root.u.c.size)
		4527	h->root.u.c.size = size;
		4528	if (alignment_power > h->root.u.c.p->alignment_power)
		4529	h->root.u.c.p->alignment_power = alignment_power;
		4530	}
		4531	}
		4532	}
		4533
		4534	/* Make a special call to the linker "notice" function to
		4535	tell it that symbols added for crefs may need to be removed. */
		4536	if (!(*bed->notice_as_needed) (abfd, info, notice_not_needed))
		4537	goto error_free_vers;
		4538
		4539	free (old_tab);
		4540	objalloc_free_block ((struct objalloc *) htab->root.table.memory,
		4541	alloc_mark);
		4542	if (nondeflt_vers != NULL)
		4543	free (nondeflt_vers);
		4544	return TRUE;
		4545	}
		4546
		4547	if (old_tab != NULL)
		4548	{
		4549	if (!(*bed->notice_as_needed) (abfd, info, notice_needed))
		4550	goto error_free_vers;
		4551	free (old_tab);
		4552	old_tab = NULL;
		4553	}
		4554
		4555	/* Now that all the symbols from this input file are created, handle
		4556	.symver foo, foo@BAR such that any relocs against foo become foo@BAR. */
		4557	if (nondeflt_vers != NULL)
		4558	{
		4559	bfd_size_type cnt, symidx;
		4560
		4561	for (cnt = 0; cnt < nondeflt_vers_cnt; ++cnt)
		4562	{
		4563	struct elf_link_hash_entry h = nondeflt_vers[cnt], hi;
		4564	char shortname, p;
		4565
		4566	p = strchr (h->root.root.string, ELF_VER_CHR);
		4567	if (p == NULL
		4568	\|\| (h->root.type != bfd_link_hash_defined
		4569	&& h->root.type != bfd_link_hash_defweak))
		4570	continue;
		4571
		4572	amt = p - h->root.root.string;
		4573	shortname = (char *) bfd_malloc (amt + 1);
		4574	if (!shortname)
		4575	goto error_free_vers;
		4576	memcpy (shortname, h->root.root.string, amt);
		4577	shortname[amt] = '\0';
		4578
		4579	hi = (struct elf_link_hash_entry *)
		4580	bfd_link_hash_lookup (&htab->root, shortname,
		4581	FALSE, FALSE, FALSE);
		4582	if (hi != NULL
		4583	&& hi->root.type == h->root.type
		4584	&& hi->root.u.def.value == h->root.u.def.value
		4585	&& hi->root.u.def.section == h->root.u.def.section)
		4586	{
		4587	(*bed->elf_backend_hide_symbol) (info, hi, TRUE);
		4588	hi->root.type = bfd_link_hash_indirect;
		4589	hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
		4590	(*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
		4591	sym_hash = elf_sym_hashes (abfd);
		4592	if (sym_hash)
		4593	for (symidx = 0; symidx < extsymcount; ++symidx)
		4594	if (sym_hash[symidx] == hi)
		4595	{
		4596	sym_hash[symidx] = h;
		4597	break;
		4598	}
		4599	}
		4600	free (shortname);
		4601	}
		4602	free (nondeflt_vers);
		4603	nondeflt_vers = NULL;
		4604	}
		4605
		4606	/* Now set the weakdefs field correctly for all the weak defined
		4607	symbols we found. The only way to do this is to search all the
		4608	symbols. Since we only need the information for non functions in
		4609	dynamic objects, that's the only time we actually put anything on
		4610	the list WEAKS. We need this information so that if a regular
		4611	object refers to a symbol defined weakly in a dynamic object, the
		4612	real symbol in the dynamic object is also put in the dynamic
		4613	symbols; we also must arrange for both symbols to point to the
		4614	same memory location. We could handle the general case of symbol
		4615	aliasing, but a general symbol alias can only be generated in
		4616	assembler code, handling it correctly would be very time
		4617	consuming, and other ELF linkers don't handle general aliasing
		4618	either. */
		4619	if (weaks != NULL)
		4620	{
		4621	struct elf_link_hash_entry **hpp;
		4622	struct elf_link_hash_entry **hppend;
		4623	struct elf_link_hash_entry **sorted_sym_hash;
		4624	struct elf_link_hash_entry *h;
		4625	size_t sym_count;
		4626
		4627	/* Since we have to search the whole symbol list for each weak
		4628	defined symbol, search time for N weak defined symbols will be
		4629	O(N^2). Binary search will cut it down to O(NlogN). */
		4630	amt = extsymcount * sizeof (struct elf_link_hash_entry *);
		4631	sorted_sym_hash = (struct elf_link_hash_entry **) bfd_malloc (amt);
		4632	if (sorted_sym_hash == NULL)
		4633	goto error_return;
		4634	sym_hash = sorted_sym_hash;
		4635	hpp = elf_sym_hashes (abfd);
		4636	hppend = hpp + extsymcount;
		4637	sym_count = 0;
		4638	for (; hpp < hppend; hpp++)
		4639	{
		4640	h = *hpp;
		4641	if (h != NULL
		4642	&& h->root.type == bfd_link_hash_defined
		4643	&& !bed->is_function_type (h->type))
		4644	{
		4645	*sym_hash = h;
		4646	sym_hash++;
		4647	sym_count++;
		4648	}
		4649	}
		4650
		4651	qsort (sorted_sym_hash, sym_count,
		4652	sizeof (struct elf_link_hash_entry *),
		4653	elf_sort_symbol);
		4654
		4655	while (weaks != NULL)
		4656	{
		4657	struct elf_link_hash_entry *hlook;
		4658	asection *slook;
		4659	bfd_vma vlook;
		4660	size_t i, j, idx = 0;
		4661
		4662	hlook = weaks;
		4663	weaks = hlook->u.weakdef;
		4664	hlook->u.weakdef = NULL;
		4665
		4666	BFD_ASSERT (hlook->root.type == bfd_link_hash_defined
		4667	\|\| hlook->root.type == bfd_link_hash_defweak
		4668	\|\| hlook->root.type == bfd_link_hash_common
		4669	\|\| hlook->root.type == bfd_link_hash_indirect);
		4670	slook = hlook->root.u.def.section;
		4671	vlook = hlook->root.u.def.value;
		4672
		4673	i = 0;
		4674	j = sym_count;
		4675	while (i != j)
		4676	{
		4677	bfd_signed_vma vdiff;
		4678	idx = (i + j) / 2;
		4679	h = sorted_sym_hash[idx];
		4680	vdiff = vlook - h->root.u.def.value;
		4681	if (vdiff < 0)
		4682	j = idx;
		4683	else if (vdiff > 0)
		4684	i = idx + 1;
		4685	else
		4686	{
		4687	long sdiff = slook->id - h->root.u.def.section->id;
		4688	if (sdiff < 0)
		4689	j = idx;
		4690	else if (sdiff > 0)
		4691	i = idx + 1;
		4692	else
		4693	break;
		4694	}
		4695	}
		4696
		4697	/* We didn't find a value/section match. */
		4698	if (i == j)
		4699	continue;
		4700
		4701	/* With multiple aliases, or when the weak symbol is already
		4702	strongly defined, we have multiple matching symbols and
		4703	the binary search above may land on any of them. Step
		4704	one past the matching symbol(s). */
		4705	while (++idx != j)
		4706	{
		4707	h = sorted_sym_hash[idx];
		4708	if (h->root.u.def.section != slook
		4709	\|\| h->root.u.def.value != vlook)
		4710	break;
		4711	}
		4712
		4713	/* Now look back over the aliases. Since we sorted by size
		4714	as well as value and section, we'll choose the one with
		4715	the largest size. */
		4716	while (idx-- != i)
		4717	{
		4718	h = sorted_sym_hash[idx];
		4719
		4720	/* Stop if value or section doesn't match. */
		4721	if (h->root.u.def.section != slook
		4722	\|\| h->root.u.def.value != vlook)
		4723	break;
		4724	else if (h != hlook)
		4725	{
		4726	hlook->u.weakdef = h;
		4727
		4728	/* If the weak definition is in the list of dynamic
		4729	symbols, make sure the real definition is put
		4730	there as well. */
		4731	if (hlook->dynindx != -1 && h->dynindx == -1)
		4732	{
		4733	if (! bfd_elf_link_record_dynamic_symbol (info, h))
		4734	{
		4735	err_free_sym_hash:
		4736	free (sorted_sym_hash);
		4737	goto error_return;
		4738	}
		4739	}
		4740
		4741	/* If the real definition is in the list of dynamic
		4742	symbols, make sure the weak definition is put
		4743	there as well. If we don't do this, then the
		4744	dynamic loader might not merge the entries for the
		4745	real definition and the weak definition. */
		4746	if (h->dynindx != -1 && hlook->dynindx == -1)
		4747	{
		4748	if (! bfd_elf_link_record_dynamic_symbol (info, hlook))
		4749	goto err_free_sym_hash;
		4750	}
		4751	break;
		4752	}
		4753	}
		4754	}
		4755
		4756	free (sorted_sym_hash);
		4757	}
		4758
		4759	if (bed->check_directives
		4760	&& !(*bed->check_directives) (abfd, info))
		4761	return FALSE;
		4762
		4763	/* If this object is the same format as the output object, and it is
		4764	not a shared library, then let the backend look through the
		4765	relocs.
		4766
		4767	This is required to build global offset table entries and to
		4768	arrange for dynamic relocs. It is not required for the
		4769	particular common case of linking non PIC code, even when linking
		4770	against shared libraries, but unfortunately there is no way of
		4771	knowing whether an object file has been compiled PIC or not.
		4772	Looking through the relocs is not particularly time consuming.
		4773	The problem is that we must either (1) keep the relocs in memory,
		4774	which causes the linker to require additional runtime memory or
		4775	(2) read the relocs twice from the input file, which wastes time.
		4776	This would be a good case for using mmap.
		4777
		4778	I have no idea how to handle linking PIC code into a file of a
		4779	different format. It probably can't be done. */
		4780	if (! dynamic
		4781	&& is_elf_hash_table (htab)
		4782	&& bed->check_relocs != NULL
		4783	&& elf_object_id (abfd) == elf_hash_table_id (htab)
		4784	&& (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
		4785	{
		4786	asection *o;
		4787
		4788	for (o = abfd->sections; o != NULL; o = o->next)
		4789	{
		4790	Elf_Internal_Rela *internal_relocs;
		4791	bfd_boolean ok;
		4792
		4793	if ((o->flags & SEC_RELOC) == 0
		4794	\|\| o->reloc_count == 0
		4795	\|\| ((info->strip == strip_all \|\| info->strip == strip_debugger)
		4796	&& (o->flags & SEC_DEBUGGING) != 0)
		4797	\|\| bfd_is_abs_section (o->output_section))
		4798	continue;
		4799
		4800	internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
		4801	info->keep_memory);
		4802	if (internal_relocs == NULL)
		4803	goto error_return;
		4804
		4805	ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
		4806
		4807	if (elf_section_data (o)->relocs != internal_relocs)
		4808	free (internal_relocs);
		4809
		4810	if (! ok)
		4811	goto error_return;
		4812	}
		4813	}
		4814
		4815	/* If this is a non-traditional link, try to optimize the handling
		4816	of the .stab/.stabstr sections. */
		4817	if (! dynamic
		4818	&& ! info->traditional_format
		4819	&& is_elf_hash_table (htab)
		4820	&& (info->strip != strip_all && info->strip != strip_debugger))
		4821	{
		4822	asection *stabstr;
		4823
		4824	stabstr = bfd_get_section_by_name (abfd, ".stabstr");
		4825	if (stabstr != NULL)
		4826	{
		4827	bfd_size_type string_offset = 0;
		4828	asection *stab;
		4829
		4830	for (stab = abfd->sections; stab; stab = stab->next)
		4831	if (CONST_STRNEQ (stab->name, ".stab")
		4832	&& (!stab->name[5] \|\|
		4833	(stab->name[5] == '.' && ISDIGIT (stab->name[6])))
		4834	&& (stab->flags & SEC_MERGE) == 0
		4835	&& !bfd_is_abs_section (stab->output_section))
		4836	{
		4837	struct bfd_elf_section_data *secdata;
		4838
		4839	secdata = elf_section_data (stab);
		4840	if (! _bfd_link_section_stabs (abfd, &htab->stab_info, stab,
		4841	stabstr, &secdata->sec_info,
		4842	&string_offset))
		4843	goto error_return;
		4844	if (secdata->sec_info)
		4845	stab->sec_info_type = SEC_INFO_TYPE_STABS;
		4846	}
		4847	}
		4848	}
		4849
		4850	if (is_elf_hash_table (htab) && add_needed)
		4851	{
		4852	/* Add this bfd to the loaded list. */
		4853	struct elf_link_loaded_list *n;
		4854
		4855	n = (struct elf_link_loaded_list *)
		4856	bfd_alloc (abfd, sizeof (struct elf_link_loaded_list));
		4857	if (n == NULL)
		4858	goto error_return;
		4859	n->abfd = abfd;
		4860	n->next = htab->loaded;
		4861	htab->loaded = n;
		4862	}
		4863
		4864	return TRUE;
		4865
		4866	error_free_vers:
		4867	if (old_tab != NULL)
		4868	free (old_tab);
		4869	if (nondeflt_vers != NULL)
		4870	free (nondeflt_vers);
		4871	if (extversym != NULL)
		4872	free (extversym);
		4873	error_free_sym:
		4874	if (isymbuf != NULL)
		4875	free (isymbuf);
		4876	error_return:
		4877	return FALSE;
		4878	}
		4879
		4880	/* Return the linker hash table entry of a symbol that might be
		4881	satisfied by an archive symbol. Return -1 on error. */
		4882
		4883	struct elf_link_hash_entry *
		4884	_bfd_elf_archive_symbol_lookup (bfd *abfd,
		4885	struct bfd_link_info *info,
		4886	const char *name)
		4887	{
		4888	struct elf_link_hash_entry *h;
		4889	char p, copy;
		4890	size_t len, first;
		4891
		4892	h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
		4893	if (h != NULL)
		4894	return h;
		4895
		4896	/* If this is a default version (the name contains @@), look up the
		4897	symbol again with only one `@' as well as without the version.
		4898	The effect is that references to the symbol with and without the
		4899	version will be matched by the default symbol in the archive. */
		4900
		4901	p = strchr (name, ELF_VER_CHR);
		4902	if (p == NULL \|\| p[1] != ELF_VER_CHR)
		4903	return h;
		4904
		4905	/* First check with only one `@'. */
		4906	len = strlen (name);
		4907	copy = (char *) bfd_alloc (abfd, len);
		4908	if (copy == NULL)
		4909	return (struct elf_link_hash_entry *) 0 - 1;
		4910
		4911	first = p - name + 1;
		4912	memcpy (copy, name, first);
		4913	memcpy (copy + first, name + first + 1, len - first);
		4914
		4915	h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
		4916	if (h == NULL)
		4917	{
		4918	/* We also need to check references to the symbol without the
		4919	version. */
		4920	copy[first - 1] = '\0';
		4921	h = elf_link_hash_lookup (elf_hash_table (info), copy,
		4922	FALSE, FALSE, TRUE);
		4923	}
		4924
		4925	bfd_release (abfd, copy);
		4926	return h;
		4927	}
		4928
		4929	/* Add symbols from an ELF archive file to the linker hash table. We
		4930	don't use _bfd_generic_link_add_archive_symbols because of a
		4931	problem which arises on UnixWare. The UnixWare libc.so is an
		4932	archive which includes an entry libc.so.1 which defines a bunch of
		4933	symbols. The libc.so archive also includes a number of other
		4934	object files, which also define symbols, some of which are the same
		4935	as those defined in libc.so.1. Correct linking requires that we
		4936	consider each object file in turn, and include it if it defines any
		4937	symbols we need. _bfd_generic_link_add_archive_symbols does not do
		4938	this; it looks through the list of undefined symbols, and includes
		4939	any object file which defines them. When this algorithm is used on
		4940	UnixWare, it winds up pulling in libc.so.1 early and defining a
		4941	bunch of symbols. This means that some of the other objects in the
		4942	archive are not included in the link, which is incorrect since they
		4943	precede libc.so.1 in the archive.
		4944
		4945	Fortunately, ELF archive handling is simpler than that done by
		4946	_bfd_generic_link_add_archive_symbols, which has to allow for a.out
		4947	oddities. In ELF, if we find a symbol in the archive map, and the
		4948	symbol is currently undefined, we know that we must pull in that
		4949	object file.
		4950
		4951	Unfortunately, we do have to make multiple passes over the symbol
		4952	table until nothing further is resolved. */
		4953
		4954	static bfd_boolean
		4955	elf_link_add_archive_symbols (bfd abfd, struct bfd_link_info info)
		4956	{
		4957	symindex c;
		4958	bfd_boolean *defined = NULL;
		4959	bfd_boolean *included = NULL;
		4960	carsym *symdefs;
		4961	bfd_boolean loop;
		4962	bfd_size_type amt;
		4963	const struct elf_backend_data *bed;
		4964	struct elf_link_hash_entry * (*archive_symbol_lookup)
		4965	(bfd , struct bfd_link_info , const char *);
		4966
		4967	if (! bfd_has_map (abfd))
		4968	{
		4969	/* An empty archive is a special case. */
		4970	if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
		4971	return TRUE;
		4972	bfd_set_error (bfd_error_no_armap);
		4973	return FALSE;
		4974	}
		4975
		4976	/* Keep track of all symbols we know to be already defined, and all
		4977	files we know to be already included. This is to speed up the
		4978	second and subsequent passes. */
		4979	c = bfd_ardata (abfd)->symdef_count;
		4980	if (c == 0)
		4981	return TRUE;
		4982	amt = c;
		4983	amt *= sizeof (bfd_boolean);
		4984	defined = (bfd_boolean *) bfd_zmalloc (amt);
		4985	included = (bfd_boolean *) bfd_zmalloc (amt);
		4986	if (defined == NULL \|\| included == NULL)
		4987	goto error_return;
		4988
		4989	symdefs = bfd_ardata (abfd)->symdefs;
		4990	bed = get_elf_backend_data (abfd);
		4991	archive_symbol_lookup = bed->elf_backend_archive_symbol_lookup;
		4992
		4993	do
		4994	{
		4995	file_ptr last;
		4996	symindex i;
		4997	carsym *symdef;
		4998	carsym *symdefend;
		4999
		5000	loop = FALSE;
		5001	last = -1;
		5002
		5003	symdef = symdefs;
		5004	symdefend = symdef + c;
		5005	for (i = 0; symdef < symdefend; symdef++, i++)
		5006	{
		5007	struct elf_link_hash_entry *h;
		5008	bfd *element;
		5009	struct bfd_link_hash_entry *undefs_tail;
		5010	symindex mark;
		5011
		5012	if (defined[i] \|\| included[i])
		5013	continue;
		5014	if (symdef->file_offset == last)
		5015	{
		5016	included[i] = TRUE;
		5017	continue;
		5018	}
		5019
		5020	h = archive_symbol_lookup (abfd, info, symdef->name);
		5021	if (h == (struct elf_link_hash_entry *) 0 - 1)
		5022	goto error_return;
		5023
		5024	if (h == NULL)
		5025	continue;
		5026
		5027	if (h->root.type == bfd_link_hash_common)
		5028	{
		5029	/* We currently have a common symbol. The archive map contains
		5030	a reference to this symbol, so we may want to include it. We
		5031	only want to include it however, if this archive element
		5032	contains a definition of the symbol, not just another common
		5033	declaration of it.
		5034
		5035	Unfortunately some archivers (including GNU ar) will put
		5036	declarations of common symbols into their archive maps, as
		5037	well as real definitions, so we cannot just go by the archive
		5038	map alone. Instead we must read in the element's symbol
		5039	table and check that to see what kind of symbol definition
		5040	this is. */
		5041	if (! elf_link_is_defined_archive_symbol (abfd, symdef))
		5042	continue;
		5043	}
		5044	else if (h->root.type != bfd_link_hash_undefined)
		5045	{
		5046	if (h->root.type != bfd_link_hash_undefweak)
		5047	defined[i] = TRUE;
		5048	continue;
		5049	}
		5050
		5051	/* We need to include this archive member. */
		5052	element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
		5053	if (element == NULL)
		5054	goto error_return;
		5055
		5056	if (! bfd_check_format (element, bfd_object))
		5057	goto error_return;
		5058
		5059	/* Doublecheck that we have not included this object
		5060	already--it should be impossible, but there may be
		5061	something wrong with the archive. */
		5062	if (element->archive_pass != 0)
		5063	{
		5064	bfd_set_error (bfd_error_bad_value);
		5065	goto error_return;
		5066	}
		5067	element->archive_pass = 1;
		5068
		5069	undefs_tail = info->hash->undefs_tail;
		5070
		5071	if (!(*info->callbacks
		5072	->add_archive_element) (info, element, symdef->name, &element))
		5073	goto error_return;
		5074	if (!bfd_link_add_symbols (element, info))
		5075	goto error_return;
		5076
		5077	/* If there are any new undefined symbols, we need to make
		5078	another pass through the archive in order to see whether
		5079	they can be defined. FIXME: This isn't perfect, because
		5080	common symbols wind up on undefs_tail and because an
		5081	undefined symbol which is defined later on in this pass
		5082	does not require another pass. This isn't a bug, but it
		5083	does make the code less efficient than it could be. */
		5084	if (undefs_tail != info->hash->undefs_tail)
		5085	loop = TRUE;
		5086
		5087	/* Look backward to mark all symbols from this object file
		5088	which we have already seen in this pass. */
		5089	mark = i;
		5090	do
		5091	{
		5092	included[mark] = TRUE;
		5093	if (mark == 0)
		5094	break;
		5095	--mark;
		5096	}
		5097	while (symdefs[mark].file_offset == symdef->file_offset);
		5098
		5099	/* We mark subsequent symbols from this object file as we go
		5100	on through the loop. */
		5101	last = symdef->file_offset;
		5102	}
		5103	}
		5104	while (loop);
		5105
		5106	free (defined);
		5107	free (included);
		5108
		5109	return TRUE;
		5110
		5111	error_return:
		5112	if (defined != NULL)
		5113	free (defined);
		5114	if (included != NULL)
		5115	free (included);
		5116	return FALSE;
		5117	}
		5118
		5119	/* Given an ELF BFD, add symbols to the global hash table as
		5120	appropriate. */
		5121
		5122	bfd_boolean
		5123	bfd_elf_link_add_symbols (bfd abfd, struct bfd_link_info info)
		5124	{
		5125	switch (bfd_get_format (abfd))
		5126	{
		5127	case bfd_object:
		5128	return elf_link_add_object_symbols (abfd, info);
		5129	case bfd_archive:
		5130	return elf_link_add_archive_symbols (abfd, info);
		5131	default:
		5132	bfd_set_error (bfd_error_wrong_format);
		5133	return FALSE;
		5134	}
		5135	}
		5136
		5137	struct hash_codes_info
		5138	{
		5139	unsigned long *hashcodes;
		5140	bfd_boolean error;
		5141	};
		5142
		5143	/* This function will be called though elf_link_hash_traverse to store
		5144	all hash value of the exported symbols in an array. */
		5145
		5146	static bfd_boolean
		5147	elf_collect_hash_codes (struct elf_link_hash_entry h, void data)
		5148	{
		5149	struct hash_codes_info inf = (struct hash_codes_info ) data;
		5150	const char *name;
		5151	char *p;
		5152	unsigned long ha;
		5153	char *alc = NULL;
		5154
		5155	/* Ignore indirect symbols. These are added by the versioning code. */
		5156	if (h->dynindx == -1)
		5157	return TRUE;
		5158
		5159	name = h->root.root.string;
		5160	p = strchr (name, ELF_VER_CHR);
		5161	if (p != NULL)
		5162	{
		5163	alc = (char *) bfd_malloc (p - name + 1);
		5164	if (alc == NULL)
		5165	{
		5166	inf->error = TRUE;
		5167	return FALSE;
		5168	}
		5169	memcpy (alc, name, p - name);
		5170	alc[p - name] = '\0';
		5171	name = alc;
		5172	}
		5173
		5174	/* Compute the hash value. */
		5175	ha = bfd_elf_hash (name);
		5176
		5177	/* Store the found hash value in the array given as the argument. */
		5178	*(inf->hashcodes)++ = ha;
		5179
		5180	/* And store it in the struct so that we can put it in the hash table
		5181	later. */
		5182	h->u.elf_hash_value = ha;
		5183
		5184	if (alc != NULL)
		5185	free (alc);
		5186
		5187	return TRUE;
		5188	}
		5189
		5190	struct collect_gnu_hash_codes
		5191	{
		5192	bfd *output_bfd;
		5193	const struct elf_backend_data *bed;
		5194	unsigned long int nsyms;
		5195	unsigned long int maskbits;
		5196	unsigned long int *hashcodes;
		5197	unsigned long int *hashval;
		5198	unsigned long int *indx;
		5199	unsigned long int *counts;
		5200	bfd_vma *bitmask;
		5201	bfd_byte *contents;
		5202	long int min_dynindx;
		5203	unsigned long int bucketcount;
		5204	unsigned long int symindx;
		5205	long int local_indx;
		5206	long int shift1, shift2;
		5207	unsigned long int mask;
		5208	bfd_boolean error;
		5209	};
		5210
		5211	/* This function will be called though elf_link_hash_traverse to store
		5212	all hash value of the exported symbols in an array. */
		5213
		5214	static bfd_boolean
		5215	elf_collect_gnu_hash_codes (struct elf_link_hash_entry h, void data)
		5216	{
		5217	struct collect_gnu_hash_codes s = (struct collect_gnu_hash_codes ) data;
		5218	const char *name;
		5219	char *p;
		5220	unsigned long ha;
		5221	char *alc = NULL;
		5222
		5223	/* Ignore indirect symbols. These are added by the versioning code. */
		5224	if (h->dynindx == -1)
		5225	return TRUE;
		5226
		5227	/* Ignore also local symbols and undefined symbols. */
		5228	if (! (*s->bed->elf_hash_symbol) (h))
		5229	return TRUE;
		5230
		5231	name = h->root.root.string;
		5232	p = strchr (name, ELF_VER_CHR);
		5233	if (p != NULL)
		5234	{
		5235	alc = (char *) bfd_malloc (p - name + 1);
		5236	if (alc == NULL)
		5237	{
		5238	s->error = TRUE;
		5239	return FALSE;
		5240	}
		5241	memcpy (alc, name, p - name);
		5242	alc[p - name] = '\0';
		5243	name = alc;
		5244	}
		5245
		5246	/* Compute the hash value. */
		5247	ha = bfd_elf_gnu_hash (name);
		5248
		5249	/* Store the found hash value in the array for compute_bucket_count,
		5250	and also for .dynsym reordering purposes. */
		5251	s->hashcodes[s->nsyms] = ha;
		5252	s->hashval[h->dynindx] = ha;
		5253	++s->nsyms;
		5254	if (s->min_dynindx < 0 \|\| s->min_dynindx > h->dynindx)
		5255	s->min_dynindx = h->dynindx;
		5256
		5257	if (alc != NULL)
		5258	free (alc);
		5259
		5260	return TRUE;
		5261	}
		5262
		5263	/* This function will be called though elf_link_hash_traverse to do
		5264	final dynaminc symbol renumbering. */
		5265
		5266	static bfd_boolean
		5267	elf_renumber_gnu_hash_syms (struct elf_link_hash_entry h, void data)
		5268	{
		5269	struct collect_gnu_hash_codes s = (struct collect_gnu_hash_codes ) data;
		5270	unsigned long int bucket;
		5271	unsigned long int val;
		5272
		5273	/* Ignore indirect symbols. */
		5274	if (h->dynindx == -1)
		5275	return TRUE;
		5276
		5277	/* Ignore also local symbols and undefined symbols. */
		5278	if (! (*s->bed->elf_hash_symbol) (h))
		5279	{
		5280	if (h->dynindx >= s->min_dynindx)
		5281	h->dynindx = s->local_indx++;
		5282	return TRUE;
		5283	}
		5284
		5285	bucket = s->hashval[h->dynindx] % s->bucketcount;
		5286	val = (s->hashval[h->dynindx] >> s->shift1)
		5287	& ((s->maskbits >> s->shift1) - 1);
		5288	s->bitmask[val] \|= ((bfd_vma) 1) << (s->hashval[h->dynindx] & s->mask);
		5289	s->bitmask[val]
		5290	\|= ((bfd_vma) 1) << ((s->hashval[h->dynindx] >> s->shift2) & s->mask);
		5291	val = s->hashval[h->dynindx] & ~(unsigned long int) 1;
		5292	if (s->counts[bucket] == 1)
		5293	/* Last element terminates the chain. */
		5294	val \|= 1;
		5295	bfd_put_32 (s->output_bfd, val,
		5296	s->contents + (s->indx[bucket] - s->symindx) * 4);
		5297	--s->counts[bucket];
		5298	h->dynindx = s->indx[bucket]++;
		5299	return TRUE;
		5300	}
		5301
		5302	/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
		5303
		5304	bfd_boolean
		5305	_bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
		5306	{
		5307	return !(h->forced_local
		5308	\|\| h->root.type == bfd_link_hash_undefined
		5309	\|\| h->root.type == bfd_link_hash_undefweak
		5310	\|\| ((h->root.type == bfd_link_hash_defined
		5311	\|\| h->root.type == bfd_link_hash_defweak)
		5312	&& h->root.u.def.section->output_section == NULL));
		5313	}
		5314
		5315	/* Array used to determine the number of hash table buckets to use
		5316	based on the number of symbols there are. If there are fewer than
		5317	3 symbols we use 1 bucket, fewer than 17 symbols we use 3 buckets,
		5318	fewer than 37 we use 17 buckets, and so forth. We never use more
		5319	than 32771 buckets. */
		5320
		5321	static const size_t elf_buckets[] =
		5322	{
		5323	1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
		5324	16411, 32771, 0
		5325	};
		5326
		5327	/* Compute bucket count for hashing table. We do not use a static set
		5328	of possible tables sizes anymore. Instead we determine for all
		5329	possible reasonable sizes of the table the outcome (i.e., the
		5330	number of collisions etc) and choose the best solution. The
		5331	weighting functions are not too simple to allow the table to grow
		5332	without bounds. Instead one of the weighting factors is the size.
		5333	Therefore the result is always a good payoff between few collisions
		5334	(= short chain lengths) and table size. */
		5335	static size_t
		5336	compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
		5337	unsigned long int *hashcodes ATTRIBUTE_UNUSED,
		5338	unsigned long int nsyms,
		5339	int gnu_hash)
		5340	{
		5341	size_t best_size = 0;
		5342	unsigned long int i;
		5343
		5344	/* We have a problem here. The following code to optimize the table
		5345	size requires an integer type with more the 32 bits. If
		5346	BFD_HOST_U_64_BIT is set we know about such a type. */
		5347	#ifdef BFD_HOST_U_64_BIT
		5348	if (info->optimize)
		5349	{
		5350	size_t minsize;
		5351	size_t maxsize;
		5352	BFD_HOST_U_64_BIT best_chlen = ~((BFD_HOST_U_64_BIT) 0);
		5353	bfd *dynobj = elf_hash_table (info)->dynobj;
		5354	size_t dynsymcount = elf_hash_table (info)->dynsymcount;
		5355	const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
		5356	unsigned long int *counts;
		5357	bfd_size_type amt;
		5358	unsigned int no_improvement_count = 0;
		5359
		5360	/* Possible optimization parameters: if we have NSYMS symbols we say
		5361	that the hashing table must at least have NSYMS/4 and at most
		5362	2NSYMS buckets. /
		5363	minsize = nsyms / 4;
		5364	if (minsize == 0)
		5365	minsize = 1;
		5366	best_size = maxsize = nsyms * 2;
		5367	if (gnu_hash)
		5368	{
		5369	if (minsize < 2)
		5370	minsize = 2;
		5371	if ((best_size & 31) == 0)
		5372	++best_size;
		5373	}
		5374
		5375	/* Create array where we count the collisions in. We must use bfd_malloc
		5376	since the size could be large. */
		5377	amt = maxsize;
		5378	amt *= sizeof (unsigned long int);
		5379	counts = (unsigned long int *) bfd_malloc (amt);
		5380	if (counts == NULL)
		5381	return 0;
		5382
		5383	/* Compute the "optimal" size for the hash table. The criteria is a
		5384	minimal chain length. The minor criteria is (of course) the size
		5385	of the table. */
		5386	for (i = minsize; i < maxsize; ++i)
		5387	{
		5388	/* Walk through the array of hashcodes and count the collisions. */
		5389	BFD_HOST_U_64_BIT max;
		5390	unsigned long int j;
		5391	unsigned long int fact;
		5392
		5393	if (gnu_hash && (i & 31) == 0)
		5394	continue;
		5395
		5396	memset (counts, '\0', i * sizeof (unsigned long int));
		5397
		5398	/* Determine how often each hash bucket is used. */
		5399	for (j = 0; j < nsyms; ++j)
		5400	++counts[hashcodes[j] % i];
		5401
		5402	/* For the weight function we need some information about the
		5403	pagesize on the target. This is information need not be 100%
		5404	accurate. Since this information is not available (so far) we
		5405	define it here to a reasonable default value. If it is crucial
		5406	to have a better value some day simply define this value. */
		5407	# ifndef BFD_TARGET_PAGESIZE
		5408	# define BFD_TARGET_PAGESIZE (4096)
		5409	# endif
		5410
		5411	/* We in any case need 2 + DYNSYMCOUNT entries for the size values
		5412	and the chains. */
		5413	max = (2 + dynsymcount) * bed->s->sizeof_hash_entry;
		5414
		5415	# if 1
		5416	/* Variant 1: optimize for short chains. We add the squares
		5417	of all the chain lengths (which favors many small chain
		5418	over a few long chains). */
		5419	for (j = 0; j < i; ++j)
		5420	max += counts[j] * counts[j];
		5421
		5422	/* This adds penalties for the overall size of the table. */
		5423	fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
		5424	max = fact fact;
		5425	# else
		5426	/* Variant 2: Optimize a lot more for small table. Here we
		5427	also add squares of the size but we also add penalties for
		5428	empty slots (the +1 term). */
		5429	for (j = 0; j < i; ++j)
		5430	max += (1 + counts[j]) * (1 + counts[j]);
		5431
		5432	/* The overall size of the table is considered, but not as
		5433	strong as in variant 1, where it is squared. */
		5434	fact = i / (BFD_TARGET_PAGESIZE / bed->s->sizeof_hash_entry) + 1;
		5435	max *= fact;
		5436	# endif
		5437
		5438	/* Compare with current best results. */
		5439	if (max < best_chlen)
		5440	{
		5441	best_chlen = max;
		5442	best_size = i;
		5443	no_improvement_count = 0;
		5444	}
		5445	/* PR 11843: Avoid futile long searches for the best bucket size
		5446	when there are a large number of symbols. */
		5447	else if (++no_improvement_count == 100)
		5448	break;
		5449	}
		5450
		5451	free (counts);
		5452	}
		5453	else
		5454	#endif /* defined (BFD_HOST_U_64_BIT) */
		5455	{
		5456	/* This is the fallback solution if no 64bit type is available or if we
		5457	are not supposed to spend much time on optimizations. We select the
		5458	bucket count using a fixed set of numbers. */
		5459	for (i = 0; elf_buckets[i] != 0; i++)
		5460	{
		5461	best_size = elf_buckets[i];
		5462	if (nsyms < elf_buckets[i + 1])
		5463	break;
		5464	}
		5465	if (gnu_hash && best_size < 2)
		5466	best_size = 2;
		5467	}
		5468
		5469	return best_size;
		5470	}
		5471
		5472	/* Size any SHT_GROUP section for ld -r. */
		5473
		5474	bfd_boolean
		5475	_bfd_elf_size_group_sections (struct bfd_link_info *info)
		5476	{
		5477	bfd *ibfd;
		5478
		5479	for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
		5480	if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
		5481	&& !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
		5482	return FALSE;
		5483	return TRUE;
		5484	}
		5485
		5486	/* Set a default stack segment size. The value in INFO wins. If it
		5487	is unset, LEGACY_SYMBOL's value is used, and if that symbol is
		5488	undefined it is initialized. */
		5489
		5490	bfd_boolean
		5491	bfd_elf_stack_segment_size (bfd *output_bfd,
		5492	struct bfd_link_info *info,
		5493	const char *legacy_symbol,
		5494	bfd_vma default_size)
		5495	{
		5496	struct elf_link_hash_entry *h = NULL;
		5497
		5498	/* Look for legacy symbol. */
		5499	if (legacy_symbol)
		5500	h = elf_link_hash_lookup (elf_hash_table (info), legacy_symbol,
		5501	FALSE, FALSE, FALSE);
		5502	if (h && (h->root.type == bfd_link_hash_defined
		5503	\|\| h->root.type == bfd_link_hash_defweak)
		5504	&& h->def_regular
		5505	&& (h->type == STT_NOTYPE \|\| h->type == STT_OBJECT))
		5506	{
		5507	/* The symbol has no type if specified on the command line. */
		5508	h->type = STT_OBJECT;
		5509	if (info->stacksize)
		5510	(*_bfd_error_handler) (_("%B: stack size specified and %s set"),
		5511	output_bfd, legacy_symbol);
		5512	else if (h->root.u.def.section != bfd_abs_section_ptr)
		5513	(*_bfd_error_handler) (_("%B: %s not absolute"),
		5514	output_bfd, legacy_symbol);
		5515	else
		5516	info->stacksize = h->root.u.def.value;
		5517	}
		5518
		5519	if (!info->stacksize)
		5520	/* If the user didn't set a size, or explicitly inhibit the
		5521	size, set it now. */
		5522	info->stacksize = default_size;
		5523
		5524	/* Provide the legacy symbol, if it is referenced. */
		5525	if (h && (h->root.type == bfd_link_hash_undefined
		5526	\|\| h->root.type == bfd_link_hash_undefweak))
		5527	{
		5528	struct bfd_link_hash_entry *bh = NULL;
		5529
		5530	if (!(_bfd_generic_link_add_one_symbol
		5531	(info, output_bfd, legacy_symbol,
		5532	BSF_GLOBAL, bfd_abs_section_ptr,
		5533	info->stacksize >= 0 ? info->stacksize : 0,
		5534	NULL, FALSE, get_elf_backend_data (output_bfd)->collect, &bh)))
		5535	return FALSE;
		5536
		5537	h = (struct elf_link_hash_entry *) bh;
		5538	h->def_regular = 1;
		5539	h->type = STT_OBJECT;
		5540	}
		5541
		5542	return TRUE;
		5543	}
		5544
		5545	/* Set up the sizes and contents of the ELF dynamic sections. This is
		5546	called by the ELF linker emulation before_allocation routine. We
		5547	must set the sizes of the sections before the linker sets the
		5548	addresses of the various sections. */
		5549
		5550	bfd_boolean
		5551	bfd_elf_size_dynamic_sections (bfd *output_bfd,
		5552	const char *soname,
		5553	const char *rpath,
		5554	const char *filter_shlib,
		5555	const char *audit,
		5556	const char *depaudit,
		5557	const char * const *auxiliary_filters,
		5558	struct bfd_link_info *info,
		5559	asection **sinterpptr)
		5560	{
		5561	bfd_size_type soname_indx;
		5562	bfd *dynobj;
		5563	const struct elf_backend_data *bed;
		5564	struct elf_info_failed asvinfo;
		5565
		5566	*sinterpptr = NULL;
		5567
		5568	soname_indx = (bfd_size_type) -1;
		5569
		5570	if (!is_elf_hash_table (info->hash))
		5571	return TRUE;
		5572
		5573	bed = get_elf_backend_data (output_bfd);
		5574
		5575	/* Any syms created from now on start with -1 in
		5576	got.refcount/offset and plt.refcount/offset. */
		5577	elf_hash_table (info)->init_got_refcount
		5578	= elf_hash_table (info)->init_got_offset;
		5579	elf_hash_table (info)->init_plt_refcount
		5580	= elf_hash_table (info)->init_plt_offset;
		5581
		5582	if (info->relocatable
		5583	&& !_bfd_elf_size_group_sections (info))
		5584	return FALSE;
		5585
		5586	/* The backend may have to create some sections regardless of whether
		5587	we're dynamic or not. */
		5588	if (bed->elf_backend_always_size_sections
		5589	&& ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
		5590	return FALSE;
		5591
		5592	/* Determine any GNU_STACK segment requirements, after the backend
		5593	has had a chance to set a default segment size. */
		5594	if (info->execstack)
		5595	elf_stack_flags (output_bfd) = PF_R \| PF_W \| PF_X;
		5596	else if (info->noexecstack)
		5597	elf_stack_flags (output_bfd) = PF_R \| PF_W;
		5598	else
		5599	{
		5600	bfd *inputobj;
		5601	asection *notesec = NULL;
		5602	int exec = 0;
		5603
		5604	for (inputobj = info->input_bfds;
		5605	inputobj;
		5606	inputobj = inputobj->link_next)
		5607	{
		5608	asection *s;
		5609
		5610	if (inputobj->flags
		5611	& (DYNAMIC \| EXEC_P \| BFD_PLUGIN \| BFD_LINKER_CREATED))
		5612	continue;
		5613	s = bfd_get_section_by_name (inputobj, ".note.GNU-stack");
		5614	if (s)
		5615	{
		5616	if (s->flags & SEC_CODE)
		5617	exec = PF_X;
		5618	notesec = s;
		5619	}
		5620	else if (bed->default_execstack)
		5621	exec = PF_X;
		5622	}
		5623	if (notesec \|\| info->stacksize > 0)
		5624	elf_stack_flags (output_bfd) = PF_R \| PF_W \| exec;
		5625	if (notesec && exec && info->relocatable
		5626	&& notesec->output_section != bfd_abs_section_ptr)
		5627	notesec->output_section->flags \|= SEC_CODE;
		5628	}
		5629
		5630	dynobj = elf_hash_table (info)->dynobj;
		5631
		5632	if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
		5633	{
		5634	struct elf_info_failed eif;
		5635	struct elf_link_hash_entry *h;
		5636	asection *dynstr;
		5637	struct bfd_elf_version_tree *t;
		5638	struct bfd_elf_version_expr *d;
		5639	asection *s;
		5640	bfd_boolean all_defined;
		5641
		5642	*sinterpptr = bfd_get_linker_section (dynobj, ".interp");
		5643	BFD_ASSERT (*sinterpptr != NULL \|\| !info->executable);
		5644
		5645	if (soname != NULL)
		5646	{
		5647	soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
		5648	soname, TRUE);
		5649	if (soname_indx == (bfd_size_type) -1
		5650	\|\| !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
		5651	return FALSE;
		5652	}
		5653
		5654	if (info->symbolic)
		5655	{
		5656	if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
		5657	return FALSE;
		5658	info->flags \|= DF_SYMBOLIC;
		5659	}
		5660
		5661	if (rpath != NULL)
		5662	{
		5663	bfd_size_type indx;
		5664	bfd_vma tag;
		5665
		5666	indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
		5667	TRUE);
		5668	if (indx == (bfd_size_type) -1)
		5669	return FALSE;
		5670
		5671	tag = info->new_dtags ? DT_RUNPATH : DT_RPATH;
		5672	if (!_bfd_elf_add_dynamic_entry (info, tag, indx))
		5673	return FALSE;
		5674	}
		5675
		5676	if (filter_shlib != NULL)
		5677	{
		5678	bfd_size_type indx;
		5679
		5680	indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
		5681	filter_shlib, TRUE);
		5682	if (indx == (bfd_size_type) -1
		5683	\|\| !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
		5684	return FALSE;
		5685	}
		5686
		5687	if (auxiliary_filters != NULL)
		5688	{
		5689	const char * const *p;
		5690
		5691	for (p = auxiliary_filters; *p != NULL; p++)
		5692	{
		5693	bfd_size_type indx;
		5694
		5695	indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
		5696	*p, TRUE);
		5697	if (indx == (bfd_size_type) -1
		5698	\|\| !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
		5699	return FALSE;
		5700	}
		5701	}
		5702
		5703	if (audit != NULL)
		5704	{
		5705	bfd_size_type indx;
		5706
		5707	indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
		5708	TRUE);
		5709	if (indx == (bfd_size_type) -1
		5710	\|\| !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
		5711	return FALSE;
		5712	}
		5713
		5714	if (depaudit != NULL)
		5715	{
		5716	bfd_size_type indx;
		5717
		5718	indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
		5719	TRUE);
		5720	if (indx == (bfd_size_type) -1
		5721	\|\| !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
		5722	return FALSE;
		5723	}
		5724
		5725	eif.info = info;
		5726	eif.failed = FALSE;
		5727
		5728	/* If we are supposed to export all symbols into the dynamic symbol
		5729	table (this is not the normal case), then do so. */
		5730	if (info->export_dynamic
		5731	\|\| (info->executable && info->dynamic))
		5732	{
		5733	elf_link_hash_traverse (elf_hash_table (info),
		5734	_bfd_elf_export_symbol,
		5735	&eif);
		5736	if (eif.failed)
		5737	return FALSE;
		5738	}
		5739
		5740	/* Make all global versions with definition. */
		5741	for (t = info->version_info; t != NULL; t = t->next)
		5742	for (d = t->globals.list; d != NULL; d = d->next)
		5743	if (!d->symver && d->literal)
		5744	{
		5745	const char verstr, name;
		5746	size_t namelen, verlen, newlen;
		5747	char newname, p, leading_char;
		5748	struct elf_link_hash_entry *newh;
		5749
		5750	leading_char = bfd_get_symbol_leading_char (output_bfd);
		5751	name = d->pattern;
		5752	namelen = strlen (name) + (leading_char != '\0');
		5753	verstr = t->name;
		5754	verlen = strlen (verstr);
		5755	newlen = namelen + verlen + 3;
		5756
		5757	newname = (char *) bfd_malloc (newlen);
		5758	if (newname == NULL)
		5759	return FALSE;
		5760	newname[0] = leading_char;
		5761	memcpy (newname + (leading_char != '\0'), name, namelen);
		5762
		5763	/* Check the hidden versioned definition. */
		5764	p = newname + namelen;
		5765	*p++ = ELF_VER_CHR;
		5766	memcpy (p, verstr, verlen + 1);
		5767	newh = elf_link_hash_lookup (elf_hash_table (info),
		5768	newname, FALSE, FALSE,
		5769	FALSE);
		5770	if (newh == NULL
		5771	\|\| (newh->root.type != bfd_link_hash_defined
		5772	&& newh->root.type != bfd_link_hash_defweak))
		5773	{
		5774	/* Check the default versioned definition. */
		5775	*p++ = ELF_VER_CHR;
		5776	memcpy (p, verstr, verlen + 1);
		5777	newh = elf_link_hash_lookup (elf_hash_table (info),
		5778	newname, FALSE, FALSE,
		5779	FALSE);
		5780	}
		5781	free (newname);
		5782
		5783	/* Mark this version if there is a definition and it is
		5784	not defined in a shared object. */
		5785	if (newh != NULL
		5786	&& !newh->def_dynamic
		5787	&& (newh->root.type == bfd_link_hash_defined
		5788	\|\| newh->root.type == bfd_link_hash_defweak))
		5789	d->symver = 1;
		5790	}
		5791
		5792	/* Attach all the symbols to their version information. */
		5793	asvinfo.info = info;
		5794	asvinfo.failed = FALSE;
		5795
		5796	elf_link_hash_traverse (elf_hash_table (info),
		5797	_bfd_elf_link_assign_sym_version,
		5798	&asvinfo);
		5799	if (asvinfo.failed)
		5800	return FALSE;
		5801
		5802	if (!info->allow_undefined_version)
		5803	{
		5804	/* Check if all global versions have a definition. */
		5805	all_defined = TRUE;
		5806	for (t = info->version_info; t != NULL; t = t->next)
		5807	for (d = t->globals.list; d != NULL; d = d->next)
		5808	if (d->literal && !d->symver && !d->script)
		5809	{
		5810	(*_bfd_error_handler)
		5811	(_("%s: undefined version: %s"),
		5812	d->pattern, t->name);
		5813	all_defined = FALSE;
		5814	}
		5815
		5816	if (!all_defined)
		5817	{
		5818	bfd_set_error (bfd_error_bad_value);
		5819	return FALSE;
		5820	}
		5821	}
		5822
		5823	/* Find all symbols which were defined in a dynamic object and make
		5824	the backend pick a reasonable value for them. */
		5825	elf_link_hash_traverse (elf_hash_table (info),
		5826	_bfd_elf_adjust_dynamic_symbol,
		5827	&eif);
		5828	if (eif.failed)
		5829	return FALSE;
		5830
		5831	/* Add some entries to the .dynamic section. We fill in some of the
		5832	values later, in bfd_elf_final_link, but we must add the entries
		5833	now so that we know the final size of the .dynamic section. */
		5834
		5835	/* If there are initialization and/or finalization functions to
		5836	call then add the corresponding DT_INIT/DT_FINI entries. */
		5837	h = (info->init_function
		5838	? elf_link_hash_lookup (elf_hash_table (info),
		5839	info->init_function, FALSE,
		5840	FALSE, FALSE)
		5841	: NULL);
		5842	if (h != NULL
		5843	&& (h->ref_regular
		5844	\|\| h->def_regular))
		5845	{
		5846	if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
		5847	return FALSE;
		5848	}
		5849	h = (info->fini_function
		5850	? elf_link_hash_lookup (elf_hash_table (info),
		5851	info->fini_function, FALSE,
		5852	FALSE, FALSE)
		5853	: NULL);
		5854	if (h != NULL
		5855	&& (h->ref_regular
		5856	\|\| h->def_regular))
		5857	{
		5858	if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
		5859	return FALSE;
		5860	}
		5861
		5862	s = bfd_get_section_by_name (output_bfd, ".preinit_array");
		5863	if (s != NULL && s->linker_has_input)
		5864	{
		5865	/* DT_PREINIT_ARRAY is not allowed in shared library. */
		5866	if (! info->executable)
		5867	{
		5868	bfd *sub;
		5869	asection *o;
		5870
		5871	for (sub = info->input_bfds; sub != NULL;
		5872	sub = sub->link_next)
		5873	if (bfd_get_flavour (sub) == bfd_target_elf_flavour)
		5874	for (o = sub->sections; o != NULL; o = o->next)
		5875	if (elf_section_data (o)->this_hdr.sh_type
		5876	== SHT_PREINIT_ARRAY)
		5877	{
		5878	(*_bfd_error_handler)
		5879	(_("%B: .preinit_array section is not allowed in DSO"),
		5880	sub);
		5881	break;
		5882	}
		5883
		5884	bfd_set_error (bfd_error_nonrepresentable_section);
		5885	return FALSE;
		5886	}
		5887
		5888	if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
		5889	\|\| !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
		5890	return FALSE;
		5891	}
		5892	s = bfd_get_section_by_name (output_bfd, ".init_array");
		5893	if (s != NULL && s->linker_has_input)
		5894	{
		5895	if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
		5896	\|\| !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
		5897	return FALSE;
		5898	}
		5899	s = bfd_get_section_by_name (output_bfd, ".fini_array");
		5900	if (s != NULL && s->linker_has_input)
		5901	{
		5902	if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
		5903	\|\| !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
		5904	return FALSE;
		5905	}
		5906
		5907	dynstr = bfd_get_linker_section (dynobj, ".dynstr");
		5908	/* If .dynstr is excluded from the link, we don't want any of
		5909	these tags. Strictly, we should be checking each section
		5910	individually; This quick check covers for the case where
		5911	someone does a /DISCARD/ : { () }. */
		5912	if (dynstr != NULL && dynstr->output_section != bfd_abs_section_ptr)
		5913	{
		5914	bfd_size_type strsize;
		5915
		5916	strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
		5917	if ((info->emit_hash
		5918	&& !_bfd_elf_add_dynamic_entry (info, DT_HASH, 0))
		5919	\|\| (info->emit_gnu_hash
		5920	&& !_bfd_elf_add_dynamic_entry (info, DT_GNU_HASH, 0))
		5921	\|\| !_bfd_elf_add_dynamic_entry (info, DT_STRTAB, 0)
		5922	\|\| !_bfd_elf_add_dynamic_entry (info, DT_SYMTAB, 0)
		5923	\|\| !_bfd_elf_add_dynamic_entry (info, DT_STRSZ, strsize)
		5924	\|\| !_bfd_elf_add_dynamic_entry (info, DT_SYMENT,
		5925	bed->s->sizeof_sym))
		5926	return FALSE;
		5927	}
		5928	}
		5929
		5930	/* The backend must work out the sizes of all the other dynamic
		5931	sections. */
		5932	if (dynobj != NULL
		5933	&& bed->elf_backend_size_dynamic_sections != NULL
		5934	&& ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
		5935	return FALSE;
		5936
		5937	if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
		5938	return FALSE;
		5939
		5940	if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
		5941	{
		5942	unsigned long section_sym_count;
		5943	struct bfd_elf_version_tree *verdefs;
		5944	asection *s;
		5945
		5946	/* Set up the version definition section. */
		5947	s = bfd_get_linker_section (dynobj, ".gnu.version_d");
		5948	BFD_ASSERT (s != NULL);
		5949
		5950	/* We may have created additional version definitions if we are
		5951	just linking a regular application. */
		5952	verdefs = info->version_info;
		5953
		5954	/* Skip anonymous version tag. */
		5955	if (verdefs != NULL && verdefs->vernum == 0)
		5956	verdefs = verdefs->next;
		5957
		5958	if (verdefs == NULL && !info->create_default_symver)
		5959	s->flags \|= SEC_EXCLUDE;
		5960	else
		5961	{
		5962	unsigned int cdefs;
		5963	bfd_size_type size;
		5964	struct bfd_elf_version_tree *t;
		5965	bfd_byte *p;
		5966	Elf_Internal_Verdef def;
		5967	Elf_Internal_Verdaux defaux;
		5968	struct bfd_link_hash_entry *bh;
		5969	struct elf_link_hash_entry *h;
		5970	const char *name;
		5971
		5972	cdefs = 0;
		5973	size = 0;
		5974
		5975	/* Make space for the base version. */
		5976	size += sizeof (Elf_External_Verdef);
		5977	size += sizeof (Elf_External_Verdaux);
		5978	++cdefs;
		5979
		5980	/* Make space for the default version. */
		5981	if (info->create_default_symver)
		5982	{
		5983	size += sizeof (Elf_External_Verdef);
		5984	++cdefs;
		5985	}
		5986
		5987	for (t = verdefs; t != NULL; t = t->next)
		5988	{
		5989	struct bfd_elf_version_deps *n;
		5990
		5991	/* Don't emit base version twice. */
		5992	if (t->vernum == 0)
		5993	continue;
		5994
		5995	size += sizeof (Elf_External_Verdef);
		5996	size += sizeof (Elf_External_Verdaux);
		5997	++cdefs;
		5998
		5999	for (n = t->deps; n != NULL; n = n->next)
		6000	size += sizeof (Elf_External_Verdaux);
		6001	}
		6002
		6003	s->size = size;
		6004	s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
		6005	if (s->contents == NULL && s->size != 0)
		6006	return FALSE;
		6007
		6008	/* Fill in the version definition section. */
		6009
		6010	p = s->contents;
		6011
		6012	def.vd_version = VER_DEF_CURRENT;
		6013	def.vd_flags = VER_FLG_BASE;
		6014	def.vd_ndx = 1;
		6015	def.vd_cnt = 1;
		6016	if (info->create_default_symver)
		6017	{
		6018	def.vd_aux = 2 * sizeof (Elf_External_Verdef);
		6019	def.vd_next = sizeof (Elf_External_Verdef);
		6020	}
		6021	else
		6022	{
		6023	def.vd_aux = sizeof (Elf_External_Verdef);
		6024	def.vd_next = (sizeof (Elf_External_Verdef)
		6025	+ sizeof (Elf_External_Verdaux));
		6026	}
		6027
		6028	if (soname_indx != (bfd_size_type) -1)
		6029	{
		6030	_bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
		6031	soname_indx);
		6032	def.vd_hash = bfd_elf_hash (soname);
		6033	defaux.vda_name = soname_indx;
		6034	name = soname;
		6035	}
		6036	else
		6037	{
		6038	bfd_size_type indx;
		6039
		6040	name = lbasename (output_bfd->filename);
		6041	def.vd_hash = bfd_elf_hash (name);
		6042	indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
		6043	name, FALSE);
		6044	if (indx == (bfd_size_type) -1)
		6045	return FALSE;
		6046	defaux.vda_name = indx;
		6047	}
		6048	defaux.vda_next = 0;
		6049
		6050	_bfd_elf_swap_verdef_out (output_bfd, &def,
		6051	(Elf_External_Verdef *) p);
		6052	p += sizeof (Elf_External_Verdef);
		6053	if (info->create_default_symver)
		6054	{
		6055	/* Add a symbol representing this version. */
		6056	bh = NULL;
		6057	if (! (_bfd_generic_link_add_one_symbol
		6058	(info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
		6059	0, NULL, FALSE,
		6060	get_elf_backend_data (dynobj)->collect, &bh)))
		6061	return FALSE;
		6062	h = (struct elf_link_hash_entry *) bh;
		6063	h->non_elf = 0;
		6064	h->def_regular = 1;
		6065	h->type = STT_OBJECT;
		6066	h->verinfo.vertree = NULL;
		6067
		6068	if (! bfd_elf_link_record_dynamic_symbol (info, h))
		6069	return FALSE;
		6070
		6071	/* Create a duplicate of the base version with the same
		6072	aux block, but different flags. */
		6073	def.vd_flags = 0;
		6074	def.vd_ndx = 2;
		6075	def.vd_aux = sizeof (Elf_External_Verdef);
		6076	if (verdefs)
		6077	def.vd_next = (sizeof (Elf_External_Verdef)
		6078	+ sizeof (Elf_External_Verdaux));
		6079	else
		6080	def.vd_next = 0;
		6081	_bfd_elf_swap_verdef_out (output_bfd, &def,
		6082	(Elf_External_Verdef *) p);
		6083	p += sizeof (Elf_External_Verdef);
		6084	}
		6085	_bfd_elf_swap_verdaux_out (output_bfd, &defaux,
		6086	(Elf_External_Verdaux *) p);
		6087	p += sizeof (Elf_External_Verdaux);
		6088
		6089	for (t = verdefs; t != NULL; t = t->next)
		6090	{
		6091	unsigned int cdeps;
		6092	struct bfd_elf_version_deps *n;
		6093
		6094	/* Don't emit the base version twice. */
		6095	if (t->vernum == 0)
		6096	continue;
		6097
		6098	cdeps = 0;
		6099	for (n = t->deps; n != NULL; n = n->next)
		6100	++cdeps;
		6101
		6102	/* Add a symbol representing this version. */
		6103	bh = NULL;
		6104	if (! (_bfd_generic_link_add_one_symbol
		6105	(info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
		6106	0, NULL, FALSE,
		6107	get_elf_backend_data (dynobj)->collect, &bh)))
		6108	return FALSE;
		6109	h = (struct elf_link_hash_entry *) bh;
		6110	h->non_elf = 0;
		6111	h->def_regular = 1;
		6112	h->type = STT_OBJECT;
		6113	h->verinfo.vertree = t;
		6114
		6115	if (! bfd_elf_link_record_dynamic_symbol (info, h))
		6116	return FALSE;
		6117
		6118	def.vd_version = VER_DEF_CURRENT;
		6119	def.vd_flags = 0;
		6120	if (t->globals.list == NULL
		6121	&& t->locals.list == NULL
		6122	&& ! t->used)
		6123	def.vd_flags \|= VER_FLG_WEAK;
		6124	def.vd_ndx = t->vernum + (info->create_default_symver ? 2 : 1);
		6125	def.vd_cnt = cdeps + 1;
		6126	def.vd_hash = bfd_elf_hash (t->name);
		6127	def.vd_aux = sizeof (Elf_External_Verdef);
		6128	def.vd_next = 0;
		6129
		6130	/* If a basever node is next, it must be the last node in
		6131	the chain, otherwise Verdef construction breaks. */
		6132	if (t->next != NULL && t->next->vernum == 0)
		6133	BFD_ASSERT (t->next->next == NULL);
		6134
		6135	if (t->next != NULL && t->next->vernum != 0)
		6136	def.vd_next = (sizeof (Elf_External_Verdef)
		6137	+ (cdeps + 1) * sizeof (Elf_External_Verdaux));
		6138
		6139	_bfd_elf_swap_verdef_out (output_bfd, &def,
		6140	(Elf_External_Verdef *) p);
		6141	p += sizeof (Elf_External_Verdef);
		6142
		6143	defaux.vda_name = h->dynstr_index;
		6144	_bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
		6145	h->dynstr_index);
		6146	defaux.vda_next = 0;
		6147	if (t->deps != NULL)
		6148	defaux.vda_next = sizeof (Elf_External_Verdaux);
		6149	t->name_indx = defaux.vda_name;
		6150
		6151	_bfd_elf_swap_verdaux_out (output_bfd, &defaux,
		6152	(Elf_External_Verdaux *) p);
		6153	p += sizeof (Elf_External_Verdaux);
		6154
		6155	for (n = t->deps; n != NULL; n = n->next)
		6156	{
		6157	if (n->version_needed == NULL)
		6158	{
		6159	/* This can happen if there was an error in the
		6160	version script. */
		6161	defaux.vda_name = 0;
		6162	}
		6163	else
		6164	{
		6165	defaux.vda_name = n->version_needed->name_indx;
		6166	_bfd_elf_strtab_addref (elf_hash_table (info)->dynstr,
		6167	defaux.vda_name);
		6168	}
		6169	if (n->next == NULL)
		6170	defaux.vda_next = 0;
		6171	else
		6172	defaux.vda_next = sizeof (Elf_External_Verdaux);
		6173
		6174	_bfd_elf_swap_verdaux_out (output_bfd, &defaux,
		6175	(Elf_External_Verdaux *) p);
		6176	p += sizeof (Elf_External_Verdaux);
		6177	}
		6178	}
		6179
		6180	if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
		6181	\|\| !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
		6182	return FALSE;
		6183
		6184	elf_tdata (output_bfd)->cverdefs = cdefs;
		6185	}
		6186
		6187	if ((info->new_dtags && info->flags) \|\| (info->flags & DF_STATIC_TLS))
		6188	{
		6189	if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
		6190	return FALSE;
		6191	}
		6192	else if (info->flags & DF_BIND_NOW)
		6193	{
		6194	if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
		6195	return FALSE;
		6196	}
		6197
		6198	if (info->flags_1)
		6199	{
		6200	if (info->executable)
		6201	info->flags_1 &= ~ (DF_1_INITFIRST
		6202	\| DF_1_NODELETE
		6203	\| DF_1_NOOPEN);
		6204	if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
		6205	return FALSE;
		6206	}
		6207
		6208	/* Work out the size of the version reference section. */
		6209
		6210	s = bfd_get_linker_section (dynobj, ".gnu.version_r");
		6211	BFD_ASSERT (s != NULL);
		6212	{
		6213	struct elf_find_verdep_info sinfo;
		6214
		6215	sinfo.info = info;
		6216	sinfo.vers = elf_tdata (output_bfd)->cverdefs;
		6217	if (sinfo.vers == 0)
		6218	sinfo.vers = 1;
		6219	sinfo.failed = FALSE;
		6220
		6221	elf_link_hash_traverse (elf_hash_table (info),
		6222	_bfd_elf_link_find_version_dependencies,
		6223	&sinfo);
		6224	if (sinfo.failed)
		6225	return FALSE;
		6226
		6227	if (elf_tdata (output_bfd)->verref == NULL)
		6228	s->flags \|= SEC_EXCLUDE;
		6229	else
		6230	{
		6231	Elf_Internal_Verneed *t;
		6232	unsigned int size;
		6233	unsigned int crefs;
		6234	bfd_byte *p;
		6235
		6236	/* Build the version dependency section. */
		6237	size = 0;
		6238	crefs = 0;
		6239	for (t = elf_tdata (output_bfd)->verref;
		6240	t != NULL;
		6241	t = t->vn_nextref)
		6242	{
		6243	Elf_Internal_Vernaux *a;
		6244
		6245	size += sizeof (Elf_External_Verneed);
		6246	++crefs;
		6247	for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
		6248	size += sizeof (Elf_External_Vernaux);
		6249	}
		6250
		6251	s->size = size;
		6252	s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
		6253	if (s->contents == NULL)
		6254	return FALSE;
		6255
		6256	p = s->contents;
		6257	for (t = elf_tdata (output_bfd)->verref;
		6258	t != NULL;
		6259	t = t->vn_nextref)
		6260	{
		6261	unsigned int caux;
		6262	Elf_Internal_Vernaux *a;
		6263	bfd_size_type indx;
		6264
		6265	caux = 0;
		6266	for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
		6267	++caux;
		6268
		6269	t->vn_version = VER_NEED_CURRENT;
		6270	t->vn_cnt = caux;
		6271	indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
		6272	elf_dt_name (t->vn_bfd) != NULL
		6273	? elf_dt_name (t->vn_bfd)
		6274	: lbasename (t->vn_bfd->filename),
		6275	FALSE);
		6276	if (indx == (bfd_size_type) -1)
		6277	return FALSE;
		6278	t->vn_file = indx;
		6279	t->vn_aux = sizeof (Elf_External_Verneed);
		6280	if (t->vn_nextref == NULL)
		6281	t->vn_next = 0;
		6282	else
		6283	t->vn_next = (sizeof (Elf_External_Verneed)
		6284	+ caux * sizeof (Elf_External_Vernaux));
		6285
		6286	_bfd_elf_swap_verneed_out (output_bfd, t,
		6287	(Elf_External_Verneed *) p);
		6288	p += sizeof (Elf_External_Verneed);
		6289
		6290	for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
		6291	{
		6292	a->vna_hash = bfd_elf_hash (a->vna_nodename);
		6293	indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
		6294	a->vna_nodename, FALSE);
		6295	if (indx == (bfd_size_type) -1)
		6296	return FALSE;
		6297	a->vna_name = indx;
		6298	if (a->vna_nextptr == NULL)
		6299	a->vna_next = 0;
		6300	else
		6301	a->vna_next = sizeof (Elf_External_Vernaux);
		6302
		6303	_bfd_elf_swap_vernaux_out (output_bfd, a,
		6304	(Elf_External_Vernaux *) p);
		6305	p += sizeof (Elf_External_Vernaux);
		6306	}
		6307	}
		6308
		6309	if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
		6310	\|\| !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
		6311	return FALSE;
		6312
		6313	elf_tdata (output_bfd)->cverrefs = crefs;
		6314	}
		6315	}
		6316
		6317	if ((elf_tdata (output_bfd)->cverrefs == 0
		6318	&& elf_tdata (output_bfd)->cverdefs == 0)
		6319	\|\| _bfd_elf_link_renumber_dynsyms (output_bfd, info,
		6320	§ion_sym_count) == 0)
		6321	{
		6322	s = bfd_get_linker_section (dynobj, ".gnu.version");
		6323	s->flags \|= SEC_EXCLUDE;
		6324	}
		6325	}
		6326	return TRUE;
		6327	}
		6328
		6329	/* Find the first non-excluded output section. We'll use its
		6330	section symbol for some emitted relocs. */
		6331	void
		6332	_bfd_elf_init_1_index_section (bfd output_bfd, struct bfd_link_info info)
		6333	{
		6334	asection *s;
		6335
		6336	for (s = output_bfd->sections; s != NULL; s = s->next)
		6337	if ((s->flags & (SEC_EXCLUDE \| SEC_ALLOC)) == SEC_ALLOC
		6338	&& !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
		6339	{
		6340	elf_hash_table (info)->text_index_section = s;
		6341	break;
		6342	}
		6343	}
		6344
		6345	/* Find two non-excluded output sections, one for code, one for data.
		6346	We'll use their section symbols for some emitted relocs. */
		6347	void
		6348	_bfd_elf_init_2_index_sections (bfd output_bfd, struct bfd_link_info info)
		6349	{
		6350	asection *s;
		6351
		6352	/* Data first, since setting text_index_section changes
		6353	_bfd_elf_link_omit_section_dynsym. */
		6354	for (s = output_bfd->sections; s != NULL; s = s->next)
		6355	if (((s->flags & (SEC_EXCLUDE \| SEC_ALLOC \| SEC_READONLY)) == SEC_ALLOC)
		6356	&& !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
		6357	{
		6358	elf_hash_table (info)->data_index_section = s;
		6359	break;
		6360	}
		6361
		6362	for (s = output_bfd->sections; s != NULL; s = s->next)
		6363	if (((s->flags & (SEC_EXCLUDE \| SEC_ALLOC \| SEC_READONLY))
		6364	== (SEC_ALLOC \| SEC_READONLY))
		6365	&& !_bfd_elf_link_omit_section_dynsym (output_bfd, info, s))
		6366	{
		6367	elf_hash_table (info)->text_index_section = s;
		6368	break;
		6369	}
		6370
		6371	if (elf_hash_table (info)->text_index_section == NULL)
		6372	elf_hash_table (info)->text_index_section
		6373	= elf_hash_table (info)->data_index_section;
		6374	}
		6375
		6376	bfd_boolean
		6377	bfd_elf_size_dynsym_hash_dynstr (bfd output_bfd, struct bfd_link_info info)
		6378	{
		6379	const struct elf_backend_data *bed;
		6380
		6381	if (!is_elf_hash_table (info->hash))
		6382	return TRUE;
		6383
		6384	bed = get_elf_backend_data (output_bfd);
		6385	(*bed->elf_backend_init_index_section) (output_bfd, info);
		6386
		6387	if (elf_hash_table (info)->dynamic_sections_created)
		6388	{
		6389	bfd *dynobj;
		6390	asection *s;
		6391	bfd_size_type dynsymcount;
		6392	unsigned long section_sym_count;
		6393	unsigned int dtagcount;
		6394
		6395	dynobj = elf_hash_table (info)->dynobj;
		6396
		6397	/* Assign dynsym indicies. In a shared library we generate a
		6398	section symbol for each output section, which come first.
		6399	Next come all of the back-end allocated local dynamic syms,
		6400	followed by the rest of the global symbols. */
		6401
		6402	dynsymcount = _bfd_elf_link_renumber_dynsyms (output_bfd, info,
		6403	§ion_sym_count);
		6404
		6405	/* Work out the size of the symbol version section. */
		6406	s = bfd_get_linker_section (dynobj, ".gnu.version");
		6407	BFD_ASSERT (s != NULL);
		6408	if (dynsymcount != 0
		6409	&& (s->flags & SEC_EXCLUDE) == 0)
		6410	{
		6411	s->size = dynsymcount * sizeof (Elf_External_Versym);
		6412	s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
		6413	if (s->contents == NULL)
		6414	return FALSE;
		6415
		6416	if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
		6417	return FALSE;
		6418	}
		6419
		6420	/* Set the size of the .dynsym and .hash sections. We counted
		6421	the number of dynamic symbols in elf_link_add_object_symbols.
		6422	We will build the contents of .dynsym and .hash when we build
		6423	the final symbol table, because until then we do not know the
		6424	correct value to give the symbols. We built the .dynstr
		6425	section as we went along in elf_link_add_object_symbols. */
		6426	s = bfd_get_linker_section (dynobj, ".dynsym");
		6427	BFD_ASSERT (s != NULL);
		6428	s->size = dynsymcount * bed->s->sizeof_sym;
		6429
		6430	if (dynsymcount != 0)
		6431	{
		6432	s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
		6433	if (s->contents == NULL)
		6434	return FALSE;
		6435
		6436	/* The first entry in .dynsym is a dummy symbol.
		6437	Clear all the section syms, in case we don't output them all. */
		6438	++section_sym_count;
		6439	memset (s->contents, 0, section_sym_count * bed->s->sizeof_sym);
		6440	}
		6441
		6442	elf_hash_table (info)->bucketcount = 0;
		6443
		6444	/* Compute the size of the hashing table. As a side effect this
		6445	computes the hash values for all the names we export. */
		6446	if (info->emit_hash)
		6447	{
		6448	unsigned long int *hashcodes;
		6449	struct hash_codes_info hashinf;
		6450	bfd_size_type amt;
		6451	unsigned long int nsyms;
		6452	size_t bucketcount;
		6453	size_t hash_entry_size;
		6454
		6455	/* Compute the hash values for all exported symbols. At the same
		6456	time store the values in an array so that we could use them for
		6457	optimizations. */
		6458	amt = dynsymcount * sizeof (unsigned long int);
		6459	hashcodes = (unsigned long int *) bfd_malloc (amt);
		6460	if (hashcodes == NULL)
		6461	return FALSE;
		6462	hashinf.hashcodes = hashcodes;
		6463	hashinf.error = FALSE;
		6464
		6465	/* Put all hash values in HASHCODES. */
		6466	elf_link_hash_traverse (elf_hash_table (info),
		6467	elf_collect_hash_codes, &hashinf);
		6468	if (hashinf.error)
		6469	{
		6470	free (hashcodes);
		6471	return FALSE;
		6472	}
		6473
		6474	nsyms = hashinf.hashcodes - hashcodes;
		6475	bucketcount
		6476	= compute_bucket_count (info, hashcodes, nsyms, 0);
		6477	free (hashcodes);
		6478
		6479	if (bucketcount == 0)
		6480	return FALSE;
		6481
		6482	elf_hash_table (info)->bucketcount = bucketcount;
		6483
		6484	s = bfd_get_linker_section (dynobj, ".hash");
		6485	BFD_ASSERT (s != NULL);
		6486	hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
		6487	s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
		6488	s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
		6489	if (s->contents == NULL)
		6490	return FALSE;
		6491
		6492	bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
		6493	bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
		6494	s->contents + hash_entry_size);
		6495	}
		6496
		6497	if (info->emit_gnu_hash)
		6498	{
		6499	size_t i, cnt;
		6500	unsigned char *contents;
		6501	struct collect_gnu_hash_codes cinfo;
		6502	bfd_size_type amt;
		6503	size_t bucketcount;
		6504
		6505	memset (&cinfo, 0, sizeof (cinfo));
		6506
		6507	/* Compute the hash values for all exported symbols. At the same
		6508	time store the values in an array so that we could use them for
		6509	optimizations. */
		6510	amt = dynsymcount * 2 * sizeof (unsigned long int);
		6511	cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
		6512	if (cinfo.hashcodes == NULL)
		6513	return FALSE;
		6514
		6515	cinfo.hashval = cinfo.hashcodes + dynsymcount;
		6516	cinfo.min_dynindx = -1;
		6517	cinfo.output_bfd = output_bfd;
		6518	cinfo.bed = bed;
		6519
		6520	/* Put all hash values in HASHCODES. */
		6521	elf_link_hash_traverse (elf_hash_table (info),
		6522	elf_collect_gnu_hash_codes, &cinfo);
		6523	if (cinfo.error)
		6524	{
		6525	free (cinfo.hashcodes);
		6526	return FALSE;
		6527	}
		6528
		6529	bucketcount
		6530	= compute_bucket_count (info, cinfo.hashcodes, cinfo.nsyms, 1);
		6531
		6532	if (bucketcount == 0)
		6533	{
		6534	free (cinfo.hashcodes);
		6535	return FALSE;
		6536	}
		6537
		6538	s = bfd_get_linker_section (dynobj, ".gnu.hash");
		6539	BFD_ASSERT (s != NULL);
		6540
		6541	if (cinfo.nsyms == 0)
		6542	{
		6543	/* Empty .gnu.hash section is special. */
		6544	BFD_ASSERT (cinfo.min_dynindx == -1);
		6545	free (cinfo.hashcodes);
		6546	s->size = 5 * 4 + bed->s->arch_size / 8;
		6547	contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
		6548	if (contents == NULL)
		6549	return FALSE;
		6550	s->contents = contents;
		6551	/* 1 empty bucket. */
		6552	bfd_put_32 (output_bfd, 1, contents);
		6553	/* SYMIDX above the special symbol 0. */
		6554	bfd_put_32 (output_bfd, 1, contents + 4);
		6555	/* Just one word for bitmask. */
		6556	bfd_put_32 (output_bfd, 1, contents + 8);
		6557	/* Only hash fn bloom filter. */
		6558	bfd_put_32 (output_bfd, 0, contents + 12);
		6559	/* No hashes are valid - empty bitmask. */
		6560	bfd_put (bed->s->arch_size, output_bfd, 0, contents + 16);
		6561	/* No hashes in the only bucket. */
		6562	bfd_put_32 (output_bfd, 0,
		6563	contents + 16 + bed->s->arch_size / 8);
		6564	}
		6565	else
		6566	{
		6567	unsigned long int maskwords, maskbitslog2, x;
		6568	BFD_ASSERT (cinfo.min_dynindx != -1);
		6569
		6570	x = cinfo.nsyms;
		6571	maskbitslog2 = 1;
		6572	while ((x >>= 1) != 0)
		6573	++maskbitslog2;
		6574	if (maskbitslog2 < 3)
		6575	maskbitslog2 = 5;
		6576	else if ((1 << (maskbitslog2 - 2)) & cinfo.nsyms)
		6577	maskbitslog2 = maskbitslog2 + 3;
		6578	else
		6579	maskbitslog2 = maskbitslog2 + 2;
		6580	if (bed->s->arch_size == 64)
		6581	{
		6582	if (maskbitslog2 == 5)
		6583	maskbitslog2 = 6;
		6584	cinfo.shift1 = 6;
		6585	}
		6586	else
		6587	cinfo.shift1 = 5;
		6588	cinfo.mask = (1 << cinfo.shift1) - 1;
		6589	cinfo.shift2 = maskbitslog2;
		6590	cinfo.maskbits = 1 << maskbitslog2;
		6591	maskwords = 1 << (maskbitslog2 - cinfo.shift1);
		6592	amt = bucketcount * sizeof (unsigned long int) * 2;
		6593	amt += maskwords * sizeof (bfd_vma);
		6594	cinfo.bitmask = (bfd_vma *) bfd_malloc (amt);
		6595	if (cinfo.bitmask == NULL)
		6596	{
		6597	free (cinfo.hashcodes);
		6598	return FALSE;
		6599	}
		6600
		6601	cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
		6602	cinfo.indx = cinfo.counts + bucketcount;
		6603	cinfo.symindx = dynsymcount - cinfo.nsyms;
		6604	memset (cinfo.bitmask, 0, maskwords * sizeof (bfd_vma));
		6605
		6606	/* Determine how often each hash bucket is used. */
		6607	memset (cinfo.counts, 0, bucketcount * sizeof (cinfo.counts[0]));
		6608	for (i = 0; i < cinfo.nsyms; ++i)
		6609	++cinfo.counts[cinfo.hashcodes[i] % bucketcount];
		6610
		6611	for (i = 0, cnt = cinfo.symindx; i < bucketcount; ++i)
		6612	if (cinfo.counts[i] != 0)
		6613	{
		6614	cinfo.indx[i] = cnt;
		6615	cnt += cinfo.counts[i];
		6616	}
		6617	BFD_ASSERT (cnt == dynsymcount);
		6618	cinfo.bucketcount = bucketcount;
		6619	cinfo.local_indx = cinfo.min_dynindx;
		6620
		6621	s->size = (4 + bucketcount + cinfo.nsyms) * 4;
		6622	s->size += cinfo.maskbits / 8;
		6623	contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
		6624	if (contents == NULL)
		6625	{
		6626	free (cinfo.bitmask);
		6627	free (cinfo.hashcodes);
		6628	return FALSE;
		6629	}
		6630
		6631	s->contents = contents;
		6632	bfd_put_32 (output_bfd, bucketcount, contents);
		6633	bfd_put_32 (output_bfd, cinfo.symindx, contents + 4);
		6634	bfd_put_32 (output_bfd, maskwords, contents + 8);
		6635	bfd_put_32 (output_bfd, cinfo.shift2, contents + 12);
		6636	contents += 16 + cinfo.maskbits / 8;
		6637
		6638	for (i = 0; i < bucketcount; ++i)
		6639	{
		6640	if (cinfo.counts[i] == 0)
		6641	bfd_put_32 (output_bfd, 0, contents);
		6642	else
		6643	bfd_put_32 (output_bfd, cinfo.indx[i], contents);
		6644	contents += 4;
		6645	}
		6646
		6647	cinfo.contents = contents;
		6648
		6649	/* Renumber dynamic symbols, populate .gnu.hash section. */
		6650	elf_link_hash_traverse (elf_hash_table (info),
		6651	elf_renumber_gnu_hash_syms, &cinfo);
		6652
		6653	contents = s->contents + 16;
		6654	for (i = 0; i < maskwords; ++i)
		6655	{
		6656	bfd_put (bed->s->arch_size, output_bfd, cinfo.bitmask[i],
		6657	contents);
		6658	contents += bed->s->arch_size / 8;
		6659	}
		6660
		6661	free (cinfo.bitmask);
		6662	free (cinfo.hashcodes);
		6663	}
		6664	}
		6665
		6666	s = bfd_get_linker_section (dynobj, ".dynstr");
		6667	BFD_ASSERT (s != NULL);
		6668
		6669	elf_finalize_dynstr (output_bfd, info);
		6670
		6671	s->size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
		6672
		6673	for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
		6674	if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
		6675	return FALSE;
		6676	}
		6677
		6678	return TRUE;
		6679	}
		6680
		6681	/* Make sure sec_info_type is cleared if sec_info is cleared too. */
		6682
		6683	static void
		6684	merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
		6685	asection *sec)
		6686	{
		6687	BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_MERGE);
		6688	sec->sec_info_type = SEC_INFO_TYPE_NONE;
		6689	}
		6690
		6691	/* Finish SHF_MERGE section merging. */
		6692
		6693	bfd_boolean
		6694	_bfd_elf_merge_sections (bfd abfd, struct bfd_link_info info)
		6695	{
		6696	bfd *ibfd;
		6697	asection *sec;
		6698
		6699	if (!is_elf_hash_table (info->hash))
		6700	return FALSE;
		6701
		6702	for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
		6703	if ((ibfd->flags & DYNAMIC) == 0)
		6704	for (sec = ibfd->sections; sec != NULL; sec = sec->next)
		6705	if ((sec->flags & SEC_MERGE) != 0
		6706	&& !bfd_is_abs_section (sec->output_section))
		6707	{
		6708	struct bfd_elf_section_data *secdata;
		6709
		6710	secdata = elf_section_data (sec);
		6711	if (! _bfd_add_merge_section (abfd,
		6712	&elf_hash_table (info)->merge_info,
		6713	sec, &secdata->sec_info))
		6714	return FALSE;
		6715	else if (secdata->sec_info)
		6716	sec->sec_info_type = SEC_INFO_TYPE_MERGE;
		6717	}
		6718
		6719	if (elf_hash_table (info)->merge_info != NULL)
		6720	_bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
		6721	merge_sections_remove_hook);
		6722	return TRUE;
		6723	}
		6724
		6725	/* Create an entry in an ELF linker hash table. */
		6726
		6727	struct bfd_hash_entry *
		6728	_bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
		6729	struct bfd_hash_table *table,
		6730	const char *string)
		6731	{
		6732	/* Allocate the structure if it has not already been allocated by a
		6733	subclass. */
		6734	if (entry == NULL)
		6735	{
		6736	entry = (struct bfd_hash_entry *)
		6737	bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
		6738	if (entry == NULL)
		6739	return entry;
		6740	}
		6741
		6742	/* Call the allocation method of the superclass. */
		6743	entry = _bfd_link_hash_newfunc (entry, table, string);
		6744	if (entry != NULL)
		6745	{
		6746	struct elf_link_hash_entry ret = (struct elf_link_hash_entry ) entry;
		6747	struct elf_link_hash_table htab = (struct elf_link_hash_table ) table;
		6748
		6749	/* Set local fields. */
		6750	ret->indx = -1;
		6751	ret->dynindx = -1;
		6752	ret->got = htab->init_got_refcount;
		6753	ret->plt = htab->init_plt_refcount;
		6754	memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
		6755	- offsetof (struct elf_link_hash_entry, size)));
		6756	/* Assume that we have been called by a non-ELF symbol reader.
		6757	This flag is then reset by the code which reads an ELF input
		6758	file. This ensures that a symbol created by a non-ELF symbol
		6759	reader will have the flag set correctly. */
		6760	ret->non_elf = 1;
		6761	}
		6762
		6763	return entry;
		6764	}
		6765
		6766	/* Copy data from an indirect symbol to its direct symbol, hiding the
		6767	old indirect symbol. Also used for copying flags to a weakdef. */
		6768
		6769	void
		6770	_bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
		6771	struct elf_link_hash_entry *dir,
		6772	struct elf_link_hash_entry *ind)
		6773	{
		6774	struct elf_link_hash_table *htab;
		6775
		6776	/* Copy down any references that we may have already seen to the
		6777	symbol which just became indirect. */
		6778
		6779	dir->ref_dynamic \|= ind->ref_dynamic;
		6780	dir->ref_regular \|= ind->ref_regular;
		6781	dir->ref_regular_nonweak \|= ind->ref_regular_nonweak;
		6782	dir->non_got_ref \|= ind->non_got_ref;
		6783	dir->needs_plt \|= ind->needs_plt;
		6784	dir->pointer_equality_needed \|= ind->pointer_equality_needed;
		6785
		6786	if (ind->root.type != bfd_link_hash_indirect)
		6787	return;
		6788
		6789	/* Copy over the global and procedure linkage table refcount entries.
		6790	These may have been already set up by a check_relocs routine. */
		6791	htab = elf_hash_table (info);
		6792	if (ind->got.refcount > htab->init_got_refcount.refcount)
		6793	{
		6794	if (dir->got.refcount < 0)
		6795	dir->got.refcount = 0;
		6796	dir->got.refcount += ind->got.refcount;
		6797	ind->got.refcount = htab->init_got_refcount.refcount;
		6798	}
		6799
		6800	if (ind->plt.refcount > htab->init_plt_refcount.refcount)
		6801	{
		6802	if (dir->plt.refcount < 0)
		6803	dir->plt.refcount = 0;
		6804	dir->plt.refcount += ind->plt.refcount;
		6805	ind->plt.refcount = htab->init_plt_refcount.refcount;
		6806	}
		6807
		6808	if (ind->dynindx != -1)
		6809	{
		6810	if (dir->dynindx != -1)
		6811	_bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
		6812	dir->dynindx = ind->dynindx;
		6813	dir->dynstr_index = ind->dynstr_index;
		6814	ind->dynindx = -1;
		6815	ind->dynstr_index = 0;
		6816	}
		6817	}
		6818
		6819	void
		6820	_bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
		6821	struct elf_link_hash_entry *h,
		6822	bfd_boolean force_local)
		6823	{
		6824	/* STT_GNU_IFUNC symbol must go through PLT. */
		6825	if (h->type != STT_GNU_IFUNC)
		6826	{
		6827	h->plt = elf_hash_table (info)->init_plt_offset;
		6828	h->needs_plt = 0;
		6829	}
		6830	if (force_local)
		6831	{
		6832	h->forced_local = 1;
		6833	if (h->dynindx != -1)
		6834	{
		6835	h->dynindx = -1;
		6836	_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
		6837	h->dynstr_index);
		6838	}
		6839	}
		6840	}
		6841
		6842	/* Initialize an ELF linker hash table. *TABLE has been zeroed by our
		6843	caller. */
		6844
		6845	bfd_boolean
		6846	_bfd_elf_link_hash_table_init
		6847	(struct elf_link_hash_table *table,
		6848	bfd *abfd,
		6849	struct bfd_hash_entry (newfunc) (struct bfd_hash_entry *,
		6850	struct bfd_hash_table *,
		6851	const char *),
		6852	unsigned int entsize,
		6853	enum elf_target_id target_id)
		6854	{
		6855	bfd_boolean ret;
		6856	int can_refcount = get_elf_backend_data (abfd)->can_refcount;
		6857
		6858	table->init_got_refcount.refcount = can_refcount - 1;
		6859	table->init_plt_refcount.refcount = can_refcount - 1;
		6860	table->init_got_offset.offset = -(bfd_vma) 1;
		6861	table->init_plt_offset.offset = -(bfd_vma) 1;
		6862	/* The first dynamic symbol is a dummy. */
		6863	table->dynsymcount = 1;
		6864
		6865	ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
		6866
		6867	table->root.type = bfd_link_elf_hash_table;
		6868	table->hash_table_id = target_id;
		6869
		6870	return ret;
		6871	}
		6872
		6873	/* Create an ELF linker hash table. */
		6874
		6875	struct bfd_link_hash_table *
		6876	_bfd_elf_link_hash_table_create (bfd *abfd)
		6877	{
		6878	struct elf_link_hash_table *ret;
		6879	bfd_size_type amt = sizeof (struct elf_link_hash_table);
		6880
		6881	ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
		6882	if (ret == NULL)
		6883	return NULL;
		6884
		6885	if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
		6886	sizeof (struct elf_link_hash_entry),
		6887	GENERIC_ELF_DATA))
		6888	{
		6889	free (ret);
		6890	return NULL;
		6891	}
		6892
		6893	return &ret->root;
		6894	}
		6895
		6896	/* Destroy an ELF linker hash table. */
		6897
		6898	void
		6899	_bfd_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
		6900	{
		6901	struct elf_link_hash_table htab = (struct elf_link_hash_table ) hash;
		6902	if (htab->dynstr != NULL)
		6903	_bfd_elf_strtab_free (htab->dynstr);
		6904	_bfd_merge_sections_free (htab->merge_info);
		6905	_bfd_generic_link_hash_table_free (hash);
		6906	}
		6907
		6908	/* This is a hook for the ELF emulation code in the generic linker to
		6909	tell the backend linker what file name to use for the DT_NEEDED
		6910	entry for a dynamic object. */
		6911
		6912	void
		6913	bfd_elf_set_dt_needed_name (bfd abfd, const char name)
		6914	{
		6915	if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
		6916	&& bfd_get_format (abfd) == bfd_object)
		6917	elf_dt_name (abfd) = name;
		6918	}
		6919
		6920	int
		6921	bfd_elf_get_dyn_lib_class (bfd *abfd)
		6922	{
		6923	int lib_class;
		6924	if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
		6925	&& bfd_get_format (abfd) == bfd_object)
		6926	lib_class = elf_dyn_lib_class (abfd);
		6927	else
		6928	lib_class = 0;
		6929	return lib_class;
		6930	}
		6931
		6932	void
		6933	bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
		6934	{
		6935	if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
		6936	&& bfd_get_format (abfd) == bfd_object)
		6937	elf_dyn_lib_class (abfd) = lib_class;
		6938	}
		6939
		6940	/* Get the list of DT_NEEDED entries for a link. This is a hook for
		6941	the linker ELF emulation code. */
		6942
		6943	struct bfd_link_needed_list *
		6944	bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
		6945	struct bfd_link_info *info)
		6946	{
		6947	if (! is_elf_hash_table (info->hash))
		6948	return NULL;
		6949	return elf_hash_table (info)->needed;
		6950	}
		6951
		6952	/* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
		6953	hook for the linker ELF emulation code. */
		6954
		6955	struct bfd_link_needed_list *
		6956	bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
		6957	struct bfd_link_info *info)
		6958	{
		6959	if (! is_elf_hash_table (info->hash))
		6960	return NULL;
		6961	return elf_hash_table (info)->runpath;
		6962	}
		6963
		6964	/* Get the name actually used for a dynamic object for a link. This
		6965	is the SONAME entry if there is one. Otherwise, it is the string
		6966	passed to bfd_elf_set_dt_needed_name, or it is the filename. */
		6967
		6968	const char *
		6969	bfd_elf_get_dt_soname (bfd *abfd)
		6970	{
		6971	if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
		6972	&& bfd_get_format (abfd) == bfd_object)
		6973	return elf_dt_name (abfd);
		6974	return NULL;
		6975	}
		6976
		6977	/* Get the list of DT_NEEDED entries from a BFD. This is a hook for
		6978	the ELF linker emulation code. */
		6979
		6980	bfd_boolean
		6981	bfd_elf_get_bfd_needed_list (bfd *abfd,
		6982	struct bfd_link_needed_list **pneeded)
		6983	{
		6984	asection *s;
		6985	bfd_byte *dynbuf = NULL;
		6986	unsigned int elfsec;
		6987	unsigned long shlink;
		6988	bfd_byte extdyn, extdynend;
		6989	size_t extdynsize;
		6990	void (swap_dyn_in) (bfd , const void , Elf_Internal_Dyn );
		6991
		6992	*pneeded = NULL;
		6993
		6994	if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
		6995	\|\| bfd_get_format (abfd) != bfd_object)
		6996	return TRUE;
		6997
		6998	s = bfd_get_section_by_name (abfd, ".dynamic");
		6999	if (s == NULL \|\| s->size == 0)
		7000	return TRUE;
		7001
		7002	if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
		7003	goto error_return;
		7004
		7005	elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
		7006	if (elfsec == SHN_BAD)
		7007	goto error_return;
		7008
		7009	shlink = elf_elfsections (abfd)[elfsec]->sh_link;
		7010
		7011	extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
		7012	swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
		7013
		7014	extdyn = dynbuf;
		7015	extdynend = extdyn + s->size;
		7016	for (; extdyn < extdynend; extdyn += extdynsize)
		7017	{
		7018	Elf_Internal_Dyn dyn;
		7019
		7020	(*swap_dyn_in) (abfd, extdyn, &dyn);
		7021
		7022	if (dyn.d_tag == DT_NULL)
		7023	break;
		7024
		7025	if (dyn.d_tag == DT_NEEDED)
		7026	{
		7027	const char *string;
		7028	struct bfd_link_needed_list *l;
		7029	unsigned int tagv = dyn.d_un.d_val;
		7030	bfd_size_type amt;
		7031
		7032	string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
		7033	if (string == NULL)
		7034	goto error_return;
		7035
		7036	amt = sizeof *l;
		7037	l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
		7038	if (l == NULL)
		7039	goto error_return;
		7040
		7041	l->by = abfd;
		7042	l->name = string;
		7043	l->next = *pneeded;
		7044	*pneeded = l;
		7045	}
		7046	}
		7047
		7048	free (dynbuf);
		7049
		7050	return TRUE;
		7051
		7052	error_return:
		7053	if (dynbuf != NULL)
		7054	free (dynbuf);
		7055	return FALSE;
		7056	}
		7057
		7058	struct elf_symbuf_symbol
		7059	{
		7060	unsigned long st_name; /* Symbol name, index in string tbl */
		7061	unsigned char st_info; /* Type and binding attributes */
		7062	unsigned char st_other; /* Visibilty, and target specific */
		7063	};
		7064
		7065	struct elf_symbuf_head
		7066	{
		7067	struct elf_symbuf_symbol *ssym;
		7068	bfd_size_type count;
		7069	unsigned int st_shndx;
		7070	};
		7071
		7072	struct elf_symbol
		7073	{
		7074	union
		7075	{
		7076	Elf_Internal_Sym *isym;
		7077	struct elf_symbuf_symbol *ssym;
		7078	} u;
		7079	const char *name;
		7080	};
		7081
		7082	/* Sort references to symbols by ascending section number. */
		7083
		7084	static int
		7085	elf_sort_elf_symbol (const void arg1, const void arg2)
		7086	{
		7087	const Elf_Internal_Sym s1 = (const Elf_Internal_Sym **) arg1;
		7088	const Elf_Internal_Sym s2 = (const Elf_Internal_Sym **) arg2;
		7089
		7090	return s1->st_shndx - s2->st_shndx;
		7091	}
		7092
		7093	static int
		7094	elf_sym_name_compare (const void arg1, const void arg2)
		7095	{
		7096	const struct elf_symbol s1 = (const struct elf_symbol ) arg1;
		7097	const struct elf_symbol s2 = (const struct elf_symbol ) arg2;
		7098	return strcmp (s1->name, s2->name);
		7099	}
		7100
		7101	static struct elf_symbuf_head *
		7102	elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
		7103	{
		7104	Elf_Internal_Sym ind, indbufend, **indbuf;
		7105	struct elf_symbuf_symbol *ssym;
		7106	struct elf_symbuf_head ssymbuf, ssymhead;
		7107	bfd_size_type i, shndx_count, total_size;
		7108
		7109	indbuf = (Elf_Internal_Sym *) bfd_malloc2 (symcount, sizeof (indbuf));
		7110	if (indbuf == NULL)
		7111	return NULL;
		7112
		7113	for (ind = indbuf, i = 0; i < symcount; i++)
		7114	if (isymbuf[i].st_shndx != SHN_UNDEF)
		7115	*ind++ = &isymbuf[i];
		7116	indbufend = ind;
		7117
		7118	qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
		7119	elf_sort_elf_symbol);
		7120
		7121	shndx_count = 0;
		7122	if (indbufend > indbuf)
		7123	for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
		7124	if (ind[0]->st_shndx != ind[1]->st_shndx)
		7125	shndx_count++;
		7126
		7127	total_size = ((shndx_count + 1) * sizeof (*ssymbuf)
		7128	+ (indbufend - indbuf) * sizeof (*ssym));
		7129	ssymbuf = (struct elf_symbuf_head *) bfd_malloc (total_size);
		7130	if (ssymbuf == NULL)
		7131	{
		7132	free (indbuf);
		7133	return NULL;
		7134	}
		7135
		7136	ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count + 1);
		7137	ssymbuf->ssym = NULL;
		7138	ssymbuf->count = shndx_count;
		7139	ssymbuf->st_shndx = 0;
		7140	for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
		7141	{
		7142	if (ind == indbuf \|\| ssymhead->st_shndx != (*ind)->st_shndx)
		7143	{
		7144	ssymhead++;
		7145	ssymhead->ssym = ssym;
		7146	ssymhead->count = 0;
		7147	ssymhead->st_shndx = (*ind)->st_shndx;
		7148	}
		7149	ssym->st_name = (*ind)->st_name;
		7150	ssym->st_info = (*ind)->st_info;
		7151	ssym->st_other = (*ind)->st_other;
		7152	ssymhead->count++;
		7153	}
		7154	BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count
		7155	&& (((bfd_hostptr_t) ssym - (bfd_hostptr_t) ssymbuf)
		7156	== total_size));
		7157
		7158	free (indbuf);
		7159	return ssymbuf;
		7160	}
		7161
		7162	/* Check if 2 sections define the same set of local and global
		7163	symbols. */
		7164
		7165	static bfd_boolean
		7166	bfd_elf_match_symbols_in_sections (asection sec1, asection sec2,
		7167	struct bfd_link_info *info)
		7168	{
		7169	bfd bfd1, bfd2;
		7170	const struct elf_backend_data bed1, bed2;
		7171	Elf_Internal_Shdr hdr1, hdr2;
		7172	bfd_size_type symcount1, symcount2;
		7173	Elf_Internal_Sym isymbuf1, isymbuf2;
		7174	struct elf_symbuf_head ssymbuf1, ssymbuf2;
		7175	Elf_Internal_Sym isym, isymend;
		7176	struct elf_symbol symtable1 = NULL, symtable2 = NULL;
		7177	bfd_size_type count1, count2, i;
		7178	unsigned int shndx1, shndx2;
		7179	bfd_boolean result;
		7180
		7181	bfd1 = sec1->owner;
		7182	bfd2 = sec2->owner;
		7183
		7184	/* Both sections have to be in ELF. */
		7185	if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
		7186	\|\| bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
		7187	return FALSE;
		7188
		7189	if (elf_section_type (sec1) != elf_section_type (sec2))
		7190	return FALSE;
		7191
		7192	shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
		7193	shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
		7194	if (shndx1 == SHN_BAD \|\| shndx2 == SHN_BAD)
		7195	return FALSE;
		7196
		7197	bed1 = get_elf_backend_data (bfd1);
		7198	bed2 = get_elf_backend_data (bfd2);
		7199	hdr1 = &elf_tdata (bfd1)->symtab_hdr;
		7200	symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
		7201	hdr2 = &elf_tdata (bfd2)->symtab_hdr;
		7202	symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
		7203
		7204	if (symcount1 == 0 \|\| symcount2 == 0)
		7205	return FALSE;
		7206
		7207	result = FALSE;
		7208	isymbuf1 = NULL;
		7209	isymbuf2 = NULL;
		7210	ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
		7211	ssymbuf2 = (struct elf_symbuf_head *) elf_tdata (bfd2)->symbuf;
		7212
		7213	if (ssymbuf1 == NULL)
		7214	{
		7215	isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
		7216	NULL, NULL, NULL);
		7217	if (isymbuf1 == NULL)
		7218	goto done;
		7219
		7220	if (!info->reduce_memory_overheads)
		7221	elf_tdata (bfd1)->symbuf = ssymbuf1
		7222	= elf_create_symbuf (symcount1, isymbuf1);
		7223	}
		7224
		7225	if (ssymbuf1 == NULL \|\| ssymbuf2 == NULL)
		7226	{
		7227	isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
		7228	NULL, NULL, NULL);
		7229	if (isymbuf2 == NULL)
		7230	goto done;
		7231
		7232	if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
		7233	elf_tdata (bfd2)->symbuf = ssymbuf2
		7234	= elf_create_symbuf (symcount2, isymbuf2);
		7235	}
		7236
		7237	if (ssymbuf1 != NULL && ssymbuf2 != NULL)
		7238	{
		7239	/* Optimized faster version. */
		7240	bfd_size_type lo, hi, mid;
		7241	struct elf_symbol *symp;
		7242	struct elf_symbuf_symbol ssym, ssymend;
		7243
		7244	lo = 0;
		7245	hi = ssymbuf1->count;
		7246	ssymbuf1++;
		7247	count1 = 0;
		7248	while (lo < hi)
		7249	{
		7250	mid = (lo + hi) / 2;
		7251	if (shndx1 < ssymbuf1[mid].st_shndx)
		7252	hi = mid;
		7253	else if (shndx1 > ssymbuf1[mid].st_shndx)
		7254	lo = mid + 1;
		7255	else
		7256	{
		7257	count1 = ssymbuf1[mid].count;
		7258	ssymbuf1 += mid;
		7259	break;
		7260	}
		7261	}
		7262
		7263	lo = 0;
		7264	hi = ssymbuf2->count;
		7265	ssymbuf2++;
		7266	count2 = 0;
		7267	while (lo < hi)
		7268	{
		7269	mid = (lo + hi) / 2;
		7270	if (shndx2 < ssymbuf2[mid].st_shndx)
		7271	hi = mid;
		7272	else if (shndx2 > ssymbuf2[mid].st_shndx)
		7273	lo = mid + 1;
		7274	else
		7275	{
		7276	count2 = ssymbuf2[mid].count;
		7277	ssymbuf2 += mid;
		7278	break;
		7279	}
		7280	}
		7281
		7282	if (count1 == 0 \|\| count2 == 0 \|\| count1 != count2)
		7283	goto done;
		7284
		7285	symtable1 = (struct elf_symbol *)
		7286	bfd_malloc (count1 * sizeof (struct elf_symbol));
		7287	symtable2 = (struct elf_symbol *)
		7288	bfd_malloc (count2 * sizeof (struct elf_symbol));
		7289	if (symtable1 == NULL \|\| symtable2 == NULL)
		7290	goto done;
		7291
		7292	symp = symtable1;
		7293	for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
		7294	ssym < ssymend; ssym++, symp++)
		7295	{
		7296	symp->u.ssym = ssym;
		7297	symp->name = bfd_elf_string_from_elf_section (bfd1,
		7298	hdr1->sh_link,
		7299	ssym->st_name);
		7300	}
		7301
		7302	symp = symtable2;
		7303	for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
		7304	ssym < ssymend; ssym++, symp++)
		7305	{
		7306	symp->u.ssym = ssym;
		7307	symp->name = bfd_elf_string_from_elf_section (bfd2,
		7308	hdr2->sh_link,
		7309	ssym->st_name);
		7310	}
		7311
		7312	/* Sort symbol by name. */
		7313	qsort (symtable1, count1, sizeof (struct elf_symbol),
		7314	elf_sym_name_compare);
		7315	qsort (symtable2, count1, sizeof (struct elf_symbol),
		7316	elf_sym_name_compare);
		7317
		7318	for (i = 0; i < count1; i++)
		7319	/* Two symbols must have the same binding, type and name. */
		7320	if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
		7321	\|\| symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
		7322	\|\| strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
		7323	goto done;
		7324
		7325	result = TRUE;
		7326	goto done;
		7327	}
		7328
		7329	symtable1 = (struct elf_symbol *)
		7330	bfd_malloc (symcount1 * sizeof (struct elf_symbol));
		7331	symtable2 = (struct elf_symbol *)
		7332	bfd_malloc (symcount2 * sizeof (struct elf_symbol));
		7333	if (symtable1 == NULL \|\| symtable2 == NULL)
		7334	goto done;
		7335
		7336	/* Count definitions in the section. */
		7337	count1 = 0;
		7338	for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
		7339	if (isym->st_shndx == shndx1)
		7340	symtable1[count1++].u.isym = isym;
		7341
		7342	count2 = 0;
		7343	for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
		7344	if (isym->st_shndx == shndx2)
		7345	symtable2[count2++].u.isym = isym;
		7346
		7347	if (count1 == 0 \|\| count2 == 0 \|\| count1 != count2)
		7348	goto done;
		7349
		7350	for (i = 0; i < count1; i++)
		7351	symtable1[i].name
		7352	= bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
		7353	symtable1[i].u.isym->st_name);
		7354
		7355	for (i = 0; i < count2; i++)
		7356	symtable2[i].name
		7357	= bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
		7358	symtable2[i].u.isym->st_name);
		7359
		7360	/* Sort symbol by name. */
		7361	qsort (symtable1, count1, sizeof (struct elf_symbol),
		7362	elf_sym_name_compare);
		7363	qsort (symtable2, count1, sizeof (struct elf_symbol),
		7364	elf_sym_name_compare);
		7365
		7366	for (i = 0; i < count1; i++)
		7367	/* Two symbols must have the same binding, type and name. */
		7368	if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
		7369	\|\| symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
		7370	\|\| strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
		7371	goto done;
		7372
		7373	result = TRUE;
		7374
		7375	done:
		7376	if (symtable1)
		7377	free (symtable1);
		7378	if (symtable2)
		7379	free (symtable2);
		7380	if (isymbuf1)
		7381	free (isymbuf1);
		7382	if (isymbuf2)
		7383	free (isymbuf2);
		7384
		7385	return result;
		7386	}
		7387
		7388	/* Return TRUE if 2 section types are compatible. */
		7389
		7390	bfd_boolean
		7391	_bfd_elf_match_sections_by_type (bfd abfd, const asection asec,
		7392	bfd bbfd, const asection bsec)
		7393	{
		7394	if (asec == NULL
		7395	\|\| bsec == NULL
		7396	\|\| abfd->xvec->flavour != bfd_target_elf_flavour
		7397	\|\| bbfd->xvec->flavour != bfd_target_elf_flavour)
		7398	return TRUE;
		7399
		7400	return elf_section_type (asec) == elf_section_type (bsec);
		7401	}
		7402
		7403	/* Final phase of ELF linker. */
		7404
		7405	/* A structure we use to avoid passing large numbers of arguments. */
		7406
		7407	struct elf_final_link_info
		7408	{
		7409	/* General link information. */
		7410	struct bfd_link_info *info;
		7411	/* Output BFD. */
		7412	bfd *output_bfd;
		7413	/* Symbol string table. */
		7414	struct bfd_strtab_hash *symstrtab;
		7415	/* .dynsym section. */
		7416	asection *dynsym_sec;
		7417	/* .hash section. */
		7418	asection *hash_sec;
		7419	/* symbol version section (.gnu.version). */
		7420	asection *symver_sec;
		7421	/* Buffer large enough to hold contents of any section. */
		7422	bfd_byte *contents;
		7423	/* Buffer large enough to hold external relocs of any section. */
		7424	void *external_relocs;
		7425	/* Buffer large enough to hold internal relocs of any section. */
		7426	Elf_Internal_Rela *internal_relocs;
		7427	/* Buffer large enough to hold external local symbols of any input
		7428	BFD. */
		7429	bfd_byte *external_syms;
		7430	/* And a buffer for symbol section indices. */
		7431	Elf_External_Sym_Shndx *locsym_shndx;
		7432	/* Buffer large enough to hold internal local symbols of any input
		7433	BFD. */
		7434	Elf_Internal_Sym *internal_syms;
		7435	/* Array large enough to hold a symbol index for each local symbol
		7436	of any input BFD. */
		7437	long *indices;
		7438	/* Array large enough to hold a section pointer for each local
		7439	symbol of any input BFD. */
		7440	asection **sections;
		7441	/* Buffer to hold swapped out symbols. */
		7442	bfd_byte *symbuf;
		7443	/* And one for symbol section indices. */
		7444	Elf_External_Sym_Shndx *symshndxbuf;
		7445	/* Number of swapped out symbols in buffer. */
		7446	size_t symbuf_count;
		7447	/* Number of symbols which fit in symbuf. */
		7448	size_t symbuf_size;
		7449	/* And same for symshndxbuf. */
		7450	size_t shndxbuf_size;
		7451	/* Number of STT_FILE syms seen. */
		7452	size_t filesym_count;
		7453	};
		7454
		7455	/* This struct is used to pass information to elf_link_output_extsym. */
		7456
		7457	struct elf_outext_info
		7458	{
		7459	bfd_boolean failed;
		7460	bfd_boolean localsyms;
		7461	bfd_boolean need_second_pass;
		7462	bfd_boolean second_pass;
		7463	struct elf_final_link_info *flinfo;
		7464	};
		7465
		7466
		7467	/* Support for evaluating a complex relocation.
		7468
		7469	Complex relocations are generalized, self-describing relocations. The
		7470	implementation of them consists of two parts: complex symbols, and the
		7471	relocations themselves.
		7472
		7473	The relocations are use a reserved elf-wide relocation type code (R_RELC
		7474	external / BFD_RELOC_RELC internal) and an encoding of relocation field
		7475	information (start bit, end bit, word width, etc) into the addend. This
		7476	information is extracted from CGEN-generated operand tables within gas.
		7477
		7478	Complex symbols are mangled symbols (BSF_RELC external / STT_RELC
		7479	internal) representing prefix-notation expressions, including but not
		7480	limited to those sorts of expressions normally encoded as addends in the
		7481	addend field. The symbol mangling format is:
		7482
		7483	:=
		7484	\| ':'
		7485	\| ':' ':'
		7486	;
		7487
		7488	:= 's' ':'
		7489	\| 'S' ':'
		7490	\| '#'
		7491	;
		7492
		7493	:= as in C
		7494	:= as in C, plus "0-" for unambiguous negation. */
		7495
		7496	static void
		7497	set_symbol_value (bfd *bfd_with_globals,
		7498	Elf_Internal_Sym *isymbuf,
		7499	size_t locsymcount,
		7500	size_t symidx,
		7501	bfd_vma val)
		7502	{
		7503	struct elf_link_hash_entry **sym_hashes;
		7504	struct elf_link_hash_entry *h;
		7505	size_t extsymoff = locsymcount;
		7506
		7507	if (symidx < locsymcount)
		7508	{
		7509	Elf_Internal_Sym *sym;
		7510
		7511	sym = isymbuf + symidx;
		7512	if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
		7513	{
		7514	/* It is a local symbol: move it to the
		7515	"absolute" section and give it a value. */
		7516	sym->st_shndx = SHN_ABS;
		7517	sym->st_value = val;
		7518	return;
		7519	}
		7520	BFD_ASSERT (elf_bad_symtab (bfd_with_globals));
		7521	extsymoff = 0;
		7522	}
		7523
		7524	/* It is a global symbol: set its link type
		7525	to "defined" and give it a value. */
		7526
		7527	sym_hashes = elf_sym_hashes (bfd_with_globals);
		7528	h = sym_hashes [symidx - extsymoff];
		7529	while (h->root.type == bfd_link_hash_indirect
		7530	\|\| h->root.type == bfd_link_hash_warning)
		7531	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		7532	h->root.type = bfd_link_hash_defined;
		7533	h->root.u.def.value = val;
		7534	h->root.u.def.section = bfd_abs_section_ptr;
		7535	}
		7536
		7537	static bfd_boolean
		7538	resolve_symbol (const char *name,
		7539	bfd *input_bfd,
		7540	struct elf_final_link_info *flinfo,
		7541	bfd_vma *result,
		7542	Elf_Internal_Sym *isymbuf,
		7543	size_t locsymcount)
		7544	{
		7545	Elf_Internal_Sym *sym;
		7546	struct bfd_link_hash_entry *global_entry;
		7547	const char *candidate = NULL;
		7548	Elf_Internal_Shdr *symtab_hdr;
		7549	size_t i;
		7550
		7551	symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
		7552
		7553	for (i = 0; i < locsymcount; ++ i)
		7554	{
		7555	sym = isymbuf + i;
		7556
		7557	if (ELF_ST_BIND (sym->st_info) != STB_LOCAL)
		7558	continue;
		7559
		7560	candidate = bfd_elf_string_from_elf_section (input_bfd,
		7561	symtab_hdr->sh_link,
		7562	sym->st_name);
		7563	#ifdef DEBUG
		7564	printf ("Comparing string: '%s' vs. '%s' = 0x%lx\n",
		7565	name, candidate, (unsigned long) sym->st_value);
		7566	#endif
		7567	if (candidate && strcmp (candidate, name) == 0)
		7568	{
		7569	asection *sec = flinfo->sections [i];
		7570
		7571	*result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
		7572	*result += sec->output_offset + sec->output_section->vma;
		7573	#ifdef DEBUG
		7574	printf ("Found symbol with value %8.8lx\n",
		7575	(unsigned long) *result);
		7576	#endif
		7577	return TRUE;
		7578	}
		7579	}
		7580
		7581	/* Hmm, haven't found it yet. perhaps it is a global. */
		7582	global_entry = bfd_link_hash_lookup (flinfo->info->hash, name,
		7583	FALSE, FALSE, TRUE);
		7584	if (!global_entry)
		7585	return FALSE;
		7586
		7587	if (global_entry->type == bfd_link_hash_defined
		7588	\|\| global_entry->type == bfd_link_hash_defweak)
		7589	{
		7590	*result = (global_entry->u.def.value
		7591	+ global_entry->u.def.section->output_section->vma
		7592	+ global_entry->u.def.section->output_offset);
		7593	#ifdef DEBUG
		7594	printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
		7595	global_entry->root.string, (unsigned long) *result);
		7596	#endif
		7597	return TRUE;
		7598	}
		7599
		7600	return FALSE;
		7601	}
		7602
		7603	static bfd_boolean
		7604	resolve_section (const char *name,
		7605	asection *sections,
		7606	bfd_vma *result)
		7607	{
		7608	asection *curr;
		7609	unsigned int len;
		7610
		7611	for (curr = sections; curr; curr = curr->next)
		7612	if (strcmp (curr->name, name) == 0)
		7613	{
		7614	*result = curr->vma;
		7615	return TRUE;
		7616	}
		7617
		7618	/* Hmm. still haven't found it. try pseudo-section names. */
		7619	for (curr = sections; curr; curr = curr->next)
		7620	{
		7621	len = strlen (curr->name);
		7622	if (len > strlen (name))
		7623	continue;
		7624
		7625	if (strncmp (curr->name, name, len) == 0)
		7626	{
		7627	if (strncmp (".end", name + len, 4) == 0)
		7628	{
		7629	*result = curr->vma + curr->size;
		7630	return TRUE;
		7631	}
		7632
		7633	/* Insert more pseudo-section names here, if you like. */
		7634	}
		7635	}
		7636
		7637	return FALSE;
		7638	}
		7639
		7640	static void
		7641	undefined_reference (const char reftype, const char name)
		7642	{
		7643	_bfd_error_handler (_("undefined %s reference in complex symbol: %s"),
		7644	reftype, name);
		7645	}
		7646
		7647	static bfd_boolean
		7648	eval_symbol (bfd_vma *result,
		7649	const char **symp,
		7650	bfd *input_bfd,
		7651	struct elf_final_link_info *flinfo,
		7652	bfd_vma dot,
		7653	Elf_Internal_Sym *isymbuf,
		7654	size_t locsymcount,
		7655	int signed_p)
		7656	{
		7657	size_t len;
		7658	size_t symlen;
		7659	bfd_vma a;
		7660	bfd_vma b;
		7661	char symbuf[4096];
		7662	const char sym = symp;
		7663	const char *symend;
		7664	bfd_boolean symbol_is_section = FALSE;
		7665
		7666	len = strlen (sym);
		7667	symend = sym + len;
		7668
		7669	if (len < 1 \|\| len > sizeof (symbuf))
		7670	{
		7671	bfd_set_error (bfd_error_invalid_operation);
		7672	return FALSE;
		7673	}
		7674
		7675	switch (* sym)
		7676	{
		7677	case '.':
		7678	*result = dot;
		7679	*symp = sym + 1;
		7680	return TRUE;
		7681
		7682	case '#':
		7683	++sym;
		7684	result = strtoul (sym, (char *) symp, 16);
		7685	return TRUE;
		7686
		7687	case 'S':
		7688	symbol_is_section = TRUE;
		7689	case 's':
		7690	++sym;
		7691	symlen = strtol (sym, (char **) symp, 10);
		7692	sym = symp + 1; / Skip the trailing ':'. */
		7693
		7694	if (symend < sym \|\| symlen + 1 > sizeof (symbuf))
		7695	{
		7696	bfd_set_error (bfd_error_invalid_operation);
		7697	return FALSE;
		7698	}
		7699
		7700	memcpy (symbuf, sym, symlen);
		7701	symbuf[symlen] = '\0';
		7702	*symp = sym + symlen;
		7703
		7704	/* Is it always possible, with complex symbols, that gas "mis-guessed"
		7705	the symbol as a section, or vice-versa. so we're pretty liberal in our
		7706	interpretation here; section means "try section first", not "must be a
		7707	section", and likewise with symbol. */
		7708
		7709	if (symbol_is_section)
		7710	{
		7711	if (!resolve_section (symbuf, flinfo->output_bfd->sections, result)
		7712	&& !resolve_symbol (symbuf, input_bfd, flinfo, result,
		7713	isymbuf, locsymcount))
		7714	{
		7715	undefined_reference ("section", symbuf);
		7716	return FALSE;
		7717	}
		7718	}
		7719	else
		7720	{
		7721	if (!resolve_symbol (symbuf, input_bfd, flinfo, result,
		7722	isymbuf, locsymcount)
		7723	&& !resolve_section (symbuf, flinfo->output_bfd->sections,
		7724	result))
		7725	{
		7726	undefined_reference ("symbol", symbuf);
		7727	return FALSE;
		7728	}
		7729	}
		7730
		7731	return TRUE;
		7732
		7733	/* All that remains are operators. */
		7734
		7735	#define UNARY_OP(op) \
		7736	if (strncmp (sym, #op, strlen (#op)) == 0) \
		7737	{ \
		7738	sym += strlen (#op); \
		7739	if (*sym == ':') \
		7740	++sym; \
		7741	*symp = sym; \
		7742	if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
		7743	isymbuf, locsymcount, signed_p)) \
		7744	return FALSE; \
		7745	if (signed_p) \
		7746	*result = op ((bfd_signed_vma) a); \
		7747	else \
		7748	*result = op a; \
		7749	return TRUE; \
		7750	}
		7751
		7752	#define BINARY_OP(op) \
		7753	if (strncmp (sym, #op, strlen (#op)) == 0) \
		7754	{ \
		7755	sym += strlen (#op); \
		7756	if (*sym == ':') \
		7757	++sym; \
		7758	*symp = sym; \
		7759	if (!eval_symbol (&a, symp, input_bfd, flinfo, dot, \
		7760	isymbuf, locsymcount, signed_p)) \
		7761	return FALSE; \
		7762	++*symp; \
		7763	if (!eval_symbol (&b, symp, input_bfd, flinfo, dot, \
		7764	isymbuf, locsymcount, signed_p)) \
		7765	return FALSE; \
		7766	if (signed_p) \
		7767	*result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b); \
		7768	else \
		7769	*result = a op b; \
		7770	return TRUE; \
		7771	}
		7772
		7773	default:
		7774	UNARY_OP (0-);
		7775	BINARY_OP (<<);
		7776	BINARY_OP (>>);
		7777	BINARY_OP (==);
		7778	BINARY_OP (!=);
		7779	BINARY_OP (<=);
		7780	BINARY_OP (>=);
		7781	BINARY_OP (&&);
		7782	BINARY_OP (\|\|);
		7783	UNARY_OP (~);
		7784	UNARY_OP (!);
		7785	BINARY_OP (*);
		7786	BINARY_OP (/);
		7787	BINARY_OP (%);
		7788	BINARY_OP (^);
		7789	BINARY_OP (\|);
		7790	BINARY_OP (&);
		7791	BINARY_OP (+);
		7792	BINARY_OP (-);
		7793	BINARY_OP (<);
		7794	BINARY_OP (>);
		7795	#undef UNARY_OP
		7796	#undef BINARY_OP
		7797	_bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
		7798	bfd_set_error (bfd_error_invalid_operation);
		7799	return FALSE;
		7800	}
		7801	}
		7802
		7803	static void
		7804	put_value (bfd_vma size,
		7805	unsigned long chunksz,
		7806	bfd *input_bfd,
		7807	bfd_vma x,
		7808	bfd_byte *location)
		7809	{
		7810	location += (size - chunksz);
		7811
		7812	for (; size; size -= chunksz, location -= chunksz, x >>= (chunksz * 8))
		7813	{
		7814	switch (chunksz)
		7815	{
		7816	default:
		7817	case 0:
		7818	abort ();
		7819	case 1:
		7820	bfd_put_8 (input_bfd, x, location);
		7821	break;
		7822	case 2:
		7823	bfd_put_16 (input_bfd, x, location);
		7824	break;
		7825	case 4:
		7826	bfd_put_32 (input_bfd, x, location);
		7827	break;
		7828	case 8:
		7829	#ifdef BFD64
		7830	bfd_put_64 (input_bfd, x, location);
		7831	#else
		7832	abort ();
		7833	#endif
		7834	break;
		7835	}
		7836	}
		7837	}
		7838
		7839	static bfd_vma
		7840	get_value (bfd_vma size,
		7841	unsigned long chunksz,
		7842	bfd *input_bfd,
		7843	bfd_byte *location)
		7844	{
		7845	int shift;
		7846	bfd_vma x = 0;
		7847
		7848	/* Sanity checks. */
		7849	BFD_ASSERT (chunksz <= sizeof (x)
		7850	&& size >= chunksz
		7851	&& chunksz != 0
		7852	&& (size % chunksz) == 0
		7853	&& input_bfd != NULL
		7854	&& location != NULL);
		7855
		7856	if (chunksz == sizeof (x))
		7857	{
		7858	BFD_ASSERT (size == chunksz);
		7859
		7860	/* Make sure that we do not perform an undefined shift operation.
		7861	We know that size == chunksz so there will only be one iteration
		7862	of the loop below. */
		7863	shift = 0;
		7864	}
		7865	else
		7866	shift = 8 * chunksz;
		7867
		7868	for (; size; size -= chunksz, location += chunksz)
		7869	{
		7870	switch (chunksz)
		7871	{
		7872	case 1:
		7873	x = (x << shift) \| bfd_get_8 (input_bfd, location);
		7874	break;
		7875	case 2:
		7876	x = (x << shift) \| bfd_get_16 (input_bfd, location);
		7877	break;
		7878	case 4:
		7879	x = (x << shift) \| bfd_get_32 (input_bfd, location);
		7880	break;
		7881	#ifdef BFD64
		7882	case 8:
		7883	x = (x << shift) \| bfd_get_64 (input_bfd, location);
		7884	break;
		7885	#endif
		7886	default:
		7887	abort ();
		7888	}
		7889	}
		7890	return x;
		7891	}
		7892
		7893	static void
		7894	decode_complex_addend (unsigned long start, / in bits */
		7895	unsigned long oplen, / in bits */
		7896	unsigned long len, / in bits */
		7897	unsigned long wordsz, / in bytes */
		7898	unsigned long chunksz, / in bytes */
		7899	unsigned long *lsb0_p,
		7900	unsigned long *signed_p,
		7901	unsigned long *trunc_p,
		7902	unsigned long encoded)
		7903	{
		7904	* start = encoded & 0x3F;
		7905	* len = (encoded >> 6) & 0x3F;
		7906	* oplen = (encoded >> 12) & 0x3F;
		7907	* wordsz = (encoded >> 18) & 0xF;
		7908	* chunksz = (encoded >> 22) & 0xF;
		7909	* lsb0_p = (encoded >> 27) & 1;
		7910	* signed_p = (encoded >> 28) & 1;
		7911	* trunc_p = (encoded >> 29) & 1;
		7912	}
		7913
		7914	bfd_reloc_status_type
		7915	bfd_elf_perform_complex_relocation (bfd *input_bfd,
		7916	asection *input_section ATTRIBUTE_UNUSED,
		7917	bfd_byte *contents,
		7918	Elf_Internal_Rela *rel,
		7919	bfd_vma relocation)
		7920	{
		7921	bfd_vma shift, x, mask;
		7922	unsigned long start, oplen, len, wordsz, chunksz, lsb0_p, signed_p, trunc_p;
		7923	bfd_reloc_status_type r;
		7924
		7925	/* Perform this reloc, since it is complex.
		7926	(this is not to say that it necessarily refers to a complex
		7927	symbol; merely that it is a self-describing CGEN based reloc.
		7928	i.e. the addend has the complete reloc information (bit start, end,
		7929	word size, etc) encoded within it.). */
		7930
		7931	decode_complex_addend (&start, &oplen, &len, &wordsz,
		7932	&chunksz, &lsb0_p, &signed_p,
		7933	&trunc_p, rel->r_addend);
		7934
		7935	mask = (((1L << (len - 1)) - 1) << 1) \| 1;
		7936
		7937	if (lsb0_p)
		7938	shift = (start + 1) - len;
		7939	else
		7940	shift = (8 * wordsz) - (start + len);
		7941
		7942	/* FIXME: octets_per_byte. */
		7943	x = get_value (wordsz, chunksz, input_bfd, contents + rel->r_offset);
		7944
		7945	#ifdef DEBUG
		7946	printf ("Doing complex reloc: "
		7947	"lsb0? %ld, signed? %ld, trunc? %ld, wordsz %ld, "
		7948	"chunksz %ld, start %ld, len %ld, oplen %ld\n"
		7949	" dest: %8.8lx, mask: %8.8lx, reloc: %8.8lx\n",
		7950	lsb0_p, signed_p, trunc_p, wordsz, chunksz, start, len,
		7951	oplen, (unsigned long) x, (unsigned long) mask,
		7952	(unsigned long) relocation);
		7953	#endif
		7954
		7955	r = bfd_reloc_ok;
		7956	if (! trunc_p)
		7957	/* Now do an overflow check. */
		7958	r = bfd_check_overflow ((signed_p
		7959	? complain_overflow_signed
		7960	: complain_overflow_unsigned),
		7961	len, 0, (8 * wordsz),
		7962	relocation);
		7963
		7964	/* Do the deed. */
		7965	x = (x & ~(mask << shift)) \| ((relocation & mask) << shift);
		7966
		7967	#ifdef DEBUG
		7968	printf (" relocation: %8.8lx\n"
		7969	" shifted mask: %8.8lx\n"
		7970	" shifted/masked reloc: %8.8lx\n"
		7971	" result: %8.8lx\n",
		7972	(unsigned long) relocation, (unsigned long) (mask << shift),
		7973	(unsigned long) ((relocation & mask) << shift), (unsigned long) x);
		7974	#endif
		7975	/* FIXME: octets_per_byte. */
		7976	put_value (wordsz, chunksz, input_bfd, x, contents + rel->r_offset);
		7977	return r;
		7978	}
		7979
		7980	/* When performing a relocatable link, the input relocations are
		7981	preserved. But, if they reference global symbols, the indices
		7982	referenced must be updated. Update all the relocations found in
		7983	RELDATA. */
		7984
		7985	static void
		7986	elf_link_adjust_relocs (bfd *abfd,
		7987	struct bfd_elf_section_reloc_data *reldata)
		7988	{
		7989	unsigned int i;
		7990	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		7991	bfd_byte *erela;
		7992	void (swap_in) (bfd , const bfd_byte , Elf_Internal_Rela );
		7993	void (swap_out) (bfd , const Elf_Internal_Rela , bfd_byte );
		7994	bfd_vma r_type_mask;
		7995	int r_sym_shift;
		7996	unsigned int count = reldata->count;
		7997	struct elf_link_hash_entry **rel_hash = reldata->hashes;
		7998
		7999	if (reldata->hdr->sh_entsize == bed->s->sizeof_rel)
		8000	{
		8001	swap_in = bed->s->swap_reloc_in;
		8002	swap_out = bed->s->swap_reloc_out;
		8003	}
		8004	else if (reldata->hdr->sh_entsize == bed->s->sizeof_rela)
		8005	{
		8006	swap_in = bed->s->swap_reloca_in;
		8007	swap_out = bed->s->swap_reloca_out;
		8008	}
		8009	else
		8010	abort ();
		8011
		8012	if (bed->s->int_rels_per_ext_rel > MAX_INT_RELS_PER_EXT_REL)
		8013	abort ();
		8014
		8015	if (bed->s->arch_size == 32)
		8016	{
		8017	r_type_mask = 0xff;
		8018	r_sym_shift = 8;
		8019	}
		8020	else
		8021	{
		8022	r_type_mask = 0xffffffff;
		8023	r_sym_shift = 32;
		8024	}
		8025
		8026	erela = reldata->hdr->contents;
		8027	for (i = 0; i < count; i++, rel_hash++, erela += reldata->hdr->sh_entsize)
		8028	{
		8029	Elf_Internal_Rela irela[MAX_INT_RELS_PER_EXT_REL];
		8030	unsigned int j;
		8031
		8032	if (*rel_hash == NULL)
		8033	continue;
		8034
		8035	BFD_ASSERT ((*rel_hash)->indx >= 0);
		8036
		8037	(*swap_in) (abfd, erela, irela);
		8038	for (j = 0; j < bed->s->int_rels_per_ext_rel; j++)
		8039	irela[j].r_info = ((bfd_vma) (*rel_hash)->indx << r_sym_shift
		8040	\| (irela[j].r_info & r_type_mask));
		8041	(*swap_out) (abfd, irela, erela);
		8042	}
		8043	}
		8044
		8045	struct elf_link_sort_rela
		8046	{
		8047	union {
		8048	bfd_vma offset;
		8049	bfd_vma sym_mask;
		8050	} u;
		8051	enum elf_reloc_type_class type;
		8052	/* We use this as an array of size int_rels_per_ext_rel. */
		8053	Elf_Internal_Rela rela[1];
		8054	};
		8055
		8056	static int
		8057	elf_link_sort_cmp1 (const void A, const void B)
		8058	{
		8059	const struct elf_link_sort_rela a = (const struct elf_link_sort_rela ) A;
		8060	const struct elf_link_sort_rela b = (const struct elf_link_sort_rela ) B;
		8061	int relativea, relativeb;
		8062
		8063	relativea = a->type == reloc_class_relative;
		8064	relativeb = b->type == reloc_class_relative;
		8065
		8066	if (relativea < relativeb)
		8067	return 1;
		8068	if (relativea > relativeb)
		8069	return -1;
		8070	if ((a->rela->r_info & a->u.sym_mask) < (b->rela->r_info & b->u.sym_mask))
		8071	return -1;
		8072	if ((a->rela->r_info & a->u.sym_mask) > (b->rela->r_info & b->u.sym_mask))
		8073	return 1;
		8074	if (a->rela->r_offset < b->rela->r_offset)
		8075	return -1;
		8076	if (a->rela->r_offset > b->rela->r_offset)
		8077	return 1;
		8078	return 0;
		8079	}
		8080
		8081	static int
		8082	elf_link_sort_cmp2 (const void A, const void B)
		8083	{
		8084	const struct elf_link_sort_rela a = (const struct elf_link_sort_rela ) A;
		8085	const struct elf_link_sort_rela b = (const struct elf_link_sort_rela ) B;
		8086
		8087	if (a->type < b->type)
		8088	return -1;
		8089	if (a->type > b->type)
		8090	return 1;
		8091	if (a->u.offset < b->u.offset)
		8092	return -1;
		8093	if (a->u.offset > b->u.offset)
		8094	return 1;
		8095	if (a->rela->r_offset < b->rela->r_offset)
		8096	return -1;
		8097	if (a->rela->r_offset > b->rela->r_offset)
		8098	return 1;
		8099	return 0;
		8100	}
		8101
		8102	static size_t
		8103	elf_link_sort_relocs (bfd abfd, struct bfd_link_info info, asection **psec)
		8104	{
		8105	asection *dynamic_relocs;
		8106	asection *rela_dyn;
		8107	asection *rel_dyn;
		8108	bfd_size_type count, size;
		8109	size_t i, ret, sort_elt, ext_size;
		8110	bfd_byte sort, s_non_relative, *p;
		8111	struct elf_link_sort_rela *sq;
		8112	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		8113	int i2e = bed->s->int_rels_per_ext_rel;
		8114	void (swap_in) (bfd , const bfd_byte , Elf_Internal_Rela );
		8115	void (swap_out) (bfd , const Elf_Internal_Rela , bfd_byte );
		8116	struct bfd_link_order *lo;
		8117	bfd_vma r_sym_mask;
		8118	bfd_boolean use_rela;
		8119
		8120	/* Find a dynamic reloc section. */
		8121	rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
		8122	rel_dyn = bfd_get_section_by_name (abfd, ".rel.dyn");
		8123	if (rela_dyn != NULL && rela_dyn->size > 0
		8124	&& rel_dyn != NULL && rel_dyn->size > 0)
		8125	{
		8126	bfd_boolean use_rela_initialised = FALSE;
		8127
		8128	/* This is just here to stop gcc from complaining.
		8129	It's initialization checking code is not perfect. */
		8130	use_rela = TRUE;
		8131
		8132	/* Both sections are present. Examine the sizes
		8133	of the indirect sections to help us choose. */
		8134	for (lo = rela_dyn->map_head.link_order; lo != NULL; lo = lo->next)
		8135	if (lo->type == bfd_indirect_link_order)
		8136	{
		8137	asection *o = lo->u.indirect.section;
		8138
		8139	if ((o->size % bed->s->sizeof_rela) == 0)
		8140	{
		8141	if ((o->size % bed->s->sizeof_rel) == 0)
		8142	/* Section size is divisible by both rel and rela sizes.
		8143	It is of no help to us. */
		8144	;
		8145	else
		8146	{
		8147	/* Section size is only divisible by rela. */
		8148	if (use_rela_initialised && (use_rela == FALSE))
		8149	{
		8150	_bfd_error_handler
		8151	(_("%B: Unable to sort relocs - they are in more than one size"), abfd);
		8152	bfd_set_error (bfd_error_invalid_operation);
		8153	return 0;
		8154	}
		8155	else
		8156	{
		8157	use_rela = TRUE;
		8158	use_rela_initialised = TRUE;
		8159	}
		8160	}
		8161	}
		8162	else if ((o->size % bed->s->sizeof_rel) == 0)
		8163	{
		8164	/* Section size is only divisible by rel. */
		8165	if (use_rela_initialised && (use_rela == TRUE))
		8166	{
		8167	_bfd_error_handler
		8168	(_("%B: Unable to sort relocs - they are in more than one size"), abfd);
		8169	bfd_set_error (bfd_error_invalid_operation);
		8170	return 0;
		8171	}
		8172	else
		8173	{
		8174	use_rela = FALSE;
		8175	use_rela_initialised = TRUE;
		8176	}
		8177	}
		8178	else
		8179	{
		8180	/* The section size is not divisible by either - something is wrong. */
		8181	_bfd_error_handler
		8182	(_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
		8183	bfd_set_error (bfd_error_invalid_operation);
		8184	return 0;
		8185	}
		8186	}
		8187
		8188	for (lo = rel_dyn->map_head.link_order; lo != NULL; lo = lo->next)
		8189	if (lo->type == bfd_indirect_link_order)
		8190	{
		8191	asection *o = lo->u.indirect.section;
		8192
		8193	if ((o->size % bed->s->sizeof_rela) == 0)
		8194	{
		8195	if ((o->size % bed->s->sizeof_rel) == 0)
		8196	/* Section size is divisible by both rel and rela sizes.
		8197	It is of no help to us. */
		8198	;
		8199	else
		8200	{
		8201	/* Section size is only divisible by rela. */
		8202	if (use_rela_initialised && (use_rela == FALSE))
		8203	{
		8204	_bfd_error_handler
		8205	(_("%B: Unable to sort relocs - they are in more than one size"), abfd);
		8206	bfd_set_error (bfd_error_invalid_operation);
		8207	return 0;
		8208	}
		8209	else
		8210	{
		8211	use_rela = TRUE;
		8212	use_rela_initialised = TRUE;
		8213	}
		8214	}
		8215	}
		8216	else if ((o->size % bed->s->sizeof_rel) == 0)
		8217	{
		8218	/* Section size is only divisible by rel. */
		8219	if (use_rela_initialised && (use_rela == TRUE))
		8220	{
		8221	_bfd_error_handler
		8222	(_("%B: Unable to sort relocs - they are in more than one size"), abfd);
		8223	bfd_set_error (bfd_error_invalid_operation);
		8224	return 0;
		8225	}
		8226	else
		8227	{
		8228	use_rela = FALSE;
		8229	use_rela_initialised = TRUE;
		8230	}
		8231	}
		8232	else
		8233	{
		8234	/* The section size is not divisible by either - something is wrong. */
		8235	_bfd_error_handler
		8236	(_("%B: Unable to sort relocs - they are of an unknown size"), abfd);
		8237	bfd_set_error (bfd_error_invalid_operation);
		8238	return 0;
		8239	}
		8240	}
		8241
		8242	if (! use_rela_initialised)
		8243	/* Make a guess. */
		8244	use_rela = TRUE;
		8245	}
		8246	else if (rela_dyn != NULL && rela_dyn->size > 0)
		8247	use_rela = TRUE;
		8248	else if (rel_dyn != NULL && rel_dyn->size > 0)
		8249	use_rela = FALSE;
		8250	else
		8251	return 0;
		8252
		8253	if (use_rela)
		8254	{
		8255	dynamic_relocs = rela_dyn;
		8256	ext_size = bed->s->sizeof_rela;
		8257	swap_in = bed->s->swap_reloca_in;
		8258	swap_out = bed->s->swap_reloca_out;
		8259	}
		8260	else
		8261	{
		8262	dynamic_relocs = rel_dyn;
		8263	ext_size = bed->s->sizeof_rel;
		8264	swap_in = bed->s->swap_reloc_in;
		8265	swap_out = bed->s->swap_reloc_out;
		8266	}
		8267
		8268	size = 0;
		8269	for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
		8270	if (lo->type == bfd_indirect_link_order)
		8271	size += lo->u.indirect.section->size;
		8272
		8273	if (size != dynamic_relocs->size)
		8274	return 0;
		8275
		8276	sort_elt = (sizeof (struct elf_link_sort_rela)
		8277	+ (i2e - 1) * sizeof (Elf_Internal_Rela));
		8278
		8279	count = dynamic_relocs->size / ext_size;
		8280	if (count == 0)
		8281	return 0;
		8282	sort = (bfd_byte ) bfd_zmalloc (sort_elt count);
		8283
		8284	if (sort == NULL)
		8285	{
		8286	(*info->callbacks->warning)
		8287	(info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
		8288	return 0;
		8289	}
		8290
		8291	if (bed->s->arch_size == 32)
		8292	r_sym_mask = ~(bfd_vma) 0xff;
		8293	else
		8294	r_sym_mask = ~(bfd_vma) 0xffffffff;
		8295
		8296	for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
		8297	if (lo->type == bfd_indirect_link_order)
		8298	{
		8299	bfd_byte erel, erelend;
		8300	asection *o = lo->u.indirect.section;
		8301
		8302	if (o->contents == NULL && o->size != 0)
		8303	{
		8304	/* This is a reloc section that is being handled as a normal
		8305	section. See bfd_section_from_shdr. We can't combine
		8306	relocs in this case. */
		8307	free (sort);
		8308	return 0;
		8309	}
		8310	erel = o->contents;
		8311	erelend = o->contents + o->size;
		8312	/* FIXME: octets_per_byte. */
		8313	p = sort + o->output_offset / ext_size * sort_elt;
		8314
		8315	while (erel < erelend)
		8316	{
		8317	struct elf_link_sort_rela s = (struct elf_link_sort_rela ) p;
		8318
		8319	(*swap_in) (abfd, erel, s->rela);
		8320	s->type = (*bed->elf_backend_reloc_type_class) (info, o, s->rela);
		8321	s->u.sym_mask = r_sym_mask;
		8322	p += sort_elt;
		8323	erel += ext_size;
		8324	}
		8325	}
		8326
		8327	qsort (sort, count, sort_elt, elf_link_sort_cmp1);
		8328
		8329	for (i = 0, p = sort; i < count; i++, p += sort_elt)
		8330	{
		8331	struct elf_link_sort_rela s = (struct elf_link_sort_rela ) p;
		8332	if (s->type != reloc_class_relative)
		8333	break;
		8334	}
		8335	ret = i;
		8336	s_non_relative = p;
		8337
		8338	sq = (struct elf_link_sort_rela *) s_non_relative;
		8339	for (; i < count; i++, p += sort_elt)
		8340	{
		8341	struct elf_link_sort_rela sp = (struct elf_link_sort_rela ) p;
		8342	if (((sp->rela->r_info ^ sq->rela->r_info) & r_sym_mask) != 0)
		8343	sq = sp;
		8344	sp->u.offset = sq->rela->r_offset;
		8345	}
		8346
		8347	qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
		8348
		8349	for (lo = dynamic_relocs->map_head.link_order; lo != NULL; lo = lo->next)
		8350	if (lo->type == bfd_indirect_link_order)
		8351	{
		8352	bfd_byte erel, erelend;
		8353	asection *o = lo->u.indirect.section;
		8354
		8355	erel = o->contents;
		8356	erelend = o->contents + o->size;
		8357	/* FIXME: octets_per_byte. */
		8358	p = sort + o->output_offset / ext_size * sort_elt;
		8359	while (erel < erelend)
		8360	{
		8361	struct elf_link_sort_rela s = (struct elf_link_sort_rela ) p;
		8362	(*swap_out) (abfd, s->rela, erel);
		8363	p += sort_elt;
		8364	erel += ext_size;
		8365	}
		8366	}
		8367
		8368	free (sort);
		8369	*psec = dynamic_relocs;
		8370	return ret;
		8371	}
		8372
		8373	/* Flush the output symbols to the file. */
		8374
		8375	static bfd_boolean
		8376	elf_link_flush_output_syms (struct elf_final_link_info *flinfo,
		8377	const struct elf_backend_data *bed)
		8378	{
		8379	if (flinfo->symbuf_count > 0)
		8380	{
		8381	Elf_Internal_Shdr *hdr;
		8382	file_ptr pos;
		8383	bfd_size_type amt;
		8384
		8385	hdr = &elf_tdata (flinfo->output_bfd)->symtab_hdr;
		8386	pos = hdr->sh_offset + hdr->sh_size;
		8387	amt = flinfo->symbuf_count * bed->s->sizeof_sym;
		8388	if (bfd_seek (flinfo->output_bfd, pos, SEEK_SET) != 0
		8389	\|\| bfd_bwrite (flinfo->symbuf, amt, flinfo->output_bfd) != amt)
		8390	return FALSE;
		8391
		8392	hdr->sh_size += amt;
		8393	flinfo->symbuf_count = 0;
		8394	}
		8395
		8396	return TRUE;
		8397	}
		8398
		8399	/* Add a symbol to the output symbol table. */
		8400
		8401	static int
		8402	elf_link_output_sym (struct elf_final_link_info *flinfo,
		8403	const char *name,
		8404	Elf_Internal_Sym *elfsym,
		8405	asection *input_sec,
		8406	struct elf_link_hash_entry *h)
		8407	{
		8408	bfd_byte *dest;
		8409	Elf_External_Sym_Shndx *destshndx;
		8410	int (*output_symbol_hook)
		8411	(struct bfd_link_info , const char , Elf_Internal_Sym , asection ,
		8412	struct elf_link_hash_entry *);
		8413	const struct elf_backend_data *bed;
		8414
		8415	bed = get_elf_backend_data (flinfo->output_bfd);
		8416	output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
		8417	if (output_symbol_hook != NULL)
		8418	{
		8419	int ret = (*output_symbol_hook) (flinfo->info, name, elfsym, input_sec, h);
		8420	if (ret != 1)
		8421	return ret;
		8422	}
		8423
		8424	if (name == NULL \|\| *name == '\0')
		8425	elfsym->st_name = 0;
		8426	else if (input_sec->flags & SEC_EXCLUDE)
		8427	elfsym->st_name = 0;
		8428	else
		8429	{
		8430	elfsym->st_name = (unsigned long) _bfd_stringtab_add (flinfo->symstrtab,
		8431	name, TRUE, FALSE);
		8432	if (elfsym->st_name == (unsigned long) -1)
		8433	return 0;
		8434	}
		8435
		8436	if (flinfo->symbuf_count >= flinfo->symbuf_size)
		8437	{
		8438	if (! elf_link_flush_output_syms (flinfo, bed))
		8439	return 0;
		8440	}
		8441
		8442	dest = flinfo->symbuf + flinfo->symbuf_count * bed->s->sizeof_sym;
		8443	destshndx = flinfo->symshndxbuf;
		8444	if (destshndx != NULL)
		8445	{
		8446	if (bfd_get_symcount (flinfo->output_bfd) >= flinfo->shndxbuf_size)
		8447	{
		8448	bfd_size_type amt;
		8449
		8450	amt = flinfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
		8451	destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
		8452	amt * 2);
		8453	if (destshndx == NULL)
		8454	return 0;
		8455	flinfo->symshndxbuf = destshndx;
		8456	memset ((char *) destshndx + amt, 0, amt);
		8457	flinfo->shndxbuf_size *= 2;
		8458	}
		8459	destshndx += bfd_get_symcount (flinfo->output_bfd);
		8460	}
		8461
		8462	bed->s->swap_symbol_out (flinfo->output_bfd, elfsym, dest, destshndx);
		8463	flinfo->symbuf_count += 1;
		8464	bfd_get_symcount (flinfo->output_bfd) += 1;
		8465
		8466	return 1;
		8467	}
		8468
		8469	/* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
		8470
		8471	static bfd_boolean
		8472	check_dynsym (bfd abfd, Elf_Internal_Sym sym)
		8473	{
		8474	if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
		8475	&& sym->st_shndx < SHN_LORESERVE)
		8476	{
		8477	/* The gABI doesn't support dynamic symbols in output sections
		8478	beyond 64k. */
		8479	(*_bfd_error_handler)
		8480	(_("%B: Too many sections: %d (>= %d)"),
		8481	abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
		8482	bfd_set_error (bfd_error_nonrepresentable_section);
		8483	return FALSE;
		8484	}
		8485	return TRUE;
		8486	}
		8487
		8488	/* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
		8489	allowing an unsatisfied unversioned symbol in the DSO to match a
		8490	versioned symbol that would normally require an explicit version.
		8491	We also handle the case that a DSO references a hidden symbol
		8492	which may be satisfied by a versioned symbol in another DSO. */
		8493
		8494	static bfd_boolean
		8495	elf_link_check_versioned_symbol (struct bfd_link_info *info,
		8496	const struct elf_backend_data *bed,
		8497	struct elf_link_hash_entry *h)
		8498	{
		8499	bfd *abfd;
		8500	struct elf_link_loaded_list *loaded;
		8501
		8502	if (!is_elf_hash_table (info->hash))
		8503	return FALSE;
		8504
		8505	/* Check indirect symbol. */
		8506	while (h->root.type == bfd_link_hash_indirect)
		8507	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		8508
		8509	switch (h->root.type)
		8510	{
		8511	default:
		8512	abfd = NULL;
		8513	break;
		8514
		8515	case bfd_link_hash_undefined:
		8516	case bfd_link_hash_undefweak:
		8517	abfd = h->root.u.undef.abfd;
		8518	if ((abfd->flags & DYNAMIC) == 0
		8519	\|\| (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
		8520	return FALSE;
		8521	break;
		8522
		8523	case bfd_link_hash_defined:
		8524	case bfd_link_hash_defweak:
		8525	abfd = h->root.u.def.section->owner;
		8526	break;
		8527
		8528	case bfd_link_hash_common:
		8529	abfd = h->root.u.c.p->section->owner;
		8530	break;
		8531	}
		8532	BFD_ASSERT (abfd != NULL);
		8533
		8534	for (loaded = elf_hash_table (info)->loaded;
		8535	loaded != NULL;
		8536	loaded = loaded->next)
		8537	{
		8538	bfd *input;
		8539	Elf_Internal_Shdr *hdr;
		8540	bfd_size_type symcount;
		8541	bfd_size_type extsymcount;
		8542	bfd_size_type extsymoff;
		8543	Elf_Internal_Shdr *versymhdr;
		8544	Elf_Internal_Sym *isym;
		8545	Elf_Internal_Sym *isymend;
		8546	Elf_Internal_Sym *isymbuf;
		8547	Elf_External_Versym *ever;
		8548	Elf_External_Versym *extversym;
		8549
		8550	input = loaded->abfd;
		8551
		8552	/* We check each DSO for a possible hidden versioned definition. */
		8553	if (input == abfd
		8554	\|\| (input->flags & DYNAMIC) == 0
		8555	\|\| elf_dynversym (input) == 0)
		8556	continue;
		8557
		8558	hdr = &elf_tdata (input)->dynsymtab_hdr;
		8559
		8560	symcount = hdr->sh_size / bed->s->sizeof_sym;
		8561	if (elf_bad_symtab (input))
		8562	{
		8563	extsymcount = symcount;
		8564	extsymoff = 0;
		8565	}
		8566	else
		8567	{
		8568	extsymcount = symcount - hdr->sh_info;
		8569	extsymoff = hdr->sh_info;
		8570	}
		8571
		8572	if (extsymcount == 0)
		8573	continue;
		8574
		8575	isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
		8576	NULL, NULL, NULL);
		8577	if (isymbuf == NULL)
		8578	return FALSE;
		8579
		8580	/* Read in any version definitions. */
		8581	versymhdr = &elf_tdata (input)->dynversym_hdr;
		8582	extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
		8583	if (extversym == NULL)
		8584	goto error_ret;
		8585
		8586	if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
		8587	\|\| (bfd_bread (extversym, versymhdr->sh_size, input)
		8588	!= versymhdr->sh_size))
		8589	{
		8590	free (extversym);
		8591	error_ret:
		8592	free (isymbuf);
		8593	return FALSE;
		8594	}
		8595
		8596	ever = extversym + extsymoff;
		8597	isymend = isymbuf + extsymcount;
		8598	for (isym = isymbuf; isym < isymend; isym++, ever++)
		8599	{
		8600	const char *name;
		8601	Elf_Internal_Versym iver;
		8602	unsigned short version_index;
		8603
		8604	if (ELF_ST_BIND (isym->st_info) == STB_LOCAL
		8605	\|\| isym->st_shndx == SHN_UNDEF)
		8606	continue;
		8607
		8608	name = bfd_elf_string_from_elf_section (input,
		8609	hdr->sh_link,
		8610	isym->st_name);
		8611	if (strcmp (name, h->root.root.string) != 0)
		8612	continue;
		8613
		8614	_bfd_elf_swap_versym_in (input, ever, &iver);
		8615
		8616	if ((iver.vs_vers & VERSYM_HIDDEN) == 0
		8617	&& !(h->def_regular
		8618	&& h->forced_local))
		8619	{
		8620	/* If we have a non-hidden versioned sym, then it should
		8621	have provided a definition for the undefined sym unless
		8622	it is defined in a non-shared object and forced local.
		8623	*/
		8624	abort ();
		8625	}
		8626
		8627	version_index = iver.vs_vers & VERSYM_VERSION;
		8628	if (version_index == 1 \|\| version_index == 2)
		8629	{
		8630	/* This is the base or first version. We can use it. */
		8631	free (extversym);
		8632	free (isymbuf);
		8633	return TRUE;
		8634	}
		8635	}
		8636
		8637	free (extversym);
		8638	free (isymbuf);
		8639	}
		8640
		8641	return FALSE;
		8642	}
		8643
		8644	/* Add an external symbol to the symbol table. This is called from
		8645	the hash table traversal routine. When generating a shared object,
		8646	we go through the symbol table twice. The first time we output
		8647	anything that might have been forced to local scope in a version
		8648	script. The second time we output the symbols that are still
		8649	global symbols. */
		8650
		8651	static bfd_boolean
		8652	elf_link_output_extsym (struct bfd_hash_entry bh, void data)
		8653	{
		8654	struct elf_link_hash_entry h = (struct elf_link_hash_entry ) bh;
		8655	struct elf_outext_info eoinfo = (struct elf_outext_info ) data;
		8656	struct elf_final_link_info *flinfo = eoinfo->flinfo;
		8657	bfd_boolean strip;
		8658	Elf_Internal_Sym sym;
		8659	asection *input_sec;
		8660	const struct elf_backend_data *bed;
		8661	long indx;
		8662	int ret;
		8663
		8664	if (h->root.type == bfd_link_hash_warning)
		8665	{
		8666	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		8667	if (h->root.type == bfd_link_hash_new)
		8668	return TRUE;
		8669	}
		8670
		8671	/* Decide whether to output this symbol in this pass. */
		8672	if (eoinfo->localsyms)
		8673	{
		8674	if (!h->forced_local)
		8675	return TRUE;
		8676	if (eoinfo->second_pass
		8677	&& !((h->root.type == bfd_link_hash_defined
		8678	\|\| h->root.type == bfd_link_hash_defweak)
		8679	&& h->root.u.def.section->output_section != NULL))
		8680	return TRUE;
		8681	}
		8682	else
		8683	{
		8684	if (h->forced_local)
		8685	return TRUE;
		8686	}
		8687
		8688	bed = get_elf_backend_data (flinfo->output_bfd);
		8689
		8690	if (h->root.type == bfd_link_hash_undefined)
		8691	{
		8692	/* If we have an undefined symbol reference here then it must have
		8693	come from a shared library that is being linked in. (Undefined
		8694	references in regular files have already been handled unless
		8695	they are in unreferenced sections which are removed by garbage
		8696	collection). */
		8697	bfd_boolean ignore_undef = FALSE;
		8698
		8699	/* Some symbols may be special in that the fact that they're
		8700	undefined can be safely ignored - let backend determine that. */
		8701	if (bed->elf_backend_ignore_undef_symbol)
		8702	ignore_undef = bed->elf_backend_ignore_undef_symbol (h);
		8703
		8704	/* If we are reporting errors for this situation then do so now. */
		8705	if (!ignore_undef
		8706	&& h->ref_dynamic
		8707	&& (!h->ref_regular \|\| flinfo->info->gc_sections)
		8708	&& !elf_link_check_versioned_symbol (flinfo->info, bed, h)
		8709	&& flinfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
		8710	{
		8711	if (!(flinfo->info->callbacks->undefined_symbol
		8712	(flinfo->info, h->root.root.string,
		8713	h->ref_regular ? NULL : h->root.u.undef.abfd,
		8714	NULL, 0,
		8715	(flinfo->info->unresolved_syms_in_shared_libs
		8716	== RM_GENERATE_ERROR))))
		8717	{
		8718	bfd_set_error (bfd_error_bad_value);
		8719	eoinfo->failed = TRUE;
		8720	return FALSE;
		8721	}
		8722	}
		8723	}
		8724
		8725	/* We should also warn if a forced local symbol is referenced from
		8726	shared libraries. */
		8727	if (!flinfo->info->relocatable
		8728	&& flinfo->info->executable
		8729	&& h->forced_local
		8730	&& h->ref_dynamic
		8731	&& h->def_regular
		8732	&& !h->dynamic_def
		8733	&& h->ref_dynamic_nonweak
		8734	&& !elf_link_check_versioned_symbol (flinfo->info, bed, h))
		8735	{
		8736	bfd *def_bfd;
		8737	const char *msg;
		8738	struct elf_link_hash_entry *hi = h;
		8739
		8740	/* Check indirect symbol. */
		8741	while (hi->root.type == bfd_link_hash_indirect)
		8742	hi = (struct elf_link_hash_entry *) hi->root.u.i.link;
		8743
		8744	if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
		8745	msg = _("%B: internal symbol `%s' in %B is referenced by DSO");
		8746	else if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
		8747	msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
		8748	else
		8749	msg = _("%B: local symbol `%s' in %B is referenced by DSO");
		8750	def_bfd = flinfo->output_bfd;
		8751	if (hi->root.u.def.section != bfd_abs_section_ptr)
		8752	def_bfd = hi->root.u.def.section->owner;
		8753	(*_bfd_error_handler) (msg, flinfo->output_bfd, def_bfd,
		8754	h->root.root.string);
		8755	bfd_set_error (bfd_error_bad_value);
		8756	eoinfo->failed = TRUE;
		8757	return FALSE;
		8758	}
		8759
		8760	/* We don't want to output symbols that have never been mentioned by
		8761	a regular file, or that we have been told to strip. However, if
		8762	h->indx is set to -2, the symbol is used by a reloc and we must
		8763	output it. */
		8764	if (h->indx == -2)
		8765	strip = FALSE;
		8766	else if ((h->def_dynamic
		8767	\|\| h->ref_dynamic
		8768	\|\| h->root.type == bfd_link_hash_new)
		8769	&& !h->def_regular
		8770	&& !h->ref_regular)
		8771	strip = TRUE;
		8772	else if (flinfo->info->strip == strip_all)
		8773	strip = TRUE;
		8774	else if (flinfo->info->strip == strip_some
		8775	&& bfd_hash_lookup (flinfo->info->keep_hash,
		8776	h->root.root.string, FALSE, FALSE) == NULL)
		8777	strip = TRUE;
		8778	else if ((h->root.type == bfd_link_hash_defined
		8779	\|\| h->root.type == bfd_link_hash_defweak)
		8780	&& ((flinfo->info->strip_discarded
		8781	&& discarded_section (h->root.u.def.section))
		8782	\|\| (h->root.u.def.section->owner != NULL
		8783	&& (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
		8784	strip = TRUE;
		8785	else if ((h->root.type == bfd_link_hash_undefined
		8786	\|\| h->root.type == bfd_link_hash_undefweak)
		8787	&& h->root.u.undef.abfd != NULL
		8788	&& (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
		8789	strip = TRUE;
		8790	else
		8791	strip = FALSE;
		8792
		8793	/* If we're stripping it, and it's not a dynamic symbol, there's
		8794	nothing else to do unless it is a forced local symbol or a
		8795	STT_GNU_IFUNC symbol. */
		8796	if (strip
		8797	&& h->dynindx == -1
		8798	&& h->type != STT_GNU_IFUNC
		8799	&& !h->forced_local)
		8800	return TRUE;
		8801
		8802	sym.st_value = 0;
		8803	sym.st_size = h->size;
		8804	sym.st_other = h->other;
		8805	if (h->forced_local)
		8806	{
		8807	sym.st_info = ELF_ST_INFO (STB_LOCAL, h->type);
		8808	/* Turn off visibility on local symbol. */
		8809	sym.st_other &= ~ELF_ST_VISIBILITY (-1);
		8810	}
		8811	/* Set STB_GNU_UNIQUE only if symbol is defined in regular object. */
		8812	else if (h->unique_global && h->def_regular)
		8813	sym.st_info = ELF_ST_INFO (STB_GNU_UNIQUE, h->type);
		8814	else if (h->root.type == bfd_link_hash_undefweak
		8815	\|\| h->root.type == bfd_link_hash_defweak)
		8816	sym.st_info = ELF_ST_INFO (STB_WEAK, h->type);
		8817	else
		8818	sym.st_info = ELF_ST_INFO (STB_GLOBAL, h->type);
		8819	sym.st_target_internal = h->target_internal;
		8820
		8821	switch (h->root.type)
		8822	{
		8823	default:
		8824	case bfd_link_hash_new:
		8825	case bfd_link_hash_warning:
		8826	abort ();
		8827	return FALSE;
		8828
		8829	case bfd_link_hash_undefined:
		8830	case bfd_link_hash_undefweak:
		8831	input_sec = bfd_und_section_ptr;
		8832	sym.st_shndx = SHN_UNDEF;
		8833	break;
		8834
		8835	case bfd_link_hash_defined:
		8836	case bfd_link_hash_defweak:
		8837	{
		8838	input_sec = h->root.u.def.section;
		8839	if (input_sec->output_section != NULL)
		8840	{
		8841	if (eoinfo->localsyms && flinfo->filesym_count == 1)
		8842	{
		8843	bfd_boolean second_pass_sym
		8844	= (input_sec->owner == flinfo->output_bfd
		8845	\|\| input_sec->owner == NULL
		8846	\|\| (input_sec->flags & SEC_LINKER_CREATED) != 0
		8847	\|\| (input_sec->owner->flags & BFD_LINKER_CREATED) != 0);
		8848
		8849	eoinfo->need_second_pass \|= second_pass_sym;
		8850	if (eoinfo->second_pass != second_pass_sym)
		8851	return TRUE;
		8852	}
		8853
		8854	sym.st_shndx =
		8855	_bfd_elf_section_from_bfd_section (flinfo->output_bfd,
		8856	input_sec->output_section);
		8857	if (sym.st_shndx == SHN_BAD)
		8858	{
		8859	(*_bfd_error_handler)
		8860	(_("%B: could not find output section %A for input section %A"),
		8861	flinfo->output_bfd, input_sec->output_section, input_sec);
		8862	bfd_set_error (bfd_error_nonrepresentable_section);
		8863	eoinfo->failed = TRUE;
		8864	return FALSE;
		8865	}
		8866
		8867	/* ELF symbols in relocatable files are section relative,
		8868	but in nonrelocatable files they are virtual
		8869	addresses. */
		8870	sym.st_value = h->root.u.def.value + input_sec->output_offset;
		8871	if (!flinfo->info->relocatable)
		8872	{
		8873	sym.st_value += input_sec->output_section->vma;
		8874	if (h->type == STT_TLS)
		8875	{
		8876	asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec;
		8877	if (tls_sec != NULL)
		8878	sym.st_value -= tls_sec->vma;
		8879	else
		8880	{
		8881	/* The TLS section may have been garbage collected. */
		8882	BFD_ASSERT (flinfo->info->gc_sections
		8883	&& !input_sec->gc_mark);
		8884	}
		8885	}
		8886	}
		8887	}
		8888	else
		8889	{
		8890	BFD_ASSERT (input_sec->owner == NULL
		8891	\|\| (input_sec->owner->flags & DYNAMIC) != 0);
		8892	sym.st_shndx = SHN_UNDEF;
		8893	input_sec = bfd_und_section_ptr;
		8894	}
		8895	}
		8896	break;
		8897
		8898	case bfd_link_hash_common:
		8899	input_sec = h->root.u.c.p->section;
		8900	sym.st_shndx = bed->common_section_index (input_sec);
		8901	sym.st_value = 1 << h->root.u.c.p->alignment_power;
		8902	break;
		8903
		8904	case bfd_link_hash_indirect:
		8905	/* These symbols are created by symbol versioning. They point
		8906	to the decorated version of the name. For example, if the
		8907	symbol foo@@GNU_1.2 is the default, which should be used when
		8908	foo is used with no version, then we add an indirect symbol
		8909	foo which points to foo@@GNU_1.2. We ignore these symbols,
		8910	since the indirected symbol is already in the hash table. */
		8911	return TRUE;
		8912	}
		8913
		8914	/* Give the processor backend a chance to tweak the symbol value,
		8915	and also to finish up anything that needs to be done for this
		8916	symbol. FIXME: Not calling elf_backend_finish_dynamic_symbol for
		8917	forced local syms when non-shared is due to a historical quirk.
		8918	STT_GNU_IFUNC symbol must go through PLT. */
		8919	if ((h->type == STT_GNU_IFUNC
		8920	&& h->def_regular
		8921	&& !flinfo->info->relocatable)
		8922	\|\| ((h->dynindx != -1
		8923	\|\| h->forced_local)
		8924	&& ((flinfo->info->shared
		8925	&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
		8926	\|\| h->root.type != bfd_link_hash_undefweak))
		8927	\|\| !h->forced_local)
		8928	&& elf_hash_table (flinfo->info)->dynamic_sections_created))
		8929	{
		8930	if (! ((*bed->elf_backend_finish_dynamic_symbol)
		8931	(flinfo->output_bfd, flinfo->info, h, &sym)))
		8932	{
		8933	eoinfo->failed = TRUE;
		8934	return FALSE;
		8935	}
		8936	}
		8937
		8938	/* If we are marking the symbol as undefined, and there are no
		8939	non-weak references to this symbol from a regular object, then
		8940	mark the symbol as weak undefined; if there are non-weak
		8941	references, mark the symbol as strong. We can't do this earlier,
		8942	because it might not be marked as undefined until the
		8943	finish_dynamic_symbol routine gets through with it. */
		8944	if (sym.st_shndx == SHN_UNDEF
		8945	&& h->ref_regular
		8946	&& (ELF_ST_BIND (sym.st_info) == STB_GLOBAL
		8947	\|\| ELF_ST_BIND (sym.st_info) == STB_WEAK))
		8948	{
		8949	int bindtype;
		8950	unsigned int type = ELF_ST_TYPE (sym.st_info);
		8951
		8952	/* Turn an undefined IFUNC symbol into a normal FUNC symbol. */
		8953	if (type == STT_GNU_IFUNC)
		8954	type = STT_FUNC;
		8955
		8956	if (h->ref_regular_nonweak)
		8957	bindtype = STB_GLOBAL;
		8958	else
		8959	bindtype = STB_WEAK;
		8960	sym.st_info = ELF_ST_INFO (bindtype, type);
		8961	}
		8962
		8963	/* If this is a symbol defined in a dynamic library, don't use the
		8964	symbol size from the dynamic library. Relinking an executable
		8965	against a new library may introduce gratuitous changes in the
		8966	executable's symbols if we keep the size. */
		8967	if (sym.st_shndx == SHN_UNDEF
		8968	&& !h->def_regular
		8969	&& h->def_dynamic)
		8970	sym.st_size = 0;
		8971
		8972	/* If a non-weak symbol with non-default visibility is not defined
		8973	locally, it is a fatal error. */
		8974	if (!flinfo->info->relocatable
		8975	&& ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
		8976	&& ELF_ST_BIND (sym.st_info) != STB_WEAK
		8977	&& h->root.type == bfd_link_hash_undefined
		8978	&& !h->def_regular)
		8979	{
		8980	const char *msg;
		8981
		8982	if (ELF_ST_VISIBILITY (sym.st_other) == STV_PROTECTED)
		8983	msg = _("%B: protected symbol `%s' isn't defined");
		8984	else if (ELF_ST_VISIBILITY (sym.st_other) == STV_INTERNAL)
		8985	msg = _("%B: internal symbol `%s' isn't defined");
		8986	else
		8987	msg = _("%B: hidden symbol `%s' isn't defined");
		8988	(*_bfd_error_handler) (msg, flinfo->output_bfd, h->root.root.string);
		8989	bfd_set_error (bfd_error_bad_value);
		8990	eoinfo->failed = TRUE;
		8991	return FALSE;
		8992	}
		8993
		8994	/* If this symbol should be put in the .dynsym section, then put it
		8995	there now. We already know the symbol index. We also fill in
		8996	the entry in the .hash section. */
		8997	if (flinfo->dynsym_sec != NULL
		8998	&& h->dynindx != -1
		8999	&& elf_hash_table (flinfo->info)->dynamic_sections_created)
		9000	{
		9001	bfd_byte *esym;
		9002
		9003	/* Since there is no version information in the dynamic string,
		9004	if there is no version info in symbol version section, we will
		9005	have a run-time problem. */
		9006	if (h->verinfo.verdef == NULL)
		9007	{
		9008	char *p = strrchr (h->root.root.string, ELF_VER_CHR);
		9009
		9010	if (p && p [1] != '\0')
		9011	{
		9012	(*_bfd_error_handler)
		9013	(_("%B: No symbol version section for versioned symbol `%s'"),
		9014	flinfo->output_bfd, h->root.root.string);
		9015	eoinfo->failed = TRUE;
		9016	return FALSE;
		9017	}
		9018	}
		9019
		9020	sym.st_name = h->dynstr_index;
		9021	esym = flinfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
		9022	if (!check_dynsym (flinfo->output_bfd, &sym))
		9023	{
		9024	eoinfo->failed = TRUE;
		9025	return FALSE;
		9026	}
		9027	bed->s->swap_symbol_out (flinfo->output_bfd, &sym, esym, 0);
		9028
		9029	if (flinfo->hash_sec != NULL)
		9030	{
		9031	size_t hash_entry_size;
		9032	bfd_byte *bucketpos;
		9033	bfd_vma chain;
		9034	size_t bucketcount;
		9035	size_t bucket;
		9036
		9037	bucketcount = elf_hash_table (flinfo->info)->bucketcount;
		9038	bucket = h->u.elf_hash_value % bucketcount;
		9039
		9040	hash_entry_size
		9041	= elf_section_data (flinfo->hash_sec)->this_hdr.sh_entsize;
		9042	bucketpos = ((bfd_byte *) flinfo->hash_sec->contents
		9043	+ (bucket + 2) * hash_entry_size);
		9044	chain = bfd_get (8 * hash_entry_size, flinfo->output_bfd, bucketpos);
		9045	bfd_put (8 * hash_entry_size, flinfo->output_bfd, h->dynindx,
		9046	bucketpos);
		9047	bfd_put (8 * hash_entry_size, flinfo->output_bfd, chain,
		9048	((bfd_byte *) flinfo->hash_sec->contents
		9049	+ (bucketcount + 2 + h->dynindx) * hash_entry_size));
		9050	}
		9051
		9052	if (flinfo->symver_sec != NULL && flinfo->symver_sec->contents != NULL)
		9053	{
		9054	Elf_Internal_Versym iversym;
		9055	Elf_External_Versym *eversym;
		9056
		9057	if (!h->def_regular)
		9058	{
		9059	if (h->verinfo.verdef == NULL)
		9060	iversym.vs_vers = 0;
		9061	else
		9062	iversym.vs_vers = h->verinfo.verdef->vd_exp_refno + 1;
		9063	}
		9064	else
		9065	{
		9066	if (h->verinfo.vertree == NULL)
		9067	iversym.vs_vers = 1;
		9068	else
		9069	iversym.vs_vers = h->verinfo.vertree->vernum + 1;
		9070	if (flinfo->info->create_default_symver)
		9071	iversym.vs_vers++;
		9072	}
		9073
		9074	if (h->hidden)
		9075	iversym.vs_vers \|= VERSYM_HIDDEN;
		9076
		9077	eversym = (Elf_External_Versym *) flinfo->symver_sec->contents;
		9078	eversym += h->dynindx;
		9079	_bfd_elf_swap_versym_out (flinfo->output_bfd, &iversym, eversym);
		9080	}
		9081	}
		9082
		9083	/* If we're stripping it, then it was just a dynamic symbol, and
		9084	there's nothing else to do. */
		9085	if (strip \|\| (input_sec->flags & SEC_EXCLUDE) != 0)
		9086	return TRUE;
		9087
		9088	indx = bfd_get_symcount (flinfo->output_bfd);
		9089	ret = elf_link_output_sym (flinfo, h->root.root.string, &sym, input_sec, h);
		9090	if (ret == 0)
		9091	{
		9092	eoinfo->failed = TRUE;
		9093	return FALSE;
		9094	}
		9095	else if (ret == 1)
		9096	h->indx = indx;
		9097	else if (h->indx == -2)
		9098	abort();
		9099
		9100	return TRUE;
		9101	}
		9102
		9103	/* Return TRUE if special handling is done for relocs in SEC against
		9104	symbols defined in discarded sections. */
		9105
		9106	static bfd_boolean
		9107	elf_section_ignore_discarded_relocs (asection *sec)
		9108	{
		9109	const struct elf_backend_data *bed;
		9110
		9111	switch (sec->sec_info_type)
		9112	{
		9113	case SEC_INFO_TYPE_STABS:
		9114	case SEC_INFO_TYPE_EH_FRAME:
		9115	return TRUE;
		9116	default:
		9117	break;
		9118	}
		9119
		9120	bed = get_elf_backend_data (sec->owner);
		9121	if (bed->elf_backend_ignore_discarded_relocs != NULL
		9122	&& (*bed->elf_backend_ignore_discarded_relocs) (sec))
		9123	return TRUE;
		9124
		9125	return FALSE;
		9126	}
		9127
		9128	/* Return a mask saying how ld should treat relocations in SEC against
		9129	symbols defined in discarded sections. If this function returns
		9130	COMPLAIN set, ld will issue a warning message. If this function
		9131	returns PRETEND set, and the discarded section was link-once and the
		9132	same size as the kept link-once section, ld will pretend that the
		9133	symbol was actually defined in the kept section. Otherwise ld will
		9134	zero the reloc (at least that is the intent, but some cooperation by
		9135	the target dependent code is needed, particularly for REL targets). */
		9136
		9137	unsigned int
		9138	_bfd_elf_default_action_discarded (asection *sec)
		9139	{
		9140	if (sec->flags & SEC_DEBUGGING)
		9141	return PRETEND;
		9142
		9143	if (strcmp (".eh_frame", sec->name) == 0)
		9144	return 0;
		9145
		9146	if (strcmp (".gcc_except_table", sec->name) == 0)
		9147	return 0;
		9148
		9149	return COMPLAIN \| PRETEND;
		9150	}
		9151
		9152	/* Find a match between a section and a member of a section group. */
		9153
		9154	static asection *
		9155	match_group_member (asection sec, asection group,
		9156	struct bfd_link_info *info)
		9157	{
		9158	asection *first = elf_next_in_group (group);
		9159	asection *s = first;
		9160
		9161	while (s != NULL)
		9162	{
		9163	if (bfd_elf_match_symbols_in_sections (s, sec, info))
		9164	return s;
		9165
		9166	s = elf_next_in_group (s);
		9167	if (s == first)
		9168	break;
		9169	}
		9170
		9171	return NULL;
		9172	}
		9173
		9174	/* Check if the kept section of a discarded section SEC can be used
		9175	to replace it. Return the replacement if it is OK. Otherwise return
		9176	NULL. */
		9177
		9178	asection *
		9179	_bfd_elf_check_kept_section (asection sec, struct bfd_link_info info)
		9180	{
		9181	asection *kept;
		9182
		9183	kept = sec->kept_section;
		9184	if (kept != NULL)
		9185	{
		9186	if ((kept->flags & SEC_GROUP) != 0)
		9187	kept = match_group_member (sec, kept, info);
		9188	if (kept != NULL
		9189	&& ((sec->rawsize != 0 ? sec->rawsize : sec->size)
		9190	!= (kept->rawsize != 0 ? kept->rawsize : kept->size)))
		9191	kept = NULL;
		9192	sec->kept_section = kept;
		9193	}
		9194	return kept;
		9195	}
		9196
		9197	/* Link an input file into the linker output file. This function
		9198	handles all the sections and relocations of the input file at once.
		9199	This is so that we only have to read the local symbols once, and
		9200	don't have to keep them in memory. */
		9201
		9202	static bfd_boolean
		9203	elf_link_input_bfd (struct elf_final_link_info flinfo, bfd input_bfd)
		9204	{
		9205	int (*relocate_section)
		9206	(bfd , struct bfd_link_info , bfd , asection , bfd_byte *,
		9207	Elf_Internal_Rela , Elf_Internal_Sym , asection **);
		9208	bfd *output_bfd;
		9209	Elf_Internal_Shdr *symtab_hdr;
		9210	size_t locsymcount;
		9211	size_t extsymoff;
		9212	Elf_Internal_Sym *isymbuf;
		9213	Elf_Internal_Sym *isym;
		9214	Elf_Internal_Sym *isymend;
		9215	long *pindex;
		9216	asection **ppsection;
		9217	asection *o;
		9218	const struct elf_backend_data *bed;
		9219	struct elf_link_hash_entry **sym_hashes;
		9220	bfd_size_type address_size;
		9221	bfd_vma r_type_mask;
		9222	int r_sym_shift;
		9223	bfd_boolean have_file_sym = FALSE;
		9224
		9225	output_bfd = flinfo->output_bfd;
		9226	bed = get_elf_backend_data (output_bfd);
		9227	relocate_section = bed->elf_backend_relocate_section;
		9228
		9229	/* If this is a dynamic object, we don't want to do anything here:
		9230	we don't want the local symbols, and we don't want the section
		9231	contents. */
		9232	if ((input_bfd->flags & DYNAMIC) != 0)
		9233	return TRUE;
		9234
		9235	symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
		9236	if (elf_bad_symtab (input_bfd))
		9237	{
		9238	locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
		9239	extsymoff = 0;
		9240	}
		9241	else
		9242	{
		9243	locsymcount = symtab_hdr->sh_info;
		9244	extsymoff = symtab_hdr->sh_info;
		9245	}
		9246
		9247	/* Read the local symbols. */
		9248	isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
		9249	if (isymbuf == NULL && locsymcount != 0)
		9250	{
		9251	isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
		9252	flinfo->internal_syms,
		9253	flinfo->external_syms,
		9254	flinfo->locsym_shndx);
		9255	if (isymbuf == NULL)
		9256	return FALSE;
		9257	}
		9258
		9259	/* Find local symbol sections and adjust values of symbols in
		9260	SEC_MERGE sections. Write out those local symbols we know are
		9261	going into the output file. */
		9262	isymend = isymbuf + locsymcount;
		9263	for (isym = isymbuf, pindex = flinfo->indices, ppsection = flinfo->sections;
		9264	isym < isymend;
		9265	isym++, pindex++, ppsection++)
		9266	{
		9267	asection *isec;
		9268	const char *name;
		9269	Elf_Internal_Sym osym;
		9270	long indx;
		9271	int ret;
		9272
		9273	*pindex = -1;
		9274
		9275	if (elf_bad_symtab (input_bfd))
		9276	{
		9277	if (ELF_ST_BIND (isym->st_info) != STB_LOCAL)
		9278	{
		9279	*ppsection = NULL;
		9280	continue;
		9281	}
		9282	}
		9283
		9284	if (isym->st_shndx == SHN_UNDEF)
		9285	isec = bfd_und_section_ptr;
		9286	else if (isym->st_shndx == SHN_ABS)
		9287	isec = bfd_abs_section_ptr;
		9288	else if (isym->st_shndx == SHN_COMMON)
		9289	isec = bfd_com_section_ptr;
		9290	else
		9291	{
		9292	isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
		9293	if (isec == NULL)
		9294	{
		9295	/* Don't attempt to output symbols with st_shnx in the
		9296	reserved range other than SHN_ABS and SHN_COMMON. */
		9297	*ppsection = NULL;
		9298	continue;
		9299	}
		9300	else if (isec->sec_info_type == SEC_INFO_TYPE_MERGE
		9301	&& ELF_ST_TYPE (isym->st_info) != STT_SECTION)
		9302	isym->st_value =
		9303	_bfd_merged_section_offset (output_bfd, &isec,
		9304	elf_section_data (isec)->sec_info,
		9305	isym->st_value);
		9306	}
		9307
		9308	*ppsection = isec;
		9309
		9310	/* Don't output the first, undefined, symbol. */
		9311	if (ppsection == flinfo->sections)
		9312	continue;
		9313
		9314	if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
		9315	{
		9316	/* We never output section symbols. Instead, we use the
		9317	section symbol of the corresponding section in the output
		9318	file. */
		9319	continue;
		9320	}
		9321
		9322	/* If we are stripping all symbols, we don't want to output this
		9323	one. */
		9324	if (flinfo->info->strip == strip_all)
		9325	continue;
		9326
		9327	/* If we are discarding all local symbols, we don't want to
		9328	output this one. If we are generating a relocatable output
		9329	file, then some of the local symbols may be required by
		9330	relocs; we output them below as we discover that they are
		9331	needed. */
		9332	if (flinfo->info->discard == discard_all)
		9333	continue;
		9334
		9335	/* If this symbol is defined in a section which we are
		9336	discarding, we don't need to keep it. */
		9337	if (isym->st_shndx != SHN_UNDEF
		9338	&& isym->st_shndx < SHN_LORESERVE
		9339	&& bfd_section_removed_from_list (output_bfd,
		9340	isec->output_section))
		9341	continue;
		9342
		9343	/* Get the name of the symbol. */
		9344	name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
		9345	isym->st_name);
		9346	if (name == NULL)
		9347	return FALSE;
		9348
		9349	/* See if we are discarding symbols with this name. */
		9350	if ((flinfo->info->strip == strip_some
		9351	&& (bfd_hash_lookup (flinfo->info->keep_hash, name, FALSE, FALSE)
		9352	== NULL))
		9353	\|\| (((flinfo->info->discard == discard_sec_merge
		9354	&& (isec->flags & SEC_MERGE) && !flinfo->info->relocatable)
		9355	\|\| flinfo->info->discard == discard_l)
		9356	&& bfd_is_local_label_name (input_bfd, name)))
		9357	continue;
		9358
		9359	if (ELF_ST_TYPE (isym->st_info) == STT_FILE)
		9360	{
		9361	have_file_sym = TRUE;
		9362	flinfo->filesym_count += 1;
		9363	}
		9364	if (!have_file_sym)
		9365	{
		9366	/* In the absence of debug info, bfd_find_nearest_line uses
		9367	FILE symbols to determine the source file for local
		9368	function symbols. Provide a FILE symbol here if input
		9369	files lack such, so that their symbols won't be
		9370	associated with a previous input file. It's not the
		9371	source file, but the best we can do. */
		9372	have_file_sym = TRUE;
		9373	flinfo->filesym_count += 1;
		9374	memset (&osym, 0, sizeof (osym));
		9375	osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
		9376	osym.st_shndx = SHN_ABS;
		9377	if (!elf_link_output_sym (flinfo, input_bfd->filename, &osym,
		9378	bfd_abs_section_ptr, NULL))
		9379	return FALSE;
		9380	}
		9381
		9382	osym = *isym;
		9383
		9384	/* Adjust the section index for the output file. */
		9385	osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
		9386	isec->output_section);
		9387	if (osym.st_shndx == SHN_BAD)
		9388	return FALSE;
		9389
		9390	/* ELF symbols in relocatable files are section relative, but
		9391	in executable files they are virtual addresses. Note that
		9392	this code assumes that all ELF sections have an associated
		9393	BFD section with a reasonable value for output_offset; below
		9394	we assume that they also have a reasonable value for
		9395	output_section. Any special sections must be set up to meet
		9396	these requirements. */
		9397	osym.st_value += isec->output_offset;
		9398	if (!flinfo->info->relocatable)
		9399	{
		9400	osym.st_value += isec->output_section->vma;
		9401	if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
		9402	{
		9403	/* STT_TLS symbols are relative to PT_TLS segment base. */
		9404	BFD_ASSERT (elf_hash_table (flinfo->info)->tls_sec != NULL);
		9405	osym.st_value -= elf_hash_table (flinfo->info)->tls_sec->vma;
		9406	}
		9407	}
		9408
		9409	indx = bfd_get_symcount (output_bfd);
		9410	ret = elf_link_output_sym (flinfo, name, &osym, isec, NULL);
		9411	if (ret == 0)
		9412	return FALSE;
		9413	else if (ret == 1)
		9414	*pindex = indx;
		9415	}
		9416
		9417	if (bed->s->arch_size == 32)
		9418	{
		9419	r_type_mask = 0xff;
		9420	r_sym_shift = 8;
		9421	address_size = 4;
		9422	}
		9423	else
		9424	{
		9425	r_type_mask = 0xffffffff;
		9426	r_sym_shift = 32;
		9427	address_size = 8;
		9428	}
		9429
		9430	/* Relocate the contents of each section. */
		9431	sym_hashes = elf_sym_hashes (input_bfd);
		9432	for (o = input_bfd->sections; o != NULL; o = o->next)
		9433	{
		9434	bfd_byte *contents;
		9435
		9436	if (! o->linker_mark)
		9437	{
		9438	/* This section was omitted from the link. */
		9439	continue;
		9440	}
		9441
		9442	if (flinfo->info->relocatable
		9443	&& (o->flags & (SEC_LINKER_CREATED \| SEC_GROUP)) == SEC_GROUP)
		9444	{
		9445	/* Deal with the group signature symbol. */
		9446	struct bfd_elf_section_data *sec_data = elf_section_data (o);
		9447	unsigned long symndx = sec_data->this_hdr.sh_info;
		9448	asection *osec = o->output_section;
		9449
		9450	if (symndx >= locsymcount
		9451	\|\| (elf_bad_symtab (input_bfd)
		9452	&& flinfo->sections[symndx] == NULL))
		9453	{
		9454	struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
		9455	while (h->root.type == bfd_link_hash_indirect
		9456	\|\| h->root.type == bfd_link_hash_warning)
		9457	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		9458	/* Arrange for symbol to be output. */
		9459	h->indx = -2;
		9460	elf_section_data (osec)->this_hdr.sh_info = -2;
		9461	}
		9462	else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
		9463	{
		9464	/* We'll use the output section target_index. */
		9465	asection *sec = flinfo->sections[symndx]->output_section;
		9466	elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
		9467	}
		9468	else
		9469	{
		9470	if (flinfo->indices[symndx] == -1)
		9471	{
		9472	/* Otherwise output the local symbol now. */
		9473	Elf_Internal_Sym sym = isymbuf[symndx];
		9474	asection *sec = flinfo->sections[symndx]->output_section;
		9475	const char *name;
		9476	long indx;
		9477	int ret;
		9478
		9479	name = bfd_elf_string_from_elf_section (input_bfd,
		9480	symtab_hdr->sh_link,
		9481	sym.st_name);
		9482	if (name == NULL)
		9483	return FALSE;
		9484
		9485	sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
		9486	sec);
		9487	if (sym.st_shndx == SHN_BAD)
		9488	return FALSE;
		9489
		9490	sym.st_value += o->output_offset;
		9491
		9492	indx = bfd_get_symcount (output_bfd);
		9493	ret = elf_link_output_sym (flinfo, name, &sym, o, NULL);
		9494	if (ret == 0)
		9495	return FALSE;
		9496	else if (ret == 1)
		9497	flinfo->indices[symndx] = indx;
		9498	else
		9499	abort ();
		9500	}
		9501	elf_section_data (osec)->this_hdr.sh_info
		9502	= flinfo->indices[symndx];
		9503	}
		9504	}
		9505
		9506	if ((o->flags & SEC_HAS_CONTENTS) == 0
		9507	\|\| (o->size == 0 && (o->flags & SEC_RELOC) == 0))
		9508	continue;
		9509
		9510	if ((o->flags & SEC_LINKER_CREATED) != 0)
		9511	{
		9512	/* Section was created by _bfd_elf_link_create_dynamic_sections
		9513	or somesuch. */
		9514	continue;
		9515	}
		9516
		9517	/* Get the contents of the section. They have been cached by a
		9518	relaxation routine. Note that o is a section in an input
		9519	file, so the contents field will not have been set by any of
		9520	the routines which work on output files. */
		9521	if (elf_section_data (o)->this_hdr.contents != NULL)
		9522	contents = elf_section_data (o)->this_hdr.contents;
		9523	else
		9524	{
		9525	contents = flinfo->contents;
		9526	if (! bfd_get_full_section_contents (input_bfd, o, &contents))
		9527	return FALSE;
		9528	}
		9529
		9530	if ((o->flags & SEC_RELOC) != 0)
		9531	{
		9532	Elf_Internal_Rela *internal_relocs;
		9533	Elf_Internal_Rela rel, relend;
		9534	int action_discarded;
		9535	int ret;
		9536
		9537	/* Get the swapped relocs. */
		9538	internal_relocs
		9539	= _bfd_elf_link_read_relocs (input_bfd, o, flinfo->external_relocs,
		9540	flinfo->internal_relocs, FALSE);
		9541	if (internal_relocs == NULL
		9542	&& o->reloc_count > 0)
		9543	return FALSE;
		9544
		9545	/* We need to reverse-copy input .ctors/.dtors sections if
		9546	they are placed in .init_array/.finit_array for output. */
		9547	if (o->size > address_size
		9548	&& ((strncmp (o->name, ".ctors", 6) == 0
		9549	&& strcmp (o->output_section->name,
		9550	".init_array") == 0)
		9551	\|\| (strncmp (o->name, ".dtors", 6) == 0
		9552	&& strcmp (o->output_section->name,
		9553	".fini_array") == 0))
		9554	&& (o->name[6] == 0 \|\| o->name[6] == '.'))
		9555	{
		9556	if (o->size != o->reloc_count * address_size)
		9557	{
		9558	(*_bfd_error_handler)
		9559	(_("error: %B: size of section %A is not "
		9560	"multiple of address size"),
		9561	input_bfd, o);
		9562	bfd_set_error (bfd_error_on_input);
		9563	return FALSE;
		9564	}
		9565	o->flags \|= SEC_ELF_REVERSE_COPY;
		9566	}
		9567
		9568	action_discarded = -1;
		9569	if (!elf_section_ignore_discarded_relocs (o))
		9570	action_discarded = (*bed->action_discarded) (o);
		9571
		9572	/* Run through the relocs evaluating complex reloc symbols and
		9573	looking for relocs against symbols from discarded sections
		9574	or section symbols from removed link-once sections.
		9575	Complain about relocs against discarded sections. Zero
		9576	relocs against removed link-once sections. */
		9577
		9578	rel = internal_relocs;
		9579	relend = rel + o->reloc_count * bed->s->int_rels_per_ext_rel;
		9580	for ( ; rel < relend; rel++)
		9581	{
		9582	unsigned long r_symndx = rel->r_info >> r_sym_shift;
		9583	unsigned int s_type;
		9584	asection *ps, sec;
		9585	struct elf_link_hash_entry *h = NULL;
		9586	const char *sym_name;
		9587
		9588	if (r_symndx == STN_UNDEF)
		9589	continue;
		9590
		9591	if (r_symndx >= locsymcount
		9592	\|\| (elf_bad_symtab (input_bfd)
		9593	&& flinfo->sections[r_symndx] == NULL))
		9594	{
		9595	h = sym_hashes[r_symndx - extsymoff];
		9596
		9597	/* Badly formatted input files can contain relocs that
		9598	reference non-existant symbols. Check here so that
		9599	we do not seg fault. */
		9600	if (h == NULL)
		9601	{
		9602	char buffer [32];
		9603
		9604	sprintf_vma (buffer, rel->r_info);
		9605	(*_bfd_error_handler)
		9606	(_("error: %B contains a reloc (0x%s) for section %A "
		9607	"that references a non-existent global symbol"),
		9608	input_bfd, o, buffer);
		9609	bfd_set_error (bfd_error_bad_value);
		9610	return FALSE;
		9611	}
		9612
		9613	while (h->root.type == bfd_link_hash_indirect
		9614	\|\| h->root.type == bfd_link_hash_warning)
		9615	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		9616
		9617	s_type = h->type;
		9618
		9619	ps = NULL;
		9620	if (h->root.type == bfd_link_hash_defined
		9621	\|\| h->root.type == bfd_link_hash_defweak)
		9622	ps = &h->root.u.def.section;
		9623
		9624	sym_name = h->root.root.string;
		9625	}
		9626	else
		9627	{
		9628	Elf_Internal_Sym *sym = isymbuf + r_symndx;
		9629
		9630	s_type = ELF_ST_TYPE (sym->st_info);
		9631	ps = &flinfo->sections[r_symndx];
		9632	sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
		9633	sym, *ps);
		9634	}
		9635
		9636	if ((s_type == STT_RELC \|\| s_type == STT_SRELC)
		9637	&& !flinfo->info->relocatable)
		9638	{
		9639	bfd_vma val;
		9640	bfd_vma dot = (rel->r_offset
		9641	+ o->output_offset + o->output_section->vma);
		9642	#ifdef DEBUG
		9643	printf ("Encountered a complex symbol!");
		9644	printf (" (input_bfd %s, section %s, reloc %ld\n",
		9645	input_bfd->filename, o->name,
		9646	(long) (rel - internal_relocs));
		9647	printf (" symbol: idx %8.8lx, name %s\n",
		9648	r_symndx, sym_name);
		9649	printf (" reloc : info %8.8lx, addr %8.8lx\n",
		9650	(unsigned long) rel->r_info,
		9651	(unsigned long) rel->r_offset);
		9652	#endif
		9653	if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot,
		9654	isymbuf, locsymcount, s_type == STT_SRELC))
		9655	return FALSE;
		9656
		9657	/* Symbol evaluated OK. Update to absolute value. */
		9658	set_symbol_value (input_bfd, isymbuf, locsymcount,
		9659	r_symndx, val);
		9660	continue;
		9661	}
		9662
		9663	if (action_discarded != -1 && ps != NULL)
		9664	{
		9665	/* Complain if the definition comes from a
		9666	discarded section. */
		9667	if ((sec = *ps) != NULL && discarded_section (sec))
		9668	{
		9669	BFD_ASSERT (r_symndx != STN_UNDEF);
		9670	if (action_discarded & COMPLAIN)
		9671	(*flinfo->info->callbacks->einfo)
		9672	(_("%X`%s' referenced in section `%A' of %B: "
		9673	"defined in discarded section `%A' of %B\n"),
		9674	sym_name, o, input_bfd, sec, sec->owner);
		9675
		9676	/* Try to do the best we can to support buggy old
		9677	versions of gcc. Pretend that the symbol is
		9678	really defined in the kept linkonce section.
		9679	FIXME: This is quite broken. Modifying the
		9680	symbol here means we will be changing all later
		9681	uses of the symbol, not just in this section. */
		9682	if (action_discarded & PRETEND)
		9683	{
		9684	asection *kept;
		9685
		9686	kept = _bfd_elf_check_kept_section (sec,
		9687	flinfo->info);
		9688	if (kept != NULL)
		9689	{
		9690	*ps = kept;
		9691	continue;
		9692	}
		9693	}
		9694	}
		9695	}
		9696	}
		9697
		9698	/* Relocate the section by invoking a back end routine.
		9699
		9700	The back end routine is responsible for adjusting the
		9701	section contents as necessary, and (if using Rela relocs
		9702	and generating a relocatable output file) adjusting the
		9703	reloc addend as necessary.
		9704
		9705	The back end routine does not have to worry about setting
		9706	the reloc address or the reloc symbol index.
		9707
		9708	The back end routine is given a pointer to the swapped in
		9709	internal symbols, and can access the hash table entries
		9710	for the external symbols via elf_sym_hashes (input_bfd).
		9711
		9712	When generating relocatable output, the back end routine
		9713	must handle STB_LOCAL/STT_SECTION symbols specially. The
		9714	output symbol is going to be a section symbol
		9715	corresponding to the output section, which will require
		9716	the addend to be adjusted. */
		9717
		9718	ret = (*relocate_section) (output_bfd, flinfo->info,
		9719	input_bfd, o, contents,
		9720	internal_relocs,
		9721	isymbuf,
		9722	flinfo->sections);
		9723	if (!ret)
		9724	return FALSE;
		9725
		9726	if (ret == 2
		9727	\|\| flinfo->info->relocatable
		9728	\|\| flinfo->info->emitrelocations)
		9729	{
		9730	Elf_Internal_Rela *irela;
		9731	Elf_Internal_Rela irelaend, irelamid;
		9732	bfd_vma last_offset;
		9733	struct elf_link_hash_entry **rel_hash;
		9734	struct elf_link_hash_entry rel_hash_list, rela_hash_list;
		9735	Elf_Internal_Shdr input_rel_hdr, input_rela_hdr;
		9736	unsigned int next_erel;
		9737	bfd_boolean rela_normal;
		9738	struct bfd_elf_section_data esdi, esdo;
		9739
		9740	esdi = elf_section_data (o);
		9741	esdo = elf_section_data (o->output_section);
		9742	rela_normal = FALSE;
		9743
		9744	/* Adjust the reloc addresses and symbol indices. */
		9745
		9746	irela = internal_relocs;
		9747	irelaend = irela + o->reloc_count * bed->s->int_rels_per_ext_rel;
		9748	rel_hash = esdo->rel.hashes + esdo->rel.count;
		9749	/* We start processing the REL relocs, if any. When we reach
		9750	IRELAMID in the loop, we switch to the RELA relocs. */
		9751	irelamid = irela;
		9752	if (esdi->rel.hdr != NULL)
		9753	irelamid += (NUM_SHDR_ENTRIES (esdi->rel.hdr)
		9754	* bed->s->int_rels_per_ext_rel);
		9755	rel_hash_list = rel_hash;
		9756	rela_hash_list = NULL;
		9757	last_offset = o->output_offset;
		9758	if (!flinfo->info->relocatable)
		9759	last_offset += o->output_section->vma;
		9760	for (next_erel = 0; irela < irelaend; irela++, next_erel++)
		9761	{
		9762	unsigned long r_symndx;
		9763	asection *sec;
		9764	Elf_Internal_Sym sym;
		9765
		9766	if (next_erel == bed->s->int_rels_per_ext_rel)
		9767	{
		9768	rel_hash++;
		9769	next_erel = 0;
		9770	}
		9771
		9772	if (irela == irelamid)
		9773	{
		9774	rel_hash = esdo->rela.hashes + esdo->rela.count;
		9775	rela_hash_list = rel_hash;
		9776	rela_normal = bed->rela_normal;
		9777	}
		9778
		9779	irela->r_offset = _bfd_elf_section_offset (output_bfd,
		9780	flinfo->info, o,
		9781	irela->r_offset);
		9782	if (irela->r_offset >= (bfd_vma) -2)
		9783	{
		9784	/* This is a reloc for a deleted entry or somesuch.
		9785	Turn it into an R_*_NONE reloc, at the same
		9786	offset as the last reloc. elf_eh_frame.c and
		9787	bfd_elf_discard_info rely on reloc offsets
		9788	being ordered. */
		9789	irela->r_offset = last_offset;
		9790	irela->r_info = 0;
		9791	irela->r_addend = 0;
		9792	continue;
		9793	}
		9794
		9795	irela->r_offset += o->output_offset;
		9796
		9797	/* Relocs in an executable have to be virtual addresses. */
		9798	if (!flinfo->info->relocatable)
		9799	irela->r_offset += o->output_section->vma;
		9800
		9801	last_offset = irela->r_offset;
		9802
		9803	r_symndx = irela->r_info >> r_sym_shift;
		9804	if (r_symndx == STN_UNDEF)
		9805	continue;
		9806
		9807	if (r_symndx >= locsymcount
		9808	\|\| (elf_bad_symtab (input_bfd)
		9809	&& flinfo->sections[r_symndx] == NULL))
		9810	{
		9811	struct elf_link_hash_entry *rh;
		9812	unsigned long indx;
		9813
		9814	/* This is a reloc against a global symbol. We
		9815	have not yet output all the local symbols, so
		9816	we do not know the symbol index of any global
		9817	symbol. We set the rel_hash entry for this
		9818	reloc to point to the global hash table entry
		9819	for this symbol. The symbol index is then
		9820	set at the end of bfd_elf_final_link. */
		9821	indx = r_symndx - extsymoff;
		9822	rh = elf_sym_hashes (input_bfd)[indx];
		9823	while (rh->root.type == bfd_link_hash_indirect
		9824	\|\| rh->root.type == bfd_link_hash_warning)
		9825	rh = (struct elf_link_hash_entry *) rh->root.u.i.link;
		9826
		9827	/* Setting the index to -2 tells
		9828	elf_link_output_extsym that this symbol is
		9829	used by a reloc. */
		9830	BFD_ASSERT (rh->indx < 0);
		9831	rh->indx = -2;
		9832
		9833	*rel_hash = rh;
		9834
		9835	continue;
		9836	}
		9837
		9838	/* This is a reloc against a local symbol. */
		9839
		9840	*rel_hash = NULL;
		9841	sym = isymbuf[r_symndx];
		9842	sec = flinfo->sections[r_symndx];
		9843	if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
		9844	{
		9845	/* I suppose the backend ought to fill in the
		9846	section of any STT_SECTION symbol against a
		9847	processor specific section. */
		9848	r_symndx = STN_UNDEF;
		9849	if (bfd_is_abs_section (sec))
		9850	;
		9851	else if (sec == NULL \|\| sec->owner == NULL)
		9852	{
		9853	bfd_set_error (bfd_error_bad_value);
		9854	return FALSE;
		9855	}
		9856	else
		9857	{
		9858	asection *osec = sec->output_section;
		9859
		9860	/* If we have discarded a section, the output
		9861	section will be the absolute section. In
		9862	case of discarded SEC_MERGE sections, use
		9863	the kept section. relocate_section should
		9864	have already handled discarded linkonce
		9865	sections. */
		9866	if (bfd_is_abs_section (osec)
		9867	&& sec->kept_section != NULL
		9868	&& sec->kept_section->output_section != NULL)
		9869	{
		9870	osec = sec->kept_section->output_section;
		9871	irela->r_addend -= osec->vma;
		9872	}
		9873
		9874	if (!bfd_is_abs_section (osec))
		9875	{
		9876	r_symndx = osec->target_index;
		9877	if (r_symndx == STN_UNDEF)
		9878	{
		9879	irela->r_addend += osec->vma;
		9880	osec = _bfd_nearby_section (output_bfd, osec,
		9881	osec->vma);
		9882	irela->r_addend -= osec->vma;
		9883	r_symndx = osec->target_index;
		9884	}
		9885	}
		9886	}
		9887
		9888	/* Adjust the addend according to where the
		9889	section winds up in the output section. */
		9890	if (rela_normal)
		9891	irela->r_addend += sec->output_offset;
		9892	}
		9893	else
		9894	{
		9895	if (flinfo->indices[r_symndx] == -1)
		9896	{
		9897	unsigned long shlink;
		9898	const char *name;
		9899	asection *osec;
		9900	long indx;
		9901
		9902	if (flinfo->info->strip == strip_all)
		9903	{
		9904	/* You can't do ld -r -s. */
		9905	bfd_set_error (bfd_error_invalid_operation);
		9906	return FALSE;
		9907	}
		9908
		9909	/* This symbol was skipped earlier, but
		9910	since it is needed by a reloc, we
		9911	must output it now. */
		9912	shlink = symtab_hdr->sh_link;
		9913	name = (bfd_elf_string_from_elf_section
		9914	(input_bfd, shlink, sym.st_name));
		9915	if (name == NULL)
		9916	return FALSE;
		9917
		9918	osec = sec->output_section;
		9919	sym.st_shndx =
		9920	_bfd_elf_section_from_bfd_section (output_bfd,
		9921	osec);
		9922	if (sym.st_shndx == SHN_BAD)
		9923	return FALSE;
		9924
		9925	sym.st_value += sec->output_offset;
		9926	if (!flinfo->info->relocatable)
		9927	{
		9928	sym.st_value += osec->vma;
		9929	if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
		9930	{
		9931	/* STT_TLS symbols are relative to PT_TLS
		9932	segment base. */
		9933	BFD_ASSERT (elf_hash_table (flinfo->info)
		9934	->tls_sec != NULL);
		9935	sym.st_value -= (elf_hash_table (flinfo->info)
		9936	->tls_sec->vma);
		9937	}
		9938	}
		9939
		9940	indx = bfd_get_symcount (output_bfd);
		9941	ret = elf_link_output_sym (flinfo, name, &sym, sec,
		9942	NULL);
		9943	if (ret == 0)
		9944	return FALSE;
		9945	else if (ret == 1)
		9946	flinfo->indices[r_symndx] = indx;
		9947	else
		9948	abort ();
		9949	}
		9950
		9951	r_symndx = flinfo->indices[r_symndx];
		9952	}
		9953
		9954	irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
		9955	\| (irela->r_info & r_type_mask));
		9956	}
		9957
		9958	/* Swap out the relocs. */
		9959	input_rel_hdr = esdi->rel.hdr;
		9960	if (input_rel_hdr && input_rel_hdr->sh_size != 0)
		9961	{
		9962	if (!bed->elf_backend_emit_relocs (output_bfd, o,
		9963	input_rel_hdr,
		9964	internal_relocs,
		9965	rel_hash_list))
		9966	return FALSE;
		9967	internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
		9968	* bed->s->int_rels_per_ext_rel);
		9969	rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
		9970	}
		9971
		9972	input_rela_hdr = esdi->rela.hdr;
		9973	if (input_rela_hdr && input_rela_hdr->sh_size != 0)
		9974	{
		9975	if (!bed->elf_backend_emit_relocs (output_bfd, o,
		9976	input_rela_hdr,
		9977	internal_relocs,
		9978	rela_hash_list))
		9979	return FALSE;
		9980	}
		9981	}
		9982	}
		9983
		9984	/* Write out the modified section contents. */
		9985	if (bed->elf_backend_write_section
		9986	&& (*bed->elf_backend_write_section) (output_bfd, flinfo->info, o,
		9987	contents))
		9988	{
		9989	/* Section written out. */
		9990	}
		9991	else switch (o->sec_info_type)
		9992	{
		9993	case SEC_INFO_TYPE_STABS:
		9994	if (! (_bfd_write_section_stabs
		9995	(output_bfd,
		9996	&elf_hash_table (flinfo->info)->stab_info,
		9997	o, &elf_section_data (o)->sec_info, contents)))
		9998	return FALSE;
		9999	break;
		10000	case SEC_INFO_TYPE_MERGE:
		10001	if (! _bfd_write_merged_section (output_bfd, o,
		10002	elf_section_data (o)->sec_info))
		10003	return FALSE;
		10004	break;
		10005	case SEC_INFO_TYPE_EH_FRAME:
		10006	{
		10007	if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info,
		10008	o, contents))
		10009	return FALSE;
		10010	}
		10011	break;
		10012	default:
		10013	{
		10014	/* FIXME: octets_per_byte. */
		10015	if (! (o->flags & SEC_EXCLUDE))
		10016	{
		10017	file_ptr offset = (file_ptr) o->output_offset;
		10018	bfd_size_type todo = o->size;
		10019	if ((o->flags & SEC_ELF_REVERSE_COPY))
		10020	{
		10021	/* Reverse-copy input section to output. */
		10022	do
		10023	{
		10024	todo -= address_size;
		10025	if (! bfd_set_section_contents (output_bfd,
		10026	o->output_section,
		10027	contents + todo,
		10028	offset,
		10029	address_size))
		10030	return FALSE;
		10031	if (todo == 0)
		10032	break;
		10033	offset += address_size;
		10034	}
		10035	while (1);
		10036	}
		10037	else if (! bfd_set_section_contents (output_bfd,
		10038	o->output_section,
		10039	contents,
		10040	offset, todo))
		10041	return FALSE;
		10042	}
		10043	}
		10044	break;
		10045	}
		10046	}
		10047
		10048	return TRUE;
		10049	}
		10050
		10051	/* Generate a reloc when linking an ELF file. This is a reloc
		10052	requested by the linker, and does not come from any input file. This
		10053	is used to build constructor and destructor tables when linking
		10054	with -Ur. */
		10055
		10056	static bfd_boolean
		10057	elf_reloc_link_order (bfd *output_bfd,
		10058	struct bfd_link_info *info,
		10059	asection *output_section,
		10060	struct bfd_link_order *link_order)
		10061	{
		10062	reloc_howto_type *howto;
		10063	long indx;
		10064	bfd_vma offset;
		10065	bfd_vma addend;
		10066	struct bfd_elf_section_reloc_data *reldata;
		10067	struct elf_link_hash_entry **rel_hash_ptr;
		10068	Elf_Internal_Shdr *rel_hdr;
		10069	const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
		10070	Elf_Internal_Rela irel[MAX_INT_RELS_PER_EXT_REL];
		10071	bfd_byte *erel;
		10072	unsigned int i;
		10073	struct bfd_elf_section_data *esdo = elf_section_data (output_section);
		10074
		10075	howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc);
		10076	if (howto == NULL)
		10077	{
		10078	bfd_set_error (bfd_error_bad_value);
		10079	return FALSE;
		10080	}
		10081
		10082	addend = link_order->u.reloc.p->addend;
		10083
		10084	if (esdo->rel.hdr)
		10085	reldata = &esdo->rel;
		10086	else if (esdo->rela.hdr)
		10087	reldata = &esdo->rela;
		10088	else
		10089	{
		10090	reldata = NULL;
		10091	BFD_ASSERT (0);
		10092	}
		10093
		10094	/* Figure out the symbol index. */
		10095	rel_hash_ptr = reldata->hashes + reldata->count;
		10096	if (link_order->type == bfd_section_reloc_link_order)
		10097	{
		10098	indx = link_order->u.reloc.p->u.section->target_index;
		10099	BFD_ASSERT (indx != 0);
		10100	*rel_hash_ptr = NULL;
		10101	}
		10102	else
		10103	{
		10104	struct elf_link_hash_entry *h;
		10105
		10106	/* Treat a reloc against a defined symbol as though it were
		10107	actually against the section. */
		10108	h = ((struct elf_link_hash_entry *)
		10109	bfd_wrapped_link_hash_lookup (output_bfd, info,
		10110	link_order->u.reloc.p->u.name,
		10111	FALSE, FALSE, TRUE));
		10112	if (h != NULL
		10113	&& (h->root.type == bfd_link_hash_defined
		10114	\|\| h->root.type == bfd_link_hash_defweak))
		10115	{
		10116	asection *section;
		10117
		10118	section = h->root.u.def.section;
		10119	indx = section->output_section->target_index;
		10120	*rel_hash_ptr = NULL;
		10121	/* It seems that we ought to add the symbol value to the
		10122	addend here, but in practice it has already been added
		10123	because it was passed to constructor_callback. */
		10124	addend += section->output_section->vma + section->output_offset;
		10125	}
		10126	else if (h != NULL)
		10127	{
		10128	/* Setting the index to -2 tells elf_link_output_extsym that
		10129	this symbol is used by a reloc. */
		10130	h->indx = -2;
		10131	*rel_hash_ptr = h;
		10132	indx = 0;
		10133	}
		10134	else
		10135	{
		10136	if (! ((*info->callbacks->unattached_reloc)
		10137	(info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
		10138	return FALSE;
		10139	indx = 0;
		10140	}
		10141	}
		10142
		10143	/* If this is an inplace reloc, we must write the addend into the
		10144	object file. */
		10145	if (howto->partial_inplace && addend != 0)
		10146	{
		10147	bfd_size_type size;
		10148	bfd_reloc_status_type rstat;
		10149	bfd_byte *buf;
		10150	bfd_boolean ok;
		10151	const char *sym_name;
		10152
		10153	size = (bfd_size_type) bfd_get_reloc_size (howto);
		10154	buf = (bfd_byte *) bfd_zmalloc (size);
		10155	if (buf == NULL)
		10156	return FALSE;
		10157	rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
		10158	switch (rstat)
		10159	{
		10160	case bfd_reloc_ok:
		10161	break;
		10162
		10163	default:
		10164	case bfd_reloc_outofrange:
		10165	abort ();
		10166
		10167	case bfd_reloc_overflow:
		10168	if (link_order->type == bfd_section_reloc_link_order)
		10169	sym_name = bfd_section_name (output_bfd,
		10170	link_order->u.reloc.p->u.section);
		10171	else
		10172	sym_name = link_order->u.reloc.p->u.name;
		10173	if (! ((*info->callbacks->reloc_overflow)
		10174	(info, NULL, sym_name, howto->name, addend, NULL,
		10175	NULL, (bfd_vma) 0)))
		10176	{
		10177	free (buf);
		10178	return FALSE;
		10179	}
		10180	break;
		10181	}
		10182	ok = bfd_set_section_contents (output_bfd, output_section, buf,
		10183	link_order->offset, size);
		10184	free (buf);
		10185	if (! ok)
		10186	return FALSE;
		10187	}
		10188
		10189	/* The address of a reloc is relative to the section in a
		10190	relocatable file, and is a virtual address in an executable
		10191	file. */
		10192	offset = link_order->offset;
		10193	if (! info->relocatable)
		10194	offset += output_section->vma;
		10195
		10196	for (i = 0; i < bed->s->int_rels_per_ext_rel; i++)
		10197	{
		10198	irel[i].r_offset = offset;
		10199	irel[i].r_info = 0;
		10200	irel[i].r_addend = 0;
		10201	}
		10202	if (bed->s->arch_size == 32)
		10203	irel[0].r_info = ELF32_R_INFO (indx, howto->type);
		10204	else
		10205	irel[0].r_info = ELF64_R_INFO (indx, howto->type);
		10206
		10207	rel_hdr = reldata->hdr;
		10208	erel = rel_hdr->contents;
		10209	if (rel_hdr->sh_type == SHT_REL)
		10210	{
		10211	erel += reldata->count * bed->s->sizeof_rel;
		10212	(*bed->s->swap_reloc_out) (output_bfd, irel, erel);
		10213	}
		10214	else
		10215	{
		10216	irel[0].r_addend = addend;
		10217	erel += reldata->count * bed->s->sizeof_rela;
		10218	(*bed->s->swap_reloca_out) (output_bfd, irel, erel);
		10219	}
		10220
		10221	++reldata->count;
		10222
		10223	return TRUE;
		10224	}
		10225
		10226
		10227	/* Get the output vma of the section pointed to by the sh_link field. */
		10228
		10229	static bfd_vma
		10230	elf_get_linked_section_vma (struct bfd_link_order *p)
		10231	{
		10232	Elf_Internal_Shdr **elf_shdrp;
		10233	asection *s;
		10234	int elfsec;
		10235
		10236	s = p->u.indirect.section;
		10237	elf_shdrp = elf_elfsections (s->owner);
		10238	elfsec = _bfd_elf_section_from_bfd_section (s->owner, s);
		10239	elfsec = elf_shdrp[elfsec]->sh_link;
		10240	/* PR 290:
		10241	The Intel C compiler generates SHT_IA_64_UNWIND with
		10242	SHF_LINK_ORDER. But it doesn't set the sh_link or
		10243	sh_info fields. Hence we could get the situation
		10244	where elfsec is 0. */
		10245	if (elfsec == 0)
		10246	{
		10247	const struct elf_backend_data *bed
		10248	= get_elf_backend_data (s->owner);
		10249	if (bed->link_order_error_handler)
		10250	bed->link_order_error_handler
		10251	(_("%B: warning: sh_link not set for section `%A'"), s->owner, s);
		10252	return 0;
		10253	}
		10254	else
		10255	{
		10256	s = elf_shdrp[elfsec]->bfd_section;
		10257	return s->output_section->vma + s->output_offset;
		10258	}
		10259	}
		10260
		10261
		10262	/* Compare two sections based on the locations of the sections they are
		10263	linked to. Used by elf_fixup_link_order. */
		10264
		10265	static int
		10266	compare_link_order (const void * a, const void * b)
		10267	{
		10268	bfd_vma apos;
		10269	bfd_vma bpos;
		10270
		10271	apos = elf_get_linked_section_vma ((struct bfd_link_order *)a);
		10272	bpos = elf_get_linked_section_vma ((struct bfd_link_order *)b);
		10273	if (apos < bpos)
		10274	return -1;
		10275	return apos > bpos;
		10276	}
		10277
		10278
		10279	/* Looks for sections with SHF_LINK_ORDER set. Rearranges them into the same
		10280	order as their linked sections. Returns false if this could not be done
		10281	because an output section includes both ordered and unordered
		10282	sections. Ideally we'd do this in the linker proper. */
		10283
		10284	static bfd_boolean
		10285	elf_fixup_link_order (bfd abfd, asection o)
		10286	{
		10287	int seen_linkorder;
		10288	int seen_other;
		10289	int n;
		10290	struct bfd_link_order *p;
		10291	bfd *sub;
		10292	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		10293	unsigned elfsec;
		10294	struct bfd_link_order **sections;
		10295	asection s, other_sec, *linkorder_sec;
		10296	bfd_vma offset;
		10297
		10298	other_sec = NULL;
		10299	linkorder_sec = NULL;
		10300	seen_other = 0;
		10301	seen_linkorder = 0;
		10302	for (p = o->map_head.link_order; p != NULL; p = p->next)
		10303	{
		10304	if (p->type == bfd_indirect_link_order)
		10305	{
		10306	s = p->u.indirect.section;
		10307	sub = s->owner;
		10308	if (bfd_get_flavour (sub) == bfd_target_elf_flavour
		10309	&& elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass
		10310	&& (elfsec = _bfd_elf_section_from_bfd_section (sub, s))
		10311	&& elfsec < elf_numsections (sub)
		10312	&& elf_elfsections (sub)[elfsec]->sh_flags & SHF_LINK_ORDER
		10313	&& elf_elfsections (sub)[elfsec]->sh_link < elf_numsections (sub))
		10314	{
		10315	seen_linkorder++;
		10316	linkorder_sec = s;
		10317	}
		10318	else
		10319	{
		10320	seen_other++;
		10321	other_sec = s;
		10322	}
		10323	}
		10324	else
		10325	seen_other++;
		10326
		10327	if (seen_other && seen_linkorder)
		10328	{
		10329	if (other_sec && linkorder_sec)
		10330	(*_bfd_error_handler) (_("%A has both ordered [`%A' in %B] and unordered [`%A' in %B] sections"),
		10331	o, linkorder_sec,
		10332	linkorder_sec->owner, other_sec,
		10333	other_sec->owner);
		10334	else
		10335	(*_bfd_error_handler) (_("%A has both ordered and unordered sections"),
		10336	o);
		10337	bfd_set_error (bfd_error_bad_value);
		10338	return FALSE;
		10339	}
		10340	}
		10341
		10342	if (!seen_linkorder)
		10343	return TRUE;
		10344
		10345	sections = (struct bfd_link_order **)
		10346	bfd_malloc (seen_linkorder * sizeof (struct bfd_link_order *));
		10347	if (sections == NULL)
		10348	return FALSE;
		10349	seen_linkorder = 0;
		10350
		10351	for (p = o->map_head.link_order; p != NULL; p = p->next)
		10352	{
		10353	sections[seen_linkorder++] = p;
		10354	}
		10355	/* Sort the input sections in the order of their linked section. */
		10356	qsort (sections, seen_linkorder, sizeof (struct bfd_link_order *),
		10357	compare_link_order);
		10358
		10359	/* Change the offsets of the sections. */
		10360	offset = 0;
		10361	for (n = 0; n < seen_linkorder; n++)
		10362	{
		10363	s = sections[n]->u.indirect.section;
		10364	offset &= ~(bfd_vma) 0 << s->alignment_power;
		10365	s->output_offset = offset;
		10366	sections[n]->offset = offset;
		10367	/* FIXME: octets_per_byte. */
		10368	offset += sections[n]->size;
		10369	}
		10370
		10371	free (sections);
		10372	return TRUE;
		10373	}
		10374
		10375	static void
		10376	elf_final_link_free (bfd obfd, struct elf_final_link_info flinfo)
		10377	{
		10378	asection *o;
		10379
		10380	if (flinfo->symstrtab != NULL)
		10381	_bfd_stringtab_free (flinfo->symstrtab);
		10382	if (flinfo->contents != NULL)
		10383	free (flinfo->contents);
		10384	if (flinfo->external_relocs != NULL)
		10385	free (flinfo->external_relocs);
		10386	if (flinfo->internal_relocs != NULL)
		10387	free (flinfo->internal_relocs);
		10388	if (flinfo->external_syms != NULL)
		10389	free (flinfo->external_syms);
		10390	if (flinfo->locsym_shndx != NULL)
		10391	free (flinfo->locsym_shndx);
		10392	if (flinfo->internal_syms != NULL)
		10393	free (flinfo->internal_syms);
		10394	if (flinfo->indices != NULL)
		10395	free (flinfo->indices);
		10396	if (flinfo->sections != NULL)
		10397	free (flinfo->sections);
		10398	if (flinfo->symbuf != NULL)
		10399	free (flinfo->symbuf);
		10400	if (flinfo->symshndxbuf != NULL)
		10401	free (flinfo->symshndxbuf);
		10402	for (o = obfd->sections; o != NULL; o = o->next)
		10403	{
		10404	struct bfd_elf_section_data *esdo = elf_section_data (o);
		10405	if ((o->flags & SEC_RELOC) != 0 && esdo->rel.hashes != NULL)
		10406	free (esdo->rel.hashes);
		10407	if ((o->flags & SEC_RELOC) != 0 && esdo->rela.hashes != NULL)
		10408	free (esdo->rela.hashes);
		10409	}
		10410	}
		10411
		10412	/* Do the final step of an ELF link. */
		10413
		10414	bfd_boolean
		10415	bfd_elf_final_link (bfd abfd, struct bfd_link_info info)
		10416	{
		10417	bfd_boolean dynamic;
		10418	bfd_boolean emit_relocs;
		10419	bfd *dynobj;
		10420	struct elf_final_link_info flinfo;
		10421	asection *o;
		10422	struct bfd_link_order *p;
		10423	bfd *sub;
		10424	bfd_size_type max_contents_size;
		10425	bfd_size_type max_external_reloc_size;
		10426	bfd_size_type max_internal_reloc_count;
		10427	bfd_size_type max_sym_count;
		10428	bfd_size_type max_sym_shndx_count;
		10429	file_ptr off;
		10430	Elf_Internal_Sym elfsym;
		10431	unsigned int i;
		10432	Elf_Internal_Shdr *symtab_hdr;
		10433	Elf_Internal_Shdr *symtab_shndx_hdr;
		10434	Elf_Internal_Shdr *symstrtab_hdr;
		10435	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		10436	struct elf_outext_info eoinfo;
		10437	bfd_boolean merged;
		10438	size_t relativecount = 0;
		10439	asection *reldyn = 0;
		10440	bfd_size_type amt;
		10441	asection *attr_section = NULL;
		10442	bfd_vma attr_size = 0;
		10443	const char *std_attrs_section;
		10444
		10445	if (! is_elf_hash_table (info->hash))
		10446	return FALSE;
		10447
		10448	if (info->shared)
		10449	abfd->flags \|= DYNAMIC;
		10450
		10451	dynamic = elf_hash_table (info)->dynamic_sections_created;
		10452	dynobj = elf_hash_table (info)->dynobj;
		10453
		10454	emit_relocs = (info->relocatable
		10455	\|\| info->emitrelocations);
		10456
		10457	flinfo.info = info;
		10458	flinfo.output_bfd = abfd;
		10459	flinfo.symstrtab = _bfd_elf_stringtab_init ();
		10460	if (flinfo.symstrtab == NULL)
		10461	return FALSE;
		10462
		10463	if (! dynamic)
		10464	{
		10465	flinfo.dynsym_sec = NULL;
		10466	flinfo.hash_sec = NULL;
		10467	flinfo.symver_sec = NULL;
		10468	}
		10469	else
		10470	{
		10471	flinfo.dynsym_sec = bfd_get_linker_section (dynobj, ".dynsym");
		10472	flinfo.hash_sec = bfd_get_linker_section (dynobj, ".hash");
		10473	/* Note that dynsym_sec can be NULL (on VMS). */
		10474	flinfo.symver_sec = bfd_get_linker_section (dynobj, ".gnu.version");
		10475	/* Note that it is OK if symver_sec is NULL. */
		10476	}
		10477
		10478	flinfo.contents = NULL;
		10479	flinfo.external_relocs = NULL;
		10480	flinfo.internal_relocs = NULL;
		10481	flinfo.external_syms = NULL;
		10482	flinfo.locsym_shndx = NULL;
		10483	flinfo.internal_syms = NULL;
		10484	flinfo.indices = NULL;
		10485	flinfo.sections = NULL;
		10486	flinfo.symbuf = NULL;
		10487	flinfo.symshndxbuf = NULL;
		10488	flinfo.symbuf_count = 0;
		10489	flinfo.shndxbuf_size = 0;
		10490	flinfo.filesym_count = 0;
		10491
		10492	/* The object attributes have been merged. Remove the input
		10493	sections from the link, and set the contents of the output
		10494	secton. */
		10495	std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
		10496	for (o = abfd->sections; o != NULL; o = o->next)
		10497	{
		10498	if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
		10499	\|\| strcmp (o->name, ".gnu.attributes") == 0)
		10500	{
		10501	for (p = o->map_head.link_order; p != NULL; p = p->next)
		10502	{
		10503	asection *input_section;
		10504
		10505	if (p->type != bfd_indirect_link_order)
		10506	continue;
		10507	input_section = p->u.indirect.section;
		10508	/* Hack: reset the SEC_HAS_CONTENTS flag so that
		10509	elf_link_input_bfd ignores this section. */
		10510	input_section->flags &= ~SEC_HAS_CONTENTS;
		10511	}
		10512
		10513	attr_size = bfd_elf_obj_attr_size (abfd);
		10514	if (attr_size)
		10515	{
		10516	bfd_set_section_size (abfd, o, attr_size);
		10517	attr_section = o;
		10518	/* Skip this section later on. */
		10519	o->map_head.link_order = NULL;
		10520	}
		10521	else
		10522	o->flags \|= SEC_EXCLUDE;
		10523	}
		10524	}
		10525
		10526	/* Count up the number of relocations we will output for each output
		10527	section, so that we know the sizes of the reloc sections. We
		10528	also figure out some maximum sizes. */
		10529	max_contents_size = 0;
		10530	max_external_reloc_size = 0;
		10531	max_internal_reloc_count = 0;
		10532	max_sym_count = 0;
		10533	max_sym_shndx_count = 0;
		10534	merged = FALSE;
		10535	for (o = abfd->sections; o != NULL; o = o->next)
		10536	{
		10537	struct bfd_elf_section_data *esdo = elf_section_data (o);
		10538	o->reloc_count = 0;
		10539
		10540	for (p = o->map_head.link_order; p != NULL; p = p->next)
		10541	{
		10542	unsigned int reloc_count = 0;
		10543	struct bfd_elf_section_data *esdi = NULL;
		10544
		10545	if (p->type == bfd_section_reloc_link_order
		10546	\|\| p->type == bfd_symbol_reloc_link_order)
		10547	reloc_count = 1;
		10548	else if (p->type == bfd_indirect_link_order)
		10549	{
		10550	asection *sec;
		10551
		10552	sec = p->u.indirect.section;
		10553	esdi = elf_section_data (sec);
		10554
		10555	/* Mark all sections which are to be included in the
		10556	link. This will normally be every section. We need
		10557	to do this so that we can identify any sections which
		10558	the linker has decided to not include. */
		10559	sec->linker_mark = TRUE;
		10560
		10561	if (sec->flags & SEC_MERGE)
		10562	merged = TRUE;
		10563
		10564	if (esdo->this_hdr.sh_type == SHT_REL
		10565	\|\| esdo->this_hdr.sh_type == SHT_RELA)
		10566	/* Some backends use reloc_count in relocation sections
		10567	to count particular types of relocs. Of course,
		10568	reloc sections themselves can't have relocations. */
		10569	reloc_count = 0;
		10570	else if (info->relocatable \|\| info->emitrelocations)
		10571	reloc_count = sec->reloc_count;
		10572	else if (bed->elf_backend_count_relocs)
		10573	reloc_count = (*bed->elf_backend_count_relocs) (info, sec);
		10574
		10575	if (sec->rawsize > max_contents_size)
		10576	max_contents_size = sec->rawsize;
		10577	if (sec->size > max_contents_size)
		10578	max_contents_size = sec->size;
		10579
		10580	/* We are interested in just local symbols, not all
		10581	symbols. */
		10582	if (bfd_get_flavour (sec->owner) == bfd_target_elf_flavour
		10583	&& (sec->owner->flags & DYNAMIC) == 0)
		10584	{
		10585	size_t sym_count;
		10586
		10587	if (elf_bad_symtab (sec->owner))
		10588	sym_count = (elf_tdata (sec->owner)->symtab_hdr.sh_size
		10589	/ bed->s->sizeof_sym);
		10590	else
		10591	sym_count = elf_tdata (sec->owner)->symtab_hdr.sh_info;
		10592
		10593	if (sym_count > max_sym_count)
		10594	max_sym_count = sym_count;
		10595
		10596	if (sym_count > max_sym_shndx_count
		10597	&& elf_symtab_shndx (sec->owner) != 0)
		10598	max_sym_shndx_count = sym_count;
		10599
		10600	if ((sec->flags & SEC_RELOC) != 0)
		10601	{
		10602	size_t ext_size = 0;
		10603
		10604	if (esdi->rel.hdr != NULL)
		10605	ext_size = esdi->rel.hdr->sh_size;
		10606	if (esdi->rela.hdr != NULL)
		10607	ext_size += esdi->rela.hdr->sh_size;
		10608
		10609	if (ext_size > max_external_reloc_size)
		10610	max_external_reloc_size = ext_size;
		10611	if (sec->reloc_count > max_internal_reloc_count)
		10612	max_internal_reloc_count = sec->reloc_count;
		10613	}
		10614	}
		10615	}
		10616
		10617	if (reloc_count == 0)
		10618	continue;
		10619
		10620	o->reloc_count += reloc_count;
		10621
		10622	if (p->type == bfd_indirect_link_order
		10623	&& (info->relocatable \|\| info->emitrelocations))
		10624	{
		10625	if (esdi->rel.hdr)
		10626	esdo->rel.count += NUM_SHDR_ENTRIES (esdi->rel.hdr);
		10627	if (esdi->rela.hdr)
		10628	esdo->rela.count += NUM_SHDR_ENTRIES (esdi->rela.hdr);
		10629	}
		10630	else
		10631	{
		10632	if (o->use_rela_p)
		10633	esdo->rela.count += reloc_count;
		10634	else
		10635	esdo->rel.count += reloc_count;
		10636	}
		10637	}
		10638
		10639	if (o->reloc_count > 0)
		10640	o->flags \|= SEC_RELOC;
		10641	else
		10642	{
		10643	/* Explicitly clear the SEC_RELOC flag. The linker tends to
		10644	set it (this is probably a bug) and if it is set
		10645	assign_section_numbers will create a reloc section. */
		10646	o->flags &=~ SEC_RELOC;
		10647	}
		10648
		10649	/* If the SEC_ALLOC flag is not set, force the section VMA to
		10650	zero. This is done in elf_fake_sections as well, but forcing
		10651	the VMA to 0 here will ensure that relocs against these
		10652	sections are handled correctly. */
		10653	if ((o->flags & SEC_ALLOC) == 0
		10654	&& ! o->user_set_vma)
		10655	o->vma = 0;
		10656	}
		10657
		10658	if (! info->relocatable && merged)
		10659	elf_link_hash_traverse (elf_hash_table (info),
		10660	_bfd_elf_link_sec_merge_syms, abfd);
		10661
		10662	/* Figure out the file positions for everything but the symbol table
		10663	and the relocs. We set symcount to force assign_section_numbers
		10664	to create a symbol table. */
		10665	bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
		10666	BFD_ASSERT (! abfd->output_has_begun);
		10667	if (! _bfd_elf_compute_section_file_positions (abfd, info))
		10668	goto error_return;
		10669
		10670	/* Set sizes, and assign file positions for reloc sections. */
		10671	for (o = abfd->sections; o != NULL; o = o->next)
		10672	{
		10673	struct bfd_elf_section_data *esdo = elf_section_data (o);
		10674	if ((o->flags & SEC_RELOC) != 0)
		10675	{
		10676	if (esdo->rel.hdr
		10677	&& !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rel)))
		10678	goto error_return;
		10679
		10680	if (esdo->rela.hdr
		10681	&& !(_bfd_elf_link_size_reloc_section (abfd, &esdo->rela)))
		10682	goto error_return;
		10683	}
		10684
		10685	/* Now, reset REL_COUNT and REL_COUNT2 so that we can use them
		10686	to count upwards while actually outputting the relocations. */
		10687	esdo->rel.count = 0;
		10688	esdo->rela.count = 0;
		10689	}
		10690
		10691	_bfd_elf_assign_file_positions_for_relocs (abfd);
		10692
		10693	/* We have now assigned file positions for all the sections except
		10694	.symtab and .strtab. We start the .symtab section at the current
		10695	file position, and write directly to it. We build the .strtab
		10696	section in memory. */
		10697	bfd_get_symcount (abfd) = 0;
		10698	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
		10699	/* sh_name is set in prep_headers. */
		10700	symtab_hdr->sh_type = SHT_SYMTAB;
		10701	/* sh_flags, sh_addr and sh_size all start off zero. */
		10702	symtab_hdr->sh_entsize = bed->s->sizeof_sym;
		10703	/* sh_link is set in assign_section_numbers. */
		10704	/* sh_info is set below. */
		10705	/* sh_offset is set just below. */
		10706	symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
		10707
		10708	off = elf_next_file_pos (abfd);
		10709	off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
		10710
		10711	/* Note that at this point elf_next_file_pos (abfd) is
		10712	incorrect. We do not yet know the size of the .symtab section.
		10713	We correct next_file_pos below, after we do know the size. */
		10714
		10715	/* Allocate a buffer to hold swapped out symbols. This is to avoid
		10716	continuously seeking to the right position in the file. */
		10717	if (! info->keep_memory \|\| max_sym_count < 20)
		10718	flinfo.symbuf_size = 20;
		10719	else
		10720	flinfo.symbuf_size = max_sym_count;
		10721	amt = flinfo.symbuf_size;
		10722	amt *= bed->s->sizeof_sym;
		10723	flinfo.symbuf = (bfd_byte *) bfd_malloc (amt);
		10724	if (flinfo.symbuf == NULL)
		10725	goto error_return;
		10726	if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
		10727	{
		10728	/* Wild guess at number of output symbols. realloc'd as needed. */
		10729	amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
		10730	flinfo.shndxbuf_size = amt;
		10731	amt *= sizeof (Elf_External_Sym_Shndx);
		10732	flinfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
		10733	if (flinfo.symshndxbuf == NULL)
		10734	goto error_return;
		10735	}
		10736
		10737	/* Start writing out the symbol table. The first symbol is always a
		10738	dummy symbol. */
		10739	if (info->strip != strip_all
		10740	\|\| emit_relocs)
		10741	{
		10742	elfsym.st_value = 0;
		10743	elfsym.st_size = 0;
		10744	elfsym.st_info = 0;
		10745	elfsym.st_other = 0;
		10746	elfsym.st_shndx = SHN_UNDEF;
		10747	elfsym.st_target_internal = 0;
		10748	if (elf_link_output_sym (&flinfo, NULL, &elfsym, bfd_und_section_ptr,
		10749	NULL) != 1)
		10750	goto error_return;
		10751	}
		10752
		10753	/* Output a symbol for each section. We output these even if we are
		10754	discarding local symbols, since they are used for relocs. These
		10755	symbols have no names. We store the index of each one in the
		10756	index field of the section, so that we can find it again when
		10757	outputting relocs. */
		10758	if (info->strip != strip_all
		10759	\|\| emit_relocs)
		10760	{
		10761	elfsym.st_size = 0;
		10762	elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
		10763	elfsym.st_other = 0;
		10764	elfsym.st_value = 0;
		10765	elfsym.st_target_internal = 0;
		10766	for (i = 1; i < elf_numsections (abfd); i++)
		10767	{
		10768	o = bfd_section_from_elf_index (abfd, i);
		10769	if (o != NULL)
		10770	{
		10771	o->target_index = bfd_get_symcount (abfd);
		10772	elfsym.st_shndx = i;
		10773	if (!info->relocatable)
		10774	elfsym.st_value = o->vma;
		10775	if (elf_link_output_sym (&flinfo, NULL, &elfsym, o, NULL) != 1)
		10776	goto error_return;
		10777	}
		10778	}
		10779	}
		10780
		10781	/* Allocate some memory to hold information read in from the input
		10782	files. */
		10783	if (max_contents_size != 0)
		10784	{
		10785	flinfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
		10786	if (flinfo.contents == NULL)
		10787	goto error_return;
		10788	}
		10789
		10790	if (max_external_reloc_size != 0)
		10791	{
		10792	flinfo.external_relocs = bfd_malloc (max_external_reloc_size);
		10793	if (flinfo.external_relocs == NULL)
		10794	goto error_return;
		10795	}
		10796
		10797	if (max_internal_reloc_count != 0)
		10798	{
		10799	amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
		10800	amt *= sizeof (Elf_Internal_Rela);
		10801	flinfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
		10802	if (flinfo.internal_relocs == NULL)
		10803	goto error_return;
		10804	}
		10805
		10806	if (max_sym_count != 0)
		10807	{
		10808	amt = max_sym_count * bed->s->sizeof_sym;
		10809	flinfo.external_syms = (bfd_byte *) bfd_malloc (amt);
		10810	if (flinfo.external_syms == NULL)
		10811	goto error_return;
		10812
		10813	amt = max_sym_count * sizeof (Elf_Internal_Sym);
		10814	flinfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
		10815	if (flinfo.internal_syms == NULL)
		10816	goto error_return;
		10817
		10818	amt = max_sym_count * sizeof (long);
		10819	flinfo.indices = (long int *) bfd_malloc (amt);
		10820	if (flinfo.indices == NULL)
		10821	goto error_return;
		10822
		10823	amt = max_sym_count * sizeof (asection *);
		10824	flinfo.sections = (asection **) bfd_malloc (amt);
		10825	if (flinfo.sections == NULL)
		10826	goto error_return;
		10827	}
		10828
		10829	if (max_sym_shndx_count != 0)
		10830	{
		10831	amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
		10832	flinfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
		10833	if (flinfo.locsym_shndx == NULL)
		10834	goto error_return;
		10835	}
		10836
		10837	if (elf_hash_table (info)->tls_sec)
		10838	{
		10839	bfd_vma base, end = 0;
		10840	asection *sec;
		10841
		10842	for (sec = elf_hash_table (info)->tls_sec;
		10843	sec && (sec->flags & SEC_THREAD_LOCAL);
		10844	sec = sec->next)
		10845	{
		10846	bfd_size_type size = sec->size;
		10847
		10848	if (size == 0
		10849	&& (sec->flags & SEC_HAS_CONTENTS) == 0)
		10850	{
		10851	struct bfd_link_order *ord = sec->map_tail.link_order;
		10852
		10853	if (ord != NULL)
		10854	size = ord->offset + ord->size;
		10855	}
		10856	end = sec->vma + size;
		10857	}
		10858	base = elf_hash_table (info)->tls_sec->vma;
		10859	/* Only align end of TLS section if static TLS doesn't have special
		10860	alignment requirements. */
		10861	if (bed->static_tls_alignment == 1)
		10862	end = align_power (end,
		10863	elf_hash_table (info)->tls_sec->alignment_power);
		10864	elf_hash_table (info)->tls_size = end - base;
		10865	}
		10866
		10867	/* Reorder SHF_LINK_ORDER sections. */
		10868	for (o = abfd->sections; o != NULL; o = o->next)
		10869	{
		10870	if (!elf_fixup_link_order (abfd, o))
		10871	return FALSE;
		10872	}
		10873
		10874	/* Since ELF permits relocations to be against local symbols, we
		10875	must have the local symbols available when we do the relocations.
		10876	Since we would rather only read the local symbols once, and we
		10877	would rather not keep them in memory, we handle all the
		10878	relocations for a single input file at the same time.
		10879
		10880	Unfortunately, there is no way to know the total number of local
		10881	symbols until we have seen all of them, and the local symbol
		10882	indices precede the global symbol indices. This means that when
		10883	we are generating relocatable output, and we see a reloc against
		10884	a global symbol, we can not know the symbol index until we have
		10885	finished examining all the local symbols to see which ones we are
		10886	going to output. To deal with this, we keep the relocations in
		10887	memory, and don't output them until the end of the link. This is
		10888	an unfortunate waste of memory, but I don't see a good way around
		10889	it. Fortunately, it only happens when performing a relocatable
		10890	link, which is not the common case. FIXME: If keep_memory is set
		10891	we could write the relocs out and then read them again; I don't
		10892	know how bad the memory loss will be. */
		10893
		10894	for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
		10895	sub->output_has_begun = FALSE;
		10896	for (o = abfd->sections; o != NULL; o = o->next)
		10897	{
		10898	for (p = o->map_head.link_order; p != NULL; p = p->next)
		10899	{
		10900	if (p->type == bfd_indirect_link_order
		10901	&& (bfd_get_flavour ((sub = p->u.indirect.section->owner))
		10902	== bfd_target_elf_flavour)
		10903	&& elf_elfheader (sub)->e_ident[EI_CLASS] == bed->s->elfclass)
		10904	{
		10905	if (! sub->output_has_begun)
		10906	{
		10907	if (! elf_link_input_bfd (&flinfo, sub))
		10908	goto error_return;
		10909	sub->output_has_begun = TRUE;
		10910	}
		10911	}
		10912	else if (p->type == bfd_section_reloc_link_order
		10913	\|\| p->type == bfd_symbol_reloc_link_order)
		10914	{
		10915	if (! elf_reloc_link_order (abfd, info, o, p))
		10916	goto error_return;
		10917	}
		10918	else
		10919	{
		10920	if (! _bfd_default_link_order (abfd, info, o, p))
		10921	{
		10922	if (p->type == bfd_indirect_link_order
		10923	&& (bfd_get_flavour (sub)
		10924	== bfd_target_elf_flavour)
		10925	&& (elf_elfheader (sub)->e_ident[EI_CLASS]
		10926	!= bed->s->elfclass))
		10927	{
		10928	const char iclass, oclass;
		10929
		10930	if (bed->s->elfclass == ELFCLASS64)
		10931	{
		10932	iclass = "ELFCLASS32";
		10933	oclass = "ELFCLASS64";
		10934	}
		10935	else
		10936	{
		10937	iclass = "ELFCLASS64";
		10938	oclass = "ELFCLASS32";
		10939	}
		10940
		10941	bfd_set_error (bfd_error_wrong_format);
		10942	(*_bfd_error_handler)
		10943	(_("%B: file class %s incompatible with %s"),
		10944	sub, iclass, oclass);
		10945	}
		10946
		10947	goto error_return;
		10948	}
		10949	}
		10950	}
		10951	}
		10952
		10953	/* Free symbol buffer if needed. */
		10954	if (!info->reduce_memory_overheads)
		10955	{
		10956	for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
		10957	if (bfd_get_flavour (sub) == bfd_target_elf_flavour
		10958	&& elf_tdata (sub)->symbuf)
		10959	{
		10960	free (elf_tdata (sub)->symbuf);
		10961	elf_tdata (sub)->symbuf = NULL;
		10962	}
		10963	}
		10964
		10965	/* Output a FILE symbol so that following locals are not associated
		10966	with the wrong input file. */
		10967	memset (&elfsym, 0, sizeof (elfsym));
		10968	elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
		10969	elfsym.st_shndx = SHN_ABS;
		10970
		10971	if (flinfo.filesym_count > 1
		10972	&& !elf_link_output_sym (&flinfo, NULL, &elfsym,
		10973	bfd_und_section_ptr, NULL))
		10974	return FALSE;
		10975
		10976	/* Output any global symbols that got converted to local in a
		10977	version script or due to symbol visibility. We do this in a
		10978	separate step since ELF requires all local symbols to appear
		10979	prior to any global symbols. FIXME: We should only do this if
		10980	some global symbols were, in fact, converted to become local.
		10981	FIXME: Will this work correctly with the Irix 5 linker? */
		10982	eoinfo.failed = FALSE;
		10983	eoinfo.flinfo = &flinfo;
		10984	eoinfo.localsyms = TRUE;
		10985	eoinfo.need_second_pass = FALSE;
		10986	eoinfo.second_pass = FALSE;
		10987	bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
		10988	if (eoinfo.failed)
		10989	return FALSE;
		10990
		10991	if (flinfo.filesym_count == 1
		10992	&& !elf_link_output_sym (&flinfo, NULL, &elfsym,
		10993	bfd_und_section_ptr, NULL))
		10994	return FALSE;
		10995
		10996	if (eoinfo.need_second_pass)
		10997	{
		10998	eoinfo.second_pass = TRUE;
		10999	bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
		11000	if (eoinfo.failed)
		11001	return FALSE;
		11002	}
		11003
		11004	/* If backend needs to output some local symbols not present in the hash
		11005	table, do it now. */
		11006	if (bed->elf_backend_output_arch_local_syms)
		11007	{
		11008	typedef int (*out_sym_func)
		11009	(void , const char , Elf_Internal_Sym , asection ,
		11010	struct elf_link_hash_entry *);
		11011
		11012	if (! ((*bed->elf_backend_output_arch_local_syms)
		11013	(abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
		11014	return FALSE;
		11015	}
		11016
		11017	/* That wrote out all the local symbols. Finish up the symbol table
		11018	with the global symbols. Even if we want to strip everything we
		11019	can, we still need to deal with those global symbols that got
		11020	converted to local in a version script. */
		11021
		11022	/* The sh_info field records the index of the first non local symbol. */
		11023	symtab_hdr->sh_info = bfd_get_symcount (abfd);
		11024
		11025	if (dynamic
		11026	&& flinfo.dynsym_sec != NULL
		11027	&& flinfo.dynsym_sec->output_section != bfd_abs_section_ptr)
		11028	{
		11029	Elf_Internal_Sym sym;
		11030	bfd_byte *dynsym = flinfo.dynsym_sec->contents;
		11031	long last_local = 0;
		11032
		11033	/* Write out the section symbols for the output sections. */
		11034	if (info->shared \|\| elf_hash_table (info)->is_relocatable_executable)
		11035	{
		11036	asection *s;
		11037
		11038	sym.st_size = 0;
		11039	sym.st_name = 0;
		11040	sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
		11041	sym.st_other = 0;
		11042	sym.st_target_internal = 0;
		11043
		11044	for (s = abfd->sections; s != NULL; s = s->next)
		11045	{
		11046	int indx;
		11047	bfd_byte *dest;
		11048	long dynindx;
		11049
		11050	dynindx = elf_section_data (s)->dynindx;
		11051	if (dynindx <= 0)
		11052	continue;
		11053	indx = elf_section_data (s)->this_idx;
		11054	BFD_ASSERT (indx > 0);
		11055	sym.st_shndx = indx;
		11056	if (! check_dynsym (abfd, &sym))
		11057	return FALSE;
		11058	sym.st_value = s->vma;
		11059	dest = dynsym + dynindx * bed->s->sizeof_sym;
		11060	if (last_local < dynindx)
		11061	last_local = dynindx;
		11062	bed->s->swap_symbol_out (abfd, &sym, dest, 0);
		11063	}
		11064	}
		11065
		11066	/* Write out the local dynsyms. */
		11067	if (elf_hash_table (info)->dynlocal)
		11068	{
		11069	struct elf_link_local_dynamic_entry *e;
		11070	for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
		11071	{
		11072	asection *s;
		11073	bfd_byte *dest;
		11074
		11075	/* Copy the internal symbol and turn off visibility.
		11076	Note that we saved a word of storage and overwrote
		11077	the original st_name with the dynstr_index. */
		11078	sym = e->isym;
		11079	sym.st_other &= ~ELF_ST_VISIBILITY (-1);
		11080
		11081	s = bfd_section_from_elf_index (e->input_bfd,
		11082	e->isym.st_shndx);
		11083	if (s != NULL)
		11084	{
		11085	sym.st_shndx =
		11086	elf_section_data (s->output_section)->this_idx;
		11087	if (! check_dynsym (abfd, &sym))
		11088	return FALSE;
		11089	sym.st_value = (s->output_section->vma
		11090	+ s->output_offset
		11091	+ e->isym.st_value);
		11092	}
		11093
		11094	if (last_local < e->dynindx)
		11095	last_local = e->dynindx;
		11096
		11097	dest = dynsym + e->dynindx * bed->s->sizeof_sym;
		11098	bed->s->swap_symbol_out (abfd, &sym, dest, 0);
		11099	}
		11100	}
		11101
		11102	elf_section_data (flinfo.dynsym_sec->output_section)->this_hdr.sh_info =
		11103	last_local + 1;
		11104	}
		11105
		11106	/* We get the global symbols from the hash table. */
		11107	eoinfo.failed = FALSE;
		11108	eoinfo.localsyms = FALSE;
		11109	eoinfo.flinfo = &flinfo;
		11110	bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
		11111	if (eoinfo.failed)
		11112	return FALSE;
		11113
		11114	/* If backend needs to output some symbols not present in the hash
		11115	table, do it now. */
		11116	if (bed->elf_backend_output_arch_syms)
		11117	{
		11118	typedef int (*out_sym_func)
		11119	(void , const char , Elf_Internal_Sym , asection ,
		11120	struct elf_link_hash_entry *);
		11121
		11122	if (! ((*bed->elf_backend_output_arch_syms)
		11123	(abfd, info, &flinfo, (out_sym_func) elf_link_output_sym)))
		11124	return FALSE;
		11125	}
		11126
		11127	/* Flush all symbols to the file. */
		11128	if (! elf_link_flush_output_syms (&flinfo, bed))
		11129	return FALSE;
		11130
		11131	/* Now we know the size of the symtab section. */
		11132	off += symtab_hdr->sh_size;
		11133
		11134	symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
		11135	if (symtab_shndx_hdr->sh_name != 0)
		11136	{
		11137	symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
		11138	symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
		11139	symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
		11140	amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
		11141	symtab_shndx_hdr->sh_size = amt;
		11142
		11143	off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
		11144	off, TRUE);
		11145
		11146	if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
		11147	\|\| (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
		11148	return FALSE;
		11149	}
		11150
		11151
		11152	/* Finish up and write out the symbol string table (.strtab)
		11153	section. */
		11154	symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
		11155	/* sh_name was set in prep_headers. */
		11156	symstrtab_hdr->sh_type = SHT_STRTAB;
		11157	symstrtab_hdr->sh_flags = 0;
		11158	symstrtab_hdr->sh_addr = 0;
		11159	symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
		11160	symstrtab_hdr->sh_entsize = 0;
		11161	symstrtab_hdr->sh_link = 0;
		11162	symstrtab_hdr->sh_info = 0;
		11163	/* sh_offset is set just below. */
		11164	symstrtab_hdr->sh_addralign = 1;
		11165
		11166	off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE);
		11167	elf_next_file_pos (abfd) = off;
		11168
		11169	if (bfd_get_symcount (abfd) > 0)
		11170	{
		11171	if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
		11172	\|\| ! _bfd_stringtab_emit (abfd, flinfo.symstrtab))
		11173	return FALSE;
		11174	}
		11175
		11176	/* Adjust the relocs to have the correct symbol indices. */
		11177	for (o = abfd->sections; o != NULL; o = o->next)
		11178	{
		11179	struct bfd_elf_section_data *esdo = elf_section_data (o);
		11180	if ((o->flags & SEC_RELOC) == 0)
		11181	continue;
		11182
		11183	if (esdo->rel.hdr != NULL)
		11184	elf_link_adjust_relocs (abfd, &esdo->rel);
		11185	if (esdo->rela.hdr != NULL)
		11186	elf_link_adjust_relocs (abfd, &esdo->rela);
		11187
		11188	/* Set the reloc_count field to 0 to prevent write_relocs from
		11189	trying to swap the relocs out itself. */
		11190	o->reloc_count = 0;
		11191	}
		11192
		11193	if (dynamic && info->combreloc && dynobj != NULL)
		11194	relativecount = elf_link_sort_relocs (abfd, info, &reldyn);
		11195
		11196	/* If we are linking against a dynamic object, or generating a
		11197	shared library, finish up the dynamic linking information. */
		11198	if (dynamic)
		11199	{
		11200	bfd_byte dyncon, dynconend;
		11201
		11202	/* Fix up .dynamic entries. */
		11203	o = bfd_get_linker_section (dynobj, ".dynamic");
		11204	BFD_ASSERT (o != NULL);
		11205
		11206	dyncon = o->contents;
		11207	dynconend = o->contents + o->size;
		11208	for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
		11209	{
		11210	Elf_Internal_Dyn dyn;
		11211	const char *name;
		11212	unsigned int type;
		11213
		11214	bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
		11215
		11216	switch (dyn.d_tag)
		11217	{
		11218	default:
		11219	continue;
		11220	case DT_NULL:
		11221	if (relativecount > 0 && dyncon + bed->s->sizeof_dyn < dynconend)
		11222	{
		11223	switch (elf_section_data (reldyn)->this_hdr.sh_type)
		11224	{
		11225	case SHT_REL: dyn.d_tag = DT_RELCOUNT; break;
		11226	case SHT_RELA: dyn.d_tag = DT_RELACOUNT; break;
		11227	default: continue;
		11228	}
		11229	dyn.d_un.d_val = relativecount;
		11230	relativecount = 0;
		11231	break;
		11232	}
		11233	continue;
		11234
		11235	case DT_INIT:
		11236	name = info->init_function;
		11237	goto get_sym;
		11238	case DT_FINI:
		11239	name = info->fini_function;
		11240	get_sym:
		11241	{
		11242	struct elf_link_hash_entry *h;
		11243
		11244	h = elf_link_hash_lookup (elf_hash_table (info), name,
		11245	FALSE, FALSE, TRUE);
		11246	if (h != NULL
		11247	&& (h->root.type == bfd_link_hash_defined
		11248	\|\| h->root.type == bfd_link_hash_defweak))
		11249	{
		11250	dyn.d_un.d_ptr = h->root.u.def.value;
		11251	o = h->root.u.def.section;
		11252	if (o->output_section != NULL)
		11253	dyn.d_un.d_ptr += (o->output_section->vma
		11254	+ o->output_offset);
		11255	else
		11256	{
		11257	/* The symbol is imported from another shared
		11258	library and does not apply to this one. */
		11259	dyn.d_un.d_ptr = 0;
		11260	}
		11261	break;
		11262	}
		11263	}
		11264	continue;
		11265
		11266	case DT_PREINIT_ARRAYSZ:
		11267	name = ".preinit_array";
		11268	goto get_size;
		11269	case DT_INIT_ARRAYSZ:
		11270	name = ".init_array";
		11271	goto get_size;
		11272	case DT_FINI_ARRAYSZ:
		11273	name = ".fini_array";
		11274	get_size:
		11275	o = bfd_get_section_by_name (abfd, name);
		11276	if (o == NULL)
		11277	{
		11278	(*_bfd_error_handler)
		11279	(_("%B: could not find output section %s"), abfd, name);
		11280	goto error_return;
		11281	}
		11282	if (o->size == 0)
		11283	(*_bfd_error_handler)
		11284	(_("warning: %s section has zero size"), name);
		11285	dyn.d_un.d_val = o->size;
		11286	break;
		11287
		11288	case DT_PREINIT_ARRAY:
		11289	name = ".preinit_array";
		11290	goto get_vma;
		11291	case DT_INIT_ARRAY:
		11292	name = ".init_array";
		11293	goto get_vma;
		11294	case DT_FINI_ARRAY:
		11295	name = ".fini_array";
		11296	goto get_vma;
		11297
		11298	case DT_HASH:
		11299	name = ".hash";
		11300	goto get_vma;
		11301	case DT_GNU_HASH:
		11302	name = ".gnu.hash";
		11303	goto get_vma;
		11304	case DT_STRTAB:
		11305	name = ".dynstr";
		11306	goto get_vma;
		11307	case DT_SYMTAB:
		11308	name = ".dynsym";
		11309	goto get_vma;
		11310	case DT_VERDEF:
		11311	name = ".gnu.version_d";
		11312	goto get_vma;
		11313	case DT_VERNEED:
		11314	name = ".gnu.version_r";
		11315	goto get_vma;
		11316	case DT_VERSYM:
		11317	name = ".gnu.version";
		11318	get_vma:
		11319	o = bfd_get_section_by_name (abfd, name);
		11320	if (o == NULL)
		11321	{
		11322	(*_bfd_error_handler)
		11323	(_("%B: could not find output section %s"), abfd, name);
		11324	goto error_return;
		11325	}
		11326	if (elf_section_data (o->output_section)->this_hdr.sh_type == SHT_NOTE)
		11327	{
		11328	(*_bfd_error_handler)
		11329	(_("warning: section '%s' is being made into a note"), name);
		11330	bfd_set_error (bfd_error_nonrepresentable_section);
		11331	goto error_return;
		11332	}
		11333	dyn.d_un.d_ptr = o->vma;
		11334	break;
		11335
		11336	case DT_REL:
		11337	case DT_RELA:
		11338	case DT_RELSZ:
		11339	case DT_RELASZ:
		11340	if (dyn.d_tag == DT_REL \|\| dyn.d_tag == DT_RELSZ)
		11341	type = SHT_REL;
		11342	else
		11343	type = SHT_RELA;
		11344	dyn.d_un.d_val = 0;
		11345	dyn.d_un.d_ptr = 0;
		11346	for (i = 1; i < elf_numsections (abfd); i++)
		11347	{
		11348	Elf_Internal_Shdr *hdr;
		11349
		11350	hdr = elf_elfsections (abfd)[i];
		11351	if (hdr->sh_type == type
		11352	&& (hdr->sh_flags & SHF_ALLOC) != 0)
		11353	{
		11354	if (dyn.d_tag == DT_RELSZ \|\| dyn.d_tag == DT_RELASZ)
		11355	dyn.d_un.d_val += hdr->sh_size;
		11356	else
		11357	{
		11358	if (dyn.d_un.d_ptr == 0
		11359	\|\| hdr->sh_addr < dyn.d_un.d_ptr)
		11360	dyn.d_un.d_ptr = hdr->sh_addr;
		11361	}
		11362	}
		11363	}
		11364	break;
		11365	}
		11366	bed->s->swap_dyn_out (dynobj, &dyn, dyncon);
		11367	}
		11368	}
		11369
		11370	/* If we have created any dynamic sections, then output them. */
		11371	if (dynobj != NULL)
		11372	{
		11373	if (! (*bed->elf_backend_finish_dynamic_sections) (abfd, info))
		11374	goto error_return;
		11375
		11376	/* Check for DT_TEXTREL (late, in case the backend removes it). */
		11377	if (((info->warn_shared_textrel && info->shared)
		11378	\|\| info->error_textrel)
		11379	&& (o = bfd_get_linker_section (dynobj, ".dynamic")) != NULL)
		11380	{
		11381	bfd_byte dyncon, dynconend;
		11382
		11383	dyncon = o->contents;
		11384	dynconend = o->contents + o->size;
		11385	for (; dyncon < dynconend; dyncon += bed->s->sizeof_dyn)
		11386	{
		11387	Elf_Internal_Dyn dyn;
		11388
		11389	bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
		11390
		11391	if (dyn.d_tag == DT_TEXTREL)
		11392	{
		11393	if (info->error_textrel)
		11394	info->callbacks->einfo
		11395	(_("%P%X: read-only segment has dynamic relocations.\n"));
		11396	else
		11397	info->callbacks->einfo
		11398	(_("%P: warning: creating a DT_TEXTREL in a shared object.\n"));
		11399	break;
		11400	}
		11401	}
		11402	}
		11403
		11404	for (o = dynobj->sections; o != NULL; o = o->next)
		11405	{
		11406	if ((o->flags & SEC_HAS_CONTENTS) == 0
		11407	\|\| o->size == 0
		11408	\|\| o->output_section == bfd_abs_section_ptr)
		11409	continue;
		11410	if ((o->flags & SEC_LINKER_CREATED) == 0)
		11411	{
		11412	/* At this point, we are only interested in sections
		11413	created by _bfd_elf_link_create_dynamic_sections. */
		11414	continue;
		11415	}
		11416	if (elf_hash_table (info)->stab_info.stabstr == o)
		11417	continue;
		11418	if (elf_hash_table (info)->eh_info.hdr_sec == o)
		11419	continue;
		11420	if (strcmp (o->name, ".dynstr") != 0)
		11421	{
		11422	/* FIXME: octets_per_byte. */
		11423	if (! bfd_set_section_contents (abfd, o->output_section,
		11424	o->contents,
		11425	(file_ptr) o->output_offset,
		11426	o->size))
		11427	goto error_return;
		11428	}
		11429	else
		11430	{
		11431	/* The contents of the .dynstr section are actually in a
		11432	stringtab. */
		11433	off = elf_section_data (o->output_section)->this_hdr.sh_offset;
		11434	if (bfd_seek (abfd, off, SEEK_SET) != 0
		11435	\|\| ! _bfd_elf_strtab_emit (abfd,
		11436	elf_hash_table (info)->dynstr))
		11437	goto error_return;
		11438	}
		11439	}
		11440	}
		11441
		11442	if (info->relocatable)
		11443	{
		11444	bfd_boolean failed = FALSE;
		11445
		11446	bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
		11447	if (failed)
		11448	goto error_return;
		11449	}
		11450
		11451	/* If we have optimized stabs strings, output them. */
		11452	if (elf_hash_table (info)->stab_info.stabstr != NULL)
		11453	{
		11454	if (! _bfd_write_stab_strings (abfd, &elf_hash_table (info)->stab_info))
		11455	goto error_return;
		11456	}
		11457
		11458	if (! _bfd_elf_write_section_eh_frame_hdr (abfd, info))
		11459	goto error_return;
		11460
		11461	elf_final_link_free (abfd, &flinfo);
		11462
		11463	elf_linker (abfd) = TRUE;
		11464
		11465	if (attr_section)
		11466	{
		11467	bfd_byte contents = (bfd_byte ) bfd_malloc (attr_size);
		11468	if (contents == NULL)
		11469	return FALSE; /* Bail out and fail. */
		11470	bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
		11471	bfd_set_section_contents (abfd, attr_section, contents, 0, attr_size);
		11472	free (contents);
		11473	}
		11474
		11475	return TRUE;
		11476
		11477	error_return:
		11478	elf_final_link_free (abfd, &flinfo);
		11479	return FALSE;
		11480	}
		11481
		11482	/* Initialize COOKIE for input bfd ABFD. */
		11483
		11484	static bfd_boolean
		11485	init_reloc_cookie (struct elf_reloc_cookie *cookie,
		11486	struct bfd_link_info info, bfd abfd)
		11487	{
		11488	Elf_Internal_Shdr *symtab_hdr;
		11489	const struct elf_backend_data *bed;
		11490
		11491	bed = get_elf_backend_data (abfd);
		11492	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
		11493
		11494	cookie->abfd = abfd;
		11495	cookie->sym_hashes = elf_sym_hashes (abfd);
		11496	cookie->bad_symtab = elf_bad_symtab (abfd);
		11497	if (cookie->bad_symtab)
		11498	{
		11499	cookie->locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
		11500	cookie->extsymoff = 0;
		11501	}
		11502	else
		11503	{
		11504	cookie->locsymcount = symtab_hdr->sh_info;
		11505	cookie->extsymoff = symtab_hdr->sh_info;
		11506	}
		11507
		11508	if (bed->s->arch_size == 32)
		11509	cookie->r_sym_shift = 8;
		11510	else
		11511	cookie->r_sym_shift = 32;
		11512
		11513	cookie->locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
		11514	if (cookie->locsyms == NULL && cookie->locsymcount != 0)
		11515	{
		11516	cookie->locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
		11517	cookie->locsymcount, 0,
		11518	NULL, NULL, NULL);
		11519	if (cookie->locsyms == NULL)
		11520	{
		11521	info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
		11522	return FALSE;
		11523	}
		11524	if (info->keep_memory)
		11525	symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
		11526	}
		11527	return TRUE;
		11528	}
		11529
		11530	/* Free the memory allocated by init_reloc_cookie, if appropriate. */
		11531
		11532	static void
		11533	fini_reloc_cookie (struct elf_reloc_cookie cookie, bfd abfd)
		11534	{
		11535	Elf_Internal_Shdr *symtab_hdr;
		11536
		11537	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
		11538	if (cookie->locsyms != NULL
		11539	&& symtab_hdr->contents != (unsigned char *) cookie->locsyms)
		11540	free (cookie->locsyms);
		11541	}
		11542
		11543	/* Initialize the relocation information in COOKIE for input section SEC
		11544	of input bfd ABFD. */
		11545
		11546	static bfd_boolean
		11547	init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
		11548	struct bfd_link_info info, bfd abfd,
		11549	asection *sec)
		11550	{
		11551	const struct elf_backend_data *bed;
		11552
		11553	if (sec->reloc_count == 0)
		11554	{
		11555	cookie->rels = NULL;
		11556	cookie->relend = NULL;
		11557	}
		11558	else
		11559	{
		11560	bed = get_elf_backend_data (abfd);
		11561
		11562	cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
		11563	info->keep_memory);
		11564	if (cookie->rels == NULL)
		11565	return FALSE;
		11566	cookie->rel = cookie->rels;
		11567	cookie->relend = (cookie->rels
		11568	+ sec->reloc_count * bed->s->int_rels_per_ext_rel);
		11569	}
		11570	cookie->rel = cookie->rels;
		11571	return TRUE;
		11572	}
		11573
		11574	/* Free the memory allocated by init_reloc_cookie_rels,
		11575	if appropriate. */
		11576
		11577	static void
		11578	fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
		11579	asection *sec)
		11580	{
		11581	if (cookie->rels && elf_section_data (sec)->relocs != cookie->rels)
		11582	free (cookie->rels);
		11583	}
		11584
		11585	/* Initialize the whole of COOKIE for input section SEC. */
		11586
		11587	static bfd_boolean
		11588	init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
		11589	struct bfd_link_info *info,
		11590	asection *sec)
		11591	{
		11592	if (!init_reloc_cookie (cookie, info, sec->owner))
		11593	goto error1;
		11594	if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
		11595	goto error2;
		11596	return TRUE;
		11597
		11598	error2:
		11599	fini_reloc_cookie (cookie, sec->owner);
		11600	error1:
		11601	return FALSE;
		11602	}
		11603
		11604	/* Free the memory allocated by init_reloc_cookie_for_section,
		11605	if appropriate. */
		11606
		11607	static void
		11608	fini_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
		11609	asection *sec)
		11610	{
		11611	fini_reloc_cookie_rels (cookie, sec);
		11612	fini_reloc_cookie (cookie, sec->owner);
		11613	}
		11614
		11615	/* Garbage collect unused sections. */
		11616
		11617	/* Default gc_mark_hook. */
		11618
		11619	asection *
		11620	_bfd_elf_gc_mark_hook (asection *sec,
		11621	struct bfd_link_info *info ATTRIBUTE_UNUSED,
		11622	Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
		11623	struct elf_link_hash_entry *h,
		11624	Elf_Internal_Sym *sym)
		11625	{
		11626	const char *sec_name;
		11627
		11628	if (h != NULL)
		11629	{
		11630	switch (h->root.type)
		11631	{
		11632	case bfd_link_hash_defined:
		11633	case bfd_link_hash_defweak:
		11634	return h->root.u.def.section;
		11635
		11636	case bfd_link_hash_common:
		11637	return h->root.u.c.p->section;
		11638
		11639	case bfd_link_hash_undefined:
		11640	case bfd_link_hash_undefweak:
		11641	/* To work around a glibc bug, keep all XXX input sections
		11642	when there is an as yet undefined reference to __start_XXX
		11643	or __stop_XXX symbols. The linker will later define such
		11644	symbols for orphan input sections that have a name
		11645	representable as a C identifier. */
		11646	if (strncmp (h->root.root.string, "__start_", 8) == 0)
		11647	sec_name = h->root.root.string + 8;
		11648	else if (strncmp (h->root.root.string, "__stop_", 7) == 0)
		11649	sec_name = h->root.root.string + 7;
		11650	else
		11651	sec_name = NULL;
		11652
		11653	if (sec_name && *sec_name != '\0')
		11654	{
		11655	bfd *i;
		11656
		11657	for (i = info->input_bfds; i; i = i->link_next)
		11658	{
		11659	sec = bfd_get_section_by_name (i, sec_name);
		11660	if (sec)
		11661	sec->flags \|= SEC_KEEP;
		11662	}
		11663	}
		11664	break;
		11665
		11666	default:
		11667	break;
		11668	}
		11669	}
		11670	else
		11671	return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
		11672
		11673	return NULL;
		11674	}
		11675
		11676	/* COOKIE->rel describes a relocation against section SEC, which is
		11677	a section we've decided to keep. Return the section that contains
		11678	the relocation symbol, or NULL if no section contains it. */
		11679
		11680	asection *
		11681	_bfd_elf_gc_mark_rsec (struct bfd_link_info info, asection sec,
		11682	elf_gc_mark_hook_fn gc_mark_hook,
		11683	struct elf_reloc_cookie *cookie)
		11684	{
		11685	unsigned long r_symndx;
		11686	struct elf_link_hash_entry *h;
		11687
		11688	r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
		11689	if (r_symndx == STN_UNDEF)
		11690	return NULL;
		11691
		11692	if (r_symndx >= cookie->locsymcount
		11693	\|\| ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
		11694	{
		11695	h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
		11696	while (h->root.type == bfd_link_hash_indirect
		11697	\|\| h->root.type == bfd_link_hash_warning)
		11698	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		11699	h->mark = 1;
		11700	/* If this symbol is weak and there is a non-weak definition, we
		11701	keep the non-weak definition because many backends put
		11702	dynamic reloc info on the non-weak definition for code
		11703	handling copy relocs. */
		11704	if (h->u.weakdef != NULL)
		11705	h->u.weakdef->mark = 1;
		11706	return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
		11707	}
		11708
		11709	return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
		11710	&cookie->locsyms[r_symndx]);
		11711	}
		11712
		11713	/* COOKIE->rel describes a relocation against section SEC, which is
		11714	a section we've decided to keep. Mark the section that contains
		11715	the relocation symbol. */
		11716
		11717	bfd_boolean
		11718	_bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
		11719	asection *sec,
		11720	elf_gc_mark_hook_fn gc_mark_hook,
		11721	struct elf_reloc_cookie *cookie)
		11722	{
		11723	asection *rsec;
		11724
		11725	rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
		11726	if (rsec && !rsec->gc_mark)
		11727	{
		11728	if (bfd_get_flavour (rsec->owner) != bfd_target_elf_flavour
		11729	\|\| (rsec->owner->flags & DYNAMIC) != 0)
		11730	rsec->gc_mark = 1;
		11731	else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
		11732	return FALSE;
		11733	}
		11734	return TRUE;
		11735	}
		11736
		11737	/* The mark phase of garbage collection. For a given section, mark
		11738	it and any sections in this section's group, and all the sections
		11739	which define symbols to which it refers. */
		11740
		11741	bfd_boolean
		11742	_bfd_elf_gc_mark (struct bfd_link_info *info,
		11743	asection *sec,
		11744	elf_gc_mark_hook_fn gc_mark_hook)
		11745	{
		11746	bfd_boolean ret;
		11747	asection group_sec, eh_frame;
		11748
		11749	sec->gc_mark = 1;
		11750
		11751	/* Mark all the sections in the group. */
		11752	group_sec = elf_section_data (sec)->next_in_group;
		11753	if (group_sec && !group_sec->gc_mark)
		11754	if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
		11755	return FALSE;
		11756
		11757	/* Look through the section relocs. */
		11758	ret = TRUE;
		11759	eh_frame = elf_eh_frame_section (sec->owner);
		11760	if ((sec->flags & SEC_RELOC) != 0
		11761	&& sec->reloc_count > 0
		11762	&& sec != eh_frame)
		11763	{
		11764	struct elf_reloc_cookie cookie;
		11765
		11766	if (!init_reloc_cookie_for_section (&cookie, info, sec))
		11767	ret = FALSE;
		11768	else
		11769	{
		11770	for (; cookie.rel < cookie.relend; cookie.rel++)
		11771	if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
		11772	{
		11773	ret = FALSE;
		11774	break;
		11775	}
		11776	fini_reloc_cookie_for_section (&cookie, sec);
		11777	}
		11778	}
		11779
		11780	if (ret && eh_frame && elf_fde_list (sec))
		11781	{
		11782	struct elf_reloc_cookie cookie;
		11783
		11784	if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
		11785	ret = FALSE;
		11786	else
		11787	{
		11788	if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
		11789	gc_mark_hook, &cookie))
		11790	ret = FALSE;
		11791	fini_reloc_cookie_for_section (&cookie, eh_frame);
		11792	}
		11793	}
		11794
		11795	return ret;
		11796	}
		11797
		11798	/* Keep debug and special sections. */
		11799
		11800	bfd_boolean
		11801	_bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
		11802	elf_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
		11803	{
		11804	bfd *ibfd;
		11805
		11806	for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
		11807	{
		11808	asection *isec;
		11809	bfd_boolean some_kept;
		11810	bfd_boolean debug_frag_seen;
		11811
		11812	if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
		11813	continue;
		11814
		11815	/* Ensure all linker created sections are kept,
		11816	see if any other section is already marked,
		11817	and note if we have any fragmented debug sections. */
		11818	debug_frag_seen = some_kept = FALSE;
		11819	for (isec = ibfd->sections; isec != NULL; isec = isec->next)
		11820	{
		11821	if ((isec->flags & SEC_LINKER_CREATED) != 0)
		11822	isec->gc_mark = 1;
		11823	else if (isec->gc_mark)
		11824	some_kept = TRUE;
		11825
		11826	if (debug_frag_seen == FALSE
		11827	&& (isec->flags & SEC_DEBUGGING)
		11828	&& CONST_STRNEQ (isec->name, ".debug_line."))
		11829	debug_frag_seen = TRUE;
		11830	}
		11831
		11832	/* If no section in this file will be kept, then we can
		11833	toss out the debug and special sections. */
		11834	if (!some_kept)
		11835	continue;
		11836
		11837	/* Keep debug and special sections like .comment when they are
		11838	not part of a group, or when we have single-member groups. */
		11839	for (isec = ibfd->sections; isec != NULL; isec = isec->next)
		11840	if ((elf_next_in_group (isec) == NULL
		11841	\|\| elf_next_in_group (isec) == isec)
		11842	&& ((isec->flags & SEC_DEBUGGING) != 0
		11843	\|\| (isec->flags & (SEC_ALLOC \| SEC_LOAD \| SEC_RELOC)) == 0))
		11844	isec->gc_mark = 1;
		11845
		11846	if (! debug_frag_seen)
		11847	continue;
		11848
		11849	/* Look for CODE sections which are going to be discarded,
		11850	and find and discard any fragmented debug sections which
		11851	are associated with that code section. */
		11852	for (isec = ibfd->sections; isec != NULL; isec = isec->next)
		11853	if ((isec->flags & SEC_CODE) != 0
		11854	&& isec->gc_mark == 0)
		11855	{
		11856	unsigned int ilen;
		11857	asection *dsec;
		11858
		11859	ilen = strlen (isec->name);
		11860
		11861	/* Association is determined by the name of the debug section
		11862	containing the name of the code section as a suffix. For
		11863	example .debug_line.text.foo is a debug section associated
		11864	with .text.foo. */
		11865	for (dsec = ibfd->sections; dsec != NULL; dsec = dsec->next)
		11866	{
		11867	unsigned int dlen;
		11868
		11869	if (dsec->gc_mark == 0
		11870	\|\| (dsec->flags & SEC_DEBUGGING) == 0)
		11871	continue;
		11872
		11873	dlen = strlen (dsec->name);
		11874
		11875	if (dlen > ilen
		11876	&& strncmp (dsec->name + (dlen - ilen),
		11877	isec->name, ilen) == 0)
		11878	{
		11879	dsec->gc_mark = 0;
		11880	break;
		11881	}
		11882	}
		11883	}
		11884	}
		11885	return TRUE;
		11886	}
		11887
		11888	/* Sweep symbols in swept sections. Called via elf_link_hash_traverse. */
		11889
		11890	struct elf_gc_sweep_symbol_info
		11891	{
		11892	struct bfd_link_info *info;
		11893	void (hide_symbol) (struct bfd_link_info , struct elf_link_hash_entry *,
		11894	bfd_boolean);
		11895	};
		11896
		11897	static bfd_boolean
		11898	elf_gc_sweep_symbol (struct elf_link_hash_entry h, void data)
		11899	{
		11900	if (!h->mark
		11901	&& (((h->root.type == bfd_link_hash_defined
		11902	\|\| h->root.type == bfd_link_hash_defweak)
		11903	&& !(h->def_regular
		11904	&& h->root.u.def.section->gc_mark))
		11905	\|\| h->root.type == bfd_link_hash_undefined
		11906	\|\| h->root.type == bfd_link_hash_undefweak))
		11907	{
		11908	struct elf_gc_sweep_symbol_info *inf;
		11909
		11910	inf = (struct elf_gc_sweep_symbol_info *) data;
		11911	(*inf->hide_symbol) (inf->info, h, TRUE);
		11912	h->def_regular = 0;
		11913	h->ref_regular = 0;
		11914	h->ref_regular_nonweak = 0;
		11915	}
		11916
		11917	return TRUE;
		11918	}
		11919
		11920	/* The sweep phase of garbage collection. Remove all garbage sections. */
		11921
		11922	typedef bfd_boolean (*gc_sweep_hook_fn)
		11923	(bfd , struct bfd_link_info , asection , const Elf_Internal_Rela );
		11924
		11925	static bfd_boolean
		11926	elf_gc_sweep (bfd abfd, struct bfd_link_info info)
		11927	{
		11928	bfd *sub;
		11929	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		11930	gc_sweep_hook_fn gc_sweep_hook = bed->gc_sweep_hook;
		11931	unsigned long section_sym_count;
		11932	struct elf_gc_sweep_symbol_info sweep_info;
		11933
		11934	for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
		11935	{
		11936	asection *o;
		11937
		11938	if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
		11939	continue;
		11940
		11941	for (o = sub->sections; o != NULL; o = o->next)
		11942	{
		11943	/* When any section in a section group is kept, we keep all
		11944	sections in the section group. If the first member of
		11945	the section group is excluded, we will also exclude the
		11946	group section. */
		11947	if (o->flags & SEC_GROUP)
		11948	{
		11949	asection *first = elf_next_in_group (o);
		11950	o->gc_mark = first->gc_mark;
		11951	}
		11952
		11953	if (o->gc_mark)
		11954	continue;
		11955
		11956	/* Skip sweeping sections already excluded. */
		11957	if (o->flags & SEC_EXCLUDE)
		11958	continue;
		11959
		11960	/* Since this is early in the link process, it is simple
		11961	to remove a section from the output. */
		11962	o->flags \|= SEC_EXCLUDE;
		11963
		11964	if (info->print_gc_sections && o->size != 0)
		11965	_bfd_error_handler (_("Removing unused section '%s' in file '%B'"), sub, o->name);
		11966
		11967	/* But we also have to update some of the relocation
		11968	info we collected before. */
		11969	if (gc_sweep_hook
		11970	&& (o->flags & SEC_RELOC) != 0
		11971	&& o->reloc_count > 0
		11972	&& !bfd_is_abs_section (o->output_section))
		11973	{
		11974	Elf_Internal_Rela *internal_relocs;
		11975	bfd_boolean r;
		11976
		11977	internal_relocs
		11978	= _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
		11979	info->keep_memory);
		11980	if (internal_relocs == NULL)
		11981	return FALSE;
		11982
		11983	r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
		11984
		11985	if (elf_section_data (o)->relocs != internal_relocs)
		11986	free (internal_relocs);
		11987
		11988	if (!r)
		11989	return FALSE;
		11990	}
		11991	}
		11992	}
		11993
		11994	/* Remove the symbols that were in the swept sections from the dynamic
		11995	symbol table. GCFIXME: Anyone know how to get them out of the
		11996	static symbol table as well? */
		11997	sweep_info.info = info;
		11998	sweep_info.hide_symbol = bed->elf_backend_hide_symbol;
		11999	elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol,
		12000	&sweep_info);
		12001
		12002	_bfd_elf_link_renumber_dynsyms (abfd, info, §ion_sym_count);
		12003	return TRUE;
		12004	}
		12005
		12006	/* Propagate collected vtable information. This is called through
		12007	elf_link_hash_traverse. */
		12008
		12009	static bfd_boolean
		12010	elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry h, void okp)
		12011	{
		12012	/* Those that are not vtables. */
		12013	if (h->vtable == NULL \|\| h->vtable->parent == NULL)
		12014	return TRUE;
		12015
		12016	/* Those vtables that do not have parents, we cannot merge. */
		12017	if (h->vtable->parent == (struct elf_link_hash_entry *) -1)
		12018	return TRUE;
		12019
		12020	/* If we've already been done, exit. */
		12021	if (h->vtable->used && h->vtable->used[-1])
		12022	return TRUE;
		12023
		12024	/* Make sure the parent's table is up to date. */
		12025	elf_gc_propagate_vtable_entries_used (h->vtable->parent, okp);
		12026
		12027	if (h->vtable->used == NULL)
		12028	{
		12029	/* None of this table's entries were referenced. Re-use the
		12030	parent's table. */
		12031	h->vtable->used = h->vtable->parent->vtable->used;
		12032	h->vtable->size = h->vtable->parent->vtable->size;
		12033	}
		12034	else
		12035	{
		12036	size_t n;
		12037	bfd_boolean cu, pu;
		12038
		12039	/* Or the parent's entries into ours. */
		12040	cu = h->vtable->used;
		12041	cu[-1] = TRUE;
		12042	pu = h->vtable->parent->vtable->used;
		12043	if (pu != NULL)
		12044	{
		12045	const struct elf_backend_data *bed;
		12046	unsigned int log_file_align;
		12047
		12048	bed = get_elf_backend_data (h->root.u.def.section->owner);
		12049	log_file_align = bed->s->log_file_align;
		12050	n = h->vtable->parent->vtable->size >> log_file_align;
		12051	while (n--)
		12052	{
		12053	if (*pu)
		12054	*cu = TRUE;
		12055	pu++;
		12056	cu++;
		12057	}
		12058	}
		12059	}
		12060
		12061	return TRUE;
		12062	}
		12063
		12064	static bfd_boolean
		12065	elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry h, void okp)
		12066	{
		12067	asection *sec;
		12068	bfd_vma hstart, hend;
		12069	Elf_Internal_Rela relstart, relend, *rel;
		12070	const struct elf_backend_data *bed;
		12071	unsigned int log_file_align;
		12072
		12073	/* Take care of both those symbols that do not describe vtables as
		12074	well as those that are not loaded. */
		12075	if (h->vtable == NULL \|\| h->vtable->parent == NULL)
		12076	return TRUE;
		12077
		12078	BFD_ASSERT (h->root.type == bfd_link_hash_defined
		12079	\|\| h->root.type == bfd_link_hash_defweak);
		12080
		12081	sec = h->root.u.def.section;
		12082	hstart = h->root.u.def.value;
		12083	hend = hstart + h->size;
		12084
		12085	relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
		12086	if (!relstart)
		12087	return (bfd_boolean ) okp = FALSE;
		12088	bed = get_elf_backend_data (sec->owner);
		12089	log_file_align = bed->s->log_file_align;
		12090
		12091	relend = relstart + sec->reloc_count * bed->s->int_rels_per_ext_rel;
		12092
		12093	for (rel = relstart; rel < relend; ++rel)
		12094	if (rel->r_offset >= hstart && rel->r_offset < hend)
		12095	{
		12096	/* If the entry is in use, do nothing. */
		12097	if (h->vtable->used
		12098	&& (rel->r_offset - hstart) < h->vtable->size)
		12099	{
		12100	bfd_vma entry = (rel->r_offset - hstart) >> log_file_align;
		12101	if (h->vtable->used[entry])
		12102	continue;
		12103	}
		12104	/* Otherwise, kill it. */
		12105	rel->r_offset = rel->r_info = rel->r_addend = 0;
		12106	}
		12107
		12108	return TRUE;
		12109	}
		12110
		12111	/* Mark sections containing dynamically referenced symbols. When
		12112	building shared libraries, we must assume that any visible symbol is
		12113	referenced. */
		12114
		12115	bfd_boolean
		12116	bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry h, void inf)
		12117	{
		12118	struct bfd_link_info info = (struct bfd_link_info ) inf;
		12119
		12120	if ((h->root.type == bfd_link_hash_defined
		12121	\|\| h->root.type == bfd_link_hash_defweak)
		12122	&& (h->ref_dynamic
		12123	\|\| ((!info->executable \|\| info->export_dynamic)
		12124	&& h->def_regular
		12125	&& ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
		12126	&& ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
		12127	&& (strchr (h->root.root.string, ELF_VER_CHR) != NULL
		12128	\|\| !bfd_hide_sym_by_version (info->version_info,
		12129	h->root.root.string)))))
		12130	h->root.u.def.section->flags \|= SEC_KEEP;
		12131
		12132	return TRUE;
		12133	}
		12134
		12135	/* Keep all sections containing symbols undefined on the command-line,
		12136	and the section containing the entry symbol. */
		12137
		12138	void
		12139	_bfd_elf_gc_keep (struct bfd_link_info *info)
		12140	{
		12141	struct bfd_sym_chain *sym;
		12142
		12143	for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
		12144	{
		12145	struct elf_link_hash_entry *h;
		12146
		12147	h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
		12148	FALSE, FALSE, FALSE);
		12149
		12150	if (h != NULL
		12151	&& (h->root.type == bfd_link_hash_defined
		12152	\|\| h->root.type == bfd_link_hash_defweak)
		12153	&& !bfd_is_abs_section (h->root.u.def.section))
		12154	h->root.u.def.section->flags \|= SEC_KEEP;
		12155	}
		12156	}
		12157
		12158	/* Do mark and sweep of unused sections. */
		12159
		12160	bfd_boolean
		12161	bfd_elf_gc_sections (bfd abfd, struct bfd_link_info info)
		12162	{
		12163	bfd_boolean ok = TRUE;
		12164	bfd *sub;
		12165	elf_gc_mark_hook_fn gc_mark_hook;
		12166	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		12167
		12168	if (!bed->can_gc_sections
		12169	\|\| !is_elf_hash_table (info->hash))
		12170	{
		12171	(*_bfd_error_handler)(_("Warning: gc-sections option ignored"));
		12172	return TRUE;
		12173	}
		12174
		12175	bed->gc_keep (info);
		12176
		12177	/* Try to parse each bfd's .eh_frame section. Point elf_eh_frame_section
		12178	at the .eh_frame section if we can mark the FDEs individually. */
		12179	_bfd_elf_begin_eh_frame_parsing (info);
		12180	for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
		12181	{
		12182	asection *sec;
		12183	struct elf_reloc_cookie cookie;
		12184
		12185	sec = bfd_get_section_by_name (sub, ".eh_frame");
		12186	while (sec && init_reloc_cookie_for_section (&cookie, info, sec))
		12187	{
		12188	_bfd_elf_parse_eh_frame (sub, info, sec, &cookie);
		12189	if (elf_section_data (sec)->sec_info
		12190	&& (sec->flags & SEC_LINKER_CREATED) == 0)
		12191	elf_eh_frame_section (sub) = sec;
		12192	fini_reloc_cookie_for_section (&cookie, sec);
		12193	sec = bfd_get_next_section_by_name (sec);
		12194	}
		12195	}
		12196	_bfd_elf_end_eh_frame_parsing (info);
		12197
		12198	/* Apply transitive closure to the vtable entry usage info. */
		12199	elf_link_hash_traverse (elf_hash_table (info),
		12200	elf_gc_propagate_vtable_entries_used,
		12201	&ok);
		12202	if (!ok)
		12203	return FALSE;
		12204
		12205	/* Kill the vtable relocations that were not used. */
		12206	elf_link_hash_traverse (elf_hash_table (info),
		12207	elf_gc_smash_unused_vtentry_relocs,
		12208	&ok);
		12209	if (!ok)
		12210	return FALSE;
		12211
		12212	/* Mark dynamically referenced symbols. */
		12213	if (elf_hash_table (info)->dynamic_sections_created)
		12214	elf_link_hash_traverse (elf_hash_table (info),
		12215	bed->gc_mark_dynamic_ref,
		12216	info);
		12217
		12218	/* Grovel through relocs to find out who stays ... */
		12219	gc_mark_hook = bed->gc_mark_hook;
		12220	for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
		12221	{
		12222	asection *o;
		12223
		12224	if (bfd_get_flavour (sub) != bfd_target_elf_flavour)
		12225	continue;
		12226
		12227	/* Start at sections marked with SEC_KEEP (ref _bfd_elf_gc_keep).
		12228	Also treat note sections as a root, if the section is not part
		12229	of a group. */
		12230	for (o = sub->sections; o != NULL; o = o->next)
		12231	if (!o->gc_mark
		12232	&& (o->flags & SEC_EXCLUDE) == 0
		12233	&& ((o->flags & SEC_KEEP) != 0
		12234	\|\| (elf_section_data (o)->this_hdr.sh_type == SHT_NOTE
		12235	&& elf_next_in_group (o) == NULL )))
		12236	{
		12237	if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
		12238	return FALSE;
		12239	}
		12240	}
		12241
		12242	/* Allow the backend to mark additional target specific sections. */
		12243	bed->gc_mark_extra_sections (info, gc_mark_hook);
		12244
		12245	/* ... and mark SEC_EXCLUDE for those that go. */
		12246	return elf_gc_sweep (abfd, info);
		12247	}
		12248
		12249	/* Called from check_relocs to record the existence of a VTINHERIT reloc. */
		12250
		12251	bfd_boolean
		12252	bfd_elf_gc_record_vtinherit (bfd *abfd,
		12253	asection *sec,
		12254	struct elf_link_hash_entry *h,
		12255	bfd_vma offset)
		12256	{
		12257	struct elf_link_hash_entry sym_hashes, sym_hashes_end;
		12258	struct elf_link_hash_entry *search, child;
		12259	bfd_size_type extsymcount;
		12260	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		12261
		12262	/* The sh_info field of the symtab header tells us where the
		12263	external symbols start. We don't care about the local symbols at
		12264	this point. */
		12265	extsymcount = elf_tdata (abfd)->symtab_hdr.sh_size / bed->s->sizeof_sym;
		12266	if (!elf_bad_symtab (abfd))
		12267	extsymcount -= elf_tdata (abfd)->symtab_hdr.sh_info;
		12268
		12269	sym_hashes = elf_sym_hashes (abfd);
		12270	sym_hashes_end = sym_hashes + extsymcount;
		12271
		12272	/* Hunt down the child symbol, which is in this section at the same
		12273	offset as the relocation. */
		12274	for (search = sym_hashes; search != sym_hashes_end; ++search)
		12275	{
		12276	if ((child = *search) != NULL
		12277	&& (child->root.type == bfd_link_hash_defined
		12278	\|\| child->root.type == bfd_link_hash_defweak)
		12279	&& child->root.u.def.section == sec
		12280	&& child->root.u.def.value == offset)
		12281	goto win;
		12282	}
		12283
		12284	(*_bfd_error_handler) ("%B: %A+%lu: No symbol found for INHERIT",
		12285	abfd, sec, (unsigned long) offset);
		12286	bfd_set_error (bfd_error_invalid_operation);
		12287	return FALSE;
		12288
		12289	win:
		12290	if (!child->vtable)
		12291	{
		12292	child->vtable = (struct elf_link_virtual_table_entry *)
		12293	bfd_zalloc (abfd, sizeof (*child->vtable));
		12294	if (!child->vtable)
		12295	return FALSE;
		12296	}
		12297	if (!h)
		12298	{
		12299	/* This should only be the absolute section. It could potentially
		12300	be that someone has defined a non-global vtable though, which
		12301	would be bad. It isn't worth paging in the local symbols to be
		12302	sure though; that case should simply be handled by the assembler. */
		12303
		12304	child->vtable->parent = (struct elf_link_hash_entry *) -1;
		12305	}
		12306	else
		12307	child->vtable->parent = h;
		12308
		12309	return TRUE;
		12310	}
		12311
		12312	/* Called from check_relocs to record the existence of a VTENTRY reloc. */
		12313
		12314	bfd_boolean
		12315	bfd_elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
		12316	asection *sec ATTRIBUTE_UNUSED,
		12317	struct elf_link_hash_entry *h,
		12318	bfd_vma addend)
		12319	{
		12320	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		12321	unsigned int log_file_align = bed->s->log_file_align;
		12322
		12323	if (!h->vtable)
		12324	{
		12325	h->vtable = (struct elf_link_virtual_table_entry *)
		12326	bfd_zalloc (abfd, sizeof (*h->vtable));
		12327	if (!h->vtable)
		12328	return FALSE;
		12329	}
		12330
		12331	if (addend >= h->vtable->size)
		12332	{
		12333	size_t size, bytes, file_align;
		12334	bfd_boolean *ptr = h->vtable->used;
		12335
		12336	/* While the symbol is undefined, we have to be prepared to handle
		12337	a zero size. */
		12338	file_align = 1 << log_file_align;
		12339	if (h->root.type == bfd_link_hash_undefined)
		12340	size = addend + file_align;
		12341	else
		12342	{
		12343	size = h->size;
		12344	if (addend >= size)
		12345	{
		12346	/* Oops! We've got a reference past the defined end of
		12347	the table. This is probably a bug -- shall we warn? */
		12348	size = addend + file_align;
		12349	}
		12350	}
		12351	size = (size + file_align - 1) & -file_align;
		12352
		12353	/* Allocate one extra entry for use as a "done" flag for the
		12354	consolidation pass. */
		12355	bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
		12356
		12357	if (ptr)
		12358	{
		12359	ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
		12360
		12361	if (ptr != NULL)
		12362	{
		12363	size_t oldbytes;
		12364
		12365	oldbytes = (((h->vtable->size >> log_file_align) + 1)
		12366	* sizeof (bfd_boolean));
		12367	memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
		12368	}
		12369	}
		12370	else
		12371	ptr = (bfd_boolean *) bfd_zmalloc (bytes);
		12372
		12373	if (ptr == NULL)
		12374	return FALSE;
		12375
		12376	/* And arrange for that done flag to be at index -1. */
		12377	h->vtable->used = ptr + 1;
		12378	h->vtable->size = size;
		12379	}
		12380
		12381	h->vtable->used[addend >> log_file_align] = TRUE;
		12382
		12383	return TRUE;
		12384	}
		12385
		12386	/* Map an ELF section header flag to its corresponding string. */
		12387	typedef struct
		12388	{
		12389	char *flag_name;
		12390	flagword flag_value;
		12391	} elf_flags_to_name_table;
		12392
		12393	static elf_flags_to_name_table elf_flags_to_names [] =
		12394	{
		12395	{ "SHF_WRITE", SHF_WRITE },
		12396	{ "SHF_ALLOC", SHF_ALLOC },
		12397	{ "SHF_EXECINSTR", SHF_EXECINSTR },
		12398	{ "SHF_MERGE", SHF_MERGE },
		12399	{ "SHF_STRINGS", SHF_STRINGS },
		12400	{ "SHF_INFO_LINK", SHF_INFO_LINK},
		12401	{ "SHF_LINK_ORDER", SHF_LINK_ORDER},
		12402	{ "SHF_OS_NONCONFORMING", SHF_OS_NONCONFORMING},
		12403	{ "SHF_GROUP", SHF_GROUP },
		12404	{ "SHF_TLS", SHF_TLS },
		12405	{ "SHF_MASKOS", SHF_MASKOS },
		12406	{ "SHF_EXCLUDE", SHF_EXCLUDE },
		12407	};
		12408
		12409	/* Returns TRUE if the section is to be included, otherwise FALSE. */
		12410	bfd_boolean
		12411	bfd_elf_lookup_section_flags (struct bfd_link_info *info,
		12412	struct flag_info *flaginfo,
		12413	asection *section)
		12414	{
		12415	const bfd_vma sh_flags = elf_section_flags (section);
		12416
		12417	if (!flaginfo->flags_initialized)
		12418	{
		12419	bfd *obfd = info->output_bfd;
		12420	const struct elf_backend_data *bed = get_elf_backend_data (obfd);
		12421	struct flag_info_list *tf = flaginfo->flag_list;
		12422	int with_hex = 0;
		12423	int without_hex = 0;
		12424
		12425	for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next)
		12426	{
		12427	unsigned i;
		12428	flagword (lookup) (char );
		12429
		12430	lookup = bed->elf_backend_lookup_section_flags_hook;
		12431	if (lookup != NULL)
		12432	{
		12433	flagword hexval = (lookup) ((char ) tf->name);
		12434
		12435	if (hexval != 0)
		12436	{
		12437	if (tf->with == with_flags)
		12438	with_hex \|= hexval;
		12439	else if (tf->with == without_flags)
		12440	without_hex \|= hexval;
		12441	tf->valid = TRUE;
		12442	continue;
		12443	}
		12444	}
		12445	for (i = 0; i < ARRAY_SIZE (elf_flags_to_names); ++i)
		12446	{
		12447	if (strcmp (tf->name, elf_flags_to_names[i].flag_name) == 0)
		12448	{
		12449	if (tf->with == with_flags)
		12450	with_hex \|= elf_flags_to_names[i].flag_value;
		12451	else if (tf->with == without_flags)
		12452	without_hex \|= elf_flags_to_names[i].flag_value;
		12453	tf->valid = TRUE;
		12454	break;
		12455	}
		12456	}
		12457	if (!tf->valid)
		12458	{
		12459	info->callbacks->einfo
		12460	(_("Unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
		12461	return FALSE;
		12462	}
		12463	}
		12464	flaginfo->flags_initialized = TRUE;
		12465	flaginfo->only_with_flags \|= with_hex;
		12466	flaginfo->not_with_flags \|= without_hex;
		12467	}
		12468
		12469	if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags)
		12470	return FALSE;
		12471
		12472	if ((flaginfo->not_with_flags & sh_flags) != 0)
		12473	return FALSE;
		12474
		12475	return TRUE;
		12476	}
		12477
		12478	struct alloc_got_off_arg {
		12479	bfd_vma gotoff;
		12480	struct bfd_link_info *info;
		12481	};
		12482
		12483	/* We need a special top-level link routine to convert got reference counts
		12484	to real got offsets. */
		12485
		12486	static bfd_boolean
		12487	elf_gc_allocate_got_offsets (struct elf_link_hash_entry h, void arg)
		12488	{
		12489	struct alloc_got_off_arg gofarg = (struct alloc_got_off_arg ) arg;
		12490	bfd *obfd = gofarg->info->output_bfd;
		12491	const struct elf_backend_data *bed = get_elf_backend_data (obfd);
		12492
		12493	if (h->got.refcount > 0)
		12494	{
		12495	h->got.offset = gofarg->gotoff;
		12496	gofarg->gotoff += bed->got_elt_size (obfd, gofarg->info, h, NULL, 0);
		12497	}
		12498	else
		12499	h->got.offset = (bfd_vma) -1;
		12500
		12501	return TRUE;
		12502	}
		12503
		12504	/* And an accompanying bit to work out final got entry offsets once
		12505	we're done. Should be called from final_link. */
		12506
		12507	bfd_boolean
		12508	bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
		12509	struct bfd_link_info *info)
		12510	{
		12511	bfd *i;
		12512	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		12513	bfd_vma gotoff;
		12514	struct alloc_got_off_arg gofarg;
		12515
		12516	BFD_ASSERT (abfd == info->output_bfd);
		12517
		12518	if (! is_elf_hash_table (info->hash))
		12519	return FALSE;
		12520
		12521	/* The GOT offset is relative to the .got section, but the GOT header is
		12522	put into the .got.plt section, if the backend uses it. */
		12523	if (bed->want_got_plt)
		12524	gotoff = 0;
		12525	else
		12526	gotoff = bed->got_header_size;
		12527
		12528	/* Do the local .got entries first. */
		12529	for (i = info->input_bfds; i; i = i->link_next)
		12530	{
		12531	bfd_signed_vma *local_got;
		12532	bfd_size_type j, locsymcount;
		12533	Elf_Internal_Shdr *symtab_hdr;
		12534
		12535	if (bfd_get_flavour (i) != bfd_target_elf_flavour)
		12536	continue;
		12537
		12538	local_got = elf_local_got_refcounts (i);
		12539	if (!local_got)
		12540	continue;
		12541
		12542	symtab_hdr = &elf_tdata (i)->symtab_hdr;
		12543	if (elf_bad_symtab (i))
		12544	locsymcount = symtab_hdr->sh_size / bed->s->sizeof_sym;
		12545	else
		12546	locsymcount = symtab_hdr->sh_info;
		12547
		12548	for (j = 0; j < locsymcount; ++j)
		12549	{
		12550	if (local_got[j] > 0)
		12551	{
		12552	local_got[j] = gotoff;
		12553	gotoff += bed->got_elt_size (abfd, info, NULL, i, j);
		12554	}
		12555	else
		12556	local_got[j] = (bfd_vma) -1;
		12557	}
		12558	}
		12559
		12560	/* Then the global .got entries. .plt refcounts are handled by
		12561	adjust_dynamic_symbol */
		12562	gofarg.gotoff = gotoff;
		12563	gofarg.info = info;
		12564	elf_link_hash_traverse (elf_hash_table (info),
		12565	elf_gc_allocate_got_offsets,
		12566	&gofarg);
		12567	return TRUE;
		12568	}
		12569
		12570	/* Many folk need no more in the way of final link than this, once
		12571	got entry reference counting is enabled. */
		12572
		12573	bfd_boolean
		12574	bfd_elf_gc_common_final_link (bfd abfd, struct bfd_link_info info)
		12575	{
		12576	if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
		12577	return FALSE;
		12578
		12579	/* Invoke the regular ELF backend linker to do all the work. */
		12580	return bfd_elf_final_link (abfd, info);
		12581	}
		12582
		12583	bfd_boolean
		12584	bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
		12585	{
		12586	struct elf_reloc_cookie rcookie = (struct elf_reloc_cookie ) cookie;
		12587
		12588	if (rcookie->bad_symtab)
		12589	rcookie->rel = rcookie->rels;
		12590
		12591	for (; rcookie->rel < rcookie->relend; rcookie->rel++)
		12592	{
		12593	unsigned long r_symndx;
		12594
		12595	if (! rcookie->bad_symtab)
		12596	if (rcookie->rel->r_offset > offset)
		12597	return FALSE;
		12598	if (rcookie->rel->r_offset != offset)
		12599	continue;
		12600
		12601	r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
		12602	if (r_symndx == STN_UNDEF)
		12603	return TRUE;
		12604
		12605	if (r_symndx >= rcookie->locsymcount
		12606	\|\| ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
		12607	{
		12608	struct elf_link_hash_entry *h;
		12609
		12610	h = rcookie->sym_hashes[r_symndx - rcookie->extsymoff];
		12611
		12612	while (h->root.type == bfd_link_hash_indirect
		12613	\|\| h->root.type == bfd_link_hash_warning)
		12614	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		12615
		12616	if ((h->root.type == bfd_link_hash_defined
		12617	\|\| h->root.type == bfd_link_hash_defweak)
		12618	&& discarded_section (h->root.u.def.section))
		12619	return TRUE;
		12620	else
		12621	return FALSE;
		12622	}
		12623	else
		12624	{
		12625	/* It's not a relocation against a global symbol,
		12626	but it could be a relocation against a local
		12627	symbol for a discarded section. */
		12628	asection *isec;
		12629	Elf_Internal_Sym *isym;
		12630
		12631	/* Need to: get the symbol; get the section. */
		12632	isym = &rcookie->locsyms[r_symndx];
		12633	isec = bfd_section_from_elf_index (rcookie->abfd, isym->st_shndx);
		12634	if (isec != NULL && discarded_section (isec))
		12635	return TRUE;
		12636	}
		12637	return FALSE;
		12638	}
		12639	return FALSE;
		12640	}
		12641
		12642	/* Discard unneeded references to discarded sections.
		12643	Returns TRUE if any section's size was changed. */
		12644	/* This function assumes that the relocations are in sorted order,
		12645	which is true for all known assemblers. */
		12646
		12647	bfd_boolean
		12648	bfd_elf_discard_info (bfd output_bfd, struct bfd_link_info info)
		12649	{
		12650	struct elf_reloc_cookie cookie;
		12651	asection stab, eh;
		12652	const struct elf_backend_data *bed;
		12653	bfd *abfd;
		12654	bfd_boolean ret = FALSE;
		12655
		12656	if (info->traditional_format
		12657	\|\| !is_elf_hash_table (info->hash))
		12658	return FALSE;
		12659
		12660	_bfd_elf_begin_eh_frame_parsing (info);
		12661	for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
		12662	{
		12663	if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
		12664	continue;
		12665
		12666	bed = get_elf_backend_data (abfd);
		12667
		12668	eh = NULL;
		12669	if (!info->relocatable)
		12670	{
		12671	eh = bfd_get_section_by_name (abfd, ".eh_frame");
		12672	while (eh != NULL
		12673	&& (eh->size == 0
		12674	\|\| bfd_is_abs_section (eh->output_section)))
		12675	eh = bfd_get_next_section_by_name (eh);
		12676	}
		12677
		12678	stab = bfd_get_section_by_name (abfd, ".stab");
		12679	if (stab != NULL
		12680	&& (stab->size == 0
		12681	\|\| bfd_is_abs_section (stab->output_section)
		12682	\|\| stab->sec_info_type != SEC_INFO_TYPE_STABS))
		12683	stab = NULL;
		12684
		12685	if (stab == NULL
		12686	&& eh == NULL
		12687	&& bed->elf_backend_discard_info == NULL)
		12688	continue;
		12689
		12690	if (!init_reloc_cookie (&cookie, info, abfd))
		12691	return FALSE;
		12692
		12693	if (stab != NULL
		12694	&& stab->reloc_count > 0
		12695	&& init_reloc_cookie_rels (&cookie, info, abfd, stab))
		12696	{
		12697	if (_bfd_discard_section_stabs (abfd, stab,
		12698	elf_section_data (stab)->sec_info,
		12699	bfd_elf_reloc_symbol_deleted_p,
		12700	&cookie))
		12701	ret = TRUE;
		12702	fini_reloc_cookie_rels (&cookie, stab);
		12703	}
		12704
		12705	while (eh != NULL
		12706	&& init_reloc_cookie_rels (&cookie, info, abfd, eh))
		12707	{
		12708	_bfd_elf_parse_eh_frame (abfd, info, eh, &cookie);
		12709	if (_bfd_elf_discard_section_eh_frame (abfd, info, eh,
		12710	bfd_elf_reloc_symbol_deleted_p,
		12711	&cookie))
		12712	ret = TRUE;
		12713	fini_reloc_cookie_rels (&cookie, eh);
		12714	eh = bfd_get_next_section_by_name (eh);
		12715	}
		12716
		12717	if (bed->elf_backend_discard_info != NULL
		12718	&& (*bed->elf_backend_discard_info) (abfd, &cookie, info))
		12719	ret = TRUE;
		12720
		12721	fini_reloc_cookie (&cookie, abfd);
		12722	}
		12723	_bfd_elf_end_eh_frame_parsing (info);
		12724
		12725	if (info->eh_frame_hdr
		12726	&& !info->relocatable
		12727	&& _bfd_elf_discard_section_eh_frame_hdr (output_bfd, info))
		12728	ret = TRUE;
		12729
		12730	return ret;
		12731	}
		12732
		12733	bfd_boolean
		12734	_bfd_elf_section_already_linked (bfd *abfd,
		12735	asection *sec,
		12736	struct bfd_link_info *info)
		12737	{
		12738	flagword flags;
		12739	const char name, key;
		12740	struct bfd_section_already_linked *l;
		12741	struct bfd_section_already_linked_hash_entry *already_linked_list;
		12742
		12743	if (sec->output_section == bfd_abs_section_ptr)
		12744	return FALSE;
		12745
		12746	flags = sec->flags;
		12747
		12748	/* Return if it isn't a linkonce section. A comdat group section
		12749	also has SEC_LINK_ONCE set. */
		12750	if ((flags & SEC_LINK_ONCE) == 0)
		12751	return FALSE;
		12752
		12753	/* Don't put group member sections on our list of already linked
		12754	sections. They are handled as a group via their group section. */
		12755	if (elf_sec_group (sec) != NULL)
		12756	return FALSE;
		12757
		12758	/* For a SHT_GROUP section, use the group signature as the key. */
		12759	name = sec->name;
		12760	if ((flags & SEC_GROUP) != 0
		12761	&& elf_next_in_group (sec) != NULL
		12762	&& elf_group_name (elf_next_in_group (sec)) != NULL)
		12763	key = elf_group_name (elf_next_in_group (sec));
		12764	else
		12765	{
		12766	/* Otherwise we should have a .gnu.linkonce.. section. */
		12767	if (CONST_STRNEQ (name, ".gnu.linkonce.")
		12768	&& (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
		12769	key++;
		12770	else
		12771	/* Must be a user linkonce section that doesn't follow gcc's
		12772	naming convention. In this case we won't be matching
		12773	single member groups. */
		12774	key = name;
		12775	}
		12776
		12777	already_linked_list = bfd_section_already_linked_table_lookup (key);
		12778
		12779	for (l = already_linked_list->entry; l != NULL; l = l->next)
		12780	{
		12781	/* We may have 2 different types of sections on the list: group
		12782	sections with a signature of ( is some string),
		12783	and linkonce sections named .gnu.linkonce...
		12784	Match like sections. LTO plugin sections are an exception.
		12785	They are always named .gnu.linkonce.t. and match either
		12786	type of section. */
		12787	if (((flags & SEC_GROUP) == (l->sec->flags & SEC_GROUP)
		12788	&& ((flags & SEC_GROUP) != 0
		12789	\|\| strcmp (name, l->sec->name) == 0))
		12790	\|\| (l->sec->owner->flags & BFD_PLUGIN) != 0)
		12791	{
		12792	/* The section has already been linked. See if we should
		12793	issue a warning. */
		12794	if (!_bfd_handle_already_linked (sec, l, info))
		12795	return FALSE;
		12796
		12797	if (flags & SEC_GROUP)
		12798	{
		12799	asection *first = elf_next_in_group (sec);
		12800	asection *s = first;
		12801
		12802	while (s != NULL)
		12803	{
		12804	s->output_section = bfd_abs_section_ptr;
		12805	/* Record which group discards it. */
		12806	s->kept_section = l->sec;
		12807	s = elf_next_in_group (s);
		12808	/* These lists are circular. */
		12809	if (s == first)
		12810	break;
		12811	}
		12812	}
		12813
		12814	return TRUE;
		12815	}
		12816	}
		12817
		12818	/* A single member comdat group section may be discarded by a
		12819	linkonce section and vice versa. */
		12820	if ((flags & SEC_GROUP) != 0)
		12821	{
		12822	asection *first = elf_next_in_group (sec);
		12823
		12824	if (first != NULL && elf_next_in_group (first) == first)
		12825	/* Check this single member group against linkonce sections. */
		12826	for (l = already_linked_list->entry; l != NULL; l = l->next)
		12827	if ((l->sec->flags & SEC_GROUP) == 0
		12828	&& bfd_elf_match_symbols_in_sections (l->sec, first, info))
		12829	{
		12830	first->output_section = bfd_abs_section_ptr;
		12831	first->kept_section = l->sec;
		12832	sec->output_section = bfd_abs_section_ptr;
		12833	break;
		12834	}
		12835	}
		12836	else
		12837	/* Check this linkonce section against single member groups. */
		12838	for (l = already_linked_list->entry; l != NULL; l = l->next)
		12839	if (l->sec->flags & SEC_GROUP)
		12840	{
		12841	asection *first = elf_next_in_group (l->sec);
		12842
		12843	if (first != NULL
		12844	&& elf_next_in_group (first) == first
		12845	&& bfd_elf_match_symbols_in_sections (first, sec, info))
		12846	{
		12847	sec->output_section = bfd_abs_section_ptr;
		12848	sec->kept_section = first;
		12849	break;
		12850	}
		12851	}
		12852
		12853	/* Do not complain on unresolved relocations in `.gnu.linkonce.r.F'
		12854	referencing its discarded `.gnu.linkonce.t.F' counterpart - g++-3.4
		12855	specific as g++-4.x is using COMDAT groups (without the `.gnu.linkonce'
		12856	prefix) instead. `.gnu.linkonce.r.*' were the `.rodata' part of its
		12857	matching `.gnu.linkonce.t.*'. If `.gnu.linkonce.r.F' is not discarded
		12858	but its `.gnu.linkonce.t.F' is discarded means we chose one-only
		12859	`.gnu.linkonce.t.F' section from a different bfd not requiring any
		12860	`.gnu.linkonce.r.F'. Thus `.gnu.linkonce.r.F' should be discarded.
		12861	The reverse order cannot happen as there is never a bfd with only the
		12862	`.gnu.linkonce.r.F' section. The order of sections in a bfd does not
		12863	matter as here were are looking only for cross-bfd sections. */
		12864
		12865	if ((flags & SEC_GROUP) == 0 && CONST_STRNEQ (name, ".gnu.linkonce.r."))
		12866	for (l = already_linked_list->entry; l != NULL; l = l->next)
		12867	if ((l->sec->flags & SEC_GROUP) == 0
		12868	&& CONST_STRNEQ (l->sec->name, ".gnu.linkonce.t."))
		12869	{
		12870	if (abfd != l->sec->owner)
		12871	sec->output_section = bfd_abs_section_ptr;
		12872	break;
		12873	}
		12874
		12875	/* This is the first section with this name. Record it. */
		12876	if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
		12877	info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
		12878	return sec->output_section == bfd_abs_section_ptr;
		12879	}
		12880
		12881	bfd_boolean
		12882	_bfd_elf_common_definition (Elf_Internal_Sym *sym)
		12883	{
		12884	return sym->st_shndx == SHN_COMMON;
		12885	}
		12886
		12887	unsigned int
		12888	_bfd_elf_common_section_index (asection *sec ATTRIBUTE_UNUSED)
		12889	{
		12890	return SHN_COMMON;
		12891	}
		12892
		12893	asection *
		12894	_bfd_elf_common_section (asection *sec ATTRIBUTE_UNUSED)
		12895	{
		12896	return bfd_com_section_ptr;
		12897	}
		12898
		12899	bfd_vma
		12900	_bfd_elf_default_got_elt_size (bfd *abfd,
		12901	struct bfd_link_info *info ATTRIBUTE_UNUSED,
		12902	struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
		12903	bfd *ibfd ATTRIBUTE_UNUSED,
		12904	unsigned long symndx ATTRIBUTE_UNUSED)
		12905	{
		12906	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		12907	return bed->s->arch_size / 8;
		12908	}
		12909
		12910	/* Routines to support the creation of dynamic relocs. */
		12911
		12912	/* Returns the name of the dynamic reloc section associated with SEC. */
		12913
		12914	static const char *
		12915	get_dynamic_reloc_section_name (bfd * abfd,
		12916	asection * sec,
		12917	bfd_boolean is_rela)
		12918	{
		12919	char *name;
		12920	const char *old_name = bfd_get_section_name (NULL, sec);
		12921	const char *prefix = is_rela ? ".rela" : ".rel";
		12922
		12923	if (old_name == NULL)
		12924	return NULL;
		12925
		12926	name = bfd_alloc (abfd, strlen (prefix) + strlen (old_name) + 1);
		12927	sprintf (name, "%s%s", prefix, old_name);
		12928
		12929	return name;
		12930	}
		12931
		12932	/* Returns the dynamic reloc section associated with SEC.
		12933	If necessary compute the name of the dynamic reloc section based
		12934	on SEC's name (looked up in ABFD's string table) and the setting
		12935	of IS_RELA. */
		12936
		12937	asection *
		12938	_bfd_elf_get_dynamic_reloc_section (bfd * abfd,
		12939	asection * sec,
		12940	bfd_boolean is_rela)
		12941	{
		12942	asection * reloc_sec = elf_section_data (sec)->sreloc;
		12943
		12944	if (reloc_sec == NULL)
		12945	{
		12946	const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
		12947
		12948	if (name != NULL)
		12949	{
		12950	reloc_sec = bfd_get_linker_section (abfd, name);
		12951
		12952	if (reloc_sec != NULL)
		12953	elf_section_data (sec)->sreloc = reloc_sec;
		12954	}
		12955	}
		12956
		12957	return reloc_sec;
		12958	}
		12959
		12960	/* Returns the dynamic reloc section associated with SEC. If the
		12961	section does not exist it is created and attached to the DYNOBJ
		12962	bfd and stored in the SRELOC field of SEC's elf_section_data
		12963	structure.
		12964
		12965	ALIGNMENT is the alignment for the newly created section and
		12966	IS_RELA defines whether the name should be .rela.
		12967	or .rel.. The section name is looked up in the
		12968	string table associated with ABFD. */
		12969
		12970	asection *
		12971	_bfd_elf_make_dynamic_reloc_section (asection * sec,
		12972	bfd * dynobj,
		12973	unsigned int alignment,
		12974	bfd * abfd,
		12975	bfd_boolean is_rela)
		12976	{
		12977	asection * reloc_sec = elf_section_data (sec)->sreloc;
		12978
		12979	if (reloc_sec == NULL)
		12980	{
		12981	const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
		12982
		12983	if (name == NULL)
		12984	return NULL;
		12985
		12986	reloc_sec = bfd_get_linker_section (dynobj, name);
		12987
		12988	if (reloc_sec == NULL)
		12989	{
		12990	flagword flags = (SEC_HAS_CONTENTS \| SEC_READONLY
		12991	\| SEC_IN_MEMORY \| SEC_LINKER_CREATED);
		12992	if ((sec->flags & SEC_ALLOC) != 0)
		12993	flags \|= SEC_ALLOC \| SEC_LOAD;
		12994
		12995	reloc_sec = bfd_make_section_anyway_with_flags (dynobj, name, flags);
		12996	if (reloc_sec != NULL)
		12997	{
		12998	/* _bfd_elf_get_sec_type_attr chooses a section type by
		12999	name. Override as it may be wrong, eg. for a user
		13000	section named "auto" we'll get ".relauto" which is
		13001	seen to be a .rela section. */
		13002	elf_section_type (reloc_sec) = is_rela ? SHT_RELA : SHT_REL;
		13003	if (! bfd_set_section_alignment (dynobj, reloc_sec, alignment))
		13004	reloc_sec = NULL;
		13005	}
		13006	}
		13007
		13008	elf_section_data (sec)->sreloc = reloc_sec;
		13009	}
		13010
		13011	return reloc_sec;
		13012	}
		13013
		13014	/* Copy the ELF symbol type associated with a linker hash entry. */
		13015	void
		13016	_bfd_elf_copy_link_hash_symbol_type (bfd *abfd ATTRIBUTE_UNUSED,
		13017	struct bfd_link_hash_entry * hdest,
		13018	struct bfd_link_hash_entry * hsrc)
		13019	{
		13020	struct elf_link_hash_entry ehdest = (struct elf_link_hash_entry )hdest;
		13021	struct elf_link_hash_entry ehsrc = (struct elf_link_hash_entry )hsrc;
		13022
		13023	ehdest->type = ehsrc->type;
		13024	ehdest->target_internal = ehsrc->target_internal;
		13025	}
		13026
		13027	/* Append a RELA relocation REL to section S in BFD. */
		13028
		13029	void
		13030	elf_append_rela (bfd abfd, asection s, Elf_Internal_Rela *rel)
		13031	{
		13032	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		13033	bfd_byte loc = s->contents + (s->reloc_count++ bed->s->sizeof_rela);
		13034	BFD_ASSERT (loc + bed->s->sizeof_rela <= s->contents + s->size);
		13035	bed->s->swap_reloca_out (abfd, rel, loc);
		13036	}
		13037
		13038	/* Append a REL relocation REL to section S in BFD. */
		13039
		13040	void
		13041	elf_append_rel (bfd abfd, asection s, Elf_Internal_Rela *rel)
		13042	{
		13043	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
		13044	bfd_byte loc = s->contents + (s->reloc_count++ bed->s->sizeof_rel);
		13045	BFD_ASSERT (loc + bed->s->sizeof_rel <= s->contents + s->size);
		13046	bed->s->swap_reloc_out (abfd, rel, loc);
		13047	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/bfd/elflink.c – Rev 5197