| blob | 62d695942947d93e086dec55968a9f90dc393d5b |
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.
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.
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.
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. */
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. */
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"
47 /* FIXME: This is a BFD internal header file, and we should not be
48 using it here. */
49 #include "../bfd/libcoff.h"
51 #include "deffile.h"
52 #include "pe-dll.h"
54 #define TARGET_IS_${EMULATION_NAME}
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
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
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
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
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 *));
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;
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 static char *pe_dll_search_prefix = NULL;
123 #endif
125 extern const char *output_filename;
127 static void
128 gld_${EMULATION_NAME}_before_parse()
129 {
130 output_filename = "${EXECUTABLE_NAME:-a.exe}";
131 ldfile_output_architecture = bfd_arch_${ARCH};
132 #ifdef DLL_SUPPORT
133 config.has_shared = 1;
135 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
136 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
137 lang_add_entry ("WinMainCRTStartup", 1);
138 #else
139 lang_add_entry ("_WinMainCRTStartup", 1);
140 #endif
141 #endif
142 #endif
143 }
144 \f
145 /* PE format extra command line options. */
147 /* Used for setting flags in the PE header. */
148 #define OPTION_BASE_FILE (300 + 1)
149 #define OPTION_DLL (OPTION_BASE_FILE + 1)
150 #define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
151 #define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
152 #define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
153 #define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
154 #define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
155 #define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
156 #define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
157 #define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
158 #define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
159 #define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
160 #define OPTION_SUBSYSTEM (OPTION_STACK + 1)
161 #define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
162 #define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
163 #define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
164 #define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
165 #define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
166 #define OPTION_KILL_ATS (OPTION_EXCLUDE_SYMBOLS + 1)
167 #define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
168 #define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
169 #define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
170 #define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
171 #define OPTION_THUMB_ENTRY (OPTION_IMPLIB_FILENAME + 1)
172 #define OPTION_WARN_DUPLICATE_EXPORTS (OPTION_THUMB_ENTRY + 1)
173 #define OPTION_IMP_COMPAT (OPTION_WARN_DUPLICATE_EXPORTS + 1)
174 #define OPTION_ENABLE_AUTO_IMAGE_BASE (OPTION_IMP_COMPAT + 1)
175 #define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
176 #define OPTION_DLL_SEARCH_PREFIX (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
178 static struct option longopts[] =
179 {
180 /* PE options */
181 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
182 {"dll", no_argument, NULL, OPTION_DLL},
183 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
184 {"heap", required_argument, NULL, OPTION_HEAP},
185 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
186 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
187 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
188 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
189 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
190 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
191 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
192 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
193 {"stack", required_argument, NULL, OPTION_STACK},
194 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
195 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
196 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
197 #ifdef DLL_SUPPORT
198 /* getopt allows abbreviations, so we do this to stop it from treating -o
199 as an abbreviation for this option */
200 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
201 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
202 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
203 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
204 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
205 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
206 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
207 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
208 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
209 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
210 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
211 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
212 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
213 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
214 #endif
215 {NULL, no_argument, NULL, 0}
216 };
219 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
220 parameters which may be input from the command line */
222 typedef struct
223 {
224 void *ptr;
225 int size;
226 int value;
227 char *symbol;
228 int inited;
229 } definfo;
231 #define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
233 static definfo init[] =
234 {
235 /* imagebase must be first */
236 #define IMAGEBASEOFF 0
237 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
238 #define DLLOFF 1
239 {&dll, sizeof(dll), 0, "__dll__", 0},
240 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
241 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
242 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
243 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
244 D(MajorImageVersion,"__major_image_version__", 1),
245 D(MinorImageVersion,"__minor_image_version__", 0),
246 #ifdef TARGET_IS_armpe
247 D(MajorSubsystemVersion,"__major_subsystem_version__", 2),
248 #else
249 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
250 #endif
251 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
252 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
253 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x2000000),
254 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
255 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
256 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
257 D(LoaderFlags,"__loader_flags__", 0x0),
258 { NULL, 0, 0, NULL, 0 }
259 };
261 static void
262 gld_${EMULATION_NAME}_list_options (file)
263 FILE * file;
264 {
265 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
266 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
267 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
268 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
269 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
270 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
271 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
272 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
273 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
274 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
275 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
276 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
277 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
278 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
279 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
280 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n"));
281 #ifdef DLL_SUPPORT
282 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
283 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
284 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
285 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
286 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
287 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
288 fprintf (file, _(" --out-implib <file> Generate import library\n"));
289 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
290 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
291 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n"));
292 fprintf (file, _(" create __imp_<SYMBOL> as well.\n"));
293 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n"));
294 fprintf (file, _(" unless user specifies one\n"));
295 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
296 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll witout an\n"));
297 fprintf (file, _(" importlib, use <string><basename>.dll \n"));
298 fprintf (file, _(" in preference to lib<basename>.dll \n"));
299 #endif
300 }
302 static void
303 set_pe_name (name, val)
304 char *name;
305 long val;
306 {
307 int i;
308 /* Find the name and set it. */
309 for (i = 0; init[i].ptr; i++)
310 {
311 if (strcmp (name, init[i].symbol) == 0)
312 {
313 init[i].value = val;
314 init[i].inited = 1;
315 return;
316 }
317 }
318 abort();
319 }
322 static void
323 set_pe_subsystem ()
324 {
325 const char *sver;
326 int len;
327 int i;
328 static const struct
329 {
330 const char *name;
331 const int value;
332 const char *entry;
333 }
334 v[] =
335 {
336 { "native", 1, "NtProcessStartup" },
337 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
338 { "windows", 2, "WinMainCRTStartup" },
339 #else
340 { "windows", 2, "WinMainCRTStartup" },
341 #endif
342 { "console", 3, "mainCRTStartup" },
343 #if 0
344 /* The Microsoft linker does not recognize this. */
345 { "os2", 5, "" },
346 #endif
347 { "posix", 7, "__PosixProcessStartup"},
348 { "wince", 9, "_WinMainCRTStartup" },
349 { 0, 0, 0 }
350 };
352 sver = strchr (optarg, ':');
353 if (sver == NULL)
354 len = strlen (optarg);
355 else
356 {
357 char *end;
359 len = sver - optarg;
360 set_pe_name ("__major_subsystem_version__",
361 strtoul (sver + 1, &end, 0));
362 if (*end == '.')
363 set_pe_name ("__minor_subsystem_version__",
364 strtoul (end + 1, &end, 0));
365 if (*end != '\0')
366 einfo (_("%P: warning: bad version number in -subsystem option\n"));
367 }
369 for (i = 0; v[i].name; i++)
370 {
371 if (strncmp (optarg, v[i].name, len) == 0
372 && v[i].name[len] == '\0')
373 {
374 const char *initial_symbol_char;
375 const char *entry;
377 set_pe_name ("__subsystem__", v[i].value);
379 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
380 if (*initial_symbol_char == '\0')
381 entry = v[i].entry;
382 else
383 {
384 char *alc_entry;
386 /* lang_add_entry expects its argument to be permanently
387 allocated, so we don't free this string. */
388 alc_entry = xmalloc (strlen (initial_symbol_char)
389 + strlen (v[i].entry)
390 + 1);
391 strcpy (alc_entry, initial_symbol_char);
392 strcat (alc_entry, v[i].entry);
393 entry = alc_entry;
394 }
396 lang_add_entry (entry, 1);
398 return;
399 }
400 }
402 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
403 }
407 static void
408 set_pe_value (name)
409 char *name;
411 {
412 char *end;
414 set_pe_name (name, strtoul (optarg, &end, 0));
416 if (end == optarg)
417 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
419 optarg = end;
420 }
422 static void
423 set_pe_stack_heap (resname, comname)
424 char *resname;
425 char *comname;
426 {
427 set_pe_value (resname);
429 if (*optarg == ',')
430 {
431 optarg++;
432 set_pe_value (comname);
433 }
434 else if (*optarg)
435 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
436 }
440 static int
441 gld_${EMULATION_NAME}_parse_args(argc, argv)
442 int argc;
443 char **argv;
444 {
445 int longind;
446 int optc;
447 int prevoptind = optind;
448 int prevopterr = opterr;
449 int wanterror;
450 static int lastoptind = -1;
452 if (lastoptind != optind)
453 opterr = 0;
454 wanterror = opterr;
456 lastoptind = optind;
458 optc = getopt_long_only (argc, argv, "-", longopts, &longind);
459 opterr = prevopterr;
461 switch (optc)
462 {
463 default:
464 if (wanterror)
465 xexit (1);
466 optind = prevoptind;
467 return 0;
469 case OPTION_BASE_FILE:
470 link_info.base_file = (PTR) fopen (optarg, FOPEN_WB);
471 if (link_info.base_file == NULL)
472 {
473 /* xgettext:c-format */
474 fprintf (stderr, _("%s: Can't open base file %s\n"),
475 program_name, optarg);
476 xexit (1);
477 }
478 break;
480 /* PE options */
481 case OPTION_HEAP:
482 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
483 break;
484 case OPTION_STACK:
485 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
486 break;
487 case OPTION_SUBSYSTEM:
488 set_pe_subsystem ();
489 break;
490 case OPTION_MAJOR_OS_VERSION:
491 set_pe_value ("__major_os_version__");
492 break;
493 case OPTION_MINOR_OS_VERSION:
494 set_pe_value ("__minor_os_version__");
495 break;
496 case OPTION_MAJOR_SUBSYSTEM_VERSION:
497 set_pe_value ("__major_subsystem_version__");
498 break;
499 case OPTION_MINOR_SUBSYSTEM_VERSION:
500 set_pe_value ("__minor_subsystem_version__");
501 break;
502 case OPTION_MAJOR_IMAGE_VERSION:
503 set_pe_value ("__major_image_version__");
504 break;
505 case OPTION_MINOR_IMAGE_VERSION:
506 set_pe_value ("__minor_image_version__");
507 break;
508 case OPTION_FILE_ALIGNMENT:
509 set_pe_value ("__file_alignment__");
510 break;
511 case OPTION_SECTION_ALIGNMENT:
512 set_pe_value ("__section_alignment__");
513 break;
514 case OPTION_DLL:
515 set_pe_name ("__dll__", 1);
516 break;
517 case OPTION_IMAGE_BASE:
518 set_pe_value ("__image_base__");
519 break;
520 case OPTION_SUPPORT_OLD_CODE:
521 support_old_code = 1;
522 break;
523 case OPTION_THUMB_ENTRY:
524 thumb_entry_symbol = optarg;
525 break;
526 #ifdef DLL_SUPPORT
527 case OPTION_OUT_DEF:
528 pe_out_def_filename = xstrdup (optarg);
529 break;
530 case OPTION_EXPORT_ALL:
531 pe_dll_export_everything = 1;
532 break;
533 case OPTION_EXCLUDE_SYMBOLS:
534 pe_dll_add_excludes (optarg);
535 break;
536 case OPTION_KILL_ATS:
537 pe_dll_kill_ats = 1;
538 break;
539 case OPTION_STDCALL_ALIASES:
540 pe_dll_stdcall_aliases = 1;
541 break;
542 case OPTION_ENABLE_STDCALL_FIXUP:
543 pe_enable_stdcall_fixup = 1;
544 break;
545 case OPTION_DISABLE_STDCALL_FIXUP:
546 pe_enable_stdcall_fixup = 0;
547 break;
548 case OPTION_IMPLIB_FILENAME:
549 pe_implib_filename = xstrdup (optarg);
550 break;
551 case OPTION_WARN_DUPLICATE_EXPORTS:
552 pe_dll_warn_dup_exports = 1;
553 break;
554 case OPTION_IMP_COMPAT:
555 pe_dll_compat_implib = 1;
556 break;
557 case OPTION_ENABLE_AUTO_IMAGE_BASE:
558 pe_enable_auto_image_base = 1;
559 break;
560 case OPTION_DISABLE_AUTO_IMAGE_BASE:
561 pe_enable_auto_image_base = 0;
562 break;
563 case OPTION_DLL_SEARCH_PREFIX:
564 pe_dll_search_prefix = xstrdup( optarg );
565 break;
566 #endif
567 }
568 return 1;
569 }
570 \f
572 #ifdef DLL_SUPPORT
573 static unsigned long
574 strhash (const char *str)
575 {
576 const unsigned char *s;
577 unsigned long hash;
578 unsigned int c;
579 unsigned int len;
581 hash = 0;
582 len = 0;
583 s = (const unsigned char *) str;
584 while ((c = *s++) != '\0')
585 {
586 hash += c + (c << 17);
587 hash ^= hash >> 2;
588 ++len;
589 }
590 hash += len + (len << 17);
591 hash ^= hash >> 2;
593 return hash;
594 }
596 /* Use the output file to create a image base for relocatable DLLs. */
597 static unsigned long
598 compute_dll_image_base (const char *ofile)
599 {
600 unsigned long hash = strhash (ofile);
601 return 0x60000000 | ((hash << 16) & 0x0FFC0000);
602 }
603 #endif
605 /* Assign values to the special symbols before the linker script is
606 read. */
608 static void
609 gld_${EMULATION_NAME}_set_symbols ()
610 {
611 /* Run through and invent symbols for all the
612 names and insert the defaults. */
613 int j;
614 lang_statement_list_type *save;
616 if (!init[IMAGEBASEOFF].inited)
617 {
618 if (link_info.relocateable)
619 init[IMAGEBASEOFF].value = 0;
620 else if (init[DLLOFF].value || link_info.shared)
621 #ifdef DLL_SUPPORT
622 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
623 compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
624 #else
625 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
626 #endif
627 else
628 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
629 }
631 /* Don't do any symbol assignments if this is a relocateable link. */
632 if (link_info.relocateable)
633 return;
635 /* Glue the assignments into the abs section */
636 save = stat_ptr;
638 stat_ptr = &(abs_output_section->children);
640 for (j = 0; init[j].ptr; j++)
641 {
642 long val = init[j].value;
643 lang_assignment_statement_type *rv;
644 rv = lang_add_assignment (exp_assop ('=' ,init[j].symbol, exp_intop (val)));
645 if (init[j].size == sizeof(short))
646 *(short *)init[j].ptr = val;
647 else if (init[j].size == sizeof(int))
648 *(int *)init[j].ptr = val;
649 else if (init[j].size == sizeof(long))
650 *(long *)init[j].ptr = val;
651 /* This might be a long long or other special type. */
652 else if (init[j].size == sizeof(bfd_vma))
653 *(bfd_vma *)init[j].ptr = val;
654 else abort();
655 if (j == IMAGEBASEOFF)
656 image_base_statement = rv;
657 }
658 /* Restore the pointer. */
659 stat_ptr = save;
661 if (pe.FileAlignment >
662 pe.SectionAlignment)
663 {
664 einfo (_("%P: warning, file alignment > section alignment.\n"));
665 }
666 }
668 /* This is called after the linker script and the command line options
669 have been read. */
671 static void
672 gld_${EMULATION_NAME}_after_parse ()
673 {
674 /* The Windows libraries are designed for the linker to treat the
675 entry point as an undefined symbol. Otherwise, the .obj that
676 defines mainCRTStartup is brought in because it is the first
677 encountered in libc.lib and it has other symbols in it which will
678 be pulled in by the link process. To avoid this, we act as
679 though the user specified -u with the entry point symbol.
681 This function is called after the linker script and command line
682 options have been read, so at this point we know the right entry
683 point. This function is called before the input files are
684 opened, so registering the symbol as undefined will make a
685 difference. */
687 if (! link_info.relocateable && entry_symbol != NULL)
688 ldlang_add_undef (entry_symbol);
689 }
691 #ifdef DLL_SUPPORT
692 static struct bfd_link_hash_entry *pe_undef_found_sym;
694 static boolean
695 pe_undef_cdecl_match (h, string)
696 struct bfd_link_hash_entry *h;
697 PTR string;
698 {
699 int sl = strlen (string);
700 if (h->type == bfd_link_hash_defined
701 && strncmp (h->root.string, string, sl) == 0
702 && h->root.string[sl] == '@')
703 {
704 pe_undef_found_sym = h;
705 return false;
706 }
707 return true;
708 }
710 static void
711 pe_fixup_stdcalls ()
712 {
713 static int gave_warning_message = 0;
714 struct bfd_link_hash_entry *undef, *sym;
715 char *at;
716 for (undef = link_info.hash->undefs; undef; undef=undef->next)
717 if (undef->type == bfd_link_hash_undefined)
718 {
719 at = strchr (undef->root.string, '@');
720 if (at)
721 {
722 /* The symbol is a stdcall symbol, so let's look for a cdecl
723 symbol with the same name and resolve to that */
724 char *cname = xstrdup (undef->root.string);
725 at = strchr (cname, '@');
726 *at = 0;
727 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
728 if (sym && sym->type == bfd_link_hash_defined)
729 {
730 undef->type = bfd_link_hash_defined;
731 undef->u.def.value = sym->u.def.value;
732 undef->u.def.section = sym->u.def.section;
733 if (pe_enable_stdcall_fixup == -1)
734 {
735 einfo (_("Warning: resolving %s by linking to %s\n"),
736 undef->root.string, cname);
737 if (! gave_warning_message)
738 {
739 gave_warning_message = 1;
740 einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
741 einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
742 }
743 }
744 }
745 }
746 else
747 {
748 /* The symbol is a cdecl symbol, so we look for stdcall
749 symbols - which means scanning the whole symbol table */
750 pe_undef_found_sym = 0;
751 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
752 (PTR) undef->root.string);
753 sym = pe_undef_found_sym;
754 if (sym)
755 {
756 undef->type = bfd_link_hash_defined;
757 undef->u.def.value = sym->u.def.value;
758 undef->u.def.section = sym->u.def.section;
759 if (pe_enable_stdcall_fixup == -1)
760 {
761 einfo (_("Warning: resolving %s by linking to %s\n"),
762 undef->root.string, sym->root.string);
763 if (! gave_warning_message)
764 {
765 gave_warning_message = 1;
766 einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
767 einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
768 }
769 }
770 }
771 }
772 }
773 }
774 #endif /* DLL_SUPPORT */
776 static void
777 gld_${EMULATION_NAME}_after_open ()
778 {
779 /* Pass the wacky PE command line options into the output bfd.
780 FIXME: This should be done via a function, rather than by
781 including an internal BFD header. */
783 if (!coff_data (output_bfd)->pe)
784 einfo (_("%F%P: PE operations on non PE file.\n"));
786 pe_data (output_bfd)->pe_opthdr = pe;
787 pe_data (output_bfd)->dll = init[DLLOFF].value;
789 #ifdef DLL_SUPPORT
790 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
791 pe_fixup_stdcalls ();
793 pe_process_import_defs(output_bfd, &link_info);
794 if (link_info.shared)
795 pe_dll_build_sections (output_bfd, &link_info);
797 #ifndef TARGET_IS_i386pe
798 #ifndef TARGET_IS_armpe
799 else
800 pe_exe_build_sections (output_bfd, &link_info);
801 #endif
802 #endif
803 #endif
805 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
806 if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
807 {
808 /* The arm backend needs special fields in the output hash structure.
809 These will only be created if the output format is an arm format,
810 hence we do not support linking and changing output formats at the
811 same time. Use a link followed by objcopy to change output formats. */
812 einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
813 return;
814 }
815 {
816 /* Find a BFD that can hold the interworking stubs. */
817 LANG_FOR_EACH_INPUT_STATEMENT (is)
818 {
819 if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
820 break;
821 }
822 }
823 #endif
825 {
826 /* This next chunk of code tries to detect the case where you have
827 two import libraries for the same DLL (specifically,
828 symbolically linking libm.a and libc.a in cygwin to
829 libcygwin.a). In those cases, it's possible for function
830 thunks from the second implib to be used but without the
831 head/tail objects, causing an improper import table. We detect
832 those cases and rename the "other" import libraries to match
833 the one the head/tail come from, so that the linker will sort
834 things nicely and produce a valid import table. */
836 LANG_FOR_EACH_INPUT_STATEMENT (is)
837 {
838 if (is->the_bfd->my_archive)
839 {
840 int idata2 = 0, reloc_count=0, is_imp = 0;
841 asection *sec;
843 /* See if this is an import library thunk. */
844 for (sec = is->the_bfd->sections; sec; sec = sec->next)
845 {
846 if (strcmp (sec->name, ".idata\$2") == 0)
847 idata2 = 1;
848 if (strncmp (sec->name, ".idata\$", 7) == 0)
849 is_imp = 1;
850 reloc_count += sec->reloc_count;
851 }
853 if (is_imp && !idata2 && reloc_count)
854 {
855 /* It is, look for the reference to head and see if it's
856 from our own library. */
857 for (sec = is->the_bfd->sections; sec; sec = sec->next)
858 {
859 int i;
860 long symsize;
861 long relsize;
862 asymbol **symbols;
863 arelent **relocs;
864 int nrelocs;
866 symsize = bfd_get_symtab_upper_bound (is->the_bfd);
867 if (symsize < 1)
868 break;
869 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
870 if (relsize < 1)
871 break;
873 symbols = (asymbol **) xmalloc (symsize);
874 symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
875 if (symsize < 0)
876 {
877 einfo ("%X%P: unable to process symbols: %E");
878 return;
879 }
881 relocs = (arelent **) xmalloc ((size_t) relsize);
882 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
883 relocs, symbols);
884 if (nrelocs < 0)
885 {
886 free (relocs);
887 einfo ("%X%P: unable to process relocs: %E");
888 return;
889 }
891 for (i = 0; i < nrelocs; i++)
892 {
893 struct symbol_cache_entry *s;
894 struct bfd_link_hash_entry * blhe;
895 bfd *other_bfd;
896 char *n;
898 s = (relocs[i]->sym_ptr_ptr)[0];
900 if (s->flags & BSF_LOCAL)
901 continue;
903 /* Thunk section with reloc to another bfd. */
904 blhe = bfd_link_hash_lookup (link_info.hash,
905 s->name,
906 false, false, true);
908 if (blhe == NULL
909 || blhe->type != bfd_link_hash_defined)
910 continue;
912 other_bfd = blhe->u.def.section->owner;
914 if (strcmp (is->the_bfd->my_archive->filename,
915 other_bfd->my_archive->filename) == 0)
916 continue;
918 /* Rename this implib to match the other. */
919 n = (char *) xmalloc (strlen (other_bfd->my_archive->filename) + 1);
921 strcpy (n, other_bfd->my_archive->filename);
923 is->the_bfd->my_archive->filename = n;
924 }
926 free (relocs);
927 /* Note - we do not free the symbols,
928 they are now cached in the BFD. */
929 }
930 }
931 }
932 }
933 }
935 {
936 int is_ms_arch = 0;
937 bfd *cur_arch = 0;
938 lang_input_statement_type *is2;
940 /* Careful - this is a shell script. Watch those dollar signs! */
941 /* Microsoft import libraries have every member named the same,
942 and not in the right order for us to link them correctly. We
943 must detect these and rename the members so that they'll link
944 correctly. There are three types of objects: the head, the
945 thunks, and the sentinel(s). The head is easy; it's the one
946 with idata2. We assume that the sentinels won't have relocs,
947 and the thunks will. It's easier than checking the symbol
948 table for external references. */
949 LANG_FOR_EACH_INPUT_STATEMENT (is)
950 {
951 if (is->the_bfd->my_archive)
952 {
953 bfd *arch = is->the_bfd->my_archive;
954 if (cur_arch != arch)
955 {
956 cur_arch = arch;
957 is_ms_arch = 1;
958 for (is2 = is;
959 is2 && is2->the_bfd->my_archive == arch;
960 is2 = (lang_input_statement_type *)is2->next)
961 {
962 if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
963 is_ms_arch = 0;
964 }
965 }
967 if (is_ms_arch)
968 {
969 int idata2 = 0, reloc_count=0;
970 asection *sec;
971 char *new_name, seq;
973 for (sec = is->the_bfd->sections; sec; sec = sec->next)
974 {
975 if (strcmp (sec->name, ".idata\$2") == 0)
976 idata2 = 1;
977 reloc_count += sec->reloc_count;
978 }
980 if (idata2) /* .idata2 is the TOC */
981 seq = 'a';
982 else if (reloc_count > 0) /* thunks */
983 seq = 'b';
984 else /* sentinel */
985 seq = 'c';
987 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
988 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
989 is->the_bfd->filename = new_name;
991 new_name = xmalloc (strlen (is->filename) + 3);
992 sprintf (new_name, "%s.%c", is->filename, seq);
993 is->filename = new_name;
994 }
995 }
996 }
997 }
998 }
999 \f
1000 static void
1001 gld_${EMULATION_NAME}_before_allocation()
1002 {
1003 #ifdef TARGET_IS_ppcpe
1004 /* Here we rummage through the found bfds to collect toc information */
1005 {
1006 LANG_FOR_EACH_INPUT_STATEMENT (is)
1007 {
1008 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1009 {
1010 /* xgettext:c-format */
1011 einfo (_("Errors encountered processing file %s\n"), is->filename);
1012 }
1013 }
1014 }
1016 /* We have seen it all. Allocate it, and carry on */
1017 ppc_allocate_toc_section (&link_info);
1018 #endif /* TARGET_IS_ppcpe */
1020 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1021 /* FIXME: we should be able to set the size of the interworking stub
1022 section.
1024 Here we rummage through the found bfds to collect glue
1025 information. FIXME: should this be based on a command line
1026 option? krk@cygnus.com */
1027 {
1028 LANG_FOR_EACH_INPUT_STATEMENT (is)
1029 {
1030 if (! bfd_arm_pe_process_before_allocation
1031 (is->the_bfd, & link_info, support_old_code))
1032 {
1033 /* xgettext:c-format */
1034 einfo (_("Errors encountered processing file %s for interworking"),
1035 is->filename);
1036 }
1037 }
1038 }
1040 /* We have seen it all. Allocate it, and carry on */
1041 bfd_arm_pe_allocate_interworking_sections (& link_info);
1042 #endif /* TARGET_IS_armpe */
1043 }
1044 \f
1045 #ifdef DLL_SUPPORT
1046 /* This is called when an input file isn't recognized as a BFD. We
1047 check here for .DEF files and pull them in automatically. */
1049 static int
1050 saw_option(char *option)
1051 {
1052 int i;
1053 for (i=0; init[i].ptr; i++)
1054 if (strcmp (init[i].symbol, option) == 0)
1055 return init[i].inited;
1056 return 0;
1057 }
1058 #endif /* DLL_SUPPORT */
1060 static boolean
1061 gld_${EMULATION_NAME}_unrecognized_file(entry)
1062 lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1063 {
1064 #ifdef DLL_SUPPORT
1065 const char *ext = entry->filename + strlen (entry->filename) - 4;
1067 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1068 {
1069 if (pe_def_file == 0)
1070 pe_def_file = def_file_empty ();
1071 def_file_parse (entry->filename, pe_def_file);
1072 if (pe_def_file)
1073 {
1074 int i, buflen=0, len;
1075 char *buf;
1076 for (i=0; i<pe_def_file->num_exports; i++)
1077 {
1078 len = strlen(pe_def_file->exports[i].internal_name);
1079 if (buflen < len+2)
1080 buflen = len+2;
1081 }
1082 buf = (char *) xmalloc (buflen);
1083 for (i=0; i<pe_def_file->num_exports; i++)
1084 {
1085 struct bfd_link_hash_entry *h;
1086 sprintf(buf, "_%s", pe_def_file->exports[i].internal_name);
1088 h = bfd_link_hash_lookup (link_info.hash, buf, true, true, true);
1089 if (h == (struct bfd_link_hash_entry *) NULL)
1090 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1091 if (h->type == bfd_link_hash_new)
1092 {
1093 h->type = bfd_link_hash_undefined;
1094 h->u.undef.abfd = NULL;
1095 bfd_link_add_undef (link_info.hash, h);
1096 }
1097 }
1098 free (buf);
1100 /* def_file_print (stdout, pe_def_file); */
1101 if (pe_def_file->is_dll == 1)
1102 link_info.shared = 1;
1104 if (pe_def_file->base_address != (bfd_vma)(-1))
1105 {
1106 pe.ImageBase =
1107 pe_data (output_bfd)->pe_opthdr.ImageBase =
1108 init[IMAGEBASEOFF].value = pe_def_file->base_address;
1109 init[IMAGEBASEOFF].inited = 1;
1110 if (image_base_statement)
1111 image_base_statement->exp =
1112 exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1113 }
1115 #if 0
1116 /* Not sure if these *should* be set */
1117 if (pe_def_file->version_major != -1)
1118 {
1119 pe.MajorImageVersion = pe_def_file->version_major;
1120 pe.MinorImageVersion = pe_def_file->version_minor;
1121 }
1122 #endif
1123 if (pe_def_file->stack_reserve != -1
1124 && ! saw_option ("__size_of_stack_reserve__"))
1125 {
1126 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1127 if (pe_def_file->stack_commit != -1)
1128 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1129 }
1130 if (pe_def_file->heap_reserve != -1
1131 && ! saw_option ("__size_of_heap_reserve__"))
1132 {
1133 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1134 if (pe_def_file->heap_commit != -1)
1135 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1136 }
1137 return true;
1138 }
1139 }
1140 #endif
1141 return false;
1143 }
1145 static boolean
1146 gld_${EMULATION_NAME}_recognized_file(entry)
1147 lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1148 {
1149 #ifdef DLL_SUPPORT
1150 #ifdef TARGET_IS_i386pe
1151 pe_dll_id_target ("pei-i386");
1152 #endif
1153 #ifdef TARGET_IS_shpe
1154 pe_dll_id_target ("pei-shl");
1155 #endif
1156 #ifdef TARGET_IS_mipspe
1157 pe_dll_id_target ("pei-mips");
1158 #endif
1159 #ifdef TARGET_IS_armpe
1160 pe_dll_id_target ("pei-arm-little");
1161 #endif
1162 if (bfd_get_format (entry->the_bfd) == bfd_object)
1163 {
1164 const char *ext = entry->filename + strlen (entry->filename) - 4;
1165 if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1166 return pe_implied_import_dll (entry->filename);
1167 }
1168 #endif
1169 return false;
1170 }
1172 static void
1173 gld_${EMULATION_NAME}_finish ()
1174 {
1175 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1176 struct bfd_link_hash_entry * h;
1178 if (thumb_entry_symbol != NULL)
1179 {
1180 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol, false, false, true);
1182 if (h != (struct bfd_link_hash_entry *) NULL
1183 && (h->type == bfd_link_hash_defined
1184 || h->type == bfd_link_hash_defweak)
1185 && h->u.def.section->output_section != NULL)
1186 {
1187 static char buffer[32];
1188 bfd_vma val;
1190 /* Special procesing is required for a Thumb entry symbol. The
1191 bottom bit of its address must be set. */
1192 val = (h->u.def.value
1193 + bfd_get_section_vma (output_bfd,
1194 h->u.def.section->output_section)
1195 + h->u.def.section->output_offset);
1197 val |= 1;
1199 /* Now convert this value into a string and store it in entry_symbol
1200 where the lang_finish() function will pick it up. */
1201 buffer[0] = '0';
1202 buffer[1] = 'x';
1204 sprintf_vma (buffer + 2, val);
1206 if (entry_symbol != NULL && entry_from_cmdline)
1207 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1208 thumb_entry_symbol, entry_symbol);
1209 entry_symbol = buffer;
1210 }
1211 else
1212 einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1213 }
1214 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1216 #ifdef DLL_SUPPORT
1217 if (link_info.shared)
1218 {
1219 pe_dll_fill_sections (output_bfd, &link_info);
1220 if (pe_implib_filename)
1221 pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1222 }
1223 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1224 /* ARM doesn't need relocs. */
1225 else
1226 {
1227 pe_exe_fill_sections (output_bfd, &link_info);
1228 }
1229 #endif
1231 if (pe_out_def_filename)
1232 pe_dll_generate_def_file (pe_out_def_filename);
1233 #endif /* DLL_SUPPORT */
1234 }
1236 \f
1237 /* Place an orphan section.
1239 We use this to put sections in a reasonable place in the file, and
1240 to ensure that they are aligned as required.
1242 We handle grouped sections here as well. A section named .foo$nn
1243 goes into the output section .foo. All grouped sections are sorted
1244 by name.
1246 Grouped sections for the default sections are handled by the
1247 default linker script using wildcards, and are sorted by
1248 sort_sections. */
1250 struct orphan_save
1251 {
1252 lang_output_section_statement_type *os;
1253 asection **section;
1254 lang_statement_union_type **stmt;
1255 };
1257 /*ARGSUSED*/
1258 static boolean
1259 gld_${EMULATION_NAME}_place_orphan (file, s)
1260 lang_input_statement_type *file;
1261 asection *s;
1262 {
1263 const char *secname;
1264 char *hold_section_name;
1265 char *dollar = NULL;
1266 lang_output_section_statement_type *os;
1267 lang_statement_list_type add_child;
1269 secname = bfd_get_section_name (s->owner, s);
1271 /* Look through the script to see where to place this section. */
1273 hold_section_name = xstrdup (secname);
1274 if (!link_info.relocateable)
1275 {
1276 dollar = strchr (hold_section_name, '$');
1277 if (dollar != NULL)
1278 *dollar = '\0';
1279 }
1281 os = lang_output_section_find (hold_section_name);
1283 lang_list_init (&add_child);
1285 if (os != NULL
1286 && os->bfd_section != NULL
1287 && ((s->flags ^ os->bfd_section->flags) & (SEC_LOAD | SEC_ALLOC)) == 0)
1288 {
1289 wild_doit (&add_child, s, os, file);
1290 }
1291 else
1292 {
1293 struct orphan_save *place;
1294 static struct orphan_save hold_text;
1295 static struct orphan_save hold_rdata;
1296 static struct orphan_save hold_data;
1297 static struct orphan_save hold_bss;
1298 char *outsecname;
1299 lang_statement_list_type *old;
1300 lang_statement_list_type add;
1301 etree_type *address;
1303 /* Try to put the new output section in a reasonable place based
1304 on the section name and section flags. */
1305 #define HAVE_SECTION(hold, name) \
1306 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1308 place = NULL;
1309 if ((s->flags & SEC_ALLOC) == 0)
1310 ;
1311 else if ((s->flags & SEC_HAS_CONTENTS) == 0
1312 && HAVE_SECTION (hold_bss, ".bss"))
1313 place = &hold_bss;
1314 else if ((s->flags & SEC_READONLY) == 0
1315 && HAVE_SECTION (hold_data, ".data"))
1316 place = &hold_data;
1317 else if ((s->flags & SEC_CODE) == 0
1318 && (s->flags & SEC_READONLY) != 0
1319 && HAVE_SECTION (hold_rdata, ".rdata"))
1320 place = &hold_rdata;
1321 else if ((s->flags & SEC_READONLY) != 0
1322 && HAVE_SECTION (hold_text, ".text"))
1323 place = &hold_text;
1325 #undef HAVE_SECTION
1327 /* Choose a unique name for the section. This will be needed if
1328 the same section name appears in the input file with
1329 different loadable or allocateable characteristics. */
1330 outsecname = xstrdup (hold_section_name);
1331 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1332 {
1333 unsigned int len;
1334 char *newname;
1335 unsigned int i;
1337 len = strlen (outsecname);
1338 newname = xmalloc (len + 5);
1339 strcpy (newname, outsecname);
1340 i = 0;
1341 do
1342 {
1343 sprintf (newname + len, "%d", i);
1344 ++i;
1345 }
1346 while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1348 free (outsecname);
1349 outsecname = newname;
1350 }
1352 /* Start building a list of statements for this section. */
1353 old = stat_ptr;
1354 stat_ptr = &add;
1355 lang_list_init (stat_ptr);
1357 if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1358 address = exp_intop ((bfd_vma) 0);
1359 else
1360 {
1361 /* All sections in an executable must be aligned to a page
1362 boundary. */
1363 address = exp_unop (ALIGN_K,
1364 exp_nameop (NAME, "__section_alignment__"));
1365 }
1367 os = lang_enter_output_section_statement (outsecname, address, 0,
1368 (bfd_vma) 0,
1369 (etree_type *) NULL,
1370 (etree_type *) NULL,
1371 (etree_type *) NULL);
1373 wild_doit (&add_child, s, os, file);
1375 lang_leave_output_section_statement
1376 ((bfd_vma) 0, "*default*",
1377 (struct lang_output_section_phdr_list *) NULL, "*default*");
1379 stat_ptr = old;
1381 if (place != NULL)
1382 {
1383 asection *snew, **pps;
1385 snew = os->bfd_section;
1386 if (place->os->bfd_section != NULL || place->section != NULL)
1387 {
1388 /* Shuffle the section to make the output file look neater. */
1389 if (place->section == NULL)
1390 {
1391 #if 0
1392 /* Finding the end of the list is a little tricky. We
1393 make a wild stab at it by comparing section flags. */
1394 flagword first_flags = place->os->bfd_section->flags;
1395 for (pps = &place->os->bfd_section->next;
1396 *pps != NULL && (*pps)->flags == first_flags;
1397 pps = &(*pps)->next)
1398 ;
1399 place->section = pps;
1400 #else
1401 /* Put orphans after the first section on the list. */
1402 place->section = &place->os->bfd_section->next;
1403 #endif
1404 }
1406 /* Unlink the section. */
1407 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
1408 ;
1409 *pps = snew->next;
1411 /* Now tack it on to the "place->os" section list. */
1412 snew->next = *place->section;
1413 *place->section = snew;
1414 }
1415 place->section = &snew->next; /* Save the end of this list. */
1417 if (place->stmt == NULL)
1418 {
1419 /* Put the new statement list right at the head. */
1420 *add.tail = place->os->header.next;
1421 place->os->header.next = add.head;
1422 }
1423 else
1424 {
1425 /* Put it after the last orphan statement we added. */
1426 *add.tail = *place->stmt;
1427 *place->stmt = add.head;
1428 }
1429 place->stmt = add.tail; /* Save the end of this list. */
1430 }
1431 }
1433 {
1434 lang_statement_union_type **pl = &os->children.head;
1436 if (dollar != NULL)
1437 {
1438 boolean found_dollar;
1440 /* The section name has a '$'. Sort it with the other '$'
1441 sections. */
1443 found_dollar = false;
1444 for ( ; *pl != NULL; pl = &(*pl)->next)
1445 {
1446 lang_input_section_type *ls;
1447 const char *lname;
1449 if ((*pl)->header.type != lang_input_section_enum)
1450 continue;
1452 ls = &(*pl)->input_section;
1454 lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1455 if (strchr (lname, '$') == NULL)
1456 {
1457 if (found_dollar)
1458 break;
1459 }
1460 else
1461 {
1462 found_dollar = true;
1463 if (strcmp (secname, lname) < 0)
1464 break;
1465 }
1466 }
1467 }
1469 if (add_child.head != NULL)
1470 {
1471 add_child.head->next = *pl;
1472 *pl = add_child.head;
1473 }
1474 }
1476 free (hold_section_name);
1478 return true;
1479 }
1481 static boolean
1482 gld_${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
1483 const char * arch ATTRIBUTE_UNUSED;
1484 search_dirs_type * search;
1485 lang_input_statement_type * entry;
1486 {
1487 const char * filename;
1488 char * string;
1490 if (! entry->is_archive)
1491 return false;
1493 filename = entry->filename;
1495 string = (char *) xmalloc (strlen (search->name)
1496 + strlen (filename)
1497 + sizeof "/lib.a.dll"
1498 #ifdef DLL_SUPPORT
1499 + (pe_dll_search_prefix ? strlen (pe_dll_search_prefix) : 0)
1500 #endif
1501 + 1);
1503 /* Try "libfoo.dll.a" first (preferred explicit import library for dll's */
1504 sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1506 if (! ldfile_try_open_bfd (string, entry))
1507 {
1508 /* Try "foo.dll.a" next (alternate explicit import library for dll's */
1509 sprintf (string, "%s/%s.dll.a", search->name, filename);
1510 if (! ldfile_try_open_bfd (string, entry))
1511 {
1512 /*
1513 Try libfoo.a next. Normally, this would be interpreted as a static
1514 library, but it *could* be an import library. For backwards compatibility,
1515 libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1516 or sometimes errors occur when building legacy packages.
1518 Putting libfoo.a here means that in a failure case (i.e. the library
1519 -lfoo is not found) we will search for libfoo.a twice before
1520 giving up -- once here, and once when searching for a "static" lib.
1521 for a "static" lib.
1522 */
1523 /* Try "libfoo.a" (import lib, or static lib, but must
1524 take precedence over dll's) */
1525 sprintf (string, "%s/lib%s.a", search->name, filename);
1526 if (! ldfile_try_open_bfd (string, entry))
1527 {
1528 #ifdef DLL_SUPPORT
1529 if (pe_dll_search_prefix)
1530 {
1531 /* Try "<prefix>foo.dll" (preferred dll name, if specified) */
1532 sprintf (string, "%s/%s%s.dll", search->name, pe_dll_search_prefix, filename);
1533 if (! ldfile_try_open_bfd (string, entry))
1534 {
1535 /* Try "libfoo.dll" (default preferred dll name) */
1536 sprintf (string, "%s/lib%s.dll", search->name, filename);
1537 if (! ldfile_try_open_bfd (string, entry))
1538 {
1539 /* Finally, try "foo.dll" (alternate dll name) */
1540 sprintf (string, "%s/%s.dll", search->name, filename);
1541 if (! ldfile_try_open_bfd (string, entry))
1542 {
1543 free (string);
1544 return false;
1545 }
1546 }
1547 }
1548 }
1549 else /* pe_dll_search_prefix not specified */
1550 #endif
1551 {
1552 /* Try "libfoo.dll" (preferred dll name) */
1553 sprintf (string, "%s/lib%s.dll", search->name, filename);
1554 if (! ldfile_try_open_bfd (string, entry))
1555 {
1556 /* Finally, try "foo.dll" (alternate dll name) */
1557 sprintf (string, "%s/%s.dll", search->name, filename);
1558 if (! ldfile_try_open_bfd (string, entry))
1559 {
1560 free (string);
1561 return false;
1562 }
1563 }
1564 }
1565 }
1566 }
1567 }
1569 entry->filename = string;
1571 return true;
1572 }
1574 static int
1575 gld_${EMULATION_NAME}_find_potential_libraries (name, entry)
1576 char * name;
1577 lang_input_statement_type * entry;
1578 {
1579 return ldfile_open_file_search (name, entry, "", ".lib");
1580 }
1581 \f
1582 static char *
1583 gld_${EMULATION_NAME}_get_script(isfile)
1584 int *isfile;
1585 EOF
1586 # Scripts compiled in.
1587 # sed commands to quote an ld script as a C string.
1588 sc="-f stringify.sed"
1590 cat >>e${EMULATION_NAME}.c <<EOF
1591 {
1592 *isfile = 0;
1594 if (link_info.relocateable == true && config.build_constructors == true)
1595 return
1596 EOF
1597 sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1598 echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1599 sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1600 echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1601 sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1602 echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1603 sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1604 echo ' ; else return' >> e${EMULATION_NAME}.c
1605 sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1606 echo '; }' >> e${EMULATION_NAME}.c
1608 cat >>e${EMULATION_NAME}.c <<EOF
1611 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1612 {
1613 gld_${EMULATION_NAME}_before_parse,
1614 syslib_default,
1615 hll_default,
1616 gld_${EMULATION_NAME}_after_parse,
1617 gld_${EMULATION_NAME}_after_open,
1618 after_allocation_default,
1619 set_output_arch_default,
1620 ldemul_default_target,
1621 gld_${EMULATION_NAME}_before_allocation,
1622 gld_${EMULATION_NAME}_get_script,
1623 "${EMULATION_NAME}",
1624 "${OUTPUT_FORMAT}",
1625 gld_${EMULATION_NAME}_finish, /* finish */
1626 NULL, /* create output section statements */
1627 gld_${EMULATION_NAME}_open_dynamic_archive,
1628 gld_${EMULATION_NAME}_place_orphan,
1629 gld_${EMULATION_NAME}_set_symbols,
1630 gld_${EMULATION_NAME}_parse_args,
1631 gld_${EMULATION_NAME}_unrecognized_file,
1632 gld_${EMULATION_NAME}_list_options,
1633 gld_${EMULATION_NAME}_recognized_file,
1634 gld_${EMULATION_NAME}_find_potential_libraries
1635 };
1636 EOF