1 /* Wrapper to call lto. Used by collect2 and the linker plugin.
2 Copyright (C) 2009-2020 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 #include "lto-section-names.h"
50 #include "collect-utils.h"
51
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"
55
56 enum lto_mode_d {
57 LTO_MODE_NONE, /* Not doing LTO. */
58 LTO_MODE_LTO, /* Normal LTO. */
59 LTO_MODE_WHOPR /* WHOPR. */
60 };
61
62 /* Current LTO mode. */
63 static enum lto_mode_d lto_mode = LTO_MODE_NONE;
64
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;
76 static bool xassembler_options_error = false;
77
78 const char tool_name[] = "lto-wrapper";
79
80 /* Delete tempfiles. Called from utils_cleanup. */
81
82 void
tool_cleanup(bool)83 tool_cleanup (bool)
84 {
85 unsigned int i;
86
87 if (ltrans_output_file)
88 maybe_unlink (ltrans_output_file);
89 if (flto_out)
90 maybe_unlink (flto_out);
91 if (offload_objects_file_name)
92 maybe_unlink (offload_objects_file_name);
93 if (makefile)
94 maybe_unlink (makefile);
95 if (early_debug_object_names)
96 for (i = 0; i < num_deb_objs; ++i)
97 if (early_debug_object_names[i])
98 maybe_unlink (early_debug_object_names[i]);
99 for (i = 0; i < nr; ++i)
100 {
101 maybe_unlink (input_names[i]);
102 if (output_names[i])
103 maybe_unlink (output_names[i]);
104 }
105 }
106
107 static void
lto_wrapper_cleanup(void)108 lto_wrapper_cleanup (void)
109 {
110 utils_cleanup (false);
111 }
112
113 /* Unlink a temporary LTRANS file unless requested otherwise. */
114
115 void
maybe_unlink(const char * file)116 maybe_unlink (const char *file)
117 {
118 if (!save_temps)
119 {
120 if (unlink_if_ordinary (file)
121 && errno != ENOENT)
122 fatal_error (input_location, "deleting LTRANS file %s: %m", file);
123 }
124 else if (verbose)
125 fprintf (stderr, "[Leaving LTRANS %s]\n", file);
126 }
127
128 /* Template of LTRANS dumpbase suffix. */
129 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
130
131 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
132 environment. */
133
134 static void
get_options_from_collect_gcc_options(const char * collect_gcc,const char * collect_gcc_options,struct cl_decoded_option ** decoded_options,unsigned int * decoded_options_count)135 get_options_from_collect_gcc_options (const char *collect_gcc,
136 const char *collect_gcc_options,
137 struct cl_decoded_option **decoded_options,
138 unsigned int *decoded_options_count)
139 {
140 struct obstack argv_obstack;
141 const char **argv;
142 int argc;
143
144 obstack_init (&argv_obstack);
145 obstack_ptr_grow (&argv_obstack, collect_gcc);
146
147 parse_options_from_collect_gcc_options (collect_gcc_options,
148 &argv_obstack, &argc);
149 argv = XOBFINISH (&argv_obstack, const char **);
150
151 decode_cmdline_options_to_array (argc, (const char **)argv, CL_DRIVER,
152 decoded_options, decoded_options_count);
153 obstack_free (&argv_obstack, NULL);
154 }
155
156 /* Append OPTION to the options array DECODED_OPTIONS with size
157 DECODED_OPTIONS_COUNT. */
158
159 static void
append_option(struct cl_decoded_option ** decoded_options,unsigned int * decoded_options_count,struct cl_decoded_option * option)160 append_option (struct cl_decoded_option **decoded_options,
161 unsigned int *decoded_options_count,
162 struct cl_decoded_option *option)
163 {
164 ++*decoded_options_count;
165 *decoded_options
166 = (struct cl_decoded_option *)
167 xrealloc (*decoded_options,
168 (*decoded_options_count
169 * sizeof (struct cl_decoded_option)));
170 memcpy (&(*decoded_options)[*decoded_options_count - 1], option,
171 sizeof (struct cl_decoded_option));
172 }
173
174 /* Remove option number INDEX from DECODED_OPTIONS, update
175 DECODED_OPTIONS_COUNT. */
176
177 static void
remove_option(struct cl_decoded_option ** decoded_options,int index,unsigned int * decoded_options_count)178 remove_option (struct cl_decoded_option **decoded_options,
179 int index, unsigned int *decoded_options_count)
180 {
181 --*decoded_options_count;
182 memmove (&(*decoded_options)[index + 1],
183 &(*decoded_options)[index],
184 sizeof (struct cl_decoded_option)
185 * (*decoded_options_count - index));
186 }
187
188 /* Try to merge and complain about options FDECODED_OPTIONS when applied
189 ontop of DECODED_OPTIONS. */
190
191 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)192 merge_and_complain (struct cl_decoded_option **decoded_options,
193 unsigned int *decoded_options_count,
194 struct cl_decoded_option *fdecoded_options,
195 unsigned int fdecoded_options_count)
196 {
197 unsigned int i, j;
198 struct cl_decoded_option *pic_option = NULL;
199 struct cl_decoded_option *pie_option = NULL;
200
201 /* ??? Merge options from files. Most cases can be
202 handled by either unioning or intersecting
203 (for example -fwrapv is a case for unioning,
204 -ffast-math is for intersection). Most complaints
205 about real conflicts between different options can
206 be deferred to the compiler proper. Options that
207 we can neither safely handle by intersection nor
208 unioning would need to be complained about here.
209 Ideally we'd have a flag in the opt files that
210 tells whether to union or intersect or reject.
211 In absence of that it's unclear what a good default is.
212 It's also difficult to get positional handling correct. */
213
214 /* The following does what the old LTO option code did,
215 union all target and a selected set of common options. */
216 for (i = 0; i < fdecoded_options_count; ++i)
217 {
218 struct cl_decoded_option *foption = &fdecoded_options[i];
219 switch (foption->opt_index)
220 {
221 case OPT_SPECIAL_unknown:
222 case OPT_SPECIAL_ignore:
223 case OPT_SPECIAL_warn_removed:
224 case OPT_SPECIAL_program_name:
225 case OPT_SPECIAL_input_file:
226 break;
227
228 default:
229 if (!(cl_options[foption->opt_index].flags & CL_TARGET))
230 break;
231
232 /* Fallthru. */
233 case OPT_fdiagnostics_show_caret:
234 case OPT_fdiagnostics_show_labels:
235 case OPT_fdiagnostics_show_line_numbers:
236 case OPT_fdiagnostics_show_option:
237 case OPT_fdiagnostics_show_location_:
238 case OPT_fshow_column:
239 case OPT_fcommon:
240 case OPT_fgnu_tm:
241 case OPT_g:
242 /* Do what the old LTO code did - collect exactly one option
243 setting per OPT code, we pick the first we encounter.
244 ??? This doesn't make too much sense, but when it doesn't
245 then we should complain. */
246 for (j = 0; j < *decoded_options_count; ++j)
247 if ((*decoded_options)[j].opt_index == foption->opt_index)
248 break;
249 if (j == *decoded_options_count)
250 append_option (decoded_options, decoded_options_count, foption);
251 break;
252
253 /* Figure out what PIC/PIE level wins and merge the results. */
254 case OPT_fPIC:
255 case OPT_fpic:
256 pic_option = foption;
257 break;
258 case OPT_fPIE:
259 case OPT_fpie:
260 pie_option = foption;
261 break;
262
263 case OPT_fopenmp:
264 case OPT_fopenacc:
265 /* For selected options we can merge conservatively. */
266 for (j = 0; j < *decoded_options_count; ++j)
267 if ((*decoded_options)[j].opt_index == foption->opt_index)
268 break;
269 if (j == *decoded_options_count)
270 append_option (decoded_options, decoded_options_count, foption);
271 /* -fopenmp > -fno-openmp,
272 -fopenacc > -fno-openacc */
273 else if (foption->value > (*decoded_options)[j].value)
274 (*decoded_options)[j] = *foption;
275 break;
276
277 case OPT_fopenacc_dim_:
278 /* Append or check identical. */
279 for (j = 0; j < *decoded_options_count; ++j)
280 if ((*decoded_options)[j].opt_index == foption->opt_index)
281 break;
282 if (j == *decoded_options_count)
283 append_option (decoded_options, decoded_options_count, foption);
284 else if (strcmp ((*decoded_options)[j].arg, foption->arg))
285 fatal_error (input_location,
286 "option %s with different values",
287 foption->orig_option_with_args_text);
288 break;
289
290 case OPT_O:
291 case OPT_Ofast:
292 case OPT_Og:
293 case OPT_Os:
294 for (j = 0; j < *decoded_options_count; ++j)
295 if ((*decoded_options)[j].opt_index == OPT_O
296 || (*decoded_options)[j].opt_index == OPT_Ofast
297 || (*decoded_options)[j].opt_index == OPT_Og
298 || (*decoded_options)[j].opt_index == OPT_Os)
299 break;
300 if (j == *decoded_options_count)
301 append_option (decoded_options, decoded_options_count, foption);
302 else if ((*decoded_options)[j].opt_index == foption->opt_index
303 && foption->opt_index != OPT_O)
304 /* Exact same options get merged. */
305 ;
306 else
307 {
308 /* For mismatched option kinds preserve the optimization
309 level only, thus merge it as -On. This also handles
310 merging of same optimization level -On. */
311 int level = 0;
312 switch (foption->opt_index)
313 {
314 case OPT_O:
315 if (foption->arg[0] == '\0')
316 level = MAX (level, 1);
317 else
318 level = MAX (level, atoi (foption->arg));
319 break;
320 case OPT_Ofast:
321 level = MAX (level, 3);
322 break;
323 case OPT_Og:
324 level = MAX (level, 1);
325 break;
326 case OPT_Os:
327 level = MAX (level, 2);
328 break;
329 default:
330 gcc_unreachable ();
331 }
332 switch ((*decoded_options)[j].opt_index)
333 {
334 case OPT_O:
335 if ((*decoded_options)[j].arg[0] == '\0')
336 level = MAX (level, 1);
337 else
338 level = MAX (level, atoi ((*decoded_options)[j].arg));
339 break;
340 case OPT_Ofast:
341 level = MAX (level, 3);
342 break;
343 case OPT_Og:
344 level = MAX (level, 1);
345 break;
346 case OPT_Os:
347 level = MAX (level, 2);
348 break;
349 default:
350 gcc_unreachable ();
351 }
352 (*decoded_options)[j].opt_index = OPT_O;
353 char *tem;
354 tem = xasprintf ("-O%d", level);
355 (*decoded_options)[j].arg = &tem[2];
356 (*decoded_options)[j].canonical_option[0] = tem;
357 (*decoded_options)[j].value = 1;
358 }
359 break;
360
361
362 case OPT_foffload_abi_:
363 for (j = 0; j < *decoded_options_count; ++j)
364 if ((*decoded_options)[j].opt_index == foption->opt_index)
365 break;
366 if (j == *decoded_options_count)
367 append_option (decoded_options, decoded_options_count, foption);
368 else if (foption->value != (*decoded_options)[j].value)
369 fatal_error (input_location,
370 "option %s not used consistently in all LTO input"
371 " files", foption->orig_option_with_args_text);
372 break;
373
374
375 case OPT_foffload_:
376 append_option (decoded_options, decoded_options_count, foption);
377 break;
378 }
379 }
380
381 /* Merge PIC options:
382 -fPIC + -fpic = -fpic
383 -fPIC + -fno-pic = -fno-pic
384 -fpic/-fPIC + nothing = nothing.
385 It is a common mistake to mix few -fPIC compiled objects into otherwise
386 non-PIC code. We do not want to build everything with PIC then.
387
388 Similarly we merge PIE options, however in addition we keep
389 -fPIC + -fPIE = -fPIE
390 -fpic + -fPIE = -fpie
391 -fPIC/-fpic + -fpie = -fpie
392
393 It would be good to warn on mismatches, but it is bit hard to do as
394 we do not know what nothing translates to. */
395
396 for (unsigned int j = 0; j < *decoded_options_count;)
397 if ((*decoded_options)[j].opt_index == OPT_fPIC
398 || (*decoded_options)[j].opt_index == OPT_fpic)
399 {
400 /* -fno-pic in one unit implies -fno-pic everywhere. */
401 if ((*decoded_options)[j].value == 0)
402 j++;
403 /* If we have no pic option or merge in -fno-pic, we still may turn
404 existing pic/PIC mode into pie/PIE if -fpie/-fPIE is present. */
405 else if ((pic_option && pic_option->value == 0)
406 || !pic_option)
407 {
408 if (pie_option)
409 {
410 bool big = (*decoded_options)[j].opt_index == OPT_fPIC
411 && pie_option->opt_index == OPT_fPIE;
412 (*decoded_options)[j].opt_index = big ? OPT_fPIE : OPT_fpie;
413 if (pie_option->value)
414 (*decoded_options)[j].canonical_option[0]
415 = big ? "-fPIE" : "-fpie";
416 else
417 (*decoded_options)[j].canonical_option[0] = "-fno-pie";
418 (*decoded_options)[j].value = pie_option->value;
419 j++;
420 }
421 else if (pic_option)
422 {
423 (*decoded_options)[j] = *pic_option;
424 j++;
425 }
426 /* We do not know if target defaults to pic or not, so just remove
427 option if it is missing in one unit but enabled in other. */
428 else
429 remove_option (decoded_options, j, decoded_options_count);
430 }
431 else if (pic_option->opt_index == OPT_fpic
432 && (*decoded_options)[j].opt_index == OPT_fPIC)
433 {
434 (*decoded_options)[j] = *pic_option;
435 j++;
436 }
437 else
438 j++;
439 }
440 else if ((*decoded_options)[j].opt_index == OPT_fPIE
441 || (*decoded_options)[j].opt_index == OPT_fpie)
442 {
443 /* -fno-pie in one unit implies -fno-pie everywhere. */
444 if ((*decoded_options)[j].value == 0)
445 j++;
446 /* If we have no pie option or merge in -fno-pie, we still preserve
447 PIE/pie if pic/PIC is present. */
448 else if ((pie_option && pie_option->value == 0)
449 || !pie_option)
450 {
451 /* If -fPIC/-fpic is given, merge it with -fPIE/-fpie. */
452 if (pic_option)
453 {
454 if (pic_option->opt_index == OPT_fpic
455 && (*decoded_options)[j].opt_index == OPT_fPIE)
456 {
457 (*decoded_options)[j].opt_index = OPT_fpie;
458 (*decoded_options)[j].canonical_option[0]
459 = pic_option->value ? "-fpie" : "-fno-pie";
460 }
461 else if (!pic_option->value)
462 (*decoded_options)[j].canonical_option[0] = "-fno-pie";
463 (*decoded_options)[j].value = pic_option->value;
464 j++;
465 }
466 else if (pie_option)
467 {
468 (*decoded_options)[j] = *pie_option;
469 j++;
470 }
471 /* Because we always append pic/PIE options this code path should
472 not happen unless the LTO object was built by old lto1 which
473 did not contain that logic yet. */
474 else
475 remove_option (decoded_options, j, decoded_options_count);
476 }
477 else if (pie_option->opt_index == OPT_fpie
478 && (*decoded_options)[j].opt_index == OPT_fPIE)
479 {
480 (*decoded_options)[j] = *pie_option;
481 j++;
482 }
483 else
484 j++;
485 }
486 else
487 j++;
488
489 if (!xassembler_options_error)
490 for (i = j = 0; ; i++, j++)
491 {
492 for (; i < *decoded_options_count; i++)
493 if ((*decoded_options)[i].opt_index == OPT_Xassembler)
494 break;
495
496 for (; j < fdecoded_options_count; j++)
497 if (fdecoded_options[j].opt_index == OPT_Xassembler)
498 break;
499
500 if (i == *decoded_options_count && j == fdecoded_options_count)
501 break;
502 else if (i < *decoded_options_count && j == fdecoded_options_count)
503 {
504 warning (0, "Extra option to -Xassembler: %s,"
505 " dropping all -Xassembler and -Wa options.",
506 (*decoded_options)[i].arg);
507 xassembler_options_error = true;
508 break;
509 }
510 else if (i == *decoded_options_count && j < fdecoded_options_count)
511 {
512 warning (0, "Extra option to -Xassembler: %s,"
513 " dropping all -Xassembler and -Wa options.",
514 fdecoded_options[j].arg);
515 xassembler_options_error = true;
516 break;
517 }
518 else if (strcmp ((*decoded_options)[i].arg, fdecoded_options[j].arg))
519 {
520 warning (0, "Options to Xassembler do not match: %s, %s,"
521 " dropping all -Xassembler and -Wa options.",
522 (*decoded_options)[i].arg, fdecoded_options[j].arg);
523 xassembler_options_error = true;
524 break;
525 }
526 }
527 }
528
529 /* Auxiliary function that frees elements of PTR and PTR itself.
530 N is number of elements to be freed. If PTR is NULL, nothing is freed.
531 If an element is NULL, subsequent elements are not freed. */
532
533 static void **
free_array_of_ptrs(void ** ptr,unsigned n)534 free_array_of_ptrs (void **ptr, unsigned n)
535 {
536 if (!ptr)
537 return NULL;
538 for (unsigned i = 0; i < n; i++)
539 {
540 if (!ptr[i])
541 break;
542 free (ptr[i]);
543 }
544 free (ptr);
545 return NULL;
546 }
547
548 /* Parse STR, saving found tokens into PVALUES and return their number.
549 Tokens are assumed to be delimited by ':'. If APPEND is non-null,
550 append it to every token we find. */
551
552 static unsigned
parse_env_var(const char * str,char *** pvalues,const char * append)553 parse_env_var (const char *str, char ***pvalues, const char *append)
554 {
555 const char *curval, *nextval;
556 char **values;
557 unsigned num = 1, i;
558
559 curval = strchr (str, ':');
560 while (curval)
561 {
562 num++;
563 curval = strchr (curval + 1, ':');
564 }
565
566 values = (char**) xmalloc (num * sizeof (char*));
567 curval = str;
568 nextval = strchr (curval, ':');
569 if (nextval == NULL)
570 nextval = strchr (curval, '\0');
571
572 int append_len = append ? strlen (append) : 0;
573 for (i = 0; i < num; i++)
574 {
575 int l = nextval - curval;
576 values[i] = (char*) xmalloc (l + 1 + append_len);
577 memcpy (values[i], curval, l);
578 values[i][l] = 0;
579 if (append)
580 strcat (values[i], append);
581 curval = nextval + 1;
582 nextval = strchr (curval, ':');
583 if (nextval == NULL)
584 nextval = strchr (curval, '\0');
585 }
586 *pvalues = values;
587 return num;
588 }
589
590 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK. */
591
592 static void
append_compiler_options(obstack * argv_obstack,struct cl_decoded_option * opts,unsigned int count)593 append_compiler_options (obstack *argv_obstack, struct cl_decoded_option *opts,
594 unsigned int count)
595 {
596 /* Append compiler driver arguments as far as they were merged. */
597 for (unsigned int j = 1; j < count; ++j)
598 {
599 struct cl_decoded_option *option = &opts[j];
600
601 /* File options have been properly filtered by lto-opts.c. */
602 switch (option->opt_index)
603 {
604 /* Drop arguments that we want to take from the link line. */
605 case OPT_flto_:
606 case OPT_flto:
607 case OPT_flto_partition_:
608 continue;
609
610 default:
611 break;
612 }
613
614 /* For now do what the original LTO option code was doing - pass
615 on any CL_TARGET flag and a few selected others. */
616 switch (option->opt_index)
617 {
618 case OPT_fdiagnostics_show_caret:
619 case OPT_fdiagnostics_show_labels:
620 case OPT_fdiagnostics_show_line_numbers:
621 case OPT_fdiagnostics_show_option:
622 case OPT_fdiagnostics_show_location_:
623 case OPT_fshow_column:
624 case OPT_fPIC:
625 case OPT_fpic:
626 case OPT_fPIE:
627 case OPT_fpie:
628 case OPT_fcommon:
629 case OPT_fgnu_tm:
630 case OPT_fopenmp:
631 case OPT_fopenacc:
632 case OPT_fopenacc_dim_:
633 case OPT_foffload_abi_:
634 case OPT_g:
635 case OPT_O:
636 case OPT_Ofast:
637 case OPT_Og:
638 case OPT_Os:
639 break;
640
641 case OPT_Xassembler:
642 /* When we detected a mismatch in assembler options between
643 the input TU's fall back to previous behavior of ignoring them. */
644 if (xassembler_options_error)
645 continue;
646 break;
647
648 default:
649 if (!(cl_options[option->opt_index].flags & CL_TARGET))
650 continue;
651 }
652
653 /* Pass the option on. */
654 for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
655 obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
656 }
657 }
658
659 /* Append diag options in OPTS with length COUNT to ARGV_OBSTACK. */
660
661 static void
append_diag_options(obstack * argv_obstack,struct cl_decoded_option * opts,unsigned int count)662 append_diag_options (obstack *argv_obstack, struct cl_decoded_option *opts,
663 unsigned int count)
664 {
665 /* Append compiler driver arguments as far as they were merged. */
666 for (unsigned int j = 1; j < count; ++j)
667 {
668 struct cl_decoded_option *option = &opts[j];
669
670 switch (option->opt_index)
671 {
672 case OPT_fdiagnostics_color_:
673 case OPT_fdiagnostics_format_:
674 case OPT_fdiagnostics_show_caret:
675 case OPT_fdiagnostics_show_labels:
676 case OPT_fdiagnostics_show_line_numbers:
677 case OPT_fdiagnostics_show_option:
678 case OPT_fdiagnostics_show_location_:
679 case OPT_fshow_column:
680 break;
681 default:
682 continue;
683 }
684
685 /* Pass the option on. */
686 for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
687 obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
688 }
689 }
690
691
692 /* Append linker options OPTS to ARGV_OBSTACK. */
693
694 static void
append_linker_options(obstack * argv_obstack,struct cl_decoded_option * opts,unsigned int count)695 append_linker_options (obstack *argv_obstack, struct cl_decoded_option *opts,
696 unsigned int count)
697 {
698 /* Append linker driver arguments. Compiler options from the linker
699 driver arguments will override / merge with those from the compiler. */
700 for (unsigned int j = 1; j < count; ++j)
701 {
702 struct cl_decoded_option *option = &opts[j];
703
704 /* Do not pass on frontend specific flags not suitable for lto. */
705 if (!(cl_options[option->opt_index].flags
706 & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO)))
707 continue;
708
709 switch (option->opt_index)
710 {
711 case OPT_o:
712 case OPT_flto_:
713 case OPT_flto:
714 /* We've handled these LTO options, do not pass them on. */
715 continue;
716
717 case OPT_fopenmp:
718 case OPT_fopenacc:
719 /* Ignore -fno-XXX form of these options, as otherwise
720 corresponding builtins will not be enabled. */
721 if (option->value == 0)
722 continue;
723 break;
724
725 default:
726 break;
727 }
728
729 /* Pass the option on. */
730 for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
731 obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
732 }
733 }
734
735 /* Extract options for TARGET offload compiler from OPTIONS and append
736 them to ARGV_OBSTACK. */
737
738 static void
append_offload_options(obstack * argv_obstack,const char * target,struct cl_decoded_option * options,unsigned int options_count)739 append_offload_options (obstack *argv_obstack, const char *target,
740 struct cl_decoded_option *options,
741 unsigned int options_count)
742 {
743 for (unsigned i = 0; i < options_count; i++)
744 {
745 const char *cur, *next, *opts;
746 char **argv;
747 unsigned argc;
748 struct cl_decoded_option *option = &options[i];
749
750 if (option->opt_index != OPT_foffload_)
751 continue;
752
753 /* If option argument starts with '-' then no target is specified. That
754 means offload options are specified for all targets, so we need to
755 append them. */
756 if (option->arg[0] == '-')
757 opts = option->arg;
758 else
759 {
760 opts = strchr (option->arg, '=');
761 /* If there are offload targets specified, but no actual options,
762 there is nothing to do here. */
763 if (!opts)
764 continue;
765
766 cur = option->arg;
767
768 while (cur < opts)
769 {
770 next = strchr (cur, ',');
771 if (next == NULL)
772 next = opts;
773 next = (next > opts) ? opts : next;
774
775 /* Are we looking for this offload target? */
776 if (strlen (target) == (size_t) (next - cur)
777 && strncmp (target, cur, next - cur) == 0)
778 break;
779
780 /* Skip the comma or equal sign. */
781 cur = next + 1;
782 }
783
784 if (cur >= opts)
785 continue;
786
787 opts++;
788 }
789
790 argv = buildargv (opts);
791 for (argc = 0; argv[argc]; argc++)
792 obstack_ptr_grow (argv_obstack, argv[argc]);
793 }
794 }
795
796 /* Check whether NAME can be accessed in MODE. This is like access,
797 except that it never considers directories to be executable. */
798
799 static int
access_check(const char * name,int mode)800 access_check (const char *name, int mode)
801 {
802 if (mode == X_OK)
803 {
804 struct stat st;
805
806 if (stat (name, &st) < 0
807 || S_ISDIR (st.st_mode))
808 return -1;
809 }
810
811 return access (name, mode);
812 }
813
814 /* Prepare a target image for offload TARGET, using mkoffload tool from
815 COMPILER_PATH. Return the name of the resultant object file. */
816
817 static char *
compile_offload_image(const char * target,const char * compiler_path,unsigned in_argc,char * in_argv[],struct cl_decoded_option * compiler_opts,unsigned int compiler_opt_count,struct cl_decoded_option * linker_opts,unsigned int linker_opt_count)818 compile_offload_image (const char *target, const char *compiler_path,
819 unsigned in_argc, char *in_argv[],
820 struct cl_decoded_option *compiler_opts,
821 unsigned int compiler_opt_count,
822 struct cl_decoded_option *linker_opts,
823 unsigned int linker_opt_count)
824 {
825 char *filename = NULL;
826 char **argv;
827 char *suffix
828 = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target));
829 strcpy (suffix, "/accel/");
830 strcat (suffix, target);
831 strcat (suffix, "/mkoffload");
832
833 char **paths = NULL;
834 unsigned n_paths = parse_env_var (compiler_path, &paths, suffix);
835
836 const char *compiler = NULL;
837 for (unsigned i = 0; i < n_paths; i++)
838 if (access_check (paths[i], X_OK) == 0)
839 {
840 compiler = paths[i];
841 break;
842 }
843
844 if (!compiler)
845 fatal_error (input_location,
846 "could not find %s in %s (consider using %<-B%>)",
847 suffix + 1, compiler_path);
848
849 /* Generate temporary output file name. */
850 filename = make_temp_file (".target.o");
851
852 struct obstack argv_obstack;
853 obstack_init (&argv_obstack);
854 obstack_ptr_grow (&argv_obstack, compiler);
855 if (save_temps)
856 obstack_ptr_grow (&argv_obstack, "-save-temps");
857 if (verbose)
858 obstack_ptr_grow (&argv_obstack, "-v");
859 obstack_ptr_grow (&argv_obstack, "-o");
860 obstack_ptr_grow (&argv_obstack, filename);
861
862 /* Append names of input object files. */
863 for (unsigned i = 0; i < in_argc; i++)
864 obstack_ptr_grow (&argv_obstack, in_argv[i]);
865
866 /* Append options from offload_lto sections. */
867 append_compiler_options (&argv_obstack, compiler_opts,
868 compiler_opt_count);
869 append_diag_options (&argv_obstack, linker_opts, linker_opt_count);
870
871 /* Append options specified by -foffload last. In case of conflicting
872 options we expect offload compiler to choose the latest. */
873 append_offload_options (&argv_obstack, target, compiler_opts,
874 compiler_opt_count);
875 append_offload_options (&argv_obstack, target, linker_opts,
876 linker_opt_count);
877
878 obstack_ptr_grow (&argv_obstack, NULL);
879 argv = XOBFINISH (&argv_obstack, char **);
880 fork_execute (argv[0], argv, true);
881 obstack_free (&argv_obstack, NULL);
882
883 free_array_of_ptrs ((void **) paths, n_paths);
884 return filename;
885 }
886
887
888 /* The main routine dealing with offloading.
889 The routine builds a target image for each offload target. IN_ARGC and
890 IN_ARGV specify options and input object files. As all of them could contain
891 target sections, we pass them all to target compilers. */
892
893 static void
compile_images_for_offload_targets(unsigned in_argc,char * in_argv[],struct cl_decoded_option * compiler_opts,unsigned int compiler_opt_count,struct cl_decoded_option * linker_opts,unsigned int linker_opt_count)894 compile_images_for_offload_targets (unsigned in_argc, char *in_argv[],
895 struct cl_decoded_option *compiler_opts,
896 unsigned int compiler_opt_count,
897 struct cl_decoded_option *linker_opts,
898 unsigned int linker_opt_count)
899 {
900 char **names = NULL;
901 const char *target_names = getenv (OFFLOAD_TARGET_NAMES_ENV);
902 if (!target_names)
903 return;
904 unsigned num_targets = parse_env_var (target_names, &names, NULL);
905
906 int next_name_entry = 0;
907 const char *compiler_path = getenv ("COMPILER_PATH");
908 if (!compiler_path)
909 goto out;
910
911 /* Prepare an image for each target and save the name of the resultant object
912 file to the OFFLOAD_NAMES array. It is terminated by a NULL entry. */
913 offload_names = XCNEWVEC (char *, num_targets + 1);
914 for (unsigned i = 0; i < num_targets; i++)
915 {
916 /* HSA does not use LTO-like streaming and a different compiler, skip
917 it. */
918 if (strcmp (names[i], "hsa") == 0)
919 continue;
920
921 offload_names[next_name_entry]
922 = compile_offload_image (names[i], compiler_path, in_argc, in_argv,
923 compiler_opts, compiler_opt_count,
924 linker_opts, linker_opt_count);
925 if (!offload_names[next_name_entry])
926 fatal_error (input_location,
927 "problem with building target image for %s", names[i]);
928 next_name_entry++;
929 }
930
931 out:
932 free_array_of_ptrs ((void **) names, num_targets);
933 }
934
935 /* Copy a file from SRC to DEST. */
936
937 static void
copy_file(const char * dest,const char * src)938 copy_file (const char *dest, const char *src)
939 {
940 FILE *d = fopen (dest, "wb");
941 FILE *s = fopen (src, "rb");
942 char buffer[512];
943 while (!feof (s))
944 {
945 size_t len = fread (buffer, 1, 512, s);
946 if (ferror (s) != 0)
947 fatal_error (input_location, "reading input file");
948 if (len > 0)
949 {
950 fwrite (buffer, 1, len, d);
951 if (ferror (d) != 0)
952 fatal_error (input_location, "writing output file");
953 }
954 }
955 fclose (d);
956 fclose (s);
957 }
958
959 /* Find the crtoffloadtable.o file in LIBRARY_PATH, make copy and pass name of
960 the copy to the linker. */
961
962 static void
find_crtoffloadtable(void)963 find_crtoffloadtable (void)
964 {
965 char **paths = NULL;
966 const char *library_path = getenv ("LIBRARY_PATH");
967 if (!library_path)
968 return;
969 unsigned n_paths = parse_env_var (library_path, &paths, "/crtoffloadtable.o");
970
971 unsigned i;
972 for (i = 0; i < n_paths; i++)
973 if (access_check (paths[i], R_OK) == 0)
974 {
975 /* The linker will delete the filename we give it, so make a copy. */
976 char *crtoffloadtable = make_temp_file (".crtoffloadtable.o");
977 copy_file (crtoffloadtable, paths[i]);
978 printf ("%s\n", crtoffloadtable);
979 XDELETEVEC (crtoffloadtable);
980 break;
981 }
982 if (i == n_paths)
983 fatal_error (input_location,
984 "installation error, cannot find %<crtoffloadtable.o%>");
985
986 free_array_of_ptrs ((void **) paths, n_paths);
987 }
988
989 /* A subroutine of run_gcc. Examine the open file FD for lto sections with
990 name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
991 and OPT_COUNT. Return true if we found a matchingn section, false
992 otherwise. COLLECT_GCC holds the value of the environment variable with
993 the same name. */
994
995 static bool
find_and_merge_options(int fd,off_t file_offset,const char * prefix,struct cl_decoded_option ** opts,unsigned int * opt_count,const char * collect_gcc)996 find_and_merge_options (int fd, off_t file_offset, const char *prefix,
997 struct cl_decoded_option **opts,
998 unsigned int *opt_count, const char *collect_gcc)
999 {
1000 off_t offset, length;
1001 char *data;
1002 char *fopts;
1003 const char *errmsg;
1004 int err;
1005 struct cl_decoded_option *fdecoded_options = *opts;
1006 unsigned int fdecoded_options_count = *opt_count;
1007
1008 simple_object_read *sobj;
1009 sobj = simple_object_start_read (fd, file_offset, "__GNU_LTO",
1010 &errmsg, &err);
1011 if (!sobj)
1012 return false;
1013
1014 char *secname = XALLOCAVEC (char, strlen (prefix) + sizeof (".opts"));
1015 strcpy (secname, prefix);
1016 strcat (secname, ".opts");
1017 if (!simple_object_find_section (sobj, secname, &offset, &length,
1018 &errmsg, &err))
1019 {
1020 simple_object_release_read (sobj);
1021 return false;
1022 }
1023
1024 lseek (fd, file_offset + offset, SEEK_SET);
1025 data = (char *)xmalloc (length);
1026 read (fd, data, length);
1027 fopts = data;
1028 do
1029 {
1030 struct cl_decoded_option *f2decoded_options;
1031 unsigned int f2decoded_options_count;
1032 get_options_from_collect_gcc_options (collect_gcc, fopts,
1033 &f2decoded_options,
1034 &f2decoded_options_count);
1035 if (!fdecoded_options)
1036 {
1037 fdecoded_options = f2decoded_options;
1038 fdecoded_options_count = f2decoded_options_count;
1039 }
1040 else
1041 merge_and_complain (&fdecoded_options,
1042 &fdecoded_options_count,
1043 f2decoded_options, f2decoded_options_count);
1044
1045 fopts += strlen (fopts) + 1;
1046 }
1047 while (fopts - data < length);
1048
1049 free (data);
1050 simple_object_release_read (sobj);
1051 *opts = fdecoded_options;
1052 *opt_count = fdecoded_options_count;
1053 return true;
1054 }
1055
1056 /* Copy early debug info sections from INFILE to a new file whose name
1057 is returned. Return NULL on error. */
1058
1059 const char *
debug_objcopy(const char * infile,bool rename)1060 debug_objcopy (const char *infile, bool rename)
1061 {
1062 char *outfile;
1063 const char *errmsg;
1064 int err;
1065
1066 const char *p;
1067 const char *orig_infile = infile;
1068 off_t inoff = 0;
1069 long loffset;
1070 int consumed;
1071 if ((p = strrchr (infile, '@'))
1072 && p != infile
1073 && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
1074 && strlen (p) == (unsigned int) consumed)
1075 {
1076 char *fname = xstrdup (infile);
1077 fname[p - infile] = '\0';
1078 infile = fname;
1079 inoff = (off_t) loffset;
1080 }
1081 int infd = open (infile, O_RDONLY | O_BINARY);
1082 if (infd == -1)
1083 return NULL;
1084 simple_object_read *inobj = simple_object_start_read (infd, inoff,
1085 "__GNU_LTO",
1086 &errmsg, &err);
1087 if (!inobj)
1088 return NULL;
1089
1090 off_t off, len;
1091 if (simple_object_find_section (inobj, ".gnu.debuglto_.debug_info",
1092 &off, &len, &errmsg, &err) != 1)
1093 {
1094 if (errmsg)
1095 fatal_error (0, "%s: %s", errmsg, xstrerror (err));
1096
1097 simple_object_release_read (inobj);
1098 close (infd);
1099 return NULL;
1100 }
1101
1102 if (save_temps)
1103 {
1104 outfile = (char *) xmalloc (strlen (orig_infile)
1105 + sizeof (".debug.temp.o") + 1);
1106 strcpy (outfile, orig_infile);
1107 strcat (outfile, ".debug.temp.o");
1108 }
1109 else
1110 outfile = make_temp_file (".debug.temp.o");
1111 errmsg = simple_object_copy_lto_debug_sections (inobj, outfile, &err, rename);
1112 if (errmsg)
1113 {
1114 unlink_if_ordinary (outfile);
1115 fatal_error (0, "%s: %s", errmsg, xstrerror (err));
1116 }
1117
1118 simple_object_release_read (inobj);
1119 close (infd);
1120
1121 return outfile;
1122 }
1123
1124 /* Helper for qsort: compare priorities for parallel compilation. */
1125
1126 int
cmp_priority(const void * a,const void * b)1127 cmp_priority (const void *a, const void *b)
1128 {
1129 return *((const int *)b)-*((const int *)a);
1130 }
1131
1132 /* Number of CPUs that can be used for parallel LTRANS phase. */
1133
1134 static unsigned long nthreads_var = 0;
1135
1136 #ifdef HAVE_PTHREAD_AFFINITY_NP
1137 unsigned long cpuset_size;
1138 static unsigned long get_cpuset_size;
1139 cpu_set_t *cpusetp;
1140
1141 unsigned long
cpuset_popcount(unsigned long cpusetsize,cpu_set_t * cpusetp)1142 static cpuset_popcount (unsigned long cpusetsize, cpu_set_t *cpusetp)
1143 {
1144 #ifdef CPU_COUNT_S
1145 /* glibc 2.7 and above provide a macro for this. */
1146 return CPU_COUNT_S (cpusetsize, cpusetp);
1147 #else
1148 #ifdef CPU_COUNT
1149 if (cpusetsize == sizeof (cpu_set_t))
1150 /* glibc 2.6 and above provide a macro for this. */
1151 return CPU_COUNT (cpusetp);
1152 #endif
1153 size_t i;
1154 unsigned long ret = 0;
1155 STATIC_ASSERT (sizeof (cpusetp->__bits[0]) == sizeof (unsigned long int));
1156 for (i = 0; i < cpusetsize / sizeof (cpusetp->__bits[0]); i++)
1157 {
1158 unsigned long int mask = cpusetp->__bits[i];
1159 if (mask == 0)
1160 continue;
1161 ret += __builtin_popcountl (mask);
1162 }
1163 return ret;
1164 #endif
1165 }
1166 #endif
1167
1168 /* At startup, determine the default number of threads. It would seem
1169 this should be related to the number of cpus online. */
1170
1171 static void
init_num_threads(void)1172 init_num_threads (void)
1173 {
1174 #ifdef HAVE_PTHREAD_AFFINITY_NP
1175 #if defined (_SC_NPROCESSORS_CONF) && defined (CPU_ALLOC_SIZE)
1176 cpuset_size = sysconf (_SC_NPROCESSORS_CONF);
1177 cpuset_size = CPU_ALLOC_SIZE (cpuset_size);
1178 #else
1179 cpuset_size = sizeof (cpu_set_t);
1180 #endif
1181
1182 cpusetp = (cpu_set_t *) xmalloc (gomp_cpuset_size);
1183 do
1184 {
1185 int ret = pthread_getaffinity_np (pthread_self (), gomp_cpuset_size,
1186 cpusetp);
1187 if (ret == 0)
1188 {
1189 /* Count only the CPUs this process can use. */
1190 nthreads_var = cpuset_popcount (cpuset_size, cpusetp);
1191 if (nthreads_var == 0)
1192 break;
1193 get_cpuset_size = cpuset_size;
1194 #ifdef CPU_ALLOC_SIZE
1195 unsigned long i;
1196 for (i = cpuset_size * 8; i; i--)
1197 if (CPU_ISSET_S (i - 1, cpuset_size, cpusetp))
1198 break;
1199 cpuset_size = CPU_ALLOC_SIZE (i);
1200 #endif
1201 return;
1202 }
1203 if (ret != EINVAL)
1204 break;
1205 #ifdef CPU_ALLOC_SIZE
1206 if (cpuset_size < sizeof (cpu_set_t))
1207 cpuset_size = sizeof (cpu_set_t);
1208 else
1209 cpuset_size = cpuset_size * 2;
1210 if (cpuset_size < 8 * sizeof (cpu_set_t))
1211 cpusetp
1212 = (cpu_set_t *) realloc (cpusetp, cpuset_size);
1213 else
1214 {
1215 /* Avoid fatal if too large memory allocation would be
1216 requested, e.g. kernel returning EINVAL all the time. */
1217 void *p = realloc (cpusetp, cpuset_size);
1218 if (p == NULL)
1219 break;
1220 cpusetp = (cpu_set_t *) p;
1221 }
1222 #else
1223 break;
1224 #endif
1225 }
1226 while (1);
1227 cpuset_size = 0;
1228 nthreads_var = 1;
1229 free (cpusetp);
1230 cpusetp = NULL;
1231 #endif
1232 #ifdef _SC_NPROCESSORS_ONLN
1233 nthreads_var = sysconf (_SC_NPROCESSORS_ONLN);
1234 #endif
1235 }
1236
1237 /* FIXME: once using -std=c++11, we can use std::thread::hardware_concurrency. */
1238
1239 /* Return true when a jobserver is running and can accept a job. */
1240
1241 static bool
jobserver_active_p(void)1242 jobserver_active_p (void)
1243 {
1244 const char *makeflags = getenv ("MAKEFLAGS");
1245 if (makeflags == NULL)
1246 return false;
1247
1248 const char *needle = "--jobserver-auth=";
1249 const char *n = strstr (makeflags, needle);
1250 if (n == NULL)
1251 return false;
1252
1253 int rfd = -1;
1254 int wfd = -1;
1255
1256 return (sscanf (n + strlen (needle), "%d,%d", &rfd, &wfd) == 2
1257 && rfd > 0
1258 && wfd > 0
1259 && is_valid_fd (rfd)
1260 && is_valid_fd (wfd));
1261 }
1262
1263 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
1264
1265 static void
run_gcc(unsigned argc,char * argv[])1266 run_gcc (unsigned argc, char *argv[])
1267 {
1268 unsigned i, j;
1269 const char **new_argv;
1270 const char **argv_ptr;
1271 char *list_option_full = NULL;
1272 const char *linker_output = NULL;
1273 const char *collect_gcc;
1274 char *collect_gcc_options;
1275 int parallel = 0;
1276 int jobserver = 0;
1277 int auto_parallel = 0;
1278 bool no_partition = false;
1279 struct cl_decoded_option *fdecoded_options = NULL;
1280 struct cl_decoded_option *offload_fdecoded_options = NULL;
1281 unsigned int fdecoded_options_count = 0;
1282 unsigned int offload_fdecoded_options_count = 0;
1283 struct cl_decoded_option *decoded_options;
1284 unsigned int decoded_options_count;
1285 struct obstack argv_obstack;
1286 int new_head_argc;
1287 bool have_lto = false;
1288 bool have_offload = false;
1289 unsigned lto_argc = 0, ltoobj_argc = 0;
1290 char **lto_argv, **ltoobj_argv;
1291 bool linker_output_rel = false;
1292 bool skip_debug = false;
1293 unsigned n_debugobj;
1294
1295 /* Get the driver and options. */
1296 collect_gcc = getenv ("COLLECT_GCC");
1297 if (!collect_gcc)
1298 fatal_error (input_location,
1299 "environment variable %<COLLECT_GCC%> must be set");
1300 collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
1301 if (!collect_gcc_options)
1302 fatal_error (input_location,
1303 "environment variable %<COLLECT_GCC_OPTIONS%> must be set");
1304
1305 char *collect_as_options = getenv ("COLLECT_AS_OPTIONS");
1306
1307 /* Prepend -Xassembler to each option, and append the string
1308 to collect_gcc_options. */
1309 if (collect_as_options)
1310 {
1311 obstack temporary_obstack;
1312 obstack_init (&temporary_obstack);
1313
1314 prepend_xassembler_to_collect_as_options (collect_as_options,
1315 &temporary_obstack);
1316 obstack_1grow (&temporary_obstack, '\0');
1317
1318 char *xassembler_opts_string
1319 = XOBFINISH (&temporary_obstack, char *);
1320 collect_gcc_options = concat (collect_gcc_options, xassembler_opts_string,
1321 NULL);
1322 }
1323
1324 get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options,
1325 &decoded_options,
1326 &decoded_options_count);
1327
1328 /* Allocate array for input object files with LTO IL,
1329 and for possible preceding arguments. */
1330 lto_argv = XNEWVEC (char *, argc);
1331 ltoobj_argv = XNEWVEC (char *, argc);
1332
1333 /* Look at saved options in the IL files. */
1334 for (i = 1; i < argc; ++i)
1335 {
1336 char *p;
1337 int fd;
1338 off_t file_offset = 0;
1339 long loffset;
1340 int consumed;
1341 char *filename = argv[i];
1342
1343 if (strncmp (argv[i], "-foffload-objects=",
1344 sizeof ("-foffload-objects=") - 1) == 0)
1345 {
1346 have_offload = true;
1347 offload_objects_file_name
1348 = argv[i] + sizeof ("-foffload-objects=") - 1;
1349 continue;
1350 }
1351
1352 if ((p = strrchr (argv[i], '@'))
1353 && p != argv[i]
1354 && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
1355 && strlen (p) == (unsigned int) consumed)
1356 {
1357 filename = XNEWVEC (char, p - argv[i] + 1);
1358 memcpy (filename, argv[i], p - argv[i]);
1359 filename[p - argv[i]] = '\0';
1360 file_offset = (off_t) loffset;
1361 }
1362 fd = open (filename, O_RDONLY | O_BINARY);
1363 /* Linker plugin passes -fresolution and -flinker-output options.
1364 -flinker-output is passed only when user did not specify one and thus
1365 we do not need to worry about duplicities with the option handling
1366 below. */
1367 if (fd == -1)
1368 {
1369 lto_argv[lto_argc++] = argv[i];
1370 if (strcmp (argv[i], "-flinker-output=rel") == 0)
1371 linker_output_rel = true;
1372 continue;
1373 }
1374
1375 if (find_and_merge_options (fd, file_offset, LTO_SECTION_NAME_PREFIX,
1376 &fdecoded_options, &fdecoded_options_count,
1377 collect_gcc))
1378 {
1379 have_lto = true;
1380 ltoobj_argv[ltoobj_argc++] = argv[i];
1381 }
1382 close (fd);
1383 }
1384
1385 /* Initalize the common arguments for the driver. */
1386 obstack_init (&argv_obstack);
1387 obstack_ptr_grow (&argv_obstack, collect_gcc);
1388 obstack_ptr_grow (&argv_obstack, "-xlto");
1389 obstack_ptr_grow (&argv_obstack, "-c");
1390
1391 append_compiler_options (&argv_obstack, fdecoded_options,
1392 fdecoded_options_count);
1393 append_linker_options (&argv_obstack, decoded_options, decoded_options_count);
1394
1395 /* Scan linker driver arguments for things that are of relevance to us. */
1396 for (j = 1; j < decoded_options_count; ++j)
1397 {
1398 struct cl_decoded_option *option = &decoded_options[j];
1399 switch (option->opt_index)
1400 {
1401 case OPT_o:
1402 linker_output = option->arg;
1403 break;
1404
1405 case OPT_save_temps:
1406 save_temps = 1;
1407 break;
1408
1409 case OPT_v:
1410 verbose = 1;
1411 break;
1412
1413 case OPT_flto_partition_:
1414 if (strcmp (option->arg, "none") == 0)
1415 no_partition = true;
1416 break;
1417
1418 case OPT_flto_:
1419 if (strcmp (option->arg, "jobserver") == 0)
1420 {
1421 parallel = 1;
1422 jobserver = 1;
1423 }
1424 else if (strcmp (option->arg, "auto") == 0)
1425 {
1426 parallel = 1;
1427 auto_parallel = 1;
1428 }
1429 else
1430 {
1431 parallel = atoi (option->arg);
1432 if (parallel <= 1)
1433 parallel = 0;
1434 }
1435 /* Fallthru. */
1436
1437 case OPT_flto:
1438 lto_mode = LTO_MODE_WHOPR;
1439 break;
1440
1441 case OPT_flinker_output_:
1442 linker_output_rel = !strcmp (option->arg, "rel");
1443 break;
1444
1445 case OPT_g:
1446 /* Recognize -g0. */
1447 skip_debug = option->arg && !strcmp (option->arg, "0");
1448 break;
1449
1450 default:
1451 break;
1452 }
1453 }
1454
1455 /* Output lto-wrapper invocation command. */
1456 if (verbose)
1457 {
1458 for (i = 0; i < argc; ++i)
1459 {
1460 fputs (argv[i], stderr);
1461 fputc (' ', stderr);
1462 }
1463 fputc ('\n', stderr);
1464 }
1465
1466 if (linker_output_rel)
1467 no_partition = true;
1468
1469 if (no_partition)
1470 {
1471 lto_mode = LTO_MODE_LTO;
1472 jobserver = 0;
1473 auto_parallel = 0;
1474 parallel = 0;
1475 }
1476 else if (!jobserver && jobserver_active_p ())
1477 {
1478 parallel = 1;
1479 jobserver = 1;
1480 }
1481
1482 if (linker_output)
1483 {
1484 char *output_dir, *base, *name;
1485 bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0;
1486
1487 output_dir = xstrdup (linker_output);
1488 base = output_dir;
1489 for (name = base; *name; name++)
1490 if (IS_DIR_SEPARATOR (*name))
1491 base = name + 1;
1492 *base = '\0';
1493
1494 linker_output = &linker_output[base - output_dir];
1495 if (*output_dir == '\0')
1496 {
1497 static char current_dir[] = { '.', DIR_SEPARATOR, '\0' };
1498 output_dir = current_dir;
1499 }
1500 if (!bit_bucket)
1501 {
1502 obstack_ptr_grow (&argv_obstack, "-dumpdir");
1503 obstack_ptr_grow (&argv_obstack, output_dir);
1504 }
1505
1506 obstack_ptr_grow (&argv_obstack, "-dumpbase");
1507 }
1508
1509 /* Remember at which point we can scrub args to re-use the commons. */
1510 new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *);
1511
1512 if (have_offload)
1513 {
1514 unsigned i, num_offload_files;
1515 char **offload_argv;
1516 FILE *f;
1517
1518 f = fopen (offload_objects_file_name, "r");
1519 if (f == NULL)
1520 fatal_error (input_location, "cannot open %s: %m",
1521 offload_objects_file_name);
1522 if (fscanf (f, "%u ", &num_offload_files) != 1)
1523 fatal_error (input_location, "cannot read %s: %m",
1524 offload_objects_file_name);
1525 offload_argv = XCNEWVEC (char *, num_offload_files);
1526
1527 /* Read names of object files with offload. */
1528 for (i = 0; i < num_offload_files; i++)
1529 {
1530 const unsigned piece = 32;
1531 char *buf, *filename = XNEWVEC (char, piece);
1532 size_t len;
1533
1534 buf = filename;
1535 cont1:
1536 if (!fgets (buf, piece, f))
1537 break;
1538 len = strlen (filename);
1539 if (filename[len - 1] != '\n')
1540 {
1541 filename = XRESIZEVEC (char, filename, len + piece);
1542 buf = filename + len;
1543 goto cont1;
1544 }
1545 filename[len - 1] = '\0';
1546 offload_argv[i] = filename;
1547 }
1548 fclose (f);
1549 if (offload_argv[num_offload_files - 1] == NULL)
1550 fatal_error (input_location, "invalid format of %s",
1551 offload_objects_file_name);
1552 maybe_unlink (offload_objects_file_name);
1553 offload_objects_file_name = NULL;
1554
1555 /* Look at saved offload options in files. */
1556 for (i = 0; i < num_offload_files; i++)
1557 {
1558 char *p;
1559 long loffset;
1560 int fd, consumed;
1561 off_t file_offset = 0;
1562 char *filename = offload_argv[i];
1563
1564 if ((p = strrchr (offload_argv[i], '@'))
1565 && p != offload_argv[i]
1566 && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
1567 && strlen (p) == (unsigned int) consumed)
1568 {
1569 filename = XNEWVEC (char, p - offload_argv[i] + 1);
1570 memcpy (filename, offload_argv[i], p - offload_argv[i]);
1571 filename[p - offload_argv[i]] = '\0';
1572 file_offset = (off_t) loffset;
1573 }
1574 fd = open (filename, O_RDONLY | O_BINARY);
1575 if (fd == -1)
1576 fatal_error (input_location, "cannot open %s: %m", filename);
1577 if (!find_and_merge_options (fd, file_offset,
1578 OFFLOAD_SECTION_NAME_PREFIX,
1579 &offload_fdecoded_options,
1580 &offload_fdecoded_options_count,
1581 collect_gcc))
1582 fatal_error (input_location, "cannot read %s: %m", filename);
1583 close (fd);
1584 if (filename != offload_argv[i])
1585 XDELETEVEC (filename);
1586 }
1587
1588 compile_images_for_offload_targets (num_offload_files, offload_argv,
1589 offload_fdecoded_options,
1590 offload_fdecoded_options_count,
1591 decoded_options,
1592 decoded_options_count);
1593
1594 free_array_of_ptrs ((void **) offload_argv, num_offload_files);
1595
1596 if (offload_names)
1597 {
1598 find_crtoffloadtable ();
1599 for (i = 0; offload_names[i]; i++)
1600 printf ("%s\n", offload_names[i]);
1601 free_array_of_ptrs ((void **) offload_names, i);
1602 }
1603 }
1604
1605 /* If object files contain offload sections, but do not contain LTO sections,
1606 then there is no need to perform a link-time recompilation, i.e.
1607 lto-wrapper is used only for a compilation of offload images. */
1608 if (have_offload && !have_lto)
1609 goto finish;
1610
1611 if (lto_mode == LTO_MODE_LTO)
1612 {
1613 if (linker_output)
1614 {
1615 obstack_ptr_grow (&argv_obstack, linker_output);
1616 flto_out = (char *) xmalloc (strlen (linker_output)
1617 + sizeof (".lto.o") + 1);
1618 strcpy (flto_out, linker_output);
1619 strcat (flto_out, ".lto.o");
1620 }
1621 else
1622 flto_out = make_temp_file (".lto.o");
1623 obstack_ptr_grow (&argv_obstack, "-o");
1624 obstack_ptr_grow (&argv_obstack, flto_out);
1625 }
1626 else
1627 {
1628 const char *list_option = "-fltrans-output-list=";
1629 size_t list_option_len = strlen (list_option);
1630 char *tmp;
1631
1632 if (linker_output)
1633 {
1634 char *dumpbase = (char *) xmalloc (strlen (linker_output)
1635 + sizeof (".wpa") + 1);
1636 strcpy (dumpbase, linker_output);
1637 strcat (dumpbase, ".wpa");
1638 obstack_ptr_grow (&argv_obstack, dumpbase);
1639 }
1640
1641 if (linker_output && save_temps)
1642 {
1643 ltrans_output_file = (char *) xmalloc (strlen (linker_output)
1644 + sizeof (".ltrans.out") + 1);
1645 strcpy (ltrans_output_file, linker_output);
1646 strcat (ltrans_output_file, ".ltrans.out");
1647 }
1648 else
1649 {
1650 char *prefix = NULL;
1651 if (linker_output)
1652 {
1653 prefix = (char *) xmalloc (strlen (linker_output) + 2);
1654 strcpy (prefix, linker_output);
1655 strcat (prefix, ".");
1656 }
1657
1658 ltrans_output_file = make_temp_file_with_prefix (prefix,
1659 ".ltrans.out");
1660 free (prefix);
1661 }
1662 list_option_full = (char *) xmalloc (sizeof (char) *
1663 (strlen (ltrans_output_file) + list_option_len + 1));
1664 tmp = list_option_full;
1665
1666 obstack_ptr_grow (&argv_obstack, tmp);
1667 strcpy (tmp, list_option);
1668 tmp += list_option_len;
1669 strcpy (tmp, ltrans_output_file);
1670
1671 if (jobserver)
1672 {
1673 if (verbose)
1674 fprintf (stderr, "Using make jobserver\n");
1675 obstack_ptr_grow (&argv_obstack, xstrdup ("-fwpa=jobserver"));
1676 }
1677 else if (auto_parallel)
1678 {
1679 char buf[256];
1680 init_num_threads ();
1681 if (verbose)
1682 fprintf (stderr, "LTO parallelism level set to %ld\n",
1683 nthreads_var);
1684 sprintf (buf, "-fwpa=%ld", nthreads_var);
1685 obstack_ptr_grow (&argv_obstack, xstrdup (buf));
1686 }
1687 else if (parallel > 1)
1688 {
1689 char buf[256];
1690 sprintf (buf, "-fwpa=%i", parallel);
1691 obstack_ptr_grow (&argv_obstack, xstrdup (buf));
1692 }
1693 else
1694 obstack_ptr_grow (&argv_obstack, "-fwpa");
1695 }
1696
1697 /* Append input arguments. */
1698 for (i = 0; i < lto_argc; ++i)
1699 obstack_ptr_grow (&argv_obstack, lto_argv[i]);
1700 /* Append the input objects. */
1701 for (i = 0; i < ltoobj_argc; ++i)
1702 obstack_ptr_grow (&argv_obstack, ltoobj_argv[i]);
1703 obstack_ptr_grow (&argv_obstack, NULL);
1704
1705 new_argv = XOBFINISH (&argv_obstack, const char **);
1706 argv_ptr = &new_argv[new_head_argc];
1707 fork_execute (new_argv[0], CONST_CAST (char **, new_argv), true);
1708
1709 /* Copy the early generated debug info from the objects to temporary
1710 files and append those to the partial link commandline. */
1711 n_debugobj = 0;
1712 early_debug_object_names = NULL;
1713 if (! skip_debug)
1714 {
1715 early_debug_object_names = XCNEWVEC (const char *, ltoobj_argc+ 1);
1716 num_deb_objs = ltoobj_argc;
1717 for (i = 0; i < ltoobj_argc; ++i)
1718 {
1719 const char *tem;
1720 if ((tem = debug_objcopy (ltoobj_argv[i], !linker_output_rel)))
1721 {
1722 early_debug_object_names[i] = tem;
1723 n_debugobj++;
1724 }
1725 }
1726 }
1727
1728 if (lto_mode == LTO_MODE_LTO)
1729 {
1730 printf ("%s\n", flto_out);
1731 if (!skip_debug)
1732 {
1733 for (i = 0; i < ltoobj_argc; ++i)
1734 if (early_debug_object_names[i] != NULL)
1735 printf ("%s\n", early_debug_object_names[i]);
1736 }
1737 /* These now belong to collect2. */
1738 free (flto_out);
1739 flto_out = NULL;
1740 free (early_debug_object_names);
1741 early_debug_object_names = NULL;
1742 }
1743 else
1744 {
1745 FILE *stream = fopen (ltrans_output_file, "r");
1746 FILE *mstream = NULL;
1747 struct obstack env_obstack;
1748 int priority;
1749
1750 if (!stream)
1751 fatal_error (input_location, "%<fopen%>: %s: %m", ltrans_output_file);
1752
1753 /* Parse the list of LTRANS inputs from the WPA stage. */
1754 obstack_init (&env_obstack);
1755 nr = 0;
1756 for (;;)
1757 {
1758 const unsigned piece = 32;
1759 char *output_name = NULL;
1760 char *buf, *input_name = (char *)xmalloc (piece);
1761 size_t len;
1762
1763 buf = input_name;
1764 if (fscanf (stream, "%i\n", &priority) != 1)
1765 {
1766 if (!feof (stream))
1767 fatal_error (input_location,
1768 "corrupted ltrans output file %s",
1769 ltrans_output_file);
1770 break;
1771 }
1772 cont:
1773 if (!fgets (buf, piece, stream))
1774 break;
1775 len = strlen (input_name);
1776 if (input_name[len - 1] != '\n')
1777 {
1778 input_name = (char *)xrealloc (input_name, len + piece);
1779 buf = input_name + len;
1780 goto cont;
1781 }
1782 input_name[len - 1] = '\0';
1783
1784 if (input_name[0] == '*')
1785 output_name = &input_name[1];
1786
1787 nr++;
1788 ltrans_priorities
1789 = (int *)xrealloc (ltrans_priorities, nr * sizeof (int) * 2);
1790 input_names = (char **)xrealloc (input_names, nr * sizeof (char *));
1791 output_names = (char **)xrealloc (output_names, nr * sizeof (char *));
1792 ltrans_priorities[(nr-1)*2] = priority;
1793 ltrans_priorities[(nr-1)*2+1] = nr-1;
1794 input_names[nr-1] = input_name;
1795 output_names[nr-1] = output_name;
1796 }
1797 fclose (stream);
1798 maybe_unlink (ltrans_output_file);
1799 ltrans_output_file = NULL;
1800
1801 if (parallel)
1802 {
1803 makefile = make_temp_file (".mk");
1804 mstream = fopen (makefile, "w");
1805 qsort (ltrans_priorities, nr, sizeof (int) * 2, cmp_priority);
1806 }
1807
1808 /* Execute the LTRANS stage for each input file (or prepare a
1809 makefile to invoke this in parallel). */
1810 for (i = 0; i < nr; ++i)
1811 {
1812 char *output_name;
1813 char *input_name = input_names[i];
1814 /* If it's a pass-through file do nothing. */
1815 if (output_names[i])
1816 continue;
1817
1818 /* Replace the .o suffix with a .ltrans.o suffix and write
1819 the resulting name to the LTRANS output list. */
1820 obstack_grow (&env_obstack, input_name, strlen (input_name) - 2);
1821 obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
1822 output_name = XOBFINISH (&env_obstack, char *);
1823
1824 /* Adjust the dumpbase if the linker output file was seen. */
1825 if (linker_output)
1826 {
1827 char *dumpbase
1828 = (char *) xmalloc (strlen (linker_output)
1829 + sizeof (DUMPBASE_SUFFIX) + 1);
1830 snprintf (dumpbase,
1831 strlen (linker_output) + sizeof (DUMPBASE_SUFFIX),
1832 "%s.ltrans%u", linker_output, i);
1833 argv_ptr[0] = dumpbase;
1834 }
1835
1836 argv_ptr[1] = "-fltrans";
1837 argv_ptr[2] = "-o";
1838 argv_ptr[3] = output_name;
1839 argv_ptr[4] = input_name;
1840 argv_ptr[5] = NULL;
1841 if (parallel)
1842 {
1843 fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]);
1844 for (j = 1; new_argv[j] != NULL; ++j)
1845 fprintf (mstream, " '%s'", new_argv[j]);
1846 fprintf (mstream, "\n");
1847 /* If we are not preserving the ltrans input files then
1848 truncate them as soon as we have processed it. This
1849 reduces temporary disk-space usage. */
1850 if (! save_temps)
1851 fprintf (mstream, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1852 "&& mv %s.tem %s\n",
1853 input_name, input_name, input_name, input_name);
1854 }
1855 else
1856 {
1857 fork_execute (new_argv[0], CONST_CAST (char **, new_argv),
1858 true);
1859 maybe_unlink (input_name);
1860 }
1861
1862 output_names[i] = output_name;
1863 }
1864 if (parallel)
1865 {
1866 struct pex_obj *pex;
1867 char jobs[32];
1868
1869 fprintf (mstream,
1870 ".PHONY: all\n"
1871 "all:");
1872 for (i = 0; i < nr; ++i)
1873 {
1874 int j = ltrans_priorities[i*2 + 1];
1875 fprintf (mstream, " \\\n\t%s", output_names[j]);
1876 }
1877 fprintf (mstream, "\n");
1878 fclose (mstream);
1879 if (!jobserver)
1880 {
1881 /* Avoid passing --jobserver-fd= and similar flags
1882 unless jobserver mode is explicitly enabled. */
1883 putenv (xstrdup ("MAKEFLAGS="));
1884 putenv (xstrdup ("MFLAGS="));
1885 }
1886 new_argv[0] = getenv ("MAKE");
1887 if (!new_argv[0])
1888 new_argv[0] = "make";
1889 new_argv[1] = "-f";
1890 new_argv[2] = makefile;
1891 i = 3;
1892 if (!jobserver)
1893 {
1894 snprintf (jobs, 31, "-j%ld",
1895 auto_parallel ? nthreads_var : parallel);
1896 new_argv[i++] = jobs;
1897 }
1898 new_argv[i++] = "all";
1899 new_argv[i++] = NULL;
1900 pex = collect_execute (new_argv[0], CONST_CAST (char **, new_argv),
1901 NULL, NULL, PEX_SEARCH, false);
1902 do_wait (new_argv[0], pex);
1903 maybe_unlink (makefile);
1904 makefile = NULL;
1905 for (i = 0; i < nr; ++i)
1906 maybe_unlink (input_names[i]);
1907 }
1908 for (i = 0; i < nr; ++i)
1909 {
1910 fputs (output_names[i], stdout);
1911 putc ('\n', stdout);
1912 free (input_names[i]);
1913 }
1914 if (!skip_debug)
1915 {
1916 for (i = 0; i < ltoobj_argc; ++i)
1917 if (early_debug_object_names[i] != NULL)
1918 printf ("%s\n", early_debug_object_names[i]);
1919 }
1920 nr = 0;
1921 free (ltrans_priorities);
1922 free (output_names);
1923 output_names = NULL;
1924 free (early_debug_object_names);
1925 early_debug_object_names = NULL;
1926 free (input_names);
1927 free (list_option_full);
1928 obstack_free (&env_obstack, NULL);
1929 }
1930
1931 finish:
1932 XDELETE (lto_argv);
1933 obstack_free (&argv_obstack, NULL);
1934 }
1935
1936
1937 /* Entry point. */
1938
1939 int
main(int argc,char * argv[])1940 main (int argc, char *argv[])
1941 {
1942 const char *p;
1943
1944 init_opts_obstack ();
1945
1946 p = argv[0] + strlen (argv[0]);
1947 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
1948 --p;
1949 progname = p;
1950
1951 xmalloc_set_program_name (progname);
1952
1953 gcc_init_libintl ();
1954
1955 diagnostic_initialize (global_dc, 0);
1956
1957 if (atexit (lto_wrapper_cleanup) != 0)
1958 fatal_error (input_location, "%<atexit%> failed");
1959
1960 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1961 signal (SIGINT, fatal_signal);
1962 #ifdef SIGHUP
1963 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1964 signal (SIGHUP, fatal_signal);
1965 #endif
1966 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
1967 signal (SIGTERM, fatal_signal);
1968 #ifdef SIGPIPE
1969 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
1970 signal (SIGPIPE, fatal_signal);
1971 #endif
1972 #ifdef SIGCHLD
1973 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1974 receive the signal. A different setting is inheritable */
1975 signal (SIGCHLD, SIG_DFL);
1976 #endif
1977
1978 /* We may be called with all the arguments stored in some file and
1979 passed with @file. Expand them into argv before processing. */
1980 expandargv (&argc, &argv);
1981
1982 run_gcc (argc, argv);
1983
1984 return 0;
1985 }
1986