WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/ld/pe-dll.c

Rev	Author	Line No.	Line
5199	serge	1	/* Routines to help build PEI-format DLLs (Win32 etc)
6324	serge	2	Copyright (C) 1998-2015 Free Software Foundation, Inc.
5199	serge	3	Written by DJ Delorie
		4
		5	This file is part of the GNU Binutils.
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 3 of the License, or
		10	(at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
		20	MA 02110-1301, USA. */
		21
		22	#include "sysdep.h"
		23	#include "bfd.h"
		24	#include "bfdlink.h"
		25	#include "libiberty.h"
		26	#include "filenames.h"
		27	#include "safe-ctype.h"
		28
		29	#include
		30
		31	#include "ld.h"
		32	#include "ldexp.h"
		33	#include "ldlang.h"
		34	#include "ldwrite.h"
		35	#include "ldmisc.h"
		36	#include
		37	#include "ldmain.h"
		38	#include "ldfile.h"
		39	#include "ldemul.h"
		40	#include "coff/internal.h"
		41	#include "../bfd/libcoff.h"
		42	#include "deffile.h"
		43
		44	#ifdef pe_use_x86_64
		45
		46	#define PE_IDATA4_SIZE 8
		47	#define PE_IDATA5_SIZE 8
		48	#include "pep-dll.h"
		49	#undef AOUTSZ
		50	#define AOUTSZ PEPAOUTSZ
		51	#define PEAOUTHDR PEPAOUTHDR
		52
		53	#else
		54
		55	#include "pe-dll.h"
		56
		57	#endif
		58
		59	#ifndef PE_IDATA4_SIZE
		60	#define PE_IDATA4_SIZE 4
		61	#endif
		62
		63	#ifndef PE_IDATA5_SIZE
		64	#define PE_IDATA5_SIZE 4
		65	#endif
		66
		67	/* This file turns a regular Windows PE image into a DLL. Because of
		68	the complexity of this operation, it has been broken down into a
		69	number of separate modules which are all called by the main function
		70	at the end of this file. This function is not re-entrant and is
		71	normally only called once, so static variables are used to reduce
		72	the number of parameters and return values required.
		73
		74	See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
		75
		76	/* Auto-import feature by Paul Sokolovsky
		77
		78	Quick facts:
		79
		80	1. With this feature on, DLL clients can import variables from DLL
		81	without any concern from their side (for example, without any source
		82	code modifications).
		83
		84	2. This is done completely in bounds of the PE specification (to be fair,
		85	there's a place where it pokes nose out of, but in practice it works).
		86	So, resulting module can be used with any other PE compiler/linker.
		87
		88	3. Auto-import is fully compatible with standard import method and they
		89	can be mixed together.
		90
		91	4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
		92	reference to it; load time: negligible; virtual/physical memory: should be
		93	less than effect of DLL relocation, and I sincerely hope it doesn't affect
		94	DLL sharability (too much).
		95
		96	Idea
		97
		98	The obvious and only way to get rid of dllimport insanity is to make client
		99	access variable directly in the DLL, bypassing extra dereference. I.e.,
		100	whenever client contains something like
		101
		102	mov dll_var,%eax,
		103
		104	address of dll_var in the command should be relocated to point into loaded
		105	DLL. The aim is to make OS loader do so, and than make ld help with that.
		106	Import section of PE made following way: there's a vector of structures
		107	each describing imports from particular DLL. Each such structure points
		108	to two other parallel vectors: one holding imported names, and one which
		109	will hold address of corresponding imported name. So, the solution is
		110	de-vectorize these structures, making import locations be sparse and
		111	pointing directly into code. Before continuing, it is worth a note that,
		112	while authors strives to make PE act ELF-like, there're some other people
		113	make ELF act PE-like: elfvector, ;-) .
		114
		115	Implementation
		116
		117	For each reference of data symbol to be imported from DLL (to set of which
		118	belong symbols with name , if __imp_ is found in implib), the
		119	import fixup entry is generated. That entry is of type
		120	IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
		121	fixup entry contains pointer to symbol's address within .text section
		122	(marked with __fuN_ symbol, where N is integer), pointer to DLL name
		123	(so, DLL name is referenced by multiple entries), and pointer to symbol
		124	name thunk. Symbol name thunk is singleton vector (__nm_th_)
		125	pointing to IMAGE_IMPORT_BY_NAME structure (__nm_) directly
		126	containing imported name. Here comes that "on the edge" problem mentioned
		127	above: PE specification rambles that name vector (OriginalFirstThunk)
		128	should run in parallel with addresses vector (FirstThunk), i.e. that they
		129	should have same number of elements and terminated with zero. We violate
		130	this, since FirstThunk points directly into machine code. But in practice,
		131	OS loader implemented the sane way: it goes thru OriginalFirstThunk and
		132	puts addresses to FirstThunk, not something else. It once again should be
		133	noted that dll and symbol name structures are reused across fixup entries
		134	and should be there anyway to support standard import stuff, so sustained
		135	overhead is 20 bytes per reference. Other question is whether having several
		136	IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
		137	done even by native compiler/linker (libth32's functions are in fact reside
		138	in windows9x kernel32.dll, so if you use it, you have two
		139	IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
		140	referencing the same PE structures several times is valid. The answer is why
		141	not, prohibiting that (detecting violation) would require more work on
		142	behalf of loader than not doing it.
		143
		144	See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
		145
		146	static void add_bfd_to_link (bfd , const char , struct bfd_link_info *);
		147
		148	/* For emultempl/pe.em. */
		149
		150	def_file * pe_def_file = 0;
		151	int pe_dll_export_everything = 0;
		152	int pe_dll_exclude_all_symbols = 0;
		153	int pe_dll_do_default_excludes = 1;
		154	int pe_dll_kill_ats = 0;
		155	int pe_dll_stdcall_aliases = 0;
		156	int pe_dll_warn_dup_exports = 0;
		157	int pe_dll_compat_implib = 0;
		158	int pe_dll_extra_pe_debug = 0;
		159	int pe_use_nul_prefixed_import_tables = 0;
		160	int pe_use_coff_long_section_names = -1;
		161	int pe_leading_underscore = -1;
		162
		163	/* Static variables and types. */
		164
		165	static bfd_vma image_base;
		166	static bfd *filler_bfd;
		167	static struct bfd_section edata_s, reloc_s;
		168	static unsigned char edata_d, reloc_d;
		169	static size_t edata_sz, reloc_sz;
		170	static int runtime_pseudo_relocs_created = 0;
		171	static int runtime_pseudp_reloc_v2_init = 0;
		172
		173	typedef struct
		174	{
		175	const char *name;
		176	int len;
		177	}
		178	autofilter_entry_type;
		179
		180	typedef struct
		181	{
		182	const char *target_name;
		183	const char *object_target;
		184	unsigned int imagebase_reloc;
		185	int pe_arch;
		186	int bfd_arch;
		187	bfd_boolean underscored;
		188	const autofilter_entry_type* autofilter_symbollist;
		189	}
		190	pe_details_type;
		191
		192	static const autofilter_entry_type autofilter_symbollist_generic[] =
		193	{
		194	{ STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
		195	/* Entry point symbols. */
		196	{ STRING_COMMA_LEN ("DllMain") },
		197	{ STRING_COMMA_LEN ("DllMainCRTStartup") },
		198	{ STRING_COMMA_LEN ("_DllMainCRTStartup") },
		199	/* Runtime pseudo-reloc. */
		200	{ STRING_COMMA_LEN ("_pei386_runtime_relocator") },
		201	{ STRING_COMMA_LEN ("do_pseudo_reloc") },
		202	{ NULL, 0 }
		203	};
		204
		205	static const autofilter_entry_type autofilter_symbollist_i386[] =
		206	{
		207	{ STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
		208	/* Entry point symbols, and entry hooks. */
		209	{ STRING_COMMA_LEN ("cygwin_crt0") },
		210	#ifdef pe_use_x86_64
		211	{ STRING_COMMA_LEN ("DllMain") },
		212	{ STRING_COMMA_LEN ("DllEntryPoint") },
		213	{ STRING_COMMA_LEN ("DllMainCRTStartup") },
		214	{ STRING_COMMA_LEN ("_cygwin_dll_entry") },
		215	{ STRING_COMMA_LEN ("_cygwin_crt0_common") },
		216	{ STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
		217	#else
		218	{ STRING_COMMA_LEN ("DllMain@12") },
		219	{ STRING_COMMA_LEN ("DllEntryPoint@0") },
		220	{ STRING_COMMA_LEN ("DllMainCRTStartup@12") },
		221	{ STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
		222	{ STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
		223	{ STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
		224	{ STRING_COMMA_LEN ("cygwin_attach_dll") },
		225	#endif
		226	{ STRING_COMMA_LEN ("cygwin_premain0") },
		227	{ STRING_COMMA_LEN ("cygwin_premain1") },
		228	{ STRING_COMMA_LEN ("cygwin_premain2") },
		229	{ STRING_COMMA_LEN ("cygwin_premain3") },
		230	/* Runtime pseudo-reloc. */
		231	{ STRING_COMMA_LEN ("_pei386_runtime_relocator") },
		232	{ STRING_COMMA_LEN ("do_pseudo_reloc") },
		233	/* Global vars that should not be exported. */
		234	{ STRING_COMMA_LEN ("impure_ptr") },
		235	{ STRING_COMMA_LEN ("_impure_ptr") },
		236	{ STRING_COMMA_LEN ("_fmode") },
		237	{ STRING_COMMA_LEN ("environ") },
6324	serge	238	{ STRING_COMMA_LEN ("__dso_handle") },
5199	serge	239	{ NULL, 0 }
		240	};
		241
		242	#define PE_ARCH_i386 1
		243	#define PE_ARCH_sh 2
		244	#define PE_ARCH_mips 3
		245	#define PE_ARCH_arm 4
		246	#define PE_ARCH_arm_epoc 5
		247	#define PE_ARCH_arm_wince 6
		248
		249	/* Don't make it constant as underscore mode gets possibly overriden
		250	by target or -(no-)leading-underscore option. */
		251	static pe_details_type pe_detail_list[] =
		252	{
		253	{
		254	#ifdef pe_use_x86_64
		255	"pei-x86-64",
		256	"pe-x86-64",
		257	3 /* R_IMAGEBASE */,
		258	#else
		259	"pei-i386",
		260	"pe-i386",
		261	7 /* R_IMAGEBASE */,
		262	#endif
		263	PE_ARCH_i386,
		264	bfd_arch_i386,
		265	#ifdef pe_use_x86_64
		266	FALSE,
		267	#else
		268	TRUE,
		269	#endif
		270	autofilter_symbollist_i386
		271	},
		272	{
		273	"pei-shl",
		274	"pe-shl",
		275	16 /* R_SH_IMAGEBASE */,
		276	PE_ARCH_sh,
		277	bfd_arch_sh,
		278	TRUE,
		279	autofilter_symbollist_generic
		280	},
		281	{
		282	"pei-mips",
		283	"pe-mips",
		284	34 /* MIPS_R_RVA */,
		285	PE_ARCH_mips,
		286	bfd_arch_mips,
		287	FALSE,
		288	autofilter_symbollist_generic
		289	},
		290	{
		291	"pei-arm-little",
		292	"pe-arm-little",
		293	11 /* ARM_RVA32 */,
		294	PE_ARCH_arm,
		295	bfd_arch_arm,
		296	TRUE,
		297	autofilter_symbollist_generic
		298	},
		299	{
		300	"epoc-pei-arm-little",
		301	"epoc-pe-arm-little",
		302	11 /* ARM_RVA32 */,
		303	PE_ARCH_arm_epoc,
		304	bfd_arch_arm,
		305	FALSE,
		306	autofilter_symbollist_generic
		307	},
		308	{
		309	"pei-arm-wince-little",
		310	"pe-arm-wince-little",
		311	2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
		312	PE_ARCH_arm_wince,
		313	bfd_arch_arm,
		314	FALSE,
		315	autofilter_symbollist_generic
		316	},
		317	{ NULL, NULL, 0, 0, 0, FALSE, NULL }
		318	};
		319
		320	static const pe_details_type *pe_details;
		321
		322	/* Do not specify library suffix explicitly, to allow for dllized versions. */
		323	static const autofilter_entry_type autofilter_liblist[] =
		324	{
		325	{ STRING_COMMA_LEN ("libcegcc") },
		326	{ STRING_COMMA_LEN ("libcygwin") },
		327	{ STRING_COMMA_LEN ("libgcc") },
		328	{ STRING_COMMA_LEN ("libgcc_s") },
		329	{ STRING_COMMA_LEN ("libstdc++") },
		330	{ STRING_COMMA_LEN ("libmingw32") },
		331	{ STRING_COMMA_LEN ("libmingwex") },
		332	{ STRING_COMMA_LEN ("libg2c") },
		333	{ STRING_COMMA_LEN ("libsupc++") },
		334	{ STRING_COMMA_LEN ("libobjc") },
		335	{ STRING_COMMA_LEN ("libgcj") },
		336	{ NULL, 0 }
		337	};
		338
		339	/* Regardless of the suffix issue mentioned above, we must ensure that
		340	we do not falsely match on a leading substring, such as when libtool
		341	builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
		342	This routine ensures that the leading part of the name matches and that
		343	it is followed by only an optional version suffix and a file extension,
		344	returning zero if so or -1 if not. */
		345	static int libnamencmp (const char libname, const autofilter_entry_type afptr)
		346	{
		347	if (filename_ncmp (libname, afptr->name, afptr->len))
		348	return -1;
		349
		350	libname += afptr->len;
		351
		352	/* Be liberal in interpreting what counts as a version suffix; we
		353	accept anything that has a dash to separate it from the name and
		354	begins with a digit. */
		355	if (libname[0] == '-')
		356	{
		357	if (!ISDIGIT (*++libname))
		358	return -1;
		359	/* Ensure the filename has an extension. */
		360	while (*++libname != '.')
		361	if (!*libname)
		362	return -1;
		363	}
		364	else if (libname[0] != '.')
		365	return -1;
		366
		367	return 0;
		368	}
		369
		370	static const autofilter_entry_type autofilter_objlist[] =
		371	{
		372	{ STRING_COMMA_LEN ("crt0.o") },
		373	{ STRING_COMMA_LEN ("crt1.o") },
		374	{ STRING_COMMA_LEN ("crt2.o") },
		375	{ STRING_COMMA_LEN ("dllcrt1.o") },
		376	{ STRING_COMMA_LEN ("dllcrt2.o") },
		377	{ STRING_COMMA_LEN ("gcrt0.o") },
		378	{ STRING_COMMA_LEN ("gcrt1.o") },
		379	{ STRING_COMMA_LEN ("gcrt2.o") },
		380	{ STRING_COMMA_LEN ("crtbegin.o") },
		381	{ STRING_COMMA_LEN ("crtend.o") },
		382	{ NULL, 0 }
		383	};
		384
		385	static const autofilter_entry_type autofilter_symbolprefixlist[] =
		386	{
		387	/* _imp_ is treated specially, as it is always underscored. */
		388	/* { STRING_COMMA_LEN ("_imp_") }, */
		389	/* Don't export some c++ symbols. */
		390	{ STRING_COMMA_LEN ("__rtti_") },
		391	{ STRING_COMMA_LEN ("__builtin_") },
		392	/* Don't re-export auto-imported symbols. */
		393	{ STRING_COMMA_LEN ("__nm_") },
		394	/* Don't export symbols specifying internal DLL layout. */
		395	{ STRING_COMMA_LEN ("_head_") },
		396	{ STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
		397	/* Don't export section labels or artificial symbols
		398	(eg ".weak.foo". */
		399	{ STRING_COMMA_LEN (".") },
		400	{ NULL, 0 }
		401	};
		402
		403	static const autofilter_entry_type autofilter_symbolsuffixlist[] =
		404	{
		405	{ STRING_COMMA_LEN ("_iname") },
		406	{ STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
		407	{ NULL, 0 }
		408	};
		409
		410	#define U(str) (pe_details->underscored ? "_" str : str)
		411
		412	void
		413	pe_dll_id_target (const char *target)
		414	{
		415	int i;
		416
		417	for (i = 0; pe_detail_list[i].target_name; i++)
		418	if (strcmp (pe_detail_list[i].target_name, target) == 0
		419	\|\| strcmp (pe_detail_list[i].object_target, target) == 0)
		420	{
		421	int u = pe_leading_underscore; /* Underscoring mode. -1 for use default. */
		422	if (u == -1)
		423	bfd_get_target_info (target, NULL, NULL, &u, NULL);
		424	if (u == -1)
		425	abort ();
		426	pe_detail_list[i].underscored = (u != 0 ? TRUE : FALSE);
		427	pe_details = pe_detail_list + i;
		428	pe_leading_underscore = (u != 0 ? 1 : 0);
		429	return;
		430	}
		431	einfo (_("%XUnsupported PEI architecture: %s\n"), target);
		432	exit (1);
		433	}
		434
		435	/* Helper functions for qsort. Relocs must be sorted so that we can write
		436	them out by pages. */
		437
		438	typedef struct
		439	{
		440	bfd_vma vma;
		441	char type;
		442	short extra;
		443	}
		444	reloc_data_type;
		445
		446	static int
		447	reloc_sort (const void va, const void vb)
		448	{
		449	bfd_vma a = ((const reloc_data_type *) va)->vma;
		450	bfd_vma b = ((const reloc_data_type *) vb)->vma;
		451
		452	return (a > b) ? 1 : ((a < b) ? -1 : 0);
		453	}
		454
		455	static int
		456	pe_export_sort (const void va, const void vb)
		457	{
		458	const def_file_export *a = va;
		459	const def_file_export *b = vb;
		460	char *an = a->name;
		461	char *bn = b->name;
		462	if (a->its_name)
		463	an = a->its_name;
		464	if (b->its_name)
		465	bn = b->its_name;
		466
		467	return strcmp (an, bn);
		468	}
		469
		470	/* Read and process the .DEF file. */
		471
		472	/* These correspond to the entries in pe_def_file->exports[]. I use
		473	exported_symbol_sections[i] to tag whether or not the symbol was
		474	defined, since we can't export symbols we don't have. */
		475
		476	static bfd_vma *exported_symbol_offsets;
		477	static struct bfd_section **exported_symbol_sections;
		478	static int export_table_size;
		479	static int count_exported;
		480	static int count_exported_byname;
		481	static int count_with_ordinals;
		482	static const char *dll_name;
		483	static int min_ordinal, max_ordinal;
		484	static int *exported_symbols;
		485
		486	typedef struct exclude_list_struct
		487	{
		488	char *string;
		489	struct exclude_list_struct *next;
		490	exclude_type type;
		491	}
		492	exclude_list_struct;
		493
		494	static struct exclude_list_struct *excludes = 0;
		495
		496	void
		497	pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
		498	{
		499	char *local_copy;
		500	char *exclude_string;
		501
		502	local_copy = xstrdup (new_excludes);
		503
		504	exclude_string = strtok (local_copy, ",:");
		505	for (; exclude_string; exclude_string = strtok (NULL, ",:"))
		506	{
		507	struct exclude_list_struct *new_exclude;
		508
		509	new_exclude = xmalloc (sizeof (struct exclude_list_struct));
		510	new_exclude->string = xmalloc (strlen (exclude_string) + 1);
		511	strcpy (new_exclude->string, exclude_string);
		512	new_exclude->type = type;
		513	new_exclude->next = excludes;
		514	excludes = new_exclude;
		515	}
		516
		517	free (local_copy);
		518	}
		519
		520	static bfd_boolean
		521	is_import (const char* n)
		522	{
		523	return (CONST_STRNEQ (n, "__imp_"));
		524	}
		525
		526	/* abfd is a bfd containing n (or NULL)
		527	It can be used for contextual checks. */
		528
		529	static int
		530	auto_export (bfd abfd, def_file d, const char *n)
		531	{
		532	def_file_export key;
		533	struct exclude_list_struct *ex;
		534	const autofilter_entry_type *afptr;
		535	const char * libname = NULL;
		536
		537	if (abfd && abfd->my_archive)
		538	libname = lbasename (abfd->my_archive->filename);
		539
		540	key.name = key.its_name = (char *) n;
		541
		542	/* Return false if n is in the d->exports table. */
		543	if (bsearch (&key, d->exports, d->num_exports,
		544	sizeof (pe_def_file->exports[0]), pe_export_sort))
		545	return 0;
		546
		547	if (pe_dll_do_default_excludes)
		548	{
		549	const char * p;
		550	int len;
		551
		552	if (pe_dll_extra_pe_debug)
		553	printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
		554	n, abfd, abfd->my_archive);
		555
		556	/* First of all, make context checks:
		557	Don't export anything from standard libs. */
		558	if (libname)
		559	{
		560	afptr = autofilter_liblist;
		561
		562	while (afptr->name)
		563	{
		564	if (libnamencmp (libname, afptr) == 0 )
		565	return 0;
		566	afptr++;
		567	}
		568	}
		569
		570	/* Next, exclude symbols from certain startup objects. */
		571
		572	if (abfd && (p = lbasename (abfd->filename)))
		573	{
		574	afptr = autofilter_objlist;
		575	while (afptr->name)
		576	{
		577	if (strcmp (p, afptr->name) == 0)
		578	return 0;
		579	afptr++;
		580	}
		581	}
		582
		583	/* Don't try to blindly exclude all symbols
		584	that begin with '__'; this was tried and
		585	it is too restrictive. Instead we have
		586	a target specific list to use: */
		587	afptr = pe_details->autofilter_symbollist;
		588
		589	while (afptr->name)
		590	{
		591	if (strcmp (n, afptr->name) == 0)
		592	return 0;
		593
		594	afptr++;
		595	}
		596
		597	/* Next, exclude symbols starting with ... */
		598	afptr = autofilter_symbolprefixlist;
		599	while (afptr->name)
		600	{
		601	if (strncmp (n, afptr->name, afptr->len) == 0)
		602	return 0;
		603
		604	afptr++;
		605	}
		606
		607	/* Finally, exclude symbols ending with ... */
		608	len = strlen (n);
		609	afptr = autofilter_symbolsuffixlist;
		610	while (afptr->name)
		611	{
		612	if ((len >= afptr->len)
		613	/* Add 1 to insure match with trailing '\0'. */
		614	&& strncmp (n + len - afptr->len, afptr->name,
		615	afptr->len + 1) == 0)
		616	return 0;
		617
		618	afptr++;
		619	}
		620	}
		621
		622	for (ex = excludes; ex; ex = ex->next)
		623	{
		624	if (ex->type == EXCLUDELIBS)
		625	{
		626	if (libname
		627	&& ((filename_cmp (libname, ex->string) == 0)
		628	\|\| (strcasecmp ("ALL", ex->string) == 0)))
		629	return 0;
		630	}
		631	else if (ex->type == EXCLUDEFORIMPLIB)
		632	{
		633	if (filename_cmp (abfd->filename, ex->string) == 0)
		634	return 0;
		635	}
		636	else if (strcmp (n, ex->string) == 0)
		637	return 0;
		638	}
		639
		640	return 1;
		641	}
		642
		643	static void
		644	process_def_file_and_drectve (bfd abfd ATTRIBUTE_UNUSED, struct bfd_link_info info)
		645	{
		646	int i, j;
		647	struct bfd_link_hash_entry *blhe;
		648	bfd *b;
		649	struct bfd_section *s;
		650	def_file_export *e = 0;
		651	bfd_boolean resort_needed;
		652
		653	if (!pe_def_file)
		654	pe_def_file = def_file_empty ();
		655
		656	/* First, run around to all the objects looking for the .drectve
		657	sections, and push those into the def file too. */
6324	serge	658	for (b = info->input_bfds; b; b = b->link.next)
5199	serge	659	{
		660	s = bfd_get_section_by_name (b, ".drectve");
		661	if (s)
		662	{
		663	long size = s->size;
		664	char *buf = xmalloc (size);
		665
		666	bfd_get_section_contents (b, s, buf, 0, size);
		667	def_file_add_directive (pe_def_file, buf, size);
		668	free (buf);
		669	}
		670	}
		671
		672	/* Process aligned common symbol information from the
		673	.drectve sections now; common symbol allocation is
		674	done before final link, so it will be too late to
		675	process them in process_embedded_commands() called
		676	from _bfd_coff_link_input_bfd(). */
		677	if (pe_def_file->aligncomms)
		678	{
		679	def_file_aligncomm *ac = pe_def_file->aligncomms;
		680	while (ac)
		681	{
		682	struct coff_link_hash_entry *sym_hash;
		683	sym_hash = coff_link_hash_lookup (coff_hash_table (info),
		684	ac->symbol_name, FALSE, FALSE, FALSE);
		685	if (sym_hash && sym_hash->root.type == bfd_link_hash_common
		686	&& sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
		687	{
		688	sym_hash->root.u.c.p->alignment_power = (unsigned) ac->alignment;
		689	}
		690	ac = ac->next;
		691	}
		692	}
		693
		694	/* If we are building an executable and there is nothing
		695	to export, we do not build an export table at all. */
6324	serge	696	if (bfd_link_executable (info) && pe_def_file->num_exports == 0
5199	serge	697	&& (!pe_dll_export_everything \|\| pe_dll_exclude_all_symbols))
		698	return;
		699
		700	/* Now, maybe export everything else the default way. */
		701	if ((pe_dll_export_everything \|\| pe_def_file->num_exports == 0)
		702	&& !pe_dll_exclude_all_symbols)
		703	{
6324	serge	704	for (b = info->input_bfds; b; b = b->link.next)
5199	serge	705	{
		706	asymbol **symbols;
		707	int nsyms;
		708
		709	if (!bfd_generic_link_read_symbols (b))
		710	{
		711	einfo (_("%B%F: could not read symbols: %E\n"), b);
		712	return;
		713	}
		714
		715	symbols = bfd_get_outsymbols (b);
		716	nsyms = bfd_get_symcount (b);
		717
		718	for (j = 0; j < nsyms; j++)
		719	{
		720	/* We should export symbols which are either global or not
		721	anything at all. (.bss data is the latter)
		722	We should not export undefined symbols. */
		723	bfd_boolean would_export
		724	= (symbols[j]->section != bfd_und_section_ptr
		725	&& ((symbols[j]->flags & BSF_GLOBAL)
		726	\|\| (symbols[j]->flags == 0)));
		727	if (link_info.version_info && would_export)
		728	would_export
		729	= !bfd_hide_sym_by_version (link_info.version_info,
		730	symbols[j]->name);
		731	if (would_export)
		732	{
		733	const char *sn = symbols[j]->name;
		734
		735	/* We should not re-export imported stuff. */
		736	{
		737	char *name;
		738	if (is_import (sn))
		739	continue;
		740
		741	name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
		742	sprintf (name, "%s%s", "__imp_", sn);
		743
		744	blhe = bfd_link_hash_lookup (info->hash, name,
		745	FALSE, FALSE, FALSE);
		746	free (name);
		747
		748	if (blhe && blhe->type == bfd_link_hash_defined)
		749	continue;
		750	}
		751
		752	if (pe_details->underscored && *sn == '_')
		753	sn++;
		754
		755	if (auto_export (b, pe_def_file, sn))
		756	{
		757	int is_dup = 0;
		758	def_file_export *p;
		759
		760	p = def_file_add_export (pe_def_file, sn, 0, -1,
		761	NULL, &is_dup);
		762	/* Fill data flag properly, from dlltool.c. */
		763	if (!is_dup)
		764	p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
		765	}
		766	}
		767	}
		768	}
		769	}
		770
		771	#undef NE
		772	#define NE pe_def_file->num_exports
		773
		774	/* Don't create an empty export table. */
		775	if (NE == 0)
		776	return;
		777
		778	resort_needed = FALSE;
		779
		780	/* Canonicalize the export list. */
		781	if (pe_dll_kill_ats)
		782	{
		783	for (i = 0; i < NE; i++)
		784	{
		785	/* Check for fastcall/stdcall-decoration, but ignore
		786	C++ mangled names. */
		787	if (pe_def_file->exports[i].name[0] != '?'
		788	&& strchr (pe_def_file->exports[i].name, '@'))
		789	{
		790	/* This will preserve internal_name, which may have been
		791	pointing to the same memory as name, or might not
		792	have. */
		793	int lead_at = (*pe_def_file->exports[i].name == '@');
		794	char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
		795	char *tmp_at = strrchr (tmp, '@');
		796
		797	if (tmp_at)
		798	*tmp_at = 0;
		799	else
		800	einfo (_("%XCannot export %s: invalid export name\n"),
		801	pe_def_file->exports[i].name);
		802	pe_def_file->exports[i].name = tmp;
		803	resort_needed = TRUE;
		804	}
		805	}
		806	}
		807
		808	/* Re-sort the exports table as we have possibly changed the order
		809	by removing leading @. */
		810	if (resort_needed)
		811	qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
		812	pe_export_sort);
		813
		814	if (pe_dll_stdcall_aliases)
		815	{
		816	for (i = 0; i < NE; i++)
		817	{
		818	if (is_import (pe_def_file->exports[i].name))
		819	continue;
		820
		821	if (strchr (pe_def_file->exports[i].name, '@'))
		822	{
		823	int is_dup = 1;
		824	int lead_at = (*pe_def_file->exports[i].name == '@');
		825	char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
		826
		827	*(strchr (tmp, '@')) = 0;
		828	if (auto_export (NULL, pe_def_file, tmp))
		829	def_file_add_export (pe_def_file, tmp,
		830	pe_def_file->exports[i].internal_name,
		831	-1, NULL, &is_dup);
		832	if (is_dup)
		833	free (tmp);
		834	}
		835	}
		836	}
		837
		838	/* Convenience, but watch out for it changing. */
		839	e = pe_def_file->exports;
		840
		841	for (i = 0, j = 0; i < NE; i++)
		842	{
		843	if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
		844	{
		845	/* This is a duplicate. */
		846	if (e[j - 1].ordinal != -1
		847	&& e[i].ordinal != -1
		848	&& e[j - 1].ordinal != e[i].ordinal)
		849	{
		850	if (pe_dll_warn_dup_exports)
		851	/* xgettext:c-format */
		852	einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
		853	e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
		854	}
		855	else
		856	{
		857	if (pe_dll_warn_dup_exports)
		858	/* xgettext:c-format */
		859	einfo (_("Warning, duplicate EXPORT: %s\n"),
		860	e[j - 1].name);
		861	}
		862
		863	if (e[i].ordinal != -1)
		864	e[j - 1].ordinal = e[i].ordinal;
		865	e[j - 1].flag_private \|= e[i].flag_private;
		866	e[j - 1].flag_constant \|= e[i].flag_constant;
		867	e[j - 1].flag_noname \|= e[i].flag_noname;
		868	e[j - 1].flag_data \|= e[i].flag_data;
		869	if (e[i].name)
		870	free (e[i].name);
		871	if (e[i].internal_name)
		872	free (e[i].internal_name);
		873	if (e[i].its_name)
		874	free (e[i].its_name);
		875	}
		876	else
		877	{
		878	if (i != j)
		879	e[j] = e[i];
		880	j++;
		881	}
		882	}
		883	pe_def_file->num_exports = j; /* == NE */
		884
		885	exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
		886	exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
		887
		888	memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
		889	max_ordinal = 0;
		890	min_ordinal = 65536;
		891	count_exported = 0;
		892	count_exported_byname = 0;
		893	count_with_ordinals = 0;
		894
		895	for (i = 0; i < NE; i++)
		896	{
		897	char *name;
		898	name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
		899	if (pe_details->underscored
		900	&& (*pe_def_file->exports[i].internal_name != '@'))
		901	{
		902	*name = '_';
		903	strcpy (name + 1, pe_def_file->exports[i].internal_name);
		904	}
		905	else
		906	strcpy (name, pe_def_file->exports[i].internal_name);
		907
		908	blhe = bfd_link_hash_lookup (info->hash,
		909	name,
		910	FALSE, FALSE, TRUE);
		911
		912	if (blhe
		913	&& (blhe->type == bfd_link_hash_defined
		914	\|\| (blhe->type == bfd_link_hash_common)))
		915	{
		916	count_exported++;
		917	if (!pe_def_file->exports[i].flag_noname)
		918	count_exported_byname++;
		919
		920	/* Only fill in the sections. The actual offsets are computed
		921	in fill_exported_offsets() after common symbols are laid
		922	out. */
		923	if (blhe->type == bfd_link_hash_defined)
		924	exported_symbol_sections[i] = blhe->u.def.section;
		925	else
		926	exported_symbol_sections[i] = blhe->u.c.p->section;
		927
		928	if (pe_def_file->exports[i].ordinal != -1)
		929	{
		930	if (max_ordinal < pe_def_file->exports[i].ordinal)
		931	max_ordinal = pe_def_file->exports[i].ordinal;
		932	if (min_ordinal > pe_def_file->exports[i].ordinal)
		933	min_ordinal = pe_def_file->exports[i].ordinal;
		934	count_with_ordinals++;
		935	}
		936	}
		937	/* Check for forward exports. These are indicated in DEF files by an
		938	export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
		939	but we must take care not to be fooled when the user wants to export
		940	a symbol that actually really has a dot in it, so we only check
		941	for them here, after real defined symbols have already been matched. */
		942	else if (strchr (pe_def_file->exports[i].internal_name, '.'))
		943	{
		944	count_exported++;
		945	if (!pe_def_file->exports[i].flag_noname)
		946	count_exported_byname++;
		947
		948	pe_def_file->exports[i].flag_forward = 1;
		949
		950	if (pe_def_file->exports[i].ordinal != -1)
		951	{
		952	if (max_ordinal < pe_def_file->exports[i].ordinal)
		953	max_ordinal = pe_def_file->exports[i].ordinal;
		954	if (min_ordinal > pe_def_file->exports[i].ordinal)
		955	min_ordinal = pe_def_file->exports[i].ordinal;
		956	count_with_ordinals++;
		957	}
		958	}
		959	else if (blhe && blhe->type == bfd_link_hash_undefined)
		960	{
		961	/* xgettext:c-format */
		962	einfo (_("%XCannot export %s: symbol not defined\n"),
		963	pe_def_file->exports[i].internal_name);
		964	}
		965	else if (blhe)
		966	{
		967	/* xgettext:c-format */
		968	einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
		969	pe_def_file->exports[i].internal_name,
		970	blhe->type, bfd_link_hash_defined);
		971	}
		972	else
		973	{
		974	/* xgettext:c-format */
		975	einfo (_("%XCannot export %s: symbol not found\n"),
		976	pe_def_file->exports[i].internal_name);
		977	}
		978	free (name);
		979	}
		980	}
		981
		982	/* Build the bfd that will contain .edata and .reloc sections. */
		983
		984	static void
		985	build_filler_bfd (int include_edata)
		986	{
		987	lang_input_statement_type *filler_file;
		988	filler_file = lang_add_input_file ("dll stuff",
		989	lang_input_file_is_fake_enum,
		990	NULL);
		991	filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff",
		992	link_info.output_bfd);
		993	if (filler_bfd == NULL
		994	\|\| !bfd_set_arch_mach (filler_bfd,
		995	bfd_get_arch (link_info.output_bfd),
		996	bfd_get_mach (link_info.output_bfd)))
		997	{
		998	einfo ("%X%P: can not create BFD: %E\n");
		999	return;
		1000	}
		1001
		1002	if (include_edata)
		1003	{
		1004	edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
		1005	if (edata_s == NULL
		1006	\|\| !bfd_set_section_flags (filler_bfd, edata_s,
		1007	(SEC_HAS_CONTENTS
		1008	\| SEC_ALLOC
		1009	\| SEC_LOAD
		1010	\| SEC_KEEP
		1011	\| SEC_IN_MEMORY)))
		1012	{
		1013	einfo ("%X%P: can not create .edata section: %E\n");
		1014	return;
		1015	}
		1016	bfd_set_section_size (filler_bfd, edata_s, edata_sz);
		1017	}
		1018
		1019	reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
		1020	if (reloc_s == NULL
		1021	\|\| !bfd_set_section_flags (filler_bfd, reloc_s,
		1022	(SEC_HAS_CONTENTS
		1023	\| SEC_ALLOC
		1024	\| SEC_LOAD
		1025	\| SEC_KEEP
		1026	\| SEC_IN_MEMORY)))
		1027	{
		1028	einfo ("%X%P: can not create .reloc section: %E\n");
		1029	return;
		1030	}
		1031
		1032	bfd_set_section_size (filler_bfd, reloc_s, 0);
		1033
		1034	ldlang_add_file (filler_file);
		1035	}
		1036
		1037	/* Gather all the exported symbols and build the .edata section. */
		1038
		1039	static void
		1040	generate_edata (bfd abfd, struct bfd_link_info info ATTRIBUTE_UNUSED)
		1041	{
		1042	int i, next_ordinal;
		1043	int name_table_size = 0;
		1044	const char *dlnp;
		1045
		1046	/* First, we need to know how many exported symbols there are,
		1047	and what the range of ordinals is. */
		1048	if (pe_def_file->name)
		1049	dll_name = pe_def_file->name;
		1050	else
		1051	{
		1052	dll_name = abfd->filename;
		1053
		1054	for (dlnp = dll_name; *dlnp; dlnp++)
		1055	if (dlnp == '\\' \|\| dlnp == '/' \|\| *dlnp == ':')
		1056	dll_name = dlnp + 1;
		1057	}
		1058
		1059	if (count_with_ordinals && max_ordinal > count_exported)
		1060	{
		1061	if (min_ordinal > max_ordinal - count_exported + 1)
		1062	min_ordinal = max_ordinal - count_exported + 1;
		1063	}
		1064	else
		1065	{
		1066	min_ordinal = 1;
		1067	max_ordinal = count_exported;
		1068	}
		1069
		1070	export_table_size = max_ordinal - min_ordinal + 1;
		1071	exported_symbols = xmalloc (export_table_size * sizeof (int));
		1072	for (i = 0; i < export_table_size; i++)
		1073	exported_symbols[i] = -1;
		1074
		1075	/* Now we need to assign ordinals to those that don't have them. */
		1076	for (i = 0; i < NE; i++)
		1077	{
		1078	if (exported_symbol_sections[i] \|\|
		1079	pe_def_file->exports[i].flag_forward)
		1080	{
		1081	if (pe_def_file->exports[i].ordinal != -1)
		1082	{
		1083	int ei = pe_def_file->exports[i].ordinal - min_ordinal;
		1084	int pi = exported_symbols[ei];
		1085
		1086	if (pi != -1)
		1087	{
		1088	/* xgettext:c-format */
		1089	einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
		1090	pe_def_file->exports[i].ordinal,
		1091	pe_def_file->exports[i].name,
		1092	pe_def_file->exports[pi].name);
		1093	}
		1094	exported_symbols[ei] = i;
		1095	}
		1096	if (pe_def_file->exports[i].its_name)
		1097	name_table_size += strlen (pe_def_file->exports[i].its_name) + 1;
		1098	else
		1099	name_table_size += strlen (pe_def_file->exports[i].name) + 1;
		1100	}
		1101
		1102	/* Reserve space for the forward name. */
		1103	if (pe_def_file->exports[i].flag_forward)
		1104	{
		1105	name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
		1106	}
		1107	}
		1108
		1109	next_ordinal = min_ordinal;
		1110	for (i = 0; i < NE; i++)
		1111	if ((exported_symbol_sections[i] \|\|
		1112	pe_def_file->exports[i].flag_forward) &&
		1113	pe_def_file->exports[i].ordinal == -1)
		1114	{
		1115	while (exported_symbols[next_ordinal - min_ordinal] != -1)
		1116	next_ordinal++;
		1117
		1118	exported_symbols[next_ordinal - min_ordinal] = i;
		1119	pe_def_file->exports[i].ordinal = next_ordinal;
		1120	}
		1121
		1122	/* OK, now we can allocate some memory. */
		1123	edata_sz = (40 /* directory */
		1124	+ 4 * export_table_size /* addresses */
		1125	+ 4 * count_exported_byname /* name ptrs */
		1126	+ 2 * count_exported_byname /* ordinals */
		1127	+ name_table_size + strlen (dll_name) + 1);
		1128	}
		1129
		1130	/* Fill the exported symbol offsets. The preliminary work has already
		1131	been done in process_def_file_and_drectve(). */
		1132
		1133	static void
		1134	fill_exported_offsets (bfd abfd ATTRIBUTE_UNUSED, struct bfd_link_info info)
		1135	{
		1136	int i;
		1137	struct bfd_link_hash_entry *blhe;
		1138
		1139	for (i = 0; i < pe_def_file->num_exports; i++)
		1140	{
		1141	char *name;
		1142
		1143	name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
		1144	if (pe_details->underscored
		1145	&& *pe_def_file->exports[i].internal_name != '@')
		1146	{
		1147	*name = '_';
		1148	strcpy (name + 1, pe_def_file->exports[i].internal_name);
		1149	}
		1150	else
		1151	strcpy (name, pe_def_file->exports[i].internal_name);
		1152
		1153	blhe = bfd_link_hash_lookup (info->hash,
		1154	name,
		1155	FALSE, FALSE, TRUE);
		1156
		1157	if (blhe && blhe->type == bfd_link_hash_defined)
		1158	exported_symbol_offsets[i] = blhe->u.def.value;
		1159
		1160	free (name);
		1161	}
		1162	}
		1163
		1164	static void
		1165	fill_edata (bfd abfd, struct bfd_link_info info ATTRIBUTE_UNUSED)
		1166	{
		1167	int s, hint;
		1168	unsigned char *edirectory;
		1169	unsigned char *eaddresses;
		1170	unsigned char *enameptrs;
		1171	unsigned char *eordinals;
		1172	char *enamestr;
		1173
		1174	edata_d = xmalloc (edata_sz);
		1175
		1176	/* Note use of array pointer math here. */
		1177	edirectory = edata_d;
		1178	eaddresses = edirectory + 40;
		1179	enameptrs = eaddresses + 4 * export_table_size;
		1180	eordinals = enameptrs + 4 * count_exported_byname;
		1181	enamestr = (char ) eordinals + 2 count_exported_byname;
		1182
		1183	#define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
		1184	+ edata_s->output_section->vma - image_base)
		1185
		1186	memset (edata_d, 0, edata_sz);
		1187
		1188	if (pe_data (abfd)->insert_timestamp)
		1189	H_PUT_32 (abfd, time (0), edata_d + 4);
		1190
		1191	if (pe_def_file->version_major != -1)
		1192	{
		1193	bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
		1194	bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
		1195	}
		1196
		1197	bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
		1198	strcpy (enamestr, dll_name);
		1199	enamestr += strlen (enamestr) + 1;
		1200	bfd_put_32 (abfd, min_ordinal, edata_d + 16);
		1201	bfd_put_32 (abfd, export_table_size, edata_d + 20);
		1202	bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
		1203	bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
		1204	bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
		1205	bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
		1206
		1207	fill_exported_offsets (abfd, info);
		1208
		1209	/* Ok, now for the filling in part.
		1210	Scan alphabetically - ie the ordering in the exports[] table,
		1211	rather than by ordinal - the ordering in the exported_symbol[]
		1212	table. See dlltool.c and:
		1213	http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
		1214	for more information. */
		1215	hint = 0;
		1216	for (s = 0; s < NE; s++)
		1217	{
		1218	struct bfd_section *ssec = exported_symbol_sections[s];
		1219	if (pe_def_file->exports[s].ordinal != -1 &&
		1220	(pe_def_file->exports[s].flag_forward \|\| ssec != NULL))
		1221	{
		1222	int ord = pe_def_file->exports[s].ordinal;
		1223
		1224	if (pe_def_file->exports[s].flag_forward)
		1225	{
		1226	bfd_put_32 (abfd, ERVA (enamestr),
		1227	eaddresses + 4 * (ord - min_ordinal));
		1228
		1229	strcpy (enamestr, pe_def_file->exports[s].internal_name);
		1230	enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
		1231	}
		1232	else
		1233	{
		1234	bfd_vma srva = (exported_symbol_offsets[s]
		1235	+ ssec->output_section->vma
		1236	+ ssec->output_offset);
		1237
		1238	bfd_put_32 (abfd, srva - image_base,
		1239	eaddresses + 4 * (ord - min_ordinal));
		1240	}
		1241
		1242	if (!pe_def_file->exports[s].flag_noname)
		1243	{
		1244	char *ename = pe_def_file->exports[s].name;
		1245	if (pe_def_file->exports[s].its_name)
		1246	ename = pe_def_file->exports[s].its_name;
		1247
		1248	bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
		1249	enameptrs += 4;
		1250	strcpy (enamestr, ename);
		1251	enamestr += strlen (enamestr) + 1;
		1252	bfd_put_16 (abfd, ord - min_ordinal, eordinals);
		1253	eordinals += 2;
		1254	pe_def_file->exports[s].hint = hint++;
		1255	}
		1256	}
		1257	}
		1258	}
		1259
		1260
		1261	static struct bfd_section *current_sec;
		1262
		1263	void
		1264	pe_walk_relocs_of_symbol (struct bfd_link_info *info,
		1265	const char *name,
		1266	int (cb) (arelent , asection *))
		1267	{
		1268	bfd *b;
		1269	asection *s;
		1270
6324	serge	1271	for (b = info->input_bfds; b; b = b->link.next)
5199	serge	1272	{
		1273	asymbol **symbols;
		1274
		1275	if (!bfd_generic_link_read_symbols (b))
		1276	{
		1277	einfo (_("%B%F: could not read symbols: %E\n"), b);
		1278	return;
		1279	}
		1280
		1281	symbols = bfd_get_outsymbols (b);
		1282
		1283	for (s = b->sections; s; s = s->next)
		1284	{
		1285	arelent **relocs;
		1286	int relsize, nrelocs, i;
		1287	int flags = bfd_get_section_flags (b, s);
		1288
		1289	/* Skip discarded linkonce sections. */
		1290	if (flags & SEC_LINK_ONCE
		1291	&& s->output_section == bfd_abs_section_ptr)
		1292	continue;
		1293
		1294	current_sec = s;
		1295
		1296	relsize = bfd_get_reloc_upper_bound (b, s);
		1297	relocs = xmalloc (relsize);
		1298	nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
		1299
		1300	for (i = 0; i < nrelocs; i++)
		1301	{
		1302	struct bfd_symbol sym = relocs[i]->sym_ptr_ptr;
		1303
		1304	if (!strcmp (name, sym->name))
		1305	cb (relocs[i], s);
		1306	}
		1307
		1308	free (relocs);
		1309
		1310	/* Warning: the allocated symbols are remembered in BFD and reused
		1311	later, so don't free them! */
		1312	/* free (symbols); */
		1313	}
		1314	}
		1315	}
		1316
		1317	/* Gather all the relocations and build the .reloc section. */
		1318
		1319	static void
		1320	generate_reloc (bfd abfd, struct bfd_link_info info)
		1321	{
		1322
		1323	/* For .reloc stuff. */
		1324	reloc_data_type *reloc_data;
		1325	int total_relocs = 0;
		1326	int i;
		1327	bfd_vma sec_page = (bfd_vma) -1;
		1328	bfd_vma page_ptr, page_count;
		1329	int bi;
		1330	bfd *b;
		1331	struct bfd_section *s;
		1332
		1333	total_relocs = 0;
6324	serge	1334	for (b = info->input_bfds; b; b = b->link.next)
5199	serge	1335	for (s = b->sections; s; s = s->next)
		1336	total_relocs += s->reloc_count;
		1337
		1338	reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
		1339
		1340	total_relocs = 0;
		1341	bi = 0;
6324	serge	1342	for (bi = 0, b = info->input_bfds; b; bi++, b = b->link.next)
5199	serge	1343	{
		1344	arelent **relocs;
		1345	int relsize, nrelocs;
		1346
		1347	for (s = b->sections; s; s = s->next)
		1348	{
		1349	bfd_vma sec_vma = s->output_section->vma + s->output_offset;
		1350	asymbol **symbols;
		1351
		1352	/* If it's not loaded, we don't need to relocate it this way. */
		1353	if (!(s->output_section->flags & SEC_LOAD))
		1354	continue;
		1355
		1356	/* I don't know why there would be a reloc for these, but I've
		1357	seen it happen - DJ */
		1358	if (s->output_section == bfd_abs_section_ptr)
		1359	continue;
		1360
		1361	if (s->output_section->vma == 0)
		1362	{
		1363	/* Huh? Shouldn't happen, but punt if it does. */
		1364	einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
		1365	s->output_section->name, s->output_section->index,
		1366	s->output_section->flags);
		1367	continue;
		1368	}
		1369
		1370	if (!bfd_generic_link_read_symbols (b))
		1371	{
		1372	einfo (_("%B%F: could not read symbols: %E\n"), b);
		1373	return;
		1374	}
		1375
		1376	symbols = bfd_get_outsymbols (b);
		1377	relsize = bfd_get_reloc_upper_bound (b, s);
		1378	relocs = xmalloc (relsize);
		1379	nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
		1380
		1381	for (i = 0; i < nrelocs; i++)
		1382	{
		1383	if (pe_dll_extra_pe_debug)
		1384	{
		1385	struct bfd_symbol sym = relocs[i]->sym_ptr_ptr;
		1386	printf ("rel: %s\n", sym->name);
		1387	}
		1388	if (!relocs[i]->howto->pc_relative
		1389	&& relocs[i]->howto->type != pe_details->imagebase_reloc)
		1390	{
		1391	struct bfd_symbol sym = relocs[i]->sym_ptr_ptr;
		1392
		1393	/* Don't create relocs for undefined weak symbols. */
		1394	if (sym->flags == BSF_WEAK)
		1395	{
		1396	struct bfd_link_hash_entry *blhe
		1397	= bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
		1398	FALSE, FALSE, FALSE);
		1399	if (blhe && blhe->type == bfd_link_hash_undefweak)
		1400	{
		1401	/* Check aux sym and see if it is defined or not. */
		1402	struct coff_link_hash_entry h, h2;
		1403	h = (struct coff_link_hash_entry *)blhe;
		1404	if (h->symbol_class != C_NT_WEAK \|\| h->numaux != 1)
		1405	continue;
		1406	h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
		1407	[h->aux->x_sym.x_tagndx.l];
		1408	/* We don't want a base reloc if the aux sym is not
		1409	found, undefined, or if it is the constant ABS
		1410	zero default value. (We broaden that slightly by
		1411	not testing the value, just the section; there's
		1412	no reason we'd want a reference to any absolute
		1413	address to get relocated during rebasing). */
		1414	if (!h2 \|\| h2->root.type == bfd_link_hash_undefined
		1415	\|\| h2->root.u.def.section == bfd_abs_section_ptr)
		1416	continue;
		1417	}
		1418	else if (!blhe \|\| blhe->type != bfd_link_hash_defined)
		1419	continue;
		1420	}
		1421	/* Nor for Dwarf FDE references to discarded sections. */
		1422	else if (bfd_is_abs_section (sym->section->output_section))
		1423	{
		1424	/* We only ignore relocs from .eh_frame sections, as
		1425	they are discarded by the final link rather than
		1426	resolved against the kept section. */
		1427	if (!strcmp (s->name, ".eh_frame"))
		1428	continue;
		1429	}
		1430
		1431	reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
		1432
		1433	#define BITS_AND_SHIFT(bits, shift) (bits * 1000 \| shift)
		1434
		1435	switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
		1436	relocs[i]->howto->rightshift)
		1437	{
		1438	#ifdef pe_use_x86_64
		1439	case BITS_AND_SHIFT (64, 0):
		1440	reloc_data[total_relocs].type = 10;
		1441	total_relocs++;
		1442	break;
		1443	#endif
		1444	case BITS_AND_SHIFT (32, 0):
		1445	reloc_data[total_relocs].type = 3;
		1446	total_relocs++;
		1447	break;
		1448	case BITS_AND_SHIFT (16, 0):
		1449	reloc_data[total_relocs].type = 2;
		1450	total_relocs++;
		1451	break;
		1452	case BITS_AND_SHIFT (16, 16):
		1453	reloc_data[total_relocs].type = 4;
		1454	/* FIXME: we can't know the symbol's right value
		1455	yet, but we probably can safely assume that
		1456	CE will relocate us in 64k blocks, so leaving
		1457	it zero is safe. */
		1458	reloc_data[total_relocs].extra = 0;
		1459	total_relocs++;
		1460	break;
		1461	case BITS_AND_SHIFT (26, 2):
		1462	reloc_data[total_relocs].type = 5;
		1463	total_relocs++;
		1464	break;
		1465	case BITS_AND_SHIFT (24, 2):
		1466	/* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
		1467	Those ARM_xxx definitions should go in proper
		1468	header someday. */
		1469	if (relocs[i]->howto->type == 0
		1470	/* Older GNU linkers used 5 instead of 0 for this reloc. */
		1471	\|\| relocs[i]->howto->type == 5)
		1472	/* This is an ARM_26D reloc, which is an ARM_26 reloc
		1473	that has already been fully processed during a
		1474	previous link stage, so ignore it here. */
		1475	break;
		1476	/* Fall through. */
		1477	default:
		1478	/* xgettext:c-format */
		1479	einfo (_("%XError: %d-bit reloc in dll\n"),
		1480	relocs[i]->howto->bitsize);
		1481	break;
		1482	}
		1483	}
		1484	}
		1485	free (relocs);
		1486	/* Warning: the allocated symbols are remembered in BFD and
		1487	reused later, so don't free them! */
		1488	}
		1489	}
		1490
		1491	/* At this point, we have total_relocs relocation addresses in
		1492	reloc_addresses, which are all suitable for the .reloc section.
		1493	We must now create the new sections. */
		1494	qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
		1495
		1496	for (i = 0; i < total_relocs; i++)
		1497	{
		1498	bfd_vma this_page = (reloc_data[i].vma >> 12);
		1499
		1500	if (this_page != sec_page)
		1501	{
		1502	reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
		1503	reloc_sz += 8;
		1504	sec_page = this_page;
		1505	}
		1506
		1507	reloc_sz += 2;
		1508
		1509	if (reloc_data[i].type == 4)
		1510	reloc_sz += 2;
		1511	}
		1512
		1513	reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
		1514	reloc_d = xmalloc (reloc_sz);
		1515	sec_page = (bfd_vma) -1;
		1516	reloc_sz = 0;
		1517	page_ptr = (bfd_vma) -1;
		1518	page_count = 0;
		1519
		1520	for (i = 0; i < total_relocs; i++)
		1521	{
		1522	bfd_vma rva = reloc_data[i].vma - image_base;
		1523	bfd_vma this_page = (rva & ~0xfff);
		1524
		1525	if (this_page != sec_page)
		1526	{
		1527	while (reloc_sz & 3)
		1528	reloc_d[reloc_sz++] = 0;
		1529
		1530	if (page_ptr != (bfd_vma) -1)
		1531	bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
		1532
		1533	bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
		1534	page_ptr = reloc_sz;
		1535	reloc_sz += 8;
		1536	sec_page = this_page;
		1537	page_count = 0;
		1538	}
		1539
		1540	bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
		1541	reloc_d + reloc_sz);
		1542	reloc_sz += 2;
		1543
		1544	if (reloc_data[i].type == 4)
		1545	{
		1546	bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
		1547	reloc_sz += 2;
		1548	}
		1549
		1550	page_count++;
		1551	}
		1552
		1553	while (reloc_sz & 3)
		1554	reloc_d[reloc_sz++] = 0;
		1555
		1556	if (page_ptr != (bfd_vma) -1)
		1557	bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
		1558
		1559	while (reloc_sz < reloc_s->size)
		1560	reloc_d[reloc_sz++] = 0;
		1561	}
		1562
		1563	/* Given the exiting def_file structure, print out a .DEF file that
		1564	corresponds to it. */
		1565
		1566	static void
		1567	quoteput (char s, FILE f, int needs_quotes)
		1568	{
		1569	char *cp;
		1570
		1571	for (cp = s; *cp; cp++)
		1572	if (*cp == '\''
		1573	\|\| *cp == '"'
		1574	\|\| *cp == '\\'
		1575	\|\| ISSPACE (*cp)
		1576	\|\| *cp == ','
		1577	\|\| *cp == ';')
		1578	needs_quotes = 1;
		1579
		1580	if (needs_quotes)
		1581	{
		1582	putc ('"', f);
		1583
		1584	while (*s)
		1585	{
		1586	if (s == '"' \|\| s == '\\')
		1587	putc ('\\', f);
		1588
		1589	putc (*s, f);
		1590	s++;
		1591	}
		1592
		1593	putc ('"', f);
		1594	}
		1595	else
		1596	fputs (s, f);
		1597	}
		1598
		1599	void
		1600	pe_dll_generate_def_file (const char *pe_out_def_filename)
		1601	{
		1602	int i;
		1603	FILE *out = fopen (pe_out_def_filename, "w");
		1604
		1605	if (out == NULL)
		1606	/* xgettext:c-format */
		1607	einfo (_("%s: Can't open output def file %s\n"),
		1608	program_name, pe_out_def_filename);
		1609
		1610	if (pe_def_file)
		1611	{
		1612	if (pe_def_file->name)
		1613	{
		1614	if (pe_def_file->is_dll)
		1615	fprintf (out, "LIBRARY ");
		1616	else
		1617	fprintf (out, "NAME ");
		1618
		1619	quoteput (pe_def_file->name, out, 1);
		1620
		1621	if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
		1622	{
		1623	fprintf (out, " BASE=0x");
		1624	fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
		1625	}
		1626	fprintf (out, "\n");
		1627	}
		1628
		1629	if (pe_def_file->description)
		1630	{
		1631	fprintf (out, "DESCRIPTION ");
		1632	quoteput (pe_def_file->description, out, 1);
		1633	fprintf (out, "\n");
		1634	}
		1635
		1636	if (pe_def_file->version_minor != -1)
		1637	fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
		1638	pe_def_file->version_minor);
		1639	else if (pe_def_file->version_major != -1)
		1640	fprintf (out, "VERSION %d\n", pe_def_file->version_major);
		1641
		1642	if (pe_def_file->stack_reserve != -1 \|\| pe_def_file->heap_reserve != -1)
		1643	fprintf (out, "\n");
		1644
		1645	if (pe_def_file->stack_commit != -1)
		1646	fprintf (out, "STACKSIZE 0x%x,0x%x\n",
		1647	pe_def_file->stack_reserve, pe_def_file->stack_commit);
		1648	else if (pe_def_file->stack_reserve != -1)
		1649	fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
		1650
		1651	if (pe_def_file->heap_commit != -1)
		1652	fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
		1653	pe_def_file->heap_reserve, pe_def_file->heap_commit);
		1654	else if (pe_def_file->heap_reserve != -1)
		1655	fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
		1656
		1657	if (pe_def_file->num_section_defs > 0)
		1658	{
		1659	fprintf (out, "\nSECTIONS\n\n");
		1660
		1661	for (i = 0; i < pe_def_file->num_section_defs; i++)
		1662	{
		1663	fprintf (out, " ");
		1664	quoteput (pe_def_file->section_defs[i].name, out, 0);
		1665
		1666	if (pe_def_file->section_defs[i].class)
		1667	{
		1668	fprintf (out, " CLASS ");
		1669	quoteput (pe_def_file->section_defs[i].class, out, 0);
		1670	}
		1671
		1672	if (pe_def_file->section_defs[i].flag_read)
		1673	fprintf (out, " READ");
		1674
		1675	if (pe_def_file->section_defs[i].flag_write)
		1676	fprintf (out, " WRITE");
		1677
		1678	if (pe_def_file->section_defs[i].flag_execute)
		1679	fprintf (out, " EXECUTE");
		1680
		1681	if (pe_def_file->section_defs[i].flag_shared)
		1682	fprintf (out, " SHARED");
		1683
		1684	fprintf (out, "\n");
		1685	}
		1686	}
		1687
		1688	if (pe_def_file->num_exports > 0)
		1689	{
		1690	fprintf (out, "EXPORTS\n");
		1691
		1692	for (i = 0; i < pe_def_file->num_exports; i++)
		1693	{
		1694	def_file_export *e = pe_def_file->exports + i;
		1695	fprintf (out, " ");
		1696	quoteput (e->name, out, 0);
		1697
		1698	if (e->internal_name && strcmp (e->internal_name, e->name))
		1699	{
		1700	fprintf (out, " = ");
		1701	quoteput (e->internal_name, out, 0);
		1702	}
		1703
		1704	if (e->ordinal != -1)
		1705	fprintf (out, " @%d", e->ordinal);
		1706
		1707	if (e->flag_private)
		1708	fprintf (out, " PRIVATE");
		1709
		1710	if (e->flag_constant)
		1711	fprintf (out, " CONSTANT");
		1712
		1713	if (e->flag_noname)
		1714	fprintf (out, " NONAME");
		1715
		1716	if (e->flag_data)
		1717	fprintf (out, " DATA");
		1718
		1719	fprintf (out, "\n");
		1720	}
		1721	}
		1722
		1723	if (pe_def_file->num_imports > 0)
		1724	{
		1725	fprintf (out, "\nIMPORTS\n\n");
		1726
		1727	for (i = 0; i < pe_def_file->num_imports; i++)
		1728	{
		1729	def_file_import *im = pe_def_file->imports + i;
		1730	fprintf (out, " ");
		1731
		1732	if (im->internal_name
		1733	&& (!im->name \|\| strcmp (im->internal_name, im->name)))
		1734	{
		1735	quoteput (im->internal_name, out, 0);
		1736	fprintf (out, " = ");
		1737	}
		1738
		1739	quoteput (im->module->name, out, 0);
		1740	fprintf (out, ".");
		1741
		1742	if (im->name)
		1743	quoteput (im->name, out, 0);
		1744	else
		1745	fprintf (out, "%d", im->ordinal);
		1746
		1747	if (im->its_name)
		1748	{
		1749	fprintf (out, " == ");
		1750	quoteput (im->its_name, out, 0);
		1751	}
		1752
		1753	fprintf (out, "\n");
		1754	}
		1755	}
		1756	}
		1757	else
		1758	fprintf (out, _("; no contents available\n"));
		1759
		1760	if (fclose (out) == EOF)
		1761	/* xgettext:c-format */
		1762	einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
		1763	}
		1764
		1765	/* Generate the import library. */
		1766
		1767	static asymbol **symtab;
		1768	static int symptr;
		1769	static int tmp_seq;
		1770	static int tmp_seq2;
		1771	static const char *dll_filename;
		1772	static char *dll_symname;
		1773
		1774	#define UNDSEC bfd_und_section_ptr
		1775
		1776	static asection *
		1777	quick_section (bfd abfd, const char name, int flags, int align)
		1778	{
		1779	asection *sec;
		1780	asymbol *sym;
		1781
		1782	sec = bfd_make_section_old_way (abfd, name);
		1783	bfd_set_section_flags (abfd, sec, flags \| SEC_ALLOC \| SEC_LOAD \| SEC_KEEP);
		1784	bfd_set_section_alignment (abfd, sec, align);
		1785	/* Remember to undo this before trying to link internally! */
		1786	sec->output_section = sec;
		1787
		1788	sym = bfd_make_empty_symbol (abfd);
		1789	symtab[symptr++] = sym;
		1790	sym->name = sec->name;
		1791	sym->section = sec;
		1792	sym->flags = BSF_LOCAL;
		1793	sym->value = 0;
		1794
		1795	return sec;
		1796	}
		1797
		1798	static void
		1799	quick_symbol (bfd *abfd,
		1800	const char *n1,
		1801	const char *n2,
		1802	const char *n3,
		1803	asection *sec,
		1804	int flags,
		1805	int addr)
		1806	{
		1807	asymbol *sym;
		1808	char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
		1809
		1810	strcpy (name, n1);
		1811	strcat (name, n2);
		1812	strcat (name, n3);
		1813	sym = bfd_make_empty_symbol (abfd);
		1814	sym->name = name;
		1815	sym->section = sec;
		1816	sym->flags = flags;
		1817	sym->value = addr;
		1818	symtab[symptr++] = sym;
		1819	}
		1820
		1821	static arelent *reltab = 0;
		1822	static int relcount = 0, relsize = 0;
		1823
		1824	static void
		1825	quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
		1826	{
		1827	if (relcount >= relsize - 1)
		1828	{
		1829	relsize += 10;
		1830	if (reltab)
		1831	reltab = xrealloc (reltab, relsize * sizeof (arelent));
		1832	else
		1833	reltab = xmalloc (relsize * sizeof (arelent));
		1834	}
		1835	reltab[relcount].address = address;
		1836	reltab[relcount].addend = 0;
		1837	reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
		1838	reltab[relcount].sym_ptr_ptr = symtab + symidx;
		1839	relcount++;
		1840	}
		1841
		1842	static void
		1843	save_relocs (asection *sec)
		1844	{
		1845	int i;
		1846
		1847	sec->relocation = reltab;
		1848	sec->reloc_count = relcount;
		1849	sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
		1850	for (i = 0; i < relcount; i++)
		1851	sec->orelocation[i] = sec->relocation + i;
		1852	sec->orelocation[relcount] = 0;
		1853	sec->flags \|= SEC_RELOC;
		1854	reltab = 0;
		1855	relcount = relsize = 0;
		1856	}
		1857
		1858	/* .section .idata$2
		1859	.global __head_my_dll
		1860	__head_my_dll:
		1861	.rva hname
		1862	.long 0
		1863	.long 0
		1864	.rva __my_dll_iname
		1865	.rva fthunk
		1866
		1867	.section .idata$5
		1868	.long 0
		1869	fthunk:
		1870
		1871	.section .idata$4
		1872	.long 0
		1873	hname: */
		1874
		1875	static bfd *
		1876	make_head (bfd *parent)
		1877	{
		1878	asection id2, id5, *id4;
		1879	unsigned char d2, d5, *d4;
		1880	char *oname;
		1881	bfd *abfd;
		1882
		1883	oname = xmalloc (20);
		1884	sprintf (oname, "d%06d.o", tmp_seq);
		1885	tmp_seq++;
		1886
		1887	abfd = bfd_create (oname, parent);
		1888	bfd_find_target (pe_details->object_target, abfd);
		1889	bfd_make_writable (abfd);
		1890
		1891	bfd_set_format (abfd, bfd_object);
		1892	bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
		1893
		1894	symptr = 0;
		1895	symtab = xmalloc (6 * sizeof (asymbol *));
		1896	id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
		1897	id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
		1898	id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
		1899	quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
		1900	quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
		1901
		1902	/* OK, pay attention here. I got confused myself looking back at
		1903	it. We create a four-byte section to mark the beginning of the
		1904	list, and we include an offset of 4 in the section, so that the
		1905	pointer to the list points to the end of this section, which is
		1906	the start of the list of sections from other objects. */
		1907
		1908	bfd_set_section_size (abfd, id2, 20);
		1909	d2 = xmalloc (20);
		1910	id2->contents = d2;
		1911	memset (d2, 0, 20);
		1912	if (pe_use_nul_prefixed_import_tables)
		1913	d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
		1914	quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
		1915	quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
		1916	quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
		1917	save_relocs (id2);
		1918
		1919	if (pe_use_nul_prefixed_import_tables)
		1920	bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
		1921	else
		1922	bfd_set_section_size (abfd, id5, 0);
		1923	d5 = xmalloc (PE_IDATA5_SIZE);
		1924	id5->contents = d5;
		1925	memset (d5, 0, PE_IDATA5_SIZE);
		1926	if (pe_use_nul_prefixed_import_tables)
		1927	bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
		1928	else
		1929	bfd_set_section_size (abfd, id4, 0);
		1930	d4 = xmalloc (PE_IDATA4_SIZE);
		1931	id4->contents = d4;
		1932	memset (d4, 0, PE_IDATA4_SIZE);
		1933
		1934	bfd_set_symtab (abfd, symtab, symptr);
		1935
		1936	bfd_set_section_contents (abfd, id2, d2, 0, 20);
		1937	if (pe_use_nul_prefixed_import_tables)
		1938	{
		1939	bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
		1940	bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
		1941	}
		1942	else
		1943	{
		1944	bfd_set_section_contents (abfd, id5, d5, 0, 0);
		1945	bfd_set_section_contents (abfd, id4, d4, 0, 0);
		1946	}
		1947
		1948	bfd_make_readable (abfd);
		1949	return abfd;
		1950	}
		1951
		1952	/* .section .idata$4
		1953	.long 0
		1954	[.long 0] for PE+
		1955	.section .idata$5
		1956	.long 0
		1957	[.long 0] for PE+
		1958	.section idata$7
		1959	.global __my_dll_iname
		1960	__my_dll_iname:
		1961	.asciz "my.dll" */
		1962
		1963	static bfd *
		1964	make_tail (bfd *parent)
		1965	{
		1966	asection id4, id5, *id7;
		1967	unsigned char d4, d5, *d7;
		1968	int len;
		1969	char *oname;
		1970	bfd *abfd;
		1971
		1972	oname = xmalloc (20);
		1973	sprintf (oname, "d%06d.o", tmp_seq);
		1974	tmp_seq++;
		1975
		1976	abfd = bfd_create (oname, parent);
		1977	bfd_find_target (pe_details->object_target, abfd);
		1978	bfd_make_writable (abfd);
		1979
		1980	bfd_set_format (abfd, bfd_object);
		1981	bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
		1982
		1983	symptr = 0;
		1984	symtab = xmalloc (5 * sizeof (asymbol *));
		1985	id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
		1986	id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
		1987	id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
		1988	quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
		1989
		1990	bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
		1991	d4 = xmalloc (PE_IDATA4_SIZE);
		1992	id4->contents = d4;
		1993	memset (d4, 0, PE_IDATA4_SIZE);
		1994
		1995	bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
		1996	d5 = xmalloc (PE_IDATA5_SIZE);
		1997	id5->contents = d5;
		1998	memset (d5, 0, PE_IDATA5_SIZE);
		1999
		2000	len = strlen (dll_filename) + 1;
		2001	if (len & 1)
		2002	len++;
		2003	bfd_set_section_size (abfd, id7, len);
		2004	d7 = xmalloc (len);
		2005	id7->contents = d7;
		2006	strcpy ((char *) d7, dll_filename);
		2007	/* If len was odd, the above
		2008	strcpy leaves behind an undefined byte. That is harmless,
		2009	but we set it to 0 just so the binary dumps are pretty. */
		2010	d7[len - 1] = 0;
		2011
		2012	bfd_set_symtab (abfd, symtab, symptr);
		2013
		2014	bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
		2015	bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
		2016	bfd_set_section_contents (abfd, id7, d7, 0, len);
		2017
		2018	bfd_make_readable (abfd);
		2019	return abfd;
		2020	}
		2021
		2022	/* .text
		2023	.global _function
		2024	.global ___imp_function
		2025	.global __imp__function
		2026	_function:
		2027	jmp *__imp__function:
		2028
		2029	.section idata$7
		2030	.long __head_my_dll
		2031
		2032	.section .idata$5
		2033	___imp_function:
		2034	__imp__function:
		2035	iat?
		2036	.section .idata$4
		2037	iat?
		2038	.section .idata$6
		2039	ID:
		2040	.short
		2041	.asciz "function" xlate? (add underscore, kill at) */
		2042
		2043	static const unsigned char jmp_ix86_bytes[] =
		2044	{
		2045	0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
		2046	};
		2047
		2048	/* _function:
		2049	mov.l ip+8,r0
		2050	mov.l @r0,r0
		2051	jmp @r0
		2052	nop
		2053	.dw __imp_function */
		2054
		2055	static const unsigned char jmp_sh_bytes[] =
		2056	{
		2057	0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
		2058	};
		2059
		2060	/* _function:
		2061	lui $t0,
		2062	lw $t0,
		2063	jr $t0
		2064	nop */
		2065
		2066	static const unsigned char jmp_mips_bytes[] =
		2067	{
		2068	0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
		2069	0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
		2070	};
		2071
		2072	static const unsigned char jmp_arm_bytes[] =
		2073	{
		2074	0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
		2075	0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
		2076	0, 0, 0, 0
		2077	};
		2078
		2079
		2080	static bfd *
		2081	make_one (def_file_export exp, bfd parent, bfd_boolean include_jmp_stub)
		2082	{
		2083	asection tx, id7, id5, id4, *id6;
		2084	unsigned char td = NULL, d7, d5, d4, *d6 = NULL;
		2085	int len;
		2086	char *oname;
		2087	bfd *abfd;
		2088	const unsigned char *jmp_bytes = NULL;
		2089	int jmp_byte_count = 0;
		2090
		2091	/* Include the jump stub section only if it is needed. A jump
		2092	stub is needed if the symbol being imported is a function
		2093	symbol and there is at least one undefined reference to that
		2094	symbol. In other words, if all the import references to are
		2095	explicitly through _declspec(dllimport) then the jump stub is not
		2096	needed. */
		2097	if (include_jmp_stub)
		2098	{
		2099	switch (pe_details->pe_arch)
		2100	{
		2101	case PE_ARCH_i386:
		2102	jmp_bytes = jmp_ix86_bytes;
		2103	jmp_byte_count = sizeof (jmp_ix86_bytes);
		2104	break;
		2105	case PE_ARCH_sh:
		2106	jmp_bytes = jmp_sh_bytes;
		2107	jmp_byte_count = sizeof (jmp_sh_bytes);
		2108	break;
		2109	case PE_ARCH_mips:
		2110	jmp_bytes = jmp_mips_bytes;
		2111	jmp_byte_count = sizeof (jmp_mips_bytes);
		2112	break;
		2113	case PE_ARCH_arm:
		2114	case PE_ARCH_arm_epoc:
		2115	case PE_ARCH_arm_wince:
		2116	jmp_bytes = jmp_arm_bytes;
		2117	jmp_byte_count = sizeof (jmp_arm_bytes);
		2118	break;
		2119	default:
		2120	abort ();
		2121	}
		2122	}
		2123
		2124	oname = xmalloc (20);
		2125	sprintf (oname, "d%06d.o", tmp_seq);
		2126	tmp_seq++;
		2127
		2128	abfd = bfd_create (oname, parent);
		2129	bfd_find_target (pe_details->object_target, abfd);
		2130	bfd_make_writable (abfd);
		2131
		2132	bfd_set_format (abfd, bfd_object);
		2133	bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
		2134
		2135	symptr = 0;
		2136	symtab = xmalloc (12 * sizeof (asymbol *));
		2137
		2138	tx = quick_section (abfd, ".text", SEC_CODE \| SEC_HAS_CONTENTS \| SEC_READONLY, 2);
		2139	id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
		2140	id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
		2141	id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
		2142	id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
		2143
		2144	if (*exp->internal_name == '@')
		2145	{
		2146	quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
		2147	BSF_GLOBAL, 0);
		2148	if (include_jmp_stub)
		2149	quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
		2150	quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
		2151	BSF_GLOBAL, 0);
		2152	/* Fastcall applies only to functions,
		2153	so no need for auto-import symbol. */
		2154	}
		2155	else
		2156	{
		2157	quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
		2158	BSF_GLOBAL, 0);
		2159	if (include_jmp_stub)
		2160	quick_symbol (abfd, U (""), exp->internal_name, "", tx,
		2161	BSF_GLOBAL, 0);
		2162	quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
		2163	BSF_GLOBAL, 0);
		2164	/* Symbol to reference ord/name of imported
		2165	data symbol, used to implement auto-import. */
		2166	if (exp->flag_data)
		2167	quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
		2168	BSF_GLOBAL,0);
		2169	}
		2170	if (pe_dll_compat_implib)
		2171	quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
		2172	BSF_GLOBAL, 0);
		2173
		2174	if (include_jmp_stub)
		2175	{
		2176	bfd_set_section_size (abfd, tx, jmp_byte_count);
		2177	td = xmalloc (jmp_byte_count);
		2178	tx->contents = td;
		2179	memcpy (td, jmp_bytes, jmp_byte_count);
		2180
		2181	switch (pe_details->pe_arch)
		2182	{
		2183	case PE_ARCH_i386:
		2184	#ifdef pe_use_x86_64
		2185	quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
		2186	#else
		2187	/* Mark this object as SAFESEH compatible. */
		2188	quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
		2189	BSF_LOCAL, 1);
		2190	quick_reloc (abfd, 2, BFD_RELOC_32, 2);
		2191	#endif
		2192	break;
		2193	case PE_ARCH_sh:
		2194	quick_reloc (abfd, 8, BFD_RELOC_32, 2);
		2195	break;
		2196	case PE_ARCH_mips:
		2197	quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
		2198	quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
		2199	quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
		2200	break;
		2201	case PE_ARCH_arm:
		2202	case PE_ARCH_arm_epoc:
		2203	case PE_ARCH_arm_wince:
		2204	quick_reloc (abfd, 8, BFD_RELOC_32, 2);
		2205	break;
		2206	default:
		2207	abort ();
		2208	}
		2209	save_relocs (tx);
		2210	}
		2211	else
		2212	bfd_set_section_size (abfd, tx, 0);
		2213
		2214	bfd_set_section_size (abfd, id7, 4);
		2215	d7 = xmalloc (4);
		2216	id7->contents = d7;
		2217	memset (d7, 0, 4);
		2218	quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
		2219	save_relocs (id7);
		2220
		2221	bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
		2222	d5 = xmalloc (PE_IDATA5_SIZE);
		2223	id5->contents = d5;
		2224	memset (d5, 0, PE_IDATA5_SIZE);
		2225
		2226	if (exp->flag_noname)
		2227	{
		2228	d5[0] = exp->ordinal;
		2229	d5[1] = exp->ordinal >> 8;
		2230	d5[PE_IDATA5_SIZE - 1] = 0x80;
		2231	}
		2232	else
		2233	{
		2234	quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
		2235	save_relocs (id5);
		2236	}
		2237
		2238	bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
		2239	d4 = xmalloc (PE_IDATA4_SIZE);
		2240	id4->contents = d4;
		2241	memset (d4, 0, PE_IDATA4_SIZE);
		2242
		2243	if (exp->flag_noname)
		2244	{
		2245	d4[0] = exp->ordinal;
		2246	d4[1] = exp->ordinal >> 8;
		2247	d4[PE_IDATA4_SIZE - 1] = 0x80;
		2248	}
		2249	else
		2250	{
		2251	quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
		2252	save_relocs (id4);
		2253	}
		2254
		2255	if (exp->flag_noname)
		2256	{
		2257	len = 0;
		2258	bfd_set_section_size (abfd, id6, 0);
		2259	}
		2260	else
		2261	{
		2262	/* { short, asciz } */
		2263	if (exp->its_name)
		2264	len = 2 + strlen (exp->its_name) + 1;
		2265	else
		2266	len = 2 + strlen (exp->name) + 1;
		2267	if (len & 1)
		2268	len++;
		2269	bfd_set_section_size (abfd, id6, len);
		2270	d6 = xmalloc (len);
		2271	id6->contents = d6;
		2272	memset (d6, 0, len);
		2273	d6[0] = exp->hint & 0xff;
		2274	d6[1] = exp->hint >> 8;
		2275	if (exp->its_name)
		2276	strcpy ((char*) d6 + 2, exp->its_name);
		2277	else
		2278	strcpy ((char *) d6 + 2, exp->name);
		2279	}
		2280
		2281	bfd_set_symtab (abfd, symtab, symptr);
		2282
		2283	if (include_jmp_stub)
		2284	bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
		2285	bfd_set_section_contents (abfd, id7, d7, 0, 4);
		2286	bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
		2287	bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
		2288	if (!exp->flag_noname)
		2289	bfd_set_section_contents (abfd, id6, d6, 0, len);
		2290
		2291	bfd_make_readable (abfd);
		2292	return abfd;
		2293	}
		2294
		2295	static bfd *
		2296	make_singleton_name_imp (const char import, bfd parent)
		2297	{
		2298	/* Name thunks go to idata$4. */
		2299	asection *id5;
		2300	unsigned char *d5;
		2301	char *oname;
		2302	bfd *abfd;
		2303
		2304	oname = xmalloc (20);
		2305	sprintf (oname, "nmimp%06d.o", tmp_seq2);
		2306	tmp_seq2++;
		2307
		2308	abfd = bfd_create (oname, parent);
		2309	bfd_find_target (pe_details->object_target, abfd);
		2310	bfd_make_writable (abfd);
		2311
		2312	bfd_set_format (abfd, bfd_object);
		2313	bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
		2314
		2315	symptr = 0;
		2316	symtab = xmalloc (3 * sizeof (asymbol *));
		2317	id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
		2318	quick_symbol (abfd, "__imp_", import, "", id5, BSF_GLOBAL, 0);
		2319
		2320	/* We need space for the real thunk and for the null terminator. */
		2321	bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE * 2);
		2322	d5 = xmalloc (PE_IDATA5_SIZE * 2);
		2323	id5->contents = d5;
		2324	memset (d5, 0, PE_IDATA5_SIZE * 2);
		2325	quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
		2326	save_relocs (id5);
		2327
		2328	bfd_set_symtab (abfd, symtab, symptr);
		2329
		2330	bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA4_SIZE * 2);
		2331
		2332	bfd_make_readable (abfd);
		2333	return abfd;
		2334	}
		2335
		2336	static bfd *
		2337	make_singleton_name_thunk (const char import, bfd parent)
		2338	{
		2339	/* Name thunks go to idata$4. */
		2340	asection *id4;
		2341	unsigned char *d4;
		2342	char *oname;
		2343	bfd *abfd;
		2344
		2345	oname = xmalloc (20);
		2346	sprintf (oname, "nmth%06d.o", tmp_seq);
		2347	tmp_seq++;
		2348
		2349	abfd = bfd_create (oname, parent);
		2350	bfd_find_target (pe_details->object_target, abfd);
		2351	bfd_make_writable (abfd);
		2352
		2353	bfd_set_format (abfd, bfd_object);
		2354	bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
		2355
		2356	symptr = 0;
		2357	symtab = xmalloc (3 * sizeof (asymbol *));
		2358	id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
		2359	quick_symbol (abfd, "__nm_thnk_", import, "", id4, BSF_GLOBAL, 0);
		2360	quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
		2361
		2362	/* We need space for the real thunk and for the null terminator. */
		2363	bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
		2364	d4 = xmalloc (PE_IDATA4_SIZE * 2);
		2365	id4->contents = d4;
		2366	memset (d4, 0, PE_IDATA4_SIZE * 2);
		2367	quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
		2368	save_relocs (id4);
		2369
		2370	bfd_set_symtab (abfd, symtab, symptr);
		2371
		2372	bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
		2373
		2374	bfd_make_readable (abfd);
		2375	return abfd;
		2376	}
		2377
		2378	static char *
		2379	make_import_fixup_mark (arelent *rel)
		2380	{
		2381	/* We convert reloc to symbol, for later reference. */
		2382	static int counter;
		2383	static char *fixup_name = NULL;
		2384	static size_t buffer_len = 0;
		2385
		2386	struct bfd_symbol sym = rel->sym_ptr_ptr;
		2387
		2388	bfd *abfd = bfd_asymbol_bfd (sym);
		2389	struct bfd_link_hash_entry *bh;
		2390
		2391	if (!fixup_name)
		2392	{
		2393	fixup_name = xmalloc (384);
		2394	buffer_len = 384;
		2395	}
		2396
		2397	if (strlen (sym->name) + 25 > buffer_len)
		2398	/* Assume 25 chars for "__fu" + counter + "_". If counter is
		2399	bigger than 20 digits long, we've got worse problems than
		2400	overflowing this buffer... */
		2401	{
		2402	free (fixup_name);
		2403	/* New buffer size is length of symbol, plus 25, but
		2404	then rounded up to the nearest multiple of 128. */
		2405	buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
		2406	fixup_name = xmalloc (buffer_len);
		2407	}
		2408
		2409	sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
		2410
		2411	bh = NULL;
		2412	bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
		2413	current_sec, /* sym->section, */
		2414	rel->address, NULL, TRUE, FALSE, &bh);
		2415
		2416	return fixup_name;
		2417	}
		2418
		2419	/* .section .idata$2
		2420	.rva __nm_thnk_SYM (singleton thunk with name of func)
		2421	.long 0
		2422	.long 0
		2423	.rva __my_dll_iname (name of dll)
		2424	.rva __fuNN_SYM (pointer to reference (address) in text) */
		2425
		2426	static bfd *
		2427	make_import_fixup_entry (const char *name,
		2428	const char *fixup_name,
		2429	const char *symname,
		2430	bfd *parent)
		2431	{
		2432	asection *id2;
		2433	unsigned char *d2;
		2434	char *oname;
		2435	bfd *abfd;
		2436
		2437	oname = xmalloc (20);
		2438	sprintf (oname, "fu%06d.o", tmp_seq);
		2439	tmp_seq++;
		2440
		2441	abfd = bfd_create (oname, parent);
		2442	bfd_find_target (pe_details->object_target, abfd);
		2443	bfd_make_writable (abfd);
		2444
		2445	bfd_set_format (abfd, bfd_object);
		2446	bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
		2447
		2448	symptr = 0;
		2449	symtab = xmalloc (6 * sizeof (asymbol *));
		2450	id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
		2451
		2452	quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
		2453	quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
		2454	/* For relocator v2 we have to use the .idata$5 element and not
		2455	fixup_name. */
		2456	if (link_info.pei386_runtime_pseudo_reloc == 2)
		2457	quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
		2458	else
		2459	quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
		2460
		2461	bfd_set_section_size (abfd, id2, 20);
		2462	d2 = xmalloc (20);
		2463	id2->contents = d2;
		2464	memset (d2, 0, 20);
		2465
		2466	quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
		2467	quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
		2468	quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
		2469	save_relocs (id2);
		2470
		2471	bfd_set_symtab (abfd, symtab, symptr);
		2472
		2473	bfd_set_section_contents (abfd, id2, d2, 0, 20);
		2474
		2475	bfd_make_readable (abfd);
		2476	return abfd;
		2477	}
		2478
		2479	/* .section .rdata_runtime_pseudo_reloc
		2480	.long addend
		2481	.rva __fuNN_SYM (pointer to reference (address) in text) */
		2482
		2483	static bfd *
		2484	make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
		2485	const char *fixup_name,
		2486	bfd_vma addend ATTRIBUTE_UNUSED,
		2487	bfd_vma bitsize,
		2488	bfd *parent)
		2489	{
		2490	asection *rt_rel;
		2491	unsigned char *rt_rel_d;
		2492	char *oname;
		2493	bfd *abfd;
		2494	oname = xmalloc (20);
		2495	sprintf (oname, "rtr%06d.o", tmp_seq);
		2496	tmp_seq++;
		2497
		2498	abfd = bfd_create (oname, parent);
		2499	bfd_find_target (pe_details->object_target, abfd);
		2500	bfd_make_writable (abfd);
		2501
		2502	bfd_set_format (abfd, bfd_object);
		2503	bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
		2504
		2505	symptr = 0;
		2506	if (link_info.pei386_runtime_pseudo_reloc == 2)
		2507	{
		2508	symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
		2509	}
		2510	else
		2511	{
		2512	symtab = xmalloc (2 * sizeof (asymbol *));
		2513	}
		2514	rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
		2515	SEC_HAS_CONTENTS, 2);
		2516
		2517	quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
		2518
		2519	if (link_info.pei386_runtime_pseudo_reloc == 2)
		2520	{
		2521	size_t size = 12;
		2522	if (! runtime_pseudp_reloc_v2_init)
		2523	{
		2524	size += 12;
		2525	runtime_pseudp_reloc_v2_init = 1;
		2526	}
		2527	quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
		2528
		2529	bfd_set_section_size (abfd, rt_rel, size);
		2530	rt_rel_d = xmalloc (size);
		2531	rt_rel->contents = rt_rel_d;
		2532	memset (rt_rel_d, 0, size);
		2533	quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
		2534	quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
		2535	bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
		2536	if (size != 12)
		2537	bfd_put_32 (abfd, 1, rt_rel_d + 8);
		2538	save_relocs (rt_rel);
		2539
		2540	bfd_set_symtab (abfd, symtab, symptr);
		2541
		2542	bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
		2543	}
		2544	else
		2545	{
		2546	bfd_set_section_size (abfd, rt_rel, 8);
		2547	rt_rel_d = xmalloc (8);
		2548	rt_rel->contents = rt_rel_d;
		2549	memset (rt_rel_d, 0, 8);
		2550
		2551	bfd_put_32 (abfd, addend, rt_rel_d);
		2552	quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
		2553
		2554	save_relocs (rt_rel);
		2555
		2556	bfd_set_symtab (abfd, symtab, symptr);
		2557
		2558	bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
		2559	}
		2560	bfd_make_readable (abfd);
		2561	return abfd;
		2562	}
		2563
		2564	/* .section .rdata
		2565	.rva __pei386_runtime_relocator */
		2566
		2567	static bfd *
		2568	pe_create_runtime_relocator_reference (bfd *parent)
		2569	{
		2570	asection *extern_rt_rel;
		2571	unsigned char *extern_rt_rel_d;
		2572	char *oname;
		2573	bfd *abfd;
		2574
		2575	oname = xmalloc (20);
		2576	sprintf (oname, "ertr%06d.o", tmp_seq);
		2577	tmp_seq++;
		2578
		2579	abfd = bfd_create (oname, parent);
		2580	bfd_find_target (pe_details->object_target, abfd);
		2581	bfd_make_writable (abfd);
		2582
		2583	bfd_set_format (abfd, bfd_object);
		2584	bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
		2585
		2586	symptr = 0;
		2587	symtab = xmalloc (2 * sizeof (asymbol *));
		2588	extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
		2589
		2590	quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
		2591	BSF_NO_FLAGS, 0);
		2592
		2593	bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
6324	serge	2594	extern_rt_rel_d = xcalloc (1, PE_IDATA5_SIZE);
5199	serge	2595	extern_rt_rel->contents = extern_rt_rel_d;
		2596
		2597	quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
		2598	save_relocs (extern_rt_rel);
		2599
		2600	bfd_set_symtab (abfd, symtab, symptr);
		2601
		2602	bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
		2603
		2604	bfd_make_readable (abfd);
		2605	return abfd;
		2606	}
		2607
		2608	void
		2609	pe_create_import_fixup (arelent rel, asection s, bfd_vma addend)
		2610	{
		2611	char buf[300];
		2612	struct bfd_symbol sym = rel->sym_ptr_ptr;
		2613	struct bfd_link_hash_entry *name_thunk_sym;
		2614	struct bfd_link_hash_entry *name_imp_sym;
		2615	const char *name = sym->name;
		2616	char *fixup_name = make_import_fixup_mark (rel);
		2617	bfd *b;
		2618	int need_import_table = 1;
		2619
		2620	sprintf (buf, "__imp_%s", name);
		2621	name_imp_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
		2622
		2623	sprintf (buf, "__nm_thnk_%s", name);
		2624
		2625	name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
		2626
		2627	/* For version 2 pseudo relocation we don't need to add an import
		2628	if the import symbol is already present. */
		2629	if (link_info.pei386_runtime_pseudo_reloc == 2
		2630	&& name_imp_sym
		2631	&& name_imp_sym->type == bfd_link_hash_defined)
		2632	need_import_table = 0;
		2633
		2634	if (need_import_table == 1
		2635	&& (!name_thunk_sym \|\| name_thunk_sym->type != bfd_link_hash_defined))
		2636	{
		2637	b = make_singleton_name_thunk (name, link_info.output_bfd);
		2638	add_bfd_to_link (b, b->filename, &link_info);
		2639
		2640	/* If we ever use autoimport, we have to cast text section writable.
		2641	But not for version 2. */
		2642	if (link_info.pei386_runtime_pseudo_reloc != 2)
		2643	{
		2644	config.text_read_only = FALSE;
		2645	link_info.output_bfd->flags &= ~WP_TEXT;
		2646	}
		2647	if (link_info.pei386_runtime_pseudo_reloc == 2)
		2648	{
		2649	b = make_singleton_name_imp (name, link_info.output_bfd);
		2650	add_bfd_to_link (b, b->filename, &link_info);
		2651	}
		2652	}
		2653
		2654	if ((addend == 0 \|\| link_info.pei386_runtime_pseudo_reloc)
		2655	&& need_import_table == 1)
		2656	{
		2657	extern char * pe_data_import_dll;
		2658	char * symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
		2659
		2660	b = make_import_fixup_entry (name, fixup_name, symname,
		2661	link_info.output_bfd);
		2662	add_bfd_to_link (b, b->filename, &link_info);
		2663	}
		2664
		2665	if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
		2666	\|\| link_info.pei386_runtime_pseudo_reloc == 2)
		2667	{
		2668	if (pe_dll_extra_pe_debug)
		2669	printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
		2670	fixup_name, (int) addend);
		2671
		2672	b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
		2673	link_info.output_bfd);
		2674	add_bfd_to_link (b, b->filename, &link_info);
		2675
		2676	if (runtime_pseudo_relocs_created == 0)
		2677	{
		2678	b = pe_create_runtime_relocator_reference (link_info.output_bfd);
		2679	add_bfd_to_link (b, b->filename, &link_info);
		2680	}
		2681	runtime_pseudo_relocs_created++;
		2682	}
		2683	else if (addend != 0)
		2684	{
		2685	einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
		2686	s->owner, s, rel->address, sym->name);
		2687	einfo ("%X");
		2688	}
		2689	}
		2690
		2691
		2692	void
		2693	pe_dll_generate_implib (def_file def, const char impfilename, struct bfd_link_info *info)
		2694	{
		2695	int i;
		2696	bfd *ar_head;
		2697	bfd *ar_tail;
		2698	bfd *outarch;
		2699	bfd *ibfd;
		2700	bfd *head = 0;
		2701
		2702	dll_filename = (def->name) ? def->name : dll_name;
		2703	dll_symname = xstrdup (dll_filename);
		2704	for (i = 0; dll_symname[i]; i++)
		2705	if (!ISALNUM (dll_symname[i]))
		2706	dll_symname[i] = '_';
		2707
		2708	unlink_if_ordinary (impfilename);
		2709
		2710	outarch = bfd_openw (impfilename, 0);
		2711
		2712	if (!outarch)
		2713	{
		2714	/* xgettext:c-format */
		2715	einfo (_("%XCan't open .lib file: %s\n"), impfilename);
		2716	return;
		2717	}
		2718
		2719	if (verbose)
		2720	/* xgettext:c-format */
		2721	info_msg (_("Creating library file: %s\n"), impfilename);
		2722
		2723	bfd_set_format (outarch, bfd_archive);
		2724	outarch->has_armap = 1;
		2725
		2726	/* Work out a reasonable size of things to put onto one line. */
		2727	ar_head = make_head (outarch);
		2728
		2729	/* Iterate the input BFDs, looking for exclude-modules-for-implib. */
6324	serge	2730	for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
5199	serge	2731	{
		2732	/* Iterate the exclude list. */
		2733	struct exclude_list_struct *ex;
		2734	char found;
		2735	for (ex = excludes, found = 0; ex && !found; ex = ex->next)
		2736	{
		2737	if (ex->type != EXCLUDEFORIMPLIB)
		2738	continue;
		2739	found = (filename_cmp (ex->string, ibfd->filename) == 0);
		2740	}
		2741	/* If it matched, we must open a fresh BFD for it (the original
		2742	input BFD is still needed for the DLL's final link) and add
		2743	it into the archive member chain. */
		2744	if (found)
		2745	{
		2746	bfd *newbfd = bfd_openr (ibfd->my_archive
		2747	? ibfd->my_archive->filename : ibfd->filename, NULL);
		2748	if (!newbfd)
		2749	{
		2750	einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
		2751	return;
		2752	}
		2753	if (ibfd->my_archive)
		2754	{
		2755	/* Must now iterate through archive until we find the
		2756	required member. A minor shame that we'll open the
		2757	archive once per member that we require from it, and
		2758	leak those archive bfds rather than reuse them. */
		2759	bfd *arbfd = newbfd;
		2760	if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
		2761	{
		2762	einfo (_("%X%s(%s): can't find member in non-archive file"),
		2763	ibfd->my_archive->filename, ibfd->filename);
		2764	return;
		2765	}
		2766	newbfd = NULL;
		2767	while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
		2768	{
		2769	if (filename_cmp (newbfd->filename, ibfd->filename) == 0)
		2770	break;
		2771	}
		2772	if (!newbfd)
		2773	{
		2774	einfo (_("%X%s(%s): can't find member in archive"),
		2775	ibfd->my_archive->filename, ibfd->filename);
		2776	return;
		2777	}
		2778	}
		2779	newbfd->archive_next = head;
		2780	head = newbfd;
		2781	}
		2782	}
		2783
		2784	for (i = 0; i < def->num_exports; i++)
		2785	{
		2786	/* The import library doesn't know about the internal name. */
		2787	char *internal = def->exports[i].internal_name;
		2788	bfd *n;
		2789
		2790	/* Don't add PRIVATE entries to import lib. */
		2791	if (pe_def_file->exports[i].flag_private)
		2792	continue;
		2793	def->exports[i].internal_name = def->exports[i].name;
		2794	n = make_one (def->exports + i, outarch,
		2795	! (def->exports + i)->flag_data);
		2796	n->archive_next = head;
		2797	head = n;
		2798	def->exports[i].internal_name = internal;
		2799	}
		2800
		2801	ar_tail = make_tail (outarch);
		2802
		2803	if (ar_head == NULL \|\| ar_tail == NULL)
		2804	return;
		2805
		2806	/* Now stick them all into the archive. */
		2807	ar_head->archive_next = head;
		2808	ar_tail->archive_next = ar_head;
		2809	head = ar_tail;
		2810
		2811	if (! bfd_set_archive_head (outarch, head))
		2812	einfo ("%Xbfd_set_archive_head: %E\n");
		2813
		2814	if (! bfd_close (outarch))
		2815	einfo ("%Xbfd_close %s: %E\n", impfilename);
		2816
		2817	while (head != NULL)
		2818	{
		2819	bfd *n = head->archive_next;
		2820	bfd_close (head);
		2821	head = n;
		2822	}
		2823	}
		2824
		2825	static int undef_count = 0;
		2826
		2827	struct key_value
		2828	{
		2829	char *key;
		2830	const char *oname;
		2831	};
		2832
		2833	static struct key_value *udef_table;
		2834
		2835	static int undef_sort_cmp (const void l1, const void r1)
		2836	{
		2837	const struct key_value *l = l1;
		2838	const struct key_value *r = r1;
		2839
		2840	return strcmp (l->key, r->key);
		2841	}
		2842
		2843	static struct bfd_link_hash_entry *
		2844	pe_find_cdecl_alias_match (struct bfd_link_info linfo, char name)
		2845	{
		2846	struct bfd_link_hash_entry *h = NULL;
		2847	struct key_value *kv;
		2848	struct key_value key;
		2849	char at, lname = (char *) alloca (strlen (name) + 3);
		2850
		2851	strcpy (lname, name);
		2852
		2853	at = strchr (lname + (lname[0] == '@'), '@');
		2854	if (at)
		2855	at[1] = 0;
		2856
		2857	key.key = lname;
		2858	kv = bsearch (&key, udef_table, undef_count, sizeof (struct key_value),
		2859	undef_sort_cmp);
		2860
		2861	if (kv)
		2862	{
		2863	h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
		2864	if (h->type == bfd_link_hash_undefined)
		2865	return h;
		2866	}
		2867	if (lname[0] == '?')
		2868	return NULL;
		2869	if (at \|\| lname[0] == '@')
		2870	{
		2871	if (lname[0] == '@')
		2872	{
		2873	if (pe_details->underscored)
		2874	lname[0] = '_';
		2875	else
		2876	strcpy (lname, lname + 1);
		2877	key.key = lname;
		2878	kv = bsearch (&key, udef_table, undef_count,
		2879	sizeof (struct key_value), undef_sort_cmp);
		2880	if (kv)
		2881	{
		2882	h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
		2883	if (h->type == bfd_link_hash_undefined)
		2884	return h;
		2885	}
		2886	}
		2887	if (at)
		2888	*strchr (lname, '@') = 0;
		2889	key.key = lname;
		2890	kv = bsearch (&key, udef_table, undef_count,
		2891	sizeof (struct key_value), undef_sort_cmp);
		2892	if (kv)
		2893	{
		2894	h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
		2895	if (h->type == bfd_link_hash_undefined)
		2896	return h;
		2897	}
		2898	return NULL;
		2899	}
		2900
		2901	strcat (lname, "@");
		2902	key.key = lname;
		2903	kv = bsearch (&key, udef_table, undef_count,
		2904	sizeof (struct key_value), undef_sort_cmp);
		2905
		2906	if (kv)
		2907	{
		2908	h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
		2909	if (h->type == bfd_link_hash_undefined)
		2910	return h;
		2911	}
		2912
		2913	if (lname[0] == '_' && pe_details->underscored)
		2914	lname[0] = '@';
		2915	else
		2916	{
		2917	memmove (lname + 1, lname, strlen (lname) + 1);
		2918	lname[0] = '@';
		2919	}
		2920	key.key = lname;
		2921
		2922	kv = bsearch (&key, udef_table, undef_count,
		2923	sizeof (struct key_value), undef_sort_cmp);
		2924
		2925	if (kv)
		2926	{
		2927	h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
		2928	if (h->type == bfd_link_hash_undefined)
		2929	return h;
		2930	}
		2931
		2932	return NULL;
		2933	}
		2934
		2935	static bfd_boolean
		2936	pe_undef_count (struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
		2937	void *inf ATTRIBUTE_UNUSED)
		2938	{
		2939	if (h->type == bfd_link_hash_undefined)
		2940	undef_count++;
		2941	return TRUE;
		2942	}
		2943
		2944	static bfd_boolean
		2945	pe_undef_fill (struct bfd_link_hash_entry h, void inf ATTRIBUTE_UNUSED)
		2946	{
		2947	if (h->type == bfd_link_hash_undefined)
		2948	{
		2949	char *at;
		2950
		2951	udef_table[undef_count].key = xstrdup (h->root.string);
		2952	at = strchr (udef_table[undef_count].key
		2953	+ (udef_table[undef_count].key[0] == '@'), '@');
		2954	if (at)
		2955	at[1] = 0;
		2956	udef_table[undef_count].oname = h->root.string;
		2957	undef_count++;
		2958	}
		2959	return TRUE;
		2960	}
		2961
		2962	static void
		2963	pe_create_undef_table (void)
		2964	{
		2965	undef_count = 0;
		2966
		2967	/* count undefined symbols */
		2968
		2969	bfd_link_hash_traverse (link_info.hash, pe_undef_count, "");
		2970
		2971	/* create and fill the corresponding table */
		2972	udef_table = xmalloc (undef_count * sizeof (struct key_value));
		2973
		2974	undef_count = 0;
		2975	bfd_link_hash_traverse (link_info.hash, pe_undef_fill, "");
		2976
		2977	/* sort items */
		2978	qsort (udef_table, undef_count, sizeof (struct key_value), undef_sort_cmp);
		2979	}
		2980
		2981	static void
		2982	add_bfd_to_link (bfd abfd, const char name, struct bfd_link_info *linfo)
		2983	{
		2984	lang_input_statement_type *fake_file;
		2985
		2986	fake_file = lang_add_input_file (name,
		2987	lang_input_file_is_fake_enum,
		2988	NULL);
		2989	fake_file->the_bfd = abfd;
		2990	ldlang_add_file (fake_file);
		2991
		2992	if (!bfd_link_add_symbols (abfd, linfo))
		2993	einfo ("%Xaddsym %s: %E\n", name);
		2994	}
		2995
		2996	void
		2997	pe_process_import_defs (bfd output_bfd, struct bfd_link_info linfo)
		2998	{
		2999	int i, j;
		3000	def_file_module *module;
		3001	def_file_import *imp;
		3002
		3003	pe_dll_id_target (bfd_get_target (output_bfd));
		3004
		3005	if (!pe_def_file)
		3006	return;
		3007
		3008	imp = pe_def_file->imports;
		3009
		3010	pe_create_undef_table ();
		3011
		3012	for (module = pe_def_file->modules; module; module = module->next)
		3013	{
		3014	int do_this_dll = 0;
		3015
		3016	for (i = 0; i < pe_def_file->num_imports && imp[i].module != module; i++)
		3017	;
		3018	if (i >= pe_def_file->num_imports)
		3019	continue;
		3020
		3021	dll_filename = module->name;
		3022	dll_symname = xstrdup (module->name);
		3023	for (j = 0; dll_symname[j]; j++)
		3024	if (!ISALNUM (dll_symname[j]))
		3025	dll_symname[j] = '_';
		3026
		3027	for (; i < pe_def_file->num_imports && imp[i].module == module; i++)
		3028	{
		3029	def_file_export exp;
		3030	struct bfd_link_hash_entry *blhe;
		3031	int lead_at = (*imp[i].internal_name == '@');
		3032	/* See if we need this import. */
		3033	size_t len = strlen (imp[i].internal_name);
		3034	char *name = xmalloc (len + 2 + 6);
		3035	bfd_boolean include_jmp_stub = FALSE;
		3036	bfd_boolean is_cdecl = FALSE;
		3037	bfd_boolean is_undef = FALSE;
		3038
		3039	if (!lead_at && strchr (imp[i].internal_name, '@') == NULL)
		3040	is_cdecl = TRUE;
		3041
		3042	if (lead_at)
		3043	sprintf (name, "%s", imp[i].internal_name);
		3044	else
		3045	sprintf (name, "%s%s",U (""), imp[i].internal_name);
		3046
		3047	blhe = bfd_link_hash_lookup (linfo->hash, name,
		3048	FALSE, FALSE, FALSE);
		3049
		3050	/* Include the jump stub for only if the
		3051	is undefined. */
		3052	if (!blhe \|\| (blhe && blhe->type != bfd_link_hash_undefined))
		3053	{
		3054	if (lead_at)
		3055	sprintf (name, "%s%s", "__imp_", imp[i].internal_name);
		3056	else
		3057	sprintf (name, "%s%s%s", "__imp_", U (""),
		3058	imp[i].internal_name);
		3059
		3060	blhe = bfd_link_hash_lookup (linfo->hash, name,
		3061	FALSE, FALSE, FALSE);
		3062	if (blhe)
		3063	is_undef = (blhe->type == bfd_link_hash_undefined);
		3064	}
		3065	else
		3066	{
		3067	include_jmp_stub = TRUE;
		3068	is_undef = (blhe->type == bfd_link_hash_undefined);
		3069	}
		3070
		3071	if (is_cdecl && (!blhe \|\| (blhe && blhe->type != bfd_link_hash_undefined)))
		3072	{
		3073	sprintf (name, "%s%s",U (""), imp[i].internal_name);
		3074	blhe = pe_find_cdecl_alias_match (linfo, name);
		3075	include_jmp_stub = TRUE;
		3076	if (blhe)
		3077	is_undef = (blhe->type == bfd_link_hash_undefined);
		3078	}
		3079
		3080	free (name);
		3081
		3082	if (is_undef)
		3083	{
		3084	bfd *one;
		3085	/* We do. */
		3086	if (!do_this_dll)
		3087	{
		3088	bfd *ar_head = make_head (output_bfd);
		3089	add_bfd_to_link (ar_head, ar_head->filename, linfo);
		3090	do_this_dll = 1;
		3091	}
		3092	exp.internal_name = imp[i].internal_name;
		3093	exp.name = imp[i].name;
		3094	exp.its_name = imp[i].its_name;
		3095	exp.ordinal = imp[i].ordinal;
		3096	exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
		3097	exp.flag_private = 0;
		3098	exp.flag_constant = 0;
		3099	exp.flag_data = imp[i].data;
		3100	exp.flag_noname = exp.name ? 0 : 1;
		3101	one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
		3102	add_bfd_to_link (one, one->filename, linfo);
		3103	}
		3104	}
		3105	if (do_this_dll)
		3106	{
		3107	bfd *ar_tail = make_tail (output_bfd);
		3108	add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
		3109	}
		3110
		3111	free (dll_symname);
		3112	}
		3113
		3114	while (undef_count)
		3115	{
		3116	--undef_count;
		3117	free (udef_table[undef_count].key);
		3118	}
		3119	free (udef_table);
		3120	}
		3121
		3122	/* We were handed a *.DLL file. Parse it and turn it into a set of
		3123	IMPORTS directives in the def file. Return TRUE if the file was
		3124	handled, FALSE if not. */
		3125
		3126	static unsigned int
		3127	pe_get16 (bfd *abfd, int where)
		3128	{
		3129	unsigned char b[2];
		3130
		3131	bfd_seek (abfd, (file_ptr) where, SEEK_SET);
		3132	bfd_bread (b, (bfd_size_type) 2, abfd);
		3133	return b[0] + (b[1] << 8);
		3134	}
		3135
		3136	static unsigned int
		3137	pe_get32 (bfd *abfd, int where)
		3138	{
		3139	unsigned char b[4];
		3140
		3141	bfd_seek (abfd, (file_ptr) where, SEEK_SET);
		3142	bfd_bread (b, (bfd_size_type) 4, abfd);
		3143	return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
		3144	}
		3145
		3146	static unsigned int
		3147	pe_as32 (void *ptr)
		3148	{
		3149	unsigned char *b = ptr;
		3150
		3151	return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
		3152	}
		3153
		3154	bfd_boolean
		3155	pe_implied_import_dll (const char *filename)
		3156	{
		3157	bfd *dll;
		3158	bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
		3159	bfd_vma export_rva, export_size, nsections, secptr, expptr;
		3160	bfd_vma exp_funcbase;
		3161	unsigned char *expdata;
		3162	char *erva;
		3163	bfd_vma name_rvas, nexp;
		3164	const char *dllname;
		3165	/* Initialization with start > end guarantees that is_data
		3166	will not be set by mistake, and avoids compiler warning. */
		3167	bfd_vma data_start = 1;
		3168	bfd_vma data_end = 0;
		3169	bfd_vma rdata_start = 1;
		3170	bfd_vma rdata_end = 0;
		3171	bfd_vma bss_start = 1;
		3172	bfd_vma bss_end = 0;
		3173
		3174	/* No, I can't use bfd here. kernel32.dll puts its export table in
		3175	the middle of the .rdata section. */
		3176	dll = bfd_openr (filename, pe_details->target_name);
		3177	if (!dll)
		3178	{
		3179	einfo ("%Xopen %s: %E\n", filename);
		3180	return FALSE;
		3181	}
		3182
		3183	/* PEI dlls seem to be bfd_objects. */
		3184	if (!bfd_check_format (dll, bfd_object))
		3185	{
		3186	einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
		3187	return FALSE;
		3188	}
		3189
		3190	/* Get pe_header, optional header and numbers of directory entries. */
		3191	pe_header_offset = pe_get32 (dll, 0x3c);
		3192	opthdr_ofs = pe_header_offset + 4 + 20;
		3193	#ifdef pe_use_x86_64
		3194	num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
		3195	#else
		3196	num_entries = pe_get32 (dll, opthdr_ofs + 92);
		3197	#endif
		3198
		3199	/* No import or export directory entry. */
		3200	if (num_entries < 1)
		3201	return FALSE;
		3202
		3203	#ifdef pe_use_x86_64
		3204	export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
		3205	export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
		3206	#else
		3207	export_rva = pe_get32 (dll, opthdr_ofs + 96);
		3208	export_size = pe_get32 (dll, opthdr_ofs + 100);
		3209	#endif
		3210
		3211	/* No export table - nothing to export. */
		3212	if (export_size == 0)
		3213	return FALSE;
		3214
		3215	nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
		3216	secptr = (pe_header_offset + 4 + 20 +
		3217	pe_get16 (dll, pe_header_offset + 4 + 16));
		3218	expptr = 0;
		3219
		3220	/* Get the rva and size of the export section. */
		3221	for (i = 0; i < nsections; i++)
		3222	{
		3223	char sname[8];
		3224	bfd_vma secptr1 = secptr + 40 * i;
		3225	bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
		3226	bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
		3227	bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
		3228
		3229	bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
		3230	bfd_bread (sname, (bfd_size_type) 8, dll);
		3231
		3232	if (vaddr <= export_rva && vaddr + vsize > export_rva)
		3233	{
		3234	expptr = fptr + (export_rva - vaddr);
		3235	if (export_rva + export_size > vaddr + vsize)
		3236	export_size = vsize - (export_rva - vaddr);
		3237	break;
		3238	}
		3239	}
		3240
		3241	/* Scan sections and store the base and size of the
		3242	data and bss segments in data/base_start/end. */
		3243	for (i = 0; i < nsections; i++)
		3244	{
		3245	bfd_vma secptr1 = secptr + 40 * i;
		3246	bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
		3247	bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
		3248	bfd_vma flags = pe_get32 (dll, secptr1 + 36);
		3249	char sec_name[9];
		3250
		3251	sec_name[8] = '\0';
		3252	bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
		3253	bfd_bread (sec_name, (bfd_size_type) 8, dll);
		3254
		3255	if (strcmp(sec_name,".data") == 0)
		3256	{
		3257	data_start = vaddr;
		3258	data_end = vaddr + vsize;
		3259
		3260	if (pe_dll_extra_pe_debug)
		3261	printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
		3262	__FUNCTION__, sec_name, (unsigned long) vaddr,
		3263	(unsigned long) (vaddr + vsize), (unsigned long) flags);
		3264	}
		3265	else if (strcmp(sec_name,".rdata") == 0)
		3266	{
		3267	rdata_start = vaddr;
		3268	rdata_end = vaddr + vsize;
		3269
		3270	if (pe_dll_extra_pe_debug)
		3271	printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
		3272	__FUNCTION__, sec_name, (unsigned long) vaddr,
		3273	(unsigned long) (vaddr + vsize), (unsigned long) flags);
		3274	}
		3275	else if (strcmp (sec_name,".bss") == 0)
		3276	{
		3277	bss_start = vaddr;
		3278	bss_end = vaddr + vsize;
		3279
		3280	if (pe_dll_extra_pe_debug)
		3281	printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
		3282	__FUNCTION__, sec_name, (unsigned long) vaddr,
		3283	(unsigned long) (vaddr + vsize), (unsigned long) flags);
		3284	}
		3285	}
		3286
		3287	expdata = xmalloc (export_size);
		3288	bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
		3289	bfd_bread (expdata, (bfd_size_type) export_size, dll);
		3290	erva = (char *) expdata - export_rva;
		3291
		3292	if (pe_def_file == 0)
		3293	pe_def_file = def_file_empty ();
		3294
		3295	nexp = pe_as32 (expdata + 24);
		3296	name_rvas = pe_as32 (expdata + 32);
		3297	exp_funcbase = pe_as32 (expdata + 28);
		3298
		3299	/* Use internal dll name instead of filename
		3300	to enable symbolic dll linking. */
		3301	dllname = erva + pe_as32 (expdata + 12);
		3302
		3303	/* Check to see if the dll has already been added to
		3304	the definition list and if so return without error.
		3305	This avoids multiple symbol definitions. */
		3306	if (def_get_module (pe_def_file, dllname))
		3307	{
		3308	if (pe_dll_extra_pe_debug)
		3309	printf ("%s is already loaded\n", dllname);
		3310	return TRUE;
		3311	}
		3312
		3313	/* Iterate through the list of symbols. */
		3314	for (i = 0; i < nexp; i++)
		3315	{
		3316	/* Pointer to the names vector. */
		3317	bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
		3318	def_file_import *imp;
		3319	/* Pointer to the function address vector. */
		3320	bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
		3321	int is_data = 0;
		3322
		3323	/* Skip unwanted symbols, which are
		3324	exported in buggy auto-import releases. */
		3325	if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
		3326	{
		3327	int is_dup = 0;
		3328	/* is_data is true if the address is in the data, rdata or bss
		3329	segment. */
		3330	is_data =
		3331	(func_rva >= data_start && func_rva < data_end)
		3332	\|\| (func_rva >= rdata_start && func_rva < rdata_end)
		3333	\|\| (func_rva >= bss_start && func_rva < bss_end);
		3334
		3335	imp = def_file_add_import (pe_def_file, erva + name_rva,
		3336	dllname, i, NULL, NULL, &is_dup);
		3337	/* Mark symbol type. */
		3338	if (!is_dup)
		3339	imp->data = is_data;
		3340
		3341	if (pe_dll_extra_pe_debug)
		3342	printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
		3343	__FUNCTION__, dllname, erva + name_rva,
		3344	(unsigned long) func_rva, is_data ? "(data)" : "");
		3345	}
		3346	}
		3347
		3348	return TRUE;
		3349	}
		3350
		3351	void
		3352	pe_output_file_set_long_section_names (bfd *abfd)
		3353	{
		3354	if (pe_use_coff_long_section_names < 0)
		3355	return;
		3356	if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
		3357	einfo (_("%XError: can't use long section names on this arch\n"));
		3358	}
		3359
		3360	/* These are the main functions, called from the emulation. The first
		3361	is called after the bfds are read, so we can guess at how much space
		3362	we need. The second is called after everything is placed, so we
		3363	can put the right values in place. */
		3364
		3365	void
		3366	pe_dll_build_sections (bfd abfd, struct bfd_link_info info)
		3367	{
		3368	pe_dll_id_target (bfd_get_target (abfd));
		3369	pe_output_file_set_long_section_names (abfd);
		3370	process_def_file_and_drectve (abfd, info);
		3371
6324	serge	3372	if (pe_def_file->num_exports == 0 && !bfd_link_pic (info))
5199	serge	3373	return;
		3374
		3375	generate_edata (abfd, info);
		3376	build_filler_bfd (1);
		3377	pe_output_file_set_long_section_names (filler_bfd);
		3378	}
		3379
		3380	void
		3381	pe_exe_build_sections (bfd abfd, struct bfd_link_info info ATTRIBUTE_UNUSED)
		3382	{
		3383	pe_dll_id_target (bfd_get_target (abfd));
		3384	pe_output_file_set_long_section_names (abfd);
		3385	build_filler_bfd (0);
		3386	pe_output_file_set_long_section_names (filler_bfd);
		3387	}
		3388
		3389	void
		3390	pe_dll_fill_sections (bfd abfd, struct bfd_link_info info)
		3391	{
		3392	pe_dll_id_target (bfd_get_target (abfd));
		3393	pe_output_file_set_long_section_names (abfd);
		3394	image_base = pe_data (abfd)->pe_opthdr.ImageBase;
		3395
		3396	generate_reloc (abfd, info);
		3397	if (reloc_sz > 0)
		3398	{
		3399	bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
		3400
		3401	/* Resize the sections. */
		3402	lang_reset_memory_regions ();
		3403	lang_size_sections (NULL, TRUE);
		3404
		3405	/* Redo special stuff. */
		3406	ldemul_after_allocation ();
		3407
		3408	/* Do the assignments again. */
		3409	lang_do_assignments (lang_final_phase_enum);
		3410	}
		3411
		3412	fill_edata (abfd, info);
		3413
6324	serge	3414	if (bfd_link_dll (info))
5199	serge	3415	pe_data (abfd)->dll = 1;
		3416
		3417	edata_s->contents = edata_d;
		3418	reloc_s->contents = reloc_d;
		3419	}
		3420
		3421	void
		3422	pe_exe_fill_sections (bfd abfd, struct bfd_link_info info)
		3423	{
		3424	pe_dll_id_target (bfd_get_target (abfd));
		3425	pe_output_file_set_long_section_names (abfd);
		3426	image_base = pe_data (abfd)->pe_opthdr.ImageBase;
		3427
		3428	generate_reloc (abfd, info);
		3429	if (reloc_sz > 0)
		3430	{
		3431	bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
		3432
		3433	/* Resize the sections. */
		3434	lang_reset_memory_regions ();
		3435	lang_size_sections (NULL, TRUE);
		3436
		3437	/* Redo special stuff. */
		3438	ldemul_after_allocation ();
		3439
		3440	/* Do the assignments again. */
		3441	lang_do_assignments (lang_final_phase_enum);
		3442	}
		3443	reloc_s->contents = reloc_d;
		3444	}
		3445
		3446	bfd_boolean
		3447	pe_bfd_is_dll (bfd *abfd)
		3448	{
		3449	return (bfd_get_format (abfd) == bfd_object
		3450	&& obj_pe (abfd)
		3451	&& pe_data (abfd)->dll);
		3452	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/ld/pe-dll.c – Rev 8031