[strictfp] Add token support for FP constraints

[andrew.w.kaylor]

Summary

This patch adds support for token values to describe floating point rounding modes and exception behaviors. The intent is that we will convert the constrained fp intrinsics to use operand bundles with these tokens instead of string metadata arguments to describe the constraints.

The FPEnv.h header file is borrowed from D69552, which I expect to land before this one. My only changes to the as introduced there are to add "num" entries to the enums.

[uweigand]

I like the notion of having those values expressed directly as LLVM IR tokens, but I'm not really sure the LLVM "token" type is the correct way to represent those.

The way I understood the token type as described in the IR docs, it seems to be intended to hold opaque numerical values generated at run time by some system library; in the only real current use case, this would be the Windows exception dispatch library.

Using it, like here, to encode LLVM internal compile-time enumeration values seems to be a bit of an overloading of that concept. I think this may probably need to be discussed more with the wider community, maybe on llvm-dev?

[simoll]

In D70261#1747498, @uweigand wrote:

I like the notion of having those values expressed directly as LLVM IR tokens

+1
I also like the (optional) operand bundles (see llvm-dev reply).

Quoting: https://llvm.org/docs/LangRef.html#token-type

"The token type is used when a value is associated with an instruction but all uses of the value must not attempt to introspect or obscure it. As such, it is not appropriate to have a phi or select of type token."

That seems to be a pretty accurate description of how the fpround/fpexcept params are supposed to be handled (they must not change the operation/implementation of the constrained fp op).

[uweigand]

In D70261#1747641, @simoll wrote:

Quoting: https://llvm.org/docs/LangRef.html#token-type

"The token type is used when a value is associated with an instruction but all uses of the value must not attempt to introspect or obscure it. As such, it is not appropriate to have a phi or select of type token."

That seems to be a pretty accurate description of how the fpround/fpexcept params are supposed to be handled (they must not change the operation/implementation of the constrained fp op).

Maybe I'm just interpreting this differently, but for me this reads as a description of the token value itself, which is something opaque that the compiler must not attempt to modify (as in the current use of tokens with Windows exception handling, where the token values generated by the OS apparently interact with exception control flow in a non-obvious way).

This is really a different scenario from constrained fp ops, where the fpround/fpexcept params are not so much operands, but just compile-time constants associated with an instruction -- in a sense, more like "extended opcodes" (similar to fast-math flags or the like).

[andrew.w.kaylor]

As referenced in Simon's reply, I have started a mailing list discussion about this.

I see your point, Ulrich, about this overloading the token concept a bit. The token type is also used by coroutine handling, but it uses tokens in the same way as exception handling -- it's an opaque value returned by an intrinsic call and passed to other intrinsics. In what I've proposed here, the optimizer is intended to inspect and use the value of the token. However, it's still opaque to the program. For instance, you can't assign the token to another token or add two tokens together or print the token to stdout.

I feel pretty good about moving the constraints to an operand bundle and making it optional. I'm on the fence about tokens as the way to do it.

I don't think any current concept fits better (maybe attributes, but call site specific attributes are uncommon and confusing). A new IR concept to handle this feels like a worse idea than extending the concept of tokens.

[andrew.w.kaylor]

I think we've agreed that this isn't a good use of tokens. The operand bundle approach may still be useful, but that can be attempted in a new revision.

llvm/include/llvm-c/Core.h

typedef enum {
 
   LLVMUndefValueValueKind,
   LLVMConstantAggregateZeroValueKind,
   LLVMConstantDataArrayValueKind,
   LLVMConstantDataVectorValueKind,
   LLVMConstantIntValueKind,
   LLVMConstantFPValueKind,
   LLVMConstantPointerNullValueKind,
+  LLVMConstantTokenFPRoundValueKind,
+  LLVMConstantTokenFPExceptValueKind,
   LLVMConstantTokenNoneValueKind,
 
   LLVMMetadataAsValueValueKind,
   LLVMInlineAsmValueKind,
 
   LLVMInstructionValueKind,
 } LLVMValueKind;
 

llvm/include/llvm/Bitcode/LLVMBitCodes.h

CST_CODE_INLINEASM_OLD = 18,   // INLINEASM:     [sideeffect|alignstack,
                                  //                 asmstr,conststr]
   CST_CODE_CE_SHUFVEC_EX = 19,   // SHUFVEC_EX:    [opty, opval, opval, opval]
   CST_CODE_CE_INBOUNDS_GEP = 20, // INBOUNDS_GEP:  [n x operands]
   CST_CODE_BLOCKADDRESS = 21,    // CST_CODE_BLOCKADDRESS [fnty, fnval, bb#]
   CST_CODE_DATA = 22,            // DATA:          [n x elements]
   CST_CODE_INLINEASM = 23,       // INLINEASM:     [sideeffect|alignstack|
                                  //                 asmdialect,asmstr,conststr]
   CST_CODE_CE_GEP_WITH_INRANGE_INDEX = 24, //      [opty, flags, n x operands]
-  CST_CODE_CE_UNOP = 25,         // CE_UNOP:      [opcode, opval]
+  CST_CODE_CE_UNOP = 25,         // CE_UNOP:       [opcode, opval]
+  CST_CODE_FPROUND = 26,         // CE_FPROUND:    [opcode, opval]
+  CST_CODE_FPEXCEPT = 27,        // CE_FPEXCEPT:   [opcode, opval]
 };
 
 /// CastOpcodes - These are values used in the bitcode files to encode which
 /// cast a CST_CODE_CE_CAST or a XXX refers to.  The values of these enums
 /// have no fixed relation to the LLVM IR enum values.  Changing these will
 /// break compatibility with old files.
 enum CastOpcodes {
   CAST_TRUNC = 0,

llvm/include/llvm/IR/Constants.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/OperandTraits.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
public:
   static ConstantTokenNone *get(LLVMContext &Context);
 
   /// Methods to support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Value *V) {
     return V->getValueID() == ConstantTokenNoneVal;
   }
 };
 
+//===----------------------------------------------------------------------===//
+/// A constant token that represents floating point rounding mode
+///
+class ConstantTokenFPRound final : public ConstantData {
+  friend class Constant;
+
+  explicit ConstantTokenFPRound(LLVMContext &Context, fp::RoundingMode RM)
+      : ConstantData(Type::getTokenTy(Context), ConstantTokenFPRoundVal),
+        RM(RM) {}
+
+  void destroyConstantImpl();
+
+  fp::RoundingMode RM;
+
+public:
+  ConstantTokenFPRound(const ConstantTokenFPRound &) = delete;
+
+  fp::RoundingMode getRoundingMode() const { return RM; }
+
+  /// Return the ConstantTokenFPRound for the given rounding mode.
+  static ConstantTokenFPRound *get(LLVMContext &Context, fp::RoundingMode RM);
+
+  /// Methods to support type inquiry through isa, cast, and dyn_cast.
+  static bool classof(const Value *V) {
+    return V->getValueID() == ConstantTokenFPRoundVal;
+  }
+};
+
+//===----------------------------------------------------------------------===//
+/// A constant token that represents floating point exception semantics
+///
+class ConstantTokenFPExcept final : public ConstantData {
+  friend class Constant;
+
+  explicit ConstantTokenFPExcept(LLVMContext &Context,
+                                 fp::ExceptionBehavior EB)
+      : ConstantData(Type::getTokenTy(Context), ConstantTokenFPExceptVal),
+        EB(EB) {}
+
+  void destroyConstantImpl();
+
+  fp::ExceptionBehavior EB;
+
+public:
+  ConstantTokenFPExcept(const ConstantTokenFPExcept &) = delete;
+
+  fp::ExceptionBehavior getExceptionBehavior() const { return EB; }
+
+  /// Return the ConstantTokenFPExcept for the given exception behavior.
+  static ConstantTokenFPExcept *get(LLVMContext &Context,
+                                    fp::ExceptionBehavior EB);
+
+  /// Methods to support type inquiry through isa, cast, and dyn_cast.
+  static bool classof(const Value *V) {
+    return V->getValueID() == ConstantTokenFPExceptVal;
+  }
+};
+
 /// The address of a basic block.
 ///
 class BlockAddress final : public Constant {
   friend class Constant;
 
   BlockAddress(Function *F, BasicBlock *BB);
 
   void *operator new(size_t s) { return User::operator new(s, 2); }

llvm/include/llvm/IR/FPEnv.h

+//===- FPEnv.h ---- FP Environment ------------------------------*- C++ -*-===//
+//
+// 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 declarations of entities that describe floating
+/// point environment and related functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_FPENV_H
+#define LLVM_IR_FPENV_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include <stdint.h>
+
+namespace llvm {
+
+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 {
+  rmDynamic,    ///< This corresponds to "fpround.dynamic".
+  rmToNearest,  ///< This corresponds to "fpround.tonearest".
+  rmDownward,   ///< This corresponds to "fpround.downward".
+  rmUpward,     ///< This corresponds to "fpround.upward".
+  rmTowardZero, ///< This corresponds to "fpround.tozero".
+  numRoundingModes
+};
+
+/// 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 {
+  ebIgnore,  ///< This corresponds to "fpexcept.ignore".
+  ebMayTrap, ///< This corresponds to "fpexcept.maytrap".
+  ebStrict,  ///< This corresponds to "fpexcept.strict".
+  numExceptionBehaviors
+};
+
+}
+
+/// Returns a valid RoundingMode enumerator when given a string
+/// that is valid as input in constrained intrinsic rounding mode
+/// metadata.
+Optional<fp::RoundingMode> StrToRoundingMode(StringRef);
+
+/// For any RoundingMode enumerator, returns a string valid as input in
+/// constrained intrinsic rounding mode metadata.
+Optional<StringRef> RoundingModeToStr(fp::RoundingMode);
+
+/// 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);
+
+}
+#endif
 No newline at end of file

llvm/include/llvm/IR/Value.def

 // ConstantData.
 HANDLE_CONSTANT(UndefValue)
 HANDLE_CONSTANT(ConstantAggregateZero)
 HANDLE_CONSTANT(ConstantDataArray)
 HANDLE_CONSTANT(ConstantDataVector)
 HANDLE_CONSTANT(ConstantInt)
 HANDLE_CONSTANT(ConstantFP)
 HANDLE_CONSTANT(ConstantPointerNull)
+HANDLE_CONSTANT(ConstantTokenFPRound)
+HANDLE_CONSTANT(ConstantTokenFPExcept)
 HANDLE_CONSTANT(ConstantTokenNone)
 
 HANDLE_CONSTANT_MARKER(ConstantFirstVal, Function)
 HANDLE_CONSTANT_MARKER(ConstantLastVal, ConstantTokenNone)
 HANDLE_CONSTANT_MARKER(ConstantDataFirstVal, UndefValue)
 HANDLE_CONSTANT_MARKER(ConstantDataLastVal, ConstantTokenNone)
 HANDLE_CONSTANT_MARKER(ConstantAggregateFirstVal, ConstantArray)
 HANDLE_CONSTANT_MARKER(ConstantAggregateLastVal, ConstantVector)

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(uniformRetVal);
   KEYWORD(uniqueRetVal);
   KEYWORD(virtualConstProp);
   KEYWORD(info);
   KEYWORD(byte);
   KEYWORD(bit);
   KEYWORD(varFlags);
 
+  // Floating point rounding mode keywords
+  KEYWORD(rmDynamic);
+  KEYWORD(rmToNearest);
+  KEYWORD(rmDownward);
+  KEYWORD(rmUpward);
+  KEYWORD(rmTowardZero);
+
+  // Floating point exception behavior keywords
+  KEYWORD(ebIgnore);
+  KEYWORD(ebMayTrap);
+  KEYWORD(ebStrict);
+
 #undef KEYWORD
 
   // Keywords for types.
 #define TYPEKEYWORD(STR, LLVMTY)                                               \
   do {                                                                         \
     if (Keyword == STR) {                                                      \
       TyVal = LLVMTY;                                                          \
       return lltok::Type;                                                      \

llvm/lib/AsmParser/LLParser.cpp

case lltok::kw_false:
     ID.ConstantVal = ConstantInt::getFalse(Context);
     ID.Kind = ValID::t_Constant;
     break;
   case lltok::kw_null: ID.Kind = ValID::t_Null; break;
   case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
   case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
   case lltok::kw_none: ID.Kind = ValID::t_None; break;
 
+  case lltok::kw_rmDynamic:
+    ID.ConstantVal = ConstantTokenFPRound::get(Context, fp::rmDynamic);
+    ID.Kind = ValID::t_Constant;
+    break;
+  case lltok::kw_rmToNearest:
+    ID.ConstantVal = ConstantTokenFPRound::get(Context, fp::rmToNearest);
+    ID.Kind = ValID::t_Constant;
+    break;
+  case lltok::kw_rmDownward:
+    ID.ConstantVal = ConstantTokenFPRound::get(Context, fp::rmDownward);
+    ID.Kind = ValID::t_Constant;
+    break;
+  case lltok::kw_rmUpward:
+    ID.ConstantVal = ConstantTokenFPRound::get(Context, fp::rmUpward);
+    ID.Kind = ValID::t_Constant;
+    break;
+  case lltok::kw_rmTowardZero:
+    ID.ConstantVal = ConstantTokenFPRound::get(Context, fp::rmTowardZero);
+    ID.Kind = ValID::t_Constant;
+    break;
+
+  case lltok::kw_ebIgnore:
+    ID.ConstantVal = ConstantTokenFPExcept::get(Context, fp::ebIgnore);
+    ID.Kind = ValID::t_Constant;
+    break;
+  case lltok::kw_ebMayTrap:
+    ID.ConstantVal = ConstantTokenFPExcept::get(Context, fp::ebMayTrap);
+    ID.Kind = ValID::t_Constant;
+    break;
+  case lltok::kw_ebStrict:
+    ID.ConstantVal = ConstantTokenFPExcept::get(Context, fp::ebStrict);
+    ID.Kind = ValID::t_Constant;
+    break;
+
   case lltok::lbrace: {
     // ValID ::= '{' ConstVector '}'
     Lex.Lex();
     SmallVector<Constant*, 16> Elts;
     if (ParseGlobalValueVector(Elts) ||
         ParseToken(lltok::rbrace, "expected end of struct constant"))
       return true;
 

llvm/lib/AsmParser/LLToken.h

enum Kind {
   kw_uniformRetVal,
   kw_uniqueRetVal,
   kw_virtualConstProp,
   kw_info,
   kw_byte,
   kw_bit,
   kw_varFlags,
 
+  // FP rounding modes
+  kw_rmDynamic,
+  kw_rmToNearest,
+  kw_rmDownward,
+  kw_rmUpward,
+  kw_rmTowardZero,
+
+  // FP exception behaviors
+  kw_ebIgnore,
+  kw_ebMayTrap,
+  kw_ebStrict,
+
   // Unsigned Valued tokens (UIntVal).
   LabelID,    // 42:
   GlobalID,   // @42
   LocalVarID, // %42
   AttrGrpID,  // #42
   SummaryID,  // ^42
 
   // String valued tokens (StrVal).

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::CST_CODE_SETTYPE:   // SETTYPE: [typeid]
       CurFullTy = TypeList[Record[0]];
       CurTy = flattenPointerTypes(CurFullTy);
       continue;  // Skip the ValueList manipulation.
     case bitc::CST_CODE_NULL:      // NULL
       if (CurTy->isVoidTy() || CurTy->isFunctionTy() || CurTy->isLabelTy())
         return error("Invalid type for a constant null value");
       V = Constant::getNullValue(CurTy);
       break;
+    case bitc::CST_CODE_FPROUND:   // FPROUND: [intval]
+      if (!CurTy->isTokenTy() || Record.empty())
+        return error("Invalid record");
+      V = ConstantTokenFPRound::get(Context,
+                                    static_cast<fp::RoundingMode>(Record[0]));
+      break;
+    case bitc::CST_CODE_FPEXCEPT:   // FPEXCEPT: [intval]
+      if (!CurTy->isTokenTy() || Record.empty())
+        return error("Invalid record");
+      V = ConstantTokenFPExcept::get(
+            Context, static_cast<fp::ExceptionBehavior>(Record[0]));
+      break;
     case bitc::CST_CODE_INTEGER:   // INTEGER: [intval]
       if (!CurTy->isIntegerTy() || Record.empty())
         return error("Invalid record");
       V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
       break;
     case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]
       if (!CurTy->isIntegerTy() || Record.empty())
         return error("Invalid record");

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

for (unsigned i = FirstVal; i != LastVal; ++i) {
     }
     const Constant *C = cast<Constant>(V);
     unsigned Code = -1U;
     unsigned AbbrevToUse = 0;
     if (C->isNullValue()) {
       Code = bitc::CST_CODE_NULL;
     } else if (isa<UndefValue>(C)) {
       Code = bitc::CST_CODE_UNDEF;
+    } else if (const auto *Tok = dyn_cast<ConstantTokenFPRound>(C)) {
+      Code = bitc::CST_CODE_FPROUND;
+      Record.push_back(static_cast<uint64_t>(Tok->getRoundingMode()));
+    } else if (const auto *Tok = dyn_cast<ConstantTokenFPExcept>(C)) {
+      Code = bitc::CST_CODE_FPEXCEPT;
+      Record.push_back(static_cast<uint64_t>(Tok->getExceptionBehavior()));
     } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
       if (IV->getBitWidth() <= 64) {
         uint64_t V = IV->getSExtValue();
         emitSignedInt64(Record, V);
         Code = bitc::CST_CODE_INTEGER;
         AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
       } else {                             // Wide integers, > 64 bits in size.
         // We have an arbitrary precision integer value to write whose

llvm/lib/IR/AsmWriter.cpp

if (isa<ConstantPointerNull>(CV)) {
     return;
   }
 
   if (isa<ConstantTokenNone>(CV)) {
     Out << "none";
     return;
   }
 
+  if (auto *Tok = dyn_cast<ConstantTokenFPRound>(CV)) {
+    switch (Tok->getRoundingMode()) {
+    default: llvm_unreachable("Invalid FP rounding mode token");
+    case fp::rmDynamic: Out << "rmDynamic"; return;
+    case fp::rmToNearest: Out << "rmToNearest"; return;
+    case fp::rmDownward: Out << "rmDownward"; return;
+    case fp::rmUpward: Out << "rmUpward"; return;
+    case fp::rmTowardZero: Out << "rmTowardZero"; return;
+    }
+  }
+
+  if (auto *Tok = dyn_cast<ConstantTokenFPExcept>(CV)) {
+    switch (Tok->getExceptionBehavior()) {
+    default: llvm_unreachable("Invalid FP exception behavior token");
+    case fp::ebIgnore: Out << "ebIgnore"; return;
+    case fp::ebMayTrap: Out << "ebMayTrap"; return;
+    case fp::ebStrict: Out << "ebStrict"; return;
+    }
+  }
+
   if (isa<UndefValue>(CV)) {
     Out << "undef";
     return;
   }
 
   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
     Out << CE->getOpcodeName();
     WriteOptimizationInfo(Out, CE);

llvm/lib/IR/Constants.cpp

ConstantTokenNone *ConstantTokenNone::get(LLVMContext &Context) {
   return pImpl->TheNoneToken.get();
 }
 
 /// Remove the constant from the constant table.
 void ConstantTokenNone::destroyConstantImpl() {
   llvm_unreachable("You can't ConstantTokenNone->destroyConstantImpl()!");
 }
 
+ConstantTokenFPRound *ConstantTokenFPRound::get(LLVMContext &Context,
+                                                fp::RoundingMode RM) {
+  LLVMContextImpl *pImpl = Context.pImpl;
+  int Idx = static_cast<int>(RM);
+  assert(Idx >= 0 && Idx < fp::numRoundingModes &&
+         "Unexpected FP rounding mode constant request");
+  if (!pImpl->FPRoundTokens[Idx])
+    pImpl->FPRoundTokens[Idx].reset(new ConstantTokenFPRound(Context, RM));
+  return pImpl->FPRoundTokens[Idx].get();
+}
+
+/// Remove the constant from the constant table.
+void ConstantTokenFPRound::destroyConstantImpl() {
+  llvm_unreachable("You can't ConstantTokenFPRound->destroyConstantImpl()!");
+}
+
+ConstantTokenFPExcept *ConstantTokenFPExcept::get(LLVMContext &Context,
+                                                  fp::ExceptionBehavior EB) {
+  LLVMContextImpl *pImpl = Context.pImpl;
+  int Idx = static_cast<int>(EB);
+  assert(Idx >= 0 && Idx < fp::numExceptionBehaviors &&
+         "Unexpected FP rounding mode constant request");
+  if (!pImpl->FPExceptTokens[Idx])
+    pImpl->FPExceptTokens[Idx].reset(new ConstantTokenFPExcept(Context, EB));
+  return pImpl->FPExceptTokens[Idx].get();
+}
+
+/// Remove the constant from the constant table.
+void ConstantTokenFPExcept::destroyConstantImpl() {
+  llvm_unreachable("You can't ConstantTokenFPExcept->destroyConstantImpl()!");
+}
+
 // Utility function for determining if a ConstantExpr is a CastOp or not. This
 // can't be inline because we don't want to #include Instruction.h into
 // Constant.h
 bool ConstantExpr::isCast() const {
   return Instruction::isCast(getOpcode());
 }
 
 bool ConstantExpr::isCompare() const {

llvm/lib/IR/LLVMContextImpl.h

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/FPEnv.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/RemarkStreamer.h"
 #include "llvm/IR/TrackingMDRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/YAMLTraits.h"
DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
     BlockAddresses;
   ConstantUniqueMap<ConstantExpr> ExprConstants;
 
   ConstantUniqueMap<InlineAsm> InlineAsms;
 
   ConstantInt *TheTrueVal = nullptr;
   ConstantInt *TheFalseVal = nullptr;
 
+  std::unique_ptr<ConstantTokenFPRound> FPRoundTokens[fp::numRoundingModes];
+  std::unique_ptr<ConstantTokenFPExcept>
+    FPExceptTokens[fp::numExceptionBehaviors];
+
   std::unique_ptr<ConstantTokenNone> TheNoneToken;
 
   // Basic type instances.
   Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy;
   Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
   IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
 
   BumpPtrAllocator Alloc;

llvm/test/Assembler/fpconstraint-tokens.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+; Basic smoke test for FP constraint tokens.
+
+; CHECK: declare void @llvm.fp.constraint.test()
+declare void @llvm.fp.constraint.test()
+
+define void @f() {
+; CHECK:  call void @llvm.fp.constraint.test() [ "fpround"(token rmDynamic), "fpexcept"(token ebStrict) ]
+; CHECK:  call void @llvm.fp.constraint.test() [ "fpround"(token rmToNearest), "fpexcept"(token ebIgnore) ]
+; CHECK:  call void @llvm.fp.constraint.test() [ "fpround"(token rmDownward), "fpexcept"(token ebIgnore) ]
+; CHECK:  call void @llvm.fp.constraint.test() [ "fpround"(token rmUpward), "fpexcept"(token ebMayTrap) ]
+; CHECK:  call void @llvm.fp.constraint.test() [ "fpround"(token rmTowardZero), "fpexcept"(token ebMayTrap) ]
+  call void @llvm.fp.constraint.test() [ "fpround"(token rmDynamic), "fpexcept"(token ebStrict) ]
+  call void @llvm.fp.constraint.test() [ "fpround"(token rmToNearest), "fpexcept"(token ebIgnore) ]
+  call void @llvm.fp.constraint.test() [ "fpround"(token rmDownward), "fpexcept"(token ebIgnore) ]
+  call void @llvm.fp.constraint.test() [ "fpround"(token rmUpward), "fpexcept"(token ebMayTrap) ]
+  call void @llvm.fp.constraint.test() [ "fpround"(token rmTowardZero), "fpexcept"(token ebMayTrap) ]
+  ret void
+}