WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/bfd/elf-eh-frame.c

Rev	Author	Line No.	Line
5197	serge	1	/* .eh_frame section optimization.
6324	serge	2	Copyright (C) 2001-2015 Free Software Foundation, Inc.
5197	serge	3	Written by Jakub Jelinek .
		4
		5	This file is part of BFD, the Binary File Descriptor library.
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 3 of the License, or
		10	(at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
		20	MA 02110-1301, USA. */
		21
		22	#include "sysdep.h"
		23	#include "bfd.h"
		24	#include "libbfd.h"
		25	#include "elf-bfd.h"
		26	#include "dwarf2.h"
		27
		28	#define EH_FRAME_HDR_SIZE 8
		29
		30	struct cie
		31	{
		32	unsigned int length;
		33	unsigned int hash;
		34	unsigned char version;
		35	unsigned char local_personality;
		36	char augmentation[20];
		37	bfd_vma code_align;
		38	bfd_signed_vma data_align;
		39	bfd_vma ra_column;
		40	bfd_vma augmentation_size;
		41	union {
		42	struct elf_link_hash_entry *h;
6324	serge	43	struct {
		44	unsigned int bfd_id;
		45	unsigned int index;
		46	} sym;
5197	serge	47	unsigned int reloc_index;
		48	} personality;
		49	struct eh_cie_fde *cie_inf;
		50	unsigned char per_encoding;
		51	unsigned char lsda_encoding;
		52	unsigned char fde_encoding;
		53	unsigned char initial_insn_length;
		54	unsigned char can_make_lsda_relative;
		55	unsigned char initial_instructions[50];
		56	};
		57
		58
		59
		60	/* If ITER hasn't reached END yet, read the next byte into RESULT and
		61	move onto the next byte. Return true on success. */
		62
		63	static inline bfd_boolean
		64	read_byte (bfd_byte *iter, bfd_byte end, unsigned char *result)
		65	{
		66	if (*iter >= end)
		67	return FALSE;
		68	result = ((*iter)++);
		69	return TRUE;
		70	}
		71
		72	/* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
		73	Return true it was possible to move LENGTH bytes. */
		74
		75	static inline bfd_boolean
		76	skip_bytes (bfd_byte *iter, bfd_byte end, bfd_size_type length)
		77	{
		78	if ((bfd_size_type) (end - *iter) < length)
		79	{
		80	*iter = end;
		81	return FALSE;
		82	}
		83	*iter += length;
		84	return TRUE;
		85	}
		86
		87	/* Move *ITER over an leb128, stopping at END. Return true if the end
		88	of the leb128 was found. */
		89
		90	static bfd_boolean
		91	skip_leb128 (bfd_byte *iter, bfd_byte end)
		92	{
		93	unsigned char byte;
		94	do
		95	if (!read_byte (iter, end, &byte))
		96	return FALSE;
		97	while (byte & 0x80);
		98	return TRUE;
		99	}
		100
		101	/* Like skip_leb128, but treat the leb128 as an unsigned value and
		102	store it in VALUE. /
		103
		104	static bfd_boolean
		105	read_uleb128 (bfd_byte *iter, bfd_byte end, bfd_vma *value)
		106	{
		107	bfd_byte start, p;
		108
		109	start = *iter;
		110	if (!skip_leb128 (iter, end))
		111	return FALSE;
		112
		113	p = *iter;
		114	value = --p;
		115	while (p > start)
		116	value = (value << 7) \| (*--p & 0x7f);
		117
		118	return TRUE;
		119	}
		120
		121	/* Like read_uleb128, but for signed values. */
		122
		123	static bfd_boolean
		124	read_sleb128 (bfd_byte *iter, bfd_byte end, bfd_signed_vma *value)
		125	{
		126	bfd_byte start, p;
		127
		128	start = *iter;
		129	if (!skip_leb128 (iter, end))
		130	return FALSE;
		131
		132	p = *iter;
		133	value = ((--p & 0x7f) ^ 0x40) - 0x40;
		134	while (p > start)
		135	value = (value << 7) \| (*--p & 0x7f);
		136
		137	return TRUE;
		138	}
		139
		140	/* Return 0 if either encoding is variable width, or not yet known to bfd. */
		141
		142	static
		143	int get_DW_EH_PE_width (int encoding, int ptr_size)
		144	{
		145	/* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
		146	was added to bfd. */
		147	if ((encoding & 0x60) == 0x60)
		148	return 0;
		149
		150	switch (encoding & 7)
		151	{
		152	case DW_EH_PE_udata2: return 2;
		153	case DW_EH_PE_udata4: return 4;
		154	case DW_EH_PE_udata8: return 8;
		155	case DW_EH_PE_absptr: return ptr_size;
		156	default:
		157	break;
		158	}
		159
		160	return 0;
		161	}
		162
		163	#define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
		164
		165	/* Read a width sized value from memory. */
		166
		167	static bfd_vma
		168	read_value (bfd abfd, bfd_byte buf, int width, int is_signed)
		169	{
		170	bfd_vma value;
		171
		172	switch (width)
		173	{
		174	case 2:
		175	if (is_signed)
		176	value = bfd_get_signed_16 (abfd, buf);
		177	else
		178	value = bfd_get_16 (abfd, buf);
		179	break;
		180	case 4:
		181	if (is_signed)
		182	value = bfd_get_signed_32 (abfd, buf);
		183	else
		184	value = bfd_get_32 (abfd, buf);
		185	break;
		186	case 8:
		187	if (is_signed)
		188	value = bfd_get_signed_64 (abfd, buf);
		189	else
		190	value = bfd_get_64 (abfd, buf);
		191	break;
		192	default:
		193	BFD_FAIL ();
		194	return 0;
		195	}
		196
		197	return value;
		198	}
		199
		200	/* Store a width sized value to memory. */
		201
		202	static void
		203	write_value (bfd abfd, bfd_byte buf, bfd_vma value, int width)
		204	{
		205	switch (width)
		206	{
		207	case 2: bfd_put_16 (abfd, value, buf); break;
		208	case 4: bfd_put_32 (abfd, value, buf); break;
		209	case 8: bfd_put_64 (abfd, value, buf); break;
		210	default: BFD_FAIL ();
		211	}
		212	}
		213
		214	/* Return one if C1 and C2 CIEs can be merged. */
		215
		216	static int
		217	cie_eq (const void e1, const void e2)
		218	{
		219	const struct cie c1 = (const struct cie ) e1;
		220	const struct cie c2 = (const struct cie ) e2;
		221
		222	if (c1->hash == c2->hash
		223	&& c1->length == c2->length
		224	&& c1->version == c2->version
		225	&& c1->local_personality == c2->local_personality
		226	&& strcmp (c1->augmentation, c2->augmentation) == 0
		227	&& strcmp (c1->augmentation, "eh") != 0
		228	&& c1->code_align == c2->code_align
		229	&& c1->data_align == c2->data_align
		230	&& c1->ra_column == c2->ra_column
		231	&& c1->augmentation_size == c2->augmentation_size
		232	&& memcmp (&c1->personality, &c2->personality,
		233	sizeof (c1->personality)) == 0
6324	serge	234	&& (c1->cie_inf->u.cie.u.sec->output_section
		235	== c2->cie_inf->u.cie.u.sec->output_section)
5197	serge	236	&& c1->per_encoding == c2->per_encoding
		237	&& c1->lsda_encoding == c2->lsda_encoding
		238	&& c1->fde_encoding == c2->fde_encoding
		239	&& c1->initial_insn_length == c2->initial_insn_length
6324	serge	240	&& c1->initial_insn_length <= sizeof (c1->initial_instructions)
5197	serge	241	&& memcmp (c1->initial_instructions,
		242	c2->initial_instructions,
		243	c1->initial_insn_length) == 0)
		244	return 1;
		245
		246	return 0;
		247	}
		248
		249	static hashval_t
		250	cie_hash (const void *e)
		251	{
		252	const struct cie c = (const struct cie ) e;
		253	return c->hash;
		254	}
		255
		256	static hashval_t
		257	cie_compute_hash (struct cie *c)
		258	{
		259	hashval_t h = 0;
6324	serge	260	size_t len;
5197	serge	261	h = iterative_hash_object (c->length, h);
		262	h = iterative_hash_object (c->version, h);
		263	h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
		264	h = iterative_hash_object (c->code_align, h);
		265	h = iterative_hash_object (c->data_align, h);
		266	h = iterative_hash_object (c->ra_column, h);
		267	h = iterative_hash_object (c->augmentation_size, h);
		268	h = iterative_hash_object (c->personality, h);
6324	serge	269	h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h);
5197	serge	270	h = iterative_hash_object (c->per_encoding, h);
		271	h = iterative_hash_object (c->lsda_encoding, h);
		272	h = iterative_hash_object (c->fde_encoding, h);
		273	h = iterative_hash_object (c->initial_insn_length, h);
6324	serge	274	len = c->initial_insn_length;
		275	if (len > sizeof (c->initial_instructions))
		276	len = sizeof (c->initial_instructions);
		277	h = iterative_hash (c->initial_instructions, len, h);
5197	serge	278	c->hash = h;
		279	return h;
		280	}
		281
		282	/* Return the number of extra bytes that we'll be inserting into
		283	ENTRY's augmentation string. */
		284
		285	static INLINE unsigned int
		286	extra_augmentation_string_bytes (struct eh_cie_fde *entry)
		287	{
		288	unsigned int size = 0;
		289	if (entry->cie)
		290	{
		291	if (entry->add_augmentation_size)
		292	size++;
		293	if (entry->u.cie.add_fde_encoding)
		294	size++;
		295	}
		296	return size;
		297	}
		298
		299	/* Likewise ENTRY's augmentation data. */
		300
		301	static INLINE unsigned int
		302	extra_augmentation_data_bytes (struct eh_cie_fde *entry)
		303	{
		304	unsigned int size = 0;
		305	if (entry->add_augmentation_size)
		306	size++;
		307	if (entry->cie && entry->u.cie.add_fde_encoding)
		308	size++;
		309	return size;
		310	}
		311
		312	/* Return the size that ENTRY will have in the output. ALIGNMENT is the
		313	required alignment of ENTRY in bytes. */
		314
		315	static unsigned int
		316	size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
		317	{
		318	if (entry->removed)
		319	return 0;
		320	if (entry->size == 4)
		321	return 4;
		322	return (entry->size
		323	+ extra_augmentation_string_bytes (entry)
		324	+ extra_augmentation_data_bytes (entry)
		325	+ alignment - 1) & -alignment;
		326	}
		327
		328	/* Assume that the bytes between *ITER and END are CFA instructions.
		329	Try to move *ITER past the first instruction and return true on
		330	success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
		331
		332	static bfd_boolean
		333	skip_cfa_op (bfd_byte *iter, bfd_byte end, unsigned int encoded_ptr_width)
		334	{
		335	bfd_byte op;
		336	bfd_vma length;
		337
		338	if (!read_byte (iter, end, &op))
		339	return FALSE;
		340
		341	switch (op & 0xc0 ? op & 0xc0 : op)
		342	{
		343	case DW_CFA_nop:
		344	case DW_CFA_advance_loc:
		345	case DW_CFA_restore:
		346	case DW_CFA_remember_state:
		347	case DW_CFA_restore_state:
		348	case DW_CFA_GNU_window_save:
		349	/* No arguments. */
		350	return TRUE;
		351
		352	case DW_CFA_offset:
		353	case DW_CFA_restore_extended:
		354	case DW_CFA_undefined:
		355	case DW_CFA_same_value:
		356	case DW_CFA_def_cfa_register:
		357	case DW_CFA_def_cfa_offset:
		358	case DW_CFA_def_cfa_offset_sf:
		359	case DW_CFA_GNU_args_size:
		360	/* One leb128 argument. */
		361	return skip_leb128 (iter, end);
		362
		363	case DW_CFA_val_offset:
		364	case DW_CFA_val_offset_sf:
		365	case DW_CFA_offset_extended:
		366	case DW_CFA_register:
		367	case DW_CFA_def_cfa:
		368	case DW_CFA_offset_extended_sf:
		369	case DW_CFA_GNU_negative_offset_extended:
		370	case DW_CFA_def_cfa_sf:
		371	/* Two leb128 arguments. */
		372	return (skip_leb128 (iter, end)
		373	&& skip_leb128 (iter, end));
		374
		375	case DW_CFA_def_cfa_expression:
		376	/* A variable-length argument. */
		377	return (read_uleb128 (iter, end, &length)
		378	&& skip_bytes (iter, end, length));
		379
		380	case DW_CFA_expression:
		381	case DW_CFA_val_expression:
		382	/* A leb128 followed by a variable-length argument. */
		383	return (skip_leb128 (iter, end)
		384	&& read_uleb128 (iter, end, &length)
		385	&& skip_bytes (iter, end, length));
		386
		387	case DW_CFA_set_loc:
		388	return skip_bytes (iter, end, encoded_ptr_width);
		389
		390	case DW_CFA_advance_loc1:
		391	return skip_bytes (iter, end, 1);
		392
		393	case DW_CFA_advance_loc2:
		394	return skip_bytes (iter, end, 2);
		395
		396	case DW_CFA_advance_loc4:
		397	return skip_bytes (iter, end, 4);
		398
		399	case DW_CFA_MIPS_advance_loc8:
		400	return skip_bytes (iter, end, 8);
		401
		402	default:
		403	return FALSE;
		404	}
		405	}
		406
		407	/* Try to interpret the bytes between BUF and END as CFA instructions.
		408	If every byte makes sense, return a pointer to the first DW_CFA_nop
		409	padding byte, or END if there is no padding. Return null otherwise.
		410	ENCODED_PTR_WIDTH is as for skip_cfa_op. */
		411
		412	static bfd_byte *
		413	skip_non_nops (bfd_byte buf, bfd_byte end, unsigned int encoded_ptr_width,
		414	unsigned int *set_loc_count)
		415	{
		416	bfd_byte *last;
		417
		418	last = buf;
		419	while (buf < end)
		420	if (*buf == DW_CFA_nop)
		421	buf++;
		422	else
		423	{
		424	if (*buf == DW_CFA_set_loc)
		425	++*set_loc_count;
		426	if (!skip_cfa_op (&buf, end, encoded_ptr_width))
		427	return 0;
		428	last = buf;
		429	}
		430	return last;
		431	}
		432
		433	/* Convert absolute encoding ENCODING into PC-relative form.
		434	SIZE is the size of a pointer. */
		435
		436	static unsigned char
		437	make_pc_relative (unsigned char encoding, unsigned int ptr_size)
		438	{
		439	if ((encoding & 0x7f) == DW_EH_PE_absptr)
		440	switch (ptr_size)
		441	{
		442	case 2:
		443	encoding \|= DW_EH_PE_sdata2;
		444	break;
		445	case 4:
		446	encoding \|= DW_EH_PE_sdata4;
		447	break;
		448	case 8:
		449	encoding \|= DW_EH_PE_sdata8;
		450	break;
		451	}
		452	return encoding \| DW_EH_PE_pcrel;
		453	}
		454
6324	serge	455	/* Examine each .eh_frame_entry section and discard those
		456	those that are marked SEC_EXCLUDE. */
5197	serge	457
6324	serge	458	static void
		459	bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info)
5197	serge	460	{
6324	serge	461	unsigned int i;
		462	for (i = 0; i < hdr_info->array_count; i++)
		463	{
		464	if (hdr_info->u.compact.entries[i]->flags & SEC_EXCLUDE)
		465	{
		466	unsigned int j;
		467	for (j = i + 1; j < hdr_info->array_count; j++)
		468	hdr_info->u.compact.entries[j-1] = hdr_info->u.compact.entries[j];
		469
		470	hdr_info->array_count--;
		471	hdr_info->u.compact.entries[hdr_info->array_count] = NULL;
		472	i--;
		473	}
		474	}
		475	}
		476
		477	/* Add a .eh_frame_entry section. */
		478
		479	static void
		480	bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info *hdr_info,
		481	asection *sec)
		482	{
		483	if (hdr_info->array_count == hdr_info->u.compact.allocated_entries)
		484	{
		485	if (hdr_info->u.compact.allocated_entries == 0)
		486	{
		487	hdr_info->frame_hdr_is_compact = TRUE;
		488	hdr_info->u.compact.allocated_entries = 2;
		489	hdr_info->u.compact.entries =
		490	bfd_malloc (hdr_info->u.compact.allocated_entries
		491	* sizeof (hdr_info->u.compact.entries[0]));
		492	}
		493	else
		494	{
		495	hdr_info->u.compact.allocated_entries *= 2;
		496	hdr_info->u.compact.entries =
		497	bfd_realloc (hdr_info->u.compact.entries,
		498	hdr_info->u.compact.allocated_entries
		499	* sizeof (hdr_info->u.compact.entries[0]));
		500	}
		501
		502	BFD_ASSERT (hdr_info->u.compact.entries);
		503	}
		504
		505	hdr_info->u.compact.entries[hdr_info->array_count++] = sec;
		506	}
		507
		508	/* Parse a .eh_frame_entry section. Figure out which text section it
		509	references. */
		510
		511	bfd_boolean
		512	_bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info,
		513	asection sec, struct elf_reloc_cookie cookie)
		514	{
		515	struct elf_link_hash_table *htab;
5197	serge	516	struct eh_frame_hdr_info *hdr_info;
6324	serge	517	unsigned long r_symndx;
		518	asection *text_sec;
5197	serge	519
6324	serge	520	htab = elf_hash_table (info);
		521	hdr_info = &htab->eh_info;
		522
		523	if (sec->size == 0
		524	\|\| sec->sec_info_type != SEC_INFO_TYPE_NONE)
		525	{
		526	return TRUE;
		527	}
		528
		529	if (sec->output_section && bfd_is_abs_section (sec->output_section))
		530	{
		531	/* At least one of the sections is being discarded from the
		532	link, so we should just ignore them. */
		533	return TRUE;
		534	}
		535
		536	if (cookie->rel == cookie->relend)
		537	return FALSE;
		538
		539	/* The first relocation is the function start. */
		540	r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
		541	if (r_symndx == STN_UNDEF)
		542	return FALSE;
		543
		544	text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, FALSE);
		545
		546	if (text_sec == NULL)
		547	return FALSE;
		548
		549	elf_section_eh_frame_entry (text_sec) = sec;
		550	if (text_sec->output_section
		551	&& bfd_is_abs_section (text_sec->output_section))
		552	sec->flags \|= SEC_EXCLUDE;
		553
		554	sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY;
		555	elf_section_data (sec)->sec_info = text_sec;
		556	bfd_elf_record_eh_frame_entry (hdr_info, sec);
		557	return TRUE;
5197	serge	558	}
		559
		560	/* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
		561	information in the section's sec_info field on success. COOKIE
		562	describes the relocations in SEC. */
		563
		564	void
		565	_bfd_elf_parse_eh_frame (bfd abfd, struct bfd_link_info info,
		566	asection sec, struct elf_reloc_cookie cookie)
		567	{
		568	#define REQUIRE(COND) \
		569	do \
		570	if (!(COND)) \
		571	goto free_no_table; \
		572	while (0)
		573
		574	bfd_byte ehbuf = NULL, buf, *end;
		575	bfd_byte *last_fde;
		576	struct eh_cie_fde *this_inf;
		577	unsigned int hdr_length, hdr_id;
		578	unsigned int cie_count;
		579	struct cie cie, local_cies = NULL;
		580	struct elf_link_hash_table *htab;
		581	struct eh_frame_hdr_info *hdr_info;
		582	struct eh_frame_sec_info *sec_info = NULL;
		583	unsigned int ptr_size;
		584	unsigned int num_cies;
		585	unsigned int num_entries;
		586	elf_gc_mark_hook_fn gc_mark_hook;
		587
		588	htab = elf_hash_table (info);
		589	hdr_info = &htab->eh_info;
		590
		591	if (sec->size == 0
		592	\|\| sec->sec_info_type != SEC_INFO_TYPE_NONE)
		593	{
		594	/* This file does not contain .eh_frame information. */
		595	return;
		596	}
		597
		598	if (bfd_is_abs_section (sec->output_section))
		599	{
		600	/* At least one of the sections is being discarded from the
		601	link, so we should just ignore them. */
		602	return;
		603	}
		604
		605	/* Read the frame unwind information from abfd. */
		606
		607	REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
		608
		609	if (sec->size >= 4
		610	&& bfd_get_32 (abfd, ehbuf) == 0
		611	&& cookie->rel == cookie->relend)
		612	{
		613	/* Empty .eh_frame section. */
		614	free (ehbuf);
		615	return;
		616	}
		617
		618	/* If .eh_frame section size doesn't fit into int, we cannot handle
		619	it (it would need to use 64-bit .eh_frame format anyway). */
		620	REQUIRE (sec->size == (unsigned int) sec->size);
		621
		622	ptr_size = (get_elf_backend_data (abfd)
		623	->elf_backend_eh_frame_address_size (abfd, sec));
		624	REQUIRE (ptr_size != 0);
		625
		626	/* Go through the section contents and work out how many FDEs and
		627	CIEs there are. */
		628	buf = ehbuf;
		629	end = ehbuf + sec->size;
		630	num_cies = 0;
		631	num_entries = 0;
		632	while (buf != end)
		633	{
		634	num_entries++;
		635
		636	/* Read the length of the entry. */
		637	REQUIRE (skip_bytes (&buf, end, 4));
		638	hdr_length = bfd_get_32 (abfd, buf - 4);
		639
		640	/* 64-bit .eh_frame is not supported. */
		641	REQUIRE (hdr_length != 0xffffffff);
		642	if (hdr_length == 0)
		643	break;
		644
		645	REQUIRE (skip_bytes (&buf, end, 4));
		646	hdr_id = bfd_get_32 (abfd, buf - 4);
		647	if (hdr_id == 0)
		648	num_cies++;
		649
		650	REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
		651	}
		652
		653	sec_info = (struct eh_frame_sec_info *)
		654	bfd_zmalloc (sizeof (struct eh_frame_sec_info)
		655	+ (num_entries - 1) * sizeof (struct eh_cie_fde));
		656	REQUIRE (sec_info);
		657
		658	/* We need to have a "struct cie" for each CIE in this section. */
		659	local_cies = (struct cie ) bfd_zmalloc (num_cies sizeof (*local_cies));
		660	REQUIRE (local_cies);
		661
		662	/* FIXME: octets_per_byte. */
		663	#define ENSURE_NO_RELOCS(buf) \
6324	serge	664	while (cookie->rel < cookie->relend \
5197	serge	665	&& (cookie->rel->r_offset \
6324	serge	666	< (bfd_size_type) ((buf) - ehbuf))) \
		667	{ \
		668	REQUIRE (cookie->rel->r_info == 0); \
		669	cookie->rel++; \
		670	}
5197	serge	671
		672	/* FIXME: octets_per_byte. */
		673	#define SKIP_RELOCS(buf) \
		674	while (cookie->rel < cookie->relend \
		675	&& (cookie->rel->r_offset \
		676	< (bfd_size_type) ((buf) - ehbuf))) \
		677	cookie->rel++
		678
		679	/* FIXME: octets_per_byte. */
		680	#define GET_RELOC(buf) \
		681	((cookie->rel < cookie->relend \
		682	&& (cookie->rel->r_offset \
		683	== (bfd_size_type) ((buf) - ehbuf))) \
		684	? cookie->rel : NULL)
		685
		686	buf = ehbuf;
		687	cie_count = 0;
		688	gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
		689	while ((bfd_size_type) (buf - ehbuf) != sec->size)
		690	{
		691	char *aug;
		692	bfd_byte start, insns, *insns_end;
		693	bfd_size_type length;
		694	unsigned int set_loc_count;
		695
		696	this_inf = sec_info->entry + sec_info->count;
		697	last_fde = buf;
		698
		699	/* Read the length of the entry. */
		700	REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
		701	hdr_length = bfd_get_32 (abfd, buf - 4);
		702
		703	/* The CIE/FDE must be fully contained in this input section. */
		704	REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
		705	end = buf + hdr_length;
		706
		707	this_inf->offset = last_fde - ehbuf;
		708	this_inf->size = 4 + hdr_length;
		709	this_inf->reloc_index = cookie->rel - cookie->rels;
		710
		711	if (hdr_length == 0)
		712	{
		713	/* A zero-length CIE should only be found at the end of
		714	the section. */
		715	REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
		716	ENSURE_NO_RELOCS (buf);
		717	sec_info->count++;
		718	break;
		719	}
		720
		721	REQUIRE (skip_bytes (&buf, end, 4));
		722	hdr_id = bfd_get_32 (abfd, buf - 4);
		723
		724	if (hdr_id == 0)
		725	{
		726	unsigned int initial_insn_length;
		727
		728	/* CIE */
		729	this_inf->cie = 1;
		730
		731	/* Point CIE to one of the section-local cie structures. */
		732	cie = local_cies + cie_count++;
		733
		734	cie->cie_inf = this_inf;
		735	cie->length = hdr_length;
		736	start = buf;
		737	REQUIRE (read_byte (&buf, end, &cie->version));
		738
		739	/* Cannot handle unknown versions. */
		740	REQUIRE (cie->version == 1
		741	\|\| cie->version == 3
		742	\|\| cie->version == 4);
		743	REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
		744
		745	strcpy (cie->augmentation, (char *) buf);
		746	buf = (bfd_byte ) strchr ((char ) buf, '\0') + 1;
		747	ENSURE_NO_RELOCS (buf);
		748	if (buf[0] == 'e' && buf[1] == 'h')
		749	{
		750	/* GCC < 3.0 .eh_frame CIE */
		751	/* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
		752	is private to each CIE, so we don't need it for anything.
		753	Just skip it. */
		754	REQUIRE (skip_bytes (&buf, end, ptr_size));
		755	SKIP_RELOCS (buf);
		756	}
		757	if (cie->version >= 4)
		758	{
		759	REQUIRE (buf + 1 < end);
		760	REQUIRE (buf[0] == ptr_size);
		761	REQUIRE (buf[1] == 0);
		762	buf += 2;
		763	}
		764	REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
		765	REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
		766	if (cie->version == 1)
		767	{
		768	REQUIRE (buf < end);
		769	cie->ra_column = *buf++;
		770	}
		771	else
		772	REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
		773	ENSURE_NO_RELOCS (buf);
		774	cie->lsda_encoding = DW_EH_PE_omit;
		775	cie->fde_encoding = DW_EH_PE_omit;
		776	cie->per_encoding = DW_EH_PE_omit;
		777	aug = cie->augmentation;
		778	if (aug[0] != 'e' \|\| aug[1] != 'h')
		779	{
		780	if (*aug == 'z')
		781	{
		782	aug++;
		783	REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
		784	ENSURE_NO_RELOCS (buf);
		785	}
		786
		787	while (*aug != '\0')
		788	switch (*aug++)
		789	{
		790	case 'L':
		791	REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
		792	ENSURE_NO_RELOCS (buf);
		793	REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
		794	break;
		795	case 'R':
		796	REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
		797	ENSURE_NO_RELOCS (buf);
		798	REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
		799	break;
		800	case 'S':
		801	break;
		802	case 'P':
		803	{
		804	int per_width;
		805
		806	REQUIRE (read_byte (&buf, end, &cie->per_encoding));
		807	per_width = get_DW_EH_PE_width (cie->per_encoding,
		808	ptr_size);
		809	REQUIRE (per_width);
		810	if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
		811	{
		812	length = -(buf - ehbuf) & (per_width - 1);
		813	REQUIRE (skip_bytes (&buf, end, length));
		814	}
		815	this_inf->u.cie.personality_offset = buf - start;
		816	ENSURE_NO_RELOCS (buf);
		817	/* Ensure we have a reloc here. */
		818	REQUIRE (GET_RELOC (buf));
		819	cie->personality.reloc_index
		820	= cookie->rel - cookie->rels;
		821	/* Cope with MIPS-style composite relocations. */
		822	do
		823	cookie->rel++;
		824	while (GET_RELOC (buf) != NULL);
		825	REQUIRE (skip_bytes (&buf, end, per_width));
		826	}
		827	break;
		828	default:
		829	/* Unrecognized augmentation. Better bail out. */
		830	goto free_no_table;
		831	}
		832	}
		833
		834	/* For shared libraries, try to get rid of as many RELATIVE relocs
		835	as possible. */
6324	serge	836	if (bfd_link_pic (info)
5197	serge	837	&& (get_elf_backend_data (abfd)
		838	->elf_backend_can_make_relative_eh_frame
		839	(abfd, info, sec)))
		840	{
		841	if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
		842	this_inf->make_relative = 1;
		843	/* If the CIE doesn't already have an 'R' entry, it's fairly
		844	easy to add one, provided that there's no aligned data
		845	after the augmentation string. */
		846	else if (cie->fde_encoding == DW_EH_PE_omit
		847	&& (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
		848	{
		849	if (*cie->augmentation == 0)
		850	this_inf->add_augmentation_size = 1;
		851	this_inf->u.cie.add_fde_encoding = 1;
		852	this_inf->make_relative = 1;
		853	}
		854
		855	if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
		856	cie->can_make_lsda_relative = 1;
		857	}
		858
		859	/* If FDE encoding was not specified, it defaults to
		860	DW_EH_absptr. */
		861	if (cie->fde_encoding == DW_EH_PE_omit)
		862	cie->fde_encoding = DW_EH_PE_absptr;
		863
		864	initial_insn_length = end - buf;
		865	cie->initial_insn_length = initial_insn_length;
6324	serge	866	memcpy (cie->initial_instructions, buf,
		867	initial_insn_length <= sizeof (cie->initial_instructions)
		868	? initial_insn_length : sizeof (cie->initial_instructions));
5197	serge	869	insns = buf;
		870	buf += initial_insn_length;
		871	ENSURE_NO_RELOCS (buf);
		872
6324	serge	873	if (!bfd_link_relocatable (info))
		874	{
		875	/* Keep info for merging cies. */
5197	serge	876	this_inf->u.cie.u.full_cie = cie;
		877	this_inf->u.cie.per_encoding_relative
		878	= (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
		879	}
6324	serge	880	}
5197	serge	881	else
		882	{
		883	/* Find the corresponding CIE. */
		884	unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
		885	for (cie = local_cies; cie < local_cies + cie_count; cie++)
		886	if (cie_offset == cie->cie_inf->offset)
		887	break;
		888
		889	/* Ensure this FDE references one of the CIEs in this input
		890	section. */
		891	REQUIRE (cie != local_cies + cie_count);
		892	this_inf->u.fde.cie_inf = cie->cie_inf;
		893	this_inf->make_relative = cie->cie_inf->make_relative;
		894	this_inf->add_augmentation_size
		895	= cie->cie_inf->add_augmentation_size;
		896
		897	ENSURE_NO_RELOCS (buf);
		898	if ((sec->flags & SEC_LINKER_CREATED) == 0 \|\| cookie->rels != NULL)
		899	{
		900	asection *rsec;
		901
		902	REQUIRE (GET_RELOC (buf));
		903
		904	/* Chain together the FDEs for each section. */
6324	serge	905	rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook,
		906	cookie, NULL);
5197	serge	907	/* RSEC will be NULL if FDE was cleared out as it was belonging to
		908	a discarded SHT_GROUP. */
		909	if (rsec)
		910	{
		911	REQUIRE (rsec->owner == abfd);
		912	this_inf->u.fde.next_for_section = elf_fde_list (rsec);
		913	elf_fde_list (rsec) = this_inf;
		914	}
		915	}
		916
		917	/* Skip the initial location and address range. */
		918	start = buf;
		919	length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
		920	REQUIRE (skip_bytes (&buf, end, 2 * length));
		921
6324	serge	922	SKIP_RELOCS (buf - length);
		923	if (!GET_RELOC (buf - length)
		924	&& read_value (abfd, buf - length, length, FALSE) == 0)
		925	{
		926	(*info->callbacks->minfo)
		927	(_("discarding zero address range FDE in %B(%A).\n"),
		928	abfd, sec);
		929	this_inf->u.fde.cie_inf = NULL;
		930	}
		931
5197	serge	932	/* Skip the augmentation size, if present. */
		933	if (cie->augmentation[0] == 'z')
		934	REQUIRE (read_uleb128 (&buf, end, &length));
		935	else
		936	length = 0;
		937
		938	/* Of the supported augmentation characters above, only 'L'
		939	adds augmentation data to the FDE. This code would need to
		940	be adjusted if any future augmentations do the same thing. */
		941	if (cie->lsda_encoding != DW_EH_PE_omit)
		942	{
		943	SKIP_RELOCS (buf);
		944	if (cie->can_make_lsda_relative && GET_RELOC (buf))
		945	cie->cie_inf->u.cie.make_lsda_relative = 1;
		946	this_inf->lsda_offset = buf - start;
		947	/* If there's no 'z' augmentation, we don't know where the
		948	CFA insns begin. Assume no padding. */
		949	if (cie->augmentation[0] != 'z')
		950	length = end - buf;
		951	}
		952
		953	/* Skip over the augmentation data. */
		954	REQUIRE (skip_bytes (&buf, end, length));
		955	insns = buf;
		956
		957	buf = last_fde + 4 + hdr_length;
		958
		959	/* For NULL RSEC (cleared FDE belonging to a discarded section)
		960	the relocations are commonly cleared. We do not sanity check if
		961	all these relocations are cleared as (1) relocations to
		962	.gcc_except_table will remain uncleared (they will get dropped
		963	with the drop of this unused FDE) and (2) BFD already safely drops
		964	relocations of any type to .eh_frame by
		965	elf_section_ignore_discarded_relocs.
		966	TODO: The .gcc_except_table entries should be also filtered as
		967	.eh_frame entries; or GCC could rather use COMDAT for them. */
		968	SKIP_RELOCS (buf);
		969	}
		970
		971	/* Try to interpret the CFA instructions and find the first
		972	padding nop. Shrink this_inf's size so that it doesn't
		973	include the padding. */
		974	length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
		975	set_loc_count = 0;
		976	insns_end = skip_non_nops (insns, end, length, &set_loc_count);
		977	/* If we don't understand the CFA instructions, we can't know
		978	what needs to be adjusted there. */
		979	if (insns_end == NULL
		980	/* For the time being we don't support DW_CFA_set_loc in
		981	CIE instructions. */
		982	\|\| (set_loc_count && this_inf->cie))
		983	goto free_no_table;
		984	this_inf->size -= end - insns_end;
		985	if (insns_end != end && this_inf->cie)
		986	{
		987	cie->initial_insn_length -= end - insns_end;
		988	cie->length -= end - insns_end;
		989	}
		990	if (set_loc_count
		991	&& ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
		992	\|\| this_inf->make_relative))
		993	{
		994	unsigned int cnt;
		995	bfd_byte *p;
		996
		997	this_inf->set_loc = (unsigned int *)
		998	bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
		999	REQUIRE (this_inf->set_loc);
		1000	this_inf->set_loc[0] = set_loc_count;
		1001	p = insns;
		1002	cnt = 0;
		1003	while (p < end)
		1004	{
		1005	if (*p == DW_CFA_set_loc)
		1006	this_inf->set_loc[++cnt] = p + 1 - start;
		1007	REQUIRE (skip_cfa_op (&p, end, length));
		1008	}
		1009	}
		1010
		1011	this_inf->removed = 1;
		1012	this_inf->fde_encoding = cie->fde_encoding;
		1013	this_inf->lsda_encoding = cie->lsda_encoding;
		1014	sec_info->count++;
		1015	}
		1016	BFD_ASSERT (sec_info->count == num_entries);
		1017	BFD_ASSERT (cie_count == num_cies);
		1018
		1019	elf_section_data (sec)->sec_info = sec_info;
		1020	sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
6324	serge	1021	if (!bfd_link_relocatable (info))
5197	serge	1022	{
6324	serge	1023	/* Keep info for merging cies. */
5197	serge	1024	sec_info->cies = local_cies;
		1025	local_cies = NULL;
		1026	}
		1027	goto success;
		1028
		1029	free_no_table:
		1030	(*info->callbacks->einfo)
		1031	(_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
		1032	abfd, sec);
6324	serge	1033	hdr_info->u.dwarf.table = FALSE;
5197	serge	1034	if (sec_info)
		1035	free (sec_info);
		1036	success:
		1037	if (ehbuf)
		1038	free (ehbuf);
		1039	if (local_cies)
		1040	free (local_cies);
		1041	#undef REQUIRE
		1042	}
		1043
6324	serge	1044	/* Order eh_frame_hdr entries by the VMA of their text section. */
5197	serge	1045
6324	serge	1046	static int
		1047	cmp_eh_frame_hdr (const void a, const void b)
		1048	{
		1049	bfd_vma text_a;
		1050	bfd_vma text_b;
		1051	asection *sec;
		1052
		1053	sec = (asection const *)a;
		1054	sec = (asection *) elf_section_data (sec)->sec_info;
		1055	text_a = sec->output_section->vma + sec->output_offset;
		1056	sec = (asection const *)b;
		1057	sec = (asection *) elf_section_data (sec)->sec_info;
		1058	text_b = sec->output_section->vma + sec->output_offset;
		1059
		1060	if (text_a < text_b)
		1061	return -1;
		1062	return text_a > text_b;
		1063
		1064	}
		1065
		1066	/* Add space for a CANTUNWIND terminator to SEC if the text sections
		1067	referenced by it and NEXT are not contiguous, or NEXT is NULL. */
		1068
		1069	static void
		1070	add_eh_frame_hdr_terminator (asection *sec,
		1071	asection *next)
		1072	{
		1073	bfd_vma end;
		1074	bfd_vma next_start;
		1075	asection *text_sec;
		1076
		1077	if (next)
		1078	{
		1079	/* See if there is a gap (presumably a text section without unwind info)
		1080	between these two entries. */
		1081	text_sec = (asection *) elf_section_data (sec)->sec_info;
		1082	end = text_sec->output_section->vma + text_sec->output_offset
		1083	+ text_sec->size;
		1084	text_sec = (asection *) elf_section_data (next)->sec_info;
		1085	next_start = text_sec->output_section->vma + text_sec->output_offset;
		1086	if (end == next_start)
		1087	return;
		1088	}
		1089
		1090	/* Add space for a CANTUNWIND terminator. */
		1091	if (!sec->rawsize)
		1092	sec->rawsize = sec->size;
		1093
		1094	bfd_set_section_size (sec->owner, sec, sec->size + 8);
		1095	}
		1096
		1097	/* Finish a pass over all .eh_frame_entry sections. */
		1098
		1099	bfd_boolean
5197	serge	1100	_bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
		1101	{
		1102	struct eh_frame_hdr_info *hdr_info;
6324	serge	1103	unsigned int i;
5197	serge	1104
		1105	hdr_info = &elf_hash_table (info)->eh_info;
6324	serge	1106
		1107	if (info->eh_frame_hdr_type != COMPACT_EH_HDR
		1108	\|\| hdr_info->array_count == 0)
		1109	return FALSE;
		1110
		1111	bfd_elf_discard_eh_frame_entry (hdr_info);
		1112
		1113	qsort (hdr_info->u.compact.entries, hdr_info->array_count,
		1114	sizeof (asection *), cmp_eh_frame_hdr);
		1115
		1116	for (i = 0; i < hdr_info->array_count - 1; i++)
		1117	{
		1118	add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i],
		1119	hdr_info->u.compact.entries[i + 1]);
		1120	}
		1121
		1122	/* Add a CANTUNWIND terminator after the last entry. */
		1123	add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL);
		1124	return TRUE;
5197	serge	1125	}
		1126
		1127	/* Mark all relocations against CIE or FDE ENT, which occurs in
		1128	.eh_frame section SEC. COOKIE describes the relocations in SEC;
		1129	its "rel" field can be changed freely. */
		1130
		1131	static bfd_boolean
		1132	mark_entry (struct bfd_link_info info, asection sec,
		1133	struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
		1134	struct elf_reloc_cookie *cookie)
		1135	{
		1136	/* FIXME: octets_per_byte. */
		1137	for (cookie->rel = cookie->rels + ent->reloc_index;
		1138	cookie->rel < cookie->relend
		1139	&& cookie->rel->r_offset < ent->offset + ent->size;
		1140	cookie->rel++)
		1141	if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
		1142	return FALSE;
		1143
		1144	return TRUE;
		1145	}
		1146
		1147	/* Mark all the relocations against FDEs that relate to code in input
		1148	section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
		1149	relocations are described by COOKIE. */
		1150
		1151	bfd_boolean
		1152	_bfd_elf_gc_mark_fdes (struct bfd_link_info info, asection sec,
		1153	asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
		1154	struct elf_reloc_cookie *cookie)
		1155	{
		1156	struct eh_cie_fde fde, cie;
		1157
		1158	for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
		1159	{
		1160	if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
		1161	return FALSE;
		1162
		1163	/* At this stage, all cie_inf fields point to local CIEs, so we
		1164	can use the same cookie to refer to them. */
		1165	cie = fde->u.fde.cie_inf;
6324	serge	1166	if (cie != NULL && !cie->u.cie.gc_mark)
5197	serge	1167	{
		1168	cie->u.cie.gc_mark = 1;
		1169	if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
		1170	return FALSE;
		1171	}
		1172	}
		1173	return TRUE;
		1174	}
		1175
		1176	/* Input section SEC of ABFD is an .eh_frame section that contains the
		1177	CIE described by CIE_INF. Return a version of CIE_INF that is going
		1178	to be kept in the output, adding CIE_INF to the output if necessary.
		1179
		1180	HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
		1181	relocations in REL. */
		1182
		1183	static struct eh_cie_fde *
		1184	find_merged_cie (bfd abfd, struct bfd_link_info info, asection *sec,
		1185	struct eh_frame_hdr_info *hdr_info,
		1186	struct elf_reloc_cookie *cookie,
		1187	struct eh_cie_fde *cie_inf)
		1188	{
		1189	unsigned long r_symndx;
		1190	struct cie cie, new_cie;
		1191	Elf_Internal_Rela *rel;
		1192	void **loc;
		1193
		1194	/* Use CIE_INF if we have already decided to keep it. */
		1195	if (!cie_inf->removed)
		1196	return cie_inf;
		1197
		1198	/* If we have merged CIE_INF with another CIE, use that CIE instead. */
		1199	if (cie_inf->u.cie.merged)
		1200	return cie_inf->u.cie.u.merged_with;
		1201
		1202	cie = cie_inf->u.cie.u.full_cie;
		1203
		1204	/* Assume we will need to keep CIE_INF. */
		1205	cie_inf->removed = 0;
		1206	cie_inf->u.cie.u.sec = sec;
		1207
		1208	/* If we are not merging CIEs, use CIE_INF. */
		1209	if (cie == NULL)
		1210	return cie_inf;
		1211
		1212	if (cie->per_encoding != DW_EH_PE_omit)
		1213	{
		1214	bfd_boolean per_binds_local;
		1215
6324	serge	1216	/* Work out the address of personality routine, or at least
		1217	enough info that we could calculate the address had we made a
		1218	final section layout. The symbol on the reloc is enough,
		1219	either the hash for a global, or (bfd id, index) pair for a
		1220	local. The assumption here is that no one uses addends on
		1221	the reloc. */
5197	serge	1222	rel = cookie->rels + cie->personality.reloc_index;
		1223	memset (&cie->personality, 0, sizeof (cie->personality));
		1224	#ifdef BFD64
		1225	if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
		1226	r_symndx = ELF64_R_SYM (rel->r_info);
		1227	else
		1228	#endif
		1229	r_symndx = ELF32_R_SYM (rel->r_info);
		1230	if (r_symndx >= cookie->locsymcount
		1231	\|\| ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
		1232	{
		1233	struct elf_link_hash_entry *h;
		1234
		1235	r_symndx -= cookie->extsymoff;
		1236	h = cookie->sym_hashes[r_symndx];
		1237
		1238	while (h->root.type == bfd_link_hash_indirect
		1239	\|\| h->root.type == bfd_link_hash_warning)
		1240	h = (struct elf_link_hash_entry *) h->root.u.i.link;
		1241
		1242	cie->personality.h = h;
		1243	per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
		1244	}
		1245	else
		1246	{
		1247	Elf_Internal_Sym *sym;
		1248	asection *sym_sec;
		1249
		1250	sym = &cookie->locsyms[r_symndx];
		1251	sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
		1252	if (sym_sec == NULL)
		1253	return cie_inf;
		1254
		1255	if (sym_sec->kept_section != NULL)
		1256	sym_sec = sym_sec->kept_section;
		1257	if (sym_sec->output_section == NULL)
		1258	return cie_inf;
		1259
		1260	cie->local_personality = 1;
6324	serge	1261	cie->personality.sym.bfd_id = abfd->id;
		1262	cie->personality.sym.index = r_symndx;
5197	serge	1263	per_binds_local = TRUE;
		1264	}
		1265
		1266	if (per_binds_local
6324	serge	1267	&& bfd_link_pic (info)
5197	serge	1268	&& (cie->per_encoding & 0x70) == DW_EH_PE_absptr
		1269	&& (get_elf_backend_data (abfd)
		1270	->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
		1271	{
		1272	cie_inf->u.cie.make_per_encoding_relative = 1;
		1273	cie_inf->u.cie.per_encoding_relative = 1;
		1274	}
		1275	}
		1276
		1277	/* See if we can merge this CIE with an earlier one. */
		1278	cie_compute_hash (cie);
6324	serge	1279	if (hdr_info->u.dwarf.cies == NULL)
5197	serge	1280	{
6324	serge	1281	hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free);
		1282	if (hdr_info->u.dwarf.cies == NULL)
5197	serge	1283	return cie_inf;
		1284	}
6324	serge	1285	loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie,
		1286	cie->hash, INSERT);
5197	serge	1287	if (loc == NULL)
		1288	return cie_inf;
		1289
		1290	new_cie = (struct cie ) loc;
		1291	if (new_cie == NULL)
		1292	{
		1293	/* Keep CIE_INF and record it in the hash table. */
		1294	new_cie = (struct cie *) malloc (sizeof (struct cie));
		1295	if (new_cie == NULL)
		1296	return cie_inf;
		1297
		1298	memcpy (new_cie, cie, sizeof (struct cie));
		1299	*loc = new_cie;
		1300	}
		1301	else
		1302	{
		1303	/* Merge CIE_INF with NEW_CIE->CIE_INF. */
		1304	cie_inf->removed = 1;
		1305	cie_inf->u.cie.merged = 1;
		1306	cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
		1307	if (cie_inf->u.cie.make_lsda_relative)
		1308	new_cie->cie_inf->u.cie.make_lsda_relative = 1;
		1309	}
		1310	return new_cie->cie_inf;
		1311	}
		1312
		1313	/* This function is called for each input file before the .eh_frame
		1314	section is relocated. It discards duplicate CIEs and FDEs for discarded
		1315	functions. The function returns TRUE iff any entries have been
		1316	deleted. */
		1317
		1318	bfd_boolean
		1319	_bfd_elf_discard_section_eh_frame
		1320	(bfd abfd, struct bfd_link_info info, asection *sec,
		1321	bfd_boolean (reloc_symbol_deleted_p) (bfd_vma, void ),
		1322	struct elf_reloc_cookie *cookie)
		1323	{
		1324	struct eh_cie_fde *ent;
		1325	struct eh_frame_sec_info *sec_info;
		1326	struct eh_frame_hdr_info *hdr_info;
		1327	unsigned int ptr_size, offset;
		1328
		1329	if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
		1330	return FALSE;
		1331
		1332	sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
		1333	if (sec_info == NULL)
		1334	return FALSE;
		1335
		1336	ptr_size = (get_elf_backend_data (sec->owner)
		1337	->elf_backend_eh_frame_address_size (sec->owner, sec));
		1338
		1339	hdr_info = &elf_hash_table (info)->eh_info;
		1340	for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
		1341	if (ent->size == 4)
		1342	/* There should only be one zero terminator, on the last input
		1343	file supplying .eh_frame (crtend.o). Remove any others. */
		1344	ent->removed = sec->map_head.s != NULL;
6324	serge	1345	else if (!ent->cie && ent->u.fde.cie_inf != NULL)
5197	serge	1346	{
		1347	bfd_boolean keep;
		1348	if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
		1349	{
		1350	unsigned int width
		1351	= get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
		1352	bfd_vma value
		1353	= read_value (abfd, sec->contents + ent->offset + 8 + width,
		1354	width, get_DW_EH_PE_signed (ent->fde_encoding));
		1355	keep = value != 0;
		1356	}
		1357	else
		1358	{
		1359	cookie->rel = cookie->rels + ent->reloc_index;
		1360	/* FIXME: octets_per_byte. */
		1361	BFD_ASSERT (cookie->rel < cookie->relend
		1362	&& cookie->rel->r_offset == ent->offset + 8);
		1363	keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
		1364	}
		1365	if (keep)
		1366	{
6324	serge	1367	if (bfd_link_pic (info)
5197	serge	1368	&& (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
		1369	&& ent->make_relative == 0)
		1370	\|\| (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
		1371	{
		1372	/* If a shared library uses absolute pointers
		1373	which we cannot turn into PC relative,
		1374	don't create the binary search table,
		1375	since it is affected by runtime relocations. */
6324	serge	1376	hdr_info->u.dwarf.table = FALSE;
5197	serge	1377	(*info->callbacks->einfo)
6324	serge	1378	(_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
5197	serge	1379	" table being created.\n"), abfd, sec);
		1380	}
		1381	ent->removed = 0;
6324	serge	1382	hdr_info->u.dwarf.fde_count++;
5197	serge	1383	ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
		1384	cookie, ent->u.fde.cie_inf);
		1385	}
		1386	}
		1387
		1388	if (sec_info->cies)
		1389	{
		1390	free (sec_info->cies);
		1391	sec_info->cies = NULL;
		1392	}
		1393
		1394	offset = 0;
		1395	for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
		1396	if (!ent->removed)
		1397	{
		1398	ent->new_offset = offset;
		1399	offset += size_of_output_cie_fde (ent, ptr_size);
		1400	}
		1401
		1402	sec->rawsize = sec->size;
		1403	sec->size = offset;
		1404	return offset != sec->rawsize;
		1405	}
		1406
		1407	/* This function is called for .eh_frame_hdr section after
		1408	_bfd_elf_discard_section_eh_frame has been called on all .eh_frame
		1409	input sections. It finalizes the size of .eh_frame_hdr section. */
		1410
		1411	bfd_boolean
		1412	_bfd_elf_discard_section_eh_frame_hdr (bfd abfd, struct bfd_link_info info)
		1413	{
		1414	struct elf_link_hash_table *htab;
		1415	struct eh_frame_hdr_info *hdr_info;
		1416	asection *sec;
		1417
		1418	htab = elf_hash_table (info);
		1419	hdr_info = &htab->eh_info;
		1420
6324	serge	1421	if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL)
5197	serge	1422	{
6324	serge	1423	htab_delete (hdr_info->u.dwarf.cies);
		1424	hdr_info->u.dwarf.cies = NULL;
5197	serge	1425	}
		1426
		1427	sec = hdr_info->hdr_sec;
		1428	if (sec == NULL)
		1429	return FALSE;
		1430
6324	serge	1431	if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
		1432	{
		1433	/* For compact frames we only add the header. The actual table comes
		1434	from the .eh_frame_entry sections. */
		1435	sec->size = 8;
		1436	}
		1437	else
		1438	{
5197	serge	1439	sec->size = EH_FRAME_HDR_SIZE;
6324	serge	1440	if (hdr_info->u.dwarf.table)
		1441	sec->size += 4 + hdr_info->u.dwarf.fde_count * 8;
		1442	}
5197	serge	1443
		1444	elf_eh_frame_hdr (abfd) = sec;
		1445	return TRUE;
		1446	}
		1447
		1448	/* Return true if there is at least one non-empty .eh_frame section in
		1449	input files. Can only be called after ld has mapped input to
		1450	output sections, and before sections are stripped. */
6324	serge	1451
5197	serge	1452	bfd_boolean
		1453	_bfd_elf_eh_frame_present (struct bfd_link_info *info)
		1454	{
		1455	asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
		1456
		1457	if (eh == NULL)
		1458	return FALSE;
		1459
		1460	/* Count only sections which have at least a single CIE or FDE.
		1461	There cannot be any CIE or FDE <= 8 bytes. */
		1462	for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
		1463	if (eh->size > 8)
		1464	return TRUE;
		1465
		1466	return FALSE;
		1467	}
		1468
6324	serge	1469	/* Return true if there is at least one .eh_frame_entry section in
		1470	input files. */
		1471
		1472	bfd_boolean
		1473	_bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
		1474	{
		1475	asection *o;
		1476	bfd *abfd;
		1477
		1478	for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
		1479	{
		1480	for (o = abfd->sections; o; o = o->next)
		1481	{
		1482	const char *name = bfd_get_section_name (abfd, o);
		1483
		1484	if (strcmp (name, ".eh_frame_entry")
		1485	&& !bfd_is_abs_section (o->output_section))
		1486	return TRUE;
		1487	}
		1488	}
		1489	return FALSE;
		1490	}
		1491
5197	serge	1492	/* This function is called from size_dynamic_sections.
		1493	It needs to decide whether .eh_frame_hdr should be output or not,
		1494	because when the dynamic symbol table has been sized it is too late
		1495	to strip sections. */
		1496
		1497	bfd_boolean
		1498	_bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
		1499	{
		1500	struct elf_link_hash_table *htab;
		1501	struct eh_frame_hdr_info *hdr_info;
6324	serge	1502	struct bfd_link_hash_entry *bh = NULL;
		1503	struct elf_link_hash_entry *h;
5197	serge	1504
		1505	htab = elf_hash_table (info);
		1506	hdr_info = &htab->eh_info;
		1507	if (hdr_info->hdr_sec == NULL)
		1508	return TRUE;
		1509
		1510	if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
6324	serge	1511	\|\| info->eh_frame_hdr_type == 0
		1512	\|\| (info->eh_frame_hdr_type == DWARF2_EH_HDR
		1513	&& !_bfd_elf_eh_frame_present (info))
		1514	\|\| (info->eh_frame_hdr_type == COMPACT_EH_HDR
		1515	&& !_bfd_elf_eh_frame_entry_present (info)))
5197	serge	1516	{
		1517	hdr_info->hdr_sec->flags \|= SEC_EXCLUDE;
		1518	hdr_info->hdr_sec = NULL;
		1519	return TRUE;
		1520	}
		1521
6324	serge	1522	/* Add a hidden symbol so that systems without access to PHDRs can
		1523	find the table. */
		1524	if (! (_bfd_generic_link_add_one_symbol
		1525	(info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
		1526	hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
		1527	return FALSE;
		1528
		1529	h = (struct elf_link_hash_entry *) bh;
		1530	h->def_regular = 1;
		1531	h->other = STV_HIDDEN;
		1532	get_elf_backend_data
		1533	(info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
		1534
		1535	if (!hdr_info->frame_hdr_is_compact)
		1536	hdr_info->u.dwarf.table = TRUE;
5197	serge	1537	return TRUE;
		1538	}
		1539
		1540	/* Adjust an address in the .eh_frame section. Given OFFSET within
		1541	SEC, this returns the new offset in the adjusted .eh_frame section,
		1542	or -1 if the address refers to a CIE/FDE which has been removed
		1543	or to offset with dynamic relocation which is no longer needed. */
		1544
		1545	bfd_vma
		1546	_bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
		1547	struct bfd_link_info *info ATTRIBUTE_UNUSED,
		1548	asection *sec,
		1549	bfd_vma offset)
		1550	{
		1551	struct eh_frame_sec_info *sec_info;
		1552	unsigned int lo, hi, mid;
		1553
		1554	if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
		1555	return offset;
		1556	sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
		1557
		1558	if (offset >= sec->rawsize)
		1559	return offset - sec->rawsize + sec->size;
		1560
		1561	lo = 0;
		1562	hi = sec_info->count;
		1563	mid = 0;
		1564	while (lo < hi)
		1565	{
		1566	mid = (lo + hi) / 2;
		1567	if (offset < sec_info->entry[mid].offset)
		1568	hi = mid;
		1569	else if (offset
		1570	>= sec_info->entry[mid].offset + sec_info->entry[mid].size)
		1571	lo = mid + 1;
		1572	else
		1573	break;
		1574	}
		1575
		1576	BFD_ASSERT (lo < hi);
		1577
		1578	/* FDE or CIE was removed. */
		1579	if (sec_info->entry[mid].removed)
		1580	return (bfd_vma) -1;
		1581
		1582	/* If converting personality pointers to DW_EH_PE_pcrel, there will be
		1583	no need for run-time relocation against the personality field. */
		1584	if (sec_info->entry[mid].cie
		1585	&& sec_info->entry[mid].u.cie.make_per_encoding_relative
		1586	&& offset == (sec_info->entry[mid].offset + 8
		1587	+ sec_info->entry[mid].u.cie.personality_offset))
		1588	return (bfd_vma) -2;
		1589
		1590	/* If converting to DW_EH_PE_pcrel, there will be no need for run-time
		1591	relocation against FDE's initial_location field. */
		1592	if (!sec_info->entry[mid].cie
		1593	&& sec_info->entry[mid].make_relative
		1594	&& offset == sec_info->entry[mid].offset + 8)
		1595	return (bfd_vma) -2;
		1596
		1597	/* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
		1598	for run-time relocation against LSDA field. */
		1599	if (!sec_info->entry[mid].cie
		1600	&& sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
		1601	&& offset == (sec_info->entry[mid].offset + 8
		1602	+ sec_info->entry[mid].lsda_offset))
		1603	return (bfd_vma) -2;
		1604
		1605	/* If converting to DW_EH_PE_pcrel, there will be no need for run-time
		1606	relocation against DW_CFA_set_loc's arguments. */
		1607	if (sec_info->entry[mid].set_loc
		1608	&& sec_info->entry[mid].make_relative
		1609	&& (offset >= sec_info->entry[mid].offset + 8
		1610	+ sec_info->entry[mid].set_loc[1]))
		1611	{
		1612	unsigned int cnt;
		1613
		1614	for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
		1615	if (offset == sec_info->entry[mid].offset + 8
		1616	+ sec_info->entry[mid].set_loc[cnt])
		1617	return (bfd_vma) -2;
		1618	}
		1619
		1620	/* Any new augmentation bytes go before the first relocation. */
		1621	return (offset + sec_info->entry[mid].new_offset
		1622	- sec_info->entry[mid].offset
		1623	+ extra_augmentation_string_bytes (sec_info->entry + mid)
		1624	+ extra_augmentation_data_bytes (sec_info->entry + mid));
		1625	}
		1626
6324	serge	1627	/* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed.
		1628	Also check that the contents look sane. */
		1629
		1630	bfd_boolean
		1631	_bfd_elf_write_section_eh_frame_entry (bfd abfd, struct bfd_link_info info,
		1632	asection sec, bfd_byte contents)
		1633	{
		1634	const struct elf_backend_data *bed;
		1635	bfd_byte cantunwind[8];
		1636	bfd_vma addr;
		1637	bfd_vma last_addr;
		1638	bfd_vma offset;
		1639	asection text_sec = (asection ) elf_section_data (sec)->sec_info;
		1640
		1641	if (!sec->rawsize)
		1642	sec->rawsize = sec->size;
		1643
		1644	BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY);
		1645
		1646	/* Check to make sure that the text section corresponding to this eh_frame_entry
		1647	section has not been excluded. In particular, mips16 stub entries will be
		1648	excluded outside of the normal process. */
		1649	if (sec->flags & SEC_EXCLUDE
		1650	\|\| text_sec->flags & SEC_EXCLUDE)
		1651	return TRUE;
		1652
		1653	if (!bfd_set_section_contents (abfd, sec->output_section, contents,
		1654	sec->output_offset, sec->rawsize))
		1655	return FALSE;
		1656
		1657	last_addr = bfd_get_signed_32 (abfd, contents);
		1658	/* Check that all the entries are in order. */
		1659	for (offset = 8; offset < sec->rawsize; offset += 8)
		1660	{
		1661	addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
		1662	if (addr <= last_addr)
		1663	{
		1664	(*_bfd_error_handler) (_("%B: %s not in order"), sec->owner, sec->name);
		1665	return FALSE;
		1666	}
		1667
		1668	last_addr = addr;
		1669	}
		1670
		1671	addr = text_sec->output_section->vma + text_sec->output_offset
		1672	+ text_sec->size;
		1673	addr &= ~1;
		1674	addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
		1675	if (addr & 1)
		1676	{
		1677	(*_bfd_error_handler) (_("%B: %s invalid input section size"),
		1678	sec->owner, sec->name);
		1679	bfd_set_error (bfd_error_bad_value);
		1680	return FALSE;
		1681	}
		1682	if (last_addr >= addr + sec->rawsize)
		1683	{
		1684	(*_bfd_error_handler) (_("%B: %s points past end of text section"),
		1685	sec->owner, sec->name);
		1686	bfd_set_error (bfd_error_bad_value);
		1687	return FALSE;
		1688	}
		1689
		1690	if (sec->size == sec->rawsize)
		1691	return TRUE;
		1692
		1693	bed = get_elf_backend_data (abfd);
		1694	BFD_ASSERT (sec->size == sec->rawsize + 8);
		1695	BFD_ASSERT ((addr & 1) == 0);
		1696	BFD_ASSERT (bed->cant_unwind_opcode);
		1697
		1698	bfd_put_32 (abfd, addr, cantunwind);
		1699	bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4);
		1700	return bfd_set_section_contents (abfd, sec->output_section, cantunwind,
		1701	sec->output_offset + sec->rawsize, 8);
		1702	}
		1703
5197	serge	1704	/* Write out .eh_frame section. This is called with the relocated
		1705	contents. */
		1706
		1707	bfd_boolean
		1708	_bfd_elf_write_section_eh_frame (bfd *abfd,
		1709	struct bfd_link_info *info,
		1710	asection *sec,
		1711	bfd_byte *contents)
		1712	{
		1713	struct eh_frame_sec_info *sec_info;
		1714	struct elf_link_hash_table *htab;
		1715	struct eh_frame_hdr_info *hdr_info;
		1716	unsigned int ptr_size;
		1717	struct eh_cie_fde *ent;
6324	serge	1718	bfd_size_type sec_size;
5197	serge	1719
		1720	if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
		1721	/* FIXME: octets_per_byte. */
		1722	return bfd_set_section_contents (abfd, sec->output_section, contents,
		1723	sec->output_offset, sec->size);
		1724
		1725	ptr_size = (get_elf_backend_data (abfd)
		1726	->elf_backend_eh_frame_address_size (abfd, sec));
		1727	BFD_ASSERT (ptr_size != 0);
		1728
		1729	sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
		1730	htab = elf_hash_table (info);
		1731	hdr_info = &htab->eh_info;
		1732
6324	serge	1733	if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
		1734	{
		1735	hdr_info->frame_hdr_is_compact = FALSE;
		1736	hdr_info->u.dwarf.array = (struct eh_frame_array_ent *)
		1737	bfd_malloc (hdr_info->u.dwarf.fde_count
		1738	* sizeof (*hdr_info->u.dwarf.array));
		1739	}
		1740	if (hdr_info->u.dwarf.array == NULL)
5197	serge	1741	hdr_info = NULL;
		1742
		1743	/* The new offsets can be bigger or smaller than the original offsets.
		1744	We therefore need to make two passes over the section: one backward
		1745	pass to move entries up and one forward pass to move entries down.
		1746	The two passes won't interfere with each other because entries are
		1747	not reordered */
		1748	for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
		1749	if (!ent->removed && ent->new_offset > ent->offset)
		1750	memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
		1751
		1752	for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
		1753	if (!ent->removed && ent->new_offset < ent->offset)
		1754	memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
		1755
		1756	for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
		1757	{
		1758	unsigned char buf, end;
		1759	unsigned int new_size;
		1760
		1761	if (ent->removed)
		1762	continue;
		1763
		1764	if (ent->size == 4)
		1765	{
		1766	/* Any terminating FDE must be at the end of the section. */
		1767	BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
		1768	continue;
		1769	}
		1770
		1771	buf = contents + ent->new_offset;
		1772	end = buf + ent->size;
		1773	new_size = size_of_output_cie_fde (ent, ptr_size);
		1774
		1775	/* Update the size. It may be shrinked. */
		1776	bfd_put_32 (abfd, new_size - 4, buf);
		1777
		1778	/* Filling the extra bytes with DW_CFA_nops. */
		1779	if (new_size != ent->size)
		1780	memset (end, 0, new_size - ent->size);
		1781
		1782	if (ent->cie)
		1783	{
		1784	/* CIE */
		1785	if (ent->make_relative
		1786	\|\| ent->u.cie.make_lsda_relative
		1787	\|\| ent->u.cie.per_encoding_relative)
		1788	{
		1789	char *aug;
		1790	unsigned int action, extra_string, extra_data;
		1791	unsigned int per_width, per_encoding;
		1792
		1793	/* Need to find 'R' or 'L' augmentation's argument and modify
		1794	DW_EH_PE_* value. */
		1795	action = ((ent->make_relative ? 1 : 0)
		1796	\| (ent->u.cie.make_lsda_relative ? 2 : 0)
		1797	\| (ent->u.cie.per_encoding_relative ? 4 : 0));
		1798	extra_string = extra_augmentation_string_bytes (ent);
		1799	extra_data = extra_augmentation_data_bytes (ent);
		1800
		1801	/* Skip length, id and version. */
		1802	buf += 9;
		1803	aug = (char *) buf;
		1804	buf += strlen (aug) + 1;
		1805	skip_leb128 (&buf, end);
		1806	skip_leb128 (&buf, end);
		1807	skip_leb128 (&buf, end);
		1808	if (*aug == 'z')
		1809	{
		1810	/* The uleb128 will always be a single byte for the kind
		1811	of augmentation strings that we're prepared to handle. */
		1812	*buf++ += extra_data;
		1813	aug++;
		1814	}
		1815
		1816	/* Make room for the new augmentation string and data bytes. */
		1817	memmove (buf + extra_string + extra_data, buf, end - buf);
		1818	memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
		1819	buf += extra_string;
		1820	end += extra_string + extra_data;
		1821
		1822	if (ent->add_augmentation_size)
		1823	{
		1824	*aug++ = 'z';
		1825	*buf++ = extra_data - 1;
		1826	}
		1827	if (ent->u.cie.add_fde_encoding)
		1828	{
		1829	BFD_ASSERT (action & 1);
		1830	*aug++ = 'R';
		1831	*buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
		1832	action &= ~1;
		1833	}
		1834
		1835	while (action)
		1836	switch (*aug++)
		1837	{
		1838	case 'L':
		1839	if (action & 2)
		1840	{
		1841	BFD_ASSERT (*buf == ent->lsda_encoding);
		1842	buf = make_pc_relative (buf, ptr_size);
		1843	action &= ~2;
		1844	}
		1845	buf++;
		1846	break;
		1847	case 'P':
		1848	if (ent->u.cie.make_per_encoding_relative)
		1849	buf = make_pc_relative (buf, ptr_size);
		1850	per_encoding = *buf++;
		1851	per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
		1852	BFD_ASSERT (per_width != 0);
		1853	BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
		1854	== ent->u.cie.per_encoding_relative);
		1855	if ((per_encoding & 0x70) == DW_EH_PE_aligned)
		1856	buf = (contents
		1857	+ ((buf - contents + per_width - 1)
		1858	& ~((bfd_size_type) per_width - 1)));
		1859	if (action & 4)
		1860	{
		1861	bfd_vma val;
		1862
		1863	val = read_value (abfd, buf, per_width,
		1864	get_DW_EH_PE_signed (per_encoding));
		1865	if (ent->u.cie.make_per_encoding_relative)
		1866	val -= (sec->output_section->vma
		1867	+ sec->output_offset
		1868	+ (buf - contents));
		1869	else
		1870	{
		1871	val += (bfd_vma) ent->offset - ent->new_offset;
		1872	val -= extra_string + extra_data;
		1873	}
		1874	write_value (abfd, buf, val, per_width);
		1875	action &= ~4;
		1876	}
		1877	buf += per_width;
		1878	break;
		1879	case 'R':
		1880	if (action & 1)
		1881	{
		1882	BFD_ASSERT (*buf == ent->fde_encoding);
		1883	buf = make_pc_relative (buf, ptr_size);
		1884	action &= ~1;
		1885	}
		1886	buf++;
		1887	break;
		1888	case 'S':
		1889	break;
		1890	default:
		1891	BFD_FAIL ();
		1892	}
		1893	}
		1894	}
		1895	else
		1896	{
		1897	/* FDE */
		1898	bfd_vma value, address;
		1899	unsigned int width;
		1900	bfd_byte *start;
		1901	struct eh_cie_fde *cie;
		1902
		1903	/* Skip length. */
		1904	cie = ent->u.fde.cie_inf;
		1905	buf += 4;
		1906	value = ((ent->new_offset + sec->output_offset + 4)
		1907	- (cie->new_offset + cie->u.cie.u.sec->output_offset));
		1908	bfd_put_32 (abfd, value, buf);
6324	serge	1909	if (bfd_link_relocatable (info))
		1910	continue;
5197	serge	1911	buf += 4;
		1912	width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
		1913	value = read_value (abfd, buf, width,
		1914	get_DW_EH_PE_signed (ent->fde_encoding));
		1915	address = value;
		1916	if (value)
		1917	{
		1918	switch (ent->fde_encoding & 0x70)
		1919	{
		1920	case DW_EH_PE_textrel:
		1921	BFD_ASSERT (hdr_info == NULL);
		1922	break;
		1923	case DW_EH_PE_datarel:
		1924	{
		1925	switch (abfd->arch_info->arch)
		1926	{
		1927	case bfd_arch_ia64:
		1928	BFD_ASSERT (elf_gp (abfd) != 0);
		1929	address += elf_gp (abfd);
		1930	break;
		1931	default:
		1932	(*info->callbacks->einfo)
		1933	(_("%P: DW_EH_PE_datarel unspecified"
		1934	" for this architecture.\n"));
		1935	/* Fall thru */
		1936	case bfd_arch_frv:
		1937	case bfd_arch_i386:
		1938	BFD_ASSERT (htab->hgot != NULL
		1939	&& ((htab->hgot->root.type
		1940	== bfd_link_hash_defined)
		1941	\|\| (htab->hgot->root.type
		1942	== bfd_link_hash_defweak)));
		1943	address
		1944	+= (htab->hgot->root.u.def.value
		1945	+ htab->hgot->root.u.def.section->output_offset
		1946	+ (htab->hgot->root.u.def.section->output_section
		1947	->vma));
		1948	break;
		1949	}
		1950	}
		1951	break;
		1952	case DW_EH_PE_pcrel:
		1953	value += (bfd_vma) ent->offset - ent->new_offset;
		1954	address += (sec->output_section->vma
		1955	+ sec->output_offset
		1956	+ ent->offset + 8);
		1957	break;
		1958	}
		1959	if (ent->make_relative)
		1960	value -= (sec->output_section->vma
		1961	+ sec->output_offset
		1962	+ ent->new_offset + 8);
		1963	write_value (abfd, buf, value, width);
		1964	}
		1965
		1966	start = buf;
		1967
		1968	if (hdr_info)
		1969	{
		1970	/* The address calculation may overflow, giving us a
		1971	value greater than 4G on a 32-bit target when
		1972	dwarf_vma is 64-bit. */
		1973	if (sizeof (address) > 4 && ptr_size == 4)
		1974	address &= 0xffffffff;
6324	serge	1975	hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
		1976	= address;
		1977	hdr_info->u.dwarf.array[hdr_info->array_count].range
		1978	= read_value (abfd, buf + width, width, FALSE);
		1979	hdr_info->u.dwarf.array[hdr_info->array_count++].fde
5197	serge	1980	= (sec->output_section->vma
		1981	+ sec->output_offset
		1982	+ ent->new_offset);
		1983	}
		1984
		1985	if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
		1986	\|\| cie->u.cie.make_lsda_relative)
		1987	{
		1988	buf += ent->lsda_offset;
		1989	width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
		1990	value = read_value (abfd, buf, width,
		1991	get_DW_EH_PE_signed (ent->lsda_encoding));
		1992	if (value)
		1993	{
		1994	if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
		1995	value += (bfd_vma) ent->offset - ent->new_offset;
		1996	else if (cie->u.cie.make_lsda_relative)
		1997	value -= (sec->output_section->vma
		1998	+ sec->output_offset
		1999	+ ent->new_offset + 8 + ent->lsda_offset);
		2000	write_value (abfd, buf, value, width);
		2001	}
		2002	}
		2003	else if (ent->add_augmentation_size)
		2004	{
		2005	/* Skip the PC and length and insert a zero byte for the
		2006	augmentation size. */
		2007	buf += width * 2;
		2008	memmove (buf + 1, buf, end - buf);
		2009	*buf = 0;
		2010	}
		2011
		2012	if (ent->set_loc)
		2013	{
		2014	/* Adjust DW_CFA_set_loc. */
		2015	unsigned int cnt;
		2016	bfd_vma new_offset;
		2017
		2018	width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
		2019	new_offset = ent->new_offset + 8
		2020	+ extra_augmentation_string_bytes (ent)
		2021	+ extra_augmentation_data_bytes (ent);
		2022
		2023	for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
		2024	{
		2025	buf = start + ent->set_loc[cnt];
		2026
		2027	value = read_value (abfd, buf, width,
		2028	get_DW_EH_PE_signed (ent->fde_encoding));
		2029	if (!value)
		2030	continue;
		2031
		2032	if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
		2033	value += (bfd_vma) ent->offset + 8 - new_offset;
		2034	if (ent->make_relative)
		2035	value -= (sec->output_section->vma
		2036	+ sec->output_offset
		2037	+ new_offset + ent->set_loc[cnt]);
		2038	write_value (abfd, buf, value, width);
		2039	}
		2040	}
		2041	}
		2042	}
		2043
		2044	/* We don't align the section to its section alignment since the
		2045	runtime library only expects all CIE/FDE records aligned at
		2046	the pointer size. _bfd_elf_discard_section_eh_frame should
		2047	have padded CIE/FDE records to multiple of pointer size with
		2048	size_of_output_cie_fde. */
6324	serge	2049	sec_size = sec->size;
		2050	if (sec_info->count != 0
		2051	&& sec_info->entry[sec_info->count - 1].size == 4)
		2052	sec_size -= 4;
		2053	if ((sec_size % ptr_size) != 0)
5197	serge	2054	abort ();
		2055
		2056	/* FIXME: octets_per_byte. */
		2057	return bfd_set_section_contents (abfd, sec->output_section,
		2058	contents, (file_ptr) sec->output_offset,
		2059	sec->size);
		2060	}
		2061
		2062	/* Helper function used to sort .eh_frame_hdr search table by increasing
		2063	VMA of FDE initial location. */
		2064
		2065	static int
		2066	vma_compare (const void a, const void b)
		2067	{
		2068	const struct eh_frame_array_ent p = (const struct eh_frame_array_ent ) a;
		2069	const struct eh_frame_array_ent q = (const struct eh_frame_array_ent ) b;
		2070	if (p->initial_loc > q->initial_loc)
		2071	return 1;
		2072	if (p->initial_loc < q->initial_loc)
		2073	return -1;
6324	serge	2074	if (p->range > q->range)
		2075	return 1;
		2076	if (p->range < q->range)
		2077	return -1;
5197	serge	2078	return 0;
		2079	}
		2080
6324	serge	2081	/* Reorder .eh_frame_entry sections to match the associated text sections.
		2082	This routine is called during the final linking step, just before writing
		2083	the contents. At this stage, sections in the eh_frame_hdr_info are already
		2084	sorted in order of increasing text section address and so we simply need
		2085	to make the .eh_frame_entrys follow that same order. Note that it is
		2086	invalid for a linker script to try to force a particular order of
		2087	.eh_frame_entry sections. */
		2088
		2089	bfd_boolean
		2090	_bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
		2091	{
		2092	asection *sec = NULL;
		2093	asection *osec;
		2094	struct eh_frame_hdr_info *hdr_info;
		2095	unsigned int i;
		2096	bfd_vma offset;
		2097	struct bfd_link_order *p;
		2098
		2099	hdr_info = &elf_hash_table (info)->eh_info;
		2100
		2101	if (hdr_info->hdr_sec == NULL
		2102	\|\| info->eh_frame_hdr_type != COMPACT_EH_HDR
		2103	\|\| hdr_info->array_count == 0)
		2104	return TRUE;
		2105
		2106	/* Change section output offsets to be in text section order. */
		2107	offset = 8;
		2108	osec = hdr_info->u.compact.entries[0]->output_section;
		2109	for (i = 0; i < hdr_info->array_count; i++)
		2110	{
		2111	sec = hdr_info->u.compact.entries[i];
		2112	if (sec->output_section != osec)
		2113	{
		2114	(*_bfd_error_handler)
		2115	(_("Invalid output section for .eh_frame_entry: %s"),
		2116	sec->output_section->name);
		2117	return FALSE;
		2118	}
		2119	sec->output_offset = offset;
		2120	offset += sec->size;
		2121	}
		2122
		2123
		2124	/* Fix the link_order to match. */
		2125	for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next)
		2126	{
		2127	if (p->type != bfd_indirect_link_order)
		2128	abort();
		2129
		2130	p->offset = p->u.indirect.section->output_offset;
		2131	if (p->next != NULL)
		2132	i--;
		2133	}
		2134
		2135	if (i != 0)
		2136	{
		2137	(*_bfd_error_handler)
		2138	(_("Invalid contents in %s section"), osec->name);
		2139	return FALSE;
		2140	}
		2141
		2142	return TRUE;
		2143	}
		2144
		2145	/* The .eh_frame_hdr format for Compact EH frames:
		2146	ubyte version (2)
		2147	ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references)
		2148	uint32_t count (Number of entries in table)
		2149	[array from .eh_frame_entry sections] */
		2150
		2151	static bfd_boolean
		2152	write_compact_eh_frame_hdr (bfd abfd, struct bfd_link_info info)
		2153	{
		2154	struct elf_link_hash_table *htab;
		2155	struct eh_frame_hdr_info *hdr_info;
		2156	asection *sec;
		2157	const struct elf_backend_data *bed;
		2158	bfd_vma count;
		2159	bfd_byte contents[8];
		2160	unsigned int i;
		2161
		2162	htab = elf_hash_table (info);
		2163	hdr_info = &htab->eh_info;
		2164	sec = hdr_info->hdr_sec;
		2165
		2166	if (sec->size != 8)
		2167	abort();
		2168
		2169	for (i = 0; i < sizeof (contents); i++)
		2170	contents[i] = 0;
		2171
		2172	contents[0] = COMPACT_EH_HDR;
		2173	bed = get_elf_backend_data (abfd);
		2174
		2175	BFD_ASSERT (bed->compact_eh_encoding);
		2176	contents[1] = (*bed->compact_eh_encoding) (info);
		2177
		2178	count = (sec->output_section->size - 8) / 8;
		2179	bfd_put_32 (abfd, count, contents + 4);
		2180	return bfd_set_section_contents (abfd, sec->output_section, contents,
		2181	(file_ptr) sec->output_offset, sec->size);
		2182	}
		2183
		2184	/* The .eh_frame_hdr format for DWARF frames:
		2185
5197	serge	2186	ubyte version (currently 1)
		2187	ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
		2188	.eh_frame section)
		2189	ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
		2190	number (or DW_EH_PE_omit if there is no
		2191	binary search table computed))
		2192	ubyte table_enc (DW_EH_PE_* encoding of binary search table,
		2193	or DW_EH_PE_omit if not present.
		2194	DW_EH_PE_datarel is using address of
		2195	.eh_frame_hdr section start as base)
		2196	[encoded] eh_frame_ptr (pointer to start of .eh_frame section)
		2197	optionally followed by:
		2198	[encoded] fde_count (total number of FDEs in .eh_frame section)
		2199	fde_count x [encoded] initial_loc, fde
		2200	(array of encoded pairs containing
		2201	FDE initial_location field and FDE address,
		2202	sorted by increasing initial_loc). */
		2203
6324	serge	2204	static bfd_boolean
		2205	write_dwarf_eh_frame_hdr (bfd abfd, struct bfd_link_info info)
5197	serge	2206	{
		2207	struct elf_link_hash_table *htab;
		2208	struct eh_frame_hdr_info *hdr_info;
		2209	asection *sec;
		2210	bfd_boolean retval = TRUE;
		2211
		2212	htab = elf_hash_table (info);
		2213	hdr_info = &htab->eh_info;
		2214	sec = hdr_info->hdr_sec;
		2215	bfd_byte *contents;
		2216	asection *eh_frame_sec;
		2217	bfd_size_type size;
		2218	bfd_vma encoded_eh_frame;
		2219
		2220	size = EH_FRAME_HDR_SIZE;
6324	serge	2221	if (hdr_info->u.dwarf.array
		2222	&& hdr_info->array_count == hdr_info->u.dwarf.fde_count)
		2223	size += 4 + hdr_info->u.dwarf.fde_count * 8;
5197	serge	2224	contents = (bfd_byte *) bfd_malloc (size);
		2225	if (contents == NULL)
		2226	return FALSE;
		2227
		2228	eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
		2229	if (eh_frame_sec == NULL)
		2230	{
		2231	free (contents);
		2232	return FALSE;
		2233	}
		2234
		2235	memset (contents, 0, EH_FRAME_HDR_SIZE);
		2236	/* Version. */
		2237	contents[0] = 1;
		2238	/* .eh_frame offset. */
		2239	contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
		2240	(abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
		2241
6324	serge	2242	if (hdr_info->u.dwarf.array
		2243	&& hdr_info->array_count == hdr_info->u.dwarf.fde_count)
5197	serge	2244	{
		2245	/* FDE count encoding. */
		2246	contents[2] = DW_EH_PE_udata4;
		2247	/* Search table encoding. */
		2248	contents[3] = DW_EH_PE_datarel \| DW_EH_PE_sdata4;
		2249	}
		2250	else
		2251	{
		2252	contents[2] = DW_EH_PE_omit;
		2253	contents[3] = DW_EH_PE_omit;
		2254	}
		2255	bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
		2256
		2257	if (contents[2] != DW_EH_PE_omit)
		2258	{
		2259	unsigned int i;
6324	serge	2260	bfd_boolean overlap, overflow;
5197	serge	2261
6324	serge	2262	bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
		2263	contents + EH_FRAME_HDR_SIZE);
		2264	qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
		2265	sizeof (*hdr_info->u.dwarf.array), vma_compare);
		2266	overlap = FALSE;
		2267	overflow = FALSE;
		2268	for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
		2269	{
		2270	bfd_vma val;
		2271
		2272	val = hdr_info->u.dwarf.array[i].initial_loc
		2273	- sec->output_section->vma;
		2274	val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
		2275	if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
		2276	&& (hdr_info->u.dwarf.array[i].initial_loc
		2277	!= sec->output_section->vma + val))
		2278	overflow = TRUE;
		2279	bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
		2280	val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
		2281	val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
		2282	if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
		2283	&& (hdr_info->u.dwarf.array[i].fde
		2284	!= sec->output_section->vma + val))
		2285	overflow = TRUE;
		2286	bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
		2287	if (i != 0
		2288	&& (hdr_info->u.dwarf.array[i].initial_loc
		2289	< (hdr_info->u.dwarf.array[i - 1].initial_loc
		2290	+ hdr_info->u.dwarf.array[i - 1].range)))
		2291	overlap = TRUE;
		2292	}
		2293	if (overflow)
		2294	(*info->callbacks->einfo) (_("%P: .eh_frame_hdr entry overflow.\n"));
		2295	if (overlap)
		2296	(*info->callbacks->einfo)
		2297	(_("%P: .eh_frame_hdr refers to overlapping FDEs.\n"));
		2298	if (overflow \|\| overlap)
		2299	{
		2300	bfd_set_error (bfd_error_bad_value);
		2301	retval = FALSE;
5197	serge	2302	}
		2303	}
		2304
		2305	/* FIXME: octets_per_byte. */
6324	serge	2306	if (!bfd_set_section_contents (abfd, sec->output_section, contents,
5197	serge	2307	(file_ptr) sec->output_offset,
6324	serge	2308	sec->size))
		2309	retval = FALSE;
5197	serge	2310	free (contents);
6324	serge	2311
		2312	if (hdr_info->u.dwarf.array != NULL)
		2313	free (hdr_info->u.dwarf.array);
5197	serge	2314	return retval;
		2315	}
		2316
6324	serge	2317	/* Write out .eh_frame_hdr section. This must be called after
		2318	_bfd_elf_write_section_eh_frame has been called on all input
		2319	.eh_frame sections. */
		2320
		2321	bfd_boolean
		2322	_bfd_elf_write_section_eh_frame_hdr (bfd abfd, struct bfd_link_info info)
		2323	{
		2324	struct elf_link_hash_table *htab;
		2325	struct eh_frame_hdr_info *hdr_info;
		2326	asection *sec;
		2327
		2328	htab = elf_hash_table (info);
		2329	hdr_info = &htab->eh_info;
		2330	sec = hdr_info->hdr_sec;
		2331
		2332	if (info->eh_frame_hdr_type == 0 \|\| sec == NULL)
		2333	return TRUE;
		2334
		2335	if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
		2336	return write_compact_eh_frame_hdr (abfd, info);
		2337	else
		2338	return write_dwarf_eh_frame_hdr (abfd, info);
		2339	}
		2340
5197	serge	2341	/* Return the width of FDE addresses. This is the default implementation. */
		2342
		2343	unsigned int
		2344	_bfd_elf_eh_frame_address_size (bfd abfd, asection sec ATTRIBUTE_UNUSED)
		2345	{
		2346	return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
		2347	}
		2348
		2349	/* Decide whether we can use a PC-relative encoding within the given
		2350	EH frame section. This is the default implementation. */
		2351
		2352	bfd_boolean
		2353	_bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
		2354	struct bfd_link_info *info ATTRIBUTE_UNUSED,
		2355	asection *eh_frame_section ATTRIBUTE_UNUSED)
		2356	{
		2357	return TRUE;
		2358	}
		2359
		2360	/* Select an encoding for the given address. Preference is given to
		2361	PC-relative addressing modes. */
		2362
		2363	bfd_byte
		2364	_bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
		2365	struct bfd_link_info *info ATTRIBUTE_UNUSED,
		2366	asection *osec, bfd_vma offset,
		2367	asection *loc_sec, bfd_vma loc_offset,
		2368	bfd_vma *encoded)
		2369	{
		2370	*encoded = osec->vma + offset -
		2371	(loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
		2372	return DW_EH_PE_pcrel \| DW_EH_PE_sdata4;
		2373	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/bfd/elf-eh-frame.c – Rev 6324