| blob | 79b30d3299628582533fd9501dbf677e97390799 |
1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 if [ -z "$MACHINE" ]; then
4 OUTPUT_ARCH=${ARCH}
5 else
6 OUTPUT_ARCH=${ARCH}:${MACHINE}
7 fi
8 rm -f e${EMULATION_NAME}.c
9 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
10 fragment <<EOF
11 /* Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
12 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
14 This file is part of the GNU Binutils.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
29 MA 02110-1301, USA. */
32 /* For WINDOWS_NT */
33 /* The original file generated returned different default scripts depending
34 on whether certain switches were set, but these switches pertain to the
35 Linux system and that particular version of coff. In the NT case, we
36 only determine if the subsystem is console or windows in order to select
37 the correct entry point by default. */
39 #define TARGET_IS_${EMULATION_NAME}
41 /* Do this before including bfd.h, so we prototype the right functions. */
43 #if defined(TARGET_IS_armpe) \
44 || defined(TARGET_IS_arm_epoc_pe) \
45 || defined(TARGET_IS_arm_wince_pe)
46 #define bfd_arm_allocate_interworking_sections \
47 bfd_${EMULATION_NAME}_allocate_interworking_sections
48 #define bfd_arm_get_bfd_for_interworking \
49 bfd_${EMULATION_NAME}_get_bfd_for_interworking
50 #define bfd_arm_process_before_allocation \
51 bfd_${EMULATION_NAME}_process_before_allocation
52 #endif
54 #include "sysdep.h"
55 #include "bfd.h"
56 #include "bfdlink.h"
57 #include "getopt.h"
58 #include "libiberty.h"
59 #include "ld.h"
60 #include "ldmain.h"
61 #include "ldexp.h"
62 #include "ldlang.h"
63 #include "ldfile.h"
64 #include "ldemul.h"
65 #include <ldgram.h>
66 #include "ldlex.h"
67 #include "ldmisc.h"
68 #include "ldctor.h"
69 #include "coff/internal.h"
71 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
72 header in generic PE code. */
73 #include "coff/i386.h"
74 #include "coff/pe.h"
76 /* FIXME: This is a BFD internal header file, and we should not be
77 using it here. */
78 #include "../bfd/libcoff.h"
80 #include "deffile.h"
81 #include "pe-dll.h"
82 #include "safe-ctype.h"
84 /* Permit the emulation parameters to override the default section
85 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes
86 it seem that include/coff/internal.h should not define
87 PE_DEF_SECTION_ALIGNMENT. */
88 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
89 #undef PE_DEF_SECTION_ALIGNMENT
90 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
91 #endif
93 #if defined(TARGET_IS_i386pe) \
94 || defined(TARGET_IS_shpe) \
95 || defined(TARGET_IS_mipspe) \
96 || defined(TARGET_IS_armpe) \
97 || defined(TARGET_IS_arm_epoc_pe) \
98 || defined(TARGET_IS_arm_wince_pe)
99 #define DLL_SUPPORT
100 #endif
102 #if defined(TARGET_IS_i386pe)
103 #define DEFAULT_PSEUDO_RELOC_VERSION 2
104 #else
105 #define DEFAULT_PSEUDO_RELOC_VERSION 1
106 #endif
108 #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
109 #define PE_DEF_SUBSYSTEM 3
110 #else
111 #undef NT_EXE_IMAGE_BASE
112 #undef PE_DEF_SECTION_ALIGNMENT
113 #undef PE_DEF_FILE_ALIGNMENT
114 #define NT_EXE_IMAGE_BASE 0x00010000
116 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
117 #define PE_DEF_SECTION_ALIGNMENT 0x00001000
118 #define PE_DEF_SUBSYSTEM 9
119 #else
120 #define PE_DEF_SECTION_ALIGNMENT 0x00000400
121 #define PE_DEF_SUBSYSTEM 2
122 #endif
123 #define PE_DEF_FILE_ALIGNMENT 0x00000200
124 #endif
126 #define U(S) ${INITIAL_SYMBOL_CHAR} S
128 static struct internal_extra_pe_aouthdr pe;
129 static int dll;
130 static int pe_subsystem = ${SUBSYSTEM};
131 static flagword real_flags = 0;
132 static int support_old_code = 0;
133 static char * thumb_entry_symbol = NULL;
134 static lang_assignment_statement_type *image_base_statement = 0;
135 static unsigned short pe_dll_characteristics = 0;
137 #ifdef DLL_SUPPORT
138 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable. */
139 static char *pe_out_def_filename = NULL;
140 static char *pe_implib_filename = NULL;
141 static int pe_enable_auto_image_base = 0;
142 static char *pe_dll_search_prefix = NULL;
143 #endif
145 extern const char *output_filename;
147 static void
148 gld_${EMULATION_NAME}_before_parse (void)
149 {
150 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
151 output_filename = "${EXECUTABLE_NAME:-a.exe}";
152 #ifdef DLL_SUPPORT
153 config.dynamic_link = TRUE;
154 config.has_shared = 1;
155 EOF
157 # Cygwin no longer wants these noisy warnings. Other PE
158 # targets might like to consider adding themselves here.
159 case ${target} in
160 *-*-cygwin*)
161 default_auto_import=1
162 ;;
163 *)
164 default_auto_import=-1
165 ;;
166 esac
168 fragment <<EOF
169 link_info.pei386_auto_import = ${default_auto_import};
170 /* Use by default version. */
171 link_info.pei386_runtime_pseudo_reloc = DEFAULT_PSEUDO_RELOC_VERSION;
172 #endif
173 }
174 \f
175 /* PE format extra command line options. */
177 /* Used for setting flags in the PE header. */
178 #define OPTION_BASE_FILE (300 + 1)
179 #define OPTION_DLL (OPTION_BASE_FILE + 1)
180 #define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
181 #define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
182 #define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
183 #define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
184 #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
185 #define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
186 #define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
187 #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
188 #define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
189 #define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
190 #define OPTION_SUBSYSTEM (OPTION_STACK + 1)
191 #define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
192 #define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
193 #define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
194 #define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
195 #define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
196 #define OPTION_EXCLUDE_ALL_SYMBOLS (OPTION_EXCLUDE_SYMBOLS + 1)
197 #define OPTION_KILL_ATS (OPTION_EXCLUDE_ALL_SYMBOLS + 1)
198 #define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
199 #define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
200 #define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
201 #define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
202 #define OPTION_THUMB_ENTRY (OPTION_IMPLIB_FILENAME + 1)
203 #define OPTION_WARN_DUPLICATE_EXPORTS (OPTION_THUMB_ENTRY + 1)
204 #define OPTION_IMP_COMPAT (OPTION_WARN_DUPLICATE_EXPORTS + 1)
205 #define OPTION_ENABLE_AUTO_IMAGE_BASE (OPTION_IMP_COMPAT + 1)
206 #define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
207 #define OPTION_DLL_SEARCH_PREFIX (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
208 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_DLL_SEARCH_PREFIX + 1)
209 #define OPTION_DLL_ENABLE_AUTO_IMPORT (OPTION_NO_DEFAULT_EXCLUDES + 1)
210 #define OPTION_DLL_DISABLE_AUTO_IMPORT (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
211 #define OPTION_ENABLE_EXTRA_PE_DEBUG (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
212 #define OPTION_EXCLUDE_LIBS (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)
213 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC \
214 (OPTION_EXCLUDE_LIBS + 1)
215 #define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC \
216 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)
217 #define OPTION_LARGE_ADDRESS_AWARE \
218 (OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC + 1)
219 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1 \
220 (OPTION_LARGE_ADDRESS_AWARE + 1)
221 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2 \
222 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1 + 1)
223 #define OPTION_EXCLUDE_MODULES_FOR_IMPLIB \
224 (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2 + 1)
225 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \
226 (OPTION_EXCLUDE_MODULES_FOR_IMPLIB + 1)
227 #define OPTION_ENABLE_LONG_SECTION_NAMES \
228 (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1)
229 #define OPTION_DISABLE_LONG_SECTION_NAMES \
230 (OPTION_ENABLE_LONG_SECTION_NAMES + 1)
231 /* DLLCharacteristics flags */
232 #define OPTION_DYNAMIC_BASE (OPTION_DISABLE_LONG_SECTION_NAMES + 1)
233 #define OPTION_FORCE_INTEGRITY (OPTION_DYNAMIC_BASE + 1)
234 #define OPTION_NX_COMPAT (OPTION_FORCE_INTEGRITY + 1)
235 #define OPTION_NO_ISOLATION (OPTION_NX_COMPAT + 1)
236 #define OPTION_NO_SEH (OPTION_NO_ISOLATION + 1)
237 #define OPTION_NO_BIND (OPTION_NO_SEH + 1)
238 #define OPTION_WDM_DRIVER (OPTION_NO_BIND + 1)
239 #define OPTION_TERMINAL_SERVER_AWARE (OPTION_WDM_DRIVER + 1)
241 static void
242 gld${EMULATION_NAME}_add_options
243 (int ns ATTRIBUTE_UNUSED,
244 char **shortopts ATTRIBUTE_UNUSED,
245 int nl,
246 struct option **longopts,
247 int nrl ATTRIBUTE_UNUSED,
248 struct option **really_longopts ATTRIBUTE_UNUSED)
249 {
250 static const struct option xtra_long[] = {
251 /* PE options */
252 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
253 {"dll", no_argument, NULL, OPTION_DLL},
254 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
255 {"heap", required_argument, NULL, OPTION_HEAP},
256 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
257 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
258 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
259 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
260 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
261 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
262 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
263 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
264 {"stack", required_argument, NULL, OPTION_STACK},
265 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
266 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
267 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
268 {"use-nul-prefixed-import-tables", no_argument, NULL,
269 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
270 #ifdef DLL_SUPPORT
271 /* getopt allows abbreviations, so we do this to stop it
272 from treating -o as an abbreviation for this option. */
273 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
274 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
275 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
276 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
277 {"exclude-all-symbols", no_argument, NULL, OPTION_EXCLUDE_ALL_SYMBOLS},
278 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
279 {"exclude-modules-for-implib", required_argument, NULL, OPTION_EXCLUDE_MODULES_FOR_IMPLIB},
280 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
281 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
282 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
283 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
284 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
285 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
286 /* getopt() allows abbreviations, so we do this to stop it from
287 treating -c as an abbreviation for these --compat-implib. */
288 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
289 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
290 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
291 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
292 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
293 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
294 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
295 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
296 {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
297 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
298 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
299 {"enable-runtime-pseudo-reloc-v1", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1},
300 {"enable-runtime-pseudo-reloc-v2", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2},
301 #endif
302 {"large-address-aware", no_argument, NULL, OPTION_LARGE_ADDRESS_AWARE},
303 {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES},
304 {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES},
305 {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE},
306 {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY},
307 {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT},
308 {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION},
309 {"no-seh", no_argument, NULL, OPTION_NO_SEH},
310 {"no-bind", no_argument, NULL, OPTION_NO_BIND},
311 {"wdmdriver", no_argument, NULL, OPTION_WDM_DRIVER},
312 {"tsaware", no_argument, NULL, OPTION_TERMINAL_SERVER_AWARE},
313 {NULL, no_argument, NULL, 0}
314 };
316 *longopts
317 = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
318 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
319 }
321 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
322 parameters which may be input from the command line. */
324 typedef struct
325 {
326 void *ptr;
327 int size;
328 int value;
329 char *symbol;
330 int inited;
331 } definfo;
333 #define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
335 static definfo init[] =
336 {
337 /* imagebase must be first */
338 #define IMAGEBASEOFF 0
339 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
340 #define DLLOFF 1
341 {&dll, sizeof(dll), 0, "__dll__", 0},
342 #define MSIMAGEBASEOFF 2
343 D(ImageBase, U ("__ImageBase"), NT_EXE_IMAGE_BASE),
344 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
345 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
346 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
347 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
348 D(MajorImageVersion,"__major_image_version__", 1),
349 D(MinorImageVersion,"__minor_image_version__", 0),
350 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
351 D(MajorSubsystemVersion,"__major_subsystem_version__", 3),
352 #else
353 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
354 #endif
355 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
356 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
357 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
358 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
359 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
360 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
361 D(LoaderFlags,"__loader_flags__", 0x0),
362 D(DllCharacteristics, "__dll_characteristics__", 0x0),
363 { NULL, 0, 0, NULL, 0 }
364 };
367 static void
368 gld_${EMULATION_NAME}_list_options (FILE *file)
369 {
370 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
371 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
372 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
373 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
374 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
375 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
376 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
377 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
378 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
379 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
380 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
381 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
382 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
383 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
384 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
385 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n"));
386 #ifdef DLL_SUPPORT
387 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
388 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
389 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
390 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
391 fprintf (file, _(" --exclude-all-symbols Exclude all symbols from automatic export\n"));
392 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n"));
393 fprintf (file, _(" --exclude-modules-for-implib mod,mod,...\n"));
394 fprintf (file, _(" Exclude objects, archive members from auto\n"));
395 fprintf (file, _(" export, place into import library instead.\n"));
396 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
397 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
398 fprintf (file, _(" --out-implib <file> Generate import library\n"));
399 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
400 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
401 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\
402 create __imp_<SYMBOL> as well.\n"));
403 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n\
404 unless user specifies one\n"));
405 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
406 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\
407 an importlib, use <string><basename>.dll\n\
408 in preference to lib<basename>.dll \n"));
409 fprintf (file, _(" --enable-auto-import Do sophistcated linking of _sym to\n\
410 __imp_sym for DATA references\n"));
411 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n"));
412 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\
413 adding pseudo-relocations resolved at\n\
414 runtime.\n"));
415 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\
416 auto-imported DATA.\n"));
417 fprintf (file, _(" --enable-extra-pe-debug Enable verbose debug output when building\n\
418 or linking to DLLs (esp. auto-import)\n"));
419 #endif
420 fprintf (file, _(" --large-address-aware Executable supports virtual addresses\n\
421 greater than 2 gigabytes\n"));
422 fprintf (file, _(" --enable-long-section-names Use long COFF section names even in\n\
423 executable image files\n"));
424 fprintf (file, _(" --disable-long-section-names Never use long COFF section names, even\n\
425 in object files\n"));
426 fprintf (file, _(" --dynamicbase Image base address may be relocated using\n\
427 address space layout randomization (ASLR)\n"));
428 fprintf (file, _(" --forceinteg Code integrity checks are enforced\n"));
429 fprintf (file, _(" --nxcompat Image is compatible with data execution prevention\n"));
430 fprintf (file, _(" --no-isolation Image understands isolation but do not isolate the image\n"));
431 fprintf (file, _(" --no-seh Image does not use SEH. No SE handler may\n\
432 be called in this image\n"));
433 fprintf (file, _(" --no-bind Do not bind this image\n"));
434 fprintf (file, _(" --wdmdriver Driver uses the WDM model\n"));
435 fprintf (file, _(" --tsaware Image is Terminal Server aware\n"));
436 }
439 static void
440 set_pe_name (char *name, long val)
441 {
442 int i;
444 /* Find the name and set it. */
445 for (i = 0; init[i].ptr; i++)
446 {
447 if (strcmp (name, init[i].symbol) == 0)
448 {
449 init[i].value = val;
450 init[i].inited = 1;
451 if (strcmp (name,"__image_base__") == 0)
452 set_pe_name (U ("__ImageBase"), val);
453 return;
454 }
455 }
456 abort ();
457 }
459 static void
460 set_entry_point (void)
461 {
462 const char *entry;
463 const char *initial_symbol_char;
464 int i;
466 static const struct
467 {
468 const int value;
469 const char *entry;
470 }
471 v[] =
472 {
473 { 1, "NtProcessStartup" },
474 { 2, "WinMainCRTStartup" },
475 { 3, "mainCRTStartup" },
476 { 7, "__PosixProcessStartup"},
477 { 9, "WinMainCRTStartup" },
478 {14, "mainCRTStartup" },
479 { 0, NULL }
480 };
482 /* Entry point name for arbitrary subsystem numbers. */
483 static const char default_entry[] = "mainCRTStartup";
485 if (link_info.shared || dll)
486 {
487 #if defined (TARGET_IS_i386pe)
488 entry = "DllMainCRTStartup@12";
489 #else
490 entry = "DllMainCRTStartup";
491 #endif
492 }
493 else
494 {
496 for (i = 0; v[i].entry; i++)
497 if (v[i].value == pe_subsystem)
498 break;
500 /* If no match, use the default. */
501 if (v[i].entry != NULL)
502 entry = v[i].entry;
503 else
504 entry = default_entry;
505 }
507 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
508 if (*initial_symbol_char != '\0')
509 {
510 char *alc_entry;
512 /* lang_default_entry expects its argument to be permanently
513 allocated, so we don't free this string. */
514 alc_entry = xmalloc (strlen (initial_symbol_char)
515 + strlen (entry)
516 + 1);
517 strcpy (alc_entry, initial_symbol_char);
518 strcat (alc_entry, entry);
519 entry = alc_entry;
520 }
522 lang_default_entry (entry);
523 }
525 static void
526 set_pe_subsystem (void)
527 {
528 const char *sver;
529 char *end;
530 int len;
531 int i;
532 unsigned long temp_subsystem;
533 static const struct
534 {
535 const char *name;
536 const int value;
537 }
538 v[] =
539 {
540 { "native", 1},
541 { "windows", 2},
542 { "console", 3},
543 { "posix", 7},
544 { "wince", 9},
545 { "xbox", 14},
546 { NULL, 0 }
547 };
549 /* Check for the presence of a version number. */
550 sver = strchr (optarg, ':');
551 if (sver == NULL)
552 len = strlen (optarg);
553 else
554 {
555 len = sver - optarg;
556 set_pe_name ("__major_subsystem_version__",
557 strtoul (sver + 1, &end, 0));
558 if (*end == '.')
559 set_pe_name ("__minor_subsystem_version__",
560 strtoul (end + 1, &end, 0));
561 if (*end != '\0')
562 einfo (_("%P: warning: bad version number in -subsystem option\n"));
563 }
565 /* Check for numeric subsystem. */
566 temp_subsystem = strtoul (optarg, & end, 0);
567 if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
568 {
569 /* Search list for a numeric match to use its entry point. */
570 for (i = 0; v[i].name; i++)
571 if (v[i].value == (int) temp_subsystem)
572 break;
574 /* Use this subsystem. */
575 pe_subsystem = (int) temp_subsystem;
576 }
577 else
578 {
579 /* Search for subsystem by name. */
580 for (i = 0; v[i].name; i++)
581 if (strncmp (optarg, v[i].name, len) == 0
582 && v[i].name[len] == '\0')
583 break;
585 if (v[i].name == NULL)
586 {
587 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
588 return;
589 }
591 pe_subsystem = v[i].value;
592 }
594 set_pe_name ("__subsystem__", pe_subsystem);
596 return;
597 }
600 static void
601 set_pe_value (char *name)
602 {
603 char *end;
605 set_pe_name (name, strtoul (optarg, &end, 0));
607 if (end == optarg)
608 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
610 optarg = end;
611 }
614 static void
615 set_pe_stack_heap (char *resname, char *comname)
616 {
617 set_pe_value (resname);
619 if (*optarg == ',')
620 {
621 optarg++;
622 set_pe_value (comname);
623 }
624 else if (*optarg)
625 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
626 }
629 static bfd_boolean
630 gld${EMULATION_NAME}_handle_option (int optc)
631 {
632 switch (optc)
633 {
634 default:
635 return FALSE;
637 case OPTION_BASE_FILE:
638 link_info.base_file = fopen (optarg, FOPEN_WB);
639 if (link_info.base_file == NULL)
640 {
641 /* xgettext:c-format */
642 fprintf (stderr, _("%s: Can't open base file %s\n"),
643 program_name, optarg);
644 xexit (1);
645 }
646 break;
648 /* PE options. */
649 case OPTION_HEAP:
650 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
651 break;
652 case OPTION_STACK:
653 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
654 break;
655 case OPTION_SUBSYSTEM:
656 set_pe_subsystem ();
657 break;
658 case OPTION_MAJOR_OS_VERSION:
659 set_pe_value ("__major_os_version__");
660 break;
661 case OPTION_MINOR_OS_VERSION:
662 set_pe_value ("__minor_os_version__");
663 break;
664 case OPTION_MAJOR_SUBSYSTEM_VERSION:
665 set_pe_value ("__major_subsystem_version__");
666 break;
667 case OPTION_MINOR_SUBSYSTEM_VERSION:
668 set_pe_value ("__minor_subsystem_version__");
669 break;
670 case OPTION_MAJOR_IMAGE_VERSION:
671 set_pe_value ("__major_image_version__");
672 break;
673 case OPTION_MINOR_IMAGE_VERSION:
674 set_pe_value ("__minor_image_version__");
675 break;
676 case OPTION_FILE_ALIGNMENT:
677 set_pe_value ("__file_alignment__");
678 break;
679 case OPTION_SECTION_ALIGNMENT:
680 set_pe_value ("__section_alignment__");
681 break;
682 case OPTION_DLL:
683 set_pe_name ("__dll__", 1);
684 break;
685 case OPTION_IMAGE_BASE:
686 set_pe_value ("__image_base__");
687 break;
688 case OPTION_SUPPORT_OLD_CODE:
689 support_old_code = 1;
690 break;
691 case OPTION_THUMB_ENTRY:
692 thumb_entry_symbol = optarg;
693 break;
694 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
695 pe_use_nul_prefixed_import_tables = TRUE;
696 break;
697 #ifdef DLL_SUPPORT
698 case OPTION_OUT_DEF:
699 pe_out_def_filename = xstrdup (optarg);
700 break;
701 case OPTION_EXPORT_ALL:
702 pe_dll_export_everything = 1;
703 break;
704 case OPTION_EXCLUDE_SYMBOLS:
705 pe_dll_add_excludes (optarg, EXCLUDESYMS);
706 break;
707 case OPTION_EXCLUDE_ALL_SYMBOLS:
708 pe_dll_exclude_all_symbols = 1;
709 break;
710 case OPTION_EXCLUDE_LIBS:
711 pe_dll_add_excludes (optarg, EXCLUDELIBS);
712 break;
713 case OPTION_EXCLUDE_MODULES_FOR_IMPLIB:
714 pe_dll_add_excludes (optarg, EXCLUDEFORIMPLIB);
715 break;
716 case OPTION_KILL_ATS:
717 pe_dll_kill_ats = 1;
718 break;
719 case OPTION_STDCALL_ALIASES:
720 pe_dll_stdcall_aliases = 1;
721 break;
722 case OPTION_ENABLE_STDCALL_FIXUP:
723 pe_enable_stdcall_fixup = 1;
724 break;
725 case OPTION_DISABLE_STDCALL_FIXUP:
726 pe_enable_stdcall_fixup = 0;
727 break;
728 case OPTION_IMPLIB_FILENAME:
729 pe_implib_filename = xstrdup (optarg);
730 break;
731 case OPTION_WARN_DUPLICATE_EXPORTS:
732 pe_dll_warn_dup_exports = 1;
733 break;
734 case OPTION_IMP_COMPAT:
735 pe_dll_compat_implib = 1;
736 break;
737 case OPTION_ENABLE_AUTO_IMAGE_BASE:
738 pe_enable_auto_image_base = 1;
739 break;
740 case OPTION_DISABLE_AUTO_IMAGE_BASE:
741 pe_enable_auto_image_base = 0;
742 break;
743 case OPTION_DLL_SEARCH_PREFIX:
744 pe_dll_search_prefix = xstrdup (optarg);
745 break;
746 case OPTION_NO_DEFAULT_EXCLUDES:
747 pe_dll_do_default_excludes = 0;
748 break;
749 case OPTION_DLL_ENABLE_AUTO_IMPORT:
750 link_info.pei386_auto_import = 1;
751 break;
752 case OPTION_DLL_DISABLE_AUTO_IMPORT:
753 link_info.pei386_auto_import = 0;
754 break;
755 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
756 link_info.pei386_runtime_pseudo_reloc =
757 DEFAULT_PSEUDO_RELOC_VERSION;
758 break;
759 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1:
760 link_info.pei386_runtime_pseudo_reloc = 1;
761 break;
762 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2:
763 link_info.pei386_runtime_pseudo_reloc = 2;
764 break;
765 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
766 link_info.pei386_runtime_pseudo_reloc = 0;
767 break;
768 case OPTION_ENABLE_EXTRA_PE_DEBUG:
769 pe_dll_extra_pe_debug = 1;
770 break;
771 #endif
772 case OPTION_LARGE_ADDRESS_AWARE:
773 real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
774 break;
775 case OPTION_ENABLE_LONG_SECTION_NAMES:
776 pe_use_coff_long_section_names = 1;
777 break;
778 case OPTION_DISABLE_LONG_SECTION_NAMES:
779 pe_use_coff_long_section_names = 0;
780 break;
781 /* Get DLLCharacteristics bits */
782 case OPTION_DYNAMIC_BASE:
783 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
784 break;
785 case OPTION_FORCE_INTEGRITY:
786 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
787 break;
788 case OPTION_NX_COMPAT:
789 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
790 break;
791 case OPTION_NO_ISOLATION:
792 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
793 break;
794 case OPTION_NO_SEH:
795 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_SEH;
796 break;
797 case OPTION_NO_BIND:
798 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_BIND;
799 break;
800 case OPTION_WDM_DRIVER:
801 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_WDM_DRIVER;
802 break;
803 case OPTION_TERMINAL_SERVER_AWARE:
804 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE;
805 break;
806 }
808 /* Set DLLCharacteristics bits */
809 set_pe_name ("__dll_characteristics__", pe_dll_characteristics);
811 return TRUE;
812 }
813 \f
815 #ifdef DLL_SUPPORT
816 static unsigned long
817 strhash (const char *str)
818 {
819 const unsigned char *s;
820 unsigned long hash;
821 unsigned int c;
822 unsigned int len;
824 hash = 0;
825 len = 0;
826 s = (const unsigned char *) str;
827 while ((c = *s++) != '\0')
828 {
829 hash += c + (c << 17);
830 hash ^= hash >> 2;
831 ++len;
832 }
833 hash += len + (len << 17);
834 hash ^= hash >> 2;
836 return hash;
837 }
839 /* Use the output file to create a image base for relocatable DLLs. */
841 static unsigned long
842 compute_dll_image_base (const char *ofile)
843 {
844 unsigned long hash = strhash (ofile);
845 return 0x61300000 + ((hash << 16) & 0x0FFC0000);
846 }
847 #endif
849 /* Assign values to the special symbols before the linker script is
850 read. */
852 static void
853 gld_${EMULATION_NAME}_set_symbols (void)
854 {
855 /* Run through and invent symbols for all the
856 names and insert the defaults. */
857 int j;
859 if (!init[IMAGEBASEOFF].inited)
860 {
861 if (link_info.relocatable)
862 init[IMAGEBASEOFF].value = 0;
863 else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
864 {
865 #ifdef DLL_SUPPORT
866 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base
867 ? compute_dll_image_base (output_filename)
868 : NT_DLL_IMAGE_BASE);
869 #else
870 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
871 #endif
872 }
873 else
874 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
875 init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value;
876 }
878 /* Don't do any symbol assignments if this is a relocatable link. */
879 if (link_info.relocatable)
880 return;
882 /* Glue the assignments into the abs section. */
883 push_stat_ptr (&abs_output_section->children);
885 for (j = 0; init[j].ptr; j++)
886 {
887 long val = init[j].value;
888 lang_assignment_statement_type *rv;
889 rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
890 exp_intop (val)));
891 if (init[j].size == sizeof (short))
892 *(short *) init[j].ptr = val;
893 else if (init[j].size == sizeof (int))
894 *(int *) init[j].ptr = val;
895 else if (init[j].size == sizeof (long))
896 *(long *) init[j].ptr = val;
897 /* This might be a long long or other special type. */
898 else if (init[j].size == sizeof (bfd_vma))
899 *(bfd_vma *) init[j].ptr = val;
900 else abort ();
901 if (j == IMAGEBASEOFF)
902 image_base_statement = rv;
903 }
904 /* Restore the pointer. */
905 pop_stat_ptr ();
907 if (pe.FileAlignment > pe.SectionAlignment)
908 {
909 einfo (_("%P: warning, file alignment > section alignment.\n"));
910 }
911 }
913 /* This is called after the linker script and the command line options
914 have been read. */
916 static void
917 gld_${EMULATION_NAME}_after_parse (void)
918 {
919 /* PR ld/6744: Warn the user if they have used an ELF-only
920 option hoping it will work on PE. */
921 if (link_info.export_dynamic)
922 einfo (_("%P: warning: --export-dynamic is not supported for PE "
923 "targets, did you mean --export-all-symbols?\n"));
925 set_entry_point ();
927 after_parse_default ();
928 }
930 /* pe-dll.c directly accesses pe_data_import_dll,
931 so it must be defined outside of #ifdef DLL_SUPPORT.
932 Note - this variable is deliberately not initialised.
933 This allows it to be treated as a common varaible, and only
934 exist in one incarnation in a multiple target enabled linker. */
935 char * pe_data_import_dll;
937 #ifdef DLL_SUPPORT
938 static struct bfd_link_hash_entry *pe_undef_found_sym;
940 static bfd_boolean
941 pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
942 {
943 int sl;
944 char *string = inf;
945 const char *hs = h->root.string;
947 sl = strlen (string);
948 if (h->type == bfd_link_hash_defined
949 && ((*hs == '@' && *string == '_'
950 && strncmp (hs + 1, string + 1, sl - 1) == 0)
951 || strncmp (hs, string, sl) == 0)
952 && h->root.string[sl] == '@')
953 {
954 pe_undef_found_sym = h;
955 return FALSE;
956 }
957 return TRUE;
958 }
960 static void
961 pe_fixup_stdcalls (void)
962 {
963 static int gave_warning_message = 0;
964 struct bfd_link_hash_entry *undef, *sym;
966 if (pe_dll_extra_pe_debug)
967 printf ("%s\n", __FUNCTION__);
969 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
970 if (undef->type == bfd_link_hash_undefined)
971 {
972 char* at = strchr (undef->root.string, '@');
973 int lead_at = (*undef->root.string == '@');
974 if (lead_at)
975 at = strchr (undef->root.string + 1, '@');
977 if (at || lead_at)
978 {
979 /* The symbol is a stdcall symbol, so let's look for a
980 cdecl symbol with the same name and resolve to that. */
981 char *cname = xstrdup (undef->root.string);
983 if (lead_at)
984 *cname = '_';
985 at = strchr (cname, '@');
986 if (at)
987 *at = 0;
988 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
990 if (sym && sym->type == bfd_link_hash_defined)
991 {
992 undef->type = bfd_link_hash_defined;
993 undef->u.def.value = sym->u.def.value;
994 undef->u.def.section = sym->u.def.section;
996 if (pe_enable_stdcall_fixup == -1)
997 {
998 einfo (_("Warning: resolving %s by linking to %s\n"),
999 undef->root.string, cname);
1000 if (! gave_warning_message)
1001 {
1002 gave_warning_message = 1;
1003 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
1004 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
1005 }
1006 }
1007 }
1008 }
1009 else
1010 {
1011 /* The symbol is a cdecl symbol, so we look for stdcall
1012 symbols - which means scanning the whole symbol table. */
1013 pe_undef_found_sym = 0;
1014 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
1015 (char *) undef->root.string);
1016 sym = pe_undef_found_sym;
1017 if (sym)
1018 {
1019 undef->type = bfd_link_hash_defined;
1020 undef->u.def.value = sym->u.def.value;
1021 undef->u.def.section = sym->u.def.section;
1023 if (pe_enable_stdcall_fixup == -1)
1024 {
1025 einfo (_("Warning: resolving %s by linking to %s\n"),
1026 undef->root.string, sym->root.string);
1027 if (! gave_warning_message)
1028 {
1029 gave_warning_message = 1;
1030 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
1031 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
1032 }
1033 }
1034 }
1035 }
1036 }
1037 }
1039 static int
1040 make_import_fixup (arelent *rel, asection *s)
1041 {
1042 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
1043 char addend[4];
1045 if (pe_dll_extra_pe_debug)
1046 printf ("arelent: %s@%#lx: add=%li\n", sym->name,
1047 (unsigned long) rel->address, (long) rel->addend);
1049 if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))
1050 einfo (_("%C: Cannot get section contents - auto-import exception\n"),
1051 s->owner, s, rel->address);
1053 pe_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend));
1055 return 1;
1056 }
1058 static void
1059 pe_find_data_imports (void)
1060 {
1061 struct bfd_link_hash_entry *undef, *sym;
1063 if (link_info.pei386_auto_import == 0)
1064 return;
1066 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
1067 {
1068 if (undef->type == bfd_link_hash_undefined)
1069 {
1070 /* C++ symbols are *long*. */
1071 char buf[4096];
1073 if (pe_dll_extra_pe_debug)
1074 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
1076 sprintf (buf, "__imp_%s", undef->root.string);
1078 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
1080 if (sym && sym->type == bfd_link_hash_defined)
1081 {
1082 bfd *b = sym->u.def.section->owner;
1083 asymbol **symbols;
1084 int nsyms, i;
1086 if (link_info.pei386_auto_import == -1)
1087 {
1088 static bfd_boolean warned = FALSE;
1090 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
1091 undef->root.string, buf);
1093 /* PR linker/4844. */
1094 if (! warned)
1095 {
1096 warned = TRUE;
1097 einfo (_("%P: warning: auto-importing has been activated without --enable-auto-import specified on the command line.\n\
1098 This should work unless it involves constant data structures referencing symbols from auto-imported DLLs.\n"));
1099 }
1100 }
1102 if (!bfd_generic_link_read_symbols (b))
1103 {
1104 einfo (_("%B%F: could not read symbols: %E\n"), b);
1105 return;
1106 }
1108 symbols = bfd_get_outsymbols (b);
1109 nsyms = bfd_get_symcount (b);
1111 for (i = 0; i < nsyms; i++)
1112 {
1113 if (! CONST_STRNEQ (symbols[i]->name, U ("_head_")))
1114 continue;
1116 if (pe_dll_extra_pe_debug)
1117 printf ("->%s\n", symbols[i]->name);
1119 pe_data_import_dll = (char*) (symbols[i]->name +
1120 sizeof (U ("_head_")) - 1);
1121 break;
1122 }
1124 pe_walk_relocs_of_symbol (&link_info, undef->root.string,
1125 make_import_fixup);
1127 /* Let's differentiate it somehow from defined. */
1128 undef->type = bfd_link_hash_defweak;
1129 /* We replace original name with __imp_ prefixed, this
1130 1) may trash memory 2) leads to duplicate symbol generation.
1131 Still, IMHO it's better than having name poluted. */
1132 undef->root.string = sym->root.string;
1133 undef->u.def.value = sym->u.def.value;
1134 undef->u.def.section = sym->u.def.section;
1135 }
1136 }
1137 }
1138 }
1140 static bfd_boolean
1141 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
1142 {
1143 if (pe_dll_extra_pe_debug)
1144 printf ("+%s\n", h->string);
1146 return TRUE;
1147 }
1148 #endif /* DLL_SUPPORT */
1150 static void
1151 debug_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
1152 {
1153 int *found = (int *) obj;
1154 if (strncmp (".debug_", sect->name, sizeof (".debug_") - 1) == 0)
1155 *found = 1;
1156 }
1158 static void
1159 gld_${EMULATION_NAME}_after_open (void)
1160 {
1161 #ifdef DLL_SUPPORT
1162 if (pe_dll_extra_pe_debug)
1163 {
1164 bfd *a;
1165 struct bfd_link_hash_entry *sym;
1167 printf ("%s()\n", __FUNCTION__);
1169 for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
1170 printf ("-%s\n", sym->root.string);
1171 bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
1173 for (a = link_info.input_bfds; a; a = a->link_next)
1174 printf ("*%s\n",a->filename);
1175 }
1176 #endif
1178 /* Pass the wacky PE command line options into the output bfd.
1179 FIXME: This should be done via a function, rather than by
1180 including an internal BFD header. */
1182 if (coff_data (link_info.output_bfd) == NULL
1183 || coff_data (link_info.output_bfd)->pe == 0)
1184 einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"),
1185 link_info.output_bfd);
1187 pe_data (link_info.output_bfd)->pe_opthdr = pe;
1188 pe_data (link_info.output_bfd)->dll = init[DLLOFF].value;
1189 pe_data (link_info.output_bfd)->real_flags |= real_flags;
1191 /* At this point we must decide whether to use long section names
1192 in the output or not. If the user hasn't explicitly specified
1193 on the command line, we leave it to the default for the format
1194 (object files yes, image files no), except if there is debug
1195 information present; GDB relies on the long section names to
1196 find it, so enable it in that case. */
1197 if (pe_use_coff_long_section_names < 0 && link_info.strip == strip_none)
1198 {
1199 /* Iterate over all sections of all input BFDs, checking
1200 for any that begin 'debug_' and are long names. */
1201 LANG_FOR_EACH_INPUT_STATEMENT (is)
1202 {
1203 int found_debug = 0;
1204 bfd_map_over_sections (is->the_bfd, debug_section_p, &found_debug);
1205 if (found_debug)
1206 {
1207 pe_use_coff_long_section_names = 1;
1208 break;
1209 }
1210 }
1211 }
1213 pe_output_file_set_long_section_names (link_info.output_bfd);
1215 #ifdef DLL_SUPPORT
1216 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
1217 pe_fixup_stdcalls ();
1219 pe_process_import_defs (link_info.output_bfd, &link_info);
1221 pe_find_data_imports ();
1223 /* As possibly new symbols are added by imports, we rerun
1224 stdcall/fastcall fixup here. */
1225 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
1226 pe_fixup_stdcalls ();
1228 #if defined (TARGET_IS_i386pe) \
1229 || defined (TARGET_IS_armpe) \
1230 || defined (TARGET_IS_arm_epoc_pe) \
1231 || defined (TARGET_IS_arm_wince_pe)
1232 if (!link_info.relocatable)
1233 pe_dll_build_sections (link_info.output_bfd, &link_info);
1234 #else
1235 if (link_info.shared)
1236 pe_dll_build_sections (link_info.output_bfd, &link_info);
1237 else
1238 pe_exe_build_sections (link_info.output_bfd, &link_info);
1239 #endif
1240 #endif /* DLL_SUPPORT */
1242 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1243 if (strstr (bfd_get_target (link_info.output_bfd), "arm") == NULL)
1244 {
1245 /* The arm backend needs special fields in the output hash structure.
1246 These will only be created if the output format is an arm format,
1247 hence we do not support linking and changing output formats at the
1248 same time. Use a link followed by objcopy to change output formats. */
1249 einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
1250 return;
1251 }
1252 {
1253 /* Find a BFD that can hold the interworking stubs. */
1254 LANG_FOR_EACH_INPUT_STATEMENT (is)
1255 {
1256 if (bfd_arm_get_bfd_for_interworking (is->the_bfd, & link_info))
1257 break;
1258 }
1259 }
1260 #endif
1262 {
1263 /* This next chunk of code tries to detect the case where you have
1264 two import libraries for the same DLL (specifically,
1265 symbolically linking libm.a and libc.a in cygwin to
1266 libcygwin.a). In those cases, it's possible for function
1267 thunks from the second implib to be used but without the
1268 head/tail objects, causing an improper import table. We detect
1269 those cases and rename the "other" import libraries to match
1270 the one the head/tail come from, so that the linker will sort
1271 things nicely and produce a valid import table. */
1273 LANG_FOR_EACH_INPUT_STATEMENT (is)
1274 {
1275 if (is->the_bfd->my_archive)
1276 {
1277 int idata2 = 0, reloc_count=0, is_imp = 0;
1278 asection *sec;
1280 /* See if this is an import library thunk. */
1281 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1282 {
1283 if (strcmp (sec->name, ".idata\$2") == 0)
1284 idata2 = 1;
1285 if (CONST_STRNEQ (sec->name, ".idata\$"))
1286 is_imp = 1;
1287 reloc_count += sec->reloc_count;
1288 }
1290 if (is_imp && !idata2 && reloc_count)
1291 {
1292 /* It is, look for the reference to head and see if it's
1293 from our own library. */
1294 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1295 {
1296 int i;
1297 long relsize;
1298 asymbol **symbols;
1299 arelent **relocs;
1300 int nrelocs;
1302 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1303 if (relsize < 1)
1304 break;
1306 if (!bfd_generic_link_read_symbols (is->the_bfd))
1307 {
1308 einfo (_("%B%F: could not read symbols: %E\n"),
1309 is->the_bfd);
1310 return;
1311 }
1312 symbols = bfd_get_outsymbols (is->the_bfd);
1314 relocs = xmalloc ((size_t) relsize);
1315 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1316 relocs, symbols);
1317 if (nrelocs < 0)
1318 {
1319 free (relocs);
1320 einfo ("%X%P: unable to process relocs: %E\n");
1321 return;
1322 }
1324 for (i = 0; i < nrelocs; i++)
1325 {
1326 struct bfd_symbol *s;
1327 struct bfd_link_hash_entry * blhe;
1328 char *other_bfd_filename;
1329 char *n;
1331 s = (relocs[i]->sym_ptr_ptr)[0];
1333 if (s->flags & BSF_LOCAL)
1334 continue;
1336 /* Thunk section with reloc to another bfd. */
1337 blhe = bfd_link_hash_lookup (link_info.hash,
1338 s->name,
1339 FALSE, FALSE, TRUE);
1341 if (blhe == NULL
1342 || blhe->type != bfd_link_hash_defined)
1343 continue;
1345 other_bfd_filename
1346 = blhe->u.def.section->owner->my_archive
1347 ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1348 : bfd_get_filename (blhe->u.def.section->owner);
1350 if (strcmp (bfd_get_filename (is->the_bfd->my_archive),
1351 other_bfd_filename) == 0)
1352 continue;
1354 /* Rename this implib to match the other one. */
1355 n = xmalloc (strlen (other_bfd_filename) + 1);
1356 strcpy (n, other_bfd_filename);
1357 is->the_bfd->my_archive->filename = n;
1358 }
1360 free (relocs);
1361 /* Note - we do not free the symbols,
1362 they are now cached in the BFD. */
1363 }
1364 }
1365 }
1366 }
1367 }
1369 {
1370 int is_ms_arch = 0;
1371 bfd *cur_arch = 0;
1372 lang_input_statement_type *is2;
1373 lang_input_statement_type *is3;
1375 /* Careful - this is a shell script. Watch those dollar signs! */
1376 /* Microsoft import libraries have every member named the same,
1377 and not in the right order for us to link them correctly. We
1378 must detect these and rename the members so that they'll link
1379 correctly. There are three types of objects: the head, the
1380 thunks, and the sentinel(s). The head is easy; it's the one
1381 with idata2. We assume that the sentinels won't have relocs,
1382 and the thunks will. It's easier than checking the symbol
1383 table for external references. */
1384 LANG_FOR_EACH_INPUT_STATEMENT (is)
1385 {
1386 if (is->the_bfd->my_archive)
1387 {
1388 char *pnt;
1389 bfd *arch = is->the_bfd->my_archive;
1391 if (cur_arch != arch)
1392 {
1393 cur_arch = arch;
1394 is_ms_arch = 1;
1396 for (is3 = is;
1397 is3 && is3->the_bfd->my_archive == arch;
1398 is3 = (lang_input_statement_type *) is3->next)
1399 {
1400 /* A MS dynamic import library can also contain static
1401 members, so look for the first element with a .dll
1402 extension, and use that for the remainder of the
1403 comparisons. */
1404 pnt = strrchr (is3->the_bfd->filename, '.');
1405 if (pnt != NULL && strcmp (pnt, ".dll") == 0)
1406 break;
1407 }
1409 if (is3 == NULL)
1410 is_ms_arch = 0;
1411 else
1412 {
1413 /* OK, found one. Now look to see if the remaining
1414 (dynamic import) members use the same name. */
1415 for (is2 = is;
1416 is2 && is2->the_bfd->my_archive == arch;
1417 is2 = (lang_input_statement_type *) is2->next)
1418 {
1419 /* Skip static members, ie anything with a .obj
1420 extension. */
1421 pnt = strrchr (is2->the_bfd->filename, '.');
1422 if (pnt != NULL && strcmp (pnt, ".obj") == 0)
1423 continue;
1425 if (strcmp (is3->the_bfd->filename,
1426 is2->the_bfd->filename))
1427 {
1428 is_ms_arch = 0;
1429 break;
1430 }
1431 }
1432 }
1433 }
1435 /* This fragment might have come from an .obj file in a Microsoft
1436 import, and not an actual import record. If this is the case,
1437 then leave the filename alone. */
1438 pnt = strrchr (is->the_bfd->filename, '.');
1440 if (is_ms_arch && (strcmp (pnt, ".dll") == 0))
1441 {
1442 int idata2 = 0, reloc_count=0;
1443 asection *sec;
1444 char *new_name, seq;
1446 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1447 {
1448 if (strcmp (sec->name, ".idata\$2") == 0)
1449 idata2 = 1;
1450 reloc_count += sec->reloc_count;
1451 }
1453 if (idata2) /* .idata2 is the TOC */
1454 seq = 'a';
1455 else if (reloc_count > 0) /* thunks */
1456 seq = 'b';
1457 else /* sentinel */
1458 seq = 'c';
1460 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1461 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1462 is->the_bfd->filename = new_name;
1464 new_name = xmalloc (strlen (is->filename) + 3);
1465 sprintf (new_name, "%s.%c", is->filename, seq);
1466 is->filename = new_name;
1467 }
1468 }
1469 }
1470 }
1472 {
1473 /* The following chunk of code tries to identify jump stubs in
1474 import libraries which are dead code and eliminates them
1475 from the final link. For each exported symbol <sym>, there
1476 is a object file in the import library with a .text section
1477 and several .idata\$* sections. The .text section contains the
1478 symbol definition for <sym> which is a jump stub of the form
1479 jmp *__imp_<sym>. The .idata\$5 contains the symbol definition
1480 for __imp_<sym> which is the address of the slot for <sym> in
1481 the import address table. When a symbol is imported explicitly
1482 using __declspec(dllimport) declaration, the compiler generates
1483 a reference to __imp_<sym> which directly resolves to the
1484 symbol in .idata\$5, in which case the jump stub code is not
1485 needed. The following code tries to identify jump stub sections
1486 in import libraries which are not referred to by anyone and
1487 marks them for exclusion from the final link. */
1488 LANG_FOR_EACH_INPUT_STATEMENT (is)
1489 {
1490 if (is->the_bfd->my_archive)
1491 {
1492 int is_imp = 0;
1493 asection *sec, *stub_sec = NULL;
1495 /* See if this is an import library thunk. */
1496 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1497 {
1498 if (strncmp (sec->name, ".idata\$", 7) == 0)
1499 is_imp = 1;
1500 /* The section containing the jmp stub has code
1501 and has a reloc. */
1502 if ((sec->flags & SEC_CODE) && sec->reloc_count)
1503 stub_sec = sec;
1504 }
1506 if (is_imp && stub_sec)
1507 {
1508 asymbol **symbols;
1509 long nsyms, src_count;
1510 struct bfd_link_hash_entry * blhe;
1512 if (!bfd_generic_link_read_symbols (is->the_bfd))
1513 {
1514 einfo (_("%B%F: could not read symbols: %E\n"),
1515 is->the_bfd);
1516 return;
1517 }
1518 symbols = bfd_get_outsymbols (is->the_bfd);
1519 nsyms = bfd_get_symcount (is->the_bfd);
1521 for (src_count = 0; src_count < nsyms; src_count++)
1522 {
1523 if (symbols[src_count]->section->id == stub_sec->id)
1524 {
1525 /* This symbol belongs to the section containing
1526 the stub. */
1527 blhe = bfd_link_hash_lookup (link_info.hash,
1528 symbols[src_count]->name,
1529 FALSE, FALSE, TRUE);
1530 /* If the symbol in the stub section has no other
1531 undefined references, exclude the stub section
1532 from the final link. */
1533 if (blhe && (blhe->type == bfd_link_hash_defined)
1534 && (blhe->u.undef.next == NULL))
1535 stub_sec->flags |= SEC_EXCLUDE;
1536 }
1537 }
1538 }
1539 }
1540 }
1541 }
1542 }
1543 \f
1544 static void
1545 gld_${EMULATION_NAME}_before_allocation (void)
1546 {
1547 #ifdef TARGET_IS_ppcpe
1548 /* Here we rummage through the found bfds to collect toc information. */
1549 {
1550 LANG_FOR_EACH_INPUT_STATEMENT (is)
1551 {
1552 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1553 {
1554 /* xgettext:c-format */
1555 einfo (_("Errors encountered processing file %s\n"), is->filename);
1556 }
1557 }
1558 }
1560 /* We have seen it all. Allocate it, and carry on. */
1561 ppc_allocate_toc_section (&link_info);
1562 #endif /* TARGET_IS_ppcpe */
1564 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1565 /* FIXME: we should be able to set the size of the interworking stub
1566 section.
1568 Here we rummage through the found bfds to collect glue
1569 information. FIXME: should this be based on a command line
1570 option? krk@cygnus.com. */
1571 {
1572 LANG_FOR_EACH_INPUT_STATEMENT (is)
1573 {
1574 if (! bfd_arm_process_before_allocation
1575 (is->the_bfd, & link_info, support_old_code))
1576 {
1577 /* xgettext:c-format */
1578 einfo (_("Errors encountered processing file %s for interworking\n"),
1579 is->filename);
1580 }
1581 }
1582 }
1584 /* We have seen it all. Allocate it, and carry on. */
1585 bfd_arm_allocate_interworking_sections (& link_info);
1586 #endif /* TARGET_IS_armpe || TARGET_IS_arm_epoc_pe || TARGET_IS_arm_wince_pe */
1588 before_allocation_default ();
1589 }
1590 \f
1591 #ifdef DLL_SUPPORT
1592 /* This is called when an input file isn't recognized as a BFD. We
1593 check here for .DEF files and pull them in automatically. */
1595 static int
1596 saw_option (char *option)
1597 {
1598 int i;
1600 for (i = 0; init[i].ptr; i++)
1601 if (strcmp (init[i].symbol, option) == 0)
1602 return init[i].inited;
1603 return 0;
1604 }
1605 #endif /* DLL_SUPPORT */
1607 static bfd_boolean
1608 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1609 {
1610 #ifdef DLL_SUPPORT
1611 const char *ext = entry->filename + strlen (entry->filename) - 4;
1613 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1614 {
1615 pe_def_file = def_file_parse (entry->filename, pe_def_file);
1617 if (pe_def_file)
1618 {
1619 int i, buflen=0, len;
1620 char *buf;
1622 for (i = 0; i < pe_def_file->num_exports; i++)
1623 {
1624 len = strlen (pe_def_file->exports[i].internal_name);
1625 if (buflen < len + 2)
1626 buflen = len + 2;
1627 }
1629 buf = xmalloc (buflen);
1631 for (i = 0; i < pe_def_file->num_exports; i++)
1632 {
1633 struct bfd_link_hash_entry *h;
1635 sprintf (buf, "%s%s", U (""), pe_def_file->exports[i].internal_name);
1637 h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1638 if (h == (struct bfd_link_hash_entry *) NULL)
1639 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1640 if (h->type == bfd_link_hash_new)
1641 {
1642 h->type = bfd_link_hash_undefined;
1643 h->u.undef.abfd = NULL;
1644 bfd_link_add_undef (link_info.hash, h);
1645 }
1646 }
1647 free (buf);
1649 /* def_file_print (stdout, pe_def_file); */
1650 if (pe_def_file->is_dll == 1)
1651 link_info.shared = 1;
1653 if (pe_def_file->base_address != (bfd_vma)(-1))
1654 {
1655 pe.ImageBase
1656 = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase
1657 = init[IMAGEBASEOFF].value
1658 = pe_def_file->base_address;
1659 init[IMAGEBASEOFF].inited = 1;
1660 if (image_base_statement)
1661 image_base_statement->exp = exp_assop ('=', "__image_base__",
1662 exp_intop (pe.ImageBase));
1663 }
1665 if (pe_def_file->stack_reserve != -1
1666 && ! saw_option ("__size_of_stack_reserve__"))
1667 {
1668 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1669 if (pe_def_file->stack_commit != -1)
1670 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1671 }
1672 if (pe_def_file->heap_reserve != -1
1673 && ! saw_option ("__size_of_heap_reserve__"))
1674 {
1675 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1676 if (pe_def_file->heap_commit != -1)
1677 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1678 }
1679 return TRUE;
1680 }
1681 }
1682 #endif
1683 return FALSE;
1684 }
1686 static bfd_boolean
1687 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1688 {
1689 #ifdef DLL_SUPPORT
1690 #ifdef TARGET_IS_i386pe
1691 pe_dll_id_target ("pei-i386");
1692 #endif
1693 #ifdef TARGET_IS_shpe
1694 pe_dll_id_target ("pei-shl");
1695 #endif
1696 #ifdef TARGET_IS_mipspe
1697 pe_dll_id_target ("pei-mips");
1698 #endif
1699 #ifdef TARGET_IS_armpe
1700 pe_dll_id_target ("pei-arm-little");
1701 #endif
1702 #ifdef TARGET_IS_arm_epoc_pe
1703 pe_dll_id_target ("epoc-pei-arm-little");
1704 #endif
1705 #ifdef TARGET_IS_arm_wince_pe
1706 pe_dll_id_target ("pei-arm-wince-little");
1707 #endif
1708 if (pe_bfd_is_dll (entry->the_bfd))
1709 return pe_implied_import_dll (entry->filename);
1710 #endif
1711 return FALSE;
1712 }
1714 static void
1715 gld_${EMULATION_NAME}_finish (void)
1716 {
1717 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1718 struct bfd_link_hash_entry * h;
1720 if (thumb_entry_symbol != NULL)
1721 {
1722 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1723 FALSE, FALSE, TRUE);
1725 if (h != (struct bfd_link_hash_entry *) NULL
1726 && (h->type == bfd_link_hash_defined
1727 || h->type == bfd_link_hash_defweak)
1728 && h->u.def.section->output_section != NULL)
1729 {
1730 static char buffer[32];
1731 bfd_vma val;
1733 /* Special procesing is required for a Thumb entry symbol. The
1734 bottom bit of its address must be set. */
1735 val = (h->u.def.value
1736 + bfd_get_section_vma (link_info.output_bfd,
1737 h->u.def.section->output_section)
1738 + h->u.def.section->output_offset);
1740 val |= 1;
1742 /* Now convert this value into a string and store it in entry_symbol
1743 where the lang_finish() function will pick it up. */
1744 buffer[0] = '0';
1745 buffer[1] = 'x';
1747 sprintf_vma (buffer + 2, val);
1749 if (entry_symbol.name != NULL && entry_from_cmdline)
1750 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1751 thumb_entry_symbol, entry_symbol.name);
1752 entry_symbol.name = buffer;
1753 }
1754 else
1755 einfo (_("%P: warning: cannot find thumb start symbol %s\n"), thumb_entry_symbol);
1756 }
1757 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe) */
1759 finish_default ();
1761 #ifdef DLL_SUPPORT
1762 if (link_info.shared
1763 #if !defined(TARGET_IS_shpe) && !defined(TARGET_IS_mipspe)
1764 || (!link_info.relocatable && pe_def_file->num_exports != 0)
1765 #endif
1766 )
1767 {
1768 pe_dll_fill_sections (link_info.output_bfd, &link_info);
1769 if (pe_implib_filename)
1770 pe_dll_generate_implib (pe_def_file, pe_implib_filename, &link_info);
1771 }
1772 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1773 /* ARM doesn't need relocs. */
1774 else
1775 {
1776 pe_exe_fill_sections (link_info.output_bfd, &link_info);
1777 }
1778 #endif
1780 if (pe_out_def_filename)
1781 pe_dll_generate_def_file (pe_out_def_filename);
1782 #endif /* DLL_SUPPORT */
1784 /* I don't know where .idata gets set as code, but it shouldn't be. */
1785 {
1786 asection *asec = bfd_get_section_by_name (link_info.output_bfd, ".idata");
1788 if (asec)
1789 {
1790 asec->flags &= ~SEC_CODE;
1791 asec->flags |= SEC_DATA;
1792 }
1793 }
1794 }
1796 \f
1797 /* Place an orphan section.
1799 We use this to put sections in a reasonable place in the file, and
1800 to ensure that they are aligned as required.
1802 We handle grouped sections here as well. A section named .foo\$nn
1803 goes into the output section .foo. All grouped sections are sorted
1804 by name.
1806 Grouped sections for the default sections are handled by the
1807 default linker script using wildcards, and are sorted by
1808 sort_sections. */
1810 static lang_output_section_statement_type *
1811 gld_${EMULATION_NAME}_place_orphan (asection *s,
1812 const char *secname,
1813 int constraint)
1814 {
1815 const char *orig_secname = secname;
1816 char *dollar = NULL;
1817 lang_output_section_statement_type *os;
1818 lang_statement_list_type add_child;
1819 lang_output_section_statement_type *match_by_name = NULL;
1820 lang_statement_union_type **pl;
1822 /* Look through the script to see where to place this section. */
1823 if (!link_info.relocatable
1824 && (dollar = strchr (secname, '\$')) != NULL)
1825 {
1826 size_t len = dollar - secname;
1827 char *newname = xmalloc (len + 1);
1828 memcpy (newname, secname, len);
1829 newname[len] = '\0';
1830 secname = newname;
1831 }
1833 lang_list_init (&add_child);
1835 os = NULL;
1836 if (constraint == 0)
1837 for (os = lang_output_section_find (secname);
1838 os != NULL;
1839 os = next_matching_output_section_statement (os, 0))
1840 {
1841 /* If we don't match an existing output section, tell
1842 lang_insert_orphan to create a new output section. */
1843 constraint = SPECIAL;
1845 if (os->bfd_section != NULL
1846 && (os->bfd_section->flags == 0
1847 || ((s->flags ^ os->bfd_section->flags)
1848 & (SEC_LOAD | SEC_ALLOC)) == 0))
1849 {
1850 /* We already have an output section statement with this
1851 name, and its bfd section has compatible flags.
1852 If the section already exists but does not have any flags set,
1853 then it has been created by the linker, probably as a result of
1854 a --section-start command line switch. */
1855 lang_add_section (&add_child, s, os);
1856 break;
1857 }
1859 /* Save unused output sections in case we can match them
1860 against orphans later. */
1861 if (os->bfd_section == NULL)
1862 match_by_name = os;
1863 }
1865 /* If we didn't match an active output section, see if we matched an
1866 unused one and use that. */
1867 if (os == NULL && match_by_name)
1868 {
1869 lang_add_section (&match_by_name->children, s, match_by_name);
1870 return match_by_name;
1871 }
1873 if (os == NULL)
1874 {
1875 static struct orphan_save hold[] =
1876 {
1877 { ".text",
1878 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1879 0, 0, 0, 0 },
1880 { ".rdata",
1881 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1882 0, 0, 0, 0 },
1883 { ".data",
1884 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1885 0, 0, 0, 0 },
1886 { ".bss",
1887 SEC_ALLOC,
1888 0, 0, 0, 0 }
1889 };
1890 enum orphan_save_index
1891 {
1892 orphan_text = 0,
1893 orphan_rodata,
1894 orphan_data,
1895 orphan_bss
1896 };
1897 static int orphan_init_done = 0;
1898 struct orphan_save *place;
1899 lang_output_section_statement_type *after;
1900 etree_type *address;
1902 if (!orphan_init_done)
1903 {
1904 struct orphan_save *ho;
1905 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1906 if (ho->name != NULL)
1907 {
1908 ho->os = lang_output_section_find (ho->name);
1909 if (ho->os != NULL && ho->os->flags == 0)
1910 ho->os->flags = ho->flags;
1911 }
1912 orphan_init_done = 1;
1913 }
1915 /* Try to put the new output section in a reasonable place based
1916 on the section name and section flags. */
1918 place = NULL;
1919 if ((s->flags & SEC_ALLOC) == 0)
1920 ;
1921 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1922 place = &hold[orphan_bss];
1923 else if ((s->flags & SEC_READONLY) == 0)
1924 place = &hold[orphan_data];
1925 else if ((s->flags & SEC_CODE) == 0)
1926 place = &hold[orphan_rodata];
1927 else
1928 place = &hold[orphan_text];
1930 after = NULL;
1931 if (place != NULL)
1932 {
1933 if (place->os == NULL)
1934 place->os = lang_output_section_find (place->name);
1935 after = place->os;
1936 if (after == NULL)
1937 after = lang_output_section_find_by_flags (s, &place->os, NULL);
1938 if (after == NULL)
1939 /* *ABS* is always the first output section statement. */
1940 after = (&lang_output_section_statement.head
1941 ->output_section_statement);
1942 }
1944 /* All sections in an executable must be aligned to a page boundary. */
1945 address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
1946 os = lang_insert_orphan (s, secname, constraint, after, place, address,
1947 &add_child);
1948 }
1950 /* If the section name has a '\$', sort it with the other '\$'
1951 sections. */
1952 for (pl = &os->children.head; *pl != NULL; pl = &(*pl)->header.next)
1953 {
1954 lang_input_section_type *ls;
1955 const char *lname;
1957 if ((*pl)->header.type != lang_input_section_enum)
1958 continue;
1960 ls = &(*pl)->input_section;
1962 lname = bfd_get_section_name (ls->section->owner, ls->section);
1963 if (strchr (lname, '\$') != NULL
1964 && (dollar == NULL || strcmp (orig_secname, lname) < 0))
1965 break;
1966 }
1968 if (add_child.head != NULL)
1969 {
1970 *add_child.tail = *pl;
1971 *pl = add_child.head;
1972 }
1974 return os;
1975 }
1977 static bfd_boolean
1978 gld_${EMULATION_NAME}_open_dynamic_archive
1979 (const char *arch ATTRIBUTE_UNUSED,
1980 search_dirs_type *search,
1981 lang_input_statement_type *entry)
1982 {
1983 static const struct
1984 {
1985 const char * format;
1986 bfd_boolean use_prefix;
1987 }
1988 libname_fmt [] =
1989 {
1990 /* Preferred explicit import library for dll's. */
1991 { "lib%s.dll.a", FALSE },
1992 /* Alternate explicit import library for dll's. */
1993 { "%s.dll.a", FALSE },
1994 /* "libfoo.a" could be either an import lib or a static lib.
1995 For backwards compatibility, libfoo.a needs to precede
1996 libfoo.dll and foo.dll in the search. */
1997 { "lib%s.a", FALSE },
1998 /* The 'native' spelling of an import lib name is "foo.lib". */
1999 { "%s.lib", FALSE },
2000 #ifdef DLL_SUPPORT
2001 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */
2002 { "%s%s.dll", TRUE },
2003 #endif
2004 /* Try "libfoo.dll" (default preferred dll name). */
2005 { "lib%s.dll", FALSE },
2006 /* Finally try 'native' dll name "foo.dll". */
2007 { "%s.dll", FALSE },
2008 /* Note: If adding more formats to this table, make sure to check to
2009 see if their length is longer than libname_fmt[0].format, and if
2010 so, update the call to xmalloc() below. */
2011 { NULL, FALSE }
2012 };
2013 static unsigned int format_max_len = 0;
2014 const char * filename;
2015 char * full_string;
2016 char * base_string;
2017 unsigned int i;
2020 if (! entry->is_archive)
2021 return FALSE;
2023 filename = entry->filename;
2025 if (format_max_len == 0)
2026 /* We need to allow space in the memory that we are going to allocate
2027 for the characters in the format string. Since the format array is
2028 static we only need to calculate this information once. In theory
2029 this value could also be computed statically, but this introduces
2030 the possibility for a discrepancy and hence a possible memory
2031 corruption. The lengths we compute here will be too long because
2032 they will include any formating characters (%s) in the strings, but
2033 this will not matter. */
2034 for (i = 0; libname_fmt[i].format; i++)
2035 if (format_max_len < strlen (libname_fmt[i].format))
2036 format_max_len = strlen (libname_fmt[i].format);
2038 full_string = xmalloc (strlen (search->name)
2039 + strlen (filename)
2040 + format_max_len
2041 #ifdef DLL_SUPPORT
2042 + (pe_dll_search_prefix
2043 ? strlen (pe_dll_search_prefix) : 0)
2044 #endif
2045 /* Allow for the terminating NUL and for the path
2046 separator character that is inserted between
2047 search->name and the start of the format string. */
2048 + 2);
2050 sprintf (full_string, "%s/", search->name);
2051 base_string = full_string + strlen (full_string);
2053 for (i = 0; libname_fmt[i].format; i++)
2054 {
2055 #ifdef DLL_SUPPORT
2056 if (libname_fmt[i].use_prefix)
2057 {
2058 if (!pe_dll_search_prefix)
2059 continue;
2060 sprintf (base_string, libname_fmt[i].format, pe_dll_search_prefix, filename);
2061 }
2062 else
2063 #endif
2064 sprintf (base_string, libname_fmt[i].format, filename);
2066 if (ldfile_try_open_bfd (full_string, entry))
2067 break;
2068 }
2070 if (!libname_fmt[i].format)
2071 {
2072 free (full_string);
2073 return FALSE;
2074 }
2076 entry->filename = full_string;
2078 return TRUE;
2079 }
2081 static int
2082 gld_${EMULATION_NAME}_find_potential_libraries
2083 (char *name, lang_input_statement_type *entry)
2084 {
2085 return ldfile_open_file_search (name, entry, "", ".lib");
2086 }
2087 \f
2088 static char *
2089 gld_${EMULATION_NAME}_get_script (int *isfile)
2090 EOF
2091 # Scripts compiled in.
2092 # sed commands to quote an ld script as a C string.
2093 sc="-f stringify.sed"
2095 fragment <<EOF
2096 {
2097 *isfile = 0;
2099 if (link_info.relocatable && config.build_constructors)
2100 return
2101 EOF
2102 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
2103 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
2104 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
2105 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
2106 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
2107 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
2108 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
2109 if test -n "$GENERATE_AUTO_IMPORT_SCRIPT" ; then
2110 echo ' ; else if (link_info.pei386_auto_import == 1) return' >> e${EMULATION_NAME}.c
2111 sed $sc ldscripts/${EMULATION_NAME}.xa >> e${EMULATION_NAME}.c
2112 fi
2113 echo ' ; else return' >> e${EMULATION_NAME}.c
2114 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
2115 echo '; }' >> e${EMULATION_NAME}.c
2117 fragment <<EOF
2120 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
2121 {
2122 gld_${EMULATION_NAME}_before_parse,
2123 syslib_default,
2124 hll_default,
2125 gld_${EMULATION_NAME}_after_parse,
2126 gld_${EMULATION_NAME}_after_open,
2127 after_allocation_default,
2128 set_output_arch_default,
2129 ldemul_default_target,
2130 gld_${EMULATION_NAME}_before_allocation,
2131 gld_${EMULATION_NAME}_get_script,
2132 "${EMULATION_NAME}",
2133 "${OUTPUT_FORMAT}",
2134 gld_${EMULATION_NAME}_finish,
2135 NULL, /* Create output section statements. */
2136 gld_${EMULATION_NAME}_open_dynamic_archive,
2137 gld_${EMULATION_NAME}_place_orphan,
2138 gld_${EMULATION_NAME}_set_symbols,
2139 NULL, /* parse_args */
2140 gld${EMULATION_NAME}_add_options,
2141 gld${EMULATION_NAME}_handle_option,
2142 gld_${EMULATION_NAME}_unrecognized_file,
2143 gld_${EMULATION_NAME}_list_options,
2144 gld_${EMULATION_NAME}_recognized_file,
2145 gld_${EMULATION_NAME}_find_potential_libraries,
2146 NULL /* new_vers_pattern. */
2147 };
2148 EOF