[FPEnv] Add constrained FCMP intrinsic

[cameron.mcinally]

Summary

This isn't so much a patch as it is an RFC...

The compares are an odd duck wrt constrained intrinsics, since they are represented internally by the FCMPInst class. There are several ways that we could handle this quirk, one of which is shown in this Diff.

This patch attempts to use one intrinsic to represent the FCMP with a dedicated operand for the condition code. That way we don't need separate intrinsics for EQ/LT/LTE/etc. IMO, this solution is most in line with the other constrained intrinsics.

There are some weaknesses here though, like encoding and decoding the condition code. I'll comment inline on some of the other issues that need addressing too.

[cameron.mcinally]

include/llvm/IR/Intrinsics.td

600

This isn't quite right. The result's vector width should be tied to the operands' vector width. Something like:

def int_experimental_constrained_fcmp : Intrinsic<[ llvm_anyint_ty ],
                                                    [ llvm_i8_ty,
                                                      LLVMVectorSameWidth<0, llvm_anyscalarfloat_ty>,
                                                      LLVMMatchType<1>,
                                                      llvm_metadata_ty,
                                                      llvm_metadata_ty ]>;

We would need to accommodate vectors of floats and doubles here, but TableGen isn't expressive enough to do that right now.

Should we extend TableGen to handle a situation like this? That's assuming the "one compare intrinsic" solution I'm proposing is what we decide on, of course.

lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

772

ExpandStrictFPOp(...) and friends would need to be updated to handle FCmp's operand types. The operand types do not match the result type, as the other constrained intrinsics do.

[cameron.mcinally]

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

5658

Oh, this is a temporary stop-gap. This code will need to be extended to create the STRICT_FCMP node. Just FYI for now...

[andrew.w.kaylor]

This is definitely a tricky case. I don't really like any of the available solutions. I'll try to think more about it, and maybe someone else will have a brilliant suggestion.

include/llvm/IR/Intrinsics.td

595

This can't be 'any' int type. It needs to be either i1 or a vector of i1, right?

596

I don't like this. If you define this as an i8 the constant will get hard-coded in the IR. So instead of 'oeq' you'll see '1' or '2' or something. The reason I used metadata arguments for rounding mode and exception behavior was to allow readable strings.

[cameron.mcinally]

All good points.

Here's another data point. The X86 builtins for compares explicitly list all the condition codes:

v4sf __builtin_ia32_cmpeqps (v4sf, v4sf)
v4sf __builtin_ia32_cmpltps (v4sf, v4sf)
v4sf __builtin_ia32_cmpleps (v4sf, v4sf)
v4sf __builtin_ia32_cmpgtps (v4sf, v4sf)
v4sf __builtin_ia32_cmpgeps (v4sf, v4sf)
v4sf __builtin_ia32_cmpunordps (v4sf, v4sf)
v4sf __builtin_ia32_cmpneqps (v4sf, v4sf)
v4sf __builtin_ia32_cmpnltps (v4sf, v4sf)
v4sf __builtin_ia32_cmpnleps (v4sf, v4sf)
v4sf __builtin_ia32_cmpngtps (v4sf, v4sf)
v4sf __builtin_ia32_cmpngeps (v4sf, v4sf)
v4sf __builtin_ia32_cmpordps (v4sf, v4sf)

So that's one way we could handle this. Although, these don't appear to cover both the quiet and signaling variants that IEEE-754 requires (I'm not sure how the X86 builtins handle that??).

In total, IEEE-754 specifies 22 compares that we need to cover:

boolean compareQuietEqual(source1, source2)
boolean compareQuietNotEqual(source1, source2) 
boolean compareSignalingEqual(source1, source2) 
boolean compareSignalingGreater(source1, source2) 
boolean compareSignalingGreaterEqual(source1, source2) 
boolean compareSignalingLess(source1, source2)
boolean compareSignalingLessEqual(source1, source2)
boolean compareSignalingNotEqual(source1, source2)
boolean compareSignalingNotGreater(source1, source2) 
boolean compareSignalingLessUnordered(source1, source2) 
boolean compareSignalingNotLess(source1, source2)
boolean compareSignalingGreaterUnordered(source1, source2) 
boolean compareQuietGreater(source1, source2)
boolean compareQuietGreaterEqual(source1, source2) 
boolean compareQuietLess(source1, source2)
boolean compareQuietLessEqual(source1, source2)
boolean compareQuietUnordered(source1, source2) 
boolean compareQuietNotGreater(source1, source2) 
boolean compareQuietLessUnordered(source1, source2) 
boolean compareQuietNotLess(source1, source2)
boolean compareQuietGreaterUnordered(source1, source2) 
boolean compareQuietOrdered(source1, source2).

[andrew.w.kaylor]

I think my preference would be to have the predicate in the function name. I briefly toyed with the idea of hacking AsmWriter to print a constant integer as the corresponding predicate string, but I think that would look too weird. Also, I don't think we should open the door to something trying to use the value that represents the predicate as if it were a real value. In this sense the predicate argument, if we had one, should really be a token but I don't think we want to add new token constants just for this.

So this is what I'm imagining

def int_experimental_constrained_fcmp_eq_quiet : Intrinsic<[ llvm_anyi1_ty ],
                                                           [ llvm_anyfloat_ty,
                                                             LLVMScalarOrSameVectorWidth<0, llvm_anyfloat_ty>,
                                                             llvm_metadata_ty,
                                                             llvm_metadata_ty ]>;

And then 21 more of those. I've been talking to Craig about a way to make this a little more compact with multiclass, but that's the general idea.

What do you think?

[cameron.mcinally]

That's cool with me. Definitely a ton of work, but it's clean and complete.

If I'm not mistaken, we could use inverse operations and swap the true/false operands for SOME of these. I'll have to dig through IEEE-754 to confirm which ones, but it could save some typing. Although, the exact relations are fairly dense, so front end writers won't be happy. E.g.:

compareSignalingGreaterEqual(a,b) is equivalent to compareSignalingLessUnordered(b, a)

My opinion is not very strong on this though. The brevity might not be worth the added complexity. At least, not as a first pass at these operations.

Also, I see you added llvm_anyi1_ty. So we would have to extend TableGen to handle that, I assume. And we'd also have to extend TableGen to handle the LLVMScalarOrSameVectorWidth<0, llvm_anyfloat_ty> problem. That should really be "llvm_anyscalarfloat_ty" or something like that.

And finally nit-picking a little here, but this should really be:

def int_experimental_constrained_fcmp_eq_quiet : Intrinsic<[ llvm_anyi1_ty ],
                                                           [ LLVMScalarOrSameVectorWidth<0, llvm_anyfloat_ty>,
                                                             LLVMMatchType<0>,
                                                             llvm_metadata_ty,
                                                             llvm_metadata_ty ]>;

[andrew.w.kaylor]

In D54121#1290989, @cameron.mcinally wrote:

compareSignalingGreaterEqual(a,b) is equivalent to compareSignalingLessUnordered(b, a)

Is it? If a or b is NaN the first one will return false but the second will return true. I was trying to think through the combinations and figure out why IEEE-754 specifies these 22 of the possible 32 combinations and why there are only 12 X86 builtins instead of 16. I think it comes down to eliminating combinations that aren't needed.

Craig pointed out to me that the 16 predicates specified for the fcmp instruction come from a bit matrix of the four possible predicate conditions, even though some of those (like true and false) don't really make any sense. I guess when you're building a processor you need to handle combinations like that in a well-defined manner.

[cameron.mcinally]

In D54121#1291085, @andrew.w.kaylor wrote:

In D54121#1290989, @cameron.mcinally wrote:

compareSignalingGreaterEqual(a,b) is equivalent to compareSignalingLessUnordered(b, a)

Is it? If a or b is NaN the first one will return false but the second will return true.

Ah, yeah, I botched that. Those tables show the negations:

(a >= b) negated is !(a >= b) [signaling and quiet] or (a ?< b) [quiet]

Which makes sense. There are 4 relations in our set: { LT, EQ, GT, UN }. So:

{ GT, EQ } is !{ LT, UN }

So, yeah, all 22 operations are distinct. Unless we want to try to pattern match NOT(compareXXX(a,b)). That's probably not safe to do though, in case the compare operation and NOT get broken up during optimizations.

[cameron.mcinally]

More insight...

There are 12 x86 builtins and only 22 IEEE functions (not 24 as expected) since the following two IEEE functions don't make sense:

compareSignalingOrdered(a, b)
compareSignalingUnordered(a, b)

Those would always raise invalid on NaNs (both SNaNs and QNaNs), so are really of no consequence.

That implies the respective x86 builtins, builtin_ia32_cmpunordxx and builtin_ia32_cmpordxx, map to compareQuietUnordered(...) and compareQuietOrdered(...).

[craig.topper]

The X86 builtin story is weird. There should be 9 builtins. I'm not sure how you found 12. 8 representing the encodings used by the SSE1/SSE2 cmpps/pd/ss/sd listed below. And 9th intrinsic that takes a 5 bit immediate to cover the 32 values that the AVX vcmpps/pd/ss/sd.

TARGET_BUILTIN(__builtin_ia32_cmpeqps, "V4fV4fV4f", "ncV:128:", "sse")
TARGET_BUILTIN(__builtin_ia32_cmpltps, "V4fV4fV4f", "ncV:128:", "sse")
TARGET_BUILTIN(__builtin_ia32_cmpleps, "V4fV4fV4f", "ncV:128:", "sse")
TARGET_BUILTIN(__builtin_ia32_cmpunordps, "V4fV4fV4f", "ncV:128:", "sse")
TARGET_BUILTIN(__builtin_ia32_cmpneqps, "V4fV4fV4f", "ncV:128:", "sse")
TARGET_BUILTIN(__builtin_ia32_cmpnltps, "V4fV4fV4f", "ncV:128:", "sse")
TARGET_BUILTIN(__builtin_ia32_cmpnleps, "V4fV4fV4f", "ncV:128:", "sse")
TARGET_BUILTIN(__builtin_ia32_cmpordps, "V4fV4fV4f", "ncV:128:", "sse")

All 9 builtins map to the same IR intrinsic that takes a 5 bit immediate. Or at least they use to. I think some map directly to fcmp these days. We have 8 separate SSE builtins because that's what gcc did way back in the SSE1 days. When AVX expanded to 32 comparison predicates, gcc decided to use one builtin with an immediate instead of adding 24 more. Clang uses the 8 legacy builtins to match gcc and to prevent users from trying to use an AVX encoding when targetting an SSE only CPU. Within the avxintrin.h file I believe we should have wrappers around the builtin for all 32 possible encodiings that just pass the correct immediate to the builtin.

[cameron.mcinally]

In D54121#1291755, @craig.topper wrote:

The X86 builtin story is weird. There should be 9 builtins. I'm not sure how you found 12.

Oh, so those are from the online GCC documentation. In the early days of writing the AVX512 builtins, the GCC AVX512 intrinsics were defined first and were used as the reference to keep the two in sync. Old habit, I suppose.

So it looks like LLVM doesn't have any of the GT/GE intrinsics, but rather uses NLE/NGT. And the extra 9th intrinsic is the general cmp.

[cameron.mcinally]

Here's a first whack at a list of operations needed internally:

compareSignalingEqual(a, b)  
compareSignalingNotEqual(a, b)
compareSignalingLess(a, b) <-> compareSignalingGreater(b, a)
compareSignalingLessEqual(a, b) <-> compareSignalingGreaterEqual(b, a)
compareSignalingLessUnordered(a, b) <-> compareSignalingGreaterUnordered(b, a)
compareSignalingNotLess(a, b) <-> compareSignalingNotGreater(b, a) 

compareQuietUnordered(a, b) 
compareQuietOrdered(a, b)
compareQuietEqual(a, b)
compareQuietNotEqual(a, b) 
compareQuietLess(a, b) <-> compareQuietGreater(b, a)
compareQuietLessEqual(a, b) <-> compareQuietGreaterEqual(b, a)
compareQuietLessUnordered(a, b) <-> compareQuietGreaterUnordered(b, a) 
compareQuietNotLess(a, b) <-> compareQuietNotGreater(b, a)

Anyone see problems with this?

[cameron.mcinally]

Thinking aloud...

I'm playing with the idea of being able to implement the signaling variants of each operation through the quiet variants. I mean, a signaling compare is really just:

bool compareSignalingEqual(a, b) {
  return is_ordered(a,b) ? compareQuietEqual(a, b) : signal Invalid;
}

But it may be difficult to get the flags right. I haven't thought that all the way through yet.

This is probably not worth serious consideration at this point. Just wanted to throw it out there.

[cameron.mcinally]

I'm working on the changes that we discussed, but they're pretty invasive. A prospective patch is coming soon, but I wanted us to start thinking about how we'll handle these intrinsics at the SelectionDAG level. There are no CMP ISD nodes (also, what does legalization look like??), so this will likely be a significant change.

[craig.topper]

What do you mean there are no CMP ISD nodes? CMPs are represented by SETCC nodes in selectiondag.

[cameron.mcinally]

Oh, right. I missed that. So there should probably be a new STRICT_SETCC node. Thanks.

[cameron.mcinally]

Abandon this Revision for D54649...

docs/LangRef.rst

 
 Semantics:
 """"""""""
 
 This function returns the same values as the libm ``trunc`` functions
 would and handles error conditions in the same way.
 
 
+'``llvm.experimental.constrained.fcmp``' Intrinsic
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Syntax:
+"""""""
+
+::
+
+      declare <type>
+      @llvm.experimental.constrained.fcmp(<type> <op1>,
+                                          metadata <rounding mode>,
+                                          metadata <exception behavior>)
+
+Overview:
+"""""""""
+
+The '``llvm.experimental.constrained.fcmp``' intrinsic returns 
+
+
+Arguments:
+""""""""""
+
+XXX FIXME
+
+The first argument and the return value are floating-point numbers of the same
+type.
+
+The second and third arguments specify the rounding mode and exception
+behavior as described above.
+
+Semantics:
+""""""""""
+
+XXX FIXME
+
+This function returns the same values as the libm ``nearbyint`` functions
+would, and handles error conditions in the same way.  The rounding mode is
+described, not determined, by the rounding mode argument.  The actual rounding
+mode is determined by the runtime floating-point environment.  The rounding
+mode argument is only intended as information to the compiler.
+
+
 General Intrinsics
 ------------------
 
 This class of intrinsics is designed to be generic and has no specific
 purpose.
 
 '``llvm.var.annotation``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

include/llvm/CodeGen/ISDOpcodes.h

enum NodeType {
     /// These will be lowered to the equivalent non-constrained pseudo-op
     /// (or expanded to the equivalent library call) before final selection.
     /// They are used to limit optimizations while the DAG is being optimized.
     STRICT_FSQRT, STRICT_FPOW, STRICT_FPOWI, STRICT_FSIN, STRICT_FCOS,
     STRICT_FEXP, STRICT_FEXP2, STRICT_FLOG, STRICT_FLOG10, STRICT_FLOG2,
     STRICT_FRINT, STRICT_FNEARBYINT, STRICT_FMAXNUM, STRICT_FMINNUM,
     STRICT_FCEIL, STRICT_FFLOOR, STRICT_FROUND, STRICT_FTRUNC,
 
+    /// Constrained version of compare. 
+    /// These will be lowered to the simple operators before final selection.
+    /// They are used to limit optimizations while the DAG is being
+    /// optimized.
+    STRICT_FCMP,
+
     /// FMA - Perform a * b + c with no intermediate rounding step.
     FMA,
 
     /// FMAD - Perform a * b + c, while getting the same result as the
     /// separately rounded operations.
     FMAD,
 
     /// FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.  NOTE: This

include/llvm/CodeGen/SelectionDAGNodes.h

switch (NodeType) {
       case ISD::STRICT_FRINT:
       case ISD::STRICT_FNEARBYINT:
       case ISD::STRICT_FMAXNUM:
       case ISD::STRICT_FMINNUM:
       case ISD::STRICT_FCEIL:
       case ISD::STRICT_FFLOOR:
       case ISD::STRICT_FROUND:
       case ISD::STRICT_FTRUNC:
+      case ISD::STRICT_FCMP:
         return true;
     }
   }
 
   /// Test if this node has a post-isel opcode, directly
   /// corresponding to a MachineInstr opcode.
   bool isMachineOpcode() const { return NodeType < 0; }
 

include/llvm/CodeGen/TargetLowering.h

switch (Op) {
       case ISD::STRICT_FRINT: EqOpc = ISD::FRINT; break;
       case ISD::STRICT_FNEARBYINT: EqOpc = ISD::FNEARBYINT; break;
       case ISD::STRICT_FMAXNUM: EqOpc = ISD::FMAXNUM; break;
       case ISD::STRICT_FMINNUM: EqOpc = ISD::FMINNUM; break;
       case ISD::STRICT_FCEIL: EqOpc = ISD::FCEIL; break;
       case ISD::STRICT_FFLOOR: EqOpc = ISD::FFLOOR; break;
       case ISD::STRICT_FROUND: EqOpc = ISD::FROUND; break;
       case ISD::STRICT_FTRUNC: EqOpc = ISD::FTRUNC; break;
+      case ISD::STRICT_FCMP: assert(0 && "Need Node"); break;
     }
 
     auto Action = getOperationAction(EqOpc, VT);
 
     // We don't currently handle Custom or Promote for strict FP pseudo-ops.
     // For now, we just expand for those cases.
     if (Action != Legal)
       Action = Expand;

include/llvm/IR/IntrinsicInst.h

static bool classof(const IntrinsicInst *I) {
       case Intrinsic::experimental_constrained_rint:
       case Intrinsic::experimental_constrained_nearbyint:
       case Intrinsic::experimental_constrained_maxnum:
       case Intrinsic::experimental_constrained_minnum:
       case Intrinsic::experimental_constrained_ceil:
       case Intrinsic::experimental_constrained_floor:
       case Intrinsic::experimental_constrained_round:
       case Intrinsic::experimental_constrained_trunc:
+      case Intrinsic::experimental_constrained_fcmp:
         return true;
       default: return false;
       }
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };

include/llvm/IR/Intrinsics.td

let IntrProperties = [IntrInaccessibleMemOnly] in {
   def int_experimental_constrained_round : Intrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
   def int_experimental_constrained_trunc : Intrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
                                                        llvm_metadata_ty,
                                                        llvm_metadata_ty ]>;
+  def int_experimental_constrained_fcmp : Intrinsic<[ llvm_anyint_ty ],
+                                                    [ llvm_i8_ty,
+                                                      llvm_anyfloat_ty,
+                                                      LLVMMatchType<1>,
+                                                      llvm_metadata_ty,
+                                                      llvm_metadata_ty ]>;
 }
-// FIXME: Add intrinsics for fcmp, fptrunc, fpext, fptoui and fptosi.
+// FIXME: Add intrinsics for fptrunc, fpext, fptoui and fptosi.
 // FIXME: Add intrinsics for fabs and copysign? 
 
 
 //===------------------------- Expect Intrinsics --------------------------===//
 //
 def int_expect : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>,
                                               LLVMMatchType<0>], [IntrNoMem]>;
 

lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

#endif
     case ISD::BITCAST:     R = SoftenFloatRes_BITCAST(N, ResNo); break;
     case ISD::BUILD_PAIR:  R = SoftenFloatRes_BUILD_PAIR(N); break;
     case ISD::ConstantFP:  R = SoftenFloatRes_ConstantFP(N, ResNo); break;
     case ISD::EXTRACT_VECTOR_ELT:
       R = SoftenFloatRes_EXTRACT_VECTOR_ELT(N, ResNo); break;
     case ISD::FABS:        R = SoftenFloatRes_FABS(N, ResNo); break;
     case ISD::FMINNUM:     R = SoftenFloatRes_FMINNUM(N); break;
     case ISD::FMAXNUM:     R = SoftenFloatRes_FMAXNUM(N); break;
+    case ISD::STRICT_FADD: R = SoftenFloatRes_FADD(DAG.mutateStrictFPToFP(N)); break;
     case ISD::FADD:        R = SoftenFloatRes_FADD(N); break;
     case ISD::FCEIL:       R = SoftenFloatRes_FCEIL(N); break;
     case ISD::FCOPYSIGN:   R = SoftenFloatRes_FCOPYSIGN(N, ResNo); break;
     case ISD::FCOS:        R = SoftenFloatRes_FCOS(N); break;
     case ISD::FDIV:        R = SoftenFloatRes_FDIV(N); break;
     case ISD::FEXP:        R = SoftenFloatRes_FEXP(N); break;
     case ISD::FEXP2:       R = SoftenFloatRes_FEXP2(N); break;
     case ISD::FFLOOR:      R = SoftenFloatRes_FFLOOR(N); break;

lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

SDValue VectorLegalizer::LegalizeOp(SDValue Op) {
   case ISD::STRICT_FRINT:
   case ISD::STRICT_FNEARBYINT:
   case ISD::STRICT_FMAXNUM:
   case ISD::STRICT_FMINNUM:
   case ISD::STRICT_FCEIL:
   case ISD::STRICT_FFLOOR:
   case ISD::STRICT_FROUND:
   case ISD::STRICT_FTRUNC:
+  case ISD::STRICT_FCMP:
     // These pseudo-ops get legalized as if they were their non-strict
     // equivalent.  For instance, if ISD::FSQRT is legal then ISD::STRICT_FSQRT
     // is also legal, but if ISD::FSQRT requires expansion then so does
     // ISD::STRICT_FSQRT.
     Action = TLI.getStrictFPOperationAction(Node->getOpcode(),
                                             Node->getValueType(0));
     break;
   case ISD::ADD:
SDValue VectorLegalizer::Expand(SDValue Op) {
   case ISD::STRICT_FRINT:
   case ISD::STRICT_FNEARBYINT:
   case ISD::STRICT_FMAXNUM:
   case ISD::STRICT_FMINNUM:
   case ISD::STRICT_FCEIL:
   case ISD::STRICT_FFLOOR:
   case ISD::STRICT_FROUND:
   case ISD::STRICT_FTRUNC:
+  case ISD::STRICT_FCMP:
     return ExpandStrictFPOp(Op);
   default:
     return DAG.UnrollVectorOp(Op.getNode());
   }
 }
 
 SDValue VectorLegalizer::ExpandSELECT(SDValue Op) {
   // Lower a select instruction where the condition is a scalar and the
   // operands are vectors. Lower this select to VSELECT and implement it
   // using XOR AND OR. The selector bit is broadcasted.

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

private:
   void visitAtomicStore(const StoreInst &I);
   void visitLoadFromSwiftError(const LoadInst &I);
   void visitStoreToSwiftError(const StoreInst &I);
 
   void visitInlineAsm(ImmutableCallSite CS);
   const char *visitIntrinsicCall(const CallInst &I, unsigned Intrinsic);
   void visitTargetIntrinsic(const CallInst &I, unsigned Intrinsic);
   void visitConstrainedFPIntrinsic(const ConstrainedFPIntrinsic &FPI);
+  void visitConstrainedFCMPIntrinsic(const ConstrainedFPIntrinsic &FPI);
 
   void visitVAStart(const CallInst &I);
   void visitVAArg(const VAArgInst &I);
   void visitVAEnd(const CallInst &I);
   void visitVACopy(const CallInst &I);
   void visitStackmap(const CallInst &I);
   void visitPatchpoint(ImmutableCallSite CS,
                        const BasicBlock *EHPadBB = nullptr);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitICmp(const User &I) {
   SDValue Op2 = getValue(I.getOperand(1));
   ISD::CondCode Opcode = getICmpCondCode(predicate);
 
   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
                                                         I.getType());
   setValue(&I, DAG.getSetCC(getCurSDLoc(), DestVT, Op1, Op2, Opcode));
 }
 
+void SelectionDAGBuilder::visitConstrainedFCMPIntrinsic(
+                                            const ConstrainedFPIntrinsic &FPI) {
+  const ConstantInt *Cond = dyn_cast<ConstantInt>(FPI.getArgOperand(0));
+  FCmpInst::Predicate predicate = FCmpInst::Predicate(Cond->getZExtValue());
+
+  SDValue Op1 = getValue(FPI.getArgOperand(1));
+  SDValue Op2 = getValue(FPI.getArgOperand(2));
+  ISD::CondCode Condition = getFCmpCondCode(predicate);
+
+  EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
+                                                        FPI.getType());
+  setValue(&FPI, DAG.getSetCC(getCurSDLoc(), DestVT, Op1, Op2, Condition));
+}
+
 void SelectionDAGBuilder::visitFCmp(const User &I) {
   FCmpInst::Predicate predicate = FCmpInst::BAD_FCMP_PREDICATE;
   if (const FCmpInst *FC = dyn_cast<FCmpInst>(&I))
     predicate = FC->getPredicate();
   else if (const ConstantExpr *FC = dyn_cast<ConstantExpr>(&I))
     predicate = FCmpInst::Predicate(FC->getPredicate());
   SDValue Op1 = getValue(I.getOperand(0));
   SDValue Op2 = getValue(I.getOperand(1));
SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I, unsigned Intrinsic) {
   case Intrinsic::experimental_constrained_maxnum:
   case Intrinsic::experimental_constrained_minnum:
   case Intrinsic::experimental_constrained_ceil:
   case Intrinsic::experimental_constrained_floor:
   case Intrinsic::experimental_constrained_round:
   case Intrinsic::experimental_constrained_trunc:
     visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(I));
     return nullptr;
+  case Intrinsic::experimental_constrained_fcmp:
+    visitConstrainedFCMPIntrinsic(cast<ConstrainedFPIntrinsic>(I));
+    return nullptr;
   case Intrinsic::fmuladd: {
     EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType());
     if (TM.Options.AllowFPOpFusion != FPOpFusion::Strict &&
         TLI.isFMAFasterThanFMulAndFAdd(VT)) {
       setValue(&I, DAG.getNode(ISD::FMA, sdl,
                                getValue(I.getArgOperand(0)).getValueType(),
                                getValue(I.getArgOperand(0)),
                                getValue(I.getArgOperand(1)),
case Intrinsic::experimental_constrained_floor:
     Opcode = ISD::STRICT_FFLOOR;
     break;
   case Intrinsic::experimental_constrained_round:
     Opcode = ISD::STRICT_FROUND;
     break;
   case Intrinsic::experimental_constrained_trunc:
     Opcode = ISD::STRICT_FTRUNC;
     break;
+  case Intrinsic::experimental_constrained_fcmp:
+    Opcode = ISD::STRICT_FCMP;
+    break;
   }
   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
   SDValue Chain = getRoot();
   SmallVector<EVT, 4> ValueVTs;
   ComputeValueVTs(TLI, DAG.getDataLayout(), FPI.getType(), ValueVTs);
   ValueVTs.push_back(MVT::Other); // Out chain
 
   SDVTList VTs = DAG.getVTList(ValueVTs);

lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

#endif
   case ISD::STACKRESTORE:               return "stackrestore";
   case ISD::TRAP:                       return "trap";
   case ISD::DEBUGTRAP:                  return "debugtrap";
   case ISD::LIFETIME_START:             return "lifetime.start";
   case ISD::LIFETIME_END:               return "lifetime.end";
   case ISD::GC_TRANSITION_START:        return "gc_transition.start";
   case ISD::GC_TRANSITION_END:          return "gc_transition.end";
   case ISD::GET_DYNAMIC_AREA_OFFSET:    return "get.dynamic.area.offset";
+  case ISD::STRICT_FCMP:                return "strict_fcmp";
 
   // Bit manipulation
   case ISD::ABS:                        return "abs";
   case ISD::BITREVERSE:                 return "bitreverse";
   case ISD::BSWAP:                      return "bswap";
   case ISD::CTPOP:                      return "ctpop";
   case ISD::CTTZ:                       return "cttz";
   case ISD::CTTZ_ZERO_UNDEF:            return "cttz_zero_undef";

lib/IR/IntrinsicInst.cpp

 }
 
 bool ConstrainedFPIntrinsic::isTernaryOp() const {
   switch (getIntrinsicID()) {
     default:
       return false;
     case Intrinsic::experimental_constrained_fma:
       return true;
+    case Intrinsic::experimental_constrained_fcmp:
+      return true;
   }
 }
 

lib/IR/Verifier.cpp

void Verifier::visitIntrinsicCallSite(Intrinsic::ID ID, CallSite CS) {
   case Intrinsic::experimental_constrained_rint:
   case Intrinsic::experimental_constrained_nearbyint:
   case Intrinsic::experimental_constrained_maxnum:
   case Intrinsic::experimental_constrained_minnum:
   case Intrinsic::experimental_constrained_ceil:
   case Intrinsic::experimental_constrained_floor:
   case Intrinsic::experimental_constrained_round:
   case Intrinsic::experimental_constrained_trunc:
+  case Intrinsic::experimental_constrained_fcmp:
     visitConstrainedFPIntrinsic(
         cast<ConstrainedFPIntrinsic>(*CS.getInstruction()));
     break;
   case Intrinsic::dbg_declare: // llvm.dbg.declare
     Assert(isa<MetadataAsValue>(CS.getArgOperand(0)),
            "invalid llvm.dbg.declare intrinsic call 1", CS);
     visitDbgIntrinsic("declare", cast<DbgVariableIntrinsic>(*CS.getInstruction()));
     break;

test/CodeGen/X86/fp-intrinsics.ll

entry:
   %rem = call double @llvm.experimental.constrained.frem.f64(
                                                double 1.000000e+00,
                                                double 1.000000e+01,
                                                metadata !"round.dynamic",
                                                metadata !"fpexcept.strict")
   ret double %rem
 }
 
+; CHECK-LABEL: f1
+define i1 @f20() {
+entry:
+  %cmp = call i1 @llvm.experimental.constrained.fcmp.f64(
+                                               i8 0,
+                                               double 1.000000e+00,
+                                               double 1.000000e+00,
+                                               metadata !"round.dynamic",
+                                               metadata !"fpexcept.strict")
+  ret i1 %cmp
+}
+
 @llvm.fp.env = thread_local global i8 zeroinitializer, section "llvm.metadata"
 declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.frem.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.pow.f64(double, double, metadata, metadata)
 declare double @llvm.experimental.constrained.powi.f64(double, i32, metadata, metadata)
 declare double @llvm.experimental.constrained.sin.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.cos.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.exp.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.exp2.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.log.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.log10.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.log2.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
 declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
 declare float @llvm.experimental.constrained.fma.f32(float, float, float, metadata, metadata)
 declare double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata)
+
+declare i1 @llvm.experimental.constrained.fcmp.f64(i8, double, double, metadata, metadata)