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

Rev	Author	Line No.	Line
5222	serge	1	/* write.c - emit .o file
6324	serge	2	Copyright (C) 1986-2015 Free Software Foundation, Inc.
5222	serge	3
		4	This file is part of GAS, the GNU Assembler.
		5
		6	GAS is free software; you can redistribute it and/or modify
		7	it under the terms of the GNU General Public License as published by
		8	the Free Software Foundation; either version 3, or (at your option)
		9	any later version.
		10
		11	GAS is distributed in the hope that it will be useful,
		12	but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		14	GNU General Public License for more details.
		15
		16	You should have received a copy of the GNU General Public License
		17	along with GAS; see the file COPYING. If not, write to the Free
		18	Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
		19	02110-1301, USA. */
		20
		21	/* This thing should be set up to do byteordering correctly. But... */
		22
		23	#include "as.h"
		24	#include "subsegs.h"
		25	#include "obstack.h"
		26	#include "output-file.h"
		27	#include "dwarf2dbg.h"
		28	#include "libbfd.h"
		29	#include "compress-debug.h"
		30
		31	#ifndef TC_FORCE_RELOCATION
		32	#define TC_FORCE_RELOCATION(FIX) \
		33	(generic_force_reloc (FIX))
		34	#endif
		35
		36	#ifndef TC_FORCE_RELOCATION_ABS
		37	#define TC_FORCE_RELOCATION_ABS(FIX) \
		38	(TC_FORCE_RELOCATION (FIX))
		39	#endif
		40
		41	#ifndef TC_FORCE_RELOCATION_LOCAL
		42	#define TC_FORCE_RELOCATION_LOCAL(FIX) \
		43	(!(FIX)->fx_pcrel \
		44	\|\| TC_FORCE_RELOCATION (FIX))
		45	#endif
		46
		47	#ifndef TC_FORCE_RELOCATION_SUB_SAME
		48	#define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
		49	(! SEG_NORMAL (SEG))
		50	#endif
		51
		52	#ifndef md_register_arithmetic
		53	# define md_register_arithmetic 1
		54	#endif
		55
		56	#ifndef TC_FORCE_RELOCATION_SUB_ABS
		57	#define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
		58	(!md_register_arithmetic && (SEG) == reg_section)
		59	#endif
		60
		61	#ifndef TC_FORCE_RELOCATION_SUB_LOCAL
		62	#ifdef DIFF_EXPR_OK
		63	#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
		64	(!md_register_arithmetic && (SEG) == reg_section)
		65	#else
		66	#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
		67	#endif
		68	#endif
		69
		70	#ifndef TC_VALIDATE_FIX_SUB
		71	#ifdef UNDEFINED_DIFFERENCE_OK
		72	/* The PA needs this for PIC code generation. */
		73	#define TC_VALIDATE_FIX_SUB(FIX, SEG) \
		74	(md_register_arithmetic \|\| (SEG) != reg_section)
		75	#else
		76	#define TC_VALIDATE_FIX_SUB(FIX, SEG) \
		77	((md_register_arithmetic \|\| (SEG) != reg_section) \
		78	&& ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
		79	\|\| (FIX)->fx_r_type == BFD_RELOC_GPREL16))
		80	#endif
		81	#endif
		82
		83	#ifndef TC_LINKRELAX_FIXUP
		84	#define TC_LINKRELAX_FIXUP(SEG) 1
		85	#endif
		86
		87	#ifndef MD_APPLY_SYM_VALUE
		88	#define MD_APPLY_SYM_VALUE(FIX) 1
		89	#endif
		90
		91	#ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
		92	#define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
		93	#endif
		94
		95	#ifndef MD_PCREL_FROM_SECTION
		96	#define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
		97	#endif
		98
		99	#ifndef TC_FAKE_LABEL
		100	#define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
		101	#endif
		102
		103	/* Positive values of TC_FX_SIZE_SLACK allow a target to define
		104	fixups that far past the end of a frag. Having such fixups
		105	is of course most most likely a bug in setting fx_size correctly.
		106	A negative value disables the fixup check entirely, which is
		107	appropriate for something like the Renesas / SuperH SH_COUNT
		108	reloc. */
		109	#ifndef TC_FX_SIZE_SLACK
		110	#define TC_FX_SIZE_SLACK(FIX) 0
		111	#endif
		112
		113	/* Used to control final evaluation of expressions. */
		114	int finalize_syms = 0;
		115
		116	int symbol_table_frozen;
		117
		118	symbolS *abs_section_sym;
		119
		120	/* Remember the value of dot when parsing expressions. */
		121	addressT dot_value;
		122
		123	/* The frag that dot_value is based from. */
		124	fragS *dot_frag;
		125
		126	/* Relocs generated by ".reloc" pseudo. */
		127	struct reloc_list* reloc_list;
		128
		129	void print_fixup (fixS *);
		130
		131	/* We generally attach relocs to frag chains. However, after we have
		132	chained these all together into a segment, any relocs we add after
		133	that must be attached to a segment. This will include relocs added
		134	in md_estimate_size_for_relax, for example. */
		135	static int frags_chained = 0;
		136
		137	static int n_fixups;
		138
		139	#define RELOC_ENUM enum bfd_reloc_code_real
		140
		141	/* Create a fixS in obstack 'notes'. */
		142
		143	static fixS *
		144	fix_new_internal (fragS frag, / Which frag? */
		145	int where, /* Where in that frag? */
		146	int size, /* 1, 2, or 4 usually. */
		147	symbolS add_symbol, / X_add_symbol. */
		148	symbolS sub_symbol, / X_op_symbol. */
		149	offsetT offset, /* X_add_number. */
		150	int pcrel, /* TRUE if PC-relative relocation. */
		151	RELOC_ENUM r_type /* Relocation type. */,
		152	int at_beginning) /* Add to the start of the list? */
		153	{
		154	fixS *fixP;
		155
		156	n_fixups++;
		157
		158	fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
		159
		160	fixP->fx_frag = frag;
		161	fixP->fx_where = where;
		162	fixP->fx_size = size;
		163	/* We've made fx_size a narrow field; check that it's wide enough. */
		164	if (fixP->fx_size != size)
		165	{
		166	as_bad (_("field fx_size too small to hold %d"), size);
		167	abort ();
		168	}
		169	fixP->fx_addsy = add_symbol;
		170	fixP->fx_subsy = sub_symbol;
		171	fixP->fx_offset = offset;
		172	fixP->fx_dot_value = dot_value;
		173	fixP->fx_dot_frag = dot_frag;
		174	fixP->fx_pcrel = pcrel;
		175	fixP->fx_r_type = r_type;
		176	fixP->fx_im_disp = 0;
		177	fixP->fx_pcrel_adjust = 0;
		178	fixP->fx_bit_fixP = 0;
		179	fixP->fx_addnumber = 0;
		180	fixP->fx_tcbit = 0;
		181	fixP->fx_tcbit2 = 0;
		182	fixP->fx_done = 0;
		183	fixP->fx_no_overflow = 0;
		184	fixP->fx_signed = 0;
		185
		186	#ifdef USING_CGEN
		187	fixP->fx_cgen.insn = NULL;
		188	fixP->fx_cgen.opinfo = 0;
		189	#endif
		190
		191	#ifdef TC_FIX_TYPE
		192	TC_INIT_FIX_DATA (fixP);
		193	#endif
		194
		195	as_where (&fixP->fx_file, &fixP->fx_line);
		196
		197	{
		198
		199	fixS **seg_fix_rootP = (frags_chained
		200	? &seg_info (now_seg)->fix_root
		201	: &frchain_now->fix_root);
		202	fixS **seg_fix_tailP = (frags_chained
		203	? &seg_info (now_seg)->fix_tail
		204	: &frchain_now->fix_tail);
		205
		206	if (at_beginning)
		207	{
		208	fixP->fx_next = *seg_fix_rootP;
		209	*seg_fix_rootP = fixP;
		210	if (fixP->fx_next == NULL)
		211	*seg_fix_tailP = fixP;
		212	}
		213	else
		214	{
		215	fixP->fx_next = NULL;
		216	if (*seg_fix_tailP)
		217	(*seg_fix_tailP)->fx_next = fixP;
		218	else
		219	*seg_fix_rootP = fixP;
		220	*seg_fix_tailP = fixP;
		221	}
		222	}
		223
		224	return fixP;
		225	}
		226
		227	/* Create a fixup relative to a symbol (plus a constant). */
		228
		229	fixS *
		230	fix_new (fragS frag, / Which frag? */
		231	int where, /* Where in that frag? */
		232	int size, /* 1, 2, or 4 usually. */
		233	symbolS add_symbol, / X_add_symbol. */
		234	offsetT offset, /* X_add_number. */
		235	int pcrel, /* TRUE if PC-relative relocation. */
		236	RELOC_ENUM r_type /* Relocation type. */)
		237	{
		238	return fix_new_internal (frag, where, size, add_symbol,
		239	(symbolS *) NULL, offset, pcrel, r_type, FALSE);
		240	}
		241
		242	/* Create a fixup for an expression. Currently we only support fixups
		243	for difference expressions. That is itself more than most object
		244	file formats support anyhow. */
		245
		246	fixS *
		247	fix_new_exp (fragS frag, / Which frag? */
		248	int where, /* Where in that frag? */
		249	int size, /* 1, 2, or 4 usually. */
		250	expressionS exp, / Expression. */
		251	int pcrel, /* TRUE if PC-relative relocation. */
		252	RELOC_ENUM r_type /* Relocation type. */)
		253	{
		254	symbolS *add = NULL;
		255	symbolS *sub = NULL;
		256	offsetT off = 0;
		257
		258	switch (exp->X_op)
		259	{
		260	case O_absent:
		261	break;
		262
		263	case O_register:
		264	as_bad (_("register value used as expression"));
		265	break;
		266
		267	case O_add:
		268	/* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
		269	the difference expression cannot immediately be reduced. */
		270	{
		271	symbolS *stmp = make_expr_symbol (exp);
		272
		273	exp->X_op = O_symbol;
		274	exp->X_op_symbol = 0;
		275	exp->X_add_symbol = stmp;
		276	exp->X_add_number = 0;
		277
		278	return fix_new_exp (frag, where, size, exp, pcrel, r_type);
		279	}
		280
		281	case O_symbol_rva:
		282	add = exp->X_add_symbol;
		283	off = exp->X_add_number;
		284	r_type = BFD_RELOC_RVA;
		285	break;
		286
		287	case O_uminus:
		288	sub = exp->X_add_symbol;
		289	off = exp->X_add_number;
		290	break;
		291
		292	case O_subtract:
		293	sub = exp->X_op_symbol;
		294	/* Fall through. */
		295	case O_symbol:
		296	add = exp->X_add_symbol;
		297	/* Fall through. */
		298	case O_constant:
		299	off = exp->X_add_number;
		300	break;
		301
		302	default:
		303	add = make_expr_symbol (exp);
		304	break;
		305	}
		306
		307	return fix_new_internal (frag, where, size, add, sub, off, pcrel,
		308	r_type, FALSE);
		309	}
		310
		311	/* Create a fixup at the beginning of FRAG. The arguments are the same
		312	as for fix_new, except that WHERE is implicitly 0. */
		313
		314	fixS *
		315	fix_at_start (fragS frag, int size, symbolS add_symbol,
		316	offsetT offset, int pcrel, RELOC_ENUM r_type)
		317	{
		318	return fix_new_internal (frag, 0, size, add_symbol,
		319	(symbolS *) NULL, offset, pcrel, r_type, TRUE);
		320	}
		321
		322	/* Generic function to determine whether a fixup requires a relocation. */
		323	int
		324	generic_force_reloc (fixS *fix)
		325	{
		326	if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
		327	\|\| fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
		328	return 1;
		329
		330	if (fix->fx_addsy == NULL)
		331	return 0;
		332
		333	return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
		334	}
		335
		336	/* Append a string onto another string, bumping the pointer along. */
		337	void
		338	append (char *charPP, char fromP, unsigned long length)
		339	{
		340	/* Don't trust memcpy() of 0 chars. */
		341	if (length == 0)
		342	return;
		343
		344	memcpy (*charPP, fromP, length);
		345	*charPP += length;
		346	}
		347
		348	/* This routine records the largest alignment seen for each segment.
		349	If the beginning of the segment is aligned on the worst-case
		350	boundary, all of the other alignments within it will work. At
		351	least one object format really uses this info. */
		352
		353	void
		354	record_alignment (/* Segment to which alignment pertains. */
		355	segT seg,
		356	/* Alignment, as a power of 2 (e.g., 1 => 2-byte
		357	boundary, 2 => 4-byte boundary, etc.) */
		358	int align)
		359	{
		360	if (seg == absolute_section)
		361	return;
		362
		363	if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
		364	bfd_set_section_alignment (stdoutput, seg, align);
		365	}
		366
		367	int
		368	get_recorded_alignment (segT seg)
		369	{
		370	if (seg == absolute_section)
		371	return 0;
		372
		373	return bfd_get_section_alignment (stdoutput, seg);
		374	}
		375
		376	/* Reset the section indices after removing the gas created sections. */
		377
		378	static void
		379	renumber_sections (bfd abfd ATTRIBUTE_UNUSED, asection sec, void *countparg)
		380	{
		381	int countp = (int ) countparg;
		382
		383	sec->index = *countp;
		384	++*countp;
		385	}
		386
		387	static fragS *
		388	chain_frchains_together_1 (segT section, struct frchain *frchp)
		389	{
		390	fragS dummy, *prev_frag = &dummy;
		391	fixS fix_dummy, *prev_fix = &fix_dummy;
		392
		393	for (; frchp; frchp = frchp->frch_next)
		394	{
		395	prev_frag->fr_next = frchp->frch_root;
		396	prev_frag = frchp->frch_last;
		397	gas_assert (prev_frag->fr_type != 0);
		398	if (frchp->fix_root != (fixS *) NULL)
		399	{
		400	if (seg_info (section)->fix_root == (fixS *) NULL)
		401	seg_info (section)->fix_root = frchp->fix_root;
		402	prev_fix->fx_next = frchp->fix_root;
		403	seg_info (section)->fix_tail = frchp->fix_tail;
		404	prev_fix = frchp->fix_tail;
		405	}
		406	}
		407	gas_assert (prev_frag != &dummy
		408	&& prev_frag->fr_type != 0);
		409	prev_frag->fr_next = 0;
		410	return prev_frag;
		411	}
		412
		413	static void
		414	chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
		415	segT section,
		416	void *xxx ATTRIBUTE_UNUSED)
		417	{
		418	segment_info_type *info;
		419
		420	/* BFD may have introduced its own sections without using
		421	subseg_new, so it is possible that seg_info is NULL. */
		422	info = seg_info (section);
		423	if (info != (segment_info_type *) NULL)
		424	info->frchainP->frch_last
		425	= chain_frchains_together_1 (section, info->frchainP);
		426
		427	/* Now that we've chained the frags together, we must add new fixups
		428	to the segment, not to the frag chain. */
		429	frags_chained = 1;
		430	}
		431
		432	static void
		433	cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
		434	{
		435	switch (fragP->fr_type)
		436	{
		437	case rs_align:
		438	case rs_align_code:
		439	case rs_align_test:
		440	case rs_org:
		441	case rs_space:
		442	#ifdef HANDLE_ALIGN
		443	HANDLE_ALIGN (fragP);
		444	#endif
		445	know (fragP->fr_next != NULL);
		446	fragP->fr_offset = (fragP->fr_next->fr_address
		447	- fragP->fr_address
		448	- fragP->fr_fix) / fragP->fr_var;
		449	if (fragP->fr_offset < 0)
		450	{
		451	as_bad_where (fragP->fr_file, fragP->fr_line,
		452	_("attempt to .org/.space backwards? (%ld)"),
		453	(long) fragP->fr_offset);
		454	fragP->fr_offset = 0;
		455	}
		456	fragP->fr_type = rs_fill;
		457	break;
		458
		459	case rs_fill:
		460	break;
		461
		462	case rs_leb128:
		463	{
		464	valueT value = S_GET_VALUE (fragP->fr_symbol);
		465	int size;
		466
		467	size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
		468	fragP->fr_subtype);
		469
		470	fragP->fr_fix += size;
		471	fragP->fr_type = rs_fill;
		472	fragP->fr_var = 0;
		473	fragP->fr_offset = 0;
		474	fragP->fr_symbol = NULL;
		475	}
		476	break;
		477
		478	case rs_cfa:
		479	eh_frame_convert_frag (fragP);
		480	break;
		481
		482	case rs_dwarf2dbg:
		483	dwarf2dbg_convert_frag (fragP);
		484	break;
		485
		486	case rs_machine_dependent:
		487	md_convert_frag (stdoutput, sec, fragP);
		488
		489	gas_assert (fragP->fr_next == NULL
		490	\|\| ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
		491	== fragP->fr_fix));
		492
		493	/* After md_convert_frag, we make the frag into a ".space 0".
		494	md_convert_frag() should set up any fixSs and constants
		495	required. */
		496	frag_wane (fragP);
		497	break;
		498
		499	#ifndef WORKING_DOT_WORD
		500	case rs_broken_word:
		501	{
		502	struct broken_word *lie;
		503
		504	if (fragP->fr_subtype)
		505	{
		506	fragP->fr_fix += md_short_jump_size;
		507	for (lie = (struct broken_word *) (fragP->fr_symbol);
		508	lie && lie->dispfrag == fragP;
		509	lie = lie->next_broken_word)
		510	if (lie->added == 1)
		511	fragP->fr_fix += md_long_jump_size;
		512	}
		513	frag_wane (fragP);
		514	}
		515	break;
		516	#endif
		517
		518	default:
		519	BAD_CASE (fragP->fr_type);
		520	break;
		521	}
		522	#ifdef md_frag_check
		523	md_frag_check (fragP);
		524	#endif
		525	}
		526
		527	struct relax_seg_info
		528	{
		529	int pass;
		530	int changed;
		531	};
		532
		533	static void
		534	relax_seg (bfd abfd ATTRIBUTE_UNUSED, asection sec, void *xxx)
		535	{
		536	segment_info_type *seginfo = seg_info (sec);
		537	struct relax_seg_info info = (struct relax_seg_info ) xxx;
		538
		539	if (seginfo && seginfo->frchainP
		540	&& relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
		541	info->changed = 1;
		542	}
		543
		544	static void
		545	size_seg (bfd abfd, asection sec, void *xxx ATTRIBUTE_UNUSED)
		546	{
		547	flagword flags;
		548	fragS *fragp;
		549	segment_info_type *seginfo;
		550	int x;
		551	valueT size, newsize;
		552
		553	subseg_change (sec, 0);
		554
		555	seginfo = seg_info (sec);
		556	if (seginfo && seginfo->frchainP)
		557	{
		558	for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
		559	cvt_frag_to_fill (sec, fragp);
		560	for (fragp = seginfo->frchainP->frch_root;
		561	fragp->fr_next;
		562	fragp = fragp->fr_next)
		563	/* Walk to last elt. */
		564	;
		565	size = fragp->fr_address + fragp->fr_fix;
		566	}
		567	else
		568	size = 0;
		569
		570	flags = bfd_get_section_flags (abfd, sec);
		571	if (size == 0 && bfd_get_section_size (sec) != 0 &&
		572	(flags & SEC_HAS_CONTENTS) != 0)
		573	return;
		574
		575	if (size > 0 && ! seginfo->bss)
		576	flags \|= SEC_HAS_CONTENTS;
		577
		578	flags &= ~SEC_RELOC;
		579	x = bfd_set_section_flags (abfd, sec, flags);
		580	gas_assert (x);
		581
		582	newsize = md_section_align (sec, size);
		583	x = bfd_set_section_size (abfd, sec, newsize);
		584	gas_assert (x);
		585
		586	/* If the size had to be rounded up, add some padding in the last
		587	non-empty frag. */
		588	gas_assert (newsize >= size);
		589	if (size != newsize)
		590	{
		591	fragS *last = seginfo->frchainP->frch_last;
		592	fragp = seginfo->frchainP->frch_root;
		593	while (fragp->fr_next != last)
		594	fragp = fragp->fr_next;
		595	last->fr_address = size;
		596	if ((newsize - size) % fragp->fr_var == 0)
		597	fragp->fr_offset += (newsize - size) / fragp->fr_var;
		598	else
		599	/* If we hit this abort, it's likely due to subsegs_finish not
		600	providing sufficient alignment on the last frag, and the
		601	machine dependent code using alignment frags with fr_var
		602	greater than 1. */
		603	abort ();
		604	}
		605
		606	#ifdef tc_frob_section
		607	tc_frob_section (sec);
		608	#endif
		609	#ifdef obj_frob_section
		610	obj_frob_section (sec);
		611	#endif
		612	}
		613
		614	#ifdef DEBUG2
		615	static void
		616	dump_section_relocs (bfd abfd ATTRIBUTE_UNUSED, asection sec, FILE *stream)
		617	{
		618	segment_info_type *seginfo = seg_info (sec);
		619	fixS *fixp = seginfo->fix_root;
		620
		621	if (!fixp)
		622	return;
		623
		624	fprintf (stream, "sec %s relocs:\n", sec->name);
		625	while (fixp)
		626	{
		627	symbolS *s = fixp->fx_addsy;
		628
		629	fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
		630	(int) fixp->fx_r_type);
		631	if (s == NULL)
		632	fprintf (stream, "no sym\n");
		633	else
		634	{
		635	print_symbol_value_1 (stream, s);
		636	fprintf (stream, "\n");
		637	}
		638	fixp = fixp->fx_next;
		639	}
		640	}
		641	#else
		642	#define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
		643	#endif
		644
		645	#ifndef EMIT_SECTION_SYMBOLS
		646	#define EMIT_SECTION_SYMBOLS 1
		647	#endif
		648
		649	/* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
		650	and check for validity. Convert RELOC_LIST from using U.A fields
		651	to U.B fields. */
		652	static void
		653	resolve_reloc_expr_symbols (void)
		654	{
		655	bfd_vma addr_mask = 1;
		656	struct reloc_list *r;
		657
		658	/* Avoid a shift by the width of type. */
		659	addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1;
		660	addr_mask <<= 1;
		661	addr_mask -= 1;
		662
		663	for (r = reloc_list; r; r = r->next)
		664	{
		665	reloc_howto_type *howto = r->u.a.howto;
		666	expressionS *symval;
		667	symbolS *sym;
		668	bfd_vma offset, addend;
		669	asection *sec;
		670
		671	resolve_symbol_value (r->u.a.offset_sym);
		672	symval = symbol_get_value_expression (r->u.a.offset_sym);
		673
		674	offset = 0;
		675	sym = NULL;
		676	if (symval->X_op == O_constant)
		677	sym = r->u.a.offset_sym;
		678	else if (symval->X_op == O_symbol)
		679	{
		680	sym = symval->X_add_symbol;
		681	offset = symval->X_add_number;
		682	symval = symbol_get_value_expression (symval->X_add_symbol);
		683	}
		684	if (sym == NULL
		685	\|\| symval->X_op != O_constant
		686	\|\| (sec = S_GET_SEGMENT (sym)) == NULL
		687	\|\| !SEG_NORMAL (sec))
		688	{
		689	as_bad_where (r->file, r->line, _("invalid offset expression"));
		690	sec = NULL;
		691	}
		692	else
		693	offset += S_GET_VALUE (sym);
		694
		695	sym = NULL;
		696	addend = r->u.a.addend;
		697	if (r->u.a.sym != NULL)
		698	{
		699	resolve_symbol_value (r->u.a.sym);
		700	symval = symbol_get_value_expression (r->u.a.sym);
		701	if (symval->X_op == O_constant)
		702	sym = r->u.a.sym;
		703	else if (symval->X_op == O_symbol)
		704	{
		705	sym = symval->X_add_symbol;
		706	addend += symval->X_add_number;
		707	symval = symbol_get_value_expression (symval->X_add_symbol);
		708	}
		709	if (symval->X_op != O_constant)
		710	{
		711	as_bad_where (r->file, r->line, _("invalid reloc expression"));
		712	sec = NULL;
		713	}
		714	else if (sym != NULL)
		715	{
		716	/* Convert relocs against local symbols to refer to the
		717	corresponding section symbol plus offset instead. Keep
		718	PC-relative relocs of the REL variety intact though to
		719	prevent the offset from overflowing the relocated field,
		720	unless it has enough bits to cover the whole address
		721	space. */
		722	if (S_IS_LOCAL (sym) && !symbol_section_p (sym)
		723	&& (sec->use_rela_p
		724	\|\| (howto->partial_inplace
		725	&& (!howto->pc_relative
		726	\|\| howto->src_mask == addr_mask))))
		727	{
		728	asection *symsec = S_GET_SEGMENT (sym);
		729	if (!(((symsec->flags & SEC_MERGE) != 0
		730	&& addend != 0)
		731	\|\| (symsec->flags & SEC_THREAD_LOCAL) != 0))
		732	{
		733	addend += S_GET_VALUE (sym);
		734	sym = section_symbol (symsec);
		735	}
		736	}
		737	symbol_mark_used_in_reloc (sym);
		738	}
		739	}
		740	if (sym == NULL)
		741	{
		742	if (abs_section_sym == NULL)
		743	abs_section_sym = section_symbol (absolute_section);
		744	sym = abs_section_sym;
		745	}
		746
		747	r->u.b.sec = sec;
		748	r->u.b.s = symbol_get_bfdsym (sym);
		749	r->u.b.r.sym_ptr_ptr = &r->u.b.s;
		750	r->u.b.r.address = offset;
		751	r->u.b.r.addend = addend;
		752	r->u.b.r.howto = howto;
		753	}
		754	}
		755
		756	/* This pass over fixups decides whether symbols can be replaced with
		757	section symbols. */
		758
		759	static void
		760	adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
		761	asection *sec,
		762	void *xxx ATTRIBUTE_UNUSED)
		763	{
		764	segment_info_type *seginfo = seg_info (sec);
		765	fixS *fixp;
		766
		767	if (seginfo == NULL)
		768	return;
		769
		770	dump_section_relocs (abfd, sec, stderr);
		771
		772	for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
		773	if (fixp->fx_done)
		774	/* Ignore it. */
		775	;
		776	else if (fixp->fx_addsy)
		777	{
		778	symbolS *sym;
		779	asection *symsec;
		780
		781	#ifdef DEBUG5
		782	fprintf (stderr, "\n\nadjusting fixup:\n");
		783	print_fixup (fixp);
		784	#endif
		785
		786	sym = fixp->fx_addsy;
		787
		788	/* All symbols should have already been resolved at this
		789	point. It is possible to see unresolved expression
		790	symbols, though, since they are not in the regular symbol
		791	table. */
		792	resolve_symbol_value (sym);
		793
		794	if (fixp->fx_subsy != NULL)
		795	resolve_symbol_value (fixp->fx_subsy);
		796
		797	/* If this symbol is equated to an undefined or common symbol,
		798	convert the fixup to being against that symbol. */
		799	while (symbol_equated_reloc_p (sym)
		800	\|\| S_IS_WEAKREFR (sym))
		801	{
		802	symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
		803	if (sym == newsym)
		804	break;
		805	fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
		806	fixp->fx_addsy = newsym;
		807	sym = newsym;
		808	}
		809
		810	if (symbol_mri_common_p (sym))
		811	{
		812	fixp->fx_offset += S_GET_VALUE (sym);
		813	fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
		814	continue;
		815	}
		816
		817	/* If the symbol is undefined, common, weak, or global (ELF
		818	shared libs), we can't replace it with the section symbol. */
		819	if (S_FORCE_RELOC (fixp->fx_addsy, 1))
		820	continue;
		821
		822	/* Is there some other (target cpu dependent) reason we can't adjust
		823	this one? (E.g. relocations involving function addresses on
		824	the PA. */
		825	#ifdef tc_fix_adjustable
		826	if (! tc_fix_adjustable (fixp))
		827	continue;
		828	#endif
		829
		830	/* Since we're reducing to section symbols, don't attempt to reduce
		831	anything that's already using one. */
		832	if (symbol_section_p (sym))
		833	continue;
		834
		835	symsec = S_GET_SEGMENT (sym);
		836	if (symsec == NULL)
		837	abort ();
		838
6324	serge	839	if (bfd_is_abs_section (symsec)
		840	\|\| symsec == reg_section)
5222	serge	841	{
		842	/* The fixup_segment routine normally will not use this
		843	symbol in a relocation. */
		844	continue;
		845	}
		846
		847	/* Don't try to reduce relocs which refer to non-local symbols
		848	in .linkonce sections. It can lead to confusion when a
		849	debugging section refers to a .linkonce section. I hope
		850	this will always be correct. */
		851	if (symsec != sec && ! S_IS_LOCAL (sym))
		852	{
		853	if ((symsec->flags & SEC_LINK_ONCE) != 0
		854	\|\| (IS_ELF
		855	/* The GNU toolchain uses an extension for ELF: a
		856	section beginning with the magic string
		857	.gnu.linkonce is a linkonce section. */
		858	&& strncmp (segment_name (symsec), ".gnu.linkonce",
		859	sizeof ".gnu.linkonce" - 1) == 0))
		860	continue;
		861	}
		862
		863	/* Never adjust a reloc against local symbol in a merge section
		864	with non-zero addend. */
		865	if ((symsec->flags & SEC_MERGE) != 0
		866	&& (fixp->fx_offset != 0 \|\| fixp->fx_subsy != NULL))
		867	continue;
		868
		869	/* Never adjust a reloc against TLS local symbol. */
		870	if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
		871	continue;
		872
		873	/* We refetch the segment when calling section_symbol, rather
		874	than using symsec, because S_GET_VALUE may wind up changing
		875	the section when it calls resolve_symbol_value. */
		876	fixp->fx_offset += S_GET_VALUE (sym);
		877	fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
		878	#ifdef DEBUG5
		879	fprintf (stderr, "\nadjusted fixup:\n");
		880	print_fixup (fixp);
		881	#endif
		882	}
		883
		884	dump_section_relocs (abfd, sec, stderr);
		885	}
		886
		887	/* fixup_segment()
		888
		889	Go through all the fixS's in a segment and see which ones can be
		890	handled now. (These consist of fixS where we have since discovered
		891	the value of a symbol, or the address of the frag involved.)
		892	For each one, call md_apply_fix to put the fix into the frag data.
		893	Ones that we couldn't completely handle here will be output later
		894	by emit_relocations. */
		895
		896	static void
		897	fixup_segment (fixS *fixP, segT this_segment)
		898	{
		899	valueT add_number;
		900	fragS *fragP;
		901	segT add_symbol_segment = absolute_section;
		902
		903	if (fixP != NULL && abs_section_sym == NULL)
		904	abs_section_sym = section_symbol (absolute_section);
		905
		906	/* If the linker is doing the relaxing, we must not do any fixups.
		907
		908	Well, strictly speaking that's not true -- we could do any that
		909	are PC-relative and don't cross regions that could change size.
		910	And for the i960 we might be able to turn callx/callj into bal
		911	anyways in cases where we know the maximum displacement. */
		912	if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
		913	{
		914	for (; fixP; fixP = fixP->fx_next)
		915	if (!fixP->fx_done)
		916	{
		917	if (fixP->fx_addsy == NULL)
		918	{
		919	/* There was no symbol required by this relocation.
		920	However, BFD doesn't really handle relocations
		921	without symbols well. So fake up a local symbol in
		922	the absolute section. */
		923	fixP->fx_addsy = abs_section_sym;
		924	}
		925	symbol_mark_used_in_reloc (fixP->fx_addsy);
		926	if (fixP->fx_subsy != NULL)
		927	symbol_mark_used_in_reloc (fixP->fx_subsy);
		928	}
		929	return;
		930	}
		931
		932	for (; fixP; fixP = fixP->fx_next)
		933	{
		934	#ifdef DEBUG5
		935	fprintf (stderr, "\nprocessing fixup:\n");
		936	print_fixup (fixP);
		937	#endif
		938
		939	fragP = fixP->fx_frag;
		940	know (fragP);
		941	#ifdef TC_VALIDATE_FIX
		942	TC_VALIDATE_FIX (fixP, this_segment, skip);
		943	#endif
		944	add_number = fixP->fx_offset;
		945
		946	if (fixP->fx_addsy != NULL)
		947	add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
		948
		949	if (fixP->fx_subsy != NULL)
		950	{
		951	segT sub_symbol_segment;
		952	resolve_symbol_value (fixP->fx_subsy);
		953	sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
		954	if (fixP->fx_addsy != NULL
		955	&& sub_symbol_segment == add_symbol_segment
		956	&& !S_FORCE_RELOC (fixP->fx_addsy, 0)
		957	&& !S_FORCE_RELOC (fixP->fx_subsy, 0)
		958	&& !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
		959	{
		960	add_number += S_GET_VALUE (fixP->fx_addsy);
		961	add_number -= S_GET_VALUE (fixP->fx_subsy);
		962	fixP->fx_offset = add_number;
		963	fixP->fx_addsy = NULL;
		964	fixP->fx_subsy = NULL;
		965	#ifdef TC_M68K
		966	/* See the comment below about 68k weirdness. */
		967	fixP->fx_pcrel = 0;
		968	#endif
		969	}
		970	else if (sub_symbol_segment == absolute_section
		971	&& !S_FORCE_RELOC (fixP->fx_subsy, 0)
		972	&& !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
		973	{
		974	add_number -= S_GET_VALUE (fixP->fx_subsy);
		975	fixP->fx_offset = add_number;
		976	fixP->fx_subsy = NULL;
		977	}
		978	else if (sub_symbol_segment == this_segment
		979	&& !S_FORCE_RELOC (fixP->fx_subsy, 0)
		980	&& !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
		981	{
		982	add_number -= S_GET_VALUE (fixP->fx_subsy);
		983	fixP->fx_offset = (add_number + fixP->fx_dot_value
		984	+ fixP->fx_dot_frag->fr_address);
		985
		986	/* Make it pc-relative. If the back-end code has not
		987	selected a pc-relative reloc, cancel the adjustment
		988	we do later on all pc-relative relocs. */
		989	if (0
		990	#ifdef TC_M68K
		991	/* Do this for m68k even if it's already described
		992	as pc-relative. On the m68k, an operand of
		993	"pc@(foo-.-2)" should address "foo" in a
		994	pc-relative mode. */
		995	\|\| 1
		996	#endif
		997	\|\| !fixP->fx_pcrel)
		998	add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
		999	fixP->fx_subsy = NULL;
		1000	fixP->fx_pcrel = 1;
		1001	}
		1002	else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
		1003	{
		1004	if (!md_register_arithmetic
		1005	&& (add_symbol_segment == reg_section
		1006	\|\| sub_symbol_segment == reg_section))
		1007	as_bad_where (fixP->fx_file, fixP->fx_line,
		1008	_("register value used as expression"));
		1009	else
		1010	as_bad_where (fixP->fx_file, fixP->fx_line,
		1011	_("can't resolve `%s' {%s section} - `%s' {%s section}"),
		1012	fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
		1013	segment_name (add_symbol_segment),
		1014	S_GET_NAME (fixP->fx_subsy),
		1015	segment_name (sub_symbol_segment));
		1016	}
		1017	else if (sub_symbol_segment != undefined_section
		1018	&& ! bfd_is_com_section (sub_symbol_segment)
		1019	&& MD_APPLY_SYM_VALUE (fixP))
		1020	add_number -= S_GET_VALUE (fixP->fx_subsy);
		1021	}
		1022
		1023	if (fixP->fx_addsy)
		1024	{
		1025	if (add_symbol_segment == this_segment
		1026	&& !S_FORCE_RELOC (fixP->fx_addsy, 0)
		1027	&& !TC_FORCE_RELOCATION_LOCAL (fixP))
		1028	{
		1029	/* This fixup was made when the symbol's segment was
		1030	SEG_UNKNOWN, but it is now in the local segment.
		1031	So we know how to do the address without relocation. */
		1032	add_number += S_GET_VALUE (fixP->fx_addsy);
		1033	fixP->fx_offset = add_number;
		1034	if (fixP->fx_pcrel)
		1035	add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
		1036	fixP->fx_addsy = NULL;
		1037	fixP->fx_pcrel = 0;
		1038	}
		1039	else if (add_symbol_segment == absolute_section
		1040	&& !S_FORCE_RELOC (fixP->fx_addsy, 0)
		1041	&& !TC_FORCE_RELOCATION_ABS (fixP))
		1042	{
		1043	add_number += S_GET_VALUE (fixP->fx_addsy);
		1044	fixP->fx_offset = add_number;
		1045	fixP->fx_addsy = NULL;
		1046	}
		1047	else if (add_symbol_segment != undefined_section
		1048	&& ! bfd_is_com_section (add_symbol_segment)
		1049	&& MD_APPLY_SYM_VALUE (fixP))
		1050	add_number += S_GET_VALUE (fixP->fx_addsy);
		1051	}
		1052
		1053	if (fixP->fx_pcrel)
		1054	{
		1055	add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
		1056	if (!fixP->fx_done && fixP->fx_addsy == NULL)
		1057	{
		1058	/* There was no symbol required by this relocation.
		1059	However, BFD doesn't really handle relocations
		1060	without symbols well. So fake up a local symbol in
		1061	the absolute section. */
		1062	fixP->fx_addsy = abs_section_sym;
		1063	}
		1064	}
		1065
		1066	if (!fixP->fx_done)
		1067	md_apply_fix (fixP, &add_number, this_segment);
		1068
		1069	if (!fixP->fx_done)
		1070	{
		1071	if (fixP->fx_addsy == NULL)
		1072	fixP->fx_addsy = abs_section_sym;
		1073	symbol_mark_used_in_reloc (fixP->fx_addsy);
		1074	if (fixP->fx_subsy != NULL)
		1075	symbol_mark_used_in_reloc (fixP->fx_subsy);
		1076	}
		1077
		1078	if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
		1079	{
		1080	if (fixP->fx_size < sizeof (valueT))
		1081	{
		1082	valueT mask;
		1083
		1084	mask = 0;
		1085	mask--; /* Set all bits to one. */
		1086	mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
		1087	if ((add_number & mask) != 0 && (add_number & mask) != mask)
		1088	{
		1089	char buf[50], buf2[50];
		1090	sprint_value (buf, fragP->fr_address + fixP->fx_where);
		1091	if (add_number > 1000)
		1092	sprint_value (buf2, add_number);
		1093	else
		1094	sprintf (buf2, "%ld", (long) add_number);
		1095	as_bad_where (fixP->fx_file, fixP->fx_line,
		1096	_("value of %s too large for field of %d bytes at %s"),
		1097	buf2, fixP->fx_size, buf);
		1098	} /* Generic error checking. */
		1099	}
		1100	#ifdef WARN_SIGNED_OVERFLOW_WORD
		1101	/* Warn if a .word value is too large when treated as a signed
		1102	number. We already know it is not too negative. This is to
		1103	catch over-large switches generated by gcc on the 68k. */
		1104	if (!flag_signed_overflow_ok
		1105	&& fixP->fx_size == 2
		1106	&& add_number > 0x7fff)
		1107	as_bad_where (fixP->fx_file, fixP->fx_line,
		1108	_("signed .word overflow; switch may be too large; %ld at 0x%lx"),
		1109	(long) add_number,
		1110	(long) (fragP->fr_address + fixP->fx_where));
		1111	#endif
		1112	} /* Not a bit fix. */
		1113
		1114	#ifdef TC_VALIDATE_FIX
		1115	skip: ATTRIBUTE_UNUSED_LABEL
		1116	;
		1117	#endif
		1118	#ifdef DEBUG5
		1119	fprintf (stderr, "result:\n");
		1120	print_fixup (fixP);
		1121	#endif
		1122	} /* For each fixS in this segment. */
		1123	}
		1124
		1125	static void
		1126	fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
		1127	asection *sec,
		1128	void *xxx ATTRIBUTE_UNUSED)
		1129	{
		1130	segment_info_type *seginfo = seg_info (sec);
		1131
		1132	fixup_segment (seginfo->fix_root, sec);
		1133	}
		1134
		1135	static void
		1136	install_reloc (asection sec, arelent reloc, fragS *fragp,
		1137	char *file, unsigned int line)
		1138	{
		1139	char *err;
		1140	bfd_reloc_status_type s;
		1141	asymbol *sym;
		1142
		1143	if (reloc->sym_ptr_ptr != NULL
		1144	&& (sym = *reloc->sym_ptr_ptr) != NULL
		1145	&& (sym->flags & BSF_KEEP) == 0
		1146	&& ((sym->flags & BSF_SECTION_SYM) == 0
		1147	\|\| (EMIT_SECTION_SYMBOLS
		1148	&& !bfd_is_abs_section (sym->section))))
		1149	as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
		1150
		1151	s = bfd_install_relocation (stdoutput, reloc,
		1152	fragp->fr_literal, fragp->fr_address,
		1153	sec, &err);
		1154	switch (s)
		1155	{
		1156	case bfd_reloc_ok:
		1157	break;
		1158	case bfd_reloc_overflow:
		1159	as_bad_where (file, line, _("relocation overflow"));
		1160	break;
		1161	case bfd_reloc_outofrange:
		1162	as_bad_where (file, line, _("relocation out of range"));
		1163	break;
		1164	default:
		1165	as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
		1166	file, line, s);
		1167	}
		1168	}
		1169
		1170	static fragS *
		1171	get_frag_for_reloc (fragS *last_frag,
		1172	const segment_info_type *seginfo,
		1173	const struct reloc_list *r)
		1174	{
		1175	fragS *f;
		1176
		1177	for (f = last_frag; f != NULL; f = f->fr_next)
		1178	if (f->fr_address <= r->u.b.r.address
		1179	&& r->u.b.r.address < f->fr_address + f->fr_fix)
		1180	return f;
		1181
		1182	for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
		1183	if (f->fr_address <= r->u.b.r.address
		1184	&& r->u.b.r.address < f->fr_address + f->fr_fix)
		1185	return f;
		1186
6324	serge	1187	for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
		1188	if (f->fr_address <= r->u.b.r.address
		1189	&& r->u.b.r.address <= f->fr_address + f->fr_fix)
		1190	return f;
		1191
5222	serge	1192	as_bad_where (r->file, r->line,
		1193	_("reloc not within (fixed part of) section"));
		1194	return NULL;
		1195	}
		1196
		1197	static void
		1198	write_relocs (bfd abfd, asection sec, void *xxx ATTRIBUTE_UNUSED)
		1199	{
		1200	segment_info_type *seginfo = seg_info (sec);
		1201	unsigned int n;
		1202	struct reloc_list my_reloc_list, rp, r;
		1203	arelent **relocs;
		1204	fixS *fixp;
		1205	fragS *last_frag;
		1206
		1207	/* If seginfo is NULL, we did not create this section; don't do
		1208	anything with it. */
		1209	if (seginfo == NULL)
		1210	return;
		1211
		1212	n = 0;
		1213	for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
		1214	if (!fixp->fx_done)
		1215	n++;
		1216
		1217	#ifdef RELOC_EXPANSION_POSSIBLE
		1218	n *= MAX_RELOC_EXPANSION;
		1219	#endif
		1220
		1221	/* Extract relocs for this section from reloc_list. */
		1222	rp = &reloc_list;
		1223	my_reloc_list = NULL;
		1224	while ((r = *rp) != NULL)
		1225	{
		1226	if (r->u.b.sec == sec)
		1227	{
		1228	*rp = r->next;
		1229	r->next = my_reloc_list;
		1230	my_reloc_list = r;
		1231	n++;
		1232	}
		1233	else
		1234	rp = &r->next;
		1235	}
		1236
		1237	relocs = (arelent *) xcalloc (n, sizeof (arelent ));
		1238
		1239	n = 0;
		1240	r = my_reloc_list;
		1241	last_frag = NULL;
		1242	for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
		1243	{
		1244	int fx_size, slack;
		1245	offsetT loc;
		1246	arelent **reloc;
		1247	#ifndef RELOC_EXPANSION_POSSIBLE
		1248	arelent *rel;
		1249
		1250	reloc = &rel;
		1251	#endif
		1252
		1253	if (fixp->fx_done)
		1254	continue;
		1255
		1256	fx_size = fixp->fx_size;
		1257	slack = TC_FX_SIZE_SLACK (fixp);
		1258	if (slack > 0)
		1259	fx_size = fx_size > slack ? fx_size - slack : 0;
		1260	loc = fixp->fx_where + fx_size;
		1261	if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
		1262	as_bad_where (fixp->fx_file, fixp->fx_line,
		1263	_("internal error: fixup not contained within frag"));
		1264
		1265	#ifndef RELOC_EXPANSION_POSSIBLE
		1266	*reloc = tc_gen_reloc (sec, fixp);
		1267	#else
		1268	reloc = tc_gen_reloc (sec, fixp);
		1269	#endif
		1270
		1271	while (*reloc)
		1272	{
		1273	while (r != NULL && r->u.b.r.address < (*reloc)->address)
		1274	{
		1275	fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
		1276	if (f != NULL)
		1277	{
		1278	last_frag = f;
		1279	relocs[n++] = &r->u.b.r;
		1280	install_reloc (sec, &r->u.b.r, f, r->file, r->line);
		1281	}
		1282	r = r->next;
		1283	}
		1284	relocs[n++] = *reloc;
		1285	install_reloc (sec, *reloc, fixp->fx_frag,
		1286	fixp->fx_file, fixp->fx_line);
		1287	#ifndef RELOC_EXPANSION_POSSIBLE
		1288	break;
		1289	#else
		1290	reloc++;
		1291	#endif
		1292	}
		1293	}
		1294
		1295	while (r != NULL)
		1296	{
		1297	fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
		1298	if (f != NULL)
		1299	{
		1300	last_frag = f;
		1301	relocs[n++] = &r->u.b.r;
		1302	install_reloc (sec, &r->u.b.r, f, r->file, r->line);
		1303	}
		1304	r = r->next;
		1305	}
		1306
		1307	#ifdef DEBUG4
		1308	{
		1309	unsigned int k, j, nsyms;
		1310	asymbol **sympp;
		1311	sympp = bfd_get_outsymbols (stdoutput);
		1312	nsyms = bfd_get_symcount (stdoutput);
		1313	for (k = 0; k < n; k++)
		1314	if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
		1315	{
		1316	for (j = 0; j < nsyms; j++)
		1317	if (sympp[j] == *relocs[k]->sym_ptr_ptr)
		1318	break;
		1319	if (j == nsyms)
		1320	abort ();
		1321	}
		1322	}
		1323	#endif
		1324
		1325	if (n)
		1326	{
		1327	flagword flags = bfd_get_section_flags (abfd, sec);
		1328	flags \|= SEC_RELOC;
		1329	bfd_set_section_flags (abfd, sec, flags);
		1330	bfd_set_reloc (stdoutput, sec, relocs, n);
		1331	}
		1332
		1333	#ifdef SET_SECTION_RELOCS
		1334	SET_SECTION_RELOCS (sec, relocs, n);
		1335	#endif
		1336
		1337	#ifdef DEBUG3
		1338	{
		1339	unsigned int k;
		1340
		1341	fprintf (stderr, "relocs for sec %s\n", sec->name);
		1342	for (k = 0; k < n; k++)
		1343	{
		1344	arelent *rel = relocs[k];
		1345	asymbol s = rel->sym_ptr_ptr;
		1346	fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
		1347	k, rel, (unsigned long)rel->address, s->name,
		1348	(unsigned long)rel->addend);
		1349	}
		1350	}
		1351	#endif
		1352	}
		1353
		1354	static int
		1355	compress_frag (struct z_stream_s strm, const char contents, int in_size,
		1356	fragS *last_newf, struct obstack ob)
		1357	{
		1358	int out_size;
		1359	int total_out_size = 0;
		1360	fragS f = last_newf;
		1361	char *next_out;
		1362	int avail_out;
		1363
		1364	/* Call the compression routine repeatedly until it has finished
		1365	processing the frag. */
		1366	while (in_size > 0)
		1367	{
		1368	/* Reserve all the space available in the current chunk.
		1369	If none is available, start a new frag. */
		1370	avail_out = obstack_room (ob);
		1371	if (avail_out <= 0)
		1372	{
		1373	obstack_finish (ob);
		1374	f = frag_alloc (ob);
		1375	f->fr_type = rs_fill;
		1376	(*last_newf)->fr_next = f;
		1377	*last_newf = f;
		1378	avail_out = obstack_room (ob);
		1379	}
		1380	if (avail_out <= 0)
		1381	as_fatal (_("can't extend frag"));
		1382	next_out = obstack_next_free (ob);
		1383	obstack_blank_fast (ob, avail_out);
		1384	out_size = compress_data (strm, &contents, &in_size,
		1385	&next_out, &avail_out);
		1386	if (out_size < 0)
		1387	return -1;
		1388
		1389	f->fr_fix += out_size;
		1390	total_out_size += out_size;
		1391
		1392	/* Return unused space. */
		1393	if (avail_out > 0)
		1394	obstack_blank_fast (ob, -avail_out);
		1395	}
		1396
		1397	return total_out_size;
		1398	}
		1399
		1400	static void
		1401	compress_debug (bfd abfd, asection sec, void *xxx ATTRIBUTE_UNUSED)
		1402	{
		1403	segment_info_type *seginfo = seg_info (sec);
		1404	fragS *f;
		1405	fragS *first_newf;
		1406	fragS *last_newf;
		1407	struct obstack *ob = &seginfo->frchainP->frch_obstack;
		1408	bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
		1409	bfd_size_type compressed_size;
		1410	const char *section_name;
		1411	char *compressed_name;
		1412	char *header;
		1413	struct z_stream_s *strm;
		1414	int x;
		1415	flagword flags = bfd_get_section_flags (abfd, sec);
6324	serge	1416	unsigned int header_size, compression_header_size;
5222	serge	1417
		1418	if (seginfo == NULL
		1419	\|\| sec->size < 32
		1420	\|\| (flags & (SEC_ALLOC \| SEC_HAS_CONTENTS)) == SEC_ALLOC)
		1421	return;
		1422
		1423	section_name = bfd_get_section_name (stdoutput, sec);
		1424	if (strncmp (section_name, ".debug_", 7) != 0)
		1425	return;
		1426
		1427	strm = compress_init ();
		1428	if (strm == NULL)
		1429	return;
		1430
6324	serge	1431	if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
		1432	{
		1433	stdoutput->flags \|= BFD_COMPRESS \| BFD_COMPRESS_GABI;
		1434	compression_header_size
		1435	= bfd_get_compression_header_size (stdoutput, NULL);
		1436	header_size = compression_header_size;
		1437	}
		1438	else
		1439	{
		1440	stdoutput->flags \|= BFD_COMPRESS;
		1441	compression_header_size = 0;
		1442	header_size = 12;
		1443	}
		1444
		1445	/* Create a new frag to contain the compression header. */
5222	serge	1446	first_newf = frag_alloc (ob);
6324	serge	1447	if (obstack_room (ob) < header_size)
5222	serge	1448	first_newf = frag_alloc (ob);
6324	serge	1449	if (obstack_room (ob) < header_size)
		1450	as_fatal (_("can't extend frag %u chars"), header_size);
5222	serge	1451	last_newf = first_newf;
6324	serge	1452	obstack_blank_fast (ob, header_size);
5222	serge	1453	last_newf->fr_type = rs_fill;
6324	serge	1454	last_newf->fr_fix = header_size;
5222	serge	1455	header = last_newf->fr_literal;
6324	serge	1456	compressed_size = header_size;
5222	serge	1457
		1458	/* Stream the frags through the compression engine, adding new frags
		1459	as necessary to accomodate the compressed output. */
		1460	for (f = seginfo->frchainP->frch_root;
		1461	f;
		1462	f = f->fr_next)
		1463	{
		1464	offsetT fill_size;
		1465	char *fill_literal;
		1466	offsetT count;
		1467	int out_size;
		1468
		1469	gas_assert (f->fr_type == rs_fill);
		1470	if (f->fr_fix)
		1471	{
		1472	out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
		1473	&last_newf, ob);
		1474	if (out_size < 0)
		1475	return;
		1476	compressed_size += out_size;
		1477	}
		1478	fill_literal = f->fr_literal + f->fr_fix;
		1479	fill_size = f->fr_var;
		1480	count = f->fr_offset;
		1481	gas_assert (count >= 0);
		1482	if (fill_size && count)
		1483	{
		1484	while (count--)
		1485	{
		1486	out_size = compress_frag (strm, fill_literal, (int) fill_size,
		1487	&last_newf, ob);
		1488	if (out_size < 0)
		1489	return;
		1490	compressed_size += out_size;
		1491	}
		1492	}
		1493	}
		1494
		1495	/* Flush the compression state. */
		1496	for (;;)
		1497	{
		1498	int avail_out;
		1499	char *next_out;
		1500	int out_size;
		1501
		1502	/* Reserve all the space available in the current chunk.
		1503	If none is available, start a new frag. */
		1504	avail_out = obstack_room (ob);
		1505	if (avail_out <= 0)
		1506	{
		1507	fragS *newf;
		1508
		1509	obstack_finish (ob);
		1510	newf = frag_alloc (ob);
		1511	newf->fr_type = rs_fill;
		1512	last_newf->fr_next = newf;
		1513	last_newf = newf;
		1514	avail_out = obstack_room (ob);
		1515	}
		1516	if (avail_out <= 0)
		1517	as_fatal (_("can't extend frag"));
		1518	next_out = obstack_next_free (ob);
		1519	obstack_blank_fast (ob, avail_out);
		1520	x = compress_finish (strm, &next_out, &avail_out, &out_size);
		1521	if (x < 0)
		1522	return;
		1523
		1524	last_newf->fr_fix += out_size;
		1525	compressed_size += out_size;
		1526
		1527	/* Return unused space. */
		1528	if (avail_out > 0)
		1529	obstack_blank_fast (ob, -avail_out);
		1530
		1531	if (x == 0)
		1532	break;
		1533	}
		1534
6324	serge	1535	/* PR binutils/18087: If compression didn't make the section smaller,
		1536	just keep it uncompressed. */
		1537	if (compressed_size >= uncompressed_size)
		1538	return;
		1539
5222	serge	1540	/* Replace the uncompressed frag list with the compressed frag list. */
		1541	seginfo->frchainP->frch_root = first_newf;
		1542	seginfo->frchainP->frch_last = last_newf;
		1543
		1544	/* Update the section size and its name. */
6324	serge	1545	bfd_update_compression_header (abfd, (bfd_byte *) header, sec);
5222	serge	1546	x = bfd_set_section_size (abfd, sec, compressed_size);
		1547	gas_assert (x);
6324	serge	1548	if (!compression_header_size)
		1549	{
5222	serge	1550	compressed_name = (char *) xmalloc (strlen (section_name) + 2);
		1551	compressed_name[0] = '.';
		1552	compressed_name[1] = 'z';
		1553	strcpy (compressed_name + 2, section_name + 1);
		1554	bfd_section_name (stdoutput, sec) = compressed_name;
6324	serge	1555	}
5222	serge	1556	}
		1557
		1558	static void
		1559	write_contents (bfd *abfd ATTRIBUTE_UNUSED,
		1560	asection *sec,
		1561	void *xxx ATTRIBUTE_UNUSED)
		1562	{
		1563	segment_info_type *seginfo = seg_info (sec);
		1564	addressT offset = 0;
		1565	fragS *f;
		1566
		1567	/* Write out the frags. */
		1568	if (seginfo == NULL
		1569	\|\| !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
		1570	return;
		1571
		1572	for (f = seginfo->frchainP->frch_root;
		1573	f;
		1574	f = f->fr_next)
		1575	{
		1576	int x;
		1577	addressT fill_size;
		1578	char *fill_literal;
		1579	offsetT count;
		1580
		1581	gas_assert (f->fr_type == rs_fill);
		1582	if (f->fr_fix)
		1583	{
		1584	x = bfd_set_section_contents (stdoutput, sec,
		1585	f->fr_literal, (file_ptr) offset,
		1586	(bfd_size_type) f->fr_fix);
		1587	if (!x)
6324	serge	1588	as_fatal (_("can't write %ld bytes to section %s of %s because: '%s'"),
		1589	(long) f->fr_fix, sec->name,
		1590	stdoutput->filename,
5222	serge	1591	bfd_errmsg (bfd_get_error ()));
		1592	offset += f->fr_fix;
		1593	}
		1594	fill_literal = f->fr_literal + f->fr_fix;
		1595	fill_size = f->fr_var;
		1596	count = f->fr_offset;
		1597	gas_assert (count >= 0);
		1598	if (fill_size && count)
		1599	{
		1600	char buf[256];
		1601	if (fill_size > sizeof (buf))
		1602	{
		1603	/* Do it the old way. Can this ever happen? */
		1604	while (count--)
		1605	{
		1606	x = bfd_set_section_contents (stdoutput, sec,
		1607	fill_literal,
		1608	(file_ptr) offset,
		1609	(bfd_size_type) fill_size);
		1610	if (!x)
6324	serge	1611	as_fatal (_("can't fill %ld bytes in section %s of %s because '%s'"),
		1612	(long) fill_size, sec->name,
		1613	stdoutput->filename,
5222	serge	1614	bfd_errmsg (bfd_get_error ()));
		1615	offset += fill_size;
		1616	}
		1617	}
		1618	else
		1619	{
		1620	/* Build a buffer full of fill objects and output it as
		1621	often as necessary. This saves on the overhead of
		1622	potentially lots of bfd_set_section_contents calls. */
		1623	int n_per_buf, i;
		1624	if (fill_size == 1)
		1625	{
		1626	n_per_buf = sizeof (buf);
		1627	memset (buf, *fill_literal, n_per_buf);
		1628	}
		1629	else
		1630	{
		1631	char *bufp;
		1632	n_per_buf = sizeof (buf) / fill_size;
		1633	for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
		1634	memcpy (bufp, fill_literal, fill_size);
		1635	}
		1636	for (; count > 0; count -= n_per_buf)
		1637	{
		1638	n_per_buf = n_per_buf > count ? count : n_per_buf;
		1639	x = bfd_set_section_contents
		1640	(stdoutput, sec, buf, (file_ptr) offset,
		1641	(bfd_size_type) n_per_buf * fill_size);
		1642	if (!x)
6324	serge	1643	as_fatal (_("cannot fill %ld bytes in section %s of %s because: '%s'"),
		1644	(long)(n_per_buf * fill_size), sec->name,
5222	serge	1645	stdoutput->filename,
		1646	bfd_errmsg (bfd_get_error ()));
		1647	offset += n_per_buf * fill_size;
		1648	}
		1649	}
		1650	}
		1651	}
		1652	}
		1653
		1654	static void
		1655	merge_data_into_text (void)
		1656	{
		1657	seg_info (text_section)->frchainP->frch_last->fr_next =
		1658	seg_info (data_section)->frchainP->frch_root;
		1659	seg_info (text_section)->frchainP->frch_last =
		1660	seg_info (data_section)->frchainP->frch_last;
		1661	seg_info (data_section)->frchainP = 0;
		1662	}
		1663
		1664	static void
		1665	set_symtab (void)
		1666	{
		1667	int nsyms;
		1668	asymbol **asympp;
		1669	symbolS *symp;
		1670	bfd_boolean result;
		1671
		1672	/* Count symbols. We can't rely on a count made by the loop in
		1673	write_object_file, because *_frob_file may add a new symbol or
		1674	two. */
		1675	nsyms = 0;
		1676	for (symp = symbol_rootP; symp; symp = symbol_next (symp))
		1677	nsyms++;
		1678
		1679	if (nsyms)
		1680	{
		1681	int i;
		1682	bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
		1683
		1684	asympp = (asymbol **) bfd_alloc (stdoutput, amt);
		1685	symp = symbol_rootP;
		1686	for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
		1687	{
		1688	asympp[i] = symbol_get_bfdsym (symp);
		1689	if (asympp[i]->flags != BSF_SECTION_SYM
		1690	\|\| !(bfd_is_const_section (asympp[i]->section)
		1691	&& asympp[i]->section->symbol == asympp[i]))
		1692	asympp[i]->flags \|= BSF_KEEP;
		1693	symbol_mark_written (symp);
		1694	}
		1695	}
		1696	else
		1697	asympp = 0;
		1698	result = bfd_set_symtab (stdoutput, asympp, nsyms);
		1699	gas_assert (result);
		1700	symbol_table_frozen = 1;
		1701	}
		1702
		1703	/* Finish the subsegments. After every sub-segment, we fake an
		1704	".align ...". This conforms to BSD4.2 brane-damage. We then fake
		1705	".fill 0" because that is the kind of frag that requires least
		1706	thought. ".align" frags like to have a following frag since that
		1707	makes calculating their intended length trivial. */
		1708
		1709	#ifndef SUB_SEGMENT_ALIGN
		1710	#ifdef HANDLE_ALIGN
		1711	/* The last subsegment gets an alignment corresponding to the alignment
		1712	of the section. This allows proper nop-filling at the end of
		1713	code-bearing sections. */
		1714	#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
6324	serge	1715	(!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
		1716	? get_recorded_alignment (SEG) \
		1717	: 0)
5222	serge	1718	#else
		1719	#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
		1720	#endif
		1721	#endif
		1722
6324	serge	1723	static void
		1724	subsegs_finish_section (asection *s)
5222	serge	1725	{
		1726	struct frchain *frchainP;
		1727	segment_info_type *seginfo = seg_info (s);
		1728	if (!seginfo)
6324	serge	1729	return;
5222	serge	1730
		1731	for (frchainP = seginfo->frchainP;
		1732	frchainP != NULL;
		1733	frchainP = frchainP->frch_next)
		1734	{
		1735	int alignment = 0;
		1736
		1737	subseg_set (s, frchainP->frch_subseg);
		1738
		1739	/* This now gets called even if we had errors. In that case,
		1740	any alignment is meaningless, and, moreover, will look weird
		1741	if we are generating a listing. */
		1742	if (!had_errors ())
		1743	{
		1744	alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
		1745	if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
		1746	&& now_seg->entsize)
		1747	{
		1748	unsigned int entsize = now_seg->entsize;
		1749	int entalign = 0;
		1750
		1751	while ((entsize & 1) == 0)
		1752	{
		1753	++entalign;
		1754	entsize >>= 1;
		1755	}
6324	serge	1756
5222	serge	1757	if (entalign > alignment)
		1758	alignment = entalign;
		1759	}
		1760	}
		1761
		1762	if (subseg_text_p (now_seg))
		1763	frag_align_code (alignment, 0);
		1764	else
		1765	frag_align (alignment, 0, 0);
		1766
		1767	/* frag_align will have left a new frag.
		1768	Use this last frag for an empty ".fill".
		1769
		1770	For this segment ...
		1771	Create a last frag. Do not leave a "being filled in frag". */
		1772	frag_wane (frag_now);
		1773	frag_now->fr_fix = 0;
		1774	know (frag_now->fr_next == NULL);
		1775	}
6324	serge	1776	}
		1777
		1778	static void
		1779	subsegs_finish (void)
		1780	{
		1781	asection *s;
		1782
		1783	for (s = stdoutput->sections; s; s = s->next)
		1784	subsegs_finish_section (s);
		1785	}
		1786
		1787	#ifdef OBJ_ELF
		1788	static void
		1789	create_obj_attrs_section (void)
		1790	{
		1791	segT s;
		1792	char *p;
		1793	offsetT size;
		1794	const char *name;
		1795
		1796	size = bfd_elf_obj_attr_size (stdoutput);
		1797	if (size)
		1798	{
		1799	name = get_elf_backend_data (stdoutput)->obj_attrs_section;
		1800	if (!name)
		1801	name = ".gnu.attributes";
		1802	s = subseg_new (name, 0);
		1803	elf_section_type (s)
		1804	= get_elf_backend_data (stdoutput)->obj_attrs_section_type;
		1805	bfd_set_section_flags (stdoutput, s, SEC_READONLY \| SEC_DATA);
		1806	frag_now_fix ();
		1807	p = frag_more (size);
		1808	bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
		1809
		1810	subsegs_finish_section (s);
		1811	relax_segment (seg_info (s)->frchainP->frch_root, s, 0);
		1812	size_seg (stdoutput, s, NULL);
5222	serge	1813	}
		1814	}
6324	serge	1815	#endif
5222	serge	1816
		1817	/* Write the object file. */
		1818
		1819	void
		1820	write_object_file (void)
		1821	{
		1822	struct relax_seg_info rsi;
		1823	#ifndef WORKING_DOT_WORD
		1824	fragS fragP; / Track along all frags. */
		1825	#endif
		1826
6324	serge	1827	subsegs_finish ();
		1828
5222	serge	1829	#ifdef md_pre_output_hook
		1830	md_pre_output_hook;
		1831	#endif
		1832
		1833	#ifdef md_pre_relax_hook
		1834	md_pre_relax_hook;
		1835	#endif
		1836
		1837	/* From now on, we don't care about sub-segments. Build one frag chain
		1838	for each segment. Linked thru fr_next. */
		1839
		1840	/* Remove the sections created by gas for its own purposes. */
		1841	{
		1842	int i;
		1843
		1844	bfd_section_list_remove (stdoutput, reg_section);
		1845	bfd_section_list_remove (stdoutput, expr_section);
		1846	stdoutput->section_count -= 2;
		1847	i = 0;
		1848	bfd_map_over_sections (stdoutput, renumber_sections, &i);
		1849	}
		1850
		1851	bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
		1852
		1853	/* We have two segments. If user gave -R flag, then we must put the
		1854	data frags into the text segment. Do this before relaxing so
		1855	we know to take advantage of -R and make shorter addresses. */
		1856	if (flag_readonly_data_in_text)
		1857	{
		1858	merge_data_into_text ();
		1859	}
		1860
		1861	rsi.pass = 0;
		1862	while (1)
		1863	{
		1864	#ifndef WORKING_DOT_WORD
		1865	/* We need to reset the markers in the broken word list and
		1866	associated frags between calls to relax_segment (via
		1867	relax_seg). Since the broken word list is global, we do it
		1868	once per round, rather than locally in relax_segment for each
		1869	segment. */
		1870	struct broken_word *brokp;
		1871
		1872	for (brokp = broken_words;
		1873	brokp != (struct broken_word *) NULL;
		1874	brokp = brokp->next_broken_word)
		1875	{
		1876	brokp->added = 0;
		1877
		1878	if (brokp->dispfrag != (fragS *) NULL
		1879	&& brokp->dispfrag->fr_type == rs_broken_word)
		1880	brokp->dispfrag->fr_subtype = 0;
		1881	}
		1882	#endif
		1883
		1884	rsi.changed = 0;
		1885	bfd_map_over_sections (stdoutput, relax_seg, &rsi);
		1886	rsi.pass++;
		1887	if (!rsi.changed)
		1888	break;
		1889	}
		1890
		1891	/* Note - Most ports will use the default value of
		1892	TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
		1893	local symbols to be resolved, removing their frag information.
		1894	Some ports however, will not have finished relaxing all of
		1895	their frags and will still need the local symbol frag
		1896	information. These ports can set
		1897	TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
		1898	finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
		1899
		1900	bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
		1901
		1902	/* Relaxation has completed. Freeze all syms. */
		1903	finalize_syms = 1;
		1904
		1905	#ifdef md_post_relax_hook
		1906	md_post_relax_hook;
		1907	#endif
		1908
6324	serge	1909	#ifdef OBJ_ELF
		1910	if (IS_ELF)
		1911	create_obj_attrs_section ();
		1912	#endif
		1913
5222	serge	1914	#ifndef WORKING_DOT_WORD
		1915	{
		1916	struct broken_word *lie;
		1917	struct broken_word **prevP;
		1918
		1919	prevP = &broken_words;
		1920	for (lie = broken_words; lie; lie = lie->next_broken_word)
		1921	if (!lie->added)
		1922	{
		1923	expressionS exp;
		1924
		1925	subseg_change (lie->seg, lie->subseg);
		1926	exp.X_op = O_subtract;
		1927	exp.X_add_symbol = lie->add;
		1928	exp.X_op_symbol = lie->sub;
		1929	exp.X_add_number = lie->addnum;
		1930	#ifdef TC_CONS_FIX_NEW
		1931	TC_CONS_FIX_NEW (lie->frag,
		1932	lie->word_goes_here - lie->frag->fr_literal,
6324	serge	1933	2, &exp, TC_PARSE_CONS_RETURN_NONE);
5222	serge	1934	#else
		1935	fix_new_exp (lie->frag,
		1936	lie->word_goes_here - lie->frag->fr_literal,
		1937	2, &exp, 0, BFD_RELOC_16);
		1938	#endif
		1939	*prevP = lie->next_broken_word;
		1940	}
		1941	else
		1942	prevP = &(lie->next_broken_word);
		1943
		1944	for (lie = broken_words; lie;)
		1945	{
		1946	struct broken_word *untruth;
		1947	char *table_ptr;
		1948	addressT table_addr;
		1949	addressT from_addr, to_addr;
		1950	int n, m;
		1951
		1952	subseg_change (lie->seg, lie->subseg);
		1953	fragP = lie->dispfrag;
		1954
		1955	/* Find out how many broken_words go here. */
		1956	n = 0;
		1957	for (untruth = lie;
		1958	untruth && untruth->dispfrag == fragP;
		1959	untruth = untruth->next_broken_word)
		1960	if (untruth->added == 1)
		1961	n++;
		1962
		1963	table_ptr = lie->dispfrag->fr_opcode;
		1964	table_addr = (lie->dispfrag->fr_address
		1965	+ (table_ptr - lie->dispfrag->fr_literal));
		1966	/* Create the jump around the long jumps. This is a short
		1967	jump from table_ptr+0 to table_ptr+nlong_jump_size. /
		1968	from_addr = table_addr;
		1969	to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
		1970	md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
		1971	lie->add);
		1972	table_ptr += md_short_jump_size;
		1973	table_addr += md_short_jump_size;
		1974
		1975	for (m = 0;
		1976	lie && lie->dispfrag == fragP;
		1977	m++, lie = lie->next_broken_word)
		1978	{
		1979	if (lie->added == 2)
		1980	continue;
		1981	/* Patch the jump table. */
		1982	for (untruth = (struct broken_word *) (fragP->fr_symbol);
		1983	untruth && untruth->dispfrag == fragP;
		1984	untruth = untruth->next_broken_word)
		1985	{
		1986	if (untruth->use_jump == lie)
		1987	{
		1988	/* This is the offset from ??? to table_ptr+0.
		1989	The target is the same for all users of this
		1990	md_long_jump, but the "sub" bases (and hence the
		1991	offsets) may be different. */
		1992	addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
		1993	#ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
		1994	TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
		1995	#endif
		1996	md_number_to_chars (untruth->word_goes_here, to_word, 2);
		1997	}
		1998	}
		1999
		2000	/* Install the long jump. */
		2001	/* This is a long jump from table_ptr+0 to the final target. */
		2002	from_addr = table_addr;
		2003	to_addr = S_GET_VALUE (lie->add) + lie->addnum;
		2004	md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
		2005	lie->add);
		2006	table_ptr += md_long_jump_size;
		2007	table_addr += md_long_jump_size;
		2008	}
		2009	}
		2010	}
		2011	#endif /* not WORKING_DOT_WORD */
		2012
		2013	/* Resolve symbol values. This needs to be done before processing
		2014	the relocations. */
		2015	if (symbol_rootP)
		2016	{
		2017	symbolS *symp;
		2018
		2019	for (symp = symbol_rootP; symp; symp = symbol_next (symp))
		2020	resolve_symbol_value (symp);
		2021	}
		2022	resolve_local_symbol_values ();
		2023	resolve_reloc_expr_symbols ();
		2024
		2025	PROGRESS (1);
		2026
		2027	#ifdef tc_frob_file_before_adjust
		2028	tc_frob_file_before_adjust ();
		2029	#endif
		2030	#ifdef obj_frob_file_before_adjust
		2031	obj_frob_file_before_adjust ();
		2032	#endif
		2033
		2034	bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
		2035
		2036	#ifdef tc_frob_file_before_fix
		2037	tc_frob_file_before_fix ();
		2038	#endif
		2039	#ifdef obj_frob_file_before_fix
		2040	obj_frob_file_before_fix ();
		2041	#endif
		2042
		2043	bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
		2044
		2045	/* Set up symbol table, and write it out. */
		2046	if (symbol_rootP)
		2047	{
		2048	symbolS *symp;
		2049	bfd_boolean skip_next_symbol = FALSE;
		2050
		2051	for (symp = symbol_rootP; symp; symp = symbol_next (symp))
		2052	{
		2053	int punt = 0;
		2054	const char *name;
		2055
		2056	if (skip_next_symbol)
		2057	{
		2058	/* Don't do anything besides moving the value of the
		2059	symbol from the GAS value-field to the BFD value-field. */
		2060	symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
		2061	skip_next_symbol = FALSE;
		2062	continue;
		2063	}
		2064
		2065	if (symbol_mri_common_p (symp))
		2066	{
		2067	if (S_IS_EXTERNAL (symp))
		2068	as_bad (_("%s: global symbols not supported in common sections"),
		2069	S_GET_NAME (symp));
		2070	symbol_remove (symp, &symbol_rootP, &symbol_lastP);
		2071	continue;
		2072	}
		2073
		2074	name = S_GET_NAME (symp);
		2075	if (name)
		2076	{
		2077	const char *name2 =
		2078	decode_local_label_name ((char *) S_GET_NAME (symp));
		2079	/* They only differ if `name' is a fb or dollar local
		2080	label name. */
		2081	if (name2 != name && ! S_IS_DEFINED (symp))
		2082	as_bad (_("local label `%s' is not defined"), name2);
		2083	}
		2084
		2085	/* Do it again, because adjust_reloc_syms might introduce
		2086	more symbols. They'll probably only be section symbols,
		2087	but they'll still need to have the values computed. */
		2088	resolve_symbol_value (symp);
		2089
		2090	/* Skip symbols which were equated to undefined or common
		2091	symbols. */
		2092	if (symbol_equated_reloc_p (symp)
		2093	\|\| S_IS_WEAKREFR (symp))
		2094	{
		2095	const char *sname = S_GET_NAME (symp);
		2096
		2097	if (S_IS_COMMON (symp)
		2098	&& !TC_FAKE_LABEL (sname)
		2099	&& !S_IS_WEAKREFR (symp)
		2100	&& (!S_IS_EXTERNAL (symp) \|\| S_IS_LOCAL (symp)))
		2101	{
		2102	expressionS *e = symbol_get_value_expression (symp);
		2103
		2104	as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
		2105	sname, S_GET_NAME (e->X_add_symbol));
		2106	}
		2107	if (S_GET_SEGMENT (symp) == reg_section)
		2108	{
		2109	/* Report error only if we know the symbol name. */
		2110	if (S_GET_NAME (symp) != reg_section->name)
		2111	as_bad (_("can't make global register symbol `%s'"),
		2112	sname);
		2113	}
		2114	symbol_remove (symp, &symbol_rootP, &symbol_lastP);
		2115	continue;
		2116	}
		2117
		2118	#ifdef obj_frob_symbol
		2119	obj_frob_symbol (symp, punt);
		2120	#endif
		2121	#ifdef tc_frob_symbol
		2122	if (! punt \|\| symbol_used_in_reloc_p (symp))
		2123	tc_frob_symbol (symp, punt);
		2124	#endif
		2125
		2126	/* If we don't want to keep this symbol, splice it out of
		2127	the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
		2128	want section symbols. Otherwise, we skip local symbols
		2129	and symbols that the frob_symbol macros told us to punt,
		2130	but we keep such symbols if they are used in relocs. */
		2131	if (symp == abs_section_sym
		2132	\|\| (! EMIT_SECTION_SYMBOLS
		2133	&& symbol_section_p (symp))
		2134	/* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
		2135	opposites. Sometimes the former checks flags and the
		2136	latter examines the name... */
		2137	\|\| (!S_IS_EXTERNAL (symp)
		2138	&& (punt \|\| S_IS_LOCAL (symp) \|\|
		2139	(S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
		2140	&& ! symbol_used_in_reloc_p (symp)))
		2141	{
		2142	symbol_remove (symp, &symbol_rootP, &symbol_lastP);
		2143
		2144	/* After symbol_remove, symbol_next(symp) still returns
		2145	the one that came after it in the chain. So we don't
		2146	need to do any extra cleanup work here. */
		2147	continue;
		2148	}
		2149
		2150	/* Make sure we really got a value for the symbol. */
		2151	if (! symbol_resolved_p (symp))
		2152	{
		2153	as_bad (_("can't resolve value for symbol `%s'"),
		2154	S_GET_NAME (symp));
		2155	symbol_mark_resolved (symp);
		2156	}
		2157
		2158	/* Set the value into the BFD symbol. Up til now the value
		2159	has only been kept in the gas symbolS struct. */
		2160	symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
		2161
		2162	/* A warning construct is a warning symbol followed by the
		2163	symbol warned about. Don't let anything object-format or
		2164	target-specific muck with it; it's ready for output. */
		2165	if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
		2166	skip_next_symbol = TRUE;
		2167	}
		2168	}
		2169
		2170	PROGRESS (1);
		2171
		2172	/* Now do any format-specific adjustments to the symbol table, such
		2173	as adding file symbols. */
		2174	#ifdef tc_adjust_symtab
		2175	tc_adjust_symtab ();
		2176	#endif
		2177	#ifdef obj_adjust_symtab
		2178	obj_adjust_symtab ();
		2179	#endif
		2180
		2181	/* Stop if there is an error. */
		2182	if (had_errors ())
		2183	return;
		2184
		2185	/* Now that all the sizes are known, and contents correct, we can
		2186	start writing to the file. */
		2187	set_symtab ();
		2188
		2189	/* If *_frob_file changes the symbol value at this point, it is
		2190	responsible for moving the changed value into symp->bsym->value
		2191	as well. Hopefully all symbol value changing can be done in
		2192	_frob_symbol. /
		2193	#ifdef tc_frob_file
		2194	tc_frob_file ();
		2195	#endif
		2196	#ifdef obj_frob_file
		2197	obj_frob_file ();
		2198	#endif
		2199	#ifdef obj_coff_generate_pdata
		2200	obj_coff_generate_pdata ();
		2201	#endif
		2202	bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
		2203
		2204	#ifdef tc_frob_file_after_relocs
		2205	tc_frob_file_after_relocs ();
		2206	#endif
		2207	#ifdef obj_frob_file_after_relocs
		2208	obj_frob_file_after_relocs ();
		2209	#endif
		2210
		2211	/* Once all relocations have been written, we can compress the
		2212	contents of the debug sections. This needs to be done before
		2213	we start writing any sections, because it will affect the file
		2214	layout, which is fixed once we start writing contents. */
		2215	if (flag_compress_debug)
		2216	bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
		2217
		2218	bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
		2219	}
		2220
		2221	#ifdef TC_GENERIC_RELAX_TABLE
		2222	/* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
		2223
		2224	long
		2225	relax_frag (segT segment, fragS *fragP, long stretch)
		2226	{
		2227	const relax_typeS *this_type;
		2228	const relax_typeS *start_type;
		2229	relax_substateT next_state;
		2230	relax_substateT this_state;
		2231	offsetT growth;
		2232	offsetT aim;
		2233	addressT target;
		2234	addressT address;
		2235	symbolS *symbolP;
		2236	const relax_typeS *table;
		2237
		2238	target = fragP->fr_offset;
		2239	address = fragP->fr_address;
		2240	table = TC_GENERIC_RELAX_TABLE;
		2241	this_state = fragP->fr_subtype;
		2242	start_type = this_type = table + this_state;
		2243	symbolP = fragP->fr_symbol;
		2244
		2245	if (symbolP)
		2246	{
		2247	fragS *sym_frag;
		2248
		2249	sym_frag = symbol_get_frag (symbolP);
		2250
		2251	#ifndef DIFF_EXPR_OK
		2252	know (sym_frag != NULL);
		2253	#endif
		2254	know (S_GET_SEGMENT (symbolP) != absolute_section
		2255	\|\| sym_frag == &zero_address_frag);
		2256	target += S_GET_VALUE (symbolP);
		2257
		2258	/* If SYM_FRAG has yet to be reached on this pass, assume it
		2259	will move by STRETCH just as we did, unless there is an
		2260	alignment frag between here and SYM_FRAG. An alignment may
		2261	well absorb any STRETCH, and we don't want to choose a larger
		2262	branch insn by overestimating the needed reach of this
		2263	branch. It isn't critical to calculate TARGET exactly; We
		2264	know we'll be doing another pass if STRETCH is non-zero. */
		2265
		2266	if (stretch != 0
		2267	&& sym_frag->relax_marker != fragP->relax_marker
		2268	&& S_GET_SEGMENT (symbolP) == segment)
		2269	{
		2270	if (stretch < 0
		2271	\|\| sym_frag->region == fragP->region)
		2272	target += stretch;
		2273	/* If we get here we know we have a forward branch. This
		2274	relax pass may have stretched previous instructions so
		2275	far that omitting STRETCH would make the branch
		2276	negative. Don't allow this in case the negative reach is
		2277	large enough to require a larger branch instruction. */
		2278	else if (target < address)
		2279	target = fragP->fr_next->fr_address + stretch;
		2280	}
		2281	}
		2282
		2283	aim = target - address - fragP->fr_fix;
		2284	#ifdef TC_PCREL_ADJUST
		2285	/* Currently only the ns32k family needs this. */
		2286	aim += TC_PCREL_ADJUST (fragP);
		2287	#endif
		2288
		2289	#ifdef md_prepare_relax_scan
		2290	/* Formerly called M68K_AIM_KLUDGE. */
		2291	md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
		2292	#endif
		2293
		2294	if (aim < 0)
		2295	{
		2296	/* Look backwards. */
		2297	for (next_state = this_type->rlx_more; next_state;)
		2298	if (aim >= this_type->rlx_backward)
		2299	next_state = 0;
		2300	else
		2301	{
		2302	/* Grow to next state. */
		2303	this_state = next_state;
		2304	this_type = table + this_state;
		2305	next_state = this_type->rlx_more;
		2306	}
		2307	}
		2308	else
		2309	{
		2310	/* Look forwards. */
		2311	for (next_state = this_type->rlx_more; next_state;)
		2312	if (aim <= this_type->rlx_forward)
		2313	next_state = 0;
		2314	else
		2315	{
		2316	/* Grow to next state. */
		2317	this_state = next_state;
		2318	this_type = table + this_state;
		2319	next_state = this_type->rlx_more;
		2320	}
		2321	}
		2322
		2323	growth = this_type->rlx_length - start_type->rlx_length;
		2324	if (growth != 0)
		2325	fragP->fr_subtype = this_state;
		2326	return growth;
		2327	}
		2328
		2329	#endif /* defined (TC_GENERIC_RELAX_TABLE) */
		2330
		2331	/* Relax_align. Advance location counter to next address that has 'alignment'
		2332	lowest order bits all 0s, return size of adjustment made. */
		2333	static relax_addressT
6324	serge	2334	relax_align (relax_addressT address, /* Address now. */
		2335	int alignment /* Alignment (binary). */)
5222	serge	2336	{
		2337	relax_addressT mask;
		2338	relax_addressT new_address;
		2339
6324	serge	2340	mask = ~((relax_addressT) ~0 << alignment);
5222	serge	2341	new_address = (address + mask) & (~mask);
		2342	#ifdef LINKER_RELAXING_SHRINKS_ONLY
		2343	if (linkrelax)
		2344	/* We must provide lots of padding, so the linker can discard it
		2345	when needed. The linker will not add extra space, ever. */
		2346	new_address += (1 << alignment);
		2347	#endif
		2348	return (new_address - address);
		2349	}
		2350
		2351	/* Now we have a segment, not a crowd of sub-segments, we can make
		2352	fr_address values.
		2353
		2354	Relax the frags.
		2355
		2356	After this, all frags in this segment have addresses that are correct
		2357	within the segment. Since segments live in different file addresses,
		2358	these frag addresses may not be the same as final object-file
		2359	addresses. */
		2360
		2361	int
		2362	relax_segment (struct frag *segment_frag_root, segT segment, int pass)
		2363	{
		2364	unsigned long frag_count;
		2365	struct frag *fragP;
		2366	relax_addressT address;
		2367	int region;
		2368	int ret;
		2369
		2370	/* In case md_estimate_size_before_relax() wants to make fixSs. */
		2371	subseg_change (segment, 0);
		2372
		2373	/* For each frag in segment: count and store (a 1st guess of)
		2374	fr_address. */
		2375	address = 0;
		2376	region = 0;
		2377	for (frag_count = 0, fragP = segment_frag_root;
		2378	fragP;
		2379	fragP = fragP->fr_next, frag_count ++)
		2380	{
		2381	fragP->region = region;
		2382	fragP->relax_marker = 0;
		2383	fragP->fr_address = address;
		2384	address += fragP->fr_fix;
		2385
		2386	switch (fragP->fr_type)
		2387	{
		2388	case rs_fill:
		2389	address += fragP->fr_offset * fragP->fr_var;
		2390	break;
		2391
		2392	case rs_align:
		2393	case rs_align_code:
		2394	case rs_align_test:
		2395	{
		2396	addressT offset = relax_align (address, (int) fragP->fr_offset);
		2397
		2398	if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
		2399	offset = 0;
		2400
		2401	if (offset % fragP->fr_var != 0)
		2402	{
		2403	as_bad_where (fragP->fr_file, fragP->fr_line,
		2404	_("alignment padding (%lu bytes) not a multiple of %ld"),
		2405	(unsigned long) offset, (long) fragP->fr_var);
		2406	offset -= (offset % fragP->fr_var);
		2407	}
		2408
		2409	address += offset;
		2410	region += 1;
		2411	}
		2412	break;
		2413
		2414	case rs_org:
		2415	/* Assume .org is nugatory. It will grow with 1st relax. */
		2416	region += 1;
		2417	break;
		2418
		2419	case rs_space:
		2420	break;
		2421
		2422	case rs_machine_dependent:
		2423	/* If fr_symbol is an expression, this call to
		2424	resolve_symbol_value sets up the correct segment, which will
		2425	likely be needed in md_estimate_size_before_relax. */
		2426	if (fragP->fr_symbol)
		2427	resolve_symbol_value (fragP->fr_symbol);
		2428
		2429	address += md_estimate_size_before_relax (fragP, segment);
		2430	break;
		2431
		2432	#ifndef WORKING_DOT_WORD
		2433	/* Broken words don't concern us yet. */
		2434	case rs_broken_word:
		2435	break;
		2436	#endif
		2437
		2438	case rs_leb128:
		2439	/* Initial guess is always 1; doing otherwise can result in
		2440	stable solutions that are larger than the minimum. */
		2441	address += fragP->fr_offset = 1;
		2442	break;
		2443
		2444	case rs_cfa:
		2445	address += eh_frame_estimate_size_before_relax (fragP);
		2446	break;
		2447
		2448	case rs_dwarf2dbg:
		2449	address += dwarf2dbg_estimate_size_before_relax (fragP);
		2450	break;
		2451
		2452	default:
		2453	BAD_CASE (fragP->fr_type);
		2454	break;
		2455	}
		2456	}
		2457
		2458	/* Do relax(). */
		2459	{
		2460	unsigned long max_iterations;
		2461
		2462	/* Cumulative address adjustment. */
		2463	offsetT stretch;
		2464
		2465	/* Have we made any adjustment this pass? We can't just test
		2466	stretch because one piece of code may have grown and another
		2467	shrank. */
		2468	int stretched;
		2469
		2470	/* Most horrible, but gcc may give us some exception data that
		2471	is impossible to assemble, of the form
		2472
		2473	.align 4
		2474	.byte 0, 0
		2475	.uleb128 end - start
		2476	start:
		2477	.space 128*128 - 1
		2478	.align 4
		2479	end:
		2480
		2481	If the leb128 is two bytes in size, then end-start is 128*128,
		2482	which requires a three byte leb128. If the leb128 is three
		2483	bytes in size, then end-start is 128*128-1, which requires a
		2484	two byte leb128. We work around this dilemma by inserting
		2485	an extra 4 bytes of alignment just after the .align. This
		2486	works because the data after the align is accessed relative to
		2487	the end label.
		2488
		2489	This counter is used in a tiny state machine to detect
		2490	whether a leb128 followed by an align is impossible to
		2491	relax. */
		2492	int rs_leb128_fudge = 0;
		2493
		2494	/* We want to prevent going into an infinite loop where one frag grows
		2495	depending upon the location of a symbol which is in turn moved by
		2496	the growing frag. eg:
		2497
		2498	foo = .
		2499	.org foo+16
		2500	foo = .
		2501
		2502	So we dictate that this algorithm can be at most O2. */
		2503	max_iterations = frag_count * frag_count;
		2504	/* Check for overflow. */
		2505	if (max_iterations < frag_count)
		2506	max_iterations = frag_count;
		2507
		2508	ret = 0;
		2509	do
		2510	{
		2511	stretch = 0;
		2512	stretched = 0;
		2513
		2514	for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
		2515	{
		2516	offsetT growth = 0;
		2517	addressT was_address;
		2518	offsetT offset;
		2519	symbolS *symbolP;
		2520
		2521	fragP->relax_marker ^= 1;
		2522	was_address = fragP->fr_address;
		2523	address = fragP->fr_address += stretch;
		2524	symbolP = fragP->fr_symbol;
		2525	offset = fragP->fr_offset;
		2526
		2527	switch (fragP->fr_type)
		2528	{
		2529	case rs_fill: /* .fill never relaxes. */
		2530	growth = 0;
		2531	break;
		2532
		2533	#ifndef WORKING_DOT_WORD
		2534	/* JF: This is RMS's idea. I do NOT want to be blamed
		2535	for it I do not want to write it. I do not want to have
		2536	anything to do with it. This is not the proper way to
		2537	implement this misfeature. */
		2538	case rs_broken_word:
		2539	{
		2540	struct broken_word *lie;
		2541	struct broken_word *untruth;
		2542
		2543	/* Yes this is ugly (storing the broken_word pointer
		2544	in the symbol slot). Still, this whole chunk of
		2545	code is ugly, and I don't feel like doing anything
		2546	about it. Think of it as stubbornness in action. */
		2547	growth = 0;
		2548	for (lie = (struct broken_word *) (fragP->fr_symbol);
		2549	lie && lie->dispfrag == fragP;
		2550	lie = lie->next_broken_word)
		2551	{
		2552
		2553	if (lie->added)
		2554	continue;
		2555
		2556	offset = (S_GET_VALUE (lie->add)
		2557	+ lie->addnum
		2558	- S_GET_VALUE (lie->sub));
		2559	if (offset <= -32768 \|\| offset >= 32767)
		2560	{
		2561	if (flag_warn_displacement)
		2562	{
		2563	char buf[50];
		2564	sprint_value (buf, (addressT) lie->addnum);
		2565	as_warn_where (fragP->fr_file, fragP->fr_line,
		2566	_(".word %s-%s+%s didn't fit"),
		2567	S_GET_NAME (lie->add),
		2568	S_GET_NAME (lie->sub),
		2569	buf);
		2570	}
		2571	if (fragP->fr_subtype == 0)
		2572	{
		2573	fragP->fr_subtype++;
		2574	growth += md_short_jump_size;
		2575	}
		2576
		2577	/* Redirect all words of this table with the same
		2578	target, lest we have to handle the case where the
		2579	same target but with a offset that fits on this
		2580	round overflows at the next relaxation round. */
		2581	for (untruth = (struct broken_word *) (fragP->fr_symbol);
		2582	untruth && untruth->dispfrag == lie->dispfrag;
		2583	untruth = untruth->next_broken_word)
		2584	if ((symbol_get_frag (untruth->add)
		2585	== symbol_get_frag (lie->add))
		2586	&& (S_GET_VALUE (untruth->add)
		2587	== S_GET_VALUE (lie->add)))
		2588	{
		2589	untruth->added = 2;
		2590	untruth->use_jump = lie;
		2591	}
		2592
		2593	lie->added = 1;
		2594	growth += md_long_jump_size;
		2595	}
		2596	}
		2597
		2598	break;
		2599	} /* case rs_broken_word */
		2600	#endif
		2601	case rs_align:
		2602	case rs_align_code:
		2603	case rs_align_test:
		2604	{
		2605	addressT oldoff, newoff;
		2606
		2607	oldoff = relax_align (was_address + fragP->fr_fix,
		2608	(int) offset);
		2609	newoff = relax_align (address + fragP->fr_fix,
		2610	(int) offset);
		2611
		2612	if (fragP->fr_subtype != 0)
		2613	{
		2614	if (oldoff > fragP->fr_subtype)
		2615	oldoff = 0;
		2616	if (newoff > fragP->fr_subtype)
		2617	newoff = 0;
		2618	}
		2619
		2620	growth = newoff - oldoff;
		2621
		2622	/* If this align happens to follow a leb128 and
		2623	we have determined that the leb128 is bouncing
		2624	in size, then break the cycle by inserting an
		2625	extra alignment. */
		2626	if (growth < 0
		2627	&& (rs_leb128_fudge & 16) != 0
		2628	&& (rs_leb128_fudge & 15) >= 2)
		2629	{
		2630	segment_info_type *seginfo = seg_info (segment);
		2631	struct obstack *ob = &seginfo->frchainP->frch_obstack;
		2632	struct frag *newf;
		2633
		2634	newf = frag_alloc (ob);
		2635	obstack_blank_fast (ob, fragP->fr_var);
		2636	obstack_finish (ob);
		2637	memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
		2638	memcpy (newf->fr_literal,
		2639	fragP->fr_literal + fragP->fr_fix,
		2640	fragP->fr_var);
		2641	newf->fr_type = rs_fill;
		2642	newf->fr_address = address + fragP->fr_fix + newoff;
		2643	newf->fr_fix = 0;
		2644	newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
		2645	/ fragP->fr_var);
		2646	if (newf->fr_offset * newf->fr_var
		2647	!= (offsetT) 1 << fragP->fr_offset)
		2648	{
		2649	newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
		2650	newf->fr_var = 1;
		2651	}
		2652	/* Include size of new frag in GROWTH. */
		2653	growth += newf->fr_offset * newf->fr_var;
		2654	/* Adjust the new frag address for the amount
		2655	we'll add when we process the new frag. */
		2656	newf->fr_address -= stretch + growth;
		2657	newf->relax_marker ^= 1;
		2658	fragP->fr_next = newf;
		2659	#ifdef DEBUG
		2660	as_warn (_("padding added"));
		2661	#endif
		2662	}
		2663	}
		2664	break;
		2665
		2666	case rs_org:
		2667	{
		2668	addressT target = offset;
		2669	addressT after;
		2670
		2671	if (symbolP)
		2672	{
		2673	/* Convert from an actual address to an octet offset
		2674	into the section. Here it is assumed that the
		2675	section's VMA is zero, and can omit subtracting it
		2676	from the symbol's value to get the address offset. */
		2677	know (S_GET_SEGMENT (symbolP)->vma == 0);
		2678	target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
		2679	}
		2680
		2681	know (fragP->fr_next);
		2682	after = fragP->fr_next->fr_address + stretch;
		2683	growth = target - after;
		2684	if (growth < 0)
		2685	{
		2686	growth = 0;
		2687
		2688	/* Don't error on first few frag relax passes.
		2689	The symbol might be an expression involving
		2690	symbol values from other sections. If those
		2691	sections have not yet been processed their
		2692	frags will all have zero addresses, so we
		2693	will calculate incorrect values for them. The
		2694	number of passes we allow before giving an
		2695	error is somewhat arbitrary. It should be at
		2696	least one, with larger values requiring
		2697	increasingly contrived dependencies between
		2698	frags to trigger a false error. */
		2699	if (pass < 2)
		2700	{
		2701	/* Force another pass. */
		2702	ret = 1;
		2703	break;
		2704	}
		2705
		2706	/* Growth may be negative, but variable part of frag
		2707	cannot have fewer than 0 chars. That is, we can't
		2708	.org backwards. */
		2709	as_bad_where (fragP->fr_file, fragP->fr_line,
		2710	_("attempt to move .org backwards"));
		2711
		2712	/* We've issued an error message. Change the
		2713	frag to avoid cascading errors. */
		2714	fragP->fr_type = rs_align;
		2715	fragP->fr_subtype = 0;
		2716	fragP->fr_offset = 0;
		2717	fragP->fr_fix = after - address;
		2718	}
		2719	}
		2720	break;
		2721
		2722	case rs_space:
		2723	growth = 0;
		2724	if (symbolP)
		2725	{
		2726	offsetT amount;
		2727
		2728	amount = S_GET_VALUE (symbolP);
		2729	if (S_GET_SEGMENT (symbolP) != absolute_section
		2730	\|\| S_IS_COMMON (symbolP)
		2731	\|\| ! S_IS_DEFINED (symbolP))
		2732	{
		2733	as_bad_where (fragP->fr_file, fragP->fr_line,
		2734	_(".space specifies non-absolute value"));
		2735	/* Prevent repeat of this error message. */
		2736	fragP->fr_symbol = 0;
		2737	}
		2738	else if (amount < 0)
		2739	{
		2740	/* Don't error on first few frag relax passes.
		2741	See rs_org comment for a longer explanation. */
		2742	if (pass < 2)
		2743	{
		2744	ret = 1;
		2745	break;
		2746	}
		2747
		2748	as_warn_where (fragP->fr_file, fragP->fr_line,
		2749	_(".space or .fill with negative value, ignored"));
		2750	fragP->fr_symbol = 0;
		2751	}
		2752	else
		2753	growth = (was_address + fragP->fr_fix + amount
		2754	- fragP->fr_next->fr_address);
		2755	}
		2756	break;
		2757
		2758	case rs_machine_dependent:
		2759	#ifdef md_relax_frag
		2760	growth = md_relax_frag (segment, fragP, stretch);
		2761	#else
		2762	#ifdef TC_GENERIC_RELAX_TABLE
		2763	/* The default way to relax a frag is to look through
		2764	TC_GENERIC_RELAX_TABLE. */
		2765	growth = relax_frag (segment, fragP, stretch);
		2766	#endif /* TC_GENERIC_RELAX_TABLE */
		2767	#endif
		2768	break;
		2769
		2770	case rs_leb128:
		2771	{
		2772	valueT value;
		2773	offsetT size;
		2774
		2775	value = resolve_symbol_value (fragP->fr_symbol);
		2776	size = sizeof_leb128 (value, fragP->fr_subtype);
		2777	growth = size - fragP->fr_offset;
		2778	fragP->fr_offset = size;
		2779	}
		2780	break;
		2781
		2782	case rs_cfa:
		2783	growth = eh_frame_relax_frag (fragP);
		2784	break;
		2785
		2786	case rs_dwarf2dbg:
		2787	growth = dwarf2dbg_relax_frag (fragP);
		2788	break;
		2789
		2790	default:
		2791	BAD_CASE (fragP->fr_type);
		2792	break;
		2793	}
		2794	if (growth)
		2795	{
		2796	stretch += growth;
		2797	stretched = 1;
		2798	if (fragP->fr_type == rs_leb128)
		2799	rs_leb128_fudge += 16;
		2800	else if (fragP->fr_type == rs_align
		2801	&& (rs_leb128_fudge & 16) != 0
		2802	&& stretch == 0)
		2803	rs_leb128_fudge += 16;
		2804	else
		2805	rs_leb128_fudge = 0;
		2806	}
		2807	}
		2808
		2809	if (stretch == 0
		2810	&& (rs_leb128_fudge & 16) == 0
		2811	&& (rs_leb128_fudge & -16) != 0)
		2812	rs_leb128_fudge += 1;
		2813	else
		2814	rs_leb128_fudge = 0;
		2815	}
		2816	/* Until nothing further to relax. */
		2817	while (stretched && -- max_iterations);
		2818
		2819	if (stretched)
		2820	as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
		2821	segment_name (segment));
		2822	}
		2823
		2824	for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
		2825	if (fragP->last_fr_address != fragP->fr_address)
		2826	{
		2827	fragP->last_fr_address = fragP->fr_address;
		2828	ret = 1;
		2829	}
		2830	return ret;
		2831	}
		2832
		2833	void
		2834	number_to_chars_bigendian (char *buf, valueT val, int n)
		2835	{
		2836	if (n <= 0)
		2837	abort ();
		2838	while (n--)
		2839	{
		2840	buf[n] = val & 0xff;
		2841	val >>= 8;
		2842	}
		2843	}
		2844
		2845	void
		2846	number_to_chars_littleendian (char *buf, valueT val, int n)
		2847	{
		2848	if (n <= 0)
		2849	abort ();
		2850	while (n--)
		2851	{
		2852	*buf++ = val & 0xff;
		2853	val >>= 8;
		2854	}
		2855	}
		2856
		2857	void
		2858	write_print_statistics (FILE *file)
		2859	{
		2860	fprintf (file, "fixups: %d\n", n_fixups);
		2861	}
		2862
		2863	/* For debugging. */
		2864	extern int indent_level;
		2865
		2866	void
		2867	print_fixup (fixS *fixp)
		2868	{
		2869	indent_level = 1;
		2870	fprintf (stderr, "fix ");
		2871	fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
		2872	fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
		2873	if (fixp->fx_pcrel)
		2874	fprintf (stderr, " pcrel");
		2875	if (fixp->fx_pcrel_adjust)
		2876	fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
		2877	if (fixp->fx_im_disp)
		2878	{
		2879	#ifdef TC_NS32K
		2880	fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
		2881	#else
		2882	fprintf (stderr, " im_disp");
		2883	#endif
		2884	}
		2885	if (fixp->fx_tcbit)
		2886	fprintf (stderr, " tcbit");
		2887	if (fixp->fx_done)
		2888	fprintf (stderr, " done");
		2889	fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
		2890	fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
		2891	fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
		2892	(long) fixp->fx_where,
		2893	(unsigned long) fixp->fx_offset,
		2894	(unsigned long) fixp->fx_addnumber);
		2895	fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
		2896	fixp->fx_r_type);
		2897	if (fixp->fx_addsy)
		2898	{
		2899	fprintf (stderr, "\n +<");
		2900	print_symbol_value_1 (stderr, fixp->fx_addsy);
		2901	fprintf (stderr, ">");
		2902	}
		2903	if (fixp->fx_subsy)
		2904	{
		2905	fprintf (stderr, "\n -<");
		2906	print_symbol_value_1 (stderr, fixp->fx_subsy);
		2907	fprintf (stderr, ">");
		2908	}
		2909	fprintf (stderr, "\n");
		2910	#ifdef TC_FIX_DATA_PRINT
		2911	TC_FIX_DATA_PRINT (stderr, fixp);
		2912	#endif
		2913	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/gas/write.c – Rev 8031