gcc/lto-wrapper.c

   1 /* Wrapper to call lto.  Used by collect2 and the linker plugin.
   2    Copyright (C) 2009-2015 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 char **input_names;
  69 static char **output_names;
  70 static char **offload_names;
  71 static const char *offloadbegin, *offloadend;
  72 static char *makefile;
  73
  74 const char tool_name[] = "lto-wrapper";
  75
  76 /* Delete tempfiles.  Called from utils_cleanup.  */
  77
  78 void
  79 tool_cleanup (bool)
  80 {
  81   unsigned int i;
  82
  83   if (ltrans_output_file)
  84     maybe_unlink (ltrans_output_file);
  85   if (flto_out)
  86     maybe_unlink (flto_out);
  87   if (makefile)
  88     maybe_unlink (makefile);
  89   for (i = 0; i < nr; ++i)
  90     {
  91       maybe_unlink (input_names[i]);
  92       if (output_names[i])
  93         maybe_unlink (output_names[i]);
  94     }
  95 }
  96
  97 static void
  98 lto_wrapper_cleanup (void)
  99 {
 100   utils_cleanup (false);
 101 }
 102
 103 /* Unlink a temporary LTRANS file unless requested otherwise.  */
 104
 105 void
 106 maybe_unlink (const char *file)
 107 {
 108   if (!save_temps)
 109     {
 110       if (unlink_if_ordinary (file)
 111           && errno != ENOENT)
 112         fatal_error (input_location, "deleting LTRANS file %s: %m", file);
 113     }
 114   else if (verbose)
 115     fprintf (stderr, "[Leaving LTRANS %s]\n", file);
 116 }
 117
 118 /* Template of LTRANS dumpbase suffix.  */
 119 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
 120
 121 /* Create decoded options from the COLLECT_GCC and COLLECT_GCC_OPTIONS
 122    environment according to LANG_MASK.  */
 123
 124 static void
 125 get_options_from_collect_gcc_options (const char *collect_gcc,
 126                                       const char *collect_gcc_options,
 127                                       unsigned int lang_mask,
 128                                       struct cl_decoded_option **decoded_options,
 129                                       unsigned int *decoded_options_count)
 130 {
 131   struct obstack argv_obstack;
 132   char *argv_storage;
 133   const char **argv;
 134   int j, k, argc;
 135
 136   argv_storage = xstrdup (collect_gcc_options);
 137   obstack_init (&argv_obstack);
 138   obstack_ptr_grow (&argv_obstack, collect_gcc);
 139
 140   for (j = 0, k = 0; argv_storage[j] != '\0'; ++j)
 141     {
 142       if (argv_storage[j] == '\'')
 143         {
 144           obstack_ptr_grow (&argv_obstack, &argv_storage[k]);
 145           ++j;
 146           do
 147             {
 148               if (argv_storage[j] == '\0')
 149                 fatal_error (input_location, "malformed COLLECT_GCC_OPTIONS");
 150               else if (strncmp (&argv_storage[j], "'\\''", 4) == 0)
 151                 {
 152                   argv_storage[k++] = '\'';
 153                   j += 4;
 154                 }
 155               else if (argv_storage[j] == '\'')
 156                 break;
 157               else
 158                 argv_storage[k++] = argv_storage[j++];
 159             }
 160           while (1);
 161           argv_storage[k++] = '\0';
 162         }
 163     }
 164
 165   obstack_ptr_grow (&argv_obstack, NULL);
 166   argc = obstack_object_size (&argv_obstack) / sizeof (void *) - 1;
 167   argv = XOBFINISH (&argv_obstack, const char **);
 168
 169   decode_cmdline_options_to_array (argc, (const char **)argv,
 170                                    lang_mask,
 171                                    decoded_options, decoded_options_count);
 172   obstack_free (&argv_obstack, NULL);
 173 }
 174
 175 /* Append OPTION to the options array DECODED_OPTIONS with size
 176    DECODED_OPTIONS_COUNT.  */
 177
 178 static void
 179 append_option (struct cl_decoded_option **decoded_options,
 180                unsigned int *decoded_options_count,
 181                struct cl_decoded_option *option)
 182 {
 183   ++*decoded_options_count;
 184   *decoded_options
 185     = (struct cl_decoded_option *)
 186         xrealloc (*decoded_options,
 187                   (*decoded_options_count
 188                    * sizeof (struct cl_decoded_option)));
 189   memcpy (&(*decoded_options)[*decoded_options_count - 1], option,
 190           sizeof (struct cl_decoded_option));
 191 }
 192
 193 /* Try to merge and complain about options FDECODED_OPTIONS when applied
 194    ontop of DECODED_OPTIONS.  */
 195
 196 static void
 197 merge_and_complain (struct cl_decoded_option **decoded_options,
 198                     unsigned int *decoded_options_count,
 199                     struct cl_decoded_option *fdecoded_options,
 200                     unsigned int fdecoded_options_count)
 201 {
 202   unsigned int i, j;
 203
 204   /* ???  Merge options from files.  Most cases can be
 205      handled by either unioning or intersecting
 206      (for example -fwrapv is a case for unioning,
 207      -ffast-math is for intersection).  Most complaints
 208      about real conflicts between different options can
 209      be deferred to the compiler proper.  Options that
 210      we can neither safely handle by intersection nor
 211      unioning would need to be complained about here.
 212      Ideally we'd have a flag in the opt files that
 213      tells whether to union or intersect or reject.
 214      In absence of that it's unclear what a good default is.
 215      It's also difficult to get positional handling correct.  */
 216
 217   /* The following does what the old LTO option code did,
 218      union all target and a selected set of common options.  */
 219   for (i = 0; i < fdecoded_options_count; ++i)
 220     {
 221       struct cl_decoded_option *foption = &fdecoded_options[i];
 222       switch (foption->opt_index)
 223         {
 224         case OPT_SPECIAL_unknown:
 225         case OPT_SPECIAL_ignore:
 226         case OPT_SPECIAL_program_name:
 227         case OPT_SPECIAL_input_file:
 228           break;
 229
 230         default:
 231           if (!(cl_options[foption->opt_index].flags & CL_TARGET))
 232             break;
 233
 234           /* Fallthru.  */
 235         case OPT_fdiagnostics_show_caret:
 236         case OPT_fdiagnostics_show_option:
 237         case OPT_fdiagnostics_show_location_:
 238         case OPT_fshow_column:
 239         case OPT_fPIC:
 240         case OPT_fpic:
 241         case OPT_fPIE:
 242         case OPT_fpie:
 243         case OPT_fcommon:
 244         case OPT_fexceptions:
 245         case OPT_fnon_call_exceptions:
 246         case OPT_fgnu_tm:
 247           /* Do what the old LTO code did - collect exactly one option
 248              setting per OPT code, we pick the first we encounter.
 249              ???  This doesn't make too much sense, but when it doesn't
 250              then we should complain.  */
 251           for (j = 0; j < *decoded_options_count; ++j)
 252             if ((*decoded_options)[j].opt_index == foption->opt_index)
 253               break;
 254           if (j == *decoded_options_count)
 255             append_option (decoded_options, decoded_options_count, foption);
 256           break;
 257
 258         case OPT_ftrapv:
 259         case OPT_fstrict_overflow:
 260         case OPT_ffp_contract_:
 261           /* For selected options we can merge conservatively.  */
 262           for (j = 0; j < *decoded_options_count; ++j)
 263             if ((*decoded_options)[j].opt_index == foption->opt_index)
 264               break;
 265           if (j == *decoded_options_count)
 266             append_option (decoded_options, decoded_options_count, foption);
 267           /* FP_CONTRACT_OFF < FP_CONTRACT_ON < FP_CONTRACT_FAST,
 268              -fno-trapv < -ftrapv,
 269              -fno-strict-overflow < -fstrict-overflow  */
 270           else if (foption->value < (*decoded_options)[j].value)
 271             (*decoded_options)[j] = *foption;
 272           break;
 273
 274         case OPT_fmath_errno:
 275         case OPT_fsigned_zeros:
 276         case OPT_ftrapping_math:
 277         case OPT_fwrapv:
 278         case OPT_fopenmp:
 279         case OPT_fopenacc:
 280         case OPT_fcheck_pointer_bounds:
 281           /* For selected options we can merge conservatively.  */
 282           for (j = 0; j < *decoded_options_count; ++j)
 283             if ((*decoded_options)[j].opt_index == foption->opt_index)
 284               break;
 285           if (j == *decoded_options_count)
 286             append_option (decoded_options, decoded_options_count, foption);
 287           /* -fmath-errno > -fno-math-errno,
 288              -fsigned-zeros > -fno-signed-zeros,
 289              -ftrapping-math -> -fno-trapping-math,
 290              -fwrapv > -fno-wrapv.  */
 291           else if (foption->value > (*decoded_options)[j].value)
 292             (*decoded_options)[j] = *foption;
 293           break;
 294
 295         case OPT_freg_struct_return:
 296         case OPT_fpcc_struct_return:
 297         case OPT_fshort_double:
 298           for (j = 0; j < *decoded_options_count; ++j)
 299             if ((*decoded_options)[j].opt_index == foption->opt_index)
 300               break;
 301           if (j == *decoded_options_count)
 302             fatal_error (input_location,
 303                          "Option %s not used consistently in all LTO input"
 304                          " files", foption->orig_option_with_args_text);
 305           break;
 306
 307         case OPT_foffload_abi_:
 308           for (j = 0; j < *decoded_options_count; ++j)
 309             if ((*decoded_options)[j].opt_index == foption->opt_index)
 310               break;
 311           if (j == *decoded_options_count)
 312             append_option (decoded_options, decoded_options_count, foption);
 313           else if (foption->value != (*decoded_options)[j].value)
 314             fatal_error (input_location,
 315                          "Option %s not used consistently in all LTO input"
 316                          " files", foption->orig_option_with_args_text);
 317           break;
 318
 319         case OPT_O:
 320         case OPT_Ofast:
 321         case OPT_Og:
 322         case OPT_Os:
 323           for (j = 0; j < *decoded_options_count; ++j)
 324             if ((*decoded_options)[j].opt_index == OPT_O
 325                 || (*decoded_options)[j].opt_index == OPT_Ofast
 326                 || (*decoded_options)[j].opt_index == OPT_Og
 327                 || (*decoded_options)[j].opt_index == OPT_Os)
 328               break;
 329           if (j == *decoded_options_count)
 330             append_option (decoded_options, decoded_options_count, foption);
 331           else if ((*decoded_options)[j].opt_index == foption->opt_index
 332                    && foption->opt_index != OPT_O)
 333             /* Exact same options get merged.  */
 334             ;
 335           else
 336             {
 337               /* For mismatched option kinds preserve the optimization
 338                  level only, thus merge it as -On.  This also handles
 339                  merging of same optimization level -On.  */
 340               int level = 0;
 341               switch (foption->opt_index)
 342                 {
 343                 case OPT_O:
 344                   if (foption->arg[0] == '\0')
 345                     level = MAX (level, 1);
 346                   else
 347                     level = MAX (level, atoi (foption->arg));
 348                   break;
 349                 case OPT_Ofast:
 350                   level = MAX (level, 3);
 351                   break;
 352                 case OPT_Og:
 353                   level = MAX (level, 1);
 354                   break;
 355                 case OPT_Os:
 356                   level = MAX (level, 2);
 357                   break;
 358                 default:
 359                   gcc_unreachable ();
 360                 }
 361               switch ((*decoded_options)[j].opt_index)
 362                 {
 363                 case OPT_O:
 364                   if ((*decoded_options)[j].arg[0] == '\0')
 365                     level = MAX (level, 1);
 366                   else
 367                     level = MAX (level, atoi ((*decoded_options)[j].arg));
 368                   break;
 369                 case OPT_Ofast:
 370                   level = MAX (level, 3);
 371                   break;
 372                 case OPT_Og:
 373                   level = MAX (level, 1);
 374                   break;
 375                 case OPT_Os:
 376                   level = MAX (level, 2);
 377                   break;
 378                 default:
 379                   gcc_unreachable ();
 380                 }
 381               (*decoded_options)[j].opt_index = OPT_O;
 382               char *tem;
 383               tem = xasprintf ("-O%d", level);
 384               (*decoded_options)[j].arg = &tem[2];
 385               (*decoded_options)[j].canonical_option[0] = tem;
 386               (*decoded_options)[j].value = 1;
 387             }
 388           break;
 389
 390         case OPT_foffload_:
 391           append_option (decoded_options, decoded_options_count, foption);
 392           break;
 393         }
 394     }
 395 }
 396
 397 /* Auxiliary function that frees elements of PTR and PTR itself.
 398    N is number of elements to be freed.  If PTR is NULL, nothing is freed.
 399    If an element is NULL, subsequent elements are not freed.  */
 400
 401 static void **
 402 free_array_of_ptrs (void **ptr, unsigned n)
 403 {
 404   if (!ptr)
 405     return NULL;
 406   for (unsigned i = 0; i < n; i++)
 407     {
 408       if (!ptr[i])
 409         break;
 410       free (ptr[i]);
 411     }
 412   free (ptr);
 413   return NULL;
 414 }
 415
 416 /* Parse STR, saving found tokens into PVALUES and return their number.
 417    Tokens are assumed to be delimited by ':'.  If APPEND is non-null,
 418    append it to every token we find.  */
 419
 420 static unsigned
 421 parse_env_var (const char *str, char ***pvalues, const char *append)
 422 {
 423   const char *curval, *nextval;
 424   char **values;
 425   unsigned num = 1, i;
 426
 427   curval = strchr (str, ':');
 428   while (curval)
 429     {
 430       num++;
 431       curval = strchr (curval + 1, ':');
 432     }
 433
 434   values = (char**) xmalloc (num * sizeof (char*));
 435   curval = str;
 436   nextval = strchr (curval, ':');
 437   if (nextval == NULL)
 438     nextval = strchr (curval, '\0');
 439
 440   int append_len = append ? strlen (append) : 0;
 441   for (i = 0; i < num; i++)
 442     {
 443       int l = nextval - curval;
 444       values[i] = (char*) xmalloc (l + 1 + append_len);
 445       memcpy (values[i], curval, l);
 446       values[i][l] = 0;
 447       if (append)
 448         strcat (values[i], append);
 449       curval = nextval + 1;
 450       nextval = strchr (curval, ':');
 451       if (nextval == NULL)
 452         nextval = strchr (curval, '\0');
 453     }
 454   *pvalues = values;
 455   return num;
 456 }
 457
 458 /* Append options OPTS from lto or offload_lto sections to ARGV_OBSTACK.  */
 459
 460 static void
 461 append_compiler_options (obstack *argv_obstack, struct cl_decoded_option *opts,
 462                          unsigned int count)
 463 {
 464   /* Append compiler driver arguments as far as they were merged.  */
 465   for (unsigned int j = 1; j < count; ++j)
 466     {
 467       struct cl_decoded_option *option = &opts[j];
 468
 469       /* File options have been properly filtered by lto-opts.c.  */
 470       switch (option->opt_index)
 471         {
 472         /* Drop arguments that we want to take from the link line.  */
 473         case OPT_flto_:
 474         case OPT_flto:
 475         case OPT_flto_partition_:
 476           continue;
 477
 478         default:
 479           break;
 480         }
 481
 482       /* For now do what the original LTO option code was doing - pass
 483          on any CL_TARGET flag and a few selected others.  */
 484       switch (option->opt_index)
 485         {
 486         case OPT_fdiagnostics_show_caret:
 487         case OPT_fdiagnostics_show_option:
 488         case OPT_fdiagnostics_show_location_:
 489         case OPT_fshow_column:
 490         case OPT_fPIC:
 491         case OPT_fpic:
 492         case OPT_fPIE:
 493         case OPT_fpie:
 494         case OPT_fcommon:
 495         case OPT_fexceptions:
 496         case OPT_fnon_call_exceptions:
 497         case OPT_fgnu_tm:
 498         case OPT_freg_struct_return:
 499         case OPT_fpcc_struct_return:
 500         case OPT_fshort_double:
 501         case OPT_ffp_contract_:
 502         case OPT_fmath_errno:
 503         case OPT_fsigned_zeros:
 504         case OPT_ftrapping_math:
 505         case OPT_fwrapv:
 506         case OPT_fopenmp:
 507         case OPT_fopenacc:
 508         case OPT_ftrapv:
 509         case OPT_fstrict_overflow:
 510         case OPT_foffload_abi_:
 511         case OPT_O:
 512         case OPT_Ofast:
 513         case OPT_Og:
 514         case OPT_Os:
 515         case OPT_fcheck_pointer_bounds:
 516           break;
 517
 518         default:
 519           if (!(cl_options[option->opt_index].flags & CL_TARGET))
 520             continue;
 521         }
 522
 523       /* Pass the option on.  */
 524       for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
 525         obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
 526     }
 527 }
 528
 529 /* Append linker options OPTS to ARGV_OBSTACK.  */
 530
 531 static void
 532 append_linker_options (obstack *argv_obstack, struct cl_decoded_option *opts,
 533                        unsigned int count)
 534 {
 535   /* Append linker driver arguments.  Compiler options from the linker
 536      driver arguments will override / merge with those from the compiler.  */
 537   for (unsigned int j = 1; j < count; ++j)
 538     {
 539       struct cl_decoded_option *option = &opts[j];
 540
 541       /* Do not pass on frontend specific flags not suitable for lto.  */
 542       if (!(cl_options[option->opt_index].flags
 543             & (CL_COMMON|CL_TARGET|CL_DRIVER|CL_LTO)))
 544         continue;
 545
 546       switch (option->opt_index)
 547         {
 548         case OPT_o:
 549         case OPT_flto_:
 550         case OPT_flto:
 551           /* We've handled these LTO options, do not pass them on.  */
 552           continue;
 553
 554         case OPT_freg_struct_return:
 555         case OPT_fpcc_struct_return:
 556         case OPT_fshort_double:
 557           /* Ignore these, they are determined by the input files.
 558              ???  We fail to diagnose a possible mismatch here.  */
 559           continue;
 560
 561         default:
 562           break;
 563         }
 564
 565       /* Pass the option on.  */
 566       for (unsigned int i = 0; i < option->canonical_option_num_elements; ++i)
 567         obstack_ptr_grow (argv_obstack, option->canonical_option[i]);
 568     }
 569 }
 570
 571 /* Extract options for TARGET offload compiler from OPTIONS and append
 572    them to ARGV_OBSTACK.  */
 573
 574 static void
 575 append_offload_options (obstack *argv_obstack, const char *target,
 576                         struct cl_decoded_option *options,
 577                         unsigned int options_count)
 578 {
 579   for (unsigned i = 0; i < options_count; i++)
 580     {
 581       const char *cur, *next, *opts;
 582       char **argv;
 583       unsigned argc;
 584       struct cl_decoded_option *option = &options[i];
 585
 586       if (option->opt_index != OPT_foffload_)
 587         continue;
 588
 589       /* If option argument starts with '-' then no target is specified.  That
 590          means offload options are specified for all targets, so we need to
 591          append them.  */
 592       if (option->arg[0] == '-')
 593         opts = option->arg;
 594       else
 595         {
 596           opts = strchr (option->arg, '=');
 597           /* If there are offload targets specified, but no actual options,
 598              there is nothing to do here.  */
 599           if (!opts)
 600             continue;
 601
 602           cur = option->arg;
 603
 604           while (cur < opts)
 605             {
 606               next = strchr (cur, ',');
 607               if (next == NULL)
 608                 next = opts;
 609               next = (next > opts) ? opts : next;
 610
 611               /* Are we looking for this offload target?  */
 612               if (strlen (target) == (size_t) (next - cur)
 613                   && strncmp (target, cur, next - cur) == 0)
 614                 break;
 615
 616               /* Skip the comma or equal sign.  */
 617               cur = next + 1;
 618             }
 619
 620           if (cur >= opts)
 621             continue;
 622
 623           opts++;
 624         }
 625
 626       argv = buildargv (opts);
 627       for (argc = 0; argv[argc]; argc++)
 628         obstack_ptr_grow (argv_obstack, argv[argc]);
 629     }
 630 }
 631
 632 /* Check whether NAME can be accessed in MODE.  This is like access,
 633    except that it never considers directories to be executable.  */
 634
 635 static int
 636 access_check (const char *name, int mode)
 637 {
 638   if (mode == X_OK)
 639     {
 640       struct stat st;
 641
 642       if (stat (name, &st) < 0
 643           || S_ISDIR (st.st_mode))
 644         return -1;
 645     }
 646
 647   return access (name, mode);
 648 }
 649
 650 /* Prepare a target image for offload TARGET, using mkoffload tool from
 651    COMPILER_PATH.  Return the name of the resultant object file.  */
 652
 653 static char *
 654 compile_offload_image (const char *target, const char *compiler_path,
 655                        unsigned in_argc, char *in_argv[],
 656                        struct cl_decoded_option *compiler_opts,
 657                        unsigned int compiler_opt_count,
 658                        struct cl_decoded_option *linker_opts,
 659                        unsigned int linker_opt_count)
 660 {
 661   char *filename = NULL;
 662   char **argv;
 663   char *suffix
 664     = XALLOCAVEC (char, sizeof ("/accel//mkoffload") + strlen (target));
 665   strcpy (suffix, "/accel/");
 666   strcat (suffix, target);
 667   strcat (suffix, "/mkoffload");
 668
 669   char **paths = NULL;
 670   unsigned n_paths = parse_env_var (compiler_path, &paths, suffix);
 671
 672   const char *compiler = NULL;
 673   for (unsigned i = 0; i < n_paths; i++)
 674     if (access_check (paths[i], X_OK) == 0)
 675       {
 676         compiler = paths[i];
 677         break;
 678       }
 679
 680   if (compiler)
 681     {
 682       /* Generate temporary output file name.  */
 683       filename = make_temp_file (".target.o");
 684
 685       struct obstack argv_obstack;
 686       obstack_init (&argv_obstack);
 687       obstack_ptr_grow (&argv_obstack, compiler);
 688       if (save_temps)
 689         obstack_ptr_grow (&argv_obstack, "-save-temps");
 690       if (verbose)
 691         obstack_ptr_grow (&argv_obstack, "-v");
 692       obstack_ptr_grow (&argv_obstack, "-o");
 693       obstack_ptr_grow (&argv_obstack, filename);
 694
 695       /* Append names of input object files.  */
 696       for (unsigned i = 0; i < in_argc; i++)
 697         obstack_ptr_grow (&argv_obstack, in_argv[i]);
 698
 699       /* Append options from offload_lto sections.  */
 700       append_compiler_options (&argv_obstack, compiler_opts,
 701                                compiler_opt_count);
 702
 703       /* Append options specified by -foffload last.  In case of conflicting
 704          options we expect offload compiler to choose the latest.  */
 705       append_offload_options (&argv_obstack, target, compiler_opts,
 706                               compiler_opt_count);
 707       append_offload_options (&argv_obstack, target, linker_opts,
 708                               linker_opt_count);
 709
 710       obstack_ptr_grow (&argv_obstack, NULL);
 711       argv = XOBFINISH (&argv_obstack, char **);
 712       fork_execute (argv[0], argv, true);
 713       obstack_free (&argv_obstack, NULL);
 714     }
 715
 716   free_array_of_ptrs ((void **) paths, n_paths);
 717   return filename;
 718 }
 719
 720
 721 /* The main routine dealing with offloading.
 722    The routine builds a target image for each offload target.  IN_ARGC and
 723    IN_ARGV specify options and input object files.  As all of them could contain
 724    target sections, we pass them all to target compilers.  */
 725
 726 static void
 727 compile_images_for_offload_targets (unsigned in_argc, char *in_argv[],
 728                                     struct cl_decoded_option *compiler_opts,
 729                                     unsigned int compiler_opt_count,
 730                                     struct cl_decoded_option *linker_opts,
 731                                     unsigned int linker_opt_count)
 732 {
 733   char **names = NULL;
 734   const char *target_names = getenv (OFFLOAD_TARGET_NAMES_ENV);
 735   if (!target_names)
 736     return;
 737   unsigned num_targets = parse_env_var (target_names, &names, NULL);
 738
 739   const char *compiler_path = getenv ("COMPILER_PATH");
 740   if (!compiler_path)
 741     goto out;
 742
 743   /* Prepare an image for each target and save the name of the resultant object
 744      file to the OFFLOAD_NAMES array.  It is terminated by a NULL entry.  */
 745   offload_names = XCNEWVEC (char *, num_targets + 1);
 746   for (unsigned i = 0; i < num_targets; i++)
 747     {
 748       offload_names[i]
 749         = compile_offload_image (names[i], compiler_path, in_argc, in_argv,
 750                                  compiler_opts, compiler_opt_count,
 751                                  linker_opts, linker_opt_count);
 752       if (!offload_names[i])
 753         fatal_error (input_location,
 754                      "problem with building target image for %s\n", names[i]);
 755     }
 756
 757  out:
 758   free_array_of_ptrs ((void **) names, num_targets);
 759 }
 760
 761 /* Copy a file from SRC to DEST.  */
 762
 763 static void
 764 copy_file (const char *dest, const char *src)
 765 {
 766   FILE *d = fopen (dest, "wb");
 767   FILE *s = fopen (src, "rb");
 768   char buffer[512];
 769   while (!feof (s))
 770     {
 771       size_t len = fread (buffer, 1, 512, s);
 772       if (ferror (s) != 0)
 773         fatal_error (input_location, "reading input file");
 774       if (len > 0)
 775         {
 776           fwrite (buffer, 1, len, d);
 777           if (ferror (d) != 0)
 778             fatal_error (input_location, "writing output file");
 779         }
 780     }
 781 }
 782
 783 /* Find the crtoffloadbegin.o and crtoffloadend.o files in LIBRARY_PATH, make
 784    copies and store the names of the copies in offloadbegin and offloadend.  */
 785
 786 static void
 787 find_offloadbeginend (void)
 788 {
 789   char **paths = NULL;
 790   const char *library_path = getenv ("LIBRARY_PATH");
 791   if (!library_path)
 792     return;
 793   unsigned n_paths = parse_env_var (library_path, &paths, "/crtoffloadbegin.o");
 794
 795   unsigned i;
 796   for (i = 0; i < n_paths; i++)
 797     if (access_check (paths[i], R_OK) == 0)
 798       {
 799         size_t len = strlen (paths[i]);
 800         char *tmp = xstrdup (paths[i]);
 801         strcpy (paths[i] + len - strlen ("begin.o"), "end.o");
 802         if (access_check (paths[i], R_OK) != 0)
 803           fatal_error (input_location,
 804                        "installation error, can't find crtoffloadend.o");
 805         /* The linker will delete the filenames we give it, so make
 806            copies.  */
 807         offloadbegin = make_temp_file (".o");
 808         offloadend = make_temp_file (".o");
 809         copy_file (offloadbegin, tmp);
 810         copy_file (offloadend, paths[i]);
 811         free (tmp);
 812         break;
 813       }
 814   if (i == n_paths)
 815     fatal_error (input_location,
 816                  "installation error, can't find crtoffloadbegin.o");
 817
 818   free_array_of_ptrs ((void **) paths, n_paths);
 819 }
 820
 821 /* A subroutine of run_gcc.  Examine the open file FD for lto sections with
 822    name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
 823    and OPT_COUNT.  Return true if we found a matchingn section, false
 824    otherwise.  COLLECT_GCC holds the value of the environment variable with
 825    the same name.  */
 826
 827 static bool
 828 find_and_merge_options (int fd, off_t file_offset, const char *prefix,
 829                         struct cl_decoded_option **opts,
 830                         unsigned int *opt_count, const char *collect_gcc)
 831 {
 832   off_t offset, length;
 833   char *data;
 834   char *fopts;
 835   const char *errmsg;
 836   int err;
 837   struct cl_decoded_option *fdecoded_options = *opts;
 838   unsigned int fdecoded_options_count = *opt_count;
 839
 840   simple_object_read *sobj;
 841   sobj = simple_object_start_read (fd, file_offset, "__GNU_LTO",
 842                                    &errmsg, &err);
 843   if (!sobj)
 844     return false;
 845
 846   char *secname = XALLOCAVEC (char, strlen (prefix) + sizeof (".opts"));
 847   strcpy (secname, prefix);
 848   strcat (secname, ".opts");
 849   if (!simple_object_find_section (sobj, secname, &offset, &length,
 850                                    &errmsg, &err))
 851     {
 852       simple_object_release_read (sobj);
 853       return false;
 854     }
 855
 856   lseek (fd, file_offset + offset, SEEK_SET);
 857   data = (char *)xmalloc (length);
 858   read (fd, data, length);
 859   fopts = data;
 860   do
 861     {
 862       struct cl_decoded_option *f2decoded_options;
 863       unsigned int f2decoded_options_count;
 864       get_options_from_collect_gcc_options (collect_gcc,
 865                                             fopts, CL_LANG_ALL,
 866                                             &f2decoded_options,
 867                                             &f2decoded_options_count);
 868       if (!fdecoded_options)
 869        {
 870          fdecoded_options = f2decoded_options;
 871          fdecoded_options_count = f2decoded_options_count;
 872        }
 873       else
 874         merge_and_complain (&fdecoded_options,
 875                             &fdecoded_options_count,
 876                             f2decoded_options, f2decoded_options_count);
 877
 878       fopts += strlen (fopts) + 1;
 879     }
 880   while (fopts - data < length);
 881
 882   free (data);
 883   simple_object_release_read (sobj);
 884   *opts = fdecoded_options;
 885   *opt_count = fdecoded_options_count;
 886   return true;
 887 }
 888
 889 /* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
 890
 891 static void
 892 run_gcc (unsigned argc, char *argv[])
 893 {
 894   unsigned i, j;
 895   const char **new_argv;
 896   const char **argv_ptr;
 897   char *list_option_full = NULL;
 898   const char *linker_output = NULL;
 899   const char *collect_gcc, *collect_gcc_options;
 900   int parallel = 0;
 901   int jobserver = 0;
 902   bool no_partition = false;
 903   struct cl_decoded_option *fdecoded_options = NULL;
 904   struct cl_decoded_option *offload_fdecoded_options = NULL;
 905   unsigned int fdecoded_options_count = 0;
 906   unsigned int offload_fdecoded_options_count = 0;
 907   struct cl_decoded_option *decoded_options;
 908   unsigned int decoded_options_count;
 909   struct obstack argv_obstack;
 910   int new_head_argc;
 911   bool have_lto = false;
 912   bool have_offload = false;
 913   unsigned lto_argc = 0, offload_argc = 0;
 914   char **lto_argv, **offload_argv;
 915
 916   /* Get the driver and options.  */
 917   collect_gcc = getenv ("COLLECT_GCC");
 918   if (!collect_gcc)
 919     fatal_error (input_location,
 920                  "environment variable COLLECT_GCC must be set");
 921   collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
 922   if (!collect_gcc_options)
 923     fatal_error (input_location,
 924                  "environment variable COLLECT_GCC_OPTIONS must be set");
 925   get_options_from_collect_gcc_options (collect_gcc, collect_gcc_options,
 926                                         CL_LANG_ALL,
 927                                         &decoded_options,
 928                                         &decoded_options_count);
 929
 930   /* Allocate arrays for input object files with LTO or offload IL,
 931      and for possible preceding arguments.  */
 932   lto_argv = XNEWVEC (char *, argc);
 933   offload_argv = XNEWVEC (char *, argc);
 934
 935   /* Look at saved options in the IL files.  */
 936   for (i = 1; i < argc; ++i)
 937     {
 938       char *p;
 939       int fd;
 940       off_t file_offset = 0;
 941       long loffset;
 942       int consumed;
 943       char *filename = argv[i];
 944
 945       if ((p = strrchr (argv[i], '@'))
 946           && p != argv[i]
 947           && sscanf (p, "@%li%n", &loffset, &consumed) >= 1
 948           && strlen (p) == (unsigned int) consumed)
 949         {
 950           filename = XNEWVEC (char, p - argv[i] + 1);
 951           memcpy (filename, argv[i], p - argv[i]);
 952           filename[p - argv[i]] = '\0';
 953           file_offset = (off_t) loffset;
 954         }
 955       fd = open (filename, O_RDONLY | O_BINARY);
 956       if (fd == -1)
 957         {
 958           lto_argv[lto_argc++] = argv[i];
 959           continue;
 960         }
 961
 962       if (find_and_merge_options (fd, file_offset, LTO_SECTION_NAME_PREFIX,
 963                                   &fdecoded_options, &fdecoded_options_count,
 964                                   collect_gcc))
 965         {
 966           have_lto = true;
 967           lto_argv[lto_argc++] = argv[i];
 968         }
 969
 970       if (find_and_merge_options (fd, file_offset, OFFLOAD_SECTION_NAME_PREFIX,
 971                                   &offload_fdecoded_options,
 972                                   &offload_fdecoded_options_count, collect_gcc))
 973         {
 974           have_offload = true;
 975           offload_argv[offload_argc++] = argv[i];
 976         }
 977
 978       close (fd);
 979     }
 980
 981   /* Initalize the common arguments for the driver.  */
 982   obstack_init (&argv_obstack);
 983   obstack_ptr_grow (&argv_obstack, collect_gcc);
 984   obstack_ptr_grow (&argv_obstack, "-xlto");
 985   obstack_ptr_grow (&argv_obstack, "-c");
 986
 987   append_compiler_options (&argv_obstack, fdecoded_options,
 988                            fdecoded_options_count);
 989   append_linker_options (&argv_obstack, decoded_options, decoded_options_count);
 990
 991   /* Scan linker driver arguments for things that are of relevance to us.  */
 992   for (j = 1; j < decoded_options_count; ++j)
 993     {
 994       struct cl_decoded_option *option = &decoded_options[j];
 995       switch (option->opt_index)
 996         {
 997         case OPT_o:
 998           linker_output = option->arg;
 999           break;
1000
1001         case OPT_save_temps:
1002           save_temps = 1;
1003           break;
1004
1005         case OPT_v:
1006           verbose = 1;
1007           break;
1008
1009         case OPT_flto_partition_:
1010           if (strcmp (option->arg, "none") == 0)
1011             no_partition = true;
1012           break;
1013
1014         case OPT_flto_:
1015           if (strcmp (option->arg, "jobserver") == 0)
1016             {
1017               jobserver = 1;
1018               parallel = 1;
1019             }
1020           else
1021             {
1022               parallel = atoi (option->arg);
1023               if (parallel <= 1)
1024                 parallel = 0;
1025             }
1026           /* Fallthru.  */
1027
1028         case OPT_flto:
1029           lto_mode = LTO_MODE_WHOPR;
1030           break;
1031
1032         default:
1033           break;
1034         }
1035     }
1036
1037   if (no_partition)
1038     {
1039       lto_mode = LTO_MODE_LTO;
1040       jobserver = 0;
1041       parallel = 0;
1042     }
1043
1044   if (linker_output)
1045     {
1046       char *output_dir, *base, *name;
1047       bool bit_bucket = strcmp (linker_output, HOST_BIT_BUCKET) == 0;
1048
1049       output_dir = xstrdup (linker_output);
1050       base = output_dir;
1051       for (name = base; *name; name++)
1052         if (IS_DIR_SEPARATOR (*name))
1053           base = name + 1;
1054       *base = '\0';
1055
1056       linker_output = &linker_output[base - output_dir];
1057       if (*output_dir == '\0')
1058         {
1059           static char current_dir[] = { '.', DIR_SEPARATOR, '\0' };
1060           output_dir = current_dir;
1061         }
1062       if (!bit_bucket)
1063         {
1064           obstack_ptr_grow (&argv_obstack, "-dumpdir");
1065           obstack_ptr_grow (&argv_obstack, output_dir);
1066         }
1067
1068       obstack_ptr_grow (&argv_obstack, "-dumpbase");
1069     }
1070
1071   /* Remember at which point we can scrub args to re-use the commons.  */
1072   new_head_argc = obstack_object_size (&argv_obstack) / sizeof (void *);
1073
1074   if (have_offload)
1075     {
1076       compile_images_for_offload_targets (offload_argc, offload_argv,
1077                                           offload_fdecoded_options,
1078                                           offload_fdecoded_options_count,
1079                                           decoded_options,
1080                                           decoded_options_count);
1081       if (offload_names)
1082         {
1083           find_offloadbeginend ();
1084           for (i = 0; offload_names[i]; i++)
1085             printf ("%s\n", offload_names[i]);
1086           free_array_of_ptrs ((void **) offload_names, i);
1087         }
1088     }
1089
1090   if (offloadbegin)
1091     printf ("%s\n", offloadbegin);
1092
1093   /* If object files contain offload sections, but do not contain LTO sections,
1094      then there is no need to perform a link-time recompilation, i.e.
1095      lto-wrapper is used only for a compilation of offload images.  */
1096   if (have_offload && !have_lto)
1097     {
1098       for (i = 1; i < argc; ++i)
1099         if (strncmp (argv[i], "-fresolution=", sizeof ("-fresolution=") - 1))
1100           {
1101             char *out_file;
1102             /* Can be ".o" or ".so".  */
1103             char *ext = strrchr (argv[i], '.');
1104             if (ext == NULL)
1105               out_file = make_temp_file ("");
1106             else
1107               out_file = make_temp_file (ext);
1108             /* The linker will delete the files we give it, so make copies.  */
1109             copy_file (out_file, argv[i]);
1110             printf ("%s\n", out_file);
1111           }
1112       goto finish;
1113     }
1114
1115   if (lto_mode == LTO_MODE_LTO)
1116     {
1117       flto_out = make_temp_file (".lto.o");
1118       if (linker_output)
1119         obstack_ptr_grow (&argv_obstack, linker_output);
1120       obstack_ptr_grow (&argv_obstack, "-o");
1121       obstack_ptr_grow (&argv_obstack, flto_out);
1122     }
1123   else
1124     {
1125       const char *list_option = "-fltrans-output-list=";
1126       size_t list_option_len = strlen (list_option);
1127       char *tmp;
1128
1129       if (linker_output)
1130         {
1131           char *dumpbase = (char *) xmalloc (strlen (linker_output)
1132                                              + sizeof (".wpa") + 1);
1133           strcpy (dumpbase, linker_output);
1134           strcat (dumpbase, ".wpa");
1135           obstack_ptr_grow (&argv_obstack, dumpbase);
1136         }
1137
1138       if (linker_output && save_temps)
1139         {
1140           ltrans_output_file = (char *) xmalloc (strlen (linker_output)
1141                                                  + sizeof (".ltrans.out") + 1);
1142           strcpy (ltrans_output_file, linker_output);
1143           strcat (ltrans_output_file, ".ltrans.out");
1144         }
1145       else
1146         ltrans_output_file = make_temp_file (".ltrans.out");
1147       list_option_full = (char *) xmalloc (sizeof (char) *
1148                          (strlen (ltrans_output_file) + list_option_len + 1));
1149       tmp = list_option_full;
1150
1151       obstack_ptr_grow (&argv_obstack, tmp);
1152       strcpy (tmp, list_option);
1153       tmp += list_option_len;
1154       strcpy (tmp, ltrans_output_file);
1155
1156       if (jobserver)
1157         obstack_ptr_grow (&argv_obstack, xstrdup ("-fwpa=jobserver"));
1158       else if (parallel > 1)
1159         {
1160           char buf[256];
1161           sprintf (buf, "-fwpa=%i", parallel);
1162           obstack_ptr_grow (&argv_obstack, xstrdup (buf));
1163         }
1164       else
1165         obstack_ptr_grow (&argv_obstack, "-fwpa");
1166     }
1167
1168   /* Append the input objects and possible preceding arguments.  */
1169   for (i = 0; i < lto_argc; ++i)
1170     obstack_ptr_grow (&argv_obstack, lto_argv[i]);
1171   obstack_ptr_grow (&argv_obstack, NULL);
1172
1173   new_argv = XOBFINISH (&argv_obstack, const char **);
1174   argv_ptr = &new_argv[new_head_argc];
1175   fork_execute (new_argv[0], CONST_CAST (char **, new_argv), true);
1176
1177   if (lto_mode == LTO_MODE_LTO)
1178     {
1179       printf ("%s\n", flto_out);
1180       free (flto_out);
1181       flto_out = NULL;
1182     }
1183   else
1184     {
1185       FILE *stream = fopen (ltrans_output_file, "r");
1186       FILE *mstream = NULL;
1187       struct obstack env_obstack;
1188
1189       if (!stream)
1190         fatal_error (input_location, "fopen: %s: %m", ltrans_output_file);
1191
1192       /* Parse the list of LTRANS inputs from the WPA stage.  */
1193       obstack_init (&env_obstack);
1194       nr = 0;
1195       for (;;)
1196         {
1197           const unsigned piece = 32;
1198           char *output_name = NULL;
1199           char *buf, *input_name = (char *)xmalloc (piece);
1200           size_t len;
1201
1202           buf = input_name;
1203 cont:
1204           if (!fgets (buf, piece, stream))
1205             break;
1206           len = strlen (input_name);
1207           if (input_name[len - 1] != '\n')
1208             {
1209               input_name = (char *)xrealloc (input_name, len + piece);
1210               buf = input_name + len;
1211               goto cont;
1212             }
1213           input_name[len - 1] = '\0';
1214
1215           if (input_name[0] == '*')
1216             output_name = &input_name[1];
1217
1218           nr++;
1219           input_names = (char **)xrealloc (input_names, nr * sizeof (char *));
1220           output_names = (char **)xrealloc (output_names, nr * sizeof (char *));
1221           input_names[nr-1] = input_name;
1222           output_names[nr-1] = output_name;
1223         }
1224       fclose (stream);
1225       maybe_unlink (ltrans_output_file);
1226       ltrans_output_file = NULL;
1227
1228       if (parallel)
1229         {
1230           makefile = make_temp_file (".mk");
1231           mstream = fopen (makefile, "w");
1232         }
1233
1234       /* Execute the LTRANS stage for each input file (or prepare a
1235          makefile to invoke this in parallel).  */
1236       for (i = 0; i < nr; ++i)
1237         {
1238           char *output_name;
1239           char *input_name = input_names[i];
1240           /* If it's a pass-through file do nothing.  */
1241           if (output_names[i])
1242             continue;
1243
1244           /* Replace the .o suffix with a .ltrans.o suffix and write
1245              the resulting name to the LTRANS output list.  */
1246           obstack_grow (&env_obstack, input_name, strlen (input_name) - 2);
1247           obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
1248           output_name = XOBFINISH (&env_obstack, char *);
1249
1250           /* Adjust the dumpbase if the linker output file was seen.  */
1251           if (linker_output)
1252             {
1253               char *dumpbase
1254                   = (char *) xmalloc (strlen (linker_output)
1255                                       + sizeof (DUMPBASE_SUFFIX) + 1);
1256               snprintf (dumpbase,
1257                         strlen (linker_output) + sizeof (DUMPBASE_SUFFIX),
1258                         "%s.ltrans%u", linker_output, i);
1259               argv_ptr[0] = dumpbase;
1260             }
1261
1262           argv_ptr[1] = "-fltrans";
1263           argv_ptr[2] = "-o";
1264           argv_ptr[3] = output_name;
1265           argv_ptr[4] = input_name;
1266           argv_ptr[5] = NULL;
1267           if (parallel)
1268             {
1269               fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]);
1270               for (j = 1; new_argv[j] != NULL; ++j)
1271                 fprintf (mstream, " '%s'", new_argv[j]);
1272               fprintf (mstream, "\n");
1273               /* If we are not preserving the ltrans input files then
1274                  truncate them as soon as we have processed it.  This
1275                  reduces temporary disk-space usage.  */
1276               if (! save_temps)
1277                 fprintf (mstream, "\t@-touch -r %s %s.tem > /dev/null 2>&1 "
1278                          "&& mv %s.tem %s\n",
1279                          input_name, input_name, input_name, input_name);
1280             }
1281           else
1282             {
1283               fork_execute (new_argv[0], CONST_CAST (char **, new_argv),
1284                             true);
1285               maybe_unlink (input_name);
1286             }
1287
1288           output_names[i] = output_name;
1289         }
1290       if (parallel)
1291         {
1292           struct pex_obj *pex;
1293           char jobs[32];
1294
1295           fprintf (mstream, "all:");
1296           for (i = 0; i < nr; ++i)
1297             fprintf (mstream, " \\\n\t%s", output_names[i]);
1298           fprintf (mstream, "\n");
1299           fclose (mstream);
1300           if (!jobserver)
1301             {
1302               /* Avoid passing --jobserver-fd= and similar flags
1303                  unless jobserver mode is explicitly enabled.  */
1304               putenv (xstrdup ("MAKEFLAGS="));
1305               putenv (xstrdup ("MFLAGS="));
1306             }
1307           new_argv[0] = getenv ("MAKE");
1308           if (!new_argv[0])
1309             new_argv[0] = "make";
1310           new_argv[1] = "-f";
1311           new_argv[2] = makefile;
1312           i = 3;
1313           if (!jobserver)
1314             {
1315               snprintf (jobs, 31, "-j%d", parallel);
1316               new_argv[i++] = jobs;
1317             }
1318           new_argv[i++] = "all";
1319           new_argv[i++] = NULL;
1320           pex = collect_execute (new_argv[0], CONST_CAST (char **, new_argv),
1321                                  NULL, NULL, PEX_SEARCH, false);
1322           do_wait (new_argv[0], pex);
1323           maybe_unlink (makefile);
1324           makefile = NULL;
1325           for (i = 0; i < nr; ++i)
1326             maybe_unlink (input_names[i]);
1327         }
1328       for (i = 0; i < nr; ++i)
1329         {
1330           fputs (output_names[i], stdout);
1331           putc ('\n', stdout);
1332           free (input_names[i]);
1333         }
1334       nr = 0;
1335       free (output_names);
1336       free (input_names);
1337       free (list_option_full);
1338       obstack_free (&env_obstack, NULL);
1339     }
1340
1341  finish:
1342   if (offloadend)
1343     printf ("%s\n", offloadend);
1344
1345   XDELETE (lto_argv);
1346   XDELETE (offload_argv);
1347   obstack_free (&argv_obstack, NULL);
1348 }
1349
1350
1351 /* Entry point.  */
1352
1353 int
1354 main (int argc, char *argv[])
1355 {
1356   const char *p;
1357
1358   init_opts_obstack ();
1359
1360   p = argv[0] + strlen (argv[0]);
1361   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
1362     --p;
1363   progname = p;
1364
1365   xmalloc_set_program_name (progname);
1366
1367   gcc_init_libintl ();
1368
1369   diagnostic_initialize (global_dc, 0);
1370
1371   if (atexit (lto_wrapper_cleanup) != 0)
1372     fatal_error (input_location, "atexit failed");
1373
1374   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1375     signal (SIGINT, fatal_signal);
1376 #ifdef SIGHUP
1377   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
1378     signal (SIGHUP, fatal_signal);
1379 #endif
1380   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
1381     signal (SIGTERM, fatal_signal);
1382 #ifdef SIGPIPE
1383   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
1384     signal (SIGPIPE, fatal_signal);
1385 #endif
1386 #ifdef SIGCHLD
1387   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
1388      receive the signal.  A different setting is inheritable */
1389   signal (SIGCHLD, SIG_DFL);
1390 #endif
1391
1392   /* We may be called with all the arguments stored in some file and
1393      passed with @file.  Expand them into argv before processing.  */
1394   expandargv (&argc, &argv);
1395
1396   run_gcc (argc, argv);
1397
1398   return 0;
1399 }