[clang][Interp] Implement ConditionalOperators

[tbaeder]

Summary

Implement visiting ConditionalOperators.

This also makes it possible to enable the first existing test case with the new constant interpreter. Although I'm not sure if I should actually do that, I quite enjoy just running ninja check-clang-ast-interp and run all the relevant tests in under 2 seconds.

[shafik]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

357

Maybe I am misunderstanding what this is doing but can't we just check the result of the condition and then just visit either the true or false branch?

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

357

That's what this code is doing in the "eval case" (i.e Emitter = EvalEmitter), but when we're emitting bytecode, we can of course not just check the condition but need to do that when the byte code is emitted.

That is, if I understand the question correctly.

[shafik]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

357

Makes sense, just me being dense then.

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.h

90

Do we want to handle BinaryConditionalOperator at the same time? (IIRC, you should be able to use AbstractConditionalOperator here and the logic is handled for you automagically for both constructs.) e.g.,

foo() ? 12 : bar  // C conditional operator, has the value 12 if foo() is nonzero and bar otherwise
foo() ? : bar // GNU "missing middle" conditional operator, has the value of foo() if nonzero and bar otherwise

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.h

90

Yep, that just worked

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/ByteCodeExprGen.h

public:
   bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E);
   bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
   bool VisitInitListExpr(const InitListExpr *E);
   bool VisitConstantExpr(const ConstantExpr *E);
   bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
   bool VisitMemberExpr(const MemberExpr *E);
   bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E);
   bool VisitOpaqueValueExpr(const OpaqueValueExpr *E);
+  bool VisitConditionalOperator(const ConditionalOperator *E);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::VisitArrayInitIndexExpr(
   return this->emitConstUint64(*ArrayIndex, E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
   return this->visit(E->getSourceExpr());
 }
 
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitConditionalOperator(
+    const ConditionalOperator *E) {
+  const Expr *Condition = E->getCond();
+  const Expr *TrueExpr = E->getTrueExpr();
+  const Expr *FalseExpr = E->getFalseExpr();
+
+  LabelTy LabelEnd = this->getLabel();   // Label after the operator.
+  LabelTy LabelFalse = this->getLabel(); // Label for the false expr.
+
+  if (!this->visit(Condition))
+    return false;
+  if (!this->jumpFalse(LabelFalse))
+    return false;
+
+  if (!this->visit(TrueExpr))
+    return false;
+  if (!this->jump(LabelEnd))
+    return false;
+
+  this->emitLabel(LabelFalse);
+
+  if (!this->visit(FalseExpr))
+    return false;
+
+  this->fallthrough(LabelEnd);
+  this->emitLabel(LabelEnd);
+
+  return true;
+}
+
 template <class Emitter> bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/true);
   return this->Visit(E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visit(const Expr *E) {
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/false);

clang/test/AST/Interp/literals.cpp

namespace div {
   static_assert(12 / -3 == -4, "");
   static_assert(-12 / 3 == -4, "");
 
 
   constexpr int LHS = 12;
   constexpr long unsigned RHS = 3;
   static_assert(LHS / RHS == 4, "");
 };
+
+namespace cond {
+  constexpr bool isEven(int n) {
+    return n % 2 == 0 ? true : false;
+  }
+  static_assert(isEven(2), "");
+  static_assert(!isEven(3), "");
+  static_assert(isEven(100), "");
+
+  constexpr int M = 5 ? 10 : 20;
+  static_assert(M == 10, "");
+
+  static_assert(5 ? 13 : 16 == 13, "");
+  static_assert(0 ? 13 : 16 == 16, "");
+
+#if __cplusplus >= 201402L
+  constexpr int N = 20;
+  constexpr int foo() {
+    int m = N > 0 ? 5 : 10;
+
+    return m == 5 ? isEven(m) : true;
+  }
+  static_assert(foo() == false, "");
+
+  constexpr int dontCallMe(unsigned m) {
+    if (m == 0) return 0;
+    return dontCallMe(m - 2);
+  }
+
+  // Can't call this because it will run into infinite recursion.
+  constexpr int assertNotReached() {
+    return dontCallMe(3);
+  }
+
+  constexpr int testCond() {
+    return true ? 5 : assertNotReached();
+  }
+
+  constexpr int testCond2() {
+    return false ? assertNotReached() : 10;
+  }
+
+  static_assert(testCond() == 5, "");
+  static_assert(testCond2() == 10, "");
+
+#endif
+
+};

clang/test/SemaCXX/constexpr-factorial.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fexperimental-new-constant-interpreter %s
 
 constexpr unsigned oddfac(unsigned n) {
   return n == 1 ? 1 : n * oddfac(n-2);
 }
 constexpr unsigned k = oddfac(123);
 
 using A = int[k % 256];
 using A = int[43];