[clang][Interp] Implement missing compound assign operators

[aaron.ballman]

clang/test/AST/Interp/literals.cpp

553

static_assert(IntRem(9, 0) == 12, ""); // Not constexpr
static_assert(IntRem(__INT_MIN__, -1) == 12, ""); // Not constexpr

572–573

Same suggestion for div as for rem

595

An overflow test would be good here.

[aaron.ballman]

Precommit CI looks to have potentially found something interesting here.

clang/test/AST/Interp/literals.cpp

553

Missed the test for INT_MIN and -1?

[tbaeder]

In D137071#3915565, @aaron.ballman wrote:

Precommit CI looks to have potentially found something interesting here.

There might be one of my local patches missing, but it looks like it's somehow not applying this patch, which is weird.

clang/test/AST/Interp/literals.cpp

553

for rem, clang doesn't diagnose anything: https://godbolt.org/z/rhe5ezc54

[aaron.ballman]

clang/test/AST/Interp/literals.cpp

553

That's a bug per https://eel.is/c++draft/expr.mul#4.sentence-3 because the resulting algebraic value is not representable in the type of the result.

591

This one should fail for the same reason as %

[tbaeder]

clang/test/AST/Interp/literals.cpp

591

Works when replacing all the unsigneds with ints.

[aaron.ballman]

LGTM

[tbaeder]

Can't push this without https://reviews.llvm.org/D135750, since the variables in the test functions are used without being initialized.

[shafik]

LGTM

clang/test/AST/Interp/literals.cpp

553

Ok, this bugged me enough I figured out what was going on and put up a PR: https://reviews.llvm.org/D140455

[tbaeder]

Really didn't expect this: https://lab.llvm.org/buildbot/#/builders/214/builds/5415

Command Output (stderr):
--
+ : 'RUN: at line 1'
+ /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/build/bin/clang -cc1 -internal-isystem /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/build/lib/clang/16/include -nostdsysteminc -fexperimental-new-constant-interpreter -std=c++11 -verify /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/llvm-project/clang/test/AST/Interp/literals.cpp
+ : 'RUN: at line 2'
+ /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/build/bin/clang -cc1 -internal-isystem /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/build/lib/clang/16/include -nostdsysteminc -fexperimental-new-constant-interpreter -std=c++20 -verify /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/llvm-project/clang/test/AST/Interp/literals.cpp
error: 'error' diagnostics seen but not expected: 
  File /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/llvm-project/clang/test/AST/Interp/literals.cpp Line 481: static assertion failed due to requirement 'BoolOr(false, true)': 
  File /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/llvm-project/clang/test/AST/Interp/literals.cpp Line 500: static assertion failed due to requirement 'BoolAnd(true, true)': 
  File /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/llvm-project/clang/test/AST/Interp/literals.cpp Line 521: static assertion failed due to requirement '!BoolXor(true, true)': 
  File /scratch/powerllvm/powerllvm_env/aix-ppc64/clang-ppc64-aix/llvm-project/clang/test/AST/Interp/literals.cpp Line 523: static assertion failed due to requirement 'BoolXor(false, true)': 
4 errors generated.

[tbaeder]

I've seen s390x and AIX builders break here, probably a problem with big-endian machines?

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::VisitCharacterLiteral(
   return this->emitConst(E->getValue(), E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCompoundAssignOperator(
     const CompoundAssignOperator *E) {
   const Expr *LHS = E->getLHS();
   const Expr *RHS = E->getRHS();
-  std::optional<PrimType> LT = classify(E->getLHS()->getType());
-  std::optional<PrimType> RT = classify(E->getRHS()->getType());
+  std::optional<PrimType> LT = classify(E->getComputationLHSType());
+  std::optional<PrimType> RT = classify(E->getComputationResultType());
 
   if (!LT || !RT)
     return false;
 
   assert(!E->getType()->isPointerType() &&
          "Support pointer arithmethic in compound assignment operators");
 
   // Get LHS pointer, load its value and get RHS value.
bool ByteCodeExprGen<Emitter>::VisitCompoundAssignOperator(
   case BO_AddAssign:
     if (!this->emitAdd(*LT, E))
       return false;
     break;
   case BO_SubAssign:
     if (!this->emitSub(*LT, E))
       return false;
     break;
-
   case BO_MulAssign:
+    if (!this->emitMul(*LT, E))
+      return false;
+    break;
   case BO_DivAssign:
+    if (!this->emitDiv(*LT, E))
+      return false;
+    break;
   case BO_RemAssign:
+    if (!this->emitRem(*LT, E))
+      return false;
+    break;
   case BO_ShlAssign:
     if (!this->emitShl(*LT, *RT, E))
       return false;
     break;
   case BO_ShrAssign:
     if (!this->emitShr(*LT, *RT, E))
       return false;
     break;
   case BO_AndAssign:
+    if (!this->emitBitAnd(*LT, E))
+      return false;
+    break;
   case BO_XorAssign:
+    if (!this->emitBitXor(*LT, E))
+      return false;
+    break;
   case BO_OrAssign:
+    if (!this->emitBitOr(*LT, E))
+      return false;
+    break;
   default:
     llvm_unreachable("Unimplemented compound assign operator");
   }
 
   // And store the result in LHS.
   if (DiscardResult)
     return this->emitStorePop(*LT, E);
   return this->emitStore(*LT, E);

clang/test/AST/Interp/literals.cpp

static_assert(sub(INT_MIN, 1) == 0, ""); // expected-error {{not an integral constant expression}} \
                                            // expected-note {{in call to 'sub}} \
                                            // ref-error {{not an integral constant expression}} \
                                            // ref-note {{in call to 'sub}}
 
   constexpr int subAll(int a) {
     return (a -= a);
   }
   static_assert(subAll(213) == 0, "");
+
+  constexpr bool BoolOr(bool b1, bool b2) {
+    bool a;
+    a = b1;
+    a |= b2;
+    return a;
+  }
+  static_assert(BoolOr(true, true), "");
+  static_assert(BoolOr(true, false), "");
+  static_assert(BoolOr(false, true), "");
+  static_assert(!BoolOr(false, false), "");
+
+  constexpr int IntOr(unsigned a, unsigned b) {
+    unsigned r;
+    r = a;
+    r |= b;
+    return r;
+  }
+  static_assert(IntOr(10, 1) == 11, "");
+  static_assert(IntOr(1337, -1) == -1, "");
+  static_assert(IntOr(0, 12) == 12, "");
+
+  constexpr bool BoolAnd(bool b1, bool b2) {
+    bool a;
+    a = b1;
+    a &= b2;
+    return a;
+  }
+  static_assert(BoolAnd(true, true), "");
+  static_assert(!BoolAnd(true, false), "");
+  static_assert(!BoolAnd(false, true), "");
+  static_assert(!BoolAnd(false, false), "");
+
+  constexpr int IntAnd(unsigned a, unsigned b) {
+    unsigned r;
+    r = a;
+    r &= b;
+    return r;
+  }
+  static_assert(IntAnd(10, 1) == 0, "");
+  static_assert(IntAnd(1337, -1) == 1337, "");
+  static_assert(IntAnd(0, 12) == 0, "");
+
+  constexpr bool BoolXor(bool b1, bool b2) {
+    bool a;
+    a = b1;
+    a ^= b2;
+    return a;
+  }
+  static_assert(!BoolXor(true, true), "");
+  static_assert(BoolXor(true, false), "");
+  static_assert(BoolXor(false, true), "");
+  static_assert(!BoolXor(false, false), "");
+
+  constexpr int IntXor(unsigned a, unsigned b) {
+    unsigned r;
+    r = a;
+    r ^= b;
+    return r;
+  }
+  static_assert(IntXor(10, 1) == 11, "");
+  static_assert(IntXor(10, 10) == 0, "");
+  static_assert(IntXor(12, true) == 13, "");
+
+  constexpr bool BoolRem(bool b1, bool b2) {
+    bool a;
+    a = b1;
+    a %= b2;
+    return a;
+  }
+  static_assert(!BoolRem(true, true), "");
+  static_assert(!BoolRem(false, true), "");
+
+  constexpr int IntRem(int a, int b) {
+    int r;
+    r = a;
+    r %= b; // expected-note {{division by zero}} \
+            // ref-note {{division by zero}} \
+            // expected-note {{outside the range of representable values}} \
+            // ref-note {{outside the range of representable values}}
+    return r;
+  }
+  static_assert(IntRem(2, 2) == 0, "");
+  static_assert(IntRem(2, 1) == 0, "");
+  static_assert(IntRem(9, 7) == 2, "");
+  static_assert(IntRem(5, 0) == 0, ""); // expected-error {{not an integral constant expression}} \
+                                        // expected-note {{in call to 'IntRem(5, 0)'}} \
+                                        // ref-error {{not an integral constant expression}} \
+                                        // ref-note {{in call to 'IntRem(5, 0)'}}
+
+  static_assert(IntRem(INT_MIN, -1) == 0, ""); // expected-error {{not an integral constant expression}} \
+                                               // expected-note {{in call to 'IntRem}} \
+                                               // ref-error {{not an integral constant expression}} \
+                                               // ref-note {{in call to 'IntRem}}
+
+
+
+  constexpr bool BoolDiv(bool b1, bool b2) {
+    bool a;
+    a = b1;
+    a /= b2;
+    return a;
+  }
+  static_assert(BoolDiv(true, true), "");
+  static_assert(!BoolDiv(false, true), "");
+
+  constexpr int IntDiv(int a, int b) {
+    int r;
+    r = a;
+    r /= b; // expected-note {{division by zero}} \
+            // ref-note {{division by zero}} \
+            // expected-note {{outside the range of representable values}} \
+            // ref-note {{outside the range of representable values}}
+    return r;
+  }
+  static_assert(IntDiv(2, 2) == 1, "");
+  static_assert(IntDiv(12, 20) == 0, "");
+  static_assert(IntDiv(2, 1) == 2, "");
+  static_assert(IntDiv(9, 7) == 1, "");
+  static_assert(IntDiv(5, 0) == 0, ""); // expected-error {{not an integral constant expression}} \
+                                        // expected-note {{in call to 'IntDiv(5, 0)'}} \
+                                        // ref-error {{not an integral constant expression}} \
+                                        // ref-note {{in call to 'IntDiv(5, 0)'}}
+
+  static_assert(IntDiv(INT_MIN, -1) == 0, ""); // expected-error {{not an integral constant expression}} \
+                                               // expected-note {{in call to 'IntDiv}} \
+                                               // ref-error {{not an integral constant expression}} \
+                                               // ref-note {{in call to 'IntDiv}}
+
+  constexpr bool BoolMul(bool b1, bool b2) {
+    bool a;
+    a = b1;
+    a *= b2;
+    return a;
+  }
+  static_assert(BoolMul(true, true), "");
+  static_assert(!BoolMul(true, false), "");
+  static_assert(!BoolMul(false, true), "");
+  static_assert(!BoolMul(false, false), "");
+
+  constexpr int IntMul(int a, int b) {
+    int r;
+    r = a;
+    r *= b; // expected-note {{is outside the range of representable values of type 'int'}} \
+            // ref-note {{is outside the range of representable values of type 'int'}}
+    return r;
+  }
+  static_assert(IntMul(2, 2) == 4, "");
+  static_assert(IntMul(12, 20) == 240, "");
+  static_assert(IntMul(2, 1) == 2, "");
+  static_assert(IntMul(9, 7) == 63, "");
+  static_assert(IntMul(INT_MAX, 2) == 0, ""); // expected-error {{not an integral constant expression}} \
+                                              // expected-note {{in call to 'IntMul}} \
+                                              // ref-error {{not an integral constant expression}} \
+                                              // ref-note {{in call to 'IntMul}}
 };
 #endif