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

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

Subversion Repositories Kolibri OS

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