1/* Utility functions used by tools like collect2 and lto-wrapper.
2 Copyright (C) 2009-2017 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 (response_file && !save_temps)
72 {
73 unlink (response_file);
74 response_file = NULL;
75 }
76
77 if (status)
78 {
79 if (WIFSIGNALED (status))
80 {
81 int sig = WTERMSIG (status);
82 fatal_error (input_location, "%s terminated with signal %d [%s]%s",
83 prog, sig, strsignal (sig),
84 WCOREDUMP (status) ? ", core dumped" : "");
85 }
86
87 if (WIFEXITED (status))
88 return WEXITSTATUS (status);
89 }
90 return 0;
91}
92
93void
94do_wait (const char *prog, struct pex_obj *pex)
95{
96 int ret = collect_wait (prog, pex);
97 if (ret != 0)
98 fatal_error (input_location, "%s returned %d exit status", prog, ret);
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 tool_cleanup (from_signal);
228}
229