[Attributor] Introduce initialize calls and move code to keep attributes concise

[jdoerfert]

Summary

This patch should not change the behavior except that the added
initialize methods might indicate an optimistic fixpoint earlier. The
code movement is done to keep the attribute definitions in a single
block where it makes sense. No functional changes intended there.

[sstefan1]

LGTM

llvm/lib/Transforms/IPO/Attributor.cpp

void IRPosition::verify() {
   }
 }
 
 /// -----------------------NoUnwind Function Attribute--------------------------
 
 struct AANoUnwindImpl : AANoUnwind {
   AANoUnwindImpl(const IRPosition &IRP) : AANoUnwind(IRP) {}
 
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    if (hasAttr({Attribute::NoUnwind}))
+      indicateOptimisticFixpoint();
+  }
+
   const std::string getAsStr() const override {
     return getAssumed() ? "nounwind" : "may-unwind";
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
-};
-
-struct AANoUnwindFunction final : public AANoUnwindImpl {
-  AANoUnwindFunction(const IRPosition &IRP) : AANoUnwindImpl(IRP) {}
-
-  /// See AbstractAttribute::trackStatistics()
-  void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nounwind) }
-};
-
-ChangeStatus AANoUnwindImpl::updateImpl(Attributor &A) {
-
-  // The map from instruction opcodes to those instructions in the function.
+  ChangeStatus updateImpl(Attributor &A) override {
     auto Opcodes = {
         (unsigned)Instruction::Invoke,      (unsigned)Instruction::CallBr,
         (unsigned)Instruction::Call,        (unsigned)Instruction::CleanupRet,
         (unsigned)Instruction::CatchSwitch, (unsigned)Instruction::Resume};
 
     auto CheckForNoUnwind = [&](Instruction &I) {
       if (!I.mayThrow())
         return true;
 
       auto *NoUnwindAA = A.getAAFor<AANoUnwind>(*this, IRPosition::value(I));
       return NoUnwindAA && NoUnwindAA->isAssumedNoUnwind();
     };
 
     if (!A.checkForAllInstructions(CheckForNoUnwind, *this, Opcodes))
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
+};
+
+struct AANoUnwindFunction final : public AANoUnwindImpl {
+  AANoUnwindFunction(const IRPosition &IRP) : AANoUnwindImpl(IRP) {}
+
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nounwind) }
+};
 
 /// --------------------- Function Return Values -------------------------------
 
 /// "Attribute" that collects all potential returned values and the return
 /// instructions that they arise from.
 ///
 /// If there is a unique returned value R, the manifest method will:
 ///   - mark R with the "returned" attribute, if R is an argument.
struct AAReturnedValuesFunction final : public AAReturnedValuesImpl {
   void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(returned) }
 };
 
 /// ------------------------ NoSync Function Attribute -------------------------
 
 struct AANoSyncImpl : AANoSync {
   AANoSyncImpl(const IRPosition &IRP) : AANoSync(IRP) {}
 
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    if (hasAttr({Attribute::NoSync}))
+      indicateOptimisticFixpoint();
+  }
+
   const std::string getAsStr() const override {
     return getAssumed() ? "nosync" : "may-sync";
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override;
 
   /// Helper function used to determine whether an instruction is non-relaxed
ChangeStatus AANoSyncImpl::updateImpl(Attributor &A) {
   return ChangeStatus::UNCHANGED;
 }
 
 /// ------------------------ No-Free Attributes ----------------------------
 
 struct AANoFreeImpl : public AANoFree {
   AANoFreeImpl(const IRPosition &IRP) : AANoFree(IRP) {}
 
-  /// See AbstractAttribute::getAsStr().
-  const std::string getAsStr() const override {
-    return getAssumed() ? "nofree" : "may-free";
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    if (hasAttr({Attribute::NoFree}))
+      indicateOptimisticFixpoint();
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
-};
-
-struct AANoFreeFunction final : public AANoFreeImpl {
-  AANoFreeFunction(const IRPosition &IRP) : AANoFreeImpl(IRP) {}
-
-  /// See AbstractAttribute::trackStatistics()
-  void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nofree) }
-};
-
-ChangeStatus AANoFreeImpl::updateImpl(Attributor &A) {
-
+  ChangeStatus updateImpl(Attributor &A) override {
     auto CheckForNoFree = [&](Instruction &I) {
       ImmutableCallSite ICS(&I);
       if (ICS.hasFnAttr(Attribute::NoFree))
         return true;
 
       auto *NoFreeAA =
           A.getAAFor<AANoFreeImpl>(*this, IRPosition::callsite_function(ICS));
       return NoFreeAA && NoFreeAA->isAssumedNoFree();
     };
 
     if (!A.checkForAllCallLikeInstructions(CheckForNoFree, *this))
       return indicatePessimisticFixpoint();
     return ChangeStatus::UNCHANGED;
   }
 
+  /// See AbstractAttribute::getAsStr().
+  const std::string getAsStr() const override {
+    return getAssumed() ? "nofree" : "may-free";
+  }
+};
+
+struct AANoFreeFunction final : public AANoFreeImpl {
+  AANoFreeFunction(const IRPosition &IRP) : AANoFreeImpl(IRP) {}
+
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nofree) }
+};
+
 /// ------------------------ NonNull Argument Attribute ------------------------
 struct AANonNullImpl : AANonNull {
   AANonNullImpl(const IRPosition &IRP) : AANonNull(IRP) {}
 
   /// See AbstractAttribute::getAsStr().
   const std::string getAsStr() const override {
     return getAssumed() ? "nonnull" : "may-null";
   }
AANonNullImpl::generatePredicate(Attributor &A) {
   return Pred;
 }
 
 /// NonNull attribute for function return value.
 struct AANonNullReturned final : AANonNullImpl {
   AANonNullReturned(const IRPosition &IRP) : AANonNullImpl(IRP) {}
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
-
-  /// See AbstractAttribute::trackStatistics()
-  void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(nonnull) }
-};
-
-ChangeStatus AANonNullReturned::updateImpl(Attributor &A) {
-
+  ChangeStatus updateImpl(Attributor &A) override {
     std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> Pred =
         this->generatePredicate(A);
 
     if (!A.checkForAllReturnedValuesAndReturnInsts(Pred, *this))
       return indicatePessimisticFixpoint();
     return ChangeStatus::UNCHANGED;
   }
 
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(nonnull) }
+};
+
 /// NonNull attribute for function argument.
 struct AANonNullArgument final : AANonNullImpl {
   AANonNullArgument(const IRPosition &IRP) : AANonNullImpl(IRP) {}
 
   /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
-
-  /// See AbstractAttribute::trackStatistics()
-  void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nonnull) }
-};
-
-/// NonNull attribute for a call site argument.
-struct AANonNullCallSiteArgument final : AANonNullImpl {
-  AANonNullCallSiteArgument(const IRPosition &IRP) : AANonNullImpl(IRP) {}
-
-  /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override {
-    AANonNullImpl::initialize(A);
-    if (!isKnownNonNull() &&
-        isKnownNonZero(&getAssociatedValue(), A.getDataLayout()))
-      indicateOptimisticFixpoint();
-  }
-
-  /// See AbstractAttribute::updateImpl(Attributor &A).
-  ChangeStatus updateImpl(Attributor &A) override;
-
-  /// See AbstractAttribute::trackStatistics()
-  void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(nonnull) }
-};
-
-ChangeStatus AANonNullArgument::updateImpl(Attributor &A) {
+  ChangeStatus updateImpl(Attributor &A) override {
     unsigned ArgNo = getArgNo();
 
     // Callback function
     std::function<bool(CallSite)> CallSiteCheck = [&](CallSite CS) {
       assert(CS && "Sanity check: Call site was not initialized properly!");
 
       IRPosition CSArgPos = IRPosition::callsite_argument(CS, ArgNo);
       if (CSArgPos.hasAttr({Attribute::NonNull, Attribute::Dereferenceable}))
         return true;
 
       // Check that NonNullAA is AANonNullCallSiteArgument.
       if (auto *NonNullAA = A.getAAFor<AANonNullImpl>(*this, CSArgPos)) {
         ImmutableCallSite ICS(&NonNullAA->getAnchorValue());
         if (ICS && CS.getInstruction() == ICS.getInstruction())
           return NonNullAA->isAssumedNonNull();
         return false;
       }
 
       Value *V = CS.getArgOperand(ArgNo);
       if (isKnownNonZero(V, A.getDataLayout()))
         return true;
 
       return false;
     };
     if (!A.checkForAllCallSites(CallSiteCheck, *this, true))
       return indicatePessimisticFixpoint();
     return ChangeStatus::UNCHANGED;
   }
 
-ChangeStatus AANonNullCallSiteArgument::updateImpl(Attributor &A) {
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nonnull) }
+};
+
+/// NonNull attribute for a call site argument.
+struct AANonNullCallSiteArgument final : AANonNullImpl {
+  AANonNullCallSiteArgument(const IRPosition &IRP) : AANonNullImpl(IRP) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    AANonNullImpl::initialize(A);
+    if (!isKnownNonNull() &&
+        isKnownNonZero(&getAssociatedValue(), A.getDataLayout()))
+      indicateOptimisticFixpoint();
+  }
+
+  /// See AbstractAttribute::updateImpl(Attributor &A).
+  ChangeStatus updateImpl(Attributor &A) override {
     // NOTE: Never look at the argument of the callee in this method.
-  //       If we do this, "nonnull" is always deduced because of the assumption.
+    //       If we do this, "nonnull" is always deduced because of the
+    //       assumption.
 
     Value &V = getAssociatedValue();
     auto *NonNullAA = A.getAAFor<AANonNull>(*this, IRPosition::value(V));
 
     if (!NonNullAA || !NonNullAA->isAssumedNonNull())
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
 
-/// ------------------------ Will-Return Attributes ----------------------------
-
-struct AAWillReturnImpl : public AAWillReturn {
-  AAWillReturnImpl(const IRPosition &IRP) : AAWillReturn(IRP) {}
-
-  /// See AbstractAttribute::getAsStr()
-  const std::string getAsStr() const override {
-    return getAssumed() ? "willreturn" : "may-noreturn";
-  }
-};
-
-struct AAWillReturnFunction final : AAWillReturnImpl {
-  AAWillReturnFunction(const IRPosition &IRP) : AAWillReturnImpl(IRP) {}
-
-  /// See AbstractAttribute::initialize(...).
-  void initialize(Attributor &A) override;
-
-  /// See AbstractAttribute::updateImpl(...).
-  ChangeStatus updateImpl(Attributor &A) override;
-
   /// See AbstractAttribute::trackStatistics()
-  void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(norecurse) }
+  void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(nonnull) }
 };
 
+/// ------------------------ Will-Return Attributes ----------------------------
+
 // Helper function that checks whether a function has any cycle.
 // TODO: Replace with more efficent code
-bool containsCycle(Function &F) {
+static bool containsCycle(Function &F) {
   SmallPtrSet<BasicBlock *, 32> Visited;
 
   // Traverse BB by dfs and check whether successor is already visited.
   for (BasicBlock *BB : depth_first(&F)) {
     Visited.insert(BB);
     for (auto *SuccBB : successors(BB)) {
       if (Visited.count(SuccBB))
         return true;
     }
   }
   return false;
 }
 
 // Helper function that checks the function have a loop which might become an
 // endless loop
 // FIXME: Any cycle is regarded as endless loop for now.
 //        We have to allow some patterns.
-bool containsPossiblyEndlessLoop(Function &F) { return containsCycle(F); }
+static bool containsPossiblyEndlessLoop(Function &F) {
+  return containsCycle(F);
+}
+
+struct AAWillReturnImpl : public AAWillReturn {
+  AAWillReturnImpl(const IRPosition &IRP) : AAWillReturn(IRP) {}
+
+  /// See AbstractAttribute::getAsStr()
+  const std::string getAsStr() const override {
+    return getAssumed() ? "willreturn" : "may-noreturn";
+  }
+};
 
-void AAWillReturnFunction::initialize(Attributor &A) {
+struct AAWillReturnFunction final : AAWillReturnImpl {
+  AAWillReturnFunction(const IRPosition &IRP) : AAWillReturnImpl(IRP) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
     Function &F = *getAnchorScope();
 
     if (containsPossiblyEndlessLoop(F))
       indicatePessimisticFixpoint();
   }
 
-ChangeStatus AAWillReturnFunction::updateImpl(Attributor &A) {
+  /// See AbstractAttribute::updateImpl(...).
+  ChangeStatus updateImpl(Attributor &A) override {
     // The map from instruction opcodes to those instructions in the function.
 
     auto CheckForWillReturn = [&](Instruction &I) {
       ImmutableCallSite ICS(&I);
       if (ICS.hasFnAttr(Attribute::WillReturn))
         return true;
 
       IRPosition IPos = IRPosition::callsite_function(ICS);
       auto *WillReturnAA = A.getAAFor<AAWillReturn>(*this, IPos);
       if (!WillReturnAA || !WillReturnAA->isAssumedWillReturn())
         return false;
 
       // FIXME: Prohibit any recursion for now.
       if (ICS.hasFnAttr(Attribute::NoRecurse))
         return true;
 
       auto *NoRecurseAA = A.getAAFor<AANoRecurse>(*this, IPos);
       return NoRecurseAA && NoRecurseAA->isAssumedNoRecurse();
     };
 
     if (!A.checkForAllCallLikeInstructions(CheckForWillReturn, *this))
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
 
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(norecurse) }
+};
+
 /// ------------------------ NoAlias Argument Attribute ------------------------
 
 struct AANoAliasImpl : AANoAlias {
   AANoAliasImpl(const IRPosition &IRP) : AANoAlias(IRP) {}
 
   const std::string getAsStr() const override {
     return getAssumed() ? "noalias" : "may-alias";
   }
void initialize(Attributor &A) override {
     // Already noalias.
     if (F.returnDoesNotAlias()) {
       indicateOptimisticFixpoint();
       return;
     }
   }
 
   /// See AbstractAttribute::updateImpl(...).
-  virtual ChangeStatus updateImpl(Attributor &A) override;
-
-  /// See AbstractAttribute::trackStatistics()
-  void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(noalias) }
-};
-
-ChangeStatus AANoAliasReturned::updateImpl(Attributor &A) {
+  virtual ChangeStatus updateImpl(Attributor &A) override {
 
     auto CheckReturnValue = [&](Value &RV) -> bool {
       if (Constant *C = dyn_cast<Constant>(&RV))
         if (C->isNullValue() || isa<UndefValue>(C))
           return true;
 
       /// For now, we can only deduce noalias if we have call sites.
       /// FIXME: add more support.
       ImmutableCallSite ICS(&RV);
       if (!ICS)
         return false;
 
       if (!ICS.returnDoesNotAlias()) {
         auto *NoAliasAA =
             A.getAAFor<AANoAlias>(*this, IRPosition::callsite_returned(ICS));
         if (!NoAliasAA || !NoAliasAA->isAssumedNoAlias())
           return false;
       }
 
       /// FIXME: We can improve capture check in two ways:
       /// 1. Use the AANoCapture facilities.
       /// 2. Use the location of return insts for escape queries.
       if (PointerMayBeCaptured(&RV, /* ReturnCaptures */ false,
                                /* StoreCaptures */ true))
         return false;
 
       return true;
     };
 
     if (!A.checkForAllReturnedValues(CheckReturnValue, *this))
       return indicatePessimisticFixpoint();
 
     return ChangeStatus::UNCHANGED;
   }
 
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(noalias) }
+};
+
 /// -------------------AAIsDead Function Attribute-----------------------
 
 struct AAIsDeadImpl : public AAIsDead {
   AAIsDeadImpl(const IRPosition &IRP) : AAIsDead(IRP) {}
 
   void initialize(Attributor &A) override {
     const Function &F = *getAnchorScope();