Subversion Repositories openrisc

/* LTO IL options.

   Copyright 2009, 2010, 2011, 2012 Free Software Foundation, Inc.

   Contributed by Simon Baldwin <simonb@google.com>

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

#include "ggc.h"

#include "vec.h"

#include "bitmap.h"

#include "flags.h"

#include "opts.h"

#include "options.h"

#include "common/common-target.h"

#include "diagnostic.h"

#include "lto-streamer.h"

#include "toplev.h"

/* Append the option piece OPT to the COLLECT_GCC_OPTIONS string

   set up by OB, appropriately quoted and separated by spaces

   (if !*FIRST_P).  */

static void

append_to_collect_gcc_options (struct obstack *ob,

                               bool *first_p, const char *opt)

{

  const char *p, *q = opt;

  if (!first_p)

    obstack_grow (ob, " ", 1);

  obstack_grow (ob, "'", 1);

  while ((p = strchr (q, '\'')))

    {

      obstack_grow (ob, q, p - q);

      obstack_grow (ob, "'\\''", 4);

      q = ++p;

    }

  obstack_grow (ob, q, strlen (q));

  obstack_grow (ob, "'", 1);

  *first_p = false;

}

/* Write currently held options to an LTO IL section.  */

void

lto_write_options (void)

{

  struct lto_output_stream stream;

  char *section_name;

  struct obstack temporary_obstack;

  unsigned int i, j;

  char *args;

  bool first_p = true;

  section_name = lto_get_section_name (LTO_section_opts, NULL, NULL);

  lto_begin_section (section_name, false);

  memset (&stream, 0, sizeof (stream));

  obstack_init (&temporary_obstack);

  /* Output options that affect GIMPLE IL semantics and are implicitely

     enabled by the frontend.

     This for now includes an explicit set of options that we also handle

     explicitly in lto-wrapper.c.  In the end the effects on GIMPLE IL

     semantics should be explicitely encoded in the IL or saved per

     function rather than per compilation unit.  */

  /* -fexceptions causes the EH machinery to be initialized, enabling

     generation of unwind data so that explicit throw() calls work.  */

  if (global_options.x_flag_exceptions)

    append_to_collect_gcc_options (&temporary_obstack, &first_p,

                                   "-fexceptions");

  /* Output explicitely passed options.  */

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

    {

      struct cl_decoded_option *option = &save_decoded_options[i];

      /* Skip frontend and driver specific options here.  */

      if (!(cl_options[option->opt_index].flags & (CL_COMMON|CL_TARGET|CL_LTO)))

        continue;

      /* Drop options created from the gcc driver that will be rejected

         when passed on to the driver again.  */

      if (cl_options[option->opt_index].cl_reject_driver)

        continue;

      /* Also drop all options that are handled by the driver as well,

         which includes things like -o and -v or -fhelp for example.

         We do not need those.  Also drop all diagnostic options.  */

      if (cl_options[option->opt_index].flags & (CL_DRIVER|CL_WARNING))

        continue;

      /* Skip explicitly some common options that we do not need.  */

      switch (option->opt_index)

        {

        case OPT_dumpbase:

        case OPT_SPECIAL_input_file:

          continue;

        default:

          break;

        }

      for (j = 0; j < option->canonical_option_num_elements; ++j)

        append_to_collect_gcc_options (&temporary_obstack, &first_p,

                                       option->canonical_option[j]);

    }

  obstack_grow (&temporary_obstack, "\0", 1);

  args = XOBFINISH (&temporary_obstack, char *);

  lto_output_data_stream (&stream, args, strlen (args) + 1);

  lto_write_stream (&stream);

  lto_end_section ();

  obstack_free (&temporary_obstack, NULL);

  free (section_name);

}