WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/bfd/peigen.c

Rev	Author	Line No.	Line
5197	serge	1	/* Support for the generic parts of PE/PEI; the common executable parts.
		2	Copyright 1995-2013 Free Software Foundation, Inc.
		3	Written by Cygnus Solutions.
		4
		5	This file is part of BFD, the Binary File Descriptor library.
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 3 of the License, or
		10	(at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
		20	MA 02110-1301, USA. */
		21
		22
		23	/* Most of this hacked by Steve Chamberlain .
		24
		25	PE/PEI rearrangement (and code added): Donn Terry
		26	Softway Systems, Inc. */
		27
		28	/* Hey look, some documentation [and in a place you expect to find it]!
		29
		30	The main reference for the pei format is "Microsoft Portable Executable
		31	and Common Object File Format Specification 4.1". Get it if you need to
		32	do some serious hacking on this code.
		33
		34	Another reference:
		35	"Peering Inside the PE: A Tour of the Win32 Portable Executable
		36	File Format", MSJ 1994, Volume 9.
		37
		38	The sole difference between the pe format and the pei format is that the
		39	latter has an MSDOS 2.0 .exe header on the front that prints the message
		40	"This app must be run under Windows." (or some such).
		41	(FIXME: Whether that statement is really true or not is unknown.
		42	Are there more subtle differences between pe and pei formats?
		43	For now assume there aren't. If you find one, then for God sakes
		44	document it here!)
		45
		46	The Microsoft docs use the word "image" instead of "executable" because
		47	the former can also refer to a DLL (shared library). Confusion can arise
		48	because the `i' in `pei' also refers to "image". The `pe' format can
		49	also create images (i.e. executables), it's just that to run on a win32
		50	system you need to use the pei format.
		51
		52	FIXME: Please add more docs here so the next poor fool that has to hack
		53	on this code has a chance of getting something accomplished without
		54	wasting too much time. */
		55
		56	/* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
		57	depending on whether we're compiling for straight PE or PE+. */
		58	#define COFF_WITH_pe
		59
		60	#include "sysdep.h"
		61	#include "bfd.h"
		62	#include "libbfd.h"
		63	#include "coff/internal.h"
		64	#include "bfdver.h"
		65
		66	/* NOTE: it's strange to be including an architecture specific header
		67	in what's supposed to be general (to PE/PEI) code. However, that's
		68	where the definitions are, and they don't vary per architecture
		69	within PE/PEI, so we get them from there. FIXME: The lack of
		70	variance is an assumption which may prove to be incorrect if new
		71	PE/PEI targets are created. */
		72	#if defined COFF_WITH_pex64
		73	# include "coff/x86_64.h"
		74	#elif defined COFF_WITH_pep
		75	# include "coff/ia64.h"
		76	#else
		77	# include "coff/i386.h"
		78	#endif
		79
		80	#include "coff/pe.h"
		81	#include "libcoff.h"
		82	#include "libpei.h"
		83
		84	#if defined COFF_WITH_pep \|\| defined COFF_WITH_pex64
		85	# undef AOUTSZ
		86	# define AOUTSZ PEPAOUTSZ
		87	# define PEAOUTHDR PEPAOUTHDR
		88	#endif
		89
		90	/* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
		91	worked when the code was in peicode.h, but no longer work now that
		92	the code is in peigen.c. PowerPC NT is said to be dead. If
		93	anybody wants to revive the code, you will have to figure out how
		94	to handle those issues. */
		95
		96	void
		97	_bfd_pei_swap_sym_in (bfd * abfd, void * ext1, void * in1)
		98	{
		99	SYMENT ext = (SYMENT ) ext1;
		100	struct internal_syment in = (struct internal_syment ) in1;
		101
		102	if (ext->e.e_name[0] == 0)
		103	{
		104	in->_n._n_n._n_zeroes = 0;
		105	in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
		106	}
		107	else
		108	memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
		109
		110	in->n_value = H_GET_32 (abfd, ext->e_value);
		111	in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
		112
		113	if (sizeof (ext->e_type) == 2)
		114	in->n_type = H_GET_16 (abfd, ext->e_type);
		115	else
		116	in->n_type = H_GET_32 (abfd, ext->e_type);
		117
		118	in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
		119	in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
		120
		121	#ifndef STRICT_PE_FORMAT
		122	/* This is for Gnu-created DLLs. */
		123
		124	/* The section symbols for the .idata$ sections have class 0x68
		125	(C_SECTION), which MS documentation indicates is a section
		126	symbol. Unfortunately, the value field in the symbol is simply a
		127	copy of the .idata section's flags rather than something useful.
		128	When these symbols are encountered, change the value to 0 so that
		129	they will be handled somewhat correctly in the bfd code. */
		130	if (in->n_sclass == C_SECTION)
		131	{
		132	char namebuf[SYMNMLEN + 1];
		133	const char *name = NULL;
		134
		135	in->n_value = 0x0;
		136
		137	/* Create synthetic empty sections as needed. DJ */
		138	if (in->n_scnum == 0)
		139	{
		140	asection *sec;
		141
		142	name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
		143	if (name == NULL)
		144	/* FIXME: Return error. */
		145	abort ();
		146	sec = bfd_get_section_by_name (abfd, name);
		147	if (sec != NULL)
		148	in->n_scnum = sec->target_index;
		149	}
		150
		151	if (in->n_scnum == 0)
		152	{
		153	int unused_section_number = 0;
		154	asection *sec;
		155	flagword flags;
		156
		157	for (sec = abfd->sections; sec; sec = sec->next)
		158	if (unused_section_number <= sec->target_index)
		159	unused_section_number = sec->target_index + 1;
		160
		161	if (name == namebuf)
		162	{
		163	name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
		164	if (name == NULL)
		165	/* FIXME: Return error. */
		166	abort ();
		167	strcpy ((char *) name, namebuf);
		168	}
		169	flags = SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_DATA \| SEC_LOAD;
		170	sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
		171	if (sec == NULL)
		172	/* FIXME: Return error. */
		173	abort ();
		174
		175	sec->vma = 0;
		176	sec->lma = 0;
		177	sec->size = 0;
		178	sec->filepos = 0;
		179	sec->rel_filepos = 0;
		180	sec->reloc_count = 0;
		181	sec->line_filepos = 0;
		182	sec->lineno_count = 0;
		183	sec->userdata = NULL;
		184	sec->next = NULL;
		185	sec->alignment_power = 2;
		186
		187	sec->target_index = unused_section_number;
		188
		189	in->n_scnum = unused_section_number;
		190	}
		191	in->n_sclass = C_STAT;
		192	}
		193	#endif
		194
		195	#ifdef coff_swap_sym_in_hook
		196	/* This won't work in peigen.c, but since it's for PPC PE, it's not
		197	worth fixing. */
		198	coff_swap_sym_in_hook (abfd, ext1, in1);
		199	#endif
		200	}
		201
		202	unsigned int
		203	_bfd_pei_swap_sym_out (bfd * abfd, void * inp, void * extp)
		204	{
		205	struct internal_syment in = (struct internal_syment ) inp;
		206	SYMENT ext = (SYMENT ) extp;
		207
		208	if (in->_n._n_name[0] == 0)
		209	{
		210	H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
		211	H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
		212	}
		213	else
		214	memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
		215
		216	H_PUT_32 (abfd, in->n_value, ext->e_value);
		217	H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
		218
		219	if (sizeof (ext->e_type) == 2)
		220	H_PUT_16 (abfd, in->n_type, ext->e_type);
		221	else
		222	H_PUT_32 (abfd, in->n_type, ext->e_type);
		223
		224	H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
		225	H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
		226
		227	return SYMESZ;
		228	}
		229
		230	void
		231	_bfd_pei_swap_aux_in (bfd * abfd,
		232	void * ext1,
		233	int type,
		234	int in_class,
		235	int indx ATTRIBUTE_UNUSED,
		236	int numaux ATTRIBUTE_UNUSED,
		237	void * in1)
		238	{
		239	AUXENT ext = (AUXENT ) ext1;
		240	union internal_auxent in = (union internal_auxent ) in1;
		241
		242	switch (in_class)
		243	{
		244	case C_FILE:
		245	if (ext->x_file.x_fname[0] == 0)
		246	{
		247	in->x_file.x_n.x_zeroes = 0;
		248	in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
		249	}
		250	else
		251	memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
		252	return;
		253
		254	case C_STAT:
		255	case C_LEAFSTAT:
		256	case C_HIDDEN:
		257	if (type == T_NULL)
		258	{
		259	in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
		260	in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
		261	in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
		262	in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
		263	in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
		264	in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
		265	return;
		266	}
		267	break;
		268	}
		269
		270	in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
		271	in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
		272
		273	if (in_class == C_BLOCK \|\| in_class == C_FCN \|\| ISFCN (type)
		274	\|\| ISTAG (in_class))
		275	{
		276	in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
		277	in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
		278	}
		279	else
		280	{
		281	in->x_sym.x_fcnary.x_ary.x_dimen[0] =
		282	H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
		283	in->x_sym.x_fcnary.x_ary.x_dimen[1] =
		284	H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
		285	in->x_sym.x_fcnary.x_ary.x_dimen[2] =
		286	H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
		287	in->x_sym.x_fcnary.x_ary.x_dimen[3] =
		288	H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
		289	}
		290
		291	if (ISFCN (type))
		292	{
		293	in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
		294	}
		295	else
		296	{
		297	in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
		298	in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
		299	}
		300	}
		301
		302	unsigned int
		303	_bfd_pei_swap_aux_out (bfd * abfd,
		304	void * inp,
		305	int type,
		306	int in_class,
		307	int indx ATTRIBUTE_UNUSED,
		308	int numaux ATTRIBUTE_UNUSED,
		309	void * extp)
		310	{
		311	union internal_auxent in = (union internal_auxent ) inp;
		312	AUXENT ext = (AUXENT ) extp;
		313
		314	memset (ext, 0, AUXESZ);
		315
		316	switch (in_class)
		317	{
		318	case C_FILE:
		319	if (in->x_file.x_fname[0] == 0)
		320	{
		321	H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
		322	H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
		323	}
		324	else
		325	memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
		326
		327	return AUXESZ;
		328
		329	case C_STAT:
		330	case C_LEAFSTAT:
		331	case C_HIDDEN:
		332	if (type == T_NULL)
		333	{
		334	PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
		335	PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
		336	PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
		337	H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
		338	H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
		339	H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
		340	return AUXESZ;
		341	}
		342	break;
		343	}
		344
		345	H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
		346	H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
		347
		348	if (in_class == C_BLOCK \|\| in_class == C_FCN \|\| ISFCN (type)
		349	\|\| ISTAG (in_class))
		350	{
		351	PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
		352	PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
		353	}
		354	else
		355	{
		356	H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
		357	ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
		358	H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
		359	ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
		360	H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
		361	ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
		362	H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
		363	ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
		364	}
		365
		366	if (ISFCN (type))
		367	H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
		368	else
		369	{
		370	PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
		371	PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
		372	}
		373
		374	return AUXESZ;
		375	}
		376
		377	void
		378	_bfd_pei_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
		379	{
		380	LINENO ext = (LINENO ) ext1;
		381	struct internal_lineno in = (struct internal_lineno ) in1;
		382
		383	in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
		384	in->l_lnno = GET_LINENO_LNNO (abfd, ext);
		385	}
		386
		387	unsigned int
		388	_bfd_pei_swap_lineno_out (bfd * abfd, void * inp, void * outp)
		389	{
		390	struct internal_lineno in = (struct internal_lineno ) inp;
		391	struct external_lineno ext = (struct external_lineno ) outp;
		392	H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
		393
		394	PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
		395	return LINESZ;
		396	}
		397
		398	void
		399	_bfd_pei_swap_aouthdr_in (bfd * abfd,
		400	void * aouthdr_ext1,
		401	void * aouthdr_int1)
		402	{
		403	PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
		404	AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
		405	struct internal_aouthdr *aouthdr_int
		406	= (struct internal_aouthdr *) aouthdr_int1;
		407	struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
		408
		409	aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
		410	aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
		411	aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
		412	aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
		413	aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
		414	aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
		415	aouthdr_int->text_start =
		416	GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
		417	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		418	/* PE32+ does not have data_start member! */
		419	aouthdr_int->data_start =
		420	GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
		421	a->BaseOfData = aouthdr_int->data_start;
		422	#endif
		423
		424	a->Magic = aouthdr_int->magic;
		425	a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
		426	a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
		427	a->SizeOfCode = aouthdr_int->tsize ;
		428	a->SizeOfInitializedData = aouthdr_int->dsize ;
		429	a->SizeOfUninitializedData = aouthdr_int->bsize ;
		430	a->AddressOfEntryPoint = aouthdr_int->entry;
		431	a->BaseOfCode = aouthdr_int->text_start;
		432	a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
		433	a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
		434	a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
		435	a->MajorOperatingSystemVersion =
		436	H_GET_16 (abfd, src->MajorOperatingSystemVersion);
		437	a->MinorOperatingSystemVersion =
		438	H_GET_16 (abfd, src->MinorOperatingSystemVersion);
		439	a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
		440	a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
		441	a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
		442	a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
		443	a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
		444	a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
		445	a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
		446	a->CheckSum = H_GET_32 (abfd, src->CheckSum);
		447	a->Subsystem = H_GET_16 (abfd, src->Subsystem);
		448	a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
		449	a->SizeOfStackReserve =
		450	GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
		451	a->SizeOfStackCommit =
		452	GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
		453	a->SizeOfHeapReserve =
		454	GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
		455	a->SizeOfHeapCommit =
		456	GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
		457	a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
		458	a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
		459
		460	{
		461	int idx;
		462
		463	for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
		464	{
		465	/* If data directory is empty, rva also should be 0. */
		466	int size =
		467	H_GET_32 (abfd, src->DataDirectory[idx][1]);
		468
		469	a->DataDirectory[idx].Size = size;
		470
		471	if (size)
		472	a->DataDirectory[idx].VirtualAddress =
		473	H_GET_32 (abfd, src->DataDirectory[idx][0]);
		474	else
		475	a->DataDirectory[idx].VirtualAddress = 0;
		476	}
		477	}
		478
		479	if (aouthdr_int->entry)
		480	{
		481	aouthdr_int->entry += a->ImageBase;
		482	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		483	aouthdr_int->entry &= 0xffffffff;
		484	#endif
		485	}
		486
		487	if (aouthdr_int->tsize)
		488	{
		489	aouthdr_int->text_start += a->ImageBase;
		490	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		491	aouthdr_int->text_start &= 0xffffffff;
		492	#endif
		493	}
		494
		495	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		496	/* PE32+ does not have data_start member! */
		497	if (aouthdr_int->dsize)
		498	{
		499	aouthdr_int->data_start += a->ImageBase;
		500	aouthdr_int->data_start &= 0xffffffff;
		501	}
		502	#endif
		503
		504	#ifdef POWERPC_LE_PE
		505	/* These three fields are normally set up by ppc_relocate_section.
		506	In the case of reading a file in, we can pick them up from the
		507	DataDirectory. */
		508	first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
		509	thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
		510	import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
		511	#endif
		512	}
		513
		514	/* A support function for below. */
		515
		516	static void
		517	add_data_entry (bfd * abfd,
		518	struct internal_extra_pe_aouthdr *aout,
		519	int idx,
		520	char *name,
		521	bfd_vma base)
		522	{
		523	asection *sec = bfd_get_section_by_name (abfd, name);
		524
		525	/* Add import directory information if it exists. */
		526	if ((sec != NULL)
		527	&& (coff_section_data (abfd, sec) != NULL)
		528	&& (pei_section_data (abfd, sec) != NULL))
		529	{
		530	/* If data directory is empty, rva also should be 0. */
		531	int size = pei_section_data (abfd, sec)->virt_size;
		532	aout->DataDirectory[idx].Size = size;
		533
		534	if (size)
		535	{
		536	aout->DataDirectory[idx].VirtualAddress =
		537	(sec->vma - base) & 0xffffffff;
		538	sec->flags \|= SEC_DATA;
		539	}
		540	}
		541	}
		542
		543	unsigned int
		544	_bfd_pei_swap_aouthdr_out (bfd * abfd, void * in, void * out)
		545	{
		546	struct internal_aouthdr aouthdr_in = (struct internal_aouthdr ) in;
		547	pe_data_type *pe = pe_data (abfd);
		548	struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
		549	PEAOUTHDR aouthdr_out = (PEAOUTHDR ) out;
		550	bfd_vma sa, fa, ib;
		551	IMAGE_DATA_DIRECTORY idata2, idata5, tls;
		552
		553	sa = extra->SectionAlignment;
		554	fa = extra->FileAlignment;
		555	ib = extra->ImageBase;
		556
		557	idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
		558	idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
		559	tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
		560
		561	if (aouthdr_in->tsize)
		562	{
		563	aouthdr_in->text_start -= ib;
		564	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		565	aouthdr_in->text_start &= 0xffffffff;
		566	#endif
		567	}
		568
		569	if (aouthdr_in->dsize)
		570	{
		571	aouthdr_in->data_start -= ib;
		572	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		573	aouthdr_in->data_start &= 0xffffffff;
		574	#endif
		575	}
		576
		577	if (aouthdr_in->entry)
		578	{
		579	aouthdr_in->entry -= ib;
		580	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		581	aouthdr_in->entry &= 0xffffffff;
		582	#endif
		583	}
		584
		585	#define FA(x) (((x) + fa -1 ) & (- fa))
		586	#define SA(x) (((x) + sa -1 ) & (- sa))
		587
		588	/* We like to have the sizes aligned. */
		589	aouthdr_in->bsize = FA (aouthdr_in->bsize);
		590
		591	extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
		592
		593	add_data_entry (abfd, extra, 0, ".edata", ib);
		594	add_data_entry (abfd, extra, 2, ".rsrc", ib);
		595	add_data_entry (abfd, extra, 3, ".pdata", ib);
		596
		597	/* In theory we do not need to call add_data_entry for .idata$2 or
		598	.idata$5. It will be done in bfd_coff_final_link where all the
		599	required information is available. If however, we are not going
		600	to perform a final link, eg because we have been invoked by objcopy
		601	or strip, then we need to make sure that these Data Directory
		602	entries are initialised properly.
		603
		604	So - we copy the input values into the output values, and then, if
		605	a final link is going to be performed, it can overwrite them. */
		606	extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
		607	extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
		608	extra->DataDirectory[PE_TLS_TABLE] = tls;
		609
		610	if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
		611	/* Until other .idata fixes are made (pending patch), the entry for
		612	.idata is needed for backwards compatibility. FIXME. */
		613	add_data_entry (abfd, extra, 1, ".idata", ib);
		614
		615	/* For some reason, the virtual size (which is what's set by
		616	add_data_entry) for .reloc is not the same as the size recorded
		617	in this slot by MSVC; it doesn't seem to cause problems (so far),
		618	but since it's the best we've got, use it. It does do the right
		619	thing for .pdata. */
		620	if (pe->has_reloc_section)
		621	add_data_entry (abfd, extra, 5, ".reloc", ib);
		622
		623	{
		624	asection *sec;
		625	bfd_vma hsize = 0;
		626	bfd_vma dsize = 0;
		627	bfd_vma isize = 0;
		628	bfd_vma tsize = 0;
		629
		630	for (sec = abfd->sections; sec; sec = sec->next)
		631	{
		632	int rounded = FA (sec->size);
		633
		634	/* The first non-zero section filepos is the header size.
		635	Sections without contents will have a filepos of 0. */
		636	if (hsize == 0)
		637	hsize = sec->filepos;
		638	if (sec->flags & SEC_DATA)
		639	dsize += rounded;
		640	if (sec->flags & SEC_CODE)
		641	tsize += rounded;
		642	/* The image size is the total VIRTUAL size (which is what is
		643	in the virt_size field). Files have been seen (from MSVC
		644	5.0 link.exe) where the file size of the .data segment is
		645	quite small compared to the virtual size. Without this
		646	fix, strip munges the file.
		647
		648	FIXME: We need to handle holes between sections, which may
		649	happpen when we covert from another format. We just use
		650	the virtual address and virtual size of the last section
		651	for the image size. */
		652	if (coff_section_data (abfd, sec) != NULL
		653	&& pei_section_data (abfd, sec) != NULL)
		654	isize = (sec->vma - extra->ImageBase
		655	+ SA (FA (pei_section_data (abfd, sec)->virt_size)));
		656	}
		657
		658	aouthdr_in->dsize = dsize;
		659	aouthdr_in->tsize = tsize;
		660	extra->SizeOfHeaders = hsize;
		661	extra->SizeOfImage = isize;
		662	}
		663
		664	H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
		665
		666	/* e.g. 219510000 is linker version 2.19 */
		667	#define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
		668
		669	/* This piece of magic sets the "linker version" field to
		670	LINKER_VERSION. */
		671	H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
		672	aouthdr_out->standard.vstamp);
		673
		674	PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
		675	PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
		676	PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
		677	PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
		678	PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
		679	aouthdr_out->standard.text_start);
		680
		681	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		682	/* PE32+ does not have data_start member! */
		683	PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
		684	aouthdr_out->standard.data_start);
		685	#endif
		686
		687	PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
		688	H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
		689	H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
		690	H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
		691	aouthdr_out->MajorOperatingSystemVersion);
		692	H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
		693	aouthdr_out->MinorOperatingSystemVersion);
		694	H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
		695	H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
		696	H_PUT_16 (abfd, extra->MajorSubsystemVersion,
		697	aouthdr_out->MajorSubsystemVersion);
		698	H_PUT_16 (abfd, extra->MinorSubsystemVersion,
		699	aouthdr_out->MinorSubsystemVersion);
		700	H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
		701	H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
		702	H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
		703	H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
		704	H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
		705	H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
		706	PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
		707	aouthdr_out->SizeOfStackReserve);
		708	PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
		709	aouthdr_out->SizeOfStackCommit);
		710	PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
		711	aouthdr_out->SizeOfHeapReserve);
		712	PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
		713	aouthdr_out->SizeOfHeapCommit);
		714	H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
		715	H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
		716	aouthdr_out->NumberOfRvaAndSizes);
		717	{
		718	int idx;
		719
		720	for (idx = 0; idx < 16; idx++)
		721	{
		722	H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
		723	aouthdr_out->DataDirectory[idx][0]);
		724	H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
		725	aouthdr_out->DataDirectory[idx][1]);
		726	}
		727	}
		728
		729	return AOUTSZ;
		730	}
		731
		732	unsigned int
		733	_bfd_pei_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
		734	{
		735	int idx;
		736	struct internal_filehdr filehdr_in = (struct internal_filehdr ) in;
		737	struct external_PEI_filehdr filehdr_out = (struct external_PEI_filehdr ) out;
		738
		739	if (pe_data (abfd)->has_reloc_section
		740	\|\| pe_data (abfd)->dont_strip_reloc)
		741	filehdr_in->f_flags &= ~F_RELFLG;
		742
		743	if (pe_data (abfd)->dll)
		744	filehdr_in->f_flags \|= F_DLL;
		745
		746	filehdr_in->pe.e_magic = DOSMAGIC;
		747	filehdr_in->pe.e_cblp = 0x90;
		748	filehdr_in->pe.e_cp = 0x3;
		749	filehdr_in->pe.e_crlc = 0x0;
		750	filehdr_in->pe.e_cparhdr = 0x4;
		751	filehdr_in->pe.e_minalloc = 0x0;
		752	filehdr_in->pe.e_maxalloc = 0xffff;
		753	filehdr_in->pe.e_ss = 0x0;
		754	filehdr_in->pe.e_sp = 0xb8;
		755	filehdr_in->pe.e_csum = 0x0;
		756	filehdr_in->pe.e_ip = 0x0;
		757	filehdr_in->pe.e_cs = 0x0;
		758	filehdr_in->pe.e_lfarlc = 0x40;
		759	filehdr_in->pe.e_ovno = 0x0;
		760
		761	for (idx = 0; idx < 4; idx++)
		762	filehdr_in->pe.e_res[idx] = 0x0;
		763
		764	filehdr_in->pe.e_oemid = 0x0;
		765	filehdr_in->pe.e_oeminfo = 0x0;
		766
		767	for (idx = 0; idx < 10; idx++)
		768	filehdr_in->pe.e_res2[idx] = 0x0;
		769
		770	filehdr_in->pe.e_lfanew = 0x80;
		771
		772	/* This next collection of data are mostly just characters. It
		773	appears to be constant within the headers put on NT exes. */
		774	filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
		775	filehdr_in->pe.dos_message[1] = 0xcd09b400;
		776	filehdr_in->pe.dos_message[2] = 0x4c01b821;
		777	filehdr_in->pe.dos_message[3] = 0x685421cd;
		778	filehdr_in->pe.dos_message[4] = 0x70207369;
		779	filehdr_in->pe.dos_message[5] = 0x72676f72;
		780	filehdr_in->pe.dos_message[6] = 0x63206d61;
		781	filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
		782	filehdr_in->pe.dos_message[8] = 0x65622074;
		783	filehdr_in->pe.dos_message[9] = 0x6e757220;
		784	filehdr_in->pe.dos_message[10] = 0x206e6920;
		785	filehdr_in->pe.dos_message[11] = 0x20534f44;
		786	filehdr_in->pe.dos_message[12] = 0x65646f6d;
		787	filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
		788	filehdr_in->pe.dos_message[14] = 0x24;
		789	filehdr_in->pe.dos_message[15] = 0x0;
		790	filehdr_in->pe.nt_signature = NT_SIGNATURE;
		791
		792	H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
		793	H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
		794
		795	/* Only use a real timestamp if the option was chosen. */
		796	if ((pe_data (abfd)->insert_timestamp))
		797	H_PUT_32 (abfd, time(0), filehdr_out->f_timdat);
		798
		799	PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
		800	filehdr_out->f_symptr);
		801	H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
		802	H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
		803	H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
		804
		805	/* Put in extra dos header stuff. This data remains essentially
		806	constant, it just has to be tacked on to the beginning of all exes
		807	for NT. */
		808	H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
		809	H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
		810	H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
		811	H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
		812	H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
		813	H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
		814	H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
		815	H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
		816	H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
		817	H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
		818	H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
		819	H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
		820	H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
		821	H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
		822
		823	for (idx = 0; idx < 4; idx++)
		824	H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
		825
		826	H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
		827	H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
		828
		829	for (idx = 0; idx < 10; idx++)
		830	H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
		831
		832	H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
		833
		834	for (idx = 0; idx < 16; idx++)
		835	H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
		836	filehdr_out->dos_message[idx]);
		837
		838	/* Also put in the NT signature. */
		839	H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
		840
		841	return FILHSZ;
		842	}
		843
		844	unsigned int
		845	_bfd_pe_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
		846	{
		847	struct internal_filehdr filehdr_in = (struct internal_filehdr ) in;
		848	FILHDR filehdr_out = (FILHDR ) out;
		849
		850	H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
		851	H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
		852	H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
		853	PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
		854	H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
		855	H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
		856	H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
		857
		858	return FILHSZ;
		859	}
		860
		861	unsigned int
		862	_bfd_pei_swap_scnhdr_out (bfd * abfd, void * in, void * out)
		863	{
		864	struct internal_scnhdr scnhdr_int = (struct internal_scnhdr ) in;
		865	SCNHDR scnhdr_ext = (SCNHDR ) out;
		866	unsigned int ret = SCNHSZ;
		867	bfd_vma ps;
		868	bfd_vma ss;
		869
		870	memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
		871
		872	PUT_SCNHDR_VADDR (abfd,
		873	((scnhdr_int->s_vaddr
		874	- pe_data (abfd)->pe_opthdr.ImageBase)
		875	& 0xffffffff),
		876	scnhdr_ext->s_vaddr);
		877
		878	/* NT wants the size data to be rounded up to the next
		879	NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
		880	sometimes). */
		881	if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
		882	{
		883	if (bfd_pei_p (abfd))
		884	{
		885	ps = scnhdr_int->s_size;
		886	ss = 0;
		887	}
		888	else
		889	{
		890	ps = 0;
		891	ss = scnhdr_int->s_size;
		892	}
		893	}
		894	else
		895	{
		896	if (bfd_pei_p (abfd))
		897	ps = scnhdr_int->s_paddr;
		898	else
		899	ps = 0;
		900
		901	ss = scnhdr_int->s_size;
		902	}
		903
		904	PUT_SCNHDR_SIZE (abfd, ss,
		905	scnhdr_ext->s_size);
		906
		907	/* s_paddr in PE is really the virtual size. */
		908	PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
		909
		910	PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
		911	scnhdr_ext->s_scnptr);
		912	PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
		913	scnhdr_ext->s_relptr);
		914	PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
		915	scnhdr_ext->s_lnnoptr);
		916
		917	{
		918	/* Extra flags must be set when dealing with PE. All sections should also
		919	have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
		920	.text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
		921	sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
		922	(this is especially important when dealing with the .idata section since
		923	the addresses for routines from .dlls must be overwritten). If .reloc
		924	section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
		925	(0x02000000). Also, the resource data should also be read and
		926	writable. */
		927
		928	/* FIXME: Alignment is also encoded in this field, at least on PPC and
		929	ARM-WINCE. Although - how do we get the original alignment field
		930	back ? */
		931
		932	typedef struct
		933	{
		934	const char * section_name;
		935	unsigned long must_have;
		936	}
		937	pe_required_section_flags;
		938
		939	pe_required_section_flags known_sections [] =
		940	{
		941	{ ".arch", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA \| IMAGE_SCN_MEM_DISCARDABLE \| IMAGE_SCN_ALIGN_8BYTES },
		942	{ ".bss", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_UNINITIALIZED_DATA \| IMAGE_SCN_MEM_WRITE },
		943	{ ".data", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA \| IMAGE_SCN_MEM_WRITE },
		944	{ ".edata", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA },
		945	{ ".idata", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA \| IMAGE_SCN_MEM_WRITE },
		946	{ ".pdata", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA },
		947	{ ".rdata", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA },
		948	{ ".reloc", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA \| IMAGE_SCN_MEM_DISCARDABLE },
		949	{ ".rsrc", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA \| IMAGE_SCN_MEM_WRITE },
		950	{ ".text" , IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_CODE \| IMAGE_SCN_MEM_EXECUTE },
		951	{ ".tls", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA \| IMAGE_SCN_MEM_WRITE },
		952	{ ".xdata", IMAGE_SCN_MEM_READ \| IMAGE_SCN_CNT_INITIALIZED_DATA },
		953	{ NULL, 0}
		954	};
		955
		956	pe_required_section_flags * p;
		957
		958	/* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
		959	we know exactly what this specific section wants so we remove it
		960	and then allow the must_have field to add it back in if necessary.
		961	However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
		962	default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
		963	by ld --enable-auto-import (if auto-import is actually needed),
		964	by ld --omagic, or by obcopy --writable-text. */
		965
		966	for (p = known_sections; p->section_name; p++)
		967	if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
		968	{
		969	if (strcmp (scnhdr_int->s_name, ".text")
		970	\|\| (bfd_get_file_flags (abfd) & WP_TEXT))
		971	scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
		972	scnhdr_int->s_flags \|= p->must_have;
		973	break;
		974	}
		975
		976	H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
		977	}
		978
		979	if (coff_data (abfd)->link_info
		980	&& ! coff_data (abfd)->link_info->relocatable
		981	&& ! coff_data (abfd)->link_info->shared
		982	&& strcmp (scnhdr_int->s_name, ".text") == 0)
		983	{
		984	/* By inference from looking at MS output, the 32 bit field
		985	which is the combination of the number_of_relocs and
		986	number_of_linenos is used for the line number count in
		987	executables. A 16-bit field won't do for cc1. The MS
		988	document says that the number of relocs is zero for
		989	executables, but the 17-th bit has been observed to be there.
		990	Overflow is not an issue: a 4G-line program will overflow a
		991	bunch of other fields long before this! */
		992	H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
		993	H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
		994	}
		995	else
		996	{
		997	if (scnhdr_int->s_nlnno <= 0xffff)
		998	H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
		999	else
		1000	{
		1001	(*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
		1002	bfd_get_filename (abfd),
		1003	scnhdr_int->s_nlnno);
		1004	bfd_set_error (bfd_error_file_truncated);
		1005	H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
		1006	ret = 0;
		1007	}
		1008
		1009	/* Although we could encode 0xffff relocs here, we do not, to be
		1010	consistent with other parts of bfd. Also it lets us warn, as
		1011	we should never see 0xffff here w/o having the overflow flag
		1012	set. */
		1013	if (scnhdr_int->s_nreloc < 0xffff)
		1014	H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
		1015	else
		1016	{
		1017	/* PE can deal with large #s of relocs, but not here. */
		1018	H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
		1019	scnhdr_int->s_flags \|= IMAGE_SCN_LNK_NRELOC_OVFL;
		1020	H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
		1021	}
		1022	}
		1023	return ret;
		1024	}
		1025
		1026	static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
		1027	{
		1028	N_("Export Directory [.edata (or where ever we found it)]"),
		1029	N_("Import Directory [parts of .idata]"),
		1030	N_("Resource Directory [.rsrc]"),
		1031	N_("Exception Directory [.pdata]"),
		1032	N_("Security Directory"),
		1033	N_("Base Relocation Directory [.reloc]"),
		1034	N_("Debug Directory"),
		1035	N_("Description Directory"),
		1036	N_("Special Directory"),
		1037	N_("Thread Storage Directory [.tls]"),
		1038	N_("Load Configuration Directory"),
		1039	N_("Bound Import Directory"),
		1040	N_("Import Address Table Directory"),
		1041	N_("Delay Import Directory"),
		1042	N_("CLR Runtime Header"),
		1043	N_("Reserved")
		1044	};
		1045
		1046	#ifdef POWERPC_LE_PE
		1047	/* The code for the PPC really falls in the "architecture dependent"
		1048	category. However, it's not clear that anyone will ever care, so
		1049	we're ignoring the issue for now; if/when PPC matters, some of this
		1050	may need to go into peicode.h, or arguments passed to enable the
		1051	PPC- specific code. */
		1052	#endif
		1053
		1054	static bfd_boolean
		1055	pe_print_idata (bfd * abfd, void * vfile)
		1056	{
		1057	FILE file = (FILE ) vfile;
		1058	bfd_byte *data;
		1059	asection *section;
		1060	bfd_signed_vma adj;
		1061
		1062	#ifdef POWERPC_LE_PE
		1063	asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
		1064	#endif
		1065
		1066	bfd_size_type datasize = 0;
		1067	bfd_size_type dataoff;
		1068	bfd_size_type i;
		1069	int onaline = 20;
		1070
		1071	pe_data_type *pe = pe_data (abfd);
		1072	struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
		1073
		1074	bfd_vma addr;
		1075
		1076	addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
		1077
		1078	if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
		1079	{
		1080	/* Maybe the extra header isn't there. Look for the section. */
		1081	section = bfd_get_section_by_name (abfd, ".idata");
		1082	if (section == NULL)
		1083	return TRUE;
		1084
		1085	addr = section->vma;
		1086	datasize = section->size;
		1087	if (datasize == 0)
		1088	return TRUE;
		1089	}
		1090	else
		1091	{
		1092	addr += extra->ImageBase;
		1093	for (section = abfd->sections; section != NULL; section = section->next)
		1094	{
		1095	datasize = section->size;
		1096	if (addr >= section->vma && addr < section->vma + datasize)
		1097	break;
		1098	}
		1099
		1100	if (section == NULL)
		1101	{
		1102	fprintf (file,
		1103	_("\nThere is an import table, but the section containing it could not be found\n"));
		1104	return TRUE;
		1105	}
		1106	}
		1107
		1108	fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
		1109	section->name, (unsigned long) addr);
		1110
		1111	dataoff = addr - section->vma;
		1112
		1113	#ifdef POWERPC_LE_PE
		1114	if (rel_section != 0 && rel_section->size != 0)
		1115	{
		1116	/* The toc address can be found by taking the starting address,
		1117	which on the PPC locates a function descriptor. The
		1118	descriptor consists of the function code starting address
		1119	followed by the address of the toc. The starting address we
		1120	get from the bfd, and the descriptor is supposed to be in the
		1121	.reldata section. */
		1122
		1123	bfd_vma loadable_toc_address;
		1124	bfd_vma toc_address;
		1125	bfd_vma start_address;
		1126	bfd_byte *data;
		1127	bfd_vma offset;
		1128
		1129	if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
		1130	{
		1131	if (data != NULL)
		1132	free (data);
		1133	return FALSE;
		1134	}
		1135
		1136	offset = abfd->start_address - rel_section->vma;
		1137
		1138	if (offset >= rel_section->size \|\| offset + 8 > rel_section->size)
		1139	{
		1140	if (data != NULL)
		1141	free (data);
		1142	return FALSE;
		1143	}
		1144
		1145	start_address = bfd_get_32 (abfd, data + offset);
		1146	loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
		1147	toc_address = loadable_toc_address - 32768;
		1148
		1149	fprintf (file,
		1150	_("\nFunction descriptor located at the start address: %04lx\n"),
		1151	(unsigned long int) (abfd->start_address));
		1152	fprintf (file,
		1153	_("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
		1154	start_address, loadable_toc_address, toc_address);
		1155	if (data != NULL)
		1156	free (data);
		1157	}
		1158	else
		1159	{
		1160	fprintf (file,
		1161	_("\nNo reldata section! Function descriptor not decoded.\n"));
		1162	}
		1163	#endif
		1164
		1165	fprintf (file,
		1166	_("\nThe Import Tables (interpreted %s section contents)\n"),
		1167	section->name);
		1168	fprintf (file,
		1169	_("\
		1170	vma: Hint Time Forward DLL First\n\
		1171	Table Stamp Chain Name Thunk\n"));
		1172
		1173	/* Read the whole section. Some of the fields might be before dataoff. */
		1174	if (!bfd_malloc_and_get_section (abfd, section, &data))
		1175	{
		1176	if (data != NULL)
		1177	free (data);
		1178	return FALSE;
		1179	}
		1180
		1181	adj = section->vma - extra->ImageBase;
		1182
		1183	/* Print all image import descriptors. */
		1184	for (i = dataoff; i + onaline <= datasize; i += onaline)
		1185	{
		1186	bfd_vma hint_addr;
		1187	bfd_vma time_stamp;
		1188	bfd_vma forward_chain;
		1189	bfd_vma dll_name;
		1190	bfd_vma first_thunk;
		1191	int idx = 0;
		1192	bfd_size_type j;
		1193	char *dll;
		1194
		1195	/* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
		1196	fprintf (file, " %08lx\t", (unsigned long) (i + adj));
		1197	hint_addr = bfd_get_32 (abfd, data + i);
		1198	time_stamp = bfd_get_32 (abfd, data + i + 4);
		1199	forward_chain = bfd_get_32 (abfd, data + i + 8);
		1200	dll_name = bfd_get_32 (abfd, data + i + 12);
		1201	first_thunk = bfd_get_32 (abfd, data + i + 16);
		1202
		1203	fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
		1204	(unsigned long) hint_addr,
		1205	(unsigned long) time_stamp,
		1206	(unsigned long) forward_chain,
		1207	(unsigned long) dll_name,
		1208	(unsigned long) first_thunk);
		1209
		1210	if (hint_addr == 0 && first_thunk == 0)
		1211	break;
		1212
		1213	if (dll_name - adj >= section->size)
		1214	break;
		1215
		1216	dll = (char *) data + dll_name - adj;
		1217	fprintf (file, _("\n\tDLL Name: %s\n"), dll);
		1218
		1219	if (hint_addr != 0)
		1220	{
		1221	bfd_byte *ft_data;
		1222	asection *ft_section;
		1223	bfd_vma ft_addr;
		1224	bfd_size_type ft_datasize;
		1225	int ft_idx;
		1226	int ft_allocated;
		1227
		1228	fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
		1229
		1230	idx = hint_addr - adj;
		1231
		1232	ft_addr = first_thunk + extra->ImageBase;
		1233	ft_idx = first_thunk - adj;
		1234	ft_data = data + ft_idx;
		1235	ft_datasize = datasize - ft_idx;
		1236	ft_allocated = 0;
		1237
		1238	if (first_thunk != hint_addr)
		1239	{
		1240	/* Find the section which contains the first thunk. */
		1241	for (ft_section = abfd->sections;
		1242	ft_section != NULL;
		1243	ft_section = ft_section->next)
		1244	{
		1245	if (ft_addr >= ft_section->vma
		1246	&& ft_addr < ft_section->vma + ft_section->size)
		1247	break;
		1248	}
		1249
		1250	if (ft_section == NULL)
		1251	{
		1252	fprintf (file,
		1253	_("\nThere is a first thunk, but the section containing it could not be found\n"));
		1254	continue;
		1255	}
		1256
		1257	/* Now check to see if this section is the same as our current
		1258	section. If it is not then we will have to load its data in. */
		1259	if (ft_section != section)
		1260	{
		1261	ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
		1262	ft_datasize = ft_section->size - ft_idx;
		1263	ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
		1264	if (ft_data == NULL)
		1265	continue;
		1266
		1267	/* Read ft_datasize bytes starting at offset ft_idx. */
		1268	if (!bfd_get_section_contents (abfd, ft_section, ft_data,
		1269	(bfd_vma) ft_idx, ft_datasize))
		1270	{
		1271	free (ft_data);
		1272	continue;
		1273	}
		1274	ft_allocated = 1;
		1275	}
		1276	}
		1277
		1278	/* Print HintName vector entries. */
		1279	#ifdef COFF_WITH_pex64
		1280	for (j = 0; idx + j + 8 <= datasize; j += 8)
		1281	{
		1282	unsigned long member = bfd_get_32 (abfd, data + idx + j);
		1283	unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
		1284
		1285	if (!member && !member_high)
		1286	break;
		1287
		1288	if (member_high & 0x80000000)
		1289	fprintf (file, "\t%lx%08lx\t %4lx%08lx ",
		1290	member_high,member, member_high & 0x7fffffff, member);
		1291	else
		1292	{
		1293	int ordinal;
		1294	char *member_name;
		1295
		1296	ordinal = bfd_get_16 (abfd, data + member - adj);
		1297	member_name = (char *) data + member - adj + 2;
		1298	fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name);
		1299	}
		1300
		1301	/* If the time stamp is not zero, the import address
		1302	table holds actual addresses. */
		1303	if (time_stamp != 0
		1304	&& first_thunk != 0
		1305	&& first_thunk != hint_addr
		1306	&& j + 4 <= ft_datasize)
		1307	fprintf (file, "\t%04lx",
		1308	(unsigned long) bfd_get_32 (abfd, ft_data + j));
		1309	fprintf (file, "\n");
		1310	}
		1311	#else
		1312	for (j = 0; idx + j + 4 <= datasize; j += 4)
		1313	{
		1314	unsigned long member = bfd_get_32 (abfd, data + idx + j);
		1315
		1316	/* Print single IMAGE_IMPORT_BY_NAME vector. */
		1317	if (member == 0)
		1318	break;
		1319
		1320	if (member & 0x80000000)
		1321	fprintf (file, "\t%04lx\t %4lu ",
		1322	member, member & 0x7fffffff);
		1323	else
		1324	{
		1325	int ordinal;
		1326	char *member_name;
		1327
		1328	ordinal = bfd_get_16 (abfd, data + member - adj);
		1329	member_name = (char *) data + member - adj + 2;
		1330	fprintf (file, "\t%04lx\t %4d %s",
		1331	member, ordinal, member_name);
		1332	}
		1333
		1334	/* If the time stamp is not zero, the import address
		1335	table holds actual addresses. */
		1336	if (time_stamp != 0
		1337	&& first_thunk != 0
		1338	&& first_thunk != hint_addr
		1339	&& j + 4 <= ft_datasize)
		1340	fprintf (file, "\t%04lx",
		1341	(unsigned long) bfd_get_32 (abfd, ft_data + j));
		1342
		1343	fprintf (file, "\n");
		1344	}
		1345	#endif
		1346	if (ft_allocated)
		1347	free (ft_data);
		1348	}
		1349
		1350	fprintf (file, "\n");
		1351	}
		1352
		1353	free (data);
		1354
		1355	return TRUE;
		1356	}
		1357
		1358	static bfd_boolean
		1359	pe_print_edata (bfd * abfd, void * vfile)
		1360	{
		1361	FILE file = (FILE ) vfile;
		1362	bfd_byte *data;
		1363	asection *section;
		1364	bfd_size_type datasize = 0;
		1365	bfd_size_type dataoff;
		1366	bfd_size_type i;
		1367	bfd_signed_vma adj;
		1368	struct EDT_type
		1369	{
		1370	long export_flags; /* Reserved - should be zero. */
		1371	long time_stamp;
		1372	short major_ver;
		1373	short minor_ver;
		1374	bfd_vma name; /* RVA - relative to image base. */
		1375	long base; /* Ordinal base. */
		1376	unsigned long num_functions;/* Number in the export address table. */
		1377	unsigned long num_names; /* Number in the name pointer table. */
		1378	bfd_vma eat_addr; /* RVA to the export address table. */
		1379	bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
		1380	bfd_vma ot_addr; /* RVA to the Ordinal Table. */
		1381	} edt;
		1382
		1383	pe_data_type *pe = pe_data (abfd);
		1384	struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
		1385
		1386	bfd_vma addr;
		1387
		1388	addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
		1389
		1390	if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
		1391	{
		1392	/* Maybe the extra header isn't there. Look for the section. */
		1393	section = bfd_get_section_by_name (abfd, ".edata");
		1394	if (section == NULL)
		1395	return TRUE;
		1396
		1397	addr = section->vma;
		1398	dataoff = 0;
		1399	datasize = section->size;
		1400	if (datasize == 0)
		1401	return TRUE;
		1402	}
		1403	else
		1404	{
		1405	addr += extra->ImageBase;
		1406
		1407	for (section = abfd->sections; section != NULL; section = section->next)
		1408	if (addr >= section->vma && addr < section->vma + section->size)
		1409	break;
		1410
		1411	if (section == NULL)
		1412	{
		1413	fprintf (file,
		1414	_("\nThere is an export table, but the section containing it could not be found\n"));
		1415	return TRUE;
		1416	}
		1417
		1418	dataoff = addr - section->vma;
		1419	datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
		1420	if (datasize > section->size - dataoff)
		1421	{
		1422	fprintf (file,
		1423	_("\nThere is an export table in %s, but it does not fit into that section\n"),
		1424	section->name);
		1425	return TRUE;
		1426	}
		1427	}
		1428
		1429	fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
		1430	section->name, (unsigned long) addr);
		1431
		1432	data = (bfd_byte *) bfd_malloc (datasize);
		1433	if (data == NULL)
		1434	return FALSE;
		1435
		1436	if (! bfd_get_section_contents (abfd, section, data,
		1437	(file_ptr) dataoff, datasize))
		1438	return FALSE;
		1439
		1440	/* Go get Export Directory Table. */
		1441	edt.export_flags = bfd_get_32 (abfd, data + 0);
		1442	edt.time_stamp = bfd_get_32 (abfd, data + 4);
		1443	edt.major_ver = bfd_get_16 (abfd, data + 8);
		1444	edt.minor_ver = bfd_get_16 (abfd, data + 10);
		1445	edt.name = bfd_get_32 (abfd, data + 12);
		1446	edt.base = bfd_get_32 (abfd, data + 16);
		1447	edt.num_functions = bfd_get_32 (abfd, data + 20);
		1448	edt.num_names = bfd_get_32 (abfd, data + 24);
		1449	edt.eat_addr = bfd_get_32 (abfd, data + 28);
		1450	edt.npt_addr = bfd_get_32 (abfd, data + 32);
		1451	edt.ot_addr = bfd_get_32 (abfd, data + 36);
		1452
		1453	adj = section->vma - extra->ImageBase + dataoff;
		1454
		1455	/* Dump the EDT first. */
		1456	fprintf (file,
		1457	_("\nThe Export Tables (interpreted %s section contents)\n\n"),
		1458	section->name);
		1459
		1460	fprintf (file,
		1461	_("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
		1462
		1463	fprintf (file,
		1464	_("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
		1465
		1466	fprintf (file,
		1467	_("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
		1468
		1469	fprintf (file,
		1470	_("Name \t\t\t\t"));
		1471	bfd_fprintf_vma (abfd, file, edt.name);
		1472	fprintf (file,
		1473	" %s\n", data + edt.name - adj);
		1474
		1475	fprintf (file,
		1476	_("Ordinal Base \t\t\t%ld\n"), edt.base);
		1477
		1478	fprintf (file,
		1479	_("Number in:\n"));
		1480
		1481	fprintf (file,
		1482	_("\tExport Address Table \t\t%08lx\n"),
		1483	edt.num_functions);
		1484
		1485	fprintf (file,
		1486	_("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
		1487
		1488	fprintf (file,
		1489	_("Table Addresses\n"));
		1490
		1491	fprintf (file,
		1492	_("\tExport Address Table \t\t"));
		1493	bfd_fprintf_vma (abfd, file, edt.eat_addr);
		1494	fprintf (file, "\n");
		1495
		1496	fprintf (file,
		1497	_("\tName Pointer Table \t\t"));
		1498	bfd_fprintf_vma (abfd, file, edt.npt_addr);
		1499	fprintf (file, "\n");
		1500
		1501	fprintf (file,
		1502	_("\tOrdinal Table \t\t\t"));
		1503	bfd_fprintf_vma (abfd, file, edt.ot_addr);
		1504	fprintf (file, "\n");
		1505
		1506	/* The next table to find is the Export Address Table. It's basically
		1507	a list of pointers that either locate a function in this dll, or
		1508	forward the call to another dll. Something like:
		1509	typedef union
		1510	{
		1511	long export_rva;
		1512	long forwarder_rva;
		1513	} export_address_table_entry; */
		1514
		1515	fprintf (file,
		1516	_("\nExport Address Table -- Ordinal Base %ld\n"),
		1517	edt.base);
		1518
		1519	for (i = 0; i < edt.num_functions; ++i)
		1520	{
		1521	bfd_vma eat_member = bfd_get_32 (abfd,
		1522	data + edt.eat_addr + (i * 4) - adj);
		1523	if (eat_member == 0)
		1524	continue;
		1525
		1526	if (eat_member - adj <= datasize)
		1527	{
		1528	/* This rva is to a name (forwarding function) in our section. */
		1529	/* Should locate a function descriptor. */
		1530	fprintf (file,
		1531	"\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
		1532	(long) i,
		1533	(long) (i + edt.base),
		1534	(unsigned long) eat_member,
		1535	_("Forwarder RVA"),
		1536	data + eat_member - adj);
		1537	}
		1538	else
		1539	{
		1540	/* Should locate a function descriptor in the reldata section. */
		1541	fprintf (file,
		1542	"\t[%4ld] +base[%4ld] %04lx %s\n",
		1543	(long) i,
		1544	(long) (i + edt.base),
		1545	(unsigned long) eat_member,
		1546	_("Export RVA"));
		1547	}
		1548	}
		1549
		1550	/* The Export Name Pointer Table is paired with the Export Ordinal Table. */
		1551	/* Dump them in parallel for clarity. */
		1552	fprintf (file,
		1553	_("\n[Ordinal/Name Pointer] Table\n"));
		1554
		1555	for (i = 0; i < edt.num_names; ++i)
		1556	{
		1557	bfd_vma name_ptr = bfd_get_32 (abfd,
		1558	data +
		1559	edt.npt_addr
		1560	+ (i*4) - adj);
		1561
		1562	char name = (char ) data + name_ptr - adj;
		1563
		1564	bfd_vma ord = bfd_get_16 (abfd,
		1565	data +
		1566	edt.ot_addr
		1567	+ (i*2) - adj);
		1568	fprintf (file,
		1569	"\t[%4ld] %s\n", (long) ord, name);
		1570	}
		1571
		1572	free (data);
		1573
		1574	return TRUE;
		1575	}
		1576
		1577	/* This really is architecture dependent. On IA-64, a .pdata entry
		1578	consists of three dwords containing relative virtual addresses that
		1579	specify the start and end address of the code range the entry
		1580	covers and the address of the corresponding unwind info data.
		1581
		1582	On ARM and SH-4, a compressed PDATA structure is used :
		1583	_IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
		1584	_IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
		1585	See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
		1586
		1587	This is the version for uncompressed data. */
		1588
		1589	static bfd_boolean
		1590	pe_print_pdata (bfd * abfd, void * vfile)
		1591	{
		1592	#if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		1593	# define PDATA_ROW_SIZE (3 * 8)
		1594	#else
		1595	# define PDATA_ROW_SIZE (5 * 4)
		1596	#endif
		1597	FILE file = (FILE ) vfile;
		1598	bfd_byte *data = 0;
		1599	asection *section = bfd_get_section_by_name (abfd, ".pdata");
		1600	bfd_size_type datasize = 0;
		1601	bfd_size_type i;
		1602	bfd_size_type start, stop;
		1603	int onaline = PDATA_ROW_SIZE;
		1604
		1605	if (section == NULL
		1606	\|\| coff_section_data (abfd, section) == NULL
		1607	\|\| pei_section_data (abfd, section) == NULL)
		1608	return TRUE;
		1609
		1610	stop = pei_section_data (abfd, section)->virt_size;
		1611	if ((stop % onaline) != 0)
		1612	fprintf (file,
		1613	_("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
		1614	(long) stop, onaline);
		1615
		1616	fprintf (file,
		1617	_("\nThe Function Table (interpreted .pdata section contents)\n"));
		1618	#if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		1619	fprintf (file,
		1620	_(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
		1621	#else
		1622	fprintf (file, _("\
		1623	vma:\t\tBegin End EH EH PrologEnd Exception\n\
		1624	\t\tAddress Address Handler Data Address Mask\n"));
		1625	#endif
		1626
		1627	datasize = section->size;
		1628	if (datasize == 0)
		1629	return TRUE;
		1630
		1631	if (! bfd_malloc_and_get_section (abfd, section, &data))
		1632	{
		1633	if (data != NULL)
		1634	free (data);
		1635	return FALSE;
		1636	}
		1637
		1638	start = 0;
		1639
		1640	for (i = start; i < stop; i += onaline)
		1641	{
		1642	bfd_vma begin_addr;
		1643	bfd_vma end_addr;
		1644	bfd_vma eh_handler;
		1645	bfd_vma eh_data;
		1646	bfd_vma prolog_end_addr;
		1647	#if !defined(COFF_WITH_pep) \|\| defined(COFF_WITH_pex64)
		1648	int em_data;
		1649	#endif
		1650
		1651	if (i + PDATA_ROW_SIZE > stop)
		1652	break;
		1653
		1654	begin_addr = GET_PDATA_ENTRY (abfd, data + i );
		1655	end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
		1656	eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
		1657	eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
		1658	prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
		1659
		1660	if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
		1661	&& eh_data == 0 && prolog_end_addr == 0)
		1662	/* We are probably into the padding of the section now. */
		1663	break;
		1664
		1665	#if !defined(COFF_WITH_pep) \|\| defined(COFF_WITH_pex64)
		1666	em_data = ((eh_handler & 0x1) << 2) \| (prolog_end_addr & 0x3);
		1667	#endif
		1668	eh_handler &= ~(bfd_vma) 0x3;
		1669	prolog_end_addr &= ~(bfd_vma) 0x3;
		1670
		1671	fputc (' ', file);
		1672	bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
		1673	bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
		1674	bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
		1675	bfd_fprintf_vma (abfd, file, eh_handler);
		1676	#if !defined(COFF_WITH_pep) \|\| defined(COFF_WITH_pex64)
		1677	fputc (' ', file);
		1678	bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
		1679	bfd_fprintf_vma (abfd, file, prolog_end_addr);
		1680	fprintf (file, " %x", em_data);
		1681	#endif
		1682
		1683	#ifdef POWERPC_LE_PE
		1684	if (eh_handler == 0 && eh_data != 0)
		1685	{
		1686	/* Special bits here, although the meaning may be a little
		1687	mysterious. The only one I know for sure is 0x03
		1688	Code Significance
		1689	0x00 None
		1690	0x01 Register Save Millicode
		1691	0x02 Register Restore Millicode
		1692	0x03 Glue Code Sequence. */
		1693	switch (eh_data)
		1694	{
		1695	case 0x01:
		1696	fprintf (file, _(" Register save millicode"));
		1697	break;
		1698	case 0x02:
		1699	fprintf (file, _(" Register restore millicode"));
		1700	break;
		1701	case 0x03:
		1702	fprintf (file, _(" Glue code sequence"));
		1703	break;
		1704	default:
		1705	break;
		1706	}
		1707	}
		1708	#endif
		1709	fprintf (file, "\n");
		1710	}
		1711
		1712	free (data);
		1713
		1714	return TRUE;
		1715	#undef PDATA_ROW_SIZE
		1716	}
		1717
		1718	typedef struct sym_cache
		1719	{
		1720	int symcount;
		1721	asymbol ** syms;
		1722	} sym_cache;
		1723
		1724	static asymbol **
		1725	slurp_symtab (bfd abfd, sym_cache psc)
		1726	{
		1727	asymbol ** sy = NULL;
		1728	long storage;
		1729
		1730	if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
		1731	{
		1732	psc->symcount = 0;
		1733	return NULL;
		1734	}
		1735
		1736	storage = bfd_get_symtab_upper_bound (abfd);
		1737	if (storage < 0)
		1738	return NULL;
		1739	if (storage)
		1740	sy = (asymbol **) bfd_malloc (storage);
		1741
		1742	psc->symcount = bfd_canonicalize_symtab (abfd, sy);
		1743	if (psc->symcount < 0)
		1744	return NULL;
		1745	return sy;
		1746	}
		1747
		1748	static const char *
		1749	my_symbol_for_address (bfd abfd, bfd_vma func, sym_cache psc)
		1750	{
		1751	int i;
		1752
		1753	if (psc->syms == 0)
		1754	psc->syms = slurp_symtab (abfd, psc);
		1755
		1756	for (i = 0; i < psc->symcount; i++)
		1757	{
		1758	if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
		1759	return psc->syms[i]->name;
		1760	}
		1761
		1762	return NULL;
		1763	}
		1764
		1765	static void
		1766	cleanup_syms (sym_cache *psc)
		1767	{
		1768	psc->symcount = 0;
		1769	free (psc->syms);
		1770	psc->syms = NULL;
		1771	}
		1772
		1773	/* This is the version for "compressed" pdata. */
		1774
		1775	bfd_boolean
		1776	_bfd_pe_print_ce_compressed_pdata (bfd * abfd, void * vfile)
		1777	{
		1778	# define PDATA_ROW_SIZE (2 * 4)
		1779	FILE file = (FILE ) vfile;
		1780	bfd_byte *data = NULL;
		1781	asection *section = bfd_get_section_by_name (abfd, ".pdata");
		1782	bfd_size_type datasize = 0;
		1783	bfd_size_type i;
		1784	bfd_size_type start, stop;
		1785	int onaline = PDATA_ROW_SIZE;
		1786	struct sym_cache cache = {0, 0} ;
		1787
		1788	if (section == NULL
		1789	\|\| coff_section_data (abfd, section) == NULL
		1790	\|\| pei_section_data (abfd, section) == NULL)
		1791	return TRUE;
		1792
		1793	stop = pei_section_data (abfd, section)->virt_size;
		1794	if ((stop % onaline) != 0)
		1795	fprintf (file,
		1796	_("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
		1797	(long) stop, onaline);
		1798
		1799	fprintf (file,
		1800	_("\nThe Function Table (interpreted .pdata section contents)\n"));
		1801
		1802	fprintf (file, _("\
		1803	vma:\t\tBegin Prolog Function Flags Exception EH\n\
		1804	\t\tAddress Length Length 32b exc Handler Data\n"));
		1805
		1806	datasize = section->size;
		1807	if (datasize == 0)
		1808	return TRUE;
		1809
		1810	if (! bfd_malloc_and_get_section (abfd, section, &data))
		1811	{
		1812	if (data != NULL)
		1813	free (data);
		1814	return FALSE;
		1815	}
		1816
		1817	start = 0;
		1818
		1819	for (i = start; i < stop; i += onaline)
		1820	{
		1821	bfd_vma begin_addr;
		1822	bfd_vma other_data;
		1823	bfd_vma prolog_length, function_length;
		1824	int flag32bit, exception_flag;
		1825	asection *tsection;
		1826
		1827	if (i + PDATA_ROW_SIZE > stop)
		1828	break;
		1829
		1830	begin_addr = GET_PDATA_ENTRY (abfd, data + i );
		1831	other_data = GET_PDATA_ENTRY (abfd, data + i + 4);
		1832
		1833	if (begin_addr == 0 && other_data == 0)
		1834	/* We are probably into the padding of the section now. */
		1835	break;
		1836
		1837	prolog_length = (other_data & 0x000000FF);
		1838	function_length = (other_data & 0x3FFFFF00) >> 8;
		1839	flag32bit = (int)((other_data & 0x40000000) >> 30);
		1840	exception_flag = (int)((other_data & 0x80000000) >> 31);
		1841
		1842	fputc (' ', file);
		1843	bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
		1844	bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
		1845	bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
		1846	bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
		1847	fprintf (file, "%2d %2d ", flag32bit, exception_flag);
		1848
		1849	/* Get the exception handler's address and the data passed from the
		1850	.text section. This is really the data that belongs with the .pdata
		1851	but got "compressed" out for the ARM and SH4 architectures. */
		1852	tsection = bfd_get_section_by_name (abfd, ".text");
		1853	if (tsection && coff_section_data (abfd, tsection)
		1854	&& pei_section_data (abfd, tsection))
		1855	{
		1856	bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
		1857	bfd_byte *tdata;
		1858
		1859	tdata = (bfd_byte *) bfd_malloc (8);
		1860	if (tdata)
		1861	{
		1862	if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
		1863	{
		1864	bfd_vma eh, eh_data;
		1865
		1866	eh = bfd_get_32 (abfd, tdata);
		1867	eh_data = bfd_get_32 (abfd, tdata + 4);
		1868	fprintf (file, "%08x ", (unsigned int) eh);
		1869	fprintf (file, "%08x", (unsigned int) eh_data);
		1870	if (eh != 0)
		1871	{
		1872	const char *s = my_symbol_for_address (abfd, eh, &cache);
		1873
		1874	if (s)
		1875	fprintf (file, " (%s) ", s);
		1876	}
		1877	}
		1878	free (tdata);
		1879	}
		1880	}
		1881
		1882	fprintf (file, "\n");
		1883	}
		1884
		1885	free (data);
		1886
		1887	cleanup_syms (& cache);
		1888
		1889	return TRUE;
		1890	#undef PDATA_ROW_SIZE
		1891	}
		1892
		1893
		1894	#define IMAGE_REL_BASED_HIGHADJ 4
		1895	static const char * const tbl[] =
		1896	{
		1897	"ABSOLUTE",
		1898	"HIGH",
		1899	"LOW",
		1900	"HIGHLOW",
		1901	"HIGHADJ",
		1902	"MIPS_JMPADDR",
		1903	"SECTION",
		1904	"REL32",
		1905	"RESERVED1",
		1906	"MIPS_JMPADDR16",
		1907	"DIR64",
		1908	"HIGH3ADJ",
		1909	"UNKNOWN", /* MUST be last. */
		1910	};
		1911
		1912	static bfd_boolean
		1913	pe_print_reloc (bfd * abfd, void * vfile)
		1914	{
		1915	FILE file = (FILE ) vfile;
		1916	bfd_byte *data = 0;
		1917	asection *section = bfd_get_section_by_name (abfd, ".reloc");
		1918	bfd_size_type i;
		1919	bfd_size_type start, stop;
		1920
		1921	if (section == NULL)
		1922	return TRUE;
		1923
		1924	if (section->size == 0)
		1925	return TRUE;
		1926
		1927	fprintf (file,
		1928	_("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
		1929
		1930	if (! bfd_malloc_and_get_section (abfd, section, &data))
		1931	{
		1932	if (data != NULL)
		1933	free (data);
		1934	return FALSE;
		1935	}
		1936
		1937	start = 0;
		1938
		1939	stop = section->size;
		1940
		1941	for (i = start; i < stop;)
		1942	{
		1943	int j;
		1944	bfd_vma virtual_address;
		1945	long number, size;
		1946
		1947	/* The .reloc section is a sequence of blocks, with a header consisting
		1948	of two 32 bit quantities, followed by a number of 16 bit entries. */
		1949	virtual_address = bfd_get_32 (abfd, data+i);
		1950	size = bfd_get_32 (abfd, data+i+4);
		1951	number = (size - 8) / 2;
		1952
		1953	if (size == 0)
		1954	break;
		1955
		1956	fprintf (file,
		1957	_("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
		1958	(unsigned long) virtual_address, size, (unsigned long) size, number);
		1959
		1960	for (j = 0; j < number; ++j)
		1961	{
		1962	unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
		1963	unsigned int t = (e & 0xF000) >> 12;
		1964	int off = e & 0x0FFF;
		1965
		1966	if (t >= sizeof (tbl) / sizeof (tbl[0]))
		1967	t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
		1968
		1969	fprintf (file,
		1970	_("\treloc %4d offset %4x [%4lx] %s"),
		1971	j, off, (unsigned long) (off + virtual_address), tbl[t]);
		1972
		1973	/* HIGHADJ takes an argument, - the next record is the
		1974	low 16 bits of addend. */
		1975	if (t == IMAGE_REL_BASED_HIGHADJ)
		1976	{
		1977	fprintf (file, " (%4x)",
		1978	((unsigned int)
		1979	bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
		1980	j++;
		1981	}
		1982
		1983	fprintf (file, "\n");
		1984	}
		1985
		1986	i += size;
		1987	}
		1988
		1989	free (data);
		1990
		1991	return TRUE;
		1992	}
		1993
		1994	/* Print out the program headers. */
		1995
		1996	bfd_boolean
		1997	_bfd_pe_print_private_bfd_data_common (bfd * abfd, void * vfile)
		1998	{
		1999	FILE file = (FILE ) vfile;
		2000	int j;
		2001	pe_data_type *pe = pe_data (abfd);
		2002	struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
		2003	const char *subsystem_name = NULL;
		2004	const char *name;
		2005
		2006	/* The MS dumpbin program reportedly ands with 0xff0f before
		2007	printing the characteristics field. Not sure why. No reason to
		2008	emulate it here. */
		2009	fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
		2010	#undef PF
		2011	#define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
		2012	PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
		2013	PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
		2014	PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
		2015	PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
		2016	PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
		2017	PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
		2018	PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
		2019	PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
		2020	PF (IMAGE_FILE_SYSTEM, "system file");
		2021	PF (IMAGE_FILE_DLL, "DLL");
		2022	PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
		2023	#undef PF
		2024
		2025	/* ctime implies '\n'. */
		2026	{
		2027	time_t t = pe->coff.timestamp;
		2028	fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
		2029	}
		2030
		2031	#ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
		2032	# define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
		2033	#endif
		2034	#ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
		2035	# define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
		2036	#endif
		2037	#ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
		2038	# define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
		2039	#endif
		2040
		2041	switch (i->Magic)
		2042	{
		2043	case IMAGE_NT_OPTIONAL_HDR_MAGIC:
		2044	name = "PE32";
		2045	break;
		2046	case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
		2047	name = "PE32+";
		2048	break;
		2049	case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
		2050	name = "ROM";
		2051	break;
		2052	default:
		2053	name = NULL;
		2054	break;
		2055	}
		2056	fprintf (file, "Magic\t\t\t%04x", i->Magic);
		2057	if (name)
		2058	fprintf (file, "\t(%s)",name);
		2059	fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
		2060	fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
		2061	fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
		2062	fprintf (file, "SizeOfInitializedData\t%08lx\n",
		2063	(unsigned long) i->SizeOfInitializedData);
		2064	fprintf (file, "SizeOfUninitializedData\t%08lx\n",
		2065	(unsigned long) i->SizeOfUninitializedData);
		2066	fprintf (file, "AddressOfEntryPoint\t");
		2067	bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
		2068	fprintf (file, "\nBaseOfCode\t\t");
		2069	bfd_fprintf_vma (abfd, file, i->BaseOfCode);
		2070	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		2071	/* PE32+ does not have BaseOfData member! */
		2072	fprintf (file, "\nBaseOfData\t\t");
		2073	bfd_fprintf_vma (abfd, file, i->BaseOfData);
		2074	#endif
		2075
		2076	fprintf (file, "\nImageBase\t\t");
		2077	bfd_fprintf_vma (abfd, file, i->ImageBase);
		2078	fprintf (file, "\nSectionAlignment\t");
		2079	bfd_fprintf_vma (abfd, file, i->SectionAlignment);
		2080	fprintf (file, "\nFileAlignment\t\t");
		2081	bfd_fprintf_vma (abfd, file, i->FileAlignment);
		2082	fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
		2083	fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
		2084	fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
		2085	fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
		2086	fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
		2087	fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
		2088	fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
		2089	fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
		2090	fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
		2091	fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
		2092
		2093	switch (i->Subsystem)
		2094	{
		2095	case IMAGE_SUBSYSTEM_UNKNOWN:
		2096	subsystem_name = "unspecified";
		2097	break;
		2098	case IMAGE_SUBSYSTEM_NATIVE:
		2099	subsystem_name = "NT native";
		2100	break;
		2101	case IMAGE_SUBSYSTEM_WINDOWS_GUI:
		2102	subsystem_name = "Windows GUI";
		2103	break;
		2104	case IMAGE_SUBSYSTEM_WINDOWS_CUI:
		2105	subsystem_name = "Windows CUI";
		2106	break;
		2107	case IMAGE_SUBSYSTEM_POSIX_CUI:
		2108	subsystem_name = "POSIX CUI";
		2109	break;
		2110	case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
		2111	subsystem_name = "Wince CUI";
		2112	break;
		2113	// These are from UEFI Platform Initialization Specification 1.1.
		2114	case IMAGE_SUBSYSTEM_EFI_APPLICATION:
		2115	subsystem_name = "EFI application";
		2116	break;
		2117	case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
		2118	subsystem_name = "EFI boot service driver";
		2119	break;
		2120	case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
		2121	subsystem_name = "EFI runtime driver";
		2122	break;
		2123	case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
		2124	subsystem_name = "SAL runtime driver";
		2125	break;
		2126	// This is from revision 8.0 of the MS PE/COFF spec
		2127	case IMAGE_SUBSYSTEM_XBOX:
		2128	subsystem_name = "XBOX";
		2129	break;
		2130	// Added default case for clarity - subsystem_name is NULL anyway.
		2131	default:
		2132	subsystem_name = NULL;
		2133	}
		2134
		2135	fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
		2136	if (subsystem_name)
		2137	fprintf (file, "\t(%s)", subsystem_name);
		2138	fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
		2139	fprintf (file, "SizeOfStackReserve\t");
		2140	bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
		2141	fprintf (file, "\nSizeOfStackCommit\t");
		2142	bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
		2143	fprintf (file, "\nSizeOfHeapReserve\t");
		2144	bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
		2145	fprintf (file, "\nSizeOfHeapCommit\t");
		2146	bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
		2147	fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
		2148	fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
		2149	(unsigned long) i->NumberOfRvaAndSizes);
		2150
		2151	fprintf (file, "\nThe Data Directory\n");
		2152	for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
		2153	{
		2154	fprintf (file, "Entry %1x ", j);
		2155	bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
		2156	fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
		2157	fprintf (file, "%s\n", dir_names[j]);
		2158	}
		2159
		2160	pe_print_idata (abfd, vfile);
		2161	pe_print_edata (abfd, vfile);
		2162	if (bfd_coff_have_print_pdata (abfd))
		2163	bfd_coff_print_pdata (abfd, vfile);
		2164	else
		2165	pe_print_pdata (abfd, vfile);
		2166	pe_print_reloc (abfd, vfile);
		2167
		2168	return TRUE;
		2169	}
		2170
		2171	/* Copy any private info we understand from the input bfd
		2172	to the output bfd. */
		2173
		2174	bfd_boolean
		2175	_bfd_pe_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
		2176	{
		2177	pe_data_type ipe, ope;
		2178
		2179	/* One day we may try to grok other private data. */
		2180	if (ibfd->xvec->flavour != bfd_target_coff_flavour
		2181	\|\| obfd->xvec->flavour != bfd_target_coff_flavour)
		2182	return TRUE;
		2183
		2184	ipe = pe_data (ibfd);
		2185	ope = pe_data (obfd);
		2186
		2187	/* pe_opthdr is copied in copy_object. */
		2188	ope->dll = ipe->dll;
		2189
		2190	/* Don't copy input subsystem if output is different from input. */
		2191	if (obfd->xvec != ibfd->xvec)
		2192	ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
		2193
		2194	/* For strip: if we removed .reloc, we'll make a real mess of things
		2195	if we don't remove this entry as well. */
		2196	if (! pe_data (obfd)->has_reloc_section)
		2197	{
		2198	pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
		2199	pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
		2200	}
		2201
		2202	/* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
		2203	But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
		2204	won't be added. */
		2205	if (! pe_data (ibfd)->has_reloc_section
		2206	&& ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
		2207	pe_data (obfd)->dont_strip_reloc = 1;
		2208
		2209	return TRUE;
		2210	}
		2211
		2212	/* Copy private section data. */
		2213
		2214	bfd_boolean
		2215	_bfd_pe_bfd_copy_private_section_data (bfd *ibfd,
		2216	asection *isec,
		2217	bfd *obfd,
		2218	asection *osec)
		2219	{
		2220	if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
		2221	\|\| bfd_get_flavour (obfd) != bfd_target_coff_flavour)
		2222	return TRUE;
		2223
		2224	if (coff_section_data (ibfd, isec) != NULL
		2225	&& pei_section_data (ibfd, isec) != NULL)
		2226	{
		2227	if (coff_section_data (obfd, osec) == NULL)
		2228	{
		2229	bfd_size_type amt = sizeof (struct coff_section_tdata);
		2230	osec->used_by_bfd = bfd_zalloc (obfd, amt);
		2231	if (osec->used_by_bfd == NULL)
		2232	return FALSE;
		2233	}
		2234
		2235	if (pei_section_data (obfd, osec) == NULL)
		2236	{
		2237	bfd_size_type amt = sizeof (struct pei_section_tdata);
		2238	coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
		2239	if (coff_section_data (obfd, osec)->tdata == NULL)
		2240	return FALSE;
		2241	}
		2242
		2243	pei_section_data (obfd, osec)->virt_size =
		2244	pei_section_data (ibfd, isec)->virt_size;
		2245	pei_section_data (obfd, osec)->pe_flags =
		2246	pei_section_data (ibfd, isec)->pe_flags;
		2247	}
		2248
		2249	return TRUE;
		2250	}
		2251
		2252	void
		2253	_bfd_pe_get_symbol_info (bfd * abfd, asymbol symbol, symbol_info ret)
		2254	{
		2255	coff_get_symbol_info (abfd, symbol, ret);
		2256	}
		2257
		2258	#if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
		2259	static int
		2260	sort_x64_pdata (const void l, const void r)
		2261	{
		2262	const char lp = (const char ) l;
		2263	const char rp = (const char ) r;
		2264	bfd_vma vl, vr;
		2265	vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
		2266	if (vl != vr)
		2267	return (vl < vr ? -1 : 1);
		2268	/* We compare just begin address. */
		2269	return 0;
		2270	}
		2271	#endif
		2272
		2273	/* Handle the .idata section and other things that need symbol table
		2274	access. */
		2275
		2276	bfd_boolean
		2277	_bfd_pei_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
		2278	{
		2279	struct coff_link_hash_entry *h1;
		2280	struct bfd_link_info *info = pfinfo->info;
		2281	bfd_boolean result = TRUE;
		2282
		2283	/* There are a few fields that need to be filled in now while we
		2284	have symbol table access.
		2285
		2286	The .idata subsections aren't directly available as sections, but
		2287	they are in the symbol table, so get them from there. */
		2288
		2289	/* The import directory. This is the address of .idata$2, with size
		2290	of .idata$2 + .idata$3. */
		2291	h1 = coff_link_hash_lookup (coff_hash_table (info),
		2292	".idata$2", FALSE, FALSE, TRUE);
		2293	if (h1 != NULL)
		2294	{
		2295	/* PR ld/2729: We cannot rely upon all the output sections having been
		2296	created properly, so check before referencing them. Issue a warning
		2297	message for any sections tht could not be found. */
		2298	if ((h1->root.type == bfd_link_hash_defined
		2299	\|\| h1->root.type == bfd_link_hash_defweak)
		2300	&& h1->root.u.def.section != NULL
		2301	&& h1->root.u.def.section->output_section != NULL)
		2302	pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
		2303	(h1->root.u.def.value
		2304	+ h1->root.u.def.section->output_section->vma
		2305	+ h1->root.u.def.section->output_offset);
		2306	else
		2307	{
		2308	_bfd_error_handler
		2309	(_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
		2310	abfd);
		2311	result = FALSE;
		2312	}
		2313
		2314	h1 = coff_link_hash_lookup (coff_hash_table (info),
		2315	".idata$4", FALSE, FALSE, TRUE);
		2316	if (h1 != NULL
		2317	&& (h1->root.type == bfd_link_hash_defined
		2318	\|\| h1->root.type == bfd_link_hash_defweak)
		2319	&& h1->root.u.def.section != NULL
		2320	&& h1->root.u.def.section->output_section != NULL)
		2321	pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
		2322	((h1->root.u.def.value
		2323	+ h1->root.u.def.section->output_section->vma
		2324	+ h1->root.u.def.section->output_offset)
		2325	- pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
		2326	else
		2327	{
		2328	_bfd_error_handler
		2329	(_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
		2330	abfd);
		2331	result = FALSE;
		2332	}
		2333
		2334	/* The import address table. This is the size/address of
		2335	.idata$5. */
		2336	h1 = coff_link_hash_lookup (coff_hash_table (info),
		2337	".idata$5", FALSE, FALSE, TRUE);
		2338	if (h1 != NULL
		2339	&& (h1->root.type == bfd_link_hash_defined
		2340	\|\| h1->root.type == bfd_link_hash_defweak)
		2341	&& h1->root.u.def.section != NULL
		2342	&& h1->root.u.def.section->output_section != NULL)
		2343	pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
		2344	(h1->root.u.def.value
		2345	+ h1->root.u.def.section->output_section->vma
		2346	+ h1->root.u.def.section->output_offset);
		2347	else
		2348	{
		2349	_bfd_error_handler
		2350	(_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
		2351	abfd);
		2352	result = FALSE;
		2353	}
		2354
		2355	h1 = coff_link_hash_lookup (coff_hash_table (info),
		2356	".idata$6", FALSE, FALSE, TRUE);
		2357	if (h1 != NULL
		2358	&& (h1->root.type == bfd_link_hash_defined
		2359	\|\| h1->root.type == bfd_link_hash_defweak)
		2360	&& h1->root.u.def.section != NULL
		2361	&& h1->root.u.def.section->output_section != NULL)
		2362	pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
		2363	((h1->root.u.def.value
		2364	+ h1->root.u.def.section->output_section->vma
		2365	+ h1->root.u.def.section->output_offset)
		2366	- pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
		2367	else
		2368	{
		2369	_bfd_error_handler
		2370	(_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
		2371	abfd);
		2372	result = FALSE;
		2373	}
		2374	}
		2375	else
		2376	{
		2377	h1 = coff_link_hash_lookup (coff_hash_table (info),
		2378	"__IAT_start__", FALSE, FALSE, TRUE);
		2379	if (h1 != NULL
		2380	&& (h1->root.type == bfd_link_hash_defined
		2381	\|\| h1->root.type == bfd_link_hash_defweak)
		2382	&& h1->root.u.def.section != NULL
		2383	&& h1->root.u.def.section->output_section != NULL)
		2384	{
		2385	bfd_vma iat_va;
		2386
		2387	iat_va =
		2388	(h1->root.u.def.value
		2389	+ h1->root.u.def.section->output_section->vma
		2390	+ h1->root.u.def.section->output_offset);
		2391
		2392	h1 = coff_link_hash_lookup (coff_hash_table (info),
		2393	"__IAT_end__", FALSE, FALSE, TRUE);
		2394	if (h1 != NULL
		2395	&& (h1->root.type == bfd_link_hash_defined
		2396	\|\| h1->root.type == bfd_link_hash_defweak)
		2397	&& h1->root.u.def.section != NULL
		2398	&& h1->root.u.def.section->output_section != NULL)
		2399	{
		2400	pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
		2401	((h1->root.u.def.value
		2402	+ h1->root.u.def.section->output_section->vma
		2403	+ h1->root.u.def.section->output_offset)
		2404	- iat_va);
		2405	if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
		2406	pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
		2407	iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
		2408	}
		2409	else
		2410	{
		2411	_bfd_error_handler
		2412	(_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
		2413	" because .idata$6 is missing"), abfd);
		2414	result = FALSE;
		2415	}
		2416	}
		2417	}
		2418
		2419	h1 = coff_link_hash_lookup (coff_hash_table (info),
		2420	(bfd_get_symbol_leading_char(abfd) != 0
		2421	? "__tls_used" : "_tls_used"),
		2422	FALSE, FALSE, TRUE);
		2423	if (h1 != NULL)
		2424	{
		2425	if ((h1->root.type == bfd_link_hash_defined
		2426	\|\| h1->root.type == bfd_link_hash_defweak)
		2427	&& h1->root.u.def.section != NULL
		2428	&& h1->root.u.def.section->output_section != NULL)
		2429	pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
		2430	(h1->root.u.def.value
		2431	+ h1->root.u.def.section->output_section->vma
		2432	+ h1->root.u.def.section->output_offset
		2433	- pe_data (abfd)->pe_opthdr.ImageBase);
		2434	else
		2435	{
		2436	_bfd_error_handler
		2437	(_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
		2438	abfd);
		2439	result = FALSE;
		2440	}
		2441	/* According to PECOFF sepcifications by Microsoft version 8.2
		2442	the TLS data directory consists of 4 pointers, followed
		2443	by two 4-byte integer. This implies that the total size
		2444	is different for 32-bit and 64-bit executables. */
		2445	#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
		2446	pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
		2447	#else
		2448	pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
		2449	#endif
		2450	}
		2451
		2452	/* If there is a .pdata section and we have linked pdata finally, we
		2453	need to sort the entries ascending. */
		2454	#if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
		2455	{
		2456	asection *sec = bfd_get_section_by_name (abfd, ".pdata");
		2457
		2458	if (sec)
		2459	{
		2460	bfd_size_type x = sec->rawsize;
		2461	bfd_byte *tmp_data = NULL;
		2462
		2463	if (x)
		2464	tmp_data = bfd_malloc (x);
		2465
		2466	if (tmp_data != NULL)
		2467	{
		2468	if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
		2469	{
		2470	qsort (tmp_data,
		2471	(size_t) (x / 12),
		2472	12, sort_x64_pdata);
		2473	bfd_set_section_contents (pfinfo->output_bfd, sec,
		2474	tmp_data, 0, x);
		2475	}
		2476	free (tmp_data);
		2477	}
		2478	}
		2479	}
		2480	#endif
		2481
		2482	/* If we couldn't find idata$2, we either have an excessively
		2483	trivial program or are in DEEP trouble; we have to assume trivial
		2484	program.... */
		2485	return result;
		2486	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/bfd/peigen.c – Rev 5197