[clang][Interp] Implement inc/dec operators for floats

[tbaeder]

Summary

Looks like I forgot these.

[erichkeane]

This looks right to me.

clang/lib/AST/Interp/Floating.h

118

Extra new line vs the decrement? Obviously the nittiest of nits.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

case UO_PostInc: { // x++
 
     if (T == PT_Ptr) {
       if (!this->emitIncPtr(E))
         return false;
 
       return DiscardResult ? this->emitPopPtr(E) : true;
     }
 
+    if (T == PT_Float) {
+      return DiscardResult ? this->emitIncfPop(getRoundingMode(E), E)
+                           : this->emitIncf(getRoundingMode(E), E);
+    }
+
     return DiscardResult ? this->emitIncPop(*T, E) : this->emitInc(*T, E);
   }
   case UO_PostDec: { // x--
     if (!this->visit(SubExpr))
       return false;
 
     if (T == PT_Ptr) {
       if (!this->emitDecPtr(E))
         return false;
 
       return DiscardResult ? this->emitPopPtr(E) : true;
     }
 
+    if (T == PT_Float) {
+      return DiscardResult ? this->emitDecfPop(getRoundingMode(E), E)
+                           : this->emitDecf(getRoundingMode(E), E);
+    }
+
     return DiscardResult ? this->emitDecPop(*T, E) : this->emitDec(*T, E);
   }
   case UO_PreInc: { // ++x
     if (!this->visit(SubExpr))
       return false;
 
     if (T == PT_Ptr) {
       this->emitLoadPtr(E);
       this->emitConstUint8(1, E);
       this->emitAddOffsetUint8(E);
       return DiscardResult ? this->emitStorePopPtr(E) : this->emitStorePtr(E);
     }
 
     // Post-inc and pre-inc are the same if the value is to be discarded.
-    if (DiscardResult)
+    if (DiscardResult) {
+      if (T == PT_Float)
+        return this->emitIncfPop(getRoundingMode(E), E);
       return this->emitIncPop(*T, E);
+    }
 
+    if (T == PT_Float) {
+      const auto &TargetSemantics = Ctx.getFloatSemantics(E->getType());
+      this->emitLoadFloat(E);
+      this->emitConstFloat(llvm::APFloat(TargetSemantics, 1), E);
+      this->emitAddf(getRoundingMode(E), E);
+      return this->emitStoreFloat(E);
+    }
     this->emitLoad(*T, E);
     this->emitConst(1, E);
     this->emitAdd(*T, E);
     return this->emitStore(*T, E);
   }
   case UO_PreDec: { // --x
     if (!this->visit(SubExpr))
       return false;
 
     if (T == PT_Ptr) {
       this->emitLoadPtr(E);
       this->emitConstUint8(1, E);
       this->emitSubOffsetUint8(E);
       return DiscardResult ? this->emitStorePopPtr(E) : this->emitStorePtr(E);
     }
 
     // Post-dec and pre-dec are the same if the value is to be discarded.
-    if (DiscardResult)
+    if (DiscardResult) {
+      if (T == PT_Float)
+        return this->emitDecfPop(getRoundingMode(E), E);
       return this->emitDecPop(*T, E);
+    }
 
+    if (T == PT_Float) {
+      const auto &TargetSemantics = Ctx.getFloatSemantics(E->getType());
+      this->emitLoadFloat(E);
+      this->emitConstFloat(llvm::APFloat(TargetSemantics, 1), E);
+      this->emitSubf(getRoundingMode(E), E);
+      return this->emitStoreFloat(E);
+    }
     this->emitLoad(*T, E);
     this->emitConst(1, E);
     this->emitSub(*T, E);
     return this->emitStore(*T, E);
   }
   case UO_LNot: // !x
     if (!this->visit(SubExpr))
       return false;

clang/lib/AST/Interp/Floating.h

public:
   // -------
 
   static APFloat::opStatus add(Floating A, Floating B, llvm::RoundingMode RM,
                                Floating *R) {
     *R = Floating(A.F);
     return R->F.add(B.F, RM);
   }
 
+  static APFloat::opStatus increment(const Floating &A, llvm::RoundingMode RM,
+                                     Floating *R) {
+    APFloat One(A.F.getSemantics(), 1);
+    *R = Floating(A.F);
+    return R->F.add(One, RM);
+  }
+
   static APFloat::opStatus sub(Floating A, Floating B, llvm::RoundingMode RM,
                                Floating *R) {
     *R = Floating(A.F);
     return R->F.subtract(B.F, RM);
   }
 
+  static APFloat::opStatus decrement(const Floating &A, llvm::RoundingMode RM,
+                                     Floating *R) {
+    APFloat One(A.F.getSemantics(), 1);
+    *R = Floating(A.F);
+    return R->F.subtract(One, RM);
+  }
+
   static APFloat::opStatus mul(Floating A, Floating B, llvm::RoundingMode RM,
                                Floating *R) {
     *R = Floating(A.F);
     return R->F.multiply(B.F, RM);
   }
 
   static APFloat::opStatus div(Floating A, Floating B, llvm::RoundingMode RM,
                                Floating *R) {

clang/lib/AST/Interp/Interp.h

 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool DecPop(InterpState &S, CodePtr OpPC) {
   // FIXME: Check initialization of Ptr
   const Pointer &Ptr = S.Stk.pop<Pointer>();
 
   return IncDecHelper<T, IncDecOp::Dec, PushVal::No>(S, OpPC, Ptr);
 }
 
+template <IncDecOp Op, PushVal DoPush>
+bool IncDecFloatHelper(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
+                       llvm::RoundingMode RM) {
+  Floating Value = Ptr.deref<Floating>();
+  Floating Result;
+
+  if constexpr (DoPush == PushVal::Yes)
+    S.Stk.push<Floating>(Value);
+
+  llvm::APFloat::opStatus Status;
+  if constexpr (Op == IncDecOp::Inc)
+    Status = Floating::increment(Value, RM, &Result);
+  else
+    Status = Floating::decrement(Value, RM, &Result);
+
+  Ptr.deref<Floating>() = Result;
+
+  return CheckFloatResult(S, OpPC, Status);
+}
+
+inline bool Incf(InterpState &S, CodePtr OpPC, llvm::RoundingMode RM) {
+  // FIXME: Check initialization of Ptr
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  return IncDecFloatHelper<IncDecOp::Inc, PushVal::Yes>(S, OpPC, Ptr, RM);
+}
+
+inline bool IncfPop(InterpState &S, CodePtr OpPC, llvm::RoundingMode RM) {
+  // FIXME: Check initialization of Ptr
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  return IncDecFloatHelper<IncDecOp::Inc, PushVal::No>(S, OpPC, Ptr, RM);
+}
+
+inline bool Decf(InterpState &S, CodePtr OpPC, llvm::RoundingMode RM) {
+  // FIXME: Check initialization of Ptr
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  return IncDecFloatHelper<IncDecOp::Dec, PushVal::Yes>(S, OpPC, Ptr, RM);
+}
+
+inline bool DecfPop(InterpState &S, CodePtr OpPC, llvm::RoundingMode RM) {
+  // FIXME: Check initialization of Ptr
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  return IncDecFloatHelper<IncDecOp::Dec, PushVal::No>(S, OpPC, Ptr, RM);
+}
+
 /// 1) Pops the value from the stack.
 /// 2) Pushes the bitwise complemented value on the stack (~V).
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Comp(InterpState &S, CodePtr OpPC) {
   const T &Val = S.Stk.pop<T>();
   T Result;
   if (!T::comp(Val, &Result)) {
     S.Stk.push<T>(Result);

clang/lib/AST/Interp/Opcodes.td

 //===----------------------------------------------------------------------===//
 
 // [Real] -> [Real]
 def Inv: Opcode {
   let Types = [BoolTypeClass];
   let HasGroup = 1;
 }
 
+// Increment and decrement.
 def Inc: IntegerOpcode;
 def IncPop : IntegerOpcode;
 def Dec: IntegerOpcode;
 def DecPop: IntegerOpcode;
 
+// Float increment and decrement.
+def Incf: FloatOpcode;
+def IncfPop : FloatOpcode;
+def Decf: FloatOpcode;
+def DecfPop : FloatOpcode;
+
 // [Real] -> [Real]
 def Neg: Opcode {
   let Types = [NonPtrTypeClass];
   let HasGroup = 1;
 }
 
 // [Real] -> [Real]
 def Comp: Opcode {

clang/test/AST/Interp/floats.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify %s
 // RUN: %clang_cc1 -verify=ref %s
 
+
+constexpr void assert(bool C) {
+  if (C)
+    return;
+  // Invalid in constexpr.
+  (void)(1 / 0); // expected-warning {{undefined}} \
+                 // ref-warning {{undefined}}
+}
+
 constexpr int i = 2;
 constexpr float f = 1.0f;
 static_assert(f == 1.0f, "");
 
 constexpr float f2 = 1u * f;
 static_assert(f2 == 1.0f, "");
 
 constexpr float f3 = 1.5;
namespace compound {
   constexpr float f2() {
     float f = __FLT_MAX__;
     f += 1.0;
     return f;
   }
   static_assert(f2() == __FLT_MAX__, "");
 }
 
+namespace unary {
+  constexpr float a() {
+    float f = 0.0;
+    assert(++f == 1.0);
+    assert(f == 1.0);
+    ++f;
+    f++;
+    assert(f == 3.0);
+    --f;
+    f--;
+    assert(f == 1.0);
+    return 1.0;
+  }
+  static_assert(a() == 1.0);
+
+  constexpr float b() {
+    float f = __FLT_MAX__;
+    f++;
+    return f;
+  }
+  static_assert(b() == __FLT_MAX__);
+}
+
+
 namespace ZeroInit {
   template<typename FloatT>
   struct A {
     int a;
     FloatT f;
   };
 
   constexpr A<float> a{12};
   static_assert(a.f == 0.0f, "");
 
   constexpr A<double> b{12};
   static_assert(a.f == 0.0, "");
 };