OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [tags/] [gnu-dev/] [fsf-gcc-snapshot-1-mar-12/] [or1k-gcc/] [gcc/] [opts-global.c] - Diff between revs 684 and 783

Only display areas with differences | Details | Blame | View Log

Rev 684 Rev 783
/* Command line option handling.  Code involving global state that
/* Command line option handling.  Code involving global state that
   should not be shared with the driver.
   should not be shared with the driver.
   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
 
 
This file is part of GCC.
This file is part of GCC.
 
 
GCC is free software; you can redistribute it and/or modify it under
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
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
Software Foundation; either version 3, or (at your option) any later
version.
version.
 
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.
for more details.
 
 
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
<http://www.gnu.org/licenses/>.  */
 
 
#include "config.h"
#include "config.h"
#include "system.h"
#include "system.h"
#include "coretypes.h"
#include "coretypes.h"
#include "diagnostic.h"
#include "diagnostic.h"
#include "opts.h"
#include "opts.h"
#include "flags.h"
#include "flags.h"
#include "ggc.h"
#include "ggc.h"
#include "tree.h" /* Required by langhooks.h.  */
#include "tree.h" /* Required by langhooks.h.  */
#include "langhooks.h"
#include "langhooks.h"
#include "tm.h" /* Required by rtl.h.  */
#include "tm.h" /* Required by rtl.h.  */
#include "rtl.h"
#include "rtl.h"
#include "dbgcnt.h"
#include "dbgcnt.h"
#include "debug.h"
#include "debug.h"
#include "lto-streamer.h"
#include "lto-streamer.h"
#include "output.h"
#include "output.h"
#include "plugin.h"
#include "plugin.h"
#include "toplev.h"
#include "toplev.h"
#include "tree-pass.h"
#include "tree-pass.h"
 
 
typedef const char *const_char_p; /* For DEF_VEC_P.  */
typedef const char *const_char_p; /* For DEF_VEC_P.  */
DEF_VEC_P(const_char_p);
DEF_VEC_P(const_char_p);
DEF_VEC_ALLOC_P(const_char_p,heap);
DEF_VEC_ALLOC_P(const_char_p,heap);
 
 
static VEC(const_char_p,heap) *ignored_options;
static VEC(const_char_p,heap) *ignored_options;
 
 
/* Input file names.  */
/* Input file names.  */
const char **in_fnames;
const char **in_fnames;
unsigned num_in_fnames;
unsigned num_in_fnames;
 
 
/* Return a malloced slash-separated list of languages in MASK.  */
/* Return a malloced slash-separated list of languages in MASK.  */
 
 
static char *
static char *
write_langs (unsigned int mask)
write_langs (unsigned int mask)
{
{
  unsigned int n = 0, len = 0;
  unsigned int n = 0, len = 0;
  const char *lang_name;
  const char *lang_name;
  char *result;
  char *result;
 
 
  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
    if (mask & (1U << n))
    if (mask & (1U << n))
      len += strlen (lang_name) + 1;
      len += strlen (lang_name) + 1;
 
 
  result = XNEWVEC (char, len);
  result = XNEWVEC (char, len);
  len = 0;
  len = 0;
  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
    if (mask & (1U << n))
    if (mask & (1U << n))
      {
      {
        if (len)
        if (len)
          result[len++] = '/';
          result[len++] = '/';
        strcpy (result + len, lang_name);
        strcpy (result + len, lang_name);
        len += strlen (lang_name);
        len += strlen (lang_name);
      }
      }
 
 
  result[len] = 0;
  result[len] = 0;
 
 
  return result;
  return result;
}
}
 
 
/* Complain that switch DECODED does not apply to this front end (mask
/* Complain that switch DECODED does not apply to this front end (mask
   LANG_MASK).  */
   LANG_MASK).  */
 
 
static void
static void
complain_wrong_lang (const struct cl_decoded_option *decoded,
complain_wrong_lang (const struct cl_decoded_option *decoded,
                     unsigned int lang_mask)
                     unsigned int lang_mask)
{
{
  const struct cl_option *option = &cl_options[decoded->opt_index];
  const struct cl_option *option = &cl_options[decoded->opt_index];
  const char *text = decoded->orig_option_with_args_text;
  const char *text = decoded->orig_option_with_args_text;
  char *ok_langs = NULL, *bad_lang = NULL;
  char *ok_langs = NULL, *bad_lang = NULL;
  unsigned int opt_flags = option->flags;
  unsigned int opt_flags = option->flags;
 
 
  if (!lang_hooks.complain_wrong_lang_p (option))
  if (!lang_hooks.complain_wrong_lang_p (option))
    return;
    return;
 
 
  opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
  opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
  if (opt_flags != CL_DRIVER)
  if (opt_flags != CL_DRIVER)
    ok_langs = write_langs (opt_flags);
    ok_langs = write_langs (opt_flags);
  if (lang_mask != CL_DRIVER)
  if (lang_mask != CL_DRIVER)
    bad_lang = write_langs (lang_mask);
    bad_lang = write_langs (lang_mask);
 
 
  if (opt_flags == CL_DRIVER)
  if (opt_flags == CL_DRIVER)
    error ("command line option %qs is valid for the driver but not for %s",
    error ("command line option %qs is valid for the driver but not for %s",
           text, bad_lang);
           text, bad_lang);
  else if (lang_mask == CL_DRIVER)
  else if (lang_mask == CL_DRIVER)
    gcc_unreachable ();
    gcc_unreachable ();
  else
  else
    /* Eventually this should become a hard error IMO.  */
    /* Eventually this should become a hard error IMO.  */
    warning (0, "command line option %qs is valid for %s but not for %s",
    warning (0, "command line option %qs is valid for %s but not for %s",
             text, ok_langs, bad_lang);
             text, ok_langs, bad_lang);
 
 
  free (ok_langs);
  free (ok_langs);
  free (bad_lang);
  free (bad_lang);
}
}
 
 
/* Buffer the unknown option described by the string OPT.  Currently,
/* Buffer the unknown option described by the string OPT.  Currently,
   we only complain about unknown -Wno-* options if they may have
   we only complain about unknown -Wno-* options if they may have
   prevented a diagnostic. Otherwise, we just ignore them.  Note that
   prevented a diagnostic. Otherwise, we just ignore them.  Note that
   if we do complain, it is only as a warning, not an error; passing
   if we do complain, it is only as a warning, not an error; passing
   the compiler an unrecognised -Wno-* option should never change
   the compiler an unrecognised -Wno-* option should never change
   whether the compilation succeeds or fails.  */
   whether the compilation succeeds or fails.  */
 
 
static void
static void
postpone_unknown_option_warning (const char *opt)
postpone_unknown_option_warning (const char *opt)
{
{
  VEC_safe_push (const_char_p, heap, ignored_options, opt);
  VEC_safe_push (const_char_p, heap, ignored_options, opt);
}
}
 
 
/* Produce a warning for each option previously buffered.  */
/* Produce a warning for each option previously buffered.  */
 
 
void
void
print_ignored_options (void)
print_ignored_options (void)
{
{
  while (!VEC_empty (const_char_p, ignored_options))
  while (!VEC_empty (const_char_p, ignored_options))
    {
    {
      const char *opt;
      const char *opt;
 
 
      opt = VEC_pop (const_char_p, ignored_options);
      opt = VEC_pop (const_char_p, ignored_options);
      warning_at (UNKNOWN_LOCATION, 0,
      warning_at (UNKNOWN_LOCATION, 0,
                  "unrecognized command line option \"%s\"", opt);
                  "unrecognized command line option \"%s\"", opt);
    }
    }
}
}
 
 
/* Handle an unknown option DECODED, returning true if an error should
/* Handle an unknown option DECODED, returning true if an error should
   be given.  */
   be given.  */
 
 
static bool
static bool
unknown_option_callback (const struct cl_decoded_option *decoded)
unknown_option_callback (const struct cl_decoded_option *decoded)
{
{
  const char *opt = decoded->arg;
  const char *opt = decoded->arg;
 
 
  if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
  if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
      && !(decoded->errors & CL_ERR_NEGATIVE))
      && !(decoded->errors & CL_ERR_NEGATIVE))
    {
    {
      /* We don't generate warnings for unknown -Wno-* options unless
      /* We don't generate warnings for unknown -Wno-* options unless
         we issue diagnostics.  */
         we issue diagnostics.  */
      postpone_unknown_option_warning (opt);
      postpone_unknown_option_warning (opt);
      return false;
      return false;
    }
    }
  else
  else
    return true;
    return true;
}
}
 
 
/* Handle a front-end option; arguments and return value as for
/* Handle a front-end option; arguments and return value as for
   handle_option.  */
   handle_option.  */
 
 
static bool
static bool
lang_handle_option (struct gcc_options *opts,
lang_handle_option (struct gcc_options *opts,
                    struct gcc_options *opts_set,
                    struct gcc_options *opts_set,
                    const struct cl_decoded_option *decoded,
                    const struct cl_decoded_option *decoded,
                    unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
                    unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
                    location_t loc,
                    location_t loc,
                    const struct cl_option_handlers *handlers,
                    const struct cl_option_handlers *handlers,
                    diagnostic_context *dc)
                    diagnostic_context *dc)
{
{
  gcc_assert (opts == &global_options);
  gcc_assert (opts == &global_options);
  gcc_assert (opts_set == &global_options_set);
  gcc_assert (opts_set == &global_options_set);
  gcc_assert (dc == global_dc);
  gcc_assert (dc == global_dc);
  gcc_assert (decoded->canonical_option_num_elements <= 2);
  gcc_assert (decoded->canonical_option_num_elements <= 2);
  return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
  return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
                                   decoded->value, kind, loc, handlers);
                                   decoded->value, kind, loc, handlers);
}
}
 
 
/* Handle FILENAME from the command line.  */
/* Handle FILENAME from the command line.  */
 
 
static void
static void
add_input_filename (const char *filename)
add_input_filename (const char *filename)
{
{
  num_in_fnames++;
  num_in_fnames++;
  in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
  in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
  in_fnames[num_in_fnames - 1] = filename;
  in_fnames[num_in_fnames - 1] = filename;
}
}
 
 
/* Handle the vector of command line options (located at LOC), storing
/* Handle the vector of command line options (located at LOC), storing
   the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
   the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
   in OPTS and OPTS_SET and using DC for diagnostic state.  LANG_MASK
   in OPTS and OPTS_SET and using DC for diagnostic state.  LANG_MASK
   contains has a single bit set representing the current language.
   contains has a single bit set representing the current language.
   HANDLERS describes what functions to call for the options.  */
   HANDLERS describes what functions to call for the options.  */
 
 
static void
static void
read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
                      struct cl_decoded_option *decoded_options,
                      struct cl_decoded_option *decoded_options,
                      unsigned int decoded_options_count,
                      unsigned int decoded_options_count,
                      location_t loc,
                      location_t loc,
                      unsigned int lang_mask,
                      unsigned int lang_mask,
                      const struct cl_option_handlers *handlers,
                      const struct cl_option_handlers *handlers,
                      diagnostic_context *dc)
                      diagnostic_context *dc)
{
{
  unsigned int i;
  unsigned int i;
 
 
  for (i = 1; i < decoded_options_count; i++)
  for (i = 1; i < decoded_options_count; i++)
    {
    {
      if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
      if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
        {
        {
          /* Input files should only ever appear on the main command
          /* Input files should only ever appear on the main command
             line.  */
             line.  */
          gcc_assert (opts == &global_options);
          gcc_assert (opts == &global_options);
          gcc_assert (opts_set == &global_options_set);
          gcc_assert (opts_set == &global_options_set);
 
 
          if (opts->x_main_input_filename == NULL)
          if (opts->x_main_input_filename == NULL)
            {
            {
              opts->x_main_input_filename = decoded_options[i].arg;
              opts->x_main_input_filename = decoded_options[i].arg;
              opts->x_main_input_baselength
              opts->x_main_input_baselength
                = base_of_path (opts->x_main_input_filename,
                = base_of_path (opts->x_main_input_filename,
                                &opts->x_main_input_basename);
                                &opts->x_main_input_basename);
            }
            }
          add_input_filename (decoded_options[i].arg);
          add_input_filename (decoded_options[i].arg);
          continue;
          continue;
        }
        }
 
 
      read_cmdline_option (opts, opts_set,
      read_cmdline_option (opts, opts_set,
                           decoded_options + i, loc, lang_mask, handlers,
                           decoded_options + i, loc, lang_mask, handlers,
                           dc);
                           dc);
    }
    }
}
}
 
 
/* Language mask determined at initialization.  */
/* Language mask determined at initialization.  */
static unsigned int initial_lang_mask;
static unsigned int initial_lang_mask;
 
 
/* Initialize global options-related settings at start-up.  */
/* Initialize global options-related settings at start-up.  */
 
 
void
void
init_options_once (void)
init_options_once (void)
{
{
  /* Perform language-specific options initialization.  */
  /* Perform language-specific options initialization.  */
  initial_lang_mask = lang_hooks.option_lang_mask ();
  initial_lang_mask = lang_hooks.option_lang_mask ();
 
 
  lang_hooks.initialize_diagnostics (global_dc);
  lang_hooks.initialize_diagnostics (global_dc);
}
}
 
 
/* Decode command-line options to an array, like
/* Decode command-line options to an array, like
   decode_cmdline_options_to_array and with the same arguments but
   decode_cmdline_options_to_array and with the same arguments but
   using the default lang_mask.  */
   using the default lang_mask.  */
 
 
void
void
decode_cmdline_options_to_array_default_mask (unsigned int argc,
decode_cmdline_options_to_array_default_mask (unsigned int argc,
                                              const char **argv,
                                              const char **argv,
                                              struct cl_decoded_option **decoded_options,
                                              struct cl_decoded_option **decoded_options,
                                              unsigned int *decoded_options_count)
                                              unsigned int *decoded_options_count)
{
{
  decode_cmdline_options_to_array (argc, argv,
  decode_cmdline_options_to_array (argc, argv,
                                   initial_lang_mask | CL_COMMON | CL_TARGET,
                                   initial_lang_mask | CL_COMMON | CL_TARGET,
                                   decoded_options, decoded_options_count);
                                   decoded_options, decoded_options_count);
}
}
 
 
/* Set *HANDLERS to the default set of option handlers for use in the
/* Set *HANDLERS to the default set of option handlers for use in the
   compilers proper (not the driver).  */
   compilers proper (not the driver).  */
void
void
set_default_handlers (struct cl_option_handlers *handlers)
set_default_handlers (struct cl_option_handlers *handlers)
{
{
  handlers->unknown_option_callback = unknown_option_callback;
  handlers->unknown_option_callback = unknown_option_callback;
  handlers->wrong_lang_callback = complain_wrong_lang;
  handlers->wrong_lang_callback = complain_wrong_lang;
  handlers->num_handlers = 3;
  handlers->num_handlers = 3;
  handlers->handlers[0].handler = lang_handle_option;
  handlers->handlers[0].handler = lang_handle_option;
  handlers->handlers[0].mask = initial_lang_mask;
  handlers->handlers[0].mask = initial_lang_mask;
  handlers->handlers[1].handler = common_handle_option;
  handlers->handlers[1].handler = common_handle_option;
  handlers->handlers[1].mask = CL_COMMON;
  handlers->handlers[1].mask = CL_COMMON;
  handlers->handlers[2].handler = target_handle_option;
  handlers->handlers[2].handler = target_handle_option;
  handlers->handlers[2].mask = CL_TARGET;
  handlers->handlers[2].mask = CL_TARGET;
}
}
 
 
/* Parse command line options and set default flag values.  Do minimal
/* Parse command line options and set default flag values.  Do minimal
   options processing.  The decoded options are in *DECODED_OPTIONS
   options processing.  The decoded options are in *DECODED_OPTIONS
   and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
   and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
   the options are located at LOC.  */
   the options are located at LOC.  */
void
void
decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
                struct cl_decoded_option *decoded_options,
                struct cl_decoded_option *decoded_options,
                unsigned int decoded_options_count,
                unsigned int decoded_options_count,
                location_t loc, diagnostic_context *dc)
                location_t loc, diagnostic_context *dc)
{
{
  struct cl_option_handlers handlers;
  struct cl_option_handlers handlers;
 
 
  unsigned int lang_mask;
  unsigned int lang_mask;
 
 
  lang_mask = initial_lang_mask;
  lang_mask = initial_lang_mask;
 
 
  set_default_handlers (&handlers);
  set_default_handlers (&handlers);
 
 
  default_options_optimization (opts, opts_set,
  default_options_optimization (opts, opts_set,
                                decoded_options, decoded_options_count,
                                decoded_options, decoded_options_count,
                                loc, lang_mask, &handlers, dc);
                                loc, lang_mask, &handlers, dc);
 
 
  read_cmdline_options (opts, opts_set,
  read_cmdline_options (opts, opts_set,
                        decoded_options, decoded_options_count,
                        decoded_options, decoded_options_count,
                        loc, lang_mask,
                        loc, lang_mask,
                        &handlers, dc);
                        &handlers, dc);
 
 
  finish_options (opts, opts_set, loc);
  finish_options (opts, opts_set, loc);
}
}
 
 
/* Process common options that have been deferred until after the
/* Process common options that have been deferred until after the
   handlers have been called for all options.  */
   handlers have been called for all options.  */
 
 
void
void
handle_common_deferred_options (void)
handle_common_deferred_options (void)
{
{
  unsigned int i;
  unsigned int i;
  cl_deferred_option *opt;
  cl_deferred_option *opt;
  VEC(cl_deferred_option,heap) *vec
  VEC(cl_deferred_option,heap) *vec
    = (VEC(cl_deferred_option,heap) *) common_deferred_options;
    = (VEC(cl_deferred_option,heap) *) common_deferred_options;
 
 
  if (flag_dump_all_passed)
  if (flag_dump_all_passed)
    enable_rtl_dump_file ();
    enable_rtl_dump_file ();
 
 
  FOR_EACH_VEC_ELT (cl_deferred_option, vec, i, opt)
  FOR_EACH_VEC_ELT (cl_deferred_option, vec, i, opt)
    {
    {
      switch (opt->opt_index)
      switch (opt->opt_index)
        {
        {
        case OPT_fcall_used_:
        case OPT_fcall_used_:
          fix_register (opt->arg, 0, 1);
          fix_register (opt->arg, 0, 1);
          break;
          break;
 
 
        case OPT_fcall_saved_:
        case OPT_fcall_saved_:
          fix_register (opt->arg, 0, 0);
          fix_register (opt->arg, 0, 0);
          break;
          break;
 
 
        case OPT_fdbg_cnt_:
        case OPT_fdbg_cnt_:
          dbg_cnt_process_opt (opt->arg);
          dbg_cnt_process_opt (opt->arg);
          break;
          break;
 
 
        case OPT_fdbg_cnt_list:
        case OPT_fdbg_cnt_list:
          dbg_cnt_list_all_counters ();
          dbg_cnt_list_all_counters ();
          break;
          break;
 
 
        case OPT_fdebug_prefix_map_:
        case OPT_fdebug_prefix_map_:
          add_debug_prefix_map (opt->arg);
          add_debug_prefix_map (opt->arg);
          break;
          break;
 
 
        case OPT_fdump_:
        case OPT_fdump_:
          if (!dump_switch_p (opt->arg))
          if (!dump_switch_p (opt->arg))
            error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
            error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
          break;
          break;
 
 
        case OPT_fenable_:
        case OPT_fenable_:
        case OPT_fdisable_:
        case OPT_fdisable_:
          if (opt->opt_index == OPT_fenable_)
          if (opt->opt_index == OPT_fenable_)
            enable_pass (opt->arg);
            enable_pass (opt->arg);
          else
          else
            disable_pass (opt->arg);
            disable_pass (opt->arg);
          break;
          break;
 
 
        case OPT_ffixed_:
        case OPT_ffixed_:
          /* Deferred.  */
          /* Deferred.  */
          fix_register (opt->arg, 1, 1);
          fix_register (opt->arg, 1, 1);
          break;
          break;
 
 
        case OPT_fplugin_:
        case OPT_fplugin_:
#ifdef ENABLE_PLUGIN
#ifdef ENABLE_PLUGIN
          add_new_plugin (opt->arg);
          add_new_plugin (opt->arg);
#else
#else
          error ("plugin support is disabled; configure with --enable-plugin");
          error ("plugin support is disabled; configure with --enable-plugin");
#endif
#endif
          break;
          break;
 
 
        case OPT_fplugin_arg_:
        case OPT_fplugin_arg_:
#ifdef ENABLE_PLUGIN
#ifdef ENABLE_PLUGIN
          parse_plugin_arg_opt (opt->arg);
          parse_plugin_arg_opt (opt->arg);
#else
#else
          error ("plugin support is disabled; configure with --enable-plugin");
          error ("plugin support is disabled; configure with --enable-plugin");
#endif
#endif
          break;
          break;
 
 
        case OPT_frandom_seed:
        case OPT_frandom_seed:
          /* The real switch is -fno-random-seed.  */
          /* The real switch is -fno-random-seed.  */
          if (!opt->value)
          if (!opt->value)
            set_random_seed (NULL);
            set_random_seed (NULL);
          break;
          break;
 
 
        case OPT_frandom_seed_:
        case OPT_frandom_seed_:
          set_random_seed (opt->arg);
          set_random_seed (opt->arg);
          break;
          break;
 
 
        case OPT_fstack_limit:
        case OPT_fstack_limit:
          /* The real switch is -fno-stack-limit.  */
          /* The real switch is -fno-stack-limit.  */
          if (!opt->value)
          if (!opt->value)
            stack_limit_rtx = NULL_RTX;
            stack_limit_rtx = NULL_RTX;
          break;
          break;
 
 
        case OPT_fstack_limit_register_:
        case OPT_fstack_limit_register_:
          {
          {
            int reg = decode_reg_name (opt->arg);
            int reg = decode_reg_name (opt->arg);
            if (reg < 0)
            if (reg < 0)
              error ("unrecognized register name %qs", opt->arg);
              error ("unrecognized register name %qs", opt->arg);
            else
            else
              stack_limit_rtx = gen_rtx_REG (Pmode, reg);
              stack_limit_rtx = gen_rtx_REG (Pmode, reg);
          }
          }
          break;
          break;
 
 
        case OPT_fstack_limit_symbol_:
        case OPT_fstack_limit_symbol_:
          stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg));
          stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg));
          break;
          break;
 
 
        default:
        default:
          gcc_unreachable ();
          gcc_unreachable ();
        }
        }
    }
    }
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.