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