[Attributor] Allow explicit dependence tracking

[jdoerfert]

Summary

By default, the Attributor tracks potential dependences between abstract
attributes based on the issued Attributor::getAAFor queries. This
simplifies the development of new abstract attributes but it can also
lead to spurious dependences that might increase compile time and make
internalization harder (D63312). With this patch, abstract attributes
can opt-out of implicit dependence tracking and instead register
dependences explicitly. It is up to the implementation to make sure all
existing dependences are registered.

[sstefan1]

LGTM.

llvm/include/llvm/Transforms/IPO/Attributor.h

struct Attributor {
   ///
   /// This method is the only (supported) way an abstract attribute can retrieve
   /// information from another abstract attribute. As an example, take an
   /// abstract attribute that determines the memory access behavior for a
   /// argument (readnone, readonly, ...). It should use `getAAFor` to get the
   /// most optimistic information for other abstract attributes in-flight, e.g.
   /// the one reasoning about the "captured" state for the argument or the one
   /// reasoning on the memory access behavior of the function as a whole.
+  ///
+  /// If the flag \p TrackDependence is set to false the dependence from
+  /// \p QueryingAA to the return abstract attribute is not automatically
+  /// recorded. This should only be used if the caller will record the
+  /// dependence explicitly if necessary, thus if it the returned abstract
+  /// attribute is used for reasoning. To record the dependences explicitly use
+  /// the `Attributor::recordDependence` method.
   template <typename AAType>
   const AAType *getAAFor(AbstractAttribute &QueryingAA, const Value &V,
-                         int ArgNo = -1) {
+                         int ArgNo = -1, bool TrackDependence = true) {
     static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
                   "Cannot query an attribute with a type not derived from "
                   "'AbstractAttribute'!");
     assert(AAType::ID != Attribute::None &&
            "Cannot lookup generic abstract attributes!");
 
     // Determine the argument number automatically for llvm::Arguments.
     if (auto *Arg = dyn_cast<Argument>(&V))
       ArgNo = Arg->getArgNo();
 
     // If a function was given together with an argument number, perform the
     // lookup for the actual argument instead. Don't do it for variadic
     // arguments.
     if (ArgNo >= 0 && isa<Function>(&V) &&
         cast<Function>(&V)->arg_size() > (size_t)ArgNo)
-      return getAAFor<AAType>(
-          QueryingAA, *(cast<Function>(&V)->arg_begin() + ArgNo), ArgNo);
+      return getAAFor<AAType>(QueryingAA,
+                              *(cast<Function>(&V)->arg_begin() + ArgNo), ArgNo,
+                              TrackDependence);
 
     // Lookup the abstract attribute of type AAType. If found, return it after
     // registering a dependence of QueryingAA on the one returned attribute.
     const auto &KindToAbstractAttributeMap = AAMap.lookup({&V, ArgNo});
     if (AAType *AA = static_cast<AAType *>(
             KindToAbstractAttributeMap.lookup(AAType::ID))) {
+      if (TrackDependence)
         QueryMap[AA].insert(&QueryingAA);
       return AA;
     }
 
     // If no abstract attribute was found and we look for a call site argument,
     // defer to the actual argument instead.
     ImmutableCallSite ICS(&V);
     if (ICS && ICS.getCalledValue())
-      return getAAFor<AAType>(QueryingAA, *ICS.getCalledValue(), ArgNo);
+      return getAAFor<AAType>(QueryingAA, *ICS.getCalledValue(), ArgNo,
+                              TrackDependence);
 
     // No matching attribute found
     return nullptr;
   }
 
+  /// Explicitly record a dependence from \p FromAA to \p ToAA, that is if
+  /// \p FromAA changes \p ToAA should be updated as well.
+  ///
+  /// This method should be used in conjunction with the `getAAFor` method and
+  /// with the TrackDependence flag passed to the method set to false. This can
+  /// be beneficial to avoid false dependences but it requires the users of
+  /// `getAAFor` to explicitly record true dependences through this method.
+  void recordDependence(AbstractAttribute *FromAA, AbstractAttribute *ToAA) {
+    QueryMap[FromAA].insert(ToAA);
+  }
+
   /// Introduce a new abstract attribute into the fixpoint analysis.
   ///
   /// Note that ownership of the attribute is given to the Attributor. It will
   /// invoke delete for the Attributor on destruction of the Attributor.
   ///
   /// Attributes are identified by
   ///  (1) their anchored value (see AA.getAnchoredValue()),
   ///  (2) their argument number (\p ArgNo, or Argument::getArgNo()), and