Subversion Repositories openrisc

/* Basic IPA optimizations and utilities.

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

   Free Software Foundation, Inc.

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

#include "tree-pass.h"

#include "timevar.h"

#include "gimple.h"

#include "ggc.h"

#include "flags.h"

#include "pointer-set.h"

#include "target.h"

#include "tree-iterator.h"

#include "ipa-utils.h"

/* Look for all functions inlined to NODE and update their inlined_to pointers

   to INLINED_TO.  */

static void

update_inlined_to_pointer (struct cgraph_node *node, struct cgraph_node *inlined_to)

{

  struct cgraph_edge *e;

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

    if (e->callee->global.inlined_to)

      {

        e->callee->global.inlined_to = inlined_to;

        update_inlined_to_pointer (e->callee, inlined_to);

      }

}

/* Add cgraph NODE to queue starting at FIRST.

   The queue is linked via AUX pointers and terminated by pointer to 1.

   We enqueue nodes at two occasions: when we find them reachable or when we find

   their bodies needed for further clonning.  In the second case we mark them

   by pointer to 2 after processing so they are re-queue when they become

   reachable.  */

static void

enqueue_cgraph_node (struct cgraph_node *node, struct cgraph_node **first)

{

  /* Node is still in queue; do nothing.  */

  if (node->aux && node->aux != (void *) 2)

    return;

  /* Node was already processed as unreachable, re-enqueue

     only if it became reachable now.  */

  if (node->aux == (void *)2 && !node->reachable)

    return;

  node->aux = *first;

  *first = node;

}

/* Add varpool NODE to queue starting at FIRST.  */

static void

enqueue_varpool_node (struct varpool_node *node, struct varpool_node **first)

{

  node->aux = *first;

  *first = node;

}

/* Process references.  */

static void

process_references (struct ipa_ref_list *list,

                    struct cgraph_node **first,

                    struct varpool_node **first_varpool,

                    bool before_inlining_p)

{

  int i;

  struct ipa_ref *ref;

  for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)

    {

      if (ref->refered_type == IPA_REF_CGRAPH)

        {

          struct cgraph_node *node = ipa_ref_node (ref);

          if (!node->reachable

              && node->analyzed

              && (!DECL_EXTERNAL (node->decl)

                  || before_inlining_p))

            node->reachable = true;

          enqueue_cgraph_node (node, first);

        }

      else

        {

          struct varpool_node *node = ipa_ref_varpool_node (ref);

          if (!node->needed)

            {

              varpool_mark_needed_node (node);

              enqueue_varpool_node (node, first_varpool);

            }

        }

    }

}

/* Return true when NODE can not be local. Worker for cgraph_local_node_p.  */

static bool

cgraph_non_local_node_p_1 (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)

{

   /* FIXME: Aliases can be local, but i386 gets thunks wrong then.  */

   return !(cgraph_only_called_directly_or_aliased_p (node)

            && !ipa_ref_has_aliases_p (&node->ref_list)

            && node->analyzed

            && !DECL_EXTERNAL (node->decl)

            && !node->local.externally_visible

            && !node->reachable_from_other_partition

            && !node->in_other_partition);

}

/* Return true when function can be marked local.  */

static bool

cgraph_local_node_p (struct cgraph_node *node)

{

   struct cgraph_node *n = cgraph_function_or_thunk_node (node, NULL);

   /* FIXME: thunks can be considered local, but we need prevent i386

      from attempting to change calling convention of them.  */

   if (n->thunk.thunk_p)

     return false;

   return !cgraph_for_node_and_aliases (n,

                                        cgraph_non_local_node_p_1, NULL, true);

}

/* Return true when NODE has ADDR reference.  */

static bool

has_addr_references_p (struct cgraph_node *node,

                       void *data ATTRIBUTE_UNUSED)

{

  int i;

  struct ipa_ref *ref;

  for (i = 0; ipa_ref_list_refering_iterate (&node->ref_list, i, ref); i++)

    if (ref->use == IPA_REF_ADDR)

      return true;

  return false;

}

/* Perform reachability analysis and reclaim all unreachable nodes.

   If BEFORE_INLINING_P is true this function is called before inlining

   decisions has been made.  If BEFORE_INLINING_P is false this function also

   removes unneeded bodies of extern inline functions.  */

bool

cgraph_remove_unreachable_nodes (bool before_inlining_p, FILE *file)

{

  struct cgraph_node *first = (struct cgraph_node *) (void *) 1;

  struct varpool_node *first_varpool = (struct varpool_node *) (void *) 1;

  struct cgraph_node *node, *next;

  struct varpool_node *vnode, *vnext;

  bool changed = false;

#ifdef ENABLE_CHECKING

  verify_cgraph ();

#endif

  if (file)

    fprintf (file, "\nReclaiming functions:");

#ifdef ENABLE_CHECKING

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

    gcc_assert (!node->aux);

  for (vnode = varpool_nodes; vnode; vnode = vnode->next)

    gcc_assert (!vnode->aux);

#endif

  varpool_reset_queue ();

  /* Mark functions whose bodies are obviously needed.

     This is mostly when they can be referenced externally.  Inline clones

     are special since their declarations are shared with master clone and thus

     cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them.  */

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

    if (node->analyzed && !node->global.inlined_to

        && (!cgraph_can_remove_if_no_direct_calls_and_refs_p (node)

            /* Keep around virtual functions for possible devirtualization.  */

            || (before_inlining_p

                && DECL_VIRTUAL_P (node->decl)

                && (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl)))))

      {

        gcc_assert (!node->global.inlined_to);

        enqueue_cgraph_node (node, &first);

        node->reachable = true;

      }

    else

      {

        gcc_assert (!node->aux);

        node->reachable = false;

      }

  /* Mark variables that are obviously needed.  */

  for (vnode = varpool_nodes; vnode; vnode = vnode->next)

    {

      vnode->next_needed = NULL;

      vnode->prev_needed = NULL;

      if ((vnode->analyzed || vnode->force_output)

          && !varpool_can_remove_if_no_refs (vnode))

        {

          vnode->needed = false;

          varpool_mark_needed_node (vnode);

          enqueue_varpool_node (vnode, &first_varpool);

        }

      else

        vnode->needed = false;

    }

  /* Perform reachability analysis.  As a special case do not consider

     extern inline functions not inlined as live because we won't output

     them at all.

     We maintain two worklist, one for cgraph nodes other for varpools and

     are finished once both are empty.  */

  while (first != (struct cgraph_node *) (void *) 1

         || first_varpool != (struct varpool_node *) (void *) 1)

    {

      if (first != (struct cgraph_node *) (void *) 1)

        {

          struct cgraph_edge *e;

          node = first;

          first = (struct cgraph_node *) first->aux;

          if (!node->reachable)

            node->aux = (void *)2;

          /* If we found this node reachable, first mark on the callees

             reachable too, unless they are direct calls to extern inline functions

             we decided to not inline.  */

          if (node->reachable)

            {

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

                {

                  if (!e->callee->reachable

                      && node->analyzed

                      && (!e->inline_failed

                          || !DECL_EXTERNAL (e->callee->decl)

                          || before_inlining_p))

                    e->callee->reachable = true;

                  enqueue_cgraph_node (e->callee, &first);

                }

              process_references (&node->ref_list, &first, &first_varpool, before_inlining_p);

            }

          /* If any function in a comdat group is reachable, force

             all other functions in the same comdat group to be

             also reachable.  */

          if (node->same_comdat_group

              && node->reachable

              && !node->global.inlined_to)

            {

              for (next = node->same_comdat_group;

                   next != node;

                   next = next->same_comdat_group)

                if (!next->reachable)

                  {

                    next->reachable = true;

                    enqueue_cgraph_node (next, &first);

                  }

            }

          /* We can freely remove inline clones even if they are cloned, however if

             function is clone of real clone, we must keep it around in order to

             make materialize_clones produce function body with the changes

             applied.  */

          while (node->clone_of && !node->clone_of->aux

                 && !gimple_has_body_p (node->decl))

            {

              bool noninline = node->clone_of->decl != node->decl;

              node = node->clone_of;

              if (noninline && !node->reachable && !node->aux)

                {

                  enqueue_cgraph_node (node, &first);

                  break;

                }

            }

        }

      if (first_varpool != (struct varpool_node *) (void *) 1)

        {

          vnode = first_varpool;

          first_varpool = (struct varpool_node *)first_varpool->aux;

          vnode->aux = NULL;

          process_references (&vnode->ref_list, &first, &first_varpool, before_inlining_p);

          /* If any function in a comdat group is reachable, force

             all other functions in the same comdat group to be

             also reachable.  */

          if (vnode->same_comdat_group)

            {

              struct varpool_node *next;

              for (next = vnode->same_comdat_group;

                   next != vnode;

                   next = next->same_comdat_group)

                if (!next->needed)

                  {

                    varpool_mark_needed_node (next);

                    enqueue_varpool_node (next, &first_varpool);

                  }

            }

        }

    }

  /* Remove unreachable nodes.

     Completely unreachable functions can be fully removed from the callgraph.

     Extern inline functions that we decided to not inline need to become unanalyzed nodes of

     callgraph (so we still have edges to them).  We remove function body then.

     Also we need to care functions that are unreachable but we need to keep them around

     for later clonning.  In this case we also turn them to unanalyzed nodes, but

     keep the body around.  */

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

    {

      next = node->next;

      if (node->aux && !node->reachable)

        {

          cgraph_node_remove_callees (node);

          ipa_remove_all_references (&node->ref_list);

          node->analyzed = false;

        }

      if (!node->aux)

        {

          struct cgraph_edge *e;

          bool found = false;

          int i;

          struct ipa_ref *ref;

          node->global.inlined_to = NULL;

          if (file)

            fprintf (file, " %s", cgraph_node_name (node));

          /* See if there is reachable caller.  */

          for (e = node->callers; e && !found; e = e->next_caller)

            if (e->caller->reachable)

              found = true;

          for (i = 0; (ipa_ref_list_refering_iterate (&node->ref_list, i, ref)

                       && !found); i++)

            if (ref->refering_type == IPA_REF_CGRAPH

                && ipa_ref_refering_node (ref)->reachable)

              found = true;

            else if (ref->refering_type == IPA_REF_VARPOOL

                     && ipa_ref_refering_varpool_node (ref)->needed)

              found = true;

          /* If so, we need to keep node in the callgraph.  */

          if (found)

            {

              if (node->analyzed)

                {

                  struct cgraph_node *clone;

                  /* If there are still clones, we must keep body around.

                     Otherwise we can just remove the body but keep the clone.  */

                  for (clone = node->clones; clone;

                       clone = clone->next_sibling_clone)

                    if (clone->aux)

                      break;

                  if (!clone)

                    {

                      cgraph_release_function_body (node);

                      if (node->prev_sibling_clone)

                        node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;

                      else if (node->clone_of)

                        node->clone_of->clones = node->next_sibling_clone;

                      if (node->next_sibling_clone)

                        node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;

                      if (node->clone_of)

                        node->former_clone_of = node->clone_of->decl;

                      node->clone_of = NULL;

                      node->next_sibling_clone = NULL;

                      node->prev_sibling_clone = NULL;

                    }

                  else

                    gcc_assert (!clone->in_other_partition);

                  node->analyzed = false;

                  changed = true;

                  cgraph_node_remove_callees (node);

                  ipa_remove_all_references (&node->ref_list);

                }

            }

          else

            {

              cgraph_remove_node (node);

              changed = true;

            }

        }

    }

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

    {

      /* Inline clones might be kept around so their materializing allows further

         cloning.  If the function the clone is inlined into is removed, we need

         to turn it into normal cone.  */

      if (node->global.inlined_to

          && !node->callers)

        {

          gcc_assert (node->clones);

          node->global.inlined_to = NULL;

          update_inlined_to_pointer (node, node);

        }

      node->aux = NULL;

    }

  if (file)

    fprintf (file, "\n");

  /* We must release unused extern inlines or sanity checking will fail.  Rest of transformations

     are undesirable at -O0 since we do not want to remove anything.  */

  if (!optimize)

    return changed;

  if (file)

    fprintf (file, "Reclaiming variables:");

  for (vnode = varpool_nodes; vnode; vnode = vnext)

    {

      vnext = vnode->next;

      if (!vnode->needed)

        {

          if (file)

            fprintf (file, " %s", varpool_node_name (vnode));

          varpool_remove_node (vnode);

          changed = true;

        }

    }

  /* Now update address_taken flags and try to promote functions to be local.  */

  if (file)

    fprintf (file, "\nClearing address taken flags:");

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

    if (node->address_taken

        && !node->reachable_from_other_partition)

      {

        if (!cgraph_for_node_and_aliases (node, has_addr_references_p, NULL, true))

          {

            if (file)

              fprintf (file, " %s", cgraph_node_name (node));

            node->address_taken = false;

            changed = true;

            if (cgraph_local_node_p (node))

              {

                node->local.local = true;

                if (file)

                  fprintf (file, " (local)");

              }

          }

      }

  if (file)

    fprintf (file, "\n");

#ifdef ENABLE_CHECKING

  verify_cgraph ();

#endif

  /* Reclaim alias pairs for functions that have disappeared from the

     call graph.  */

  remove_unreachable_alias_pairs ();

  return changed;

}

/* Discover variables that have no longer address taken or that are read only

   and update their flags.

   FIXME: This can not be done in between gimplify and omp_expand since

   readonly flag plays role on what is shared and what is not.  Currently we do

   this transformation as part of whole program visibility and re-do at

   ipa-reference pass (to take into account clonning), but it would

   make sense to do it before early optimizations.  */

void

ipa_discover_readonly_nonaddressable_vars (void)

{

  struct varpool_node *vnode;

  if (dump_file)

    fprintf (dump_file, "Clearing variable flags:");

  for (vnode = varpool_nodes; vnode; vnode = vnode->next)

    if (vnode->finalized && varpool_all_refs_explicit_p (vnode)

        && (TREE_ADDRESSABLE (vnode->decl) || !TREE_READONLY (vnode->decl)))

      {

        bool written = false;

        bool address_taken = false;

        int i;

        struct ipa_ref *ref;

        for (i = 0; ipa_ref_list_refering_iterate (&vnode->ref_list, i, ref)

                    && (!written || !address_taken); i++)

          switch (ref->use)

            {

            case IPA_REF_ADDR:

              address_taken = true;

              break;

            case IPA_REF_LOAD:

              break;

            case IPA_REF_STORE:

              written = true;

              break;

            }

        if (TREE_ADDRESSABLE (vnode->decl) && !address_taken)

          {

            if (dump_file)

              fprintf (dump_file, " %s (addressable)", varpool_node_name (vnode));

            TREE_ADDRESSABLE (vnode->decl) = 0;

          }

        if (!TREE_READONLY (vnode->decl) && !address_taken && !written

            /* Making variable in explicit section readonly can cause section

               type conflict.

               See e.g. gcc.c-torture/compile/pr23237.c */

            && DECL_SECTION_NAME (vnode->decl) == NULL)

          {

            if (dump_file)

              fprintf (dump_file, " %s (read-only)", varpool_node_name (vnode));

            TREE_READONLY (vnode->decl) = 1;

          }

      }

  if (dump_file)

    fprintf (dump_file, "\n");

}

/* Return true when there is a reference to node and it is not vtable.  */

static bool

cgraph_address_taken_from_non_vtable_p (struct cgraph_node *node)

{

  int i;

  struct ipa_ref *ref;

  for (i = 0; ipa_ref_list_refering_iterate (&node->ref_list, i, ref); i++)

    if (ref->use == IPA_REF_ADDR)

      {

        struct varpool_node *node;

        if (ref->refering_type == IPA_REF_CGRAPH)

          return true;

        node = ipa_ref_refering_varpool_node (ref);

        if (!DECL_VIRTUAL_P (node->decl))

          return true;

      }

  return false;

}

/* COMDAT functions must be shared only if they have address taken,

   otherwise we can produce our own private implementation with

   -fwhole-program.

   Return true when turning COMDAT functoin static can not lead to wrong

   code when the resulting object links with a library defining same COMDAT.

   Virtual functions do have their addresses taken from the vtables,

   but in C++ there is no way to compare their addresses for equality.  */

bool

cgraph_comdat_can_be_unshared_p (struct cgraph_node *node)

{

  if ((cgraph_address_taken_from_non_vtable_p (node)

       && !DECL_VIRTUAL_P (node->decl))

      || !node->analyzed)

    return false;

  if (node->same_comdat_group)

    {

      struct cgraph_node *next;

      /* If more than one function is in the same COMDAT group, it must

         be shared even if just one function in the comdat group has

         address taken.  */

      for (next = node->same_comdat_group;

           next != node; next = next->same_comdat_group)

        if (cgraph_address_taken_from_non_vtable_p (next)

            && !DECL_VIRTUAL_P (next->decl))

          return false;

    }

  return true;

}

/* Return true when function NODE should be considered externally visible.  */

static bool

cgraph_externally_visible_p (struct cgraph_node *node,

                             bool whole_program, bool aliased)

{

  if (!node->local.finalized)

    return false;

  if (!DECL_COMDAT (node->decl)

      && (!TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl)))

    return false;

  /* Do not even try to be smart about aliased nodes.  Until we properly

     represent everything by same body alias, these are just evil.  */

  if (aliased)

    return true;

  /* Do not try to localize built-in functions yet.  One of problems is that we

     end up mangling their asm for WHOPR that makes it impossible to call them

     using the implicit built-in declarations anymore.  Similarly this enables

     us to remove them as unreachable before actual calls may appear during

     expansion or folding.  */

  if (DECL_BUILT_IN (node->decl))

    return true;

  /* If linker counts on us, we must preserve the function.  */

  if (cgraph_used_from_object_file_p (node))

    return true;

  if (DECL_PRESERVE_P (node->decl))

    return true;

  if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (node->decl)))

    return true;

  if (TARGET_DLLIMPORT_DECL_ATTRIBUTES

      && lookup_attribute ("dllexport", DECL_ATTRIBUTES (node->decl)))

    return true;

  if (node->resolution == LDPR_PREVAILING_DEF_IRONLY)

    return false;

  /* When doing LTO or whole program, we can bring COMDAT functoins static.

     This improves code quality and we know we will duplicate them at most twice

     (in the case that we are not using plugin and link with object file

      implementing same COMDAT)  */

  if ((in_lto_p || whole_program)

      && DECL_COMDAT (node->decl)

      && cgraph_comdat_can_be_unshared_p (node))

    return false;

  /* When doing link time optimizations, hidden symbols become local.  */

  if (in_lto_p

      && (DECL_VISIBILITY (node->decl) == VISIBILITY_HIDDEN

          || DECL_VISIBILITY (node->decl) == VISIBILITY_INTERNAL)

      /* Be sure that node is defined in IR file, not in other object

         file.  In that case we don't set used_from_other_object_file.  */

      && node->analyzed)

    ;

  else if (!whole_program)

    return true;

  if (MAIN_NAME_P (DECL_NAME (node->decl)))

    return true;

  return false;

}

/* Return true when variable VNODE should be considered externally visible.  */

bool

varpool_externally_visible_p (struct varpool_node *vnode, bool aliased)

{

  if (!DECL_COMDAT (vnode->decl) && !TREE_PUBLIC (vnode->decl))

    return false;

  /* Do not even try to be smart about aliased nodes.  Until we properly

     represent everything by same body alias, these are just evil.  */

  if (aliased)

    return true;

  /* If linker counts on us, we must preserve the function.  */

  if (varpool_used_from_object_file_p (vnode))

    return true;

  if (DECL_HARD_REGISTER (vnode->decl))

    return true;

  if (DECL_PRESERVE_P (vnode->decl))

    return true;

  if (lookup_attribute ("externally_visible",

                        DECL_ATTRIBUTES (vnode->decl)))

    return true;

  if (TARGET_DLLIMPORT_DECL_ATTRIBUTES

      && lookup_attribute ("dllexport",

                           DECL_ATTRIBUTES (vnode->decl)))

    return true;

  /* See if we have linker information about symbol not being used or

     if we need to make guess based on the declaration.