Add constrained fadd to FP operationsusers/spavloff/fadd

Constrained intrinsics are treated as regular intrinsicss from the
perspective of FP operand bundle mechanism, meaning they can have FP
operand bundles. The FP bundle API functions will report properties
based on the operand bundles rather than metadata arguments.

These hybrid entities are temporary objects that exist while both
alternative mechanisms remain available. Nevertheless, they can be
useful for development:

* They can represent FP instructions with bundles. For example, while
  there is currently no intrinsic that directly represents 'fadd'
  instruction (and bundles cannot be attached to a plain 'fadd' since it
  is not a call), a corresponding constrained intrinsic call can
  represent the operation while still carrying operand bundles.

* Constrained intrinsic with bundles can be assigned properties that
  otherwise cannot be expressed, such as denormal behavior.

This change adds 'experimental.constrained.fadd' to the list of FP
operations, enabling creation of tests for denormal behavior. It also
modifies methods `getRoundingMode` and `getExceptionBehavior` so that
they report information from metadata arguments if bundles are absent.
This adjustment should help incorporating constrained intrinsics into
algorithms based on operand bundles.

1 files changed, 65 insertions, 0 deletions

diff --git a/llvm/unittests/IR/IRBuilderTest.cpp b/llvm/unittests/IR/IRBuilderTest.cpp
index 48a76c9..660dc45 100644
--- a/llvm/unittests/IR/IRBuilderTest.cpp
+++ b/llvm/unittests/IR/IRBuilderTest.cpp
@@ -662,6 +662,71 @@ TEST_F(IRBuilderTest, FPBundlesStrict) {
   }
 }
 
+TEST_F(IRBuilderTest, FPBundlesConstrained) {
+  F->addFnAttr(Attribute::StrictFP);
+
+  IRBuilder<> Builder(BB);
+  LLVMContext &Context = Builder.getContext();
+  Builder.setDefaultConstrainedExcept(fp::ebStrict);
+  Builder.setDefaultConstrainedRounding(RoundingMode::TowardZero);
+  Builder.setIsFPConstrained(true);
+
+  GlobalVariable *GVDouble = new GlobalVariable(
+      *M, Type::getDoubleTy(Ctx), true, GlobalValue::ExternalLinkage, nullptr);
+  Value *FnArg = Builder.CreateLoad(GVDouble->getValueType(), GVDouble);
+  Function *Fn = Intrinsic::getOrInsertDeclaration(
+      M.get(), Intrinsic::experimental_constrained_fadd,
+      {Type::getDoubleTy(Ctx)});
+
+  const auto createConstrainedRounding = [&](RoundingMode RM) {
+    std::optional<StringRef> RoundingStr = convertRoundingModeToStr(RM);
+    assert(RoundingStr);
+    auto *RoundingMDS = MDString::get(Context, *RoundingStr);
+    return MetadataAsValue::get(Context, RoundingMDS);
+  };
+  const auto createConstrainedExcept = [&](fp::ExceptionBehavior EB) {
+    std::optional<StringRef> ExceptStr = convertExceptionBehaviorToStr(EB);
+    assert(ExceptStr);
+    auto *ExceptMDS = MDString::get(Context, *ExceptStr);
+    return MetadataAsValue::get(Context, ExceptMDS);
+  };
+
+  // Constrained function call without bundles.
+  {
+    Value *V = Builder.CreateFAdd(FnArg, FnArg);
+    auto *I = cast<IntrinsicInst>(V);
+    EXPECT_FALSE(I->getOperandBundle(LLVMContext::OB_fp_control).has_value());
+    EXPECT_FALSE(I->getOperandBundle(LLVMContext::OB_fp_except).has_value());
+    EXPECT_EQ(Intrinsic::experimental_constrained_fadd, I->getIntrinsicID());
+    EXPECT_EQ(RoundingMode::TowardZero, I->getRoundingMode());
+    EXPECT_EQ(fp::ebStrict, I->getExceptionBehavior());
+    MemoryEffects ME = I->getMemoryEffects();
+    EXPECT_TRUE(ME.doesAccessInaccessibleMem());
+  }
+
+  // Operand bundles have precedence over constrained intrinsic metadata
+  // arguments.
+  {
+    SmallVector<OperandBundleDef, 1> Bundles;
+    llvm::addFPRoundingBundle(Ctx, Bundles, RoundingMode::TowardNegative);
+    llvm::addFPExceptionBundle(Ctx, Bundles, fp::ebIgnore);
+    Value *V = Builder.CreateCall(
+        Fn,
+        {FnArg, FnArg, createConstrainedRounding(RoundingMode::TowardZero),
+         createConstrainedExcept(fp::ebStrict)},
+        Bundles);
+
+    auto *I = cast<IntrinsicInst>(V);
+    EXPECT_TRUE(I->getOperandBundle(LLVMContext::OB_fp_control).has_value());
+    EXPECT_TRUE(I->getOperandBundle(LLVMContext::OB_fp_except).has_value());
+    EXPECT_EQ(Intrinsic::experimental_constrained_fadd, I->getIntrinsicID());
+    EXPECT_EQ(RoundingMode::TowardNegative, I->getRoundingMode());
+    EXPECT_EQ(fp::ebIgnore, I->getExceptionBehavior());
+    MemoryEffects ME = I->getMemoryEffects();
+    EXPECT_TRUE(ME.doesAccessInaccessibleMem());
+  }
+}
+
 TEST_F(IRBuilderTest, Lifetime) {
   IRBuilder<> Builder(BB);
   AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());