1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2013 Free Software Foundation, Inc.
3
4 Factored out of collect2 by Rafael Espindola <espindola@google.com>
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
21
22
23 /* This program is passed a gcc, a list of gcc arguments and a list of
24 object files containing IL. It scans the argument list to check if
25 we are in whopr mode or not modifies the arguments and needed and
26 prints a list of output files on stdout.
27
28 Example:
29
30 $ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto
31
32 The above will print something like
33 /tmp/ccwbQ8B2.lto.o
34
35 If WHOPR is used instead, more than one file might be produced
36 ./ccXj2DTk.lto.ltrans.o
37 ./ccCJuXGv.lto.ltrans.o
38 */
39
40 #include "config.h"
41 #include "system.h"
42 #include "coretypes.h"
43 #include "intl.h"
44 #include "diagnostic.h"
45 #include "obstack.h"
46 #include "opts.h"
47 #include "options.h"
48 #include "simple-object.h"
49
50 /* From lto-streamer.h which we cannot include with -fkeep-inline-functions.
51 ??? Split out a lto-streamer-core.h. */
52
53 #define LTO_SECTION_NAME_PREFIX ".gnu.lto_"
54
55 /* End of lto-streamer.h copy. */
56
57 int debug; /* true if -save-temps. */
58 int verbose; /* true if -v. */
59
60 enum lto_mode_d {
61 LTO_MODE_NONE, /* Not doing LTO. */
62 LTO_MODE_LTO, /* Normal LTO. */
63 LTO_MODE_WHOPR /* WHOPR. */
64 };
65
66 /* Current LTO mode. */
67 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
68
69 static char *ltrans_output_file;
70 static char *flto_out;
71 static char *args_name;
72 static unsigned int nr;
73 static char **input_names;
74 static char **output_names;
75 static char *makefile;
76
77 static void maybe_unlink_file (const char *);
78
79 /* Delete tempfiles. */
80
81 static void
lto_wrapper_cleanup(void)82 lto_wrapper_cleanup (void)
83 {
84 static bool cleanup_done = false;
85 unsigned int i;
86
87 if (cleanup_done)
88 return;
89
90 /* Setting cleanup_done prevents an infinite loop if one of the
91 calls to maybe_unlink_file fails. */
92 cleanup_done = true;
93
94 if (ltrans_output_file)
95 maybe_unlink_file (ltrans_output_file);
96 if (flto_out)
97 maybe_unlink_file (flto_out);
98 if (args_name)
99 maybe_unlink_file (args_name);
100 if (makefile)
101 maybe_unlink_file (makefile);
102 for (i = 0; i < nr; ++i)
103 {
104 maybe_unlink_file (input_names[i]);
105 if (output_names[i])
106 maybe_unlink_file (output_names[i]);
107 }
108 }
109
110 static void
fatal_signal(int signum)111 fatal_signal (int signum)
112 {
113 signal (signum, SIG_DFL);
114 lto_wrapper_cleanup ();
115 /* Get the same signal again, this time not handled,
116 so its normal effect occurs. */
117 kill (getpid (), signum);
118 }
119
120 /* Just die. CMSGID is the error message. */
121
122 static void __attribute__ ((format (printf, 1, 2)))
fatal(const char * cmsgid,...)123 fatal (const char * cmsgid, ...)
124 {
125 va_list ap;
126
127 va_start (ap, cmsgid);
128 fprintf (stderr, "lto-wrapper: ");
129 vfprintf (stderr, _(cmsgid), ap);
130 fprintf (stderr, "\n");
131 va_end (ap);
132
133 lto_wrapper_cleanup ();
134 exit (FATAL_EXIT_CODE);
135 }
136
137
138 /* Die when sys call fails. CMSGID is the error message. */
139
140 static void __attribute__ ((format (printf, 1, 2)))
fatal_perror(const char * cmsgid,...)141 fatal_perror (const char *cmsgid, ...)
142 {
143 int e = errno;
144 va_list ap;
145
146 va_start (ap, cmsgid);
147 fprintf (stderr, "lto-wrapper: ");
148 vfprintf (stderr, _(cmsgid), ap);
149 fprintf (stderr, ": %s\n", xstrerror (e));
150 va_end (ap);
151
152 lto_wrapper_cleanup ();
153 exit (FATAL_EXIT_CODE);
154 }
155
156
157 /* Execute a program, and wait for the reply. ARGV are the arguments. The
158 last one must be NULL. */
159
160 static struct pex_obj *
collect_execute(char ** argv)161 collect_execute (char **argv)
162 {
163 struct pex_obj *pex;
164 const char *errmsg;
165 int err;
166
167 if (verbose)
168 {
169 char **p_argv;
170 const char *str;
171
172 for (p_argv = argv; (str = *p_argv) != (char *) 0; p_argv++)
173 fprintf (stderr, " %s", str);
174
175 fprintf (stderr, "\n");
176 }
177
178 fflush (stdout);
179 fflush (stderr);
180
181 pex = pex_init (0, "lto-wrapper", NULL);
182 if (pex == NULL)
183 fatal_perror ("pex_init failed");
184
185 /* Do not use PEX_LAST here, we use our stdout for communicating with
186 collect2 or the linker-plugin. Any output from the sub-process
187 will confuse that. */
188 errmsg = pex_run (pex, PEX_SEARCH, argv[0], argv, NULL,
189 NULL, &err);
190 if (errmsg != NULL)
191 {
192 if (err != 0)
193 {
194 errno = err;
195 fatal_perror (errmsg);
196 }
197 else
198 fatal (errmsg);
199 }
200
201 return pex;
202 }
203
204
205 /* Wait for a process to finish, and exit if a nonzero status is found.
206 PROG is the program name. PEX is the process we should wait for. */
207
208 static int
collect_wait(const char * prog,struct pex_obj * pex)209 collect_wait (const char *prog, struct pex_obj *pex)
210 {
211 int status;
212
213 if (!pex_get_status (pex, 1, &status))
214 fatal_perror ("can't get program status");
215 pex_free (pex);
216
217 if (status)
218 {
219 if (WIFSIGNALED (status))
220 {
221 int sig = WTERMSIG (status);
222 if (WCOREDUMP (status))
223 fatal ("%s terminated with signal %d [%s], core dumped",
224 prog, sig, strsignal (sig));
225 else
226 fatal ("%s terminated with signal %d [%s]",
227 prog, sig, strsignal (sig));
228 }
229
230 if (WIFEXITED (status))
231 fatal ("%s returned %d exit status", prog, WEXITSTATUS (status));
232 }
233
234 return 0;
235 }
236
237
238 /* Unlink a temporary LTRANS file unless requested otherwise. */
239
240 static void
maybe_unlink_file(const char * file)241 maybe_unlink_file (const char *file)
242 {
243 if (! debug)
244 {
245 if (unlink_if_ordinary (file)
246 && errno != ENOENT)
247 fatal_perror ("deleting LTRANS file %s", file);
248 }
249 else
250 fprintf (stderr, "[Leaving LTRANS %s]\n", file);
251 }
252
253
254 /* Execute program ARGV[0] with arguments ARGV. Wait for it to finish. */
255
256 static void
fork_execute(char ** argv)257 fork_execute (char **argv)
258 {
259 struct pex_obj *pex;
260 char *new_argv[3];
261 char *at_args;
262 FILE *args;
263 int status;
264
265 args_name = make_temp_file (".args");
266 at_args = concat ("@", args_name, NULL);
267 args = fopen (args_name, "w");
268 if (args == NULL)
269 fatal ("failed to open %s", args_name);
270
271 status = writeargv (&argv[1], args);
272
273 if (status)
274 fatal ("could not write to temporary file %s", args_name);
275
276 fclose (args);
277
278 new_argv[0] = argv[0];
279 new_argv[1] = at_args;
280 new_argv[2] = NULL;
281
282 pex = collect_execute (new_argv);
283 collect_wait (new_argv[0], pex);
284
285 maybe_unlink_file (args_name);
286 args_name = NULL;
287 free (at_args);
288 }
289
290 /* Template of LTRANS dumpbase suffix. */
291 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
292
293 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
294 environment according to LANG_MASK. */
295
296 static void
get_options_from_collect_gcc_options(const char * collect_gcc,const char * collect_gcc_options,unsigned int lang_mask,struct cl_decoded_option ** decoded_options,unsigned int * decoded_options_count)297 get_options_from_collect_gcc_options (const char *collect_gcc,
298 const char *collect_gcc_options,
299 unsigned int lang_mask,
300 struct cl_decoded_option **decoded_options,
301 unsigned int *decoded_options_count)
302 {
303 struct obstack argv_obstack;
304 char *argv_storage;
305 const char **argv;
306 int j, k, argc;
307
308 argv_storage = xstrdup (collect_gcc_options);
309 obstack_init (&argv_obstack);
310 obstack_ptr_grow (&argv_obstack, collect_gcc);
311
312 for (j = 0, k = 0; argv_storage[j] != '\0'; ++j)
313 {
314 if (argv_storage[j] == '\'')
315 {
316 obstack_ptr_grow (&argv_obstack, &argv_storage[k]);
317 ++j;
318 do
319 {
320 if (argv_storage[j] == '\0')
321 fatal ("malformed COLLECT_GCC_OPTIONS");
322 else if (strncmp (&argv_storage[j], "'\\''", 4) == 0)
323 {
324 argv_storage[k++] = '\'';
325 j += 4;
326 }
327 else if (argv_storage[j] == '\'')
328 break;
329 else
330 argv_storage[k++] = argv_storage[j++];
331 }
332 while (1);
333 argv_storage[k++] = '\0';
334 }
335 }
336
337 obstack_ptr_grow (&argv_obstack, NULL);
338 argc = obstack_object_size (&argv_obstack) / sizeof (void *) - 1;
339 argv = XOBFINISH (&argv_obstack, const char **);
340
341 decode_cmdline_options_to_array (argc, (const char **)argv,
342 lang_mask,
343 decoded_options, decoded_options_count);
344 obstack_free (&argv_obstack, NULL);
345 }
346
347 /* Append OPTION to the options array DECODED_OPTIONS with size
348 DECODED_OPTIONS_COUNT. */
349
350 static void
append_option(struct cl_decoded_option ** decoded_options,unsigned int * decoded_options_count,struct cl_decoded_option * option)351 append_option (struct cl_decoded_option **decoded_options,
352 unsigned int *decoded_options_count,
353 struct cl_decoded_option *option)
354 {
355 ++*decoded_options_count;
356 *decoded_options
357 = (struct cl_decoded_option *)
358 xrealloc (*decoded_options,
359 (*decoded_options_count
360 * sizeof (struct cl_decoded_option)));
361 memcpy (&(*decoded_options)[*decoded_options_count - 1], option,
362 sizeof (struct cl_decoded_option));
363 }
364
365 /* Try to merge and complain about options FDECODED_OPTIONS when applied
366 ontop of DECODED_OPTIONS. */
367
368 static void
merge_and_complain(struct cl_decoded_option ** decoded_options,unsigned int * decoded_options_count,struct cl_decoded_option * fdecoded_options,unsigned int fdecoded_options_count)369 merge_and_complain (struct cl_decoded_option **decoded_options,
370 unsigned int *decoded_options_count,
371 struct cl_decoded_option *fdecoded_options,
372 unsigned int fdecoded_options_count)
373 {
374 unsigned int i, j;
375
376 /* ??? Merge options from files. Most cases can be
377 handled by either unioning or intersecting
378 (for example -fwrapv is a case for unioning,
379 -ffast-math is for intersection). Most complaints
380 about real conflicts between different options can
381 be deferred to the compiler proper. Options that
382 we can neither safely handle by intersection nor
383 unioning would need to be complained about here.
384 Ideally we'd have a flag in the opt files that
385 tells whether to union or intersect or reject.
386 In absence of that it's unclear what a good default is.
387 It's also difficult to get positional handling correct. */
388
389 /* The following does what the old LTO option code did,
390 union all target and a selected set of common options. */
391 for (i = 0; i < fdecoded_options_count; ++i)
392 {
393 struct cl_decoded_option *foption = &fdecoded_options[i];
394 switch (foption->opt_index)
395 {
396 case OPT_SPECIAL_unknown:
397 case OPT_SPECIAL_ignore:
398 case OPT_SPECIAL_program_name:
399 case OPT_SPECIAL_input_file:
400 break;
401
402 default:
403 if (!(cl_options[foption->opt_index].flags & CL_TARGET))
404 break;
405
406 /* Fallthru. */
407 case OPT_fPIC:
408 case OPT_fpic:
409 case OPT_fpie:
410 case OPT_fcommon:
411 case OPT_fexceptions:
412 case OPT_fgnu_tm:
413 /* Do what the old LTO code did - collect exactly one option
414 setting per OPT code, we pick the first we encounter.
415 ??? This doesn't make too much sense, but when it doesn't
416 then we should complain. */
417 for (j = 0; j < *decoded_options_count; ++j)
418 if ((*decoded_options)[j].opt_index == foption->opt_index)
419 break;
420 if (j == *decoded_options_count)
421 append_option (decoded_options, decoded_options_count, foption);
422 break;
423
424 case OPT_freg_struct_return:
425 case OPT_fpcc_struct_return:
426 for (j = 0; j < *decoded_options_count; ++j)
427 if ((*decoded_options)[j].opt_index == foption->opt_index)
428 break;
429 if (j == *decoded_options_count)
430 fatal ("Option %s not used consistently in all LTO input files",
431 foption->orig_option_with_args_text);
432 break;
433 }
434 }
435 }
436
437 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
438
439 static void
run_gcc(unsigned argc,char * argv[])440 run_gcc (unsigned argc, char *argv[])
441 {
442 unsigned i, j;
443 const char **new_argv;
444 const char **argv_ptr;
445 char *list_option_full = NULL;
446 const char *linker_output = NULL;
447 const char *collect_gcc, *collect_gcc_options;
448 int parallel = 0;
449 int jobserver = 0;
450 bool no_partition = false;
451 struct cl_decoded_option *fdecoded_options = NULL;
452 unsigned int fdecoded_options_count = 0;
453 struct cl_decoded_option *decoded_options;
454 unsigned int decoded_options_count;
455 struct obstack argv_obstack;
456 int new_head_argc;
457
458 /* Get the driver and options. */
459 collect_gcc = getenv ("COLLECT_GCC");
460 if (!collect_gcc)
461 fatal ("environment variable COLLECT_GCC must be set");
462 collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
463 if (!collect_gcc_options)
464 fatal ("environment variable COLLECT_GCC_OPTIONS must be set");
465 get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options,
466 CL_LANG_ALL,
467 &decoded_options,
468 &decoded_options_count);
469
470 /* Look at saved options in the IL files. */
471 for (i = 1; i < argc; ++i)
472 {
473 char *data, *p;
474 char *fopts;
475 int fd;
476 const char *errmsg;
477 int err;
478 off_t file_offset = 0, offset, length;
479 long loffset;
480 simple_object_read *sobj;
481 int consumed;
482 struct cl_decoded_option *f2decoded_options;
483 unsigned int f2decoded_options_count;
484 char *filename = argv[i];
485 if ((p = strrchr (argv[i], '@'))
486 && p != argv[i]
487 && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
488 && strlen (p) == (unsigned int) consumed)
489 {
490 filename = XNEWVEC (char, p - argv[i] + 1);
491 memcpy (filename, argv[i], p - argv[i]);
492 filename[p - argv[i]] = '\0';
493 file_offset = (off_t) loffset;
494 }
495 fd = open (argv[i], O_RDONLY);
496 if (fd == -1)
497 continue;
498 sobj = simple_object_start_read (fd, file_offset, "__GNU_LTO",
499 &errmsg, &err);
500 if (!sobj)
501 {
502 close (fd);
503 continue;
504 }
505 if (!simple_object_find_section (sobj, LTO_SECTION_NAME_PREFIX "." "opts",
506 &offset, &length, &errmsg, &err))
507 {
508 simple_object_release_read (sobj);
509 close (fd);
510 continue;
511 }
512 lseek (fd, file_offset + offset, SEEK_SET);
513 data = (char *)xmalloc (length);
514 read (fd, data, length);
515 fopts = data;
516 do
517 {
518 get_options_from_collect_gcc_options (collect_gcc,
519 fopts, CL_LANG_ALL,
520 &f2decoded_options,
521 &f2decoded_options_count);
522 if (!fdecoded_options)
523 {
524 fdecoded_options = f2decoded_options;
525 fdecoded_options_count = f2decoded_options_count;
526 }
527 else
528 merge_and_complain (&fdecoded_options,
529 &fdecoded_options_count,
530 f2decoded_options, f2decoded_options_count);
531
532 fopts += strlen (fopts) + 1;
533 }
534 while (fopts - data < length);
535
536 free (data);
537 simple_object_release_read (sobj);
538 close (fd);
539 }
540
541 /* Initalize the common arguments for the driver. */
542 obstack_init (&argv_obstack);
543 obstack_ptr_grow (&argv_obstack, collect_gcc);
544 obstack_ptr_grow (&argv_obstack, "-xlto");
545 obstack_ptr_grow (&argv_obstack, "-c");
546
547 /* Append compiler driver arguments as far as they were merged. */
548 for (j = 1; j < fdecoded_options_count; ++j)
549 {
550 struct cl_decoded_option *option = &fdecoded_options[j];
551
552 /* File options have been properly filtered by lto-opts.c. */
553 switch (option->opt_index)
554 {
555 /* Drop arguments that we want to take from the link line. */
556 case OPT_flto_:
557 case OPT_flto:
558 case OPT_flto_partition_none:
559 case OPT_flto_partition_1to1:
560 case OPT_flto_partition_balanced:
561 continue;
562
563 default:
564 break;
565 }
566
567 /* For now do what the original LTO option code was doing - pass
568 on any CL_TARGET flag and a few selected others. */
569 switch (option->opt_index)
570 {
571 case OPT_fPIC:
572 case OPT_fpic:
573 case OPT_fpie:
574 case OPT_fcommon:
575 case OPT_fexceptions:
576 case OPT_fgnu_tm:
577 case OPT_freg_struct_return:
578 case OPT_fpcc_struct_return:
579 break;
580
581 default:
582 if (!(cl_options[option->opt_index].flags & CL_TARGET))
583 continue;
584 }
585
586 /* Pass the option on. */
587 for (i = 0; i < option->canonical_option_num_elements; ++i)
588 obstack_ptr_grow (&argv_obstack, option->canonical_option[i]);
589 }
590
591 /* Append linker driver arguments. Compiler options from the linker
592 driver arguments will override / merge with those from the compiler. */
593 for (j = 1; j < decoded_options_count; ++j)
594 {
595 struct cl_decoded_option *option = &decoded_options[j];
596
597 /* Do not pass on frontend specific flags not suitable for lto. */
598 if (!(cl_options[option->opt_index].flags
599 & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO)))
600 continue;
601
602 switch (option->opt_index)
603 {
604 case OPT_o:
605 linker_output = option->arg;
606 /* We generate new intermediate output, drop this arg. */
607 continue;
608
609 case OPT_save_temps:
610 debug = 1;
611 break;
612
613 case OPT_v:
614 verbose = 1;
615 break;
616
617 case OPT_flto_partition_none:
618 no_partition = true;
619 break;
620
621 case OPT_flto_:
622 if (strcmp (option->arg, "jobserver") == 0)
623 {
624 jobserver = 1;
625 parallel = 1;
626 }
627 else
628 {
629 parallel = atoi (option->arg);
630 if (parallel <= 1)
631 parallel = 0;
632 }
633 /* Fallthru. */
634
635 case OPT_flto:
636 lto_mode = LTO_MODE_WHOPR;
637 /* We've handled these LTO options, do not pass them on. */
638 continue;
639
640 case OPT_freg_struct_return:
641 case OPT_fpcc_struct_return:
642 /* Ignore these, they are determined by the input files.
643 ??? We fail to diagnose a possible mismatch here. */
644 continue;
645
646 default:
647 break;
648 }
649
650 /* Pass the option on. */
651 for (i = 0; i < option->canonical_option_num_elements; ++i)
652 obstack_ptr_grow (&argv_obstack, option->canonical_option[i]);
653 }
654
655 if (no_partition)
656 {
657 lto_mode = LTO_MODE_LTO;
658 jobserver = 0;
659 parallel = 0;
660 }
661
662 if (linker_output)
663 {
664 char *output_dir, *base, *name;
665 bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0;
666
667 output_dir = xstrdup (linker_output);
668 base = output_dir;
669 for (name = base; *name; name++)
670 if (IS_DIR_SEPARATOR (*name))
671 base = name + 1;
672 *base = '\0';
673
674 linker_output = &linker_output[base - output_dir];
675 if (*output_dir == '\0')
676 {
677 static char current_dir[] = { '.', DIR_SEPARATOR, '\0' };
678 output_dir = current_dir;
679 }
680 if (!bit_bucket)
681 {
682 obstack_ptr_grow (&argv_obstack, "-dumpdir");
683 obstack_ptr_grow (&argv_obstack, output_dir);
684 }
685
686 obstack_ptr_grow (&argv_obstack, "-dumpbase");
687 }
688
689 /* Remember at which point we can scrub args to re-use the commons. */
690 new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *);
691
692 if (lto_mode == LTO_MODE_LTO)
693 {
694 flto_out = make_temp_file (".lto.o");
695 if (linker_output)
696 obstack_ptr_grow (&argv_obstack, linker_output);
697 obstack_ptr_grow (&argv_obstack, "-o");
698 obstack_ptr_grow (&argv_obstack, flto_out);
699 }
700 else
701 {
702 const char *list_option = "-fltrans-output-list=";
703 size_t list_option_len = strlen (list_option);
704 char *tmp;
705
706 if (linker_output)
707 {
708 char *dumpbase = (char *) xmalloc (strlen (linker_output)
709 + sizeof (".wpa") + 1);
710 strcpy (dumpbase, linker_output);
711 strcat (dumpbase, ".wpa");
712 obstack_ptr_grow (&argv_obstack, dumpbase);
713 }
714
715 if (linker_output && debug)
716 {
717 ltrans_output_file = (char *) xmalloc (strlen (linker_output)
718 + sizeof (".ltrans.out") + 1);
719 strcpy (ltrans_output_file, linker_output);
720 strcat (ltrans_output_file, ".ltrans.out");
721 }
722 else
723 ltrans_output_file = make_temp_file (".ltrans.out");
724 list_option_full = (char *) xmalloc (sizeof (char) *
725 (strlen (ltrans_output_file) + list_option_len + 1));
726 tmp = list_option_full;
727
728 obstack_ptr_grow (&argv_obstack, tmp);
729 strcpy (tmp, list_option);
730 tmp += list_option_len;
731 strcpy (tmp, ltrans_output_file);
732
733 obstack_ptr_grow (&argv_obstack, "-fwpa");
734 }
735
736 /* Append the input objects and possible preceding arguments. */
737 for (i = 1; i < argc; ++i)
738 obstack_ptr_grow (&argv_obstack, argv[i]);
739 obstack_ptr_grow (&argv_obstack, NULL);
740
741 new_argv = XOBFINISH (&argv_obstack, const char **);
742 argv_ptr = &new_argv[new_head_argc];
743 fork_execute (CONST_CAST (char **, new_argv));
744
745 if (lto_mode == LTO_MODE_LTO)
746 {
747 printf("%s\n", flto_out);
748 free (flto_out);
749 flto_out = NULL;
750 }
751 else
752 {
753 FILE *stream = fopen (ltrans_output_file, "r");
754 FILE *mstream = NULL;
755 struct obstack env_obstack;
756
757 if (!stream)
758 fatal_perror ("fopen: %s", ltrans_output_file);
759
760 /* Parse the list of LTRANS inputs from the WPA stage. */
761 obstack_init (&env_obstack);
762 nr = 0;
763 for (;;)
764 {
765 const unsigned piece = 32;
766 char *output_name = NULL;
767 char *buf, *input_name = (char *)xmalloc (piece);
768 size_t len;
769
770 buf = input_name;
771 cont:
772 if (!fgets (buf, piece, stream))
773 break;
774 len = strlen (input_name);
775 if (input_name[len - 1] != '\n')
776 {
777 input_name = (char *)xrealloc (input_name, len + piece);
778 buf = input_name + len;
779 goto cont;
780 }
781 input_name[len - 1] = '\0';
782
783 if (input_name[0] == '*')
784 output_name = &input_name[1];
785
786 nr++;
787 input_names = (char **)xrealloc (input_names, nr * sizeof (char *));
788 output_names = (char **)xrealloc (output_names, nr * sizeof (char *));
789 input_names[nr-1] = input_name;
790 output_names[nr-1] = output_name;
791 }
792 fclose (stream);
793 maybe_unlink_file (ltrans_output_file);
794 ltrans_output_file = NULL;
795
796 if (parallel)
797 {
798 makefile = make_temp_file (".mk");
799 mstream = fopen (makefile, "w");
800 }
801
802 /* Execute the LTRANS stage for each input file (or prepare a
803 makefile to invoke this in parallel). */
804 for (i = 0; i < nr; ++i)
805 {
806 char *output_name;
807 char *input_name = input_names[i];
808 /* If it's a pass-through file do nothing. */
809 if (output_names[i])
810 continue;
811
812 /* Replace the .o suffix with a .ltrans.o suffix and write
813 the resulting name to the LTRANS output list. */
814 obstack_grow (&env_obstack, input_name, strlen (input_name) - 2);
815 obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
816 output_name = XOBFINISH (&env_obstack, char *);
817
818 /* Adjust the dumpbase if the linker output file was seen. */
819 if (linker_output)
820 {
821 char *dumpbase
822 = (char *) xmalloc (strlen (linker_output)
823 + sizeof(DUMPBASE_SUFFIX) + 1);
824 snprintf (dumpbase,
825 strlen (linker_output) + sizeof(DUMPBASE_SUFFIX),
826 "%s.ltrans%u", linker_output, i);
827 argv_ptr[0] = dumpbase;
828 }
829
830 argv_ptr[1] = "-fltrans";
831 argv_ptr[2] = "-o";
832 argv_ptr[3] = output_name;
833 argv_ptr[4] = input_name;
834 argv_ptr[5] = NULL;
835 if (parallel)
836 {
837 fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]);
838 for (j = 1; new_argv[j] != NULL; ++j)
839 fprintf (mstream, " '%s'", new_argv[j]);
840 fprintf (mstream, "\n");
841 /* If we are not preserving the ltrans input files then
842 truncate them as soon as we have processed it. This
843 reduces temporary disk-space usage. */
844 if (! debug)
845 fprintf (mstream, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
846 "&& mv %s.tem %s\n",
847 input_name, input_name, input_name, input_name);
848 }
849 else
850 {
851 fork_execute (CONST_CAST (char **, new_argv));
852 maybe_unlink_file (input_name);
853 }
854
855 output_names[i] = output_name;
856 }
857 if (parallel)
858 {
859 struct pex_obj *pex;
860 char jobs[32];
861
862 fprintf (mstream, "all:");
863 for (i = 0; i < nr; ++i)
864 fprintf (mstream, " \\\n\t%s", output_names[i]);
865 fprintf (mstream, "\n");
866 fclose (mstream);
867 if (!jobserver)
868 {
869 /* Avoid passing --jobserver-fd= and similar flags
870 unless jobserver mode is explicitly enabled. */
871 putenv (xstrdup ("MAKEFLAGS="));
872 putenv (xstrdup ("MFLAGS="));
873 }
874 new_argv[0] = getenv ("MAKE");
875 if (!new_argv[0])
876 new_argv[0] = "make";
877 new_argv[1] = "-f";
878 new_argv[2] = makefile;
879 i = 3;
880 if (!jobserver)
881 {
882 snprintf (jobs, 31, "-j%d", parallel);
883 new_argv[i++] = jobs;
884 }
885 new_argv[i++] = "all";
886 new_argv[i++] = NULL;
887 pex = collect_execute (CONST_CAST (char **, new_argv));
888 collect_wait (new_argv[0], pex);
889 maybe_unlink_file (makefile);
890 makefile = NULL;
891 for (i = 0; i < nr; ++i)
892 maybe_unlink_file (input_names[i]);
893 }
894 for (i = 0; i < nr; ++i)
895 {
896 fputs (output_names[i], stdout);
897 putc ('\n', stdout);
898 free (input_names[i]);
899 }
900 nr = 0;
901 free (output_names);
902 free (input_names);
903 free (list_option_full);
904 obstack_free (&env_obstack, NULL);
905 }
906
907 obstack_free (&argv_obstack, NULL);
908 }
909
910
911 /* Entry point. */
912
913 int
main(int argc,char * argv[])914 main (int argc, char *argv[])
915 {
916 const char *p;
917
918 gcc_obstack_init (&opts_obstack);
919
920 p = argv[0] + strlen (argv[0]);
921 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
922 --p;
923 progname = p;
924
925 xmalloc_set_program_name (progname);
926
927 gcc_init_libintl ();
928
929 diagnostic_initialize (global_dc, 0);
930
931 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
932 signal (SIGINT, fatal_signal);
933 #ifdef SIGHUP
934 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
935 signal (SIGHUP, fatal_signal);
936 #endif
937 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
938 signal (SIGTERM, fatal_signal);
939 #ifdef SIGPIPE
940 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
941 signal (SIGPIPE, fatal_signal);
942 #endif
943 #ifdef SIGCHLD
944 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
945 receive the signal. A different setting is inheritable */
946 signal (SIGCHLD, SIG_DFL);
947 #endif
948
949 /* We may be called with all the arguments stored in some file and
950 passed with @file. Expand them into argv before processing. */
951 expandargv (&argc, &argv);
952
953 run_gcc (argc, argv);
954
955 return 0;
956 }
957