Subversion Repositories openrisc

/* Parse and display command line options.

   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,

   2009, 2010, 2011, 2012

   Free Software Foundation, Inc.

   Contributed by Andy Vaught

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tree.h"

#include "flags.h"

#include "intl.h"

#include "opts.h"

#include "toplev.h"  /* For save_decoded_options.  */

#include "options.h"

#include "params.h"

#include "tree-inline.h"

#include "gfortran.h"

#include "target.h"

#include "cpp.h"

#include "diagnostic-core.h"    /* For sorry.  */

#include "tm.h"

gfc_option_t gfc_option;

/* Set flags that control warnings and errors for different

   Fortran standards to their default values.  Keep in sync with

   libgfortran/runtime/compile_options.c (init_compile_options).  */

static void

set_default_std_flags (void)

{

  gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL

    | GFC_STD_F2003 | GFC_STD_F2008 | GFC_STD_F95 | GFC_STD_F77

    | GFC_STD_F2008_OBS | GFC_STD_F2008_TS | GFC_STD_GNU | GFC_STD_LEGACY;

  gfc_option.warn_std = GFC_STD_F95_DEL | GFC_STD_LEGACY;

}

/* Return language mask for Fortran options.  */

unsigned int

gfc_option_lang_mask (void)

{

  return CL_Fortran;

}

/* Initialize options structure OPTS.  */

void

gfc_init_options_struct (struct gcc_options *opts)

{

  opts->x_flag_errno_math = 0;

  opts->x_flag_associative_math = -1;

}

/* Get ready for options handling. Keep in sync with

   libgfortran/runtime/compile_options.c (init_compile_options). */

void

gfc_init_options (unsigned int decoded_options_count,

                  struct cl_decoded_option *decoded_options)

{

  gfc_source_file = NULL;

  gfc_option.module_dir = NULL;

  gfc_option.source_form = FORM_UNKNOWN;

  gfc_option.fixed_line_length = 72;

  gfc_option.free_line_length = 132;

  gfc_option.max_continue_fixed = 255;

  gfc_option.max_continue_free = 255;

  gfc_option.max_identifier_length = GFC_MAX_SYMBOL_LEN;

  gfc_option.max_subrecord_length = 0;

  gfc_option.flag_max_array_constructor = 65535;

  gfc_option.convert = GFC_CONVERT_NATIVE;

  gfc_option.record_marker = 0;

  gfc_option.dump_fortran_original = 0;

  gfc_option.dump_fortran_optimized = 0;

  gfc_option.warn_aliasing = 0;

  gfc_option.warn_ampersand = 0;

  gfc_option.warn_character_truncation = 0;

  gfc_option.warn_array_temp = 0;

  gfc_option.gfc_warn_conversion = 0;

  gfc_option.warn_conversion_extra = 0;

  gfc_option.warn_function_elimination = 0;

  gfc_option.warn_implicit_interface = 0;

  gfc_option.warn_line_truncation = 0;

  gfc_option.warn_surprising = 0;

  gfc_option.warn_tabs = 1;

  gfc_option.warn_underflow = 1;

  gfc_option.warn_intrinsic_shadow = 0;

  gfc_option.warn_intrinsics_std = 0;

  gfc_option.warn_align_commons = 1;

  gfc_option.warn_real_q_constant = 0;

  gfc_option.warn_unused_dummy_argument = 0;

  gfc_option.max_errors = 25;

  gfc_option.flag_all_intrinsics = 0;

  gfc_option.flag_default_double = 0;

  gfc_option.flag_default_integer = 0;

  gfc_option.flag_default_real = 0;

  gfc_option.flag_integer4_kind = 0;

  gfc_option.flag_real4_kind = 0;

  gfc_option.flag_real8_kind = 0;

  gfc_option.flag_dollar_ok = 0;

  gfc_option.flag_underscoring = 1;

  gfc_option.flag_whole_file = 1;

  gfc_option.flag_f2c = 0;

  gfc_option.flag_second_underscore = -1;

  gfc_option.flag_implicit_none = 0;

  /* Default value of flag_max_stack_var_size is set in gfc_post_options.  */

  gfc_option.flag_max_stack_var_size = -2;

  gfc_option.flag_stack_arrays = -1;

  gfc_option.flag_range_check = 1;

  gfc_option.flag_pack_derived = 0;

  gfc_option.flag_repack_arrays = 0;

  gfc_option.flag_preprocessed = 0;

  gfc_option.flag_automatic = 1;

  gfc_option.flag_backslash = 0;

  gfc_option.flag_module_private = 0;

  gfc_option.flag_backtrace = 1;

  gfc_option.flag_allow_leading_underscore = 0;

  gfc_option.flag_external_blas = 0;

  gfc_option.blas_matmul_limit = 30;

  gfc_option.flag_cray_pointer = 0;

  gfc_option.flag_d_lines = -1;

  gfc_option.gfc_flag_openmp = 0;

  gfc_option.flag_sign_zero = 1;

  gfc_option.flag_recursive = 0;

  gfc_option.flag_init_integer = GFC_INIT_INTEGER_OFF;

  gfc_option.flag_init_integer_value = 0;

  gfc_option.flag_init_real = GFC_INIT_REAL_OFF;

  gfc_option.flag_init_logical = GFC_INIT_LOGICAL_OFF;

  gfc_option.flag_init_character = GFC_INIT_CHARACTER_OFF;

  gfc_option.flag_init_character_value = (char)0;

  gfc_option.flag_align_commons = 1;

  gfc_option.flag_protect_parens = -1;

  gfc_option.flag_realloc_lhs = -1;

  gfc_option.flag_aggressive_function_elimination = 0;

  gfc_option.flag_frontend_optimize = -1;

  gfc_option.fpe = 0;

  gfc_option.rtcheck = 0;

  gfc_option.coarray = GFC_FCOARRAY_NONE;

  set_default_std_flags ();

  /* Initialize cpp-related options.  */

  gfc_cpp_init_options (decoded_options_count, decoded_options);

}

/* Determine the source form from the filename extension.  We assume

   case insensitivity.  */

static gfc_source_form

form_from_filename (const char *filename)

{

  static const struct

  {

    const char *extension;

    gfc_source_form form;

  }

  exttype[] =

  {

    {

    ".f90", FORM_FREE}

    ,

    {

    ".f95", FORM_FREE}

    ,

    {

    ".f03", FORM_FREE}

    ,

    {

    ".f08", FORM_FREE}

    ,

    {

    ".f", FORM_FIXED}

    ,

    {

    ".for", FORM_FIXED}

    ,

    {

    ".ftn", FORM_FIXED}

    ,

    {

    "", FORM_UNKNOWN}

  };            /* sentinel value */

  gfc_source_form f_form;

  const char *fileext;

  int i;

  /* Find end of file name.  Note, filename is either a NULL pointer or

     a NUL terminated string.  */

  i = 0;

  while (filename[i] != '\0')

    i++;

  /* Find last period.  */

  while (i >= 0 && (filename[i] != '.'))

    i--;

  /* Did we see a file extension?  */

  if (i < 0)

    return FORM_UNKNOWN; /* Nope  */

  /* Get file extension and compare it to others.  */

  fileext = &(filename[i]);

  i = -1;

  f_form = FORM_UNKNOWN;

  do

    {

      i++;

      if (strcasecmp (fileext, exttype[i].extension) == 0)

        {

          f_form = exttype[i].form;

          break;

        }

    }

  while (exttype[i].form != FORM_UNKNOWN);

  return f_form;

}

/* Finalize commandline options.  */

bool

gfc_post_options (const char **pfilename)

{

  const char *filename = *pfilename, *canon_source_file = NULL;

  char *source_path;

  int i;

  /* Excess precision other than "fast" requires front-end

     support.  */

  if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD

      && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)

    sorry ("-fexcess-precision=standard for Fortran");

  flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;

  /* Whole program needs whole file mode.  */

  if (flag_whole_program)

    gfc_option.flag_whole_file = 1;

  /* Enable whole-file mode if LTO is in effect.  */

  if (flag_lto)

    gfc_option.flag_whole_file = 1;

  /* Fortran allows associative math - but we cannot reassociate if

     we want traps or signed zeros. Cf. also flag_protect_parens.  */

  if (flag_associative_math == -1)

    flag_associative_math = (!flag_trapping_math && !flag_signed_zeros);

  if (gfc_option.flag_protect_parens == -1)

    gfc_option.flag_protect_parens = !optimize_fast;

  if (gfc_option.flag_stack_arrays == -1)

    gfc_option.flag_stack_arrays = optimize_fast;

  /* By default, disable (re)allocation during assignment for -std=f95,

     and enable it for F2003/F2008/GNU/Legacy. */

  if (gfc_option.flag_realloc_lhs == -1)

    {

      if (gfc_option.allow_std & GFC_STD_F2003)

        gfc_option.flag_realloc_lhs = 1;

      else

        gfc_option.flag_realloc_lhs = 0;

    }

  /* -fbounds-check is equivalent to -fcheck=bounds */

  if (flag_bounds_check)

    gfc_option.rtcheck |= GFC_RTCHECK_BOUNDS;

  if (flag_compare_debug)

    gfc_option.dump_fortran_original = 0;

  /* Make -fmax-errors visible to gfortran's diagnostic machinery.  */

  if (global_options_set.x_flag_max_errors)

    gfc_option.max_errors = flag_max_errors;

  /* Verify the input file name.  */

  if (!filename || strcmp (filename, "-") == 0)

    {

      filename = "";

    }

  if (gfc_option.flag_preprocessed)

    {

      /* For preprocessed files, if the first tokens are of the form # NUM.

         handle the directives so we know the original file name.  */

      gfc_source_file = gfc_read_orig_filename (filename, &canon_source_file);

      if (gfc_source_file == NULL)

        gfc_source_file = filename;

      else

        *pfilename = gfc_source_file;

    }

  else

    gfc_source_file = filename;

  if (canon_source_file == NULL)

    canon_source_file = gfc_source_file;

  /* Adds the path where the source file is to the list of include files.  */

  i = strlen (canon_source_file);

  while (i > 0 && !IS_DIR_SEPARATOR (canon_source_file[i]))

    i--;

  if (i != 0)

    {

      source_path = (char *) alloca (i + 1);

      memcpy (source_path, canon_source_file, i);

      source_path[i] = 0;

      gfc_add_include_path (source_path, true, true);

    }

  else

    gfc_add_include_path (".", true, true);

  if (canon_source_file != gfc_source_file)

    free (CONST_CAST (char *, canon_source_file));

  /* Decide which form the file will be read in as.  */

  if (gfc_option.source_form != FORM_UNKNOWN)

    gfc_current_form = gfc_option.source_form;

  else

    {

      gfc_current_form = form_from_filename (filename);

      if (gfc_current_form == FORM_UNKNOWN)

        {

          gfc_current_form = FORM_FREE;

          gfc_warning_now ("Reading file '%s' as free form",

                           (filename[0] == '\0') ? "<stdin>" : filename);

        }

    }

  /* If the user specified -fd-lines-as-{code|comments} verify that we're

     in fixed form.  */

  if (gfc_current_form == FORM_FREE)

    {

      if (gfc_option.flag_d_lines == 0)

        gfc_warning_now ("'-fd-lines-as-comments' has no effect "

                         "in free form");

      else if (gfc_option.flag_d_lines == 1)

        gfc_warning_now ("'-fd-lines-as-code' has no effect in free form");

    }

  /* If -pedantic, warn about the use of GNU extensions.  */

  if (pedantic && (gfc_option.allow_std & GFC_STD_GNU) != 0)

    gfc_option.warn_std |= GFC_STD_GNU;

  /* -std=legacy -pedantic is effectively -std=gnu.  */

  if (pedantic && (gfc_option.allow_std & GFC_STD_LEGACY) != 0)

    gfc_option.warn_std |= GFC_STD_F95_OBS | GFC_STD_F95_DEL | GFC_STD_LEGACY;

  /* If the user didn't explicitly specify -f(no)-second-underscore we

     use it if we're trying to be compatible with f2c, and not

     otherwise.  */

  if (gfc_option.flag_second_underscore == -1)

    gfc_option.flag_second_underscore = gfc_option.flag_f2c;

  if (!gfc_option.flag_automatic && gfc_option.flag_max_stack_var_size != -2

      && gfc_option.flag_max_stack_var_size != 0)

    gfc_warning_now ("Flag -fno-automatic overwrites -fmax-stack-var-size=%d",

                     gfc_option.flag_max_stack_var_size);

  else if (!gfc_option.flag_automatic && gfc_option.flag_recursive)

    gfc_warning_now ("Flag -fno-automatic overwrites -frecursive");

  else if (!gfc_option.flag_automatic && gfc_option.gfc_flag_openmp)

    gfc_warning_now ("Flag -fno-automatic overwrites -frecursive implied by "

                     "-fopenmp");

  else if (gfc_option.flag_max_stack_var_size != -2

           && gfc_option.flag_recursive)

    gfc_warning_now ("Flag -frecursive overwrites -fmax-stack-var-size=%d",

                     gfc_option.flag_max_stack_var_size);

  else if (gfc_option.flag_max_stack_var_size != -2

           && gfc_option.gfc_flag_openmp)

    gfc_warning_now ("Flag -fmax-stack-var-size=%d overwrites -frecursive "

                     "implied by -fopenmp",

                     gfc_option.flag_max_stack_var_size);

  /* Implement -frecursive as -fmax-stack-var-size=-1.  */

  if (gfc_option.flag_recursive)

    gfc_option.flag_max_stack_var_size = -1;

  /* Implied -frecursive; implemented as -fmax-stack-var-size=-1.  */

  if (gfc_option.flag_max_stack_var_size == -2 && gfc_option.gfc_flag_openmp

      && gfc_option.flag_automatic)

    {

      gfc_option.flag_recursive = 1;

      gfc_option.flag_max_stack_var_size = -1;

    }

  /* Set default.  */

  if (gfc_option.flag_max_stack_var_size == -2)

    gfc_option.flag_max_stack_var_size = 32768;

  /* Implement -fno-automatic as -fmax-stack-var-size=0.  */

  if (!gfc_option.flag_automatic)

    gfc_option.flag_max_stack_var_size = 0;

  if (pedantic)

    {

      gfc_option.warn_ampersand = 1;

      gfc_option.warn_tabs = 0;

    }

  if (pedantic && gfc_option.flag_whole_file)

    gfc_option.flag_whole_file = 2;

  /* Optimization implies front end optimization, unless the user

     specified it directly.  */

  if (gfc_option.flag_frontend_optimize == -1)

    gfc_option.flag_frontend_optimize = optimize;

  gfc_cpp_post_options ();

/* FIXME: return gfc_cpp_preprocess_only ();

   The return value of this function indicates whether the

   backend needs to be initialized. On -E, we don't need

   the backend. However, if we return 'true' here, an

   ICE occurs. Initializing the backend doesn't hurt much,

   hence, for now we can live with it as is.  */

  return false;

}

/* Set the options for -Wall.  */

static void

set_Wall (int setting)

{

  gfc_option.warn_aliasing = setting;

  gfc_option.warn_ampersand = setting;

  gfc_option.gfc_warn_conversion = setting;

  gfc_option.warn_line_truncation = setting;

  gfc_option.warn_surprising = setting;

  gfc_option.warn_tabs = !setting;

  gfc_option.warn_underflow = setting;

  gfc_option.warn_intrinsic_shadow = setting;

  gfc_option.warn_intrinsics_std = setting;

  gfc_option.warn_character_truncation = setting;

  gfc_option.warn_real_q_constant = setting;

  gfc_option.warn_unused_dummy_argument = setting;

  warn_unused = setting;

  warn_return_type = setting;

  warn_switch = setting;

  warn_uninitialized = setting;

  warn_maybe_uninitialized = setting;

}

static void

gfc_handle_module_path_options (const char *arg)

{

  if (gfc_option.module_dir != NULL)

    gfc_fatal_error ("gfortran: Only one -J option allowed");

  gfc_option.module_dir = XCNEWVEC (char, strlen (arg) + 2);

  strcpy (gfc_option.module_dir, arg);

  gfc_add_include_path (gfc_option.module_dir, true, false);

  strcat (gfc_option.module_dir, "/");

}

static void

gfc_handle_fpe_trap_option (const char *arg)

{

  int result, pos = 0, n;

  /* precision is a backwards compatibility alias for inexact.  */

  static const char * const exception[] = { "invalid", "denormal", "zero",

                                            "overflow", "underflow",

                                            "inexact", "precision", NULL };

  static const int opt_exception[] = { GFC_FPE_INVALID, GFC_FPE_DENORMAL,

                                       GFC_FPE_ZERO, GFC_FPE_OVERFLOW,

                                       GFC_FPE_UNDERFLOW, GFC_FPE_INEXACT,

                                       GFC_FPE_INEXACT,

  while (*arg)

    {

      while (*arg == ',')

        arg++;

      while (arg[pos] && arg[pos] != ',')

        pos++;

      result = 0;

      for (n = 0; exception[n] != NULL; n++)

        {

          if (exception[n] && strncmp (exception[n], arg, pos) == 0)

            {

              gfc_option.fpe |= opt_exception[n];

              arg += pos;

              pos = 0;

              result = 1;

              break;

            }

        }

      if (!result)

        gfc_fatal_error ("Argument to -ffpe-trap is not valid: %s", arg);

    }

}

static void

gfc_handle_coarray_option (const char *arg)

{

  if (strcmp (arg, "none") == 0)

    gfc_option.coarray = GFC_FCOARRAY_NONE;

  else if (strcmp (arg, "single") == 0)

    gfc_option.coarray = GFC_FCOARRAY_SINGLE;

  else if (strcmp (arg, "lib") == 0)

    gfc_option.coarray = GFC_FCOARRAY_LIB;

  else

    gfc_fatal_error ("Argument to -fcoarray is not valid: %s", arg);

}

static void

gfc_handle_runtime_check_option (const char *arg)

{

  int result, pos = 0, n;

  static const char * const optname[] = { "all", "bounds", "array-temps",

                                          "recursion", "do", "pointer",

                                          "mem", NULL };

  static const int optmask[] = { GFC_RTCHECK_ALL, GFC_RTCHECK_BOUNDS,

                                 GFC_RTCHECK_ARRAY_TEMPS,

                                 GFC_RTCHECK_RECURSION, GFC_RTCHECK_DO,

                                 GFC_RTCHECK_POINTER, GFC_RTCHECK_MEM,

  while (*arg)

    {

      while (*arg == ',')

        arg++;

      while (arg[pos] && arg[pos] != ',')

        pos++;

      result = 0;

      for (n = 0; optname[n] != NULL; n++)

        {

          if (optname[n] && strncmp (optname[n], arg, pos) == 0)

            {

              gfc_option.rtcheck |= optmask[n];

              arg += pos;

              pos = 0;

              result = 1;

              break;

            }

        }

      if (!result)

        gfc_fatal_error ("Argument to -fcheck is not valid: %s", arg);

    }

}

/* Handle command-line options.  Returns 0 if unrecognized, 1 if

   recognized and handled.  */

bool

gfc_handle_option (size_t scode, const char *arg, int value,

                   int kind ATTRIBUTE_UNUSED, location_t loc ATTRIBUTE_UNUSED,

                   const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)

{

  bool result = true;

  enum opt_code code = (enum opt_code) scode;

  if (gfc_cpp_handle_option (scode, arg, value) == 1)

    return true;

  switch (code)

    {

    default:

      result = false;

      break;

    case OPT_Wall:

      set_Wall (value);

      break;

    case OPT_Waliasing:

      gfc_option.warn_aliasing = value;

      break;

    case OPT_Wampersand:

      gfc_option.warn_ampersand = value;

      break;

    case OPT_Warray_temporaries:

      gfc_option.warn_array_temp = value;

      break;

    case OPT_Wcharacter_truncation:

      gfc_option.warn_character_truncation = value;

      break;

    case OPT_Wconversion:

      gfc_option.gfc_warn_conversion = value;

      break;

    case OPT_Wconversion_extra:

      gfc_option.warn_conversion_extra = value;

      break;

    case OPT_Wfunction_elimination:

      gfc_option.warn_function_elimination = value;

      break;

    case OPT_Wimplicit_interface:

      gfc_option.warn_implicit_interface = value;

      break;

    case OPT_Wimplicit_procedure:

      gfc_option.warn_implicit_procedure = value;

      break;

    case OPT_Wline_truncation:

      gfc_option.warn_line_truncation = value;

      break;

    case OPT_Wreturn_type:

      warn_return_type = value;

      break;

    case OPT_Wsurprising:

      gfc_option.warn_surprising = value;

      break;

    case OPT_Wtabs:

      gfc_option.warn_tabs = value;

      break;

    case OPT_Wunderflow:

      gfc_option.warn_underflow = value;

      break;

    case OPT_Wintrinsic_shadow:

      gfc_option.warn_intrinsic_shadow = value;

      break;

    case OPT_Walign_commons:

      gfc_option.warn_align_commons = value;

      break;

    case OPT_Wreal_q_constant:

      gfc_option.warn_real_q_constant = value;

      break;

    case OPT_Wunused_dummy_argument:

      gfc_option.warn_unused_dummy_argument = value;

      break;

    case OPT_fall_intrinsics:

      gfc_option.flag_all_intrinsics = 1;

      break;

    case OPT_fautomatic:

      gfc_option.flag_automatic = value;

      break;

    case OPT_fallow_leading_underscore:

      gfc_option.flag_allow_leading_underscore = value;