projects / deliverable / binutils-gdb.git / blob
? search:


0ffeffc061b4992cd6a2679e55e4194d1afc465c
[deliverable/binutils-gdb.git] / ld / emultempl / pe.em
1 # This shell script emits a C file. -*- C -*-
2 # It does some substitutions.
3 rm -f e${EMULATION_NAME}.c
4 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
5 cat >>e${EMULATION_NAME}.c <<EOF
6 /* This file is part of GLD, the Gnu Linker.
7 Copyright 1995, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22
23 /* For WINDOWS_NT */
24 /* The original file generated returned different default scripts depending
25 on whether certain switches were set, but these switches pertain to the
26 Linux system and that particular version of coff. In the NT case, we
27 only determine if the subsystem is console or windows in order to select
28 the correct entry point by default. */
29
30 #include "bfd.h"
31 #include "sysdep.h"
32 #include "bfdlink.h"
33 #include "getopt.h"
34 #include "libiberty.h"
35 #include "ld.h"
36 #include "ldmain.h"
37 #include "ldgram.h"
38 #include "ldexp.h"
39 #include "ldlang.h"
40 #include "ldfile.h"
41 #include "ldemul.h"
42 #include "ldlex.h"
43 #include "ldmisc.h"
44 #include "ldctor.h"
45 #include "coff/internal.h"
46
47 /* FIXME: This is a BFD internal header file, and we should not be
48 using it here. */
49 #include "../bfd/libcoff.h"
50
51 #include "deffile.h"
52 #include "pe-dll.h"
53
54 #define TARGET_IS_${EMULATION_NAME}
55
56 /* Permit the emulation parameters to override the default section
57 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes
58 it seem that include/coff/internal.h should not define
59 PE_DEF_SECTION_ALIGNMENT. */
60 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
61 #undef PE_DEF_SECTION_ALIGNMENT
62 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
63 #endif
64
65 #if defined(TARGET_IS_i386pe)
66 #define DLL_SUPPORT
67 #endif
68 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe) || defined(TARGET_IS_armpe)
69 #define DLL_SUPPORT
70 #endif
71
72 #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
73 #define PE_DEF_SUBSYSTEM 3
74 #else
75 #undef NT_EXE_IMAGE_BASE
76 #undef PE_DEF_SECTION_ALIGNMENT
77 #undef PE_DEF_FILE_ALIGNMENT
78 #define NT_EXE_IMAGE_BASE 0x00010000
79 #ifdef TARGET_IS_armpe
80 #define PE_DEF_SECTION_ALIGNMENT 0x00001000
81 #define PE_DEF_SUBSYSTEM 9
82 #else
83 #define PE_DEF_SECTION_ALIGNMENT 0x00000400
84 #define PE_DEF_SUBSYSTEM 2
85 #endif
86 #define PE_DEF_FILE_ALIGNMENT 0x00000200
87 #endif
88
89 #ifdef TARGET_IS_arm_epoc_pe
90 #define bfd_arm_pe_allocate_interworking_sections \
91 bfd_arm_epoc_pe_allocate_interworking_sections
92 #define bfd_arm_pe_get_bfd_for_interworking \
93 bfd_arm_epoc_pe_get_bfd_for_interworking
94 #define bfd_arm_pe_process_before_allocation \
95 bfd_arm_epoc_pe_process_before_allocation
96 #endif
97
98 static void gld_${EMULATION_NAME}_set_symbols PARAMS ((void));
99 static void gld_${EMULATION_NAME}_after_open PARAMS ((void));
100 static void gld_${EMULATION_NAME}_before_parse PARAMS ((void));
101 static void gld_${EMULATION_NAME}_after_parse PARAMS ((void));
102 static void gld_${EMULATION_NAME}_before_allocation PARAMS ((void));
103 static boolean gld_${EMULATION_NAME}_place_orphan
104 PARAMS ((lang_input_statement_type *, asection *));
105 static char *gld_${EMULATION_NAME}_get_script PARAMS ((int *));
106 static int gld_${EMULATION_NAME}_parse_args PARAMS ((int, char **));
107 static void gld_${EMULATION_NAME}_finish PARAMS ((void));
108 static boolean gld_${EMULATION_NAME}_open_dynamic_archive
109 PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
110
111 static struct internal_extra_pe_aouthdr pe;
112 static int dll;
113 static int support_old_code = 0;
114 static char * thumb_entry_symbol = NULL;
115 static lang_assignment_statement_type *image_base_statement = 0;
116
117 #ifdef DLL_SUPPORT
118 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable */
119 static char *pe_out_def_filename = NULL;
120 static char *pe_implib_filename = NULL;
121 static int pe_enable_auto_image_base = 0;
122 #endif
123
124 extern const char *output_filename;
125
126 static void
127 gld_${EMULATION_NAME}_before_parse()
128 {
129 output_filename = "${EXECUTABLE_NAME:-a.exe}";
130 ldfile_output_architecture = bfd_arch_${ARCH};
131 #ifdef DLL_SUPPORT
132 config.has_shared = 1;
133
134 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
135 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
136 lang_add_entry ("WinMainCRTStartup", 1);
137 #else
138 lang_add_entry ("_WinMainCRTStartup", 1);
139 #endif
140 #endif
141 #endif
142 }
143 \f
144 /* PE format extra command line options. */
145
146 /* Used for setting flags in the PE header. */
147 #define OPTION_BASE_FILE (300 + 1)
148 #define OPTION_DLL (OPTION_BASE_FILE + 1)
149 #define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
150 #define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
151 #define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
152 #define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
153 #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
154 #define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
155 #define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
156 #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
157 #define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
158 #define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
159 #define OPTION_SUBSYSTEM (OPTION_STACK + 1)
160 #define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
161 #define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
162 #define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
163 #define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
164 #define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
165 #define OPTION_KILL_ATS (OPTION_EXCLUDE_SYMBOLS + 1)
166 #define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
167 #define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
168 #define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
169 #define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
170 #define OPTION_THUMB_ENTRY (OPTION_IMPLIB_FILENAME + 1)
171 #define OPTION_WARN_DUPLICATE_EXPORTS (OPTION_THUMB_ENTRY + 1)
172 #define OPTION_IMP_COMPAT (OPTION_WARN_DUPLICATE_EXPORTS + 1)
173 #define OPTION_ENABLE_AUTO_IMAGE_BASE (OPTION_IMP_COMPAT + 1)
174 #define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
175
176 static struct option longopts[] =
177 {
178 /* PE options */
179 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
180 {"dll", no_argument, NULL, OPTION_DLL},
181 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
182 {"heap", required_argument, NULL, OPTION_HEAP},
183 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
184 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
185 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
186 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
187 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
188 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
189 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
190 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
191 {"stack", required_argument, NULL, OPTION_STACK},
192 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
193 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
194 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
195 #ifdef DLL_SUPPORT
196 /* getopt allows abbreviations, so we do this to stop it from treating -o
197 as an abbreviation for this option */
198 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
199 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
200 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
201 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
202 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
203 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
204 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
205 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
206 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
207 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
208 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
209 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
210 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
211 #endif
212 {NULL, no_argument, NULL, 0}
213 };
214
215
216 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
217 parameters which may be input from the command line */
218
219 typedef struct
220 {
221 void *ptr;
222 int size;
223 int value;
224 char *symbol;
225 int inited;
226 } definfo;
227
228 #define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
229
230 static definfo init[] =
231 {
232 /* imagebase must be first */
233 #define IMAGEBASEOFF 0
234 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
235 #define DLLOFF 1
236 {&dll, sizeof(dll), 0, "__dll__", 0},
237 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
238 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
239 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
240 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
241 D(MajorImageVersion,"__major_image_version__", 1),
242 D(MinorImageVersion,"__minor_image_version__", 0),
243 #ifdef TARGET_IS_armpe
244 D(MajorSubsystemVersion,"__major_subsystem_version__", 2),
245 #else
246 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
247 #endif
248 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
249 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
250 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x2000000),
251 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
252 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
253 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
254 D(LoaderFlags,"__loader_flags__", 0x0),
255 { NULL, 0, 0, NULL, 0 }
256 };
257
258 static void
259 gld_${EMULATION_NAME}_list_options (file)
260 FILE * file;
261 {
262 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
263 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
264 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
265 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
266 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
267 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
268 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
269 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
270 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
271 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
272 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
273 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
274 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
275 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
276 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
277 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n"));
278 #ifdef DLL_SUPPORT
279 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
280 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
281 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
282 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
283 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
284 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
285 fprintf (file, _(" --out-implib <file> Generate import library\n"));
286 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
287 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
288 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n"));
289 fprintf (file, _(" create __imp_<SYMBOL> as well.\n"));
290 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n"));
291 fprintf (file, _(" unless user specifies one\n"));
292 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
293 #endif
294 }
295
296 static void
297 set_pe_name (name, val)
298 char *name;
299 long val;
300 {
301 int i;
302 /* Find the name and set it. */
303 for (i = 0; init[i].ptr; i++)
304 {
305 if (strcmp (name, init[i].symbol) == 0)
306 {
307 init[i].value = val;
308 init[i].inited = 1;
309 return;
310 }
311 }
312 abort();
313 }
314
315
316 static void
317 set_pe_subsystem ()
318 {
319 const char *sver;
320 int len;
321 int i;
322 static const struct
323 {
324 const char *name;
325 const int value;
326 const char *entry;
327 }
328 v[] =
329 {
330 { "native", 1, "NtProcessStartup" },
331 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
332 { "windows", 2, "WinMainCRTStartup" },
333 #else
334 { "windows", 2, "WinMainCRTStartup" },
335 #endif
336 { "console", 3, "mainCRTStartup" },
337 #if 0
338 /* The Microsoft linker does not recognize this. */
339 { "os2", 5, "" },
340 #endif
341 { "posix", 7, "__PosixProcessStartup"},
342 { "wince", 9, "_WinMainCRTStartup" },
343 { 0, 0, 0 }
344 };
345
346 sver = strchr (optarg, ':');
347 if (sver == NULL)
348 len = strlen (optarg);
349 else
350 {
351 char *end;
352
353 len = sver - optarg;
354 set_pe_name ("__major_subsystem_version__",
355 strtoul (sver + 1, &end, 0));
356 if (*end == '.')
357 set_pe_name ("__minor_subsystem_version__",
358 strtoul (end + 1, &end, 0));
359 if (*end != '\0')
360 einfo (_("%P: warning: bad version number in -subsystem option\n"));
361 }
362
363 for (i = 0; v[i].name; i++)
364 {
365 if (strncmp (optarg, v[i].name, len) == 0
366 && v[i].name[len] == '\0')
367 {
368 const char *initial_symbol_char;
369 const char *entry;
370
371 set_pe_name ("__subsystem__", v[i].value);
372
373 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
374 if (*initial_symbol_char == '\0')
375 entry = v[i].entry;
376 else
377 {
378 char *alc_entry;
379
380 /* lang_add_entry expects its argument to be permanently
381 allocated, so we don't free this string. */
382 alc_entry = xmalloc (strlen (initial_symbol_char)
383 + strlen (v[i].entry)
384 + 1);
385 strcpy (alc_entry, initial_symbol_char);
386 strcat (alc_entry, v[i].entry);
387 entry = alc_entry;
388 }
389
390 lang_add_entry (entry, 1);
391
392 return;
393 }
394 }
395
396 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
397 }
398
399
400
401 static void
402 set_pe_value (name)
403 char *name;
404
405 {
406 char *end;
407
408 set_pe_name (name, strtoul (optarg, &end, 0));
409
410 if (end == optarg)
411 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
412
413 optarg = end;
414 }
415
416 static void
417 set_pe_stack_heap (resname, comname)
418 char *resname;
419 char *comname;
420 {
421 set_pe_value (resname);
422
423 if (*optarg == ',')
424 {
425 optarg++;
426 set_pe_value (comname);
427 }
428 else if (*optarg)
429 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
430 }
431
432
433
434 static int
435 gld_${EMULATION_NAME}_parse_args(argc, argv)
436 int argc;
437 char **argv;
438 {
439 int longind;
440 int optc;
441 int prevoptind = optind;
442 int prevopterr = opterr;
443 int wanterror;
444 static int lastoptind = -1;
445
446 if (lastoptind != optind)
447 opterr = 0;
448 wanterror = opterr;
449
450 lastoptind = optind;
451
452 optc = getopt_long_only (argc, argv, "-", longopts, &longind);
453 opterr = prevopterr;
454
455 switch (optc)
456 {
457 default:
458 if (wanterror)
459 xexit (1);
460 optind = prevoptind;
461 return 0;
462
463 case OPTION_BASE_FILE:
464 link_info.base_file = (PTR) fopen (optarg, FOPEN_WB);
465 if (link_info.base_file == NULL)
466 {
467 /* xgettext:c-format */
468 fprintf (stderr, _("%s: Can't open base file %s\n"),
469 program_name, optarg);
470 xexit (1);
471 }
472 break;
473
474 /* PE options */
475 case OPTION_HEAP:
476 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
477 break;
478 case OPTION_STACK:
479 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
480 break;
481 case OPTION_SUBSYSTEM:
482 set_pe_subsystem ();
483 break;
484 case OPTION_MAJOR_OS_VERSION:
485 set_pe_value ("__major_os_version__");
486 break;
487 case OPTION_MINOR_OS_VERSION:
488 set_pe_value ("__minor_os_version__");
489 break;
490 case OPTION_MAJOR_SUBSYSTEM_VERSION:
491 set_pe_value ("__major_subsystem_version__");
492 break;
493 case OPTION_MINOR_SUBSYSTEM_VERSION:
494 set_pe_value ("__minor_subsystem_version__");
495 break;
496 case OPTION_MAJOR_IMAGE_VERSION:
497 set_pe_value ("__major_image_version__");
498 break;
499 case OPTION_MINOR_IMAGE_VERSION:
500 set_pe_value ("__minor_image_version__");
501 break;
502 case OPTION_FILE_ALIGNMENT:
503 set_pe_value ("__file_alignment__");
504 break;
505 case OPTION_SECTION_ALIGNMENT:
506 set_pe_value ("__section_alignment__");
507 break;
508 case OPTION_DLL:
509 set_pe_name ("__dll__", 1);
510 break;
511 case OPTION_IMAGE_BASE:
512 set_pe_value ("__image_base__");
513 break;
514 case OPTION_SUPPORT_OLD_CODE:
515 support_old_code = 1;
516 break;
517 case OPTION_THUMB_ENTRY:
518 thumb_entry_symbol = optarg;
519 break;
520 #ifdef DLL_SUPPORT
521 case OPTION_OUT_DEF:
522 pe_out_def_filename = xstrdup (optarg);
523 break;
524 case OPTION_EXPORT_ALL:
525 pe_dll_export_everything = 1;
526 break;
527 case OPTION_EXCLUDE_SYMBOLS:
528 pe_dll_add_excludes (optarg);
529 break;
530 case OPTION_KILL_ATS:
531 pe_dll_kill_ats = 1;
532 break;
533 case OPTION_STDCALL_ALIASES:
534 pe_dll_stdcall_aliases = 1;
535 break;
536 case OPTION_ENABLE_STDCALL_FIXUP:
537 pe_enable_stdcall_fixup = 1;
538 break;
539 case OPTION_DISABLE_STDCALL_FIXUP:
540 pe_enable_stdcall_fixup = 0;
541 break;
542 case OPTION_IMPLIB_FILENAME:
543 pe_implib_filename = xstrdup (optarg);
544 break;
545 case OPTION_WARN_DUPLICATE_EXPORTS:
546 pe_dll_warn_dup_exports = 1;
547 break;
548 case OPTION_IMP_COMPAT:
549 pe_dll_compat_implib = 1;
550 break;
551 case OPTION_ENABLE_AUTO_IMAGE_BASE:
552 pe_enable_auto_image_base = 1;
553 break;
554 case OPTION_DISABLE_AUTO_IMAGE_BASE:
555 pe_enable_auto_image_base = 0;
556 break;
557 #endif
558 }
559 return 1;
560 }
561 \f
562
563 #ifdef DLL_SUPPORT
564 static unsigned long
565 strhash (const char *str)
566 {
567 const unsigned char *s;
568 unsigned long hash;
569 unsigned int c;
570 unsigned int len;
571
572 hash = 0;
573 len = 0;
574 s = (const unsigned char *) str;
575 while ((c = *s++) != '\0')
576 {
577 hash += c + (c << 17);
578 hash ^= hash >> 2;
579 ++len;
580 }
581 hash += len + (len << 17);
582 hash ^= hash >> 2;
583
584 return hash;
585 }
586
587 /* Use the output file to create a image base for relocatable DLLs. */
588 static unsigned long
589 compute_dll_image_base (const char *ofile)
590 {
591 unsigned long hash = strhash (ofile);
592 return 0x60000000 | ((hash << 16) & 0x0FFC0000);
593 }
594 #endif
595
596 /* Assign values to the special symbols before the linker script is
597 read. */
598
599 static void
600 gld_${EMULATION_NAME}_set_symbols ()
601 {
602 /* Run through and invent symbols for all the
603 names and insert the defaults. */
604 int j;
605 lang_statement_list_type *save;
606
607 if (!init[IMAGEBASEOFF].inited)
608 {
609 if (link_info.relocateable)
610 init[IMAGEBASEOFF].value = 0;
611 else if (init[DLLOFF].value || link_info.shared)
612 #ifdef DLL_SUPPORT
613 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
614 compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
615 #else
616 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
617 #endif
618 else
619 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
620 }
621
622 /* Don't do any symbol assignments if this is a relocateable link. */
623 if (link_info.relocateable)
624 return;
625
626 /* Glue the assignments into the abs section */
627 save = stat_ptr;
628
629 stat_ptr = &(abs_output_section->children);
630
631 for (j = 0; init[j].ptr; j++)
632 {
633 long val = init[j].value;
634 lang_assignment_statement_type *rv;
635 rv = lang_add_assignment (exp_assop ('=' ,init[j].symbol, exp_intop (val)));
636 if (init[j].size == sizeof(short))
637 *(short *)init[j].ptr = val;
638 else if (init[j].size == sizeof(int))
639 *(int *)init[j].ptr = val;
640 else if (init[j].size == sizeof(long))
641 *(long *)init[j].ptr = val;
642 /* This might be a long long or other special type. */
643 else if (init[j].size == sizeof(bfd_vma))
644 *(bfd_vma *)init[j].ptr = val;
645 else abort();
646 if (j == IMAGEBASEOFF)
647 image_base_statement = rv;
648 }
649 /* Restore the pointer. */
650 stat_ptr = save;
651
652 if (pe.FileAlignment >
653 pe.SectionAlignment)
654 {
655 einfo (_("%P: warning, file alignment > section alignment.\n"));
656 }
657 }
658
659 /* This is called after the linker script and the command line options
660 have been read. */
661
662 static void
663 gld_${EMULATION_NAME}_after_parse ()
664 {
665 /* The Windows libraries are designed for the linker to treat the
666 entry point as an undefined symbol. Otherwise, the .obj that
667 defines mainCRTStartup is brought in because it is the first
668 encountered in libc.lib and it has other symbols in it which will
669 be pulled in by the link process. To avoid this, we act as
670 though the user specified -u with the entry point symbol.
671
672 This function is called after the linker script and command line
673 options have been read, so at this point we know the right entry
674 point. This function is called before the input files are
675 opened, so registering the symbol as undefined will make a
676 difference. */
677
678 if (! link_info.relocateable && entry_symbol != NULL)
679 ldlang_add_undef (entry_symbol);
680 }
681
682 #ifdef DLL_SUPPORT
683 static struct bfd_link_hash_entry *pe_undef_found_sym;
684
685 static boolean
686 pe_undef_cdecl_match (h, string)
687 struct bfd_link_hash_entry *h;
688 PTR string;
689 {
690 int sl = strlen (string);
691 if (h->type == bfd_link_hash_defined
692 && strncmp (h->root.string, string, sl) == 0
693 && h->root.string[sl] == '@')
694 {
695 pe_undef_found_sym = h;
696 return false;
697 }
698 return true;
699 }
700
701 static void
702 pe_fixup_stdcalls ()
703 {
704 static int gave_warning_message = 0;
705 struct bfd_link_hash_entry *undef, *sym;
706 char *at;
707 for (undef = link_info.hash->undefs; undef; undef=undef->next)
708 if (undef->type == bfd_link_hash_undefined)
709 {
710 at = strchr (undef->root.string, '@');
711 if (at)
712 {
713 /* The symbol is a stdcall symbol, so let's look for a cdecl
714 symbol with the same name and resolve to that */
715 char *cname = xstrdup (undef->root.string);
716 at = strchr (cname, '@');
717 *at = 0;
718 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
719 if (sym && sym->type == bfd_link_hash_defined)
720 {
721 undef->type = bfd_link_hash_defined;
722 undef->u.def.value = sym->u.def.value;
723 undef->u.def.section = sym->u.def.section;
724 if (pe_enable_stdcall_fixup == -1)
725 {
726 einfo (_("Warning: resolving %s by linking to %s\n"),
727 undef->root.string, cname);
728 if (! gave_warning_message)
729 {
730 gave_warning_message = 1;
731 einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
732 einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
733 }
734 }
735 }
736 }
737 else
738 {
739 /* The symbol is a cdecl symbol, so we look for stdcall
740 symbols - which means scanning the whole symbol table */
741 pe_undef_found_sym = 0;
742 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
743 (PTR) undef->root.string);
744 sym = pe_undef_found_sym;
745 if (sym)
746 {
747 undef->type = bfd_link_hash_defined;
748 undef->u.def.value = sym->u.def.value;
749 undef->u.def.section = sym->u.def.section;
750 if (pe_enable_stdcall_fixup == -1)
751 {
752 einfo (_("Warning: resolving %s by linking to %s\n"),
753 undef->root.string, sym->root.string);
754 if (! gave_warning_message)
755 {
756 gave_warning_message = 1;
757 einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
758 einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
759 }
760 }
761 }
762 }
763 }
764 }
765 #endif /* DLL_SUPPORT */
766
767 static void
768 gld_${EMULATION_NAME}_after_open ()
769 {
770 /* Pass the wacky PE command line options into the output bfd.
771 FIXME: This should be done via a function, rather than by
772 including an internal BFD header. */
773
774 if (!coff_data (output_bfd)->pe)
775 einfo (_("%F%P: PE operations on non PE file.\n"));
776
777 pe_data (output_bfd)->pe_opthdr = pe;
778 pe_data (output_bfd)->dll = init[DLLOFF].value;
779
780 #ifdef DLL_SUPPORT
781 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
782 pe_fixup_stdcalls ();
783
784 pe_process_import_defs(output_bfd, &link_info);
785 if (link_info.shared)
786 pe_dll_build_sections (output_bfd, &link_info);
787
788 #ifndef TARGET_IS_i386pe
789 #ifndef TARGET_IS_armpe
790 else
791 pe_exe_build_sections (output_bfd, &link_info);
792 #endif
793 #endif
794 #endif
795
796 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
797 if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
798 {
799 /* The arm backend needs special fields in the output hash structure.
800 These will only be created if the output format is an arm format,
801 hence we do not support linking and changing output formats at the
802 same time. Use a link followed by objcopy to change output formats. */
803 einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
804 return;
805 }
806 {
807 /* Find a BFD that can hold the interworking stubs. */
808 LANG_FOR_EACH_INPUT_STATEMENT (is)
809 {
810 if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
811 break;
812 }
813 }
814 #endif
815
816 {
817 int is_ms_arch = 0;
818 bfd *cur_arch = 0;
819 lang_input_statement_type *is2;
820
821 /* Careful - this is a shell script. Watch those dollar signs! */
822 /* Microsoft import libraries have every member named the same,
823 and not in the right order for us to link them correctly. We
824 must detect these and rename the members so that they'll link
825 correctly. There are three types of objects: the head, the
826 thunks, and the sentinel(s). The head is easy; it's the one
827 with idata2. We assume that the sentinels won't have relocs,
828 and the thunks will. It's easier than checking the symbol
829 table for external references. */
830 LANG_FOR_EACH_INPUT_STATEMENT (is)
831 {
832 if (is->the_bfd->my_archive)
833 {
834 bfd *arch = is->the_bfd->my_archive;
835 if (cur_arch != arch)
836 {
837 cur_arch = arch;
838 is_ms_arch = 1;
839 for (is2 = is;
840 is2 && is2->the_bfd->my_archive == arch;
841 is2 = (lang_input_statement_type *)is2->next)
842 {
843 if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
844 is_ms_arch = 0;
845 }
846 }
847
848 if (is_ms_arch)
849 {
850 int idata2 = 0, reloc_count=0;
851 asection *sec;
852 char *new_name, seq;
853
854 for (sec = is->the_bfd->sections; sec; sec = sec->next)
855 {
856 if (strcmp (sec->name, ".idata\$2") == 0)
857 idata2 = 1;
858 reloc_count += sec->reloc_count;
859 }
860
861 if (idata2) /* .idata2 is the TOC */
862 seq = 'a';
863 else if (reloc_count > 0) /* thunks */
864 seq = 'b';
865 else /* sentinel */
866 seq = 'c';
867
868 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
869 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
870 is->the_bfd->filename = new_name;
871
872 new_name = xmalloc (strlen (is->filename) + 3);
873 sprintf (new_name, "%s.%c", is->filename, seq);
874 is->filename = new_name;
875 }
876 }
877 }
878 }
879 }
880 \f
881 static void
882 gld_${EMULATION_NAME}_before_allocation()
883 {
884 #ifdef TARGET_IS_ppcpe
885 /* Here we rummage through the found bfds to collect toc information */
886 {
887 LANG_FOR_EACH_INPUT_STATEMENT (is)
888 {
889 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
890 {
891 /* xgettext:c-format */
892 einfo (_("Errors encountered processing file %s\n"), is->filename);
893 }
894 }
895 }
896
897 /* We have seen it all. Allocate it, and carry on */
898 ppc_allocate_toc_section (&link_info);
899 #endif /* TARGET_IS_ppcpe */
900
901 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
902 /* FIXME: we should be able to set the size of the interworking stub
903 section.
904
905 Here we rummage through the found bfds to collect glue
906 information. FIXME: should this be based on a command line
907 option? krk@cygnus.com */
908 {
909 LANG_FOR_EACH_INPUT_STATEMENT (is)
910 {
911 if (! bfd_arm_pe_process_before_allocation
912 (is->the_bfd, & link_info, support_old_code))
913 {
914 /* xgettext:c-format */
915 einfo (_("Errors encountered processing file %s for interworking"),
916 is->filename);
917 }
918 }
919 }
920
921 /* We have seen it all. Allocate it, and carry on */
922 bfd_arm_pe_allocate_interworking_sections (& link_info);
923 #endif /* TARGET_IS_armpe */
924 }
925 \f
926 #ifdef DLL_SUPPORT
927 /* This is called when an input file isn't recognized as a BFD. We
928 check here for .DEF files and pull them in automatically. */
929
930 static int
931 saw_option(char *option)
932 {
933 int i;
934 for (i=0; init[i].ptr; i++)
935 if (strcmp (init[i].symbol, option) == 0)
936 return init[i].inited;
937 return 0;
938 }
939 #endif /* DLL_SUPPORT */
940
941 static boolean
942 gld_${EMULATION_NAME}_unrecognized_file(entry)
943 lang_input_statement_type *entry ATTRIBUTE_UNUSED;
944 {
945 #ifdef DLL_SUPPORT
946 const char *ext = entry->filename + strlen (entry->filename) - 4;
947
948 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
949 {
950 if (pe_def_file == 0)
951 pe_def_file = def_file_empty ();
952 def_file_parse (entry->filename, pe_def_file);
953 if (pe_def_file)
954 {
955 int i, buflen=0, len;
956 char *buf;
957 for (i=0; i<pe_def_file->num_exports; i++)
958 {
959 len = strlen(pe_def_file->exports[i].internal_name);
960 if (buflen < len+2)
961 buflen = len+2;
962 }
963 buf = (char *) xmalloc (buflen);
964 for (i=0; i<pe_def_file->num_exports; i++)
965 {
966 struct bfd_link_hash_entry *h;
967 sprintf(buf, "_%s", pe_def_file->exports[i].internal_name);
968
969 h = bfd_link_hash_lookup (link_info.hash, buf, true, true, true);
970 if (h == (struct bfd_link_hash_entry *) NULL)
971 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
972 if (h->type == bfd_link_hash_new)
973 {
974 h->type = bfd_link_hash_undefined;
975 h->u.undef.abfd = NULL;
976 bfd_link_add_undef (link_info.hash, h);
977 }
978 }
979 free (buf);
980
981 /* def_file_print (stdout, pe_def_file); */
982 if (pe_def_file->is_dll == 1)
983 link_info.shared = 1;
984
985 if (pe_def_file->base_address != (bfd_vma)(-1))
986 {
987 pe.ImageBase =
988 pe_data (output_bfd)->pe_opthdr.ImageBase =
989 init[IMAGEBASEOFF].value = pe_def_file->base_address;
990 init[IMAGEBASEOFF].inited = 1;
991 if (image_base_statement)
992 image_base_statement->exp =
993 exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
994 }
995
996 #if 0
997 /* Not sure if these *should* be set */
998 if (pe_def_file->version_major != -1)
999 {
1000 pe.MajorImageVersion = pe_def_file->version_major;
1001 pe.MinorImageVersion = pe_def_file->version_minor;
1002 }
1003 #endif
1004 if (pe_def_file->stack_reserve != -1
1005 && ! saw_option ("__size_of_stack_reserve__"))
1006 {
1007 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1008 if (pe_def_file->stack_commit != -1)
1009 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1010 }
1011 if (pe_def_file->heap_reserve != -1
1012 && ! saw_option ("__size_of_heap_reserve__"))
1013 {
1014 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1015 if (pe_def_file->heap_commit != -1)
1016 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1017 }
1018 return true;
1019 }
1020 }
1021 #endif
1022 return false;
1023
1024 }
1025
1026 static boolean
1027 gld_${EMULATION_NAME}_recognized_file(entry)
1028 lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1029 {
1030 #ifdef DLL_SUPPORT
1031 #ifdef TARGET_IS_i386pe
1032 pe_dll_id_target ("pei-i386");
1033 #endif
1034 #ifdef TARGET_IS_shpe
1035 pe_dll_id_target ("pei-shl");
1036 #endif
1037 #ifdef TARGET_IS_mipspe
1038 pe_dll_id_target ("pei-mips");
1039 #endif
1040 #ifdef TARGET_IS_armpe
1041 pe_dll_id_target ("pei-arm-little");
1042 #endif
1043 if (bfd_get_format (entry->the_bfd) == bfd_object)
1044 {
1045 const char *ext = entry->filename + strlen (entry->filename) - 4;
1046 if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1047 return pe_implied_import_dll (entry->filename);
1048 }
1049 #endif
1050 return false;
1051 }
1052
1053 static void
1054 gld_${EMULATION_NAME}_finish ()
1055 {
1056 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1057 struct bfd_link_hash_entry * h;
1058
1059 if (thumb_entry_symbol != NULL)
1060 {
1061 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol, false, false, true);
1062
1063 if (h != (struct bfd_link_hash_entry *) NULL
1064 && (h->type == bfd_link_hash_defined
1065 || h->type == bfd_link_hash_defweak)
1066 && h->u.def.section->output_section != NULL)
1067 {
1068 static char buffer[32];
1069 bfd_vma val;
1070
1071 /* Special procesing is required for a Thumb entry symbol. The
1072 bottom bit of its address must be set. */
1073 val = (h->u.def.value
1074 + bfd_get_section_vma (output_bfd,
1075 h->u.def.section->output_section)
1076 + h->u.def.section->output_offset);
1077
1078 val |= 1;
1079
1080 /* Now convert this value into a string and store it in entry_symbol
1081 where the lang_finish() function will pick it up. */
1082 buffer[0] = '0';
1083 buffer[1] = 'x';
1084
1085 sprintf_vma (buffer + 2, val);
1086
1087 if (entry_symbol != NULL && entry_from_cmdline)
1088 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1089 thumb_entry_symbol, entry_symbol);
1090 entry_symbol = buffer;
1091 }
1092 else
1093 einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1094 }
1095 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1096
1097 #ifdef DLL_SUPPORT
1098 if (link_info.shared)
1099 {
1100 pe_dll_fill_sections (output_bfd, &link_info);
1101 if (pe_implib_filename)
1102 pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1103 }
1104 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1105 /* ARM doesn't need relocs. */
1106 else
1107 {
1108 pe_exe_fill_sections (output_bfd, &link_info);
1109 }
1110 #endif
1111
1112 if (pe_out_def_filename)
1113 pe_dll_generate_def_file (pe_out_def_filename);
1114 #endif /* DLL_SUPPORT */
1115 }
1116
1117 \f
1118 /* Place an orphan section.
1119
1120 We use this to put sections in a reasonable place in the file, and
1121 to ensure that they are aligned as required.
1122
1123 We handle grouped sections here as well. A section named .foo$nn
1124 goes into the output section .foo. All grouped sections are sorted
1125 by name.
1126
1127 Grouped sections for the default sections are handled by the
1128 default linker script using wildcards, and are sorted by
1129 sort_sections. */
1130
1131 struct orphan_save
1132 {
1133 lang_output_section_statement_type *os;
1134 asection **section;
1135 lang_statement_union_type **stmt;
1136 };
1137
1138 /*ARGSUSED*/
1139 static boolean
1140 gld_${EMULATION_NAME}_place_orphan (file, s)
1141 lang_input_statement_type *file;
1142 asection *s;
1143 {
1144 const char *secname;
1145 char *hold_section_name;
1146 char *dollar = NULL;
1147 lang_output_section_statement_type *os;
1148 lang_statement_list_type add_child;
1149
1150 secname = bfd_get_section_name (s->owner, s);
1151
1152 /* Look through the script to see where to place this section. */
1153
1154 hold_section_name = xstrdup (secname);
1155 if (!link_info.relocateable)
1156 {
1157 dollar = strchr (hold_section_name, '$');
1158 if (dollar != NULL)
1159 *dollar = '\0';
1160 }
1161
1162 os = lang_output_section_find (hold_section_name);
1163
1164 lang_list_init (&add_child);
1165
1166 if (os != NULL
1167 && os->bfd_section != NULL
1168 && ((s->flags ^ os->bfd_section->flags) & (SEC_LOAD | SEC_ALLOC)) == 0)
1169 {
1170 wild_doit (&add_child, s, os, file);
1171 }
1172 else
1173 {
1174 struct orphan_save *place;
1175 static struct orphan_save hold_text;
1176 static struct orphan_save hold_rdata;
1177 static struct orphan_save hold_data;
1178 static struct orphan_save hold_bss;
1179 char *outsecname;
1180 lang_statement_list_type *old;
1181 lang_statement_list_type add;
1182 etree_type *address;
1183
1184 /* Try to put the new output section in a reasonable place based
1185 on the section name and section flags. */
1186 #define HAVE_SECTION(hold, name) \
1187 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1188
1189 place = NULL;
1190 if ((s->flags & SEC_ALLOC) == 0)
1191 ;
1192 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1193 && HAVE_SECTION (hold_bss, ".bss"))
1194 place = &hold_bss;
1195 else if ((s->flags & SEC_READONLY) == 0
1196 && HAVE_SECTION (hold_data, ".data"))
1197 place = &hold_data;
1198 else if ((s->flags & SEC_CODE) == 0
1199 && (s->flags & SEC_READONLY) != 0
1200 && HAVE_SECTION (hold_rdata, ".rdata"))
1201 place = &hold_rdata;
1202 else if ((s->flags & SEC_READONLY) != 0
1203 && HAVE_SECTION (hold_text, ".text"))
1204 place = &hold_text;
1205
1206 #undef HAVE_SECTION
1207
1208 /* Choose a unique name for the section. This will be needed if
1209 the same section name appears in the input file with
1210 different loadable or allocateable characteristics. */
1211 outsecname = xstrdup (hold_section_name);
1212 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1213 {
1214 unsigned int len;
1215 char *newname;
1216 unsigned int i;
1217
1218 len = strlen (outsecname);
1219 newname = xmalloc (len + 5);
1220 strcpy (newname, outsecname);
1221 i = 0;
1222 do
1223 {
1224 sprintf (newname + len, "%d", i);
1225 ++i;
1226 }
1227 while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1228
1229 free (outsecname);
1230 outsecname = newname;
1231 }
1232
1233 /* Start building a list of statements for this section. */
1234 old = stat_ptr;
1235 stat_ptr = &add;
1236 lang_list_init (stat_ptr);
1237
1238 if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1239 address = exp_intop ((bfd_vma) 0);
1240 else
1241 {
1242 /* All sections in an executable must be aligned to a page
1243 boundary. */
1244 address = exp_unop (ALIGN_K,
1245 exp_nameop (NAME, "__section_alignment__"));
1246 }
1247
1248 os = lang_enter_output_section_statement (outsecname, address, 0,
1249 (bfd_vma) 0,
1250 (etree_type *) NULL,
1251 (etree_type *) NULL,
1252 (etree_type *) NULL);
1253
1254 wild_doit (&add_child, s, os, file);
1255
1256 lang_leave_output_section_statement
1257 ((bfd_vma) 0, "*default*",
1258 (struct lang_output_section_phdr_list *) NULL, "*default*");
1259
1260 stat_ptr = old;
1261
1262 if (place != NULL)
1263 {
1264 asection *snew, **pps;
1265
1266 snew = os->bfd_section;
1267 if (place->os->bfd_section != NULL || place->section != NULL)
1268 {
1269 /* Shuffle the section to make the output file look neater. */
1270 if (place->section == NULL)
1271 {
1272 #if 0
1273 /* Finding the end of the list is a little tricky. We
1274 make a wild stab at it by comparing section flags. */
1275 flagword first_flags = place->os->bfd_section->flags;
1276 for (pps = &place->os->bfd_section->next;
1277 *pps != NULL && (*pps)->flags == first_flags;
1278 pps = &(*pps)->next)
1279 ;
1280 place->section = pps;
1281 #else
1282 /* Put orphans after the first section on the list. */
1283 place->section = &place->os->bfd_section->next;
1284 #endif
1285 }
1286
1287 /* Unlink the section. */
1288 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1289 ;
1290 *pps = snew->next;
1291
1292 /* Now tack it on to the "place->os" section list. */
1293 snew->next = *place->section;
1294 *place->section = snew;
1295 }
1296 place->section = &snew->next; /* Save the end of this list. */
1297
1298 if (place->stmt == NULL)
1299 {
1300 /* Put the new statement list right at the head. */
1301 *add.tail = place->os->header.next;
1302 place->os->header.next = add.head;
1303 }
1304 else
1305 {
1306 /* Put it after the last orphan statement we added. */
1307 *add.tail = *place->stmt;
1308 *place->stmt = add.head;
1309 }
1310 place->stmt = add.tail; /* Save the end of this list. */
1311 }
1312 }
1313
1314 {
1315 lang_statement_union_type **pl = &os->children.head;
1316
1317 if (dollar != NULL)
1318 {
1319 boolean found_dollar;
1320
1321 /* The section name has a '$'. Sort it with the other '$'
1322 sections. */
1323
1324 found_dollar = false;
1325 for ( ; *pl != NULL; pl = &(*pl)->next)
1326 {
1327 lang_input_section_type *ls;
1328 const char *lname;
1329
1330 if ((*pl)->header.type != lang_input_section_enum)
1331 continue;
1332
1333 ls = &(*pl)->input_section;
1334
1335 lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1336 if (strchr (lname, '$') == NULL)
1337 {
1338 if (found_dollar)
1339 break;
1340 }
1341 else
1342 {
1343 found_dollar = true;
1344 if (strcmp (secname, lname) < 0)
1345 break;
1346 }
1347 }
1348 }
1349
1350 if (add_child.head != NULL)
1351 {
1352 add_child.head->next = *pl;
1353 *pl = add_child.head;
1354 }
1355 }
1356
1357 free (hold_section_name);
1358
1359 return true;
1360 }
1361
1362 static boolean
1363 gld_${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
1364 const char * arch ATTRIBUTE_UNUSED;
1365 search_dirs_type * search;
1366 lang_input_statement_type * entry;
1367 {
1368 const char * filename;
1369 char * string;
1370
1371 if (! entry->is_archive)
1372 return false;
1373
1374 filename = entry->filename;
1375
1376 string = (char *) xmalloc (strlen (search->name)
1377 + strlen (filename)
1378 + sizeof "/lib.a.dll"
1379 + 1);
1380
1381 /* Try "libfoo.dll.a" first (preferred explicit import library for dll's */
1382 sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1383
1384 if (! ldfile_try_open_bfd (string, entry))
1385 {
1386 /* Try "foo.dll.a" next (alternate explicit import library for dll's */
1387 sprintf (string, "%s/%s.dll.a", search->name, filename);
1388 if (! ldfile_try_open_bfd (string, entry))
1389 {
1390 /*
1391 Try libfoo.a next. Normally, this would be interpreted as a static
1392 library, but it *could* be an import library. For backwards compatibility,
1393 libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1394 or sometimes errors occur when building legacy packages.
1395
1396 Putting libfoo.a here means that in a failure case (i.e. the library
1397 -lfoo is not found) we will search for libfoo.a twice before
1398 giving up -- once here, and once when searching for a "static" lib.
1399 for a "static" lib.
1400 */
1401 /* Try "libfoo.a" (import lib, or static lib, but must
1402 take precedence over dll's) */
1403 sprintf (string, "%s/lib%s.a", search->name, filename);
1404 if (! ldfile_try_open_bfd (string, entry))
1405 {
1406 /* Try "libfoo.dll" (preferred dll name) */
1407 sprintf (string, "%s/lib%s.dll", search->name, filename);
1408 if (! ldfile_try_open_bfd (string, entry))
1409 {
1410 /* Finally, try "foo.dll" (alternate dll name) */
1411 sprintf (string, "%s/%s.dll", search->name, filename);
1412 if (! ldfile_try_open_bfd (string, entry))
1413 {
1414 free (string);
1415 return false;
1416 }
1417 }
1418 }
1419 }
1420 }
1421
1422 entry->filename = string;
1423
1424 return true;
1425 }
1426
1427 static int
1428 gld_${EMULATION_NAME}_find_potential_libraries (name, entry)
1429 char * name;
1430 lang_input_statement_type * entry;
1431 {
1432 return ldfile_open_file_search (name, entry, "", ".lib");
1433 }
1434 \f
1435 static char *
1436 gld_${EMULATION_NAME}_get_script(isfile)
1437 int *isfile;
1438 EOF
1439 # Scripts compiled in.
1440 # sed commands to quote an ld script as a C string.
1441 sc="-f stringify.sed"
1442
1443 cat >>e${EMULATION_NAME}.c <<EOF
1444 {
1445 *isfile = 0;
1446
1447 if (link_info.relocateable == true && config.build_constructors == true)
1448 return
1449 EOF
1450 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1451 echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1452 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1453 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1454 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1455 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1456 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1457 echo ' ; else return' >> e${EMULATION_NAME}.c
1458 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1459 echo '; }' >> e${EMULATION_NAME}.c
1460
1461 cat >>e${EMULATION_NAME}.c <<EOF
1462
1463
1464 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1465 {
1466 gld_${EMULATION_NAME}_before_parse,
1467 syslib_default,
1468 hll_default,
1469 gld_${EMULATION_NAME}_after_parse,
1470 gld_${EMULATION_NAME}_after_open,
1471 after_allocation_default,
1472 set_output_arch_default,
1473 ldemul_default_target,
1474 gld_${EMULATION_NAME}_before_allocation,
1475 gld_${EMULATION_NAME}_get_script,
1476 "${EMULATION_NAME}",
1477 "${OUTPUT_FORMAT}",
1478 gld_${EMULATION_NAME}_finish, /* finish */
1479 NULL, /* create output section statements */
1480 gld_${EMULATION_NAME}_open_dynamic_archive,
1481 gld_${EMULATION_NAME}_place_orphan,
1482 gld_${EMULATION_NAME}_set_symbols,
1483 gld_${EMULATION_NAME}_parse_args,
1484 gld_${EMULATION_NAME}_unrecognized_file,
1485 gld_${EMULATION_NAME}_list_options,
1486 gld_${EMULATION_NAME}_recognized_file,
1487 gld_${EMULATION_NAME}_find_potential_libraries
1488 };
1489 EOF
GDB Binutils - Deliverables
This page took 0.062497 seconds and 4 git commands to generate.