Subversion Repositories openrisc

/* Write and read any fix-up information generated by the WPA mode.

   Copyright 2009 Free Software Foundation, Inc.

   Contributed by Doug Kwan <dougkwan@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 "tm.h"

#include "toplev.h"

#include "tree.h"

#include "expr.h"

#include "flags.h"

#include "cgraph.h"

#include "function.h"

#include "diagnostic.h"

#include "vec.h"

#include "bitmap.h"

#include "timevar.h"

#include "tree-flow.h"

#include "tree-pass.h"

#include "lto-streamer.h"

/* LTO fix-up.

   In WPA mode, LTO cannot access function bodies.  Some modifications in

   IR require additional updates in function bodies,  which are not possible

   in WPA mode.  So we write out information about these modifications for

   LTRANS to fix up the function bodies accordingly.  */

/* The vectors records function DECLs having multiple copies with different

   exception throwing attributes.  We do not mark a DECL if all copies of it

   have the same exception throwing attribute. */

static bitmap lto_nothrow_fndecls;

/* We need to fix up GIMPLE bodies due to changes in exception setting.

   Consider this example:

   a.h:

   class a {

   public:

     a();

     ~a();

   };

   main.cc:

   #include "a.h"

   int

   main (int argc, char **argv)

   {

     a x;

     return 0;

   }

   a.cc:

   #include "a.h"

   a::a() {}

   a::~a() {}

   When main.cc is compiled, gcc only sees the constructor declaration, so

   the constructor and hence the call to it are marked as exception throwing.

   When a.cc is compiled, the body of the constructor is available and is

   obviously not exception throwing. Thus DECL of a::a in a.o has the NOTHROW

   attribute.  When LTO runs, two DECLs of a::a with different exception

   attributes are merged.  We want the merged DECL to be not exception

   throwing for better generated code.  To do that, we need to fix up any

   function calls that have been marked as exception throwing.  */

/* Fix up all the call statements whose target fndecls might have changed

   to NOTHROW.   Note that this problem is not WPA specific.  We can also

   run into this problem in normal LTO with multiple input files.  */

void

lto_fixup_nothrow_decls (void)

{

  struct cgraph_node *node;

  struct cgraph_edge *edge;

  struct function *caller_function;

  gimple call_stmt;

  /* Quit if we are in WPA mode or have not marked any DECLs.  */

  if (flag_wpa || !lto_nothrow_fndecls)

    return;

  /* For each node that has been marked, go over all call edges to it.  */

  for (node = cgraph_nodes; node; node = node->next)

    if (bitmap_bit_p (lto_nothrow_fndecls, DECL_UID (node->decl)))

      {

        gcc_assert (TREE_NOTHROW (node->decl));

        for (edge = node->callers; edge; edge = edge->next_caller)

          {

            caller_function = DECL_STRUCT_FUNCTION (edge->caller->decl);

            call_stmt = edge->call_stmt;

            gcc_assert (call_stmt);

            if (lookup_stmt_eh_lp_fn (caller_function, call_stmt) != 0)

              remove_stmt_from_eh_lp_fn (caller_function, call_stmt);

          }

      }

}

/* Mark FNDECL as becoming not exception throwing.  */

void

lto_mark_nothrow_fndecl (tree fndecl)

{

  gcc_assert (TREE_CODE (fndecl) == FUNCTION_DECL);

  if (!lto_nothrow_fndecls)

    lto_nothrow_fndecls = lto_bitmap_alloc ();

  bitmap_set_bit (lto_nothrow_fndecls, DECL_UID (fndecl));

}

/* Write out fix-up information.  Currently the only WPA fix-up

   information is the list of DECLs marked as not exception throwing. SET

   is a cgraph node set whose fix-up information is to be written.  */

static void

lto_output_wpa_fixup (cgraph_node_set set)

{

  struct lto_simple_output_block *ob;

  cgraph_node_set_iterator csi;

  tree fndecl;

  bitmap seen_decls;

  VEC(tree, heap) *decls = NULL;

  unsigned HOST_WIDE_INT i, count;

  ob = lto_create_simple_output_block (LTO_section_wpa_fixup);

  /* Accumulate the DECLs to be written out.  Since we do not want

     duplicates, we need to use a bitmap and a vector to save the

     DECLs we want.  Note that we need to check if lto_nothrow_fndecls

     is NULL.  This happens when no DECL has been marked.  */

  seen_decls = lto_bitmap_alloc ();

  if (lto_nothrow_fndecls)

    for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))

      {

        struct cgraph_edge *e;

        struct cgraph_node *n;

        n = csi_node (csi);

        fndecl = n->decl;

        /* Check if the N's function is in the set of nothrow functions.  */

        if (!bitmap_bit_p (seen_decls, DECL_UID (fndecl)))

          {

            bitmap_set_bit (seen_decls, (DECL_UID (fndecl)));

            if (bitmap_bit_p (lto_nothrow_fndecls, DECL_UID (fndecl)))

              VEC_safe_push (tree, heap, decls, fndecl);

          }

        /* Now check the callees and also add them if they are nothrow.  This

           is needed because node N may end up in a different partition than

           its callees.  In which case, when the file holding N is compiled,

           the calls it makes to nothrow functions will not be fixed up,

           causing verification issues.  */

        for (e = n->callees; e; e = e->next_callee)

          {

            fndecl = e->callee->decl;

            if (!bitmap_bit_p (seen_decls, DECL_UID (fndecl)))

              {

                bitmap_set_bit (seen_decls, (DECL_UID (fndecl)));

                if (bitmap_bit_p (lto_nothrow_fndecls, DECL_UID (fndecl)))

                  VEC_safe_push (tree, heap, decls, fndecl);

              }

          }

      }

  /* Write out number of DECLs, followed by the DECLs.  */

  count = VEC_length (tree, decls);

  lto_output_uleb128_stream (ob->main_stream, count);

  for (i = 0; i < count; i++)

    {

      fndecl = VEC_index (tree, decls, i);

      lto_output_fn_decl_index (ob->decl_state, ob->main_stream, fndecl);

    }

  /* Release resources.  */

  lto_destroy_simple_output_block (ob);

  VEC_free(tree, heap, decls);

  lto_bitmap_free (seen_decls);

}

/* Read in WPA fix-up information from one file. FILE_DATA points to

   DECL information of the file where as IB is the input block for the

   WPA fix-up section.  */

static void

lto_input_wpa_fixup_1 (struct lto_file_decl_data *file_data,

                   struct lto_input_block *ib)

{

  unsigned HOST_WIDE_INT i, count, decl_index;

  tree fndecl;

  count = lto_input_uleb128 (ib);

  for (i = 0; i < count; i++)

    {

      decl_index = lto_input_uleb128 (ib);

      fndecl = lto_file_decl_data_get_fn_decl (file_data, decl_index);

      lto_mark_nothrow_fndecl (fndecl);

    }

}

/* Read in WPA fix-up information. */

static void

lto_input_wpa_fixup (void)

{

  struct lto_file_decl_data ** file_data_vec

    = lto_get_file_decl_data ();

  struct lto_file_decl_data * file_data;

  int i = 0;

  /* Fix up information is only used in LTRANS mode.  */

  if (!flag_ltrans)

    return;

  while ((file_data = file_data_vec[i++]))

    {

      const char *data;

      size_t len;

      struct lto_input_block *ib

        = lto_create_simple_input_block (file_data, LTO_section_wpa_fixup,

                                         &data, &len);

      lto_input_wpa_fixup_1 (file_data, ib);

      lto_destroy_simple_input_block (file_data, LTO_section_wpa_fixup, ib,

                                      data, len);

    }

}

/* Gate function for all lto streaming passes.  */

static bool

gate_wpa_fixup (void)

{

  return (flag_wpa || flag_ltrans) && gate_lto_out ();

}

struct ipa_opt_pass_d pass_ipa_lto_wpa_fixup =

{

 {

  IPA_PASS,

  "lto_wpa_fixup",                      /* name */

  gate_wpa_fixup,                       /* gate */

  NULL,                                 /* execute */

  NULL,                                 /* sub */

  NULL,                                 /* next */

  0,                                     /* static_pass_number */

  TV_WHOPR_WPA_FIXUP,                   /* tv_id */

  0,                                     /* properties_required */

  0,                                     /* properties_provided */

  0,                                     /* properties_destroyed */

  0,                             /* todo_flags_start */

  TODO_dump_func                        /* todo_flags_finish */

 },

 NULL,                                  /* generate_summary */

 lto_output_wpa_fixup,                  /* write_summary */

 lto_input_wpa_fixup,                   /* read_summary */

 NULL,                                  /* function_read_summary */

 NULL,                                  /* stmt_fixup */

 0,                                      /* TODOs */

 NULL,                                  /* function_transform */

 NULL                                   /* variable_transform */

};