|
111
|
1 /* Utility functions used by tools like collect2 and lto-wrapper.
|
|
131
|
2 Copyright (C) 2009-2018 Free Software Foundation, Inc.
|
|
111
|
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
|
|
|
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 (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
|
|
|
93 void
|
|
|
94 do_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
|
|
|
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 (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
|
|
|
203 void
|
|
|
204 fork_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
|
|
|
215 void
|
|
|
216 utils_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 }
|
