Subversion Repositories openrisc

/* Command line option handling.

   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007

   Free Software Foundation, Inc.

   Contributed by Neil Booth.

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 "intl.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "rtl.h"

#include "ggc.h"

#include "output.h"

#include "langhooks.h"

#include "opts.h"

#include "options.h"

#include "flags.h"

#include "toplev.h"

#include "params.h"

#include "diagnostic.h"

#include "tm_p.h"               /* For OPTIMIZATION_OPTIONS.  */

#include "insn-attr.h"          /* For INSN_SCHEDULING.  */

#include "target.h"

#include "tree-pass.h"

/* Value of the -G xx switch, and whether it was passed or not.  */

unsigned HOST_WIDE_INT g_switch_value;

bool g_switch_set;

/* True if we should exit after parsing options.  */

bool exit_after_options;

/* Print various extra warnings.  -W/-Wextra.  */

bool extra_warnings;

/* True to warn about any objects definitions whose size is larger

   than N bytes.  Also want about function definitions whose returned

   values are larger than N bytes, where N is `larger_than_size'.  */

bool warn_larger_than;

HOST_WIDE_INT larger_than_size;

/* Nonzero means warn about constructs which might not be

   strict-aliasing safe.  */

int warn_strict_aliasing;

/* Nonzero means warn about optimizations which rely on undefined

   signed overflow.  */

int warn_strict_overflow;

/* Hack for cooperation between set_Wunused and set_Wextra.  */

static bool maybe_warn_unused_parameter;

/* Type(s) of debugging information we are producing (if any).  See

   flags.h for the definitions of the different possible types of

   debugging information.  */

enum debug_info_type write_symbols = NO_DEBUG;

/* Level of debugging information we are producing.  See flags.h for

   the definitions of the different possible levels.  */

enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;

/* Nonzero means use GNU-only extensions in the generated symbolic

   debugging information.  Currently, this only has an effect when

   write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */

bool use_gnu_debug_info_extensions;

/* The default visibility for all symbols (unless overridden) */

enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;

/* Disable unit-at-a-time for frontends that might be still broken in this

   respect.  */

bool no_unit_at_a_time_default;

/* Global visibility options.  */

struct visibility_flags visibility_options;

/* Columns of --help display.  */

static unsigned int columns = 80;

/* What to print when a switch has no documentation.  */

static const char undocumented_msg[] = N_("This switch lacks documentation");

/* Used for bookkeeping on whether user set these flags so

   -fprofile-use/-fprofile-generate does not use them.  */

static bool profile_arc_flag_set, flag_profile_values_set;

static bool flag_unroll_loops_set, flag_tracer_set;

static bool flag_value_profile_transformations_set;

static bool flag_peel_loops_set, flag_branch_probabilities_set;

/* Input file names.  */

const char **in_fnames;

unsigned num_in_fnames;

static int common_handle_option (size_t scode, const char *arg, int value,

                                 unsigned int lang_mask);

static void handle_param (const char *);

static void set_Wextra (int);

static unsigned int handle_option (const char **argv, unsigned int lang_mask);

static char *write_langs (unsigned int lang_mask);

static void complain_wrong_lang (const char *, const struct cl_option *,

                                 unsigned int lang_mask);

static void handle_options (unsigned int, const char **, unsigned int);

static void wrap_help (const char *help, const char *item, unsigned int);

static void print_target_help (void);

static void print_help (void);

static void print_param_help (void);

static void print_filtered_help (unsigned int);

static unsigned int print_switch (const char *text, unsigned int indent);

static void set_debug_level (enum debug_info_type type, int extended,

                             const char *arg);

/* If ARG is a non-negative integer made up solely of digits, return its

   value, otherwise return -1.  */

static int

integral_argument (const char *arg)

{

  const char *p = arg;

  while (*p && ISDIGIT (*p))

    p++;

  if (*p == '\0')

    return atoi (arg);

  return -1;

}

/* Return a malloced slash-separated list of languages in MASK.  */

static char *

write_langs (unsigned int mask)

{

  unsigned int n = 0, len = 0;

  const char *lang_name;

  char *result;

  for (n = 0; (lang_name = lang_names[n]) != 0; n++)

    if (mask & (1U << n))

      len += strlen (lang_name) + 1;

  result = XNEWVEC (char, len);

  len = 0;

  for (n = 0; (lang_name = lang_names[n]) != 0; n++)

    if (mask & (1U << n))

      {

        if (len)

          result[len++] = '/';

        strcpy (result + len, lang_name);

        len += strlen (lang_name);

      }

  result[len] = 0;

  return result;

}

/* Complain that switch OPT_INDEX does not apply to this front end.  */

static void

complain_wrong_lang (const char *text, const struct cl_option *option,

                     unsigned int lang_mask)

{

  char *ok_langs, *bad_lang;

  ok_langs = write_langs (option->flags);

  bad_lang = write_langs (lang_mask);

  /* Eventually this should become a hard error IMO.  */

  warning (0, "command line option \"%s\" is valid for %s but not for %s",

           text, ok_langs, bad_lang);

  free (ok_langs);

  free (bad_lang);

}

/* Handle the switch beginning at ARGV for the language indicated by

   LANG_MASK.  Returns the number of switches consumed.  */

static unsigned int

handle_option (const char **argv, unsigned int lang_mask)

{

  size_t opt_index;

  const char *opt, *arg = 0;

  char *dup = 0;

  int value = 1;

  unsigned int result = 0;

  const struct cl_option *option;

  opt = argv[0];

  opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);

  if (opt_index == cl_options_count

      && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')

      && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')

    {

      /* Drop the "no-" from negative switches.  */

      size_t len = strlen (opt) - 3;

      dup = XNEWVEC (char, len + 1);

      dup[0] = '-';

      dup[1] = opt[1];

      memcpy (dup + 2, opt + 5, len - 2 + 1);

      opt = dup;

      value = 0;

      opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);

    }

  if (opt_index == cl_options_count)

    goto done;

  option = &cl_options[opt_index];

  /* Reject negative form of switches that don't take negatives as

     unrecognized.  */

  if (!value && (option->flags & CL_REJECT_NEGATIVE))

    goto done;

  /* We've recognized this switch.  */

  result = 1;

  /* Check to see if the option is disabled for this configuration.  */

  if (option->flags & CL_DISABLED)

    {

      error ("command line option %qs"

             " is not supported by this configuration", opt);

      goto done;

    }

  /* Sort out any argument the switch takes.  */

  if (option->flags & CL_JOINED)

    {

      /* Have arg point to the original switch.  This is because

         some code, such as disable_builtin_function, expects its

         argument to be persistent until the program exits.  */

      arg = argv[0] + cl_options[opt_index].opt_len + 1;

      if (!value)

        arg += strlen ("no-");

      if (*arg == '\0' && !(option->flags & CL_MISSING_OK))

        {

          if (option->flags & CL_SEPARATE)

            {

              arg = argv[1];

              result = 2;

            }

          else

            /* Missing argument.  */

            arg = NULL;

        }

    }

  else if (option->flags & CL_SEPARATE)

    {

      arg = argv[1];

      result = 2;

    }

  /* Now we've swallowed any potential argument, complain if this

     is a switch for a different front end.  */

  if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))

    {

      complain_wrong_lang (argv[0], option, lang_mask);

      goto done;

    }

  if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))

    {

      if (!lang_hooks.missing_argument (opt, opt_index))

        error ("missing argument to \"%s\"", opt);

      goto done;

    }

  /* If the switch takes an integer, convert it.  */

  if (arg && (option->flags & CL_UINTEGER))

    {

      value = integral_argument (arg);

      if (value == -1)

        {

          error ("argument to \"%s\" should be a non-negative integer",

                 option->opt_text);

          goto done;

        }

    }

  if (option->flag_var)

    switch (option->var_type)

      {

      case CLVC_BOOLEAN:

        *(int *) option->flag_var = value;

        break;

      case CLVC_EQUAL:

        *(int *) option->flag_var = (value

                                     ? option->var_value

                                     : !option->var_value);

        break;

      case CLVC_BIT_CLEAR:

      case CLVC_BIT_SET:

        if ((value != 0) == (option->var_type == CLVC_BIT_SET))

          *(int *) option->flag_var |= option->var_value;

        else

          *(int *) option->flag_var &= ~option->var_value;

        if (option->flag_var == &target_flags)

          target_flags_explicit |= option->var_value;

        break;

      case CLVC_STRING:

        *(const char **) option->flag_var = arg;

        break;

      }

  if (option->flags & lang_mask)

    if (lang_hooks.handle_option (opt_index, arg, value) == 0)

      result = 0;

  if (result && (option->flags & CL_COMMON))

    if (common_handle_option (opt_index, arg, value, lang_mask) == 0)

      result = 0;

  if (result && (option->flags & CL_TARGET))

    if (!targetm.handle_option (opt_index, arg, value))

      result = 0;

 done:

  if (dup)

    free (dup);

  return result;

}

/* Handle FILENAME from the command line.  */

static void

add_input_filename (const char *filename)

{

  num_in_fnames++;

  in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));

  in_fnames[num_in_fnames - 1] = filename;

}

/* Decode and handle the vector of command line options.  LANG_MASK

   contains has a single bit set representing the current

   language.  */

static void

handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)

{

  unsigned int n, i;

  for (i = 1; i < argc; i += n)

    {

      const char *opt = argv[i];

      /* Interpret "-" or a non-switch as a file name.  */

      if (opt[0] != '-' || opt[1] == '\0')

        {

          if (main_input_filename == NULL)

            main_input_filename = opt;

          add_input_filename (opt);

          n = 1;

          continue;

        }

      n = handle_option (argv + i, lang_mask);

      if (!n)

        {

          n = 1;

          error ("unrecognized command line option \"%s\"", opt);

        }

    }

}

/* Parse command line options and set default flag values.  Do minimal

   options processing.  */

void

decode_options (unsigned int argc, const char **argv)

{

  unsigned int i, lang_mask;

  /* Perform language-specific options initialization.  */

  lang_mask = lang_hooks.init_options (argc, argv);

  lang_hooks.initialize_diagnostics (global_dc);

  /* Scan to see what optimization level has been specified.  That will

     determine the default value of many flags.  */

  for (i = 1; i < argc; i++)

    {

      if (!strcmp (argv[i], "-O"))

        {

          optimize = 1;

          optimize_size = 0;

        }

      else if (argv[i][0] == '-' && argv[i][1] == 'O')

        {

          /* Handle -Os, -O2, -O3, -O69, ...  */

          const char *p = &argv[i][2];

          if ((p[0] == 's') && (p[1] == 0))

            {

              optimize_size = 1;

              /* Optimizing for size forces optimize to be 2.  */

              optimize = 2;

            }

          else

            {

              const int optimize_val = read_integral_parameter (p, p - 2, -1);

              if (optimize_val != -1)

                {

                  optimize = optimize_val;

                  optimize_size = 0;

                }

            }

        }

    }

  if (!optimize)

    {

      flag_merge_constants = 0;

    }

  if (optimize >= 1)

    {

      flag_defer_pop = 1;

#ifdef DELAY_SLOTS

      flag_delayed_branch = 1;

#endif

#ifdef CAN_DEBUG_WITHOUT_FP

      flag_omit_frame_pointer = 1;

#endif

      flag_guess_branch_prob = 1;

      flag_cprop_registers = 1;

      flag_if_conversion = 1;

      flag_if_conversion2 = 1;

      flag_ipa_pure_const = 1;

      flag_ipa_reference = 1;

      flag_tree_ccp = 1;

      flag_tree_dce = 1;

      flag_tree_dom = 1;

      flag_tree_dse = 1;

      flag_tree_ter = 1;

      flag_tree_live_range_split = 1;

      flag_tree_sra = 1;

      flag_tree_copyrename = 1;

      flag_tree_fre = 1;

      flag_tree_copy_prop = 1;

      flag_tree_sink = 1;

      flag_tree_salias = 1;

      if (!no_unit_at_a_time_default)

        flag_unit_at_a_time = 1;

      if (!optimize_size)

        {

          /* Loop header copying usually increases size of the code.  This used

             not to be true, since quite often it is possible to verify that

             the condition is satisfied in the first iteration and therefore

             to eliminate it.  Jump threading handles these cases now.  */

          flag_tree_ch = 1;

        }

    }

  if (optimize >= 2)

    {

      flag_thread_jumps = 1;

      flag_crossjumping = 1;

      flag_optimize_sibling_calls = 1;

      flag_cse_follow_jumps = 1;

      flag_cse_skip_blocks = 1;

      flag_gcse = 1;

      flag_expensive_optimizations = 1;

      flag_ipa_type_escape = 1;

      flag_rerun_cse_after_loop = 1;

      flag_caller_saves = 1;

      flag_peephole2 = 1;

#ifdef INSN_SCHEDULING

      flag_schedule_insns = 1;

      flag_schedule_insns_after_reload = 1;

#endif

      flag_regmove = 1;

      flag_strict_aliasing = 1;

      flag_strict_overflow = 1;

      flag_delete_null_pointer_checks = 1;

      flag_reorder_blocks = 1;

      flag_reorder_functions = 1;

      flag_tree_store_ccp = 1;

      flag_tree_store_copy_prop = 1;

      flag_tree_vrp = 1;

      if (!optimize_size)

        {

          /* PRE tends to generate bigger code.  */

          flag_tree_pre = 1;

        }

    }

  if (optimize >= 3)

    {

      flag_inline_functions = 1;

      flag_unswitch_loops = 1;

      flag_gcse_after_reload = 1;

    }

  if (optimize < 2 || optimize_size)

    {

      align_loops = 1;

      align_jumps = 1;

      align_labels = 1;

      align_functions = 1;

      /* Don't reorder blocks when optimizing for size because extra

         jump insns may be created; also barrier may create extra padding.

         More correctly we should have a block reordering mode that tried

         to minimize the combined size of all the jumps.  This would more

         or less automatically remove extra jumps, but would also try to

         use more short jumps instead of long jumps.  */

      flag_reorder_blocks = 0;

      flag_reorder_blocks_and_partition = 0;

    }

  if (optimize_size)

    {

      /* Inlining of very small functions usually reduces total size.  */

      set_param_value ("max-inline-insns-single", 5);

      set_param_value ("max-inline-insns-auto", 5);

      flag_inline_functions = 1;

      /* We want to crossjump as much as possible.  */

      set_param_value ("min-crossjump-insns", 1);

    }

  /* Initialize whether `char' is signed.  */

  flag_signed_char = DEFAULT_SIGNED_CHAR;

  /* Set this to a special "uninitialized" value.  The actual default is set

     after target options have been processed.  */

  flag_short_enums = 2;

  /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can

     modify it.  */

  target_flags = targetm.default_target_flags;

  /* Some tagets have ABI-specified unwind tables.  */

  flag_unwind_tables = targetm.unwind_tables_default;

#ifdef OPTIMIZATION_OPTIONS

  /* Allow default optimizations to be specified on a per-machine basis.  */

  OPTIMIZATION_OPTIONS (optimize, optimize_size);

#endif

  handle_options (argc, argv, lang_mask);

  if (flag_pie)

    flag_pic = flag_pie;

  if (flag_pic && !flag_pie)

    flag_shlib = 1;

  if (flag_no_inline == 2)

    flag_no_inline = 0;

  else

    flag_really_no_inline = flag_no_inline;

  /* Set flag_no_inline before the post_options () hook.  The C front

     ends use it to determine tree inlining defaults.  FIXME: such

     code should be lang-independent when all front ends use tree

     inlining, in which case it, and this condition, should be moved

     to the top of process_options() instead.  */

  if (optimize == 0)

    {

      /* Inlining does not work if not optimizing,

         so force it not to be done.  */

      flag_no_inline = 1;

      warn_inline = 0;

      /* The c_decode_option function and decode_option hook set

         this to `2' if -Wall is used, so we can avoid giving out

         lots of errors for people who don't realize what -Wall does.  */

      if (warn_uninitialized == 1)

        warning (OPT_Wuninitialized,

                 "-Wuninitialized is not supported without -O");

    }

  if (flag_really_no_inline == 2)

    flag_really_no_inline = flag_no_inline;

  /* The optimization to partition hot and cold basic blocks into separate

     sections of the .o and executable files does not work (currently)

     with exception handling.  This is because there is no support for

     generating unwind info.  If flag_exceptions is turned on we need to

     turn off the partitioning optimization.  */

  if (flag_exceptions && flag_reorder_blocks_and_partition)

    {

      inform

            ("-freorder-blocks-and-partition does not work with exceptions");

      flag_reorder_blocks_and_partition = 0;

      flag_reorder_blocks = 1;

    }

  /* If user requested unwind info, then turn off the partitioning

     optimization.  */

  if (flag_unwind_tables && ! targetm.unwind_tables_default

      && flag_reorder_blocks_and_partition)

    {

      inform ("-freorder-blocks-and-partition does not support unwind info");

      flag_reorder_blocks_and_partition = 0;

      flag_reorder_blocks = 1;

    }

  /* If the target requested unwind info, then turn off the partitioning

     optimization with a different message.  Likewise, if the target does not

     support named sections.  */

  if (flag_reorder_blocks_and_partition

      && (!targetm.have_named_sections

          || (flag_unwind_tables && targetm.unwind_tables_default)))

    {

      inform

       ("-freorder-blocks-and-partition does not work on this architecture");

      flag_reorder_blocks_and_partition = 0;

      flag_reorder_blocks = 1;

    }

}

/* Handle target- and language-independent options.  Return zero to

   generate an "unknown option" message.  Only options that need

   extra handling need to be listed here; if you simply want

   VALUE assigned to a variable, it happens automatically.  */

static int

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

                      unsigned int lang_mask)

{

  enum opt_code code = (enum opt_code) scode;

  switch (code)

    {

    case OPT__help:

      print_help ();

      exit_after_options = true;

      break;

    case OPT__param:

      handle_param (arg);

      break;

    case OPT__target_help:

      print_target_help ();

      exit_after_options = true;

      break;

    case OPT__version:

      print_version (stderr, "");

      exit_after_options = true;

      break;

    case OPT_G:

      g_switch_value = value;

      g_switch_set = true;

      break;

    case OPT_O:

    case OPT_Os:

      /* Currently handled in a prescan.  */

      break;

    case OPT_W:

      /* For backward compatibility, -W is the same as -Wextra.  */

      set_Wextra (value);

      break;

    case OPT_Werror_:

      {

        char *new_option;

        int option_index;

        new_option = XNEWVEC (char, strlen (arg) + 2);