[FPEnv Core 10/14] Use Strict in IRBuilder

[sdmitrouk]

Summary

Try to create constant expression, but skip it in case of conflicts
with FPEnv access flags.

[sdmitrouk]

Reflect inversion of meaning of new fast-math flags.

[sdmitrouk]

Add comment for boolean argument in invocations.

[mehdi_amini]

unittests/IR/IRBuilderTest.cpp

224

Add a one-line comment like: Test that by default the IRBuilder does not constant fold floating-point operation that breaks the FP exceptions.

include/llvm/IR/IRBuilder.h

public:
   }
   Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
     return CreateAdd(LHS, RHS, Name, true, false);
   }
   Value *CreateFAdd(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
-        return Insert(Folder.CreateFAdd(LC, RC, FMF), Name);
+        if (Constant *C = Insert(Folder.CreateFAdd(LC, RC, FMF,
+                                                   /* Strict = */ true), Name))
+          return C;
     return Insert(AddFPMathAttributes(BinaryOperator::CreateFAdd(LHS, RHS),
                                       FPMathTag, FMF), Name);
   }
   Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
                    bool HasNUW = false, bool HasNSW = false) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
         return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
     return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
                                    HasNUW, HasNSW);
   }
   Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
     return CreateSub(LHS, RHS, Name, false, true);
   }
   Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
     return CreateSub(LHS, RHS, Name, true, false);
   }
   Value *CreateFSub(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
-        return Insert(Folder.CreateFSub(LC, RC, FMF), Name);
+        if (Constant *C = Insert(Folder.CreateFSub(LC, RC, FMF,
+                                                   /* Strict = */ true), Name))
+          return C;
     return Insert(AddFPMathAttributes(BinaryOperator::CreateFSub(LHS, RHS),
                                       FPMathTag, FMF), Name);
   }
   Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
                    bool HasNUW = false, bool HasNSW = false) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
         return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
     return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
                                    HasNUW, HasNSW);
   }
   Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
     return CreateMul(LHS, RHS, Name, false, true);
   }
   Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
     return CreateMul(LHS, RHS, Name, true, false);
   }
   Value *CreateFMul(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
-        return Insert(Folder.CreateFMul(LC, RC, FMF), Name);
+        if (Constant *C = Insert(Folder.CreateFMul(LC, RC, FMF,
+                                                   /* Strict = */ true), Name))
+          return C;
     return Insert(AddFPMathAttributes(BinaryOperator::CreateFMul(LHS, RHS),
                                       FPMathTag, FMF), Name);
   }
   Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
                     bool isExact = false) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
         return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
public:
   }
   Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
     return CreateSDiv(LHS, RHS, Name, true);
   }
   Value *CreateFDiv(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
-        return Insert(Folder.CreateFDiv(LC, RC, FMF), Name);
+        if (Constant *C = Insert(Folder.CreateFDiv(LC, RC, FMF,
+                                                   /* Strict = */ true), Name))
+          return C;
     return Insert(AddFPMathAttributes(BinaryOperator::CreateFDiv(LHS, RHS),
                                       FPMathTag, FMF), Name);
   }
   Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
         return Insert(Folder.CreateURem(LC, RC), Name);
     return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
   }
   Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
         return Insert(Folder.CreateSRem(LC, RC), Name);
     return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
   }
   Value *CreateFRem(Value *LHS, Value *RHS, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))
-        return Insert(Folder.CreateFRem(LC, RC, FMF), Name);
+        if (Constant *C = Insert(Folder.CreateFRem(LC, RC, FMF,
+                                                   /* Strict = */ true), Name))
+          return C;
     return Insert(AddFPMathAttributes(BinaryOperator::CreateFRem(LHS, RHS),
                                       FPMathTag, FMF), Name);
   }
 
   Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
                    bool HasNUW = false, bool HasNSW = false) {
     if (Constant *LC = dyn_cast<Constant>(LHS))
       if (Constant *RC = dyn_cast<Constant>(RHS))

unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, FastMathFlags) {
   FDiv->setHasAllowReciprocal(true);
   FAdd->setHasAllowReciprocal(false);
   FDiv->copyFastMathFlags(FAdd);
   EXPECT_TRUE(FDiv->hasNoNaNs());
   EXPECT_FALSE(FDiv->hasAllowReciprocal());
 
 }
 
+TEST_F(IRBuilderTest, FPEnvFlags) {
+  IRBuilder<> Builder(BB);
+  Value *F;
+
+  Constant *Huge = ConstantFP::get(Type::getDoubleTy(Ctx), 1.000000e+308);
+  Constant *Big = ConstantFP::get(Type::getDoubleTy(Ctx), 1.000000e+300);
+  Constant *Small = ConstantFP::get(Type::getDoubleTy(Ctx), 1.000000e-300);
+  Constant *Tiny = ConstantFP::get(Type::getDoubleTy(Ctx), 1.000000e-308);
+  Constant *Zero = ConstantFP::get(Type::getDoubleTy(Ctx), 0.0);
+
+  FastMathFlags KeepExceptions;
+  KeepExceptions.clear();
+  KeepExceptions.setNoRounding();
+  Builder.SetFastMathFlags(KeepExceptions);
+
+  F = Builder.CreateFAdd(Huge, Huge);
+  EXPECT_FALSE(isa<Constant>(F));
+
+  F = Builder.CreateFSub(Tiny, Huge);
+  EXPECT_FALSE(isa<Constant>(F));
+
+  F = Builder.CreateFMul(Big, Big);
+  EXPECT_FALSE(isa<Constant>(F));
+
+  F = Builder.CreateFDiv(Big, Small);
+  EXPECT_FALSE(isa<Constant>(F));
+
+  F = Builder.CreateFDiv(Big, Zero);
+  EXPECT_FALSE(isa<Constant>(F));
+
+  F = Builder.CreateFRem(Big, Zero);
+  EXPECT_FALSE(isa<Constant>(F));
+
+  FastMathFlags KeepRounding;
+  KeepRounding.clear();
+  KeepRounding.setNoExceptions();
+  Builder.SetFastMathFlags(KeepRounding);
+
+  F = Builder.CreateFAdd(Huge, Huge);
+  EXPECT_FALSE(isa<Constant>(F));
+
+  F = Builder.CreateFSub(Tiny, Huge);
+  EXPECT_FALSE(isa<Constant>(F));
+
+  F = Builder.CreateFMul(Huge, Huge);
+  EXPECT_FALSE(isa<Constant>(F));
+}
+
 TEST_F(IRBuilderTest, WrapFlags) {
   IRBuilder<true, NoFolder> Builder(BB);
 
   // Test instructions.
   GlobalVariable *G = new GlobalVariable(*M, Builder.getInt32Ty(), true,
                                          GlobalValue::ExternalLinkage, nullptr);
   Value *V = Builder.CreateLoad(G);
   EXPECT_TRUE(