1/* Utility functions used by tools like collect2 and lto-wrapper.
2   Copyright (C) 2009-2015 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along 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
32static char *response_file;
33
34bool debug;
35bool verbose;
36bool save_temps;
37
38
39/* Notify user of a non-error.  */
40void
41notice (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
50void
51fatal_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
60/* Wait for a process to finish, and exit if a nonzero status is found.  */
61
62int
63collect_wait (const char *prog, struct pex_obj *pex)
64{
65  int status;
66
67  if (!pex_get_status (pex, 1, &status))
68    fatal_error (input_location, "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 (input_location, "%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
87void
88do_wait (const char *prog, struct pex_obj *pex)
89{
90  int ret = collect_wait (prog, pex);
91  if (ret != 0)
92    fatal_error (input_location, "%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
102/* Execute a program, and wait for the reply.  */
103
104struct pex_obj *
105collect_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 (input_location, "could not open response file %s",
134		     response_file);
135
136      status = writeargv (current_argv, f);
137
138      if (status)
139        fatal_error (input_location, "could not write to response file %s",
140		     response_file);
141
142      status = fclose (f);
143
144      if (EOF == status)
145        fatal_error (input_location, "could not close response file %s",
146		     response_file);
147
148      response_arg = concat ("@", response_file, NULL);
149      response_argv[0] = argv0;
150      response_argv[1] = response_arg;
151      response_argv[2] = NULL;
152
153      argv = response_argv;
154    }
155
156  if (verbose || debug)
157    {
158      char **p_argv;
159      const char *str;
160
161      if (argv[0])
162	fprintf (stderr, "%s", argv[0]);
163      else
164	notice ("[cannot find %s]", prog);
165
166      for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
167	fprintf (stderr, " %s", str);
168
169      fprintf (stderr, "\n");
170    }
171
172  fflush (stdout);
173  fflush (stderr);
174
175  /* If we cannot find a program we need, complain error.  Do this here
176     since we might not end up needing something that we could not find.  */
177
178  if (argv[0] == 0)
179    fatal_error (input_location, "cannot find '%s'", prog);
180
181  pex = pex_init (0, "collect2", NULL);
182  if (pex == NULL)
183    fatal_error (input_location, "pex_init failed: %m");
184
185  errmsg = pex_run (pex, flags, argv[0], argv, outname,
186		    errname, &err);
187  if (errmsg != NULL)
188    {
189      if (err != 0)
190	{
191	  errno = err;
192	  fatal_error (input_location, "%s: %m", _(errmsg));
193	}
194      else
195	fatal_error (input_location, errmsg);
196    }
197
198  free (response_arg);
199
200  return pex;
201}
202
203void
204fork_execute (const char *prog, char **argv, bool use_atfile)
205{
206  struct pex_obj *pex;
207
208  pex = collect_execute (prog, argv, NULL, NULL,
209			 PEX_LAST | PEX_SEARCH, use_atfile);
210  do_wait (prog, pex);
211}
212
213/* Delete tempfiles.  */
214
215void
216utils_cleanup (bool from_signal)
217{
218  static bool cleanup_done = false;
219
220  if (cleanup_done)
221    return;
222
223  /* Setting cleanup_done prevents an infinite loop if one of the
224     calls to maybe_unlink fails. */
225  cleanup_done = true;
226
227  if (response_file)
228    maybe_unlink (response_file);
229  tool_cleanup (from_signal);
230}
231