WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/gas/dw2gencfi.c

Rev	Author	Line No.	Line
5222	serge	1	/* dw2gencfi.c - Support for generating Dwarf2 CFI information.
		2	Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
		3	Free Software Foundation, Inc.
		4	Contributed by Michal Ludvig
		5
		6	This file is part of GAS, the GNU Assembler.
		7
		8	GAS 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, or (at your option)
		11	any later version.
		12
		13	GAS 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 GAS; see the file COPYING. If not, write to the Free
		20	Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
		21	02110-1301, USA. */
		22
		23	#include "as.h"
		24	#include "dw2gencfi.h"
		25	#include "subsegs.h"
		26	#include "dwarf2dbg.h"
		27
		28	#ifdef TARGET_USE_CFIPOP
		29
		30	/* By default, use difference expressions if DIFF_EXPR_OK is defined. */
		31	#ifndef CFI_DIFF_EXPR_OK
		32	# ifdef DIFF_EXPR_OK
		33	# define CFI_DIFF_EXPR_OK 1
		34	# else
		35	# define CFI_DIFF_EXPR_OK 0
		36	# endif
		37	#endif
		38
		39	#ifndef CFI_DIFF_LSDA_OK
		40	#define CFI_DIFF_LSDA_OK CFI_DIFF_EXPR_OK
		41	#endif
		42
		43	#if CFI_DIFF_EXPR_OK == 1 && CFI_DIFF_LSDA_OK == 0
		44	# error "CFI_DIFF_EXPR_OK should imply CFI_DIFF_LSDA_OK"
		45	#endif
		46
		47	/* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
		48	of the CIE. Default to 1 if not otherwise specified. */
		49	#ifndef DWARF2_LINE_MIN_INSN_LENGTH
		50	#define DWARF2_LINE_MIN_INSN_LENGTH 1
		51	#endif
		52
		53	/* By default, use 32-bit relocations from .eh_frame into .text. */
		54	#ifndef DWARF2_FDE_RELOC_SIZE
		55	#define DWARF2_FDE_RELOC_SIZE 4
		56	#endif
		57
		58	/* By default, use a read-only .eh_frame section. */
		59	#ifndef DWARF2_EH_FRAME_READ_ONLY
		60	#define DWARF2_EH_FRAME_READ_ONLY SEC_READONLY
		61	#endif
		62
		63	#ifndef EH_FRAME_ALIGNMENT
		64	#define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
		65	#endif
		66
		67	#ifndef tc_cfi_frame_initial_instructions
		68	#define tc_cfi_frame_initial_instructions() ((void)0)
		69	#endif
		70
		71	#ifndef tc_cfi_startproc
		72	# define tc_cfi_startproc() ((void)0)
		73	#endif
		74
		75	#ifndef tc_cfi_endproc
		76	# define tc_cfi_endproc(fde) ((void) (fde))
		77	#endif
		78
		79	#ifndef DWARF2_FORMAT
		80	#define DWARF2_FORMAT(SEC) dwarf2_format_32bit
		81	#endif
		82
		83	#ifndef DWARF2_ADDR_SIZE
		84	#define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
		85	#endif
		86
		87	#if SUPPORT_FRAME_LINKONCE
		88	#define CUR_SEG(structp) structp->cur_seg
		89	#define SET_CUR_SEG(structp, seg) structp->cur_seg = seg
		90	#define HANDLED(structp) structp->handled
		91	#define SET_HANDLED(structp, val) structp->handled = val
		92	#else
		93	#define CUR_SEG(structp) NULL
		94	#define SET_CUR_SEG(structp, seg) (void) (0 && seg)
		95	#define HANDLED(structp) 0
		96	#define SET_HANDLED(structp, val) (void) (0 && val)
		97	#endif
		98
		99	/* Private segment collection list. */
		100	struct dwcfi_seg_list
		101	{
		102	segT seg;
		103	int subseg;
		104	char * seg_name;
		105	};
		106
		107	#define FRAME_NAME ".eh_frame"
		108
		109	static struct hash_control *dwcfi_hash;
		110
		111	/* Build based on segment the derived .debug_...
		112	segment name containing origin segment's postfix name part. */
		113
		114	static char *
		115	get_debugseg_name (segT seg, const char *base_name)
		116	{
		117	const char *name;
		118
		119	if (!seg)
		120	name = "";
		121	else
		122	{
		123	const char * dollar;
		124	const char * dot;
		125
		126	name = bfd_get_section_name (stdoutput, seg);
		127
		128	dollar = strchr (name, '$');
		129	dot = strchr (name + 1, '.');
		130
		131	if (!dollar && !dot)
		132	name = "";
		133	else if (!dollar)
		134	name = dot;
		135	else if (!dot)
		136	name = dollar;
		137	else if (dot < dollar)
		138	name = dot;
		139	else
		140	name = dollar;
		141	}
		142
		143	return concat (base_name, name, NULL);
		144	}
		145
		146	/* Allocate a dwcfi_seg_list structure. */
		147
		148	static struct dwcfi_seg_list *
		149	alloc_debugseg_item (segT seg, int subseg, char *name)
		150	{
		151	struct dwcfi_seg_list *r;
		152
		153	r = (struct dwcfi_seg_list *)
		154	xmalloc (sizeof (struct dwcfi_seg_list) + strlen (name));
		155	r->seg = seg;
		156	r->subseg = subseg;
		157	r->seg_name = name;
		158	return r;
		159	}
		160
		161	static segT
		162	is_now_linkonce_segment (void)
		163	{
		164	if ((bfd_get_section_flags (stdoutput, now_seg)
		165	& (SEC_LINK_ONCE \| SEC_LINK_DUPLICATES_DISCARD
		166	\| SEC_LINK_DUPLICATES_ONE_ONLY \| SEC_LINK_DUPLICATES_SAME_SIZE
		167	\| SEC_LINK_DUPLICATES_SAME_CONTENTS)) != 0)
		168	return now_seg;
		169	return NULL;
		170	}
		171
		172	/* Generate debug... segment with same linkonce properties
		173	of based segment. */
		174
		175	static segT
		176	make_debug_seg (segT cseg, char *name, int sflags)
		177	{
		178	segT save_seg = now_seg;
		179	int save_subseg = now_subseg;
		180	segT r;
		181	flagword flags;
		182
		183	r = subseg_new (name, 0);
		184
		185	/* Check if code segment is marked as linked once. */
		186	if (!cseg)
		187	flags = 0;
		188	else
		189	flags = bfd_get_section_flags (stdoutput, cseg)
		190	& (SEC_LINK_ONCE \| SEC_LINK_DUPLICATES_DISCARD
		191	\| SEC_LINK_DUPLICATES_ONE_ONLY \| SEC_LINK_DUPLICATES_SAME_SIZE
		192	\| SEC_LINK_DUPLICATES_SAME_CONTENTS);
		193
		194	/* Add standard section flags. */
		195	flags \|= sflags;
		196
		197	/* Apply possibly linked once flags to new generated segment, too. */
		198	if (!bfd_set_section_flags (stdoutput, r, flags))
		199	as_bad (_("bfd_set_section_flags: %s"),
		200	bfd_errmsg (bfd_get_error ()));
		201
		202	/* Restore to previous segment. */
		203	if (save_seg != NULL)
		204	subseg_set (save_seg, save_subseg);
		205	return r;
		206	}
		207
		208	static void
		209	dwcfi_hash_insert (const char name, struct dwcfi_seg_list item)
		210	{
		211	const char *error_string;
		212
		213	if ((error_string = hash_jam (dwcfi_hash, name, (char *) item)))
		214	as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
		215	name, error_string);
		216	}
		217
		218	static struct dwcfi_seg_list *
		219	dwcfi_hash_find (char *name)
		220	{
		221	return (struct dwcfi_seg_list *) hash_find (dwcfi_hash, name);
		222	}
		223
		224	static struct dwcfi_seg_list *
		225	dwcfi_hash_find_or_make (segT cseg, const char *base_name, int flags)
		226	{
		227	struct dwcfi_seg_list *item;
		228	char *name;
		229
		230	/* Initialize dwcfi_hash once. */
		231	if (!dwcfi_hash)
		232	dwcfi_hash = hash_new ();
		233
		234	name = get_debugseg_name (cseg, base_name);
		235
		236	item = dwcfi_hash_find (name);
		237	if (!item)
		238	{
		239	item = alloc_debugseg_item (make_debug_seg (cseg, name, flags), 0, name);
		240
		241	dwcfi_hash_insert (item->seg_name, item);
		242	}
		243	else
		244	free (name);
		245
		246	return item;
		247	}
		248
		249	/* ??? Share this with dwarf2cfg.c. */
		250	#ifndef TC_DWARF2_EMIT_OFFSET
		251	#define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
		252
		253	/* Create an offset to .dwarf2_. /
		254
		255	static void
		256	generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
		257	{
		258	expressionS exp;
		259
		260	exp.X_op = O_symbol;
		261	exp.X_add_symbol = symbol;
		262	exp.X_add_number = 0;
		263	emit_expr (&exp, size);
		264	}
		265	#endif
		266
		267	struct cfi_escape_data
		268	{
		269	struct cfi_escape_data *next;
		270	expressionS exp;
		271	};
		272
		273	struct cie_entry
		274	{
		275	struct cie_entry *next;
		276	#if SUPPORT_FRAME_LINKONCE
		277	segT cur_seg;
		278	#endif
		279	symbolS *start_address;
		280	unsigned int return_column;
		281	unsigned int signal_frame;
		282	unsigned char per_encoding;
		283	unsigned char lsda_encoding;
		284	expressionS personality;
		285	struct cfi_insn_data first, last;
		286	};
		287
		288	/* List of FDE entries. */
		289
		290	struct fde_entry *all_fde_data;
		291	static struct fde_entry **last_fde_data = &all_fde_data;
		292
		293	/* List of CIEs so that they could be reused. */
		294	static struct cie_entry *cie_root;
		295
		296	/* Stack of old CFI data, for save/restore. */
		297	struct cfa_save_data
		298	{
		299	struct cfa_save_data *next;
		300	offsetT cfa_offset;
		301	};
		302
		303	/* Current open FDE entry. */
		304	struct frch_cfi_data
		305	{
		306	struct fde_entry *cur_fde_data;
		307	symbolS *last_address;
		308	offsetT cur_cfa_offset;
		309	struct cfa_save_data *cfa_save_stack;
		310	};
		311
		312	/* Construct a new FDE structure and add it to the end of the fde list. */
		313
		314	static struct fde_entry *
		315	alloc_fde_entry (void)
		316	{
		317	struct fde_entry fde = (struct fde_entry )
		318	xcalloc (1, sizeof (struct fde_entry));
		319
		320	frchain_now->frch_cfi_data = (struct frch_cfi_data *)
		321	xcalloc (1, sizeof (struct frch_cfi_data));
		322	frchain_now->frch_cfi_data->cur_fde_data = fde;
		323	*last_fde_data = fde;
		324	last_fde_data = &fde->next;
		325	SET_CUR_SEG (fde, is_now_linkonce_segment ());
		326	SET_HANDLED (fde, 0);
		327	fde->last = &fde->data;
		328	fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
		329	fde->per_encoding = DW_EH_PE_omit;
		330	fde->lsda_encoding = DW_EH_PE_omit;
		331
		332	return fde;
		333	}
		334
		335	/* The following functions are available for a backend to construct its
		336	own unwind information, usually from legacy unwind directives. */
		337
		338	/* Construct a new INSN structure and add it to the end of the insn list
		339	for the currently active FDE. */
		340
		341	static struct cfi_insn_data *
		342	alloc_cfi_insn_data (void)
		343	{
		344	struct cfi_insn_data insn = (struct cfi_insn_data )
		345	xcalloc (1, sizeof (struct cfi_insn_data));
		346	struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data;
		347
		348	*cur_fde_data->last = insn;
		349	cur_fde_data->last = &insn->next;
		350	SET_CUR_SEG (insn, is_now_linkonce_segment ());
		351	return insn;
		352	}
		353
		354	/* Construct a new FDE structure that begins at LABEL. */
		355
		356	void
		357	cfi_new_fde (symbolS *label)
		358	{
		359	struct fde_entry *fde = alloc_fde_entry ();
		360	fde->start_address = label;
		361	frchain_now->frch_cfi_data->last_address = label;
		362	}
		363
		364	/* End the currently open FDE. */
		365
		366	void
		367	cfi_end_fde (symbolS *label)
		368	{
		369	frchain_now->frch_cfi_data->cur_fde_data->end_address = label;
		370	free (frchain_now->frch_cfi_data);
		371	frchain_now->frch_cfi_data = NULL;
		372	}
		373
		374	/* Set the return column for the current FDE. */
		375
		376	void
		377	cfi_set_return_column (unsigned regno)
		378	{
		379	frchain_now->frch_cfi_data->cur_fde_data->return_column = regno;
		380	}
		381
		382	/* Universal functions to store new instructions. */
		383
		384	static void
		385	cfi_add_CFA_insn (int insn)
		386	{
		387	struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
		388
		389	insn_ptr->insn = insn;
		390	}
		391
		392	static void
		393	cfi_add_CFA_insn_reg (int insn, unsigned regno)
		394	{
		395	struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
		396
		397	insn_ptr->insn = insn;
		398	insn_ptr->u.r = regno;
		399	}
		400
		401	static void
		402	cfi_add_CFA_insn_offset (int insn, offsetT offset)
		403	{
		404	struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
		405
		406	insn_ptr->insn = insn;
		407	insn_ptr->u.i = offset;
		408	}
		409
		410	static void
		411	cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
		412	{
		413	struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
		414
		415	insn_ptr->insn = insn;
		416	insn_ptr->u.rr.reg1 = reg1;
		417	insn_ptr->u.rr.reg2 = reg2;
		418	}
		419
		420	static void
		421	cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
		422	{
		423	struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
		424
		425	insn_ptr->insn = insn;
		426	insn_ptr->u.ri.reg = regno;
		427	insn_ptr->u.ri.offset = offset;
		428	}
		429
		430	/* Add a CFI insn to advance the PC from the last address to LABEL. */
		431
		432	void
		433	cfi_add_advance_loc (symbolS *label)
		434	{
		435	struct cfi_insn_data *insn = alloc_cfi_insn_data ();
		436
		437	insn->insn = DW_CFA_advance_loc;
		438	insn->u.ll.lab1 = frchain_now->frch_cfi_data->last_address;
		439	insn->u.ll.lab2 = label;
		440
		441	frchain_now->frch_cfi_data->last_address = label;
		442	}
		443
		444	/* Add a DW_CFA_offset record to the CFI data. */
		445
		446	void
		447	cfi_add_CFA_offset (unsigned regno, offsetT offset)
		448	{
		449	unsigned int abs_data_align;
		450
		451	gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
		452	cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
		453
		454	abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
		455	? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
		456	if (offset % abs_data_align)
		457	as_bad (_("register save offset not a multiple of %u"), abs_data_align);
		458	}
		459
		460	/* Add a DW_CFA_def_cfa record to the CFI data. */
		461
		462	void
		463	cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
		464	{
		465	cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
		466	frchain_now->frch_cfi_data->cur_cfa_offset = offset;
		467	}
		468
		469	/* Add a DW_CFA_register record to the CFI data. */
		470
		471	void
		472	cfi_add_CFA_register (unsigned reg1, unsigned reg2)
		473	{
		474	cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
		475	}
		476
		477	/* Add a DW_CFA_def_cfa_register record to the CFI data. */
		478
		479	void
		480	cfi_add_CFA_def_cfa_register (unsigned regno)
		481	{
		482	cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
		483	}
		484
		485	/* Add a DW_CFA_def_cfa_offset record to the CFI data. */
		486
		487	void
		488	cfi_add_CFA_def_cfa_offset (offsetT offset)
		489	{
		490	cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
		491	frchain_now->frch_cfi_data->cur_cfa_offset = offset;
		492	}
		493
		494	void
		495	cfi_add_CFA_restore (unsigned regno)
		496	{
		497	cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
		498	}
		499
		500	void
		501	cfi_add_CFA_undefined (unsigned regno)
		502	{
		503	cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
		504	}
		505
		506	void
		507	cfi_add_CFA_same_value (unsigned regno)
		508	{
		509	cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
		510	}
		511
		512	void
		513	cfi_add_CFA_remember_state (void)
		514	{
		515	struct cfa_save_data *p;
		516
		517	cfi_add_CFA_insn (DW_CFA_remember_state);
		518
		519	p = (struct cfa_save_data ) xmalloc (sizeof (p));
		520	p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset;
		521	p->next = frchain_now->frch_cfi_data->cfa_save_stack;
		522	frchain_now->frch_cfi_data->cfa_save_stack = p;
		523	}
		524
		525	void
		526	cfi_add_CFA_restore_state (void)
		527	{
		528	struct cfa_save_data *p;
		529
		530	cfi_add_CFA_insn (DW_CFA_restore_state);
		531
		532	p = frchain_now->frch_cfi_data->cfa_save_stack;
		533	if (p)
		534	{
		535	frchain_now->frch_cfi_data->cur_cfa_offset = p->cfa_offset;
		536	frchain_now->frch_cfi_data->cfa_save_stack = p->next;
		537	free (p);
		538	}
		539	else
		540	as_bad (_("CFI state restore without previous remember"));
		541	}
		542
		543
		544	/* Parse CFI assembler directives. */
		545
		546	static void dot_cfi (int);
		547	static void dot_cfi_escape (int);
		548	static void dot_cfi_sections (int);
		549	static void dot_cfi_startproc (int);
		550	static void dot_cfi_endproc (int);
		551	static void dot_cfi_personality (int);
		552	static void dot_cfi_lsda (int);
		553	static void dot_cfi_val_encoded_addr (int);
		554
		555	const pseudo_typeS cfi_pseudo_table[] =
		556	{
		557	{ "cfi_sections", dot_cfi_sections, 0 },
		558	{ "cfi_startproc", dot_cfi_startproc, 0 },
		559	{ "cfi_endproc", dot_cfi_endproc, 0 },
		560	{ "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
		561	{ "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
		562	{ "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
		563	{ "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
		564	{ "cfi_offset", dot_cfi, DW_CFA_offset },
		565	{ "cfi_rel_offset", dot_cfi, CFI_rel_offset },
		566	{ "cfi_register", dot_cfi, DW_CFA_register },
		567	{ "cfi_return_column", dot_cfi, CFI_return_column },
		568	{ "cfi_restore", dot_cfi, DW_CFA_restore },
		569	{ "cfi_undefined", dot_cfi, DW_CFA_undefined },
		570	{ "cfi_same_value", dot_cfi, DW_CFA_same_value },
		571	{ "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
		572	{ "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
		573	{ "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
		574	{ "cfi_escape", dot_cfi_escape, 0 },
		575	{ "cfi_signal_frame", dot_cfi, CFI_signal_frame },
		576	{ "cfi_personality", dot_cfi_personality, 0 },
		577	{ "cfi_lsda", dot_cfi_lsda, 0 },
		578	{ "cfi_val_encoded_addr", dot_cfi_val_encoded_addr, 0 },
		579	{ NULL, NULL, 0 }
		580	};
		581
		582	static void
		583	cfi_parse_separator (void)
		584	{
		585	SKIP_WHITESPACE ();
		586	if (*input_line_pointer == ',')
		587	input_line_pointer++;
		588	else
		589	as_bad (_("missing separator"));
		590	}
		591
		592	#ifndef tc_parse_to_dw2regnum
		593	static void
		594	tc_parse_to_dw2regnum (expressionS *exp)
		595	{
		596	# ifdef tc_regname_to_dw2regnum
		597	SKIP_WHITESPACE ();
		598	if (is_name_beginner (*input_line_pointer)
		599	\|\| (*input_line_pointer == '%'
		600	&& is_name_beginner (*++input_line_pointer)))
		601	{
		602	char *name, c;
		603
		604	name = input_line_pointer;
		605	c = get_symbol_end ();
		606
		607	exp->X_op = O_constant;
		608	exp->X_add_number = tc_regname_to_dw2regnum (name);
		609
		610	*input_line_pointer = c;
		611	}
		612	else
		613	# endif
		614	expression_and_evaluate (exp);
		615	}
		616	#endif
		617
		618	static unsigned
		619	cfi_parse_reg (void)
		620	{
		621	int regno;
		622	expressionS exp;
		623
		624	tc_parse_to_dw2regnum (&exp);
		625	switch (exp.X_op)
		626	{
		627	case O_register:
		628	case O_constant:
		629	regno = exp.X_add_number;
		630	break;
		631
		632	default:
		633	regno = -1;
		634	break;
		635	}
		636
		637	if (regno < 0)
		638	{
		639	as_bad (_("bad register expression"));
		640	regno = 0;
		641	}
		642
		643	return regno;
		644	}
		645
		646	static offsetT
		647	cfi_parse_const (void)
		648	{
		649	return get_absolute_expression ();
		650	}
		651
		652	static void
		653	dot_cfi (int arg)
		654	{
		655	offsetT offset;
		656	unsigned reg1, reg2;
		657
		658	if (frchain_now->frch_cfi_data == NULL)
		659	{
		660	as_bad (_("CFI instruction used without previous .cfi_startproc"));
		661	ignore_rest_of_line ();
		662	return;
		663	}
		664
		665	/* If the last address was not at the current PC, advance to current. */
		666	if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
		667	\|\| S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
		668	!= frag_now_fix ())
		669	cfi_add_advance_loc (symbol_temp_new_now ());
		670
		671	switch (arg)
		672	{
		673	case DW_CFA_offset:
		674	reg1 = cfi_parse_reg ();
		675	cfi_parse_separator ();
		676	offset = cfi_parse_const ();
		677	cfi_add_CFA_offset (reg1, offset);
		678	break;
		679
		680	case CFI_rel_offset:
		681	reg1 = cfi_parse_reg ();
		682	cfi_parse_separator ();
		683	offset = cfi_parse_const ();
		684	cfi_add_CFA_offset (reg1,
		685	offset - frchain_now->frch_cfi_data->cur_cfa_offset);
		686	break;
		687
		688	case DW_CFA_def_cfa:
		689	reg1 = cfi_parse_reg ();
		690	cfi_parse_separator ();
		691	offset = cfi_parse_const ();
		692	cfi_add_CFA_def_cfa (reg1, offset);
		693	break;
		694
		695	case DW_CFA_register:
		696	reg1 = cfi_parse_reg ();
		697	cfi_parse_separator ();
		698	reg2 = cfi_parse_reg ();
		699	cfi_add_CFA_register (reg1, reg2);
		700	break;
		701
		702	case DW_CFA_def_cfa_register:
		703	reg1 = cfi_parse_reg ();
		704	cfi_add_CFA_def_cfa_register (reg1);
		705	break;
		706
		707	case DW_CFA_def_cfa_offset:
		708	offset = cfi_parse_const ();
		709	cfi_add_CFA_def_cfa_offset (offset);
		710	break;
		711
		712	case CFI_adjust_cfa_offset:
		713	offset = cfi_parse_const ();
		714	cfi_add_CFA_def_cfa_offset (frchain_now->frch_cfi_data->cur_cfa_offset
		715	+ offset);
		716	break;
		717
		718	case DW_CFA_restore:
		719	for (;;)
		720	{
		721	reg1 = cfi_parse_reg ();
		722	cfi_add_CFA_restore (reg1);
		723	SKIP_WHITESPACE ();
		724	if (*input_line_pointer != ',')
		725	break;
		726	++input_line_pointer;
		727	}
		728	break;
		729
		730	case DW_CFA_undefined:
		731	for (;;)
		732	{
		733	reg1 = cfi_parse_reg ();
		734	cfi_add_CFA_undefined (reg1);
		735	SKIP_WHITESPACE ();
		736	if (*input_line_pointer != ',')
		737	break;
		738	++input_line_pointer;
		739	}
		740	break;
		741
		742	case DW_CFA_same_value:
		743	reg1 = cfi_parse_reg ();
		744	cfi_add_CFA_same_value (reg1);
		745	break;
		746
		747	case CFI_return_column:
		748	reg1 = cfi_parse_reg ();
		749	cfi_set_return_column (reg1);
		750	break;
		751
		752	case DW_CFA_remember_state:
		753	cfi_add_CFA_remember_state ();
		754	break;
		755
		756	case DW_CFA_restore_state:
		757	cfi_add_CFA_restore_state ();
		758	break;
		759
		760	case DW_CFA_GNU_window_save:
		761	cfi_add_CFA_insn (DW_CFA_GNU_window_save);
		762	break;
		763
		764	case CFI_signal_frame:
		765	frchain_now->frch_cfi_data->cur_fde_data->signal_frame = 1;
		766	break;
		767
		768	default:
		769	abort ();
		770	}
		771
		772	demand_empty_rest_of_line ();
		773	}
		774
		775	static void
		776	dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
		777	{
		778	struct cfi_escape_data head, tail, e;
		779	struct cfi_insn_data *insn;
		780
		781	if (frchain_now->frch_cfi_data == NULL)
		782	{
		783	as_bad (_("CFI instruction used without previous .cfi_startproc"));
		784	ignore_rest_of_line ();
		785	return;
		786	}
		787
		788	/* If the last address was not at the current PC, advance to current. */
		789	if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
		790	\|\| S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
		791	!= frag_now_fix ())
		792	cfi_add_advance_loc (symbol_temp_new_now ());
		793
		794	tail = &head;
		795	do
		796	{
		797	e = (struct cfi_escape_data ) xmalloc (sizeof (e));
		798	do_parse_cons_expression (&e->exp, 1);
		799	*tail = e;
		800	tail = &e->next;
		801	}
		802	while (*input_line_pointer++ == ',');
		803	*tail = NULL;
		804
		805	insn = alloc_cfi_insn_data ();
		806	insn->insn = CFI_escape;
		807	insn->u.esc = head;
		808
		809	--input_line_pointer;
		810	demand_empty_rest_of_line ();
		811	}
		812
		813	static void
		814	dot_cfi_personality (int ignored ATTRIBUTE_UNUSED)
		815	{
		816	struct fde_entry *fde;
		817	offsetT encoding;
		818
		819	if (frchain_now->frch_cfi_data == NULL)
		820	{
		821	as_bad (_("CFI instruction used without previous .cfi_startproc"));
		822	ignore_rest_of_line ();
		823	return;
		824	}
		825
		826	fde = frchain_now->frch_cfi_data->cur_fde_data;
		827	encoding = cfi_parse_const ();
		828	if (encoding == DW_EH_PE_omit)
		829	{
		830	demand_empty_rest_of_line ();
		831	fde->per_encoding = encoding;
		832	return;
		833	}
		834
		835	if ((encoding & 0xff) != encoding
		836	\|\| ((encoding & 0x70) != 0
		837	#if CFI_DIFF_EXPR_OK \|\| defined tc_cfi_emit_pcrel_expr
		838	&& (encoding & 0x70) != DW_EH_PE_pcrel
		839	#endif
		840	)
		841	/* leb128 can be handled, but does something actually need it? */
		842	\|\| (encoding & 7) == DW_EH_PE_uleb128
		843	\|\| (encoding & 7) > DW_EH_PE_udata8)
		844	{
		845	as_bad (_("invalid or unsupported encoding in .cfi_personality"));
		846	ignore_rest_of_line ();
		847	return;
		848	}
		849
		850	if (*input_line_pointer++ != ',')
		851	{
		852	as_bad (_(".cfi_personality requires encoding and symbol arguments"));
		853	ignore_rest_of_line ();
		854	return;
		855	}
		856
		857	expression_and_evaluate (&fde->personality);
		858	switch (fde->personality.X_op)
		859	{
		860	case O_symbol:
		861	break;
		862	case O_constant:
		863	if ((encoding & 0x70) == DW_EH_PE_pcrel)
		864	encoding = DW_EH_PE_omit;
		865	break;
		866	default:
		867	encoding = DW_EH_PE_omit;
		868	break;
		869	}
		870
		871	fde->per_encoding = encoding;
		872
		873	if (encoding == DW_EH_PE_omit)
		874	{
		875	as_bad (_("wrong second argument to .cfi_personality"));
		876	ignore_rest_of_line ();
		877	return;
		878	}
		879
		880	demand_empty_rest_of_line ();
		881	}
		882
		883	static void
		884	dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED)
		885	{
		886	struct fde_entry *fde;
		887	offsetT encoding;
		888
		889	if (frchain_now->frch_cfi_data == NULL)
		890	{
		891	as_bad (_("CFI instruction used without previous .cfi_startproc"));
		892	ignore_rest_of_line ();
		893	return;
		894	}
		895
		896	fde = frchain_now->frch_cfi_data->cur_fde_data;
		897	encoding = cfi_parse_const ();
		898	if (encoding == DW_EH_PE_omit)
		899	{
		900	demand_empty_rest_of_line ();
		901	fde->lsda_encoding = encoding;
		902	return;
		903	}
		904
		905	if ((encoding & 0xff) != encoding
		906	\|\| ((encoding & 0x70) != 0
		907	#if CFI_DIFF_LSDA_OK \|\| defined tc_cfi_emit_pcrel_expr
		908	&& (encoding & 0x70) != DW_EH_PE_pcrel
		909	#endif
		910	)
		911	/* leb128 can be handled, but does something actually need it? */
		912	\|\| (encoding & 7) == DW_EH_PE_uleb128
		913	\|\| (encoding & 7) > DW_EH_PE_udata8)
		914	{
		915	as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
		916	ignore_rest_of_line ();
		917	return;
		918	}
		919
		920	if (*input_line_pointer++ != ',')
		921	{
		922	as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
		923	ignore_rest_of_line ();
		924	return;
		925	}
		926
		927	fde->lsda_encoding = encoding;
		928
		929	expression_and_evaluate (&fde->lsda);
		930	switch (fde->lsda.X_op)
		931	{
		932	case O_symbol:
		933	break;
		934	case O_constant:
		935	if ((encoding & 0x70) == DW_EH_PE_pcrel)
		936	encoding = DW_EH_PE_omit;
		937	break;
		938	default:
		939	encoding = DW_EH_PE_omit;
		940	break;
		941	}
		942
		943	fde->lsda_encoding = encoding;
		944
		945	if (encoding == DW_EH_PE_omit)
		946	{
		947	as_bad (_("wrong second argument to .cfi_lsda"));
		948	ignore_rest_of_line ();
		949	return;
		950	}
		951
		952	demand_empty_rest_of_line ();
		953	}
		954
		955	static void
		956	dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED)
		957	{
		958	struct cfi_insn_data *insn_ptr;
		959	offsetT encoding;
		960
		961	if (frchain_now->frch_cfi_data == NULL)
		962	{
		963	as_bad (_("CFI instruction used without previous .cfi_startproc"));
		964	ignore_rest_of_line ();
		965	return;
		966	}
		967
		968	/* If the last address was not at the current PC, advance to current. */
		969	if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
		970	\|\| S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
		971	!= frag_now_fix ())
		972	cfi_add_advance_loc (symbol_temp_new_now ());
		973
		974	insn_ptr = alloc_cfi_insn_data ();
		975	insn_ptr->insn = CFI_val_encoded_addr;
		976
		977	insn_ptr->u.ea.reg = cfi_parse_reg ();
		978
		979	cfi_parse_separator ();
		980	encoding = cfi_parse_const ();
		981	if ((encoding & 0xff) != encoding
		982	\|\| ((encoding & 0x70) != 0
		983	#if CFI_DIFF_EXPR_OK \|\| defined tc_cfi_emit_pcrel_expr
		984	&& (encoding & 0x70) != DW_EH_PE_pcrel
		985	#endif
		986	)
		987	/* leb128 can be handled, but does something actually need it? */
		988	\|\| (encoding & 7) == DW_EH_PE_uleb128
		989	\|\| (encoding & 7) > DW_EH_PE_udata8)
		990	{
		991	as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
		992	encoding = DW_EH_PE_omit;
		993	}
		994
		995	cfi_parse_separator ();
		996	expression_and_evaluate (&insn_ptr->u.ea.exp);
		997	switch (insn_ptr->u.ea.exp.X_op)
		998	{
		999	case O_symbol:
		1000	break;
		1001	case O_constant:
		1002	if ((encoding & 0x70) != DW_EH_PE_pcrel)
		1003	break;
		1004	default:
		1005	encoding = DW_EH_PE_omit;
		1006	break;
		1007	}
		1008
		1009	insn_ptr->u.ea.encoding = encoding;
		1010	if (encoding == DW_EH_PE_omit)
		1011	{
		1012	as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
		1013	ignore_rest_of_line ();
		1014	return;
		1015	}
		1016
		1017	demand_empty_rest_of_line ();
		1018	}
		1019
		1020	/* By default emit .eh_frame only, not .debug_frame. */
		1021	#define CFI_EMIT_eh_frame (1 << 0)
		1022	#define CFI_EMIT_debug_frame (1 << 1)
		1023	#define CFI_EMIT_target (1 << 2)
		1024	static int cfi_sections = CFI_EMIT_eh_frame;
		1025
		1026	static void
		1027	dot_cfi_sections (int ignored ATTRIBUTE_UNUSED)
		1028	{
		1029	int sections = 0;
		1030
		1031	SKIP_WHITESPACE ();
		1032	if (is_name_beginner (*input_line_pointer))
		1033	while (1)
		1034	{
		1035	char *name, c;
		1036
		1037	name = input_line_pointer;
		1038	c = get_symbol_end ();
		1039
		1040	if (strncmp (name, ".eh_frame", sizeof ".eh_frame") == 0
		1041	&& name[9] != '_')
		1042	sections \|= CFI_EMIT_eh_frame;
		1043	else if (strncmp (name, ".debug_frame", sizeof ".debug_frame") == 0)
		1044	sections \|= CFI_EMIT_debug_frame;
		1045	#ifdef tc_cfi_section_name
		1046	else if (strcmp (name, tc_cfi_section_name) == 0)
		1047	sections \|= CFI_EMIT_target;
		1048	#endif
		1049	else
		1050	{
		1051	*input_line_pointer = c;
		1052	input_line_pointer = name;
		1053	break;
		1054	}
		1055
		1056	*input_line_pointer = c;
		1057	SKIP_WHITESPACE ();
		1058	if (*input_line_pointer == ',')
		1059	{
		1060	name = input_line_pointer++;
		1061	SKIP_WHITESPACE ();
		1062	if (!is_name_beginner (*input_line_pointer))
		1063	{
		1064	input_line_pointer = name;
		1065	break;
		1066	}
		1067	}
		1068	else if (is_name_beginner (*input_line_pointer))
		1069	break;
		1070	}
		1071
		1072	demand_empty_rest_of_line ();
		1073	cfi_sections = sections;
		1074	}
		1075
		1076	static void
		1077	dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
		1078	{
		1079	int simple = 0;
		1080
		1081	if (frchain_now->frch_cfi_data != NULL)
		1082	{
		1083	as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
		1084	ignore_rest_of_line ();
		1085	return;
		1086	}
		1087
		1088	cfi_new_fde (symbol_temp_new_now ());
		1089
		1090	SKIP_WHITESPACE ();
		1091	if (is_name_beginner (*input_line_pointer))
		1092	{
		1093	char *name, c;
		1094
		1095	name = input_line_pointer;
		1096	c = get_symbol_end ();
		1097
		1098	if (strcmp (name, "simple") == 0)
		1099	{
		1100	simple = 1;
		1101	*input_line_pointer = c;
		1102	}
		1103	else
		1104	input_line_pointer = name;
		1105	}
		1106	demand_empty_rest_of_line ();
		1107
		1108	frchain_now->frch_cfi_data->cur_cfa_offset = 0;
		1109	if (!simple)
		1110	tc_cfi_frame_initial_instructions ();
		1111
		1112	if ((cfi_sections & CFI_EMIT_target) != 0)
		1113	tc_cfi_startproc ();
		1114	}
		1115
		1116	static void
		1117	dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
		1118	{
		1119	struct fde_entry *fde;
		1120
		1121	if (frchain_now->frch_cfi_data == NULL)
		1122	{
		1123	as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
		1124	ignore_rest_of_line ();
		1125	return;
		1126	}
		1127
		1128	fde = frchain_now->frch_cfi_data->cur_fde_data;
		1129
		1130	cfi_end_fde (symbol_temp_new_now ());
		1131
		1132	demand_empty_rest_of_line ();
		1133
		1134	if ((cfi_sections & CFI_EMIT_target) != 0)
		1135	tc_cfi_endproc (fde);
		1136	}
		1137
		1138
		1139	/* Emit a single byte into the current segment. */
		1140
		1141	static inline void
		1142	out_one (int byte)
		1143	{
		1144	FRAG_APPEND_1_CHAR (byte);
		1145	}
		1146
		1147	/* Emit a two-byte word into the current segment. */
		1148
		1149	static inline void
		1150	out_two (int data)
		1151	{
		1152	md_number_to_chars (frag_more (2), data, 2);
		1153	}
		1154
		1155	/* Emit a four byte word into the current segment. */
		1156
		1157	static inline void
		1158	out_four (int data)
		1159	{
		1160	md_number_to_chars (frag_more (4), data, 4);
		1161	}
		1162
		1163	/* Emit an unsigned "little-endian base 128" number. */
		1164
		1165	static void
		1166	out_uleb128 (addressT value)
		1167	{
		1168	output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
		1169	}
		1170
		1171	/* Emit an unsigned "little-endian base 128" number. */
		1172
		1173	static void
		1174	out_sleb128 (offsetT value)
		1175	{
		1176	output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
		1177	}
		1178
		1179	static void
		1180	output_cfi_insn (struct cfi_insn_data *insn)
		1181	{
		1182	offsetT offset;
		1183	unsigned int regno;
		1184
		1185	switch (insn->insn)
		1186	{
		1187	case DW_CFA_advance_loc:
		1188	{
		1189	symbolS *from = insn->u.ll.lab1;
		1190	symbolS *to = insn->u.ll.lab2;
		1191
		1192	if (symbol_get_frag (to) == symbol_get_frag (from))
		1193	{
		1194	addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
		1195	addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
		1196
		1197	if (scaled <= 0x3F)
		1198	out_one (DW_CFA_advance_loc + scaled);
		1199	else if (scaled <= 0xFF)
		1200	{
		1201	out_one (DW_CFA_advance_loc1);
		1202	out_one (scaled);
		1203	}
		1204	else if (scaled <= 0xFFFF)
		1205	{
		1206	out_one (DW_CFA_advance_loc2);
		1207	out_two (scaled);
		1208	}
		1209	else
		1210	{
		1211	out_one (DW_CFA_advance_loc4);
		1212	out_four (scaled);
		1213	}
		1214	}
		1215	else
		1216	{
		1217	expressionS exp;
		1218
		1219	exp.X_op = O_subtract;
		1220	exp.X_add_symbol = to;
		1221	exp.X_op_symbol = from;
		1222	exp.X_add_number = 0;
		1223
		1224	/* The code in ehopt.c expects that one byte of the encoding
		1225	is already allocated to the frag. This comes from the way
		1226	that it scans the .eh_frame section looking first for the
		1227	.byte DW_CFA_advance_loc4. */
		1228	*frag_more (1) = DW_CFA_advance_loc4;
		1229
		1230	frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
		1231	make_expr_symbol (&exp), frag_now_fix () - 1,
		1232	(char *) frag_now);
		1233	}
		1234	}
		1235	break;
		1236
		1237	case DW_CFA_def_cfa:
		1238	offset = insn->u.ri.offset;
		1239	if (offset < 0)
		1240	{
		1241	out_one (DW_CFA_def_cfa_sf);
		1242	out_uleb128 (insn->u.ri.reg);
		1243	out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
		1244	}
		1245	else
		1246	{
		1247	out_one (DW_CFA_def_cfa);
		1248	out_uleb128 (insn->u.ri.reg);
		1249	out_uleb128 (offset);
		1250	}
		1251	break;
		1252
		1253	case DW_CFA_def_cfa_register:
		1254	case DW_CFA_undefined:
		1255	case DW_CFA_same_value:
		1256	out_one (insn->insn);
		1257	out_uleb128 (insn->u.r);
		1258	break;
		1259
		1260	case DW_CFA_def_cfa_offset:
		1261	offset = insn->u.i;
		1262	if (offset < 0)
		1263	{
		1264	out_one (DW_CFA_def_cfa_offset_sf);
		1265	out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
		1266	}
		1267	else
		1268	{
		1269	out_one (DW_CFA_def_cfa_offset);
		1270	out_uleb128 (offset);
		1271	}
		1272	break;
		1273
		1274	case DW_CFA_restore:
		1275	regno = insn->u.r;
		1276	if (regno <= 0x3F)
		1277	{
		1278	out_one (DW_CFA_restore + regno);
		1279	}
		1280	else
		1281	{
		1282	out_one (DW_CFA_restore_extended);
		1283	out_uleb128 (regno);
		1284	}
		1285	break;
		1286
		1287	case DW_CFA_offset:
		1288	regno = insn->u.ri.reg;
		1289	offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
		1290	if (offset < 0)
		1291	{
		1292	out_one (DW_CFA_offset_extended_sf);
		1293	out_uleb128 (regno);
		1294	out_sleb128 (offset);
		1295	}
		1296	else if (regno <= 0x3F)
		1297	{
		1298	out_one (DW_CFA_offset + regno);
		1299	out_uleb128 (offset);
		1300	}
		1301	else
		1302	{
		1303	out_one (DW_CFA_offset_extended);
		1304	out_uleb128 (regno);
		1305	out_uleb128 (offset);
		1306	}
		1307	break;
		1308
		1309	case DW_CFA_register:
		1310	out_one (DW_CFA_register);
		1311	out_uleb128 (insn->u.rr.reg1);
		1312	out_uleb128 (insn->u.rr.reg2);
		1313	break;
		1314
		1315	case DW_CFA_remember_state:
		1316	case DW_CFA_restore_state:
		1317	out_one (insn->insn);
		1318	break;
		1319
		1320	case DW_CFA_GNU_window_save:
		1321	out_one (DW_CFA_GNU_window_save);
		1322	break;
		1323
		1324	case CFI_escape:
		1325	{
		1326	struct cfi_escape_data *e;
		1327	for (e = insn->u.esc; e ; e = e->next)
		1328	emit_expr (&e->exp, 1);
		1329	break;
		1330	}
		1331
		1332	case CFI_val_encoded_addr:
		1333	{
		1334	unsigned encoding = insn->u.ea.encoding;
		1335	offsetT encoding_size;
		1336
		1337	if (encoding == DW_EH_PE_omit)
		1338	break;
		1339	out_one (DW_CFA_val_expression);
		1340	out_uleb128 (insn->u.ea.reg);
		1341
		1342	switch (encoding & 0x7)
		1343	{
		1344	case DW_EH_PE_absptr:
		1345	encoding_size = DWARF2_ADDR_SIZE (stdoutput);
		1346	break;
		1347	case DW_EH_PE_udata2:
		1348	encoding_size = 2;
		1349	break;
		1350	case DW_EH_PE_udata4:
		1351	encoding_size = 4;
		1352	break;
		1353	case DW_EH_PE_udata8:
		1354	encoding_size = 8;
		1355	break;
		1356	default:
		1357	abort ();
		1358	}
		1359
		1360	/* If the user has requested absolute encoding,
		1361	then use the smaller DW_OP_addr encoding. */
		1362	if (insn->u.ea.encoding == DW_EH_PE_absptr)
		1363	{
		1364	out_uleb128 (1 + encoding_size);
		1365	out_one (DW_OP_addr);
		1366	}
		1367	else
		1368	{
		1369	out_uleb128 (1 + 1 + encoding_size);
		1370	out_one (DW_OP_GNU_encoded_addr);
		1371	out_one (encoding);
		1372
		1373	if ((encoding & 0x70) == DW_EH_PE_pcrel)
		1374	{
		1375	#if CFI_DIFF_EXPR_OK
		1376	insn->u.ea.exp.X_op = O_subtract;
		1377	insn->u.ea.exp.X_op_symbol = symbol_temp_new_now ();
		1378	#elif defined (tc_cfi_emit_pcrel_expr)
		1379	tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, encoding_size);
		1380	break;
		1381	#else
		1382	abort ();
		1383	#endif
		1384	}
		1385	}
		1386	emit_expr (&insn->u.ea.exp, encoding_size);
		1387	}
		1388	break;
		1389
		1390	default:
		1391	abort ();
		1392	}
		1393	}
		1394
		1395	static offsetT
		1396	encoding_size (unsigned char encoding)
		1397	{
		1398	if (encoding == DW_EH_PE_omit)
		1399	return 0;
		1400	switch (encoding & 0x7)
		1401	{
		1402	case 0:
		1403	return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4;
		1404	case DW_EH_PE_udata2:
		1405	return 2;
		1406	case DW_EH_PE_udata4:
		1407	return 4;
		1408	case DW_EH_PE_udata8:
		1409	return 8;
		1410	default:
		1411	abort ();
		1412	}
		1413	}
		1414
		1415	static void
		1416	output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align)
		1417	{
		1418	symbolS after_size_address, end_address;
		1419	expressionS exp;
		1420	struct cfi_insn_data *i;
		1421	offsetT augmentation_size;
		1422	int enc;
		1423	enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
		1424
		1425	cie->start_address = symbol_temp_new_now ();
		1426	after_size_address = symbol_temp_make ();
		1427	end_address = symbol_temp_make ();
		1428
		1429	exp.X_op = O_subtract;
		1430	exp.X_add_symbol = end_address;
		1431	exp.X_op_symbol = after_size_address;
		1432	exp.X_add_number = 0;
		1433
		1434	if (eh_frame \|\| fmt == dwarf2_format_32bit)
		1435	emit_expr (&exp, 4); /* Length. */
		1436	else
		1437	{
		1438	if (fmt == dwarf2_format_64bit)
		1439	out_four (-1);
		1440	emit_expr (&exp, 8); /* Length. */
		1441	}
		1442	symbol_set_value_now (after_size_address);
		1443	if (eh_frame)
		1444	out_four (0); /* CIE id. */
		1445	else
		1446	{
		1447	out_four (-1); /* CIE id. */
		1448	if (fmt != dwarf2_format_32bit)
		1449	out_four (-1);
		1450	}
		1451	out_one (DW_CIE_VERSION); /* Version. */
		1452	if (eh_frame)
		1453	{
		1454	out_one ('z'); /* Augmentation. */
		1455	if (cie->per_encoding != DW_EH_PE_omit)
		1456	out_one ('P');
		1457	if (cie->lsda_encoding != DW_EH_PE_omit)
		1458	out_one ('L');
		1459	out_one ('R');
		1460	}
		1461	if (cie->signal_frame)
		1462	out_one ('S');
		1463	out_one (0);
		1464	out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH); /* Code alignment. */
		1465	out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT); /* Data alignment. */
		1466	if (DW_CIE_VERSION == 1) /* Return column. */
		1467	out_one (cie->return_column);
		1468	else
		1469	out_uleb128 (cie->return_column);
		1470	if (eh_frame)
		1471	{
		1472	augmentation_size = 1 + (cie->lsda_encoding != DW_EH_PE_omit);
		1473	if (cie->per_encoding != DW_EH_PE_omit)
		1474	augmentation_size += 1 + encoding_size (cie->per_encoding);
		1475	out_uleb128 (augmentation_size); /* Augmentation size. */
		1476
		1477	if (cie->per_encoding != DW_EH_PE_omit)
		1478	{
		1479	offsetT size = encoding_size (cie->per_encoding);
		1480	out_one (cie->per_encoding);
		1481	exp = cie->personality;
		1482	if ((cie->per_encoding & 0x70) == DW_EH_PE_pcrel)
		1483	{
		1484	#if CFI_DIFF_EXPR_OK
		1485	exp.X_op = O_subtract;
		1486	exp.X_op_symbol = symbol_temp_new_now ();
		1487	emit_expr (&exp, size);
		1488	#elif defined (tc_cfi_emit_pcrel_expr)
		1489	tc_cfi_emit_pcrel_expr (&exp, size);
		1490	#else
		1491	abort ();
		1492	#endif
		1493	}
		1494	else
		1495	emit_expr (&exp, size);
		1496	}
		1497
		1498	if (cie->lsda_encoding != DW_EH_PE_omit)
		1499	out_one (cie->lsda_encoding);
		1500	}
		1501
		1502	switch (DWARF2_FDE_RELOC_SIZE)
		1503	{
		1504	case 2:
		1505	enc = DW_EH_PE_sdata2;
		1506	break;
		1507	case 4:
		1508	enc = DW_EH_PE_sdata4;
		1509	break;
		1510	case 8:
		1511	enc = DW_EH_PE_sdata8;
		1512	break;
		1513	default:
		1514	abort ();
		1515	}
		1516	#if CFI_DIFF_EXPR_OK \|\| defined tc_cfi_emit_pcrel_expr
		1517	enc \|= DW_EH_PE_pcrel;
		1518	#endif
		1519	if (eh_frame)
		1520	out_one (enc);
		1521
		1522	if (cie->first)
		1523	{
		1524	for (i = cie->first; i != cie->last; i = i->next)
		1525	{
		1526	if (CUR_SEG (i) != CUR_SEG (cie))
		1527	continue;
		1528	output_cfi_insn (i);
		1529	}
		1530	}
		1531
		1532	frag_align (align, DW_CFA_nop, 0);
		1533	symbol_set_value_now (end_address);
		1534	}
		1535
		1536	static void
		1537	output_fde (struct fde_entry fde, struct cie_entry cie,
		1538	bfd_boolean eh_frame, struct cfi_insn_data *first,
		1539	int align)
		1540	{
		1541	symbolS after_size_address, end_address;
		1542	expressionS exp;
		1543	offsetT augmentation_size;
		1544	enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
		1545	int offset_size;
		1546	int addr_size;
		1547
		1548	after_size_address = symbol_temp_make ();
		1549	end_address = symbol_temp_make ();
		1550
		1551	exp.X_op = O_subtract;
		1552	exp.X_add_symbol = end_address;
		1553	exp.X_op_symbol = after_size_address;
		1554	exp.X_add_number = 0;
		1555	if (eh_frame \|\| fmt == dwarf2_format_32bit)
		1556	offset_size = 4;
		1557	else
		1558	{
		1559	if (fmt == dwarf2_format_64bit)
		1560	out_four (-1);
		1561	offset_size = 8;
		1562	}
		1563	emit_expr (&exp, offset_size); /* Length. */
		1564	symbol_set_value_now (after_size_address);
		1565
		1566	if (eh_frame)
		1567	{
		1568	exp.X_op = O_subtract;
		1569	exp.X_add_symbol = after_size_address;
		1570	exp.X_op_symbol = cie->start_address;
		1571	exp.X_add_number = 0;
		1572	emit_expr (&exp, offset_size); /* CIE offset. */
		1573	}
		1574	else
		1575	{
		1576	TC_DWARF2_EMIT_OFFSET (cie->start_address, offset_size);
		1577	}
		1578
		1579	if (eh_frame)
		1580	{
		1581	exp.X_op = O_subtract;
		1582	exp.X_add_number = 0;
		1583	#if CFI_DIFF_EXPR_OK
		1584	exp.X_add_symbol = fde->start_address;
		1585	exp.X_op_symbol = symbol_temp_new_now ();
		1586	emit_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */
		1587	#else
		1588	exp.X_op = O_symbol;
		1589	exp.X_add_symbol = fde->start_address;
		1590	#ifdef tc_cfi_emit_pcrel_expr
		1591	tc_cfi_emit_pcrel_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */
		1592	#else
		1593	emit_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */
		1594	#endif
		1595	#endif
		1596	addr_size = DWARF2_FDE_RELOC_SIZE;
		1597	}
		1598	else
		1599	{
		1600	exp.X_op = O_symbol;
		1601	exp.X_add_symbol = fde->start_address;
		1602	exp.X_add_number = 0;
		1603	addr_size = DWARF2_ADDR_SIZE (stdoutput);
		1604	emit_expr (&exp, addr_size);
		1605	}
		1606
		1607	exp.X_op = O_subtract;
		1608	exp.X_add_symbol = fde->end_address;
		1609	exp.X_op_symbol = fde->start_address; /* Code length. */
		1610	exp.X_add_number = 0;
		1611	emit_expr (&exp, addr_size);
		1612
		1613	augmentation_size = encoding_size (fde->lsda_encoding);
		1614	if (eh_frame)
		1615	out_uleb128 (augmentation_size); /* Augmentation size. */
		1616
		1617	if (fde->lsda_encoding != DW_EH_PE_omit)
		1618	{
		1619	exp = fde->lsda;
		1620	if ((fde->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
		1621	{
		1622	#if CFI_DIFF_LSDA_OK
		1623	exp.X_op = O_subtract;
		1624	exp.X_op_symbol = symbol_temp_new_now ();
		1625	emit_expr (&exp, augmentation_size);
		1626	#elif defined (tc_cfi_emit_pcrel_expr)
		1627	tc_cfi_emit_pcrel_expr (&exp, augmentation_size);
		1628	#else
		1629	abort ();
		1630	#endif
		1631	}
		1632	else
		1633	emit_expr (&exp, augmentation_size);
		1634	}
		1635
		1636	for (; first; first = first->next)
		1637	if (CUR_SEG (first) == CUR_SEG (fde))
		1638	output_cfi_insn (first);
		1639
		1640	frag_align (align, DW_CFA_nop, 0);
		1641	symbol_set_value_now (end_address);
		1642	}
		1643
		1644	static struct cie_entry *
		1645	select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame,
		1646	struct cfi_insn_data **pfirst, int align)
		1647	{
		1648	struct cfi_insn_data i, j;
		1649	struct cie_entry *cie;
		1650
		1651	for (cie = cie_root; cie; cie = cie->next)
		1652	{
		1653	if (CUR_SEG (cie) != CUR_SEG (fde))
		1654	continue;
		1655	if (cie->return_column != fde->return_column
		1656	\|\| cie->signal_frame != fde->signal_frame
		1657	\|\| cie->per_encoding != fde->per_encoding
		1658	\|\| cie->lsda_encoding != fde->lsda_encoding)
		1659	continue;
		1660	if (cie->per_encoding != DW_EH_PE_omit)
		1661	{
		1662	if (cie->personality.X_op != fde->personality.X_op
		1663	\|\| cie->personality.X_add_number
		1664	!= fde->personality.X_add_number)
		1665	continue;
		1666	switch (cie->personality.X_op)
		1667	{
		1668	case O_constant:
		1669	if (cie->personality.X_unsigned != fde->personality.X_unsigned)
		1670	continue;
		1671	break;
		1672	case O_symbol:
		1673	if (cie->personality.X_add_symbol
		1674	!= fde->personality.X_add_symbol)
		1675	continue;
		1676	break;
		1677	default:
		1678	abort ();
		1679	}
		1680	}
		1681	for (i = cie->first, j = fde->data;
		1682	i != cie->last && j != NULL;
		1683	i = i->next, j = j->next)
		1684	{
		1685	if (i->insn != j->insn)
		1686	goto fail;
		1687	switch (i->insn)
		1688	{
		1689	case DW_CFA_advance_loc:
		1690	case DW_CFA_remember_state:
		1691	/* We reached the first advance/remember in the FDE,
		1692	but did not reach the end of the CIE list. */
		1693	goto fail;
		1694
		1695	case DW_CFA_offset:
		1696	case DW_CFA_def_cfa:
		1697	if (i->u.ri.reg != j->u.ri.reg)
		1698	goto fail;
		1699	if (i->u.ri.offset != j->u.ri.offset)
		1700	goto fail;
		1701	break;
		1702
		1703	case DW_CFA_register:
		1704	if (i->u.rr.reg1 != j->u.rr.reg1)
		1705	goto fail;
		1706	if (i->u.rr.reg2 != j->u.rr.reg2)
		1707	goto fail;
		1708	break;
		1709
		1710	case DW_CFA_def_cfa_register:
		1711	case DW_CFA_restore:
		1712	case DW_CFA_undefined:
		1713	case DW_CFA_same_value:
		1714	if (i->u.r != j->u.r)
		1715	goto fail;
		1716	break;
		1717
		1718	case DW_CFA_def_cfa_offset:
		1719	if (i->u.i != j->u.i)
		1720	goto fail;
		1721	break;
		1722
		1723	case CFI_escape:
		1724	case CFI_val_encoded_addr:
		1725	/* Don't bother matching these for now. */
		1726	goto fail;
		1727
		1728	default:
		1729	abort ();
		1730	}
		1731	}
		1732
		1733	/* Success if we reached the end of the CIE list, and we've either
		1734	run out of FDE entries or we've encountered an advance,
		1735	remember, or escape. */
		1736	if (i == cie->last
		1737	&& (!j
		1738	\|\| j->insn == DW_CFA_advance_loc
		1739	\|\| j->insn == DW_CFA_remember_state
		1740	\|\| j->insn == CFI_escape
		1741	\|\| j->insn == CFI_val_encoded_addr))
		1742	{
		1743	*pfirst = j;
		1744	return cie;
		1745	}
		1746
		1747	fail:;
		1748	}
		1749
		1750	cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry));
		1751	cie->next = cie_root;
		1752	cie_root = cie;
		1753	SET_CUR_SEG (cie, CUR_SEG (fde));
		1754	cie->return_column = fde->return_column;
		1755	cie->signal_frame = fde->signal_frame;
		1756	cie->per_encoding = fde->per_encoding;
		1757	cie->lsda_encoding = fde->lsda_encoding;
		1758	cie->personality = fde->personality;
		1759	cie->first = fde->data;
		1760
		1761	for (i = cie->first; i ; i = i->next)
		1762	if (i->insn == DW_CFA_advance_loc
		1763	\|\| i->insn == DW_CFA_remember_state
		1764	\|\| i->insn == CFI_escape
		1765	\|\| i->insn == CFI_val_encoded_addr)
		1766	break;
		1767
		1768	cie->last = i;
		1769	*pfirst = i;
		1770
		1771	output_cie (cie, eh_frame, align);
		1772
		1773	return cie;
		1774	}
		1775
		1776	#ifdef md_reg_eh_frame_to_debug_frame
		1777	static void
		1778	cfi_change_reg_numbers (struct cfi_insn_data *insn, segT ccseg)
		1779	{
		1780	for (; insn; insn = insn->next)
		1781	{
		1782	if (CUR_SEG (insn) != ccseg)
		1783	continue;
		1784	switch (insn->insn)
		1785	{
		1786	case DW_CFA_advance_loc:
		1787	case DW_CFA_def_cfa_offset:
		1788	case DW_CFA_remember_state:
		1789	case DW_CFA_restore_state:
		1790	case DW_CFA_GNU_window_save:
		1791	case CFI_escape:
		1792	break;
		1793
		1794	case DW_CFA_def_cfa:
		1795	case DW_CFA_offset:
		1796	insn->u.ri.reg = md_reg_eh_frame_to_debug_frame (insn->u.ri.reg);
		1797	break;
		1798
		1799	case DW_CFA_def_cfa_register:
		1800	case DW_CFA_undefined:
		1801	case DW_CFA_same_value:
		1802	case DW_CFA_restore:
		1803	insn->u.r = md_reg_eh_frame_to_debug_frame (insn->u.r);
		1804	break;
		1805
		1806	case DW_CFA_register:
		1807	insn->u.rr.reg1 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg1);
		1808	insn->u.rr.reg2 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg2);
		1809	break;
		1810
		1811	case CFI_val_encoded_addr:
		1812	insn->u.ea.reg = md_reg_eh_frame_to_debug_frame (insn->u.ea.reg);
		1813	break;
		1814
		1815	default:
		1816	abort ();
		1817	}
		1818	}
		1819	}
		1820	#else
		1821	#define cfi_change_reg_numbers(insn, cseg) do { } while (0)
		1822	#endif
		1823
		1824	static segT
		1825	get_cfi_seg (segT cseg, const char *base, flagword flags, int align)
		1826	{
		1827	if (SUPPORT_FRAME_LINKONCE)
		1828	{
		1829	struct dwcfi_seg_list *l;
		1830
		1831	l = dwcfi_hash_find_or_make (cseg, base, flags);
		1832
		1833	cseg = l->seg;
		1834	subseg_set (cseg, l->subseg);
		1835	}
		1836	else
		1837	{
		1838	cseg = subseg_new (base, 0);
		1839	bfd_set_section_flags (stdoutput, cseg, flags);
		1840	}
		1841	record_alignment (cseg, align);
		1842	return cseg;
		1843	}
		1844
		1845	void
		1846	cfi_finish (void)
		1847	{
		1848	struct cie_entry cie, cie_next;
		1849	segT cfi_seg, ccseg;
		1850	struct fde_entry *fde;
		1851	struct cfi_insn_data *first;
		1852	int save_flag_traditional_format, seek_next_seg;
		1853
		1854	if (all_fde_data == 0)
		1855	return;
		1856
		1857	if ((cfi_sections & CFI_EMIT_eh_frame) != 0)
		1858	{
		1859	/* Make sure check_eh_frame doesn't do anything with our output. */
		1860	save_flag_traditional_format = flag_traditional_format;
		1861	flag_traditional_format = 1;
		1862
		1863	if (!SUPPORT_FRAME_LINKONCE)
		1864	{
		1865	/* Open .eh_frame section. */
		1866	cfi_seg = get_cfi_seg (NULL, ".eh_frame",
		1867	(SEC_ALLOC \| SEC_LOAD \| SEC_DATA
		1868	\| DWARF2_EH_FRAME_READ_ONLY),
		1869	EH_FRAME_ALIGNMENT);
		1870	#ifdef md_fix_up_eh_frame
		1871	md_fix_up_eh_frame (cfi_seg);
		1872	#else
		1873	(void) cfi_seg;
		1874	#endif
		1875	}
		1876
		1877	do
		1878	{
		1879	ccseg = NULL;
		1880	seek_next_seg = 0;
		1881
		1882	for (cie = cie_root; cie; cie = cie_next)
		1883	{
		1884	cie_next = cie->next;
		1885	free ((void *) cie);
		1886	}
		1887	cie_root = NULL;
		1888
		1889	for (fde = all_fde_data; fde ; fde = fde->next)
		1890	{
		1891	if (SUPPORT_FRAME_LINKONCE)
		1892	{
		1893	if (HANDLED (fde))
		1894	continue;
		1895	if (seek_next_seg && CUR_SEG (fde) != ccseg)
		1896	{
		1897	seek_next_seg = 2;
		1898	continue;
		1899	}
		1900	if (!seek_next_seg)
		1901	{
		1902	ccseg = CUR_SEG (fde);
		1903	/* Open .eh_frame section. */
		1904	cfi_seg = get_cfi_seg (ccseg, ".eh_frame",
		1905	(SEC_ALLOC \| SEC_LOAD \| SEC_DATA
		1906	\| DWARF2_EH_FRAME_READ_ONLY),
		1907	EH_FRAME_ALIGNMENT);
		1908	#ifdef md_fix_up_eh_frame
		1909	md_fix_up_eh_frame (cfi_seg);
		1910	#else
		1911	(void) cfi_seg;
		1912	#endif
		1913	seek_next_seg = 1;
		1914	}
		1915	SET_HANDLED (fde, 1);
		1916	}
		1917
		1918	if (fde->end_address == NULL)
		1919	{
		1920	as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
		1921	fde->end_address = fde->start_address;
		1922	}
		1923
		1924	cie = select_cie_for_fde (fde, TRUE, &first, 2);
		1925	output_fde (fde, cie, TRUE, first,
		1926	fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
		1927	}
		1928	}
		1929	while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
		1930
		1931	if (SUPPORT_FRAME_LINKONCE)
		1932	for (fde = all_fde_data; fde ; fde = fde->next)
		1933	SET_HANDLED (fde, 0);
		1934
		1935	flag_traditional_format = save_flag_traditional_format;
		1936	}
		1937
		1938	if ((cfi_sections & CFI_EMIT_debug_frame) != 0)
		1939	{
		1940	int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1;
		1941
		1942	if (!SUPPORT_FRAME_LINKONCE)
		1943	get_cfi_seg (NULL, ".debug_frame",
		1944	SEC_READONLY \| SEC_DEBUGGING,
		1945	alignment);
		1946
		1947	do
		1948	{
		1949	ccseg = NULL;
		1950	seek_next_seg = 0;
		1951
		1952	for (cie = cie_root; cie; cie = cie_next)
		1953	{
		1954	cie_next = cie->next;
		1955	free ((void *) cie);
		1956	}
		1957	cie_root = NULL;
		1958
		1959	for (fde = all_fde_data; fde ; fde = fde->next)
		1960	{
		1961	if (SUPPORT_FRAME_LINKONCE)
		1962	{
		1963	if (HANDLED (fde))
		1964	continue;
		1965	if (seek_next_seg && CUR_SEG (fde) != ccseg)
		1966	{
		1967	seek_next_seg = 2;
		1968	continue;
		1969	}
		1970	if (!seek_next_seg)
		1971	{
		1972	ccseg = CUR_SEG (fde);
		1973	/* Open .debug_frame section. */
		1974	get_cfi_seg (ccseg, ".debug_frame",
		1975	SEC_READONLY \| SEC_DEBUGGING,
		1976	alignment);
		1977	seek_next_seg = 1;
		1978	}
		1979	SET_HANDLED (fde, 1);
		1980	}
		1981	if (fde->end_address == NULL)
		1982	{
		1983	as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
		1984	fde->end_address = fde->start_address;
		1985	}
		1986
		1987	fde->per_encoding = DW_EH_PE_omit;
		1988	fde->lsda_encoding = DW_EH_PE_omit;
		1989	cfi_change_reg_numbers (fde->data, ccseg);
		1990	cie = select_cie_for_fde (fde, FALSE, &first, alignment);
		1991	output_fde (fde, cie, FALSE, first, alignment);
		1992	}
		1993	}
		1994	while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
		1995
		1996	if (SUPPORT_FRAME_LINKONCE)
		1997	for (fde = all_fde_data; fde ; fde = fde->next)
		1998	SET_HANDLED (fde, 0);
		1999	}
		2000	}
		2001
		2002	#else /* TARGET_USE_CFIPOP */
		2003
		2004	/* Emit an intelligible error message for missing support. */
		2005
		2006	static void
		2007	dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED)
		2008	{
		2009	as_bad (_("CFI is not supported for this target"));
		2010	ignore_rest_of_line ();
		2011	}
		2012
		2013	const pseudo_typeS cfi_pseudo_table[] =
		2014	{
		2015	{ "cfi_sections", dot_cfi_dummy, 0 },
		2016	{ "cfi_startproc", dot_cfi_dummy, 0 },
		2017	{ "cfi_endproc", dot_cfi_dummy, 0 },
		2018	{ "cfi_def_cfa", dot_cfi_dummy, 0 },
		2019	{ "cfi_def_cfa_register", dot_cfi_dummy, 0 },
		2020	{ "cfi_def_cfa_offset", dot_cfi_dummy, 0 },
		2021	{ "cfi_adjust_cfa_offset", dot_cfi_dummy, 0 },
		2022	{ "cfi_offset", dot_cfi_dummy, 0 },
		2023	{ "cfi_rel_offset", dot_cfi_dummy, 0 },
		2024	{ "cfi_register", dot_cfi_dummy, 0 },
		2025	{ "cfi_return_column", dot_cfi_dummy, 0 },
		2026	{ "cfi_restore", dot_cfi_dummy, 0 },
		2027	{ "cfi_undefined", dot_cfi_dummy, 0 },
		2028	{ "cfi_same_value", dot_cfi_dummy, 0 },
		2029	{ "cfi_remember_state", dot_cfi_dummy, 0 },
		2030	{ "cfi_restore_state", dot_cfi_dummy, 0 },
		2031	{ "cfi_window_save", dot_cfi_dummy, 0 },
		2032	{ "cfi_escape", dot_cfi_dummy, 0 },
		2033	{ "cfi_signal_frame", dot_cfi_dummy, 0 },
		2034	{ "cfi_personality", dot_cfi_dummy, 0 },
		2035	{ "cfi_lsda", dot_cfi_dummy, 0 },
		2036	{ "cfi_val_encoded_addr", dot_cfi_dummy, 0 },
		2037	{ NULL, NULL, 0 }
		2038	};
		2039
		2040	void
		2041	cfi_finish (void)
		2042	{
		2043	}
		2044	#endif /* TARGET_USE_CFIPOP */

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/gas/dw2gencfi.c – Rev 5222