[IR] Reimplement FPMathOperator::classof as a whitelist.

[foad]

Summary

This makes it much easier to verify that the implementation matches the
documentation. It uncovered a bug in the unit tests where we were
accidentally setting fast math flags on a load instruction.

[spatel]

LGTM

llvm/include/llvm/IR/Operator.h

static bool classof(const Value *V) {
     if (auto *I = dyn_cast<Instruction>(V))
       Opcode = I->getOpcode();
     else if (auto *CE = dyn_cast<ConstantExpr>(V))
       Opcode = CE->getOpcode();
     else
       return false;
 
     switch (Opcode) {
+    case Instruction::FNeg:
+    case Instruction::FAdd:
+    case Instruction::FSub:
+    case Instruction::FMul:
+    case Instruction::FDiv:
+    case Instruction::FRem:
     // FIXME: To clean up and correct the semantics of fast-math-flags, FCmp
     //        should not be treated as a math op, but the other opcodes should.
     //        This would make things consistent with Select/PHI (FP value type
     //        determines whether they are math ops and, therefore, capable of
     //        having fast-math-flags).
     case Instruction::FCmp:
       return true;
-    // non math FP Operators (no FMF)
-    case Instruction::ExtractElement:
-    case Instruction::ShuffleVector:
-    case Instruction::InsertElement:
-      return false;
-    default:
+    case Instruction::PHI:
+    case Instruction::Select:
+    case Instruction::Call:
       return V->getType()->isFPOrFPVectorTy();
+    default:
+      return false;
     }
   }
 };
 
 /// A helper template for defining operators for individual opcodes.
 template<typename SuperClass, unsigned Opc>
 class ConcreteOperator : public SuperClass {
 public:

llvm/unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, UnaryOperators) {
   // Test CreateUnOp(X)
   Value *U = Builder.CreateUnOp(Instruction::FNeg, V);
   ASSERT_TRUE(isa<Instruction>(U));
   ASSERT_TRUE(isa<FPMathOperator>(U));
   ASSERT_TRUE(isa<UnaryOperator>(U));
   ASSERT_FALSE(isa<BinaryOperator>(U));
 
   // Test CreateFNegFMF(X)
-  Instruction *I = cast<Instruction>(V);
+  Instruction *I = cast<Instruction>(U);
   I->setHasNoSignedZeros(true);
   I->setHasNoNaNs(true);
   Value *VFMF = Builder.CreateFNegFMF(V, I);
   Instruction *IFMF = cast<Instruction>(VFMF);
   EXPECT_TRUE(IFMF->hasNoSignedZeros());
   EXPECT_TRUE(IFMF->hasNoNaNs());
   EXPECT_FALSE(IFMF->hasAllowReassoc());
 }