Subversion Repositories openrisc_me

/* Command line option handling.

   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010

   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 "expr.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"

#include "dbgcnt.h"

#include "debug.h"

#include "plugin.h"

#include "except.h"

#include "lto-streamer.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;

/* Same for selective scheduling.  */

bool sel_sched_switch_set;

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

bool exit_after_options;

/* 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;

/* True to warn about any function whose frame size is larger

 * than N bytes. */

bool warn_frame_larger_than;

HOST_WIDE_INT frame_larger_than_size;

/* 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;

/* A major contribution to object and executable size is debug

   information size.  A major contribution to debug information size

   is struct descriptions replicated in several object files. The

   following flags attempt to reduce this information.  The basic

   idea is to not emit struct debugging information in the current

   compilation unit when that information will be generated by

   another compilation unit.

   Debug information for a struct defined in the current source

   file should be generated in the object file.  Likewise the

   debug information for a struct defined in a header should be

   generated in the object file of the corresponding source file.

   Both of these case are handled when the base name of the file of

   the struct definition matches the base name of the source file

   of the current compilation unit.  This matching emits minimal

   struct debugging information.

   The base file name matching rule above will fail to emit debug

   information for structs defined in system headers.  So a second

   category of files includes system headers in addition to files

   with matching bases.

   The remaining types of files are library headers and application

   headers.  We cannot currently distinguish these two types.  */

enum debug_struct_file

{

  DINFO_STRUCT_FILE_NONE,   /* Debug no structs. */

  DINFO_STRUCT_FILE_BASE,   /* Debug structs defined in files with the

                               same base name as the compilation unit. */

  DINFO_STRUCT_FILE_SYS,    /* Also debug structs defined in system

                               header files.  */

  DINFO_STRUCT_FILE_ANY     /* Debug structs defined in all files. */

};

/* Generic structs (e.g. templates not explicitly specialized)

   may not have a compilation unit associated with them, and so

   may need to be treated differently from ordinary structs.

   Structs only handled by reference (indirectly), will also usually

   not need as much debugging information.  */

static enum debug_struct_file debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]

  = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };

static enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]

  = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };

/* Parse the -femit-struct-debug-detailed option value

   and set the flag variables. */

#define MATCH( prefix, string ) \

  ((strncmp (prefix, string, sizeof prefix - 1) == 0) \

   ? ((string += sizeof prefix - 1), 1) : 0)

void

set_struct_debug_option (const char *spec)

{

  /* various labels for comparison */

  static char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";

  static char ord_lbl[] = "ord:", gen_lbl[] = "gen:";

  static char none_lbl[] = "none", any_lbl[] = "any";

  static char base_lbl[] = "base", sys_lbl[] = "sys";

  enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;

  /* Default is to apply to as much as possible. */

  enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;

  int ord = 1, gen = 1;

  /* What usage? */

  if (MATCH (dfn_lbl, spec))

    usage = DINFO_USAGE_DFN;

  else if (MATCH (dir_lbl, spec))

    usage = DINFO_USAGE_DIR_USE;

  else if (MATCH (ind_lbl, spec))

    usage = DINFO_USAGE_IND_USE;

  /* Generics or not? */

  if (MATCH (ord_lbl, spec))

    gen = 0;

  else if (MATCH (gen_lbl, spec))

    ord = 0;

  /* What allowable environment? */

  if (MATCH (none_lbl, spec))

    files = DINFO_STRUCT_FILE_NONE;

  else if (MATCH (any_lbl, spec))

    files = DINFO_STRUCT_FILE_ANY;

  else if (MATCH (sys_lbl, spec))

    files = DINFO_STRUCT_FILE_SYS;

  else if (MATCH (base_lbl, spec))

    files = DINFO_STRUCT_FILE_BASE;

  else

    error ("argument %qs to %<-femit-struct-debug-detailed%> not recognized",

           spec);

  /* Effect the specification. */

  if (usage == DINFO_USAGE_NUM_ENUMS)

    {

      if (ord)

        {

          debug_struct_ordinary[DINFO_USAGE_DFN] = files;

          debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;

          debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;

        }

      if (gen)

        {

          debug_struct_generic[DINFO_USAGE_DFN] = files;

          debug_struct_generic[DINFO_USAGE_DIR_USE] = files;

          debug_struct_generic[DINFO_USAGE_IND_USE] = files;

        }

    }

  else

    {

      if (ord)

        debug_struct_ordinary[usage] = files;

      if (gen)

        debug_struct_generic[usage] = files;

    }

  if (*spec == ',')

    set_struct_debug_option (spec+1);

  else

    {

      /* No more -femit-struct-debug-detailed specifications.

         Do final checks. */

      if (*spec != '\0')

        error ("argument %qs to %<-femit-struct-debug-detailed%> unknown",

               spec);

      if (debug_struct_ordinary[DINFO_USAGE_DIR_USE]

                < debug_struct_ordinary[DINFO_USAGE_IND_USE]

          || debug_struct_generic[DINFO_USAGE_DIR_USE]

                < debug_struct_generic[DINFO_USAGE_IND_USE])

        error ("%<-femit-struct-debug-detailed=dir:...%> must allow at least"

               " as much as %<-femit-struct-debug-detailed=ind:...%>");

    }

}

/* Find the base name of a path, stripping off both directories and

   a single final extension. */

static int

base_of_path (const char *path, const char **base_out)

{

  const char *base = path;

  const char *dot = 0;

  const char *p = path;

  char c = *p;

  while (c)

    {

      if (IS_DIR_SEPARATOR(c))

        {

          base = p + 1;

          dot = 0;

        }

      else if (c == '.')

        dot = p;

      c = *++p;

    }

  if (!dot)

    dot = p;

  *base_out = base;

  return dot - base;

}

/* Match the base name of a file to the base name of a compilation unit. */

static const char *main_input_basename;

static int main_input_baselength;

static int

matches_main_base (const char *path)

{

  /* Cache the last query. */

  static const char *last_path = NULL;

  static int last_match = 0;

  if (path != last_path)

    {

      const char *base;

      int length = base_of_path (path, &base);

      last_path = path;

      last_match = (length == main_input_baselength

                    && memcmp (base, main_input_basename, length) == 0);

    }

  return last_match;

}

#ifdef DEBUG_DEBUG_STRUCT

static int

dump_struct_debug (tree type, enum debug_info_usage usage,

                   enum debug_struct_file criterion, int generic,

                   int matches, int result)

{

  /* Find the type name. */

  tree type_decl = TYPE_STUB_DECL (type);

  tree t = type_decl;

  const char *name = 0;

  if (TREE_CODE (t) == TYPE_DECL)

    t = DECL_NAME (t);

  if (t)

    name = IDENTIFIER_POINTER (t);

  fprintf (stderr, "    struct %d %s %s %s %s %d %p %s\n",

           criterion,

           DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",

           matches ? "bas" : "hdr",

           generic ? "gen" : "ord",

           usage == DINFO_USAGE_DFN ? ";" :

             usage == DINFO_USAGE_DIR_USE ? "." : "*",

           result,

           (void*) type_decl, name);

  return result;

}

#define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \

  dump_struct_debug (type, usage, criterion, generic, matches, result)

#else

#define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \

  (result)

#endif

bool

should_emit_struct_debug (tree type, enum debug_info_usage usage)

{

  enum debug_struct_file criterion;

  tree type_decl;

  bool generic = lang_hooks.types.generic_p (type);

  if (generic)

    criterion = debug_struct_generic[usage];

  else

    criterion = debug_struct_ordinary[usage];

  if (criterion == DINFO_STRUCT_FILE_NONE)

    return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);

  if (criterion == DINFO_STRUCT_FILE_ANY)

    return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);

  type_decl = TYPE_STUB_DECL (type);

  if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))

    return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);

  if (matches_main_base (DECL_SOURCE_FILE (type_decl)))

    return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);

  return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);

}

/* 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;

/* Global visibility options.  */

struct visibility_flags visibility_options;

/* 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;

static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;

static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;

/* Functions excluded from profiling.  */

typedef char *char_p; /* For DEF_VEC_P.  */

DEF_VEC_P(char_p);

DEF_VEC_ALLOC_P(char_p,heap);

static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;

static VEC(char_p,heap) *flag_instrument_functions_exclude_files;

typedef const char *const_char_p; /* For DEF_VEC_P.  */

DEF_VEC_P(const_char_p);

DEF_VEC_ALLOC_P(const_char_p,heap);

static VEC(const_char_p,heap) *ignored_options;

/* Language specific warning pass for unused results.  */

bool flag_warn_unused_result = false;

/* 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 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 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;

  /* The LTO front end inherits all the options from the first front

     end that was used.  However, not all the original front end

     options make sense in LTO.

     A real solution would be to filter this in collect2, but collect2

     does not have access to all the option attributes to know what to

     filter.  So, in lto1 we silently accept inherited flags and do

     nothing about it.  */

  if (lang_mask & CL_LTO)

    return;

  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);

}

/* Buffer the unknown option described by the string OPT.  Currently,

   we only complain about unknown -Wno-* options if they may have

   prevented a diagnostic. Otherwise, we just ignore them.

   Note that if we do complain, it is only as a warning, not an error;

   passing the compiler an unrecognised -Wno-* option should never

   change whether the compilation succeeds or fails.  */

static void postpone_unknown_option_warning(const char *opt)

{

  VEC_safe_push (const_char_p, heap, ignored_options, opt);

}

/* Produce a warning for each option previously buffered.  */

void print_ignored_options (void)

{

  location_t saved_loc = input_location;

  input_location = 0;

  while (!VEC_empty (const_char_p, ignored_options))

    {

      const char *opt;

      opt = VEC_pop (const_char_p, ignored_options);

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

    }

  input_location = saved_loc;

}

/* 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 && opt[1] == 'W')

        {

          /* We don't generate warnings for unknown -Wno-* options

             unless we issue diagnostics.  */

          postpone_unknown_option_warning (argv[0]);

          result = 1;

          goto done;

        }

    }

  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;

    }

  else if ((option->flags & CL_TARGET)

           && (option->flags & CL_LANG_ALL)

           && !(option->flags & lang_mask))

    {

      /* Complain for target flag language mismatches if any languages

         are specified.  */

      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)

    set_option (option, value, arg);

  if (option->flags & lang_mask)

    {

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

        result = 0;

#ifdef ENABLE_LTO

      else

        lto_register_user_option (opt_index, arg, value, lang_mask);

#endif

    }

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

    {

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

        result = 0;

#ifdef ENABLE_LTO

      else

        lto_register_user_option (opt_index, arg, value, CL_COMMON);

#endif

    }

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

    {

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

        result = 0;

#ifdef ENABLE_LTO

      else

        lto_register_user_option (opt_index, arg, value, CL_TARGET);

#endif

    }

 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 = XRESIZEVEC (const char *, in_fnames, num_in_fnames);

  in_fnames[num_in_fnames - 1] = filename;

}

/* Add comma-separated strings to a char_p vector.  */

static void

add_comma_separated_to_vector (VEC(char_p,heap) **pvec, const char* arg)

{

  char *tmp;

  char *r;

  char *w;

  char *token_start;

  /* We never free this string.  */

  tmp = xstrdup (arg);

  r = tmp;

  w = tmp;

  token_start = tmp;

  while (*r != '\0')

    {

      if (*r == ',')

        {

          *w++ = '\0';

          ++r;

          VEC_safe_push (char_p, heap, *pvec, token_start);