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

524–525

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

71

llvm/lib/IR/FPEnv.cpp

92

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

 
 #include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/IR/FMF.h"
 
 namespace llvm {
 class StringRef;
 
+namespace Intrinsic {
+typedef unsigned ID;
+}
+
+class Instruction;
+
 namespace fp {
 
 /// Exception behavior 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 ExceptionBehavior : uint8_t {

 Optional<StringRef> convertExceptionBehaviorToStr(fp::ExceptionBehavior);
 
 /// Returns true if the exception handling behavior and rounding mode
 /// match what is used in the default floating point environment.
 inline bool isDefaultFPEnvironment(fp::ExceptionBehavior EB, RoundingMode RM) {
   return EB == fp::ebIgnore && RM == RoundingMode::NearestTiesToEven;
 }
 
+/// Returns constrained intrinsic id to represent the given instruction in
+/// strictfp function. If the instruction is already a constrained intrinsic or
+/// does not have a constrained intrinsic counterpart, the function returns
+/// zero.
+Intrinsic::ID getConstrainedIntrinsicID(const Instruction &Instr);
+
 /// Returns true if the rounding mode RM may be QRM at compile time or
 /// at run time.
 inline bool canRoundingModeBe(RoundingMode RM, RoundingMode QRM) {
   return RM == QRM || RM == RoundingMode::Dynamic;
 }
 
 /// Returns true if the possibility of a signaling NaN can be safely
 /// ignored.
 inline bool canIgnoreSNaN(fp::ExceptionBehavior EB, FastMathFlags FMF) {
   return (EB == fp::ebIgnore || FMF.noNaNs());
 }
 }
 #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/IR/FPEnv.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Intrinsics.h"
 
 namespace llvm {
 
 Optional<RoundingMode> convertStrToRoundingMode(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<RoundingMode>>(RoundingArg)
       .Case("round.dynamic", RoundingMode::Dynamic)
case fp::ebIgnore:
     ExceptStr = "fpexcept.ignore";
     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()) {
+  case Instruction::FCmp:
+    // Unlike other instructions FCmp can be mapped to one of two intrinsic
+    // functions. We choose the non-signaling variant.
+    IID = Intrinsic::experimental_constrained_fcmp;
+    break;
+
+    // Instructions
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                         \
+  case Instruction::NAME:                                                      \
+    IID = Intrinsic::INTRINSIC;                                                \
+    break;
+#define FUNCTION(NAME, NARG, ROUND_MODE, INTRINSIC)
+#define CMP_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)
+#include "llvm/IR/ConstrainedOps.def"
+
+  // Intrinsic calls.
+  case Instruction::Call:
+    if (auto *IntrinCall = dyn_cast<IntrinsicInst>(&Instr)) {
+      switch (IntrinCall->getIntrinsicID()) {
+#define FUNCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                            \
+  case Intrinsic::NAME:                                                        \
+    IID = Intrinsic::INTRINSIC;                                                \
+    break;
+#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)
+#define CMP_INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC, DAGN)
+#include "llvm/IR/ConstrainedOps.def"
+      default:
+        break;
+      }
+    }
+    break;
+  default:
+    break;
+  }
+
+  return IID;
+}
+
 } // namespace llvm

llvm/unittests/IR/InstructionsTest.cpp

 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfoMetadata.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::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 *Arg1 = F->arg_begin() + 1;
+
+  {
+    auto *I = cast<Instruction>(Builder.CreateFAdd(Arg0, Arg1));
+    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 *I = cast<Instruction>(Builder.CreateFCmpOEQ(Arg0, Arg1));
+    EXPECT_EQ(Intrinsic::experimental_constrained_fcmp,
+              getConstrainedIntrinsicID(*I));
+  }
+
+  {
+    auto *Arg2 = F->arg_begin() + 2;
+    auto *I = cast<Instruction>(Builder.CreateAdd(Arg2, Arg2));
+    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);