1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 if [ -z "$MACHINE" ]; then
6 OUTPUT_ARCH=${ARCH}:${MACHINE}
11 move_default_addr_high=1
14 move_default_addr_high=0;
18 rm -f e${EMULATION_NAME}.c
19 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
21 /* Copyright (C) 2006-2014 Free Software Foundation, Inc.
22 Written by Kai Tietz, OneVision Software GmbH&CoKg.
24 This file is part of the GNU Binutils.
26 This program is free software; you can redistribute it and/or modify
27 it under the terms of the GNU General Public License as published by
28 the Free Software Foundation; either version 3 of the License, or
29 (at your option) any later version.
31 This program is distributed in the hope that it will be useful,
32 but WITHOUT ANY WARRANTY; without even the implied warranty of
33 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34 GNU General Public License for more details.
36 You should have received a copy of the GNU General Public License
37 along with this program; if not, write to the Free Software
38 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
39 MA 02110-1301, USA. */
42 /* For WINDOWS_XP64 and higher */
43 /* Based on pe.em, but modified for 64 bit support. */
45 #define TARGET_IS_${EMULATION_NAME}
47 #define COFF_IMAGE_WITH_PE
49 #define COFF_WITH_pex64
55 #include "libiberty.h"
56 #include "filenames.h"
67 #include "ldbuildid.h"
68 #include "coff/internal.h"
70 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
71 header in generic PE code. */
72 #include "coff/x86_64.h"
75 /* FIXME: These are BFD internal header files, and we should not be
77 #include "../bfd/libcoff.h"
78 #include "../bfd/libpei.h"
81 #define AOUTSZ PEPAOUTSZ
82 #define PEAOUTHDR PEPAOUTHDR
86 #include "safe-ctype.h"
88 /* Permit the emulation parameters to override the default section
89 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes
90 it seem that include/coff/internal.h should not define
91 PE_DEF_SECTION_ALIGNMENT. */
92 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
93 #undef PE_DEF_SECTION_ALIGNMENT
94 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
97 #ifdef TARGET_IS_i386pep
101 #if defined(TARGET_IS_i386pep) || ! defined(DLL_SUPPORT)
102 #define PE_DEF_SUBSYSTEM 3
103 #undef NT_EXE_IMAGE_BASE
104 #define NT_EXE_IMAGE_BASE \
105 ((bfd_vma) (${move_default_addr_high} ? 0x100400000LL \
107 #undef NT_DLL_IMAGE_BASE
108 #define NT_DLL_IMAGE_BASE \
109 ((bfd_vma) (${move_default_addr_high} ? 0x400000000LL \
111 #undef NT_DLL_AUTO_IMAGE_BASE
112 #define NT_DLL_AUTO_IMAGE_BASE \
113 ((bfd_vma) (${move_default_addr_high} ? 0x400000000LL \
115 #undef NT_DLL_AUTO_IMAGE_MASK
116 #define NT_DLL_AUTO_IMAGE_MASK \
117 ((bfd_vma) (${move_default_addr_high} ? 0x1ffff0000LL \
120 #undef NT_EXE_IMAGE_BASE
121 #define NT_EXE_IMAGE_BASE \
122 ((bfd_vma) (${move_default_addr_high} ? 0x100010000LL \
124 #undef NT_DLL_IMAGE_BASE
125 #define NT_DLL_IMAGE_BASE \
126 ((bfd_vma) (${move_default_addr_high} ? 0x110000000LL \
128 #undef NT_DLL_AUTO_IMAGE_BASE
129 #define NT_DLL_AUTO_IMAGE_BASE \
130 ((bfd_vma) (${move_default_addr_high} ? 0x120000000LL \
132 #undef NT_DLL_AUTO_IMAGE_MASK
133 #define NT_DLL_AUTO_IMAGE_MASK \
134 ((bfd_vma) (${move_default_addr_high} ? 0x0ffff0000LL \
136 #undef PE_DEF_SECTION_ALIGNMENT
137 #define PE_DEF_SUBSYSTEM 2
138 #undef PE_DEF_FILE_ALIGNMENT
139 #define PE_DEF_FILE_ALIGNMENT 0x00000200
140 #define PE_DEF_SECTION_ALIGNMENT 0x00000400
143 static struct internal_extra_pe_aouthdr pep;
145 static int pep_subsystem = ${SUBSYSTEM};
146 static flagword real_flags = IMAGE_FILE_LARGE_ADDRESS_AWARE;
147 static int support_old_code = 0;
148 static lang_assignment_statement_type *image_base_statement = 0;
149 static unsigned short pe_dll_characteristics = 0;
150 static bfd_boolean insert_timestamp = TRUE;
151 static const char *emit_build_id;
154 static int pep_enable_stdcall_fixup = 1; /* 0=disable 1=enable (default). */
155 static char * pep_out_def_filename = NULL;
156 static char * pep_implib_filename = NULL;
157 static int pep_enable_auto_image_base = 0;
158 static char * pep_dll_search_prefix = NULL;
161 extern const char *output_filename;
163 static int is_underscoring (void)
166 if (pep_leading_underscore != -1)
167 return pep_leading_underscore;
168 if (!bfd_get_target_info ("${OUTPUT_FORMAT}", NULL, NULL, &u, NULL))
169 bfd_get_target_info ("${RELOCATEABLE_OUTPUT_FORMAT}", NULL, NULL, &u, NULL);
173 pep_leading_underscore = (u != 0 ? 1 : 0);
174 return pep_leading_underscore;
179 gld_${EMULATION_NAME}_before_parse (void)
182 ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
183 output_filename = "${EXECUTABLE_NAME:-a.exe}";
185 input_flags.dynamic = TRUE;
186 config.has_shared = 1;
187 link_info.pei386_auto_import = 1;
188 link_info.pei386_runtime_pseudo_reloc = 2; /* Use by default version 2. */
192 /* PE format extra command line options. */
194 /* Used for setting flags in the PE header. */
197 OPTION_BASE_FILE = 300 + 1,
199 OPTION_FILE_ALIGNMENT,
201 OPTION_MAJOR_IMAGE_VERSION,
202 OPTION_MAJOR_OS_VERSION,
203 OPTION_MAJOR_SUBSYSTEM_VERSION,
204 OPTION_MINOR_IMAGE_VERSION,
205 OPTION_MINOR_OS_VERSION,
206 OPTION_MINOR_SUBSYSTEM_VERSION,
207 OPTION_SECTION_ALIGNMENT,
211 OPTION_SUPPORT_OLD_CODE,
214 OPTION_EXCLUDE_SYMBOLS,
215 OPTION_EXCLUDE_ALL_SYMBOLS,
217 OPTION_STDCALL_ALIASES,
218 OPTION_ENABLE_STDCALL_FIXUP,
219 OPTION_DISABLE_STDCALL_FIXUP,
220 OPTION_IMPLIB_FILENAME,
221 OPTION_WARN_DUPLICATE_EXPORTS,
223 OPTION_ENABLE_AUTO_IMAGE_BASE,
224 OPTION_DISABLE_AUTO_IMAGE_BASE,
225 OPTION_DLL_SEARCH_PREFIX,
226 OPTION_NO_DEFAULT_EXCLUDES,
227 OPTION_DLL_ENABLE_AUTO_IMPORT,
228 OPTION_DLL_DISABLE_AUTO_IMPORT,
229 OPTION_ENABLE_EXTRA_PE_DEBUG,
231 OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC,
232 OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC,
233 OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2,
234 OPTION_EXCLUDE_MODULES_FOR_IMPLIB,
235 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES,
236 OPTION_NO_LEADING_UNDERSCORE,
237 OPTION_LEADING_UNDERSCORE,
238 OPTION_ENABLE_LONG_SECTION_NAMES,
239 OPTION_DISABLE_LONG_SECTION_NAMES,
241 OPTION_FORCE_INTEGRITY,
247 OPTION_INSERT_TIMESTAMP,
248 OPTION_NO_INSERT_TIMESTAMP,
249 OPTION_TERMINAL_SERVER_AWARE,
254 gld${EMULATION_NAME}_add_options
255 (int ns ATTRIBUTE_UNUSED,
256 char **shortopts ATTRIBUTE_UNUSED,
258 struct option **longopts,
259 int nrl ATTRIBUTE_UNUSED,
260 struct option **really_longopts ATTRIBUTE_UNUSED)
262 static const struct option xtra_long[] =
265 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
266 {"dll", no_argument, NULL, OPTION_DLL},
267 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
268 {"heap", required_argument, NULL, OPTION_HEAP},
269 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
270 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
271 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
272 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
273 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
274 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
275 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
276 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
277 {"stack", required_argument, NULL, OPTION_STACK},
278 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
279 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
280 {"use-nul-prefixed-import-tables", no_argument, NULL,
281 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
282 {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE},
283 {"leading-underscore", no_argument, NULL, OPTION_LEADING_UNDERSCORE},
285 /* getopt allows abbreviations, so we do this to stop it
286 from treating -o as an abbreviation for this option. */
287 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
288 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
289 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
290 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
291 {"exclude-all-symbols", no_argument, NULL, OPTION_EXCLUDE_ALL_SYMBOLS},
292 {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
293 {"exclude-modules-for-implib", required_argument, NULL, OPTION_EXCLUDE_MODULES_FOR_IMPLIB},
294 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
295 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
296 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
297 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
298 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
299 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
300 /* getopt() allows abbreviations, so we do this to stop it from
301 treating -c as an abbreviation for these --compat-implib. */
302 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
303 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
304 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
305 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
306 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
307 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
308 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
309 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
310 {"enable-extra-pep-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
311 {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
312 {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
313 {"enable-runtime-pseudo-reloc-v2", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2},
315 {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES},
316 {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES},
317 {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE},
318 {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY},
319 {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT},
320 {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION},
321 {"no-seh", no_argument, NULL, OPTION_NO_SEH},
322 {"no-bind", no_argument, NULL, OPTION_NO_BIND},
323 {"wdmdriver", no_argument, NULL, OPTION_WDM_DRIVER},
324 {"tsaware", no_argument, NULL, OPTION_TERMINAL_SERVER_AWARE},
325 {"insert-timestamp", no_argument, NULL, OPTION_INSERT_TIMESTAMP},
326 {"no-insert-timestamp", no_argument, NULL, OPTION_NO_INSERT_TIMESTAMP},
327 {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
328 {NULL, no_argument, NULL, 0}
332 = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
333 memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
336 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
337 parameters which may be input from the command line. */
346 /* FALSE for an assembly level symbol and TRUE for a C visible symbol.
347 C visible symbols can be prefixed by underscore dependent on target's
349 bfd_boolean is_c_symbol;
352 #define GET_INIT_SYMBOL_NAME(IDX) \
353 (init[(IDX)].symbol \
354 + ((init[(IDX)].is_c_symbol == FALSE || (is_underscoring () == 1)) ? 0 : 1))
356 /* Decorates the C visible symbol by underscore, if target requires. */
358 ((is_underscoring () == 0) ? CSTR : "_" CSTR)
360 /* Get size of constant string for a possible underscore prefixed
362 #define U_SIZE(CSTR) \
363 (sizeof (CSTR) + (is_underscoring () == 0 ? 0 : 1))
365 #define D(field,symbol,def,usc) {&pep.field, sizeof (pep.field), def, symbol, 0, usc}
367 static definfo init[] =
369 /* imagebase must be first */
370 #define IMAGEBASEOFF 0
371 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE, FALSE),
373 {&dll, sizeof(dll), 0, "__dll__", 0, FALSE},
374 #define MSIMAGEBASEOFF 2
375 D(ImageBase, "___ImageBase", NT_EXE_IMAGE_BASE, TRUE),
376 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT, FALSE),
377 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT, FALSE),
378 D(MajorOperatingSystemVersion,"__major_os_version__", 4, FALSE),
379 D(MinorOperatingSystemVersion,"__minor_os_version__", 0, FALSE),
380 D(MajorImageVersion,"__major_image_version__", 0, FALSE),
381 D(MinorImageVersion,"__minor_image_version__", 0, FALSE),
382 D(MajorSubsystemVersion,"__major_subsystem_version__", 5, FALSE),
383 D(MinorSubsystemVersion,"__minor_subsystem_version__", 2, FALSE),
384 D(Subsystem,"__subsystem__", ${SUBSYSTEM}, FALSE),
385 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000, FALSE),
386 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000, FALSE),
387 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000, FALSE),
388 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000, FALSE),
389 D(LoaderFlags,"__loader_flags__", 0x0, FALSE),
390 D(DllCharacteristics, "__dll_characteristics__", 0x0, FALSE),
391 { NULL, 0, 0, NULL, 0, FALSE}
396 gld_${EMULATION_NAME}_list_options (FILE *file)
398 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
399 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
400 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
401 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
402 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
403 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
404 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
405 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
406 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
407 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
408 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
409 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
410 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
411 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
412 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
413 fprintf (file, _(" --[no-]leading-underscore Set explicit symbol underscore prefix mode\n"));
414 fprintf (file, _(" --[no-]insert-timestamp Use a real timestamp rather than zero. (default)\n"));
415 fprintf (file, _(" This makes binaries non-deterministic\n"));
417 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
418 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
419 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
420 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
421 fprintf (file, _(" --exclude-all-symbols Exclude all symbols from automatic export\n"));
422 fprintf (file, _(" --exclude-libs lib,lib,... Exclude libraries from automatic export\n"));
423 fprintf (file, _(" --exclude-modules-for-implib mod,mod,...\n"));
424 fprintf (file, _(" Exclude objects, archive members from auto\n"));
425 fprintf (file, _(" export, place into import library instead.\n"));
426 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
427 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
428 fprintf (file, _(" --out-implib <file> Generate import library\n"));
429 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
430 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
431 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n\
432 create __imp_<SYMBOL> as well.\n"));
433 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n\
434 unless user specifies one\n"));
435 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
436 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll without\n\
437 an importlib, use <string><basename>.dll\n\
438 in preference to lib<basename>.dll \n"));
439 fprintf (file, _(" --enable-auto-import Do sophisticated linking of _sym to\n\
440 __imp_sym for DATA references\n"));
441 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n"));
442 fprintf (file, _(" --enable-runtime-pseudo-reloc Work around auto-import limitations by\n\
443 adding pseudo-relocations resolved at\n\
445 fprintf (file, _(" --disable-runtime-pseudo-reloc Do not add runtime pseudo-relocations for\n\
446 auto-imported DATA.\n"));
447 fprintf (file, _(" --enable-extra-pep-debug Enable verbose debug output when building\n\
448 or linking to DLLs (esp. auto-import)\n"));
449 fprintf (file, _(" --enable-long-section-names Use long COFF section names even in\n\
450 executable image files\n"));
451 fprintf (file, _(" --disable-long-section-names Never use long COFF section names, even\n\
452 in object files\n"));
453 fprintf (file, _(" --dynamicbase Image base address may be relocated using\n\
454 address space layout randomization (ASLR)\n"));
455 fprintf (file, _(" --forceinteg Code integrity checks are enforced\n"));
456 fprintf (file, _(" --nxcompat Image is compatible with data execution prevention\n"));
457 fprintf (file, _(" --no-isolation Image understands isolation but do not isolate the image\n"));
458 fprintf (file, _(" --no-seh Image does not use SEH. No SE handler may\n\
459 be called in this image\n"));
460 fprintf (file, _(" --no-bind Do not bind this image\n"));
461 fprintf (file, _(" --wdmdriver Driver uses the WDM model\n"));
462 fprintf (file, _(" --tsaware Image is Terminal Server aware\n"));
463 fprintf (file, _(" --build-id[=STYLE] Generate build ID\n"));
469 set_pep_name (char *name, bfd_vma val)
473 /* Find the name and set it. */
474 for (i = 0; init[i].ptr; i++)
476 if (strcmp (name, GET_INIT_SYMBOL_NAME (i)) == 0)
480 if (strcmp (name,"__image_base__") == 0)
481 set_pep_name (U ("__ImageBase"), val);
489 set_entry_point (void)
492 const char *initial_symbol_char;
502 { 1, "NtProcessStartup" },
503 { 2, "WinMainCRTStartup" },
504 { 3, "mainCRTStartup" },
505 { 7, "__PosixProcessStartup" },
506 { 9, "WinMainCRTStartup" },
507 {14, "mainCRTStartup" },
511 /* Entry point name for arbitrary subsystem numbers. */
512 static const char default_entry[] = "mainCRTStartup";
514 if (link_info.shared || dll)
516 entry = "DllMainCRTStartup";
520 for (i = 0; v[i].entry; i++)
521 if (v[i].value == pep_subsystem)
524 /* If no match, use the default. */
525 if (v[i].entry != NULL)
528 entry = default_entry;
531 /* Now we check target's default for getting proper symbol_char. */
532 initial_symbol_char = (is_underscoring () != 0 ? "_" : "");
534 if (*initial_symbol_char != '\0')
538 /* lang_default_entry expects its argument to be permanently
539 allocated, so we don't free this string. */
540 alc_entry = xmalloc (strlen (initial_symbol_char)
543 strcpy (alc_entry, initial_symbol_char);
544 strcat (alc_entry, entry);
548 lang_default_entry (entry);
552 set_pep_subsystem (void)
558 unsigned long temp_subsystem;
575 /* Check for the presence of a version number. */
576 sver = strchr (optarg, ':');
578 len = strlen (optarg);
582 set_pep_name ("__major_subsystem_version__",
583 strtoul (sver + 1, &end, 0));
585 set_pep_name ("__minor_subsystem_version__",
586 strtoul (end + 1, &end, 0));
588 einfo (_("%P: warning: bad version number in -subsystem option\n"));
591 /* Check for numeric subsystem. */
592 temp_subsystem = strtoul (optarg, & end, 0);
593 if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
595 /* Search list for a numeric match to use its entry point. */
596 for (i = 0; v[i].name; i++)
597 if (v[i].value == (int) temp_subsystem)
600 /* Use this subsystem. */
601 pep_subsystem = (int) temp_subsystem;
605 /* Search for subsystem by name. */
606 for (i = 0; v[i].name; i++)
607 if (strncmp (optarg, v[i].name, len) == 0
608 && v[i].name[len] == '\0')
611 if (v[i].name == NULL)
613 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
617 pep_subsystem = v[i].value;
620 set_pep_name ("__subsystem__", pep_subsystem);
627 set_pep_value (char *name)
631 set_pep_name (name, (bfd_vma) strtoull (optarg, &end, 0));
634 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
641 set_pep_stack_heap (char *resname, char *comname)
643 set_pep_value (resname);
648 set_pep_value (comname);
651 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
654 #define DEFAULT_BUILD_ID_STYLE "md5"
657 gld${EMULATION_NAME}_handle_option (int optc)
665 case OPTION_BASE_FILE:
666 link_info.base_file = fopen (optarg, FOPEN_WB);
667 if (link_info.base_file == NULL)
668 einfo (_("%F%P: cannot open base file %s\n"), optarg);
673 set_pep_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
676 set_pep_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
678 case OPTION_SUBSYSTEM:
679 set_pep_subsystem ();
681 case OPTION_MAJOR_OS_VERSION:
682 set_pep_value ("__major_os_version__");
684 case OPTION_MINOR_OS_VERSION:
685 set_pep_value ("__minor_os_version__");
687 case OPTION_MAJOR_SUBSYSTEM_VERSION:
688 set_pep_value ("__major_subsystem_version__");
690 case OPTION_MINOR_SUBSYSTEM_VERSION:
691 set_pep_value ("__minor_subsystem_version__");
693 case OPTION_MAJOR_IMAGE_VERSION:
694 set_pep_value ("__major_image_version__");
696 case OPTION_MINOR_IMAGE_VERSION:
697 set_pep_value ("__minor_image_version__");
699 case OPTION_FILE_ALIGNMENT:
700 set_pep_value ("__file_alignment__");
702 case OPTION_SECTION_ALIGNMENT:
703 set_pep_value ("__section_alignment__");
706 set_pep_name ("__dll__", 1);
708 case OPTION_IMAGE_BASE:
709 set_pep_value ("__image_base__");
711 case OPTION_SUPPORT_OLD_CODE:
712 support_old_code = 1;
714 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
715 pep_use_nul_prefixed_import_tables = TRUE;
717 case OPTION_NO_LEADING_UNDERSCORE:
718 pep_leading_underscore = 0;
720 case OPTION_LEADING_UNDERSCORE:
721 pep_leading_underscore = 1;
723 case OPTION_INSERT_TIMESTAMP:
724 insert_timestamp = TRUE;
726 case OPTION_NO_INSERT_TIMESTAMP:
727 insert_timestamp = FALSE;
731 pep_out_def_filename = xstrdup (optarg);
733 case OPTION_EXPORT_ALL:
734 pep_dll_export_everything = 1;
736 case OPTION_EXCLUDE_SYMBOLS:
737 pep_dll_add_excludes (optarg, EXCLUDESYMS);
739 case OPTION_EXCLUDE_ALL_SYMBOLS:
740 pep_dll_exclude_all_symbols = 1;
742 case OPTION_EXCLUDE_LIBS:
743 pep_dll_add_excludes (optarg, EXCLUDELIBS);
745 case OPTION_EXCLUDE_MODULES_FOR_IMPLIB:
746 pep_dll_add_excludes (optarg, EXCLUDEFORIMPLIB);
748 case OPTION_KILL_ATS:
749 pep_dll_kill_ats = 1;
751 case OPTION_STDCALL_ALIASES:
752 pep_dll_stdcall_aliases = 1;
754 case OPTION_ENABLE_STDCALL_FIXUP:
755 pep_enable_stdcall_fixup = 1;
757 case OPTION_DISABLE_STDCALL_FIXUP:
758 pep_enable_stdcall_fixup = 0;
760 case OPTION_IMPLIB_FILENAME:
761 pep_implib_filename = xstrdup (optarg);
763 case OPTION_WARN_DUPLICATE_EXPORTS:
764 pep_dll_warn_dup_exports = 1;
766 case OPTION_IMP_COMPAT:
767 pep_dll_compat_implib = 1;
769 case OPTION_ENABLE_AUTO_IMAGE_BASE:
770 pep_enable_auto_image_base = 1;
772 case OPTION_DISABLE_AUTO_IMAGE_BASE:
773 pep_enable_auto_image_base = 0;
775 case OPTION_DLL_SEARCH_PREFIX:
776 pep_dll_search_prefix = xstrdup (optarg);
778 case OPTION_NO_DEFAULT_EXCLUDES:
779 pep_dll_do_default_excludes = 0;
781 case OPTION_DLL_ENABLE_AUTO_IMPORT:
782 link_info.pei386_auto_import = 1;
784 case OPTION_DLL_DISABLE_AUTO_IMPORT:
785 link_info.pei386_auto_import = 0;
787 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
788 link_info.pei386_runtime_pseudo_reloc = 2;
790 case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
791 link_info.pei386_runtime_pseudo_reloc = 0;
793 case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2:
794 link_info.pei386_runtime_pseudo_reloc = 2;
796 case OPTION_ENABLE_EXTRA_PE_DEBUG:
797 pep_dll_extra_pe_debug = 1;
800 case OPTION_ENABLE_LONG_SECTION_NAMES:
801 pep_use_coff_long_section_names = 1;
803 case OPTION_DISABLE_LONG_SECTION_NAMES:
804 pep_use_coff_long_section_names = 0;
806 /* Get DLLCharacteristics bits */
807 case OPTION_DYNAMIC_BASE:
808 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
810 case OPTION_FORCE_INTEGRITY:
811 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
813 case OPTION_NX_COMPAT:
814 pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
816 case OPTION_NO_ISOLATION:
817 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
820 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_SEH;
823 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_BIND;
825 case OPTION_WDM_DRIVER:
826 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_WDM_DRIVER;
828 case OPTION_TERMINAL_SERVER_AWARE:
829 pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE;
831 case OPTION_BUILD_ID:
832 if (emit_build_id != NULL)
834 free ((char *) emit_build_id);
835 emit_build_id = NULL;
838 optarg = DEFAULT_BUILD_ID_STYLE;
839 if (strcmp (optarg, "none"))
840 emit_build_id = xstrdup (optarg);
844 /* Set DLLCharacteristics bits */
845 set_pep_name ("__dll_characteristics__", pe_dll_characteristics);
853 strhash (const char *str)
855 const unsigned char *s;
862 s = (const unsigned char *) str;
863 while ((c = *s++) != '\0')
865 hash += c + (c << 17);
869 hash += len + (len << 17);
875 /* Use the output file to create a image base for relocatable DLLs. */
878 compute_dll_image_base (const char *ofile)
880 bfd_vma hash = (bfd_vma) strhash (ofile);
881 return NT_DLL_AUTO_IMAGE_BASE + ((hash << 16) & NT_DLL_AUTO_IMAGE_MASK);
885 /* Assign values to the special symbols before the linker script is
889 gld_${EMULATION_NAME}_set_symbols (void)
891 /* Run through and invent symbols for all the
892 names and insert the defaults. */
897 if (!init[IMAGEBASEOFF].inited)
899 if (link_info.relocatable)
900 init[IMAGEBASEOFF].value = 0;
901 else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
904 init[IMAGEBASEOFF].value = (pep_enable_auto_image_base
905 ? compute_dll_image_base (output_filename)
906 : NT_DLL_IMAGE_BASE);
908 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
912 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
913 init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value;
916 /* Don't do any symbol assignments if this is a relocatable link. */
917 if (link_info.relocatable)
920 /* Glue the assignments into the abs section. */
921 push_stat_ptr (&abs_output_section->children);
923 for (j = 0; init[j].ptr; j++)
925 bfd_vma val = init[j].value;
926 lang_assignment_statement_type *rv;
928 rv = lang_add_assignment (exp_assign (GET_INIT_SYMBOL_NAME (j),
929 exp_intop (val), FALSE));
930 if (init[j].size == sizeof (short))
931 *(short *) init[j].ptr = (short) val;
932 else if (init[j].size == sizeof (int))
933 *(int *) init[j].ptr = (int) val;
934 else if (init[j].size == sizeof (long))
935 *(long *) init[j].ptr = (long) val;
936 /* This might be a long long or other special type. */
937 else if (init[j].size == sizeof (bfd_vma))
938 *(bfd_vma *) init[j].ptr = val;
940 if (j == IMAGEBASEOFF)
941 image_base_statement = rv;
943 /* Restore the pointer. */
946 if (pep.FileAlignment > pep.SectionAlignment)
948 einfo (_("%P: warning, file alignment > section alignment.\n"));
952 /* This is called after the linker script and the command line options
956 gld_${EMULATION_NAME}_after_parse (void)
958 /* PR ld/6744: Warn the user if they have used an ELF-only
959 option hoping it will work on PE+. */
960 if (link_info.export_dynamic)
961 einfo (_("%P: warning: --export-dynamic is not supported for PE+ "
962 "targets, did you mean --export-all-symbols?\n"));
966 after_parse_default ();
969 /* pep-dll.c directly accesses pep_data_import_dll,
970 so it must be defined outside of #ifdef DLL_SUPPORT.
971 Note - this variable is deliberately not initialised.
972 This allows it to be treated as a common varaible, and only
973 exist in one incarnation in a multiple target enabled linker. */
974 char * pep_data_import_dll;
977 static struct bfd_link_hash_entry *pep_undef_found_sym;
980 pep_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
984 const char *hs = h->root.string;
986 sl = strlen (string);
987 if (h->type == bfd_link_hash_defined
988 && ((*hs == '@' && *string == '_'
989 && strncmp (hs + 1, string + 1, sl - 1) == 0)
990 || strncmp (hs, string, sl) == 0)
991 && h->root.string[sl] == '@')
993 pep_undef_found_sym = h;
1000 pep_fixup_stdcalls (void)
1002 static int gave_warning_message = 0;
1003 struct bfd_link_hash_entry *undef, *sym;
1005 if (pep_dll_extra_pe_debug)
1006 printf ("%s\n", __FUNCTION__);
1008 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
1009 if (undef->type == bfd_link_hash_undefined)
1011 char* at = strchr (undef->root.string, '@');
1012 int lead_at = (*undef->root.string == '@');
1014 at = strchr (undef->root.string + 1, '@');
1017 /* The symbol is a stdcall symbol, so let's look for a
1018 cdecl symbol with the same name and resolve to that. */
1019 char *cname = xstrdup (undef->root.string);
1023 at = strchr (cname, '@');
1026 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
1028 if (sym && sym->type == bfd_link_hash_defined)
1030 undef->type = bfd_link_hash_defined;
1031 undef->u.def.value = sym->u.def.value;
1032 undef->u.def.section = sym->u.def.section;
1034 if (pep_enable_stdcall_fixup == -1)
1036 einfo (_("Warning: resolving %s by linking to %s\n"),
1037 undef->root.string, cname);
1038 if (! gave_warning_message)
1040 gave_warning_message = 1;
1041 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
1042 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
1049 /* The symbol is a cdecl symbol, so we look for stdcall
1050 symbols - which means scanning the whole symbol table. */
1051 pep_undef_found_sym = 0;
1052 bfd_link_hash_traverse (link_info.hash, pep_undef_cdecl_match,
1053 (char *) undef->root.string);
1054 sym = pep_undef_found_sym;
1057 undef->type = bfd_link_hash_defined;
1058 undef->u.def.value = sym->u.def.value;
1059 undef->u.def.section = sym->u.def.section;
1061 if (pep_enable_stdcall_fixup == -1)
1063 einfo (_("Warning: resolving %s by linking to %s\n"),
1064 undef->root.string, sym->root.string);
1065 if (! gave_warning_message)
1067 gave_warning_message = 1;
1068 einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
1069 einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
1078 make_import_fixup (arelent *rel, asection *s)
1080 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
1082 bfd_vma _addend = 0;
1085 if (pep_dll_extra_pe_debug)
1086 printf ("arelent: %s@%#lx: add=%li\n", sym->name,
1087 (unsigned long) rel->address, (long) rel->addend);
1089 memset (addend, 0, sizeof (addend));
1090 switch ((rel->howto->bitsize))
1093 suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 1);
1094 if (suc && rel->howto->pc_relative)
1095 _addend = (bfd_vma) ((bfd_signed_vma) ((char) bfd_get_8 (s->owner, addend)));
1097 _addend = ((bfd_vma) bfd_get_8 (s->owner, addend)) & 0xff;
1100 suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 2);
1101 if (suc && rel->howto->pc_relative)
1102 _addend = (bfd_vma) ((bfd_signed_vma) ((short) bfd_get_16 (s->owner, addend)));
1104 _addend = ((bfd_vma) bfd_get_16 (s->owner, addend)) & 0xffff;
1107 suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 4);
1108 if (suc && rel->howto->pc_relative)
1109 _addend = (bfd_vma) ((bfd_signed_vma) ((int) bfd_get_32 (s->owner, addend)));
1111 _addend = ((bfd_vma) bfd_get_32 (s->owner, addend)) & 0xffffffff;
1114 suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 8);
1116 _addend = ((bfd_vma) bfd_get_64 (s->owner, addend));
1120 einfo (_("%C: Cannot get section contents - auto-import exception\n"),
1121 s->owner, s, rel->address);
1123 if (pep_dll_extra_pe_debug)
1125 printf ("import of 0x%lx(0x%lx) sec_addr=0x%lx", (long) _addend, (long) rel->addend, (long) rel->address);
1126 if (rel->howto->pc_relative) printf (" pcrel");
1127 printf (" %d bit rel.\n",(int) rel->howto->bitsize);
1129 pep_create_import_fixup (rel, s, _addend);
1135 pep_find_data_imports (void)
1137 struct bfd_link_hash_entry *undef, *sym;
1139 if (link_info.pei386_auto_import == 0)
1142 for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
1144 if (undef->type == bfd_link_hash_undefined)
1146 /* C++ symbols are *long*. */
1149 if (pep_dll_extra_pe_debug)
1150 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
1152 sprintf (buf, "__imp_%s", undef->root.string);
1154 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
1156 if (sym && sym->type == bfd_link_hash_defined)
1158 bfd *b = sym->u.def.section->owner;
1162 if (!bfd_generic_link_read_symbols (b))
1164 einfo (_("%B%F: could not read symbols: %E\n"), b);
1168 symbols = bfd_get_outsymbols (b);
1169 nsyms = bfd_get_symcount (b);
1171 for (i = 0; i < nsyms; i++)
1173 if (! CONST_STRNEQ (symbols[i]->name, U ("_head_")))
1176 if (pep_dll_extra_pe_debug)
1177 printf ("->%s\n", symbols[i]->name);
1179 pep_data_import_dll = (char*) (symbols[i]->name +
1180 U_SIZE ("_head_") - 1);
1184 pep_walk_relocs_of_symbol (&link_info, undef->root.string,
1187 /* Let's differentiate it somehow from defined. */
1188 undef->type = bfd_link_hash_defweak;
1189 /* We replace original name with __imp_ prefixed, this
1190 1) may trash memory 2) leads to duplicate symbol generation.
1191 Still, IMHO it's better than having name poluted. */
1192 undef->root.string = sym->root.string;
1193 undef->u.def.value = sym->u.def.value;
1194 undef->u.def.section = sym->u.def.section;
1201 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
1203 printf ("+%s\n", h->string);
1207 #endif /* DLL_SUPPORT */
1210 debug_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
1212 int *found = (int *) obj;
1214 if (strncmp (".debug_", sect->name, sizeof (".debug_") - 1) == 0)
1219 pecoff_checksum_contents (bfd *abfd,
1220 void (*process) (const void *, size_t, void *),
1223 file_ptr filepos = (file_ptr) 0;
1230 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
1233 status = bfd_bread (&b, (bfd_size_type) 1, abfd);
1239 (*process) (&b, 1, arg);
1247 write_build_id (bfd *abfd)
1249 struct pe_tdata *t = pe_data (abfd);
1251 struct bfd_link_order *link_order = NULL;
1252 unsigned char *contents;
1254 bfd_size_type build_id_size;
1255 unsigned char *build_id;
1257 /* Find the section the .build-id output section has been merged info. */
1258 for (asec = abfd->sections; asec != NULL; asec = asec->next)
1260 struct bfd_link_order *l = NULL;
1261 for (l = asec->map_head.link_order; l != NULL; l = l->next)
1263 if ((l->type == bfd_indirect_link_order))
1265 if (l->u.indirect.section == t->build_id.sec)
1279 einfo (_("%P: warning: .build-id section discarded,"
1280 " --build-id ignored.\n"));
1284 if (t->build_id.sec->contents == NULL)
1285 t->build_id.sec->contents = (unsigned char *) xmalloc (t->build_id.sec->size);
1286 contents = t->build_id.sec->contents;
1287 size = t->build_id.sec->size;
1289 build_id_size = compute_build_id_size (t->build_id.style);
1290 build_id = xmalloc (build_id_size);
1291 generate_build_id (abfd, t->build_id.style, pecoff_checksum_contents, build_id, build_id_size);
1293 bfd_vma ib = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase;
1295 /* Construct a debug directory entry which points to an immediately following CodeView record. */
1296 struct internal_IMAGE_DEBUG_DIRECTORY idd;
1297 idd.Characteristics = 0;
1298 idd.TimeDateStamp = 0;
1299 idd.MajorVersion = 0;
1300 idd.MinorVersion = 0;
1301 idd.Type = PE_IMAGE_DEBUG_TYPE_CODEVIEW;
1302 idd.SizeOfData = sizeof (CV_INFO_PDB70) + 1;
1303 idd.AddressOfRawData = asec->vma - ib + link_order->offset
1304 + sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1305 idd.PointerToRawData = asec->filepos + link_order->offset
1306 + sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1308 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *)contents;
1309 _bfd_XXi_swap_debugdir_out (abfd, &idd, ext);
1311 /* Write the debug directory enttry */
1312 if (bfd_seek (abfd, asec->filepos + link_order->offset, SEEK_SET) != 0)
1315 if ((bfd_bwrite (contents, size, abfd) != size))
1318 /* Construct the CodeView record. */
1319 CODEVIEW_INFO cvinfo;
1320 cvinfo.CVSignature = CVINFO_PDB70_CVSIGNATURE;
1323 /* Zero pad or truncate the generated build_id to fit in the CodeView record. */
1324 memset (&(cvinfo.Signature), 0, CV_INFO_SIGNATURE_LENGTH);
1325 memcpy (&(cvinfo.Signature), build_id, (build_id_size > CV_INFO_SIGNATURE_LENGTH)
1326 ? CV_INFO_SIGNATURE_LENGTH : build_id_size);
1330 /* Write the codeview record. */
1331 if (_bfd_XXi_write_codeview_record (abfd, idd.PointerToRawData, &cvinfo) == 0)
1334 /* Record the location of the debug directory in the data directory. */
1335 pe_data (link_info.output_bfd)->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
1336 = asec->vma - ib + link_order->offset;
1337 pe_data (link_info.output_bfd)->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
1338 = sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1343 /* Make .build-id section, and set up coff_tdata->build_id. */
1345 setup_build_id (bfd *ibfd)
1350 if (!validate_build_id_style (emit_build_id))
1352 einfo ("%P: warning: unrecognized --build-id style ignored.\n");
1356 flags = (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_IN_MEMORY
1357 | SEC_LINKER_CREATED | SEC_READONLY | SEC_DATA);
1358 s = bfd_make_section_anyway_with_flags (ibfd, ".build-id", flags);
1361 struct pe_tdata *t = pe_data (link_info.output_bfd);
1362 t->build_id.after_write_object_contents = &write_build_id;
1363 t->build_id.style = emit_build_id;
1364 t->build_id.sec = s;
1366 /* Section is a fixed size:
1367 One IMAGE_DEBUG_DIRECTORY entry, of type IMAGE_DEBUG_TYPE_CODEVIEW,
1368 pointing at a CV_INFO_PDB70 record containing the build-id, with a
1369 null byte for PdbFileName. */
1370 s->size = sizeof (struct external_IMAGE_DEBUG_DIRECTORY)
1371 + sizeof (CV_INFO_PDB70) + 1;
1376 einfo ("%P: warning: Cannot create .build-id section,"
1377 " --build-id ignored.\n");
1382 gld_${EMULATION_NAME}_after_open (void)
1384 after_open_default ();
1388 if (pep_dll_extra_pe_debug)
1391 struct bfd_link_hash_entry *sym;
1393 printf ("%s()\n", __FUNCTION__);
1395 for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
1396 printf ("-%s\n", sym->root.string);
1397 bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
1399 for (a = link_info.input_bfds; a; a = a->link.next)
1400 printf ("*%s\n",a->filename);
1404 if (emit_build_id != NULL)
1408 /* Find a COFF input. */
1409 for (abfd = link_info.input_bfds;
1410 abfd != (bfd *) NULL; abfd = abfd->link.next)
1411 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
1414 /* If there are no COFF input files do not try to
1415 add a build-id section. */
1417 || !setup_build_id (abfd))
1419 free ((char *) emit_build_id);
1420 emit_build_id = NULL;
1424 /* Pass the wacky PE command line options into the output bfd.
1425 FIXME: This should be done via a function, rather than by
1426 including an internal BFD header. */
1428 if (coff_data (link_info.output_bfd) == NULL
1429 || coff_data (link_info.output_bfd)->pe == 0)
1430 einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"),
1431 link_info.output_bfd);
1433 pe_data (link_info.output_bfd)->pe_opthdr = pep;
1434 pe_data (link_info.output_bfd)->dll = init[DLLOFF].value;
1435 pe_data (link_info.output_bfd)->real_flags |= real_flags;
1436 pe_data (link_info.output_bfd)->insert_timestamp = insert_timestamp;
1438 /* At this point we must decide whether to use long section names
1439 in the output or not. If the user hasn't explicitly specified
1440 on the command line, we leave it to the default for the format
1441 (object files yes, image files no), except if there is debug
1442 information present; GDB relies on the long section names to
1443 find it, so enable it in that case. */
1444 if (pep_use_coff_long_section_names < 0 && link_info.strip == strip_none)
1446 if (link_info.relocatable)
1447 pep_use_coff_long_section_names = 1;
1450 /* Iterate over all sections of all input BFDs, checking
1451 for any that begin 'debug_' and are long names. */
1452 LANG_FOR_EACH_INPUT_STATEMENT (is)
1454 int found_debug = 0;
1456 bfd_map_over_sections (is->the_bfd, debug_section_p, &found_debug);
1459 pep_use_coff_long_section_names = 1;
1466 pep_output_file_set_long_section_names (link_info.output_bfd);
1469 if (pep_enable_stdcall_fixup) /* -1=warn or 1=disable */
1470 pep_fixup_stdcalls ();
1472 pep_process_import_defs (link_info.output_bfd, &link_info);
1474 pep_find_data_imports ();
1476 /* As possibly new symbols are added by imports, we rerun
1477 stdcall/fastcall fixup here. */
1478 if (pep_enable_stdcall_fixup) /* -1=warn or 1=disable */
1479 pep_fixup_stdcalls ();
1481 #ifndef TARGET_IS_i386pep
1482 if (link_info.shared)
1484 if (!link_info.relocatable)
1486 pep_dll_build_sections (link_info.output_bfd, &link_info);
1488 #ifndef TARGET_IS_i386pep
1490 pep_exe_build_sections (link_info.output_bfd, &link_info);
1492 #endif /* DLL_SUPPORT */
1495 /* This next chunk of code tries to detect the case where you have
1496 two import libraries for the same DLL (specifically,
1497 symbolically linking libm.a and libc.a in cygwin to
1498 libcygwin.a). In those cases, it's possible for function
1499 thunks from the second implib to be used but without the
1500 head/tail objects, causing an improper import table. We detect
1501 those cases and rename the "other" import libraries to match
1502 the one the head/tail come from, so that the linker will sort
1503 things nicely and produce a valid import table. */
1505 LANG_FOR_EACH_INPUT_STATEMENT (is)
1507 if (is->the_bfd->my_archive)
1509 int idata2 = 0, reloc_count=0, is_imp = 0;
1512 /* See if this is an import library thunk. */
1513 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1515 if (strcmp (sec->name, ".idata\$2") == 0)
1517 if (CONST_STRNEQ (sec->name, ".idata\$"))
1519 reloc_count += sec->reloc_count;
1522 if (is_imp && !idata2 && reloc_count)
1524 /* It is, look for the reference to head and see if it's
1525 from our own library. */
1526 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1534 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1538 if (!bfd_generic_link_read_symbols (is->the_bfd))
1540 einfo (_("%B%F: could not read symbols: %E\n"),
1544 symbols = bfd_get_outsymbols (is->the_bfd);
1546 relocs = xmalloc ((size_t) relsize);
1547 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1552 einfo ("%X%P: unable to process relocs: %E\n");
1556 for (i = 0; i < nrelocs; i++)
1558 struct bfd_symbol *s;
1559 struct bfd_link_hash_entry * blhe;
1560 char *other_bfd_filename;
1563 s = (relocs[i]->sym_ptr_ptr)[0];
1565 if (s->flags & BSF_LOCAL)
1568 /* Thunk section with reloc to another bfd. */
1569 blhe = bfd_link_hash_lookup (link_info.hash,
1571 FALSE, FALSE, TRUE);
1574 || blhe->type != bfd_link_hash_defined)
1578 = blhe->u.def.section->owner->my_archive
1579 ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1580 : bfd_get_filename (blhe->u.def.section->owner);
1582 if (filename_cmp (bfd_get_filename
1583 (is->the_bfd->my_archive),
1584 other_bfd_filename) == 0)
1587 /* Rename this implib to match the other one. */
1588 n = xmalloc (strlen (other_bfd_filename) + 1);
1589 strcpy (n, other_bfd_filename);
1590 is->the_bfd->my_archive->filename = n;
1594 /* Note - we do not free the symbols,
1595 they are now cached in the BFD. */
1605 lang_input_statement_type *is2;
1606 lang_input_statement_type *is3;
1608 /* Careful - this is a shell script. Watch those dollar signs! */
1609 /* Microsoft import libraries have every member named the same,
1610 and not in the right order for us to link them correctly. We
1611 must detect these and rename the members so that they'll link
1612 correctly. There are three types of objects: the head, the
1613 thunks, and the sentinel(s). The head is easy; it's the one
1614 with idata2. We assume that the sentinels won't have relocs,
1615 and the thunks will. It's easier than checking the symbol
1616 table for external references. */
1617 LANG_FOR_EACH_INPUT_STATEMENT (is)
1619 if (is->the_bfd->my_archive)
1622 bfd *arch = is->the_bfd->my_archive;
1624 if (cur_arch != arch)
1630 is3 && is3->the_bfd->my_archive == arch;
1631 is3 = (lang_input_statement_type *) is3->next)
1633 /* A MS dynamic import library can also contain static
1634 members, so look for the first element with a .dll
1635 extension, and use that for the remainder of the
1637 pnt = strrchr (is3->the_bfd->filename, '.');
1638 if (pnt != NULL && filename_cmp (pnt, ".dll") == 0)
1646 /* OK, found one. Now look to see if the remaining
1647 (dynamic import) members use the same name. */
1649 is2 && is2->the_bfd->my_archive == arch;
1650 is2 = (lang_input_statement_type *) is2->next)
1652 /* Skip static members, ie anything with a .obj
1654 pnt = strrchr (is2->the_bfd->filename, '.');
1655 if (pnt != NULL && filename_cmp (pnt, ".obj") == 0)
1658 if (filename_cmp (is3->the_bfd->filename,
1659 is2->the_bfd->filename))
1668 /* This fragment might have come from an .obj file in a Microsoft
1669 import, and not an actual import record. If this is the case,
1670 then leave the filename alone. */
1671 pnt = strrchr (is->the_bfd->filename, '.');
1673 if (is_ms_arch && (filename_cmp (pnt, ".dll") == 0))
1675 int idata2 = 0, reloc_count=0;
1677 char *new_name, seq;
1679 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1681 if (strcmp (sec->name, ".idata\$2") == 0)
1683 reloc_count += sec->reloc_count;
1686 if (idata2) /* .idata2 is the TOC */
1688 else if (reloc_count > 0) /* thunks */
1693 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1694 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1695 is->the_bfd->filename = new_name;
1697 new_name = xmalloc (strlen (is->filename) + 3);
1698 sprintf (new_name, "%s.%c", is->filename, seq);
1699 is->filename = new_name;
1707 gld_${EMULATION_NAME}_before_allocation (void)
1710 before_allocation_default ();
1714 /* This is called when an input file isn't recognized as a BFD. We
1715 check here for .DEF files and pull them in automatically. */
1718 saw_option (char *option)
1724 for (i = 0; init[i].ptr; i++)
1725 if (strcmp (GET_INIT_SYMBOL_NAME (i), option) == 0)
1726 return init[i].inited;
1729 #endif /* DLL_SUPPORT */
1732 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1735 const char *ext = entry->filename + strlen (entry->filename) - 4;
1737 if (filename_cmp (ext, ".def") == 0 || filename_cmp (ext, ".DEF") == 0)
1739 pep_def_file = def_file_parse (entry->filename, pep_def_file);
1743 int i, buflen=0, len;
1746 for (i = 0; i < pep_def_file->num_exports; i++)
1748 len = strlen (pep_def_file->exports[i].internal_name);
1749 if (buflen < len + 2)
1753 buf = xmalloc (buflen);
1755 for (i = 0; i < pep_def_file->num_exports; i++)
1757 struct bfd_link_hash_entry *h;
1759 sprintf (buf, "%s%s", U (""),
1760 pep_def_file->exports[i].internal_name);
1762 h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1763 if (h == (struct bfd_link_hash_entry *) NULL)
1764 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1765 if (h->type == bfd_link_hash_new)
1767 h->type = bfd_link_hash_undefined;
1768 h->u.undef.abfd = NULL;
1769 bfd_link_add_undef (link_info.hash, h);
1774 /* def_file_print (stdout, pep_def_file); */
1775 if (pep_def_file->is_dll == 1)
1776 link_info.shared = 1;
1778 if (pep_def_file->base_address != (bfd_vma)(-1))
1781 = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase
1782 = init[IMAGEBASEOFF].value
1783 = pep_def_file->base_address;
1784 init[IMAGEBASEOFF].inited = 1;
1785 if (image_base_statement)
1786 image_base_statement->exp
1787 = exp_assign ("__image_base__", exp_intop (pep.ImageBase),
1791 if (pep_def_file->stack_reserve != -1
1792 && ! saw_option ("__size_of_stack_reserve__"))
1794 pep.SizeOfStackReserve = pep_def_file->stack_reserve;
1795 if (pep_def_file->stack_commit != -1)
1796 pep.SizeOfStackCommit = pep_def_file->stack_commit;
1798 if (pep_def_file->heap_reserve != -1
1799 && ! saw_option ("__size_of_heap_reserve__"))
1801 pep.SizeOfHeapReserve = pep_def_file->heap_reserve;
1802 if (pep_def_file->heap_commit != -1)
1803 pep.SizeOfHeapCommit = pep_def_file->heap_commit;
1813 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1817 #ifdef TARGET_IS_i386pep
1818 pep_dll_id_target ("pei-x86-64");
1820 if (pep_bfd_is_dll (entry->the_bfd))
1821 return pep_implied_import_dll (entry->filename);
1827 gld_${EMULATION_NAME}_finish (void)
1833 if (link_info.shared
1834 || (!link_info.relocatable && pep_def_file->num_exports != 0))
1836 pep_dll_fill_sections (link_info.output_bfd, &link_info);
1837 if (pep_implib_filename)
1838 pep_dll_generate_implib (pep_def_file, pep_implib_filename, &link_info);
1841 if (pep_out_def_filename)
1842 pep_dll_generate_def_file (pep_out_def_filename);
1843 #endif /* DLL_SUPPORT */
1845 /* I don't know where .idata gets set as code, but it shouldn't be. */
1847 asection *asec = bfd_get_section_by_name (link_info.output_bfd, ".idata");
1851 asec->flags &= ~SEC_CODE;
1852 asec->flags |= SEC_DATA;
1858 /* Place an orphan section.
1860 We use this to put sections in a reasonable place in the file, and
1861 to ensure that they are aligned as required.
1863 We handle grouped sections here as well. A section named .foo\$nn
1864 goes into the output section .foo. All grouped sections are sorted
1867 Grouped sections for the default sections are handled by the
1868 default linker script using wildcards, and are sorted by
1871 static lang_output_section_statement_type *
1872 gld_${EMULATION_NAME}_place_orphan (asection *s,
1873 const char *secname,
1876 const char *orig_secname = secname;
1877 char *dollar = NULL;
1878 lang_output_section_statement_type *os;
1879 lang_statement_list_type add_child;
1880 lang_output_section_statement_type *match_by_name = NULL;
1881 lang_statement_union_type **pl;
1883 /* Look through the script to see where to place this section. */
1884 if (!link_info.relocatable
1885 && (dollar = strchr (secname, '\$')) != NULL)
1887 size_t len = dollar - secname;
1888 char *newname = xmalloc (len + 1);
1889 memcpy (newname, secname, len);
1890 newname[len] = '\0';
1894 lang_list_init (&add_child);
1897 if (constraint == 0)
1898 for (os = lang_output_section_find (secname);
1900 os = next_matching_output_section_statement (os, 0))
1902 /* If we don't match an existing output section, tell
1903 lang_insert_orphan to create a new output section. */
1904 constraint = SPECIAL;
1906 if (os->bfd_section != NULL
1907 && (os->bfd_section->flags == 0
1908 || ((s->flags ^ os->bfd_section->flags)
1909 & (SEC_LOAD | SEC_ALLOC)) == 0))
1911 /* We already have an output section statement with this
1912 name, and its bfd section has compatible flags.
1913 If the section already exists but does not have any flags set,
1914 then it has been created by the linker, probably as a result of
1915 a --section-start command line switch. */
1916 lang_add_section (&add_child, s, NULL, os);
1920 /* Save unused output sections in case we can match them
1921 against orphans later. */
1922 if (os->bfd_section == NULL)
1926 /* If we didn't match an active output section, see if we matched an
1927 unused one and use that. */
1928 if (os == NULL && match_by_name)
1930 lang_add_section (&match_by_name->children, s, NULL, match_by_name);
1931 return match_by_name;
1936 static struct orphan_save hold[] =
1939 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1942 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1945 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1948 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1954 enum orphan_save_index
1962 static int orphan_init_done = 0;
1963 struct orphan_save *place;
1964 lang_output_section_statement_type *after;
1965 etree_type *address;
1967 if (!orphan_init_done)
1969 struct orphan_save *ho;
1970 for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1971 if (ho->name != NULL)
1973 ho->os = lang_output_section_find (ho->name);
1974 if (ho->os != NULL && ho->os->flags == 0)
1975 ho->os->flags = ho->flags;
1977 orphan_init_done = 1;
1980 /* Try to put the new output section in a reasonable place based
1981 on the section name and section flags. */
1984 if ((s->flags & SEC_ALLOC) == 0)
1986 else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1987 place = &hold[orphan_bss];
1988 else if ((s->flags & SEC_READONLY) == 0)
1989 place = &hold[orphan_data];
1990 else if ((s->flags & SEC_CODE) == 0)
1992 place = (!strncmp (secname, ".idata\$", 7) ? &hold[orphan_idata]
1993 : &hold[orphan_rodata]);
1996 place = &hold[orphan_text];
2001 if (place->os == NULL)
2002 place->os = lang_output_section_find (place->name);
2005 after = lang_output_section_find_by_flags (s, &place->os, NULL);
2007 /* *ABS* is always the first output section statement. */
2008 after = (&lang_output_section_statement.head
2009 ->output_section_statement);
2012 /* All sections in an executable must be aligned to a page boundary.
2013 In a relocatable link, just preserve the incoming alignment; the
2014 address is discarded by lang_insert_orphan in that case, anyway. */
2015 address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
2016 os = lang_insert_orphan (s, secname, constraint, after, place, address,
2018 if (link_info.relocatable)
2020 os->section_alignment = s->alignment_power;
2021 os->bfd_section->alignment_power = s->alignment_power;
2025 /* If the section name has a '\$', sort it with the other '\$'
2027 for (pl = &os->children.head; *pl != NULL; pl = &(*pl)->header.next)
2029 lang_input_section_type *ls;
2032 if ((*pl)->header.type != lang_input_section_enum)
2035 ls = &(*pl)->input_section;
2037 lname = bfd_get_section_name (ls->section->owner, ls->section);
2038 if (strchr (lname, '\$') != NULL
2039 && (dollar == NULL || strcmp (orig_secname, lname) < 0))
2043 if (add_child.head != NULL)
2045 *add_child.tail = *pl;
2046 *pl = add_child.head;
2053 gld_${EMULATION_NAME}_open_dynamic_archive
2054 (const char *arch ATTRIBUTE_UNUSED,
2055 search_dirs_type *search,
2056 lang_input_statement_type *entry)
2060 const char * format;
2061 bfd_boolean use_prefix;
2065 /* Preferred explicit import library for dll's. */
2066 { "lib%s.dll.a", FALSE },
2067 /* Alternate explicit import library for dll's. */
2068 { "%s.dll.a", FALSE },
2069 /* "libfoo.a" could be either an import lib or a static lib.
2070 For backwards compatibility, libfoo.a needs to precede
2071 libfoo.dll and foo.dll in the search. */
2072 { "lib%s.a", FALSE },
2073 /* The 'native' spelling of an import lib name is "foo.lib". */
2074 { "%s.lib", FALSE },
2076 /* Try "<prefix>foo.dll" (preferred dll name, if specified). */
2077 { "%s%s.dll", TRUE },
2079 /* Try "libfoo.dll" (default preferred dll name). */
2080 { "lib%s.dll", FALSE },
2081 /* Finally try 'native' dll name "foo.dll". */
2082 { "%s.dll", FALSE },
2083 /* Note: If adding more formats to this table, make sure to check to
2084 see if their length is longer than libname_fmt[0].format, and if
2085 so, update the call to xmalloc() below. */
2088 static unsigned int format_max_len = 0;
2089 const char * filename;
2095 if (! entry->flags.maybe_archive || entry->flags.full_name_provided)
2098 filename = entry->filename;
2100 if (format_max_len == 0)
2101 /* We need to allow space in the memory that we are going to allocate
2102 for the characters in the format string. Since the format array is
2103 static we only need to calculate this information once. In theory
2104 this value could also be computed statically, but this introduces
2105 the possibility for a discrepancy and hence a possible memory
2106 corruption. The lengths we compute here will be too long because
2107 they will include any formating characters (%s) in the strings, but
2108 this will not matter. */
2109 for (i = 0; libname_fmt[i].format; i++)
2110 if (format_max_len < strlen (libname_fmt[i].format))
2111 format_max_len = strlen (libname_fmt[i].format);
2113 full_string = xmalloc (strlen (search->name)
2117 + (pep_dll_search_prefix
2118 ? strlen (pep_dll_search_prefix) : 0)
2120 /* Allow for the terminating NUL and for the path
2121 separator character that is inserted between
2122 search->name and the start of the format string. */
2125 sprintf (full_string, "%s/", search->name);
2126 base_string = full_string + strlen (full_string);
2128 for (i = 0; libname_fmt[i].format; i++)
2131 if (libname_fmt[i].use_prefix)
2133 if (!pep_dll_search_prefix)
2135 sprintf (base_string, libname_fmt[i].format, pep_dll_search_prefix, filename);
2139 sprintf (base_string, libname_fmt[i].format, filename);
2141 if (ldfile_try_open_bfd (full_string, entry))
2145 if (!libname_fmt[i].format)
2151 entry->filename = full_string;
2157 gld_${EMULATION_NAME}_find_potential_libraries
2158 (char *name, lang_input_statement_type *entry)
2160 return ldfile_open_file_search (name, entry, "", ".lib");
2164 gld_${EMULATION_NAME}_get_script (int *isfile)
2166 # Scripts compiled in.
2167 # sed commands to quote an ld script as a C string.
2168 sc="-f stringify.sed"
2174 if (link_info.relocatable && config.build_constructors)
2177 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
2178 echo ' ; else if (link_info.relocatable) return' >> e${EMULATION_NAME}.c
2179 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
2180 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
2181 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
2182 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
2183 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
2184 if test -n "$GENERATE_AUTO_IMPORT_SCRIPT" ; then
2185 echo ' ; else if (link_info.pei386_auto_import == 1 && link_info.pei386_runtime_pseudo_reloc != 2) return' >> e${EMULATION_NAME}.c
2186 sed $sc ldscripts/${EMULATION_NAME}.xa >> e${EMULATION_NAME}.c
2188 echo ' ; else return' >> e${EMULATION_NAME}.c
2189 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
2190 echo '; }' >> e${EMULATION_NAME}.c
2195 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
2197 gld_${EMULATION_NAME}_before_parse,
2200 gld_${EMULATION_NAME}_after_parse,
2201 gld_${EMULATION_NAME}_after_open,
2202 after_allocation_default,
2203 set_output_arch_default,
2204 ldemul_default_target,
2205 gld_${EMULATION_NAME}_before_allocation,
2206 gld_${EMULATION_NAME}_get_script,
2207 "${EMULATION_NAME}",
2209 gld_${EMULATION_NAME}_finish,
2210 NULL, /* Create output section statements. */
2211 gld_${EMULATION_NAME}_open_dynamic_archive,
2212 gld_${EMULATION_NAME}_place_orphan,
2213 gld_${EMULATION_NAME}_set_symbols,
2214 NULL, /* parse_args */
2215 gld${EMULATION_NAME}_add_options,
2216 gld${EMULATION_NAME}_handle_option,
2217 gld_${EMULATION_NAME}_unrecognized_file,
2218 gld_${EMULATION_NAME}_list_options,
2219 gld_${EMULATION_NAME}_recognized_file,
2220 gld_${EMULATION_NAME}_find_potential_libraries,
2221 NULL, /* new_vers_pattern. */
2222 NULL /* extra_map_file_text */