?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
top level:
[binutils.git] / binutils / dllwrap.c
blob59b810ff6024e62e6bb7443505067bd9421b6a1b
1 /* dllwrap.c -- wrapper for DLLTOOL and GCC to generate PE style DLLs
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
3 Free Software Foundation, Inc.
4 Contributed by Mumit Khan (khan@xraylith.wisc.edu).
5
6 This file is part of GNU Binutils.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
22
23 /* AIX requires this to be the first thing in the file. */
24 #ifndef __GNUC__
25 # ifdef _AIX
26 #pragma alloca
27 #endif
28 #endif
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #include "bfd.h"
35 #include "libiberty.h"
36 #include "bucomm.h"
37 #include "getopt.h"
38 #include "dyn-string.h"
39
40 #include <time.h>
41 #include <sys/stat.h>
42 #include <stdarg.h>
43
44 #ifdef HAVE_SYS_WAIT_H
45 #include <sys/wait.h>
46 #else /* ! HAVE_SYS_WAIT_H */
47 #if ! defined (_WIN32) || defined (__CYGWIN32__)
48 #ifndef WIFEXITED
49 #define WIFEXITED(w) (((w)&0377) == 0)
50 #endif
51 #ifndef WIFSIGNALED
52 #define WIFSIGNALED(w) (((w)&0377) != 0177 && ((w)&~0377) == 0)
53 #endif
54 #ifndef WTERMSIG
55 #define WTERMSIG(w) ((w) & 0177)
56 #endif
57 #ifndef WEXITSTATUS
58 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
59 #endif
60 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
61 #ifndef WIFEXITED
62 #define WIFEXITED(w) (((w) & 0xff) == 0)
63 #endif
64 #ifndef WIFSIGNALED
65 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
66 #endif
67 #ifndef WTERMSIG
68 #define WTERMSIG(w) ((w) & 0x7f)
69 #endif
70 #ifndef WEXITSTATUS
71 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
72 #endif
73 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
74 #endif /* ! HAVE_SYS_WAIT_H */
75
76 static char *driver_name = NULL;
77 static char *cygwin_driver_flags =
78 "-Wl,--dll -nostartfiles";
79 static char *mingw32_driver_flags = "-mdll";
80 static char *generic_driver_flags = "-Wl,--dll";
81
82 static char *entry_point;
83
84 static char *dlltool_name = NULL;
85
86 static char *target = TARGET;
87
88 typedef enum {
89 UNKNOWN_TARGET,
90 CYGWIN_TARGET,
91 MINGW_TARGET
92 }
93 target_type;
94
95 static target_type which_target = UNKNOWN_TARGET;
96
97 static int dontdeltemps = 0;
98 static int dry_run = 0;
99
100 static char *prog_name;
101
102 static int verbose = 0;
103
104 static char *dll_file_name;
105 static char *dll_name;
106 static char *base_file_name;
107 static char *exp_file_name;
108 static char *def_file_name;
109 static int delete_base_file = 1;
110 static int delete_exp_file = 1;
111 static int delete_def_file = 1;
112
113 static int run (const char *, char *);
114 static char *mybasename (const char *);
115 static int strhash (const char *);
116 static void usage (FILE *, int);
117 static void display (const char *, va_list) ATTRIBUTE_PRINTF(1,0);
118 static void inform (const char *, ...) ATTRIBUTE_PRINTF_1;
119 static void warn (const char *, ...) ATTRIBUTE_PRINTF_1;
120 static char *look_for_prog (const char *, const char *, int);
121 static char *deduce_name (const char *);
122 static void delete_temp_files (void);
123 static void cleanup_and_exit (int);
124
125 /**********************************************************************/
126
127 /* Please keep the following 4 routines in sync with dlltool.c:
128 display ()
129 inform ()
130 look_for_prog ()
131 deduce_name ()
132 It's not worth the hassle to break these out since dllwrap will
133 (hopefully) soon be retired in favor of `ld --shared. */
134
135 static void
136 display (const char * message, va_list args)
137 {
138 if (prog_name != NULL)
139 fprintf (stderr, "%s: ", prog_name);
140
141 vfprintf (stderr, message, args);
142 fputc ('\n', stderr);
143 }
144
145
146 static void
147 inform VPARAMS ((const char *message, ...))
148 {
149 VA_OPEN (args, message);
150 VA_FIXEDARG (args, const char *, message);
151
152 if (!verbose)
153 return;
154
155 display (message, args);
156
157 VA_CLOSE (args);
158 }
159
160 static void
161 warn VPARAMS ((const char *format, ...))
162 {
163 VA_OPEN (args, format);
164 VA_FIXEDARG (args, const char *, format);
165
166 display (format, args);
167
168 VA_CLOSE (args);
169 }
170
171 /* Look for the program formed by concatenating PROG_NAME and the
172 string running from PREFIX to END_PREFIX. If the concatenated
173 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
174 appropriate. */
175
176 static char *
177 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
178 {
179 struct stat s;
180 char *cmd;
181
182 cmd = xmalloc (strlen (prefix)
183 + strlen (prog_name)
184 #ifdef HAVE_EXECUTABLE_SUFFIX
185 + strlen (EXECUTABLE_SUFFIX)
186 #endif
187 + 10);
188 strcpy (cmd, prefix);
189
190 sprintf (cmd + end_prefix, "%s", prog_name);
191
192 if (strchr (cmd, '/') != NULL)
193 {
194 int found;
195
196 found = (stat (cmd, &s) == 0
197 #ifdef HAVE_EXECUTABLE_SUFFIX
198 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
199 #endif
200 );
201
202 if (! found)
203 {
204 /* xgettext:c-format */
205 inform (_("Tried file: %s"), cmd);
206 free (cmd);
207 return NULL;
208 }
209 }
210
211 /* xgettext:c-format */
212 inform (_("Using file: %s"), cmd);
213
214 return cmd;
215 }
216
217 /* Deduce the name of the program we are want to invoke.
218 PROG_NAME is the basic name of the program we want to run,
219 eg "as" or "ld". The catch is that we might want actually
220 run "i386-pe-as" or "ppc-pe-ld".
221
222 If argv[0] contains the full path, then try to find the program
223 in the same place, with and then without a target-like prefix.
224
225 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
226 deduce_name("as") uses the following search order:
227
228 /usr/local/bin/i586-cygwin32-as
229 /usr/local/bin/as
230 as
231
232 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
233 name, it'll try without and then with EXECUTABLE_SUFFIX.
234
235 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
236 as the fallback, but rather return i586-cygwin32-as.
237
238 Oh, and given, argv[0] = dlltool, it'll return "as".
239
240 Returns a dynamically allocated string. */
241
242 static char *
243 deduce_name (const char * name)
244 {
245 char *cmd;
246 const char *dash;
247 const char *slash;
248 const char *cp;
249
250 dash = NULL;
251 slash = NULL;
252 for (cp = prog_name; *cp != '\0'; ++cp)
253 {
254 if (*cp == '-')
255 dash = cp;
256
257 if (
258 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
259 *cp == ':' || *cp == '\\' ||
260 #endif
261 *cp == '/')
262 {
263 slash = cp;
264 dash = NULL;
265 }
266 }
267
268 cmd = NULL;
269
270 if (dash != NULL)
271 /* First, try looking for a prefixed NAME in the
272 PROG_NAME directory, with the same prefix as PROG_NAME. */
273 cmd = look_for_prog (name, prog_name, dash - prog_name + 1);
274
275 if (slash != NULL && cmd == NULL)
276 /* Next, try looking for a NAME in the same directory as
277 that of this program. */
278 cmd = look_for_prog (name, prog_name, slash - prog_name + 1);
279
280 if (cmd == NULL)
281 /* Just return NAME as is. */
282 cmd = xstrdup (name);
283
284 return cmd;
285 }
286
287 static void
288 delete_temp_files (void)
289 {
290 if (delete_base_file && base_file_name)
291 {
292 if (verbose)
293 {
294 if (dontdeltemps)
295 warn (_("Keeping temporary base file %s"), base_file_name);
296 else
297 warn (_("Deleting temporary base file %s"), base_file_name);
298 }
299 if (! dontdeltemps)
300 {
301 unlink (base_file_name);
302 free (base_file_name);
303 }
304 }
305
306 if (delete_exp_file && exp_file_name)
307 {
308 if (verbose)
309 {
310 if (dontdeltemps)
311 warn (_("Keeping temporary exp file %s"), exp_file_name);
312 else
313 warn (_("Deleting temporary exp file %s"), exp_file_name);
314 }
315 if (! dontdeltemps)
316 {
317 unlink (exp_file_name);
318 free (exp_file_name);
319 }
320 }
321 if (delete_def_file && def_file_name)
322 {
323 if (verbose)
324 {
325 if (dontdeltemps)
326 warn (_("Keeping temporary def file %s"), def_file_name);
327 else
328 warn (_("Deleting temporary def file %s"), def_file_name);
329 }
330 if (! dontdeltemps)
331 {
332 unlink (def_file_name);
333 free (def_file_name);
334 }
335 }
336 }
337
338 static void
339 cleanup_and_exit (int status)
340 {
341 delete_temp_files ();
342 exit (status);
343 }
344
345 static int
346 run (const char *what, char *args)
347 {
348 char *s;
349 int pid, wait_status, retcode;
350 int i;
351 const char **argv;
352 char *errmsg_fmt, *errmsg_arg;
353 char *temp_base = choose_temp_base ();
354 int in_quote;
355 char sep;
356
357 if (verbose || dry_run)
358 fprintf (stderr, "%s %s\n", what, args);
359
360 /* Count the args */
361 i = 0;
362 for (s = args; *s; s++)
363 if (*s == ' ')
364 i++;
365 i++;
366 argv = alloca (sizeof (char *) * (i + 3));
367 i = 0;
368 argv[i++] = what;
369 s = args;
370 while (1)
371 {
372 while (*s == ' ' && *s != 0)
373 s++;
374 if (*s == 0)
375 break;
376 in_quote = (*s == '\'' || *s == '"');
377 sep = (in_quote) ? *s++ : ' ';
378 argv[i++] = s;
379 while (*s != sep && *s != 0)
380 s++;
381 if (*s == 0)
382 break;
383 *s++ = 0;
384 if (in_quote)
385 s++;
386 }
387 argv[i++] = NULL;
388
389 if (dry_run)
390 return 0;
391
392 pid = pexecute (argv[0], (char * const *) argv, prog_name, temp_base,
393 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
394
395 if (pid == -1)
396 {
397 int errno_val = errno;
398
399 fprintf (stderr, "%s: ", prog_name);
400 fprintf (stderr, errmsg_fmt, errmsg_arg);
401 fprintf (stderr, ": %s\n", strerror (errno_val));
402 return 1;
403 }
404
405 retcode = 0;
406 pid = pwait (pid, &wait_status, 0);
407 if (pid == -1)
408 {
409 warn ("wait: %s", strerror (errno));
410 retcode = 1;
411 }
412 else if (WIFSIGNALED (wait_status))
413 {
414 warn (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
415 retcode = 1;
416 }
417 else if (WIFEXITED (wait_status))
418 {
419 if (WEXITSTATUS (wait_status) != 0)
420 {
421 warn (_("%s exited with status %d"), what, WEXITSTATUS (wait_status));
422 retcode = 1;
423 }
424 }
425 else
426 retcode = 1;
427
428 return retcode;
429 }
430
431 static char *
432 mybasename (const char *name)
433 {
434 const char *base = name;
435
436 while (*name)
437 {
438 if (*name == '/' || *name == '\\')
439 {
440 base = name + 1;
441 }
442 ++name;
443 }
444 return (char *) base;
445 }
446
447 static int
448 strhash (const char *str)
449 {
450 const unsigned char *s;
451 unsigned long hash;
452 unsigned int c;
453 unsigned int len;
454
455 hash = 0;
456 len = 0;
457 s = (const unsigned char *) str;
458 while ((c = *s++) != '\0')
459 {
460 hash += c + (c << 17);
461 hash ^= hash >> 2;
462 ++len;
463 }
464 hash += len + (len << 17);
465 hash ^= hash >> 2;
466
467 return hash;
468 }
469
470 /**********************************************************************/
471
472 static void
473 usage (FILE *file, int status)
474 {
475 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), prog_name);
476 fprintf (file, _(" Generic options:\n"));
477 fprintf (file, _(" @<file> Read options from <file>\n"));
478 fprintf (file, _(" --quiet, -q Work quietly\n"));
479 fprintf (file, _(" --verbose, -v Verbose\n"));
480 fprintf (file, _(" --version Print dllwrap version\n"));
481 fprintf (file, _(" --implib <outname> Synonym for --output-lib\n"));
482 fprintf (file, _(" Options for %s:\n"), prog_name);
483 fprintf (file, _(" --driver-name <driver> Defaults to \"gcc\"\n"));
484 fprintf (file, _(" --driver-flags <flags> Override default ld flags\n"));
485 fprintf (file, _(" --dlltool-name <dlltool> Defaults to \"dlltool\"\n"));
486 fprintf (file, _(" --entry <entry> Specify alternate DLL entry point\n"));
487 fprintf (file, _(" --image-base <base> Specify image base address\n"));
488 fprintf (file, _(" --target <machine> i386-cygwin32 or i386-mingw32\n"));
489 fprintf (file, _(" --dry-run Show what needs to be run\n"));
490 fprintf (file, _(" --mno-cygwin Create Mingw DLL\n"));
491 fprintf (file, _(" Options passed to DLLTOOL:\n"));
492 fprintf (file, _(" --machine <machine>\n"));
493 fprintf (file, _(" --output-exp <outname> Generate export file.\n"));
494 fprintf (file, _(" --output-lib <outname> Generate input library.\n"));
495 fprintf (file, _(" --add-indirect Add dll indirects to export file.\n"));
496 fprintf (file, _(" --dllname <name> Name of input dll to put into output lib.\n"));
497 fprintf (file, _(" --def <deffile> Name input .def file\n"));
498 fprintf (file, _(" --output-def <deffile> Name output .def file\n"));
499 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
500 fprintf (file, _(" --no-export-all-symbols Only export .drectve symbols\n"));
501 fprintf (file, _(" --exclude-symbols <list> Exclude <list> from .def\n"));
502 fprintf (file, _(" --no-default-excludes Zap default exclude symbols\n"));
503 fprintf (file, _(" --base-file <basefile> Read linker generated base file\n"));
504 fprintf (file, _(" --no-idata4 Don't generate idata$4 section\n"));
505 fprintf (file, _(" --no-idata5 Don't generate idata$5 section\n"));
506 fprintf (file, _(" -U Add underscores to .lib\n"));
507 fprintf (file, _(" -k Kill @<n> from exported names\n"));
508 fprintf (file, _(" --add-stdcall-alias Add aliases without @<n>\n"));
509 fprintf (file, _(" --as <name> Use <name> for assembler\n"));
510 fprintf (file, _(" --nodelete Keep temp files.\n"));
511 fprintf (file, _(" Rest are passed unmodified to the language driver\n"));
512 fprintf (file, "\n\n");
513 if (REPORT_BUGS_TO[0] && status == 0)
514 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
515 exit (status);
516 }
517
518 #define OPTION_START 149
519
520 /* GENERIC options. */
521 #define OPTION_QUIET (OPTION_START + 1)
522 #define OPTION_VERBOSE (OPTION_QUIET + 1)
523 #define OPTION_VERSION (OPTION_VERBOSE + 1)
524
525 /* DLLWRAP options. */
526 #define OPTION_DRY_RUN (OPTION_VERSION + 1)
527 #define OPTION_DRIVER_NAME (OPTION_DRY_RUN + 1)
528 #define OPTION_DRIVER_FLAGS (OPTION_DRIVER_NAME + 1)
529 #define OPTION_DLLTOOL_NAME (OPTION_DRIVER_FLAGS + 1)
530 #define OPTION_ENTRY (OPTION_DLLTOOL_NAME + 1)
531 #define OPTION_IMAGE_BASE (OPTION_ENTRY + 1)
532 #define OPTION_TARGET (OPTION_IMAGE_BASE + 1)
533 #define OPTION_MNO_CYGWIN (OPTION_TARGET + 1)
534
535 /* DLLTOOL options. */
536 #define OPTION_NODELETE (OPTION_MNO_CYGWIN + 1)
537 #define OPTION_DLLNAME (OPTION_NODELETE + 1)
538 #define OPTION_NO_IDATA4 (OPTION_DLLNAME + 1)
539 #define OPTION_NO_IDATA5 (OPTION_NO_IDATA4 + 1)
540 #define OPTION_OUTPUT_EXP (OPTION_NO_IDATA5 + 1)
541 #define OPTION_OUTPUT_DEF (OPTION_OUTPUT_EXP + 1)
542 #define OPTION_EXPORT_ALL_SYMS (OPTION_OUTPUT_DEF + 1)
543 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
544 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
545 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
546 #define OPTION_OUTPUT_LIB (OPTION_NO_DEFAULT_EXCLUDES + 1)
547 #define OPTION_DEF (OPTION_OUTPUT_LIB + 1)
548 #define OPTION_ADD_UNDERSCORE (OPTION_DEF + 1)
549 #define OPTION_KILLAT (OPTION_ADD_UNDERSCORE + 1)
550 #define OPTION_HELP (OPTION_KILLAT + 1)
551 #define OPTION_MACHINE (OPTION_HELP + 1)
552 #define OPTION_ADD_INDIRECT (OPTION_MACHINE + 1)
553 #define OPTION_BASE_FILE (OPTION_ADD_INDIRECT + 1)
554 #define OPTION_AS (OPTION_BASE_FILE + 1)
555
556 static const struct option long_options[] =
557 {
558 /* generic options. */
559 {"quiet", no_argument, NULL, 'q'},
560 {"verbose", no_argument, NULL, 'v'},
561 {"version", no_argument, NULL, OPTION_VERSION},
562 {"implib", required_argument, NULL, OPTION_OUTPUT_LIB},
563
564 /* dllwrap options. */
565 {"dry-run", no_argument, NULL, OPTION_DRY_RUN},
566 {"driver-name", required_argument, NULL, OPTION_DRIVER_NAME},
567 {"driver-flags", required_argument, NULL, OPTION_DRIVER_FLAGS},
568 {"dlltool-name", required_argument, NULL, OPTION_DLLTOOL_NAME},
569 {"entry", required_argument, NULL, 'e'},
570 {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
571 {"target", required_argument, NULL, OPTION_TARGET},
572
573 /* dlltool options. */
574 {"no-delete", no_argument, NULL, 'n'},
575 {"dllname", required_argument, NULL, OPTION_DLLNAME},
576 {"no-idata4", no_argument, NULL, OPTION_NO_IDATA4},
577 {"no-idata5", no_argument, NULL, OPTION_NO_IDATA5},
578 {"output-exp", required_argument, NULL, OPTION_OUTPUT_EXP},
579 {"output-def", required_argument, NULL, OPTION_OUTPUT_DEF},
580 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
581 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
582 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
583 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
584 {"output-lib", required_argument, NULL, OPTION_OUTPUT_LIB},
585 {"def", required_argument, NULL, OPTION_DEF},
586 {"add-underscore", no_argument, NULL, 'U'},
587 {"killat", no_argument, NULL, 'k'},
588 {"add-stdcall-alias", no_argument, NULL, 'A'},
589 {"help", no_argument, NULL, 'h'},
590 {"machine", required_argument, NULL, OPTION_MACHINE},
591 {"add-indirect", no_argument, NULL, OPTION_ADD_INDIRECT},
592 {"base-file", required_argument, NULL, OPTION_BASE_FILE},
593 {"as", required_argument, NULL, OPTION_AS},
594 {0, 0, 0, 0}
595 };
596
597 int main (int, char **);
598
599 int
600 main (int argc, char **argv)
601 {
602 int c;
603 int i;
604
605 char **saved_argv = 0;
606 int cmdline_len = 0;
607
608 int export_all = 0;
609
610 int *dlltool_arg_indices;
611 int *driver_arg_indices;
612
613 char *driver_flags = 0;
614 char *output_lib_file_name = 0;
615
616 dyn_string_t dlltool_cmdline;
617 dyn_string_t driver_cmdline;
618
619 int def_file_seen = 0;
620
621 char *image_base_str = 0;
622
623 prog_name = argv[0];
624
625 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
626 setlocale (LC_MESSAGES, "");
627 #endif
628 #if defined (HAVE_SETLOCALE)
629 setlocale (LC_CTYPE, "");
630 #endif
631 bindtextdomain (PACKAGE, LOCALEDIR);
632 textdomain (PACKAGE);
633
634 expandargv (&argc, &argv);
635
636 saved_argv = (char **) xmalloc (argc * sizeof (char*));
637 dlltool_arg_indices = (int *) xmalloc (argc * sizeof (int));
638 driver_arg_indices = (int *) xmalloc (argc * sizeof (int));
639 for (i = 0; i < argc; ++i)
640 {
641 size_t len = strlen (argv[i]);
642 char *arg = (char *) xmalloc (len + 1);
643 strcpy (arg, argv[i]);
644 cmdline_len += len;
645 saved_argv[i] = arg;
646 dlltool_arg_indices[i] = 0;
647 driver_arg_indices[i] = 1;
648 }
649 cmdline_len++;
650
651 /* We recognize dllwrap and dlltool options, and everything else is
652 passed onto the language driver (eg., to GCC). We collect options
653 to dlltool and driver in dlltool_args and driver_args. */
654
655 opterr = 0;
656 while ((c = getopt_long_only (argc, argv, "nkAqve:Uho:l:L:I:",
657 long_options, (int *) 0)) != EOF)
658 {
659 int dlltool_arg;
660 int driver_arg;
661 int single_word_option_value_pair;
662
663 dlltool_arg = 0;
664 driver_arg = 1;
665 single_word_option_value_pair = 0;
666
667 if (c != '?')
668 {
669 /* We recognize this option, so it has to be either dllwrap or
670 dlltool option. Do not pass to driver unless it's one of the
671 generic options that are passed to all the tools (such as -v)
672 which are dealt with later. */
673 driver_arg = 0;
674 }
675
676 /* deal with generic and dllwrap options first. */
677 switch (c)
678 {
679 case 'h':
680 usage (stdout, 0);
681 break;
682 case 'q':
683 verbose = 0;
684 break;
685 case 'v':
686 verbose = 1;
687 break;
688 case OPTION_VERSION:
689 print_version (prog_name);
690 break;
691 case 'e':
692 entry_point = optarg;
693 break;
694 case OPTION_IMAGE_BASE:
695 image_base_str = optarg;
696 break;
697 case OPTION_DEF:
698 def_file_name = optarg;
699 def_file_seen = 1;
700 delete_def_file = 0;
701 break;
702 case 'n':
703 dontdeltemps = 1;
704 dlltool_arg = 1;
705 break;
706 case 'o':
707 dll_file_name = optarg;
708 break;
709 case 'I':
710 case 'l':
711 case 'L':
712 driver_arg = 1;
713 break;
714 case OPTION_DLLNAME:
715 dll_name = optarg;
716 break;
717 case OPTION_DRY_RUN:
718 dry_run = 1;
719 break;
720 case OPTION_DRIVER_NAME:
721 driver_name = optarg;
722 break;
723 case OPTION_DRIVER_FLAGS:
724 driver_flags = optarg;
725 break;
726 case OPTION_DLLTOOL_NAME:
727 dlltool_name = optarg;
728 break;
729 case OPTION_TARGET:
730 target = optarg;
731 break;
732 case OPTION_MNO_CYGWIN:
733 target = "i386-mingw32";
734 break;
735 case OPTION_BASE_FILE:
736 base_file_name = optarg;
737 delete_base_file = 0;
738 break;
739 case OPTION_OUTPUT_EXP:
740 exp_file_name = optarg;
741 delete_exp_file = 0;
742 break;
743 case OPTION_EXPORT_ALL_SYMS:
744 export_all = 1;
745 break;
746 case OPTION_OUTPUT_LIB:
747 output_lib_file_name = optarg;
748 break;
749 case '?':
750 break;
751 default:
752 dlltool_arg = 1;
753 break;
754 }
755
756 /* Handle passing through --option=value case. */
757 if (optarg
758 && saved_argv[optind-1][0] == '-'
759 && saved_argv[optind-1][1] == '-'
760 && strchr (saved_argv[optind-1], '='))
761 single_word_option_value_pair = 1;
762
763 if (dlltool_arg)
764 {
765 dlltool_arg_indices[optind-1] = 1;
766 if (optarg && ! single_word_option_value_pair)
767 {
768 dlltool_arg_indices[optind-2] = 1;
769 }
770 }
771
772 if (! driver_arg)
773 {
774 driver_arg_indices[optind-1] = 0;
775 if (optarg && ! single_word_option_value_pair)
776 {
777 driver_arg_indices[optind-2] = 0;
778 }
779 }
780 }
781
782 /* Sanity checks. */
783 if (! dll_name && ! dll_file_name)
784 {
785 warn (_("Must provide at least one of -o or --dllname options"));
786 exit (1);
787 }
788 else if (! dll_name)
789 {
790 dll_name = xstrdup (mybasename (dll_file_name));
791 }
792 else if (! dll_file_name)
793 {
794 dll_file_name = xstrdup (dll_name);
795 }
796
797 /* Deduce driver-name and dlltool-name from our own. */
798 if (driver_name == NULL)
799 driver_name = deduce_name ("gcc");
800
801 if (dlltool_name == NULL)
802 dlltool_name = deduce_name ("dlltool");
803
804 if (! def_file_seen)
805 {
806 char *fileprefix = choose_temp_base ();
807
808 def_file_name = (char *) xmalloc (strlen (fileprefix) + 5);
809 sprintf (def_file_name, "%s.def",
810 (dontdeltemps) ? mybasename (fileprefix) : fileprefix);
811 delete_def_file = 1;
812 free (fileprefix);
813 delete_def_file = 1;
814 warn (_("no export definition file provided.\n\
815 Creating one, but that may not be what you want"));
816 }
817
818 /* Set the target platform. */
819 if (strstr (target, "cygwin"))
820 which_target = CYGWIN_TARGET;
821 else if (strstr (target, "mingw"))
822 which_target = MINGW_TARGET;
823 else
824 which_target = UNKNOWN_TARGET;
825
826 /* Re-create the command lines as a string, taking care to quote stuff. */
827 dlltool_cmdline = dyn_string_new (cmdline_len);
828 if (verbose)
829 dyn_string_append_cstr (dlltool_cmdline, " -v");
830
831 dyn_string_append_cstr (dlltool_cmdline, " --dllname ");
832 dyn_string_append_cstr (dlltool_cmdline, dll_name);
833
834 for (i = 1; i < argc; ++i)
835 {
836 if (dlltool_arg_indices[i])
837 {
838 char *arg = saved_argv[i];
839 int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
840 dyn_string_append_cstr (dlltool_cmdline,
841 (quote) ? " \"" : " ");
842 dyn_string_append_cstr (dlltool_cmdline, arg);
843 dyn_string_append_cstr (dlltool_cmdline,
844 (quote) ? "\"" : "");
845 }
846 }
847
848 driver_cmdline = dyn_string_new (cmdline_len);
849 if (! driver_flags || strlen (driver_flags) == 0)
850 {
851 switch (which_target)
852 {
853 case CYGWIN_TARGET:
854 driver_flags = cygwin_driver_flags;
855 break;
856
857 case MINGW_TARGET:
858 driver_flags = mingw32_driver_flags;
859 break;
860
861 default:
862 driver_flags = generic_driver_flags;
863 break;
864 }
865 }
866 dyn_string_append_cstr (driver_cmdline, driver_flags);
867 dyn_string_append_cstr (driver_cmdline, " -o ");
868 dyn_string_append_cstr (driver_cmdline, dll_file_name);
869
870 if (! entry_point || strlen (entry_point) == 0)
871 {
872 switch (which_target)
873 {
874 case CYGWIN_TARGET:
875 entry_point = "__cygwin_dll_entry@12";
876 break;
877
878 case MINGW_TARGET:
879 entry_point = "_DllMainCRTStartup@12";
880 break;
881
882 default:
883 entry_point = "_DllMain@12";
884 break;
885 }
886 }
887 dyn_string_append_cstr (driver_cmdline, " -Wl,-e,");
888 dyn_string_append_cstr (driver_cmdline, entry_point);
889 dyn_string_append_cstr (dlltool_cmdline, " --exclude-symbol=");
890 dyn_string_append_cstr (dlltool_cmdline,
891 (entry_point[0] == '_') ? entry_point+1 : entry_point);
892
893 if (! image_base_str || strlen (image_base_str) == 0)
894 {
895 char *tmpbuf = (char *) xmalloc (sizeof ("0x12345678") + 1);
896 unsigned long hash = strhash (dll_file_name);
897 sprintf (tmpbuf, "0x%.8lX", 0x60000000|((hash<<16)&0xFFC0000));
898 image_base_str = tmpbuf;
899 }
900
901 dyn_string_append_cstr (driver_cmdline, " -Wl,--image-base,");
902 dyn_string_append_cstr (driver_cmdline, image_base_str);
903
904 if (verbose)
905 {
906 dyn_string_append_cstr (driver_cmdline, " -v");
907 }
908
909 for (i = 1; i < argc; ++i)
910 {
911 if (driver_arg_indices[i])
912 {
913 char *arg = saved_argv[i];
914 int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
915 dyn_string_append_cstr (driver_cmdline,
916 (quote) ? " \"" : " ");
917 dyn_string_append_cstr (driver_cmdline, arg);
918 dyn_string_append_cstr (driver_cmdline,
919 (quote) ? "\"" : "");
920 }
921 }
922
923 /* Step pre-1. If no --def <EXPORT_DEF> is specified,
924 then create it and then pass it on. */
925
926 if (! def_file_seen)
927 {
928 int i;
929 dyn_string_t step_pre1;
930
931 step_pre1 = dyn_string_new (1024);
932
933 dyn_string_append_cstr (step_pre1, dlltool_cmdline->s);
934 if (export_all)
935 {
936 dyn_string_append_cstr (step_pre1, " --export-all --exclude-symbol=");
937 dyn_string_append_cstr (step_pre1,
938 "_cygwin_dll_entry@12,DllMainCRTStartup@12,DllMain@12,DllEntryPoint@12");
939 }
940 dyn_string_append_cstr (step_pre1, " --output-def ");
941 dyn_string_append_cstr (step_pre1, def_file_name);
942
943 for (i = 1; i < argc; ++i)
944 {
945 if (driver_arg_indices[i])
946 {
947 char *arg = saved_argv[i];
948 size_t len = strlen (arg);
949 if (len >= 2 && arg[len-2] == '.'
950 && (arg[len-1] == 'o' || arg[len-1] == 'a'))
951 {
952 int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
953 dyn_string_append_cstr (step_pre1,
954 (quote) ? " \"" : " ");
955 dyn_string_append_cstr (step_pre1, arg);
956 dyn_string_append_cstr (step_pre1,
957 (quote) ? "\"" : "");
958 }
959 }
960 }
961
962 if (run (dlltool_name, step_pre1->s))
963 cleanup_and_exit (1);
964
965 dyn_string_delete (step_pre1);
966 }
967
968 dyn_string_append_cstr (dlltool_cmdline, " --def ");
969 dyn_string_append_cstr (dlltool_cmdline, def_file_name);
970
971 if (verbose)
972 {
973 fprintf (stderr, _("DLLTOOL name : %s\n"), dlltool_name);
974 fprintf (stderr, _("DLLTOOL options : %s\n"), dlltool_cmdline->s);
975 fprintf (stderr, _("DRIVER name : %s\n"), driver_name);
976 fprintf (stderr, _("DRIVER options : %s\n"), driver_cmdline->s);
977 }
978
979 /* Step 1. Call GCC/LD to create base relocation file. If using GCC, the
980 driver command line will look like the following:
981
982 % gcc -Wl,--dll --Wl,--base-file,foo.base [rest of command line]
983
984 If the user does not specify a base name, create temporary one that
985 is deleted at exit. */
986
987 if (! base_file_name)
988 {
989 char *fileprefix = choose_temp_base ();
990 base_file_name = (char *) xmalloc (strlen (fileprefix) + 6);
991 sprintf (base_file_name, "%s.base",
992 (dontdeltemps) ? mybasename (fileprefix) : fileprefix);
993 delete_base_file = 1;
994 free (fileprefix);
995 }
996
997 {
998 int quote;
999
1000 dyn_string_t step1 = dyn_string_new (driver_cmdline->length
1001 + strlen (base_file_name)
1002 + 20);
1003 dyn_string_append_cstr (step1, "-Wl,--base-file,");
1004 quote = (strchr (base_file_name, ' ')
1005 || strchr (base_file_name, '\t'));
1006 dyn_string_append_cstr (step1,
1007 (quote) ? "\"" : "");
1008 dyn_string_append_cstr (step1, base_file_name);
1009 dyn_string_append_cstr (step1,
1010 (quote) ? "\"" : "");
1011 if (driver_cmdline->length)
1012 {
1013 dyn_string_append_cstr (step1, " ");
1014 dyn_string_append_cstr (step1, driver_cmdline->s);
1015 }
1016
1017 if (run (driver_name, step1->s))
1018 cleanup_and_exit (1);
1019
1020 dyn_string_delete (step1);
1021 }
1022
1023 /* Step 2. generate the exp file by running dlltool.
1024 dlltool command line will look like the following:
1025
1026 % dlltool -Wl,--dll --Wl,--base-file,foo.base [rest of command line]
1027
1028 If the user does not specify a base name, create temporary one that
1029 is deleted at exit. */
1030
1031 if (! exp_file_name)
1032 {
1033 char *p = strrchr (dll_name, '.');
1034 size_t prefix_len = (p) ? (size_t) (p - dll_name) : strlen (dll_name);
1035
1036 exp_file_name = (char *) xmalloc (prefix_len + 4 + 1);
1037 strncpy (exp_file_name, dll_name, prefix_len);
1038 exp_file_name[prefix_len] = '\0';
1039 strcat (exp_file_name, ".exp");
1040 delete_exp_file = 1;
1041 }
1042
1043 {
1044 int quote;
1045
1046 dyn_string_t step2 = dyn_string_new (dlltool_cmdline->length
1047 + strlen (base_file_name)
1048 + strlen (exp_file_name)
1049 + 20);
1050
1051 dyn_string_append_cstr (step2, "--base-file ");
1052 quote = (strchr (base_file_name, ' ')
1053 || strchr (base_file_name, '\t'));
1054 dyn_string_append_cstr (step2,
1055 (quote) ? "\"" : "");
1056 dyn_string_append_cstr (step2, base_file_name);
1057 dyn_string_append_cstr (step2,
1058 (quote) ? "\" " : " ");
1059
1060 dyn_string_append_cstr (step2, "--output-exp ");
1061 quote = (strchr (exp_file_name, ' ')
1062 || strchr (exp_file_name, '\t'));
1063 dyn_string_append_cstr (step2,
1064 (quote) ? "\"" : "");
1065 dyn_string_append_cstr (step2, exp_file_name);
1066 dyn_string_append_cstr (step2,
1067 (quote) ? "\"" : "");
1068
1069 if (dlltool_cmdline->length)
1070 {
1071 dyn_string_append_cstr (step2, " ");
1072 dyn_string_append_cstr (step2, dlltool_cmdline->s);
1073 }
1074
1075 if (run (dlltool_name, step2->s))
1076 cleanup_and_exit (1);
1077
1078 dyn_string_delete (step2);
1079 }
1080
1081 /*
1082 * Step 3. Call GCC/LD to again, adding the exp file this time.
1083 * driver command line will look like the following:
1084 *
1085 * % gcc -Wl,--dll --Wl,--base-file,foo.base foo.exp [rest ...]
1086 */
1087
1088 {
1089 int quote;
1090
1091 dyn_string_t step3 = dyn_string_new (driver_cmdline->length
1092 + strlen (exp_file_name)
1093 + strlen (base_file_name)
1094 + 20);
1095 dyn_string_append_cstr (step3, "-Wl,--base-file,");
1096 quote = (strchr (base_file_name, ' ')
1097 || strchr (base_file_name, '\t'));
1098 dyn_string_append_cstr (step3,
1099 (quote) ? "\"" : "");
1100 dyn_string_append_cstr (step3, base_file_name);
1101 dyn_string_append_cstr (step3,
1102 (quote) ? "\" " : " ");
1103
1104 quote = (strchr (exp_file_name, ' ')
1105 || strchr (exp_file_name, '\t'));
1106 dyn_string_append_cstr (step3,
1107 (quote) ? "\"" : "");
1108 dyn_string_append_cstr (step3, exp_file_name);
1109 dyn_string_append_cstr (step3,
1110 (quote) ? "\"" : "");
1111
1112 if (driver_cmdline->length)
1113 {
1114 dyn_string_append_cstr (step3, " ");
1115 dyn_string_append_cstr (step3, driver_cmdline->s);
1116 }
1117
1118 if (run (driver_name, step3->s))
1119 cleanup_and_exit (1);
1120
1121 dyn_string_delete (step3);
1122 }
1123
1124
1125 /*
1126 * Step 4. Run DLLTOOL again using the same command line.
1127 */
1128
1129 {
1130 int quote;
1131 dyn_string_t step4 = dyn_string_new (dlltool_cmdline->length
1132 + strlen (base_file_name)
1133 + strlen (exp_file_name)
1134 + 20);
1135
1136 dyn_string_append_cstr (step4, "--base-file ");
1137 quote = (strchr (base_file_name, ' ')
1138 || strchr (base_file_name, '\t'));
1139 dyn_string_append_cstr (step4,
1140 (quote) ? "\"" : "");
1141 dyn_string_append_cstr (step4, base_file_name);
1142 dyn_string_append_cstr (step4,
1143 (quote) ? "\" " : " ");
1144
1145 dyn_string_append_cstr (step4, "--output-exp ");
1146 quote = (strchr (exp_file_name, ' ')
1147 || strchr (exp_file_name, '\t'));
1148 dyn_string_append_cstr (step4,
1149 (quote) ? "\"" : "");
1150 dyn_string_append_cstr (step4, exp_file_name);
1151 dyn_string_append_cstr (step4,
1152 (quote) ? "\"" : "");
1153
1154 if (dlltool_cmdline->length)
1155 {
1156 dyn_string_append_cstr (step4, " ");
1157 dyn_string_append_cstr (step4, dlltool_cmdline->s);
1158 }
1159
1160 if (output_lib_file_name)
1161 {
1162 dyn_string_append_cstr (step4, " --output-lib ");
1163 dyn_string_append_cstr (step4, output_lib_file_name);
1164 }
1165
1166 if (run (dlltool_name, step4->s))
1167 cleanup_and_exit (1);
1168
1169 dyn_string_delete (step4);
1170 }
1171
1172
1173 /*
1174 * Step 5. Link it all together and be done with it.
1175 * driver command line will look like the following:
1176 *
1177 * % gcc -Wl,--dll foo.exp [rest ...]
1178 *
1179 */
1180
1181 {
1182 int quote;
1183
1184 dyn_string_t step5 = dyn_string_new (driver_cmdline->length
1185 + strlen (exp_file_name)
1186 + 20);
1187 quote = (strchr (exp_file_name, ' ')
1188 || strchr (exp_file_name, '\t'));
1189 dyn_string_append_cstr (step5,
1190 (quote) ? "\"" : "");
1191 dyn_string_append_cstr (step5, exp_file_name);
1192 dyn_string_append_cstr (step5,
1193 (quote) ? "\"" : "");
1194
1195 if (driver_cmdline->length)
1196 {
1197 dyn_string_append_cstr (step5, " ");
1198 dyn_string_append_cstr (step5, driver_cmdline->s);
1199 }
1200
1201 if (run (driver_name, step5->s))
1202 cleanup_and_exit (1);
1203
1204 dyn_string_delete (step5);
1205 }
1206
1207 cleanup_and_exit (0);
1208
1209 return 0;
1210 }
git-cvsimport of binutils cvsroot