re PR debug/66691 (ICE on valid code at -O3 with -g enabled in simplify_subreg, at...

[gcc.git] / gcc / ipa.c

diff --git a/gcc/ipa.c b/gcc/ipa.c
index 620431c54d6b1c2c7b86c877ab18aea3010daec9..fdfb88072da6652a47309f1071ae5c5696ae6b70 100644 (file)
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -21,29 +21,17 @@ along with GCC; see the file COPYING3.  If not see
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
-#include "hash-set.h"
-#include "machmode.h"
-#include "vec.h"
-#include "double-int.h"
-#include "input.h"
 #include "alias.h"
 #include "symtab.h"
 #include "options.h"
-#include "wide-int.h"
-#include "inchash.h"
 #include "tree.h"
 #include "fold-const.h"
 #include "calls.h"
 #include "stringpool.h"
 #include "predict.h"
 #include "basic-block.h"
-#include "hash-map.h"
-#include "is-a.h"
-#include "plugin-api.h"
 #include "hard-reg-set.h"
-#include "input.h"
 #include "function.h"
-#include "ipa-ref.h"
 #include "cgraph.h"
 #include "tree-pass.h"
 #include "gimple-expr.h"
@@ -197,7 +185,7 @@ walk_polymorphic_call_targets (hash_set<void *> *reachable_call_targets,
             unused.  */
          if (TREE_CODE (TREE_TYPE (n->decl)) == METHOD_TYPE
              && type_in_anonymous_namespace_p
-                   (method_class_type (TREE_TYPE (n->decl))))
+                   (TYPE_METHOD_BASETYPE (TREE_TYPE (n->decl))))
            continue;
 
           symtab_node *body = n->function_symbol ();
@@ -476,6 +464,20 @@ symbol_table::remove_unreachable_nodes (FILE *file)
              if (cnode->global.inlined_to)
                body_needed_for_clonning.add (cnode->decl);
 
+             /* For instrumentation clones we always need original
+                function node for proper LTO privatization.  */
+             if (cnode->instrumentation_clone
+                 && cnode->definition)
+               {
+                 gcc_assert (cnode->instrumented_version || in_lto_p);
+                 if (cnode->instrumented_version)
+                   {
+                     enqueue_node (cnode->instrumented_version, &first,
+                                   &reachable);
+                     reachable.add (cnode->instrumented_version);
+                   }
+               }
+
              /* For non-inline clones, force their origins to the boundary and ensure
                 that body is not removed.  */
              while (cnode->clone_of)
@@ -492,7 +494,7 @@ symbol_table::remove_unreachable_nodes (FILE *file)
            }
          else if (cnode->thunk.thunk_p)
            enqueue_node (cnode->callees->callee, &first, &reachable);
-             
+
          /* If any reachable function has simd clones, mark them as
             reachable as well.  */
          if (cnode->simd_clones)
@@ -537,7 +539,13 @@ symbol_table::remove_unreachable_nodes (FILE *file)
       /* If node is unreachable, remove its body.  */
       else if (!reachable.contains (node))
         {
-         if (!body_needed_for_clonning.contains (node->decl))
+         /* We keep definitions of thunks and aliases in the boundary so
+            we can walk to the ultimate alias targets and function symbols
+            reliably.  */
+         if (node->alias || node->thunk.thunk_p)
+           ;
+         else if (!body_needed_for_clonning.contains (node->decl)
+             && !node->alias && !node->thunk.thunk_p)
            node->release_body ();
          else if (!node->clone_of)
            gcc_assert (in_lto_p || DECL_RESULT (node->decl));
@@ -655,7 +663,7 @@ symbol_table::remove_unreachable_nodes (FILE *file)
     if (node->address_taken
        && !node->used_from_other_partition)
       {
-       if (!node->call_for_symbol_thunks_and_aliases
+       if (!node->call_for_symbol_and_aliases
            (has_addr_references_p, NULL, true)
            && (!node->instrumentation_clone
                || !node->instrumented_version
@@ -802,8 +810,8 @@ ipa_discover_readonly_nonaddressable_vars (void)
          {
            if (TREE_ADDRESSABLE (vnode->decl) && dump_file)
              fprintf (dump_file, " %s (non-addressable)", vnode->name ());
-           vnode->call_for_node_and_aliases (clear_addressable_bit, NULL,
-                                             true);
+           vnode->call_for_symbol_and_aliases (clear_addressable_bit, NULL,
+                                               true);
          }
        if (!address_taken && !written
            /* Making variable in explicit section readonly can cause section
@@ -813,14 +821,14 @@ ipa_discover_readonly_nonaddressable_vars (void)
          {
            if (!TREE_READONLY (vnode->decl) && dump_file)
              fprintf (dump_file, " %s (read-only)", vnode->name ());
-           vnode->call_for_node_and_aliases (set_readonly_bit, NULL, true);
+           vnode->call_for_symbol_and_aliases (set_readonly_bit, NULL, true);
          }
        if (!vnode->writeonly && !read && !address_taken && written)
          {
            if (dump_file)
              fprintf (dump_file, " %s (write-only)", vnode->name ());
-           vnode->call_for_node_and_aliases (set_writeonly_bit, &remove_p, 
-                                            true);
+           vnode->call_for_symbol_and_aliases (set_writeonly_bit, &remove_p, 
+                                               true);
          }
       }
   if (dump_file)
@@ -1337,9 +1345,8 @@ ipa_single_use (void)
          single_user_map.put (var, user);
 
          /* Enqueue all aliases for re-processing.  */
-         for (i = 0; var->iterate_referring (i, ref); i++)
-           if (ref->use == IPA_REF_ALIAS
-               && !ref->referring->aux)
+         for (i = 0; var->iterate_direct_aliases (i, ref); i++)
+           if (!ref->referring->aux)
              {
                ref->referring->aux = first;
                first = dyn_cast <varpool_node *> (ref->referring);