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   /* Re-create the command lines as a string, taking care to quote stuff.  */
 859   dlltool_cmdline = dyn_string_new (cmdline_len);
 860   if (verbose)
 861     dyn_string_append_cstr (dlltool_cmdline, " -v");
 862
 863   dyn_string_append_cstr (dlltool_cmdline, " --dllname ");
 864   dyn_string_append_cstr (dlltool_cmdline, dll_name);
 865
 866   for (i = 1; i < argc; ++i)
 867     {
 868       if (dlltool_arg_indices[i])
 869         {
 870           char *arg = saved_argv[i];
 871           int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
 872           dyn_string_append_cstr (dlltool_cmdline,
 873                              (quote) ? " \"" : " ");
 874           dyn_string_append_cstr (dlltool_cmdline, arg);
 875           dyn_string_append_cstr (dlltool_cmdline,
 876                              (quote) ? "\"" : "");
 877         }
 878     }
 879
 880   driver_cmdline = dyn_string_new (cmdline_len);
 881   if (! driver_flags || strlen (driver_flags) == 0)
 882     {
 883       switch (which_target)
 884         {
 885         case CYGWIN_TARGET:
 886           driver_flags = cygwin_driver_flags;
 887           break;
 888
 889         case MINGW_TARGET:
 890           driver_flags = mingw32_driver_flags;
 891           break;
 892
 893         default:
 894           driver_flags = generic_driver_flags;
 895           break;
 896         }
 897     }
 898   dyn_string_append_cstr (driver_cmdline, driver_flags);
 899   dyn_string_append_cstr (driver_cmdline, " -o ");
 900   dyn_string_append_cstr (driver_cmdline, dll_file_name);
 901
 902   if (is_leading_underscore == 0)
 903     dyn_string_append_cstr (driver_cmdline, " --no-leading-underscore");
 904   else if (is_leading_underscore == 1)
 905     dyn_string_append_cstr (driver_cmdline, " --leading-underscore");
 906
 907   if (! entry_point || strlen (entry_point) == 0)
 908     {
 909       const char *prefix = (is_leading_underscore != 0 ? "_" : "");
 910       const char *postfix = "";
 911       const char *name_entry;
 912
 913       if (which_cpu == X86_CPU || which_cpu == UNKNOWN_CPU)
 914         postfix = "@12";
 915
 916       switch (which_target)
 917         {
 918         case CYGWIN_TARGET:
 919           name_entry = "_cygwin_dll_entry";
 920           break;
 921
 922         case MINGW_TARGET:
 923           name_entry = "DllMainCRTStartup";
 924           break;
 925
 926         default:
 927           name_entry = "DllMain";
 928           break;
 929         }
 930       entry_point =
 931         (char *) malloc (strlen (name_entry) + strlen (prefix)
 932                          + strlen (postfix) + 1);
 933       sprintf (entry_point, "%s%s%s", prefix, name_entry, postfix);
 934     }
 935   dyn_string_append_cstr (driver_cmdline, " -Wl,-e,");
 936   dyn_string_append_cstr (driver_cmdline, entry_point);
 937   dyn_string_append_cstr (dlltool_cmdline, " --exclude-symbol=");
 938   dyn_string_append_cstr (dlltool_cmdline,
 939                     (entry_point[0] == '_') ? entry_point+1 : entry_point);
 940
 941   if (! image_base_str || strlen (image_base_str) == 0)
 942     {
 943       char *tmpbuf = (char *) xmalloc (sizeof ("0x12345678") + 1);
 944       unsigned long hash = strhash (dll_file_name);
 945       sprintf (tmpbuf, "0x%.8lX", 0x60000000|((hash<<16)&0xFFC0000));
 946       image_base_str = tmpbuf;
 947     }
 948
 949   dyn_string_append_cstr (driver_cmdline, " -Wl,--image-base,");
 950   dyn_string_append_cstr (driver_cmdline, image_base_str);
 951
 952   if (verbose)
 953     {
 954       dyn_string_append_cstr (driver_cmdline, " -v");
 955     }
 956
 957   for (i = 1; i < argc; ++i)
 958     {
 959       if (driver_arg_indices[i])
 960         {
 961           char *arg = saved_argv[i];
 962           int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
 963           dyn_string_append_cstr (driver_cmdline,
 964                              (quote) ? " \"" : " ");
 965           dyn_string_append_cstr (driver_cmdline, arg);
 966           dyn_string_append_cstr (driver_cmdline,
 967                              (quote) ? "\"" : "");
 968         }
 969     }
 970
 971   /* Step pre-1. If no --def <EXPORT_DEF> is specified,
 972      then create it and then pass it on.  */
 973
 974   if (! def_file_seen)
 975     {
 976       dyn_string_t step_pre1;
 977
 978       step_pre1 = dyn_string_new (1024);
 979
 980       dyn_string_append_cstr (step_pre1, dlltool_cmdline->s);
 981       if (export_all)
 982         {
 983           dyn_string_append_cstr (step_pre1, " --export-all --exclude-symbol=");
 984           dyn_string_append_cstr (step_pre1,
 985           "_cygwin_dll_entry@12,DllMainCRTStartup@12,DllMain@12,DllEntryPoint@12");
 986         }
 987       dyn_string_append_cstr (step_pre1, " --output-def ");
 988       dyn_string_append_cstr (step_pre1, def_file_name);
 989
 990       for (i = 1; i < argc; ++i)
 991         {
 992           if (driver_arg_indices[i])
 993             {
 994               char *arg = saved_argv[i];
 995               size_t len = strlen (arg);
 996               if (len >= 2 && arg[len-2] == '.'
 997                   && (arg[len-1] == 'o' || arg[len-1] == 'a'))
 998                 {
 999                   int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
1000                   dyn_string_append_cstr (step_pre1,
1001                                      (quote) ? " \"" : " ");
1002                   dyn_string_append_cstr (step_pre1, arg);
1003                   dyn_string_append_cstr (step_pre1,
1004                                      (quote) ? "\"" : "");
1005                 }
1006             }
1007         }
1008
1009       if (run (dlltool_name, step_pre1->s))
1010         cleanup_and_exit (1);
1011
1012       dyn_string_delete (step_pre1);
1013     }
1014
1015   dyn_string_append_cstr (dlltool_cmdline, " --def ");
1016   dyn_string_append_cstr (dlltool_cmdline, def_file_name);
1017
1018   if (verbose)
1019     {
1020       fprintf (stderr, _("DLLTOOL name    : %s\n"), dlltool_name);
1021       fprintf (stderr, _("DLLTOOL options : %s\n"), dlltool_cmdline->s);
1022       fprintf (stderr, _("DRIVER name     : %s\n"), driver_name);
1023       fprintf (stderr, _("DRIVER options  : %s\n"), driver_cmdline->s);
1024     }
1025
1026   /* Step 1. Call GCC/LD to create base relocation file. If using GCC, the
1027      driver command line will look like the following:
1028
1029         % gcc -Wl,--dll --Wl,--base-file,foo.base [rest of command line]
1030
1031      If the user does not specify a base name, create temporary one that
1032      is deleted at exit.  */
1033
1034   if (! base_file_name)
1035     {
1036       char *fileprefix = choose_temp_base ();
1037       base_file_name = (char *) xmalloc (strlen (fileprefix) + 6);
1038       sprintf (base_file_name, "%s.base",
1039                (dontdeltemps) ? mybasename (fileprefix) : fileprefix);
1040       delete_base_file = 1;
1041       free (fileprefix);
1042     }
1043
1044   {
1045     int quote;
1046
1047     dyn_string_t step1 = dyn_string_new (driver_cmdline->length
1048                                          + strlen (base_file_name)
1049                                          + 20);
1050     dyn_string_append_cstr (step1, "-Wl,--base-file,");
1051     quote = (strchr (base_file_name, ' ')
1052              || strchr (base_file_name, '\t'));
1053     dyn_string_append_cstr (step1,
1054                        (quote) ? "\"" : "");
1055     dyn_string_append_cstr (step1, base_file_name);
1056     dyn_string_append_cstr (step1,
1057                        (quote) ? "\"" : "");
1058     if (driver_cmdline->length)
1059       {
1060         dyn_string_append_cstr (step1, " ");
1061         dyn_string_append_cstr (step1, driver_cmdline->s);
1062       }
1063
1064     if (run (driver_name, step1->s))
1065       cleanup_and_exit (1);
1066
1067     dyn_string_delete (step1);
1068   }
1069
1070   /* Step 2. generate the exp file by running dlltool.
1071      dlltool command line will look like the following:
1072
1073         % dlltool -Wl,--dll --Wl,--base-file,foo.base [rest of command line]
1074
1075      If the user does not specify a base name, create temporary one that
1076      is deleted at exit.  */
1077
1078   if (! exp_file_name)
1079     {
1080       char *p = strrchr (dll_name, '.');
1081       size_t prefix_len = (p) ? (size_t) (p - dll_name) : strlen (dll_name);
1082
1083       exp_file_name = (char *) xmalloc (prefix_len + 4 + 1);
1084       strncpy (exp_file_name, dll_name, prefix_len);
1085       exp_file_name[prefix_len] = '\0';
1086       strcat (exp_file_name, ".exp");
1087       delete_exp_file = 1;
1088     }
1089
1090   {
1091     int quote;
1092
1093     dyn_string_t step2 = dyn_string_new (dlltool_cmdline->length
1094                                          + strlen (base_file_name)
1095                                          + strlen (exp_file_name)
1096                                          + 20);
1097
1098     dyn_string_append_cstr (step2, "--base-file ");
1099     quote = (strchr (base_file_name, ' ')
1100              || strchr (base_file_name, '\t'));
1101     dyn_string_append_cstr (step2,
1102                        (quote) ? "\"" : "");
1103     dyn_string_append_cstr (step2, base_file_name);
1104     dyn_string_append_cstr (step2,
1105                        (quote) ? "\" " : " ");
1106
1107     dyn_string_append_cstr (step2, "--output-exp ");
1108     quote = (strchr (exp_file_name, ' ')
1109              || strchr (exp_file_name, '\t'));
1110     dyn_string_append_cstr (step2,
1111                        (quote) ? "\"" : "");
1112     dyn_string_append_cstr (step2, exp_file_name);
1113     dyn_string_append_cstr (step2,
1114                        (quote) ? "\"" : "");
1115
1116     if (dlltool_cmdline->length)
1117       {
1118         dyn_string_append_cstr (step2, " ");
1119         dyn_string_append_cstr (step2, dlltool_cmdline->s);
1120       }
1121
1122     if (run (dlltool_name, step2->s))
1123       cleanup_and_exit (1);
1124
1125     dyn_string_delete (step2);
1126   }
1127
1128   /*
1129    * Step 3. Call GCC/LD to again, adding the exp file this time.
1130    * driver command line will look like the following:
1131    *
1132    *    % gcc -Wl,--dll --Wl,--base-file,foo.base foo.exp [rest ...]
1133    */
1134
1135   {
1136     int quote;
1137
1138     dyn_string_t step3 = dyn_string_new (driver_cmdline->length
1139                                          + strlen (exp_file_name)
1140                                          + strlen (base_file_name)
1141                                          + 20);
1142     dyn_string_append_cstr (step3, "-Wl,--base-file,");
1143     quote = (strchr (base_file_name, ' ')
1144              || strchr (base_file_name, '\t'));
1145     dyn_string_append_cstr (step3,
1146                        (quote) ? "\"" : "");
1147     dyn_string_append_cstr (step3, base_file_name);
1148     dyn_string_append_cstr (step3,
1149                        (quote) ? "\" " : " ");
1150
1151     quote = (strchr (exp_file_name, ' ')
1152              || strchr (exp_file_name, '\t'));
1153     dyn_string_append_cstr (step3,
1154                        (quote) ? "\"" : "");
1155     dyn_string_append_cstr (step3, exp_file_name);
1156     dyn_string_append_cstr (step3,
1157                        (quote) ? "\"" : "");
1158
1159     if (driver_cmdline->length)
1160       {
1161         dyn_string_append_cstr (step3, " ");
1162         dyn_string_append_cstr (step3, driver_cmdline->s);
1163       }
1164
1165     if (run (driver_name, step3->s))
1166       cleanup_and_exit (1);
1167
1168     dyn_string_delete (step3);
1169   }
1170
1171
1172   /*
1173    * Step 4. Run DLLTOOL again using the same command line.
1174    */
1175
1176   {
1177     int quote;
1178     dyn_string_t step4 = dyn_string_new (dlltool_cmdline->length
1179                                          + strlen (base_file_name)
1180                                          + strlen (exp_file_name)
1181                                          + 20);
1182
1183     dyn_string_append_cstr (step4, "--base-file ");
1184     quote = (strchr (base_file_name, ' ')
1185              || strchr (base_file_name, '\t'));
1186     dyn_string_append_cstr (step4,
1187                        (quote) ? "\"" : "");
1188     dyn_string_append_cstr (step4, base_file_name);
1189     dyn_string_append_cstr (step4,
1190                        (quote) ? "\" " : " ");
1191
1192     dyn_string_append_cstr (step4, "--output-exp ");
1193     quote = (strchr (exp_file_name, ' ')
1194              || strchr (exp_file_name, '\t'));
1195     dyn_string_append_cstr (step4,
1196                        (quote) ? "\"" : "");
1197     dyn_string_append_cstr (step4, exp_file_name);
1198     dyn_string_append_cstr (step4,
1199                        (quote) ? "\"" : "");
1200
1201     if (dlltool_cmdline->length)
1202       {
1203         dyn_string_append_cstr (step4, " ");
1204         dyn_string_append_cstr (step4, dlltool_cmdline->s);
1205       }
1206
1207     if (output_lib_file_name)
1208       {
1209         dyn_string_append_cstr (step4, " --output-lib ");
1210         dyn_string_append_cstr (step4, output_lib_file_name);
1211       }
1212
1213     if (run (dlltool_name, step4->s))
1214       cleanup_and_exit (1);
1215
1216     dyn_string_delete (step4);
1217   }
1218
1219
1220   /*
1221    * Step 5. Link it all together and be done with it.
1222    * driver command line will look like the following:
1223    *
1224    *    % gcc -Wl,--dll foo.exp [rest ...]
1225    *
1226    */
1227
1228   {
1229     int quote;
1230
1231     dyn_string_t step5 = dyn_string_new (driver_cmdline->length
1232                                          + strlen (exp_file_name)
1233                                          + 20);
1234     quote = (strchr (exp_file_name, ' ')
1235              || strchr (exp_file_name, '\t'));
1236     dyn_string_append_cstr (step5,
1237                        (quote) ? "\"" : "");
1238     dyn_string_append_cstr (step5, exp_file_name);
1239     dyn_string_append_cstr (step5,
1240                        (quote) ? "\"" : "");
1241
1242     if (driver_cmdline->length)
1243       {
1244         dyn_string_append_cstr (step5, " ");
1245         dyn_string_append_cstr (step5, driver_cmdline->s);
1246       }
1247
1248     if (run (driver_name, step5->s))
1249       cleanup_and_exit (1);
1250
1251     dyn_string_delete (step5);
1252   }
1253
1254   cleanup_and_exit (0);
1255
1256   return 0;
1257 }