[SDAG] Add AllowContract to SNodeFlags

[anemet]

Summary

Properly propagate the FMF from the LLVM IR to this flag.

This is toward moving fp-contraction=fast from an LLVM TargetOption to a
FastMathFlag in order to fix PR25721.

[anemet]

Ping

[anemet]

@spatel, @arsenm, this is a trivial patch to expose the new FMF to SDAG. Since you guys looked at the rest of the LLVM patches in the set, would you mind reviewing this too?

[spatel]

In D31165#712564, @anemet wrote:

@spatel, @arsenm, this is a trivial patch to expose the new FMF to SDAG. Since you guys looked at the rest of the LLVM patches in the set, would you mind reviewing this too?

I actually haven't looked at all of the patches. Can you add me to those?

This patch LGTM. I made a couple of small suggestions for follow-ups.

I don't know if this is addressed in one of the other patches, but we'll want to extend FMF to more than binops...or we won't be able to propagate the contract flag to FMA nodes.

include/llvm/CodeGen/SelectionDAGNodes.h

396 ↗

(On Diff #92421)

VectorReduction is missing. It's an independent change from this patch of course, but since you're here...

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

2589 ↗

(On Diff #92421)

I hid these behind a flag, so it would be easier to test, but it should be safe to remove this now. It's an independent change from this patch of course, but since you're here... :)

[anemet]

In D31165#712632, @spatel wrote:

In D31165#712564, @anemet wrote:

@spatel, @arsenm, this is a trivial patch to expose the new FMF to SDAG. Since you guys looked at the rest of the LLVM patches in the set, would you mind reviewing this too?

I actually haven't looked at all of the patches. Can you add me to those?

You were already added to the LLVM patches (there is one left for now but I am working on more ;). I'll add you to the clang ones too.

This patch LGTM. I made a couple of small suggestions for follow-ups.

Thanks, Sanjay! I committed the changes you requested (r298962, r298963).

I don't know if this is addressed in one of the other patches, but we'll want to extend FMF to more than binops...or we won't be able to propagate the contract flag to FMA nodes.

Not, it's not addressed; we can do that later if it's useful. When is that useful?

[spatel]

In D31165#712746, @anemet wrote:

In D31165#712632, @spatel wrote:

I don't know if this is addressed in one of the other patches, but we'll want to extend FMF to more than binops...or we won't be able to propagate the contract flag to FMA nodes.

Not, it's not addressed; we can do that later if it's useful. When is that useful?

I'm not sure, but the examples in D31164 ( x + x + x -> 3*x ) made me think we're probably missing some folds that could involve an FMA. It definitely would help when fast/reassociate/unsafe are in play as we saw in D28675.

llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h

private:
   bool NoSignedWrap : 1;
   bool Exact : 1;
   bool UnsafeAlgebra : 1;
   bool NoNaNs : 1;
   bool NoInfs : 1;
   bool NoSignedZeros : 1;
   bool AllowReciprocal : 1;
   bool VectorReduction : 1;
+  bool AllowContract : 1;
 
 public:
   /// Default constructor turns off all optimization flags.
   SDNodeFlags()
       : NoUnsignedWrap(false), NoSignedWrap(false), Exact(false),
         UnsafeAlgebra(false), NoNaNs(false), NoInfs(false),
-        NoSignedZeros(false), AllowReciprocal(false), VectorReduction(false) {}
+        NoSignedZeros(false), AllowReciprocal(false), VectorReduction(false),
+        AllowContract(false) {}
 
   // These are mutators for each flag.
   void setNoUnsignedWrap(bool b) { NoUnsignedWrap = b; }
   void setNoSignedWrap(bool b) { NoSignedWrap = b; }
   void setExact(bool b) { Exact = b; }
   void setUnsafeAlgebra(bool b) { UnsafeAlgebra = b; }
   void setNoNaNs(bool b) { NoNaNs = b; }
   void setNoInfs(bool b) { NoInfs = b; }
   void setNoSignedZeros(bool b) { NoSignedZeros = b; }
   void setAllowReciprocal(bool b) { AllowReciprocal = b; }
   void setVectorReduction(bool b) { VectorReduction = b; }
+  void setAllowContract(bool b) { AllowContract = b; }
 
   // These are accessors for each flag.
   bool hasNoUnsignedWrap() const { return NoUnsignedWrap; }
   bool hasNoSignedWrap() const { return NoSignedWrap; }
   bool hasExact() const { return Exact; }
   bool hasUnsafeAlgebra() const { return UnsafeAlgebra; }
   bool hasNoNaNs() const { return NoNaNs; }
   bool hasNoInfs() const { return NoInfs; }
   bool hasNoSignedZeros() const { return NoSignedZeros; }
   bool hasAllowReciprocal() const { return AllowReciprocal; }
   bool hasVectorReduction() const { return VectorReduction; }
+  bool hasAllowContract() const { return AllowContract; }
 
   /// Clear any flags in this flag set that aren't also set in Flags.
   void intersectWith(const SDNodeFlags *Flags) {
     NoUnsignedWrap &= Flags->NoUnsignedWrap;
     NoSignedWrap &= Flags->NoSignedWrap;
     Exact &= Flags->Exact;
     UnsafeAlgebra &= Flags->UnsafeAlgebra;
     NoNaNs &= Flags->NoNaNs;
     NoInfs &= Flags->NoInfs;
     NoSignedZeros &= Flags->NoSignedZeros;
     AllowReciprocal &= Flags->AllowReciprocal;
+    AllowContract &= Flags->AllowContract;
   }
 };
 
 /// Represents one node in the SelectionDAG.
 ///
 class SDNode : public FoldingSetNode, public ilist_node<SDNode> {
 private:
   /// The operation that this node performs.

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitBinary(const User &I, unsigned OpCode) {
 
   SDNodeFlags Flags;
   Flags.setExact(exact);
   Flags.setNoSignedWrap(nsw);
   Flags.setNoUnsignedWrap(nuw);
   Flags.setVectorReduction(vec_redux);
   if (EnableFMFInDAG) {
     Flags.setAllowReciprocal(FMF.allowReciprocal());
+    Flags.setAllowContract(FMF.allowContract());
     Flags.setNoInfs(FMF.noInfs());
     Flags.setNoNaNs(FMF.noNaNs());
     Flags.setNoSignedZeros(FMF.noSignedZeros());
     Flags.setUnsafeAlgebra(FMF.unsafeAlgebra());
   }
   SDValue BinNodeValue = DAG.getNode(OpCode, getCurSDLoc(), Op1.getValueType(),
                                      Op1, Op2, &Flags);
   setValue(&I, BinNodeValue);