gcc/collect-utils.c

   1 /* Utility functions used by tools like collect2 and lto-wrapper.
   2    Copyright (C) 2009-2014 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "intl.h"
  24 #include "diagnostic.h"
  25 #include "obstack.h"
  26 #include "opts.h"
  27 #include "options.h"
  28 #include "simple-object.h"
  29 #include "lto-section-names.h"
  30 #include "collect-utils.h"
  31
  32 static char *response_file;
  33
  34 bool debug;
  35 bool verbose;
  36 bool save_temps;
  37
  38
  39 /* Notify user of a non-error.  */
  40 void
  41 notice (const char *cmsgid, ...)
  42 {
  43   va_list ap;
  44
  45   va_start (ap, cmsgid);
  46   vfprintf (stderr, _(cmsgid), ap);
  47   va_end (ap);
  48 }
  49
  50 void
  51 fatal_signal (int signum)
  52 {
  53   signal (signum, SIG_DFL);
  54   utils_cleanup (true);
  55   /* Get the same signal again, this time not handled,
  56      so its normal effect occurs.  */
  57   kill (getpid (), signum);
  58 }
  59 \f
  60 /* Wait for a process to finish, and exit if a nonzero status is found.  */
  61
  62 int
  63 collect_wait (const char *prog, struct pex_obj *pex)
  64 {
  65   int status;
  66
  67   if (!pex_get_status (pex, 1, &status))
  68     fatal_error ("can't get program status: %m");
  69   pex_free (pex);
  70
  71   if (status)
  72     {
  73       if (WIFSIGNALED (status))
  74         {
  75           int sig = WTERMSIG (status);
  76           fatal_error ("%s terminated with signal %d [%s]%s",
  77                        prog, sig, strsignal (sig),
  78                        WCOREDUMP (status) ? ", core dumped" : "");
  79         }
  80
  81       if (WIFEXITED (status))
  82         return WEXITSTATUS (status);
  83     }
  84   return 0;
  85 }
  86
  87 void
  88 do_wait (const char *prog, struct pex_obj *pex)
  89 {
  90   int ret = collect_wait (prog, pex);
  91   if (ret != 0)
  92     fatal_error ("%s returned %d exit status", prog, ret);
  93
  94   if (response_file && !save_temps)
  95     {
  96       unlink (response_file);
  97       response_file = NULL;
  98     }
  99 }
 100
 101 \f
 102 /* Execute a program, and wait for the reply.  */
 103
 104 struct pex_obj *
 105 collect_execute (const char *prog, char **argv, const char *outname,
 106                  const char *errname, int flags, bool use_atfile)
 107 {
 108   struct pex_obj *pex;
 109   const char *errmsg;
 110   int err;
 111   char *response_arg = NULL;
 112   char *response_argv[3];
 113
 114   if (use_atfile && argv[0] != NULL)
 115     {
 116       /* If using @file arguments, create a temporary file and put the
 117          contents of argv into it.  Then change argv to an array corresponding
 118          to a single argument @FILE, where FILE is the temporary filename.  */
 119
 120       char **current_argv = argv + 1;
 121       char *argv0 = argv[0];
 122       int status;
 123       FILE *f;
 124
 125       /* Note: we assume argv contains at least one element; this is
 126          checked above.  */
 127
 128       response_file = make_temp_file ("");
 129
 130       f = fopen (response_file, "w");
 131
 132       if (f == NULL)
 133         fatal_error ("could not open response file %s", response_file);
 134
 135       status = writeargv (current_argv, f);
 136
 137       if (status)
 138         fatal_error ("could not write to response file %s", response_file);
 139
 140       status = fclose (f);
 141
 142       if (EOF == status)
 143         fatal_error ("could not close response file %s", response_file);
 144
 145       response_arg = concat ("@", response_file, NULL);
 146       response_argv[0] = argv0;
 147       response_argv[1] = response_arg;
 148       response_argv[2] = NULL;
 149
 150       argv = response_argv;
 151     }
 152
 153   if (verbose || debug)
 154     {
 155       char **p_argv;
 156       const char *str;
 157
 158       if (argv[0])
 159         fprintf (stderr, "%s", argv[0]);
 160       else
 161         notice ("[cannot find %s]", prog);
 162
 163       for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
 164         fprintf (stderr, " %s", str);
 165
 166       fprintf (stderr, "\n");
 167     }
 168
 169   fflush (stdout);
 170   fflush (stderr);
 171
 172   /* If we cannot find a program we need, complain error.  Do this here
 173      since we might not end up needing something that we could not find.  */
 174
 175   if (argv[0] == 0)
 176     fatal_error ("cannot find '%s'", prog);
 177
 178   pex = pex_init (0, "collect2", NULL);
 179   if (pex == NULL)
 180     fatal_error ("pex_init failed: %m");
 181
 182   errmsg = pex_run (pex, flags, argv[0], argv, outname,
 183                     errname, &err);
 184   if (errmsg != NULL)
 185     {
 186       if (err != 0)
 187         {
 188           errno = err;
 189           fatal_error ("%s: %m", _(errmsg));
 190         }
 191       else
 192         fatal_error (errmsg);
 193     }
 194
 195   free (response_arg);
 196
 197   return pex;
 198 }
 199
 200 void
 201 fork_execute (const char *prog, char **argv, bool use_atfile)
 202 {
 203   struct pex_obj *pex;
 204
 205   pex = collect_execute (prog, argv, NULL, NULL,
 206                          PEX_LAST | PEX_SEARCH, use_atfile);
 207   do_wait (prog, pex);
 208 }
 209
 210 /* Delete tempfiles.  */
 211
 212 void
 213 utils_cleanup (bool from_signal)
 214 {
 215   static bool cleanup_done = false;
 216
 217   if (cleanup_done)
 218     return;
 219
 220   /* Setting cleanup_done prevents an infinite loop if one of the
 221      calls to maybe_unlink fails. */
 222   cleanup_done = true;
 223
 224   if (response_file)
 225     maybe_unlink (response_file);
 226   tool_cleanup (from_signal);
 227 }