projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* dwarf2dbg.c (dwarf2_directive_file): Avoid signed/unsigned warning.
[deliverable/binutils-gdb.git] / ld / emultempl / pe.em
CommitLineData
252b5132
RH		 1# This shell script emits a C file. -*- C -*-
2# It does some substitutions.
3fc90ddb 3if [ -z "$MACHINE" ]; then
86af25fe
L		 4 OUTPUT_ARCH=${ARCH}
5else
6 OUTPUT_ARCH=${ARCH}:${MACHINE}
7fi
361d94e7
ILT		 8rm -f e${EMULATION_NAME}.c
9(echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
c6c37250 10cat >>e${EMULATION_NAME}.c <<EOF
252b5132 11/* This file is part of GLD, the Gnu Linker.
39dcfe18 12 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001
a2b64bed 13 Free Software Foundation, Inc.
252b5132
RH		 14
15This program is free software; you can redistribute it and/or modify
16it under the terms of the GNU General Public License as published by
17the Free Software Foundation; either version 2 of the License, or
18(at your option) any later version.
19
20This program is distributed in the hope that it will be useful,
21but WITHOUT ANY WARRANTY; without even the implied warranty of
22MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23GNU General Public License for more details.
24
25You should have received a copy of the GNU General Public License
26along with this program; if not, write to the Free Software
27Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28
29/* For WINDOWS_NT */
30/* The original file generated returned different default scripts depending
31 on whether certain switches were set, but these switches pertain to the
32 Linux system and that particular version of coff. In the NT case, we
33 only determine if the subsystem is console or windows in order to select
3fc90ddb
AJ		 34 the correct entry point by default. */
35
252b5132
RH		 36#include "bfd.h"
37#include "sysdep.h"
38#include "bfdlink.h"
39#include "getopt.h"
40#include "libiberty.h"
41#include "ld.h"
42#include "ldmain.h"
43#include "ldgram.h"
44#include "ldexp.h"
45#include "ldlang.h"
b71e2778 46#include "ldfile.h"
252b5132
RH		 47#include "ldemul.h"
48#include "ldlex.h"
49#include "ldmisc.h"
50#include "ldctor.h"
252b5132 51#include "coff/internal.h"
71add731
ILT		 52
53/* FIXME: This is a BFD internal header file, and we should not be
54 using it here. */
252b5132 55#include "../bfd/libcoff.h"
71add731 56
252b5132 57#include "deffile.h"
1069dd8d 58#include "pe-dll.h"
252b5132 59
14fe918e
L		 60#include <ctype.h>
61
252b5132
RH		 62#define TARGET_IS_${EMULATION_NAME}
63
2be9b2c7
ILT		 64/* Permit the emulation parameters to override the default section
65 alignment by setting OVERRIDE_SECTION_ALIGNMENT. FIXME: This makes
66 it seem that include/coff/internal.h should not define
67 PE_DEF_SECTION_ALIGNMENT. */
68#if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
69#undef PE_DEF_SECTION_ALIGNMENT
70#define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
71#endif
72
c6c37250
DD		 73#if defined(TARGET_IS_i386pe)
74#define DLL_SUPPORT
75#endif
344a211f
NC		 76#if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe) || defined(TARGET_IS_armpe)
77#define DLL_SUPPORT
78#endif
c6c37250 79
344a211f 80#if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
c6c37250 81#define PE_DEF_SUBSYSTEM 3
344a211f
NC		 82#else
83#undef NT_EXE_IMAGE_BASE
84#undef PE_DEF_SECTION_ALIGNMENT
85#undef PE_DEF_FILE_ALIGNMENT
86#define NT_EXE_IMAGE_BASE 0x00010000
87#ifdef TARGET_IS_armpe
88#define PE_DEF_SECTION_ALIGNMENT 0x00001000
89#define PE_DEF_SUBSYSTEM 9
90#else
91#define PE_DEF_SECTION_ALIGNMENT 0x00000400
92#define PE_DEF_SUBSYSTEM 2
93#endif
94#define PE_DEF_FILE_ALIGNMENT 0x00000200
95#endif
c6c37250 96
434d1125
NC		 97#ifdef TARGET_IS_arm_epoc_pe
98#define bfd_arm_pe_allocate_interworking_sections \
99 bfd_arm_epoc_pe_allocate_interworking_sections
100#define bfd_arm_pe_get_bfd_for_interworking \
101 bfd_arm_epoc_pe_get_bfd_for_interworking
102#define bfd_arm_pe_process_before_allocation \
103 bfd_arm_epoc_pe_process_before_allocation
104#endif
105
252b5132
RH		 106static void gld_${EMULATION_NAME}_set_symbols PARAMS ((void));
107static void gld_${EMULATION_NAME}_after_open PARAMS ((void));
108static void gld_${EMULATION_NAME}_before_parse PARAMS ((void));
109static void gld_${EMULATION_NAME}_after_parse PARAMS ((void));
110static void gld_${EMULATION_NAME}_before_allocation PARAMS ((void));
ae7fb08f
AM		 111static asection *output_prev_sec_find
112 PARAMS ((lang_output_section_statement_type *));
252b5132
RH		 113static boolean gld_${EMULATION_NAME}_place_orphan
114 PARAMS ((lang_input_statement_type *, asection *));
252b5132
RH		 115static char *gld_${EMULATION_NAME}_get_script PARAMS ((int *));
116static int gld_${EMULATION_NAME}_parse_args PARAMS ((int, char **));
6f798e5c 117static void gld_${EMULATION_NAME}_finish PARAMS ((void));
3fc90ddb 118static boolean gld_${EMULATION_NAME}_open_dynamic_archive
690a460e 119 PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
3fc90ddb
AJ		 120static void gld_${EMULATION_NAME}_list_options PARAMS ((FILE *));
121static void set_pe_name PARAMS ((char *, long));
122static void set_pe_subsystem PARAMS ((void));
123static void set_pe_value PARAMS ((char *));
124static void set_pe_stack_heap PARAMS ((char *, char *));
125
126#ifdef DLL_SUPPORT
127static boolean pe_undef_cdecl_match
128 PARAMS ((struct bfd_link_hash_entry *, PTR));
129static void pe_fixup_stdcalls PARAMS ((void));
0d888aac 130static int make_import_fixup PARAMS ((arelent *, asection *));
3fc90ddb
AJ		 131static void pe_find_data_imports PARAMS ((void));
132#endif
133
134static boolean pr_sym PARAMS ((struct bfd_hash_entry *, PTR string));
135static boolean gld_${EMULATION_NAME}_unrecognized_file
136 PARAMS ((lang_input_statement_type *));
137static boolean gld_${EMULATION_NAME}_recognized_file
138 PARAMS ((lang_input_statement_type *));
139static int gld_${EMULATION_NAME}_find_potential_libraries
140 PARAMS ((char *, lang_input_statement_type *));
141
252b5132
RH		 142
143static struct internal_extra_pe_aouthdr pe;
144static int dll;
145static int support_old_code = 0;
6f798e5c 146static char * thumb_entry_symbol = NULL;
252b5132
RH		 147static lang_assignment_statement_type *image_base_statement = 0;
148
f0c87f88 149#ifdef DLL_SUPPORT
2ef53d66 150static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable */
690a460e
NC		 151static char *pe_out_def_filename = NULL;
152static char *pe_implib_filename = NULL;
5f577f7d 153static int pe_enable_auto_image_base = 0;
627427de 154static char *pe_dll_search_prefix = NULL;
f0c87f88 155#endif
252b5132
RH		 156
157extern const char *output_filename;
158
159static void
160gld_${EMULATION_NAME}_before_parse()
161{
86af25fe
L		 162 const bfd_arch_info_type *arch = bfd_scan_arch ("${OUTPUT_ARCH}");
163 if (arch)
164 {
165 ldfile_output_architecture = arch->arch;
166 ldfile_output_machine = arch->mach;
167 ldfile_output_machine_name = arch->printable_name;
168 }
169 else
170 ldfile_output_architecture = bfd_arch_${ARCH};
db8d4f23 171 output_filename = "${EXECUTABLE_NAME:-a.exe}";
c6c37250 172#ifdef DLL_SUPPORT
decc3638 173 config.dynamic_link = true;
252b5132 174 config.has_shared = 1;
decc3638 175/* link_info.pei386_auto_import = true; */
344a211f
NC		 176
177#if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
178#if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
179 lang_add_entry ("WinMainCRTStartup", 1);
180#else
181 lang_add_entry ("_WinMainCRTStartup", 1);
182#endif
183#endif
252b5132
RH		 184#endif
185}
186\f
187/* PE format extra command line options. */
188
189/* Used for setting flags in the PE header. */
190#define OPTION_BASE_FILE (300 + 1)
191#define OPTION_DLL (OPTION_BASE_FILE + 1)
192#define OPTION_FILE_ALIGNMENT (OPTION_DLL + 1)
193#define OPTION_IMAGE_BASE (OPTION_FILE_ALIGNMENT + 1)
194#define OPTION_MAJOR_IMAGE_VERSION (OPTION_IMAGE_BASE + 1)
195#define OPTION_MAJOR_OS_VERSION (OPTION_MAJOR_IMAGE_VERSION + 1)
196#define OPTION_MAJOR_SUBSYSTEM_VERSION (OPTION_MAJOR_OS_VERSION + 1)
197#define OPTION_MINOR_IMAGE_VERSION (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
198#define OPTION_MINOR_OS_VERSION (OPTION_MINOR_IMAGE_VERSION + 1)
199#define OPTION_MINOR_SUBSYSTEM_VERSION (OPTION_MINOR_OS_VERSION + 1)
200#define OPTION_SECTION_ALIGNMENT (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
201#define OPTION_STACK (OPTION_SECTION_ALIGNMENT + 1)
202#define OPTION_SUBSYSTEM (OPTION_STACK + 1)
203#define OPTION_HEAP (OPTION_SUBSYSTEM + 1)
204#define OPTION_SUPPORT_OLD_CODE (OPTION_HEAP + 1)
205#define OPTION_OUT_DEF (OPTION_SUPPORT_OLD_CODE + 1)
206#define OPTION_EXPORT_ALL (OPTION_OUT_DEF + 1)
207#define OPTION_EXCLUDE_SYMBOLS (OPTION_EXPORT_ALL + 1)
208#define OPTION_KILL_ATS (OPTION_EXCLUDE_SYMBOLS + 1)
209#define OPTION_STDCALL_ALIASES (OPTION_KILL_ATS + 1)
210#define OPTION_ENABLE_STDCALL_FIXUP (OPTION_STDCALL_ALIASES + 1)
211#define OPTION_DISABLE_STDCALL_FIXUP (OPTION_ENABLE_STDCALL_FIXUP + 1)
212#define OPTION_IMPLIB_FILENAME (OPTION_DISABLE_STDCALL_FIXUP + 1)
6f798e5c 213#define OPTION_THUMB_ENTRY (OPTION_IMPLIB_FILENAME + 1)
870df5dc
NC		 214#define OPTION_WARN_DUPLICATE_EXPORTS (OPTION_THUMB_ENTRY + 1)
215#define OPTION_IMP_COMPAT (OPTION_WARN_DUPLICATE_EXPORTS + 1)
5f577f7d
DD		 216#define OPTION_ENABLE_AUTO_IMAGE_BASE (OPTION_IMP_COMPAT + 1)
217#define OPTION_DISABLE_AUTO_IMAGE_BASE (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
1122a5fc
NC		 218#define OPTION_DLL_SEARCH_PREFIX (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
219#define OPTION_NO_DEFAULT_EXCLUDES (OPTION_DLL_SEARCH_PREFIX + 1)
decc3638
CW		 220#define OPTION_DLL_ENABLE_AUTO_IMPORT (OPTION_NO_DEFAULT_EXCLUDES + 1)
221#define OPTION_DLL_DISABLE_AUTO_IMPORT (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
222#define OPTION_ENABLE_EXTRA_PE_DEBUG (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
252b5132 223
1122a5fc 224static struct option longopts[] = {
252b5132
RH		 225 /* PE options */
226 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
227 {"dll", no_argument, NULL, OPTION_DLL},
228 {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
3fc90ddb 229 {"heap", required_argument, NULL, OPTION_HEAP},
252b5132
RH		 230 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
231 {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
232 {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
233 {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
234 {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
235 {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
236 {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
237 {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
238 {"stack", required_argument, NULL, OPTION_STACK},
239 {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
240 {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
6f798e5c 241 {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
c6c37250 242#ifdef DLL_SUPPORT
252b5132
RH		 243 /* getopt allows abbreviations, so we do this to stop it from treating -o
244 as an abbreviation for this option */
245 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
246 {"output-def", required_argument, NULL, OPTION_OUT_DEF},
247 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
248 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
249 {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
250 {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
251 {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
252 {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
253 {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
870df5dc
NC		 254 {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
255 {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
5f577f7d
DD		 256 {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
257 {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
627427de 258 {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
1122a5fc 259 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
decc3638
CW		 260 {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
261 {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
262 {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
252b5132
RH		 263#endif
264 {NULL, no_argument, NULL, 0}
265};
266
267
268/* PE/WIN32; added routines to get the subsystem type, heap and/or stack
269 parameters which may be input from the command line */
270
271typedef struct
272{
273 void *ptr;
274 int size;
275 int value;
276 char *symbol;
277 int inited;
278} definfo;
279
280#define D(field,symbol,def) {&pe.field,sizeof(pe.field), def, symbol,0}
281
282static definfo init[] =
283{
284 /* imagebase must be first */
285#define IMAGEBASEOFF 0
286 D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
287#define DLLOFF 1
1069dd8d 288 {&dll, sizeof(dll), 0, "__dll__", 0},
252b5132
RH		 289 D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
290 D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
291 D(MajorOperatingSystemVersion,"__major_os_version__", 4),
292 D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
293 D(MajorImageVersion,"__major_image_version__", 1),
294 D(MinorImageVersion,"__minor_image_version__", 0),
344a211f
NC		 295#ifdef TARGET_IS_armpe
296 D(MajorSubsystemVersion,"__major_subsystem_version__", 2),
297#else
252b5132 298 D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
344a211f 299#endif
252b5132 300 D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
2be9b2c7 301 D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
3763134d 302 D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
252b5132
RH		 303 D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
304 D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
305 D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
306 D(LoaderFlags,"__loader_flags__", 0x0),
307 { NULL, 0, 0, NULL, 0 }
308};
309
310static void
311gld_${EMULATION_NAME}_list_options (file)
312 FILE * file;
313{
314 fprintf (file, _(" --base_file <basefile> Generate a base file for relocatable DLLs\n"));
315 fprintf (file, _(" --dll Set image base to the default for DLLs\n"));
316 fprintf (file, _(" --file-alignment <size> Set file alignment\n"));
317 fprintf (file, _(" --heap <size> Set initial size of the heap\n"));
318 fprintf (file, _(" --image-base <address> Set start address of the executable\n"));
319 fprintf (file, _(" --major-image-version <number> Set version number of the executable\n"));
320 fprintf (file, _(" --major-os-version <number> Set minimum required OS version\n"));
321 fprintf (file, _(" --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
322 fprintf (file, _(" --minor-image-version <number> Set revision number of the executable\n"));
323 fprintf (file, _(" --minor-os-version <number> Set minimum required OS revision\n"));
324 fprintf (file, _(" --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
325 fprintf (file, _(" --section-alignment <size> Set section alignment\n"));
326 fprintf (file, _(" --stack <size> Set size of the initial stack\n"));
327 fprintf (file, _(" --subsystem <name>[:<version>] Set required OS subsystem [& version]\n"));
328 fprintf (file, _(" --support-old-code Support interworking with old code\n"));
6f798e5c 329 fprintf (file, _(" --thumb-entry=<symbol> Set the entry point to be Thumb <symbol>\n"));
c6c37250 330#ifdef DLL_SUPPORT
252b5132
RH		 331 fprintf (file, _(" --add-stdcall-alias Export symbols with and without @nn\n"));
332 fprintf (file, _(" --disable-stdcall-fixup Don't link _sym to _sym@nn\n"));
333 fprintf (file, _(" --enable-stdcall-fixup Link _sym to _sym@nn without warnings\n"));
334 fprintf (file, _(" --exclude-symbols sym,sym,... Exclude symbols from automatic export\n"));
335 fprintf (file, _(" --export-all-symbols Automatically export all globals to DLL\n"));
336 fprintf (file, _(" --kill-at Remove @nn from exported symbols\n"));
337 fprintf (file, _(" --out-implib <file> Generate import library\n"));
338 fprintf (file, _(" --output-def <file> Generate a .DEF file for the built DLL\n"));
0752a404
NC		 339 fprintf (file, _(" --warn-duplicate-exports Warn about duplicate exports.\n"));
340 fprintf (file, _(" --compat-implib Create backward compatible import libs;\n"));
341 fprintf (file, _(" create __imp_<SYMBOL> as well.\n"));
5f577f7d
DD		 342 fprintf (file, _(" --enable-auto-image-base Automatically choose image base for DLLs\n"));
343 fprintf (file, _(" unless user specifies one\n"));
344 fprintf (file, _(" --disable-auto-image-base Do not auto-choose image base. (default)\n"));
627427de
DD		 345 fprintf (file, _(" --dll-search-prefix=<string> When linking dynamically to a dll witout an\n"));
346 fprintf (file, _(" importlib, use <string><basename>.dll \n"));
347 fprintf (file, _(" in preference to lib<basename>.dll \n"));
decc3638
CW		 348 fprintf (file, _(" --enable-auto-import Do sophistcated linking of _sym to \n"));
349 fprintf (file, _(" __imp_sym for DATA references\n"));
350 fprintf (file, _(" --disable-auto-import Do not auto-import DATA items from DLLs\n"));
351 fprintf (file, _(" --enable-extra-pe-debug Enable verbose debug output when building\n"));
352 fprintf (file, _(" or linking to DLLs (esp. auto-import)\n"));
252b5132
RH		 353#endif
354}
355
356static void
357set_pe_name (name, val)
358 char *name;
359 long val;
360{
361 int i;
362 /* Find the name and set it. */
363 for (i = 0; init[i].ptr; i++)
364 {
365 if (strcmp (name, init[i].symbol) == 0)
366 {
367 init[i].value = val;
368 init[i].inited = 1;
369 return;
370 }
371 }
372 abort();
373}
374
375
376static void
377set_pe_subsystem ()
378{
379 const char *sver;
380 int len;
381 int i;
3fc90ddb 382 static const struct
252b5132
RH		 383 {
384 const char *name;
385 const int value;
386 const char *entry;
387 }
388 v[] =
389 {
2be9b2c7 390 { "native", 1, "NtProcessStartup" },
344a211f 391#if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
2be9b2c7 392 { "windows", 2, "WinMainCRTStartup" },
344a211f
NC		 393#else
394 { "windows", 2, "WinMainCRTStartup" },
395#endif
2be9b2c7 396 { "console", 3, "mainCRTStartup" },
252b5132
RH		 397#if 0
398 /* The Microsoft linker does not recognize this. */
399 { "os2", 5, "" },
400#endif
2be9b2c7 401 { "posix", 7, "__PosixProcessStartup"},
344a211f 402 { "wince", 9, "_WinMainCRTStartup" },
252b5132
RH		 403 { 0, 0, 0 }
404 };
405
406 sver = strchr (optarg, ':');
407 if (sver == NULL)
408 len = strlen (optarg);
409 else
410 {
411 char *end;
412
413 len = sver - optarg;
414 set_pe_name ("__major_subsystem_version__",
415 strtoul (sver + 1, &end, 0));
416 if (*end == '.')
417 set_pe_name ("__minor_subsystem_version__",
418 strtoul (end + 1, &end, 0));
419 if (*end != '\0')
420 einfo (_("%P: warning: bad version number in -subsystem option\n"));
421 }
422
423 for (i = 0; v[i].name; i++)
424 {
425 if (strncmp (optarg, v[i].name, len) == 0
426 && v[i].name[len] == '\0')
427 {
2be9b2c7
ILT		 428 const char *initial_symbol_char;
429 const char *entry;
430
252b5132
RH		 431 set_pe_name ("__subsystem__", v[i].value);
432
2be9b2c7
ILT		 433 initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
434 if (*initial_symbol_char == '\0')
435 entry = v[i].entry;
436 else
437 {
438 char *alc_entry;
439
440 /* lang_add_entry expects its argument to be permanently
441 allocated, so we don't free this string. */
442 alc_entry = xmalloc (strlen (initial_symbol_char)
443 + strlen (v[i].entry)
444 + 1);
445 strcpy (alc_entry, initial_symbol_char);
446 strcat (alc_entry, v[i].entry);
447 entry = alc_entry;
448 }
449
450 lang_add_entry (entry, 1);
252b5132
RH		 451
452 return;
453 }
454 }
3fc90ddb 455
252b5132
RH		 456 einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
457}
458
459
460
461static void
462set_pe_value (name)
463 char *name;
3fc90ddb 464
252b5132
RH		 465{
466 char *end;
3fc90ddb 467
252b5132 468 set_pe_name (name, strtoul (optarg, &end, 0));
3fc90ddb 469
252b5132
RH		 470 if (end == optarg)
471 einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
472
473 optarg = end;
474}
475
476static void
477set_pe_stack_heap (resname, comname)
478 char *resname;
479 char *comname;
480{
481 set_pe_value (resname);
3fc90ddb 482
252b5132
RH		 483 if (*optarg == ',')
484 {
485 optarg++;
486 set_pe_value (comname);
487 }
488 else if (*optarg)
489 einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
490}
491
492
493
494static int
495gld_${EMULATION_NAME}_parse_args(argc, argv)
496 int argc;
497 char **argv;
498{
499 int longind;
500 int optc;
501 int prevoptind = optind;
502 int prevopterr = opterr;
503 int wanterror;
504 static int lastoptind = -1;
505
506 if (lastoptind != optind)
507 opterr = 0;
508 wanterror = opterr;
509
510 lastoptind = optind;
511
512 optc = getopt_long_only (argc, argv, "-", longopts, &longind);
513 opterr = prevopterr;
514
515 switch (optc)
516 {
517 default:
518 if (wanterror)
519 xexit (1);
520 optind = prevoptind;
521 return 0;
522
523 case OPTION_BASE_FILE:
524 link_info.base_file = (PTR) fopen (optarg, FOPEN_WB);
525 if (link_info.base_file == NULL)
526 {
527 /* xgettext:c-format */
528 fprintf (stderr, _("%s: Can't open base file %s\n"),
529 program_name, optarg);
530 xexit (1);
531 }
532 break;
533
534 /* PE options */
3fc90ddb 535 case OPTION_HEAP:
252b5132
RH		 536 set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
537 break;
3fc90ddb 538 case OPTION_STACK:
252b5132
RH		 539 set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
540 break;
541 case OPTION_SUBSYSTEM:
542 set_pe_subsystem ();
543 break;
544 case OPTION_MAJOR_OS_VERSION:
545 set_pe_value ("__major_os_version__");
546 break;
547 case OPTION_MINOR_OS_VERSION:
548 set_pe_value ("__minor_os_version__");
549 break;
550 case OPTION_MAJOR_SUBSYSTEM_VERSION:
551 set_pe_value ("__major_subsystem_version__");
552 break;
553 case OPTION_MINOR_SUBSYSTEM_VERSION:
554 set_pe_value ("__minor_subsystem_version__");
555 break;
556 case OPTION_MAJOR_IMAGE_VERSION:
557 set_pe_value ("__major_image_version__");
558 break;
559 case OPTION_MINOR_IMAGE_VERSION:
560 set_pe_value ("__minor_image_version__");
561 break;
562 case OPTION_FILE_ALIGNMENT:
563 set_pe_value ("__file_alignment__");
564 break;
565 case OPTION_SECTION_ALIGNMENT:
566 set_pe_value ("__section_alignment__");
567 break;
568 case OPTION_DLL:
569 set_pe_name ("__dll__", 1);
570 break;
571 case OPTION_IMAGE_BASE:
572 set_pe_value ("__image_base__");
573 break;
574 case OPTION_SUPPORT_OLD_CODE:
575 support_old_code = 1;
576 break;
6f798e5c
NC		 577 case OPTION_THUMB_ENTRY:
578 thumb_entry_symbol = optarg;
579 break;
c6c37250 580#ifdef DLL_SUPPORT
252b5132
RH		 581 case OPTION_OUT_DEF:
582 pe_out_def_filename = xstrdup (optarg);
583 break;
584 case OPTION_EXPORT_ALL:
585 pe_dll_export_everything = 1;
586 break;
587 case OPTION_EXCLUDE_SYMBOLS:
252b5132 588 pe_dll_add_excludes (optarg);
252b5132
RH		 589 break;
590 case OPTION_KILL_ATS:
591 pe_dll_kill_ats = 1;
592 break;
593 case OPTION_STDCALL_ALIASES:
594 pe_dll_stdcall_aliases = 1;
595 break;
596 case OPTION_ENABLE_STDCALL_FIXUP:
597 pe_enable_stdcall_fixup = 1;
598 break;
599 case OPTION_DISABLE_STDCALL_FIXUP:
600 pe_enable_stdcall_fixup = 0;
601 break;
602 case OPTION_IMPLIB_FILENAME:
603 pe_implib_filename = xstrdup (optarg);
604 break;
870df5dc
NC		 605 case OPTION_WARN_DUPLICATE_EXPORTS:
606 pe_dll_warn_dup_exports = 1;
607 break;
608 case OPTION_IMP_COMPAT:
609 pe_dll_compat_implib = 1;
610 break;
5f577f7d
DD		 611 case OPTION_ENABLE_AUTO_IMAGE_BASE:
612 pe_enable_auto_image_base = 1;
613 break;
614 case OPTION_DISABLE_AUTO_IMAGE_BASE:
615 pe_enable_auto_image_base = 0;
616 break;
627427de
DD		 617 case OPTION_DLL_SEARCH_PREFIX:
618 pe_dll_search_prefix = xstrdup( optarg );
619 break;
1122a5fc
NC		 620 case OPTION_NO_DEFAULT_EXCLUDES:
621 pe_dll_do_default_excludes = 0;
622 break;
decc3638
CW		 623 case OPTION_DLL_ENABLE_AUTO_IMPORT:
624 link_info.pei386_auto_import = true;
625 break;
626 case OPTION_DLL_DISABLE_AUTO_IMPORT:
627 link_info.pei386_auto_import = false;
628 break;
629 case OPTION_ENABLE_EXTRA_PE_DEBUG:
630 pe_dll_extra_pe_debug = 1;
631 break;
c6c37250 632#endif
252b5132
RH		 633 }
634 return 1;
635}
636\f
5f577f7d 637
2ef53d66 638#ifdef DLL_SUPPORT
3fc90ddb 639static unsigned long
5f577f7d
DD		 640strhash (const char *str)
641{
642 const unsigned char *s;
643 unsigned long hash;
644 unsigned int c;
645 unsigned int len;
646
647 hash = 0;
648 len = 0;
649 s = (const unsigned char *) str;
650 while ((c = *s++) != '\0')
651 {
652 hash += c + (c << 17);
653 hash ^= hash >> 2;
654 ++len;
655 }
656 hash += len + (len << 17);
657 hash ^= hash >> 2;
658
659 return hash;
660}
661
662/* Use the output file to create a image base for relocatable DLLs. */
663static unsigned long
664compute_dll_image_base (const char *ofile)
665{
666 unsigned long hash = strhash (ofile);
667 return 0x60000000 | ((hash << 16) & 0x0FFC0000);
668}
2ef53d66 669#endif
5f577f7d 670
252b5132
RH		 671/* Assign values to the special symbols before the linker script is
672 read. */
673
674static void
675gld_${EMULATION_NAME}_set_symbols ()
676{
677 /* Run through and invent symbols for all the
678 names and insert the defaults. */
679 int j;
680 lang_statement_list_type *save;
681
682 if (!init[IMAGEBASEOFF].inited)
683 {
684 if (link_info.relocateable)
685 init[IMAGEBASEOFF].value = 0;
686 else if (init[DLLOFF].value || link_info.shared)
2ef53d66 687#ifdef DLL_SUPPORT
5f577f7d
DD		 688 init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
689 compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
2ef53d66
L		 690#else
691 init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
692#endif
252b5132
RH		 693 else
694 init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
695 }
696
697 /* Don't do any symbol assignments if this is a relocateable link. */
698 if (link_info.relocateable)
699 return;
700
701 /* Glue the assignments into the abs section */
702 save = stat_ptr;
703
704 stat_ptr = &(abs_output_section->children);
705
706 for (j = 0; init[j].ptr; j++)
707 {
708 long val = init[j].value;
709 lang_assignment_statement_type *rv;
710 rv = lang_add_assignment (exp_assop ('=' ,init[j].symbol, exp_intop (val)));
711 if (init[j].size == sizeof(short))
712 *(short *)init[j].ptr = val;
713 else if (init[j].size == sizeof(int))
714 *(int *)init[j].ptr = val;
715 else if (init[j].size == sizeof(long))
716 *(long *)init[j].ptr = val;
717 /* This might be a long long or other special type. */
718 else if (init[j].size == sizeof(bfd_vma))
719 *(bfd_vma *)init[j].ptr = val;
720 else abort();
721 if (j == IMAGEBASEOFF)
722 image_base_statement = rv;
723 }
724 /* Restore the pointer. */
725 stat_ptr = save;
3fc90ddb 726
252b5132
RH		 727 if (pe.FileAlignment >
728 pe.SectionAlignment)
729 {
730 einfo (_("%P: warning, file alignment > section alignment.\n"));
731 }
732}
733
734/* This is called after the linker script and the command line options
735 have been read. */
736
737static void
738gld_${EMULATION_NAME}_after_parse ()
739{
740 /* The Windows libraries are designed for the linker to treat the
741 entry point as an undefined symbol. Otherwise, the .obj that
742 defines mainCRTStartup is brought in because it is the first
743 encountered in libc.lib and it has other symbols in it which will
744 be pulled in by the link process. To avoid this, we act as
745 though the user specified -u with the entry point symbol.
746
747 This function is called after the linker script and command line
748 options have been read, so at this point we know the right entry
749 point. This function is called before the input files are
750 opened, so registering the symbol as undefined will make a
751 difference. */
752
2a275620 753 if (! link_info.relocateable && entry_symbol != NULL)
252b5132
RH		 754 ldlang_add_undef (entry_symbol);
755}
756
2ef53d66 757#ifdef DLL_SUPPORT
252b5132
RH		 758static struct bfd_link_hash_entry *pe_undef_found_sym;
759
760static boolean
761pe_undef_cdecl_match (h, string)
762 struct bfd_link_hash_entry *h;
763 PTR string;
764{
decc3638
CW		 765 int sl;
766 sl = strlen (string); /* silence compiler warning */
252b5132
RH		 767 if (h->type == bfd_link_hash_defined
768 && strncmp (h->root.string, string, sl) == 0
769 && h->root.string[sl] == '@')
decc3638
CW		 770 {
771 pe_undef_found_sym = h;
772 return false;
773 }
252b5132
RH		 774 return true;
775}
776
777static void
778pe_fixup_stdcalls ()
779{
780 static int gave_warning_message = 0;
781 struct bfd_link_hash_entry *undef, *sym;
782 char *at;
3fc90ddb 783 if (pe_dll_extra_pe_debug)
decc3638
CW		 784 {
785 printf ("%s\n", __FUNCTION__);
786 }
3fc90ddb 787
252b5132
RH		 788 for (undef = link_info.hash->undefs; undef; undef=undef->next)
789 if (undef->type == bfd_link_hash_undefined)
790 {
791 at = strchr (undef->root.string, '@');
792 if (at)
793 {
794 /* The symbol is a stdcall symbol, so let's look for a cdecl
795 symbol with the same name and resolve to that */
796 char *cname = xstrdup (undef->root.string);
797 at = strchr (cname, '@');
798 *at = 0;
799 sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
800 if (sym && sym->type == bfd_link_hash_defined)
801 {
802 undef->type = bfd_link_hash_defined;
803 undef->u.def.value = sym->u.def.value;
804 undef->u.def.section = sym->u.def.section;
805 if (pe_enable_stdcall_fixup == -1)
806 {
807 einfo (_("Warning: resolving %s by linking to %s\n"),
808 undef->root.string, cname);
809 if (! gave_warning_message)
810 {
811 gave_warning_message = 1;
812 einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
813 einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
814 }
815 }
816 }
817 }
818 else
819 {
820 /* The symbol is a cdecl symbol, so we look for stdcall
821 symbols - which means scanning the whole symbol table */
822 pe_undef_found_sym = 0;
823 bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
824 (PTR) undef->root.string);
825 sym = pe_undef_found_sym;
826 if (sym)
827 {
828 undef->type = bfd_link_hash_defined;
829 undef->u.def.value = sym->u.def.value;
830 undef->u.def.section = sym->u.def.section;
831 if (pe_enable_stdcall_fixup == -1)
832 {
833 einfo (_("Warning: resolving %s by linking to %s\n"),
834 undef->root.string, sym->root.string);
835 if (! gave_warning_message)
836 {
837 gave_warning_message = 1;
838 einfo(_("Use --enable-stdcall-fixup to disable these warnings\n"));
839 einfo(_("Use --disable-stdcall-fixup to disable these fixups\n"));
840 }
841 }
842 }
843 }
844 }
845}
decc3638
CW		 846
847static int
0d888aac 848make_import_fixup (rel, s)
decc3638 849 arelent *rel;
0d888aac 850 asection *s;
decc3638
CW		 851{
852 struct symbol_cache_entry *sym = *rel->sym_ptr_ptr;
decc3638 853
3fc90ddb 854 if (pe_dll_extra_pe_debug)
decc3638 855 {
3fc90ddb 856 printf ("arelent: %s@%#x: add=%li\n", sym->name,
decc3638
CW		 857 (int) rel->address, rel->addend);
858 }
0d888aac
CW		 859
860 {
861 int addend = 0;
862 if (!bfd_get_section_contents(s->owner, s, &addend, rel->address, sizeof(addend)))
863 {
864 einfo (_("%C: Cannot get section contents - auto-import exception\n"),
865 s->owner, s, rel->address);
866 }
867
868 if (addend == 0)
869 pe_create_import_fixup (rel);
870 else
871 {
872 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
873 s->owner, s, rel->address, sym->name);
874 einfo ("%X");
875 }
876 }
877
decc3638
CW		 878 return 1;
879}
880
881char *pe_data_import_dll;
882
883static void
884pe_find_data_imports ()
885{
886 struct bfd_link_hash_entry *undef, *sym;
887 for (undef = link_info.hash->undefs; undef; undef=undef->next)
888 {
889 if (undef->type == bfd_link_hash_undefined)
890 {
891 /* C++ symbols are *long* */
892 char buf[4096];
3fc90ddb 893 if (pe_dll_extra_pe_debug)
decc3638
CW		 894 {
895 printf ("%s:%s\n", __FUNCTION__, undef->root.string);
896 }
897 sprintf (buf, "__imp_%s", undef->root.string);
898
899 sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
900 if (sym && sym->type == bfd_link_hash_defined)
901 {
902 einfo (_("Warning: resolving %s by linking to %s (auto-import)\n"),
903 undef->root.string, buf);
3fc90ddb 904 {
decc3638
CW		 905 bfd *b = sym->u.def.section->owner;
906 asymbol **symbols;
907 int nsyms, symsize, i;
3fc90ddb 908
decc3638
CW		 909 symsize = bfd_get_symtab_upper_bound (b);
910 symbols = (asymbol **) xmalloc (symsize);
911 nsyms = bfd_canonicalize_symtab (b, symbols);
912
913 for (i = 0; i < nsyms; i++)
914 {
3fc90ddb 915 if (memcmp(symbols[i]->name, "__head_",
decc3638
CW		 916 sizeof ("__head_") - 1))
917 continue;
918 if (pe_dll_extra_pe_debug)
919 {
920 printf ("->%s\n", symbols[i]->name);
921 }
3fc90ddb 922 pe_data_import_dll = (char*) (symbols[i]->name +
decc3638
CW		 923 sizeof ("__head_") - 1);
924 break;
925 }
926 }
927
3fc90ddb 928 pe_walk_relocs_of_symbol (&link_info, undef->root.string,
decc3638
CW		 929 make_import_fixup);
930
931 /* let's differentiate it somehow from defined */
932 undef->type = bfd_link_hash_defweak;
933 /* we replace original name with __imp_ prefixed, this
934 1) may trash memory 2) leads to duplicate symbol generation.
935 Still, IMHO it's better than having name poluted. */
936 undef->root.string = sym->root.string;
937 undef->u.def.value = sym->u.def.value;
938 undef->u.def.section = sym->u.def.section;
939 }
940 }
941 }
942}
f0c87f88 943#endif /* DLL_SUPPORT */
252b5132 944
decc3638
CW		 945static boolean
946pr_sym (h, string)
947 struct bfd_hash_entry *h;
3fc90ddb 948 PTR string ATTRIBUTE_UNUSED;
decc3638 949{
3fc90ddb 950 if (pe_dll_extra_pe_debug)
decc3638
CW		 951 {
952 printf("+%s\n",h->string);
953 }
954 return true;
955}
956
957
252b5132
RH		 958static void
959gld_${EMULATION_NAME}_after_open ()
960{
decc3638 961
3fc90ddb 962 if (pe_dll_extra_pe_debug)
decc3638
CW		 963 {
964 bfd *a;
965 struct bfd_link_hash_entry *sym;
966 printf ("%s()\n", __FUNCTION__);
967
968 for (sym = link_info.hash->undefs; sym; sym=sym->next)
969 printf ("-%s\n", sym->root.string);
970 bfd_hash_traverse (&link_info.hash->table, pr_sym,NULL);
971
972 for (a = link_info.input_bfds; a; a = a->link_next)
973 {
974 printf("*%s\n",a->filename);
975 }
976 }
3fc90ddb 977
252b5132
RH		 978 /* Pass the wacky PE command line options into the output bfd.
979 FIXME: This should be done via a function, rather than by
980 including an internal BFD header. */
3fc90ddb 981
d29d80f2 982 if (coff_data (output_bfd) == NULL || coff_data (output_bfd)->pe == NULL)
252b5132
RH		 983 einfo (_("%F%P: PE operations on non PE file.\n"));
984
985 pe_data (output_bfd)->pe_opthdr = pe;
986 pe_data (output_bfd)->dll = init[DLLOFF].value;
987
c6c37250 988#ifdef DLL_SUPPORT
252b5132
RH		 989 if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
990 pe_fixup_stdcalls ();
991
3fc90ddb 992 pe_find_data_imports ();
decc3638 993
252b5132
RH		 994 pe_process_import_defs(output_bfd, &link_info);
995 if (link_info.shared)
996 pe_dll_build_sections (output_bfd, &link_info);
344a211f
NC		 997
998#ifndef TARGET_IS_i386pe
999#ifndef TARGET_IS_armpe
1000 else
1001 pe_exe_build_sections (output_bfd, &link_info);
1002#endif
1003#endif
252b5132
RH		 1004#endif
1005
626e0105 1006#if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
f11523b0
NC		 1007 if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
1008 {
1009 /* The arm backend needs special fields in the output hash structure.
1010 These will only be created if the output format is an arm format,
1011 hence we do not support linking and changing output formats at the
1012 same time. Use a link followed by objcopy to change output formats. */
1013 einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
1014 return;
1015 }
252b5132
RH		 1016 {
1017 /* Find a BFD that can hold the interworking stubs. */
1018 LANG_FOR_EACH_INPUT_STATEMENT (is)
1019 {
46d23b7c 1020 if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
252b5132
RH		 1021 break;
1022 }
1023 }
1024#endif
c6c37250 1025
486e80e2 1026 {
486e80e2
DD		 1027 /* This next chunk of code tries to detect the case where you have
1028 two import libraries for the same DLL (specifically,
1029 symbolically linking libm.a and libc.a in cygwin to
1030 libcygwin.a). In those cases, it's possible for function
1031 thunks from the second implib to be used but without the
1032 head/tail objects, causing an improper import table. We detect
1033 those cases and rename the "other" import libraries to match
1034 the one the head/tail come from, so that the linker will sort
1035 things nicely and produce a valid import table. */
1036
1037 LANG_FOR_EACH_INPUT_STATEMENT (is)
1038 {
1039 if (is->the_bfd->my_archive)
1040 {
1041 int idata2 = 0, reloc_count=0, is_imp = 0;
1042 asection *sec;
3fc90ddb 1043
6e45556a 1044 /* See if this is an import library thunk. */
486e80e2
DD		 1045 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1046 {
1047 if (strcmp (sec->name, ".idata\$2") == 0)
1048 idata2 = 1;
1049 if (strncmp (sec->name, ".idata\$", 7) == 0)
1050 is_imp = 1;
1051 reloc_count += sec->reloc_count;
1052 }
3fc90ddb 1053
486e80e2
DD		 1054 if (is_imp && !idata2 && reloc_count)
1055 {
6e45556a
NC		 1056 /* It is, look for the reference to head and see if it's
1057 from our own library. */
486e80e2
DD		 1058 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1059 {
1060 int i;
6e45556a
NC		 1061 long symsize;
1062 long relsize;
102c86f8 1063 asymbol **symbols;
102c86f8
NC		 1064 arelent **relocs;
1065 int nrelocs;
3fc90ddb 1066
102c86f8 1067 symsize = bfd_get_symtab_upper_bound (is->the_bfd);
6e45556a
NC		 1068 if (symsize < 1)
1069 break;
102c86f8 1070 relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
6e45556a
NC		 1071 if (relsize < 1)
1072 break;
3fc90ddb 1073
6e45556a 1074 symbols = (asymbol **) xmalloc (symsize);
3fc90ddb 1075 symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
6e45556a
NC		 1076 if (symsize < 0)
1077 {
1078 einfo ("%X%P: unable to process symbols: %E");
1079 return;
1080 }
3fc90ddb 1081
102c86f8
NC		 1082 relocs = (arelent **) xmalloc ((size_t) relsize);
1083 nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
486e80e2 1084 relocs, symbols);
6e45556a
NC		 1085 if (nrelocs < 0)
1086 {
1087 free (relocs);
1088 einfo ("%X%P: unable to process relocs: %E");
1089 return;
1090 }
3fc90ddb 1091
6e45556a 1092 for (i = 0; i < nrelocs; i++)
486e80e2
DD		 1093 {
1094 struct symbol_cache_entry *s;
6e45556a
NC		 1095 struct bfd_link_hash_entry * blhe;
1096 bfd *other_bfd;
1097 char *n;
3fc90ddb 1098
486e80e2 1099 s = (relocs[i]->sym_ptr_ptr)[0];
3fc90ddb 1100
6e45556a
NC		 1101 if (s->flags & BSF_LOCAL)
1102 continue;
3fc90ddb 1103
6e45556a
NC		 1104 /* Thunk section with reloc to another bfd. */
1105 blhe = bfd_link_hash_lookup (link_info.hash,
1106 s->name,
1107 false, false, true);
3fc90ddb 1108
6e45556a
NC		 1109 if (blhe == NULL
1110 || blhe->type != bfd_link_hash_defined)
1111 continue;
3fc90ddb 1112
6e45556a 1113 other_bfd = blhe->u.def.section->owner;
3fc90ddb 1114
6e45556a
NC		 1115 if (strcmp (is->the_bfd->my_archive->filename,
1116 other_bfd->my_archive->filename) == 0)
1117 continue;
3fc90ddb 1118
6e45556a
NC		 1119 /* Rename this implib to match the other. */
1120 n = (char *) xmalloc (strlen (other_bfd->my_archive->filename) + 1);
3fc90ddb 1121
6e45556a 1122 strcpy (n, other_bfd->my_archive->filename);
3fc90ddb 1123
6e45556a 1124 is->the_bfd->my_archive->filename = n;
486e80e2
DD		 1125 }
1126
1127 free (relocs);
6e45556a
NC		 1128 /* Note - we do not free the symbols,
1129 they are now cached in the BFD. */
486e80e2
DD		 1130 }
1131 }
1132 }
1133 }
1134 }
1135
c6c37250 1136 {
f0c87f88 1137 int is_ms_arch = 0;
1069dd8d 1138 bfd *cur_arch = 0;
c6c37250 1139 lang_input_statement_type *is2;
1069dd8d 1140
c6c37250
DD		 1141 /* Careful - this is a shell script. Watch those dollar signs! */
1142 /* Microsoft import libraries have every member named the same,
1143 and not in the right order for us to link them correctly. We
1144 must detect these and rename the members so that they'll link
1145 correctly. There are three types of objects: the head, the
1146 thunks, and the sentinel(s). The head is easy; it's the one
1147 with idata2. We assume that the sentinels won't have relocs,
1148 and the thunks will. It's easier than checking the symbol
1069dd8d 1149 table for external references. */
c6c37250
DD		 1150 LANG_FOR_EACH_INPUT_STATEMENT (is)
1151 {
1152 if (is->the_bfd->my_archive)
1153 {
1154 bfd *arch = is->the_bfd->my_archive;
1155 if (cur_arch != arch)
1156 {
1157 cur_arch = arch;
1158 is_ms_arch = 1;
1159 for (is2 = is;
1160 is2 && is2->the_bfd->my_archive == arch;
1161 is2 = (lang_input_statement_type *)is2->next)
1162 {
1163 if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
1164 is_ms_arch = 0;
1165 }
1166 }
1167
1168 if (is_ms_arch)
1169 {
1069dd8d 1170 int idata2 = 0, reloc_count=0;
c6c37250
DD		 1171 asection *sec;
1172 char *new_name, seq;
1069dd8d 1173
c6c37250
DD		 1174 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1175 {
1176 if (strcmp (sec->name, ".idata\$2") == 0)
1177 idata2 = 1;
1178 reloc_count += sec->reloc_count;
1179 }
1180
1181 if (idata2) /* .idata2 is the TOC */
1182 seq = 'a';
1183 else if (reloc_count > 0) /* thunks */
1184 seq = 'b';
1185 else /* sentinel */
1186 seq = 'c';
1187
e4e24acb 1188 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
c6c37250
DD		 1189 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1190 is->the_bfd->filename = new_name;
1191
690a460e 1192 new_name = xmalloc (strlen (is->filename) + 3);
c6c37250
DD		 1193 sprintf (new_name, "%s.%c", is->filename, seq);
1194 is->filename = new_name;
1195 }
1196 }
1197 }
1198 }
252b5132
RH		 1199}
1200\f
3fc90ddb 1201static void
252b5132
RH		 1202gld_${EMULATION_NAME}_before_allocation()
1203{
1204#ifdef TARGET_IS_ppcpe
1205 /* Here we rummage through the found bfds to collect toc information */
1206 {
1207 LANG_FOR_EACH_INPUT_STATEMENT (is)
1208 {
1209 if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1210 {
1211 /* xgettext:c-format */
1212 einfo (_("Errors encountered processing file %s\n"), is->filename);
1213 }
1214 }
1215 }
1216
1217 /* We have seen it all. Allocate it, and carry on */
1218 ppc_allocate_toc_section (&link_info);
1219#endif /* TARGET_IS_ppcpe */
1220
626e0105 1221#if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
252b5132
RH		 1222 /* FIXME: we should be able to set the size of the interworking stub
1223 section.
1224
1225 Here we rummage through the found bfds to collect glue
1226 information. FIXME: should this be based on a command line
1227 option? krk@cygnus.com */
1228 {
1229 LANG_FOR_EACH_INPUT_STATEMENT (is)
1230 {
46d23b7c 1231 if (! bfd_arm_pe_process_before_allocation
252b5132
RH		 1232 (is->the_bfd, & link_info, support_old_code))
1233 {
1234 /* xgettext:c-format */
1235 einfo (_("Errors encountered processing file %s for interworking"),
1236 is->filename);
1237 }
1238 }
1239 }
1240
1241 /* We have seen it all. Allocate it, and carry on */
46d23b7c 1242 bfd_arm_pe_allocate_interworking_sections (& link_info);
252b5132
RH		 1243#endif /* TARGET_IS_armpe */
1244}
1245\f
690a460e 1246#ifdef DLL_SUPPORT
252b5132
RH		 1247/* This is called when an input file isn't recognized as a BFD. We
1248 check here for .DEF files and pull them in automatically. */
690a460e 1249
252b5132
RH		 1250static int
1251saw_option(char *option)
1252{
1253 int i;
1254 for (i=0; init[i].ptr; i++)
1255 if (strcmp (init[i].symbol, option) == 0)
1256 return init[i].inited;
1257 return 0;
1258}
690a460e 1259#endif /* DLL_SUPPORT */
252b5132
RH		 1260
1261static boolean
1262gld_${EMULATION_NAME}_unrecognized_file(entry)
f0c87f88 1263 lang_input_statement_type *entry ATTRIBUTE_UNUSED;
252b5132 1264{
c6c37250 1265#ifdef DLL_SUPPORT
252b5132
RH		 1266 const char *ext = entry->filename + strlen (entry->filename) - 4;
1267
1268 if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1269 {
1270 if (pe_def_file == 0)
1271 pe_def_file = def_file_empty ();
1272 def_file_parse (entry->filename, pe_def_file);
1273 if (pe_def_file)
1274 {
1275 int i, buflen=0, len;
1276 char *buf;
1277 for (i=0; i<pe_def_file->num_exports; i++)
1278 {
1279 len = strlen(pe_def_file->exports[i].internal_name);
1280 if (buflen < len+2)
1281 buflen = len+2;
1282 }
1283 buf = (char *) xmalloc (buflen);
1284 for (i=0; i<pe_def_file->num_exports; i++)
1285 {
1286 struct bfd_link_hash_entry *h;
1287 sprintf(buf, "_%s", pe_def_file->exports[i].internal_name);
1288
1289 h = bfd_link_hash_lookup (link_info.hash, buf, true, true, true);
1290 if (h == (struct bfd_link_hash_entry *) NULL)
1291 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1292 if (h->type == bfd_link_hash_new)
1293 {
1294 h->type = bfd_link_hash_undefined;
1295 h->u.undef.abfd = NULL;
1296 bfd_link_add_undef (link_info.hash, h);
1297 }
1298 }
1299 free (buf);
1300
1301 /* def_file_print (stdout, pe_def_file); */
1302 if (pe_def_file->is_dll == 1)
1303 link_info.shared = 1;
1304
1305 if (pe_def_file->base_address != (bfd_vma)(-1))
1306 {
1307 pe.ImageBase =
1308 pe_data (output_bfd)->pe_opthdr.ImageBase =
1309 init[IMAGEBASEOFF].value = pe_def_file->base_address;
1310 init[IMAGEBASEOFF].inited = 1;
1311 if (image_base_statement)
1312 image_base_statement->exp =
1313 exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1314 }
1315
1316#if 0
1317 /* Not sure if these *should* be set */
1318 if (pe_def_file->version_major != -1)
1319 {
1320 pe.MajorImageVersion = pe_def_file->version_major;
1321 pe.MinorImageVersion = pe_def_file->version_minor;
1322 }
1323#endif
1324 if (pe_def_file->stack_reserve != -1
1325 && ! saw_option ("__size_of_stack_reserve__"))
1326 {
1327 pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1328 if (pe_def_file->stack_commit != -1)
1329 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1330 }
1331 if (pe_def_file->heap_reserve != -1
1332 && ! saw_option ("__size_of_heap_reserve__"))
1333 {
1334 pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1335 if (pe_def_file->heap_commit != -1)
1336 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1337 }
1338 return true;
1339 }
1340 }
1341#endif
1342 return false;
3fc90ddb 1343
252b5132
RH		 1344}
1345
1346static boolean
1347gld_${EMULATION_NAME}_recognized_file(entry)
f0c87f88 1348 lang_input_statement_type *entry ATTRIBUTE_UNUSED;
252b5132 1349{
c6c37250 1350#ifdef DLL_SUPPORT
252b5132 1351#ifdef TARGET_IS_i386pe
c6c37250 1352 pe_dll_id_target ("pei-i386");
344a211f
NC		 1353#endif
1354#ifdef TARGET_IS_shpe
1355 pe_dll_id_target ("pei-shl");
1356#endif
1357#ifdef TARGET_IS_mipspe
1358 pe_dll_id_target ("pei-mips");
1359#endif
1360#ifdef TARGET_IS_armpe
1361 pe_dll_id_target ("pei-arm-little");
c6c37250 1362#endif
252b5132
RH		 1363 if (bfd_get_format (entry->the_bfd) == bfd_object)
1364 {
1365 const char *ext = entry->filename + strlen (entry->filename) - 4;
1366 if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1367 return pe_implied_import_dll (entry->filename);
1368 }
1369#endif
1370 return false;
1371}
1372
1373static void
1374gld_${EMULATION_NAME}_finish ()
1375{
6f798e5c
NC		 1376#if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1377 struct bfd_link_hash_entry * h;
1378
1379 if (thumb_entry_symbol != NULL)
1380 {
1381 h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol, false, false, true);
3fc90ddb 1382
6f798e5c
NC		 1383 if (h != (struct bfd_link_hash_entry *) NULL
1384 && (h->type == bfd_link_hash_defined
1385 || h->type == bfd_link_hash_defweak)
1386 && h->u.def.section->output_section != NULL)
1387 {
1388 static char buffer[32];
1389 bfd_vma val;
3fc90ddb 1390
6f798e5c
NC		 1391 /* Special procesing is required for a Thumb entry symbol. The
1392 bottom bit of its address must be set. */
1393 val = (h->u.def.value
1394 + bfd_get_section_vma (output_bfd,
1395 h->u.def.section->output_section)
1396 + h->u.def.section->output_offset);
3fc90ddb 1397
6f798e5c 1398 val |= 1;
3fc90ddb 1399
6f798e5c
NC		 1400 /* Now convert this value into a string and store it in entry_symbol
1401 where the lang_finish() function will pick it up. */
1402 buffer[0] = '0';
1403 buffer[1] = 'x';
3fc90ddb 1404
6f798e5c 1405 sprintf_vma (buffer + 2, val);
3fc90ddb 1406
6f798e5c
NC		 1407 if (entry_symbol != NULL && entry_from_cmdline)
1408 einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1409 thumb_entry_symbol, entry_symbol);
1410 entry_symbol = buffer;
1411 }
1412 else
1413 einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1414 }
1415#endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1416
c6c37250 1417#ifdef DLL_SUPPORT
252b5132
RH		 1418 if (link_info.shared)
1419 {
1420 pe_dll_fill_sections (output_bfd, &link_info);
1421 if (pe_implib_filename)
1422 pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1423 }
344a211f 1424#if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
690a460e 1425 /* ARM doesn't need relocs. */
344a211f
NC		 1426 else
1427 {
1428 pe_exe_fill_sections (output_bfd, &link_info);
1429 }
1430#endif
3fc90ddb 1431
252b5132
RH		 1432 if (pe_out_def_filename)
1433 pe_dll_generate_def_file (pe_out_def_filename);
690a460e 1434#endif /* DLL_SUPPORT */
decc3638
CW		 1435
1436 /* I don't know where .idata gets set as code, but it shouldn't be */
1437 {
1438 asection *asec = bfd_get_section_by_name (output_bfd, ".idata");
1439 if (asec)
1440 {
1441 asec->flags &= ~SEC_CODE;
1442 asec->flags |= SEC_DATA;
1443 }
1444 }
252b5132
RH		 1445}
1446
1447\f
ae7fb08f
AM		 1448/* Find the last output section before given output statement.
1449 Used by place_orphan. */
1450
1451static asection *
1452output_prev_sec_find (os)
1453 lang_output_section_statement_type *os;
1454{
1455 asection *s = (asection *) NULL;
1456 lang_statement_union_type *u;
1457 lang_output_section_statement_type *lookup;
1458
1459 for (u = lang_output_section_statement.head;
1460 u != (lang_statement_union_type *) NULL;
1461 u = lookup->next)
1462 {
1463 lookup = &u->output_section_statement;
1464 if (lookup == os)
1465 return s;
1466
1467 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1468 s = lookup->bfd_section;
1469 }
1470
1471 return NULL;
1472}
1473
252b5132
RH		 1474/* Place an orphan section.
1475
1476 We use this to put sections in a reasonable place in the file, and
1477 to ensure that they are aligned as required.
1478
1479 We handle grouped sections here as well. A section named .foo$nn
1480 goes into the output section .foo. All grouped sections are sorted
1481 by name.
1482
1483 Grouped sections for the default sections are handled by the
1484 default linker script using wildcards, and are sorted by
1485 sort_sections. */
1486
6a345e87
AM		 1487struct orphan_save
1488{
1489 lang_output_section_statement_type *os;
5ba47421 1490 asection **section;
6a345e87
AM		 1491 lang_statement_union_type **stmt;
1492};
252b5132
RH		 1493
1494/*ARGSUSED*/
1495static boolean
1496gld_${EMULATION_NAME}_place_orphan (file, s)
1497 lang_input_statement_type *file;
1498 asection *s;
1499{
1500 const char *secname;
aea4bd9d 1501 char *hold_section_name;
f0c87f88 1502 char *dollar = NULL;
2e418547 1503 const char *ps = NULL;
aea4bd9d 1504 lang_output_section_statement_type *os;
5ba47421 1505 lang_statement_list_type add_child;
252b5132 1506
252b5132
RH		 1507 secname = bfd_get_section_name (s->owner, s);
1508
1509 /* Look through the script to see where to place this section. */
1510
252b5132 1511 hold_section_name = xstrdup (secname);
6eec49fc
DD		 1512 if (!link_info.relocateable)
1513 {
1514 dollar = strchr (hold_section_name, '$');
1515 if (dollar != NULL)
1516 *dollar = '\0';
1517 }
252b5132 1518
aea4bd9d 1519 os = lang_output_section_find (hold_section_name);
252b5132 1520
5ba47421
AM		 1521 lang_list_init (&add_child);
1522
aea4bd9d 1523 if (os != NULL
ae7fb08f
AM		 1524 && (os->bfd_section == NULL
1525 || ((s->flags ^ os->bfd_section->flags)
1526 & (SEC_LOAD | SEC_ALLOC)) == 0))
5ba47421 1527 {
ae7fb08f
AM		 1528 /* We already have an output section statement with this
1529 name, and its bfd section, if any, has compatible flags. */
39dcfe18 1530 lang_add_section (&add_child, s, os, file);
5ba47421
AM		 1531 }
1532 else
252b5132 1533 {
6a345e87 1534 struct orphan_save *place;
aea4bd9d
AM		 1535 static struct orphan_save hold_text;
1536 static struct orphan_save hold_rdata;
1537 static struct orphan_save hold_data;
1538 static struct orphan_save hold_bss;
252b5132 1539 char *outsecname;
252b5132
RH		 1540 lang_statement_list_type *old;
1541 lang_statement_list_type add;
1542 etree_type *address;
1543
1544 /* Try to put the new output section in a reasonable place based
1545 on the section name and section flags. */
aea4bd9d
AM		 1546#define HAVE_SECTION(hold, name) \
1547(hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1548
252b5132 1549 place = NULL;
5ba47421
AM		 1550 if ((s->flags & SEC_ALLOC) == 0)
1551 ;
1552 else if ((s->flags & SEC_HAS_CONTENTS) == 0
aea4bd9d 1553 && HAVE_SECTION (hold_bss, ".bss"))
6a345e87 1554 place = &hold_bss;
252b5132 1555 else if ((s->flags & SEC_READONLY) == 0
aea4bd9d 1556 && HAVE_SECTION (hold_data, ".data"))
6a345e87 1557 place = &hold_data;
252b5132
RH		 1558 else if ((s->flags & SEC_CODE) == 0
1559 && (s->flags & SEC_READONLY) != 0
aea4bd9d 1560 && HAVE_SECTION (hold_rdata, ".rdata"))
6a345e87 1561 place = &hold_rdata;
252b5132 1562 else if ((s->flags & SEC_READONLY) != 0
aea4bd9d 1563 && HAVE_SECTION (hold_text, ".text"))
6a345e87 1564 place = &hold_text;
252b5132 1565
aea4bd9d
AM		 1566#undef HAVE_SECTION
1567
252b5132
RH		 1568 /* Choose a unique name for the section. This will be needed if
1569 the same section name appears in the input file with
ae7fb08f 1570 different loadable or allocatable characteristics. */
252b5132
RH		 1571 outsecname = xstrdup (hold_section_name);
1572 if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1573 {
1574 unsigned int len;
1575 char *newname;
1576 unsigned int i;
1577
1578 len = strlen (outsecname);
1579 newname = xmalloc (len + 5);
1580 strcpy (newname, outsecname);
1581 i = 0;
1582 do
1583 {
1584 sprintf (newname + len, "%d", i);
1585 ++i;
1586 }
1587 while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1588
1589 free (outsecname);
1590 outsecname = newname;
1591 }
1592
252b5132
RH		 1593 /* Start building a list of statements for this section. */
1594 old = stat_ptr;
1595 stat_ptr = &add;
1596 lang_list_init (stat_ptr);
1597
2e418547
PB		 1598 if (config.build_constructors)
1599 {
1600 /* If the name of the section is representable in C, then create
1601 symbols to mark the start and the end of the section. */
1602 for (ps = outsecname; *ps != '\0'; ps++)
1603 if (! isalnum ((unsigned char) *ps) && *ps != '_')
1604 break;
1605 if (*ps == '\0')
1606 {
1607 char *symname;
1608 etree_type *e_align;
3fc90ddb 1609
2e418547
PB		 1610 symname = (char *) xmalloc (ps - outsecname + sizeof "___start_");
1611 sprintf (symname, "___start_%s", outsecname);
1612 e_align = exp_unop (ALIGN_K,
1613 exp_intop ((bfd_vma) 1 << s->alignment_power));
1614 lang_add_assignment (exp_assop ('=', symname, e_align));
1615 }
1616 }
3fc90ddb 1617
01cc8ff8
AM		 1618 if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1619 address = exp_intop ((bfd_vma) 0);
252b5132
RH		 1620 else
1621 {
1622 /* All sections in an executable must be aligned to a page
1623 boundary. */
1624 address = exp_unop (ALIGN_K,
1625 exp_nameop (NAME, "__section_alignment__"));
1626 }
1627
aea4bd9d
AM		 1628 os = lang_enter_output_section_statement (outsecname, address, 0,
1629 (bfd_vma) 0,
1630 (etree_type *) NULL,
1631 (etree_type *) NULL,
1632 (etree_type *) NULL);
252b5132 1633
39dcfe18 1634 lang_add_section (&add_child, s, os, file);
252b5132
RH		 1635
1636 lang_leave_output_section_statement
1637 ((bfd_vma) 0, "*default*",
aea4bd9d 1638 (struct lang_output_section_phdr_list *) NULL, "*default*");
252b5132 1639
2e418547
PB		 1640 if (config.build_constructors && *ps == '\0')
1641 {
1642 char *symname;
1643
1644 /* lang_leave_ouput_section_statement resets stat_ptr. Put
1645 stat_ptr back where we want it. */
1646 if (place != NULL)
1647 stat_ptr = &add;
3fc90ddb 1648
2e418547
PB		 1649 symname = (char *) xmalloc (ps - outsecname + sizeof "___stop_");
1650 sprintf (symname, "___stop_%s", outsecname);
1651 lang_add_assignment (exp_assop ('=', symname,
1652 exp_nameop (NAME, ".")));
1653 }
1654
5ba47421
AM		 1655 stat_ptr = old;
1656
252b5132
RH		 1657 if (place != NULL)
1658 {
5ba47421
AM		 1659 asection *snew, **pps;
1660
aea4bd9d 1661 snew = os->bfd_section;
ae7fb08f
AM		 1662
1663 /* Shuffle the bfd section list to make the output file look
1664 neater. This is really only cosmetic. */
1665 if (place->section == NULL)
5ba47421 1666 {
ae7fb08f
AM		 1667 asection *bfd_section = place->os->bfd_section;
1668
1669 /* If the output statement hasn't been used to place
1670 any input sections (and thus doesn't have an output
1671 bfd_section), look for the closest prior output statement
1672 having an output section. */
1673 if (bfd_section == NULL)
1674 bfd_section = output_prev_sec_find (place->os);
1675
1676 if (bfd_section != NULL && bfd_section != snew)
1677 place->section = &bfd_section->next;
1678 }
5ba47421 1679
ae7fb08f
AM		 1680 if (place->section != NULL)
1681 {
5ba47421 1682 /* Unlink the section. */
ae7fb08f
AM		 1683 for (pps = &output_bfd->sections;
1684 *pps != snew;
1685 pps = &(*pps)->next)
5ba47421
AM		 1686 ;
1687 *pps = snew->next;
1688
1689 /* Now tack it on to the "place->os" section list. */
1690 snew->next = *place->section;
1691 *place->section = snew;
1692 }
5ba47421 1693
ae7fb08f
AM		 1694 /* Save the end of this list. Further ophans of this type will
1695 follow the one we've just added. */
1696 place->section = &snew->next;
1697
1698 /* The following is non-cosmetic. We try to put the output
1699 statements in some sort of reasonable order here, because
1700 they determine the final load addresses of the orphan
1701 sections. In addition, placing output statements in the
1702 wrong order may require extra segments. For instance,
1703 given a typical situation of all read-only sections placed
1704 in one segment and following that a segment containing all
1705 the read-write sections, we wouldn't want to place an orphan
1706 read/write section before or amongst the read-only ones. */
1707 if (add.head != NULL)
6a345e87 1708 {
ae7fb08f
AM		 1709 if (place->stmt == NULL)
1710 {
1711 /* Put the new statement list right at the head. */
1712 *add.tail = place->os->header.next;
1713 place->os->header.next = add.head;
1714 }
1715 else
1716 {
1717 /* Put it after the last orphan statement we added. */
1718 *add.tail = *place->stmt;
1719 *place->stmt = add.head;
1720 }
1721
1722 /* Fix the global list pointer if we happened to tack our
1723 new list at the tail. */
1724 if (*old->tail == add.head)
1725 old->tail = add.tail;
1726
1727 /* Save the end of this list. */
1728 place->stmt = add.tail;
6a345e87 1729 }
252b5132 1730 }
252b5132
RH		 1731 }
1732
5ba47421 1733 {
aea4bd9d 1734 lang_statement_union_type **pl = &os->children.head;
252b5132 1735
5ba47421
AM		 1736 if (dollar != NULL)
1737 {
1738 boolean found_dollar;
252b5132 1739
5ba47421
AM		 1740 /* The section name has a '$'. Sort it with the other '$'
1741 sections. */
252b5132 1742
5ba47421 1743 found_dollar = false;
bba1a0c0 1744 for ( ; *pl != NULL; pl = &(*pl)->header.next)
5ba47421
AM		 1745 {
1746 lang_input_section_type *ls;
1747 const char *lname;
252b5132 1748
5ba47421
AM		 1749 if ((*pl)->header.type != lang_input_section_enum)
1750 continue;
252b5132 1751
5ba47421 1752 ls = &(*pl)->input_section;
252b5132 1753
5ba47421
AM		 1754 lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1755 if (strchr (lname, '$') == NULL)
1756 {
1757 if (found_dollar)
1758 break;
1759 }
1760 else
1761 {
1762 found_dollar = true;
1763 if (strcmp (secname, lname) < 0)
1764 break;
1765 }
1766 }
1767 }
1768
1769 if (add_child.head != NULL)
1770 {
bba1a0c0 1771 add_child.head->header.next = *pl;
5ba47421
AM		 1772 *pl = add_child.head;
1773 }
1774 }
252b5132
RH		 1775
1776 free (hold_section_name);
1777
1778 return true;
1779}
1780
690a460e
NC		 1781static boolean
1782gld_${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
2ef53d66 1783 const char * arch ATTRIBUTE_UNUSED;
690a460e
NC		 1784 search_dirs_type * search;
1785 lang_input_statement_type * entry;
1786{
1787 const char * filename;
1788 char * string;
1789
1790 if (! entry->is_archive)
1791 return false;
1792
1793 filename = entry->filename;
1794
1795 string = (char *) xmalloc (strlen (search->name)
3fc90ddb 1796 + strlen (filename)
602e90d3 1797 + sizeof "/lib.a.dll"
b9a69188
NC		 1798#ifdef DLL_SUPPORT
1799 + (pe_dll_search_prefix ? strlen (pe_dll_search_prefix) : 0)
1800#endif
690a460e
NC		 1801 + 1);
1802
602e90d3
DD		 1803 /* Try "libfoo.dll.a" first (preferred explicit import library for dll's */
1804 sprintf (string, "%s/lib%s.dll.a", search->name, filename);
690a460e
NC		 1805
1806 if (! ldfile_try_open_bfd (string, entry))
1807 {
602e90d3
DD		 1808 /* Try "foo.dll.a" next (alternate explicit import library for dll's */
1809 sprintf (string, "%s/%s.dll.a", search->name, filename);
690a460e
NC		 1810 if (! ldfile_try_open_bfd (string, entry))
1811 {
0ad8cf4c
DD		 1812/*
1813 Try libfoo.a next. Normally, this would be interpreted as a static
1814 library, but it *could* be an import library. For backwards compatibility,
1815 libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1816 or sometimes errors occur when building legacy packages.
1817
1818 Putting libfoo.a here means that in a failure case (i.e. the library
1819 -lfoo is not found) we will search for libfoo.a twice before
1820 giving up -- once here, and once when searching for a "static" lib.
1821 for a "static" lib.
1822*/
1823 /* Try "libfoo.a" (import lib, or static lib, but must
1824 take precedence over dll's) */
1825 sprintf (string, "%s/lib%s.a", search->name, filename);
602e90d3 1826 if (! ldfile_try_open_bfd (string, entry))
627427de 1827 {
b9a69188
NC		 1828#ifdef DLL_SUPPORT
1829 if (pe_dll_search_prefix)
3fc90ddb 1830 {
627427de
DD		 1831 /* Try "<prefix>foo.dll" (preferred dll name, if specified) */
1832 sprintf (string, "%s/%s%s.dll", search->name, pe_dll_search_prefix, filename);
0ad8cf4c
DD		 1833 if (! ldfile_try_open_bfd (string, entry))
1834 {
627427de
DD		 1835 /* Try "libfoo.dll" (default preferred dll name) */
1836 sprintf (string, "%s/lib%s.dll", search->name, filename);
1837 if (! ldfile_try_open_bfd (string, entry))
1838 {
1839 /* Finally, try "foo.dll" (alternate dll name) */
1840 sprintf (string, "%s/%s.dll", search->name, filename);
1841 if (! ldfile_try_open_bfd (string, entry))
1842 {
1843 free (string);
1844 return false;
1845 }
1846 }
0ad8cf4c 1847 }
602e90d3 1848 }
627427de 1849 else /* pe_dll_search_prefix not specified */
3fc90ddb 1850#endif
627427de
DD		 1851 {
1852 /* Try "libfoo.dll" (preferred dll name) */
1853 sprintf (string, "%s/lib%s.dll", search->name, filename);
1854 if (! ldfile_try_open_bfd (string, entry))
1855 {
1856 /* Finally, try "foo.dll" (alternate dll name) */
1857 sprintf (string, "%s/%s.dll", search->name, filename);
1858 if (! ldfile_try_open_bfd (string, entry))
1859 {
1860 free (string);
1861 return false;
1862 }
1863 }
b9a69188 1864 }
602e90d3 1865 }
690a460e
NC		 1866 }
1867 }
602e90d3 1868
690a460e
NC		 1869 entry->filename = string;
1870
1871 return true;
1872}
1873
344a211f
NC		 1874static int
1875gld_${EMULATION_NAME}_find_potential_libraries (name, entry)
1876 char * name;
1877 lang_input_statement_type * entry;
1878{
1879 return ldfile_open_file_search (name, entry, "", ".lib");
1880}
252b5132
RH		 1881\f
1882static char *
1883gld_${EMULATION_NAME}_get_script(isfile)
1884 int *isfile;
1885EOF
1886# Scripts compiled in.
1887# sed commands to quote an ld script as a C string.
597e2591 1888sc="-f stringify.sed"
252b5132
RH		 1889
1890cat >>e${EMULATION_NAME}.c <<EOF
3fc90ddb 1891{
252b5132
RH		 1892 *isfile = 0;
1893
1894 if (link_info.relocateable == true && config.build_constructors == true)
1895 return
1896EOF
1897sed $sc ldscripts/${EMULATION_NAME}.xu >> e${EMULATION_NAME}.c
1898echo ' ; else if (link_info.relocateable == true) return' >> e${EMULATION_NAME}.c
1899sed $sc ldscripts/${EMULATION_NAME}.xr >> e${EMULATION_NAME}.c
1900echo ' ; else if (!config.text_read_only) return' >> e${EMULATION_NAME}.c
1901sed $sc ldscripts/${EMULATION_NAME}.xbn >> e${EMULATION_NAME}.c
1902echo ' ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1903sed $sc ldscripts/${EMULATION_NAME}.xn >> e${EMULATION_NAME}.c
1904echo ' ; else return' >> e${EMULATION_NAME}.c
1905sed $sc ldscripts/${EMULATION_NAME}.x >> e${EMULATION_NAME}.c
1906echo '; }' >> e${EMULATION_NAME}.c
1907
1908cat >>e${EMULATION_NAME}.c <<EOF
1909
1910
3fc90ddb 1911struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
252b5132
RH		 1912{
1913 gld_${EMULATION_NAME}_before_parse,
1914 syslib_default,
1915 hll_default,
1916 gld_${EMULATION_NAME}_after_parse,
1917 gld_${EMULATION_NAME}_after_open,
1918 after_allocation_default,
1919 set_output_arch_default,
1920 ldemul_default_target,
1921 gld_${EMULATION_NAME}_before_allocation,
1922 gld_${EMULATION_NAME}_get_script,
1923 "${EMULATION_NAME}",
1924 "${OUTPUT_FORMAT}",
1925 gld_${EMULATION_NAME}_finish, /* finish */
1926 NULL, /* create output section statements */
690a460e 1927 gld_${EMULATION_NAME}_open_dynamic_archive,
252b5132
RH		 1928 gld_${EMULATION_NAME}_place_orphan,
1929 gld_${EMULATION_NAME}_set_symbols,
1930 gld_${EMULATION_NAME}_parse_args,
1931 gld_${EMULATION_NAME}_unrecognized_file,
1932 gld_${EMULATION_NAME}_list_options,
344a211f
NC		 1933 gld_${EMULATION_NAME}_recognized_file,
1934 gld_${EMULATION_NAME}_find_potential_libraries
252b5132
RH		 1935};
1936EOF
GDB Binutils - Deliverables
This page took 0.173138 seconds and 4 git commands to generate.