Mapping of FP operations to constrained intrinsics

[sepavloff]

Summary

This change adds new function 'getConstainedIntrinsic', which for any
gived instruction returns corresponding constrained intrinsic, if the
instruction involves floating point operation. For other instructions,
including constrained intrinsics the function returns zero.

[sepavloff]

Fixed typo

[kpn]

The IRBuilder handles mapping non-constrained operations to constrained operations already. So a front-end just needs to enable strict mode in the IRBuilder and most everything "just works". And clang uses the IRBuilder, so we're good there. Are you working on a front-end that doesn't use the IRBuilder?

[kpn]

llvm/lib/IR/FloatingPoint.cpp

170 ↗

(On Diff #227057)

Can you please update docs/AddingConstrainedIntrics.rst as well? When new intrinsics are added this switch here would need to be updated as well. Might as well document that fact.

[sepavloff]

In D69562#1732337, @kpn wrote:

The IRBuilder handles mapping non-constrained operations to constrained operations already. So a front-end just needs to enable strict mode in the IRBuilder and most everything "just works". And clang uses the IRBuilder, so we're good there. Are you working on a front-end that doesn't use the IRBuilder?

In the inliner (D69798) we need to know if we need to use constrained intrinsic prior to the instruction creation. Besides, instruction there are created without operands. So IRBuilder is not suitable in this case.

llvm/lib/IR/FloatingPoint.cpp

170 ↗

(On Diff #227057)

Depending on whether D69887 will be accepted or not, the wording would be different. I will update the doc when things become definite.

[kpn]

llvm/lib/IR/FloatingPoint.cpp

81 ↗

(On Diff #227057)

For something that's not part of a class, shouldn't it have a more specific name? Maybe getConstrainedIntrinsicID()?

[kpn]

llvm/lib/IR/FloatingPoint.cpp

81 ↗

(On Diff #227057)

Eh, scratch half of that comment, but I do still prefer the more specific name "getConstrainedIntrinsicID".

[arsenm]

llvm/lib/IR/FloatingPoint.cpp

85 ↗

(On Diff #227057)

I would prefer direct returns rather than variable assign and break

172 ↗

(On Diff #227057)

I think this should assert or something on unhandled target intrinsics. Right now it will just return then original ID which is probably not expected

172 ↗

(On Diff #227057)

Nevermind, I can't read. It will return not_intrinsic although I still think this is a possible source of error

llvm/unittests/IR/InstructionsTest.cpp

436–437

EXPECT_EQ

[kpn]

llvm/lib/IR/FloatingPoint.cpp

172 ↗

(On Diff #227057)

Honestly, I agree that this being a possible source of error. But I'm not sure we have an easy check that callers can make to find out if they should be calling this function in the first place. Without an easy check we're left with calling this function and checking the return value.

[sepavloff]

Updated patch

• Renamed getConstrainedIntrinsic to getConstrainedIntrinsicID.
• Implementwd mapping using fix from D69887.
• Used EXPECT_EQ instead of EXPECT_TRUE in unit test.

[sepavloff]

llvm/lib/IR/FloatingPoint.cpp

85 ↗

(On Diff #227057)

Single exit point has advantages. For instance we could set a watch in debugger on return statement and filter interesting cases.

172 ↗

(On Diff #227057)

This function must work correctly if Instr does not represent floating point operation. This property is mentioned in the function documentation. It is used in Inliner (D69798) to check if current instruction requires replacement with constrained intrinsic or may be processed with clone method.

[sepavloff]

Rebased patch

[sepavloff]

Updated patch

[sepavloff]

Rebase plus cosmetic changes

[andrew.w.kaylor]

This looks good. I have just a couple of minor nits.

llvm/include/llvm/IR/FPEnv.h

77

llvm/lib/IR/FPEnv.cpp

84

It may be worth having a comment here to explain why FCmp is handled separately.

[sepavloff]

Addressed reviewer's notes

[sepavloff]

Thanks!

llvm/include/llvm/IR/FPEnv.h

 #define LLVM_IR_FLOATINGPOINT_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include <stdint.h>
 
 namespace llvm {
 
+namespace Intrinsic {
+enum ID : unsigned;
+}
+
+class Instruction;
+
 namespace fp {
 
 /// Rounding mode used for floating point operations.
 ///
 /// Each of these values correspond to some metadata argument value of a
 /// constrained floating point intrinsic. See the LLVM Language Reference Manual
 /// for details.
 enum RoundingMode : uint8_t {

 /// Returns a valid ExceptionBehavior enumerator when given a string
 /// valid as input in constrained intrinsic exception behavior metadata.
 Optional<fp::ExceptionBehavior> StrToExceptionBehavior(StringRef);
 
 /// For any ExceptionBehavior enumerator, returns a string valid as
 /// input in constrained intrinsic exception behavior metadata.
 Optional<StringRef> ExceptionBehaviorToStr(fp::ExceptionBehavior);
 
+/// Returns constrained intrinsic id to represent the source instruction, if
+/// it involves floating point operations. If the instruction is already a
+/// constrained intrinsic or does not involve floating point operations, the
+/// function returns zero.
+Intrinsic::ID getConstrainedIntrinsicID(const Instruction &Instr);
+
 }
 #endif

llvm/lib/IR/FPEnv.cpp

 //===-- FPEnv.cpp ---- FP Environment -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 /// @file
 /// This file contains the implementations of entities that describe floating
 /// point environment.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/IR/FPEnv.h"
+#include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/IntrinsicInst.h"
 
 namespace llvm {
 
 Optional<fp::RoundingMode> StrToRoundingMode(StringRef RoundingArg) {
   // For dynamic rounding mode, we use round to nearest but we will set the
   // 'exact' SDNodeFlag so that the value will not be rounded.
   return StringSwitch<Optional<fp::RoundingMode>>(RoundingArg)
       .Case("round.dynamic", fp::rmDynamic)
case fp::ebIgnore:
     break;
   case fp::ebMayTrap:
     ExceptStr = "fpexcept.maytrap";
     break;
   }
   return ExceptStr;
 }
 
+Intrinsic::ID getConstrainedIntrinsicID(const Instruction &Instr) {
+  Intrinsic::ID IID = Intrinsic::not_intrinsic;
+  switch (Instr.getOpcode()) {
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                   \
+  case Instruction::NAME:                                                      \
+    IID = Intrinsic::INTRINSIC;                                                \
+    break;
+#define FUNCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)
+#include "llvm/IR/ConstrainedOps.def"
+  case Instruction::Call:
+    if (auto *IntrinCall = dyn_cast<IntrinsicInst>(&Instr)) {
+      switch (IntrinCall->getIntrinsicID()) {
+#define FUNCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)                      \
+      case Intrinsic::NAME:                                                    \
+        IID = Intrinsic::INTRINSIC;                                            \
+        break;
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)
+#include "llvm/IR/ConstrainedOps.def"
+      default:
+        break;
+      }
+    }
+    break;
+  default:
+    break;
+  }
+
+  return IID;
+}
+
 }
 No newline at end of file

llvm/unittests/IR/InstructionsTest.cpp

 //===- llvm/unittest/IR/InstructionsTest.cpp - Instructions unit tests ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/NoFolder.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/SourceMgr.h"
TEST(InstructionsTest, FPMathOperator) {
   Value *V1 = Builder.CreateFAdd(I, I, "", MD1);
   EXPECT_TRUE(isa<FPMathOperator>(V1));
   FPMathOperator *O1 = cast<FPMathOperator>(V1);
   EXPECT_EQ(O1->getFPAccuracy(), 1.0);
   V1->deleteValue();
   I->deleteValue();
 }
 
+TEST(InstructionTest, ConstrainedTrans) {
+  LLVMContext Context;
+  std::unique_ptr<Module> M(new Module("MyModule", Context));
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
+      { Type::getFloatTy(Context), Type::getInt32Ty(Context) }, false);
+  auto *F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
+  auto *BB = BasicBlock::Create(Context, "bb", F);
+  IRBuilder<> Builder(Context);
+  Builder.SetInsertPoint(BB);
+  auto *Arg0 = F->arg_begin();
+
+  {
+    auto *I = cast<Instruction>(Builder.CreateFAdd(Arg0, Arg0));
+    EXPECT_EQ(Intrinsic::experimental_constrained_fadd,
+              getConstrainedIntrinsicID(*I));
+  }
+
+  {
+    auto *I = cast<Instruction>(
+        Builder.CreateFPToSI(Arg0, Type::getInt32Ty(Context)));
+    EXPECT_EQ(Intrinsic::experimental_constrained_fptosi,
+              getConstrainedIntrinsicID(*I));
+  }
+
+  {
+    auto *I = cast<Instruction>(Builder.CreateIntrinsic(Intrinsic::ceil,
+        { Type::getFloatTy(Context) }, { Arg0 }));
+    EXPECT_EQ(Intrinsic::experimental_constrained_ceil,
+              getConstrainedIntrinsicID(*I));
+  }
+
+  {
+    auto *Arg1 = F->arg_begin() + 1;
+    auto *I = cast<Instruction>(Builder.CreateAdd(Arg1, Arg1));
+    EXPECT_EQ(Intrinsic::not_intrinsic, getConstrainedIntrinsicID(*I));
+  }
+
+  {
+    auto *I = cast<Instruction>(Builder.CreateConstrainedFPBinOp(
+        Intrinsic::experimental_constrained_fadd, Arg0, Arg0));
+    EXPECT_EQ(Intrinsic::not_intrinsic, getConstrainedIntrinsicID(*I));
+  }
+}
 
 TEST(InstructionsTest, isEliminableCastPair) {
   LLVMContext C;
 
   Type* Int16Ty = Type::getInt16Ty(C);
   Type* Int32Ty = Type::getInt32Ty(C);
   Type* Int64Ty = Type::getInt64Ty(C);
   Type* Int64PtrTy = Type::getInt64PtrTy(C);