binutils/dllwrap.c

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