[clang][Interp] Implement Div opcode

[tbaeder]

Summary

Same as the rem patch basically.

[tbaeder]

clang/lib/AST/Interp/Interp.h

200

Could use a helper function here and in Rem to reduce code duplication.

[erichkeane]

Seems good enoguh to me.

[shafik]

clang/lib/AST/Interp/Interp.h

194

Just like rem we need to catch INT_MIN / -1

CheckICE(...) looks like it does checking for both in the same spot.

[aaron.ballman]

clang/test/AST/Interp/literals.cpp

202

The only test coverage is for integer division; do you intend to also cover floating-point division?

[tbaeder]

clang/test/AST/Interp/literals.cpp

202

I added some float div coverage in https://reviews.llvm.org/D134859

[shafik]

clang/test/AST/Interp/literals.cpp

192

Can we add a test case for INT_MIN / -1 same for %

[aaron.ballman]

LGTM aside from a simple refactoring (feel free to apply it when landing or do it post-commit as an NFC change).

clang/lib/AST/Interp/Interp.h

203–211

We should factor this out into a helper function so we don't have duplication between Div and Rem. Same for the above block checking for division by zero.

[tbaeder]

In D134749#3839980, @aaron.ballman wrote:

LGTM aside from a simple refactoring (feel free to apply it when landing or do it post-commit as an NFC change).

I actually suggested something like this review :P I'll write it down and provide a follow-up NFC commit, thanks.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (Optional<PrimType> T = classify(BO->getType())) {
     case BO_Sub:
       return Discard(this->emitSub(*T, BO));
     case BO_Add:
       return Discard(this->emitAdd(*T, BO));
     case BO_Mul:
       return Discard(this->emitMul(*T, BO));
     case BO_Rem:
       return Discard(this->emitRem(*T, BO));
+    case BO_Div:
+      return Discard(this->emitDiv(*T, BO));
     case BO_Assign:
       if (!this->emitStore(*T, BO))
         return false;
       return DiscardResult ? this->emitPopPtr(BO) : true;
     default:
       return this->bail(BO);
     }
   }

clang/lib/AST/Interp/Integral.h

static bool mul(Integral A, Integral B, unsigned OpBits, Integral *R) {
     return CheckMulUB(A.V, B.V, R->V);
   }
 
   static bool rem(Integral A, Integral B, unsigned OpBits, Integral *R) {
     *R = Integral(A.V % B.V);
     return false;
   }
 
+  static bool div(Integral A, Integral B, unsigned OpBits, Integral *R) {
+    *R = Integral(A.V / B.V);
+    return false;
+  }
+
   static bool neg(Integral A, Integral *R) {
     *R = -A;
     return false;
   }
 
   static bool comp(Integral A, Integral *R) {
     *R = Integral(~A.V);
     return false;

clang/lib/AST/Interp/Interp.h

bool Rem(InterpState &S, CodePtr OpPC) {
   T Result;
   if (!T::rem(LHS, RHS, Bits, &Result)) {
     S.Stk.push<T>(Result);
     return true;
   }
   return false;
 }
 
+/// 1) Pops the RHS from the stack.
+/// 2) Pops the LHS from the stack.
+/// 3) Pushes 'LHS / RHS' on the stack
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Div(InterpState &S, CodePtr OpPC) {
+  const T &RHS = S.Stk.pop<T>();
+  const T &LHS = S.Stk.pop<T>();
+
+  if (RHS.isZero()) {
+    const SourceInfo &Loc = S.Current->getSource(OpPC);
+    S.FFDiag(Loc, diag::note_expr_divide_by_zero);
+    return false;
+  }
+
+  if (LHS.isSigned() && LHS.isMin() && RHS.isNegative() && RHS.isMinusOne()) {
+    APSInt LHSInt = LHS.toAPSInt();
+    SmallString<32> Trunc;
+    (-LHSInt.extend(LHSInt.getBitWidth() + 1)).toString(Trunc, 10);
+    const SourceInfo &Loc = S.Current->getSource(OpPC);
+    const Expr *E = S.Current->getExpr(OpPC);
+    S.CCEDiag(Loc, diag::note_constexpr_overflow) << Trunc << E->getType();
+    return false;
+  }
+
+  const unsigned Bits = RHS.bitWidth() * 2;
+  T Result;
+  if (!T::div(LHS, RHS, Bits, &Result)) {
+    S.Stk.push<T>(Result);
+    return true;
+  }
+  return false;
+}
+
 //===----------------------------------------------------------------------===//
 // Inv
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Inv(InterpState &S, CodePtr OpPC) {
   using BoolT = PrimConv<PT_Bool>::T;
   const T &Val = S.Stk.pop<T>();

clang/lib/AST/Interp/Opcodes.td

 // [Real, Real] -> [Real]
 def Sub : AluOpcode;
 def Add : AluOpcode;
 def Mul : AluOpcode;
 def Rem : Opcode {
   let Types = [NumberTypeClass];
   let HasGroup = 1;
 }
-
+def Div : Opcode {
+  let Types = [NumberTypeClass];
+  let HasGroup = 1;
+}
 
 //===----------------------------------------------------------------------===//
 // Unary operators.
 //===----------------------------------------------------------------------===//
 
 // [Real] -> [Real]
 def Inv: Opcode {
   let Types = [BoolTypeClass];

clang/test/AST/Interp/literals.cpp

static_assert(true % false == 10, ""); // ref-error {{not an integral constant expression}} \
                                          // expected-error {{not an integral constant expression}} \
                                          // expected-note {{division by zero}}
   constexpr int x = INT_MIN % - 1; // ref-error {{must be initialized by a constant expression}} \
                                    // ref-note {{value 2147483648 is outside the range}} \
                                    // expected-error {{must be initialized by a constant expression}} \
                                    // expected-note {{value 2147483648 is outside the range}} \
 
 };
+
+namespace div {
+  constexpr int zero() { return 0; }
+  static_assert(12 / 3 == 4, "");
+  static_assert(12 / zero() == 12, ""); // ref-error {{not an integral constant expression}} \
+                                        // ref-note {{division by zero}} \
+                                        // expected-error {{not an integral constant expression}} \
+                                        // expected-note {{division by zero}}
+  static_assert(12 / -3 == -4, "");
+  static_assert(-12 / 3 == -4, "");
+
+
+  constexpr int LHS = 12;
+  constexpr long unsigned RHS = 3;
+  static_assert(LHS / RHS == 4, "");
+
+  constexpr int x = INT_MIN / - 1; // ref-error {{must be initialized by a constant expression}} \
+                                   // ref-note {{value 2147483648 is outside the range}} \
+                                   // expected-error {{must be initialized by a constant expression}} \
+                                   // expected-note {{value 2147483648 is outside the range}} \
+
+};