[Attributor] Add all missing attribute definitions/symbols

[jdoerfert]

Summary

As a preparation to "on-demand" abstract attribute generation we need
implementations for all attributes (as they can be queried and then
created on-demand where we now fail to find one).

[uenoku]

LGTM

[jdoerfert]

Make it not WillReturn specific but add all missing attributes

[jdoerfert]

I added all missing attribute symbols now

[jdoerfert]

minor update

[uenoku]

LGTM

llvm/lib/Transforms/IPO/Attributor.cpp

static bool containsCycle(Function &F) {
   }
   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.
-static bool containsPossiblyEndlessLoop(Function &F) {
-  return containsCycle(F);
+static bool containsPossiblyEndlessLoop(Function *F) {
+  return !F || !F->hasExactDefinition() || 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";
-  }
-};
-
-struct AAWillReturnFunction final : AAWillReturnImpl {
-  AAWillReturnFunction(const IRPosition &IRP) : AAWillReturnImpl(IRP) {}
-
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
-    Function &F = *getAnchorScope();
+    if (hasAttr({Attribute::WillReturn})) {
+      indicateOptimisticFixpoint();
+      return;
+    }
 
+    Function *F = getAssociatedFunction();
     if (containsPossiblyEndlessLoop(F))
       indicatePessimisticFixpoint();
   }
 
   /// 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::getAsStr()
+  const std::string getAsStr() const override {
+    return getAssumed() ? "willreturn" : "may-noreturn";
+  }
+};
+
+struct AAWillReturnFunction final : AAWillReturnImpl {
+  AAWillReturnFunction(const IRPosition &IRP) : AAWillReturnImpl(IRP) {}
+
   /// See AbstractAttribute::trackStatistics()
-  void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(norecurse) }
+  void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(willreturn) }
 };
 
-/// WillReturn attribute deduction for a call sites.
-using AAWillReturnCallSite = AAWillReturnFunction;
+struct AAWillReturnCallSite final : AAWillReturnImpl {
+  AAWillReturnCallSite(const IRPosition &IRP) : AAWillReturnImpl(IRP) {}
+
+  /// See AbstractAttribute::trackStatistics()
+  void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(willreturn) }
+};
 
 /// ------------------------ NoAlias Argument Attribute ------------------------
 
 struct AANoAliasImpl : AANoAlias {
   AANoAliasImpl(const IRPosition &IRP) : AANoAlias(IRP) {}
 
   const std::string getAsStr() const override {
     return getAssumed() ? "noalias" : "may-alias";