Hi,

Modref tree template stores its own copy of param_moderf_max_bases, *_max_refs
and *_max_accesses values.  This was done before we had per-function limits and
even back then it was bit dubious, so this patch removes it.

Bootstrapped/regtested x86_64-linux, will commit it shortly.
Honza

gcc/ChangeLog:

        * ipa-modref-tree.h (struct modref_tree): Remove max_bases, max_refs
        and max_accesses.
        (modref_tree::modref_tree): Remove parametr.
        (modref_tree::insert_base): Add max_bases parameter.
        (modref_tree::insert): Add max_bases, max_refs, max_accesses
        parameters.
        (modref_tree::insert): New member function.
        (modref_tree::merge): Add max_bases, max_refs, max_accesses
        parameters.
        (modref_tree::insert): New member function.
        * ipa-modref-tree.c (test_insert_search_collapse): Update.
        (test_merge): Update.
        * ipa-modref.c (dump_records): Don't dump max_refs and max_bases.
        (dump_lto_records): Likewise.
        (modref_summary::finalize): Fix whitespace.
        (get_modref_function_summary): Likewise.
        (modref_access_analysis::record_access): Update.
        (modref_access_analysis::record_access_lto): Update.
        (modref_access_analysis::process_fnspec): Update.
        (analyze_function): Update.
        (modref_summaries::duplicate): Update.
        (modref_summaries_lto::duplicate): Update.
        (write_modref_records): Update.
        (read_modref_records): Update.
        (read_section): Update.
        (propagate_unknown_call): Update.
        (modref_propagate_in_scc): Update.
        (ipa_merge_modref_summary_after_inlining): Update.

diff --git a/gcc/ipa-modref-tree.c b/gcc/ipa-modref-tree.c
index e23d88d7fc0..0671fa76199 100644
--- a/gcc/ipa-modref-tree.c
+++ b/gcc/ipa-modref-tree.c
@@ -874,11 +874,11 @@ test_insert_search_collapse ()
   modref_ref_node<alias_set_type> *ref_node;
   modref_access_node a = unspecified_modref_access_node;
 
-  modref_tree<alias_set_type> *t = new modref_tree<alias_set_type>(1, 2, 2);
+  modref_tree<alias_set_type> *t = new modref_tree<alias_set_type>();
   ASSERT_FALSE (t->every_base);
 
   /* Insert into an empty tree.  */
-  t->insert (1, 2, a, false);
+  t->insert (1, 2, 2, 1, 2, a, false);
   ASSERT_NE (t->bases, NULL);
   ASSERT_EQ (t->bases->length (), 1);
   ASSERT_FALSE (t->every_base);
@@ -896,7 +896,7 @@ test_insert_search_collapse ()
   ASSERT_EQ (ref_node->ref, 2);
 
   /* Insert when base exists but ref does not.  */
-  t->insert (1, 3, a, false);
+  t->insert (1, 2, 2, 1, 3, a, false);
   ASSERT_NE (t->bases, NULL);
   ASSERT_EQ (t->bases->length (), 1);
   ASSERT_EQ (t->search (1), base_node);
@@ -909,7 +909,7 @@ test_insert_search_collapse ()
 
   /* Insert when base and ref exist, but access is not dominated by nor
      dominates other accesses.  */
-  t->insert (1, 2, a, false);
+  t->insert (1, 2, 2, 1, 2, a, false);
   ASSERT_EQ (t->bases->length (), 1);
   ASSERT_EQ (t->search (1), base_node);
 
@@ -917,12 +917,12 @@ test_insert_search_collapse ()
   ASSERT_NE (ref_node, NULL);
 
   /* Insert when base and ref exist and access is dominated.  */
-  t->insert (1, 2, a, false);
+  t->insert (1, 2, 2, 1, 2, a, false);
   ASSERT_EQ (t->search (1), base_node);
   ASSERT_EQ (base_node->search (2), ref_node);
 
   /* Insert ref to trigger ref list collapse for base 1.  */
-  t->insert (1, 4, a, false);
+  t->insert (1, 2, 2, 1, 4, a, false);
   ASSERT_EQ (t->search (1), base_node);
   ASSERT_EQ (base_node->refs, NULL);
   ASSERT_EQ (base_node->search (2), NULL);
@@ -930,7 +930,7 @@ test_insert_search_collapse ()
   ASSERT_TRUE (base_node->every_ref);
 
   /* Further inserts to collapsed ref list are ignored.  */
-  t->insert (1, 5, a, false);
+  t->insert (1, 2, 2, 1, 5, a, false);
   ASSERT_EQ (t->search (1), base_node);
   ASSERT_EQ (base_node->refs, NULL);
   ASSERT_EQ (base_node->search (2), NULL);
@@ -938,13 +938,13 @@ test_insert_search_collapse ()
   ASSERT_TRUE (base_node->every_ref);
 
   /* Insert base to trigger base list collapse.  */
-  t->insert (5, 0, a, false);
+  t->insert (1, 2, 2, 5, 0, a, false);
   ASSERT_TRUE (t->every_base);
   ASSERT_EQ (t->bases, NULL);
   ASSERT_EQ (t->search (1), NULL);
 
   /* Further inserts to collapsed base list are ignored.  */
-  t->insert (7, 8, a, false);
+  t->insert (1, 2, 2, 7, 8, a, false);
   ASSERT_TRUE (t->every_base);
   ASSERT_EQ (t->bases, NULL);
   ASSERT_EQ (t->search (1), NULL);
@@ -959,23 +959,23 @@ test_merge ()
   modref_base_node<alias_set_type> *base_node;
   modref_access_node a = unspecified_modref_access_node;
 
-  t1 = new modref_tree<alias_set_type>(3, 4, 1);
-  t1->insert (1, 1, a, false);
-  t1->insert (1, 2, a, false);
-  t1->insert (1, 3, a, false);
-  t1->insert (2, 1, a, false);
-  t1->insert (3, 1, a, false);
-
-  t2 = new modref_tree<alias_set_type>(10, 10, 10);
-  t2->insert (1, 2, a, false);
-  t2->insert (1, 3, a, false);
-  t2->insert (1, 4, a, false);
-  t2->insert (3, 2, a, false);
-  t2->insert (3, 3, a, false);
-  t2->insert (3, 4, a, false);
-  t2->insert (3, 5, a, false);
-
-  t1->merge (t2, NULL, NULL, false);
+  t1 = new modref_tree<alias_set_type>();
+  t1->insert (3, 4, 1, 1, 1, a, false);
+  t1->insert (3, 4, 1, 1, 2, a, false);
+  t1->insert (3, 4, 1, 1, 3, a, false);
+  t1->insert (3, 4, 1, 2, 1, a, false);
+  t1->insert (3, 4, 1, 3, 1, a, false);
+
+  t2 = new modref_tree<alias_set_type>();
+  t2->insert (10, 10, 10, 1, 2, a, false);
+  t2->insert (10, 10, 10, 1, 3, a, false);
+  t2->insert (10, 10, 10, 1, 4, a, false);
+  t2->insert (10, 10, 10, 3, 2, a, false);
+  t2->insert (10, 10, 10, 3, 3, a, false);
+  t2->insert (10, 10, 10, 3, 4, a, false);
+  t2->insert (10, 10, 10, 3, 5, a, false);
+
+  t1->merge (3, 4, 1, t2, NULL, NULL, false);
 
   ASSERT_FALSE (t1->every_base);
   ASSERT_NE (t1->bases, NULL);
diff --git a/gcc/ipa-modref-tree.h b/gcc/ipa-modref-tree.h
index 6796e6ecc34..35190c212ca 100644
--- a/gcc/ipa-modref-tree.h
+++ b/gcc/ipa-modref-tree.h
@@ -304,16 +304,10 @@ template <typename T>
 struct GTY((user)) modref_tree
 {
   vec <modref_base_node <T> *, va_gc> *bases;
-  size_t max_bases;
-  size_t max_refs;
-  size_t max_accesses;
   bool every_base;
 
-  modref_tree (size_t max_bases, size_t max_refs, size_t max_accesses):
+  modref_tree ():
     bases (NULL),
-    max_bases (max_bases),
-    max_refs (max_refs),
-    max_accesses (max_accesses),
     every_base (false) {}
 
   /* Insert BASE; collapse tree if there are more than MAX_REFS.
@@ -321,7 +315,9 @@ struct GTY((user)) modref_tree
      something changed.
      If table gets full, try to insert REF instead.  */
 
-  modref_base_node <T> *insert_base (T base, T ref, bool *changed = NULL)
+  modref_base_node <T> *insert_base (T base, T ref,
+                                    unsigned int max_bases,
+                                    bool *changed = NULL)
   {
     modref_base_node <T> *base_node;
 
@@ -367,7 +363,10 @@ struct GTY((user)) modref_tree
 
   /* Insert memory access to the tree.
      Return true if something changed.  */
-  bool insert (T base, T ref, modref_access_node a,
+  bool insert (unsigned int max_bases,
+              unsigned int max_refs,
+              unsigned int max_accesses,
+              T base, T ref, modref_access_node a,
               bool record_adjustments)
   {
     if (every_base)
@@ -412,7 +411,8 @@ struct GTY((user)) modref_tree
        return true;
       }
 
-    modref_base_node <T> *base_node = insert_base (base, ref, &changed);
+    modref_base_node <T> *base_node
+      = insert_base (base, ref, max_bases, &changed);
     base = base_node->base;
     /* If table got full we may end up with useless base.  */
     if (!base && !ref && !a.useful_p ())
@@ -431,8 +431,8 @@ struct GTY((user)) modref_tree
        return true;
       }
 
-    modref_ref_node <T> *ref_node = base_node->insert_ref (ref, max_refs,
-                                                          &changed);
+    modref_ref_node <T> *ref_node
+           = base_node->insert_ref (ref, max_refs, &changed);
     ref = ref_node->ref;
 
     if (ref_node->every_access)
@@ -458,6 +458,18 @@ struct GTY((user)) modref_tree
     return changed;
   }
 
+  /* Insert memory access to the tree.
+     Return true if something changed.  */
+  bool insert (tree fndecl,
+              T base, T ref, const modref_access_node &a,
+              bool record_adjustments)
+  {
+     return insert (opt_for_fn (fndecl, param_modref_max_bases),
+                   opt_for_fn (fndecl, param_modref_max_refs),
+                   opt_for_fn (fndecl, param_modref_max_accesses),
+                   base, ref, a, record_adjustments);
+  }
+
  /* Remove tree branches that are not useful (i.e. they will always pass).  */
 
  void cleanup ()
@@ -506,7 +518,10 @@ struct GTY((user)) modref_tree
      PARM_MAP, if non-NULL, maps parm indexes of callee to caller.
      Similar CHAIN_MAP, if non-NULL, maps static chain of callee to caller.
      Return true if something has changed.  */
-  bool merge (modref_tree <T> *other, vec <modref_parm_map> *parm_map,
+  bool merge (unsigned int max_bases,
+             unsigned int max_refs,
+             unsigned int max_accesses,
+             modref_tree <T> *other, vec <modref_parm_map> *parm_map,
              modref_parm_map *static_chain_map,
              bool record_accesses)
   {
@@ -530,7 +545,7 @@ struct GTY((user)) modref_tree
     if (other == this)
       {
        release = true;
-       other = modref_tree<T>::create_ggc (max_bases, max_refs, max_accesses);
+       other = modref_tree<T>::create_ggc ();
        other->copy_from (this);
       }
 
@@ -538,7 +553,8 @@ struct GTY((user)) modref_tree
       {
        if (base_node->every_ref)
          {
-           my_base_node = insert_base (base_node->base, 0, &changed);
+           my_base_node = insert_base (base_node->base, 0,
+                                       max_bases, &changed);
            if (my_base_node && !my_base_node->every_ref)
              {
                my_base_node->collapse ();
@@ -551,7 +567,8 @@ struct GTY((user)) modref_tree
            {
              if (ref_node->every_access)
                {
-                 changed |= insert (base_node->base,
+                 changed |= insert (max_bases, max_refs, max_accesses,
+                                    base_node->base,
                                     ref_node->ref,
                                     unspecified_modref_access_node,
                                     record_accesses);
@@ -578,8 +595,9 @@ struct GTY((user)) modref_tree
                            a.parm_index = m.parm_index;
                          }
                      }
-                   changed |= insert (base_node->base, ref_node->ref, a,
-                                      record_accesses);
+                   changed |= insert (max_bases, max_refs, max_accesses,
+                                      base_node->base, ref_node->ref,
+                                      a, record_accesses);
                  }
            }
       }
@@ -588,10 +606,25 @@ struct GTY((user)) modref_tree
     return changed;
   }
 
+  /* Merge OTHER into the tree.
+     PARM_MAP, if non-NULL, maps parm indexes of callee to caller.
+     Similar CHAIN_MAP, if non-NULL, maps static chain of callee to caller.
+     Return true if something has changed.  */
+  bool merge (tree fndecl,
+             modref_tree <T> *other, vec <modref_parm_map> *parm_map,
+             modref_parm_map *static_chain_map,
+             bool record_accesses)
+  {
+     return merge (opt_for_fn (fndecl, param_modref_max_bases),
+                  opt_for_fn (fndecl, param_modref_max_refs),
+                  opt_for_fn (fndecl, param_modref_max_accesses),
+                  other, parm_map, static_chain_map, record_accesses);
+  }
+
   /* Copy OTHER to THIS.  */
   void copy_from (modref_tree <T> *other)
   {
-    merge (other, NULL, NULL, false);
+    merge (INT_MAX, INT_MAX, INT_MAX, other, NULL, NULL, false);
   }
 
   /* Search BASE in tree; return NULL if failed.  */
@@ -633,11 +666,10 @@ struct GTY((user)) modref_tree
   /* Return ggc allocated instance.  We explicitly call destructors via
      ggc_delete and do not want finalizers to be registered and
      called at the garbage collection time.  */
-  static modref_tree<T> *create_ggc (size_t max_bases, size_t max_refs,
-                                    size_t max_accesses)
+  static modref_tree<T> *create_ggc ()
   {
     return new (ggc_alloc_no_dtor<modref_tree<T>> ())
-        modref_tree<T> (max_bases, max_refs, max_accesses);
+        modref_tree<T> ();
   }
 
   /* Remove all records and mark tree to alias with everything.  */
diff --git a/gcc/ipa-modref.c b/gcc/ipa-modref.c
index 4f9323165ea..79d7d774715 100644
--- a/gcc/ipa-modref.c
+++ b/gcc/ipa-modref.c
@@ -423,8 +423,6 @@ modref_summary_lto::useful_p (int ecf_flags, bool 
check_flags)
 static void
 dump_records (modref_records *tt, FILE *out)
 {
-  fprintf (out, "    Limits: %i bases, %i refs\n",
-          (int)tt->max_bases, (int)tt->max_refs);
   if (tt->every_base)
     {
       fprintf (out, "    Every base\n");
@@ -466,8 +464,6 @@ dump_records (modref_records *tt, FILE *out)
 static void
 dump_lto_records (modref_records_lto *tt, FILE *out)
 {
-  fprintf (out, "    Limits: %i bases, %i refs\n",
-          (int)tt->max_bases, (int)tt->max_refs);
   if (tt->every_base)
     {
       fprintf (out, "    Every base\n");
@@ -693,7 +689,7 @@ modref_summary::finalize (tree fun)
       try_dse = true;
       size_t i, j, k;
       int num_tests = 0, max_tests
-               = opt_for_fn (fun, param_modref_max_tests);
+       = opt_for_fn (fun, param_modref_max_tests);
       modref_base_node <alias_set_type> *base_node;
       modref_ref_node <alias_set_type> *ref_node;
       modref_access_node *access_node;
@@ -768,7 +764,7 @@ get_modref_function_summary (gcall *call, bool *interposed)
   modref_summary *r = get_modref_function_summary (node);
   if (interposed && r)
     *interposed = r->calls_interposable
-                 || !node->binds_to_current_def_p ();
+                 || !node->binds_to_current_def_p ();
   return r;
 }
 
@@ -996,7 +992,7 @@ modref_access_analysis::record_access (modref_records *tt,
                base_set, ref_set);
        a.dump (dump_file);
     }
-  tt->insert (base_set, ref_set, a, false);
+  tt->insert (current_function_decl, base_set, ref_set, a, false);
 }
 
 /* IPA version of record_access_tree.  */
@@ -1062,7 +1058,7 @@ modref_access_analysis::record_access_lto 
(modref_records_lto *tt, ao_ref *ref,
        a.dump (dump_file);
     }
 
-  tt->insert (base_type, ref_type, a, false);
+  tt->insert (current_function_decl, base_type, ref_type, a, false);
 }
 
 /* Returns true if and only if we should store the access to EXPR.
@@ -1277,12 +1273,15 @@ modref_access_analysis::merge_call_side_effects
     }
 
   /* Merge in loads.  */
-  changed |= m_summary->loads->merge (callee_summary->loads, &parm_map,
-                                     &chain_map, record_adjustments);
+  changed |= m_summary->loads->merge (current_function_decl,
+                                     callee_summary->loads,
+                                     &parm_map, &chain_map,
+                                     record_adjustments);
   /* Merge in stores.  */
   if (!ignore_stores_p (current_function_decl, flags))
     {
-      changed |= m_summary->stores->merge (callee_summary->stores,
+      changed |= m_summary->stores->merge (current_function_decl,
+                                          callee_summary->stores,
                                           &parm_map, &chain_map,
                                           record_adjustments);
       if (!m_summary->writes_errno
@@ -1395,9 +1394,10 @@ modref_access_analysis::process_fnspec (gcall *call)
            if (a.parm_index == MODREF_LOCAL_MEMORY_PARM)
              continue;
            if (m_summary)
-             m_summary->loads->insert (0, 0, a, false);
+             m_summary->loads->insert (current_function_decl, 0, 0, a, false);
            if (m_summary_lto)
-             m_summary_lto->loads->insert (0, 0, a, false);
+             m_summary_lto->loads->insert (current_function_decl, 0, 0, a,
+                                           false);
          }
     }
   if (ignore_stores_p (current_function_decl, flags))
@@ -1426,9 +1426,10 @@ modref_access_analysis::process_fnspec (gcall *call)
            if (a.parm_index == MODREF_LOCAL_MEMORY_PARM)
              continue;
            if (m_summary)
-             m_summary->stores->insert (0, 0, a, false);
+             m_summary->stores->insert (current_function_decl, 0, 0, a, false);
            if (m_summary_lto)
-             m_summary_lto->stores->insert (0, 0, a, false);
+             m_summary_lto->stores->insert (current_function_decl,
+                                            0, 0, a, false);
          }
       if (fnspec.errno_maybe_written_p () && flag_errno_math)
        {
@@ -3024,13 +3025,9 @@ analyze_function (function *f, bool ipa)
   if (nolto)
     {
       gcc_assert (!summary->loads);
-      summary->loads = modref_records::create_ggc (param_modref_max_bases,
-                                                  param_modref_max_refs,
-                                                  param_modref_max_accesses);
+      summary->loads = modref_records::create_ggc ();
       gcc_assert (!summary->stores);
-      summary->stores = modref_records::create_ggc (param_modref_max_bases,
-                                                   param_modref_max_refs,
-                                                   param_modref_max_accesses);
+      summary->stores = modref_records::create_ggc ();
       summary->writes_errno = false;
       summary->side_effects = false;
       summary->nondeterministic = false;
@@ -3039,15 +3036,9 @@ analyze_function (function *f, bool ipa)
   if (lto)
     {
       gcc_assert (!summary_lto->loads);
-      summary_lto->loads = modref_records_lto::create_ggc
-                                (param_modref_max_bases,
-                                 param_modref_max_refs,
-                                 param_modref_max_accesses);
+      summary_lto->loads = modref_records_lto::create_ggc ();
       gcc_assert (!summary_lto->stores);
-      summary_lto->stores = modref_records_lto::create_ggc
-                                (param_modref_max_bases,
-                                 param_modref_max_refs,
-                                 param_modref_max_accesses);
+      summary_lto->stores = modref_records_lto::create_ggc ();
       summary_lto->writes_errno = false;
       summary_lto->side_effects = false;
       summary_lto->nondeterministic = false;
@@ -3287,15 +3278,9 @@ modref_summaries::duplicate (cgraph_node *, cgraph_node 
*dst,
       optimization_summaries->remove (dst);
       return;
     }
-  dst_data->stores = modref_records::create_ggc
-                       (src_data->stores->max_bases,
-                        src_data->stores->max_refs,
-                        src_data->stores->max_accesses);
+  dst_data->stores = modref_records::create_ggc ();
   dst_data->stores->copy_from (src_data->stores);
-  dst_data->loads = modref_records::create_ggc
-                       (src_data->loads->max_bases,
-                        src_data->loads->max_refs,
-                        src_data->loads->max_accesses);
+  dst_data->loads = modref_records::create_ggc ();
   dst_data->loads->copy_from (src_data->loads);
   dst_data->kills.reserve_exact (src_data->kills.length ());
   dst_data->kills.splice (src_data->kills);
@@ -3319,15 +3304,9 @@ modref_summaries_lto::duplicate (cgraph_node *, 
cgraph_node *,
   /* Be sure that no further cloning happens after ipa-modref.  If it does
      we will need to update signatures for possible param changes.  */
   gcc_checking_assert (!((modref_summaries_lto *)summaries_lto)->propagated);
-  dst_data->stores = modref_records_lto::create_ggc
-                       (src_data->stores->max_bases,
-                        src_data->stores->max_refs,
-                        src_data->stores->max_accesses);
+  dst_data->stores = modref_records_lto::create_ggc ();
   dst_data->stores->copy_from (src_data->stores);
-  dst_data->loads = modref_records_lto::create_ggc
-                       (src_data->loads->max_bases,
-                        src_data->loads->max_refs,
-                        src_data->loads->max_accesses);
+  dst_data->loads = modref_records_lto::create_ggc ();
   dst_data->loads->copy_from (src_data->loads);
   dst_data->kills.reserve_exact (src_data->kills.length ());
   dst_data->kills.splice (src_data->kills);
@@ -3379,10 +3358,6 @@ class pass_modref : public gimple_opt_pass
 static void
 write_modref_records (modref_records_lto *tt, struct output_block *ob)
 {
-  streamer_write_uhwi (ob, tt->max_bases);
-  streamer_write_uhwi (ob, tt->max_refs);
-  streamer_write_uhwi (ob, tt->max_accesses);
-
   streamer_write_uhwi (ob, tt->every_base);
   streamer_write_uhwi (ob, vec_safe_length (tt->bases));
   for (auto base_node : tt->bases)
@@ -3410,20 +3385,19 @@ write_modref_records (modref_records_lto *tt, struct 
output_block *ob)
    LTO streaming is expected or not.  */
 
 static void
-read_modref_records (lto_input_block *ib, struct data_in *data_in,
+read_modref_records (tree decl,
+                    lto_input_block *ib, struct data_in *data_in,
                     modref_records **nolto_ret,
                     modref_records_lto **lto_ret)
 {
-  size_t max_bases = streamer_read_uhwi (ib);
-  size_t max_refs = streamer_read_uhwi (ib);
-  size_t max_accesses = streamer_read_uhwi (ib);
+  size_t max_bases = opt_for_fn (decl, param_modref_max_bases);
+  size_t max_refs = opt_for_fn (decl, param_modref_max_refs);
+  size_t max_accesses = opt_for_fn (decl, param_modref_max_accesses);
 
   if (lto_ret)
-    *lto_ret = modref_records_lto::create_ggc (max_bases, max_refs,
-                                              max_accesses);
+    *lto_ret = modref_records_lto::create_ggc ();
   if (nolto_ret)
-    *nolto_ret = modref_records::create_ggc (max_bases, max_refs,
-                                            max_accesses);
+    *nolto_ret = modref_records::create_ggc ();
   gcc_checking_assert (lto_ret || nolto_ret);
 
   size_t every_base = streamer_read_uhwi (ib);
@@ -3461,9 +3435,9 @@ read_modref_records (lto_input_block *ib, struct data_in 
*data_in,
       if (nolto_ret)
        nolto_base_node = (*nolto_ret)->insert_base (base_tree
                                                     ? get_alias_set (base_tree)
-                                                    : 0, 0);
+                                                    : 0, 0, INT_MAX);
       if (lto_ret)
-       lto_base_node = (*lto_ret)->insert_base (base_tree, 0);
+       lto_base_node = (*lto_ret)->insert_base (base_tree, 0, max_bases);
       size_t every_ref = streamer_read_uhwi (ib);
       size_t nref = streamer_read_uhwi (ib);
 
@@ -3743,10 +3717,10 @@ read_section (struct lto_file_decl_data *file_data, 
const char *data,
       if (modref_sum_lto)
        modref_sum_lto->static_chain_flags = flags;
 
-      read_modref_records (&ib, data_in,
+      read_modref_records (node->decl, &ib, data_in,
                           modref_sum ? &modref_sum->loads : NULL,
                           modref_sum_lto ? &modref_sum_lto->loads : NULL);
-      read_modref_records (&ib, data_in,
+      read_modref_records (node->decl, &ib, data_in,
                           modref_sum ? &modref_sum->stores : NULL,
                           modref_sum_lto ? &modref_sum_lto->stores : NULL);
       int j = streamer_read_uhwi (&ib);
@@ -4425,10 +4399,12 @@ propagate_unknown_call (cgraph_node *node,
                }
              if (cur_summary)
                changed |= cur_summary->loads->insert
-                 (0, 0, get_access_for_fnspec (e, fnspec, i, map), false);
+                 (node->decl, 0, 0,
+                  get_access_for_fnspec (e, fnspec, i, map), false);
              if (cur_summary_lto)
                changed |= cur_summary_lto->loads->insert
-                 (0, 0, get_access_for_fnspec (e, fnspec, i, map), false);
+                 (node->decl, 0, 0,
+                  get_access_for_fnspec (e, fnspec, i, map), false);
            }
        }
       if (ignore_stores_p (node->decl, ecf_flags))
@@ -4455,10 +4431,12 @@ propagate_unknown_call (cgraph_node *node,
                }
              if (cur_summary)
                changed |= cur_summary->stores->insert
-                 (0, 0, get_access_for_fnspec (e, fnspec, i, map), false);
+                 (node->decl, 0, 0,
+                  get_access_for_fnspec (e, fnspec, i, map), false);
              if (cur_summary_lto)
                changed |= cur_summary_lto->stores->insert
-                 (0, 0, get_access_for_fnspec (e, fnspec, i, map), false);
+                 (node->decl, 0, 0,
+                  get_access_for_fnspec (e, fnspec, i, map), false);
            }
        }
       if (fnspec.errno_maybe_written_p () && flag_errno_math)
@@ -4703,13 +4681,13 @@ modref_propagate_in_scc (cgraph_node *component_node)
              if (callee_summary)
                {
                  changed |= cur_summary->loads->merge
-                                 (callee_summary->loads, &parm_map,
-                                  &chain_map, !first);
+                                 (node->decl, callee_summary->loads,
+                                  &parm_map, &chain_map, !first);
                  if (!ignore_stores)
                    {
                      changed |= cur_summary->stores->merge
-                                     (callee_summary->stores, &parm_map,
-                                      &chain_map, !first);
+                                     (node->decl, callee_summary->stores,
+                                      &parm_map, &chain_map, !first);
                      if (!cur_summary->writes_errno
                          && callee_summary->writes_errno)
                        {
@@ -4721,13 +4699,13 @@ modref_propagate_in_scc (cgraph_node *component_node)
              if (callee_summary_lto)
                {
                  changed |= cur_summary_lto->loads->merge
-                                 (callee_summary_lto->loads, &parm_map,
-                                  &chain_map, !first);
+                                 (node->decl, callee_summary_lto->loads,
+                                  &parm_map, &chain_map, !first);
                  if (!ignore_stores)
                    {
                      changed |= cur_summary_lto->stores->merge
-                                     (callee_summary_lto->stores, &parm_map,
-                                      &chain_map, !first);
+                                     (node->decl, callee_summary_lto->stores,
+                                      &parm_map, &chain_map, !first);
                      if (!cur_summary_lto->writes_errno
                          && callee_summary_lto->writes_errno)
                        {
@@ -5114,20 +5092,20 @@ ipa_merge_modref_summary_after_inlining (cgraph_edge 
*edge)
       if (!ignore_stores)
        {
          if (to_info && callee_info)
-           to_info->stores->merge (callee_info->stores, &parm_map,
+           to_info->stores->merge (to->decl, callee_info->stores, &parm_map,
                                    &chain_map, false);
          if (to_info_lto && callee_info_lto)
-           to_info_lto->stores->merge (callee_info_lto->stores, &parm_map,
-                                       &chain_map, false);
+           to_info_lto->stores->merge (to->decl, callee_info_lto->stores,
+                                       &parm_map, &chain_map, false);
        }
       if (!(flags & (ECF_CONST | ECF_NOVOPS)))
        {
          if (to_info && callee_info)
-           to_info->loads->merge (callee_info->loads, &parm_map,
+           to_info->loads->merge (to->decl, callee_info->loads, &parm_map,
                                   &chain_map, false);
          if (to_info_lto && callee_info_lto)
-           to_info_lto->loads->merge (callee_info_lto->loads, &parm_map,
-                                      &chain_map, false);
+           to_info_lto->loads->merge (to->decl, callee_info_lto->loads,
+                                      &parm_map, &chain_map, false);
        }
     }
 

Reply via email to