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
   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 *prog_name, const char *prefix, int end_prefix)
 186 {
 187   struct stat s;
 188   char *cmd;
 189
 190   cmd = xmalloc (strlen (prefix)
 191                  + strlen (prog_name)
 192 #ifdef HAVE_EXECUTABLE_SUFFIX
 193                  + strlen (EXECUTABLE_SUFFIX)
 194 #endif
 195                  + 10);
 196   strcpy (cmd, prefix);
 197
 198   sprintf (cmd + end_prefix, "%s", prog_name);
 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       int i;
 977       dyn_string_t step_pre1;
 978
 979       step_pre1 = dyn_string_new (1024);
 980
 981       dyn_string_append_cstr (step_pre1, dlltool_cmdline->s);
 982       if (export_all)
 983         {
 984           dyn_string_append_cstr (step_pre1, " --export-all --exclude-symbol=");
 985           dyn_string_append_cstr (step_pre1,
 986           "_cygwin_dll_entry@12,DllMainCRTStartup@12,DllMain@12,DllEntryPoint@12");
 987         }
 988       dyn_string_append_cstr (step_pre1, " --output-def ");
 989       dyn_string_append_cstr (step_pre1, def_file_name);
 990
 991       for (i = 1; i < argc; ++i)
 992         {
 993           if (driver_arg_indices[i])
 994             {
 995               char *arg = saved_argv[i];
 996               size_t len = strlen (arg);
 997               if (len >= 2 && arg[len-2] == '.'
 998                   && (arg[len-1] == 'o' || arg[len-1] == 'a'))
 999                 {
1000                   int quote = (strchr (arg, ' ') || strchr (arg, '\t'));
1001                   dyn_string_append_cstr (step_pre1,
1002                                      (quote) ? " \"" : " ");
1003                   dyn_string_append_cstr (step_pre1, arg);
1004                   dyn_string_append_cstr (step_pre1,
1005                                      (quote) ? "\"" : "");
1006                 }
1007             }
1008         }
1009
1010       if (run (dlltool_name, step_pre1->s))
1011         cleanup_and_exit (1);
1012
1013       dyn_string_delete (step_pre1);
1014     }
1015
1016   dyn_string_append_cstr (dlltool_cmdline, " --def ");
1017   dyn_string_append_cstr (dlltool_cmdline, def_file_name);
1018
1019   if (verbose)
1020     {
1021       fprintf (stderr, _("DLLTOOL name    : %s\n"), dlltool_name);
1022       fprintf (stderr, _("DLLTOOL options : %s\n"), dlltool_cmdline->s);
1023       fprintf (stderr, _("DRIVER name     : %s\n"), driver_name);
1024       fprintf (stderr, _("DRIVER options  : %s\n"), driver_cmdline->s);
1025     }
1026
1027   /* Step 1. Call GCC/LD to create base relocation file. If using GCC, the
1028      driver command line will look like the following:
1029
1030         % gcc -Wl,--dll --Wl,--base-file,foo.base [rest of command line]
1031
1032      If the user does not specify a base name, create temporary one that
1033      is deleted at exit.  */
1034
1035   if (! base_file_name)
1036     {
1037       char *fileprefix = choose_temp_base ();
1038       base_file_name = (char *) xmalloc (strlen (fileprefix) + 6);
1039       sprintf (base_file_name, "%s.base",
1040                (dontdeltemps) ? mybasename (fileprefix) : fileprefix);
1041       delete_base_file = 1;
1042       free (fileprefix);
1043     }
1044
1045   {
1046     int quote;
1047
1048     dyn_string_t step1 = dyn_string_new (driver_cmdline->length
1049                                          + strlen (base_file_name)
1050                                          + 20);
1051     dyn_string_append_cstr (step1, "-Wl,--base-file,");
1052     quote = (strchr (base_file_name, ' ')
1053              || strchr (base_file_name, '\t'));
1054     dyn_string_append_cstr (step1,
1055                        (quote) ? "\"" : "");
1056     dyn_string_append_cstr (step1, base_file_name);
1057     dyn_string_append_cstr (step1,
1058                        (quote) ? "\"" : "");
1059     if (driver_cmdline->length)
1060       {
1061         dyn_string_append_cstr (step1, " ");
1062         dyn_string_append_cstr (step1, driver_cmdline->s);
1063       }
1064
1065     if (run (driver_name, step1->s))
1066       cleanup_and_exit (1);
1067
1068     dyn_string_delete (step1);
1069   }
1070
1071   /* Step 2. generate the exp file by running dlltool.
1072      dlltool command line will look like the following:
1073
1074         % dlltool -Wl,--dll --Wl,--base-file,foo.base [rest of command line]
1075
1076      If the user does not specify a base name, create temporary one that
1077      is deleted at exit.  */
1078
1079   if (! exp_file_name)
1080     {
1081       char *p = strrchr (dll_name, '.');
1082       size_t prefix_len = (p) ? (size_t) (p - dll_name) : strlen (dll_name);
1083
1084       exp_file_name = (char *) xmalloc (prefix_len + 4 + 1);
1085       strncpy (exp_file_name, dll_name, prefix_len);
1086       exp_file_name[prefix_len] = '\0';
1087       strcat (exp_file_name, ".exp");
1088       delete_exp_file = 1;
1089     }
1090
1091   {
1092     int quote;
1093
1094     dyn_string_t step2 = dyn_string_new (dlltool_cmdline->length
1095                                          + strlen (base_file_name)
1096                                          + strlen (exp_file_name)
1097                                          + 20);
1098
1099     dyn_string_append_cstr (step2, "--base-file ");
1100     quote = (strchr (base_file_name, ' ')
1101              || strchr (base_file_name, '\t'));
1102     dyn_string_append_cstr (step2,
1103                        (quote) ? "\"" : "");
1104     dyn_string_append_cstr (step2, base_file_name);
1105     dyn_string_append_cstr (step2,
1106                        (quote) ? "\" " : " ");
1107
1108     dyn_string_append_cstr (step2, "--output-exp ");
1109     quote = (strchr (exp_file_name, ' ')
1110              || strchr (exp_file_name, '\t'));
1111     dyn_string_append_cstr (step2,
1112                        (quote) ? "\"" : "");
1113     dyn_string_append_cstr (step2, exp_file_name);
1114     dyn_string_append_cstr (step2,
1115                        (quote) ? "\"" : "");
1116
1117     if (dlltool_cmdline->length)
1118       {
1119         dyn_string_append_cstr (step2, " ");
1120         dyn_string_append_cstr (step2, dlltool_cmdline->s);
1121       }
1122
1123     if (run (dlltool_name, step2->s))
1124       cleanup_and_exit (1);
1125
1126     dyn_string_delete (step2);
1127   }
1128
1129   /*
1130    * Step 3. Call GCC/LD to again, adding the exp file this time.
1131    * driver command line will look like the following:
1132    *
1133    *    % gcc -Wl,--dll --Wl,--base-file,foo.base foo.exp [rest ...]
1134    */
1135
1136   {
1137     int quote;
1138
1139     dyn_string_t step3 = dyn_string_new (driver_cmdline->length
1140                                          + strlen (exp_file_name)
1141                                          + strlen (base_file_name)
1142                                          + 20);
1143     dyn_string_append_cstr (step3, "-Wl,--base-file,");
1144     quote = (strchr (base_file_name, ' ')
1145              || strchr (base_file_name, '\t'));
1146     dyn_string_append_cstr (step3,
1147                        (quote) ? "\"" : "");
1148     dyn_string_append_cstr (step3, base_file_name);
1149     dyn_string_append_cstr (step3,
1150                        (quote) ? "\" " : " ");
1151
1152     quote = (strchr (exp_file_name, ' ')
1153              || strchr (exp_file_name, '\t'));
1154     dyn_string_append_cstr (step3,
1155                        (quote) ? "\"" : "");
1156     dyn_string_append_cstr (step3, exp_file_name);
1157     dyn_string_append_cstr (step3,
1158                        (quote) ? "\"" : "");
1159
1160     if (driver_cmdline->length)
1161       {
1162         dyn_string_append_cstr (step3, " ");
1163         dyn_string_append_cstr (step3, driver_cmdline->s);
1164       }
1165
1166     if (run (driver_name, step3->s))
1167       cleanup_and_exit (1);
1168
1169     dyn_string_delete (step3);
1170   }
1171
1172
1173   /*
1174    * Step 4. Run DLLTOOL again using the same command line.
1175    */
1176
1177   {
1178     int quote;
1179     dyn_string_t step4 = dyn_string_new (dlltool_cmdline->length
1180                                          + strlen (base_file_name)
1181                                          + strlen (exp_file_name)
1182                                          + 20);
1183
1184     dyn_string_append_cstr (step4, "--base-file ");
1185     quote = (strchr (base_file_name, ' ')
1186              || strchr (base_file_name, '\t'));
1187     dyn_string_append_cstr (step4,
1188                        (quote) ? "\"" : "");
1189     dyn_string_append_cstr (step4, base_file_name);
1190     dyn_string_append_cstr (step4,
1191                        (quote) ? "\" " : " ");
1192
1193     dyn_string_append_cstr (step4, "--output-exp ");
1194     quote = (strchr (exp_file_name, ' ')
1195              || strchr (exp_file_name, '\t'));
1196     dyn_string_append_cstr (step4,
1197                        (quote) ? "\"" : "");
1198     dyn_string_append_cstr (step4, exp_file_name);
1199     dyn_string_append_cstr (step4,
1200                        (quote) ? "\"" : "");
1201
1202     if (dlltool_cmdline->length)
1203       {
1204         dyn_string_append_cstr (step4, " ");
1205         dyn_string_append_cstr (step4, dlltool_cmdline->s);
1206       }
1207
1208     if (output_lib_file_name)
1209       {
1210         dyn_string_append_cstr (step4, " --output-lib ");
1211         dyn_string_append_cstr (step4, output_lib_file_name);
1212       }
1213
1214     if (run (dlltool_name, step4->s))
1215       cleanup_and_exit (1);
1216
1217     dyn_string_delete (step4);
1218   }
1219
1220
1221   /*
1222    * Step 5. Link it all together and be done with it.
1223    * driver command line will look like the following:
1224    *
1225    *    % gcc -Wl,--dll foo.exp [rest ...]
1226    *
1227    */
1228
1229   {
1230     int quote;
1231
1232     dyn_string_t step5 = dyn_string_new (driver_cmdline->length
1233                                          + strlen (exp_file_name)
1234                                          + 20);
1235     quote = (strchr (exp_file_name, ' ')
1236              || strchr (exp_file_name, '\t'));
1237     dyn_string_append_cstr (step5,
1238                        (quote) ? "\"" : "");
1239     dyn_string_append_cstr (step5, exp_file_name);
1240     dyn_string_append_cstr (step5,
1241                        (quote) ? "\"" : "");
1242
1243     if (driver_cmdline->length)
1244       {
1245         dyn_string_append_cstr (step5, " ");
1246         dyn_string_append_cstr (step5, driver_cmdline->s);
1247       }
1248
1249     if (run (driver_name, step5->s))
1250       cleanup_and_exit (1);
1251
1252     dyn_string_delete (step5);
1253   }
1254
1255   cleanup_and_exit (0);
1256
1257   return 0;
1258 }