1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2019 Free Software Foundation, Inc.
4 Factored out of collect2 by Rafael Espindola <espindola@google.com>
6 This file is part of GCC.
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
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
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/>. */
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.
30 $ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto
32 The above will print something like
35 If WHOPR is used instead, more than one file might be produced
36 ./ccXj2DTk.lto.ltrans.o
37 ./ccCJuXGv.lto.ltrans.o
42 #include "coretypes.h"
44 #include "diagnostic.h"
48 #include "simple-object.h"
49 #include "lto-section-names.h"
50 #include "collect-utils.h"
52 /* Environment variable, used for passing the names of offload targets from GCC
53 driver to lto-wrapper. */
54 #define OFFLOAD_TARGET_NAMES_ENV "OFFLOAD_TARGET_NAMES"
57 LTO_MODE_NONE
, /* Not doing LTO. */
58 LTO_MODE_LTO
, /* Normal LTO. */
59 LTO_MODE_WHOPR
/* WHOPR. */
62 /* Current LTO mode. */
63 static enum lto_mode_d lto_mode
= LTO_MODE_NONE
;
65 static char *ltrans_output_file
;
66 static char *flto_out
;
67 static unsigned int nr
;
68 static int *ltrans_priorities
;
69 static char **input_names
;
70 static char **output_names
;
71 static char **offload_names
;
72 static char *offload_objects_file_name
;
73 static char *makefile
;
74 static unsigned int num_deb_objs
;
75 static const char **early_debug_object_names
;
77 const char tool_name
[] = "lto-wrapper";
79 /* Delete tempfiles. Called from utils_cleanup. */
86 if (ltrans_output_file
)
87 maybe_unlink (ltrans_output_file
);
89 maybe_unlink (flto_out
);
90 if (offload_objects_file_name
)
91 maybe_unlink (offload_objects_file_name
);
93 maybe_unlink (makefile
);
94 if (early_debug_object_names
)
95 for (i
= 0; i
< num_deb_objs
; ++i
)
96 if (early_debug_object_names
[i
])
97 maybe_unlink (early_debug_object_names
[i
]);
98 for (i
= 0; i
< nr
; ++i
)
100 maybe_unlink (input_names
[i
]);
102 maybe_unlink (output_names
[i
]);
107 lto_wrapper_cleanup (void)
109 utils_cleanup (false);
112 /* Unlink a temporary LTRANS file unless requested otherwise. */
115 maybe_unlink (const char *file
)
119 if (unlink_if_ordinary (file
)
121 fatal_error (input_location
, "deleting LTRANS file %s: %m", file
);
124 fprintf (stderr
, "[Leaving LTRANS %s]\n", file
);
127 /* Template of LTRANS dumpbase suffix. */
128 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
130 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
131 environment according to LANG_MASK. */
134 get_options_from_collect_gcc_options (const char *collect_gcc
,
135 const char *collect_gcc_options
,
136 unsigned int lang_mask
,
137 struct cl_decoded_option
**decoded_options
,
138 unsigned int *decoded_options_count
)
140 struct obstack argv_obstack
;
145 argv_storage
= xstrdup (collect_gcc_options
);
146 obstack_init (&argv_obstack
);
147 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
149 for (j
= 0, k
= 0; argv_storage
[j
] != '\0'; ++j
)
151 if (argv_storage
[j
] == '\'')
153 obstack_ptr_grow (&argv_obstack
, &argv_storage
[k
]);
157 if (argv_storage
[j
] == '\0')
158 fatal_error (input_location
,
159 "malformed %<COLLECT_GCC_OPTIONS%>");
160 else if (strncmp (&argv_storage
[j
], "'\\''", 4) == 0)
162 argv_storage
[k
++] = '\'';
165 else if (argv_storage
[j
] == '\'')
168 argv_storage
[k
++] = argv_storage
[j
++];
171 argv_storage
[k
++] = '\0';
175 obstack_ptr_grow (&argv_obstack
, NULL
);
176 argc
= obstack_object_size (&argv_obstack
) / sizeof (void *) - 1;
177 argv
= XOBFINISH (&argv_obstack
, const char **);
179 decode_cmdline_options_to_array (argc
, (const char **)argv
,
181 decoded_options
, decoded_options_count
);
182 obstack_free (&argv_obstack
, NULL
);
185 /* Append OPTION to the options array DECODED_OPTIONS with size
186 DECODED_OPTIONS_COUNT. */
189 append_option (struct cl_decoded_option
**decoded_options
,
190 unsigned int *decoded_options_count
,
191 struct cl_decoded_option
*option
)
193 ++*decoded_options_count
;
195 = (struct cl_decoded_option
*)
196 xrealloc (*decoded_options
,
197 (*decoded_options_count
198 * sizeof (struct cl_decoded_option
)));
199 memcpy (&(*decoded_options
)[*decoded_options_count
- 1], option
,
200 sizeof (struct cl_decoded_option
));
203 /* Remove option number INDEX from DECODED_OPTIONS, update
204 DECODED_OPTIONS_COUNT. */
207 remove_option (struct cl_decoded_option
**decoded_options
,
208 int index
, unsigned int *decoded_options_count
)
210 --*decoded_options_count
;
211 memmove (&(*decoded_options
)[index
+ 1],
212 &(*decoded_options
)[index
],
213 sizeof (struct cl_decoded_option
)
214 * (*decoded_options_count
- index
));
217 /* Try to merge and complain about options FDECODED_OPTIONS when applied
218 ontop of DECODED_OPTIONS. */
221 merge_and_complain (struct cl_decoded_option
**decoded_options
,
222 unsigned int *decoded_options_count
,
223 struct cl_decoded_option
*fdecoded_options
,
224 unsigned int fdecoded_options_count
)
227 struct cl_decoded_option
*pic_option
= NULL
;
228 struct cl_decoded_option
*pie_option
= NULL
;
230 /* ??? Merge options from files. Most cases can be
231 handled by either unioning or intersecting
232 (for example -fwrapv is a case for unioning,
233 -ffast-math is for intersection). Most complaints
234 about real conflicts between different options can
235 be deferred to the compiler proper. Options that
236 we can neither safely handle by intersection nor
237 unioning would need to be complained about here.
238 Ideally we'd have a flag in the opt files that
239 tells whether to union or intersect or reject.
240 In absence of that it's unclear what a good default is.
241 It's also difficult to get positional handling correct. */
243 /* The following does what the old LTO option code did,
244 union all target and a selected set of common options. */
245 for (i
= 0; i
< fdecoded_options_count
; ++i
)
247 struct cl_decoded_option
*foption
= &fdecoded_options
[i
];
248 switch (foption
->opt_index
)
250 case OPT_SPECIAL_unknown
:
251 case OPT_SPECIAL_ignore
:
252 case OPT_SPECIAL_deprecated
:
253 case OPT_SPECIAL_program_name
:
254 case OPT_SPECIAL_input_file
:
258 if (!(cl_options
[foption
->opt_index
].flags
& CL_TARGET
))
262 case OPT_fdiagnostics_show_caret
:
263 case OPT_fdiagnostics_show_labels
:
264 case OPT_fdiagnostics_show_line_numbers
:
265 case OPT_fdiagnostics_show_option
:
266 case OPT_fdiagnostics_show_location_
:
267 case OPT_fshow_column
:
270 /* Do what the old LTO code did - collect exactly one option
271 setting per OPT code, we pick the first we encounter.
272 ??? This doesn't make too much sense, but when it doesn't
273 then we should complain. */
274 for (j
= 0; j
< *decoded_options_count
; ++j
)
275 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
277 if (j
== *decoded_options_count
)
278 append_option (decoded_options
, decoded_options_count
, foption
);
281 /* Figure out what PIC/PIE level wins and merge the results. */
284 pic_option
= foption
;
288 pie_option
= foption
;
293 /* For selected options we can merge conservatively. */
294 for (j
= 0; j
< *decoded_options_count
; ++j
)
295 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
297 if (j
== *decoded_options_count
)
298 append_option (decoded_options
, decoded_options_count
, foption
);
299 /* -fopenmp > -fno-openmp,
300 -fopenacc > -fno-openacc */
301 else if (foption
->value
> (*decoded_options
)[j
].value
)
302 (*decoded_options
)[j
] = *foption
;
305 case OPT_fopenacc_dim_
:
306 /* Append or check identical. */
307 for (j
= 0; j
< *decoded_options_count
; ++j
)
308 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
310 if (j
== *decoded_options_count
)
311 append_option (decoded_options
, decoded_options_count
, foption
);
312 else if (strcmp ((*decoded_options
)[j
].arg
, foption
->arg
))
313 fatal_error (input_location
,
314 "option %s with different values",
315 foption
->orig_option_with_args_text
);
322 for (j
= 0; j
< *decoded_options_count
; ++j
)
323 if ((*decoded_options
)[j
].opt_index
== OPT_O
324 || (*decoded_options
)[j
].opt_index
== OPT_Ofast
325 || (*decoded_options
)[j
].opt_index
== OPT_Og
326 || (*decoded_options
)[j
].opt_index
== OPT_Os
)
328 if (j
== *decoded_options_count
)
329 append_option (decoded_options
, decoded_options_count
, foption
);
330 else if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
331 && foption
->opt_index
!= OPT_O
)
332 /* Exact same options get merged. */
336 /* For mismatched option kinds preserve the optimization
337 level only, thus merge it as -On. This also handles
338 merging of same optimization level -On. */
340 switch (foption
->opt_index
)
343 if (foption
->arg
[0] == '\0')
344 level
= MAX (level
, 1);
346 level
= MAX (level
, atoi (foption
->arg
));
349 level
= MAX (level
, 3);
352 level
= MAX (level
, 1);
355 level
= MAX (level
, 2);
360 switch ((*decoded_options
)[j
].opt_index
)
363 if ((*decoded_options
)[j
].arg
[0] == '\0')
364 level
= MAX (level
, 1);
366 level
= MAX (level
, atoi ((*decoded_options
)[j
].arg
));
369 level
= MAX (level
, 3);
372 level
= MAX (level
, 1);
375 level
= MAX (level
, 2);
380 (*decoded_options
)[j
].opt_index
= OPT_O
;
382 tem
= xasprintf ("-O%d", level
);
383 (*decoded_options
)[j
].arg
= &tem
[2];
384 (*decoded_options
)[j
].canonical_option
[0] = tem
;
385 (*decoded_options
)[j
].value
= 1;
390 case OPT_foffload_abi_
:
391 for (j
= 0; j
< *decoded_options_count
; ++j
)
392 if ((*decoded_options
)[j
].opt_index
== foption
->opt_index
)
394 if (j
== *decoded_options_count
)
395 append_option (decoded_options
, decoded_options_count
, foption
);
396 else if (foption
->value
!= (*decoded_options
)[j
].value
)
397 fatal_error (input_location
,
398 "option %s not used consistently in all LTO input"
399 " files", foption
->orig_option_with_args_text
);
404 append_option (decoded_options
, decoded_options_count
, foption
);
409 /* Merge PIC options:
410 -fPIC + -fpic = -fpic
411 -fPIC + -fno-pic = -fno-pic
412 -fpic/-fPIC + nothin = nothing.
413 It is a common mistake to mix few -fPIC compiled objects into otherwise
414 non-PIC code. We do not want to build everything with PIC then.
416 Similarly we merge PIE options, however in addition we keep
417 -fPIC + -fPIE = -fPIE
418 -fpic + -fPIE = -fpie
419 -fPIC/-fpic + -fpie = -fpie
421 It would be good to warn on mismatches, but it is bit hard to do as
422 we do not know what nothing translates to. */
424 for (unsigned int j
= 0; j
< *decoded_options_count
;)
425 if ((*decoded_options
)[j
].opt_index
== OPT_fPIC
426 || (*decoded_options
)[j
].opt_index
== OPT_fpic
)
428 /* -fno-pic in one unit implies -fno-pic everywhere. */
429 if ((*decoded_options
)[j
].value
== 0)
431 /* If we have no pic option or merge in -fno-pic, we still may turn
432 existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */
433 else if ((pic_option
&& pic_option
->value
== 0)
438 bool big
= (*decoded_options
)[j
].opt_index
== OPT_fPIC
439 && pie_option
->opt_index
== OPT_fPIE
;
440 (*decoded_options
)[j
].opt_index
= big
? OPT_fPIE
: OPT_fpie
;
441 if (pie_option
->value
)
442 (*decoded_options
)[j
].canonical_option
[0] = big
? "-fPIE" : "-fpie";
444 (*decoded_options
)[j
].canonical_option
[0] = big
? "-fno-pie" : "-fno-pie";
445 (*decoded_options
)[j
].value
= pie_option
->value
;
450 (*decoded_options
)[j
] = *pic_option
;
453 /* We do not know if target defaults to pic or not, so just remove
454 option if it is missing in one unit but enabled in other. */
456 remove_option (decoded_options
, j
, decoded_options_count
);
458 else if (pic_option
->opt_index
== OPT_fpic
459 && (*decoded_options
)[j
].opt_index
== OPT_fPIC
)
461 (*decoded_options
)[j
] = *pic_option
;
467 else if ((*decoded_options
)[j
].opt_index
== OPT_fPIE
468 || (*decoded_options
)[j
].opt_index
== OPT_fpie
)
470 /* -fno-pie in one unit implies -fno-pie everywhere. */
471 if ((*decoded_options
)[j
].value
== 0)
473 /* If we have no pie option or merge in -fno-pie, we still preserve
474 PIE/pie if pic/PIC is present. */
475 else if ((pie_option
&& pie_option
->value
== 0)
478 /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */
481 if (pic_option
->opt_index
== OPT_fpic
482 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
484 (*decoded_options
)[j
].opt_index
= OPT_fpie
;
485 (*decoded_options
)[j
].canonical_option
[0]
486 = pic_option
->value
? "-fpie" : "-fno-pie";
488 else if (!pic_option
->value
)
489 (*decoded_options
)[j
].canonical_option
[0] = "-fno-pie";
490 (*decoded_options
)[j
].value
= pic_option
->value
;
495 (*decoded_options
)[j
] = *pie_option
;
498 /* Because we always append pic/PIE options this code path should
499 not happen unless the LTO object was built by old lto1 which
500 did not contain that logic yet. */
502 remove_option (decoded_options
, j
, decoded_options_count
);
504 else if (pie_option
->opt_index
== OPT_fpie
505 && (*decoded_options
)[j
].opt_index
== OPT_fPIE
)
507 (*decoded_options
)[j
] = *pie_option
;
517 /* Auxiliary function that frees elements of PTR and PTR itself.
518 N is number of elements to be freed. If PTR is NULL, nothing is freed.
519 If an element is NULL, subsequent elements are not freed. */
522 free_array_of_ptrs (void **ptr
, unsigned n
)
526 for (unsigned i
= 0; i
< n
; i
++)
536 /* Parse STR, saving found tokens into PVALUES and return their number.
537 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
538 append it to every token we find. */
541 parse_env_var (const char *str
, char ***pvalues
, const char *append
)
543 const char *curval
, *nextval
;
547 curval
= strchr (str
, ':');
551 curval
= strchr (curval
+ 1, ':');
554 values
= (char**) xmalloc (num
* sizeof (char*));
556 nextval
= strchr (curval
, ':');
558 nextval
= strchr (curval
, '\0');
560 int append_len
= append
? strlen (append
) : 0;
561 for (i
= 0; i
< num
; i
++)
563 int l
= nextval
- curval
;
564 values
[i
] = (char*) xmalloc (l
+ 1 + append_len
);
565 memcpy (values
[i
], curval
, l
);
568 strcat (values
[i
], append
);
569 curval
= nextval
+ 1;
570 nextval
= strchr (curval
, ':');
572 nextval
= strchr (curval
, '\0');
578 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
581 append_compiler_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
584 /* Append compiler driver arguments as far as they were merged. */
585 for (unsigned int j
= 1; j
< count
; ++j
)
587 struct cl_decoded_option
*option
= &opts
[j
];
589 /* File options have been properly filtered by lto-opts.c. */
590 switch (option
->opt_index
)
592 /* Drop arguments that we want to take from the link line. */
595 case OPT_flto_partition_
:
602 /* For now do what the original LTO option code was doing - pass
603 on any CL_TARGET flag and a few selected others. */
604 switch (option
->opt_index
)
606 case OPT_fdiagnostics_show_caret
:
607 case OPT_fdiagnostics_show_labels
:
608 case OPT_fdiagnostics_show_line_numbers
:
609 case OPT_fdiagnostics_show_option
:
610 case OPT_fdiagnostics_show_location_
:
611 case OPT_fshow_column
:
620 case OPT_fopenacc_dim_
:
621 case OPT_foffload_abi_
:
629 if (!(cl_options
[option
->opt_index
].flags
& CL_TARGET
))
633 /* Pass the option on. */
634 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
635 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
639 /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */
642 append_diag_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
645 /* Append compiler driver arguments as far as they were merged. */
646 for (unsigned int j
= 1; j
< count
; ++j
)
648 struct cl_decoded_option
*option
= &opts
[j
];
650 switch (option
->opt_index
)
652 case OPT_fdiagnostics_color_
:
653 case OPT_fdiagnostics_format_
:
654 case OPT_fdiagnostics_show_caret
:
655 case OPT_fdiagnostics_show_labels
:
656 case OPT_fdiagnostics_show_line_numbers
:
657 case OPT_fdiagnostics_show_option
:
658 case OPT_fdiagnostics_show_location_
:
659 case OPT_fshow_column
:
665 /* Pass the option on. */
666 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
667 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
672 /* Append linker options OPTS to ARGV_OBSTACK. */
675 append_linker_options (obstack
*argv_obstack
, struct cl_decoded_option
*opts
,
678 /* Append linker driver arguments. Compiler options from the linker
679 driver arguments will override / merge with those from the compiler. */
680 for (unsigned int j
= 1; j
< count
; ++j
)
682 struct cl_decoded_option
*option
= &opts
[j
];
684 /* Do not pass on frontend specific flags not suitable for lto. */
685 if (!(cl_options
[option
->opt_index
].flags
686 & (CL_COMMON
|CL_TARGET
|CL_DRIVER
|CL_LTO
)))
689 switch (option
->opt_index
)
694 /* We've handled these LTO options, do not pass them on. */
699 /* Ignore -fno-XXX form of these options, as otherwise
700 corresponding builtins will not be enabled. */
701 if (option
->value
== 0)
709 /* Pass the option on. */
710 for (unsigned int i
= 0; i
< option
->canonical_option_num_elements
; ++i
)
711 obstack_ptr_grow (argv_obstack
, option
->canonical_option
[i
]);
715 /* Extract options for TARGET offload compiler from OPTIONS and append
716 them to ARGV_OBSTACK. */
719 append_offload_options (obstack
*argv_obstack
, const char *target
,
720 struct cl_decoded_option
*options
,
721 unsigned int options_count
)
723 for (unsigned i
= 0; i
< options_count
; i
++)
725 const char *cur
, *next
, *opts
;
728 struct cl_decoded_option
*option
= &options
[i
];
730 if (option
->opt_index
!= OPT_foffload_
)
733 /* If option argument starts with '-' then no target is specified. That
734 means offload options are specified for all targets, so we need to
736 if (option
->arg
[0] == '-')
740 opts
= strchr (option
->arg
, '=');
741 /* If there are offload targets specified, but no actual options,
742 there is nothing to do here. */
750 next
= strchr (cur
, ',');
753 next
= (next
> opts
) ? opts
: next
;
755 /* Are we looking for this offload target? */
756 if (strlen (target
) == (size_t) (next
- cur
)
757 && strncmp (target
, cur
, next
- cur
) == 0)
760 /* Skip the comma or equal sign. */
770 argv
= buildargv (opts
);
771 for (argc
= 0; argv
[argc
]; argc
++)
772 obstack_ptr_grow (argv_obstack
, argv
[argc
]);
776 /* Check whether NAME can be accessed in MODE. This is like access,
777 except that it never considers directories to be executable. */
780 access_check (const char *name
, int mode
)
786 if (stat (name
, &st
) < 0
787 || S_ISDIR (st
.st_mode
))
791 return access (name
, mode
);
794 /* Prepare a target image for offload TARGET, using mkoffload tool from
795 COMPILER_PATH. Return the name of the resultant object file. */
798 compile_offload_image (const char *target
, const char *compiler_path
,
799 unsigned in_argc
, char *in_argv
[],
800 struct cl_decoded_option
*compiler_opts
,
801 unsigned int compiler_opt_count
,
802 struct cl_decoded_option
*linker_opts
,
803 unsigned int linker_opt_count
)
805 char *filename
= NULL
;
808 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target
));
809 strcpy (suffix
, "/accel/");
810 strcat (suffix
, target
);
811 strcat (suffix
, "/mkoffload");
814 unsigned n_paths
= parse_env_var (compiler_path
, &paths
, suffix
);
816 const char *compiler
= NULL
;
817 for (unsigned i
= 0; i
< n_paths
; i
++)
818 if (access_check (paths
[i
], X_OK
) == 0)
825 fatal_error (input_location
,
826 "could not find %s in %s (consider using %<-B%>)",
827 suffix
+ 1, compiler_path
);
829 /* Generate temporary output file name. */
830 filename
= make_temp_file (".target.o");
832 struct obstack argv_obstack
;
833 obstack_init (&argv_obstack
);
834 obstack_ptr_grow (&argv_obstack
, compiler
);
836 obstack_ptr_grow (&argv_obstack
, "-save-temps");
838 obstack_ptr_grow (&argv_obstack
, "-v");
839 obstack_ptr_grow (&argv_obstack
, "-o");
840 obstack_ptr_grow (&argv_obstack
, filename
);
842 /* Append names of input object files. */
843 for (unsigned i
= 0; i
< in_argc
; i
++)
844 obstack_ptr_grow (&argv_obstack
, in_argv
[i
]);
846 /* Append options from offload_lto sections. */
847 append_compiler_options (&argv_obstack
, compiler_opts
,
849 append_diag_options (&argv_obstack
, linker_opts
, linker_opt_count
);
851 /* Append options specified by -foffload last. In case of conflicting
852 options we expect offload compiler to choose the latest. */
853 append_offload_options (&argv_obstack
, target
, compiler_opts
,
855 append_offload_options (&argv_obstack
, target
, linker_opts
,
858 obstack_ptr_grow (&argv_obstack
, NULL
);
859 argv
= XOBFINISH (&argv_obstack
, char **);
860 fork_execute (argv
[0], argv
, true);
861 obstack_free (&argv_obstack
, NULL
);
863 free_array_of_ptrs ((void **) paths
, n_paths
);
868 /* The main routine dealing with offloading.
869 The routine builds a target image for each offload target. IN_ARGC and
870 IN_ARGV specify options and input object files. As all of them could contain
871 target sections, we pass them all to target compilers. */
874 compile_images_for_offload_targets (unsigned in_argc
, char *in_argv
[],
875 struct cl_decoded_option
*compiler_opts
,
876 unsigned int compiler_opt_count
,
877 struct cl_decoded_option
*linker_opts
,
878 unsigned int linker_opt_count
)
881 const char *target_names
= getenv (OFFLOAD_TARGET_NAMES_ENV
);
884 unsigned num_targets
= parse_env_var (target_names
, &names
, NULL
);
886 int next_name_entry
= 0;
887 const char *compiler_path
= getenv ("COMPILER_PATH");
891 /* Prepare an image for each target and save the name of the resultant object
892 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
893 offload_names
= XCNEWVEC (char *, num_targets
+ 1);
894 for (unsigned i
= 0; i
< num_targets
; i
++)
896 /* HSA does not use LTO-like streaming and a different compiler, skip
898 if (strcmp (names
[i
], "hsa") == 0)
901 offload_names
[next_name_entry
]
902 = compile_offload_image (names
[i
], compiler_path
, in_argc
, in_argv
,
903 compiler_opts
, compiler_opt_count
,
904 linker_opts
, linker_opt_count
);
905 if (!offload_names
[next_name_entry
])
906 fatal_error (input_location
,
907 "problem with building target image for %s", names
[i
]);
912 free_array_of_ptrs ((void **) names
, num_targets
);
915 /* Copy a file from SRC to DEST. */
918 copy_file (const char *dest
, const char *src
)
920 FILE *d
= fopen (dest
, "wb");
921 FILE *s
= fopen (src
, "rb");
925 size_t len
= fread (buffer
, 1, 512, s
);
927 fatal_error (input_location
, "reading input file");
930 fwrite (buffer
, 1, len
, d
);
932 fatal_error (input_location
, "writing output file");
939 /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
940 the copy to the linker. */
943 find_crtoffloadtable (void)
946 const char *library_path
= getenv ("LIBRARY_PATH");
949 unsigned n_paths
= parse_env_var (library_path
, &paths
, "/crtoffloadtable.o");
952 for (i
= 0; i
< n_paths
; i
++)
953 if (access_check (paths
[i
], R_OK
) == 0)
955 /* The linker will delete the filename we give it, so make a copy. */
956 char *crtoffloadtable
= make_temp_file (".crtoffloadtable.o");
957 copy_file (crtoffloadtable
, paths
[i
]);
958 printf ("%s\n", crtoffloadtable
);
959 XDELETEVEC (crtoffloadtable
);
963 fatal_error (input_location
,
964 "installation error, cannot find %<crtoffloadtable.o%>");
966 free_array_of_ptrs ((void **) paths
, n_paths
);
969 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
970 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
971 and OPT_COUNT. Return true if we found a matchingn section, false
972 otherwise. COLLECT_GCC holds the value of the environment variable with
976 find_and_merge_options (int fd
, off_t file_offset
, const char *prefix
,
977 struct cl_decoded_option
**opts
,
978 unsigned int *opt_count
, const char *collect_gcc
)
980 off_t offset
, length
;
985 struct cl_decoded_option
*fdecoded_options
= *opts
;
986 unsigned int fdecoded_options_count
= *opt_count
;
988 simple_object_read
*sobj
;
989 sobj
= simple_object_start_read (fd
, file_offset
, "__GNU_LTO",
994 char *secname
= XALLOCAVEC (char, strlen (prefix
) + sizeof (".opts"));
995 strcpy (secname
, prefix
);
996 strcat (secname
, ".opts");
997 if (!simple_object_find_section (sobj
, secname
, &offset
, &length
,
1000 simple_object_release_read (sobj
);
1004 lseek (fd
, file_offset
+ offset
, SEEK_SET
);
1005 data
= (char *)xmalloc (length
);
1006 read (fd
, data
, length
);
1010 struct cl_decoded_option
*f2decoded_options
;
1011 unsigned int f2decoded_options_count
;
1012 get_options_from_collect_gcc_options (collect_gcc
,
1015 &f2decoded_options_count
);
1016 if (!fdecoded_options
)
1018 fdecoded_options
= f2decoded_options
;
1019 fdecoded_options_count
= f2decoded_options_count
;
1022 merge_and_complain (&fdecoded_options
,
1023 &fdecoded_options_count
,
1024 f2decoded_options
, f2decoded_options_count
);
1026 fopts
+= strlen (fopts
) + 1;
1028 while (fopts
- data
< length
);
1031 simple_object_release_read (sobj
);
1032 *opts
= fdecoded_options
;
1033 *opt_count
= fdecoded_options_count
;
1037 /* Copy early debug info sections from INFILE to a new file whose name
1038 is returned. Return NULL on error. */
1041 debug_objcopy (const char *infile
, bool rename
)
1048 const char *orig_infile
= infile
;
1052 if ((p
= strrchr (infile
, '@'))
1054 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1055 && strlen (p
) == (unsigned int) consumed
)
1057 char *fname
= xstrdup (infile
);
1058 fname
[p
- infile
] = '\0';
1060 inoff
= (off_t
) loffset
;
1062 int infd
= open (infile
, O_RDONLY
| O_BINARY
);
1065 simple_object_read
*inobj
= simple_object_start_read (infd
, inoff
,
1072 if (simple_object_find_section (inobj
, ".gnu.debuglto_.debug_info",
1073 &off
, &len
, &errmsg
, &err
) != 1)
1076 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1078 simple_object_release_read (inobj
);
1085 outfile
= (char *) xmalloc (strlen (orig_infile
)
1086 + sizeof (".debug.temp.o") + 1);
1087 strcpy (outfile
, orig_infile
);
1088 strcat (outfile
, ".debug.temp.o");
1091 outfile
= make_temp_file (".debug.temp.o");
1092 errmsg
= simple_object_copy_lto_debug_sections (inobj
, outfile
, &err
, rename
);
1095 unlink_if_ordinary (outfile
);
1096 fatal_error (0, "%s: %s", errmsg
, xstrerror (err
));
1099 simple_object_release_read (inobj
);
1105 /* Helper for qsort: compare priorities for parallel compilation. */
1108 cmp_priority (const void *a
, const void *b
)
1110 return *((const int *)b
)-*((const int *)a
);
1114 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1117 run_gcc (unsigned argc
, char *argv
[])
1120 const char **new_argv
;
1121 const char **argv_ptr
;
1122 char *list_option_full
= NULL
;
1123 const char *linker_output
= NULL
;
1124 const char *collect_gcc
, *collect_gcc_options
;
1127 bool no_partition
= false;
1128 struct cl_decoded_option
*fdecoded_options
= NULL
;
1129 struct cl_decoded_option
*offload_fdecoded_options
= NULL
;
1130 unsigned int fdecoded_options_count
= 0;
1131 unsigned int offload_fdecoded_options_count
= 0;
1132 struct cl_decoded_option
*decoded_options
;
1133 unsigned int decoded_options_count
;
1134 struct obstack argv_obstack
;
1136 bool have_lto
= false;
1137 bool have_offload
= false;
1138 unsigned lto_argc
= 0, ltoobj_argc
= 0;
1139 char **lto_argv
, **ltoobj_argv
;
1140 bool linker_output_rel
= false;
1141 bool skip_debug
= false;
1142 unsigned n_debugobj
;
1144 /* Get the driver and options. */
1145 collect_gcc
= getenv ("COLLECT_GCC");
1147 fatal_error (input_location
,
1148 "environment variable %<COLLECT_GCC%> must be set");
1149 collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1150 if (!collect_gcc_options
)
1151 fatal_error (input_location
,
1152 "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
1153 get_options_from_collect_gcc_options (collect_gcc
, collect_gcc_options
,
1156 &decoded_options_count
);
1158 /* Allocate array for input object files with LTO IL,
1159 and for possible preceding arguments. */
1160 lto_argv
= XNEWVEC (char *, argc
);
1161 ltoobj_argv
= XNEWVEC (char *, argc
);
1163 /* Look at saved options in the IL files. */
1164 for (i
= 1; i
< argc
; ++i
)
1168 off_t file_offset
= 0;
1171 char *filename
= argv
[i
];
1173 if (strncmp (argv
[i
], "-foffload-objects=",
1174 sizeof ("-foffload-objects=") - 1) == 0)
1176 have_offload
= true;
1177 offload_objects_file_name
1178 = argv
[i
] + sizeof ("-foffload-objects=") - 1;
1182 if ((p
= strrchr (argv
[i
], '@'))
1184 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1185 && strlen (p
) == (unsigned int) consumed
)
1187 filename
= XNEWVEC (char, p
- argv
[i
] + 1);
1188 memcpy (filename
, argv
[i
], p
- argv
[i
]);
1189 filename
[p
- argv
[i
]] = '\0';
1190 file_offset
= (off_t
) loffset
;
1192 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1193 /* Linker plugin passes -fresolution and -flinker-output options.
1194 -flinker-output is passed only when user did not specify one and thus
1195 we do not need to worry about duplicities with the option handling
1199 lto_argv
[lto_argc
++] = argv
[i
];
1200 if (strcmp (argv
[i
], "-flinker-output=rel") == 0)
1201 linker_output_rel
= true;
1205 if (find_and_merge_options (fd
, file_offset
, LTO_SECTION_NAME_PREFIX
,
1206 &fdecoded_options
, &fdecoded_options_count
,
1210 ltoobj_argv
[ltoobj_argc
++] = argv
[i
];
1215 /* Initalize the common arguments for the driver. */
1216 obstack_init (&argv_obstack
);
1217 obstack_ptr_grow (&argv_obstack
, collect_gcc
);
1218 obstack_ptr_grow (&argv_obstack
, "-xlto");
1219 obstack_ptr_grow (&argv_obstack
, "-c");
1221 append_compiler_options (&argv_obstack
, fdecoded_options
,
1222 fdecoded_options_count
);
1223 append_linker_options (&argv_obstack
, decoded_options
, decoded_options_count
);
1225 /* Scan linker driver arguments for things that are of relevance to us. */
1226 for (j
= 1; j
< decoded_options_count
; ++j
)
1228 struct cl_decoded_option
*option
= &decoded_options
[j
];
1229 switch (option
->opt_index
)
1232 linker_output
= option
->arg
;
1235 case OPT_save_temps
:
1243 case OPT_flto_partition_
:
1244 if (strcmp (option
->arg
, "none") == 0)
1245 no_partition
= true;
1249 if (strcmp (option
->arg
, "jobserver") == 0)
1256 parallel
= atoi (option
->arg
);
1263 lto_mode
= LTO_MODE_WHOPR
;
1266 case OPT_flinker_output_
:
1267 linker_output_rel
= !strcmp (option
->arg
, "rel");
1276 /* Output lto-wrapper invocation command. */
1279 for (i
= 0; i
< argc
; ++i
)
1281 fputs (argv
[i
], stderr
);
1282 fputc (' ', stderr
);
1284 fputc ('\n', stderr
);
1287 if (linker_output_rel
)
1288 no_partition
= true;
1292 lto_mode
= LTO_MODE_LTO
;
1299 char *output_dir
, *base
, *name
;
1300 bool bit_bucket
= strcmp (linker_output
, HOST_BIT_BUCKET
) == 0;
1302 output_dir
= xstrdup (linker_output
);
1304 for (name
= base
; *name
; name
++)
1305 if (IS_DIR_SEPARATOR (*name
))
1309 linker_output
= &linker_output
[base
- output_dir
];
1310 if (*output_dir
== '\0')
1312 static char current_dir
[] = { '.', DIR_SEPARATOR
, '\0' };
1313 output_dir
= current_dir
;
1317 obstack_ptr_grow (&argv_obstack
, "-dumpdir");
1318 obstack_ptr_grow (&argv_obstack
, output_dir
);
1321 obstack_ptr_grow (&argv_obstack
, "-dumpbase");
1324 /* Remember at which point we can scrub args to re-use the commons. */
1325 new_head_argc
= obstack_object_size (&argv_obstack
) / sizeof (void *);
1329 unsigned i
, num_offload_files
;
1330 char **offload_argv
;
1333 f
= fopen (offload_objects_file_name
, "r");
1335 fatal_error (input_location
, "cannot open %s: %m",
1336 offload_objects_file_name
);
1337 if (fscanf (f
, "%u ", &num_offload_files
) != 1)
1338 fatal_error (input_location
, "cannot read %s: %m",
1339 offload_objects_file_name
);
1340 offload_argv
= XCNEWVEC (char *, num_offload_files
);
1342 /* Read names of object files with offload. */
1343 for (i
= 0; i
< num_offload_files
; i
++)
1345 const unsigned piece
= 32;
1346 char *buf
, *filename
= XNEWVEC (char, piece
);
1351 if (!fgets (buf
, piece
, f
))
1353 len
= strlen (filename
);
1354 if (filename
[len
- 1] != '\n')
1356 filename
= XRESIZEVEC (char, filename
, len
+ piece
);
1357 buf
= filename
+ len
;
1360 filename
[len
- 1] = '\0';
1361 offload_argv
[i
] = filename
;
1364 if (offload_argv
[num_offload_files
- 1] == NULL
)
1365 fatal_error (input_location
, "invalid format of %s",
1366 offload_objects_file_name
);
1367 maybe_unlink (offload_objects_file_name
);
1368 offload_objects_file_name
= NULL
;
1370 /* Look at saved offload options in files. */
1371 for (i
= 0; i
< num_offload_files
; i
++)
1376 off_t file_offset
= 0;
1377 char *filename
= offload_argv
[i
];
1379 if ((p
= strrchr (offload_argv
[i
], '@'))
1380 && p
!= offload_argv
[i
]
1381 && sscanf (p
, "@%li%n", &loffset
, &consumed
) >= 1
1382 && strlen (p
) == (unsigned int) consumed
)
1384 filename
= XNEWVEC (char, p
- offload_argv
[i
] + 1);
1385 memcpy (filename
, offload_argv
[i
], p
- offload_argv
[i
]);
1386 filename
[p
- offload_argv
[i
]] = '\0';
1387 file_offset
= (off_t
) loffset
;
1389 fd
= open (filename
, O_RDONLY
| O_BINARY
);
1391 fatal_error (input_location
, "cannot open %s: %m", filename
);
1392 if (!find_and_merge_options (fd
, file_offset
,
1393 OFFLOAD_SECTION_NAME_PREFIX
,
1394 &offload_fdecoded_options
,
1395 &offload_fdecoded_options_count
,
1397 fatal_error (input_location
, "cannot read %s: %m", filename
);
1399 if (filename
!= offload_argv
[i
])
1400 XDELETEVEC (filename
);
1403 compile_images_for_offload_targets (num_offload_files
, offload_argv
,
1404 offload_fdecoded_options
,
1405 offload_fdecoded_options_count
,
1407 decoded_options_count
);
1409 free_array_of_ptrs ((void **) offload_argv
, num_offload_files
);
1413 find_crtoffloadtable ();
1414 for (i
= 0; offload_names
[i
]; i
++)
1415 printf ("%s\n", offload_names
[i
]);
1416 free_array_of_ptrs ((void **) offload_names
, i
);
1420 /* If object files contain offload sections, but do not contain LTO sections,
1421 then there is no need to perform a link-time recompilation, i.e.
1422 lto-wrapper is used only for a compilation of offload images. */
1423 if (have_offload
&& !have_lto
)
1426 if (lto_mode
== LTO_MODE_LTO
)
1430 obstack_ptr_grow (&argv_obstack
, linker_output
);
1431 flto_out
= (char *) xmalloc (strlen (linker_output
)
1432 + sizeof (".lto.o") + 1);
1433 strcpy (flto_out
, linker_output
);
1434 strcat (flto_out
, ".lto.o");
1437 flto_out
= make_temp_file (".lto.o");
1438 obstack_ptr_grow (&argv_obstack
, "-o");
1439 obstack_ptr_grow (&argv_obstack
, flto_out
);
1443 const char *list_option
= "-fltrans-output-list=";
1444 size_t list_option_len
= strlen (list_option
);
1449 char *dumpbase
= (char *) xmalloc (strlen (linker_output
)
1450 + sizeof (".wpa") + 1);
1451 strcpy (dumpbase
, linker_output
);
1452 strcat (dumpbase
, ".wpa");
1453 obstack_ptr_grow (&argv_obstack
, dumpbase
);
1456 if (linker_output
&& save_temps
)
1458 ltrans_output_file
= (char *) xmalloc (strlen (linker_output
)
1459 + sizeof (".ltrans.out") + 1);
1460 strcpy (ltrans_output_file
, linker_output
);
1461 strcat (ltrans_output_file
, ".ltrans.out");
1465 char *prefix
= NULL
;
1468 prefix
= (char *) xmalloc (strlen (linker_output
) + 2);
1469 strcpy (prefix
, linker_output
);
1470 strcat (prefix
, ".");
1473 ltrans_output_file
= make_temp_file_with_prefix (prefix
,
1477 list_option_full
= (char *) xmalloc (sizeof (char) *
1478 (strlen (ltrans_output_file
) + list_option_len
+ 1));
1479 tmp
= list_option_full
;
1481 obstack_ptr_grow (&argv_obstack
, tmp
);
1482 strcpy (tmp
, list_option
);
1483 tmp
+= list_option_len
;
1484 strcpy (tmp
, ltrans_output_file
);
1487 obstack_ptr_grow (&argv_obstack
, xstrdup ("-fwpa=jobserver"));
1488 else if (parallel
> 1)
1491 sprintf (buf
, "-fwpa=%i", parallel
);
1492 obstack_ptr_grow (&argv_obstack
, xstrdup (buf
));
1495 obstack_ptr_grow (&argv_obstack
, "-fwpa");
1498 /* Append input arguments. */
1499 for (i
= 0; i
< lto_argc
; ++i
)
1500 obstack_ptr_grow (&argv_obstack
, lto_argv
[i
]);
1501 /* Append the input objects. */
1502 for (i
= 0; i
< ltoobj_argc
; ++i
)
1503 obstack_ptr_grow (&argv_obstack
, ltoobj_argv
[i
]);
1504 obstack_ptr_grow (&argv_obstack
, NULL
);
1506 new_argv
= XOBFINISH (&argv_obstack
, const char **);
1507 argv_ptr
= &new_argv
[new_head_argc
];
1508 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
), true);
1510 /* Copy the early generated debug info from the objects to temporary
1511 files and append those to the partial link commandline. */
1513 early_debug_object_names
= NULL
;
1516 early_debug_object_names
= XCNEWVEC (const char *, ltoobj_argc
+ 1);
1517 num_deb_objs
= ltoobj_argc
;
1518 for (i
= 0; i
< ltoobj_argc
; ++i
)
1521 if ((tem
= debug_objcopy (ltoobj_argv
[i
], !linker_output_rel
)))
1523 early_debug_object_names
[i
] = tem
;
1529 if (lto_mode
== LTO_MODE_LTO
)
1531 printf ("%s\n", flto_out
);
1534 for (i
= 0; i
< ltoobj_argc
; ++i
)
1535 if (early_debug_object_names
[i
] != NULL
)
1536 printf ("%s\n", early_debug_object_names
[i
]);
1538 /* These now belong to collect2. */
1541 free (early_debug_object_names
);
1542 early_debug_object_names
= NULL
;
1546 FILE *stream
= fopen (ltrans_output_file
, "r");
1547 FILE *mstream
= NULL
;
1548 struct obstack env_obstack
;
1552 fatal_error (input_location
, "%<fopen%>: %s: %m", ltrans_output_file
);
1554 /* Parse the list of LTRANS inputs from the WPA stage. */
1555 obstack_init (&env_obstack
);
1559 const unsigned piece
= 32;
1560 char *output_name
= NULL
;
1561 char *buf
, *input_name
= (char *)xmalloc (piece
);
1565 if (fscanf (stream
, "%i\n", &priority
) != 1)
1568 fatal_error (input_location
,
1569 "corrupted ltrans output file %s",
1570 ltrans_output_file
);
1574 if (!fgets (buf
, piece
, stream
))
1576 len
= strlen (input_name
);
1577 if (input_name
[len
- 1] != '\n')
1579 input_name
= (char *)xrealloc (input_name
, len
+ piece
);
1580 buf
= input_name
+ len
;
1583 input_name
[len
- 1] = '\0';
1585 if (input_name
[0] == '*')
1586 output_name
= &input_name
[1];
1590 = (int *)xrealloc (ltrans_priorities
, nr
* sizeof (int) * 2);
1591 input_names
= (char **)xrealloc (input_names
, nr
* sizeof (char *));
1592 output_names
= (char **)xrealloc (output_names
, nr
* sizeof (char *));
1593 ltrans_priorities
[(nr
-1)*2] = priority
;
1594 ltrans_priorities
[(nr
-1)*2+1] = nr
-1;
1595 input_names
[nr
-1] = input_name
;
1596 output_names
[nr
-1] = output_name
;
1599 maybe_unlink (ltrans_output_file
);
1600 ltrans_output_file
= NULL
;
1604 makefile
= make_temp_file (".mk");
1605 mstream
= fopen (makefile
, "w");
1606 qsort (ltrans_priorities
, nr
, sizeof (int) * 2, cmp_priority
);
1609 /* Execute the LTRANS stage for each input file (or prepare a
1610 makefile to invoke this in parallel). */
1611 for (i
= 0; i
< nr
; ++i
)
1614 char *input_name
= input_names
[i
];
1615 /* If it's a pass-through file do nothing. */
1616 if (output_names
[i
])
1619 /* Replace the .o suffix with a .ltrans.o suffix and write
1620 the resulting name to the LTRANS output list. */
1621 obstack_grow (&env_obstack
, input_name
, strlen (input_name
) - 2);
1622 obstack_grow (&env_obstack
, ".ltrans.o", sizeof (".ltrans.o"));
1623 output_name
= XOBFINISH (&env_obstack
, char *);
1625 /* Adjust the dumpbase if the linker output file was seen. */
1629 = (char *) xmalloc (strlen (linker_output
)
1630 + sizeof (DUMPBASE_SUFFIX
) + 1);
1632 strlen (linker_output
) + sizeof (DUMPBASE_SUFFIX
),
1633 "%s.ltrans%u", linker_output
, i
);
1634 argv_ptr
[0] = dumpbase
;
1637 argv_ptr
[1] = "-fltrans";
1639 argv_ptr
[3] = output_name
;
1640 argv_ptr
[4] = input_name
;
1644 fprintf (mstream
, "%s:\n\t@%s ", output_name
, new_argv
[0]);
1645 for (j
= 1; new_argv
[j
] != NULL
; ++j
)
1646 fprintf (mstream
, " '%s'", new_argv
[j
]);
1647 fprintf (mstream
, "\n");
1648 /* If we are not preserving the ltrans input files then
1649 truncate them as soon as we have processed it. This
1650 reduces temporary disk-space usage. */
1652 fprintf (mstream
, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1653 "&& mv %s.tem %s\n",
1654 input_name
, input_name
, input_name
, input_name
);
1658 fork_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1660 maybe_unlink (input_name
);
1663 output_names
[i
] = output_name
;
1667 struct pex_obj
*pex
;
1673 for (i
= 0; i
< nr
; ++i
)
1675 int j
= ltrans_priorities
[i
*2 + 1];
1676 fprintf (mstream
, " \\\n\t%s", output_names
[j
]);
1678 fprintf (mstream
, "\n");
1682 /* Avoid passing --jobserver-fd= and similar flags
1683 unless jobserver mode is explicitly enabled. */
1684 putenv (xstrdup ("MAKEFLAGS="));
1685 putenv (xstrdup ("MFLAGS="));
1687 new_argv
[0] = getenv ("MAKE");
1689 new_argv
[0] = "make";
1691 new_argv
[2] = makefile
;
1695 snprintf (jobs
, 31, "-j%d", parallel
);
1696 new_argv
[i
++] = jobs
;
1698 new_argv
[i
++] = "all";
1699 new_argv
[i
++] = NULL
;
1700 pex
= collect_execute (new_argv
[0], CONST_CAST (char **, new_argv
),
1701 NULL
, NULL
, PEX_SEARCH
, false);
1702 do_wait (new_argv
[0], pex
);
1703 maybe_unlink (makefile
);
1705 for (i
= 0; i
< nr
; ++i
)
1706 maybe_unlink (input_names
[i
]);
1708 for (i
= 0; i
< nr
; ++i
)
1710 fputs (output_names
[i
], stdout
);
1711 putc ('\n', stdout
);
1712 free (input_names
[i
]);
1716 for (i
= 0; i
< ltoobj_argc
; ++i
)
1717 if (early_debug_object_names
[i
] != NULL
)
1718 printf ("%s\n", early_debug_object_names
[i
]);
1721 free (ltrans_priorities
);
1722 free (output_names
);
1723 output_names
= NULL
;
1724 free (early_debug_object_names
);
1725 early_debug_object_names
= NULL
;
1727 free (list_option_full
);
1728 obstack_free (&env_obstack
, NULL
);
1733 obstack_free (&argv_obstack
, NULL
);
1740 main (int argc
, char *argv
[])
1744 init_opts_obstack ();
1746 p
= argv
[0] + strlen (argv
[0]);
1747 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
1751 xmalloc_set_program_name (progname
);
1753 gcc_init_libintl ();
1755 diagnostic_initialize (global_dc
, 0);
1757 if (atexit (lto_wrapper_cleanup
) != 0)
1758 fatal_error (input_location
, "%<atexit%> failed");
1760 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
1761 signal (SIGINT
, fatal_signal
);
1763 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
1764 signal (SIGHUP
, fatal_signal
);
1766 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
1767 signal (SIGTERM
, fatal_signal
);
1769 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
1770 signal (SIGPIPE
, fatal_signal
);
1773 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1774 receive the signal. A different setting is inheritable */
1775 signal (SIGCHLD
, SIG_DFL
);
1778 /* We may be called with all the arguments stored in some file and
1779 passed with @file. Expand them into argv before processing. */
1780 expandargv (&argc
, &argv
);
1782 run_gcc (argc
, argv
);