gcc/lto-wrapper.c

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