Move implementation of isAssumeLikeIntrinsic into IntrinsicInst

[rampitec]

Summary

This is remove dependency on ValueTracking in the future patch.

[dexonsmith]

Not sure I'm the best person to review this, but I have a couple of drive-by questions.

llvm/include/llvm/IR/IntrinsicInst.h

104

Usually we'd have a default: break; or default: return false; if the switch isn't totally covered... is there a reason you removed it when moving the code?

llvm/lib/Analysis/ValueTracking.cpp

526

Should this FIXME be kept?

[rampitec]

llvm/include/llvm/IR/IntrinsicInst.h

104

Will add, thanks!

llvm/lib/Analysis/ValueTracking.cpp

526

I have checked, it is not relevant anymore. The list there is way longer now.

[rampitec]

Ping.

llvm/include/llvm/IR/IntrinsicInst.h

bool isCommutative() const {
     case Intrinsic::fma:
     case Intrinsic::fmuladd:
       return true;
     default:
       return false;
     }
   }
 
+  // Checks if the intrinsic is an annotation.
+  bool isAssumeLikeIntrinsic() const {
+    switch (getIntrinsicID()) {
+    case Intrinsic::assume:
+    case Intrinsic::sideeffect:
+    case Intrinsic::pseudoprobe:
+    case Intrinsic::dbg_declare:
+    case Intrinsic::dbg_value:
+    case Intrinsic::dbg_label:
+    case Intrinsic::invariant_start:
+    case Intrinsic::invariant_end:
+    case Intrinsic::lifetime_start:
+    case Intrinsic::lifetime_end:
+    case Intrinsic::experimental_noalias_scope_decl:
+    case Intrinsic::objectsize:
+    case Intrinsic::ptr_annotation:
+    case Intrinsic::var_annotation:
+      return true;
+    }
+    return false;
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const CallInst *I) {
     if (const Function *CF = I->getCalledFunction())
       return CF->isIntrinsic();
     return false;
   }
   static bool classof(const Value *V) {
     return isa<CallInst>(V) && classof(cast<CallInst>(V));

llvm/lib/Analysis/ValueTracking.cpp

while (!WorkSet.empty()) {
     }
   }
 
   return false;
 }
 
 // Is this an intrinsic that cannot be speculated but also cannot trap?
 bool llvm::isAssumeLikeIntrinsic(const Instruction *I) {
-  if (const CallInst *CI = dyn_cast<CallInst>(I))
-    if (Function *F = CI->getCalledFunction())
-      switch (F->getIntrinsicID()) {
-      default: break;
-      // FIXME: This list is repeated from NoTTI::getIntrinsicCost.
-      case Intrinsic::assume:
-      case Intrinsic::sideeffect:
-      case Intrinsic::pseudoprobe:
-      case Intrinsic::dbg_declare:
-      case Intrinsic::dbg_value:
-      case Intrinsic::dbg_label:
-      case Intrinsic::invariant_start:
-      case Intrinsic::invariant_end:
-      case Intrinsic::lifetime_start:
-      case Intrinsic::lifetime_end:
-      case Intrinsic::experimental_noalias_scope_decl:
-      case Intrinsic::objectsize:
-      case Intrinsic::ptr_annotation:
-      case Intrinsic::var_annotation:
-        return true;
-      }
+  if (const IntrinsicInst *CI = dyn_cast<IntrinsicInst>(I))
+    return CI->isAssumeLikeIntrinsic();
 
   return false;
 }
 
 bool llvm::isValidAssumeForContext(const Instruction *Inv,
                                    const Instruction *CxtI,
                                    const DominatorTree *DT) {
   // There are two restrictions on the use of an assume: