[Instruction] Split out 'and' of non-poison generating flags (NFC).

[fhahn]

Summary

This patch moves the code to perform a logical and of non-poison
generating flags out to a separate helper, to be used in D115247.

[reames]

Per LangRef, nnan and ninf are poison generating. The handling on the other FMF flags is unclear to me, but looking at the use case, I'd probably restrict to non-float as a starting point,

llvm/include/llvm/IR/Instruction.h

public:
   /// Convenience method to copy supported exact, fast-math, and (optionally)
   /// wrapping flags from V to this instruction.
   void copyIRFlags(const Value *V, bool IncludeWrapFlags = true);
 
   /// Logical 'and' of any supported wrapping, exact, and fast-math flags of
   /// V and this instruction.
   void andIRFlags(const Value *V);
 
+  /// Logical 'and' of non poison generating flags, like fast-math flags, of
+  /// V and this instruction.
+  void andNonPoisonGeneratingIRFlags(const Value *V);
+
   /// Merge 2 debug locations and apply it to the Instruction. If the
   /// instruction is a CallIns, we need to traverse the inline chain to find
   /// the common scope. This is not efficient for N-way merging as each time
   /// you merge 2 iterations, you need to rebuild the hashmap to find the
   /// common scope. However, we still choose this API because:
   ///  1) Simplicity: it takes 2 locations instead of a list of locations.
   ///  2) In worst case, it increases the complexity from O(N*I) to
   ///     O(2*N*I), where N is # of Instructions to merge, and I is the

llvm/lib/IR/Instruction.cpp

if (auto *FP = dyn_cast<FPMathOperator>(V))
     if (isa<FPMathOperator>(this))
       copyFastMathFlags(FP->getFastMathFlags());
 
   if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
     if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
       DestGEP->setIsInBounds(SrcGEP->isInBounds() || DestGEP->isInBounds());
 }
 
+void Instruction::andNonPoisonGeneratingIRFlags(const Value *V) {
+  if (auto *FP = dyn_cast<FPMathOperator>(V)) {
+    if (isa<FPMathOperator>(this)) {
+      FastMathFlags FM = getFastMathFlags();
+      FM &= FP->getFastMathFlags();
+      copyFastMathFlags(FM);
+    }
+  }
+}
+
 void Instruction::andIRFlags(const Value *V) {
   if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
     if (isa<OverflowingBinaryOperator>(this)) {
       setHasNoSignedWrap(hasNoSignedWrap() && OB->hasNoSignedWrap());
       setHasNoUnsignedWrap(hasNoUnsignedWrap() && OB->hasNoUnsignedWrap());
     }
   }
 
   if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
     if (isa<PossiblyExactOperator>(this))
       setIsExact(isExact() && PE->isExact());
 
-  if (auto *FP = dyn_cast<FPMathOperator>(V)) {
-    if (isa<FPMathOperator>(this)) {
-      FastMathFlags FM = getFastMathFlags();
-      FM &= FP->getFastMathFlags();
-      copyFastMathFlags(FM);
-    }
-  }
-
   if (auto *SrcGEP = dyn_cast<GetElementPtrInst>(V))
     if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
       DestGEP->setIsInBounds(SrcGEP->isInBounds() && DestGEP->isInBounds());
+
+  andNonPoisonGeneratingIRFlags(V);
 }
 
 const char *Instruction::getOpcodeName(unsigned OpCode) {
   switch (OpCode) {
   // Terminators
   case Ret:    return "ret";
   case Br:     return "br";
   case Switch: return "switch";