LCOV - code coverage report
Current view: top level - gcc/fortran - options.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 356 410 86.8 %
Date: 2020-03-28 11:57:23 Functions: 12 14 85.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Parse and display command line options.
       2                 :            :    Copyright (C) 2000-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Andy Vaught
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "target.h"
      25                 :            : #include "tree.h"
      26                 :            : #include "gfortran.h"
      27                 :            : #include "diagnostic.h"       /* For global_dc.  */
      28                 :            : #include "opts.h"
      29                 :            : #include "toplev.h"  /* For save_decoded_options.  */
      30                 :            : #include "cpp.h"
      31                 :            : #include "langhooks.h"
      32                 :            : 
      33                 :            : gfc_option_t gfc_option;
      34                 :            : 
      35                 :            : #define SET_FLAG(flag, condition, on_value, off_value) \
      36                 :            :   do \
      37                 :            :     { \
      38                 :            :       if (condition) \
      39                 :            :         flag = (on_value); \
      40                 :            :       else \
      41                 :            :         flag = (off_value); \
      42                 :            :     } while (0)
      43                 :            : 
      44                 :            : #define SET_BITFLAG2(m) m
      45                 :            : 
      46                 :            : #define SET_BITFLAG(flag, condition, value) \
      47                 :            :   SET_BITFLAG2 (SET_FLAG (flag, condition, (flag | (value)), (flag & ~(value))))
      48                 :            : 
      49                 :            : 
      50                 :            : /* Set flags that control warnings and errors for different
      51                 :            :    Fortran standards to their default values.  Keep in sync with
      52                 :            :    libgfortran/runtime/compile_options.c (init_compile_options).  */
      53                 :            : 
      54                 :            : static void
      55                 :      26316 : set_default_std_flags (void)
      56                 :            : {
      57                 :      26316 :   gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
      58                 :            :     | GFC_STD_F2003 | GFC_STD_F2008 | GFC_STD_F95 | GFC_STD_F77
      59                 :            :     | GFC_STD_F2008_OBS | GFC_STD_GNU | GFC_STD_LEGACY
      60                 :            :     | GFC_STD_F2018 | GFC_STD_F2018_DEL | GFC_STD_F2018_OBS;
      61                 :      26316 :   gfc_option.warn_std = GFC_STD_F2018_DEL | GFC_STD_F95_DEL | GFC_STD_LEGACY;
      62                 :        332 : }
      63                 :            : 
      64                 :            : /* Set (or unset) the DEC extension flags.  */
      65                 :            : 
      66                 :            : static void
      67                 :      25423 : set_dec_flags (int value)
      68                 :            : {
      69                 :            :   /* Set (or unset) other DEC compatibility extensions.  */
      70                 :      25423 :   SET_BITFLAG (flag_dollar_ok, value, value);
      71                 :      25423 :   SET_BITFLAG (flag_cray_pointer, value, value);
      72                 :      25423 :   SET_BITFLAG (flag_dec_structure, value, value);
      73                 :      25423 :   SET_BITFLAG (flag_dec_intrinsic_ints, value, value);
      74                 :      25423 :   SET_BITFLAG (flag_dec_static, value, value);
      75                 :      25423 :   SET_BITFLAG (flag_dec_math, value, value);
      76                 :      25423 :   SET_BITFLAG (flag_dec_include, value, value);
      77                 :      25423 :   SET_BITFLAG (flag_dec_format_defaults, value, value);
      78                 :      25423 :   SET_BITFLAG (flag_dec_blank_format_item, value, value);
      79                 :      25423 :   SET_BITFLAG (flag_dec_char_conversions, value, value);
      80                 :      25423 : }
      81                 :            : 
      82                 :            : /* Finalize DEC flags.  */
      83                 :            : 
      84                 :            : static void
      85                 :      25213 : post_dec_flags (int value)
      86                 :            : {
      87                 :            :   /* Don't warn for legacy code if -fdec is given; however, setting -fno-dec
      88                 :            :      does not force these warnings.  We make one final determination on this
      89                 :            :      at the end because -std= is always set first; thus, we can avoid
      90                 :            :      clobbering the user's desired standard settings in gfc_handle_option
      91                 :            :      e.g. when -fdec and -fno-dec are both given.  */
      92                 :          0 :   if (value)
      93                 :            :     {
      94                 :        198 :       gfc_option.allow_std |= GFC_STD_F95_OBS | GFC_STD_F95_DEL
      95                 :            :         | GFC_STD_GNU | GFC_STD_LEGACY;
      96                 :        198 :       gfc_option.warn_std &= ~(GFC_STD_LEGACY | GFC_STD_F95_DEL);
      97                 :            :     }
      98                 :          0 : }
      99                 :            : 
     100                 :            : /* Enable (or disable) -finit-local-zero.  */
     101                 :            : 
     102                 :            : static void
     103                 :      25265 : set_init_local_zero (int value)
     104                 :            : {
     105                 :      25265 :   gfc_option.flag_init_integer_value = 0;
     106                 :      25265 :   gfc_option.flag_init_character_value = (char)0;
     107                 :            : 
     108                 :         51 :   SET_FLAG (gfc_option.flag_init_integer, value, GFC_INIT_INTEGER_ON,
     109                 :            :             GFC_INIT_INTEGER_OFF);
     110                 :         51 :   SET_FLAG (gfc_option.flag_init_logical, value, GFC_INIT_LOGICAL_FALSE,
     111                 :            :             GFC_INIT_LOGICAL_OFF);
     112                 :         51 :   SET_FLAG (gfc_option.flag_init_character, value, GFC_INIT_CHARACTER_ON,
     113                 :            :             GFC_INIT_CHARACTER_OFF);
     114                 :         51 :   SET_FLAG (flag_init_real, value, GFC_INIT_REAL_ZERO, GFC_INIT_REAL_OFF);
     115                 :         51 : }
     116                 :            : 
     117                 :            : /* Return language mask for Fortran options.  */
     118                 :            : 
     119                 :            : unsigned int
     120                 :     276070 : gfc_option_lang_mask (void)
     121                 :            : {
     122                 :     276070 :   return CL_Fortran;
     123                 :            : }
     124                 :            : 
     125                 :            : /* Initialize options structure OPTS.  */
     126                 :            : 
     127                 :            : void
     128                 :      25542 : gfc_init_options_struct (struct gcc_options *opts)
     129                 :            : {
     130                 :      25542 :   opts->x_flag_errno_math = 0;
     131                 :      25542 :   opts->frontend_set_flag_errno_math = true;
     132                 :      25542 :   opts->x_flag_associative_math = -1;
     133                 :      25542 :   opts->frontend_set_flag_associative_math = true;
     134                 :      25542 : }
     135                 :            : 
     136                 :            : /* Get ready for options handling. Keep in sync with
     137                 :            :    libgfortran/runtime/compile_options.c (init_compile_options).  */
     138                 :            : 
     139                 :            : void
     140                 :      25214 : gfc_init_options (unsigned int decoded_options_count,
     141                 :            :                   struct cl_decoded_option *decoded_options)
     142                 :            : {
     143                 :      25214 :   gfc_source_file = NULL;
     144                 :      25214 :   gfc_option.module_dir = NULL;
     145                 :      25214 :   gfc_option.source_form = FORM_UNKNOWN;
     146                 :      25214 :   gfc_option.max_continue_fixed = 255;
     147                 :      25214 :   gfc_option.max_continue_free = 255;
     148                 :      25214 :   gfc_option.max_identifier_length = GFC_MAX_SYMBOL_LEN;
     149                 :      25214 :   gfc_option.max_errors = 25;
     150                 :            : 
     151                 :      25214 :   gfc_option.flag_preprocessed = 0;
     152                 :      25214 :   gfc_option.flag_d_lines = -1;
     153                 :      25214 :   set_init_local_zero (0);
     154                 :            :   
     155                 :      25214 :   gfc_option.fpe = 0;
     156                 :            :   /* All except GFC_FPE_INEXACT.  */
     157                 :      25214 :   gfc_option.fpe_summary = GFC_FPE_INVALID | GFC_FPE_DENORMAL
     158                 :            :                            | GFC_FPE_ZERO | GFC_FPE_OVERFLOW
     159                 :            :                            | GFC_FPE_UNDERFLOW;
     160                 :      25214 :   gfc_option.rtcheck = 0;
     161                 :            : 
     162                 :            :   /* ??? Wmissing-include-dirs is disabled by default in C/C++ but
     163                 :            :      enabled by default in Fortran.  Ideally, we should express this
     164                 :            :      in .opt, but that is not supported yet.  */
     165                 :      25214 :   SET_OPTION_IF_UNSET (&global_options, &global_options_set,
     166                 :            :                        cpp_warn_missing_include_dirs, 1);
     167                 :            : 
     168                 :      25214 :   set_dec_flags (0);
     169                 :            : 
     170                 :      25214 :   set_default_std_flags ();
     171                 :            : 
     172                 :            :   /* Initialize cpp-related options.  */
     173                 :      25214 :   gfc_cpp_init_options (decoded_options_count, decoded_options);
     174                 :      25214 :   gfc_diagnostics_init ();
     175                 :      25214 : }
     176                 :            : 
     177                 :            : 
     178                 :            : /* Determine the source form from the filename extension.  We assume
     179                 :            :    case insensitivity.  */
     180                 :            : 
     181                 :            : static gfc_source_form
     182                 :      23402 : form_from_filename (const char *filename)
     183                 :            : {
     184                 :      23402 :   static const struct
     185                 :            :   {
     186                 :            :     const char *extension;
     187                 :            :     gfc_source_form form;
     188                 :            :   }
     189                 :            :   exttype[] =
     190                 :            :   {
     191                 :            :     {
     192                 :            :     ".f90", FORM_FREE}
     193                 :            :     ,
     194                 :            :     {
     195                 :            :     ".f95", FORM_FREE}
     196                 :            :     ,
     197                 :            :     {
     198                 :            :     ".f03", FORM_FREE}
     199                 :            :     ,
     200                 :            :     {
     201                 :            :     ".f08", FORM_FREE}
     202                 :            :     ,
     203                 :            :     {
     204                 :            :     ".f", FORM_FIXED}
     205                 :            :     ,
     206                 :            :     {
     207                 :            :     ".for", FORM_FIXED}
     208                 :            :     ,
     209                 :            :     {
     210                 :            :     ".ftn", FORM_FIXED}
     211                 :            :     ,
     212                 :            :     {
     213                 :            :     "", FORM_UNKNOWN}
     214                 :            :   };            /* sentinel value */
     215                 :            : 
     216                 :      23402 :   gfc_source_form f_form;
     217                 :      23402 :   const char *fileext;
     218                 :      23402 :   int i;
     219                 :            : 
     220                 :            :   /* Find end of file name.  Note, filename is either a NULL pointer or
     221                 :            :      a NUL terminated string.  */
     222                 :      23402 :   i = 0;
     223                 :    2350350 :   while (filename[i] != '\0')
     224                 :    2326950 :     i++;
     225                 :            : 
     226                 :            :   /* Find last period.  */
     227                 :     117010 :   while (i >= 0 && (filename[i] != '.'))
     228                 :      93608 :     i--;
     229                 :            : 
     230                 :            :   /* Did we see a file extension?  */
     231                 :      23402 :   if (i < 0)
     232                 :            :     return FORM_UNKNOWN; /* Nope  */
     233                 :            : 
     234                 :            :   /* Get file extension and compare it to others.  */
     235                 :      23402 :   fileext = &(filename[i]);
     236                 :            : 
     237                 :      23402 :   i = -1;
     238                 :      23402 :   f_form = FORM_UNKNOWN;
     239                 :      28798 :   do
     240                 :            :     {
     241                 :      28798 :       i++;
     242                 :      28798 :       if (strcasecmp (fileext, exttype[i].extension) == 0)
     243                 :            :         {
     244                 :      23402 :           f_form = exttype[i].form;
     245                 :      23402 :           break;
     246                 :            :         }
     247                 :            :     }
     248                 :       5396 :   while (exttype[i].form != FORM_UNKNOWN);
     249                 :            : 
     250                 :            :   return f_form;
     251                 :            : }
     252                 :            : 
     253                 :            : 
     254                 :            : /* Finalize commandline options.  */
     255                 :            : 
     256                 :            : bool
     257                 :      25213 : gfc_post_options (const char **pfilename)
     258                 :            : {
     259                 :      25213 :   const char *filename = *pfilename, *canon_source_file = NULL;
     260                 :      25213 :   char *source_path;
     261                 :      25213 :   int i;
     262                 :            : 
     263                 :            :   /* Finalize DEC flags.  */
     264                 :      25213 :   post_dec_flags (flag_dec);
     265                 :            : 
     266                 :            :   /* Excess precision other than "fast" requires front-end
     267                 :            :      support.  */
     268                 :      25213 :   if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
     269                 :          0 :     sorry ("%<-fexcess-precision=standard%> for Fortran");
     270                 :      25213 :   flag_excess_precision = EXCESS_PRECISION_FAST;
     271                 :            : 
     272                 :            :   /* Fortran allows associative math - but we cannot reassociate if
     273                 :            :      we want traps or signed zeros. Cf. also flag_protect_parens.  */
     274                 :      25213 :   if (flag_associative_math == -1)
     275                 :      50270 :     flag_associative_math = (!flag_trapping_math && !flag_signed_zeros);
     276                 :            : 
     277                 :      25213 :   if (flag_protect_parens == -1)
     278                 :      25212 :     flag_protect_parens = !optimize_fast;
     279                 :            : 
     280                 :            :   /* -Ofast sets implies -fstack-arrays unless an explicit size is set for
     281                 :            :      stack arrays.  */
     282                 :      25213 :   if (flag_stack_arrays == -1 && flag_max_stack_var_size == -2)
     283                 :      25195 :     flag_stack_arrays = optimize_fast;
     284                 :            : 
     285                 :            :   /* By default, disable (re)allocation during assignment for -std=f95,
     286                 :            :      and enable it for F2003/F2008/GNU/Legacy.  */
     287                 :      25213 :   if (flag_realloc_lhs == -1)
     288                 :            :     {
     289                 :      25155 :       if (gfc_option.allow_std & GFC_STD_F2003)
     290                 :      25023 :         flag_realloc_lhs = 1;
     291                 :            :       else
     292                 :        132 :         flag_realloc_lhs = 0;
     293                 :            :     }
     294                 :            : 
     295                 :            :   /* -fbounds-check is equivalent to -fcheck=bounds */
     296                 :      25213 :   if (flag_bounds_check)
     297                 :        860 :     gfc_option.rtcheck |= GFC_RTCHECK_BOUNDS;
     298                 :            : 
     299                 :      25213 :   if (flag_compare_debug)
     300                 :         14 :     flag_dump_fortran_original = 0;
     301                 :            : 
     302                 :            :   /* Make -fmax-errors visible to gfortran's diagnostic machinery.  */
     303                 :      25213 :   if (global_options_set.x_flag_max_errors)
     304                 :         31 :     gfc_option.max_errors = flag_max_errors;
     305                 :            : 
     306                 :            :   /* Verify the input file name.  */
     307                 :      25213 :   if (!filename || strcmp (filename, "-") == 0)
     308                 :            :     {
     309                 :          0 :       filename = "";
     310                 :            :     }
     311                 :            : 
     312                 :      25213 :   if (gfc_option.flag_preprocessed)
     313                 :            :     {
     314                 :            :       /* For preprocessed files, if the first tokens are of the form # NUM.
     315                 :            :          handle the directives so we know the original file name.  */
     316                 :          2 :       gfc_source_file = gfc_read_orig_filename (filename, &canon_source_file);
     317                 :          2 :       if (gfc_source_file == NULL)
     318                 :          0 :         gfc_source_file = filename;
     319                 :            :       else
     320                 :          2 :         *pfilename = gfc_source_file;
     321                 :            :     }
     322                 :            :   else
     323                 :      25211 :     gfc_source_file = filename;
     324                 :            : 
     325                 :      25213 :   if (canon_source_file == NULL)
     326                 :      25212 :     canon_source_file = gfc_source_file;
     327                 :            : 
     328                 :            :   /* Adds the path where the source file is to the list of include files.  */
     329                 :            : 
     330                 :      25213 :   i = strlen (canon_source_file);
     331                 :     471696 :   while (i > 0 && !IS_DIR_SEPARATOR (canon_source_file[i]))
     332                 :     446483 :     i--;
     333                 :            : 
     334                 :      25213 :   if (i != 0)
     335                 :            :     {
     336                 :      25071 :       source_path = (char *) alloca (i + 1);
     337                 :      25071 :       memcpy (source_path, canon_source_file, i);
     338                 :      25071 :       source_path[i] = 0;
     339                 :      25071 :       gfc_add_include_path (source_path, true, true, true);
     340                 :            :     }
     341                 :            :   else
     342                 :        142 :     gfc_add_include_path (".", true, true, true);
     343                 :            : 
     344                 :      25213 :   if (canon_source_file != gfc_source_file)
     345                 :          1 :     free (CONST_CAST (char *, canon_source_file));
     346                 :            : 
     347                 :            :   /* Decide which form the file will be read in as.  */
     348                 :            : 
     349                 :      25213 :   if (gfc_option.source_form != FORM_UNKNOWN)
     350                 :       1811 :     gfc_current_form = gfc_option.source_form;
     351                 :            :   else
     352                 :            :     {
     353                 :      23402 :       gfc_current_form = form_from_filename (filename);
     354                 :            : 
     355                 :      23402 :       if (gfc_current_form == FORM_UNKNOWN)
     356                 :            :         {
     357                 :          0 :           gfc_current_form = FORM_FREE;
     358                 :          0 :           main_input_filename = filename;
     359                 :          0 :           gfc_warning_now (0, "Reading file %qs as free form", 
     360                 :          0 :                            (filename[0] == '\0') ? "<stdin>" : filename);
     361                 :            :         }
     362                 :            :     }
     363                 :            : 
     364                 :            :   /* If the user specified -fd-lines-as-{code|comments} verify that we're
     365                 :            :      in fixed form.  */
     366                 :      25213 :   if (gfc_current_form == FORM_FREE)
     367                 :            :     {
     368                 :      23415 :       if (gfc_option.flag_d_lines == 0)
     369                 :          0 :         gfc_warning_now (0, "%<-fd-lines-as-comments%> has no effect "
     370                 :            :                            "in free form");
     371                 :      23415 :       else if (gfc_option.flag_d_lines == 1)
     372                 :          0 :         gfc_warning_now (0, "%<-fd-lines-as-code%> has no effect in free form");
     373                 :            : 
     374                 :      23415 :       if (warn_line_truncation == -1)
     375                 :      22661 :           warn_line_truncation = 1;
     376                 :            : 
     377                 :            :       /* Enable -Werror=line-truncation when -Werror and -Wno-error have
     378                 :            :          not been set.  */
     379                 :      23415 :       if (warn_line_truncation && !global_options_set.x_warnings_are_errors
     380                 :      22757 :           && (global_dc->classify_diagnostic[OPT_Wline_truncation] ==
     381                 :            :               DK_UNSPECIFIED))
     382                 :      22757 :         diagnostic_classify_diagnostic (global_dc, OPT_Wline_truncation,
     383                 :            :                                         DK_ERROR, UNKNOWN_LOCATION);
     384                 :            :     }
     385                 :            :   else
     386                 :            :     {
     387                 :            :       /* With -fdec, set -fd-lines-as-comments by default in fixed form.  */
     388                 :       1798 :       if (flag_dec && gfc_option.flag_d_lines == -1)
     389                 :          9 :         gfc_option.flag_d_lines = 0;
     390                 :            : 
     391                 :       1798 :       if (warn_line_truncation == -1)
     392                 :       1794 :         warn_line_truncation = 0;
     393                 :            :     }
     394                 :            : 
     395                 :            :   /* If -pedantic, warn about the use of GNU extensions.  */
     396                 :      25213 :   if (pedantic && (gfc_option.allow_std & GFC_STD_GNU) != 0)
     397                 :      12642 :     gfc_option.warn_std |= GFC_STD_GNU;
     398                 :            :   /* -std=legacy -pedantic is effectively -std=gnu.  */
     399                 :      25213 :   if (pedantic && (gfc_option.allow_std & GFC_STD_LEGACY) != 0)
     400                 :      12642 :     gfc_option.warn_std |= GFC_STD_F95_OBS | GFC_STD_F95_DEL | GFC_STD_LEGACY;
     401                 :            : 
     402                 :            :   /* If the user didn't explicitly specify -f(no)-second-underscore we
     403                 :            :      use it if we're trying to be compatible with f2c, and not
     404                 :            :      otherwise.  */
     405                 :      25213 :   if (flag_second_underscore == -1)
     406                 :      25213 :     flag_second_underscore = flag_f2c;
     407                 :            : 
     408                 :      25213 :   if (!flag_automatic && flag_max_stack_var_size != -2
     409                 :          0 :       && flag_max_stack_var_size != 0)
     410                 :          0 :     gfc_warning_now (0, "Flag %<-fno-automatic%> overwrites %<-fmax-stack-var-size=%d%>",
     411                 :            :                      flag_max_stack_var_size);
     412                 :      25213 :   else if (!flag_automatic && flag_recursive)
     413                 :          8 :     gfc_warning_now (OPT_Woverwrite_recursive, "Flag %<-fno-automatic%> "
     414                 :            :                      "overwrites %<-frecursive%>");
     415                 :      25205 :   else if (!flag_automatic && flag_openmp)
     416                 :          0 :     gfc_warning_now (0, "Flag %<-fno-automatic%> overwrites %<-frecursive%> implied by "
     417                 :            :                      "%<-fopenmp%>");
     418                 :      25205 :   else if (flag_max_stack_var_size != -2 && flag_recursive)
     419                 :          0 :     gfc_warning_now (0, "Flag %<-frecursive%> overwrites %<-fmax-stack-var-size=%d%>",
     420                 :            :                      flag_max_stack_var_size);
     421                 :      25205 :   else if (flag_max_stack_var_size != -2 && flag_openmp)
     422                 :          0 :     gfc_warning_now (0, "Flag %<-fmax-stack-var-size=%d%> overwrites %<-frecursive%> "
     423                 :            :                      "implied by %<-fopenmp%>", flag_max_stack_var_size);
     424                 :            : 
     425                 :            :   /* Implement -frecursive as -fmax-stack-var-size=-1.  */
     426                 :      25213 :   if (flag_recursive)
     427                 :         21 :     flag_max_stack_var_size = -1;
     428                 :            : 
     429                 :            :   /* Implied -frecursive; implemented as -fmax-stack-var-size=-1.  */
     430                 :      25213 :   if (flag_max_stack_var_size == -2 && flag_openmp && flag_automatic)
     431                 :            :     {
     432                 :       1708 :       flag_recursive = 1;
     433                 :       1708 :       flag_max_stack_var_size = -1;
     434                 :            :     }
     435                 :            : 
     436                 :            :   /* Set flag_stack_arrays correctly.  */
     437                 :      25213 :   if (flag_stack_arrays == -1)
     438                 :         14 :     flag_stack_arrays = 0;
     439                 :            : 
     440                 :            :   /* Set default.  */
     441                 :      25213 :   if (flag_max_stack_var_size == -2)
     442                 :      23470 :     flag_max_stack_var_size = 65536;
     443                 :            : 
     444                 :            :   /* Implement -fno-automatic as -fmax-stack-var-size=0.  */
     445                 :      25213 :   if (!flag_automatic)
     446                 :         64 :     flag_max_stack_var_size = 0;
     447                 :            :   
     448                 :            :   /* If the user did not specify an inline matmul limit, inline up to the BLAS
     449                 :            :      limit or up to 30 if no external BLAS is specified.  */
     450                 :            : 
     451                 :      25213 :   if (flag_inline_matmul_limit < 0)
     452                 :            :     {
     453                 :      25166 :       if (flag_external_blas)
     454                 :          9 :         flag_inline_matmul_limit = flag_blas_matmul_limit;
     455                 :            :       else
     456                 :      25157 :         flag_inline_matmul_limit = 30;
     457                 :            :     }
     458                 :            : 
     459                 :            :   /* Optimization implies front end optimization, unless the user
     460                 :            :      specified it directly.  */
     461                 :            : 
     462                 :      25213 :   if (flag_frontend_optimize == -1)
     463                 :      28511 :     flag_frontend_optimize = optimize && !optimize_debug;
     464                 :            : 
     465                 :            :   /* Same for front end loop interchange.  */
     466                 :            : 
     467                 :      25213 :   if (flag_frontend_loop_interchange == -1)
     468                 :      25209 :     flag_frontend_loop_interchange = optimize;
     469                 :            : 
     470                 :            :   /* Do inline packing by default if optimizing, but not if
     471                 :            :      optimizing for size.  */
     472                 :      25213 :   if (flag_inline_arg_packing == -1)
     473                 :      31861 :     flag_inline_arg_packing = optimize && !optimize_size;
     474                 :            : 
     475                 :      25213 :   if (flag_max_array_constructor < 65535)
     476                 :          0 :     flag_max_array_constructor = 65535;
     477                 :            : 
     478                 :      25213 :   if (flag_fixed_line_length != 0 && flag_fixed_line_length < 7)
     479                 :          0 :     gfc_fatal_error ("Fixed line length must be at least seven");
     480                 :            : 
     481                 :      25213 :   if (flag_free_line_length != 0 && flag_free_line_length < 4)
     482                 :          0 :     gfc_fatal_error ("Free line length must be at least three");
     483                 :            : 
     484                 :      25213 :   if (flag_max_subrecord_length > MAX_SUBRECORD_LENGTH)
     485                 :          0 :     gfc_fatal_error ("Maximum subrecord length cannot exceed %d",
     486                 :            :                      MAX_SUBRECORD_LENGTH);
     487                 :            : 
     488                 :      25213 :   gfc_cpp_post_options ();
     489                 :            : 
     490                 :      25213 :   if (gfc_option.allow_std & GFC_STD_F2008)
     491                 :      24876 :     lang_hooks.name = "GNU Fortran2008";
     492                 :        337 :   else if (gfc_option.allow_std & GFC_STD_F2003)
     493                 :        205 :     lang_hooks.name = "GNU Fortran2003";
     494                 :            : 
     495                 :      25213 :   return gfc_cpp_preprocess_only ();
     496                 :            : }
     497                 :            : 
     498                 :            : 
     499                 :            : static void
     500                 :          1 : gfc_handle_module_path_options (const char *arg)
     501                 :            : {
     502                 :            : 
     503                 :          1 :   if (gfc_option.module_dir != NULL)
     504                 :          0 :     gfc_fatal_error ("gfortran: Only one %<-J%> option allowed");
     505                 :            : 
     506                 :          1 :   gfc_option.module_dir = XCNEWVEC (char, strlen (arg) + 2);
     507                 :          1 :   strcpy (gfc_option.module_dir, arg);
     508                 :            : 
     509                 :          1 :   gfc_add_include_path (gfc_option.module_dir, true, false, true);
     510                 :            : 
     511                 :          1 :   strcat (gfc_option.module_dir, "/");
     512                 :          1 : }
     513                 :            : 
     514                 :            : 
     515                 :            : /* Handle options -ffpe-trap= and -ffpe-summary=.  */
     516                 :            : 
     517                 :            : static void
     518                 :          6 : gfc_handle_fpe_option (const char *arg, bool trap)
     519                 :            : {
     520                 :          6 :   int result, pos = 0, n;
     521                 :            :   /* precision is a backwards compatibility alias for inexact.  */
     522                 :          6 :   static const char * const exception[] = { "invalid", "denormal", "zero",
     523                 :            :                                             "overflow", "underflow",
     524                 :            :                                             "inexact", "precision", NULL };
     525                 :          6 :   static const int opt_exception[] = { GFC_FPE_INVALID, GFC_FPE_DENORMAL,
     526                 :            :                                        GFC_FPE_ZERO, GFC_FPE_OVERFLOW,
     527                 :            :                                        GFC_FPE_UNDERFLOW, GFC_FPE_INEXACT,
     528                 :            :                                        GFC_FPE_INEXACT,
     529                 :            :                                        0 };
     530                 :            : 
     531                 :            :   /* As the default for -ffpe-summary= is nonzero, set it to 0.  */
     532                 :          6 :   if (!trap)
     533                 :          0 :     gfc_option.fpe_summary = 0;
     534                 :            : 
     535                 :         18 :   while (*arg)
     536                 :            :     {
     537                 :         18 :       while (*arg == ',')
     538                 :          6 :         arg++;
     539                 :            : 
     540                 :        102 :       while (arg[pos] && arg[pos] != ',')
     541                 :         90 :         pos++;
     542                 :            : 
     543                 :         12 :       result = 0;
     544                 :         12 :       if (!trap && strncmp ("none", arg, pos) == 0)
     545                 :            :         {
     546                 :          0 :           gfc_option.fpe_summary = 0;
     547                 :          0 :           arg += pos;
     548                 :          0 :           pos = 0;
     549                 :          0 :           continue;
     550                 :            :         }
     551                 :         12 :       else if (!trap && strncmp ("all", arg, pos) == 0)
     552                 :            :         {
     553                 :          0 :           gfc_option.fpe_summary = GFC_FPE_INVALID | GFC_FPE_DENORMAL
     554                 :            :                                    | GFC_FPE_ZERO | GFC_FPE_OVERFLOW
     555                 :            :                                    | GFC_FPE_UNDERFLOW | GFC_FPE_INEXACT;
     556                 :          0 :           arg += pos;
     557                 :          0 :           pos = 0;
     558                 :          0 :           continue;
     559                 :            :         }
     560                 :            :       else
     561                 :         30 :         for (n = 0; exception[n] != NULL; n++)
     562                 :            :           {
     563                 :         30 :           if (exception[n] && strncmp (exception[n], arg, pos) == 0)
     564                 :            :             {
     565                 :         12 :               if (trap)
     566                 :         12 :                 gfc_option.fpe |= opt_exception[n];
     567                 :            :               else
     568                 :          0 :                 gfc_option.fpe_summary |= opt_exception[n];
     569                 :            :               arg += pos;
     570                 :            :               pos = 0;
     571                 :            :               result = 1;
     572                 :            :               break;
     573                 :            :             }
     574                 :            :           }
     575                 :         12 :       if (!result && !trap)
     576                 :          0 :         gfc_fatal_error ("Argument to %<-ffpe-trap%> is not valid: %s", arg);
     577                 :         12 :       else if (!result)
     578                 :          0 :         gfc_fatal_error ("Argument to %<-ffpe-summary%> is not valid: %s", arg);
     579                 :            : 
     580                 :            :     }
     581                 :          6 : }
     582                 :            : 
     583                 :            : 
     584                 :            : static void
     585                 :        347 : gfc_handle_runtime_check_option (const char *arg)
     586                 :            : {
     587                 :        347 :   int result, pos = 0, n;
     588                 :        694 :   static const char * const optname[] = { "all", "bounds", "array-temps",
     589                 :            :                                           "recursion", "do", "pointer",
     590                 :            :                                           "mem", "bits", NULL };
     591                 :        694 :   static const int optmask[] = { GFC_RTCHECK_ALL, GFC_RTCHECK_BOUNDS,
     592                 :            :                                  GFC_RTCHECK_ARRAY_TEMPS,
     593                 :            :                                  GFC_RTCHECK_RECURSION, GFC_RTCHECK_DO,
     594                 :            :                                  GFC_RTCHECK_POINTER, GFC_RTCHECK_MEM,
     595                 :            :                                  GFC_RTCHECK_BITS, 0 };
     596                 :            :  
     597                 :        694 :   while (*arg)
     598                 :            :     {
     599                 :        347 :       while (*arg == ',')
     600                 :          0 :         arg++;
     601                 :            : 
     602                 :       2137 :       while (arg[pos] && arg[pos] != ',')
     603                 :       1790 :         pos++;
     604                 :            : 
     605                 :       1070 :       result = 0;
     606                 :       1070 :       for (n = 0; optname[n] != NULL; n++)
     607                 :            :         {
     608                 :       1070 :           if (optname[n] && strncmp (optname[n], arg, pos) == 0)
     609                 :            :             {
     610                 :        347 :               gfc_option.rtcheck |= optmask[n];
     611                 :        347 :               arg += pos;
     612                 :        347 :               pos = 0;
     613                 :        347 :               result = 1;
     614                 :        347 :               break;
     615                 :            :             }
     616                 :        723 :           else if (optname[n] && pos > 3 && gfc_str_startswith (arg, "no-")
     617                 :          0 :                    && strncmp (optname[n], arg+3, pos-3) == 0)
     618                 :            :             {
     619                 :          0 :               gfc_option.rtcheck &= ~optmask[n];
     620                 :          0 :               arg += pos;
     621                 :          0 :               pos = 0;
     622                 :          0 :               result = 1;
     623                 :          0 :               break;
     624                 :            :             }
     625                 :            :         }
     626                 :        347 :       if (!result)
     627                 :          0 :         gfc_fatal_error ("Argument to %<-fcheck%> is not valid: %s", arg);
     628                 :            :     }
     629                 :        347 : }
     630                 :            : 
     631                 :            : 
     632                 :            : /* Handle command-line options.  Returns 0 if unrecognized, 1 if
     633                 :            :    recognized and handled.  */
     634                 :            : 
     635                 :            : bool
     636                 :     171149 : gfc_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
     637                 :            :                    int kind ATTRIBUTE_UNUSED, location_t loc ATTRIBUTE_UNUSED,
     638                 :            :                    const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
     639                 :            : {
     640                 :     171149 :   bool result = true;
     641                 :     171149 :   enum opt_code code = (enum opt_code) scode;
     642                 :            : 
     643                 :     171149 :   if (gfc_cpp_handle_option (scode, arg, value) == 1)
     644                 :            :     return true;
     645                 :            : 
     646                 :     134144 :   switch (code)
     647                 :            :     {
     648                 :      87780 :     default:
     649                 :      87780 :       if (cl_options[code].flags & gfc_option_lang_mask ())
     650                 :            :         break;
     651                 :          0 :       result = false;
     652                 :          0 :       break;
     653                 :            : 
     654                 :         12 :     case OPT_fcheck_array_temporaries:
     655                 :         12 :       SET_BITFLAG (gfc_option.rtcheck, value, GFC_RTCHECK_ARRAY_TEMPS);
     656                 :            :       break;
     657                 :            :       
     658                 :          4 :     case OPT_fd_lines_as_code:
     659                 :          4 :       gfc_option.flag_d_lines = 1;
     660                 :          4 :       break;
     661                 :            : 
     662                 :          1 :     case OPT_fd_lines_as_comments:
     663                 :          1 :       gfc_option.flag_d_lines = 0;
     664                 :          1 :       break;
     665                 :            : 
     666                 :       1811 :     case OPT_ffixed_form:
     667                 :       1811 :       gfc_option.source_form = FORM_FIXED;
     668                 :       1811 :       break;
     669                 :            : 
     670                 :         13 :     case OPT_ffree_form:
     671                 :         13 :       gfc_option.source_form = FORM_FREE;
     672                 :         13 :       break;
     673                 :            : 
     674                 :            :     case OPT_static_libgfortran:
     675                 :            : #ifndef HAVE_LD_STATIC_DYNAMIC
     676                 :            :       gfc_fatal_error ("%<-static-libgfortran%> is not supported in this "
     677                 :            :                        "configuration");
     678                 :            : #endif
     679                 :            :       break;
     680                 :            : 
     681                 :      27825 :     case OPT_fintrinsic_modules_path:
     682                 :      27825 :     case OPT_fintrinsic_modules_path_:
     683                 :            : 
     684                 :            :       /* This is needed because omp_lib.h is in a directory together
     685                 :            :          with intrinsic modules.  Do no warn because during testing
     686                 :            :          without an installed compiler, we would get lots of bogus
     687                 :            :          warnings for a missing include directory.  */
     688                 :      27825 :       gfc_add_include_path (arg, false, false, false);
     689                 :            : 
     690                 :      27825 :       gfc_add_intrinsic_modules_path (arg);
     691                 :      27825 :       break;
     692                 :            : 
     693                 :          2 :     case OPT_fpreprocessed:
     694                 :          2 :       gfc_option.flag_preprocessed = value;
     695                 :          2 :       break;
     696                 :            : 
     697                 :          0 :     case OPT_fmax_identifier_length_:
     698                 :          0 :       if (value > GFC_MAX_SYMBOL_LEN)
     699                 :          0 :         gfc_fatal_error ("Maximum supported identifier length is %d",
     700                 :            :                          GFC_MAX_SYMBOL_LEN);
     701                 :          0 :       gfc_option.max_identifier_length = value;
     702                 :          0 :       break;
     703                 :            : 
     704                 :         51 :     case OPT_finit_local_zero:
     705                 :         51 :       set_init_local_zero (value);
     706                 :         51 :       break;
     707                 :            : 
     708                 :         19 :     case OPT_finit_logical_:
     709                 :         19 :       if (!strcasecmp (arg, "false"))
     710                 :          6 :         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
     711                 :         13 :       else if (!strcasecmp (arg, "true"))
     712                 :         13 :         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_TRUE;
     713                 :            :       else
     714                 :          0 :         gfc_fatal_error ("Unrecognized option to %<-finit-logical%>: %s",
     715                 :            :                          arg);
     716                 :            :       break;
     717                 :            : 
     718                 :         38 :     case OPT_finit_integer_:
     719                 :         38 :       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
     720                 :         38 :       gfc_option.flag_init_integer_value = strtol (arg, NULL, 10);
     721                 :         38 :       break;
     722                 :            : 
     723                 :         19 :     case OPT_finit_character_:
     724                 :         19 :       if (value >= 0 && value <= 127)
     725                 :            :         {
     726                 :         19 :           gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
     727                 :         19 :           gfc_option.flag_init_character_value = (char)value;
     728                 :            :         }
     729                 :            :       else
     730                 :          0 :         gfc_fatal_error ("The value of n in %<-finit-character=n%> must be "
     731                 :            :                          "between 0 and 127");
     732                 :         19 :       break;
     733                 :            : 
     734                 :      14360 :     case OPT_I:
     735                 :      14360 :       gfc_add_include_path (arg, true, false, true);
     736                 :      14360 :       break;
     737                 :            : 
     738                 :          1 :     case OPT_J:
     739                 :          1 :       gfc_handle_module_path_options (arg);
     740                 :          1 :       break;
     741                 :            : 
     742                 :          6 :     case OPT_ffpe_trap_:
     743                 :          6 :       gfc_handle_fpe_option (arg, true);
     744                 :          6 :       break;
     745                 :            : 
     746                 :          0 :     case OPT_ffpe_summary_:
     747                 :          0 :       gfc_handle_fpe_option (arg, false);
     748                 :          0 :       break;
     749                 :            : 
     750                 :        132 :     case OPT_std_f95:
     751                 :        132 :       gfc_option.allow_std = GFC_STD_OPT_F95;
     752                 :        132 :       gfc_option.warn_std = GFC_STD_F95_OBS;
     753                 :        132 :       gfc_option.max_continue_fixed = 19;
     754                 :        132 :       gfc_option.max_continue_free = 39;
     755                 :        132 :       gfc_option.max_identifier_length = 31;
     756                 :        132 :       warn_ampersand = 1;
     757                 :        132 :       warn_tabs = 1;
     758                 :        132 :       break;
     759                 :            : 
     760                 :        205 :     case OPT_std_f2003:
     761                 :        205 :       gfc_option.allow_std = GFC_STD_OPT_F03;
     762                 :        205 :       gfc_option.warn_std = GFC_STD_F95_OBS;
     763                 :        205 :       gfc_option.max_identifier_length = 63;
     764                 :        205 :       warn_ampersand = 1;
     765                 :        205 :       warn_tabs = 1;
     766                 :        205 :       break;
     767                 :            : 
     768                 :        184 :     case OPT_std_f2008:
     769                 :        184 :       gfc_option.allow_std = GFC_STD_OPT_F08;
     770                 :        184 :       gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F2008_OBS;
     771                 :        184 :       gfc_option.max_identifier_length = 63;
     772                 :        184 :       warn_ampersand = 1;
     773                 :        184 :       warn_tabs = 1;
     774                 :        184 :       break;
     775                 :            : 
     776                 :         11 :     case OPT_std_f2008ts:
     777                 :         11 :     case OPT_std_f2018:
     778                 :         11 :       gfc_option.allow_std = GFC_STD_OPT_F18;
     779                 :         11 :       gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F2008_OBS
     780                 :            :         | GFC_STD_F2018_OBS;
     781                 :         11 :       gfc_option.max_identifier_length = 63;
     782                 :         11 :       warn_ampersand = 1;
     783                 :         11 :       warn_tabs = 1;
     784                 :         11 :       break;
     785                 :            : 
     786                 :        332 :     case OPT_std_gnu:
     787                 :        332 :       set_default_std_flags ();
     788                 :            :       break;
     789                 :            : 
     790                 :        770 :     case OPT_std_legacy:
     791                 :        770 :       set_default_std_flags ();
     792                 :        770 :       gfc_option.warn_std = 0;
     793                 :        770 :       break;
     794                 :            : 
     795                 :            :     case OPT_fshort_enums:
     796                 :            :       /* Handled in language-independent code.  */
     797                 :            :       break;
     798                 :            : 
     799                 :        347 :     case OPT_fcheck_:
     800                 :        347 :       gfc_handle_runtime_check_option (arg);
     801                 :        347 :       break;
     802                 :            : 
     803                 :        209 :     case OPT_fdec:
     804                 :            :       /* Set (or unset) the DEC extension flags.  */
     805                 :        209 :       set_dec_flags (value);
     806                 :        209 :       break;
     807                 :            :     }
     808                 :            : 
     809                 :     134143 :   Fortran_handle_option_auto (&global_options, &global_options_set, 
     810                 :            :                               scode, arg, value, 
     811                 :            :                               gfc_option_lang_mask (), kind,
     812                 :            :                               loc, handlers, global_dc);
     813                 :     134143 :   return result;
     814                 :            : }
     815                 :            : 
     816                 :            : 
     817                 :            : /* Return a string with the options passed to the compiler; used for
     818                 :            :    Fortran's compiler_options() intrinsic.  */
     819                 :            : 
     820                 :            : char *
     821                 :          8 : gfc_get_option_string (void)
     822                 :            : {
     823                 :          8 :   unsigned j;
     824                 :          8 :   size_t len, pos;
     825                 :          8 :   char *result;
     826                 :            : 
     827                 :            :   /* Allocate and return a one-character string with '\0'.  */
     828                 :          8 :   if (!save_decoded_options_count)
     829                 :          0 :     return XCNEWVEC (char, 1);
     830                 :            : 
     831                 :            :   /* Determine required string length.  */
     832                 :            : 
     833                 :            :   len = 0;
     834                 :        134 :   for (j = 1; j < save_decoded_options_count; j++)
     835                 :            :     {
     836                 :        126 :       switch (save_decoded_options[j].opt_index)
     837                 :            :         {
     838                 :            :         case OPT_o:
     839                 :            :         case OPT_d:
     840                 :            :         case OPT_dumpbase:
     841                 :            :         case OPT_dumpdir:
     842                 :            :         case OPT_auxbase:
     843                 :            :         case OPT_quiet:
     844                 :            :         case OPT_version:
     845                 :            :         case OPT_fintrinsic_modules_path:
     846                 :            :         case OPT_fintrinsic_modules_path_:
     847                 :            :           /* Ignore these.  */
     848                 :            :           break;
     849                 :         87 :         default:
     850                 :            :           /* Ignore file names.  */
     851                 :         87 :           if (save_decoded_options[j].orig_option_with_args_text[0] == '-')
     852                 :         79 :             len += 1
     853                 :         79 :                  + strlen (save_decoded_options[j].orig_option_with_args_text);
     854                 :            :         }
     855                 :            :     }
     856                 :            : 
     857                 :          8 :   result = XCNEWVEC (char, len);
     858                 :            : 
     859                 :          8 :   pos = 0; 
     860                 :        134 :   for (j = 1; j < save_decoded_options_count; j++)
     861                 :            :     {
     862                 :        126 :       switch (save_decoded_options[j].opt_index)
     863                 :            :         {
     864                 :         39 :         case OPT_o:
     865                 :         39 :         case OPT_d:
     866                 :         39 :         case OPT_dumpbase:
     867                 :         39 :         case OPT_dumpdir:
     868                 :         39 :         case OPT_auxbase:
     869                 :         39 :         case OPT_quiet:
     870                 :         39 :         case OPT_version:
     871                 :         39 :         case OPT_fintrinsic_modules_path:
     872                 :         39 :         case OPT_fintrinsic_modules_path_:
     873                 :            :           /* Ignore these.  */
     874                 :         39 :           continue;
     875                 :            : 
     876                 :            :         case OPT_cpp_:
     877                 :            :           /* Use "-cpp" rather than "-cpp=<temporary file>".  */
     878                 :            :           len = 4;
     879                 :            :           break;
     880                 :            : 
     881                 :         87 :         default:
     882                 :            :           /* Ignore file names.  */
     883                 :         87 :           if (save_decoded_options[j].orig_option_with_args_text[0] != '-')
     884                 :          8 :             continue;
     885                 :            : 
     886                 :         79 :           len = strlen (save_decoded_options[j].orig_option_with_args_text);
     887                 :            :         }
     888                 :            : 
     889                 :         79 :       memcpy (&result[pos], save_decoded_options[j].orig_option_with_args_text, len);
     890                 :         79 :       pos += len;
     891                 :         79 :       result[pos++] = ' ';
     892                 :            :     }
     893                 :            : 
     894                 :          8 :   result[--pos] = '\0';
     895                 :          8 :   return result;
     896                 :            : }
     897                 :            : 
     898                 :            : #undef SET_BITFLAG
     899                 :            : #undef SET_BITFLAG2
     900                 :            : #undef SET_FLAG

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.