[ConstExprPreter] Implemented control flow statements

[nand]

Summary

Added support for:

• for
• switch
• do-while
• while

Also implemented assignment to enable useful tests.

The patch also includes range-based for loops which are
not yet tested, but having them in ByteCodeStmtGen should
simplify the process of slicing off further patches.

[nand]

rebase

[nand]

ping

clang/lib/AST/Interp/ByteCodeEmitter.cpp

for (const ParmVarDecl *PD : F->parameters()) {
     ParamOffset += align(primSize(Ty));
     ParamTypes.push_back(Ty);
   }
 
   // Create a handle over the emitted code.
   Function *Func = P.createFunction(F, ParamOffset, std::move(ParamTypes),
                                     std::move(ParamDescriptors));
   // Compile the function body.
-  if (!F->isConstexpr() || !visitFunc(F)) {
-    // Return a dummy function if compilation failed.
-    if (BailLocation)
+  if (!F->isConstexpr()) {
+    // Return a dummy function for non-constexpr.
+    return Func;
+  } else if (!visitFunc(F)) {
+    if (BailLocation) {
+      // If compiler bailed, return an error.
       return llvm::make_error<ByteCodeGenError>(*BailLocation);
-    else
+    } else {
+      // Otherwise, return a dummy function which is not constexpr.
       return Func;
+    }
   } else {
     // Create scopes from descriptors.
     llvm::SmallVector<Scope, 2> Scopes;
     for (auto &DS : Descriptors) {
       Scopes.emplace_back(std::move(DS));
     }
 
     // Set the function's code.

clang/lib/AST/Interp/ByteCodeExprGen.h

public:
   bool VisitCastExpr(const CastExpr *E);
   bool VisitConstantExpr(const ConstantExpr *E);
   bool VisitIntegerLiteral(const IntegerLiteral *E);
   bool VisitParenExpr(const ParenExpr *E);
   bool VisitBinaryOperator(const BinaryOperator *E);
   bool VisitUnaryMinus(const UnaryOperator *E);
   bool VisitCallExpr(const CallExpr *E);
 
+  // Fallback methods for nodes which are not yet implemented.
+  bool VisitStmt(const Stmt *E) { llvm_unreachable("not an expression"); }
+  bool VisitExpr(const Expr *E) { return this->bail(E); }
+
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();
 
private:
   friend class LocalScope<Emitter>;
   friend class RecordScope<Emitter>;
   friend class OptionScope<Emitter>;
 
   /// Emits a direct function call.
   bool emitFunctionCall(const FunctionDecl *Callee, llvm::Optional<PrimType> T,
                         const Expr *Call);
 
+  bool visitAssign(PrimType T, const BinaryOperator *BO);
+
   enum class DerefKind {
     /// Value is read and pushed to stack.
     Read,
     /// Direct method generates a value which is written. Returns pointer.
     Write,
     /// Direct method receives the value, pushes mutated value. Returns pointer.
     ReadWrite,
   };

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::VisitBinaryOperator(const BinaryOperator *BO) {
 
   auto Discard = [this, T, BO](bool Result) {
     if (!Result)
       return false;
     return DiscardResult ? this->emitPop(*T, BO) : true;
   };
 
   switch (BO->getOpcode()) {
+  case BO_Assign:
+    return visitAssign(*T, BO);
   case BO_EQ: return Discard(this->emitEQ(*LT, *T, BO));
   case BO_NE: return Discard(this->emitNE(*LT, *T, BO));
   case BO_LT: return Discard(this->emitLT(*LT, *T, BO));
   case BO_LE: return Discard(this->emitLE(*LT, *T, BO));
   case BO_GT: return Discard(this->emitGT(*LT, *T, BO));
   case BO_GE: return Discard(this->emitGE(*LT, *T, BO));
   case BO_Sub: return Discard(this->emitSub(*T, BO));
   case BO_Add: return Discard(this->emitAdd(*T, BO));
if (Expected<Function *> Func = P.getOrCreateFunction(S, Callee)) {
     if (*Func) {
       if (!this->emitCall(*Func, E))
         return false;
     } else {
       if (!this->emitNoCall(Callee, E))
         return false;
     }
   } else {
-    consumeError(Func.takeError());
-    return this->bail(E);
+    handleAllErrors(Func.takeError(), [this](ByteCodeGenError &Err) {
+      S.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
+    });
+    return false;
   }
   return DiscardResult && T ? this->emitPop(*T, E) : true;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   QualType Ty = E->getType();
   if (Ty->isVoidType() || !E->isRValue() || classify(Ty)) {
if (!visit(E))
       return false;
     return (*T != PT_Bool) ? this->emitTest(*T, E) : true;
   } else {
     return this->bail(E);
   }
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitAssign(PrimType T,
+                                           const BinaryOperator *BO) {
+  return dereference(
+      BO->getLHS(), DerefKind::Write,
+      [this, BO](PrimType) {
+        // Generate a value to store - will be set.
+        return visit(BO->getRHS());
+      },
+      [this, BO](PrimType T) {
+        // Pointer on stack - compile RHS and assign to pointer.
+        if (!visit(BO->getRHS()))
+          return false;
+
+        if (BO->getLHS()->refersToBitField()) {
+          return this->bail(BO);
+        } else {
+          if (DiscardResult)
+            return this->emitStorePop(T, BO);
+          else
+            return this->emitStore(T, BO);
+        }
+      });
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereference(
     const Expr *LV, DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
     llvm::function_ref<bool(PrimType)> Indirect) {
   if (Optional<PrimType> T = classify(LV->getType())) {
     if (!LV->refersToBitField()) {
       // Only primitive, non bit-field types can be dereferenced directly.
       if (auto *DE = dyn_cast<DeclRefExpr>(LV)) {
         if (!DE->getDecl()->getType()->isReferenceType()) {

clang/lib/AST/Interp/ByteCodeStmtGen.h

private:
   friend class LabelScope<Emitter>;
   friend class LoopScope<Emitter>;
   friend class SwitchScope<Emitter>;
 
   // Statement visitors.
   bool visitStmt(const Stmt *S);
   bool visitCompoundStmt(const CompoundStmt *S);
   bool visitDeclStmt(const DeclStmt *DS);
+  bool visitForStmt(const ForStmt *FS);
+  bool visitWhileStmt(const WhileStmt *DS);
+  bool visitDoStmt(const DoStmt *DS);
   bool visitReturnStmt(const ReturnStmt *RS);
   bool visitIfStmt(const IfStmt *IS);
+  bool visitBreakStmt(const BreakStmt *BS);
+  bool visitContinueStmt(const ContinueStmt *CS);
+  bool visitSwitchStmt(const SwitchStmt *SS);
+  bool visitCaseStmt(const SwitchCase *CS);
+  bool visitCXXForRangeStmt(const CXXForRangeStmt *FS);
 
   /// Compiles a variable declaration.
   bool visitVarDecl(const VarDecl *VD);
 
 private:
   /// Type of the expression returned by the function.
   llvm::Optional<PrimType> ReturnType;
 

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitStmt(const Stmt *S) {
   switch (S->getStmtClass()) {
   case Stmt::CompoundStmtClass:
     return visitCompoundStmt(cast<CompoundStmt>(S));
   case Stmt::DeclStmtClass:
     return visitDeclStmt(cast<DeclStmt>(S));
+  case Stmt::ForStmtClass:
+    return visitForStmt(cast<ForStmt>(S));
+  case Stmt::WhileStmtClass:
+    return visitWhileStmt(cast<WhileStmt>(S));
+  case Stmt::DoStmtClass:
+    return visitDoStmt(cast<DoStmt>(S));
   case Stmt::ReturnStmtClass:
     return visitReturnStmt(cast<ReturnStmt>(S));
   case Stmt::IfStmtClass:
     return visitIfStmt(cast<IfStmt>(S));
+  case Stmt::BreakStmtClass:
+    return visitBreakStmt(cast<BreakStmt>(S));
+  case Stmt::ContinueStmtClass:
+    return visitContinueStmt(cast<ContinueStmt>(S));
+  case Stmt::SwitchStmtClass:
+    return visitSwitchStmt(cast<SwitchStmt>(S));
+  case Stmt::CaseStmtClass:
+  case Stmt::DefaultStmtClass:
+    return visitCaseStmt(cast<SwitchCase>(S));
+  case Stmt::CXXForRangeStmtClass:
+    return visitCXXForRangeStmt(cast<CXXForRangeStmt>(S));
   case Stmt::NullStmtClass:
     return true;
   default: {
     if (auto *Exp = dyn_cast<Expr>(S))
       return this->discard(Exp);
     return this->bail(S);
   }
   }
 }
 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitCompoundStmt(
     const CompoundStmt *CompoundStmt) {
   BlockScope<Emitter> Scope(this);
-  for (auto *InnerStmt : CompoundStmt->body())
+  for (auto *InnerStmt : CompoundStmt->body()) {
     if (!visitStmt(InnerStmt))
       return false;
+  }
   return true;
 }
 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitDeclStmt(const DeclStmt *DS) {
   for (auto *D : DS->decls()) {
     // Variable declarator.
     if (auto *VD = dyn_cast<VarDecl>(D)) {
       if (!visitVarDecl(VD))
         return false;
       continue;
     }
 
     // Decomposition declarator.
     if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
       return this->bail(DD);
     }
   }
 
   return true;
 }
 
 template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitForStmt(const ForStmt *FS) {
+  // Compile the initialisation statement in an outer scope.
+  BlockScope<Emitter> OuterScope(this);
+  if (auto *Init = FS->getInit())
+    if (!visitStmt(Init))
+      return false;
+
+  LabelTy LabelStart = this->getLabel();
+  LabelTy LabelEnd = this->getLabel();
+
+  // Compile the condition, body and increment in the loop scope.
+  this->emitLabel(LabelStart);
+  {
+    BlockScope<Emitter> InnerScope(this);
+
+    if (auto *Cond = FS->getCond()) {
+      if (auto *CondDecl = FS->getConditionVariableDeclStmt())
+        if (!visitDeclStmt(CondDecl))
+          return false;
+
+      if (!this->visit(Cond))
+        return false;
+
+      if (!this->jumpFalse(LabelEnd))
+        return false;
+    }
+
+    if (auto *Body = FS->getBody()) {
+      LabelTy LabelSkip = this->getLabel();
+      LoopScope<Emitter> FlowScope(this, LabelEnd, LabelSkip);
+      if (!visitStmt(Body))
+        return false;
+      this->emitLabel(LabelSkip);
+    }
+
+    if (auto *Inc = FS->getInc()) {
+      ExprScope<Emitter> IncScope(this);
+      if (!this->discard(Inc))
+        return false;
+    }
+    if (!this->jump(LabelStart))
+      return false;
+  }
+  this->emitLabel(LabelEnd);
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitWhileStmt(const WhileStmt *WS) {
+  LabelTy LabelStart = this->getLabel();
+  LabelTy LabelEnd = this->getLabel();
+
+  this->emitLabel(LabelStart);
+  {
+    BlockScope<Emitter> InnerScope(this);
+    if (auto *CondDecl = WS->getConditionVariableDeclStmt())
+      if (!visitDeclStmt(CondDecl))
+        return false;
+
+    if (!this->visit(WS->getCond()))
+      return false;
+
+    if (!this->jumpFalse(LabelEnd))
+      return false;
+
+    {
+      LoopScope<Emitter> FlowScope(this, LabelEnd, LabelStart);
+      if (!visitStmt(WS->getBody()))
+        return false;
+    }
+    if (!this->jump(LabelStart))
+      return false;
+  }
+  this->emitLabel(LabelEnd);
+
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitDoStmt(const DoStmt *DS) {
+  LabelTy LabelStart = this->getLabel();
+  LabelTy LabelEnd = this->getLabel();
+  LabelTy LabelSkip = this->getLabel();
+
+  this->emitLabel(LabelStart);
+  {
+    {
+      LoopScope<Emitter> FlowScope(this, LabelEnd, LabelSkip);
+      if (!visitStmt(DS->getBody()))
+        return false;
+      this->emitLabel(LabelSkip);
+    }
+
+    {
+      ExprScope<Emitter> CondScope(this);
+      if (!this->visitBool(DS->getCond()))
+        return false;
+    }
+
+    if (!this->jumpTrue(LabelStart))
+      return false;
+  }
+  this->emitLabel(LabelEnd);
+
+  return true;
+}
+
+template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitReturnStmt(const ReturnStmt *RS) {
   if (const Expr *RE = RS->getRetValue()) {
     ExprScope<Emitter> RetScope(this);
     if (ReturnType) {
       // Primitive types are simply returned.
       if (!this->visit(RE))
         return false;
       this->emitCleanup();
if (!visitStmt(IS->getThen()))
       return false;
     this->emitLabel(LabelEnd);
   }
 
   return true;
 }
 
 template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitBreakStmt(const BreakStmt *BS) {
+  if (!BreakLabel)
+    return this->bail(BS);
+  return this->jump(*BreakLabel);
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitContinueStmt(const ContinueStmt *CS) {
+  if (!ContinueLabel)
+    return this->bail(CS);
+  return this->jump(*ContinueLabel);
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitSwitchStmt(const SwitchStmt *SS) {
+  BlockScope<Emitter> InnerScope(this);
+
+  if (Optional<PrimType> T = this->classify(SS->getCond()->getType())) {
+    // The condition is stored in a local and fetched for every test.
+    unsigned Off = this->allocateLocalPrimitive(SS->getCond(), *T,
+                                                /*isConst=*/true);
+
+    // Compile the condition in its own scope.
+    {
+      ExprScope<Emitter> CondScope(this);
+      if (const Stmt *CondInit = SS->getInit())
+        if (!visitStmt(SS->getInit()))
+          return false;
+
+      if (const DeclStmt *CondDecl = SS->getConditionVariableDeclStmt())
+        if (!visitDeclStmt(CondDecl))
+          return false;
+
+      if (!this->visit(SS->getCond()))
+        return false;
+
+      if (!this->emitSetLocal(*T, Off, SS->getCond()))
+        return false;
+    }
+
+    LabelTy LabelEnd = this->getLabel();
+
+    // Generate code to inspect all case labels, jumping to the matched one.
+    const DefaultStmt *Default = nullptr;
+    CaseMap Labels;
+    for (auto *SC = SS->getSwitchCaseList(); SC; SC = SC->getNextSwitchCase()) {
+      LabelTy Label = this->getLabel();
+      Labels.insert({SC, Label});
+
+      if (auto *DS = dyn_cast<DefaultStmt>(SC)) {
+        Default = DS;
+        continue;
+      }
+
+      if (auto *CS = dyn_cast<CaseStmt>(SC)) {
+        if (!this->emitGetLocal(*T, Off, CS))
+          return false;
+        if (!this->visit(CS->getLHS()))
+          return false;
+
+        if (auto *RHS = CS->getRHS()) {
+          if (!this->visit(CS->getRHS()))
+            return false;
+          if (!this->emitInRange(*T, CS))
+            return false;
+        } else {
+          if (!this->emitEQ(*T, PT_Bool, CS))
+            return false;
+        }
+
+        if (!this->jumpTrue(Label))
+          return false;
+        continue;
+      }
+
+      return this->bail(SS);
+    }
+
+    // If a case wasn't matched, jump to default or skip the body.
+    if (!this->jump(Default ? Labels[Default] : LabelEnd))
+      return false;
+    OptLabelTy DefaultLabel = Default ? Labels[Default] : OptLabelTy{};
+
+    // Compile the body, using labels defined previously.
+    SwitchScope<Emitter> LabelScope(this, std::move(Labels), LabelEnd,
+                                    DefaultLabel);
+    if (!visitStmt(SS->getBody()))
+      return false;
+    this->emitLabel(LabelEnd);
+    return true;
+  } else {
+    return this->bail(SS);
+  }
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitCaseStmt(const SwitchCase *CS) {
+  auto It = CaseLabels.find(CS);
+  if (It == CaseLabels.end())
+    return this->bail(CS);
+
+  this->emitLabel(It->second);
+  return visitStmt(CS->getSubStmt());
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitCXXForRangeStmt(const CXXForRangeStmt *FS) {
+  BlockScope<Emitter> Scope(this);
+
+  // Emit the optional init-statement.
+  if (auto *Init = FS->getInit()) {
+    if (!visitStmt(Init))
+      return false;
+  }
+
+  // Initialise the __range variable.
+  if (!visitStmt(FS->getRangeStmt()))
+    return false;
+
+  // Create the __begin and __end iterators.
+  if (!visitStmt(FS->getBeginStmt()) || !visitStmt(FS->getEndStmt()))
+    return false;
+
+  LabelTy LabelStart = this->getLabel();
+  LabelTy LabelEnd = this->getLabel();
+
+  this->emitLabel(LabelStart);
+  {
+    // Lower the condition.
+    if (!this->visitBool(FS->getCond()))
+      return false;
+    if (!this->jumpFalse(LabelEnd))
+      return false;
+
+    // Lower the loop var and body, marking labels for continue/break.
+    {
+      BlockScope<Emitter> InnerScope(this);
+      if (!visitStmt(FS->getLoopVarStmt()))
+        return false;
+
+      LabelTy LabelSkip = this->getLabel();
+      {
+        LoopScope<Emitter> FlowScope(this, LabelEnd, LabelSkip);
+
+        if (!visitStmt(FS->getBody()))
+          return false;
+      }
+      this->emitLabel(LabelSkip);
+    }
+
+    // Increment: ++__begin
+    if (!visitStmt(FS->getInc()))
+      return false;
+    if (!this->jump(LabelStart))
+      return false;
+  }
+  this->emitLabel(LabelEnd);
+  return true;
+}
+
+template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitVarDecl(const VarDecl *VD) {
   auto DT = VD->getType();
 
   if (!VD->hasLocalStorage()) {
     // No code generation required.
     return true;
   }
 

clang/lib/AST/Interp/Context.h

public:
   bool isOpenCL() { return getLangOpts().OpenCL; }
   /// Checks is language mode is C++20.
   bool isCPlusPlus2a() { return getLangOpts().CPlusPlus2a; }
 
   /// Classifies an expression.
   llvm::Optional<PrimType> classify(QualType T);
 
 private:
-  /// Runs a function.
-  bool Run(State &Parent, Function *Func, APValue &Result);
-
-  /// Checks a result fromt the interpreter.
-  bool Check(State &Parent, llvm::Expected<bool> &&R);
-
-private:
   /// Current compilation context.
   ASTContext &Ctx;
   /// Interpreter stack, shared across invocations.
   InterpStack Stk;
   /// Constexpr program.
   std::unique_ptr<Program> P;
 };
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Context.cpp

 using namespace clang;
 using namespace clang::interp;
 
 Context::Context(ASTContext &Ctx) : Ctx(Ctx), P(new Program(*this)) {}
 
 Context::~Context() {}
 
 bool Context::isPotentialConstantExpr(State &Parent, const FunctionDecl *FD) {
+  // Try to compile the function. This either produces an error message (if this
+  // is the first attempt to compile) or returns a dummy function with no body.
   Function *Func = P->getFunction(FD);
   if (!Func) {
     ByteCodeStmtGen<ByteCodeEmitter> C(*this, *P, Parent);
     if (auto R = C.compileFunc(FD)) {
       Func = *R;
     } else {
       handleAllErrors(R.takeError(), [&Parent](ByteCodeGenError &Err) {
         Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
       });
       return false;
     }
   }
 
+  // If function has no body, it is definitely not constexpr.
   if (!Func->isConstexpr())
     return false;
 
-  APValue Dummy;
-  return Run(Parent, Func, Dummy);
+  // Run the function in a dummy context.
+  APValue DummyResult;
+  InterpState State(Parent, *P, Stk, *this);
+  State.Current = new InterpFrame(State, Func, nullptr, {}, {});
+  if (Interpret(State, DummyResult))
+    return true;
+  Stk.clear();
+  return false;
 }
 
 bool Context::evaluateAsRValue(State &Parent, const Expr *E, APValue &Result) {
   ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
-  return Check(Parent, C.interpretExpr(E));
+  if (auto Flag = C.interpretExpr(E)) {
+    return *Flag;
+  } else {
+    handleAllErrors(Flag.takeError(), [&Parent](ByteCodeGenError &Err) {
+      Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
+    });
+    return false;
+  }
 }
 
 bool Context::evaluateAsInitializer(State &Parent, const VarDecl *VD,
                                     APValue &Result) {
   ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
-  return Check(Parent, C.interpretDecl(VD));
+  if (auto Flag = C.interpretDecl(VD)) {
+    return *Flag;
+  } else {
+    handleAllErrors(Flag.takeError(), [&Parent](ByteCodeGenError &Err) {
+      Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
+    });
+    return false;
+  }
 }
 
 const LangOptions &Context::getLangOpts() const { return Ctx.getLangOpts(); }
 
 llvm::Optional<PrimType> Context::classify(QualType T) {
   // Pointer type check.
   if (T->isReferenceType())
     return PT_Ptr;
if (auto *AT = dyn_cast<AtomicType>(T))
     return classify(AT->getValueType());
 
   return {};
 }
 
 unsigned Context::getCharBit() const {
   return Ctx.getTargetInfo().getCharWidth();
 }
-
-bool Context::Run(State &Parent, Function *Func, APValue &Result) {
-  InterpState State(Parent, *P, Stk, *this);
-  State.Current = new InterpFrame(State, Func, nullptr, {}, {});
-  if (Interpret(State, Result))
-    return true;
-  Stk.clear();
-  return false;
-}
-
-bool Context::Check(State &Parent, llvm::Expected<bool> &&Flag) {
-  if (Flag)
-    return *Flag;
-  handleAllErrors(Flag.takeError(), [&Parent](ByteCodeGenError &Err) {
-    Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
-  });
-  return false;
-}

clang/lib/AST/Interp/EvalEmitter.cpp

 }
 
 bool EvalEmitter::executeCall(Function *F, Pointer &&This,
                               const SourceInfo &Info) {
   if (!S.CheckCallable(OpPC, F->getDecl()))
     return false;
   if (S.checkingPotentialConstantExpression())
     return false;
+  if (!F->isConstexpr())
+    return false;
   S.Current = new InterpFrame(S, F, S.Current, OpPC, std::move(This));
   return Interpret(S, Result);
 }
 
 bool EvalEmitter::executeNoCall(const FunctionDecl *F, const SourceInfo &Info) {
   if (!S.CheckCallable(OpPC, F))
     return false;
   if (S.checkingPotentialConstantExpression())

clang/lib/AST/Interp/InterpLoop.cpp

 //===----------------------------------------------------------------------===//
 
 static bool HandleCall(InterpState &S, CodePtr &PC, CodePtr OpPC, Function *F,
                        Pointer &&This) {
   if (!S.CheckCallable(OpPC, F->getDecl()))
     return false;
   if (S.checkingPotentialConstantExpression())
     return false;
+  if (!F->isConstexpr())
+    return false;
 
   // Adjust the state.
   S.CallStackDepth++;
 
   // Construct a new frame.
   S.Current = new InterpFrame(S, F, S.Current, PC, std::move(This));
 
   // Transfer control to the callee.

clang/lib/AST/Interp/Opcodes.td

let Types = [Sint8, Uint8, Sint16, Uint16, Sint32,
                Uint32, Sint64, Uint64, Bool];
 }
 
 def PtrTypeClass : TypeClass {
   let Types = [Ptr];
 }
 
 def FPTypeClass : TypeClass {
-  let Types = IntTypeClass.Types;
+  let Types = [];
+}
+
+def IntFPTypeClass : TypeClass {
+  let Types = !listconcat(IntTypeClass.Types, FPTypeClass.Types);
 }
 
 def AluFPRealFPTypeClass : TypeClass {
   let Types = IntTypeClass.Types;
 }
 
 def AllTypeClass : TypeClass {
   let Types = !listconcat(AluFPRealFPTypeClass.Types, PtrTypeClass.Types);

 def EQ : ComparisonOpcode;
 def NE : ComparisonOpcode;
 def LT : ComparisonOpcode;
 def LE : ComparisonOpcode;
 def GT : ComparisonOpcode;
 def GE : ComparisonOpcode;
 
 //===----------------------------------------------------------------------===//
+// Range test.
+//===----------------------------------------------------------------------===//
+
+// [Real, Real, Real] -> [Bool]
+def InRange : Opcode {
+  let Types = [IntFPTypeClass];
+  let HasGroup = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // Stack management.
 //===----------------------------------------------------------------------===//
 
 // [Value] -> []
 def Pop : Opcode {
   let Types = [AllTypeClass];
   let HasGroup = 1;
 }

clang/lib/AST/Interp/Opcodes/Comparison.h

template <PrimType Name, PrimType Flag> bool GE(InterpState &S, CodePtr OpPC) {
   if (auto R = detail::CmpWrapperOrdered<Name>(S, OpPC)) {
     bool Result = *R == CmpResult::Greater || *R == CmpResult::Equal;
     S.Stk.push<FlagTy>(FlagTy::from(Result));
     return true;
   }
   return false;
 }
 
+template <PrimType Name>
+bool InRange(InterpState &S, CodePtr OpPC) {
+  using T = typename PrimConv<Name>::T;
+  const T &RHS = S.Stk.pop<T>();
+  const T &LHS = S.Stk.pop<T>();
+  const T &Value = S.Stk.pop<T>();
+
+  S.Stk.push<bool>(LHS <= Value && Value <= RHS);
+  return true;
+}
+
 #endif