FastMathFlags: Make it easier to unset individual ones.

[Nicola]

Summary

This makes the various flags similar to current setAllowContract.

I added a default argument that sets them to true to avoid breaking the current uses.

[spatel]

LGTM - thanks!

See https://bugs.llvm.org/show_bug.cgi?id=37581 for an independent bug based on this code.

include/llvm/IR/Operator.h

210–214

Run clang-format on this?

Would be easier to see that these are all the same basic logic if they all had the function body on a separate line.

[Nicola]

include/llvm/IR/Operator.h

210–214

I did, that's how it ended up like that :(

I'll make it look "nice" again and submit.

include/llvm/IR/Operator.h

   bool noSignedZeros() const   { return 0 != (Flags & NoSignedZeros); }
   bool allowReciprocal() const { return 0 != (Flags & AllowReciprocal); }
   bool allowContract() const   { return 0 != (Flags & AllowContract); }
   bool approxFunc() const      { return 0 != (Flags & ApproxFunc); }
   /// 'Fast' means all bits are set.
   bool isFast() const          { return all(); }
 
   /// Flag setters
-  void setAllowReassoc()    { Flags |= AllowReassoc; }
-  void setNoNaNs()          { Flags |= NoNaNs; }
-  void setNoInfs()          { Flags |= NoInfs; }
-  void setNoSignedZeros()   { Flags |= NoSignedZeros; }
-  void setAllowReciprocal() { Flags |= AllowReciprocal; }
-  // TODO: Change the other set* functions to take a parameter?
-  void setAllowContract(bool B) {
+  void setAllowReassoc(bool B = true) {
+    Flags = (Flags & ~AllowReassoc) | B * AllowReassoc;
+  }
+  void setNoNaNs(bool B = true) { Flags = (Flags & ~NoNaNs) | B * NoNaNs; }
+  void setNoInfs(bool B = true) { Flags = (Flags & ~NoInfs) | B * NoInfs; }
+  void setNoSignedZeros(bool B = true) {
+    Flags = (Flags & ~NoSignedZeros) | B * NoSignedZeros;
+  }
+  void setAllowReciprocal(bool B = true) {
+    Flags = (Flags & ~AllowReciprocal) | B * AllowReciprocal;
+  }
+  void setAllowContract(bool B = true) {
     Flags = (Flags & ~AllowContract) | B * AllowContract;
   }
-  void setApproxFunc()      { Flags |= ApproxFunc; }
-  void setFast()            { set(); }
+  void setApproxFunc(bool B = true) {
+    Flags = (Flags & ~ApproxFunc) | B * ApproxFunc;
+  }
+  void setFast(bool B = true) { B ? set() : clear(); }
 
   void operator&=(const FastMathFlags &OtherFlags) {
     Flags &= OtherFlags.Flags;
   }
 };
 
 /// Utility class for floating point operations which can have
 /// information about relaxed accuracy requirements attached to them.