LCOV - code coverage report
Current view: top level - gcc - lto-opts.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 73 86 84.9 %
Date: 2020-04-04 11:58:09 Functions: 2 2 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* LTO IL options.
       2                 :            : 
       3                 :            :    Copyright (C) 2009-2020 Free Software Foundation, Inc.
       4                 :            :    Contributed by Simon Baldwin <simonb@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                 :            : #include "config.h"
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "backend.h"
      26                 :            : #include "target.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "gimple.h"
      29                 :            : #include "cgraph.h"
      30                 :            : #include "lto-streamer.h"
      31                 :            : #include "opts.h"
      32                 :            : #include "toplev.h"
      33                 :            : 
      34                 :            : /* Append the option piece OPT to the COLLECT_GCC_OPTIONS string
      35                 :            :    set up by OB, appropriately quoted and separated by spaces
      36                 :            :    (if !*FIRST_P).  */
      37                 :            : 
      38                 :            : static void
      39                 :     274370 : append_to_collect_gcc_options (struct obstack *ob,
      40                 :            :                                bool *first_p, const char *opt)
      41                 :            : {
      42                 :     274370 :   const char *p, *q = opt;
      43                 :     274370 :   if (!*first_p)
      44                 :     252532 :     obstack_grow (ob, " ", 1);
      45                 :     274370 :   obstack_grow (ob, "'", 1);
      46                 :     274370 :   while ((p = strchr (q, '\'')))
      47                 :            :     {
      48                 :          0 :       obstack_grow (ob, q, p - q);
      49                 :          0 :       obstack_grow (ob, "'\\''", 4);
      50                 :          0 :       q = ++p;
      51                 :            :     }
      52                 :     274370 :   obstack_grow (ob, q, strlen (q));
      53                 :     274370 :   obstack_grow (ob, "'", 1);
      54                 :     274370 :   *first_p = false;
      55                 :     274370 : }
      56                 :            : 
      57                 :            : /* Write currently held options to an LTO IL section.  */
      58                 :            : 
      59                 :            : void
      60                 :      21838 : lto_write_options (void)
      61                 :            : {
      62                 :      21838 :   char *section_name;
      63                 :      21838 :   struct obstack temporary_obstack;
      64                 :      21838 :   unsigned int i, j;
      65                 :      21838 :   char *args;
      66                 :      21838 :   bool first_p = true;
      67                 :            : 
      68                 :      21838 :   section_name = lto_get_section_name (LTO_section_opts, NULL, 0, NULL);
      69                 :      21838 :   lto_begin_section (section_name, false);
      70                 :            : 
      71                 :      21838 :   obstack_init (&temporary_obstack);
      72                 :            : 
      73                 :      21838 :   if (!global_options_set.x_flag_openmp
      74                 :      16416 :       && !global_options.x_flag_openmp)
      75                 :      16416 :     append_to_collect_gcc_options (&temporary_obstack, &first_p,
      76                 :            :                                    "-fno-openmp");
      77                 :      21838 :   if (!global_options_set.x_flag_openacc
      78                 :      16447 :       && !global_options.x_flag_openacc)
      79                 :      16447 :     append_to_collect_gcc_options (&temporary_obstack, &first_p,
      80                 :            :                                    "-fno-openacc");
      81                 :            :   /* Append PIC/PIE mode because its default depends on target and it is
      82                 :            :      subject of merging in lto-wrapper.  */
      83                 :      21838 :   if (!global_options_set.x_flag_pic && !global_options_set.x_flag_pie)
      84                 :            :     {
      85                 :      16153 :        append_to_collect_gcc_options (&temporary_obstack, &first_p,
      86                 :      16153 :                                       global_options.x_flag_pic == 2
      87                 :            :                                       ? "-fPIC"
      88                 :            :                                       : global_options.x_flag_pic == 1
      89                 :      16153 :                                       ? "-fpic"
      90                 :      16153 :                                       : global_options.x_flag_pie == 2
      91                 :      16153 :                                       ? "-fPIE"
      92                 :            :                                       : global_options.x_flag_pie == 1
      93                 :      16153 :                                       ? "-fpie"
      94                 :            :                                       : "-fno-pie");
      95                 :            :     }
      96                 :            : 
      97                 :            :   /* If debug info is enabled append -g.  */
      98                 :      21838 :   if (debug_info_level > DINFO_LEVEL_NONE)
      99                 :       1341 :     append_to_collect_gcc_options (&temporary_obstack, &first_p, "-g");
     100                 :            : 
     101                 :            :   /* Append options from target hook and store them to offload_lto section.  */
     102                 :      21838 :   if (lto_stream_offload_p)
     103                 :            :     {
     104                 :          0 :       char *offload_opts = targetm.offload_options ();
     105                 :          0 :       char *offload_ptr = offload_opts;
     106                 :          0 :       while (offload_ptr)
     107                 :            :        {
     108                 :          0 :          char *next = strchr (offload_ptr, ' ');
     109                 :          0 :          if (next)
     110                 :          0 :            *next++ = '\0';
     111                 :          0 :          append_to_collect_gcc_options (&temporary_obstack, &first_p,
     112                 :            :                                         offload_ptr);
     113                 :          0 :          offload_ptr = next;
     114                 :            :        }
     115                 :          0 :       free (offload_opts);
     116                 :            :     }
     117                 :            : 
     118                 :            :   /* Output explicitly passed options.  */
     119                 :     509405 :   for (i = 1; i < save_decoded_options_count; ++i)
     120                 :            :     {
     121                 :     487567 :       struct cl_decoded_option *option = &save_decoded_options[i];
     122                 :            : 
     123                 :            :       /* Skip explicitly some common options that we do not need.  */
     124                 :     487567 :       switch (option->opt_index)
     125                 :            :       {
     126                 :      54901 :         case OPT_dumpbase:
     127                 :      54901 :         case OPT_SPECIAL_unknown:
     128                 :      54901 :         case OPT_SPECIAL_ignore:
     129                 :      54901 :         case OPT_SPECIAL_warn_removed:
     130                 :      54901 :         case OPT_SPECIAL_program_name:
     131                 :      54901 :         case OPT_SPECIAL_input_file:
     132                 :      54901 :         case OPT_dumpdir:
     133                 :      54901 :         case OPT_fresolution_:
     134                 :      54901 :         case OPT_fdebug_prefix_map_:
     135                 :      54901 :         case OPT_ffile_prefix_map_:
     136                 :      54901 :         case OPT_fmacro_prefix_map_:
     137                 :      54901 :           continue;
     138                 :            : 
     139                 :     432666 :         default:
     140                 :     432666 :           break;
     141                 :            :       }
     142                 :            : 
     143                 :            :       /* Skip frontend and driver specific options here.  */
     144                 :     432666 :       if (!(cl_options[option->opt_index].flags & (CL_COMMON|CL_TARGET|CL_LTO)))
     145                 :      73338 :         continue;
     146                 :            : 
     147                 :            :       /* Do not store target-specific options in offload_lto section.  */
     148                 :     359328 :       if ((cl_options[option->opt_index].flags & CL_TARGET)
     149                 :      47504 :           && lto_stream_offload_p)
     150                 :          0 :        continue;
     151                 :            : 
     152                 :            :       /* Drop options created from the gcc driver that will be rejected
     153                 :            :          when passed on to the driver again.  */
     154                 :     359328 :       if (cl_options[option->opt_index].cl_reject_driver)
     155                 :      59941 :         continue;
     156                 :            : 
     157                 :            :       /* Also drop all options that are handled by the driver as well,
     158                 :            :          which includes things like -o and -v or -fhelp for example.
     159                 :            :          We do not need those.  The only exception is -foffload option, if we
     160                 :            :          write it in offload_lto section.  Also drop all diagnostic options.  */
     161                 :     299387 :       if ((cl_options[option->opt_index].flags & (CL_DRIVER|CL_WARNING))
     162                 :      75374 :           && (!lto_stream_offload_p || option->opt_index != OPT_foffload_))
     163                 :      75374 :         continue;
     164                 :            : 
     165                 :     448026 :       for (j = 0; j < option->canonical_option_num_elements; ++j)
     166                 :     224013 :         append_to_collect_gcc_options (&temporary_obstack, &first_p,
     167                 :            :                                        option->canonical_option[j]);
     168                 :            :     }
     169                 :            : 
     170                 :      21838 :   const char *collect_as_options = getenv ("COLLECT_AS_OPTIONS");
     171                 :      21838 :   if (collect_as_options)
     172                 :          2 :     prepend_xassembler_to_collect_as_options (collect_as_options,
     173                 :            :                                               &temporary_obstack);
     174                 :            : 
     175                 :      21838 :   obstack_grow (&temporary_obstack, "\0", 1);
     176                 :      21838 :   args = XOBFINISH (&temporary_obstack, char *);
     177                 :      21838 :   lto_write_data (args, strlen (args) + 1);
     178                 :      21838 :   lto_end_section ();
     179                 :            : 
     180                 :      21838 :   obstack_free (&temporary_obstack, NULL);
     181                 :      21838 :   free (section_name);
     182                 :      21838 : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.