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    2011, 2012 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 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "libiberty.h"
  26 #include "getopt.h"
  27 #include "dyn-string.h"
  28 #include "bucomm.h"
  29
  30 #include <time.h>
  31
  32 #ifdef HAVE_SYS_WAIT_H
  33 #include <sys/wait.h>
  34 #else /* ! HAVE_SYS_WAIT_H */
  35 #if ! defined (_WIN32) || defined (__CYGWIN32__)
  36 #ifndef WIFEXITED
  37 #define WIFEXITED(w)    (((w)&0377) == 0)
  38 #endif
  39 #ifndef WIFSIGNALED
  40 #define WIFSIGNALED(w)  (((w)&0377) != 0177 && ((w)&~0377) == 0)
  41 #endif
  42 #ifndef WTERMSIG
  43 #define WTERMSIG(w)     ((w) & 0177)
  44 #endif
  45 #ifndef WEXITSTATUS
  46 #define WEXITSTATUS(w)  (((w) >> 8) & 0377)
  47 #endif
  48 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
  49 #ifndef WIFEXITED
  50 #define WIFEXITED(w)    (((w) & 0xff) == 0)
  51 #endif
  52 #ifndef WIFSIGNALED
  53 #define WIFSIGNALED(w)  (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
  54 #endif
  55 #ifndef WTERMSIG
  56 #define WTERMSIG(w)     ((w) & 0x7f)
  57 #endif
  58 #ifndef WEXITSTATUS
  59 #define WEXITSTATUS(w)  (((w) & 0xff00) >> 8)
  60 #endif
  61 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
  62 #endif /* ! HAVE_SYS_WAIT_H */
  63
  64 static char *driver_name = NULL;
  65 static char *cygwin_driver_flags =
  66   "-Wl,--dll -nostartfiles";
  67 static char *mingw32_driver_flags = "-mdll";
  68 static char *generic_driver_flags = "-Wl,--dll";
  69
  70 static char *entry_point;
  71
  72 static char *dlltool_name = NULL;
  73
  74 static char *target = TARGET;
  75
  76 /* -1: use default, 0: no underscoring, 1: underscore.  */
  77 static int is_leading_underscore = -1;
  78
  79 typedef enum {
  80   UNKNOWN_TARGET,
  81   CYGWIN_TARGET,
  82   MINGW_TARGET
  83 }
  84 target_type;
  85
  86 typedef enum {
  87   UNKNOWN_CPU,
  88   X86_CPU,
  89   X64_CPU,
  90   ARM_CPU
  91 }
  92 target_cpu;
  93
  94 static target_type which_target = UNKNOWN_TARGET;
  95 static target_cpu which_cpu = UNKNOWN_CPU;
  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 *progname, const char *prefix, int end_prefix)
 178 {
 179   struct stat s;
 180   char *cmd;
 181
 182   cmd = xmalloc (strlen (prefix)
 183                  + strlen (progname)
 184 #ifdef HAVE_EXECUTABLE_SUFFIX
 185                  + strlen (EXECUTABLE_SUFFIX)
 186 #endif
 187                  + 10);
 188   strcpy (cmd, prefix);
 189
 190   sprintf (cmd + end_prefix, "%s", progname);
 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 (_("pwait returns: %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, _("   --no-leading-underscore  Entrypoint without underscore\n"));
 512   fprintf (file, _("   --leading-underscore     Entrypoint with underscore.\n"));
 513   fprintf (file, _("  Rest are passed unmodified to the language driver\n"));
 514   fprintf (file, "\n\n");
 515   if (REPORT_BUGS_TO[0] && status == 0)
 516     fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 517   exit (status);
 518 }
 519
 520 #define OPTION_START            149
 521
 522 /* GENERIC options.  */
 523 #define OPTION_QUIET            (OPTION_START + 1)
 524 #define OPTION_VERBOSE          (OPTION_QUIET + 1)
 525 #define OPTION_VERSION          (OPTION_VERBOSE + 1)
 526
 527 /* DLLWRAP options.  */
 528 #define OPTION_DRY_RUN          (OPTION_VERSION + 1)
 529 #define OPTION_DRIVER_NAME      (OPTION_DRY_RUN + 1)
 530 #define OPTION_DRIVER_FLAGS     (OPTION_DRIVER_NAME + 1)
 531 #define OPTION_DLLTOOL_NAME     (OPTION_DRIVER_FLAGS + 1)
 532 #define OPTION_ENTRY            (OPTION_DLLTOOL_NAME + 1)
 533 #define OPTION_IMAGE_BASE       (OPTION_ENTRY + 1)
 534 #define OPTION_TARGET           (OPTION_IMAGE_BASE + 1)
 535 #define OPTION_MNO_CYGWIN       (OPTION_TARGET + 1)
 536 #define OPTION_NO_LEADING_UNDERSCORE (OPTION_MNO_CYGWIN + 1)
 537 #define OPTION_LEADING_UNDERSCORE (OPTION_NO_LEADING_UNDERSCORE + 1)
 538
 539 /* DLLTOOL options.  */
 540 #define OPTION_NODELETE         (OPTION_LEADING_UNDERSCORE + 1)
 541 #define OPTION_DLLNAME          (OPTION_NODELETE + 1)
 542 #define OPTION_NO_IDATA4        (OPTION_DLLNAME + 1)
 543 #define OPTION_NO_IDATA5        (OPTION_NO_IDATA4 + 1)
 544 #define OPTION_OUTPUT_EXP       (OPTION_NO_IDATA5 + 1)
 545 #define OPTION_OUTPUT_DEF       (OPTION_OUTPUT_EXP + 1)
 546 #define OPTION_EXPORT_ALL_SYMS  (OPTION_OUTPUT_DEF + 1)
 547 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
 548 #define OPTION_EXCLUDE_SYMS     (OPTION_NO_EXPORT_ALL_SYMS + 1)
 549 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
 550 #define OPTION_OUTPUT_LIB       (OPTION_NO_DEFAULT_EXCLUDES + 1)
 551 #define OPTION_DEF              (OPTION_OUTPUT_LIB + 1)
 552 #define OPTION_ADD_UNDERSCORE   (OPTION_DEF + 1)
 553 #define OPTION_KILLAT           (OPTION_ADD_UNDERSCORE + 1)
 554 #define OPTION_HELP             (OPTION_KILLAT + 1)
 555 #define OPTION_MACHINE          (OPTION_HELP + 1)
 556 #define OPTION_ADD_INDIRECT     (OPTION_MACHINE + 1)
 557 #define OPTION_BASE_FILE        (OPTION_ADD_INDIRECT + 1)
 558 #define OPTION_AS               (OPTION_BASE_FILE + 1)
 559
 560 static const struct option long_options[] =
 561 {
 562   /* generic options.  */
 563   {"quiet", no_argument, NULL, 'q'},
 564   {"verbose", no_argument, NULL, 'v'},
 565   {"version", no_argument, NULL, OPTION_VERSION},
 566   {"implib", required_argument, NULL, OPTION_OUTPUT_LIB},
 567
 568   /* dllwrap options.  */
 569   {"dry-run", no_argument, NULL, OPTION_DRY_RUN},
 570   {"driver-name", required_argument, NULL, OPTION_DRIVER_NAME},
 571   {"driver-flags", required_argument, NULL, OPTION_DRIVER_FLAGS},
 572   {"dlltool-name", required_argument, NULL, OPTION_DLLTOOL_NAME},
 573   {"entry", required_argument, NULL, 'e'},
 574   {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
 575   {"target", required_argument, NULL, OPTION_TARGET},
 576   {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE},
 577   {"leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE},
 578
 579   /* dlltool options.  */
 580   {"no-delete", no_argument, NULL, 'n'},
 581   {"dllname", required_argument, NULL, OPTION_DLLNAME},
 582   {"no-idata4", no_argument, NULL, OPTION_NO_IDATA4},
 583   {"no-idata5", no_argument, NULL, OPTION_NO_IDATA5},
 584   {"output-exp", required_argument, NULL, OPTION_OUTPUT_EXP},
 585   {"output-def", required_argument, NULL, OPTION_OUTPUT_DEF},
 586   {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
 587   {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
 588   {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
 589   {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
 590   {"output-lib", required_argument, NULL, OPTION_OUTPUT_LIB},
 591   {"def", required_argument, NULL, OPTION_DEF},
 592   {"add-underscore", no_argument, NULL, 'U'},
 593   {"killat", no_argument, NULL, 'k'},
 594   {"add-stdcall-alias", no_argument, NULL, 'A'},
 595   {"help", no_argument, NULL, 'h'},
 596   {"machine", required_argument, NULL, OPTION_MACHINE},
 597   {"add-indirect", no_argument, NULL, OPTION_ADD_INDIRECT},
 598   {"base-file", required_argument, NULL, OPTION_BASE_FILE},
 599   {"as", required_argument, NULL, OPTION_AS},
 600   {0, 0, 0, 0}
 601 };
 602
 603 int main (int, char **);
 604
 605 int
 606 main (int argc, char **argv)
 607 {
 608   int c;
 609   int i;
 610
 611   char **saved_argv = 0;
 612   int cmdline_len = 0;
 613
 614   int export_all = 0;
 615
 616   int *dlltool_arg_indices;
 617   int *driver_arg_indices;
 618
 619   char *driver_flags = 0;
 620   char *output_lib_file_name = 0;
 621
 622   dyn_string_t dlltool_cmdline;
 623   dyn_string_t driver_cmdline;
 624
 625   int def_file_seen = 0;
 626
 627   char *image_base_str = 0;
 628
 629   prog_name = argv[0];
 630
 631 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 632   setlocale (LC_MESSAGES, "");
 633 #endif
 634 #if defined (HAVE_SETLOCALE)
 635   setlocale (LC_CTYPE, "");
 636 #endif
 637   bindtextdomain (PACKAGE, LOCALEDIR);
 638   textdomain (PACKAGE);
 639
 640   expandargv (&argc, &argv);
 641
 642   saved_argv = (char **) xmalloc (argc * sizeof (char*));
 643   dlltool_arg_indices = (int *) xmalloc (argc * sizeof (int));
 644   driver_arg_indices = (int *) xmalloc (argc * sizeof (int));
 645   for (i = 0; i < argc; ++i)
 646     {
 647       size_t len = strlen (argv[i]);
 648       char *arg = (char *) xmalloc (len + 1);
 649       strcpy (arg, argv[i]);
 650       cmdline_len += len;
 651       saved_argv[i] = arg;
 652       dlltool_arg_indices[i] = 0;
 653       driver_arg_indices[i] = 1;
 654     }
 655   cmdline_len++;
 656
 657   /* We recognize dllwrap and dlltool options, and everything else is
 658      passed onto the language driver (eg., to GCC). We collect options
 659      to dlltool and driver in dlltool_args and driver_args.  */
 660
 661   opterr = 0;
 662   while ((c = getopt_long_only (argc, argv, "nkAqve:Uho:l:L:I:",
 663                                 long_options, (int *) 0)) != EOF)
 664     {
 665       int dlltool_arg;
 666       int driver_arg;
 667       int single_word_option_value_pair;
 668
 669       dlltool_arg = 0;
 670       driver_arg = 1;
 671       single_word_option_value_pair = 0;
 672
 673       if (c != '?')
 674         {
 675           /* We recognize this option, so it has to be either dllwrap or
 676              dlltool option. Do not pass to driver unless it's one of the
 677              generic options that are passed to all the tools (such as -v)
 678              which are dealt with later.  */
 679           driver_arg = 0;
 680         }
 681
 682       /* deal with generic and dllwrap options first.  */
 683       switch (c)
 684         {
 685         case 'h':
 686           usage (stdout, 0);
 687           break;
 688         case 'q':
 689           verbose = 0;
 690           break;
 691         case 'v':
 692           verbose = 1;
 693           break;
 694         case OPTION_VERSION:
 695           print_version (prog_name);
 696           break;
 697         case 'e':
 698           entry_point = optarg;
 699           break;
 700         case OPTION_IMAGE_BASE:
 701           image_base_str = optarg;
 702           break;
 703         case OPTION_DEF:
 704           def_file_name = optarg;
 705           def_file_seen = 1;
 706           delete_def_file = 0;
 707           break;
 708         case 'n':
 709           dontdeltemps = 1;
 710           dlltool_arg = 1;
 711           break;
 712         case 'o':
 713           dll_file_name = optarg;
 714           break;
 715         case 'I':
 716         case 'l':
 717         case 'L':
 718           driver_arg = 1;
 719           break;
 720         case OPTION_DLLNAME:
 721           dll_name = optarg;
 722           break;
 723         case OPTION_DRY_RUN:
 724           dry_run = 1;
 725           break;
 726         case OPTION_DRIVER_NAME:
 727           driver_name = optarg;
 728           break;
 729         case OPTION_DRIVER_FLAGS:
 730           driver_flags = optarg;
 731           break;
 732         case OPTION_DLLTOOL_NAME:
 733           dlltool_name = optarg;
 734           break;
 735         case OPTION_TARGET:
 736           target = optarg;
 737           break;
 738         case OPTION_MNO_CYGWIN:
 739           target = "i386-mingw32";
 740           break;
 741         case OPTION_NO_LEADING_UNDERSCORE:
 742           is_leading_underscore = 0;
 743           break;
 744         case OPTION_LEADING_UNDERSCORE:
 745           is_leading_underscore = 1;
 746           break;
 747         case OPTION_BASE_FILE:
 748           base_file_name = optarg;
 749           delete_base_file = 0;
 750           break;
 751         case OPTION_OUTPUT_EXP:
 752           exp_file_name = optarg;
 753           delete_exp_file = 0;
 754           break;
 755         case OPTION_EXPORT_ALL_SYMS:
 756           export_all = 1;
 757           break;
 758         case OPTION_OUTPUT_LIB:
 759           output_lib_file_name = optarg;
 760           break;
 761         case '?':
 762           break;
 763         default:
 764           dlltool_arg = 1;
 765           break;
 766         }
 767
 768       /* Handle passing through --option=value case.  */
 769       if (optarg
 770           && saved_argv[optind-1][0] == '-'
 771           && saved_argv[optind-1][1] == '-'
 772           && strchr (saved_argv[optind-1], '='))
 773         single_word_option_value_pair = 1;
 774
 775       if (dlltool_arg)
 776         {
 777           dlltool_arg_indices[optind-1] = 1;
 778           if (optarg && ! single_word_option_value_pair)
 779             {
 780               dlltool_arg_indices[optind-2] = 1;
 781             }
 782         }
 783
 784       if (! driver_arg)
 785         {
 786           driver_arg_indices[optind-1] = 0;
 787           if (optarg && ! single_word_option_value_pair)
 788             {
 789               driver_arg_indices[optind-2] = 0;
 790             }
 791         }
 792     }
 793
 794   /* Sanity checks.  */
 795   if (! dll_name && ! dll_file_name)
 796     {
 797       warn (_("Must provide at least one of -o or --dllname options"));
 798       exit (1);
 799     }
 800   else if (! dll_name)
 801     {
 802       dll_name = xstrdup (mybasename (dll_file_name));
 803     }
 804   else if (! dll_file_name)
 805     {
 806       dll_file_name = xstrdup (dll_name);
 807     }
 808
 809   /* Deduce driver-name and dlltool-name from our own.  */
 810   if (driver_name == NULL)
 811     driver_name = deduce_name ("gcc");
 812
 813   if (dlltool_name == NULL)
 814     dlltool_name = deduce_name ("dlltool");
 815
 816   if (! def_file_seen)
 817     {
 818       char *fileprefix = choose_temp_base ();
 819
 820       def_file_name = (char *) xmalloc (strlen (fileprefix) + 5);
 821       sprintf (def_file_name, "%s.def",
 822                (dontdeltemps) ? mybasename (fileprefix) : fileprefix);
 823       delete_def_file = 1;
 824       free (fileprefix);
 825       delete_def_file = 1;
 826       warn (_("no export definition file provided.\n\
 827 Creating one, but that may not be what you want"));
 828     }
 829
 830   /* Set the target platform.  */
 831   if (strstr (target, "cygwin"))
 832     which_target = CYGWIN_TARGET;
 833   else if (strstr (target, "mingw"))
 834     which_target = MINGW_TARGET;
 835   else
 836     which_target = UNKNOWN_TARGET;
 837
 838   if (! strncmp (target, "arm", 3))
 839     which_cpu = ARM_CPU;
 840   else if (!strncmp (target, "x86_64", 6)
 841            || !strncmp (target, "athlon64", 8)
 842            || !strncmp (target, "amd64", 5))
 843     which_cpu = X64_CPU;
 844   else if (target[0] == 'i' && (target[1] >= '3' && target[1] <= '6')
 845            && target[2] == '8' && target[3] == '6')
 846     which_cpu = X86_CPU;
 847   else
 848     which_cpu = UNKNOWN_CPU;
 849
 850   if (is_leading_underscore == -1)
 851     is_leading_underscore = (which_cpu != X64_CPU && which_cpu != ARM_CPU);
 852
 853   /* Re-create the command lines as a string, taking care to quote stuff.  */
 854   dlltool_cmdline = dyn_string_new (cmdline_len);
 855   if (verbose)
 856     dyn_string_append_cstr (dlltool_cmdline, " -v");
 857
 858   dyn_string_append_cstr (dlltool_cmdline, " --dllname ");
 859   dyn_string_append_cstr (dlltool_cmdline, dll_name);
 860
 861   for (i = 1; i < argc; ++i)
 862     {
 863       if (dlltool_arg_indices[i])
 864         {
 865           char *arg = saved_argv[i];
 866           int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
 867           dyn_string_append_cstr (dlltool_cmdline,
 868                              (quote) ? " \"" : " ");
 869           dyn_string_append_cstr (dlltool_cmdline, arg);
 870           dyn_string_append_cstr (dlltool_cmdline,
 871                              (quote) ? "\"" : "");
 872         }
 873     }
 874
 875   driver_cmdline = dyn_string_new (cmdline_len);
 876   if (! driver_flags || strlen (driver_flags) == 0)
 877     {
 878       switch (which_target)
 879         {
 880         case CYGWIN_TARGET:
 881           driver_flags = cygwin_driver_flags;
 882           break;
 883
 884         case MINGW_TARGET:
 885           driver_flags = mingw32_driver_flags;
 886           break;
 887
 888         default:
 889           driver_flags = generic_driver_flags;
 890           break;
 891         }
 892     }
 893   dyn_string_append_cstr (driver_cmdline, driver_flags);
 894   dyn_string_append_cstr (driver_cmdline, " -o ");
 895   dyn_string_append_cstr (driver_cmdline, dll_file_name);
 896
 897   if (is_leading_underscore == 0)
 898     dyn_string_append_cstr (driver_cmdline, " --no-leading-underscore");
 899   else if (is_leading_underscore == 1)
 900     dyn_string_append_cstr (driver_cmdline, " --leading-underscore");
 901
 902   if (! entry_point || strlen (entry_point) == 0)
 903     {
 904       const char *prefix = (is_leading_underscore != 0 ? "_" : "");
 905       const char *postfix = "";
 906       const char *name_entry;
 907
 908       if (which_cpu == X86_CPU || which_cpu == UNKNOWN_CPU)
 909         postfix = "@12";
 910
 911       switch (which_target)
 912         {
 913         case CYGWIN_TARGET:
 914           name_entry = "_cygwin_dll_entry";
 915           break;
 916
 917         case MINGW_TARGET:
 918           name_entry = "DllMainCRTStartup";
 919           break;
 920
 921         default:
 922           name_entry = "DllMain";
 923           break;
 924         }
 925       entry_point =
 926         (char *) malloc (strlen (name_entry) + strlen (prefix)
 927                          + strlen (postfix) + 1);
 928       sprintf (entry_point, "%s%s%s", prefix, name_entry, postfix);
 929     }
 930   dyn_string_append_cstr (driver_cmdline, " -Wl,-e,");
 931   dyn_string_append_cstr (driver_cmdline, entry_point);
 932   dyn_string_append_cstr (dlltool_cmdline, " --exclude-symbol=");
 933   dyn_string_append_cstr (dlltool_cmdline,
 934                     (entry_point[0] == '_') ? entry_point+1 : entry_point);
 935
 936   if (! image_base_str || strlen (image_base_str) == 0)
 937     {
 938       char *tmpbuf = (char *) xmalloc (sizeof ("0x12345678") + 1);
 939       unsigned long hash = strhash (dll_file_name);
 940       sprintf (tmpbuf, "0x%.8lX", 0x60000000|((hash<<16)&0xFFC0000));
 941       image_base_str = tmpbuf;
 942     }
 943
 944   dyn_string_append_cstr (driver_cmdline, " -Wl,--image-base,");
 945   dyn_string_append_cstr (driver_cmdline, image_base_str);
 946
 947   if (verbose)
 948     {
 949       dyn_string_append_cstr (driver_cmdline, " -v");
 950     }
 951
 952   for (i = 1; i < argc; ++i)
 953     {
 954       if (driver_arg_indices[i])
 955         {
 956           char *arg = saved_argv[i];
 957           int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
 958           dyn_string_append_cstr (driver_cmdline,
 959                              (quote) ? " \"" : " ");
 960           dyn_string_append_cstr (driver_cmdline, arg);
 961           dyn_string_append_cstr (driver_cmdline,
 962                              (quote) ? "\"" : "");
 963         }
 964     }
 965
 966   /* Step pre-1. If no --def <EXPORT_DEF> is specified,
 967      then create it and then pass it on.  */
 968
 969   if (! def_file_seen)
 970     {
 971       dyn_string_t step_pre1;
 972
 973       step_pre1 = dyn_string_new (1024);
 974
 975       dyn_string_append_cstr (step_pre1, dlltool_cmdline->s);
 976       if (export_all)
 977         {
 978           dyn_string_append_cstr (step_pre1, " --export-all --exclude-symbol=");
 979           dyn_string_append_cstr (step_pre1,
 980           "_cygwin_dll_entry@12,DllMainCRTStartup@12,DllMain@12,DllEntryPoint@12");
 981         }
 982       dyn_string_append_cstr (step_pre1, " --output-def ");
 983       dyn_string_append_cstr (step_pre1, def_file_name);
 984
 985       for (i = 1; i < argc; ++i)
 986         {
 987           if (driver_arg_indices[i])
 988             {
 989               char *arg = saved_argv[i];
 990               size_t len = strlen (arg);
 991               if (len >= 2 && arg[len-2] == '.'
 992                   && (arg[len-1] == 'o' || arg[len-1] == 'a'))
 993                 {
 994                   int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
 995                   dyn_string_append_cstr (step_pre1,
 996                                      (quote) ? " \"" : " ");
 997                   dyn_string_append_cstr (step_pre1, arg);
 998                   dyn_string_append_cstr (step_pre1,
 999                                      (quote) ? "\"" : "");
1000                 }
1001             }
1002         }
1003
1004       if (run (dlltool_name, step_pre1->s))
1005         cleanup_and_exit (1);
1006
1007       dyn_string_delete (step_pre1);
1008     }
1009
1010   dyn_string_append_cstr (dlltool_cmdline, " --def ");
1011   dyn_string_append_cstr (dlltool_cmdline, def_file_name);
1012
1013   if (verbose)
1014     {
1015       fprintf (stderr, _("DLLTOOL name    : %s\n"), dlltool_name);
1016       fprintf (stderr, _("DLLTOOL options : %s\n"), dlltool_cmdline->s);
1017       fprintf (stderr, _("DRIVER name     : %s\n"), driver_name);
1018       fprintf (stderr, _("DRIVER options  : %s\n"), driver_cmdline->s);
1019     }
1020
1021   /* Step 1. Call GCC/LD to create base relocation file. If using GCC, the
1022      driver command line will look like the following:
1023
1024         % gcc -Wl,--dll --Wl,--base-file,foo.base [rest of command line]
1025
1026      If the user does not specify a base name, create temporary one that
1027      is deleted at exit.  */
1028
1029   if (! base_file_name)
1030     {
1031       char *fileprefix = choose_temp_base ();
1032       base_file_name = (char *) xmalloc (strlen (fileprefix) + 6);
1033       sprintf (base_file_name, "%s.base",
1034                (dontdeltemps) ? mybasename (fileprefix) : fileprefix);
1035       delete_base_file = 1;
1036       free (fileprefix);
1037     }
1038
1039   {
1040     int quote;
1041
1042     dyn_string_t step1 = dyn_string_new (driver_cmdline->length
1043                                          + strlen (base_file_name)
1044                                          + 20);
1045     dyn_string_append_cstr (step1, "-Wl,--base-file,");
1046     quote = (strchr (base_file_name, ' ')
1047              || strchr (base_file_name, '\t'));
1048     dyn_string_append_cstr (step1,
1049                        (quote) ? "\"" : "");
1050     dyn_string_append_cstr (step1, base_file_name);
1051     dyn_string_append_cstr (step1,
1052                        (quote) ? "\"" : "");
1053     if (driver_cmdline->length)
1054       {
1055         dyn_string_append_cstr (step1, " ");
1056         dyn_string_append_cstr (step1, driver_cmdline->s);
1057       }
1058
1059     if (run (driver_name, step1->s))
1060       cleanup_and_exit (1);
1061
1062     dyn_string_delete (step1);
1063   }
1064
1065   /* Step 2. generate the exp file by running dlltool.
1066      dlltool command line will look like the following:
1067
1068         % dlltool -Wl,--dll --Wl,--base-file,foo.base [rest of command line]
1069
1070      If the user does not specify a base name, create temporary one that
1071      is deleted at exit.  */
1072
1073   if (! exp_file_name)
1074     {
1075       char *p = strrchr (dll_name, '.');
1076       size_t prefix_len = (p) ? (size_t) (p - dll_name) : strlen (dll_name);
1077
1078       exp_file_name = (char *) xmalloc (prefix_len + 4 + 1);
1079       strncpy (exp_file_name, dll_name, prefix_len);
1080       exp_file_name[prefix_len] = '\0';
1081       strcat (exp_file_name, ".exp");
1082       delete_exp_file = 1;
1083     }
1084
1085   {
1086     int quote;
1087
1088     dyn_string_t step2 = dyn_string_new (dlltool_cmdline->length
1089                                          + strlen (base_file_name)
1090                                          + strlen (exp_file_name)
1091                                          + 20);
1092
1093     dyn_string_append_cstr (step2, "--base-file ");
1094     quote = (strchr (base_file_name, ' ')
1095              || strchr (base_file_name, '\t'));
1096     dyn_string_append_cstr (step2,
1097                        (quote) ? "\"" : "");
1098     dyn_string_append_cstr (step2, base_file_name);
1099     dyn_string_append_cstr (step2,
1100                        (quote) ? "\" " : " ");
1101
1102     dyn_string_append_cstr (step2, "--output-exp ");
1103     quote = (strchr (exp_file_name, ' ')
1104              || strchr (exp_file_name, '\t'));
1105     dyn_string_append_cstr (step2,
1106                        (quote) ? "\"" : "");
1107     dyn_string_append_cstr (step2, exp_file_name);
1108     dyn_string_append_cstr (step2,
1109                        (quote) ? "\"" : "");
1110
1111     if (dlltool_cmdline->length)
1112       {
1113         dyn_string_append_cstr (step2, " ");
1114         dyn_string_append_cstr (step2, dlltool_cmdline->s);
1115       }
1116
1117     if (run (dlltool_name, step2->s))
1118       cleanup_and_exit (1);
1119
1120     dyn_string_delete (step2);
1121   }
1122
1123   /*
1124    * Step 3. Call GCC/LD to again, adding the exp file this time.
1125    * driver command line will look like the following:
1126    *
1127    *    % gcc -Wl,--dll --Wl,--base-file,foo.base foo.exp [rest ...]
1128    */
1129
1130   {
1131     int quote;
1132
1133     dyn_string_t step3 = dyn_string_new (driver_cmdline->length
1134                                          + strlen (exp_file_name)
1135                                          + strlen (base_file_name)
1136                                          + 20);
1137     dyn_string_append_cstr (step3, "-Wl,--base-file,");
1138     quote = (strchr (base_file_name, ' ')
1139              || strchr (base_file_name, '\t'));
1140     dyn_string_append_cstr (step3,
1141                        (quote) ? "\"" : "");
1142     dyn_string_append_cstr (step3, base_file_name);
1143     dyn_string_append_cstr (step3,
1144                        (quote) ? "\" " : " ");
1145
1146     quote = (strchr (exp_file_name, ' ')
1147              || strchr (exp_file_name, '\t'));
1148     dyn_string_append_cstr (step3,
1149                        (quote) ? "\"" : "");
1150     dyn_string_append_cstr (step3, exp_file_name);
1151     dyn_string_append_cstr (step3,
1152                        (quote) ? "\"" : "");
1153
1154     if (driver_cmdline->length)
1155       {
1156         dyn_string_append_cstr (step3, " ");
1157         dyn_string_append_cstr (step3, driver_cmdline->s);
1158       }
1159
1160     if (run (driver_name, step3->s))
1161       cleanup_and_exit (1);
1162
1163     dyn_string_delete (step3);
1164   }
1165
1166
1167   /*
1168    * Step 4. Run DLLTOOL again using the same command line.
1169    */
1170
1171   {
1172     int quote;
1173     dyn_string_t step4 = dyn_string_new (dlltool_cmdline->length
1174                                          + strlen (base_file_name)
1175                                          + strlen (exp_file_name)
1176                                          + 20);
1177
1178     dyn_string_append_cstr (step4, "--base-file ");
1179     quote = (strchr (base_file_name, ' ')
1180              || strchr (base_file_name, '\t'));
1181     dyn_string_append_cstr (step4,
1182                        (quote) ? "\"" : "");
1183     dyn_string_append_cstr (step4, base_file_name);
1184     dyn_string_append_cstr (step4,
1185                        (quote) ? "\" " : " ");
1186
1187     dyn_string_append_cstr (step4, "--output-exp ");
1188     quote = (strchr (exp_file_name, ' ')
1189              || strchr (exp_file_name, '\t'));
1190     dyn_string_append_cstr (step4,
1191                        (quote) ? "\"" : "");
1192     dyn_string_append_cstr (step4, exp_file_name);
1193     dyn_string_append_cstr (step4,
1194                        (quote) ? "\"" : "");
1195
1196     if (dlltool_cmdline->length)
1197       {
1198         dyn_string_append_cstr (step4, " ");
1199         dyn_string_append_cstr (step4, dlltool_cmdline->s);
1200       }
1201
1202     if (output_lib_file_name)
1203       {
1204         dyn_string_append_cstr (step4, " --output-lib ");
1205         dyn_string_append_cstr (step4, output_lib_file_name);
1206       }
1207
1208     if (run (dlltool_name, step4->s))
1209       cleanup_and_exit (1);
1210
1211     dyn_string_delete (step4);
1212   }
1213
1214
1215   /*
1216    * Step 5. Link it all together and be done with it.
1217    * driver command line will look like the following:
1218    *
1219    *    % gcc -Wl,--dll foo.exp [rest ...]
1220    *
1221    */
1222
1223   {
1224     int quote;
1225
1226     dyn_string_t step5 = dyn_string_new (driver_cmdline->length
1227                                          + strlen (exp_file_name)
1228                                          + 20);
1229     quote = (strchr (exp_file_name, ' ')
1230              || strchr (exp_file_name, '\t'));
1231     dyn_string_append_cstr (step5,
1232                        (quote) ? "\"" : "");
1233     dyn_string_append_cstr (step5, exp_file_name);
1234     dyn_string_append_cstr (step5,
1235                        (quote) ? "\"" : "");
1236
1237     if (driver_cmdline->length)
1238       {
1239         dyn_string_append_cstr (step5, " ");
1240         dyn_string_append_cstr (step5, driver_cmdline->s);
1241       }
1242
1243     if (run (driver_name, step5->s))
1244       cleanup_and_exit (1);
1245
1246     dyn_string_delete (step5);
1247   }
1248
1249   cleanup_and_exit (0);
1250
1251   return 0;
1252 }