WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/ld/ldlang.c

Rev	Author	Line No.	Line
5199	serge	1	/* Linker command language support.
6324	serge	2	Copyright (C) 1991-2015 Free Software Foundation, Inc.
5199	serge	3
		4	This file is part of the GNU Binutils.
		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 "libiberty.h"
		24	#include "filenames.h"
		25	#include "safe-ctype.h"
		26	#include "obstack.h"
		27	#include "bfdlink.h"
		28
		29	#include "ld.h"
		30	#include "ldmain.h"
		31	#include "ldexp.h"
		32	#include "ldlang.h"
		33	#include
		34	#include "ldlex.h"
		35	#include "ldmisc.h"
		36	#include "ldctor.h"
		37	#include "ldfile.h"
		38	#include "ldemul.h"
		39	#include "fnmatch.h"
		40	#include "demangle.h"
		41	#include "hashtab.h"
		42	#include "libbfd.h"
6324	serge	43	#include "elf-bfd.h"
5199	serge	44	#ifdef ENABLE_PLUGINS
		45	#include "plugin.h"
		46	#endif /* ENABLE_PLUGINS */
		47
		48	#ifndef offsetof
		49	#define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
		50	#endif
		51
		52	/* Locals variables. */
		53	static struct obstack stat_obstack;
		54	static struct obstack map_obstack;
		55
		56	#define obstack_chunk_alloc xmalloc
		57	#define obstack_chunk_free free
		58	static const char *entry_symbol_default = "start";
		59	static bfd_boolean placed_commons = FALSE;
6324	serge	60	static bfd_boolean map_head_is_link_order = FALSE;
5199	serge	61	static lang_output_section_statement_type *default_common_section;
		62	static bfd_boolean map_option_f;
		63	static bfd_vma print_dot;
		64	static lang_input_statement_type *first_file;
		65	static const char *current_target;
		66	static lang_statement_list_type statement_list;
		67	static lang_statement_list_type *stat_save[10];
		68	static lang_statement_list_type **stat_save_ptr = &stat_save[0];
		69	static struct unique_sections *unique_section_list;
6324	serge	70	static struct asneeded_minfo *asneeded_list_head;
5199	serge	71
		72	/* Forward declarations. */
		73	static void exp_init_os (etree_type *);
		74	static lang_input_statement_type lookup_name (const char );
		75	static void insert_undefined (const char *);
		76	static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry , void );
		77	static void print_statement (lang_statement_union_type *,
		78	lang_output_section_statement_type *);
		79	static void print_statement_list (lang_statement_union_type *,
		80	lang_output_section_statement_type *);
		81	static void print_statements (void);
		82	static void print_input_section (asection *, bfd_boolean);
		83	static bfd_boolean lang_one_common (struct bfd_link_hash_entry , void );
		84	static void lang_record_phdrs (void);
		85	static void lang_do_version_exports_section (void);
		86	static void lang_finalize_version_expr_head
		87	(struct bfd_elf_version_expr_head *);
6324	serge	88	static void lang_do_memory_regions (void);
5199	serge	89
		90	/* Exported variables. */
		91	const char *output_target;
		92	lang_output_section_statement_type *abs_output_section;
		93	lang_statement_list_type lang_output_section_statement;
		94	lang_statement_list_type *stat_ptr = &statement_list;
		95	lang_statement_list_type file_chain = { NULL, NULL };
		96	lang_statement_list_type input_file_chain;
		97	struct bfd_sym_chain entry_symbol = { NULL, NULL };
		98	const char *entry_section = ".text";
		99	struct lang_input_statement_flags input_flags;
		100	bfd_boolean entry_from_cmdline;
		101	bfd_boolean undef_from_cmdline;
		102	bfd_boolean lang_has_input_file = FALSE;
		103	bfd_boolean had_output_filename = FALSE;
		104	bfd_boolean lang_float_flag = FALSE;
		105	bfd_boolean delete_output_file_on_failure = FALSE;
		106	struct lang_phdr *lang_phdr_list;
		107	struct lang_nocrossrefs *nocrossref_list;
6324	serge	108	struct asneeded_minfo **asneeded_list_tail;
5199	serge	109
		110	/* Functions that traverse the linker script and might evaluate
6324	serge	111	DEFINED() need to increment this at the start of the traversal. */
5199	serge	112	int lang_statement_iteration = 0;
		113
		114	/* Return TRUE if the PATTERN argument is a wildcard pattern.
		115	Although backslashes are treated specially if a pattern contains
		116	wildcards, we do not consider the mere presence of a backslash to
		117	be enough to cause the pattern to be treated as a wildcard.
		118	That lets us handle DOS filenames more naturally. */
		119	#define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
		120
		121	#define new_stat(x, y) \
		122	(x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
		123
		124	#define outside_section_address(q) \
		125	((q)->output_offset + (q)->output_section->vma)
		126
		127	#define outside_symbol_address(q) \
		128	((q)->value + outside_section_address (q->section))
		129
		130	#define SECTION_NAME_MAP_LENGTH (16)
		131
		132	void *
		133	stat_alloc (size_t size)
		134	{
		135	return obstack_alloc (&stat_obstack, size);
		136	}
		137
		138	static int
		139	name_match (const char pattern, const char name)
		140	{
		141	if (wildcardp (pattern))
		142	return fnmatch (pattern, name, 0);
		143	return strcmp (pattern, name);
		144	}
		145
		146	/* If PATTERN is of the form archive:file, return a pointer to the
		147	separator. If not, return NULL. */
		148
		149	static char *
		150	archive_path (const char *pattern)
		151	{
		152	char *p = NULL;
		153
		154	if (link_info.path_separator == 0)
		155	return p;
		156
		157	p = strchr (pattern, link_info.path_separator);
		158	#ifdef HAVE_DOS_BASED_FILE_SYSTEM
		159	if (p == NULL \|\| link_info.path_separator != ':')
		160	return p;
		161
		162	/* Assume a match on the second char is part of drive specifier,
		163	as in "c:\silly.dos". */
		164	if (p == pattern + 1 && ISALPHA (*pattern))
		165	p = strchr (p + 1, link_info.path_separator);
		166	#endif
		167	return p;
		168	}
		169
		170	/* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
		171	return whether F matches FILE_SPEC. */
		172
		173	static bfd_boolean
		174	input_statement_is_archive_path (const char file_spec, char sep,
		175	lang_input_statement_type *f)
		176	{
		177	bfd_boolean match = FALSE;
		178
		179	if ((*(sep + 1) == 0
		180	\|\| name_match (sep + 1, f->filename) == 0)
		181	&& ((sep != file_spec)
		182	== (f->the_bfd != NULL && f->the_bfd->my_archive != NULL)))
		183	{
		184	match = TRUE;
		185
		186	if (sep != file_spec)
		187	{
		188	const char *aname = f->the_bfd->my_archive->filename;
		189	*sep = 0;
		190	match = name_match (file_spec, aname) == 0;
		191	*sep = link_info.path_separator;
		192	}
		193	}
		194	return match;
		195	}
		196
		197	static bfd_boolean
		198	unique_section_p (const asection *sec,
		199	const lang_output_section_statement_type *os)
		200	{
		201	struct unique_sections *unam;
		202	const char *secnam;
		203
6324	serge	204	if (bfd_link_relocatable (&link_info)
5199	serge	205	&& sec->owner != NULL
		206	&& bfd_is_group_section (sec->owner, sec))
		207	return !(os != NULL
		208	&& strcmp (os->name, DISCARD_SECTION_NAME) == 0);
		209
		210	secnam = sec->name;
		211	for (unam = unique_section_list; unam; unam = unam->next)
		212	if (name_match (unam->name, secnam) == 0)
		213	return TRUE;
		214
		215	return FALSE;
		216	}
		217
		218	/* Generic traversal routines for finding matching sections. */
		219
		220	/* Try processing a section against a wildcard. This just calls
		221	the callback unless the filename exclusion list is present
		222	and excludes the file. It's hardly ever present so this
		223	function is very fast. */
		224
		225	static void
		226	walk_wild_consider_section (lang_wild_statement_type *ptr,
		227	lang_input_statement_type *file,
		228	asection *s,
		229	struct wildcard_list *sec,
		230	callback_t callback,
		231	void *data)
		232	{
		233	struct name_list *list_tmp;
		234
		235	/* Don't process sections from files which were excluded. */
		236	for (list_tmp = sec->spec.exclude_name_list;
		237	list_tmp;
		238	list_tmp = list_tmp->next)
		239	{
		240	char *p = archive_path (list_tmp->name);
		241
		242	if (p != NULL)
		243	{
		244	if (input_statement_is_archive_path (list_tmp->name, p, file))
		245	return;
		246	}
		247
		248	else if (name_match (list_tmp->name, file->filename) == 0)
		249	return;
		250
		251	/* FIXME: Perhaps remove the following at some stage? Matching
		252	unadorned archives like this was never documented and has
		253	been superceded by the archive:path syntax. */
		254	else if (file->the_bfd != NULL
		255	&& file->the_bfd->my_archive != NULL
		256	&& name_match (list_tmp->name,
		257	file->the_bfd->my_archive->filename) == 0)
		258	return;
		259	}
		260
		261	(*callback) (ptr, sec, s, ptr->section_flag_list, file, data);
		262	}
		263
		264	/* Lowest common denominator routine that can handle everything correctly,
		265	but slowly. */
		266
		267	static void
		268	walk_wild_section_general (lang_wild_statement_type *ptr,
		269	lang_input_statement_type *file,
		270	callback_t callback,
		271	void *data)
		272	{
		273	asection *s;
		274	struct wildcard_list *sec;
		275
		276	for (s = file->the_bfd->sections; s != NULL; s = s->next)
		277	{
		278	sec = ptr->section_list;
		279	if (sec == NULL)
		280	(*callback) (ptr, sec, s, ptr->section_flag_list, file, data);
		281
		282	while (sec != NULL)
		283	{
		284	bfd_boolean skip = FALSE;
		285
		286	if (sec->spec.name != NULL)
		287	{
		288	const char *sname = bfd_get_section_name (file->the_bfd, s);
		289
		290	skip = name_match (sec->spec.name, sname) != 0;
		291	}
		292
		293	if (!skip)
		294	walk_wild_consider_section (ptr, file, s, sec, callback, data);
		295
		296	sec = sec->next;
		297	}
		298	}
		299	}
		300
		301	/* Routines to find a single section given its name. If there's more
		302	than one section with that name, we report that. */
		303
		304	typedef struct
		305	{
		306	asection *found_section;
		307	bfd_boolean multiple_sections_found;
		308	} section_iterator_callback_data;
		309
		310	static bfd_boolean
		311	section_iterator_callback (bfd abfd ATTRIBUTE_UNUSED, asection s, void *data)
		312	{
		313	section_iterator_callback_data d = (section_iterator_callback_data ) data;
		314
		315	if (d->found_section != NULL)
		316	{
		317	d->multiple_sections_found = TRUE;
		318	return TRUE;
		319	}
		320
		321	d->found_section = s;
		322	return FALSE;
		323	}
		324
		325	static asection *
		326	find_section (lang_input_statement_type *file,
		327	struct wildcard_list *sec,
		328	bfd_boolean *multiple_sections_found)
		329	{
		330	section_iterator_callback_data cb_data = { NULL, FALSE };
		331
		332	bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
		333	section_iterator_callback, &cb_data);
		334	*multiple_sections_found = cb_data.multiple_sections_found;
		335	return cb_data.found_section;
		336	}
		337
		338	/* Code for handling simple wildcards without going through fnmatch,
		339	which can be expensive because of charset translations etc. */
		340
		341	/* A simple wild is a literal string followed by a single '*',
		342	where the literal part is at least 4 characters long. */
		343
		344	static bfd_boolean
		345	is_simple_wild (const char *name)
		346	{
		347	size_t len = strcspn (name, "*?[");
		348	return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
		349	}
		350
		351	static bfd_boolean
		352	match_simple_wild (const char pattern, const char name)
		353	{
		354	/* The first four characters of the pattern are guaranteed valid
		355	non-wildcard characters. So we can go faster. */
		356	if (pattern[0] != name[0] \|\| pattern[1] != name[1]
		357	\|\| pattern[2] != name[2] \|\| pattern[3] != name[3])
		358	return FALSE;
		359
		360	pattern += 4;
		361	name += 4;
		362	while (pattern != '')
		363	if (name++ != pattern++)
		364	return FALSE;
		365
		366	return TRUE;
		367	}
		368
		369	/* Return the numerical value of the init_priority attribute from
		370	section name NAME. */
		371
		372	static unsigned long
		373	get_init_priority (const char *name)
		374	{
		375	char *end;
		376	unsigned long init_priority;
		377
		378	/* GCC uses the following section names for the init_priority
		379	attribute with numerical values 101 and 65535 inclusive. A
		380	lower value means a higher priority.
		381
		382	1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
		383	decimal numerical value of the init_priority attribute.
		384	The order of execution in .init_array is forward and
		385	.fini_array is backward.
		386	2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the
		387	decimal numerical value of the init_priority attribute.
		388	The order of execution in .ctors is backward and .dtors
		389	is forward.
		390	*/
		391	if (strncmp (name, ".init_array.", 12) == 0
		392	\|\| strncmp (name, ".fini_array.", 12) == 0)
		393	{
		394	init_priority = strtoul (name + 12, &end, 10);
		395	return *end ? 0 : init_priority;
		396	}
		397	else if (strncmp (name, ".ctors.", 7) == 0
		398	\|\| strncmp (name, ".dtors.", 7) == 0)
		399	{
		400	init_priority = strtoul (name + 7, &end, 10);
		401	return *end ? 0 : 65535 - init_priority;
		402	}
		403
		404	return 0;
		405	}
		406
		407	/* Compare sections ASEC and BSEC according to SORT. */
		408
		409	static int
		410	compare_section (sort_type sort, asection asec, asection bsec)
		411	{
		412	int ret;
		413	unsigned long ainit_priority, binit_priority;
		414
		415	switch (sort)
		416	{
		417	default:
		418	abort ();
		419
		420	case by_init_priority:
		421	ainit_priority
		422	= get_init_priority (bfd_get_section_name (asec->owner, asec));
		423	binit_priority
		424	= get_init_priority (bfd_get_section_name (bsec->owner, bsec));
		425	if (ainit_priority == 0 \|\| binit_priority == 0)
		426	goto sort_by_name;
		427	ret = ainit_priority - binit_priority;
		428	if (ret)
		429	break;
		430	else
		431	goto sort_by_name;
		432
		433	case by_alignment_name:
		434	ret = (bfd_section_alignment (bsec->owner, bsec)
		435	- bfd_section_alignment (asec->owner, asec));
		436	if (ret)
		437	break;
		438	/* Fall through. */
		439
		440	case by_name:
		441	sort_by_name:
		442	ret = strcmp (bfd_get_section_name (asec->owner, asec),
		443	bfd_get_section_name (bsec->owner, bsec));
		444	break;
		445
		446	case by_name_alignment:
		447	ret = strcmp (bfd_get_section_name (asec->owner, asec),
		448	bfd_get_section_name (bsec->owner, bsec));
		449	if (ret)
		450	break;
		451	/* Fall through. */
		452
		453	case by_alignment:
		454	ret = (bfd_section_alignment (bsec->owner, bsec)
		455	- bfd_section_alignment (asec->owner, asec));
		456	break;
		457	}
		458
		459	return ret;
		460	}
		461
		462	/* Build a Binary Search Tree to sort sections, unlike insertion sort
		463	used in wild_sort(). BST is considerably faster if the number of
		464	of sections are large. */
		465
		466	static lang_section_bst_type **
		467	wild_sort_fast (lang_wild_statement_type *wild,
		468	struct wildcard_list *sec,
		469	lang_input_statement_type *file ATTRIBUTE_UNUSED,
		470	asection *section)
		471	{
		472	lang_section_bst_type **tree;
		473
		474	tree = &wild->tree;
		475	if (!wild->filenames_sorted
		476	&& (sec == NULL \|\| sec->spec.sorted == none))
		477	{
		478	/* Append at the right end of tree. */
		479	while (*tree)
		480	tree = &((*tree)->right);
		481	return tree;
		482	}
		483
		484	while (*tree)
		485	{
		486	/* Find the correct node to append this section. */
		487	if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
		488	tree = &((*tree)->left);
		489	else
		490	tree = &((*tree)->right);
		491	}
		492
		493	return tree;
		494	}
		495
		496	/* Use wild_sort_fast to build a BST to sort sections. */
		497
		498	static void
		499	output_section_callback_fast (lang_wild_statement_type *ptr,
		500	struct wildcard_list *sec,
		501	asection *section,
		502	struct flag_info *sflag_list ATTRIBUTE_UNUSED,
		503	lang_input_statement_type *file,
		504	void *output)
		505	{
		506	lang_section_bst_type *node;
		507	lang_section_bst_type **tree;
		508	lang_output_section_statement_type *os;
		509
		510	os = (lang_output_section_statement_type *) output;
		511
		512	if (unique_section_p (section, os))
		513	return;
		514
		515	node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type));
		516	node->left = 0;
		517	node->right = 0;
		518	node->section = section;
		519
		520	tree = wild_sort_fast (ptr, sec, file, section);
		521	if (tree != NULL)
		522	*tree = node;
		523	}
		524
		525	/* Convert a sorted sections' BST back to list form. */
		526
		527	static void
		528	output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
		529	lang_section_bst_type *tree,
		530	void *output)
		531	{
		532	if (tree->left)
		533	output_section_callback_tree_to_list (ptr, tree->left, output);
		534
		535	lang_add_section (&ptr->children, tree->section, NULL,
		536	(lang_output_section_statement_type *) output);
		537
		538	if (tree->right)
		539	output_section_callback_tree_to_list (ptr, tree->right, output);
		540
		541	free (tree);
		542	}
		543
		544	/* Specialized, optimized routines for handling different kinds of
		545	wildcards */
		546
		547	static void
		548	walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
		549	lang_input_statement_type *file,
		550	callback_t callback,
		551	void *data)
		552	{
		553	/* We can just do a hash lookup for the section with the right name.
		554	But if that lookup discovers more than one section with the name
		555	(should be rare), we fall back to the general algorithm because
		556	we would otherwise have to sort the sections to make sure they
		557	get processed in the bfd's order. */
		558	bfd_boolean multiple_sections_found;
		559	struct wildcard_list *sec0 = ptr->handler_data[0];
		560	asection *s0 = find_section (file, sec0, &multiple_sections_found);
		561
		562	if (multiple_sections_found)
		563	walk_wild_section_general (ptr, file, callback, data);
		564	else if (s0)
		565	walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
		566	}
		567
		568	static void
		569	walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
		570	lang_input_statement_type *file,
		571	callback_t callback,
		572	void *data)
		573	{
		574	asection *s;
		575	struct wildcard_list *wildsec0 = ptr->handler_data[0];
		576
		577	for (s = file->the_bfd->sections; s != NULL; s = s->next)
		578	{
		579	const char *sname = bfd_get_section_name (file->the_bfd, s);
		580	bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
		581
		582	if (!skip)
		583	walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
		584	}
		585	}
		586
		587	static void
		588	walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
		589	lang_input_statement_type *file,
		590	callback_t callback,
		591	void *data)
		592	{
		593	asection *s;
		594	struct wildcard_list *sec0 = ptr->handler_data[0];
		595	struct wildcard_list *wildsec1 = ptr->handler_data[1];
		596	bfd_boolean multiple_sections_found;
		597	asection *s0 = find_section (file, sec0, &multiple_sections_found);
		598
		599	if (multiple_sections_found)
		600	{
		601	walk_wild_section_general (ptr, file, callback, data);
		602	return;
		603	}
		604
		605	/* Note that if the section was not found, s0 is NULL and
		606	we'll simply never succeed the s == s0 test below. */
		607	for (s = file->the_bfd->sections; s != NULL; s = s->next)
		608	{
		609	/* Recall that in this code path, a section cannot satisfy more
		610	than one spec, so if s == s0 then it cannot match
		611	wildspec1. */
		612	if (s == s0)
		613	walk_wild_consider_section (ptr, file, s, sec0, callback, data);
		614	else
		615	{
		616	const char *sname = bfd_get_section_name (file->the_bfd, s);
		617	bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
		618
		619	if (!skip)
		620	walk_wild_consider_section (ptr, file, s, wildsec1, callback,
		621	data);
		622	}
		623	}
		624	}
		625
		626	static void
		627	walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
		628	lang_input_statement_type *file,
		629	callback_t callback,
		630	void *data)
		631	{
		632	asection *s;
		633	struct wildcard_list *sec0 = ptr->handler_data[0];
		634	struct wildcard_list *wildsec1 = ptr->handler_data[1];
		635	struct wildcard_list *wildsec2 = ptr->handler_data[2];
		636	bfd_boolean multiple_sections_found;
		637	asection *s0 = find_section (file, sec0, &multiple_sections_found);
		638
		639	if (multiple_sections_found)
		640	{
		641	walk_wild_section_general (ptr, file, callback, data);
		642	return;
		643	}
		644
		645	for (s = file->the_bfd->sections; s != NULL; s = s->next)
		646	{
		647	if (s == s0)
		648	walk_wild_consider_section (ptr, file, s, sec0, callback, data);
		649	else
		650	{
		651	const char *sname = bfd_get_section_name (file->the_bfd, s);
		652	bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
		653
		654	if (!skip)
		655	walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
		656	else
		657	{
		658	skip = !match_simple_wild (wildsec2->spec.name, sname);
		659	if (!skip)
		660	walk_wild_consider_section (ptr, file, s, wildsec2, callback,
		661	data);
		662	}
		663	}
		664	}
		665	}
		666
		667	static void
		668	walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
		669	lang_input_statement_type *file,
		670	callback_t callback,
		671	void *data)
		672	{
		673	asection *s;
		674	struct wildcard_list *sec0 = ptr->handler_data[0];
		675	struct wildcard_list *sec1 = ptr->handler_data[1];
		676	struct wildcard_list *wildsec2 = ptr->handler_data[2];
		677	struct wildcard_list *wildsec3 = ptr->handler_data[3];
		678	bfd_boolean multiple_sections_found;
		679	asection s0 = find_section (file, sec0, &multiple_sections_found), s1;
		680
		681	if (multiple_sections_found)
		682	{
		683	walk_wild_section_general (ptr, file, callback, data);
		684	return;
		685	}
		686
		687	s1 = find_section (file, sec1, &multiple_sections_found);
		688	if (multiple_sections_found)
		689	{
		690	walk_wild_section_general (ptr, file, callback, data);
		691	return;
		692	}
		693
		694	for (s = file->the_bfd->sections; s != NULL; s = s->next)
		695	{
		696	if (s == s0)
		697	walk_wild_consider_section (ptr, file, s, sec0, callback, data);
		698	else
		699	if (s == s1)
		700	walk_wild_consider_section (ptr, file, s, sec1, callback, data);
		701	else
		702	{
		703	const char *sname = bfd_get_section_name (file->the_bfd, s);
		704	bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
		705	sname);
		706
		707	if (!skip)
		708	walk_wild_consider_section (ptr, file, s, wildsec2, callback,
		709	data);
		710	else
		711	{
		712	skip = !match_simple_wild (wildsec3->spec.name, sname);
		713	if (!skip)
		714	walk_wild_consider_section (ptr, file, s, wildsec3,
		715	callback, data);
		716	}
		717	}
		718	}
		719	}
		720
		721	static void
		722	walk_wild_section (lang_wild_statement_type *ptr,
		723	lang_input_statement_type *file,
		724	callback_t callback,
		725	void *data)
		726	{
		727	if (file->flags.just_syms)
		728	return;
		729
		730	(*ptr->walk_wild_section_handler) (ptr, file, callback, data);
		731	}
		732
		733	/* Returns TRUE when name1 is a wildcard spec that might match
		734	something name2 can match. We're conservative: we return FALSE
		735	only if the prefixes of name1 and name2 are different up to the
		736	first wildcard character. */
		737
		738	static bfd_boolean
		739	wild_spec_can_overlap (const char name1, const char name2)
		740	{
		741	size_t prefix1_len = strcspn (name1, "?*[");
		742	size_t prefix2_len = strcspn (name2, "?*[");
		743	size_t min_prefix_len;
		744
		745	/* Note that if there is no wildcard character, then we treat the
		746	terminating 0 as part of the prefix. Thus ".text" won't match
		747	".text." or ".text.", for example. /
		748	if (name1[prefix1_len] == '\0')
		749	prefix1_len++;
		750	if (name2[prefix2_len] == '\0')
		751	prefix2_len++;
		752
		753	min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
		754
		755	return memcmp (name1, name2, min_prefix_len) == 0;
		756	}
		757
		758	/* Select specialized code to handle various kinds of wildcard
		759	statements. */
		760
		761	static void
		762	analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
		763	{
		764	int sec_count = 0;
		765	int wild_name_count = 0;
		766	struct wildcard_list *sec;
		767	int signature;
		768	int data_counter;
		769
		770	ptr->walk_wild_section_handler = walk_wild_section_general;
		771	ptr->handler_data[0] = NULL;
		772	ptr->handler_data[1] = NULL;
		773	ptr->handler_data[2] = NULL;
		774	ptr->handler_data[3] = NULL;
		775	ptr->tree = NULL;
		776
		777	/* Count how many wildcard_specs there are, and how many of those
		778	actually use wildcards in the name. Also, bail out if any of the
		779	wildcard names are NULL. (Can this actually happen?
		780	walk_wild_section used to test for it.) And bail out if any
		781	of the wildcards are more complex than a simple string
		782	ending in a single ''. /
		783	for (sec = ptr->section_list; sec != NULL; sec = sec->next)
		784	{
		785	++sec_count;
		786	if (sec->spec.name == NULL)
		787	return;
		788	if (wildcardp (sec->spec.name))
		789	{
		790	++wild_name_count;
		791	if (!is_simple_wild (sec->spec.name))
		792	return;
		793	}
		794	}
		795
		796	/* The zero-spec case would be easy to optimize but it doesn't
		797	happen in practice. Likewise, more than 4 specs doesn't
		798	happen in practice. */
		799	if (sec_count == 0 \|\| sec_count > 4)
		800	return;
		801
		802	/* Check that no two specs can match the same section. */
		803	for (sec = ptr->section_list; sec != NULL; sec = sec->next)
		804	{
		805	struct wildcard_list *sec2;
		806	for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
		807	{
		808	if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
		809	return;
		810	}
		811	}
		812
		813	signature = (sec_count << 8) + wild_name_count;
		814	switch (signature)
		815	{
		816	case 0x0100:
		817	ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
		818	break;
		819	case 0x0101:
		820	ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
		821	break;
		822	case 0x0201:
		823	ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
		824	break;
		825	case 0x0302:
		826	ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
		827	break;
		828	case 0x0402:
		829	ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
		830	break;
		831	default:
		832	return;
		833	}
		834
		835	/* Now fill the data array with pointers to the specs, first the
		836	specs with non-wildcard names, then the specs with wildcard
		837	names. It's OK to process the specs in different order from the
		838	given order, because we've already determined that no section
		839	will match more than one spec. */
		840	data_counter = 0;
		841	for (sec = ptr->section_list; sec != NULL; sec = sec->next)
		842	if (!wildcardp (sec->spec.name))
		843	ptr->handler_data[data_counter++] = sec;
		844	for (sec = ptr->section_list; sec != NULL; sec = sec->next)
		845	if (wildcardp (sec->spec.name))
		846	ptr->handler_data[data_counter++] = sec;
		847	}
		848
		849	/* Handle a wild statement for a single file F. */
		850
		851	static void
		852	walk_wild_file (lang_wild_statement_type *s,
		853	lang_input_statement_type *f,
		854	callback_t callback,
		855	void *data)
		856	{
		857	if (f->the_bfd == NULL
		858	\|\| ! bfd_check_format (f->the_bfd, bfd_archive))
		859	walk_wild_section (s, f, callback, data);
		860	else
		861	{
		862	bfd *member;
		863
		864	/* This is an archive file. We must map each member of the
		865	archive separately. */
		866	member = bfd_openr_next_archived_file (f->the_bfd, NULL);
		867	while (member != NULL)
		868	{
		869	/* When lookup_name is called, it will call the add_symbols
		870	entry point for the archive. For each element of the
		871	archive which is included, BFD will call ldlang_add_file,
		872	which will set the usrdata field of the member to the
		873	lang_input_statement. */
		874	if (member->usrdata != NULL)
		875	{
		876	walk_wild_section (s,
		877	(lang_input_statement_type *) member->usrdata,
		878	callback, data);
		879	}
		880
		881	member = bfd_openr_next_archived_file (f->the_bfd, member);
		882	}
		883	}
		884	}
		885
		886	static void
		887	walk_wild (lang_wild_statement_type s, callback_t callback, void data)
		888	{
		889	const char *file_spec = s->filename;
		890	char *p;
		891
		892	if (file_spec == NULL)
		893	{
		894	/* Perform the iteration over all files in the list. */
		895	LANG_FOR_EACH_INPUT_STATEMENT (f)
		896	{
		897	walk_wild_file (s, f, callback, data);
		898	}
		899	}
		900	else if ((p = archive_path (file_spec)) != NULL)
		901	{
		902	LANG_FOR_EACH_INPUT_STATEMENT (f)
		903	{
		904	if (input_statement_is_archive_path (file_spec, p, f))
		905	walk_wild_file (s, f, callback, data);
		906	}
		907	}
		908	else if (wildcardp (file_spec))
		909	{
		910	LANG_FOR_EACH_INPUT_STATEMENT (f)
		911	{
		912	if (fnmatch (file_spec, f->filename, 0) == 0)
		913	walk_wild_file (s, f, callback, data);
		914	}
		915	}
		916	else
		917	{
		918	lang_input_statement_type *f;
		919
		920	/* Perform the iteration over a single file. */
		921	f = lookup_name (file_spec);
		922	if (f)
		923	walk_wild_file (s, f, callback, data);
		924	}
		925	}
		926
		927	/* lang_for_each_statement walks the parse tree and calls the provided
		928	function for each node, except those inside output section statements
		929	with constraint set to -1. */
		930
		931	void
		932	lang_for_each_statement_worker (void (func) (lang_statement_union_type ),
		933	lang_statement_union_type *s)
		934	{
		935	for (; s != NULL; s = s->header.next)
		936	{
		937	func (s);
		938
		939	switch (s->header.type)
		940	{
		941	case lang_constructors_statement_enum:
		942	lang_for_each_statement_worker (func, constructor_list.head);
		943	break;
		944	case lang_output_section_statement_enum:
		945	if (s->output_section_statement.constraint != -1)
		946	lang_for_each_statement_worker
		947	(func, s->output_section_statement.children.head);
		948	break;
		949	case lang_wild_statement_enum:
		950	lang_for_each_statement_worker (func,
		951	s->wild_statement.children.head);
		952	break;
		953	case lang_group_statement_enum:
		954	lang_for_each_statement_worker (func,
		955	s->group_statement.children.head);
		956	break;
		957	case lang_data_statement_enum:
		958	case lang_reloc_statement_enum:
		959	case lang_object_symbols_statement_enum:
		960	case lang_output_statement_enum:
		961	case lang_target_statement_enum:
		962	case lang_input_section_enum:
		963	case lang_input_statement_enum:
		964	case lang_assignment_statement_enum:
		965	case lang_padding_statement_enum:
		966	case lang_address_statement_enum:
		967	case lang_fill_statement_enum:
		968	case lang_insert_statement_enum:
		969	break;
		970	default:
		971	FAIL ();
		972	break;
		973	}
		974	}
		975	}
		976
		977	void
		978	lang_for_each_statement (void (func) (lang_statement_union_type ))
		979	{
		980	lang_for_each_statement_worker (func, statement_list.head);
		981	}
		982
		983	/----------------------------------------------------------------------/
		984
		985	void
		986	lang_list_init (lang_statement_list_type *list)
		987	{
		988	list->head = NULL;
		989	list->tail = &list->head;
		990	}
		991
		992	void
		993	push_stat_ptr (lang_statement_list_type *new_ptr)
		994	{
		995	if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0]))
		996	abort ();
		997	*stat_save_ptr++ = stat_ptr;
		998	stat_ptr = new_ptr;
		999	}
		1000
		1001	void
		1002	pop_stat_ptr (void)
		1003	{
		1004	if (stat_save_ptr <= stat_save)
		1005	abort ();
		1006	stat_ptr = *--stat_save_ptr;
		1007	}
		1008
		1009	/* Build a new statement node for the parse tree. */
		1010
		1011	static lang_statement_union_type *
		1012	new_statement (enum statement_enum type,
		1013	size_t size,
		1014	lang_statement_list_type *list)
		1015	{
		1016	lang_statement_union_type *new_stmt;
		1017
		1018	new_stmt = (lang_statement_union_type *) stat_alloc (size);
		1019	new_stmt->header.type = type;
		1020	new_stmt->header.next = NULL;
		1021	lang_statement_append (list, new_stmt, &new_stmt->header.next);
		1022	return new_stmt;
		1023	}
		1024
		1025	/* Build a new input file node for the language. There are several
		1026	ways in which we treat an input file, eg, we only look at symbols,
		1027	or prefix it with a -l etc.
		1028
		1029	We can be supplied with requests for input files more than once;
		1030	they may, for example be split over several lines like foo.o(.text)
		1031	foo.o(.data) etc, so when asked for a file we check that we haven't
		1032	got it already so we don't duplicate the bfd. */
		1033
		1034	static lang_input_statement_type *
		1035	new_afile (const char *name,
		1036	lang_input_file_enum_type file_type,
		1037	const char *target,
		1038	bfd_boolean add_to_list)
		1039	{
		1040	lang_input_statement_type *p;
		1041
		1042	lang_has_input_file = TRUE;
		1043
		1044	if (add_to_list)
		1045	p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr);
		1046	else
		1047	{
		1048	p = (lang_input_statement_type *)
		1049	stat_alloc (sizeof (lang_input_statement_type));
		1050	p->header.type = lang_input_statement_enum;
		1051	p->header.next = NULL;
		1052	}
		1053
		1054	memset (&p->the_bfd, 0,
		1055	sizeof (*p) - offsetof (lang_input_statement_type, the_bfd));
		1056	p->target = target;
		1057	p->flags.dynamic = input_flags.dynamic;
		1058	p->flags.add_DT_NEEDED_for_dynamic = input_flags.add_DT_NEEDED_for_dynamic;
		1059	p->flags.add_DT_NEEDED_for_regular = input_flags.add_DT_NEEDED_for_regular;
		1060	p->flags.whole_archive = input_flags.whole_archive;
		1061	p->flags.sysrooted = input_flags.sysrooted;
		1062
		1063	switch (file_type)
		1064	{
		1065	case lang_input_file_is_symbols_only_enum:
		1066	p->filename = name;
		1067	p->local_sym_name = name;
		1068	p->flags.real = TRUE;
		1069	p->flags.just_syms = TRUE;
		1070	break;
		1071	case lang_input_file_is_fake_enum:
		1072	p->filename = name;
		1073	p->local_sym_name = name;
		1074	break;
		1075	case lang_input_file_is_l_enum:
6324	serge	1076	if (name[0] == ':' && name[1] != '\0')
		1077	{
		1078	p->filename = name + 1;
		1079	p->flags.full_name_provided = TRUE;
		1080	}
		1081	else
5199	serge	1082	p->filename = name;
		1083	p->local_sym_name = concat ("-l", name, (const char *) NULL);
		1084	p->flags.maybe_archive = TRUE;
		1085	p->flags.real = TRUE;
		1086	p->flags.search_dirs = TRUE;
		1087	break;
		1088	case lang_input_file_is_marker_enum:
		1089	p->filename = name;
		1090	p->local_sym_name = name;
		1091	p->flags.search_dirs = TRUE;
		1092	break;
		1093	case lang_input_file_is_search_file_enum:
		1094	p->filename = name;
		1095	p->local_sym_name = name;
		1096	p->flags.real = TRUE;
		1097	p->flags.search_dirs = TRUE;
		1098	break;
		1099	case lang_input_file_is_file_enum:
		1100	p->filename = name;
		1101	p->local_sym_name = name;
		1102	p->flags.real = TRUE;
		1103	break;
		1104	default:
		1105	FAIL ();
		1106	}
		1107
		1108	lang_statement_append (&input_file_chain,
		1109	(lang_statement_union_type *) p,
		1110	&p->next_real_file);
		1111	return p;
		1112	}
		1113
		1114	lang_input_statement_type *
		1115	lang_add_input_file (const char *name,
		1116	lang_input_file_enum_type file_type,
		1117	const char *target)
		1118	{
6324	serge	1119	if (name != NULL && *name == '=')
		1120	{
		1121	lang_input_statement_type *ret;
		1122	char *sysrooted_name
		1123	= concat (ld_sysroot, name + 1, (const char *) NULL);
		1124
		1125	/* We've now forcibly prepended the sysroot, making the input
		1126	file independent of the context. Therefore, temporarily
		1127	force a non-sysrooted context for this statement, so it won't
		1128	get the sysroot prepended again when opened. (N.B. if it's a
		1129	script, any child nodes with input files starting with "/"
		1130	will be handled as "sysrooted" as they'll be found to be
		1131	within the sysroot subdirectory.) */
		1132	unsigned int outer_sysrooted = input_flags.sysrooted;
		1133	input_flags.sysrooted = 0;
		1134	ret = new_afile (sysrooted_name, file_type, target, TRUE);
		1135	input_flags.sysrooted = outer_sysrooted;
		1136	return ret;
		1137	}
		1138
5199	serge	1139	return new_afile (name, file_type, target, TRUE);
		1140	}
		1141
		1142	struct out_section_hash_entry
		1143	{
		1144	struct bfd_hash_entry root;
		1145	lang_statement_union_type s;
		1146	};
		1147
		1148	/* The hash table. */
		1149
		1150	static struct bfd_hash_table output_section_statement_table;
		1151
		1152	/* Support routines for the hash table used by lang_output_section_find,
		1153	initialize the table, fill in an entry and remove the table. */
		1154
		1155	static struct bfd_hash_entry *
		1156	output_section_statement_newfunc (struct bfd_hash_entry *entry,
		1157	struct bfd_hash_table *table,
		1158	const char *string)
		1159	{
		1160	lang_output_section_statement_type **nextp;
		1161	struct out_section_hash_entry *ret;
		1162
		1163	if (entry == NULL)
		1164	{
		1165	entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,
		1166	sizeof (*ret));
		1167	if (entry == NULL)
		1168	return entry;
		1169	}
		1170
		1171	entry = bfd_hash_newfunc (entry, table, string);
		1172	if (entry == NULL)
		1173	return entry;
		1174
		1175	ret = (struct out_section_hash_entry *) entry;
		1176	memset (&ret->s, 0, sizeof (ret->s));
		1177	ret->s.header.type = lang_output_section_statement_enum;
		1178	ret->s.output_section_statement.subsection_alignment = -1;
		1179	ret->s.output_section_statement.section_alignment = -1;
		1180	ret->s.output_section_statement.block_value = 1;
		1181	lang_list_init (&ret->s.output_section_statement.children);
		1182	lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
		1183
		1184	/* For every output section statement added to the list, except the
		1185	first one, lang_output_section_statement.tail points to the "next"
		1186	field of the last element of the list. */
		1187	if (lang_output_section_statement.head != NULL)
		1188	ret->s.output_section_statement.prev
		1189	= ((lang_output_section_statement_type *)
		1190	((char *) lang_output_section_statement.tail
		1191	- offsetof (lang_output_section_statement_type, next)));
		1192
		1193	/* GCC's strict aliasing rules prevent us from just casting the
		1194	address, so we store the pointer in a variable and cast that
		1195	instead. */
		1196	nextp = &ret->s.output_section_statement.next;
		1197	lang_statement_append (&lang_output_section_statement,
		1198	&ret->s,
		1199	(lang_statement_union_type **) nextp);
		1200	return &ret->root;
		1201	}
		1202
		1203	static void
		1204	output_section_statement_table_init (void)
		1205	{
		1206	if (!bfd_hash_table_init_n (&output_section_statement_table,
		1207	output_section_statement_newfunc,
		1208	sizeof (struct out_section_hash_entry),
		1209	61))
		1210	einfo (_("%P%F: can not create hash table: %E\n"));
		1211	}
		1212
		1213	static void
		1214	output_section_statement_table_free (void)
		1215	{
		1216	bfd_hash_table_free (&output_section_statement_table);
		1217	}
		1218
		1219	/* Build enough state so that the parser can build its tree. */
		1220
		1221	void
		1222	lang_init (void)
		1223	{
		1224	obstack_begin (&stat_obstack, 1000);
		1225
		1226	stat_ptr = &statement_list;
		1227
		1228	output_section_statement_table_init ();
		1229
		1230	lang_list_init (stat_ptr);
		1231
		1232	lang_list_init (&input_file_chain);
		1233	lang_list_init (&lang_output_section_statement);
		1234	lang_list_init (&file_chain);
		1235	first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
		1236	NULL);
		1237	abs_output_section =
		1238	lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);
		1239
		1240	abs_output_section->bfd_section = bfd_abs_section_ptr;
		1241
6324	serge	1242	asneeded_list_head = NULL;
		1243	asneeded_list_tail = &asneeded_list_head;
5199	serge	1244	}
		1245
		1246	void
		1247	lang_finish (void)
		1248	{
		1249	output_section_statement_table_free ();
		1250	}
		1251
		1252	/*----------------------------------------------------------------------
		1253	A region is an area of memory declared with the
		1254	MEMORY { name:org=exp, len=exp ... }
		1255	syntax.
		1256
		1257	We maintain a list of all the regions here.
		1258
		1259	If no regions are specified in the script, then the default is used
		1260	which is created when looked up to be the entire data space.
		1261
		1262	If create is true we are creating a region inside a MEMORY block.
		1263	In this case it is probably an error to create a region that has
		1264	already been created. If we are not inside a MEMORY block it is
		1265	dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
		1266	and so we issue a warning.
		1267
		1268	Each region has at least one name. The first name is either
		1269	DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
		1270	alias names to an existing region within a script with
		1271	REGION_ALIAS (alias, region_name). Each name corresponds to at most one
		1272	region. */
		1273
		1274	static lang_memory_region_type *lang_memory_region_list;
		1275	static lang_memory_region_type **lang_memory_region_list_tail
		1276	= &lang_memory_region_list;
		1277
		1278	lang_memory_region_type *
		1279	lang_memory_region_lookup (const char *const name, bfd_boolean create)
		1280	{
		1281	lang_memory_region_name *n;
		1282	lang_memory_region_type *r;
		1283	lang_memory_region_type *new_region;
		1284
		1285	/* NAME is NULL for LMA memspecs if no region was specified. */
		1286	if (name == NULL)
		1287	return NULL;
		1288
		1289	for (r = lang_memory_region_list; r != NULL; r = r->next)
		1290	for (n = &r->name_list; n != NULL; n = n->next)
		1291	if (strcmp (n->name, name) == 0)
		1292	{
		1293	if (create)
		1294	einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
		1295	NULL, name);
		1296	return r;
		1297	}
		1298
		1299	if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
		1300	einfo (_("%P:%S: warning: memory region `%s' not declared\n"),
		1301	NULL, name);
		1302
		1303	new_region = (lang_memory_region_type *)
		1304	stat_alloc (sizeof (lang_memory_region_type));
		1305
		1306	new_region->name_list.name = xstrdup (name);
		1307	new_region->name_list.next = NULL;
		1308	new_region->next = NULL;
6324	serge	1309	new_region->origin_exp = NULL;
5199	serge	1310	new_region->origin = 0;
6324	serge	1311	new_region->length_exp = NULL;
5199	serge	1312	new_region->length = ~(bfd_size_type) 0;
		1313	new_region->current = 0;
		1314	new_region->last_os = NULL;
		1315	new_region->flags = 0;
		1316	new_region->not_flags = 0;
		1317	new_region->had_full_message = FALSE;
		1318
		1319	*lang_memory_region_list_tail = new_region;
		1320	lang_memory_region_list_tail = &new_region->next;
		1321
		1322	return new_region;
		1323	}
		1324
		1325	void
		1326	lang_memory_region_alias (const char * alias, const char * region_name)
		1327	{
		1328	lang_memory_region_name * n;
		1329	lang_memory_region_type * r;
		1330	lang_memory_region_type * region;
		1331
		1332	/* The default region must be unique. This ensures that it is not necessary
		1333	to iterate through the name list if someone wants the check if a region is
		1334	the default memory region. */
		1335	if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0
		1336	\|\| strcmp (alias, DEFAULT_MEMORY_REGION) == 0)
		1337	einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL);
		1338
		1339	/* Look for the target region and check if the alias is not already
		1340	in use. */
		1341	region = NULL;
		1342	for (r = lang_memory_region_list; r != NULL; r = r->next)
		1343	for (n = &r->name_list; n != NULL; n = n->next)
		1344	{
		1345	if (region == NULL && strcmp (n->name, region_name) == 0)
		1346	region = r;
		1347	if (strcmp (n->name, alias) == 0)
		1348	einfo (_("%F%P:%S: error: redefinition of memory region "
		1349	"alias `%s'\n"),
		1350	NULL, alias);
		1351	}
		1352
		1353	/* Check if the target region exists. */
		1354	if (region == NULL)
		1355	einfo (_("%F%P:%S: error: memory region `%s' "
		1356	"for alias `%s' does not exist\n"),
		1357	NULL, region_name, alias);
		1358
		1359	/* Add alias to region name list. */
		1360	n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name));
		1361	n->name = xstrdup (alias);
		1362	n->next = region->name_list.next;
		1363	region->name_list.next = n;
		1364	}
		1365
		1366	static lang_memory_region_type *
		1367	lang_memory_default (asection * section)
		1368	{
		1369	lang_memory_region_type *p;
		1370
		1371	flagword sec_flags = section->flags;
		1372
		1373	/* Override SEC_DATA to mean a writable section. */
		1374	if ((sec_flags & (SEC_ALLOC \| SEC_READONLY \| SEC_CODE)) == SEC_ALLOC)
		1375	sec_flags \|= SEC_DATA;
		1376
		1377	for (p = lang_memory_region_list; p != NULL; p = p->next)
		1378	{
		1379	if ((p->flags & sec_flags) != 0
		1380	&& (p->not_flags & sec_flags) == 0)
		1381	{
		1382	return p;
		1383	}
		1384	}
		1385	return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
		1386	}
		1387
6324	serge	1388	/* Get the output section statement directly from the userdata. */
		1389
		1390	lang_output_section_statement_type *
		1391	lang_output_section_get (const asection *output_section)
		1392	{
		1393	return get_userdata (output_section);
		1394	}
		1395
5199	serge	1396	/* Find or create an output_section_statement with the given NAME.
		1397	If CONSTRAINT is non-zero match one with that constraint, otherwise
		1398	match any non-negative constraint. If CREATE, always make a
		1399	new output_section_statement for SPECIAL CONSTRAINT. */
		1400
		1401	lang_output_section_statement_type *
		1402	lang_output_section_statement_lookup (const char *name,
		1403	int constraint,
		1404	bfd_boolean create)
		1405	{
		1406	struct out_section_hash_entry *entry;
		1407
		1408	entry = ((struct out_section_hash_entry *)
		1409	bfd_hash_lookup (&output_section_statement_table, name,
		1410	create, FALSE));
		1411	if (entry == NULL)
		1412	{
		1413	if (create)
		1414	einfo (_("%P%F: failed creating section `%s': %E\n"), name);
		1415	return NULL;
		1416	}
		1417
		1418	if (entry->s.output_section_statement.name != NULL)
		1419	{
		1420	/* We have a section of this name, but it might not have the correct
		1421	constraint. */
		1422	struct out_section_hash_entry *last_ent;
		1423
		1424	name = entry->s.output_section_statement.name;
		1425	if (create && constraint == SPECIAL)
		1426	/* Not traversing to the end reverses the order of the second
		1427	and subsequent SPECIAL sections in the hash table chain,
		1428	but that shouldn't matter. */
		1429	last_ent = entry;
		1430	else
		1431	do
		1432	{
		1433	if (constraint == entry->s.output_section_statement.constraint
		1434	\|\| (constraint == 0
		1435	&& entry->s.output_section_statement.constraint >= 0))
		1436	return &entry->s.output_section_statement;
		1437	last_ent = entry;
		1438	entry = (struct out_section_hash_entry *) entry->root.next;
		1439	}
		1440	while (entry != NULL
		1441	&& name == entry->s.output_section_statement.name);
		1442
		1443	if (!create)
		1444	return NULL;
		1445
		1446	entry
		1447	= ((struct out_section_hash_entry *)
		1448	output_section_statement_newfunc (NULL,
		1449	&output_section_statement_table,
		1450	name));
		1451	if (entry == NULL)
		1452	{
		1453	einfo (_("%P%F: failed creating section `%s': %E\n"), name);
		1454	return NULL;
		1455	}
		1456	entry->root = last_ent->root;
		1457	last_ent->root.next = &entry->root;
		1458	}
		1459
		1460	entry->s.output_section_statement.name = name;
		1461	entry->s.output_section_statement.constraint = constraint;
		1462	return &entry->s.output_section_statement;
		1463	}
		1464
		1465	/* Find the next output_section_statement with the same name as OS.
		1466	If CONSTRAINT is non-zero, find one with that constraint otherwise
		1467	match any non-negative constraint. */
		1468
		1469	lang_output_section_statement_type *
		1470	next_matching_output_section_statement (lang_output_section_statement_type *os,
		1471	int constraint)
		1472	{
		1473	/* All output_section_statements are actually part of a
		1474	struct out_section_hash_entry. */
		1475	struct out_section_hash_entry entry = (struct out_section_hash_entry )
		1476	((char *) os
		1477	- offsetof (struct out_section_hash_entry, s.output_section_statement));
		1478	const char *name = os->name;
		1479
		1480	ASSERT (name == entry->root.string);
		1481	do
		1482	{
		1483	entry = (struct out_section_hash_entry *) entry->root.next;
		1484	if (entry == NULL
		1485	\|\| name != entry->s.output_section_statement.name)
		1486	return NULL;
		1487	}
		1488	while (constraint != entry->s.output_section_statement.constraint
		1489	&& (constraint != 0
		1490	\|\| entry->s.output_section_statement.constraint < 0));
		1491
		1492	return &entry->s.output_section_statement;
		1493	}
		1494
		1495	/* A variant of lang_output_section_find used by place_orphan.
		1496	Returns the output statement that should precede a new output
		1497	statement for SEC. If an exact match is found on certain flags,
		1498	sets EXACT too. /
		1499
		1500	lang_output_section_statement_type *
		1501	lang_output_section_find_by_flags (const asection *sec,
6324	serge	1502	flagword sec_flags,
5199	serge	1503	lang_output_section_statement_type **exact,
		1504	lang_match_sec_type_func match_type)
		1505	{
		1506	lang_output_section_statement_type first, look, *found;
6324	serge	1507	flagword look_flags, differ;
5199	serge	1508
		1509	/* We know the first statement on this list is ABS. May as well
		1510	skip it. */
		1511	first = &lang_output_section_statement.head->output_section_statement;
		1512	first = first->next;
		1513
		1514	/* First try for an exact match. */
		1515	found = NULL;
		1516	for (look = first; look; look = look->next)
		1517	{
6324	serge	1518	look_flags = look->flags;
5199	serge	1519	if (look->bfd_section != NULL)
		1520	{
6324	serge	1521	look_flags = look->bfd_section->flags;
5199	serge	1522	if (match_type && !match_type (link_info.output_bfd,
		1523	look->bfd_section,
		1524	sec->owner, sec))
		1525	continue;
		1526	}
6324	serge	1527	differ = look_flags ^ sec_flags;
		1528	if (!(differ & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_READONLY
5199	serge	1529	\| SEC_CODE \| SEC_SMALL_DATA \| SEC_THREAD_LOCAL)))
		1530	found = look;
		1531	}
		1532	if (found != NULL)
		1533	{
		1534	if (exact != NULL)
		1535	*exact = found;
		1536	return found;
		1537	}
		1538
6324	serge	1539	if ((sec_flags & SEC_CODE) != 0
		1540	&& (sec_flags & SEC_ALLOC) != 0)
5199	serge	1541	{
		1542	/* Try for a rw code section. */
		1543	for (look = first; look; look = look->next)
		1544	{
6324	serge	1545	look_flags = look->flags;
5199	serge	1546	if (look->bfd_section != NULL)
		1547	{
6324	serge	1548	look_flags = look->bfd_section->flags;
5199	serge	1549	if (match_type && !match_type (link_info.output_bfd,
		1550	look->bfd_section,
		1551	sec->owner, sec))
		1552	continue;
		1553	}
6324	serge	1554	differ = look_flags ^ sec_flags;
		1555	if (!(differ & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD
5199	serge	1556	\| SEC_CODE \| SEC_SMALL_DATA \| SEC_THREAD_LOCAL)))
		1557	found = look;
		1558	}
		1559	}
6324	serge	1560	else if ((sec_flags & SEC_READONLY) != 0
		1561	&& (sec_flags & SEC_ALLOC) != 0)
5199	serge	1562	{
		1563	/* .rodata can go after .text, .sdata2 after .rodata. */
		1564	for (look = first; look; look = look->next)
		1565	{
6324	serge	1566	look_flags = look->flags;
5199	serge	1567	if (look->bfd_section != NULL)
		1568	{
6324	serge	1569	look_flags = look->bfd_section->flags;
5199	serge	1570	if (match_type && !match_type (link_info.output_bfd,
		1571	look->bfd_section,
		1572	sec->owner, sec))
		1573	continue;
		1574	}
6324	serge	1575	differ = look_flags ^ sec_flags;
		1576	if (!(differ & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD
5199	serge	1577	\| SEC_READONLY \| SEC_SMALL_DATA))
6324	serge	1578	\|\| (!(differ & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD
5199	serge	1579	\| SEC_READONLY))
6324	serge	1580	&& !(look_flags & SEC_SMALL_DATA)))
5199	serge	1581	found = look;
		1582	}
		1583	}
6324	serge	1584	else if ((sec_flags & SEC_THREAD_LOCAL) != 0
		1585	&& (sec_flags & SEC_ALLOC) != 0)
5199	serge	1586	{
6324	serge	1587	/* .tdata can go after .data, .tbss after .tdata. Treat .tbss
		1588	as if it were a loaded section, and don't use match_type. */
		1589	bfd_boolean seen_thread_local = FALSE;
		1590
		1591	match_type = NULL;
		1592	for (look = first; look; look = look->next)
		1593	{
		1594	look_flags = look->flags;
		1595	if (look->bfd_section != NULL)
		1596	look_flags = look->bfd_section->flags;
		1597
		1598	differ = look_flags ^ (sec_flags \| SEC_LOAD \| SEC_HAS_CONTENTS);
		1599	if (!(differ & (SEC_THREAD_LOCAL \| SEC_ALLOC)))
		1600	{
		1601	/* .tdata and .tbss must be adjacent and in that order. */
		1602	if (!(look_flags & SEC_LOAD)
		1603	&& (sec_flags & SEC_LOAD))
		1604	/* ..so if we're at a .tbss section and we're placing
		1605	a .tdata section stop looking and return the
		1606	previous section. */
		1607	break;
		1608	found = look;
		1609	seen_thread_local = TRUE;
		1610	}
		1611	else if (seen_thread_local)
		1612	break;
		1613	else if (!(differ & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD)))
		1614	found = look;
		1615	}
		1616	}
		1617	else if ((sec_flags & SEC_SMALL_DATA) != 0
		1618	&& (sec_flags & SEC_ALLOC) != 0)
		1619	{
5199	serge	1620	/* .sdata goes after .data, .sbss after .sdata. */
		1621	for (look = first; look; look = look->next)
		1622	{
6324	serge	1623	look_flags = look->flags;
5199	serge	1624	if (look->bfd_section != NULL)
		1625	{
6324	serge	1626	look_flags = look->bfd_section->flags;
5199	serge	1627	if (match_type && !match_type (link_info.output_bfd,
		1628	look->bfd_section,
		1629	sec->owner, sec))
		1630	continue;
		1631	}
6324	serge	1632	differ = look_flags ^ sec_flags;
		1633	if (!(differ & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD
5199	serge	1634	\| SEC_THREAD_LOCAL))
6324	serge	1635	\|\| ((look_flags & SEC_SMALL_DATA)
		1636	&& !(sec_flags & SEC_HAS_CONTENTS)))
5199	serge	1637	found = look;
		1638	}
		1639	}
6324	serge	1640	else if ((sec_flags & SEC_HAS_CONTENTS) != 0
		1641	&& (sec_flags & SEC_ALLOC) != 0)
5199	serge	1642	{
		1643	/* .data goes after .rodata. */
		1644	for (look = first; look; look = look->next)
		1645	{
6324	serge	1646	look_flags = look->flags;
5199	serge	1647	if (look->bfd_section != NULL)
		1648	{
6324	serge	1649	look_flags = look->bfd_section->flags;
5199	serge	1650	if (match_type && !match_type (link_info.output_bfd,
		1651	look->bfd_section,
		1652	sec->owner, sec))
		1653	continue;
		1654	}
6324	serge	1655	differ = look_flags ^ sec_flags;
		1656	if (!(differ & (SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD
5199	serge	1657	\| SEC_SMALL_DATA \| SEC_THREAD_LOCAL)))
		1658	found = look;
		1659	}
		1660	}
6324	serge	1661	else if ((sec_flags & SEC_ALLOC) != 0)
5199	serge	1662	{
		1663	/* .bss goes after any other alloc section. */
		1664	for (look = first; look; look = look->next)
		1665	{
6324	serge	1666	look_flags = look->flags;
5199	serge	1667	if (look->bfd_section != NULL)
		1668	{
6324	serge	1669	look_flags = look->bfd_section->flags;
5199	serge	1670	if (match_type && !match_type (link_info.output_bfd,
		1671	look->bfd_section,
		1672	sec->owner, sec))
		1673	continue;
		1674	}
6324	serge	1675	differ = look_flags ^ sec_flags;
		1676	if (!(differ & SEC_ALLOC))
5199	serge	1677	found = look;
		1678	}
		1679	}
		1680	else
		1681	{
		1682	/* non-alloc go last. */
		1683	for (look = first; look; look = look->next)
		1684	{
6324	serge	1685	look_flags = look->flags;
5199	serge	1686	if (look->bfd_section != NULL)
6324	serge	1687	look_flags = look->bfd_section->flags;
		1688	differ = look_flags ^ sec_flags;
		1689	if (!(differ & SEC_DEBUGGING))
5199	serge	1690	found = look;
		1691	}
		1692	return found;
		1693	}
		1694
		1695	if (found \|\| !match_type)
		1696	return found;
		1697
6324	serge	1698	return lang_output_section_find_by_flags (sec, sec_flags, NULL, NULL);
5199	serge	1699	}
		1700
		1701	/* Find the last output section before given output statement.
		1702	Used by place_orphan. */
		1703
		1704	static asection *
		1705	output_prev_sec_find (lang_output_section_statement_type *os)
		1706	{
		1707	lang_output_section_statement_type *lookup;
		1708
		1709	for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
		1710	{
		1711	if (lookup->constraint < 0)
		1712	continue;
		1713
		1714	if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
		1715	return lookup->bfd_section;
		1716	}
		1717
		1718	return NULL;
		1719	}
		1720
		1721	/* Look for a suitable place for a new output section statement. The
		1722	idea is to skip over anything that might be inside a SECTIONS {}
		1723	statement in a script, before we find another output section
		1724	statement. Assignments to "dot" before an output section statement
		1725	are assumed to belong to it, except in two cases; The first
		1726	assignment to dot, and assignments before non-alloc sections.
		1727	Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
		1728	similar assignments that set the initial address, or we might
		1729	insert non-alloc note sections among assignments setting end of
		1730	image symbols. */
		1731
		1732	static lang_statement_union_type **
		1733	insert_os_after (lang_output_section_statement_type *after)
		1734	{
		1735	lang_statement_union_type **where;
		1736	lang_statement_union_type **assign = NULL;
		1737	bfd_boolean ignore_first;
		1738
		1739	ignore_first
		1740	= after == &lang_output_section_statement.head->output_section_statement;
		1741
		1742	for (where = &after->header.next;
		1743	*where != NULL;
		1744	where = &(*where)->header.next)
		1745	{
		1746	switch ((*where)->header.type)
		1747	{
		1748	case lang_assignment_statement_enum:
		1749	if (assign == NULL)
		1750	{
		1751	lang_assignment_statement_type *ass;
		1752
		1753	ass = &(*where)->assignment_statement;
		1754	if (ass->exp->type.node_class != etree_assert
		1755	&& ass->exp->assign.dst[0] == '.'
		1756	&& ass->exp->assign.dst[1] == 0
		1757	&& !ignore_first)
		1758	assign = where;
		1759	}
		1760	ignore_first = FALSE;
		1761	continue;
		1762	case lang_wild_statement_enum:
		1763	case lang_input_section_enum:
		1764	case lang_object_symbols_statement_enum:
		1765	case lang_fill_statement_enum:
		1766	case lang_data_statement_enum:
		1767	case lang_reloc_statement_enum:
		1768	case lang_padding_statement_enum:
		1769	case lang_constructors_statement_enum:
		1770	assign = NULL;
		1771	continue;
		1772	case lang_output_section_statement_enum:
		1773	if (assign != NULL)
		1774	{
		1775	asection s = (where)->output_section_statement.bfd_section;
		1776
		1777	if (s == NULL
		1778	\|\| s->map_head.s == NULL
		1779	\|\| (s->flags & SEC_ALLOC) != 0)
		1780	where = assign;
		1781	}
		1782	break;
		1783	case lang_input_statement_enum:
		1784	case lang_address_statement_enum:
		1785	case lang_target_statement_enum:
		1786	case lang_output_statement_enum:
		1787	case lang_group_statement_enum:
		1788	case lang_insert_statement_enum:
		1789	continue;
		1790	}
		1791	break;
		1792	}
		1793
		1794	return where;
		1795	}
		1796
		1797	lang_output_section_statement_type *
		1798	lang_insert_orphan (asection *s,
		1799	const char *secname,
		1800	int constraint,
		1801	lang_output_section_statement_type *after,
		1802	struct orphan_save *place,
		1803	etree_type *address,
		1804	lang_statement_list_type *add_child)
		1805	{
		1806	lang_statement_list_type add;
		1807	const char *ps;
6324	serge	1808	lang_assignment_statement_type *start_assign;
5199	serge	1809	lang_output_section_statement_type *os;
		1810	lang_output_section_statement_type **os_tail;
		1811
		1812	/* If we have found an appropriate place for the output section
		1813	statements for this orphan, add them to our own private list,
		1814	inserting them later into the global statement list. */
		1815	if (after != NULL)
		1816	{
		1817	lang_list_init (&add);
		1818	push_stat_ptr (&add);
		1819	}
		1820
6324	serge	1821	if (bfd_link_relocatable (&link_info)
		1822	\|\| (s->flags & (SEC_LOAD \| SEC_ALLOC)) == 0)
5199	serge	1823	address = exp_intop (0);
		1824
		1825	os_tail = ((lang_output_section_statement_type **)
		1826	lang_output_section_statement.tail);
		1827	os = lang_enter_output_section_statement (secname, address, normal_section,
		1828	NULL, NULL, NULL, constraint, 0);
		1829
		1830	ps = NULL;
6324	serge	1831	start_assign = NULL;
5199	serge	1832	if (config.build_constructors && *os_tail == os)
		1833	{
		1834	/* If the name of the section is representable in C, then create
		1835	symbols to mark the start and the end of the section. */
		1836	for (ps = secname; *ps != '\0'; ps++)
		1837	if (! ISALNUM ((unsigned char) ps) && ps != '_')
		1838	break;
		1839	if (*ps == '\0')
		1840	{
		1841	char *symname;
		1842
		1843	symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
		1844	symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
		1845	sprintf (symname + (symname[0] != 0), "__start_%s", secname);
6324	serge	1846	start_assign
		1847	= lang_add_assignment (exp_provide (symname,
5199	serge	1848	exp_nameop (NAME, "."),
		1849	FALSE));
		1850	}
		1851	}
		1852
		1853	if (add_child == NULL)
		1854	add_child = &os->children;
		1855	lang_add_section (add_child, s, NULL, os);
		1856
		1857	if (after && (s->flags & (SEC_LOAD \| SEC_ALLOC)) != 0)
		1858	{
		1859	const char *region = (after->region
		1860	? after->region->name_list.name
		1861	: DEFAULT_MEMORY_REGION);
		1862	const char *lma_region = (after->lma_region
		1863	? after->lma_region->name_list.name
		1864	: NULL);
		1865	lang_leave_output_section_statement (NULL, region, after->phdrs,
		1866	lma_region);
		1867	}
		1868	else
		1869	lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,
		1870	NULL);
		1871
6324	serge	1872	if (start_assign != NULL)
5199	serge	1873	{
		1874	char *symname;
6324	serge	1875	lang_assignment_statement_type *stop_assign;
		1876	bfd_vma dot;
5199	serge	1877
		1878	symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
		1879	symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
		1880	sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
6324	serge	1881	stop_assign
		1882	= lang_add_assignment (exp_provide (symname,
5199	serge	1883	exp_nameop (NAME, "."),
		1884	FALSE));
6324	serge	1885	/* Evaluate the expression to define the symbol if referenced,
		1886	before sizing dynamic sections. */
		1887	dot = os->bfd_section->vma;
		1888	exp_fold_tree (start_assign->exp, os->bfd_section, &dot);
		1889	dot += s->size;
		1890	exp_fold_tree (stop_assign->exp, os->bfd_section, &dot);
5199	serge	1891	}
		1892
		1893	/* Restore the global list pointer. */
		1894	if (after != NULL)
		1895	pop_stat_ptr ();
		1896
		1897	if (after != NULL && os->bfd_section != NULL)
		1898	{
		1899	asection snew, as;
		1900
		1901	snew = os->bfd_section;
		1902
		1903	/* Shuffle the bfd section list to make the output file look
		1904	neater. This is really only cosmetic. */
		1905	if (place->section == NULL
		1906	&& after != (&lang_output_section_statement.head
		1907	->output_section_statement))
		1908	{
		1909	asection *bfd_section = after->bfd_section;
		1910
		1911	/* If the output statement hasn't been used to place any input
		1912	sections (and thus doesn't have an output bfd_section),
		1913	look for the closest prior output statement having an
		1914	output section. */
		1915	if (bfd_section == NULL)
		1916	bfd_section = output_prev_sec_find (after);
		1917
		1918	if (bfd_section != NULL && bfd_section != snew)
		1919	place->section = &bfd_section->next;
		1920	}
		1921
		1922	if (place->section == NULL)
		1923	place->section = &link_info.output_bfd->sections;
		1924
		1925	as = *place->section;
		1926
		1927	if (!as)
		1928	{
		1929	/* Put the section at the end of the list. */
		1930
		1931	/* Unlink the section. */
		1932	bfd_section_list_remove (link_info.output_bfd, snew);
		1933
		1934	/* Now tack it back on in the right place. */
		1935	bfd_section_list_append (link_info.output_bfd, snew);
		1936	}
		1937	else if (as != snew && as->prev != snew)
		1938	{
		1939	/* Unlink the section. */
		1940	bfd_section_list_remove (link_info.output_bfd, snew);
		1941
		1942	/* Now tack it back on in the right place. */
		1943	bfd_section_list_insert_before (link_info.output_bfd, as, snew);
		1944	}
		1945
		1946	/* Save the end of this list. Further ophans of this type will
		1947	follow the one we've just added. */
		1948	place->section = &snew->next;
		1949
		1950	/* The following is non-cosmetic. We try to put the output
		1951	statements in some sort of reasonable order here, because they
		1952	determine the final load addresses of the orphan sections.
		1953	In addition, placing output statements in the wrong order may
		1954	require extra segments. For instance, given a typical
		1955	situation of all read-only sections placed in one segment and
		1956	following that a segment containing all the read-write
		1957	sections, we wouldn't want to place an orphan read/write
		1958	section before or amongst the read-only ones. */
		1959	if (add.head != NULL)
		1960	{
		1961	lang_output_section_statement_type *newly_added_os;
		1962
		1963	if (place->stmt == NULL)
		1964	{
		1965	lang_statement_union_type **where = insert_os_after (after);
		1966
		1967	add.tail = where;
		1968	*where = add.head;
		1969
		1970	place->os_tail = &after->next;
		1971	}
		1972	else
		1973	{
		1974	/* Put it after the last orphan statement we added. */
		1975	add.tail = place->stmt;
		1976	*place->stmt = add.head;
		1977	}
		1978
		1979	/* Fix the global list pointer if we happened to tack our
		1980	new list at the tail. */
		1981	if (*stat_ptr->tail == add.head)
		1982	stat_ptr->tail = add.tail;
		1983
		1984	/* Save the end of this list. */
		1985	place->stmt = add.tail;
		1986
		1987	/* Do the same for the list of output section statements. */
		1988	newly_added_os = *os_tail;
		1989	*os_tail = NULL;
		1990	newly_added_os->prev = (lang_output_section_statement_type *)
		1991	((char *) place->os_tail
		1992	- offsetof (lang_output_section_statement_type, next));
		1993	newly_added_os->next = *place->os_tail;
		1994	if (newly_added_os->next != NULL)
		1995	newly_added_os->next->prev = newly_added_os;
		1996	*place->os_tail = newly_added_os;
		1997	place->os_tail = &newly_added_os->next;
		1998
		1999	/* Fixing the global list pointer here is a little different.
		2000	We added to the list in lang_enter_output_section_statement,
		2001	trimmed off the new output_section_statment above when
		2002	assigning *os_tail = NULL, but possibly added it back in
		2003	the same place when assigning place->os_tail. /
		2004	if (*os_tail == NULL)
		2005	lang_output_section_statement.tail
		2006	= (lang_statement_union_type **) os_tail;
		2007	}
		2008	}
		2009	return os;
		2010	}
		2011
		2012	static void
6324	serge	2013	lang_print_asneeded (void)
		2014	{
		2015	struct asneeded_minfo *m;
		2016	char buf[100];
		2017
		2018	if (asneeded_list_head == NULL)
		2019	return;
		2020
		2021	sprintf (buf, _("\nAs-needed library included "
		2022	"to satisfy reference by file (symbol)\n\n"));
		2023	minfo ("%s", buf);
		2024
		2025	for (m = asneeded_list_head; m != NULL; m = m->next)
		2026	{
		2027	size_t len;
		2028
		2029	minfo ("%s", m->soname);
		2030	len = strlen (m->soname);
		2031
		2032	if (len >= 29)
		2033	{
		2034	print_nl ();
		2035	len = 0;
		2036	}
		2037	while (len < 30)
		2038	{
		2039	print_space ();
		2040	++len;
		2041	}
		2042
		2043	if (m->ref != NULL)
		2044	minfo ("%B ", m->ref);
		2045	minfo ("(%T)\n", m->name);
		2046	}
		2047	}
		2048
		2049	static void
5199	serge	2050	lang_map_flags (flagword flag)
		2051	{
		2052	if (flag & SEC_ALLOC)
		2053	minfo ("a");
		2054
		2055	if (flag & SEC_CODE)
		2056	minfo ("x");
		2057
		2058	if (flag & SEC_READONLY)
		2059	minfo ("r");
		2060
		2061	if (flag & SEC_DATA)
		2062	minfo ("w");
		2063
		2064	if (flag & SEC_LOAD)
		2065	minfo ("l");
		2066	}
		2067
		2068	void
		2069	lang_map (void)
		2070	{
		2071	lang_memory_region_type *m;
		2072	bfd_boolean dis_header_printed = FALSE;
		2073
		2074	LANG_FOR_EACH_INPUT_STATEMENT (file)
		2075	{
		2076	asection *s;
		2077
		2078	if ((file->the_bfd->flags & (BFD_LINKER_CREATED \| DYNAMIC)) != 0
		2079	\|\| file->flags.just_syms)
		2080	continue;
		2081
		2082	for (s = file->the_bfd->sections; s != NULL; s = s->next)
		2083	if ((s->output_section == NULL
		2084	\|\| s->output_section->owner != link_info.output_bfd)
		2085	&& (s->flags & (SEC_LINKER_CREATED \| SEC_KEEP)) == 0)
		2086	{
		2087	if (! dis_header_printed)
		2088	{
		2089	fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
		2090	dis_header_printed = TRUE;
		2091	}
		2092
		2093	print_input_section (s, TRUE);
		2094	}
		2095	}
		2096
		2097	minfo (_("\nMemory Configuration\n\n"));
		2098	fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
		2099	_("Name"), _("Origin"), _("Length"), _("Attributes"));
		2100
		2101	for (m = lang_memory_region_list; m != NULL; m = m->next)
		2102	{
		2103	char buf[100];
		2104	int len;
		2105
		2106	fprintf (config.map_file, "%-16s ", m->name_list.name);
		2107
		2108	sprintf_vma (buf, m->origin);
		2109	minfo ("0x%s ", buf);
		2110	len = strlen (buf);
		2111	while (len < 16)
		2112	{
		2113	print_space ();
		2114	++len;
		2115	}
		2116
		2117	minfo ("0x%V", m->length);
		2118	if (m->flags \|\| m->not_flags)
		2119	{
		2120	#ifndef BFD64
		2121	minfo (" ");
		2122	#endif
		2123	if (m->flags)
		2124	{
		2125	print_space ();
		2126	lang_map_flags (m->flags);
		2127	}
		2128
		2129	if (m->not_flags)
		2130	{
		2131	minfo (" !");
		2132	lang_map_flags (m->not_flags);
		2133	}
		2134	}
		2135
		2136	print_nl ();
		2137	}
		2138
		2139	fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
		2140
		2141	if (! link_info.reduce_memory_overheads)
		2142	{
		2143	obstack_begin (&map_obstack, 1000);
		2144	bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
		2145	}
6324	serge	2146	lang_statement_iteration++;
5199	serge	2147	print_statements ();
		2148
6324	serge	2149	ldemul_extra_map_file_text (link_info.output_bfd, &link_info, config.map_file);
5199	serge	2150	}
		2151
		2152	static bfd_boolean
		2153	sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
		2154	void *info ATTRIBUTE_UNUSED)
		2155	{
6324	serge	2156	if ((hash_entry->type == bfd_link_hash_defined
5199	serge	2157	\|\| hash_entry->type == bfd_link_hash_defweak)
6324	serge	2158	&& hash_entry->u.def.section->owner != link_info.output_bfd
		2159	&& hash_entry->u.def.section->owner != NULL)
5199	serge	2160	{
6324	serge	2161	input_section_userdata_type *ud;
5199	serge	2162	struct map_symbol_def *def;
		2163
6324	serge	2164	ud = ((input_section_userdata_type *)
		2165	get_userdata (hash_entry->u.def.section));
		2166	if (!ud)
5199	serge	2167	{
6324	serge	2168	ud = (input_section_userdata_type ) stat_alloc (sizeof (ud));
		2169	get_userdata (hash_entry->u.def.section) = ud;
		2170	ud->map_symbol_def_tail = &ud->map_symbol_def_head;
		2171	ud->map_symbol_def_count = 0;
5199	serge	2172	}
		2173	else if (!ud->map_symbol_def_tail)
		2174	ud->map_symbol_def_tail = &ud->map_symbol_def_head;
		2175
		2176	def = (struct map_symbol_def ) obstack_alloc (&map_obstack, sizeof def);
		2177	def->entry = hash_entry;
		2178	*(ud->map_symbol_def_tail) = def;
		2179	ud->map_symbol_def_tail = &def->next;
		2180	ud->map_symbol_def_count++;
		2181	}
		2182	return TRUE;
		2183	}
		2184
		2185	/* Initialize an output section. */
		2186
		2187	static void
		2188	init_os (lang_output_section_statement_type *s, flagword flags)
		2189	{
		2190	if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
		2191	einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
		2192
		2193	if (s->constraint != SPECIAL)
		2194	s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
		2195	if (s->bfd_section == NULL)
		2196	s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
		2197	s->name, flags);
		2198	if (s->bfd_section == NULL)
		2199	{
		2200	einfo (_("%P%F: output format %s cannot represent section called %s\n"),
		2201	link_info.output_bfd->xvec->name, s->name);
		2202	}
		2203	s->bfd_section->output_section = s->bfd_section;
		2204	s->bfd_section->output_offset = 0;
		2205
6324	serge	2206	/* Set the userdata of the output section to the output section
		2207	statement to avoid lookup. */
		2208	get_userdata (s->bfd_section) = s;
5199	serge	2209
		2210	/* If there is a base address, make sure that any sections it might
		2211	mention are initialized. */
		2212	if (s->addr_tree != NULL)
		2213	exp_init_os (s->addr_tree);
		2214
		2215	if (s->load_base != NULL)
		2216	exp_init_os (s->load_base);
		2217
		2218	/* If supplied an alignment, set it. */
		2219	if (s->section_alignment != -1)
		2220	s->bfd_section->alignment_power = s->section_alignment;
		2221	}
		2222
		2223	/* Make sure that all output sections mentioned in an expression are
		2224	initialized. */
		2225
		2226	static void
		2227	exp_init_os (etree_type *exp)
		2228	{
		2229	switch (exp->type.node_class)
		2230	{
		2231	case etree_assign:
		2232	case etree_provide:
		2233	exp_init_os (exp->assign.src);
		2234	break;
		2235
		2236	case etree_binary:
		2237	exp_init_os (exp->binary.lhs);
		2238	exp_init_os (exp->binary.rhs);
		2239	break;
		2240
		2241	case etree_trinary:
		2242	exp_init_os (exp->trinary.cond);
		2243	exp_init_os (exp->trinary.lhs);
		2244	exp_init_os (exp->trinary.rhs);
		2245	break;
		2246
		2247	case etree_assert:
		2248	exp_init_os (exp->assert_s.child);
		2249	break;
		2250
		2251	case etree_unary:
		2252	exp_init_os (exp->unary.child);
		2253	break;
		2254
		2255	case etree_name:
		2256	switch (exp->type.node_code)
		2257	{
		2258	case ADDR:
		2259	case LOADADDR:
		2260	case SIZEOF:
		2261	{
		2262	lang_output_section_statement_type *os;
		2263
		2264	os = lang_output_section_find (exp->name.name);
		2265	if (os != NULL && os->bfd_section == NULL)
		2266	init_os (os, 0);
		2267	}
		2268	}
		2269	break;
		2270
		2271	default:
		2272	break;
		2273	}
		2274	}
		2275
		2276	static void
		2277	section_already_linked (bfd abfd, asection sec, void *data)
		2278	{
		2279	lang_input_statement_type entry = (lang_input_statement_type ) data;
		2280
		2281	/* If we are only reading symbols from this object, then we want to
		2282	discard all sections. */
		2283	if (entry->flags.just_syms)
		2284	{
		2285	bfd_link_just_syms (abfd, sec, &link_info);
		2286	return;
		2287	}
		2288
		2289	if (!(abfd->flags & DYNAMIC))
		2290	bfd_section_already_linked (abfd, sec, &link_info);
		2291	}
		2292
		2293	/* The wild routines.
		2294
		2295	These expand statements like *(.text) and foo.o to a list of
		2296	explicit actions, like foo.o(.text), bar.o(.text) and
		2297	foo.o(.text, .data). */
		2298
		2299	/* Add SECTION to the output section OUTPUT. Do this by creating a
		2300	lang_input_section statement which is placed at PTR. */
		2301
		2302	void
		2303	lang_add_section (lang_statement_list_type *ptr,
		2304	asection *section,
		2305	struct flag_info *sflag_info,
		2306	lang_output_section_statement_type *output)
		2307	{
		2308	flagword flags = section->flags;
		2309
		2310	bfd_boolean discard;
		2311	lang_input_section_type *new_section;
		2312	bfd *abfd = link_info.output_bfd;
		2313
		2314	/* Discard sections marked with SEC_EXCLUDE. */
		2315	discard = (flags & SEC_EXCLUDE) != 0;
		2316
		2317	/* Discard input sections which are assigned to a section named
		2318	DISCARD_SECTION_NAME. */
		2319	if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
		2320	discard = TRUE;
		2321
		2322	/* Discard debugging sections if we are stripping debugging
		2323	information. */
		2324	if ((link_info.strip == strip_debugger \|\| link_info.strip == strip_all)
		2325	&& (flags & SEC_DEBUGGING) != 0)
		2326	discard = TRUE;
		2327
		2328	if (discard)
		2329	{
		2330	if (section->output_section == NULL)
		2331	{
		2332	/* This prevents future calls from assigning this section. */
		2333	section->output_section = bfd_abs_section_ptr;
		2334	}
		2335	return;
		2336	}
		2337
		2338	if (sflag_info)
		2339	{
		2340	bfd_boolean keep;
		2341
		2342	keep = bfd_lookup_section_flags (&link_info, sflag_info, section);
		2343	if (!keep)
		2344	return;
		2345	}
		2346
		2347	if (section->output_section != NULL)
		2348	return;
		2349
		2350	/* We don't copy the SEC_NEVER_LOAD flag from an input section
		2351	to an output section, because we want to be able to include a
		2352	SEC_NEVER_LOAD section in the middle of an otherwise loaded
		2353	section (I don't know why we want to do this, but we do).
		2354	build_link_order in ldwrite.c handles this case by turning
		2355	the embedded SEC_NEVER_LOAD section into a fill. */
		2356	flags &= ~ SEC_NEVER_LOAD;
		2357
		2358	/* If final link, don't copy the SEC_LINK_ONCE flags, they've
		2359	already been processed. One reason to do this is that on pe
		2360	format targets, .text$foo sections go into .text and it's odd
		2361	to see .text with SEC_LINK_ONCE set. */
		2362
6324	serge	2363	if (!bfd_link_relocatable (&link_info))
5199	serge	2364	flags &= ~(SEC_LINK_ONCE \| SEC_LINK_DUPLICATES \| SEC_RELOC);
		2365
		2366	switch (output->sectype)
		2367	{
		2368	case normal_section:
		2369	case overlay_section:
		2370	break;
		2371	case noalloc_section:
		2372	flags &= ~SEC_ALLOC;
		2373	break;
		2374	case noload_section:
		2375	flags &= ~SEC_LOAD;
		2376	flags \|= SEC_NEVER_LOAD;
		2377	/* Unfortunately GNU ld has managed to evolve two different
		2378	meanings to NOLOAD in scripts. ELF gets a .bss style noload,
		2379	alloc, no contents section. All others get a noload, noalloc
		2380	section. */
		2381	if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
		2382	flags &= ~SEC_HAS_CONTENTS;
		2383	else
		2384	flags &= ~SEC_ALLOC;
		2385	break;
		2386	}
		2387
		2388	if (output->bfd_section == NULL)
		2389	init_os (output, flags);
		2390
		2391	/* If SEC_READONLY is not set in the input section, then clear
		2392	it from the output section. */
		2393	output->bfd_section->flags &= flags \| ~SEC_READONLY;
		2394
		2395	if (output->bfd_section->linker_has_input)
		2396	{
		2397	/* Only set SEC_READONLY flag on the first input section. */
		2398	flags &= ~ SEC_READONLY;
		2399
		2400	/* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
		2401	if ((output->bfd_section->flags & (SEC_MERGE \| SEC_STRINGS))
		2402	!= (flags & (SEC_MERGE \| SEC_STRINGS))
		2403	\|\| ((flags & SEC_MERGE) != 0
		2404	&& output->bfd_section->entsize != section->entsize))
		2405	{
		2406	output->bfd_section->flags &= ~ (SEC_MERGE \| SEC_STRINGS);
		2407	flags &= ~ (SEC_MERGE \| SEC_STRINGS);
		2408	}
		2409	}
		2410	output->bfd_section->flags \|= flags;
		2411
		2412	if (!output->bfd_section->linker_has_input)
		2413	{
		2414	output->bfd_section->linker_has_input = 1;
		2415	/* This must happen after flags have been updated. The output
		2416	section may have been created before we saw its first input
		2417	section, eg. for a data statement. */
		2418	bfd_init_private_section_data (section->owner, section,
		2419	link_info.output_bfd,
		2420	output->bfd_section,
		2421	&link_info);
		2422	if ((flags & SEC_MERGE) != 0)
		2423	output->bfd_section->entsize = section->entsize;
		2424	}
		2425
		2426	if ((flags & SEC_TIC54X_BLOCK) != 0
		2427	&& bfd_get_arch (section->owner) == bfd_arch_tic54x)
		2428	{
		2429	/* FIXME: This value should really be obtained from the bfd... */
		2430	output->block_value = 128;
		2431	}
		2432
		2433	if (section->alignment_power > output->bfd_section->alignment_power)
		2434	output->bfd_section->alignment_power = section->alignment_power;
		2435
		2436	section->output_section = output->bfd_section;
		2437
6324	serge	2438	if (!map_head_is_link_order)
5199	serge	2439	{
		2440	asection *s = output->bfd_section->map_tail.s;
		2441	output->bfd_section->map_tail.s = section;
		2442	section->map_head.s = NULL;
		2443	section->map_tail.s = s;
		2444	if (s != NULL)
		2445	s->map_head.s = section;
		2446	else
		2447	output->bfd_section->map_head.s = section;
		2448	}
		2449
		2450	/* Add a section reference to the list. */
		2451	new_section = new_stat (lang_input_section, ptr);
		2452	new_section->section = section;
		2453	}
		2454
		2455	/* Handle wildcard sorting. This returns the lang_input_section which
		2456	should follow the one we are going to create for SECTION and FILE,
		2457	based on the sorting requirements of WILD. It returns NULL if the
		2458	new section should just go at the end of the current list. */
		2459
		2460	static lang_statement_union_type *
		2461	wild_sort (lang_wild_statement_type *wild,
		2462	struct wildcard_list *sec,
		2463	lang_input_statement_type *file,
		2464	asection *section)
		2465	{
		2466	lang_statement_union_type *l;
		2467
		2468	if (!wild->filenames_sorted
		2469	&& (sec == NULL \|\| sec->spec.sorted == none))
		2470	return NULL;
		2471
		2472	for (l = wild->children.head; l != NULL; l = l->header.next)
		2473	{
		2474	lang_input_section_type *ls;
		2475
		2476	if (l->header.type != lang_input_section_enum)
		2477	continue;
		2478	ls = &l->input_section;
		2479
		2480	/* Sorting by filename takes precedence over sorting by section
		2481	name. */
		2482
		2483	if (wild->filenames_sorted)
		2484	{
		2485	const char fn, ln;
		2486	bfd_boolean fa, la;
		2487	int i;
		2488
		2489	/* The PE support for the .idata section as generated by
		2490	dlltool assumes that files will be sorted by the name of
		2491	the archive and then the name of the file within the
		2492	archive. */
		2493
		2494	if (file->the_bfd != NULL
		2495	&& bfd_my_archive (file->the_bfd) != NULL)
		2496	{
		2497	fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
		2498	fa = TRUE;
		2499	}
		2500	else
		2501	{
		2502	fn = file->filename;
		2503	fa = FALSE;
		2504	}
		2505
		2506	if (bfd_my_archive (ls->section->owner) != NULL)
		2507	{
		2508	ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
		2509	la = TRUE;
		2510	}
		2511	else
		2512	{
		2513	ln = ls->section->owner->filename;
		2514	la = FALSE;
		2515	}
		2516
		2517	i = filename_cmp (fn, ln);
		2518	if (i > 0)
		2519	continue;
		2520	else if (i < 0)
		2521	break;
		2522
		2523	if (fa \|\| la)
		2524	{
		2525	if (fa)
		2526	fn = file->filename;
		2527	if (la)
		2528	ln = ls->section->owner->filename;
		2529
		2530	i = filename_cmp (fn, ln);
		2531	if (i > 0)
		2532	continue;
		2533	else if (i < 0)
		2534	break;
		2535	}
		2536	}
		2537
		2538	/* Here either the files are not sorted by name, or we are
		2539	looking at the sections for this file. */
		2540
		2541	if (sec != NULL
		2542	&& sec->spec.sorted != none
		2543	&& sec->spec.sorted != by_none)
		2544	if (compare_section (sec->spec.sorted, section, ls->section) < 0)
		2545	break;
		2546	}
		2547
		2548	return l;
		2549	}
		2550
		2551	/* Expand a wild statement for a particular FILE. SECTION may be
		2552	NULL, in which case it is a wild card. */
		2553
		2554	static void
		2555	output_section_callback (lang_wild_statement_type *ptr,
		2556	struct wildcard_list *sec,
		2557	asection *section,
		2558	struct flag_info *sflag_info,
		2559	lang_input_statement_type *file,
		2560	void *output)
		2561	{
		2562	lang_statement_union_type *before;
		2563	lang_output_section_statement_type *os;
		2564
		2565	os = (lang_output_section_statement_type *) output;
		2566
		2567	/* Exclude sections that match UNIQUE_SECTION_LIST. */
		2568	if (unique_section_p (section, os))
		2569	return;
		2570
		2571	before = wild_sort (ptr, sec, file, section);
		2572
		2573	/* Here BEFORE points to the lang_input_section which
		2574	should follow the one we are about to add. If BEFORE
		2575	is NULL, then the section should just go at the end
		2576	of the current list. */
		2577
		2578	if (before == NULL)
		2579	lang_add_section (&ptr->children, section, sflag_info, os);
		2580	else
		2581	{
		2582	lang_statement_list_type list;
		2583	lang_statement_union_type **pp;
		2584
		2585	lang_list_init (&list);
		2586	lang_add_section (&list, section, sflag_info, os);
		2587
		2588	/* If we are discarding the section, LIST.HEAD will
		2589	be NULL. */
		2590	if (list.head != NULL)
		2591	{
		2592	ASSERT (list.head->header.next == NULL);
		2593
		2594	for (pp = &ptr->children.head;
		2595	*pp != before;
		2596	pp = &(*pp)->header.next)
		2597	ASSERT (*pp != NULL);
		2598
		2599	list.head->header.next = *pp;
		2600	*pp = list.head;
		2601	}
		2602	}
		2603	}
		2604
		2605	/* Check if all sections in a wild statement for a particular FILE
		2606	are readonly. */
		2607
		2608	static void
		2609	check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
		2610	struct wildcard_list *sec ATTRIBUTE_UNUSED,
		2611	asection *section,
		2612	struct flag_info *sflag_info ATTRIBUTE_UNUSED,
		2613	lang_input_statement_type *file ATTRIBUTE_UNUSED,
		2614	void *output)
		2615	{
		2616	lang_output_section_statement_type *os;
		2617
		2618	os = (lang_output_section_statement_type *) output;
		2619
		2620	/* Exclude sections that match UNIQUE_SECTION_LIST. */
		2621	if (unique_section_p (section, os))
		2622	return;
		2623
		2624	if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
		2625	os->all_input_readonly = FALSE;
		2626	}
		2627
		2628	/* This is passed a file name which must have been seen already and
		2629	added to the statement tree. We will see if it has been opened
		2630	already and had its symbols read. If not then we'll read it. */
		2631
		2632	static lang_input_statement_type *
		2633	lookup_name (const char *name)
		2634	{
		2635	lang_input_statement_type *search;
		2636
		2637	for (search = (lang_input_statement_type *) input_file_chain.head;
		2638	search != NULL;
		2639	search = (lang_input_statement_type *) search->next_real_file)
		2640	{
		2641	/* Use the local_sym_name as the name of the file that has
		2642	already been loaded as filename might have been transformed
		2643	via the search directory lookup mechanism. */
		2644	const char *filename = search->local_sym_name;
		2645
		2646	if (filename != NULL
		2647	&& filename_cmp (filename, name) == 0)
		2648	break;
		2649	}
		2650
		2651	if (search == NULL)
		2652	search = new_afile (name, lang_input_file_is_search_file_enum,
		2653	default_target, FALSE);
		2654
		2655	/* If we have already added this file, or this file is not real
		2656	don't add this file. */
		2657	if (search->flags.loaded \|\| !search->flags.real)
		2658	return search;
		2659
		2660	if (! load_symbols (search, NULL))
		2661	return NULL;
		2662
		2663	return search;
		2664	}
		2665
		2666	/* Save LIST as a list of libraries whose symbols should not be exported. */
		2667
		2668	struct excluded_lib
		2669	{
		2670	char *name;
		2671	struct excluded_lib *next;
		2672	};
		2673	static struct excluded_lib *excluded_libs;
		2674
		2675	void
		2676	add_excluded_libs (const char *list)
		2677	{
		2678	const char p = list, end;
		2679
		2680	while (*p != '\0')
		2681	{
		2682	struct excluded_lib *entry;
		2683	end = strpbrk (p, ",:");
		2684	if (end == NULL)
		2685	end = p + strlen (p);
		2686	entry = (struct excluded_lib ) xmalloc (sizeof (entry));
		2687	entry->next = excluded_libs;
		2688	entry->name = (char *) xmalloc (end - p + 1);
		2689	memcpy (entry->name, p, end - p);
		2690	entry->name[end - p] = '\0';
		2691	excluded_libs = entry;
		2692	if (*end == '\0')
		2693	break;
		2694	p = end + 1;
		2695	}
		2696	}
		2697
		2698	static void
		2699	check_excluded_libs (bfd *abfd)
		2700	{
		2701	struct excluded_lib *lib = excluded_libs;
		2702
		2703	while (lib)
		2704	{
		2705	int len = strlen (lib->name);
		2706	const char *filename = lbasename (abfd->filename);
		2707
		2708	if (strcmp (lib->name, "ALL") == 0)
		2709	{
		2710	abfd->no_export = TRUE;
		2711	return;
		2712	}
		2713
		2714	if (filename_ncmp (lib->name, filename, len) == 0
		2715	&& (filename[len] == '\0'
		2716	\|\| (filename[len] == '.' && filename[len + 1] == 'a'
		2717	&& filename[len + 2] == '\0')))
		2718	{
		2719	abfd->no_export = TRUE;
		2720	return;
		2721	}
		2722
		2723	lib = lib->next;
		2724	}
		2725	}
		2726
		2727	/* Get the symbols for an input file. */
		2728
		2729	bfd_boolean
		2730	load_symbols (lang_input_statement_type *entry,
		2731	lang_statement_list_type *place)
		2732	{
		2733	char **matching;
		2734
		2735	if (entry->flags.loaded)
		2736	return TRUE;
		2737
		2738	ldfile_open_file (entry);
		2739
		2740	/* Do not process further if the file was missing. */
		2741	if (entry->flags.missing_file)
		2742	return TRUE;
		2743
		2744	if (! bfd_check_format (entry->the_bfd, bfd_archive)
		2745	&& ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
		2746	{
		2747	bfd_error_type err;
		2748	struct lang_input_statement_flags save_flags;
		2749	extern FILE *yyin;
		2750
		2751	err = bfd_get_error ();
		2752
		2753	/* See if the emulation has some special knowledge. */
		2754	if (ldemul_unrecognized_file (entry))
		2755	return TRUE;
		2756
		2757	if (err == bfd_error_file_ambiguously_recognized)
		2758	{
		2759	char **p;
		2760
		2761	einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
		2762	einfo (_("%B: matching formats:"), entry->the_bfd);
		2763	for (p = matching; *p != NULL; p++)
		2764	einfo (" %s", *p);
		2765	einfo ("%F\n");
		2766	}
		2767	else if (err != bfd_error_file_not_recognized
		2768	\|\| place == NULL)
		2769	einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
		2770
		2771	bfd_close (entry->the_bfd);
		2772	entry->the_bfd = NULL;
		2773
		2774	/* Try to interpret the file as a linker script. */
		2775	save_flags = input_flags;
		2776	ldfile_open_command_file (entry->filename);
		2777
		2778	push_stat_ptr (place);
		2779	input_flags.add_DT_NEEDED_for_regular
		2780	= entry->flags.add_DT_NEEDED_for_regular;
		2781	input_flags.add_DT_NEEDED_for_dynamic
		2782	= entry->flags.add_DT_NEEDED_for_dynamic;
		2783	input_flags.whole_archive = entry->flags.whole_archive;
		2784	input_flags.dynamic = entry->flags.dynamic;
		2785
		2786	ldfile_assumed_script = TRUE;
		2787	parser_input = input_script;
		2788	yyparse ();
		2789	ldfile_assumed_script = FALSE;
		2790
		2791	/* missing_file is sticky. sysrooted will already have been
		2792	restored when seeing EOF in yyparse, but no harm to restore
		2793	again. */
		2794	save_flags.missing_file \|= input_flags.missing_file;
		2795	input_flags = save_flags;
		2796	pop_stat_ptr ();
		2797	fclose (yyin);
		2798	yyin = NULL;
		2799	entry->flags.loaded = TRUE;
		2800
		2801	return TRUE;
		2802	}
		2803
		2804	if (ldemul_recognized_file (entry))
		2805	return TRUE;
		2806
		2807	/* We don't call ldlang_add_file for an archive. Instead, the
		2808	add_symbols entry point will call ldlang_add_file, via the
		2809	add_archive_element callback, for each element of the archive
		2810	which is used. */
		2811	switch (bfd_get_format (entry->the_bfd))
		2812	{
		2813	default:
		2814	break;
		2815
		2816	case bfd_object:
		2817	if (!entry->flags.reload)
		2818	ldlang_add_file (entry);
		2819	if (trace_files \|\| verbose)
		2820	info_msg ("%I\n", entry);
		2821	break;
		2822
		2823	case bfd_archive:
		2824	check_excluded_libs (entry->the_bfd);
		2825
		2826	if (entry->flags.whole_archive)
		2827	{
		2828	bfd *member = NULL;
		2829	bfd_boolean loaded = TRUE;
		2830
		2831	for (;;)
		2832	{
		2833	bfd *subsbfd;
		2834	member = bfd_openr_next_archived_file (entry->the_bfd, member);
		2835
		2836	if (member == NULL)
		2837	break;
		2838
		2839	if (! bfd_check_format (member, bfd_object))
		2840	{
		2841	einfo (_("%F%B: member %B in archive is not an object\n"),
		2842	entry->the_bfd, member);
		2843	loaded = FALSE;
		2844	}
		2845
		2846	subsbfd = member;
		2847	if (!(*link_info.callbacks
		2848	->add_archive_element) (&link_info, member,
		2849	"--whole-archive", &subsbfd))
		2850	abort ();
		2851
		2852	/* Potentially, the add_archive_element hook may have set a
		2853	substitute BFD for us. */
		2854	if (!bfd_link_add_symbols (subsbfd, &link_info))
		2855	{
		2856	einfo (_("%F%B: error adding symbols: %E\n"), member);
		2857	loaded = FALSE;
		2858	}
		2859	}
		2860
		2861	entry->flags.loaded = loaded;
		2862	return loaded;
		2863	}
		2864	break;
		2865	}
		2866
		2867	if (bfd_link_add_symbols (entry->the_bfd, &link_info))
		2868	entry->flags.loaded = TRUE;
		2869	else
		2870	einfo (_("%F%B: error adding symbols: %E\n"), entry->the_bfd);
		2871
		2872	return entry->flags.loaded;
		2873	}
		2874
		2875	/* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
		2876	may be NULL, indicating that it is a wildcard. Separate
		2877	lang_input_section statements are created for each part of the
		2878	expansion; they are added after the wild statement S. OUTPUT is
		2879	the output section. */
		2880
		2881	static void
		2882	wild (lang_wild_statement_type *s,
		2883	const char *target ATTRIBUTE_UNUSED,
		2884	lang_output_section_statement_type *output)
		2885	{
		2886	struct wildcard_list *sec;
		2887
		2888	if (s->handler_data[0]
		2889	&& s->handler_data[0]->spec.sorted == by_name
		2890	&& !s->filenames_sorted)
		2891	{
		2892	lang_section_bst_type *tree;
		2893
		2894	walk_wild (s, output_section_callback_fast, output);
		2895
		2896	tree = s->tree;
		2897	if (tree)
		2898	{
		2899	output_section_callback_tree_to_list (s, tree, output);
		2900	s->tree = NULL;
		2901	}
		2902	}
		2903	else
		2904	walk_wild (s, output_section_callback, output);
		2905
		2906	if (default_common_section == NULL)
		2907	for (sec = s->section_list; sec != NULL; sec = sec->next)
		2908	if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
		2909	{
		2910	/* Remember the section that common is going to in case we
		2911	later get something which doesn't know where to put it. */
		2912	default_common_section = output;
		2913	break;
		2914	}
		2915	}
		2916
		2917	/* Return TRUE iff target is the sought target. */
		2918
		2919	static int
		2920	get_target (const bfd_target target, void data)
		2921	{
		2922	const char sought = (const char ) data;
		2923
		2924	return strcmp (target->name, sought) == 0;
		2925	}
		2926
		2927	/* Like strcpy() but convert to lower case as well. */
		2928
		2929	static void
		2930	stricpy (char dest, char src)
		2931	{
		2932	char c;
		2933
		2934	while ((c = *src++) != 0)
		2935	*dest++ = TOLOWER (c);
		2936
		2937	*dest = 0;
		2938	}
		2939
		2940	/* Remove the first occurrence of needle (if any) in haystack
		2941	from haystack. */
		2942
		2943	static void
		2944	strcut (char haystack, char needle)
		2945	{
		2946	haystack = strstr (haystack, needle);
		2947
		2948	if (haystack)
		2949	{
		2950	char *src;
		2951
		2952	for (src = haystack + strlen (needle); *src;)
		2953	haystack++ = src++;
		2954
		2955	*haystack = 0;
		2956	}
		2957	}
		2958
		2959	/* Compare two target format name strings.
		2960	Return a value indicating how "similar" they are. */
		2961
		2962	static int
		2963	name_compare (char first, char second)
		2964	{
		2965	char *copy1;
		2966	char *copy2;
		2967	int result;
		2968
		2969	copy1 = (char *) xmalloc (strlen (first) + 1);
		2970	copy2 = (char *) xmalloc (strlen (second) + 1);
		2971
		2972	/* Convert the names to lower case. */
		2973	stricpy (copy1, first);
		2974	stricpy (copy2, second);
		2975
		2976	/* Remove size and endian strings from the name. */
		2977	strcut (copy1, "big");
		2978	strcut (copy1, "little");
		2979	strcut (copy2, "big");
		2980	strcut (copy2, "little");
		2981
		2982	/* Return a value based on how many characters match,
		2983	starting from the beginning. If both strings are
		2984	the same then return 10 * their length. */
		2985	for (result = 0; copy1[result] == copy2[result]; result++)
		2986	if (copy1[result] == 0)
		2987	{
		2988	result *= 10;
		2989	break;
		2990	}
		2991
		2992	free (copy1);
		2993	free (copy2);
		2994
		2995	return result;
		2996	}
		2997
		2998	/* Set by closest_target_match() below. */
		2999	static const bfd_target *winner;
		3000
		3001	/* Scan all the valid bfd targets looking for one that has the endianness
		3002	requirement that was specified on the command line, and is the nearest
		3003	match to the original output target. */
		3004
		3005	static int
		3006	closest_target_match (const bfd_target target, void data)
		3007	{
		3008	const bfd_target original = (const bfd_target ) data;
		3009
		3010	if (command_line.endian == ENDIAN_BIG
		3011	&& target->byteorder != BFD_ENDIAN_BIG)
		3012	return 0;
		3013
		3014	if (command_line.endian == ENDIAN_LITTLE
		3015	&& target->byteorder != BFD_ENDIAN_LITTLE)
		3016	return 0;
		3017
		3018	/* Must be the same flavour. */
		3019	if (target->flavour != original->flavour)
		3020	return 0;
		3021
		3022	/* Ignore generic big and little endian elf vectors. */
		3023	if (strcmp (target->name, "elf32-big") == 0
		3024	\|\| strcmp (target->name, "elf64-big") == 0
		3025	\|\| strcmp (target->name, "elf32-little") == 0
		3026	\|\| strcmp (target->name, "elf64-little") == 0)
		3027	return 0;
		3028
		3029	/* If we have not found a potential winner yet, then record this one. */
		3030	if (winner == NULL)
		3031	{
		3032	winner = target;
		3033	return 0;
		3034	}
		3035
		3036	/* Oh dear, we now have two potential candidates for a successful match.
		3037	Compare their names and choose the better one. */
		3038	if (name_compare (target->name, original->name)
		3039	> name_compare (winner->name, original->name))
		3040	winner = target;
		3041
		3042	/* Keep on searching until wqe have checked them all. */
		3043	return 0;
		3044	}
		3045
		3046	/* Return the BFD target format of the first input file. */
		3047
		3048	static char *
		3049	get_first_input_target (void)
		3050	{
		3051	char *target = NULL;
		3052
		3053	LANG_FOR_EACH_INPUT_STATEMENT (s)
		3054	{
		3055	if (s->header.type == lang_input_statement_enum
		3056	&& s->flags.real)
		3057	{
		3058	ldfile_open_file (s);
		3059
		3060	if (s->the_bfd != NULL
		3061	&& bfd_check_format (s->the_bfd, bfd_object))
		3062	{
		3063	target = bfd_get_target (s->the_bfd);
		3064
		3065	if (target != NULL)
		3066	break;
		3067	}
		3068	}
		3069	}
		3070
		3071	return target;
		3072	}
		3073
		3074	const char *
		3075	lang_get_output_target (void)
		3076	{
		3077	const char *target;
		3078
		3079	/* Has the user told us which output format to use? */
		3080	if (output_target != NULL)
		3081	return output_target;
		3082
		3083	/* No - has the current target been set to something other than
		3084	the default? */
		3085	if (current_target != default_target && current_target != NULL)
		3086	return current_target;
		3087
		3088	/* No - can we determine the format of the first input file? */
		3089	target = get_first_input_target ();
		3090	if (target != NULL)
		3091	return target;
		3092
		3093	/* Failed - use the default output target. */
		3094	return default_target;
		3095	}
		3096
		3097	/* Open the output file. */
		3098
		3099	static void
		3100	open_output (const char *name)
		3101	{
		3102	output_target = lang_get_output_target ();
		3103
		3104	/* Has the user requested a particular endianness on the command
		3105	line? */
		3106	if (command_line.endian != ENDIAN_UNSET)
		3107	{
		3108	const bfd_target *target;
		3109	enum bfd_endian desired_endian;
		3110
		3111	/* Get the chosen target. */
		3112	target = bfd_search_for_target (get_target, (void *) output_target);
		3113
		3114	/* If the target is not supported, we cannot do anything. */
		3115	if (target != NULL)
		3116	{
		3117	if (command_line.endian == ENDIAN_BIG)
		3118	desired_endian = BFD_ENDIAN_BIG;
		3119	else
		3120	desired_endian = BFD_ENDIAN_LITTLE;
		3121
		3122	/* See if the target has the wrong endianness. This should
		3123	not happen if the linker script has provided big and
		3124	little endian alternatives, but some scrips don't do
		3125	this. */
		3126	if (target->byteorder != desired_endian)
		3127	{
		3128	/* If it does, then see if the target provides
		3129	an alternative with the correct endianness. */
		3130	if (target->alternative_target != NULL
		3131	&& (target->alternative_target->byteorder == desired_endian))
		3132	output_target = target->alternative_target->name;
		3133	else
		3134	{
		3135	/* Try to find a target as similar as possible to
		3136	the default target, but which has the desired
		3137	endian characteristic. */
		3138	bfd_search_for_target (closest_target_match,
		3139	(void *) target);
		3140
		3141	/* Oh dear - we could not find any targets that
		3142	satisfy our requirements. */
		3143	if (winner == NULL)
		3144	einfo (_("%P: warning: could not find any targets"
		3145	" that match endianness requirement\n"));
		3146	else
		3147	output_target = winner->name;
		3148	}
		3149	}
		3150	}
		3151	}
		3152
		3153	link_info.output_bfd = bfd_openw (name, output_target);
		3154
		3155	if (link_info.output_bfd == NULL)
		3156	{
		3157	if (bfd_get_error () == bfd_error_invalid_target)
		3158	einfo (_("%P%F: target %s not found\n"), output_target);
		3159
		3160	einfo (_("%P%F: cannot open output file %s: %E\n"), name);
		3161	}
		3162
		3163	delete_output_file_on_failure = TRUE;
		3164
		3165	if (! bfd_set_format (link_info.output_bfd, bfd_object))
		3166	einfo (_("%P%F:%s: can not make object file: %E\n"), name);
		3167	if (! bfd_set_arch_mach (link_info.output_bfd,
		3168	ldfile_output_architecture,
		3169	ldfile_output_machine))
		3170	einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
		3171
		3172	link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
		3173	if (link_info.hash == NULL)
		3174	einfo (_("%P%F: can not create hash table: %E\n"));
		3175
		3176	bfd_set_gp_size (link_info.output_bfd, g_switch_value);
		3177	}
		3178
		3179	static void
		3180	ldlang_open_output (lang_statement_union_type *statement)
		3181	{
		3182	switch (statement->header.type)
		3183	{
		3184	case lang_output_statement_enum:
		3185	ASSERT (link_info.output_bfd == NULL);
		3186	open_output (statement->output_statement.name);
		3187	ldemul_set_output_arch ();
6324	serge	3188	if (config.magic_demand_paged
		3189	&& !bfd_link_relocatable (&link_info))
5199	serge	3190	link_info.output_bfd->flags \|= D_PAGED;
		3191	else
		3192	link_info.output_bfd->flags &= ~D_PAGED;
		3193	if (config.text_read_only)
		3194	link_info.output_bfd->flags \|= WP_TEXT;
		3195	else
		3196	link_info.output_bfd->flags &= ~WP_TEXT;
		3197	if (link_info.traditional_format)
		3198	link_info.output_bfd->flags \|= BFD_TRADITIONAL_FORMAT;
		3199	else
		3200	link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
		3201	break;
		3202
		3203	case lang_target_statement_enum:
		3204	current_target = statement->target_statement.target;
		3205	break;
		3206	default:
		3207	break;
		3208	}
		3209	}
		3210
		3211	/* Convert between addresses in bytes and sizes in octets.
		3212	For currently supported targets, octets_per_byte is always a power
		3213	of two, so we can use shifts. */
		3214	#define TO_ADDR(X) ((X) >> opb_shift)
		3215	#define TO_SIZE(X) ((X) << opb_shift)
		3216
		3217	/* Support the above. */
		3218	static unsigned int opb_shift = 0;
		3219
		3220	static void
		3221	init_opb (void)
		3222	{
		3223	unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
		3224	ldfile_output_machine);
		3225	opb_shift = 0;
		3226	if (x > 1)
		3227	while ((x & 1) == 0)
		3228	{
		3229	x >>= 1;
		3230	++opb_shift;
		3231	}
		3232	ASSERT (x == 1);
		3233	}
		3234
		3235	/* Open all the input files. */
		3236
		3237	enum open_bfd_mode
		3238	{
		3239	OPEN_BFD_NORMAL = 0,
		3240	OPEN_BFD_FORCE = 1,
		3241	OPEN_BFD_RESCAN = 2
		3242	};
		3243	#ifdef ENABLE_PLUGINS
		3244	static lang_input_statement_type *plugin_insert = NULL;
		3245	#endif
		3246
		3247	static void
		3248	open_input_bfds (lang_statement_union_type *s, enum open_bfd_mode mode)
		3249	{
		3250	for (; s != NULL; s = s->header.next)
		3251	{
		3252	switch (s->header.type)
		3253	{
		3254	case lang_constructors_statement_enum:
		3255	open_input_bfds (constructor_list.head, mode);
		3256	break;
		3257	case lang_output_section_statement_enum:
		3258	open_input_bfds (s->output_section_statement.children.head, mode);
		3259	break;
		3260	case lang_wild_statement_enum:
		3261	/* Maybe we should load the file's symbols. */
		3262	if ((mode & OPEN_BFD_RESCAN) == 0
		3263	&& s->wild_statement.filename
		3264	&& !wildcardp (s->wild_statement.filename)
		3265	&& !archive_path (s->wild_statement.filename))
		3266	lookup_name (s->wild_statement.filename);
		3267	open_input_bfds (s->wild_statement.children.head, mode);
		3268	break;
		3269	case lang_group_statement_enum:
		3270	{
		3271	struct bfd_link_hash_entry *undefs;
		3272
		3273	/* We must continually search the entries in the group
		3274	until no new symbols are added to the list of undefined
		3275	symbols. */
		3276
		3277	do
		3278	{
		3279	undefs = link_info.hash->undefs_tail;
		3280	open_input_bfds (s->group_statement.children.head,
		3281	mode \| OPEN_BFD_FORCE);
		3282	}
		3283	while (undefs != link_info.hash->undefs_tail);
		3284	}
		3285	break;
		3286	case lang_target_statement_enum:
		3287	current_target = s->target_statement.target;
		3288	break;
		3289	case lang_input_statement_enum:
		3290	if (s->input_statement.flags.real)
		3291	{
		3292	lang_statement_union_type **os_tail;
		3293	lang_statement_list_type add;
6324	serge	3294	bfd *abfd;
5199	serge	3295
		3296	s->input_statement.target = current_target;
		3297
		3298	/* If we are being called from within a group, and this
		3299	is an archive which has already been searched, then
		3300	force it to be researched unless the whole archive
6324	serge	3301	has been loaded already. Do the same for a rescan.
		3302	Likewise reload --as-needed shared libs. */
5199	serge	3303	if (mode != OPEN_BFD_NORMAL
		3304	#ifdef ENABLE_PLUGINS
		3305	&& ((mode & OPEN_BFD_RESCAN) == 0
		3306	\|\| plugin_insert == NULL)
		3307	#endif
		3308	&& s->input_statement.flags.loaded
6324	serge	3309	&& (abfd = s->input_statement.the_bfd) != NULL
		3310	&& ((bfd_get_format (abfd) == bfd_archive
		3311	&& !s->input_statement.flags.whole_archive)
		3312	\|\| (bfd_get_format (abfd) == bfd_object
		3313	&& ((abfd->flags) & DYNAMIC) != 0
5199	serge	3314	&& s->input_statement.flags.add_DT_NEEDED_for_regular
6324	serge	3315	&& bfd_get_flavour (abfd) == bfd_target_elf_flavour
		3316	&& (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)))
5199	serge	3317	{
		3318	s->input_statement.flags.loaded = FALSE;
		3319	s->input_statement.flags.reload = TRUE;
		3320	}
		3321
		3322	os_tail = lang_output_section_statement.tail;
		3323	lang_list_init (&add);
		3324
		3325	if (! load_symbols (&s->input_statement, &add))
		3326	config.make_executable = FALSE;
		3327
		3328	if (add.head != NULL)
		3329	{
		3330	/* If this was a script with output sections then
		3331	tack any added statements on to the end of the
		3332	list. This avoids having to reorder the output
		3333	section statement list. Very likely the user
		3334	forgot -T, and whatever we do here will not meet
		3335	naive user expectations. */
		3336	if (os_tail != lang_output_section_statement.tail)
		3337	{
		3338	einfo (_("%P: warning: %s contains output sections;"
		3339	" did you forget -T?\n"),
		3340	s->input_statement.filename);
		3341	*stat_ptr->tail = add.head;
		3342	stat_ptr->tail = add.tail;
		3343	}
		3344	else
		3345	{
		3346	*add.tail = s->header.next;
		3347	s->header.next = add.head;
		3348	}
		3349	}
		3350	}
		3351	#ifdef ENABLE_PLUGINS
		3352	/* If we have found the point at which a plugin added new
		3353	files, clear plugin_insert to enable archive rescan. */
		3354	if (&s->input_statement == plugin_insert)
		3355	plugin_insert = NULL;
		3356	#endif
		3357	break;
		3358	case lang_assignment_statement_enum:
		3359	if (s->assignment_statement.exp->assign.defsym)
		3360	/* This is from a --defsym on the command line. */
		3361	exp_fold_tree_no_dot (s->assignment_statement.exp);
		3362	break;
		3363	default:
		3364	break;
		3365	}
		3366	}
		3367
		3368	/* Exit if any of the files were missing. */
		3369	if (input_flags.missing_file)
		3370	einfo ("%F");
		3371	}
		3372
		3373	/* Add the supplied name to the symbol table as an undefined reference.
		3374	This is a two step process as the symbol table doesn't even exist at
		3375	the time the ld command line is processed. First we put the name
		3376	on a list, then, once the output file has been opened, transfer the
		3377	name to the symbol table. */
		3378
		3379	typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
		3380
		3381	#define ldlang_undef_chain_list_head entry_symbol.next
		3382
		3383	void
		3384	ldlang_add_undef (const char *const name, bfd_boolean cmdline)
		3385	{
		3386	ldlang_undef_chain_list_type *new_undef;
		3387
		3388	undef_from_cmdline = undef_from_cmdline \|\| cmdline;
		3389	new_undef = (ldlang_undef_chain_list_type ) stat_alloc (sizeof (new_undef));
		3390	new_undef->next = ldlang_undef_chain_list_head;
		3391	ldlang_undef_chain_list_head = new_undef;
		3392
		3393	new_undef->name = xstrdup (name);
		3394
		3395	if (link_info.output_bfd != NULL)
		3396	insert_undefined (new_undef->name);
		3397	}
		3398
		3399	/* Insert NAME as undefined in the symbol table. */
		3400
		3401	static void
		3402	insert_undefined (const char *name)
		3403	{
		3404	struct bfd_link_hash_entry *h;
		3405
		3406	h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
		3407	if (h == NULL)
		3408	einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
		3409	if (h->type == bfd_link_hash_new)
		3410	{
		3411	h->type = bfd_link_hash_undefined;
		3412	h->u.undef.abfd = NULL;
		3413	bfd_link_add_undef (link_info.hash, h);
		3414	}
		3415	}
		3416
		3417	/* Run through the list of undefineds created above and place them
		3418	into the linker hash table as undefined symbols belonging to the
		3419	script file. */
		3420
		3421	static void
		3422	lang_place_undefineds (void)
		3423	{
		3424	ldlang_undef_chain_list_type *ptr;
		3425
		3426	for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
		3427	insert_undefined (ptr->name);
		3428	}
		3429
6324	serge	3430	/* Structure used to build the list of symbols that the user has required
		3431	be defined. */
		3432
		3433	struct require_defined_symbol
		3434	{
		3435	const char *name;
		3436	struct require_defined_symbol *next;
		3437	};
		3438
		3439	/* The list of symbols that the user has required be defined. */
		3440
		3441	static struct require_defined_symbol *require_defined_symbol_list;
		3442
		3443	/* Add a new symbol NAME to the list of symbols that are required to be
		3444	defined. */
		3445
		3446	void
		3447	ldlang_add_require_defined (const char * const name)
		3448	{
		3449	struct require_defined_symbol *ptr;
		3450
		3451	ldlang_add_undef (name, TRUE);
		3452	ptr = (struct require_defined_symbol ) stat_alloc (sizeof (ptr));
		3453	ptr->next = require_defined_symbol_list;
		3454	ptr->name = strdup (name);
		3455	require_defined_symbol_list = ptr;
		3456	}
		3457
		3458	/* Check that all symbols the user required to be defined, are defined,
		3459	raise an error if we find a symbol that is not defined. */
		3460
		3461	static void
		3462	ldlang_check_require_defined_symbols (void)
		3463	{
		3464	struct require_defined_symbol *ptr;
		3465
		3466	for (ptr = require_defined_symbol_list; ptr != NULL; ptr = ptr->next)
		3467	{
		3468	struct bfd_link_hash_entry *h;
		3469
		3470	h = bfd_link_hash_lookup (link_info.hash, ptr->name,
		3471	FALSE, FALSE, TRUE);
		3472	if (h == NULL
		3473	\|\| (h->type != bfd_link_hash_defined
		3474	&& h->type != bfd_link_hash_defweak))
		3475	einfo(_("%P%X: required symbol `%s' not defined\n"), ptr->name);
		3476	}
		3477	}
		3478
5199	serge	3479	/* Check for all readonly or some readwrite sections. */
		3480
		3481	static void
		3482	check_input_sections
		3483	(lang_statement_union_type *s,
		3484	lang_output_section_statement_type *output_section_statement)
		3485	{
		3486	for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
		3487	{
		3488	switch (s->header.type)
		3489	{
		3490	case lang_wild_statement_enum:
		3491	walk_wild (&s->wild_statement, check_section_callback,
		3492	output_section_statement);
		3493	if (! output_section_statement->all_input_readonly)
		3494	return;
		3495	break;
		3496	case lang_constructors_statement_enum:
		3497	check_input_sections (constructor_list.head,
		3498	output_section_statement);
		3499	if (! output_section_statement->all_input_readonly)
		3500	return;
		3501	break;
		3502	case lang_group_statement_enum:
		3503	check_input_sections (s->group_statement.children.head,
		3504	output_section_statement);
		3505	if (! output_section_statement->all_input_readonly)
		3506	return;
		3507	break;
		3508	default:
		3509	break;
		3510	}
		3511	}
		3512	}
		3513
		3514	/* Update wildcard statements if needed. */
		3515
		3516	static void
		3517	update_wild_statements (lang_statement_union_type *s)
		3518	{
		3519	struct wildcard_list *sec;
		3520
		3521	switch (sort_section)
		3522	{
		3523	default:
		3524	FAIL ();
		3525
		3526	case none:
		3527	break;
		3528
		3529	case by_name:
		3530	case by_alignment:
		3531	for (; s != NULL; s = s->header.next)
		3532	{
		3533	switch (s->header.type)
		3534	{
		3535	default:
		3536	break;
		3537
		3538	case lang_wild_statement_enum:
		3539	for (sec = s->wild_statement.section_list; sec != NULL;
		3540	sec = sec->next)
		3541	{
		3542	switch (sec->spec.sorted)
		3543	{
		3544	case none:
		3545	sec->spec.sorted = sort_section;
		3546	break;
		3547	case by_name:
		3548	if (sort_section == by_alignment)
		3549	sec->spec.sorted = by_name_alignment;
		3550	break;
		3551	case by_alignment:
		3552	if (sort_section == by_name)
		3553	sec->spec.sorted = by_alignment_name;
		3554	break;
		3555	default:
		3556	break;
		3557	}
		3558	}
		3559	break;
		3560
		3561	case lang_constructors_statement_enum:
		3562	update_wild_statements (constructor_list.head);
		3563	break;
		3564
		3565	case lang_output_section_statement_enum:
		3566	/* Don't sort .init/.fini sections. */
		3567	if (strcmp (s->output_section_statement.name, ".init") != 0
		3568	&& strcmp (s->output_section_statement.name, ".fini") != 0)
		3569	update_wild_statements
		3570	(s->output_section_statement.children.head);
		3571	break;
		3572
		3573	case lang_group_statement_enum:
		3574	update_wild_statements (s->group_statement.children.head);
		3575	break;
		3576	}
		3577	}
		3578	break;
		3579	}
		3580	}
		3581
		3582	/* Open input files and attach to output sections. */
		3583
		3584	static void
		3585	map_input_to_output_sections
		3586	(lang_statement_union_type s, const char target,
		3587	lang_output_section_statement_type *os)
		3588	{
		3589	for (; s != NULL; s = s->header.next)
		3590	{
		3591	lang_output_section_statement_type *tos;
		3592	flagword flags;
		3593
		3594	switch (s->header.type)
		3595	{
		3596	case lang_wild_statement_enum:
		3597	wild (&s->wild_statement, target, os);
		3598	break;
		3599	case lang_constructors_statement_enum:
		3600	map_input_to_output_sections (constructor_list.head,
		3601	target,
		3602	os);
		3603	break;
		3604	case lang_output_section_statement_enum:
		3605	tos = &s->output_section_statement;
		3606	if (tos->constraint != 0)
		3607	{
		3608	if (tos->constraint != ONLY_IF_RW
		3609	&& tos->constraint != ONLY_IF_RO)
		3610	break;
		3611	tos->all_input_readonly = TRUE;
		3612	check_input_sections (tos->children.head, tos);
		3613	if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))
		3614	{
		3615	tos->constraint = -1;
		3616	break;
		3617	}
		3618	}
		3619	map_input_to_output_sections (tos->children.head,
		3620	target,
		3621	tos);
		3622	break;
		3623	case lang_output_statement_enum:
		3624	break;
		3625	case lang_target_statement_enum:
		3626	target = s->target_statement.target;
		3627	break;
		3628	case lang_group_statement_enum:
		3629	map_input_to_output_sections (s->group_statement.children.head,
		3630	target,
		3631	os);
		3632	break;
		3633	case lang_data_statement_enum:
		3634	/* Make sure that any sections mentioned in the expression
		3635	are initialized. */
		3636	exp_init_os (s->data_statement.exp);
		3637	/* The output section gets CONTENTS, ALLOC and LOAD, but
		3638	these may be overridden by the script. */
		3639	flags = SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD;
		3640	switch (os->sectype)
		3641	{
		3642	case normal_section:
		3643	case overlay_section:
		3644	break;
		3645	case noalloc_section:
		3646	flags = SEC_HAS_CONTENTS;
		3647	break;
		3648	case noload_section:
		3649	if (bfd_get_flavour (link_info.output_bfd)
		3650	== bfd_target_elf_flavour)
		3651	flags = SEC_NEVER_LOAD \| SEC_ALLOC;
		3652	else
		3653	flags = SEC_NEVER_LOAD \| SEC_HAS_CONTENTS;
		3654	break;
		3655	}
		3656	if (os->bfd_section == NULL)
		3657	init_os (os, flags);
		3658	else
		3659	os->bfd_section->flags \|= flags;
		3660	break;
		3661	case lang_input_section_enum:
		3662	break;
		3663	case lang_fill_statement_enum:
		3664	case lang_object_symbols_statement_enum:
		3665	case lang_reloc_statement_enum:
		3666	case lang_padding_statement_enum:
		3667	case lang_input_statement_enum:
		3668	if (os != NULL && os->bfd_section == NULL)
		3669	init_os (os, 0);
		3670	break;
		3671	case lang_assignment_statement_enum:
		3672	if (os != NULL && os->bfd_section == NULL)
		3673	init_os (os, 0);
		3674
		3675	/* Make sure that any sections mentioned in the assignment
		3676	are initialized. */
		3677	exp_init_os (s->assignment_statement.exp);
		3678	break;
		3679	case lang_address_statement_enum:
		3680	/* Mark the specified section with the supplied address.
		3681	If this section was actually a segment marker, then the
		3682	directive is ignored if the linker script explicitly
		3683	processed the segment marker. Originally, the linker
		3684	treated segment directives (like -Ttext on the
		3685	command-line) as section directives. We honor the
		3686	section directive semantics for backwards compatibilty;
		3687	linker scripts that do not specifically check for
		3688	SEGMENT_START automatically get the old semantics. */
		3689	if (!s->address_statement.segment
		3690	\|\| !s->address_statement.segment->used)
		3691	{
		3692	const char *name = s->address_statement.section_name;
		3693
		3694	/* Create the output section statement here so that
		3695	orphans with a set address will be placed after other
		3696	script sections. If we let the orphan placement code
		3697	place them in amongst other sections then the address
		3698	will affect following script sections, which is
		3699	likely to surprise naive users. */
		3700	tos = lang_output_section_statement_lookup (name, 0, TRUE);
		3701	tos->addr_tree = s->address_statement.address;
		3702	if (tos->bfd_section == NULL)
		3703	init_os (tos, 0);
		3704	}
		3705	break;
		3706	case lang_insert_statement_enum:
		3707	break;
		3708	}
		3709	}
		3710	}
		3711
		3712	/* An insert statement snips out all the linker statements from the
		3713	start of the list and places them after the output section
		3714	statement specified by the insert. This operation is complicated
		3715	by the fact that we keep a doubly linked list of output section
		3716	statements as well as the singly linked list of all statements. */
		3717
		3718	static void
		3719	process_insert_statements (void)
		3720	{
		3721	lang_statement_union_type **s;
		3722	lang_output_section_statement_type *first_os = NULL;
		3723	lang_output_section_statement_type *last_os = NULL;
		3724	lang_output_section_statement_type *os;
		3725
		3726	/* "start of list" is actually the statement immediately after
		3727	the special abs_section output statement, so that it isn't
		3728	reordered. */
		3729	s = &lang_output_section_statement.head;
		3730	while ((s = &(s)->header.next) != NULL)
		3731	{
		3732	if ((*s)->header.type == lang_output_section_statement_enum)
		3733	{
		3734	/* Keep pointers to the first and last output section
		3735	statement in the sequence we may be about to move. */
		3736	os = &(*s)->output_section_statement;
		3737
		3738	ASSERT (last_os == NULL \|\| last_os->next == os);
		3739	last_os = os;
		3740
		3741	/* Set constraint negative so that lang_output_section_find
		3742	won't match this output section statement. At this
		3743	stage in linking constraint has values in the range
		3744	[-1, ONLY_IN_RW]. */
		3745	last_os->constraint = -2 - last_os->constraint;
		3746	if (first_os == NULL)
		3747	first_os = last_os;
		3748	}
		3749	else if ((*s)->header.type == lang_insert_statement_enum)
		3750	{
		3751	lang_insert_statement_type i = &(s)->insert_statement;
		3752	lang_output_section_statement_type *where;
		3753	lang_statement_union_type **ptr;
		3754	lang_statement_union_type *first;
		3755
		3756	where = lang_output_section_find (i->where);
		3757	if (where != NULL && i->is_before)
		3758	{
		3759	do
		3760	where = where->prev;
		3761	while (where != NULL && where->constraint < 0);
		3762	}
		3763	if (where == NULL)
		3764	{
		3765	einfo (_("%F%P: %s not found for insert\n"), i->where);
		3766	return;
		3767	}
		3768
		3769	/* Deal with reordering the output section statement list. */
		3770	if (last_os != NULL)
		3771	{
		3772	asection first_sec, last_sec;
		3773	struct lang_output_section_statement_struct **next;
		3774
		3775	/* Snip out the output sections we are moving. */
		3776	first_os->prev->next = last_os->next;
		3777	if (last_os->next == NULL)
		3778	{
		3779	next = &first_os->prev->next;
		3780	lang_output_section_statement.tail
		3781	= (lang_statement_union_type **) next;
		3782	}
		3783	else
		3784	last_os->next->prev = first_os->prev;
		3785	/* Add them in at the new position. */
		3786	last_os->next = where->next;
		3787	if (where->next == NULL)
		3788	{
		3789	next = &last_os->next;
		3790	lang_output_section_statement.tail
		3791	= (lang_statement_union_type **) next;
		3792	}
		3793	else
		3794	where->next->prev = last_os;
		3795	first_os->prev = where;
		3796	where->next = first_os;
		3797
		3798	/* Move the bfd sections in the same way. */
		3799	first_sec = NULL;
		3800	last_sec = NULL;
		3801	for (os = first_os; os != NULL; os = os->next)
		3802	{
		3803	os->constraint = -2 - os->constraint;
		3804	if (os->bfd_section != NULL
		3805	&& os->bfd_section->owner != NULL)
		3806	{
		3807	last_sec = os->bfd_section;
		3808	if (first_sec == NULL)
		3809	first_sec = last_sec;
		3810	}
		3811	if (os == last_os)
		3812	break;
		3813	}
		3814	if (last_sec != NULL)
		3815	{
		3816	asection *sec = where->bfd_section;
		3817	if (sec == NULL)
		3818	sec = output_prev_sec_find (where);
		3819
		3820	/* The place we want to insert must come after the
		3821	sections we are moving. So if we find no
		3822	section or if the section is the same as our
		3823	last section, then no move is needed. */
		3824	if (sec != NULL && sec != last_sec)
		3825	{
		3826	/* Trim them off. */
		3827	if (first_sec->prev != NULL)
		3828	first_sec->prev->next = last_sec->next;
		3829	else
		3830	link_info.output_bfd->sections = last_sec->next;
		3831	if (last_sec->next != NULL)
		3832	last_sec->next->prev = first_sec->prev;
		3833	else
		3834	link_info.output_bfd->section_last = first_sec->prev;
		3835	/* Add back. */
		3836	last_sec->next = sec->next;
		3837	if (sec->next != NULL)
		3838	sec->next->prev = last_sec;
		3839	else
		3840	link_info.output_bfd->section_last = last_sec;
		3841	first_sec->prev = sec;
		3842	sec->next = first_sec;
		3843	}
		3844	}
		3845
		3846	first_os = NULL;
		3847	last_os = NULL;
		3848	}
		3849
		3850	ptr = insert_os_after (where);
		3851	/* Snip everything after the abs_section output statement we
		3852	know is at the start of the list, up to and including
		3853	the insert statement we are currently processing. */
		3854	first = lang_output_section_statement.head->header.next;
		3855	lang_output_section_statement.head->header.next = (*s)->header.next;
		3856	/* Add them back where they belong. */
		3857	s = ptr;
		3858	if (*s == NULL)
		3859	statement_list.tail = s;
		3860	*ptr = first;
		3861	s = &lang_output_section_statement.head;
		3862	}
		3863	}
		3864
		3865	/* Undo constraint twiddling. */
		3866	for (os = first_os; os != NULL; os = os->next)
		3867	{
		3868	os->constraint = -2 - os->constraint;
		3869	if (os == last_os)
		3870	break;
		3871	}
		3872	}
		3873
		3874	/* An output section might have been removed after its statement was
		3875	added. For example, ldemul_before_allocation can remove dynamic
		3876	sections if they turn out to be not needed. Clean them up here. */
		3877
		3878	void
		3879	strip_excluded_output_sections (void)
		3880	{
		3881	lang_output_section_statement_type *os;
		3882
		3883	/* Run lang_size_sections (if not already done). */
		3884	if (expld.phase != lang_mark_phase_enum)
		3885	{
		3886	expld.phase = lang_mark_phase_enum;
		3887	expld.dataseg.phase = exp_dataseg_none;
		3888	one_lang_size_sections_pass (NULL, FALSE);
		3889	lang_reset_memory_regions ();
		3890	}
		3891
		3892	for (os = &lang_output_section_statement.head->output_section_statement;
		3893	os != NULL;
		3894	os = os->next)
		3895	{
		3896	asection *output_section;
		3897	bfd_boolean exclude;
		3898
		3899	if (os->constraint < 0)
		3900	continue;
		3901
		3902	output_section = os->bfd_section;
		3903	if (output_section == NULL)
		3904	continue;
		3905
		3906	exclude = (output_section->rawsize == 0
		3907	&& (output_section->flags & SEC_KEEP) == 0
		3908	&& !bfd_section_removed_from_list (link_info.output_bfd,
		3909	output_section));
		3910
		3911	/* Some sections have not yet been sized, notably .gnu.version,
		3912	.dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
		3913	input sections, so don't drop output sections that have such
		3914	input sections unless they are also marked SEC_EXCLUDE. */
		3915	if (exclude && output_section->map_head.s != NULL)
		3916	{
		3917	asection *s;
		3918
		3919	for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
		3920	if ((s->flags & SEC_EXCLUDE) == 0
		3921	&& ((s->flags & SEC_LINKER_CREATED) != 0
		3922	\|\| link_info.emitrelocations))
		3923	{
		3924	exclude = FALSE;
		3925	break;
		3926	}
		3927	}
		3928
		3929	if (exclude)
		3930	{
		3931	/* We don't set bfd_section to NULL since bfd_section of the
		3932	removed output section statement may still be used. */
		3933	if (!os->update_dot)
		3934	os->ignored = TRUE;
		3935	output_section->flags \|= SEC_EXCLUDE;
		3936	bfd_section_list_remove (link_info.output_bfd, output_section);
		3937	link_info.output_bfd->section_count--;
		3938	}
		3939	}
6324	serge	3940	}
5199	serge	3941
6324	serge	3942	/* Called from ldwrite to clear out asection.map_head and
		3943	asection.map_tail for use as link_orders in ldwrite.
		3944	FIXME: Except for sh64elf.em which starts creating link_orders in
		3945	its after_allocation routine so needs to call it early. */
		3946
		3947	void
		3948	lang_clear_os_map (void)
		3949	{
		3950	lang_output_section_statement_type *os;
		3951
		3952	if (map_head_is_link_order)
		3953	return;
		3954
		3955	for (os = &lang_output_section_statement.head->output_section_statement;
		3956	os != NULL;
		3957	os = os->next)
		3958	{
		3959	asection *output_section;
		3960
		3961	if (os->constraint < 0)
		3962	continue;
		3963
		3964	output_section = os->bfd_section;
		3965	if (output_section == NULL)
		3966	continue;
		3967
		3968	/* TODO: Don't just junk map_head.s, turn them into link_orders. */
		3969	output_section->map_head.link_order = NULL;
		3970	output_section->map_tail.link_order = NULL;
		3971	}
		3972
5199	serge	3973	/* Stop future calls to lang_add_section from messing with map_head
		3974	and map_tail link_order fields. */
6324	serge	3975	map_head_is_link_order = TRUE;
5199	serge	3976	}
		3977
		3978	static void
		3979	print_output_section_statement
		3980	(lang_output_section_statement_type *output_section_statement)
		3981	{
		3982	asection *section = output_section_statement->bfd_section;
		3983	int len;
		3984
		3985	if (output_section_statement != abs_output_section)
		3986	{
		3987	minfo ("\n%s", output_section_statement->name);
		3988
		3989	if (section != NULL)
		3990	{
		3991	print_dot = section->vma;
		3992
		3993	len = strlen (output_section_statement->name);
		3994	if (len >= SECTION_NAME_MAP_LENGTH - 1)
		3995	{
		3996	print_nl ();
		3997	len = 0;
		3998	}
		3999	while (len < SECTION_NAME_MAP_LENGTH)
		4000	{
		4001	print_space ();
		4002	++len;
		4003	}
		4004
		4005	minfo ("0x%V %W", section->vma, section->size);
		4006
		4007	if (section->vma != section->lma)
		4008	minfo (_(" load address 0x%V"), section->lma);
		4009
		4010	if (output_section_statement->update_dot_tree != NULL)
		4011	exp_fold_tree (output_section_statement->update_dot_tree,
		4012	bfd_abs_section_ptr, &print_dot);
		4013	}
		4014
		4015	print_nl ();
		4016	}
		4017
		4018	print_statement_list (output_section_statement->children.head,
		4019	output_section_statement);
		4020	}
		4021
		4022	static void
		4023	print_assignment (lang_assignment_statement_type *assignment,
		4024	lang_output_section_statement_type *output_section)
		4025	{
		4026	unsigned int i;
		4027	bfd_boolean is_dot;
		4028	etree_type *tree;
		4029	asection *osec;
		4030
		4031	for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
		4032	print_space ();
		4033
		4034	if (assignment->exp->type.node_class == etree_assert)
		4035	{
		4036	is_dot = FALSE;
		4037	tree = assignment->exp->assert_s.child;
		4038	}
		4039	else
		4040	{
		4041	const char *dst = assignment->exp->assign.dst;
		4042
		4043	is_dot = (dst[0] == '.' && dst[1] == 0);
6324	serge	4044	if (!is_dot)
5199	serge	4045	expld.assign_name = dst;
		4046	tree = assignment->exp->assign.src;
		4047	}
		4048
		4049	osec = output_section->bfd_section;
		4050	if (osec == NULL)
		4051	osec = bfd_abs_section_ptr;
6324	serge	4052
		4053	if (assignment->exp->type.node_class != etree_provide)
5199	serge	4054	exp_fold_tree (tree, osec, &print_dot);
6324	serge	4055	else
		4056	expld.result.valid_p = FALSE;
		4057
5199	serge	4058	if (expld.result.valid_p)
		4059	{
		4060	bfd_vma value;
		4061
		4062	if (assignment->exp->type.node_class == etree_assert
		4063	\|\| is_dot
		4064	\|\| expld.assign_name != NULL)
		4065	{
		4066	value = expld.result.value;
		4067
		4068	if (expld.result.section != NULL)
		4069	value += expld.result.section->vma;
		4070
		4071	minfo ("0x%V", value);
		4072	if (is_dot)
		4073	print_dot = value;
		4074	}
		4075	else
		4076	{
		4077	struct bfd_link_hash_entry *h;
		4078
		4079	h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
		4080	FALSE, FALSE, TRUE);
		4081	if (h)
		4082	{
		4083	value = h->u.def.value;
		4084	value += h->u.def.section->output_section->vma;
		4085	value += h->u.def.section->output_offset;
		4086
		4087	minfo ("[0x%V]", value);
		4088	}
		4089	else
		4090	minfo ("[unresolved]");
		4091	}
		4092	}
		4093	else
		4094	{
6324	serge	4095	if (assignment->exp->type.node_class == etree_provide)
		4096	minfo ("[!provide]");
		4097	else
5199	serge	4098	minfo ("undef ");
		4099	#ifdef BFD64
		4100	minfo (" ");
		4101	#endif
		4102	}
		4103	expld.assign_name = NULL;
		4104
		4105	minfo (" ");
		4106	exp_print_tree (assignment->exp);
		4107	print_nl ();
		4108	}
		4109
		4110	static void
		4111	print_input_statement (lang_input_statement_type *statm)
		4112	{
		4113	if (statm->filename != NULL
		4114	&& (statm->the_bfd == NULL
		4115	\|\| (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))
		4116	fprintf (config.map_file, "LOAD %s\n", statm->filename);
		4117	}
		4118
		4119	/* Print all symbols defined in a particular section. This is called
		4120	via bfd_link_hash_traverse, or by print_all_symbols. */
		4121
		4122	static bfd_boolean
		4123	print_one_symbol (struct bfd_link_hash_entry hash_entry, void ptr)
		4124	{
		4125	asection sec = (asection ) ptr;
		4126
		4127	if ((hash_entry->type == bfd_link_hash_defined
		4128	\|\| hash_entry->type == bfd_link_hash_defweak)
		4129	&& sec == hash_entry->u.def.section)
		4130	{
		4131	int i;
		4132
		4133	for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
		4134	print_space ();
		4135	minfo ("0x%V ",
		4136	(hash_entry->u.def.value
		4137	+ hash_entry->u.def.section->output_offset
		4138	+ hash_entry->u.def.section->output_section->vma));
		4139
		4140	minfo (" %T\n", hash_entry->root.string);
		4141	}
		4142
		4143	return TRUE;
		4144	}
		4145
		4146	static int
		4147	hash_entry_addr_cmp (const void a, const void b)
		4148	{
		4149	const struct bfd_link_hash_entry l = (const struct bfd_link_hash_entry **)a;
		4150	const struct bfd_link_hash_entry r = (const struct bfd_link_hash_entry **)b;
		4151
		4152	if (l->u.def.value < r->u.def.value)
		4153	return -1;
		4154	else if (l->u.def.value > r->u.def.value)
		4155	return 1;
		4156	else
		4157	return 0;
		4158	}
		4159
		4160	static void
		4161	print_all_symbols (asection *sec)
		4162	{
6324	serge	4163	input_section_userdata_type *ud
		4164	= (input_section_userdata_type *) get_userdata (sec);
5199	serge	4165	struct map_symbol_def *def;
		4166	struct bfd_link_hash_entry **entries;
		4167	unsigned int i;
		4168
		4169	if (!ud)
		4170	return;
		4171
		4172	*ud->map_symbol_def_tail = 0;
		4173
		4174	/* Sort the symbols by address. */
		4175	entries = (struct bfd_link_hash_entry **)
		4176	obstack_alloc (&map_obstack, ud->map_symbol_def_count * sizeof (*entries));
		4177
		4178	for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)
		4179	entries[i] = def->entry;
		4180
		4181	qsort (entries, ud->map_symbol_def_count, sizeof (*entries),
		4182	hash_entry_addr_cmp);
		4183
		4184	/* Print the symbols. */
		4185	for (i = 0; i < ud->map_symbol_def_count; i++)
		4186	print_one_symbol (entries[i], sec);
		4187
		4188	obstack_free (&map_obstack, entries);
		4189	}
		4190
		4191	/* Print information about an input section to the map file. */
		4192
		4193	static void
		4194	print_input_section (asection *i, bfd_boolean is_discarded)
		4195	{
		4196	bfd_size_type size = i->size;
		4197	int len;
		4198	bfd_vma addr;
		4199
		4200	init_opb ();
		4201
		4202	print_space ();
		4203	minfo ("%s", i->name);
		4204
		4205	len = 1 + strlen (i->name);
		4206	if (len >= SECTION_NAME_MAP_LENGTH - 1)
		4207	{
		4208	print_nl ();
		4209	len = 0;
		4210	}
		4211	while (len < SECTION_NAME_MAP_LENGTH)
		4212	{
		4213	print_space ();
		4214	++len;
		4215	}
		4216
		4217	if (i->output_section != NULL
		4218	&& i->output_section->owner == link_info.output_bfd)
		4219	addr = i->output_section->vma + i->output_offset;
		4220	else
		4221	{
		4222	addr = print_dot;
		4223	if (!is_discarded)
		4224	size = 0;
		4225	}
		4226
		4227	minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
		4228
		4229	if (size != i->rawsize && i->rawsize != 0)
		4230	{
		4231	len = SECTION_NAME_MAP_LENGTH + 3;
		4232	#ifdef BFD64
		4233	len += 16;
		4234	#else
		4235	len += 8;
		4236	#endif
		4237	while (len > 0)
		4238	{
		4239	print_space ();
		4240	--len;
		4241	}
		4242
		4243	minfo (_("%W (size before relaxing)\n"), i->rawsize);
		4244	}
		4245
		4246	if (i->output_section != NULL
		4247	&& i->output_section->owner == link_info.output_bfd)
		4248	{
		4249	if (link_info.reduce_memory_overheads)
		4250	bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
		4251	else
		4252	print_all_symbols (i);
		4253
		4254	/* Update print_dot, but make sure that we do not move it
		4255	backwards - this could happen if we have overlays and a
		4256	later overlay is shorter than an earier one. */
		4257	if (addr + TO_ADDR (size) > print_dot)
		4258	print_dot = addr + TO_ADDR (size);
		4259	}
		4260	}
		4261
		4262	static void
		4263	print_fill_statement (lang_fill_statement_type *fill)
		4264	{
		4265	size_t size;
		4266	unsigned char *p;
		4267	fputs (" FILL mask 0x", config.map_file);
		4268	for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
		4269	fprintf (config.map_file, "%02x", *p);
		4270	fputs ("\n", config.map_file);
		4271	}
		4272
		4273	static void
		4274	print_data_statement (lang_data_statement_type *data)
		4275	{
		4276	int i;
		4277	bfd_vma addr;
		4278	bfd_size_type size;
		4279	const char *name;
		4280
		4281	init_opb ();
		4282	for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
		4283	print_space ();
		4284
		4285	addr = data->output_offset;
		4286	if (data->output_section != NULL)
		4287	addr += data->output_section->vma;
		4288
		4289	switch (data->type)
		4290	{
		4291	default:
		4292	abort ();
		4293	case BYTE:
		4294	size = BYTE_SIZE;
		4295	name = "BYTE";
		4296	break;
		4297	case SHORT:
		4298	size = SHORT_SIZE;
		4299	name = "SHORT";
		4300	break;
		4301	case LONG:
		4302	size = LONG_SIZE;
		4303	name = "LONG";
		4304	break;
		4305	case QUAD:
		4306	size = QUAD_SIZE;
		4307	name = "QUAD";
		4308	break;
		4309	case SQUAD:
		4310	size = QUAD_SIZE;
		4311	name = "SQUAD";
		4312	break;
		4313	}
		4314
		4315	minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
		4316
		4317	if (data->exp->type.node_class != etree_value)
		4318	{
		4319	print_space ();
		4320	exp_print_tree (data->exp);
		4321	}
		4322
		4323	print_nl ();
		4324
		4325	print_dot = addr + TO_ADDR (size);
		4326	}
		4327
		4328	/* Print an address statement. These are generated by options like
		4329	-Ttext. */
		4330
		4331	static void
		4332	print_address_statement (lang_address_statement_type *address)
		4333	{
		4334	minfo (_("Address of section %s set to "), address->section_name);
		4335	exp_print_tree (address->address);
		4336	print_nl ();
		4337	}
		4338
		4339	/* Print a reloc statement. */
		4340
		4341	static void
		4342	print_reloc_statement (lang_reloc_statement_type *reloc)
		4343	{
		4344	int i;
		4345	bfd_vma addr;
		4346	bfd_size_type size;
		4347
		4348	init_opb ();
		4349	for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
		4350	print_space ();
		4351
		4352	addr = reloc->output_offset;
		4353	if (reloc->output_section != NULL)
		4354	addr += reloc->output_section->vma;
		4355
		4356	size = bfd_get_reloc_size (reloc->howto);
		4357
		4358	minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
		4359
		4360	if (reloc->name != NULL)
		4361	minfo ("%s+", reloc->name);
		4362	else
		4363	minfo ("%s+", reloc->section->name);
		4364
		4365	exp_print_tree (reloc->addend_exp);
		4366
		4367	print_nl ();
		4368
		4369	print_dot = addr + TO_ADDR (size);
		4370	}
		4371
		4372	static void
		4373	print_padding_statement (lang_padding_statement_type *s)
		4374	{
		4375	int len;
		4376	bfd_vma addr;
		4377
		4378	init_opb ();
		4379	minfo (" fill");
		4380
		4381	len = sizeof " fill" - 1;
		4382	while (len < SECTION_NAME_MAP_LENGTH)
		4383	{
		4384	print_space ();
		4385	++len;
		4386	}
		4387
		4388	addr = s->output_offset;
		4389	if (s->output_section != NULL)
		4390	addr += s->output_section->vma;
		4391	minfo ("0x%V %W ", addr, (bfd_vma) s->size);
		4392
		4393	if (s->fill->size != 0)
		4394	{
		4395	size_t size;
		4396	unsigned char *p;
		4397	for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
		4398	fprintf (config.map_file, "%02x", *p);
		4399	}
		4400
		4401	print_nl ();
		4402
		4403	print_dot = addr + TO_ADDR (s->size);
		4404	}
		4405
		4406	static void
		4407	print_wild_statement (lang_wild_statement_type *w,
		4408	lang_output_section_statement_type *os)
		4409	{
		4410	struct wildcard_list *sec;
		4411
		4412	print_space ();
		4413
		4414	if (w->filenames_sorted)
		4415	minfo ("SORT(");
		4416	if (w->filename != NULL)
		4417	minfo ("%s", w->filename);
		4418	else
		4419	minfo ("*");
		4420	if (w->filenames_sorted)
		4421	minfo (")");
		4422
		4423	minfo ("(");
		4424	for (sec = w->section_list; sec; sec = sec->next)
		4425	{
		4426	if (sec->spec.sorted)
		4427	minfo ("SORT(");
		4428	if (sec->spec.exclude_name_list != NULL)
		4429	{
		4430	name_list *tmp;
		4431	minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
		4432	for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
		4433	minfo (" %s", tmp->name);
		4434	minfo (") ");
		4435	}
		4436	if (sec->spec.name != NULL)
		4437	minfo ("%s", sec->spec.name);
		4438	else
		4439	minfo ("*");
		4440	if (sec->spec.sorted)
		4441	minfo (")");
		4442	if (sec->next)
		4443	minfo (" ");
		4444	}
		4445	minfo (")");
		4446
		4447	print_nl ();
		4448
		4449	print_statement_list (w->children.head, os);
		4450	}
		4451
		4452	/* Print a group statement. */
		4453
		4454	static void
		4455	print_group (lang_group_statement_type *s,
		4456	lang_output_section_statement_type *os)
		4457	{
		4458	fprintf (config.map_file, "START GROUP\n");
		4459	print_statement_list (s->children.head, os);
		4460	fprintf (config.map_file, "END GROUP\n");
		4461	}
		4462
		4463	/* Print the list of statements in S.
		4464	This can be called for any statement type. */
		4465
		4466	static void
		4467	print_statement_list (lang_statement_union_type *s,
		4468	lang_output_section_statement_type *os)
		4469	{
		4470	while (s != NULL)
		4471	{
		4472	print_statement (s, os);
		4473	s = s->header.next;
		4474	}
		4475	}
		4476
		4477	/* Print the first statement in statement list S.
		4478	This can be called for any statement type. */
		4479
		4480	static void
		4481	print_statement (lang_statement_union_type *s,
		4482	lang_output_section_statement_type *os)
		4483	{
		4484	switch (s->header.type)
		4485	{
		4486	default:
		4487	fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
		4488	FAIL ();
		4489	break;
		4490	case lang_constructors_statement_enum:
		4491	if (constructor_list.head != NULL)
		4492	{
		4493	if (constructors_sorted)
		4494	minfo (" SORT (CONSTRUCTORS)\n");
		4495	else
		4496	minfo (" CONSTRUCTORS\n");
		4497	print_statement_list (constructor_list.head, os);
		4498	}
		4499	break;
		4500	case lang_wild_statement_enum:
		4501	print_wild_statement (&s->wild_statement, os);
		4502	break;
		4503	case lang_address_statement_enum:
		4504	print_address_statement (&s->address_statement);
		4505	break;
		4506	case lang_object_symbols_statement_enum:
		4507	minfo (" CREATE_OBJECT_SYMBOLS\n");
		4508	break;
		4509	case lang_fill_statement_enum:
		4510	print_fill_statement (&s->fill_statement);
		4511	break;
		4512	case lang_data_statement_enum:
		4513	print_data_statement (&s->data_statement);
		4514	break;
		4515	case lang_reloc_statement_enum:
		4516	print_reloc_statement (&s->reloc_statement);
		4517	break;
		4518	case lang_input_section_enum:
		4519	print_input_section (s->input_section.section, FALSE);
		4520	break;
		4521	case lang_padding_statement_enum:
		4522	print_padding_statement (&s->padding_statement);
		4523	break;
		4524	case lang_output_section_statement_enum:
		4525	print_output_section_statement (&s->output_section_statement);
		4526	break;
		4527	case lang_assignment_statement_enum:
		4528	print_assignment (&s->assignment_statement, os);
		4529	break;
		4530	case lang_target_statement_enum:
		4531	fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
		4532	break;
		4533	case lang_output_statement_enum:
		4534	minfo ("OUTPUT(%s", s->output_statement.name);
		4535	if (output_target != NULL)
		4536	minfo (" %s", output_target);
		4537	minfo (")\n");
		4538	break;
		4539	case lang_input_statement_enum:
		4540	print_input_statement (&s->input_statement);
		4541	break;
		4542	case lang_group_statement_enum:
		4543	print_group (&s->group_statement, os);
		4544	break;
		4545	case lang_insert_statement_enum:
		4546	minfo ("INSERT %s %s\n",
		4547	s->insert_statement.is_before ? "BEFORE" : "AFTER",
		4548	s->insert_statement.where);
		4549	break;
		4550	}
		4551	}
		4552
		4553	static void
		4554	print_statements (void)
		4555	{
		4556	print_statement_list (statement_list.head, abs_output_section);
		4557	}
		4558
		4559	/* Print the first N statements in statement list S to STDERR.
		4560	If N == 0, nothing is printed.
		4561	If N < 0, the entire list is printed.
		4562	Intended to be called from GDB. */
		4563
		4564	void
		4565	dprint_statement (lang_statement_union_type *s, int n)
		4566	{
		4567	FILE *map_save = config.map_file;
		4568
		4569	config.map_file = stderr;
		4570
		4571	if (n < 0)
		4572	print_statement_list (s, abs_output_section);
		4573	else
		4574	{
		4575	while (s && --n >= 0)
		4576	{
		4577	print_statement (s, abs_output_section);
		4578	s = s->header.next;
		4579	}
		4580	}
		4581
		4582	config.map_file = map_save;
		4583	}
		4584
		4585	static void
		4586	insert_pad (lang_statement_union_type **ptr,
		4587	fill_type *fill,
		4588	bfd_size_type alignment_needed,
		4589	asection *output_section,
		4590	bfd_vma dot)
		4591	{
		4592	static fill_type zero_fill;
		4593	lang_statement_union_type *pad = NULL;
		4594
		4595	if (ptr != &statement_list.head)
		4596	pad = ((lang_statement_union_type *)
		4597	((char *) ptr - offsetof (lang_statement_union_type, header.next)));
		4598	if (pad != NULL
		4599	&& pad->header.type == lang_padding_statement_enum
		4600	&& pad->padding_statement.output_section == output_section)
		4601	{
		4602	/* Use the existing pad statement. */
		4603	}
		4604	else if ((pad = *ptr) != NULL
		4605	&& pad->header.type == lang_padding_statement_enum
		4606	&& pad->padding_statement.output_section == output_section)
		4607	{
		4608	/* Use the existing pad statement. */
		4609	}
		4610	else
		4611	{
		4612	/* Make a new padding statement, linked into existing chain. */
		4613	pad = (lang_statement_union_type *)
		4614	stat_alloc (sizeof (lang_padding_statement_type));
		4615	pad->header.next = *ptr;
		4616	*ptr = pad;
		4617	pad->header.type = lang_padding_statement_enum;
		4618	pad->padding_statement.output_section = output_section;
		4619	if (fill == NULL)
		4620	fill = &zero_fill;
		4621	pad->padding_statement.fill = fill;
		4622	}
		4623	pad->padding_statement.output_offset = dot - output_section->vma;
		4624	pad->padding_statement.size = alignment_needed;
		4625	output_section->size = TO_SIZE (dot + TO_ADDR (alignment_needed)
		4626	- output_section->vma);
		4627	}
		4628
		4629	/* Work out how much this section will move the dot point. */
		4630
		4631	static bfd_vma
		4632	size_input_section
		4633	(lang_statement_union_type **this_ptr,
		4634	lang_output_section_statement_type *output_section_statement,
		4635	fill_type *fill,
		4636	bfd_vma dot)
		4637	{
		4638	lang_input_section_type is = &((this_ptr)->input_section);
		4639	asection *i = is->section;
6324	serge	4640	asection *o = output_section_statement->bfd_section;
5199	serge	4641
6324	serge	4642	if (i->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
		4643	i->output_offset = i->vma - o->vma;
		4644	else if ((i->flags & SEC_EXCLUDE) != 0)
		4645	i->output_offset = dot - o->vma;
		4646	else
5199	serge	4647	{
		4648	bfd_size_type alignment_needed;
		4649
		4650	/* Align this section first to the input sections requirement,
		4651	then to the output section's requirement. If this alignment
		4652	is greater than any seen before, then record it too. Perform
		4653	the alignment by inserting a magic 'padding' statement. */
		4654
		4655	if (output_section_statement->subsection_alignment != -1)
		4656	i->alignment_power = output_section_statement->subsection_alignment;
		4657
		4658	if (o->alignment_power < i->alignment_power)
		4659	o->alignment_power = i->alignment_power;
		4660
		4661	alignment_needed = align_power (dot, i->alignment_power) - dot;
		4662
		4663	if (alignment_needed != 0)
		4664	{
		4665	insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
		4666	dot += alignment_needed;
		4667	}
		4668
		4669	/* Remember where in the output section this input section goes. */
		4670	i->output_offset = dot - o->vma;
		4671
		4672	/* Mark how big the output section must be to contain this now. */
		4673	dot += TO_ADDR (i->size);
		4674	o->size = TO_SIZE (dot - o->vma);
		4675	}
		4676
		4677	return dot;
		4678	}
		4679
		4680	static int
		4681	sort_sections_by_lma (const void arg1, const void arg2)
		4682	{
		4683	const asection sec1 = (const asection **) arg1;
		4684	const asection sec2 = (const asection **) arg2;
		4685
		4686	if (bfd_section_lma (sec1->owner, sec1)
		4687	< bfd_section_lma (sec2->owner, sec2))
		4688	return -1;
		4689	else if (bfd_section_lma (sec1->owner, sec1)
		4690	> bfd_section_lma (sec2->owner, sec2))
		4691	return 1;
		4692	else if (sec1->id < sec2->id)
		4693	return -1;
		4694	else if (sec1->id > sec2->id)
		4695	return 1;
		4696
		4697	return 0;
		4698	}
		4699
		4700	#define IGNORE_SECTION(s) \
		4701	((s->flags & SEC_ALLOC) == 0 \
		4702	\|\| ((s->flags & SEC_THREAD_LOCAL) != 0 \
		4703	&& (s->flags & SEC_LOAD) == 0))
		4704
		4705	/* Check to see if any allocated sections overlap with other allocated
		4706	sections. This can happen if a linker script specifies the output
		4707	section addresses of the two sections. Also check whether any memory
		4708	region has overflowed. */
		4709
		4710	static void
		4711	lang_check_section_addresses (void)
		4712	{
		4713	asection s, p;
		4714	asection sections, spp;
		4715	unsigned int count;
		4716	bfd_vma s_start;
		4717	bfd_vma s_end;
		4718	bfd_vma p_start;
		4719	bfd_vma p_end;
		4720	bfd_size_type amt;
		4721	lang_memory_region_type *m;
		4722
		4723	if (bfd_count_sections (link_info.output_bfd) <= 1)
		4724	return;
		4725
		4726	amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
		4727	sections = (asection **) xmalloc (amt);
		4728
		4729	/* Scan all sections in the output list. */
		4730	count = 0;
		4731	for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
		4732	{
		4733	/* Only consider loadable sections with real contents. */
		4734	if (!(s->flags & SEC_LOAD)
		4735	\|\| !(s->flags & SEC_ALLOC)
		4736	\|\| s->size == 0)
		4737	continue;
		4738
		4739	sections[count] = s;
		4740	count++;
		4741	}
		4742
		4743	if (count <= 1)
		4744	return;
		4745
		4746	qsort (sections, (size_t) count, sizeof (asection *),
		4747	sort_sections_by_lma);
		4748
		4749	spp = sections;
		4750	s = *spp++;
		4751	s_start = s->lma;
		4752	s_end = s_start + TO_ADDR (s->size) - 1;
		4753	for (count--; count; count--)
		4754	{
		4755	/* We must check the sections' LMA addresses not their VMA
		4756	addresses because overlay sections can have overlapping VMAs
		4757	but they must have distinct LMAs. */
		4758	p = s;
		4759	p_start = s_start;
		4760	p_end = s_end;
		4761	s = *spp++;
		4762	s_start = s->lma;
		4763	s_end = s_start + TO_ADDR (s->size) - 1;
		4764
		4765	/* Look for an overlap. We have sorted sections by lma, so we
		4766	know that s_start >= p_start. Besides the obvious case of
		4767	overlap when the current section starts before the previous
		4768	one ends, we also must have overlap if the previous section
		4769	wraps around the address space. */
		4770	if (s_start <= p_end
		4771	\|\| p_end < p_start)
		4772	einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
		4773	s->name, s_start, s_end, p->name, p_start, p_end);
		4774	}
		4775
		4776	free (sections);
		4777
		4778	/* If any memory region has overflowed, report by how much.
		4779	We do not issue this diagnostic for regions that had sections
		4780	explicitly placed outside their bounds; os_region_check's
		4781	diagnostics are adequate for that case.
		4782
		4783	FIXME: It is conceivable that m->current - (m->origin + m->length)
		4784	might overflow a 32-bit integer. There is, alas, no way to print
		4785	a bfd_vma quantity in decimal. */
		4786	for (m = lang_memory_region_list; m; m = m->next)
		4787	if (m->had_full_message)
		4788	einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
		4789	m->name_list.name, (long)(m->current - (m->origin + m->length)));
		4790
		4791	}
		4792
		4793	/* Make sure the new address is within the region. We explicitly permit the
		4794	current address to be at the exact end of the region when the address is
		4795	non-zero, in case the region is at the end of addressable memory and the
		4796	calculation wraps around. */
		4797
		4798	static void
		4799	os_region_check (lang_output_section_statement_type *os,
		4800	lang_memory_region_type *region,
		4801	etree_type *tree,
		4802	bfd_vma rbase)
		4803	{
		4804	if ((region->current < region->origin
		4805	\|\| (region->current - region->origin > region->length))
		4806	&& ((region->current != region->origin + region->length)
		4807	\|\| rbase == 0))
		4808	{
		4809	if (tree != NULL)
		4810	{
		4811	einfo (_("%X%P: address 0x%v of %B section `%s'"
		4812	" is not within region `%s'\n"),
		4813	region->current,
		4814	os->bfd_section->owner,
		4815	os->bfd_section->name,
		4816	region->name_list.name);
		4817	}
		4818	else if (!region->had_full_message)
		4819	{
		4820	region->had_full_message = TRUE;
		4821
		4822	einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
		4823	os->bfd_section->owner,
		4824	os->bfd_section->name,
		4825	region->name_list.name);
		4826	}
		4827	}
		4828	}
		4829
		4830	/* Set the sizes for all the output sections. */
		4831
		4832	static bfd_vma
		4833	lang_size_sections_1
		4834	(lang_statement_union_type **prev,
		4835	lang_output_section_statement_type *output_section_statement,
		4836	fill_type *fill,
		4837	bfd_vma dot,
		4838	bfd_boolean *relax,
		4839	bfd_boolean check_regions)
		4840	{
		4841	lang_statement_union_type *s;
		4842
		4843	/* Size up the sections from their constituent parts. */
		4844	for (s = *prev; s != NULL; s = s->header.next)
		4845	{
		4846	switch (s->header.type)
		4847	{
		4848	case lang_output_section_statement_enum:
		4849	{
6324	serge	4850	bfd_vma newdot, after, dotdelta;
5199	serge	4851	lang_output_section_statement_type *os;
		4852	lang_memory_region_type *r;
		4853	int section_alignment = 0;
		4854
		4855	os = &s->output_section_statement;
		4856	if (os->constraint == -1)
		4857	break;
		4858
		4859	/* FIXME: We shouldn't need to zero section vmas for ld -r
		4860	here, in lang_insert_orphan, or in the default linker scripts.
		4861	This is covering for coff backend linker bugs. See PR6945. */
		4862	if (os->addr_tree == NULL
6324	serge	4863	&& bfd_link_relocatable (&link_info)
5199	serge	4864	&& (bfd_get_flavour (link_info.output_bfd)
		4865	== bfd_target_coff_flavour))
		4866	os->addr_tree = exp_intop (0);
		4867	if (os->addr_tree != NULL)
		4868	{
		4869	os->processed_vma = FALSE;
		4870	exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
		4871
		4872	if (expld.result.valid_p)
		4873	{
		4874	dot = expld.result.value;
		4875	if (expld.result.section != NULL)
		4876	dot += expld.result.section->vma;
		4877	}
		4878	else if (expld.phase != lang_mark_phase_enum)
		4879	einfo (_("%F%S: non constant or forward reference"
		4880	" address expression for section %s\n"),
		4881	os->addr_tree, os->name);
		4882	}
		4883
		4884	if (os->bfd_section == NULL)
		4885	/* This section was removed or never actually created. */
		4886	break;
		4887
		4888	/* If this is a COFF shared library section, use the size and
		4889	address from the input section. FIXME: This is COFF
		4890	specific; it would be cleaner if there were some other way
		4891	to do this, but nothing simple comes to mind. */
		4892	if (((bfd_get_flavour (link_info.output_bfd)
		4893	== bfd_target_ecoff_flavour)
		4894	\|\| (bfd_get_flavour (link_info.output_bfd)
		4895	== bfd_target_coff_flavour))
		4896	&& (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
		4897	{
		4898	asection *input;
		4899
		4900	if (os->children.head == NULL
		4901	\|\| os->children.head->header.next != NULL
		4902	\|\| (os->children.head->header.type
		4903	!= lang_input_section_enum))
		4904	einfo (_("%P%X: Internal error on COFF shared library"
		4905	" section %s\n"), os->name);
		4906
		4907	input = os->children.head->input_section.section;
		4908	bfd_set_section_vma (os->bfd_section->owner,
		4909	os->bfd_section,
		4910	bfd_section_vma (input->owner, input));
		4911	os->bfd_section->size = input->size;
		4912	break;
		4913	}
		4914
		4915	newdot = dot;
6324	serge	4916	dotdelta = 0;
5199	serge	4917	if (bfd_is_abs_section (os->bfd_section))
		4918	{
		4919	/* No matter what happens, an abs section starts at zero. */
		4920	ASSERT (os->bfd_section->vma == 0);
		4921	}
		4922	else
		4923	{
		4924	if (os->addr_tree == NULL)
		4925	{
		4926	/* No address specified for this section, get one
		4927	from the region specification. */
		4928	if (os->region == NULL
		4929	\|\| ((os->bfd_section->flags & (SEC_ALLOC \| SEC_LOAD))
		4930	&& os->region->name_list.name[0] == '*'
		4931	&& strcmp (os->region->name_list.name,
		4932	DEFAULT_MEMORY_REGION) == 0))
		4933	{
		4934	os->region = lang_memory_default (os->bfd_section);
		4935	}
		4936
		4937	/* If a loadable section is using the default memory
		4938	region, and some non default memory regions were
		4939	defined, issue an error message. */
		4940	if (!os->ignored
		4941	&& !IGNORE_SECTION (os->bfd_section)
6324	serge	4942	&& !bfd_link_relocatable (&link_info)
5199	serge	4943	&& check_regions
		4944	&& strcmp (os->region->name_list.name,
		4945	DEFAULT_MEMORY_REGION) == 0
		4946	&& lang_memory_region_list != NULL
		4947	&& (strcmp (lang_memory_region_list->name_list.name,
		4948	DEFAULT_MEMORY_REGION) != 0
		4949	\|\| lang_memory_region_list->next != NULL)
		4950	&& expld.phase != lang_mark_phase_enum)
		4951	{
		4952	/* By default this is an error rather than just a
		4953	warning because if we allocate the section to the
		4954	default memory region we can end up creating an
		4955	excessively large binary, or even seg faulting when
		4956	attempting to perform a negative seek. See
		4957	sources.redhat.com/ml/binutils/2003-04/msg00423.html
		4958	for an example of this. This behaviour can be
		4959	overridden by the using the --no-check-sections
		4960	switch. */
		4961	if (command_line.check_section_addresses)
		4962	einfo (_("%P%F: error: no memory region specified"
		4963	" for loadable section `%s'\n"),
		4964	bfd_get_section_name (link_info.output_bfd,
		4965	os->bfd_section));
		4966	else
		4967	einfo (_("%P: warning: no memory region specified"
		4968	" for loadable section `%s'\n"),
		4969	bfd_get_section_name (link_info.output_bfd,
		4970	os->bfd_section));
		4971	}
		4972
		4973	newdot = os->region->current;
		4974	section_alignment = os->bfd_section->alignment_power;
		4975	}
		4976	else
		4977	section_alignment = os->section_alignment;
		4978
		4979	/* Align to what the section needs. */
		4980	if (section_alignment > 0)
		4981	{
		4982	bfd_vma savedot = newdot;
		4983	newdot = align_power (newdot, section_alignment);
		4984
6324	serge	4985	dotdelta = newdot - savedot;
		4986	if (dotdelta != 0
5199	serge	4987	&& (config.warn_section_align
		4988	\|\| os->addr_tree != NULL)
		4989	&& expld.phase != lang_mark_phase_enum)
		4990	einfo (_("%P: warning: changing start of section"
		4991	" %s by %lu bytes\n"),
6324	serge	4992	os->name, (unsigned long) dotdelta);
5199	serge	4993	}
		4994
		4995	bfd_set_section_vma (0, os->bfd_section, newdot);
		4996
		4997	os->bfd_section->output_offset = 0;
		4998	}
		4999
		5000	lang_size_sections_1 (&os->children.head, os,
		5001	os->fill, newdot, relax, check_regions);
		5002
		5003	os->processed_vma = TRUE;
		5004
		5005	if (bfd_is_abs_section (os->bfd_section) \|\| os->ignored)
		5006	/* Except for some special linker created sections,
		5007	no output section should change from zero size
		5008	after strip_excluded_output_sections. A non-zero
		5009	size on an ignored section indicates that some
		5010	input section was not sized early enough. */
		5011	ASSERT (os->bfd_section->size == 0);
		5012	else
		5013	{
		5014	dot = os->bfd_section->vma;
		5015
		5016	/* Put the section within the requested block size, or
		5017	align at the block boundary. */
		5018	after = ((dot
		5019	+ TO_ADDR (os->bfd_section->size)
		5020	+ os->block_value - 1)
		5021	& - (bfd_vma) os->block_value);
		5022
		5023	os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
		5024	}
		5025
		5026	/* Set section lma. */
		5027	r = os->region;
		5028	if (r == NULL)
		5029	r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
		5030
		5031	if (os->load_base)
		5032	{
		5033	bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
		5034	os->bfd_section->lma = lma;
		5035	}
		5036	else if (os->lma_region != NULL)
		5037	{
		5038	bfd_vma lma = os->lma_region->current;
		5039
6324	serge	5040	if (os->align_lma_with_input)
		5041	lma += dotdelta;
		5042	else
		5043	{
5199	serge	5044	/* When LMA_REGION is the same as REGION, align the LMA
		5045	as we did for the VMA, possibly including alignment
		5046	from the bfd section. If a different region, then
		5047	only align according to the value in the output
6324	serge	5048	statement. */
		5049	if (os->lma_region != os->region)
5199	serge	5050	section_alignment = os->section_alignment;
		5051	if (section_alignment > 0)
		5052	lma = align_power (lma, section_alignment);
6324	serge	5053	}
5199	serge	5054	os->bfd_section->lma = lma;
		5055	}
		5056	else if (r->last_os != NULL
		5057	&& (os->bfd_section->flags & SEC_ALLOC) != 0)
		5058	{
		5059	bfd_vma lma;
		5060	asection *last;
		5061
		5062	last = r->last_os->output_section_statement.bfd_section;
		5063
		5064	/* A backwards move of dot should be accompanied by
		5065	an explicit assignment to the section LMA (ie.
		5066	os->load_base set) because backwards moves can
		5067	create overlapping LMAs. */
		5068	if (dot < last->vma
		5069	&& os->bfd_section->size != 0
		5070	&& dot + os->bfd_section->size <= last->vma)
		5071	{
		5072	/* If dot moved backwards then leave lma equal to
		5073	vma. This is the old default lma, which might
		5074	just happen to work when the backwards move is
		5075	sufficiently large. Nag if this changes anything,
		5076	so people can fix their linker scripts. */
		5077
		5078	if (last->vma != last->lma)
		5079	einfo (_("%P: warning: dot moved backwards before `%s'\n"),
		5080	os->name);
		5081	}
		5082	else
		5083	{
		5084	/* If this is an overlay, set the current lma to that
		5085	at the end of the previous section. */
		5086	if (os->sectype == overlay_section)
		5087	lma = last->lma + last->size;
		5088
		5089	/* Otherwise, keep the same lma to vma relationship
		5090	as the previous section. */
		5091	else
		5092	lma = dot + last->lma - last->vma;
		5093
		5094	if (section_alignment > 0)
		5095	lma = align_power (lma, section_alignment);
		5096	os->bfd_section->lma = lma;
		5097	}
		5098	}
		5099	os->processed_lma = TRUE;
		5100
		5101	if (bfd_is_abs_section (os->bfd_section) \|\| os->ignored)
		5102	break;
		5103
		5104	/* Keep track of normal sections using the default
		5105	lma region. We use this to set the lma for
		5106	following sections. Overlays or other linker
		5107	script assignment to lma might mean that the
		5108	default lma == vma is incorrect.
		5109	To avoid warnings about dot moving backwards when using
		5110	-Ttext, don't start tracking sections until we find one
		5111	of non-zero size or with lma set differently to vma. */
		5112	if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
		5113	\|\| (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
		5114	&& (os->bfd_section->flags & SEC_ALLOC) != 0
		5115	&& (os->bfd_section->size != 0
		5116	\|\| (r->last_os == NULL
		5117	&& os->bfd_section->vma != os->bfd_section->lma)
		5118	\|\| (r->last_os != NULL
		5119	&& dot >= (r->last_os->output_section_statement
		5120	.bfd_section->vma)))
		5121	&& os->lma_region == NULL
6324	serge	5122	&& !bfd_link_relocatable (&link_info))
5199	serge	5123	r->last_os = s;
		5124
		5125	/* .tbss sections effectively have zero size. */
		5126	if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
		5127	\|\| (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
6324	serge	5128	\|\| bfd_link_relocatable (&link_info))
		5129	dotdelta = TO_ADDR (os->bfd_section->size);
		5130	else
		5131	dotdelta = 0;
		5132	dot += dotdelta;
5199	serge	5133
		5134	if (os->update_dot_tree != 0)
		5135	exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
		5136
		5137	/* Update dot in the region ?
		5138	We only do this if the section is going to be allocated,
		5139	since unallocated sections do not contribute to the region's
		5140	overall size in memory. */
		5141	if (os->region != NULL
		5142	&& (os->bfd_section->flags & (SEC_ALLOC \| SEC_LOAD)))
		5143	{
		5144	os->region->current = dot;
		5145
		5146	if (check_regions)
		5147	/* Make sure the new address is within the region. */
		5148	os_region_check (os, os->region, os->addr_tree,
		5149	os->bfd_section->vma);
		5150
		5151	if (os->lma_region != NULL && os->lma_region != os->region
6324	serge	5152	&& ((os->bfd_section->flags & SEC_LOAD)
		5153	\|\| os->align_lma_with_input))
5199	serge	5154	{
6324	serge	5155	os->lma_region->current = os->bfd_section->lma + dotdelta;
5199	serge	5156
		5157	if (check_regions)
		5158	os_region_check (os, os->lma_region, NULL,
		5159	os->bfd_section->lma);
		5160	}
		5161	}
		5162	}
		5163	break;
		5164
		5165	case lang_constructors_statement_enum:
		5166	dot = lang_size_sections_1 (&constructor_list.head,
		5167	output_section_statement,
		5168	fill, dot, relax, check_regions);
		5169	break;
		5170
		5171	case lang_data_statement_enum:
		5172	{
		5173	unsigned int size = 0;
		5174
		5175	s->data_statement.output_offset =
		5176	dot - output_section_statement->bfd_section->vma;
		5177	s->data_statement.output_section =
		5178	output_section_statement->bfd_section;
		5179
		5180	/* We might refer to provided symbols in the expression, and
		5181	need to mark them as needed. */
		5182	exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
		5183
		5184	switch (s->data_statement.type)
		5185	{
		5186	default:
		5187	abort ();
		5188	case QUAD:
		5189	case SQUAD:
		5190	size = QUAD_SIZE;
		5191	break;
		5192	case LONG:
		5193	size = LONG_SIZE;
		5194	break;
		5195	case SHORT:
		5196	size = SHORT_SIZE;
		5197	break;
		5198	case BYTE:
		5199	size = BYTE_SIZE;
		5200	break;
		5201	}
		5202	if (size < TO_SIZE ((unsigned) 1))
		5203	size = TO_SIZE ((unsigned) 1);
		5204	dot += TO_ADDR (size);
		5205	output_section_statement->bfd_section->size
		5206	= TO_SIZE (dot - output_section_statement->bfd_section->vma);
		5207
		5208	}
		5209	break;
		5210
		5211	case lang_reloc_statement_enum:
		5212	{
		5213	int size;
		5214
		5215	s->reloc_statement.output_offset =
		5216	dot - output_section_statement->bfd_section->vma;
		5217	s->reloc_statement.output_section =
		5218	output_section_statement->bfd_section;
		5219	size = bfd_get_reloc_size (s->reloc_statement.howto);
		5220	dot += TO_ADDR (size);
		5221	output_section_statement->bfd_section->size
		5222	= TO_SIZE (dot - output_section_statement->bfd_section->vma);
		5223	}
		5224	break;
		5225
		5226	case lang_wild_statement_enum:
		5227	dot = lang_size_sections_1 (&s->wild_statement.children.head,
		5228	output_section_statement,
		5229	fill, dot, relax, check_regions);
		5230	break;
		5231
		5232	case lang_object_symbols_statement_enum:
		5233	link_info.create_object_symbols_section =
		5234	output_section_statement->bfd_section;
		5235	break;
		5236
		5237	case lang_output_statement_enum:
		5238	case lang_target_statement_enum:
		5239	break;
		5240
		5241	case lang_input_section_enum:
		5242	{
		5243	asection *i;
		5244
		5245	i = s->input_section.section;
		5246	if (relax)
		5247	{
		5248	bfd_boolean again;
		5249
		5250	if (! bfd_relax_section (i->owner, i, &link_info, &again))
		5251	einfo (_("%P%F: can't relax section: %E\n"));
		5252	if (again)
		5253	*relax = TRUE;
		5254	}
		5255	dot = size_input_section (prev, output_section_statement,
6324	serge	5256	fill, dot);
5199	serge	5257	}
		5258	break;
		5259
		5260	case lang_input_statement_enum:
		5261	break;
		5262
		5263	case lang_fill_statement_enum:
		5264	s->fill_statement.output_section =
		5265	output_section_statement->bfd_section;
		5266
		5267	fill = s->fill_statement.fill;
		5268	break;
		5269
		5270	case lang_assignment_statement_enum:
		5271	{
		5272	bfd_vma newdot = dot;
		5273	etree_type *tree = s->assignment_statement.exp;
		5274
		5275	expld.dataseg.relro = exp_dataseg_relro_none;
		5276
		5277	exp_fold_tree (tree,
		5278	output_section_statement->bfd_section,
		5279	&newdot);
		5280
		5281	if (expld.dataseg.relro == exp_dataseg_relro_start)
		5282	{
		5283	if (!expld.dataseg.relro_start_stat)
		5284	expld.dataseg.relro_start_stat = s;
		5285	else
		5286	{
		5287	ASSERT (expld.dataseg.relro_start_stat == s);
		5288	}
		5289	}
		5290	else if (expld.dataseg.relro == exp_dataseg_relro_end)
		5291	{
		5292	if (!expld.dataseg.relro_end_stat)
		5293	expld.dataseg.relro_end_stat = s;
		5294	else
		5295	{
		5296	ASSERT (expld.dataseg.relro_end_stat == s);
		5297	}
		5298	}
		5299	expld.dataseg.relro = exp_dataseg_relro_none;
		5300
		5301	/* This symbol may be relative to this section. */
		5302	if ((tree->type.node_class == etree_provided
		5303	\|\| tree->type.node_class == etree_assign)
		5304	&& (tree->assign.dst [0] != '.'
		5305	\|\| tree->assign.dst [1] != '\0'))
		5306	output_section_statement->update_dot = 1;
		5307
		5308	if (!output_section_statement->ignored)
		5309	{
		5310	if (output_section_statement == abs_output_section)
		5311	{
		5312	/* If we don't have an output section, then just adjust
		5313	the default memory address. */
		5314	lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
		5315	FALSE)->current = newdot;
		5316	}
		5317	else if (newdot != dot)
		5318	{
		5319	/* Insert a pad after this statement. We can't
		5320	put the pad before when relaxing, in case the
		5321	assignment references dot. */
		5322	insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
		5323	output_section_statement->bfd_section, dot);
		5324
		5325	/* Don't neuter the pad below when relaxing. */
		5326	s = s->header.next;
		5327
		5328	/* If dot is advanced, this implies that the section
		5329	should have space allocated to it, unless the
		5330	user has explicitly stated that the section
		5331	should not be allocated. */
		5332	if (output_section_statement->sectype != noalloc_section
		5333	&& (output_section_statement->sectype != noload_section
		5334	\|\| (bfd_get_flavour (link_info.output_bfd)
		5335	== bfd_target_elf_flavour)))
		5336	output_section_statement->bfd_section->flags \|= SEC_ALLOC;
		5337	}
		5338	dot = newdot;
		5339	}
		5340	}
		5341	break;
		5342
		5343	case lang_padding_statement_enum:
		5344	/* If this is the first time lang_size_sections is called,
		5345	we won't have any padding statements. If this is the
		5346	second or later passes when relaxing, we should allow
		5347	padding to shrink. If padding is needed on this pass, it
		5348	will be added back in. */
		5349	s->padding_statement.size = 0;
		5350
		5351	/* Make sure output_offset is valid. If relaxation shrinks
		5352	the section and this pad isn't needed, it's possible to
		5353	have output_offset larger than the final size of the
		5354	section. bfd_set_section_contents will complain even for
		5355	a pad size of zero. */
		5356	s->padding_statement.output_offset
		5357	= dot - output_section_statement->bfd_section->vma;
		5358	break;
		5359
		5360	case lang_group_statement_enum:
		5361	dot = lang_size_sections_1 (&s->group_statement.children.head,
		5362	output_section_statement,
		5363	fill, dot, relax, check_regions);
		5364	break;
		5365
		5366	case lang_insert_statement_enum:
		5367	break;
		5368
		5369	/* We can only get here when relaxing is turned on. */
		5370	case lang_address_statement_enum:
		5371	break;
		5372
		5373	default:
		5374	FAIL ();
		5375	break;
		5376	}
		5377	prev = &s->header.next;
		5378	}
		5379	return dot;
		5380	}
		5381
		5382	/* Callback routine that is used in _bfd_elf_map_sections_to_segments.
		5383	The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
		5384	CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
		5385	segments. We are allowed an opportunity to override this decision. */
		5386
		5387	bfd_boolean
		5388	ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
		5389	bfd * abfd ATTRIBUTE_UNUSED,
		5390	asection * current_section,
		5391	asection * previous_section,
		5392	bfd_boolean new_segment)
		5393	{
		5394	lang_output_section_statement_type * cur;
		5395	lang_output_section_statement_type * prev;
		5396
		5397	/* The checks below are only necessary when the BFD library has decided
		5398	that the two sections ought to be placed into the same segment. */
		5399	if (new_segment)
		5400	return TRUE;
		5401
		5402	/* Paranoia checks. */
		5403	if (current_section == NULL \|\| previous_section == NULL)
		5404	return new_segment;
		5405
		5406	/* If this flag is set, the target never wants code and non-code
		5407	sections comingled in the same segment. */
		5408	if (config.separate_code
		5409	&& ((current_section->flags ^ previous_section->flags) & SEC_CODE))
		5410	return TRUE;
		5411
		5412	/* Find the memory regions associated with the two sections.
		5413	We call lang_output_section_find() here rather than scanning the list
		5414	of output sections looking for a matching section pointer because if
		5415	we have a large number of sections then a hash lookup is faster. */
		5416	cur = lang_output_section_find (current_section->name);
		5417	prev = lang_output_section_find (previous_section->name);
		5418
		5419	/* More paranoia. */
		5420	if (cur == NULL \|\| prev == NULL)
		5421	return new_segment;
		5422
		5423	/* If the regions are different then force the sections to live in
		5424	different segments. See the email thread starting at the following
		5425	URL for the reasons why this is necessary:
		5426	http://sourceware.org/ml/binutils/2007-02/msg00216.html */
		5427	return cur->region != prev->region;
		5428	}
		5429
		5430	void
		5431	one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
		5432	{
		5433	lang_statement_iteration++;
		5434	lang_size_sections_1 (&statement_list.head, abs_output_section,
		5435	0, 0, relax, check_regions);
		5436	}
		5437
		5438	void
		5439	lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
		5440	{
		5441	expld.phase = lang_allocating_phase_enum;
		5442	expld.dataseg.phase = exp_dataseg_none;
		5443
		5444	one_lang_size_sections_pass (relax, check_regions);
		5445	if (expld.dataseg.phase == exp_dataseg_end_seen
		5446	&& link_info.relro && expld.dataseg.relro_end)
		5447	{
6324	serge	5448	bfd_vma initial_base, relro_end, desired_end;
		5449	asection *sec;
5199	serge	5450
		5451	/* Compute the expected PT_GNU_RELRO segment end. */
		5452	relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
		5453	& ~(expld.dataseg.pagesize - 1));
6324	serge	5454
		5455	/* Adjust by the offset arg of DATA_SEGMENT_RELRO_END. */
		5456	desired_end = relro_end - expld.dataseg.relro_offset;
		5457
		5458	/* For sections in the relro segment.. */
		5459	for (sec = link_info.output_bfd->section_last; sec; sec = sec->prev)
		5460	if ((sec->flags & SEC_ALLOC) != 0
		5461	&& sec->vma >= expld.dataseg.base
		5462	&& sec->vma < expld.dataseg.relro_end - expld.dataseg.relro_offset)
		5463	{
		5464	/* Where do we want to put this section so that it ends as
		5465	desired? */
		5466	bfd_vma start, end, bump;
		5467
		5468	end = start = sec->vma;
		5469	if ((sec->flags & SEC_HAS_CONTENTS) != 0
		5470	\|\| (sec->flags & SEC_THREAD_LOCAL) == 0)
		5471	end += sec->size;
		5472	bump = desired_end - end;
		5473	/* We'd like to increase START by BUMP, but we must heed
		5474	alignment so the increase might be less than optimum. */
		5475	start += bump;
		5476	start &= ~(((bfd_vma) 1 << sec->alignment_power) - 1);
		5477	/* This is now the desired end for the previous section. */
		5478	desired_end = start;
5199	serge	5479	}
6324	serge	5480
		5481	expld.dataseg.phase = exp_dataseg_relro_adjust;
		5482	ASSERT (desired_end >= expld.dataseg.base);
		5483	initial_base = expld.dataseg.base;
		5484	expld.dataseg.base = desired_end;
5199	serge	5485	lang_reset_memory_regions ();
		5486	one_lang_size_sections_pass (relax, check_regions);
6324	serge	5487
5199	serge	5488	if (expld.dataseg.relro_end > relro_end)
		5489	{
6324	serge	5490	/* Assignments to dot, or to output section address in a
		5491	user script have increased padding over the original.
		5492	Revert. */
		5493	expld.dataseg.base = initial_base;
5199	serge	5494	lang_reset_memory_regions ();
		5495	one_lang_size_sections_pass (relax, check_regions);
		5496	}
6324	serge	5497
5199	serge	5498	link_info.relro_start = expld.dataseg.base;
		5499	link_info.relro_end = expld.dataseg.relro_end;
		5500	}
		5501	else if (expld.dataseg.phase == exp_dataseg_end_seen)
		5502	{
		5503	/* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
		5504	a page could be saved in the data segment. */
		5505	bfd_vma first, last;
		5506
		5507	first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
		5508	last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
		5509	if (first && last
		5510	&& ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
		5511	!= (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
		5512	&& first + last <= expld.dataseg.pagesize)
		5513	{
		5514	expld.dataseg.phase = exp_dataseg_adjust;
		5515	lang_reset_memory_regions ();
		5516	one_lang_size_sections_pass (relax, check_regions);
		5517	}
		5518	else
		5519	expld.dataseg.phase = exp_dataseg_done;
		5520	}
		5521	else
		5522	expld.dataseg.phase = exp_dataseg_done;
		5523	}
		5524
		5525	static lang_output_section_statement_type *current_section;
		5526	static lang_assignment_statement_type *current_assign;
		5527	static bfd_boolean prefer_next_section;
		5528
		5529	/* Worker function for lang_do_assignments. Recursiveness goes here. */
		5530
		5531	static bfd_vma
		5532	lang_do_assignments_1 (lang_statement_union_type *s,
		5533	lang_output_section_statement_type *current_os,
		5534	fill_type *fill,
		5535	bfd_vma dot,
		5536	bfd_boolean *found_end)
		5537	{
		5538	for (; s != NULL; s = s->header.next)
		5539	{
		5540	switch (s->header.type)
		5541	{
		5542	case lang_constructors_statement_enum:
		5543	dot = lang_do_assignments_1 (constructor_list.head,
		5544	current_os, fill, dot, found_end);
		5545	break;
		5546
		5547	case lang_output_section_statement_enum:
		5548	{
		5549	lang_output_section_statement_type *os;
		5550
		5551	os = &(s->output_section_statement);
		5552	os->after_end = *found_end;
		5553	if (os->bfd_section != NULL && !os->ignored)
		5554	{
		5555	if ((os->bfd_section->flags & SEC_ALLOC) != 0)
		5556	{
		5557	current_section = os;
		5558	prefer_next_section = FALSE;
		5559	}
		5560	dot = os->bfd_section->vma;
		5561
		5562	lang_do_assignments_1 (os->children.head,
		5563	os, os->fill, dot, found_end);
		5564
		5565	/* .tbss sections effectively have zero size. */
		5566	if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
		5567	\|\| (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
6324	serge	5568	\|\| bfd_link_relocatable (&link_info))
5199	serge	5569	dot += TO_ADDR (os->bfd_section->size);
		5570
		5571	if (os->update_dot_tree != NULL)
		5572	exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
		5573	}
		5574	}
		5575	break;
		5576
		5577	case lang_wild_statement_enum:
		5578
		5579	dot = lang_do_assignments_1 (s->wild_statement.children.head,
		5580	current_os, fill, dot, found_end);
		5581	break;
		5582
		5583	case lang_object_symbols_statement_enum:
		5584	case lang_output_statement_enum:
		5585	case lang_target_statement_enum:
		5586	break;
		5587
		5588	case lang_data_statement_enum:
		5589	exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
		5590	if (expld.result.valid_p)
		5591	{
		5592	s->data_statement.value = expld.result.value;
		5593	if (expld.result.section != NULL)
		5594	s->data_statement.value += expld.result.section->vma;
		5595	}
		5596	else
		5597	einfo (_("%F%P: invalid data statement\n"));
		5598	{
		5599	unsigned int size;
		5600	switch (s->data_statement.type)
		5601	{
		5602	default:
		5603	abort ();
		5604	case QUAD:
		5605	case SQUAD:
		5606	size = QUAD_SIZE;
		5607	break;
		5608	case LONG:
		5609	size = LONG_SIZE;
		5610	break;
		5611	case SHORT:
		5612	size = SHORT_SIZE;
		5613	break;
		5614	case BYTE:
		5615	size = BYTE_SIZE;
		5616	break;
		5617	}
		5618	if (size < TO_SIZE ((unsigned) 1))
		5619	size = TO_SIZE ((unsigned) 1);
		5620	dot += TO_ADDR (size);
		5621	}
		5622	break;
		5623
		5624	case lang_reloc_statement_enum:
		5625	exp_fold_tree (s->reloc_statement.addend_exp,
		5626	bfd_abs_section_ptr, &dot);
		5627	if (expld.result.valid_p)
		5628	s->reloc_statement.addend_value = expld.result.value;
		5629	else
		5630	einfo (_("%F%P: invalid reloc statement\n"));
		5631	dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
		5632	break;
		5633
		5634	case lang_input_section_enum:
		5635	{
		5636	asection *in = s->input_section.section;
		5637
		5638	if ((in->flags & SEC_EXCLUDE) == 0)
		5639	dot += TO_ADDR (in->size);
		5640	}
		5641	break;
		5642
		5643	case lang_input_statement_enum:
		5644	break;
		5645
		5646	case lang_fill_statement_enum:
		5647	fill = s->fill_statement.fill;
		5648	break;
		5649
		5650	case lang_assignment_statement_enum:
		5651	current_assign = &s->assignment_statement;
		5652	if (current_assign->exp->type.node_class != etree_assert)
		5653	{
		5654	const char *p = current_assign->exp->assign.dst;
		5655
		5656	if (current_os == abs_output_section && p[0] == '.' && p[1] == 0)
		5657	prefer_next_section = TRUE;
		5658
		5659	while (*p == '_')
		5660	++p;
		5661	if (strcmp (p, "end") == 0)
		5662	*found_end = TRUE;
		5663	}
		5664	exp_fold_tree (s->assignment_statement.exp,
		5665	current_os->bfd_section,
		5666	&dot);
		5667	break;
		5668
		5669	case lang_padding_statement_enum:
		5670	dot += TO_ADDR (s->padding_statement.size);
		5671	break;
		5672
		5673	case lang_group_statement_enum:
		5674	dot = lang_do_assignments_1 (s->group_statement.children.head,
		5675	current_os, fill, dot, found_end);
		5676	break;
		5677
		5678	case lang_insert_statement_enum:
		5679	break;
		5680
		5681	case lang_address_statement_enum:
		5682	break;
		5683
		5684	default:
		5685	FAIL ();
		5686	break;
		5687	}
		5688	}
		5689	return dot;
		5690	}
		5691
		5692	void
		5693	lang_do_assignments (lang_phase_type phase)
		5694	{
		5695	bfd_boolean found_end = FALSE;
		5696
		5697	current_section = NULL;
		5698	prefer_next_section = FALSE;
		5699	expld.phase = phase;
		5700	lang_statement_iteration++;
		5701	lang_do_assignments_1 (statement_list.head,
		5702	abs_output_section, NULL, 0, &found_end);
		5703	}
		5704
		5705	/* For an assignment statement outside of an output section statement,
		5706	choose the best of neighbouring output sections to use for values
		5707	of "dot". */
		5708
		5709	asection *
		5710	section_for_dot (void)
		5711	{
		5712	asection *s;
		5713
		5714	/* Assignments belong to the previous output section, unless there
		5715	has been an assignment to "dot", in which case following
		5716	assignments belong to the next output section. (The assumption
		5717	is that an assignment to "dot" is setting up the address for the
		5718	next output section.) Except that past the assignment to "_end"
		5719	we always associate with the previous section. This exception is
		5720	for targets like SH that define an alloc .stack or other
		5721	weirdness after non-alloc sections. */
		5722	if (current_section == NULL \|\| prefer_next_section)
		5723	{
		5724	lang_statement_union_type *stmt;
		5725	lang_output_section_statement_type *os;
		5726
		5727	for (stmt = (lang_statement_union_type *) current_assign;
		5728	stmt != NULL;
		5729	stmt = stmt->header.next)
		5730	if (stmt->header.type == lang_output_section_statement_enum)
		5731	break;
		5732
		5733	os = &stmt->output_section_statement;
		5734	while (os != NULL
		5735	&& !os->after_end
		5736	&& (os->bfd_section == NULL
		5737	\|\| (os->bfd_section->flags & SEC_EXCLUDE) != 0
		5738	\|\| bfd_section_removed_from_list (link_info.output_bfd,
		5739	os->bfd_section)))
		5740	os = os->next;
		5741
		5742	if (current_section == NULL \|\| os == NULL \|\| !os->after_end)
		5743	{
		5744	if (os != NULL)
		5745	s = os->bfd_section;
		5746	else
		5747	s = link_info.output_bfd->section_last;
		5748	while (s != NULL
		5749	&& ((s->flags & SEC_ALLOC) == 0
		5750	\|\| (s->flags & SEC_THREAD_LOCAL) != 0))
		5751	s = s->prev;
		5752	if (s != NULL)
		5753	return s;
		5754
		5755	return bfd_abs_section_ptr;
		5756	}
		5757	}
		5758
		5759	s = current_section->bfd_section;
		5760
		5761	/* The section may have been stripped. */
		5762	while (s != NULL
		5763	&& ((s->flags & SEC_EXCLUDE) != 0
		5764	\|\| (s->flags & SEC_ALLOC) == 0
		5765	\|\| (s->flags & SEC_THREAD_LOCAL) != 0
		5766	\|\| bfd_section_removed_from_list (link_info.output_bfd, s)))
		5767	s = s->prev;
		5768	if (s == NULL)
		5769	s = link_info.output_bfd->sections;
		5770	while (s != NULL
		5771	&& ((s->flags & SEC_ALLOC) == 0
		5772	\|\| (s->flags & SEC_THREAD_LOCAL) != 0))
		5773	s = s->next;
		5774	if (s != NULL)
		5775	return s;
		5776
		5777	return bfd_abs_section_ptr;
		5778	}
		5779
		5780	/* Fix any .startof. or .sizeof. symbols. When the assemblers see the
		5781	operator .startof. (section_name), it produces an undefined symbol
		5782	.startof.section_name. Similarly, when it sees
		5783	.sizeof. (section_name), it produces an undefined symbol
		5784	.sizeof.section_name. For all the output sections, we look for
		5785	such symbols, and set them to the correct value. */
		5786
		5787	static void
		5788	lang_set_startof (void)
		5789	{
		5790	asection *s;
		5791
6324	serge	5792	if (bfd_link_relocatable (&link_info))
5199	serge	5793	return;
		5794
		5795	for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
		5796	{
		5797	const char *secname;
		5798	char *buf;
		5799	struct bfd_link_hash_entry *h;
		5800
		5801	secname = bfd_get_section_name (link_info.output_bfd, s);
		5802	buf = (char *) xmalloc (10 + strlen (secname));
		5803
		5804	sprintf (buf, ".startof.%s", secname);
		5805	h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
		5806	if (h != NULL && h->type == bfd_link_hash_undefined)
		5807	{
		5808	h->type = bfd_link_hash_defined;
		5809	h->u.def.value = 0;
		5810	h->u.def.section = s;
		5811	}
		5812
		5813	sprintf (buf, ".sizeof.%s", secname);
		5814	h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
		5815	if (h != NULL && h->type == bfd_link_hash_undefined)
		5816	{
		5817	h->type = bfd_link_hash_defined;
		5818	h->u.def.value = TO_ADDR (s->size);
		5819	h->u.def.section = bfd_abs_section_ptr;
		5820	}
		5821
		5822	free (buf);
		5823	}
		5824	}
		5825
		5826	static void
		5827	lang_end (void)
		5828	{
		5829	struct bfd_link_hash_entry *h;
		5830	bfd_boolean warn;
		5831
6324	serge	5832	if ((bfd_link_relocatable (&link_info) && !link_info.gc_sections)
		5833	\|\| bfd_link_dll (&link_info))
5199	serge	5834	warn = entry_from_cmdline;
		5835	else
		5836	warn = TRUE;
		5837
		5838	/* Force the user to specify a root when generating a relocatable with
		5839	--gc-sections. */
6324	serge	5840	if (link_info.gc_sections && bfd_link_relocatable (&link_info)
5199	serge	5841	&& !(entry_from_cmdline \|\| undef_from_cmdline))
		5842	einfo (_("%P%F: gc-sections requires either an entry or "
		5843	"an undefined symbol\n"));
		5844
		5845	if (entry_symbol.name == NULL)
		5846	{
		5847	/* No entry has been specified. Look for the default entry, but
		5848	don't warn if we don't find it. */
		5849	entry_symbol.name = entry_symbol_default;
		5850	warn = FALSE;
		5851	}
		5852
		5853	h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
		5854	FALSE, FALSE, TRUE);
		5855	if (h != NULL
		5856	&& (h->type == bfd_link_hash_defined
		5857	\|\| h->type == bfd_link_hash_defweak)
		5858	&& h->u.def.section->output_section != NULL)
		5859	{
		5860	bfd_vma val;
		5861
		5862	val = (h->u.def.value
		5863	+ bfd_get_section_vma (link_info.output_bfd,
		5864	h->u.def.section->output_section)
		5865	+ h->u.def.section->output_offset);
		5866	if (! bfd_set_start_address (link_info.output_bfd, val))
		5867	einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
		5868	}
		5869	else
		5870	{
		5871	bfd_vma val;
		5872	const char *send;
		5873
		5874	/* We couldn't find the entry symbol. Try parsing it as a
		5875	number. */
		5876	val = bfd_scan_vma (entry_symbol.name, &send, 0);
		5877	if (*send == '\0')
		5878	{
		5879	if (! bfd_set_start_address (link_info.output_bfd, val))
		5880	einfo (_("%P%F: can't set start address\n"));
		5881	}
		5882	else
		5883	{
		5884	asection *ts;
		5885
		5886	/* Can't find the entry symbol, and it's not a number. Use
		5887	the first address in the text section. */
		5888	ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
		5889	if (ts != NULL)
		5890	{
		5891	if (warn)
		5892	einfo (_("%P: warning: cannot find entry symbol %s;"
		5893	" defaulting to %V\n"),
		5894	entry_symbol.name,
		5895	bfd_get_section_vma (link_info.output_bfd, ts));
		5896	if (!(bfd_set_start_address
		5897	(link_info.output_bfd,
		5898	bfd_get_section_vma (link_info.output_bfd, ts))))
		5899	einfo (_("%P%F: can't set start address\n"));
		5900	}
		5901	else
		5902	{
		5903	if (warn)
		5904	einfo (_("%P: warning: cannot find entry symbol %s;"
		5905	" not setting start address\n"),
		5906	entry_symbol.name);
		5907	}
		5908	}
		5909	}
		5910	}
		5911
		5912	/* This is a small function used when we want to ignore errors from
		5913	BFD. */
		5914
		5915	static void
		5916	ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
		5917	{
		5918	/* Don't do anything. */
		5919	}
		5920
		5921	/* Check that the architecture of all the input files is compatible
		5922	with the output file. Also call the backend to let it do any
		5923	other checking that is needed. */
		5924
		5925	static void
		5926	lang_check (void)
		5927	{
		5928	lang_statement_union_type *file;
		5929	bfd *input_bfd;
		5930	const bfd_arch_info_type *compatible;
		5931
		5932	for (file = file_chain.head; file != NULL; file = file->input_statement.next)
		5933	{
		5934	#ifdef ENABLE_PLUGINS
		5935	/* Don't check format of files claimed by plugin. */
		5936	if (file->input_statement.flags.claimed)
		5937	continue;
		5938	#endif /* ENABLE_PLUGINS */
		5939	input_bfd = file->input_statement.the_bfd;
		5940	compatible
		5941	= bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
		5942	command_line.accept_unknown_input_arch);
		5943
		5944	/* In general it is not possible to perform a relocatable
		5945	link between differing object formats when the input
		5946	file has relocations, because the relocations in the
		5947	input format may not have equivalent representations in
		5948	the output format (and besides BFD does not translate
		5949	relocs for other link purposes than a final link). */
6324	serge	5950	if ((bfd_link_relocatable (&link_info)
		5951	\|\| link_info.emitrelocations)
5199	serge	5952	&& (compatible == NULL
		5953	\|\| (bfd_get_flavour (input_bfd)
		5954	!= bfd_get_flavour (link_info.output_bfd)))
		5955	&& (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
		5956	{
		5957	einfo (_("%P%F: Relocatable linking with relocations from"
		5958	" format %s (%B) to format %s (%B) is not supported\n"),
		5959	bfd_get_target (input_bfd), input_bfd,
		5960	bfd_get_target (link_info.output_bfd), link_info.output_bfd);
		5961	/* einfo with %F exits. */
		5962	}
		5963
		5964	if (compatible == NULL)
		5965	{
		5966	if (command_line.warn_mismatch)
		5967	einfo (_("%P%X: %s architecture of input file `%B'"
		5968	" is incompatible with %s output\n"),
		5969	bfd_printable_name (input_bfd), input_bfd,
		5970	bfd_printable_name (link_info.output_bfd));
		5971	}
		5972	else if (bfd_count_sections (input_bfd))
		5973	{
		5974	/* If the input bfd has no contents, it shouldn't set the
		5975	private data of the output bfd. */
		5976
		5977	bfd_error_handler_type pfn = NULL;
		5978
		5979	/* If we aren't supposed to warn about mismatched input
		5980	files, temporarily set the BFD error handler to a
		5981	function which will do nothing. We still want to call
		5982	bfd_merge_private_bfd_data, since it may set up
		5983	information which is needed in the output file. */
		5984	if (! command_line.warn_mismatch)
		5985	pfn = bfd_set_error_handler (ignore_bfd_errors);
		5986	if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
		5987	{
		5988	if (command_line.warn_mismatch)
		5989	einfo (_("%P%X: failed to merge target specific data"
		5990	" of file %B\n"), input_bfd);
		5991	}
		5992	if (! command_line.warn_mismatch)
		5993	bfd_set_error_handler (pfn);
		5994	}
		5995	}
		5996	}
		5997
		5998	/* Look through all the global common symbols and attach them to the
		5999	correct section. The -sort-common command line switch may be used
		6000	to roughly sort the entries by alignment. */
		6001
		6002	static void
		6003	lang_common (void)
		6004	{
		6005	if (command_line.inhibit_common_definition)
		6006	return;
6324	serge	6007	if (bfd_link_relocatable (&link_info)
5199	serge	6008	&& ! command_line.force_common_definition)
		6009	return;
		6010
		6011	if (! config.sort_common)
		6012	bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
		6013	else
		6014	{
		6015	unsigned int power;
		6016
		6017	if (config.sort_common == sort_descending)
		6018	{
		6019	for (power = 4; power > 0; power--)
		6020	bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
		6021
		6022	power = 0;
		6023	bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
		6024	}
		6025	else
		6026	{
		6027	for (power = 0; power <= 4; power++)
		6028	bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
		6029
6324	serge	6030	power = (unsigned int) -1;
5199	serge	6031	bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
		6032	}
		6033	}
		6034	}
		6035
		6036	/* Place one common symbol in the correct section. */
		6037
		6038	static bfd_boolean
		6039	lang_one_common (struct bfd_link_hash_entry h, void info)
		6040	{
		6041	unsigned int power_of_two;
		6042	bfd_vma size;
		6043	asection *section;
		6044
		6045	if (h->type != bfd_link_hash_common)
		6046	return TRUE;
		6047
		6048	size = h->u.c.size;
		6049	power_of_two = h->u.c.p->alignment_power;
		6050
		6051	if (config.sort_common == sort_descending
		6052	&& power_of_two < (unsigned int ) info)
		6053	return TRUE;
		6054	else if (config.sort_common == sort_ascending
		6055	&& power_of_two > (unsigned int ) info)
		6056	return TRUE;
		6057
		6058	section = h->u.c.p->section;
		6059	if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))
		6060	einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
		6061	h->root.string);
		6062
		6063	if (config.map_file != NULL)
		6064	{
		6065	static bfd_boolean header_printed;
		6066	int len;
		6067	char *name;
		6068	char buf[50];
		6069
		6070	if (! header_printed)
		6071	{
		6072	minfo (_("\nAllocating common symbols\n"));
		6073	minfo (_("Common symbol size file\n\n"));
		6074	header_printed = TRUE;
		6075	}
		6076
		6077	name = bfd_demangle (link_info.output_bfd, h->root.string,
		6078	DMGL_ANSI \| DMGL_PARAMS);
		6079	if (name == NULL)
		6080	{
		6081	minfo ("%s", h->root.string);
		6082	len = strlen (h->root.string);
		6083	}
		6084	else
		6085	{
		6086	minfo ("%s", name);
		6087	len = strlen (name);
		6088	free (name);
		6089	}
		6090
		6091	if (len >= 19)
		6092	{
		6093	print_nl ();
		6094	len = 0;
		6095	}
		6096	while (len < 20)
		6097	{
		6098	print_space ();
		6099	++len;
		6100	}
		6101
		6102	minfo ("0x");
		6103	if (size <= 0xffffffff)
		6104	sprintf (buf, "%lx", (unsigned long) size);
		6105	else
		6106	sprintf_vma (buf, size);
		6107	minfo ("%s", buf);
		6108	len = strlen (buf);
		6109
		6110	while (len < 16)
		6111	{
		6112	print_space ();
		6113	++len;
		6114	}
		6115
		6116	minfo ("%B\n", section->owner);
		6117	}
		6118
		6119	return TRUE;
		6120	}
		6121
6324	serge	6122	/* Handle a single orphan section S, placing the orphan into an appropriate
		6123	output section. The effects of the --orphan-handling command line
		6124	option are handled here. */
		6125
		6126	static void
		6127	ldlang_place_orphan (asection *s)
		6128	{
		6129	if (config.orphan_handling == orphan_handling_discard)
		6130	{
		6131	lang_output_section_statement_type *os;
		6132	os = lang_output_section_statement_lookup (DISCARD_SECTION_NAME, 0,
		6133	TRUE);
		6134	if (os->addr_tree == NULL
		6135	&& (bfd_link_relocatable (&link_info)
		6136	\|\| (s->flags & (SEC_LOAD \| SEC_ALLOC)) == 0))
		6137	os->addr_tree = exp_intop (0);
		6138	lang_add_section (&os->children, s, NULL, os);
		6139	}
		6140	else
		6141	{
		6142	lang_output_section_statement_type *os;
		6143	const char *name = s->name;
		6144	int constraint = 0;
		6145
		6146	if (config.orphan_handling == orphan_handling_error)
		6147	einfo ("%X%P: error: unplaced orphan section `%A' from `%B'.\n",
		6148	s, s->owner);
		6149
		6150	if (config.unique_orphan_sections \|\| unique_section_p (s, NULL))
		6151	constraint = SPECIAL;
		6152
		6153	os = ldemul_place_orphan (s, name, constraint);
		6154	if (os == NULL)
		6155	{
		6156	os = lang_output_section_statement_lookup (name, constraint, TRUE);
		6157	if (os->addr_tree == NULL
		6158	&& (bfd_link_relocatable (&link_info)
		6159	\|\| (s->flags & (SEC_LOAD \| SEC_ALLOC)) == 0))
		6160	os->addr_tree = exp_intop (0);
		6161	lang_add_section (&os->children, s, NULL, os);
		6162	}
		6163
		6164	if (config.orphan_handling == orphan_handling_warn)
		6165	einfo ("%P: warning: orphan section `%A' from `%B' being "
		6166	"placed in section `%s'.\n",
		6167	s, s->owner, os->name);
		6168	}
		6169	}
		6170
5199	serge	6171	/* Run through the input files and ensure that every input section has
		6172	somewhere to go. If one is found without a destination then create
		6173	an input request and place it into the statement tree. */
		6174
		6175	static void
		6176	lang_place_orphans (void)
		6177	{
		6178	LANG_FOR_EACH_INPUT_STATEMENT (file)
		6179	{
		6180	asection *s;
		6181
		6182	for (s = file->the_bfd->sections; s != NULL; s = s->next)
		6183	{
		6184	if (s->output_section == NULL)
		6185	{
		6186	/* This section of the file is not attached, root
		6187	around for a sensible place for it to go. */
		6188
		6189	if (file->flags.just_syms)
		6190	bfd_link_just_syms (file->the_bfd, s, &link_info);
		6191	else if ((s->flags & SEC_EXCLUDE) != 0)
		6192	s->output_section = bfd_abs_section_ptr;
		6193	else if (strcmp (s->name, "COMMON") == 0)
		6194	{
		6195	/* This is a lonely common section which must have
		6196	come from an archive. We attach to the section
		6197	with the wildcard. */
6324	serge	6198	if (!bfd_link_relocatable (&link_info)
5199	serge	6199	\|\| command_line.force_common_definition)
		6200	{
		6201	if (default_common_section == NULL)
		6202	default_common_section
		6203	= lang_output_section_statement_lookup (".bss", 0,
		6204	TRUE);
		6205	lang_add_section (&default_common_section->children, s,
		6206	NULL, default_common_section);
		6207	}
		6208	}
		6209	else
6324	serge	6210	ldlang_place_orphan (s);
5199	serge	6211	}
		6212	}
		6213	}
		6214	}
		6215
		6216	void
		6217	lang_set_flags (lang_memory_region_type ptr, const char flags, int invert)
		6218	{
		6219	flagword *ptr_flags;
		6220
		6221	ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
6324	serge	6222
5199	serge	6223	while (*flags)
		6224	{
		6225	switch (*flags)
		6226	{
6324	serge	6227	/* PR 17900: An exclamation mark in the attributes reverses
		6228	the sense of any of the attributes that follow. */
		6229	case '!':
		6230	invert = ! invert;
		6231	ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
		6232	break;
		6233
5199	serge	6234	case 'A': case 'a':
		6235	*ptr_flags \|= SEC_ALLOC;
		6236	break;
		6237
		6238	case 'R': case 'r':
		6239	*ptr_flags \|= SEC_READONLY;
		6240	break;
		6241
		6242	case 'W': case 'w':
		6243	*ptr_flags \|= SEC_DATA;
		6244	break;
		6245
		6246	case 'X': case 'x':
		6247	*ptr_flags \|= SEC_CODE;
		6248	break;
		6249
		6250	case 'L': case 'l':
		6251	case 'I': case 'i':
		6252	*ptr_flags \|= SEC_LOAD;
		6253	break;
		6254
		6255	default:
6324	serge	6256	einfo (_("%P%F: invalid character %c (%d) in flags\n"), * flags, * flags);
5199	serge	6257	break;
		6258	}
		6259	flags++;
		6260	}
		6261	}
		6262
		6263	/* Call a function on each input file. This function will be called
		6264	on an archive, but not on the elements. */
		6265
		6266	void
		6267	lang_for_each_input_file (void (func) (lang_input_statement_type ))
		6268	{
		6269	lang_input_statement_type *f;
		6270
		6271	for (f = (lang_input_statement_type *) input_file_chain.head;
		6272	f != NULL;
		6273	f = (lang_input_statement_type *) f->next_real_file)
		6274	func (f);
		6275	}
		6276
		6277	/* Call a function on each file. The function will be called on all
		6278	the elements of an archive which are included in the link, but will
		6279	not be called on the archive file itself. */
		6280
		6281	void
		6282	lang_for_each_file (void (func) (lang_input_statement_type ))
		6283	{
		6284	LANG_FOR_EACH_INPUT_STATEMENT (f)
		6285	{
		6286	func (f);
		6287	}
		6288	}
		6289
		6290	void
		6291	ldlang_add_file (lang_input_statement_type *entry)
		6292	{
		6293	lang_statement_append (&file_chain,
		6294	(lang_statement_union_type *) entry,
		6295	&entry->next);
		6296
		6297	/* The BFD linker needs to have a list of all input BFDs involved in
		6298	a link. */
6324	serge	6299	ASSERT (entry->the_bfd->link.next == NULL);
5199	serge	6300	ASSERT (entry->the_bfd != link_info.output_bfd);
		6301
		6302	*link_info.input_bfds_tail = entry->the_bfd;
6324	serge	6303	link_info.input_bfds_tail = &entry->the_bfd->link.next;
5199	serge	6304	entry->the_bfd->usrdata = entry;
		6305	bfd_set_gp_size (entry->the_bfd, g_switch_value);
		6306
		6307	/* Look through the sections and check for any which should not be
		6308	included in the link. We need to do this now, so that we can
		6309	notice when the backend linker tries to report multiple
		6310	definition errors for symbols which are in sections we aren't
		6311	going to link. FIXME: It might be better to entirely ignore
		6312	symbols which are defined in sections which are going to be
		6313	discarded. This would require modifying the backend linker for
		6314	each backend which might set the SEC_LINK_ONCE flag. If we do
		6315	this, we should probably handle SEC_EXCLUDE in the same way. */
		6316
		6317	bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
		6318	}
		6319
		6320	void
		6321	lang_add_output (const char *name, int from_script)
		6322	{
		6323	/* Make -o on command line override OUTPUT in script. */
		6324	if (!had_output_filename \|\| !from_script)
		6325	{
		6326	output_filename = name;
		6327	had_output_filename = TRUE;
		6328	}
		6329	}
		6330
		6331	static int
		6332	topower (int x)
		6333	{
		6334	unsigned int i = 1;
		6335	int l;
		6336
		6337	if (x < 0)
		6338	return -1;
		6339
		6340	for (l = 0; l < 32; l++)
		6341	{
		6342	if (i >= (unsigned int) x)
		6343	return l;
		6344	i <<= 1;
		6345	}
		6346
		6347	return 0;
		6348	}
		6349
		6350	lang_output_section_statement_type *
		6351	lang_enter_output_section_statement (const char *output_section_statement_name,
		6352	etree_type *address_exp,
		6353	enum section_type sectype,
		6354	etree_type *align,
		6355	etree_type *subalign,
		6356	etree_type *ebase,
		6357	int constraint,
		6358	int align_with_input)
		6359	{
		6360	lang_output_section_statement_type *os;
		6361
		6362	os = lang_output_section_statement_lookup (output_section_statement_name,
		6363	constraint, TRUE);
		6364	current_section = os;
		6365
		6366	if (os->addr_tree == NULL)
		6367	{
		6368	os->addr_tree = address_exp;
		6369	}
		6370	os->sectype = sectype;
		6371	if (sectype != noload_section)
		6372	os->flags = SEC_NO_FLAGS;
		6373	else
		6374	os->flags = SEC_NEVER_LOAD;
		6375	os->block_value = 1;
		6376
		6377	/* Make next things chain into subchain of this. */
		6378	push_stat_ptr (&os->children);
		6379
		6380	os->align_lma_with_input = align_with_input == ALIGN_WITH_INPUT;
		6381	if (os->align_lma_with_input && align != NULL)
		6382	einfo (_("%F%P:%S: error: align with input and explicit align specified\n"), NULL);
		6383
		6384	os->subsection_alignment =
		6385	topower (exp_get_value_int (subalign, -1, "subsection alignment"));
		6386	os->section_alignment =
		6387	topower (exp_get_value_int (align, -1, "section alignment"));
		6388
		6389	os->load_base = ebase;
		6390	return os;
		6391	}
		6392
		6393	void
		6394	lang_final (void)
		6395	{
		6396	lang_output_statement_type *new_stmt;
		6397
		6398	new_stmt = new_stat (lang_output_statement, stat_ptr);
		6399	new_stmt->name = output_filename;
		6400	}
		6401
		6402	/* Reset the current counters in the regions. */
		6403
		6404	void
		6405	lang_reset_memory_regions (void)
		6406	{
		6407	lang_memory_region_type *p = lang_memory_region_list;
		6408	asection *o;
		6409	lang_output_section_statement_type *os;
		6410
		6411	for (p = lang_memory_region_list; p != NULL; p = p->next)
		6412	{
		6413	p->current = p->origin;
		6414	p->last_os = NULL;
		6415	}
		6416
		6417	for (os = &lang_output_section_statement.head->output_section_statement;
		6418	os != NULL;
		6419	os = os->next)
		6420	{
		6421	os->processed_vma = FALSE;
		6422	os->processed_lma = FALSE;
		6423	}
		6424
		6425	for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
		6426	{
		6427	/* Save the last size for possible use by bfd_relax_section. */
		6428	o->rawsize = o->size;
		6429	o->size = 0;
		6430	}
		6431	}
		6432
		6433	/* Worker for lang_gc_sections_1. */
		6434
		6435	static void
		6436	gc_section_callback (lang_wild_statement_type *ptr,
		6437	struct wildcard_list *sec ATTRIBUTE_UNUSED,
		6438	asection *section,
		6439	struct flag_info *sflag_info ATTRIBUTE_UNUSED,
		6440	lang_input_statement_type *file ATTRIBUTE_UNUSED,
		6441	void *data ATTRIBUTE_UNUSED)
		6442	{
		6443	/* If the wild pattern was marked KEEP, the member sections
		6444	should be as well. */
		6445	if (ptr->keep_sections)
		6446	section->flags \|= SEC_KEEP;
		6447	}
		6448
		6449	/* Iterate over sections marking them against GC. */
		6450
		6451	static void
		6452	lang_gc_sections_1 (lang_statement_union_type *s)
		6453	{
		6454	for (; s != NULL; s = s->header.next)
		6455	{
		6456	switch (s->header.type)
		6457	{
		6458	case lang_wild_statement_enum:
		6459	walk_wild (&s->wild_statement, gc_section_callback, NULL);
		6460	break;
		6461	case lang_constructors_statement_enum:
		6462	lang_gc_sections_1 (constructor_list.head);
		6463	break;
		6464	case lang_output_section_statement_enum:
		6465	lang_gc_sections_1 (s->output_section_statement.children.head);
		6466	break;
		6467	case lang_group_statement_enum:
		6468	lang_gc_sections_1 (s->group_statement.children.head);
		6469	break;
		6470	default:
		6471	break;
		6472	}
		6473	}
		6474	}
		6475
		6476	static void
		6477	lang_gc_sections (void)
		6478	{
		6479	/* Keep all sections so marked in the link script. */
		6480
		6481	lang_gc_sections_1 (statement_list.head);
		6482
		6483	/* SEC_EXCLUDE is ignored when doing a relocatable link, except in
		6484	the special case of debug info. (See bfd/stabs.c)
		6485	Twiddle the flag here, to simplify later linker code. */
6324	serge	6486	if (bfd_link_relocatable (&link_info))
5199	serge	6487	{
		6488	LANG_FOR_EACH_INPUT_STATEMENT (f)
		6489	{
		6490	asection *sec;
		6491	#ifdef ENABLE_PLUGINS
		6492	if (f->flags.claimed)
		6493	continue;
		6494	#endif
		6495	for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
		6496	if ((sec->flags & SEC_DEBUGGING) == 0)
		6497	sec->flags &= ~SEC_EXCLUDE;
		6498	}
		6499	}
		6500
		6501	if (link_info.gc_sections)
		6502	bfd_gc_sections (link_info.output_bfd, &link_info);
		6503	}
		6504
		6505	/* Worker for lang_find_relro_sections_1. */
		6506
		6507	static void
		6508	find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
		6509	struct wildcard_list *sec ATTRIBUTE_UNUSED,
		6510	asection *section,
		6511	struct flag_info *sflag_info ATTRIBUTE_UNUSED,
		6512	lang_input_statement_type *file ATTRIBUTE_UNUSED,
		6513	void *data)
		6514	{
		6515	/* Discarded, excluded and ignored sections effectively have zero
		6516	size. */
		6517	if (section->output_section != NULL
		6518	&& section->output_section->owner == link_info.output_bfd
		6519	&& (section->output_section->flags & SEC_EXCLUDE) == 0
		6520	&& !IGNORE_SECTION (section)
		6521	&& section->size != 0)
		6522	{
		6523	bfd_boolean has_relro_section = (bfd_boolean ) data;
		6524	*has_relro_section = TRUE;
		6525	}
		6526	}
		6527
		6528	/* Iterate over sections for relro sections. */
		6529
		6530	static void
		6531	lang_find_relro_sections_1 (lang_statement_union_type *s,
		6532	bfd_boolean *has_relro_section)
		6533	{
		6534	if (*has_relro_section)
		6535	return;
		6536
		6537	for (; s != NULL; s = s->header.next)
		6538	{
		6539	if (s == expld.dataseg.relro_end_stat)
		6540	break;
		6541
		6542	switch (s->header.type)
		6543	{
		6544	case lang_wild_statement_enum:
		6545	walk_wild (&s->wild_statement,
		6546	find_relro_section_callback,
		6547	has_relro_section);
		6548	break;
		6549	case lang_constructors_statement_enum:
		6550	lang_find_relro_sections_1 (constructor_list.head,
		6551	has_relro_section);
		6552	break;
		6553	case lang_output_section_statement_enum:
		6554	lang_find_relro_sections_1 (s->output_section_statement.children.head,
		6555	has_relro_section);
		6556	break;
		6557	case lang_group_statement_enum:
		6558	lang_find_relro_sections_1 (s->group_statement.children.head,
		6559	has_relro_section);
		6560	break;
		6561	default:
		6562	break;
		6563	}
		6564	}
		6565	}
		6566
		6567	static void
		6568	lang_find_relro_sections (void)
		6569	{
		6570	bfd_boolean has_relro_section = FALSE;
		6571
		6572	/* Check all sections in the link script. */
		6573
		6574	lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
		6575	&has_relro_section);
		6576
		6577	if (!has_relro_section)
		6578	link_info.relro = FALSE;
		6579	}
		6580
		6581	/* Relax all sections until bfd_relax_section gives up. */
		6582
		6583	void
		6584	lang_relax_sections (bfd_boolean need_layout)
		6585	{
		6586	if (RELAXATION_ENABLED)
		6587	{
		6588	/* We may need more than one relaxation pass. */
		6589	int i = link_info.relax_pass;
		6590
		6591	/* The backend can use it to determine the current pass. */
		6592	link_info.relax_pass = 0;
		6593
		6594	while (i--)
		6595	{
		6596	/* Keep relaxing until bfd_relax_section gives up. */
		6597	bfd_boolean relax_again;
		6598
		6599	link_info.relax_trip = -1;
		6600	do
		6601	{
		6602	link_info.relax_trip++;
		6603
		6604	/* Note: pe-dll.c does something like this also. If you find
		6605	you need to change this code, you probably need to change
		6606	pe-dll.c also. DJ */
		6607
		6608	/* Do all the assignments with our current guesses as to
		6609	section sizes. */
		6610	lang_do_assignments (lang_assigning_phase_enum);
		6611
		6612	/* We must do this after lang_do_assignments, because it uses
		6613	size. */
		6614	lang_reset_memory_regions ();
		6615
		6616	/* Perform another relax pass - this time we know where the
		6617	globals are, so can make a better guess. */
		6618	relax_again = FALSE;
		6619	lang_size_sections (&relax_again, FALSE);
		6620	}
		6621	while (relax_again);
		6622
		6623	link_info.relax_pass++;
		6624	}
		6625	need_layout = TRUE;
		6626	}
		6627
		6628	if (need_layout)
		6629	{
		6630	/* Final extra sizing to report errors. */
		6631	lang_do_assignments (lang_assigning_phase_enum);
		6632	lang_reset_memory_regions ();
		6633	lang_size_sections (NULL, TRUE);
		6634	}
		6635	}
		6636
		6637	#ifdef ENABLE_PLUGINS
		6638	/* Find the insert point for the plugin's replacement files. We
		6639	place them after the first claimed real object file, or if the
		6640	first claimed object is an archive member, after the last real
		6641	object file immediately preceding the archive. In the event
		6642	no objects have been claimed at all, we return the first dummy
		6643	object file on the list as the insert point; that works, but
		6644	the callee must be careful when relinking the file_chain as it
		6645	is not actually on that chain, only the statement_list and the
		6646	input_file list; in that case, the replacement files must be
		6647	inserted at the head of the file_chain. */
		6648
		6649	static lang_input_statement_type *
		6650	find_replacements_insert_point (void)
		6651	{
		6652	lang_input_statement_type claim1, lastobject;
		6653	lastobject = &input_file_chain.head->input_statement;
		6654	for (claim1 = &file_chain.head->input_statement;
		6655	claim1 != NULL;
		6656	claim1 = &claim1->next->input_statement)
		6657	{
		6658	if (claim1->flags.claimed)
		6659	return claim1->flags.claim_archive ? lastobject : claim1;
		6660	/* Update lastobject if this is a real object file. */
		6661	if (claim1->the_bfd && (claim1->the_bfd->my_archive == NULL))
		6662	lastobject = claim1;
		6663	}
		6664	/* No files were claimed by the plugin. Choose the last object
		6665	file found on the list (maybe the first, dummy entry) as the
		6666	insert point. */
		6667	return lastobject;
		6668	}
		6669
		6670	/* Insert SRCLIST into DESTLIST after given element by chaining
		6671	on FIELD as the next-pointer. (Counterintuitively does not need
		6672	a pointer to the actual after-node itself, just its chain field.) */
		6673
		6674	static void
		6675	lang_list_insert_after (lang_statement_list_type *destlist,
		6676	lang_statement_list_type *srclist,
		6677	lang_statement_union_type **field)
		6678	{
		6679	(srclist->tail) = field;
		6680	*field = srclist->head;
		6681	if (destlist->tail == field)
		6682	destlist->tail = srclist->tail;
		6683	}
		6684
		6685	/* Detach new nodes added to DESTLIST since the time ORIGLIST
		6686	was taken as a copy of it and leave them in ORIGLIST. */
		6687
		6688	static void
		6689	lang_list_remove_tail (lang_statement_list_type *destlist,
		6690	lang_statement_list_type *origlist)
		6691	{
		6692	union lang_statement_union **savetail;
		6693	/* Check that ORIGLIST really is an earlier state of DESTLIST. */
		6694	ASSERT (origlist->head == destlist->head);
		6695	savetail = origlist->tail;
		6696	origlist->head = *(savetail);
		6697	origlist->tail = destlist->tail;
		6698	destlist->tail = savetail;
		6699	*savetail = NULL;
		6700	}
		6701	#endif /* ENABLE_PLUGINS */
		6702
		6703	void
		6704	lang_process (void)
		6705	{
		6706	/* Finalize dynamic list. */
		6707	if (link_info.dynamic_list)
		6708	lang_finalize_version_expr_head (&link_info.dynamic_list->head);
		6709
		6710	current_target = default_target;
		6711
		6712	/* Open the output file. */
		6713	lang_for_each_statement (ldlang_open_output);
		6714	init_opb ();
		6715
		6716	ldemul_create_output_section_statements ();
		6717
		6718	/* Add to the hash table all undefineds on the command line. */
		6719	lang_place_undefineds ();
		6720
		6721	if (!bfd_section_already_linked_table_init ())
		6722	einfo (_("%P%F: Failed to create hash table\n"));
		6723
		6724	/* Create a bfd for each input file. */
		6725	current_target = default_target;
		6726	open_input_bfds (statement_list.head, OPEN_BFD_NORMAL);
		6727
		6728	#ifdef ENABLE_PLUGINS
6324	serge	6729	if (link_info.lto_plugin_active)
5199	serge	6730	{
		6731	lang_statement_list_type added;
		6732	lang_statement_list_type files, inputfiles;
		6733
		6734	/* Now all files are read, let the plugin(s) decide if there
		6735	are any more to be added to the link before we call the
		6736	emulation's after_open hook. We create a private list of
		6737	input statements for this purpose, which we will eventually
		6738	insert into the global statment list after the first claimed
		6739	file. */
		6740	added = *stat_ptr;
		6741	/* We need to manipulate all three chains in synchrony. */
		6742	files = file_chain;
		6743	inputfiles = input_file_chain;
		6744	if (plugin_call_all_symbols_read ())
		6745	einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
		6746	plugin_error_plugin ());
		6747	/* Open any newly added files, updating the file chains. */
		6748	open_input_bfds (*added.tail, OPEN_BFD_NORMAL);
		6749	/* Restore the global list pointer now they have all been added. */
		6750	lang_list_remove_tail (stat_ptr, &added);
		6751	/* And detach the fresh ends of the file lists. */
		6752	lang_list_remove_tail (&file_chain, &files);
		6753	lang_list_remove_tail (&input_file_chain, &inputfiles);
		6754	/* Were any new files added? */
		6755	if (added.head != NULL)
		6756	{
		6757	/* If so, we will insert them into the statement list immediately
		6758	after the first input file that was claimed by the plugin. */
		6759	plugin_insert = find_replacements_insert_point ();
		6760	/* If a plugin adds input files without having claimed any, we
		6761	don't really have a good idea where to place them. Just putting
		6762	them at the start or end of the list is liable to leave them
		6763	outside the crtbegin...crtend range. */
		6764	ASSERT (plugin_insert != NULL);
		6765	/* Splice the new statement list into the old one. */
		6766	lang_list_insert_after (stat_ptr, &added,
		6767	&plugin_insert->header.next);
		6768	/* Likewise for the file chains. */
		6769	lang_list_insert_after (&input_file_chain, &inputfiles,
		6770	&plugin_insert->next_real_file);
		6771	/* We must be careful when relinking file_chain; we may need to
		6772	insert the new files at the head of the list if the insert
		6773	point chosen is the dummy first input file. */
		6774	if (plugin_insert->filename)
		6775	lang_list_insert_after (&file_chain, &files, &plugin_insert->next);
		6776	else
		6777	lang_list_insert_after (&file_chain, &files, &file_chain.head);
		6778
		6779	/* Rescan archives in case new undefined symbols have appeared. */
		6780	open_input_bfds (statement_list.head, OPEN_BFD_RESCAN);
		6781	}
		6782	}
		6783	#endif /* ENABLE_PLUGINS */
		6784
		6785	link_info.gc_sym_list = &entry_symbol;
		6786	if (entry_symbol.name == NULL)
		6787	link_info.gc_sym_list = ldlang_undef_chain_list_head;
6324	serge	6788	if (link_info.init_function != NULL)
		6789	{
		6790	struct bfd_sym_chain *sym
		6791	= (struct bfd_sym_chain ) stat_alloc (sizeof (sym));
		6792	sym->next = link_info.gc_sym_list;
		6793	sym->name = link_info.init_function;
		6794	link_info.gc_sym_list = sym;
		6795	}
		6796	if (link_info.fini_function != NULL)
		6797	{
		6798	struct bfd_sym_chain *sym
		6799	= (struct bfd_sym_chain ) stat_alloc (sizeof (sym));
		6800	sym->next = link_info.gc_sym_list;
		6801	sym->name = link_info.fini_function;
		6802	link_info.gc_sym_list = sym;
		6803	}
5199	serge	6804
		6805	ldemul_after_open ();
6324	serge	6806	if (config.map_file != NULL)
		6807	lang_print_asneeded ();
5199	serge	6808
		6809	bfd_section_already_linked_table_free ();
		6810
		6811	/* Make sure that we're not mixing architectures. We call this
		6812	after all the input files have been opened, but before we do any
		6813	other processing, so that any operations merge_private_bfd_data
		6814	does on the output file will be known during the rest of the
		6815	link. */
		6816	lang_check ();
		6817
		6818	/* Handle .exports instead of a version script if we're told to do so. */
		6819	if (command_line.version_exports_section)
		6820	lang_do_version_exports_section ();
		6821
		6822	/* Build all sets based on the information gathered from the input
		6823	files. */
		6824	ldctor_build_sets ();
		6825
		6826	/* PR 13683: We must rerun the assignments prior to running garbage
		6827	collection in order to make sure that all symbol aliases are resolved. */
		6828	lang_do_assignments (lang_mark_phase_enum);
6324	serge	6829
		6830	lang_do_memory_regions();
5199	serge	6831	expld.phase = lang_first_phase_enum;
		6832
6324	serge	6833	/* Size up the common data. */
		6834	lang_common ();
		6835
5199	serge	6836	/* Remove unreferenced sections if asked to. */
		6837	lang_gc_sections ();
		6838
		6839	/* Update wild statements. */
		6840	update_wild_statements (statement_list.head);
		6841
		6842	/* Run through the contours of the script and attach input sections
		6843	to the correct output sections. */
		6844	lang_statement_iteration++;
		6845	map_input_to_output_sections (statement_list.head, NULL, NULL);
		6846
		6847	process_insert_statements ();
		6848
		6849	/* Find any sections not attached explicitly and handle them. */
		6850	lang_place_orphans ();
		6851
6324	serge	6852	if (!bfd_link_relocatable (&link_info))
5199	serge	6853	{
		6854	asection *found;
		6855
		6856	/* Merge SEC_MERGE sections. This has to be done after GC of
		6857	sections, so that GCed sections are not merged, but before
		6858	assigning dynamic symbols, since removing whole input sections
		6859	is hard then. */
		6860	bfd_merge_sections (link_info.output_bfd, &link_info);
		6861
		6862	/* Look for a text section and set the readonly attribute in it. */
		6863	found = bfd_get_section_by_name (link_info.output_bfd, ".text");
		6864
		6865	if (found != NULL)
		6866	{
		6867	if (config.text_read_only)
		6868	found->flags \|= SEC_READONLY;
		6869	else
		6870	found->flags &= ~SEC_READONLY;
		6871	}
		6872	}
		6873
		6874	/* Do anything special before sizing sections. This is where ELF
		6875	and other back-ends size dynamic sections. */
		6876	ldemul_before_allocation ();
		6877
		6878	/* We must record the program headers before we try to fix the
		6879	section positions, since they will affect SIZEOF_HEADERS. */
		6880	lang_record_phdrs ();
		6881
		6882	/* Check relro sections. */
6324	serge	6883	if (link_info.relro && !bfd_link_relocatable (&link_info))
5199	serge	6884	lang_find_relro_sections ();
		6885
		6886	/* Size up the sections. */
		6887	lang_size_sections (NULL, ! RELAXATION_ENABLED);
		6888
		6889	/* See if anything special should be done now we know how big
		6890	everything is. This is where relaxation is done. */
		6891	ldemul_after_allocation ();
		6892
		6893	/* Fix any .startof. or .sizeof. symbols. */
		6894	lang_set_startof ();
		6895
		6896	/* Do all the assignments, now that we know the final resting places
		6897	of all the symbols. */
		6898	lang_do_assignments (lang_final_phase_enum);
		6899
		6900	ldemul_finish ();
		6901
6324	serge	6902	/* Convert absolute symbols to section relative. */
		6903	ldexp_finalize_syms ();
		6904
5199	serge	6905	/* Make sure that the section addresses make sense. */
		6906	if (command_line.check_section_addresses)
		6907	lang_check_section_addresses ();
		6908
6324	serge	6909	/* Check any required symbols are known. */
		6910	ldlang_check_require_defined_symbols ();
		6911
5199	serge	6912	lang_end ();
		6913	}
		6914
		6915	/* EXPORTED TO YACC */
		6916
		6917	void
		6918	lang_add_wild (struct wildcard_spec *filespec,
		6919	struct wildcard_list *section_list,
		6920	bfd_boolean keep_sections)
		6921	{
		6922	struct wildcard_list curr, next;
		6923	lang_wild_statement_type *new_stmt;
		6924
		6925	/* Reverse the list as the parser puts it back to front. */
		6926	for (curr = section_list, section_list = NULL;
		6927	curr != NULL;
		6928	section_list = curr, curr = next)
		6929	{
		6930	if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
		6931	placed_commons = TRUE;
		6932
		6933	next = curr->next;
		6934	curr->next = section_list;
		6935	}
		6936
		6937	if (filespec != NULL && filespec->name != NULL)
		6938	{
		6939	if (strcmp (filespec->name, "*") == 0)
		6940	filespec->name = NULL;
		6941	else if (! wildcardp (filespec->name))
		6942	lang_has_input_file = TRUE;
		6943	}
		6944
		6945	new_stmt = new_stat (lang_wild_statement, stat_ptr);
		6946	new_stmt->filename = NULL;
		6947	new_stmt->filenames_sorted = FALSE;
		6948	new_stmt->section_flag_list = NULL;
		6949	if (filespec != NULL)
		6950	{
		6951	new_stmt->filename = filespec->name;
		6952	new_stmt->filenames_sorted = filespec->sorted == by_name;
		6953	new_stmt->section_flag_list = filespec->section_flag_list;
		6954	}
		6955	new_stmt->section_list = section_list;
		6956	new_stmt->keep_sections = keep_sections;
		6957	lang_list_init (&new_stmt->children);
		6958	analyze_walk_wild_section_handler (new_stmt);
		6959	}
		6960
		6961	void
		6962	lang_section_start (const char name, etree_type address,
		6963	const segment_type *segment)
		6964	{
		6965	lang_address_statement_type *ad;
		6966
		6967	ad = new_stat (lang_address_statement, stat_ptr);
		6968	ad->section_name = name;
		6969	ad->address = address;
		6970	ad->segment = segment;
		6971	}
		6972
		6973	/* Set the start symbol to NAME. CMDLINE is nonzero if this is called
		6974	because of a -e argument on the command line, or zero if this is
		6975	called by ENTRY in a linker script. Command line arguments take
		6976	precedence. */
		6977
		6978	void
		6979	lang_add_entry (const char *name, bfd_boolean cmdline)
		6980	{
		6981	if (entry_symbol.name == NULL
		6982	\|\| cmdline
		6983	\|\| ! entry_from_cmdline)
		6984	{
		6985	entry_symbol.name = name;
		6986	entry_from_cmdline = cmdline;
		6987	}
		6988	}
		6989
		6990	/* Set the default start symbol to NAME. .em files should use this,
		6991	not lang_add_entry, to override the use of "start" if neither the
		6992	linker script nor the command line specifies an entry point. NAME
		6993	must be permanently allocated. */
		6994	void
		6995	lang_default_entry (const char *name)
		6996	{
		6997	entry_symbol_default = name;
		6998	}
		6999
		7000	void
		7001	lang_add_target (const char *name)
		7002	{
		7003	lang_target_statement_type *new_stmt;
		7004
		7005	new_stmt = new_stat (lang_target_statement, stat_ptr);
		7006	new_stmt->target = name;
		7007	}
		7008
		7009	void
		7010	lang_add_map (const char *name)
		7011	{
		7012	while (*name)
		7013	{
		7014	switch (*name)
		7015	{
		7016	case 'F':
		7017	map_option_f = TRUE;
		7018	break;
		7019	}
		7020	name++;
		7021	}
		7022	}
		7023
		7024	void
		7025	lang_add_fill (fill_type *fill)
		7026	{
		7027	lang_fill_statement_type *new_stmt;
		7028
		7029	new_stmt = new_stat (lang_fill_statement, stat_ptr);
		7030	new_stmt->fill = fill;
		7031	}
		7032
		7033	void
		7034	lang_add_data (int type, union etree_union *exp)
		7035	{
		7036	lang_data_statement_type *new_stmt;
		7037
		7038	new_stmt = new_stat (lang_data_statement, stat_ptr);
		7039	new_stmt->exp = exp;
		7040	new_stmt->type = type;
		7041	}
		7042
		7043	/* Create a new reloc statement. RELOC is the BFD relocation type to
		7044	generate. HOWTO is the corresponding howto structure (we could
		7045	look this up, but the caller has already done so). SECTION is the
		7046	section to generate a reloc against, or NAME is the name of the
		7047	symbol to generate a reloc against. Exactly one of SECTION and
		7048	NAME must be NULL. ADDEND is an expression for the addend. */
		7049
		7050	void
		7051	lang_add_reloc (bfd_reloc_code_real_type reloc,
		7052	reloc_howto_type *howto,
		7053	asection *section,
		7054	const char *name,
		7055	union etree_union *addend)
		7056	{
		7057	lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
		7058
		7059	p->reloc = reloc;
		7060	p->howto = howto;
		7061	p->section = section;
		7062	p->name = name;
		7063	p->addend_exp = addend;
		7064
		7065	p->addend_value = 0;
		7066	p->output_section = NULL;
		7067	p->output_offset = 0;
		7068	}
		7069
		7070	lang_assignment_statement_type *
		7071	lang_add_assignment (etree_type *exp)
		7072	{
		7073	lang_assignment_statement_type *new_stmt;
		7074
		7075	new_stmt = new_stat (lang_assignment_statement, stat_ptr);
		7076	new_stmt->exp = exp;
		7077	return new_stmt;
		7078	}
		7079
		7080	void
		7081	lang_add_attribute (enum statement_enum attribute)
		7082	{
		7083	new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
		7084	}
		7085
		7086	void
		7087	lang_startup (const char *name)
		7088	{
		7089	if (first_file->filename != NULL)
		7090	{
		7091	einfo (_("%P%F: multiple STARTUP files\n"));
		7092	}
		7093	first_file->filename = name;
		7094	first_file->local_sym_name = name;
		7095	first_file->flags.real = TRUE;
		7096	}
		7097
		7098	void
		7099	lang_float (bfd_boolean maybe)
		7100	{
		7101	lang_float_flag = maybe;
		7102	}
		7103
		7104
		7105	/* Work out the load- and run-time regions from a script statement, and
		7106	store them in LMA_REGION and REGION respectively.
		7107
		7108	MEMSPEC is the name of the run-time region, or the value of
		7109	DEFAULT_MEMORY_REGION if the statement didn't specify one.
		7110	LMA_MEMSPEC is the name of the load-time region, or null if the
		7111	statement didn't specify one.HAVE_LMA_P is TRUE if the statement
		7112	had an explicit load address.
		7113
		7114	It is an error to specify both a load region and a load address. */
		7115
		7116	static void
		7117	lang_get_regions (lang_memory_region_type **region,
		7118	lang_memory_region_type **lma_region,
		7119	const char *memspec,
		7120	const char *lma_memspec,
		7121	bfd_boolean have_lma,
		7122	bfd_boolean have_vma)
		7123	{
		7124	*lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
		7125
		7126	/* If no runtime region or VMA has been specified, but the load region
		7127	has been specified, then use the load region for the runtime region
		7128	as well. */
		7129	if (lma_memspec != NULL
		7130	&& ! have_vma
		7131	&& strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
		7132	region = lma_region;
		7133	else
		7134	*region = lang_memory_region_lookup (memspec, FALSE);
		7135
		7136	if (have_lma && lma_memspec != 0)
		7137	einfo (_("%X%P:%S: section has both a load address and a load region\n"),
		7138	NULL);
		7139	}
		7140
		7141	void
		7142	lang_leave_output_section_statement (fill_type fill, const char memspec,
		7143	lang_output_section_phdr_list *phdrs,
		7144	const char *lma_memspec)
		7145	{
		7146	lang_get_regions (¤t_section->region,
		7147	¤t_section->lma_region,
		7148	memspec, lma_memspec,
		7149	current_section->load_base != NULL,
		7150	current_section->addr_tree != NULL);
		7151
		7152	/* If this section has no load region or base, but uses the same
		7153	region as the previous section, then propagate the previous
		7154	section's load region. */
		7155
		7156	if (current_section->lma_region == NULL
		7157	&& current_section->load_base == NULL
		7158	&& current_section->addr_tree == NULL
		7159	&& current_section->region == current_section->prev->region)
		7160	current_section->lma_region = current_section->prev->lma_region;
		7161
		7162	current_section->fill = fill;
		7163	current_section->phdrs = phdrs;
		7164	pop_stat_ptr ();
		7165	}
		7166
		7167	void
		7168	lang_statement_append (lang_statement_list_type *list,
		7169	lang_statement_union_type *element,
		7170	lang_statement_union_type **field)
		7171	{
		7172	*(list->tail) = element;
		7173	list->tail = field;
		7174	}
		7175
		7176	/* Set the output format type. -oformat overrides scripts. */
		7177
		7178	void
		7179	lang_add_output_format (const char *format,
		7180	const char *big,
		7181	const char *little,
		7182	int from_script)
		7183	{
		7184	if (output_target == NULL \|\| !from_script)
		7185	{
		7186	if (command_line.endian == ENDIAN_BIG
		7187	&& big != NULL)
		7188	format = big;
		7189	else if (command_line.endian == ENDIAN_LITTLE
		7190	&& little != NULL)
		7191	format = little;
		7192
		7193	output_target = format;
		7194	}
		7195	}
		7196
		7197	void
		7198	lang_add_insert (const char *where, int is_before)
		7199	{
		7200	lang_insert_statement_type *new_stmt;
		7201
		7202	new_stmt = new_stat (lang_insert_statement, stat_ptr);
		7203	new_stmt->where = where;
		7204	new_stmt->is_before = is_before;
		7205	saved_script_handle = previous_script_handle;
		7206	}
		7207
		7208	/* Enter a group. This creates a new lang_group_statement, and sets
		7209	stat_ptr to build new statements within the group. */
		7210
		7211	void
		7212	lang_enter_group (void)
		7213	{
		7214	lang_group_statement_type *g;
		7215
		7216	g = new_stat (lang_group_statement, stat_ptr);
		7217	lang_list_init (&g->children);
		7218	push_stat_ptr (&g->children);
		7219	}
		7220
		7221	/* Leave a group. This just resets stat_ptr to start writing to the
		7222	regular list of statements again. Note that this will not work if
		7223	groups can occur inside anything else which can adjust stat_ptr,
		7224	but currently they can't. */
		7225
		7226	void
		7227	lang_leave_group (void)
		7228	{
		7229	pop_stat_ptr ();
		7230	}
		7231
		7232	/* Add a new program header. This is called for each entry in a PHDRS
		7233	command in a linker script. */
		7234
		7235	void
		7236	lang_new_phdr (const char *name,
		7237	etree_type *type,
		7238	bfd_boolean filehdr,
		7239	bfd_boolean phdrs,
		7240	etree_type *at,
		7241	etree_type *flags)
		7242	{
		7243	struct lang_phdr n, *pp;
		7244	bfd_boolean hdrs;
		7245
		7246	n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
		7247	n->next = NULL;
		7248	n->name = name;
		7249	n->type = exp_get_value_int (type, 0, "program header type");
		7250	n->filehdr = filehdr;
		7251	n->phdrs = phdrs;
		7252	n->at = at;
		7253	n->flags = flags;
		7254
		7255	hdrs = n->type == 1 && (phdrs \|\| filehdr);
		7256
		7257	for (pp = &lang_phdr_list; pp != NULL; pp = &(pp)->next)
		7258	if (hdrs
		7259	&& (*pp)->type == 1
		7260	&& !((pp)->filehdr \|\| (pp)->phdrs))
		7261	{
		7262	einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
		7263	" when prior PT_LOAD headers lack them\n"), NULL);
		7264	hdrs = FALSE;
		7265	}
		7266
		7267	*pp = n;
		7268	}
		7269
		7270	/* Record the program header information in the output BFD. FIXME: We
		7271	should not be calling an ELF specific function here. */
		7272
		7273	static void
		7274	lang_record_phdrs (void)
		7275	{
		7276	unsigned int alc;
		7277	asection **secs;
		7278	lang_output_section_phdr_list *last;
		7279	struct lang_phdr *l;
		7280	lang_output_section_statement_type *os;
		7281
		7282	alc = 10;
		7283	secs = (asection *) xmalloc (alc sizeof (asection *));
		7284	last = NULL;
		7285
		7286	for (l = lang_phdr_list; l != NULL; l = l->next)
		7287	{
		7288	unsigned int c;
		7289	flagword flags;
		7290	bfd_vma at;
		7291
		7292	c = 0;
		7293	for (os = &lang_output_section_statement.head->output_section_statement;
		7294	os != NULL;
		7295	os = os->next)
		7296	{
		7297	lang_output_section_phdr_list *pl;
		7298
		7299	if (os->constraint < 0)
		7300	continue;
		7301
		7302	pl = os->phdrs;
		7303	if (pl != NULL)
		7304	last = pl;
		7305	else
		7306	{
		7307	if (os->sectype == noload_section
		7308	\|\| os->bfd_section == NULL
		7309	\|\| (os->bfd_section->flags & SEC_ALLOC) == 0)
		7310	continue;
		7311
		7312	/* Don't add orphans to PT_INTERP header. */
		7313	if (l->type == 3)
		7314	continue;
		7315
		7316	if (last == NULL)
		7317	{
		7318	lang_output_section_statement_type * tmp_os;
		7319
		7320	/* If we have not run across a section with a program
		7321	header assigned to it yet, then scan forwards to find
		7322	one. This prevents inconsistencies in the linker's
		7323	behaviour when a script has specified just a single
		7324	header and there are sections in that script which are
		7325	not assigned to it, and which occur before the first
		7326	use of that header. See here for more details:
		7327	http://sourceware.org/ml/binutils/2007-02/msg00291.html */
		7328	for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
		7329	if (tmp_os->phdrs)
		7330	{
		7331	last = tmp_os->phdrs;
		7332	break;
		7333	}
		7334	if (last == NULL)
		7335	einfo (_("%F%P: no sections assigned to phdrs\n"));
		7336	}
		7337	pl = last;
		7338	}
		7339
		7340	if (os->bfd_section == NULL)
		7341	continue;
		7342
		7343	for (; pl != NULL; pl = pl->next)
		7344	{
		7345	if (strcmp (pl->name, l->name) == 0)
		7346	{
		7347	if (c >= alc)
		7348	{
		7349	alc *= 2;
		7350	secs = (asection **) xrealloc (secs,
		7351	alc * sizeof (asection *));
		7352	}
		7353	secs[c] = os->bfd_section;
		7354	++c;
		7355	pl->used = TRUE;
		7356	}
		7357	}
		7358	}
		7359
		7360	if (l->flags == NULL)
		7361	flags = 0;
		7362	else
		7363	flags = exp_get_vma (l->flags, 0, "phdr flags");
		7364
		7365	if (l->at == NULL)
		7366	at = 0;
		7367	else
		7368	at = exp_get_vma (l->at, 0, "phdr load address");
		7369
		7370	if (! bfd_record_phdr (link_info.output_bfd, l->type,
		7371	l->flags != NULL, flags, l->at != NULL,
		7372	at, l->filehdr, l->phdrs, c, secs))
		7373	einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
		7374	}
		7375
		7376	free (secs);
		7377
		7378	/* Make sure all the phdr assignments succeeded. */
		7379	for (os = &lang_output_section_statement.head->output_section_statement;
		7380	os != NULL;
		7381	os = os->next)
		7382	{
		7383	lang_output_section_phdr_list *pl;
		7384
		7385	if (os->constraint < 0
		7386	\|\| os->bfd_section == NULL)
		7387	continue;
		7388
		7389	for (pl = os->phdrs;
		7390	pl != NULL;
		7391	pl = pl->next)
		7392	if (! pl->used && strcmp (pl->name, "NONE") != 0)
		7393	einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
		7394	os->name, pl->name);
		7395	}
		7396	}
		7397
		7398	/* Record a list of sections which may not be cross referenced. */
		7399
		7400	void
		7401	lang_add_nocrossref (lang_nocrossref_type *l)
		7402	{
		7403	struct lang_nocrossrefs *n;
		7404
		7405	n = (struct lang_nocrossrefs ) xmalloc (sizeof n);
		7406	n->next = nocrossref_list;
		7407	n->list = l;
		7408	nocrossref_list = n;
		7409
		7410	/* Set notice_all so that we get informed about all symbols. */
		7411	link_info.notice_all = TRUE;
		7412	}
		7413
		7414	/* Overlay handling. We handle overlays with some static variables. */
		7415
		7416	/* The overlay virtual address. */
		7417	static etree_type *overlay_vma;
		7418	/* And subsection alignment. */
		7419	static etree_type *overlay_subalign;
		7420
		7421	/* An expression for the maximum section size seen so far. */
		7422	static etree_type *overlay_max;
		7423
		7424	/* A list of all the sections in this overlay. */
		7425
		7426	struct overlay_list {
		7427	struct overlay_list *next;
		7428	lang_output_section_statement_type *os;
		7429	};
		7430
		7431	static struct overlay_list *overlay_list;
		7432
		7433	/* Start handling an overlay. */
		7434
		7435	void
		7436	lang_enter_overlay (etree_type vma_expr, etree_type subalign)
		7437	{
		7438	/* The grammar should prevent nested overlays from occurring. */
		7439	ASSERT (overlay_vma == NULL
		7440	&& overlay_subalign == NULL
		7441	&& overlay_max == NULL);
		7442
		7443	overlay_vma = vma_expr;
		7444	overlay_subalign = subalign;
		7445	}
		7446
		7447	/* Start a section in an overlay. We handle this by calling
		7448	lang_enter_output_section_statement with the correct VMA.
		7449	lang_leave_overlay sets up the LMA and memory regions. */
		7450
		7451	void
		7452	lang_enter_overlay_section (const char *name)
		7453	{
		7454	struct overlay_list *n;
		7455	etree_type *size;
		7456
		7457	lang_enter_output_section_statement (name, overlay_vma, overlay_section,
		7458	0, overlay_subalign, 0, 0, 0);
		7459
		7460	/* If this is the first section, then base the VMA of future
		7461	sections on this one. This will work correctly even if `.' is
		7462	used in the addresses. */
		7463	if (overlay_list == NULL)
		7464	overlay_vma = exp_nameop (ADDR, name);
		7465
		7466	/* Remember the section. */
		7467	n = (struct overlay_list ) xmalloc (sizeof n);
		7468	n->os = current_section;
		7469	n->next = overlay_list;
		7470	overlay_list = n;
		7471
		7472	size = exp_nameop (SIZEOF, name);
		7473
		7474	/* Arrange to work out the maximum section end address. */
		7475	if (overlay_max == NULL)
		7476	overlay_max = size;
		7477	else
		7478	overlay_max = exp_binop (MAX_K, overlay_max, size);
		7479	}
		7480
		7481	/* Finish a section in an overlay. There isn't any special to do
		7482	here. */
		7483
		7484	void
		7485	lang_leave_overlay_section (fill_type *fill,
		7486	lang_output_section_phdr_list *phdrs)
		7487	{
		7488	const char *name;
		7489	char clean, s2;
		7490	const char *s1;
		7491	char *buf;
		7492
		7493	name = current_section->name;
		7494
		7495	/* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
		7496	region and that no load-time region has been specified. It doesn't
		7497	really matter what we say here, since lang_leave_overlay will
		7498	override it. */
		7499	lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
		7500
		7501	/* Define the magic symbols. */
		7502
		7503	clean = (char *) xmalloc (strlen (name) + 1);
		7504	s2 = clean;
		7505	for (s1 = name; *s1 != '\0'; s1++)
		7506	if (ISALNUM (s1) \|\| s1 == '_')
		7507	s2++ = s1;
		7508	*s2 = '\0';
		7509
		7510	buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_");
		7511	sprintf (buf, "__load_start_%s", clean);
		7512	lang_add_assignment (exp_provide (buf,
		7513	exp_nameop (LOADADDR, name),
		7514	FALSE));
		7515
		7516	buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_");
		7517	sprintf (buf, "__load_stop_%s", clean);
		7518	lang_add_assignment (exp_provide (buf,
		7519	exp_binop ('+',
		7520	exp_nameop (LOADADDR, name),
		7521	exp_nameop (SIZEOF, name)),
		7522	FALSE));
		7523
		7524	free (clean);
		7525	}
		7526
		7527	/* Finish an overlay. If there are any overlay wide settings, this
		7528	looks through all the sections in the overlay and sets them. */
		7529
		7530	void
		7531	lang_leave_overlay (etree_type *lma_expr,
		7532	int nocrossrefs,
		7533	fill_type *fill,
		7534	const char *memspec,
		7535	lang_output_section_phdr_list *phdrs,
		7536	const char *lma_memspec)
		7537	{
		7538	lang_memory_region_type *region;
		7539	lang_memory_region_type *lma_region;
		7540	struct overlay_list *l;
		7541	lang_nocrossref_type *nocrossref;
		7542
		7543	lang_get_regions (®ion, &lma_region,
		7544	memspec, lma_memspec,
		7545	lma_expr != NULL, FALSE);
		7546
		7547	nocrossref = NULL;
		7548
		7549	/* After setting the size of the last section, set '.' to end of the
		7550	overlay region. */
		7551	if (overlay_list != NULL)
		7552	{
		7553	overlay_list->os->update_dot = 1;
		7554	overlay_list->os->update_dot_tree
		7555	= exp_assign (".", exp_binop ('+', overlay_vma, overlay_max), FALSE);
		7556	}
		7557
		7558	l = overlay_list;
		7559	while (l != NULL)
		7560	{
		7561	struct overlay_list *next;
		7562
		7563	if (fill != NULL && l->os->fill == NULL)
		7564	l->os->fill = fill;
		7565
		7566	l->os->region = region;
		7567	l->os->lma_region = lma_region;
		7568
		7569	/* The first section has the load address specified in the
		7570	OVERLAY statement. The rest are worked out from that.
		7571	The base address is not needed (and should be null) if
		7572	an LMA region was specified. */
		7573	if (l->next == 0)
		7574	{
		7575	l->os->load_base = lma_expr;
		7576	l->os->sectype = normal_section;
		7577	}
		7578	if (phdrs != NULL && l->os->phdrs == NULL)
		7579	l->os->phdrs = phdrs;
		7580
		7581	if (nocrossrefs)
		7582	{
		7583	lang_nocrossref_type *nc;
		7584
		7585	nc = (lang_nocrossref_type ) xmalloc (sizeof nc);
		7586	nc->name = l->os->name;
		7587	nc->next = nocrossref;
		7588	nocrossref = nc;
		7589	}
		7590
		7591	next = l->next;
		7592	free (l);
		7593	l = next;
		7594	}
		7595
		7596	if (nocrossref != NULL)
		7597	lang_add_nocrossref (nocrossref);
		7598
		7599	overlay_vma = NULL;
		7600	overlay_list = NULL;
		7601	overlay_max = NULL;
		7602	}
		7603
		7604	/* Version handling. This is only useful for ELF. */
		7605
		7606	/* If PREV is NULL, return first version pattern matching particular symbol.
		7607	If PREV is non-NULL, return first version pattern matching particular
		7608	symbol after PREV (previously returned by lang_vers_match). */
		7609
		7610	static struct bfd_elf_version_expr *
		7611	lang_vers_match (struct bfd_elf_version_expr_head *head,
		7612	struct bfd_elf_version_expr *prev,
		7613	const char *sym)
		7614	{
		7615	const char *c_sym;
		7616	const char *cxx_sym = sym;
		7617	const char *java_sym = sym;
		7618	struct bfd_elf_version_expr *expr = NULL;
		7619	enum demangling_styles curr_style;
		7620
		7621	curr_style = CURRENT_DEMANGLING_STYLE;
		7622	cplus_demangle_set_style (no_demangling);
		7623	c_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_NO_OPTS);
		7624	if (!c_sym)
		7625	c_sym = sym;
		7626	cplus_demangle_set_style (curr_style);
		7627
		7628	if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
		7629	{
		7630	cxx_sym = bfd_demangle (link_info.output_bfd, sym,
		7631	DMGL_PARAMS \| DMGL_ANSI);
		7632	if (!cxx_sym)
		7633	cxx_sym = sym;
		7634	}
		7635	if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
		7636	{
		7637	java_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_JAVA);
		7638	if (!java_sym)
		7639	java_sym = sym;
		7640	}
		7641
		7642	if (head->htab && (prev == NULL \|\| prev->literal))
		7643	{
		7644	struct bfd_elf_version_expr e;
		7645
		7646	switch (prev ? prev->mask : 0)
		7647	{
		7648	case 0:
		7649	if (head->mask & BFD_ELF_VERSION_C_TYPE)
		7650	{
		7651	e.pattern = c_sym;
		7652	expr = (struct bfd_elf_version_expr *)
		7653	htab_find ((htab_t) head->htab, &e);
		7654	while (expr && strcmp (expr->pattern, c_sym) == 0)
		7655	if (expr->mask == BFD_ELF_VERSION_C_TYPE)
		7656	goto out_ret;
		7657	else
		7658	expr = expr->next;
		7659	}
		7660	/* Fallthrough */
		7661	case BFD_ELF_VERSION_C_TYPE:
		7662	if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
		7663	{
		7664	e.pattern = cxx_sym;
		7665	expr = (struct bfd_elf_version_expr *)
		7666	htab_find ((htab_t) head->htab, &e);
		7667	while (expr && strcmp (expr->pattern, cxx_sym) == 0)
		7668	if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
		7669	goto out_ret;
		7670	else
		7671	expr = expr->next;
		7672	}
		7673	/* Fallthrough */
		7674	case BFD_ELF_VERSION_CXX_TYPE:
		7675	if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
		7676	{
		7677	e.pattern = java_sym;
		7678	expr = (struct bfd_elf_version_expr *)
		7679	htab_find ((htab_t) head->htab, &e);
		7680	while (expr && strcmp (expr->pattern, java_sym) == 0)
		7681	if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
		7682	goto out_ret;
		7683	else
		7684	expr = expr->next;
		7685	}
		7686	/* Fallthrough */
		7687	default:
		7688	break;
		7689	}
		7690	}
		7691
		7692	/* Finally, try the wildcards. */
		7693	if (prev == NULL \|\| prev->literal)
		7694	expr = head->remaining;
		7695	else
		7696	expr = prev->next;
		7697	for (; expr; expr = expr->next)
		7698	{
		7699	const char *s;
		7700
		7701	if (!expr->pattern)
		7702	continue;
		7703
		7704	if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
		7705	break;
		7706
		7707	if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
		7708	s = java_sym;
		7709	else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
		7710	s = cxx_sym;
		7711	else
		7712	s = c_sym;
		7713	if (fnmatch (expr->pattern, s, 0) == 0)
		7714	break;
		7715	}
		7716
		7717	out_ret:
		7718	if (c_sym != sym)
		7719	free ((char *) c_sym);
		7720	if (cxx_sym != sym)
		7721	free ((char *) cxx_sym);
		7722	if (java_sym != sym)
		7723	free ((char *) java_sym);
		7724	return expr;
		7725	}
		7726
		7727	/* Return NULL if the PATTERN argument is a glob pattern, otherwise,
		7728	return a pointer to the symbol name with any backslash quotes removed. */
		7729
		7730	static const char *
		7731	realsymbol (const char *pattern)
		7732	{
		7733	const char *p;
		7734	bfd_boolean changed = FALSE, backslash = FALSE;
		7735	char s, symbol = (char *) xmalloc (strlen (pattern) + 1);
		7736
		7737	for (p = pattern, s = symbol; *p != '\0'; ++p)
		7738	{
		7739	/* It is a glob pattern only if there is no preceding
		7740	backslash. */
		7741	if (backslash)
		7742	{
		7743	/* Remove the preceding backslash. */
		7744	(s - 1) = p;
		7745	backslash = FALSE;
		7746	changed = TRUE;
		7747	}
		7748	else
		7749	{
		7750	if (p == '?' \|\| p == '' \|\| p == '[')
		7751	{
		7752	free (symbol);
		7753	return NULL;
		7754	}
		7755
		7756	s++ = p;
		7757	backslash = *p == '\\';
		7758	}
		7759	}
		7760
		7761	if (changed)
		7762	{
		7763	*s = '\0';
		7764	return symbol;
		7765	}
		7766	else
		7767	{
		7768	free (symbol);
		7769	return pattern;
		7770	}
		7771	}
		7772
		7773	/* This is called for each variable name or match expression. NEW_NAME is
		7774	the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
		7775	pattern to be matched against symbol names. */
		7776
		7777	struct bfd_elf_version_expr *
		7778	lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
		7779	const char *new_name,
		7780	const char *lang,
		7781	bfd_boolean literal_p)
		7782	{
		7783	struct bfd_elf_version_expr *ret;
		7784
		7785	ret = (struct bfd_elf_version_expr ) xmalloc (sizeof ret);
		7786	ret->next = orig;
		7787	ret->symver = 0;
		7788	ret->script = 0;
		7789	ret->literal = TRUE;
		7790	ret->pattern = literal_p ? new_name : realsymbol (new_name);
		7791	if (ret->pattern == NULL)
		7792	{
		7793	ret->pattern = new_name;
		7794	ret->literal = FALSE;
		7795	}
		7796
		7797	if (lang == NULL \|\| strcasecmp (lang, "C") == 0)
		7798	ret->mask = BFD_ELF_VERSION_C_TYPE;
		7799	else if (strcasecmp (lang, "C++") == 0)
		7800	ret->mask = BFD_ELF_VERSION_CXX_TYPE;
		7801	else if (strcasecmp (lang, "Java") == 0)
		7802	ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
		7803	else
		7804	{
		7805	einfo (_("%X%P: unknown language `%s' in version information\n"),
		7806	lang);
		7807	ret->mask = BFD_ELF_VERSION_C_TYPE;
		7808	}
		7809
		7810	return ldemul_new_vers_pattern (ret);
		7811	}
		7812
		7813	/* This is called for each set of variable names and match
		7814	expressions. */
		7815
		7816	struct bfd_elf_version_tree *
		7817	lang_new_vers_node (struct bfd_elf_version_expr *globals,
		7818	struct bfd_elf_version_expr *locals)
		7819	{
		7820	struct bfd_elf_version_tree *ret;
		7821
		7822	ret = (struct bfd_elf_version_tree ) xcalloc (1, sizeof ret);
		7823	ret->globals.list = globals;
		7824	ret->locals.list = locals;
		7825	ret->match = lang_vers_match;
		7826	ret->name_indx = (unsigned int) -1;
		7827	return ret;
		7828	}
		7829
		7830	/* This static variable keeps track of version indices. */
		7831
		7832	static int version_index;
		7833
		7834	static hashval_t
		7835	version_expr_head_hash (const void *p)
		7836	{
		7837	const struct bfd_elf_version_expr *e =
		7838	(const struct bfd_elf_version_expr *) p;
		7839
		7840	return htab_hash_string (e->pattern);
		7841	}
		7842
		7843	static int
		7844	version_expr_head_eq (const void p1, const void p2)
		7845	{
		7846	const struct bfd_elf_version_expr *e1 =
		7847	(const struct bfd_elf_version_expr *) p1;
		7848	const struct bfd_elf_version_expr *e2 =
		7849	(const struct bfd_elf_version_expr *) p2;
		7850
		7851	return strcmp (e1->pattern, e2->pattern) == 0;
		7852	}
		7853
		7854	static void
		7855	lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
		7856	{
		7857	size_t count = 0;
		7858	struct bfd_elf_version_expr e, next;
		7859	struct bfd_elf_version_expr list_loc, remaining_loc;
		7860
		7861	for (e = head->list; e; e = e->next)
		7862	{
		7863	if (e->literal)
		7864	count++;
		7865	head->mask \|= e->mask;
		7866	}
		7867
		7868	if (count)
		7869	{
		7870	head->htab = htab_create (count * 2, version_expr_head_hash,
		7871	version_expr_head_eq, NULL);
		7872	list_loc = &head->list;
		7873	remaining_loc = &head->remaining;
		7874	for (e = head->list; e; e = next)
		7875	{
		7876	next = e->next;
		7877	if (!e->literal)
		7878	{
		7879	*remaining_loc = e;
		7880	remaining_loc = &e->next;
		7881	}
		7882	else
		7883	{
		7884	void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT);
		7885
		7886	if (*loc)
		7887	{
		7888	struct bfd_elf_version_expr e1, last;
		7889
		7890	e1 = (struct bfd_elf_version_expr ) loc;
		7891	last = NULL;
		7892	do
		7893	{
		7894	if (e1->mask == e->mask)
		7895	{
		7896	last = NULL;
		7897	break;
		7898	}
		7899	last = e1;
		7900	e1 = e1->next;
		7901	}
		7902	while (e1 && strcmp (e1->pattern, e->pattern) == 0);
		7903
		7904	if (last == NULL)
		7905	{
		7906	/* This is a duplicate. */
		7907	/* FIXME: Memory leak. Sometimes pattern is not
		7908	xmalloced alone, but in larger chunk of memory. */
		7909	/* free (e->pattern); */
		7910	free (e);
		7911	}
		7912	else
		7913	{
		7914	e->next = last->next;
		7915	last->next = e;
		7916	}
		7917	}
		7918	else
		7919	{
		7920	*loc = e;
		7921	*list_loc = e;
		7922	list_loc = &e->next;
		7923	}
		7924	}
		7925	}
		7926	*remaining_loc = NULL;
		7927	*list_loc = head->remaining;
		7928	}
		7929	else
		7930	head->remaining = head->list;
		7931	}
		7932
		7933	/* This is called when we know the name and dependencies of the
		7934	version. */
		7935
		7936	void
		7937	lang_register_vers_node (const char *name,
		7938	struct bfd_elf_version_tree *version,
		7939	struct bfd_elf_version_deps *deps)
		7940	{
		7941	struct bfd_elf_version_tree t, *pp;
		7942	struct bfd_elf_version_expr *e1;
		7943
		7944	if (name == NULL)
		7945	name = "";
		7946
		7947	if (link_info.version_info != NULL
		7948	&& (name[0] == '\0' \|\| link_info.version_info->name[0] == '\0'))
		7949	{
		7950	einfo (_("%X%P: anonymous version tag cannot be combined"
		7951	" with other version tags\n"));
		7952	free (version);
		7953	return;
		7954	}
		7955
		7956	/* Make sure this node has a unique name. */
		7957	for (t = link_info.version_info; t != NULL; t = t->next)
		7958	if (strcmp (t->name, name) == 0)
		7959	einfo (_("%X%P: duplicate version tag `%s'\n"), name);
		7960
		7961	lang_finalize_version_expr_head (&version->globals);
		7962	lang_finalize_version_expr_head (&version->locals);
		7963
		7964	/* Check the global and local match names, and make sure there
		7965	aren't any duplicates. */
		7966
		7967	for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
		7968	{
		7969	for (t = link_info.version_info; t != NULL; t = t->next)
		7970	{
		7971	struct bfd_elf_version_expr *e2;
		7972
		7973	if (t->locals.htab && e1->literal)
		7974	{
		7975	e2 = (struct bfd_elf_version_expr *)
		7976	htab_find ((htab_t) t->locals.htab, e1);
		7977	while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
		7978	{
		7979	if (e1->mask == e2->mask)
		7980	einfo (_("%X%P: duplicate expression `%s'"
		7981	" in version information\n"), e1->pattern);
		7982	e2 = e2->next;
		7983	}
		7984	}
		7985	else if (!e1->literal)
		7986	for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
		7987	if (strcmp (e1->pattern, e2->pattern) == 0
		7988	&& e1->mask == e2->mask)
		7989	einfo (_("%X%P: duplicate expression `%s'"
		7990	" in version information\n"), e1->pattern);
		7991	}
		7992	}
		7993
		7994	for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
		7995	{
		7996	for (t = link_info.version_info; t != NULL; t = t->next)
		7997	{
		7998	struct bfd_elf_version_expr *e2;
		7999
		8000	if (t->globals.htab && e1->literal)
		8001	{
		8002	e2 = (struct bfd_elf_version_expr *)
		8003	htab_find ((htab_t) t->globals.htab, e1);
		8004	while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
		8005	{
		8006	if (e1->mask == e2->mask)
		8007	einfo (_("%X%P: duplicate expression `%s'"
		8008	" in version information\n"),
		8009	e1->pattern);
		8010	e2 = e2->next;
		8011	}
		8012	}
		8013	else if (!e1->literal)
		8014	for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
		8015	if (strcmp (e1->pattern, e2->pattern) == 0
		8016	&& e1->mask == e2->mask)
		8017	einfo (_("%X%P: duplicate expression `%s'"
		8018	" in version information\n"), e1->pattern);
		8019	}
		8020	}
		8021
		8022	version->deps = deps;
		8023	version->name = name;
		8024	if (name[0] != '\0')
		8025	{
		8026	++version_index;
		8027	version->vernum = version_index;
		8028	}
		8029	else
		8030	version->vernum = 0;
		8031
		8032	for (pp = &link_info.version_info; pp != NULL; pp = &(pp)->next)
		8033	;
		8034	*pp = version;
		8035	}
		8036
		8037	/* This is called when we see a version dependency. */
		8038
		8039	struct bfd_elf_version_deps *
		8040	lang_add_vers_depend (struct bfd_elf_version_deps list, const char name)
		8041	{
		8042	struct bfd_elf_version_deps *ret;
		8043	struct bfd_elf_version_tree *t;
		8044
		8045	ret = (struct bfd_elf_version_deps ) xmalloc (sizeof ret);
		8046	ret->next = list;
		8047
		8048	for (t = link_info.version_info; t != NULL; t = t->next)
		8049	{
		8050	if (strcmp (t->name, name) == 0)
		8051	{
		8052	ret->version_needed = t;
		8053	return ret;
		8054	}
		8055	}
		8056
		8057	einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
		8058
		8059	ret->version_needed = NULL;
		8060	return ret;
		8061	}
		8062
		8063	static void
		8064	lang_do_version_exports_section (void)
		8065	{
		8066	struct bfd_elf_version_expr greg = NULL, lreg;
		8067
		8068	LANG_FOR_EACH_INPUT_STATEMENT (is)
		8069	{
		8070	asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
		8071	char contents, p;
		8072	bfd_size_type len;
		8073
		8074	if (sec == NULL)
		8075	continue;
		8076
		8077	len = sec->size;
		8078	contents = (char *) xmalloc (len);
		8079	if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
		8080	einfo (_("%X%P: unable to read .exports section contents\n"), sec);
		8081
		8082	p = contents;
		8083	while (p < contents + len)
		8084	{
		8085	greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
		8086	p = strchr (p, '\0') + 1;
		8087	}
		8088
		8089	/* Do not free the contents, as we used them creating the regex. */
		8090
		8091	/* Do not include this section in the link. */
		8092	sec->flags \|= SEC_EXCLUDE \| SEC_KEEP;
		8093	}
		8094
		8095	lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
		8096	lang_register_vers_node (command_line.version_exports_section,
		8097	lang_new_vers_node (greg, lreg), NULL);
		8098	}
		8099
6324	serge	8100	/* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
		8101
		8102	static void
		8103	lang_do_memory_regions (void)
		8104	{
		8105	lang_memory_region_type *r = lang_memory_region_list;
		8106
		8107	for (; r != NULL; r = r->next)
		8108	{
		8109	if (r->origin_exp)
		8110	{
		8111	exp_fold_tree_no_dot (r->origin_exp);
		8112	if (expld.result.valid_p)
		8113	{
		8114	r->origin = expld.result.value;
		8115	r->current = r->origin;
		8116	}
		8117	else
		8118	einfo (_("%F%P: invalid origin for memory region %s\n"), r->name_list.name);
		8119	}
		8120	if (r->length_exp)
		8121	{
		8122	exp_fold_tree_no_dot (r->length_exp);
		8123	if (expld.result.valid_p)
		8124	r->length = expld.result.value;
		8125	else
		8126	einfo (_("%F%P: invalid length for memory region %s\n"), r->name_list.name);
		8127	}
		8128	}
		8129	}
		8130
5199	serge	8131	void
		8132	lang_add_unique (const char *name)
		8133	{
		8134	struct unique_sections *ent;
		8135
		8136	for (ent = unique_section_list; ent; ent = ent->next)
		8137	if (strcmp (ent->name, name) == 0)
		8138	return;
		8139
		8140	ent = (struct unique_sections ) xmalloc (sizeof ent);
		8141	ent->name = xstrdup (name);
		8142	ent->next = unique_section_list;
		8143	unique_section_list = ent;
		8144	}
		8145
		8146	/* Append the list of dynamic symbols to the existing one. */
		8147
		8148	void
		8149	lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
		8150	{
		8151	if (link_info.dynamic_list)
		8152	{
		8153	struct bfd_elf_version_expr *tail;
		8154	for (tail = dynamic; tail->next != NULL; tail = tail->next)
		8155	;
		8156	tail->next = link_info.dynamic_list->head.list;
		8157	link_info.dynamic_list->head.list = dynamic;
		8158	}
		8159	else
		8160	{
		8161	struct bfd_elf_dynamic_list *d;
		8162
		8163	d = (struct bfd_elf_dynamic_list ) xcalloc (1, sizeof d);
		8164	d->head.list = dynamic;
		8165	d->match = lang_vers_match;
		8166	link_info.dynamic_list = d;
		8167	}
		8168	}
		8169
		8170	/* Append the list of C++ typeinfo dynamic symbols to the existing
		8171	one. */
		8172
		8173	void
		8174	lang_append_dynamic_list_cpp_typeinfo (void)
		8175	{
		8176	const char * symbols [] =
		8177	{
		8178	"typeinfo name for*",
		8179	"typeinfo for*"
		8180	};
		8181	struct bfd_elf_version_expr *dynamic = NULL;
		8182	unsigned int i;
		8183
		8184	for (i = 0; i < ARRAY_SIZE (symbols); i++)
		8185	dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
		8186	FALSE);
		8187
		8188	lang_append_dynamic_list (dynamic);
		8189	}
		8190
		8191	/* Append the list of C++ operator new and delete dynamic symbols to the
		8192	existing one. */
		8193
		8194	void
		8195	lang_append_dynamic_list_cpp_new (void)
		8196	{
		8197	const char * symbols [] =
		8198	{
		8199	"operator new*",
		8200	"operator delete*"
		8201	};
		8202	struct bfd_elf_version_expr *dynamic = NULL;
		8203	unsigned int i;
		8204
		8205	for (i = 0; i < ARRAY_SIZE (symbols); i++)
		8206	dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
		8207	FALSE);
		8208
		8209	lang_append_dynamic_list (dynamic);
		8210	}
		8211
		8212	/* Scan a space and/or comma separated string of features. */
		8213
		8214	void
		8215	lang_ld_feature (char *str)
		8216	{
		8217	char p, q;
		8218
		8219	p = str;
		8220	while (*p)
		8221	{
		8222	char sep;
		8223	while (p == ',' \|\| ISSPACE (p))
		8224	++p;
		8225	if (!*p)
		8226	break;
		8227	q = p + 1;
		8228	while (q && q != ',' && !ISSPACE (*q))
		8229	++q;
		8230	sep = *q;
		8231	*q = 0;
		8232	if (strcasecmp (p, "SANE_EXPR") == 0)
		8233	config.sane_expr = TRUE;
		8234	else
		8235	einfo (_("%X%P: unknown feature `%s'\n"), p);
		8236	*q = sep;
		8237	p = q;
		8238	}
		8239	}
6324	serge	8240
		8241	/* Pretty print memory amount. */
		8242
		8243	static void
		8244	lang_print_memory_size (bfd_vma sz)
		8245	{
		8246	if ((sz & 0x3fffffff) == 0)
		8247	printf ("%10" BFD_VMA_FMT "u GB", sz >> 30);
		8248	else if ((sz & 0xfffff) == 0)
		8249	printf ("%10" BFD_VMA_FMT "u MB", sz >> 20);
		8250	else if ((sz & 0x3ff) == 0)
		8251	printf ("%10" BFD_VMA_FMT "u KB", sz >> 10);
		8252	else
		8253	printf (" %10" BFD_VMA_FMT "u B", sz);
		8254	}
		8255
		8256	/* Implement --print-memory-usage: disply per region memory usage. */
		8257
		8258	void
		8259	lang_print_memory_usage (void)
		8260	{
		8261	lang_memory_region_type *r;
		8262
		8263	printf ("Memory region Used Size Region Size %%age Used\n");
		8264	for (r = lang_memory_region_list; r->next != NULL; r = r->next)
		8265	{
		8266	bfd_vma used_length = r->current - r->origin;
		8267	double percent;
		8268
		8269	printf ("%16s: ",r->name_list.name);
		8270	lang_print_memory_size (used_length);
		8271	lang_print_memory_size ((bfd_vma) r->length);
		8272
		8273	percent = used_length * 100.0 / r->length;
		8274
		8275	printf (" %6.2f%%\n", percent);
		8276	}
		8277	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/ld/ldlang.c @ 8031 – Rev 6324