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