[Attributor][modulemap] Revert r368064 but fix the build

[jdoerfert]

Summary

Commit r368064 was necessary after r367953 (D65712) broke the module
build. That happened, apparently, because the template class IRAttribute
defined in the header had a virtual method defined in the corresponding
source file (IRAttribute::manifest). To unbreak the situation this patc
introduces a helper function IRAttributeManifest::manifestAttrs which
is used to implement IRAttribute::manifest in the header. The deifnition
of the helper function is still in the source file.

[jdoerfert]

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

668

forget these two lines of change

[kristina]

Thank you for taking the time to fix this properly, Modules+LTO linked successfully.

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

protected:
 
   /// The value this abstract attribute is anchored at.
   Value &AnchorVal;
 
   /// The index in the attribute list.
   int AttributeIdx;
 };
 
+/// Helper struct necessary as the modular build fails if the virtual method
+/// IRAttribute::manifest is defined in the Attributor.cpp.
+struct IRAttributeManifest {
+  static ChangeStatus manifestAttrs(Attributor &A, IRPosition &IRP,
+      const ArrayRef<Attribute> &DeducedAttrs);
+};
+
 /// Helper class that provides common functionality to manifest IR attributes.
 template <Attribute::AttrKind AK, typename Base>
-struct IRAttribute : public IRPosition, public Base {
+struct IRAttribute : public IRPosition, public Base, public IRAttributeManifest {
+  ~IRAttribute() {}
 
   /// Constructors for the IRPosition.
   ///
   ///{
   IRPositionConstructorForward(IRAttribute, IRPosition);
   ///}
 
   /// See AbstractAttribute::manifest(...).
-  virtual ChangeStatus manifest(Attributor &A);
+  ChangeStatus manifest(Attributor &A) {
+    SmallVector<Attribute, 4> DeducedAttrs;
+    getDeducedAttributes(getAnchorScope().getContext(), DeducedAttrs);
+    return IRAttributeManifest::manifestAttrs(A, getIRPosition(), DeducedAttrs);
+  }
 
   /// Return the kind that identifies the abstract attribute implementation.
   Attribute::AttrKind getAttrKind() const { return AK; }
 
   /// Return the deduced attributes in \p Attrs.
   virtual void getDeducedAttributes(LLVMContext &Ctx,
                                     SmallVectorImpl<Attribute> &Attrs) const {
     Attrs.emplace_back(Attribute::get(Ctx, getAttrKind()));

llvm/include/llvm/module.modulemap

module LLVM_TableGen {
   umbrella "TableGen"
   module * { export * }
 }
 
 module LLVM_Transforms {
   requires cplusplus
   umbrella "Transforms"
 
-  // FIXME: This is far from a perfect solution but at the moment this header
-  // is difficult to modularize and would require splitting it up. Exclude it
-  // completely to avoid a link failure with modular builds.
-  exclude header "Transforms/IPO/Attributor.h"
-
   module * { export * }
 }
 
 extern module LLVM_Extern_Utils_DataTypes "module.extern.modulemap"
 
 // A module covering ADT/ and Support/. These are intertwined and
 // codependent, and notionally form a single module.
 module LLVM_Utils {

llvm/lib/Transforms/IPO/Attributor.cpp

ChangeStatus AbstractAttribute::update(Attributor &A,
   HasChanged = updateImpl(A, InfoCache);
 
   LLVM_DEBUG(dbgs() << "[Attributor] Update " << HasChanged << " " << *this
                     << "\n");
 
   return HasChanged;
 }
 
-template <Attribute::AttrKind AK, typename Base>
-ChangeStatus IRAttribute<AK, Base>::manifest(Attributor &A) {
-  assert(this->getState().isValidState() &&
-         "Attempted to manifest an invalid state!");
-  assert(getIRPosition().getAssociatedValue() &&
+ ChangeStatus IRAttributeManifest::manifestAttrs(Attributor &A, IRPosition
+     &IRP, const ArrayRef<Attribute> &DeducedAttrs) {
+  assert(IRP.getAssociatedValue() &&
          "Attempted to manifest an attribute without associated value!");
 
   ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
 
-  Function &ScopeFn = getAnchorScope();
+  Function &ScopeFn = IRP.getAnchorScope();
   LLVMContext &Ctx = ScopeFn.getContext();
-  IRPosition::Kind PK = getPositionKind();
-
-  SmallVector<Attribute, 4> DeducedAttrs;
-  getDeducedAttributes(Ctx, DeducedAttrs);
+  IRPosition::Kind PK = IRP.getPositionKind();
 
   // In the following some generic code that will manifest attributes in
   // DeducedAttrs if they improve the current IR. Due to the different
   // annotation positions we use the underlying AttributeList interface.
 
   AttributeList Attrs;
   switch (PK) {
   case IRPosition::IRP_ARGUMENT:
   case IRPosition::IRP_FUNCTION:
   case IRPosition::IRP_RETURNED:
     Attrs = ScopeFn.getAttributes();
     break;
   case IRPosition::IRP_CALL_SITE_ARGUMENT:
-    Attrs = ImmutableCallSite(&getAnchorValue()).getAttributes();
+    Attrs = ImmutableCallSite(&IRP.getAnchorValue()).getAttributes();
     break;
   }
 
   for (const Attribute &Attr : DeducedAttrs) {
-    if (!addIfNotExistent(Ctx, Attr, Attrs, getAttrIdx()))
+    if (!addIfNotExistent(Ctx, Attr, Attrs, IRP.getAttrIdx()))
       continue;
 
     HasChanged = ChangeStatus::CHANGED;
     bookkeeping(PK, Attr);
   }
 
   if (HasChanged == ChangeStatus::UNCHANGED)
     return HasChanged;
 
   switch (PK) {
   case IRPosition::IRP_ARGUMENT:
   case IRPosition::IRP_FUNCTION:
   case IRPosition::IRP_RETURNED:
     ScopeFn.setAttributes(Attrs);
     break;
   case IRPosition::IRP_CALL_SITE_ARGUMENT:
-    CallSite(&getAnchorValue()).setAttributes(Attrs);
+    CallSite(&IRP.getAnchorValue()).setAttributes(Attrs);
   }
 
   return HasChanged;
 }
 
 /// -----------------------NoUnwind Function Attribute--------------------------
 
 struct AANoUnwindImpl : AANoUnwind, BooleanState {