[Clang][Interp] Add some basic functionality to the experimental new constant interpreter

[tbaeder]

Summary

Hi,

I wanted to maybe work on the new experimental constant interpreter in clang. I took last week to get to know the code a little and implement some basic functionality.

New in this patch are:

• Simple function calls
• array initializers and subscript expressions
• pointer reference and dereference
• local and global variables

Some tests for the functionality is in test/AST/Interp/interp.cpp.

As far as I know the interpreter has been abandoned quite some time ago, so I was just looking for some basic feedback about whether this is worth it to pursue. If the feedback is positive, I will continue working on it.

[erichkeane]

So you're right, we haven't seen much work on this interpreter in a while, and I have no real experience with reviewing it at all, which I'm sure is the experience of most of my co-reviewers.

At the same time, I believe there is good potential in this interpreter, so I would love to see progress on it.

SO, if you could start by splitting this patch up into the smallest parts possible, it would be really appreciated. This patch seems to be doing a lot, and I'm a bit overwhelmed trying to review it all at once.

Additionally, I suspect there is going to be a LOT of tests, so I'd suggest writing 1 whole 'test file' per topic (instead of throwing everything into interp.cpp). I also suspect that there is need for more in depth testing than that. For exmaple, 'if' statements likely need to check things like side-effects and init statements/etc.

One valuable strategy might be to temporarily switch this over to the 'default' interpreter in your local workspace, make changes, and see if you can add a new 'run' line to any existing tests that each individual change you make causes to pass.

[tbaeder]

Thanks for the fast reply, Erich!

In D131888#3723017, @erichkeane wrote:

So you're right, we haven't seen much work on this interpreter in a while, and I have no real experience with reviewing it at all, which I'm sure is the experience of most of my co-reviewers.

Sure, that's expected.

At the same time, I believe there is good potential in this interpreter, so I would love to see progress on it.

SO, if you could start by splitting this patch up into the smallest parts possible, it would be really appreciated. This patch seems to be doing a lot, and I'm a bit overwhelmed trying to review it all at once.

I actually have several smaller patches locally but merged them into one for review :) I'll try to find a middle way.

Additionally, I suspect there is going to be a LOT of tests, so I'd suggest writing 1 whole 'test file' per topic (instead of throwing everything into interp.cpp). I also suspect that there is need for more in depth testing than that. For exmaple, 'if' statements likely need to check things like side-effects and init statements/etc.

One valuable strategy might be to temporarily switch this over to the 'default' interpreter in your local workspace, make changes, and see if you can add a new 'run' line to any existing tests that each individual change you make causes to pass.

I tried running the clang testsuite locally with the new interpreter, but basically all tests fail because something is missing, so I think that's gonna have to wait. But adding more files and tests on a per-patch basis is a good approach.

clang/lib/AST/Interp/Boolean.h

static bool sub(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
     *R = Boolean(A.V ^ B.V);
     return false;
   }
 
   static bool mul(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
     *R = Boolean(A.V && B.V);
     return false;
   }
+
+  static bool inv(Boolean A, Boolean *R) {
+    *R = Boolean(!A.V);
+    return false;
+  }
+
+  static bool neg(Boolean A, Boolean *R) {
+    *R = Boolean(-A.V);
+    return false;
+  }
 };
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Boolean &B) {
   B.print(OS);
   return OS;
 }
 
 }  // namespace interp
 }  // namespace clang
 
 #endif

clang/lib/AST/Interp/ByteCodeExprGen.h

 template <class Emitter> class DeclScope;
 template <class Emitter> class OptionScope;
 
 /// Compilation context for expressions.
 template <class Emitter>
 class ByteCodeExprGen : public ConstStmtVisitor<ByteCodeExprGen<Emitter>, bool>,
                         public Emitter {
 protected:
-  // Emitters for opcodes of various arities.
-  using NullaryFn = bool (ByteCodeExprGen::*)(const SourceInfo &);
-  using UnaryFn = bool (ByteCodeExprGen::*)(PrimType, const SourceInfo &);
-  using BinaryFn = bool (ByteCodeExprGen::*)(PrimType, PrimType,
-                                             const SourceInfo &);
-
-  // Aliases for types defined in the emitter.
-  using LabelTy = typename Emitter::LabelTy;
-  using AddrTy = typename Emitter::AddrTy;
-
-  // Reference to a function generating the pointer of an initialized object.s
+  // Reference to a function generating the pointer of an initialized object.
   using InitFnRef = std::function<bool()>;
 
+  // Function initializing a variable with the value on the stack.
+  using InitElemRef = std::function<bool(PrimType, unsigned)>;
+
   /// Current compilation context.
   Context &Ctx;
   /// Program to link to.
   Program &P;
 
 public:
   /// Initializes the compiler and the backend emitter.
   template <typename... Tys>
   ByteCodeExprGen(Context &Ctx, Program &P, Tys &&... Args)
       : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
 
   // Expression visitors - result returned on stack.
   bool VisitCastExpr(const CastExpr *E);
   bool VisitIntegerLiteral(const IntegerLiteral *E);
+  bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E);
   bool VisitParenExpr(const ParenExpr *E);
   bool VisitBinaryOperator(const BinaryOperator *E);
+  bool VisitCallExpr(const CallExpr *E);
+  bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E);
+  bool VisitUnaryOperator(const UnaryOperator *E);
+  bool VisitInitListExpr(const InitListExpr *E);
+  bool VisitDeclRefExpr(const DeclRefExpr *E);
+  bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();
PrimType classifyPrim(QualType Ty) const {
     }
     llvm_unreachable("not a primitive type");
   }
 
   /// Evaluates an expression for side effects and discards the result.
   bool discard(const Expr *E);
   /// Evaluates an expression and places result on stack.
   bool visit(const Expr *E);
-  /// Compiles an initializer for a local.
-  bool visitInitializer(const Expr *E, InitFnRef GenPtr);
+  /// Compiles an initializer.
+  bool visitInitializer(const Expr *E, InitFnRef GenPtr, InitElemRef InitElem);
 
   /// Visits an expression and converts it to a boolean.
   bool visitBool(const Expr *E);
 
   /// Visits an initializer for a local.
   bool visitLocalInitializer(const Expr *Init, unsigned I) {
-    return visitInitializer(Init, [this, I, Init] {
-      return this->emitGetPtrLocal(I, Init);
+    return visitInitializer(
+        Init, [this, I, Init] { return this->emitGetPtrLocal(I, Init); },
+        [this, Init](PrimType T, unsigned ElemIndex) {
+          return this->emitInitElem(T, ElemIndex, Init);
         });
   }
 
   /// Visits an initializer for a global.
   bool visitGlobalInitializer(const Expr *Init, unsigned I) {
-    return visitInitializer(Init, [this, I, Init] {
-      return this->emitGetPtrGlobal(I, Init);
+    return visitInitializer(
+        Init, [this, I, Init] { return this->emitGetPtrGlobal(I, Init); },
+        [this, Init](PrimType T, unsigned ElemIndex) {
+          return this->emitInitElem(T, ElemIndex, Init);
         });
   }
 
   /// Visits a delegated initializer.
   bool visitThisInitializer(const Expr *I) {
-    return visitInitializer(I, [this, I] { return this->emitThis(I); });
+    return visitInitializer(
+        I, [this, I] { return this->emitThis(I); },
+        [](PrimType T, unsigned EI) { return true; });
   }
 
   /// Creates a local primitive value.
   unsigned allocateLocalPrimitive(DeclTy &&Decl, PrimType Ty, bool IsMutable,
                                   bool IsExtended = false);
 
   /// Allocates a space storing a local given its type.
   llvm::Optional<unsigned> allocateLocal(DeclTy &&Decl,
protected:
   llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
 
   /// OpaqueValueExpr to location mapping.
   llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
 
   /// Current scope.
   VariableScope<Emitter> *VarScope = nullptr;
 
-  /// Current argument index.
-  llvm::Optional<uint64_t> ArrayIndex;
-
   /// Flag indicating if return value is to be discarded.
   bool DiscardResult = false;
 
   /// Expression being initialized.
   llvm::Optional<InitFnRef> InitFn = {};
 };
 
 extern template class ByteCodeExprGen<ByteCodeEmitter>;

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 };
 
 } // namespace interp
 } // namespace clang
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
   auto *SubExpr = CE->getSubExpr();
-  switch (CE->getCastKind()) {
 
+  switch (CE->getCastKind()) {
   case CK_LValueToRValue: {
     return dereference(
-        CE->getSubExpr(), DerefKind::Read,
+        SubExpr, DerefKind::Read,
         [](PrimType) {
           // Value loaded - nothing to do here.
           return true;
         },
-        [this, CE](PrimType T) {
-          // Pointer on stack - dereference it.
+        [this, CE, SubExpr](PrimType T) {
+          if (isa<DeclRefExpr>(SubExpr->IgnoreImpCasts())) {
             if (!this->emitLoadPop(T, CE))
               return false;
             return DiscardResult ? this->emitPop(T, CE) : true;
+          }
+          return true;
         });
   }
 
   case CK_ArrayToPointerDecay:
   case CK_AtomicToNonAtomic:
   case CK_ConstructorConversion:
   case CK_FunctionToPointerDecay:
   case CK_NonAtomicToAtomic:
   case CK_NoOp:
   case CK_UserDefinedConversion:
+  case CK_NullToPointer:
+  case CK_IntegralCast:
     return this->Visit(SubExpr);
 
   case CK_ToVoid:
     return discard(SubExpr);
 
-  default: {
-    // TODO: implement other casts.
-    return this->bail(CE);
-  }
+  case CK_IntegralToBoolean:
+    return this->visitBool(SubExpr);
+
+  default:
+    llvm_unreachable("cast not implemented");
   }
+  return this->bail(CE);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitIntegerLiteral(const IntegerLiteral *LE) {
   if (DiscardResult)
     return true;
 
   auto Val = LE->getValue();
   QualType LitTy = LE->getType();
   if (Optional<PrimType> T = classify(LitTy))
     return emitConst(*T, getIntWidth(LitTy), LE->getValue(), LE);
   return this->bail(LE);
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXNullPtrLiteralExpr(
+    const CXXNullPtrLiteralExpr *E) {
+  return this->emitNullPtr(E);
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitParenExpr(const ParenExpr *PE) {
   return this->Visit(PE->getSubExpr());
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitBinaryOperator(const BinaryOperator *BO) {
   const Expr *LHS = BO->getLHS();
   const Expr *RHS = BO->getRHS();
bool ByteCodeExprGen<Emitter>::VisitBinaryOperator(const BinaryOperator *BO) {
   // Typecheck the args.
   Optional<PrimType> LT = classify(LHS->getType());
   Optional<PrimType> RT = classify(RHS->getType());
   if (!LT || !RT) {
     return this->bail(BO);
   }
 
   if (Optional<PrimType> T = classify(BO->getType())) {
+    // Handle assignments separately.
+    if (BO->getOpcode() == BO_Assign) {
+      // No type checks here since all this needs to be true right now.
       if (!visit(LHS))
         return false;
       if (!visit(RHS))
         return false;
 
+      if (!this->emitStore(*T, BO))
+        return false;
+
+      // TODO: This should go away.
+      return this->emitPopPtr(BO);
+    }
+
+    if (!visit(LHS))
+      return false;
+
+    if (!visit(RHS)) {
+      // Get rid of LHS on stack.
+      this->emitPop(*LT, BO);
+      return false;
+    }
+
     auto Discard = [this, T, BO](bool Result) {
       if (!Result)
         return false;
       return DiscardResult ? this->emitPop(*T, BO) : true;
     };
 
     switch (BO->getOpcode()) {
     case BO_EQ:
default:
       return this->bail(BO);
     }
   }
 
   return this->bail(BO);
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitArraySubscriptExpr(
+    const ArraySubscriptExpr *E) {
+  const Expr *Base = E->getBase();
+  const Expr *Index = E->getIdx();
+
+  // Take pointer of LHS, add offset from RHS, dereference result.
+  if (Optional<PrimType> T = classify(E->getType())) {
+    if (!this->Visit(Base))
+      return false;
+
+    if (!this->Visit(Index))
+      return false;
+
+    if (!this->emitAddOffset(*T, E))
+      return false;
+
+    if (!this->emitLoadPop(*T, E))
+      return false;
+
+    return true;
+  }
+
+  return false;
+}
+
+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);
ByteCodeExprGen<Emitter>::allocateLocal(DeclTy &&Src, bool IsExtended) {
   Scope::Local Local = this->createLocal(D);
   if (Key)
     Locals.insert({Key, Local});
   VarScope->add(Local, IsExtended);
   return Local.Offset;
 }
 
 template <class Emitter>
-bool ByteCodeExprGen<Emitter>::visitInitializer(
-    const Expr *Init, InitFnRef InitFn) {
-  OptionScope<Emitter> Scope(this, InitFn);
-  return this->Visit(Init);
+bool ByteCodeExprGen<Emitter>::visitInitializer(const Expr *Initializer,
+                                                InitFnRef GenPtr,
+                                                InitElemRef InitElem) {
+
+  if (const auto *InitList = cast<InitListExpr>(Initializer)) {
+
+    // Get a pointer to the value being initialized on the stack.
+    if (!GenPtr())
+      return false;
+
+    unsigned ElementIndex = 0;
+    // We assume here that the current stack top is a pointer
+    // to the value being initialized.
+    for (const Expr *Init : InitList->inits()) {
+      if (!this->Visit(Init)) {
+        return false;
+      }
+      Optional<PrimType> InitType = classify(Init);
+      assert(InitType);
+
+      if (!InitElem(*InitType, ElementIndex))
+        return false;
+
+      ++ElementIndex;
+    }
+
+    // Pop the initialized pointer
+    return this->emitPopPtr(Initializer);
+  }
+
+  return this->Visit(Initializer);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::getPtrVarDecl(const VarDecl *VD, const Expr *E) {
   // Generate a pointer to the local, loading refs.
   if (Optional<unsigned> Idx = getGlobalIdx(VD)) {
     if (VD->getType()->isReferenceType())
       return this->emitGetGlobalPtr(*Idx, E);
if (Optional<PrimType> T = classify(VD->getType())) {
       return this->emitRetValue(VD);
     }
   }
 
   return this->bail(VD);
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCallExpr(const CallExpr *E) {
+  if (unsigned BuiltinOp = E->getBuiltinCallee()) {
+    switch (BuiltinOp) {
+    default:
+      llvm_unreachable("Builtin function not implemented");
+    }
+    return false;
+  }
+
+  const Decl *Callee = E->getCalleeDecl();
+  if (const auto *FuncDecl = dyn_cast_or_null<FunctionDecl>(Callee)) {
+    Function *Func = P.getFunction(FuncDecl);
+    // TODO: templated functions might need to be instantiated here if they
+    // don't exist yet.
+    assert(Func);
+
+    if (Optional<PrimType> T = classify(E->getType())) {
+      // Put arguments on the stack
+      for (const auto *Arg : E->arguments()) {
+        // TODO: Is this always the correct thing to do?
+        visit(Arg);
+      }
+
+      this->emitCall(*T, Func, E);
+      return true;
+    } else {
+      assert(false && "Can't classify function return type");
+    }
+
+  } else {
+    assert(false && "We don't support non-FunctionDecl callees right now.");
+  }
+
+  return false;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXBoolLiteralExpr(
+    const CXXBoolLiteralExpr *E) {
+  if (DiscardResult)
+    return true;
+  return emitConst(E, E->getValue());
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryOperator(const UnaryOperator *E) {
+  switch (E->getOpcode()) {
+  case UO_PostInc: // x++
+  case UO_PostDec: // x--
+  case UO_PreInc:  // --x
+  case UO_PreDec:  // ++x
+    return false;
+
+  case UO_LNot: // !x
+    if (!this->Visit(E->getSubExpr()))
+      return false;
+    return this->emitInvBool(E);
+  case UO_Minus: // -x
+    if (!this->Visit(E->getSubExpr()))
+      return false;
+    // TODO: Special-case integer literals.
+    if (Optional<PrimType> T = classify(E->getType()))
+      return this->emitNeg(*T, E);
+    return false;
+  case UO_Plus:                          // +x
+    return this->Visit(E->getSubExpr()); // noop
+
+  case UO_Deref: // *x
+    return dereference(
+        E->getSubExpr(), DerefKind::Read,
+        [](PrimType) {
+          llvm_unreachable("Dereferencing requires a pointer");
+          return false;
+        },
+        [this, E](PrimType T) {
+          // T: type we get here from classify() is the subexpr
+          // TODO: Is this right?
+          T = *classify(E->getType());
+          if (!this->emitLoadPop(T, E))
+            return false;
+          return DiscardResult ? this->emitPop(T, E) : true;
+        });
+
+  case UO_AddrOf: // &x
+    // Should have a pointer on the stack now...
+    return this->Visit(E->getSubExpr());
+  case UO_Not:  // ~x
+  case UO_Real: // __real x
+  case UO_Imag: // __imag x
+  case UO_Extension:
+  case UO_Coawait:
+    llvm_unreachable("Unhandled opcode");
+  }
+
+  return false;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitInitListExpr(const InitListExpr *E) {
+  for (const Expr *Init : E->inits()) {
+    if (!this->visit(Init))
+      return false;
+  }
+
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitDeclRefExpr(const DeclRefExpr *E) {
+  if (auto It = Locals.find(E->getDecl()); It != Locals.end()) {
+    const unsigned Offset = It->second.Offset;
+    return this->emitGetPtrLocal(Offset, E);
+  } else if (auto GlobalIndex = P.getGlobal(E->getDecl())) {
+    return this->emitGetPtrGlobal(*GlobalIndex, E);
+  } else if (isa<ParmVarDecl>(E->getDecl())) {
+    // I'm pretty sure we should do something here, BUT
+    // when we're in evaluateAsRValue(), we don't have any parameters,
+    // so we can't actually use this->Params. This happens when
+    // a parameter is used in a return statement.
+    return false;
+  }
+
+  // Silently ignore everything here...
+  return false;
+}
+
+template <class Emitter>
 void ByteCodeExprGen<Emitter>::emitCleanup() {
   for (VariableScope<Emitter> *C = VarScope; C; C = C->getParent())
     C->emitDestruction();
 }
 
 namespace clang {
 namespace interp {
 
 template class ByteCodeExprGen<ByteCodeEmitter>;
 template class ByteCodeExprGen<EvalEmitter>;
 
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/ByteCodeStmtGen.h

 namespace interp {
 
 template <class Emitter> class LoopScope;
 template <class Emitter> class SwitchScope;
 template <class Emitter> class LabelScope;
 
 /// Compilation context for statements.
 template <class Emitter>
-class ByteCodeStmtGen : public ByteCodeExprGen<Emitter> {
+class ByteCodeStmtGen final : public ByteCodeExprGen<Emitter> {
   using LabelTy = typename Emitter::LabelTy;
   using AddrTy = typename Emitter::AddrTy;
   using OptLabelTy = llvm::Optional<LabelTy>;
   using CaseMap = llvm::DenseMap<const SwitchCase *, LabelTy>;
 
 public:
   template<typename... Tys>
   ByteCodeStmtGen(Tys&&... Args)

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

bool ByteCodeStmtGen<Emitter>::visitCompoundStmt(
   for (auto *InnerStmt : CompoundStmt->body())
     if (!visitStmt(InnerStmt))
       return false;
   return true;
 }
 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitDeclStmt(const DeclStmt *DS) {
+  llvm::errs() << __PRETTY_FUNCTION__ << "\n";
   for (auto *D : DS->decls()) {
     // Variable declarator.
     if (auto *VD = dyn_cast<VarDecl>(D)) {
       if (!visitVarDecl(VD))
         return false;
       continue;
     }
 
if (ReturnType) {
       // Primitive types are simply returned.
       if (!this->visit(RE))
         return false;
       this->emitCleanup();
       return this->emitRet(*ReturnType, RS);
     } else {
       // RVO - construct the value in the return location.
       auto ReturnLocation = [this, RE] { return this->emitGetParamPtr(0, RE); };
-      if (!this->visitInitializer(RE, ReturnLocation))
+      if (!this->visitInitializer(RE, ReturnLocation, [](PrimType T, unsigned) {
+            llvm_unreachable("woops");
+            return false;
+          }))
         return false;
       this->emitCleanup();
       return this->emitRetVoid(RS);
     }
   } else {
     this->emitCleanup();
     if (!this->emitRetVoid(RS))
       return false;
if (const Stmt *Else = IS->getElse()) {
     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;
   }
 
   // Integers, pointers, primitives.
-  if (Optional<PrimType> T = this->classify(DT)) {
-    auto Off = this->allocateLocalPrimitive(VD, *T, DT.isConstQualified());
+  if (Optional<PrimType> T = this->classify(VD->getType())) {
+    auto Offset =
+        this->allocateLocalPrimitive(VD, *T, VD->getType().isConstQualified());
     // Compile the initialiser in its own scope.
     {
       ExprScope<Emitter> Scope(this);
       if (!this->visit(VD->getInit()))
         return false;
     }
     // Set the value.
-    return this->emitSetLocal(*T, Off, VD);
+    return this->emitSetLocal(*T, Offset, VD);
   } else {
     // Composite types - allocate storage and initialize it.
-    if (auto Off = this->allocateLocal(VD)) {
-      return this->visitLocalInitializer(VD->getInit(), *Off);
+    if (auto Offset = this->allocateLocal(VD)) {
+      return this->visitLocalInitializer(VD->getInit(), *Offset);
     } else {
       return this->bail(VD);
     }
   }
 }
 
 namespace clang {
 namespace interp {
 
 template class ByteCodeStmtGen<ByteCodeEmitter>;
 
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/Context.h

public:
   /// Returns the interpreter stack.
   InterpStack &getStack() { return Stk; }
   /// Returns CHAR_BIT.
   unsigned getCharBit() const;
 
   /// Classifies an expression.
   llvm::Optional<PrimType> classify(QualType T);
 
-private:
   /// Runs a function.
   bool Run(State &Parent, Function *Func, APValue &Result);
 
+private:
   /// Checks a result from 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/Descriptor.h

 /// descriptors. Data is not copied since it cannot be legally read.
 using BlockMoveFn = void (*)(Block *Storage, char *SrcFieldPtr,
                              char *DstFieldPtr, Descriptor *FieldDesc);
 
 /// Object size as used by the interpreter.
 using InterpSize = unsigned;
 
 /// Describes a memory block created by an allocation site.
-struct Descriptor {
+struct Descriptor final {
 private:
   /// Original declaration, used to emit the error message.
   const DeclTy Source;
   /// Size of an element, in host bytes.
   const InterpSize ElemSize;
   /// Size of the storage, in host bytes.
   const InterpSize Size;
   /// Size of the allocation (storage + metadata), in host bytes.
struct InlineDescriptor {
 
   Descriptor *Desc;
 };
 
 /// Bitfield tracking the initialisation status of elements of primitive arrays.
 /// A pointer to this is embedded at the end of all primitive arrays.
 /// If the map was not yet created and nothing was initialized, the pointer to
 /// this structure is 0. If the object was fully initialized, the pointer is -1.
-struct InitMap {
+struct InitMap final {
 private:
   /// Type packing bits.
   using T = uint64_t;
   /// Bits stored in a single field.
   static constexpr uint64_t PER_FIELD = sizeof(T) * CHAR_BIT;
 
   /// Initializes the map with no fields set.
   InitMap(unsigned N);

clang/lib/AST/Interp/Disasm.cpp

 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Format.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 template <typename T>
 inline std::enable_if_t<!std::is_pointer<T>::value, T> ReadArg(Program &P,
-                                                               CodePtr OpPC) {
+                                                               CodePtr &OpPC) {
   return OpPC.read<T>();
 }
 
 template <typename T>
 inline std::enable_if_t<std::is_pointer<T>::value, T> ReadArg(Program &P,
-                                                              CodePtr OpPC) {
+                                                              CodePtr &OpPC) {
   uint32_t ID = OpPC.read<uint32_t>();
   return reinterpret_cast<T>(P.getNativePointer(ID));
 }
 
 LLVM_DUMP_METHOD void Function::dump() const { dump(llvm::errs()); }
 
 LLVM_DUMP_METHOD void Function::dump(llvm::raw_ostream &OS) const {
   if (F) {

clang/lib/AST/Interp/EvalEmitter.cpp

 
 template <PrimType OpType> bool EvalEmitter::emitRet(const SourceInfo &Info) {
   if (!isActive())
     return true;
   using T = typename PrimConv<OpType>::T;
   return ReturnValue<T>(S.Stk.pop<T>(), Result);
 }
 
+template <PrimType OpType>
+bool EvalEmitter::emitCall(const Function *Func, const SourceInfo &Info) {
+
+  S.Current =
+      new InterpFrame(S, const_cast<Function *>(Func), S.Current, {}, {});
+  if (Interpret(S, Result)) {
+    // We don't need to handle the return value specially here since the callee
+    // will put it on the stack for us.
+    return true;
+  }
+  return false;
+}
+
 bool EvalEmitter::emitRetVoid(const SourceInfo &Info) { return true; }
 
 bool EvalEmitter::emitRetValue(const SourceInfo &Info) {
   // Method to recursively traverse composites.
   std::function<bool(QualType, const Pointer &, APValue &)> Composite;
   Composite = [this, &Composite](QualType Ty, const Pointer &Ptr, APValue &R) {
     if (auto *AT = Ty->getAs<AtomicType>())
       Ty = AT->getValueType();

clang/lib/AST/Interp/Function.h

 /// Contains links to the bytecode of the function, as well as metadata
 /// describing all arguments and stack-local variables.
 class Function {
 public:
   using ParamDescriptor = std::pair<PrimType, Descriptor *>;
 
   /// Returns the size of the function's local stack.
   unsigned getFrameSize() const { return FrameSize; }
-  /// Returns the size of the argument stackx
+  /// Returns the size of the argument stack.
   unsigned getArgSize() const { return ArgSize; }
 
   /// Returns a pointer to the start of the code.
-  CodePtr getCodeBegin() const;
+  CodePtr getCodeBegin() const { return Code.data(); }
   /// Returns a pointer to the end of the code.
-  CodePtr getCodeEnd() const;
+  CodePtr getCodeEnd() const { return Code.data() + Code.size(); }
 
   /// Returns the original FunctionDecl.
   const FunctionDecl *getDecl() const { return F; }
 
+  /// Returns the name of the function decl this code
+  /// was generated for.
+  const std::string getName() const { return F->getNameInfo().getAsString(); }
+
   /// Returns the location.
   SourceLocation getLoc() const { return Loc; }
 
   /// Returns a parameter descriptor.
   ParamDescriptor getParamDescriptor(unsigned Offset) const;
 
   /// Checks if the first argument is a RVO pointer.
   bool hasRVO() const { return ParamTypes.size() != Params.size(); }

clang/lib/AST/Interp/Function.cpp

 using namespace clang::interp;
 
 Function::Function(Program &P, const FunctionDecl *F, unsigned ArgSize,
                    llvm::SmallVector<PrimType, 8> &&ParamTypes,
                    llvm::DenseMap<unsigned, ParamDescriptor> &&Params)
     : P(P), Loc(F->getBeginLoc()), F(F), ArgSize(ArgSize),
       ParamTypes(std::move(ParamTypes)), Params(std::move(Params)) {}
 
-CodePtr Function::getCodeBegin() const { return Code.data(); }
-
-CodePtr Function::getCodeEnd() const { return Code.data() + Code.size(); }
-
 Function::ParamDescriptor Function::getParamDescriptor(unsigned Offset) const {
   auto It = Params.find(Offset);
   assert(It != Params.end() && "Invalid parameter offset");
   return It->second;
 }
 
 SourceInfo Function::getSource(CodePtr PC) const {
   unsigned Offset = PC - getCodeBegin();

clang/lib/AST/Interp/Integral.h

public:
   static bool sub(Integral A, Integral B, unsigned OpBits, Integral *R) {
     return CheckSubUB(A.V, B.V, R->V);
   }
 
   static bool mul(Integral A, Integral B, unsigned OpBits, Integral *R) {
     return CheckMulUB(A.V, B.V, R->V);
   }
 
+  static bool neg(Integral A, Integral *R) {
+    *R = -A;
+    return false;
+  }
+
 private:
   template <typename T>
   static std::enable_if_t<std::is_signed<T>::value, bool> CheckAddUB(T A, T B,
                                                                      T &R) {
     return llvm::AddOverflow<T>(A, B, R);
   }
 
   template <typename T>

clang/lib/AST/Interp/Interp.h

 #define LLVM_CLANG_AST_INTERP_INTERP_H
 
 #include "Function.h"
 #include "InterpFrame.h"
 #include "InterpStack.h"
 #include "InterpState.h"
 #include "Opcode.h"
 #include "PrimType.h"
-#include "Program.h"
 #include "State.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/Expr.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/Support/Endian.h"

 bool Mul(InterpState &S, CodePtr OpPC) {
   const T &RHS = S.Stk.pop<T>();
   const T &LHS = S.Stk.pop<T>();
   const unsigned Bits = RHS.bitWidth() * 2;
   return AddSubMulHelper<T, T::mul, std::multiplies>(S, OpPC, Bits, LHS, RHS);
 }
 
 //===----------------------------------------------------------------------===//
+// 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>();
+  const unsigned Bits = Val.bitWidth();
+  Boolean R;
+  Boolean::inv(BoolT::from(Val, Bits), &R);
+
+  S.Stk.push<BoolT>(R);
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Neg
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Neg(InterpState &S, CodePtr OpPC) {
+  const T &Val = S.Stk.pop<T>();
+  T Result;
+  T::neg(Val, &Result);
+
+  S.Stk.push<T>(Result);
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
 // EQ, NE, GT, GE, LT, LE
 //===----------------------------------------------------------------------===//
 
 using CompareFn = llvm::function_ref<bool(ComparisonCategoryResult)>;
 
 template <typename T>
 bool CmpHelper(InterpState &S, CodePtr OpPC, CompareFn Fn) {
   using BoolT = PrimConv<PT_Bool>::T;
bool GetGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
   if (B->isExtern())
     return false;
   S.Stk.push<T>(B->deref<T>());
   return true;
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool SetGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
-  // TODO: emit warning.
+  llvm_unreachable("Can't set a global");
   return false;
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool InitGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
   S.P.getGlobal(I)->deref<T>() = S.Stk.pop<T>();
   return true;
 }

 bool LoadPop(InterpState &S, CodePtr OpPC) {
   const Pointer &Ptr = S.Stk.pop<Pointer>();
   if (!CheckLoad(S, OpPC, Ptr))
     return false;
   S.Stk.push<T>(Ptr.deref<T>());
   return true;
 }
 
+/// Pops the value to store from the stack.
+/// Writes it at the pointer that's next on the stack.
+/// Does NOT pop the pointer from the stack.
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Store(InterpState &S, CodePtr OpPC) {
   const T &Value = S.Stk.pop<T>();
   const Pointer &Ptr = S.Stk.peek<Pointer>();
   if (!CheckStore(S, OpPC, Ptr))
     return false;
   Ptr.deref<T>() = Value;
   return true;

 }
 
 //===----------------------------------------------------------------------===//
 // Read opcode arguments
 //===----------------------------------------------------------------------===//
 
 template <typename T>
 inline std::enable_if_t<!std::is_pointer<T>::value, T> ReadArg(InterpState &S,
-                                                               CodePtr OpPC) {
+                                                               CodePtr &OpPC) {
   return OpPC.read<T>();
 }
 
 template <typename T>
 inline std::enable_if_t<std::is_pointer<T>::value, T> ReadArg(InterpState &S,
-                                                              CodePtr OpPC) {
+                                                              CodePtr &OpPC) {
   uint32_t ID = OpPC.read<uint32_t>();
   return reinterpret_cast<T>(S.P.getNativePointer(ID));
 }
 
 /// Interpreter entry point.
 bool Interpret(InterpState &S, APValue &Result);
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Interp.cpp

if (InterpFrame *Caller = S.Current->Caller) {
     delete S.Current;
     S.Current = nullptr;
     if (!ReturnValue<T>(Ret, Result))
       return false;
   }
   return true;
 }
 
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+static bool Call(InterpState &S, CodePtr &PC, APValue &Result,
+                 const Function *Func) {
+  InterpStack Stack;
+  InterpState State(S, S.P, Stack, S.Ctx);
+  State.Current =
+      new InterpFrame(State, const_cast<Function *>(Func), nullptr, {}, {});
+  if (Interpret(State, Result)) {
+    // TODO: Support non-integer return values
+    assert(Result.isInt());
+    assert(Result.getInt().getZExtValue() == 0 ||
+           Result.getInt().getZExtValue() == 1);
+    S.Stk.push<bool>(Result.getInt().getZExtValue());
+    return true;
+  }
+
+  return false;
+}
+
 static bool RetVoid(InterpState &S, CodePtr &PC, APValue &Result) {
   S.CallStackDepth--;
 
   assert(S.Current->getFrameOffset() == S.Stk.size() && "Invalid frame");
   if (!S.checkingPotentialConstantExpression())
     S.Current->popArgs();
 
   if (InterpFrame *Caller = S.Current->Caller) {

 bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD) {
   if (!MD->isPure())
     return true;
   const SourceInfo &E = S.Current->getSource(OpPC);
   S.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << MD;
   S.Note(MD->getLocation(), diag::note_declared_at);
   return false;
 }
+
 bool Interpret(InterpState &S, APValue &Result) {
+  assert(!S.Current->isRoot());
   CodePtr PC = S.Current->getPC();
 
+  // Empty program.
+  if (!PC)
+    return true;
+
   for (;;) {
     auto Op = PC.read<Opcode>();
     CodePtr OpPC = PC;
 
     switch (Op) {
 #define GET_INTERP
 #include "Opcodes.inc"
 #undef GET_INTERP
     }
   }
 }
 
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/InterpBlock.h

public:
   /// Invokes the constructor.
   void invokeCtor() {
     std::memset(data(), 0, getSize());
     if (Desc->CtorFn)
       Desc->CtorFn(this, data(), Desc->IsConst, Desc->IsMutable,
                    /*isActive=*/true, Desc);
   }
 
+  void print(llvm::raw_ostream &OS) const {
+    OS << "Block {\n";
+    OS << "  hasPointers: " << hasPointers() << "\n";
+    OS << "  isExtern: " << isExtern() << "\n";
+    OS << "  isStatic: " << isStatic() << "\n";
+    OS << "  isArray: " << getDescriptor()->isArray() << "\n";
+    if (getDescriptor()->isArray()) {
+      OS << "  ElemSize: " << getDescriptor()->getElemSize() << "\n";
+      OS << "  NumElems: " << getDescriptor()->getNumElems() << "\n";
+    }
+    OS << "}";
+  }
+  void dump() const {
+    print(llvm::errs());
+    llvm::errs() << '\n';
+  }
+
 protected:
   friend class Pointer;
   friend class DeadBlock;
   friend class InterpState;
 
   Block(Descriptor *Desc, bool IsExtern, bool IsStatic, bool IsDead)
     : IsStatic(IsStatic), IsExtern(IsExtern), IsDead(true), Desc(Desc) {}
 

clang/lib/AST/Interp/InterpFrame.cpp

if (llvm::Optional<PrimType> T = S.Ctx.classify(Ty)) {
       PrimTy = PT_Ptr;
     }
 
     TYPE_SWITCH(PrimTy, print(OS, stackRef<T>(Off), S.getCtx(), Ty));
     Off += align(primSize(PrimTy));
     if (I + 1 != N)
       OS << ", ";
   }
-  OS << ")";
+  OS << ")\n";
 }
 
 Frame *InterpFrame::getCaller() const {
   if (Caller->Caller)
     return Caller;
   return S.getSplitFrame();
 }
 

clang/lib/AST/Interp/InterpStack.h

 //===--- InterpStack.h - Stack implementation for the VM --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the upwards-growing stack used by the interpreter.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_INTERP_INTERPSTACK_H
 #define LLVM_CLANG_AST_INTERP_INTERPSTACK_H
 
+#include "Pointer.h"
+#include "llvm/Support/raw_ostream.h"
 #include <memory>
 
 namespace clang {
 namespace interp {
 
 /// Stack frame storing temporaries and parameters.
 class InterpStack final {
 public:
public:
   }
 
   /// Returns a pointer to the top object.
   void *top() { return Chunk ? peek(0) : nullptr; }
 
   /// Returns the size of the stack in bytes.
   size_t size() const { return StackSize; }
 
+  /// Return whether the stack is empty.
+  bool empty() const { return StackSize == 0; }
+
   /// Clears the stack without calling any destructors.
   void clear();
 
+  void dump() {
+    llvm::errs() << "InterpStack(" << size() << "):\n";
+    // Try to read everything as sint32.
+    while (!empty()) {
+      auto V = this->pop<int32_t>();
+      llvm::errs() << V << "\n";
+    }
+  }
+
 private:
   /// All stack slots are aligned to the native pointer alignment for storage.
   /// The size of an object is rounded up to a pointer alignment multiple.
   template <typename T> constexpr size_t aligned_size() const {
     constexpr size_t PtrAlign = alignof(void *);
     return ((sizeof(T) + PtrAlign - 1) / PtrAlign) * PtrAlign;
   }
 

clang/lib/AST/Interp/InterpState.h

public:
   /// Deallocates a pointer.
   void deallocate(Block *B);
 
   /// Delegates source mapping to the mapper.
   SourceInfo getSource(Function *F, CodePtr PC) const override {
     return M ? M->getSource(F, PC) : F->getSource(PC);
   }
 
-private:
   /// AST Walker state.
   State &Parent;
+
+private:
   /// Dead block chain.
   DeadBlock *DeadBlocks = nullptr;
   /// Reference to the offset-source mapping.
   SourceMapper *M;
 
 public:
   /// Reference to the module containing all bytecode.
   Program &P;

clang/lib/AST/Interp/Opcodes.td

 def ArgSint16 : ArgType { let Name = "int16_t"; }
 def ArgUint16 : ArgType { let Name = "uint16_t"; }
 def ArgSint32 : ArgType { let Name = "int32_t"; }
 def ArgUint32 : ArgType { let Name = "uint32_t"; }
 def ArgSint64 : ArgType { let Name = "int64_t"; }
 def ArgUint64 : ArgType { let Name = "uint64_t"; }
 def ArgBool : ArgType { let Name = "bool"; }
 
-def ArgFunction : ArgType { let Name = "Function *"; }
+def ArgFunction : ArgType { let Name = "const Function *"; }
 def ArgRecord : ArgType { let Name = "Record *"; }
 
 def ArgSema : ArgType { let Name = "const fltSemantics *"; }
 
 def ArgExpr : ArgType { let Name = "const Expr *"; }
 def ArgFloatingLiteral : ArgType { let Name = "const FloatingLiteral *"; }
 def ArgCXXMethodDecl : ArgType { let Name = "const CXXMethodDecl *"; }
 def ArgFunctionDecl : ArgType { let Name = "const FunctionDecl *"; }
def AluTypeClass : TypeClass {
   let Types = [Sint8, Uint8, Sint16, Uint16, Sint32,
                Uint32, Sint64, Uint64, Bool];
 }
 
 def PtrTypeClass : TypeClass {
   let Types = [Ptr];
 }
 
+def BoolTypeClass : TypeClass {
+  let Types = [Bool];
+}
+
 def AllTypeClass : TypeClass {
   let Types = !listconcat(AluTypeClass.Types, PtrTypeClass.Types);
 }
 
 def ComparableTypeClass : TypeClass {
   let Types = !listconcat(AluTypeClass.Types, [Ptr]);
 }
 

 def RetValue : Opcode {
   let CanReturn = 1;
   let ChangesPC = 1;
   let HasCustomEval = 1;
 }
 // [] -> EXIT
 def NoRet : Opcode {}
 
+
+def Call : Opcode {
+  let Args = [ArgFunction];
+  let Types = [AllTypeClass];
+  let ChangesPC = 1;
+  let CanReturn = 1;
+  let HasCustomEval = 1;
+  let HasGroup = 1;
+}
+
+
 //===----------------------------------------------------------------------===//
 // Frame management
 //===----------------------------------------------------------------------===//
 
 // [] -> []
 def Destroy : Opcode {
   let Args = [ArgUint32];
   let HasCustomEval = 1;

 // Binary operators.
 //===----------------------------------------------------------------------===//
 
 // [Real, Real] -> [Real]
 def Sub : AluOpcode;
 def Add : AluOpcode;
 def Mul : AluOpcode;
 
+
+//===----------------------------------------------------------------------===//
+// Unary operators.
+//===----------------------------------------------------------------------===//
+
+
+
+// [Real] -> [Real]
+def Inv: Opcode {
+  let Types = [BoolTypeClass];
+  let HasGroup = 1;
+}
+
+// [Real] -> [Real]
+def Neg: Opcode {
+  let Types = [AluTypeClass];
+  let HasGroup = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // Comparison opcodes.
 //===----------------------------------------------------------------------===//
 
 class EqualityOpcode : Opcode {
   let Types = [AllTypeClass];
   let HasGroup = 1;
 }

clang/lib/AST/Interp/Pointer.h

void print(llvm::raw_ostream &OS) const {
     OS << "{" << Base << ", " << Offset << ", ";
     if (Pointee)
       OS << Pointee->getSize();
     else
       OS << "nullptr";
     OS << "}";
   }
 
+  void dump() const {
+    print(llvm::errs());
+    llvm::errs() << '\n';
+  }
+
 private:
   friend class Block;
   friend class DeadBlock;
 
   Pointer(Block *Pointee, unsigned Base, unsigned Offset);
 
   /// Returns the embedded descriptor preceding a field.
   InlineDescriptor *getInlineDesc() const { return getDescriptor(Base); }

clang/lib/AST/Interp/PrimType.h

 #include "Integral.h"
 #include "Pointer.h"
 
 namespace clang {
 namespace interp {
 
 /// Enumeration of the primitive types of the VM.
 enum PrimType : unsigned {
-  PT_Sint8,
-  PT_Uint8,
-  PT_Sint16,
-  PT_Uint16,
-  PT_Sint32,
-  PT_Uint32,
-  PT_Sint64,
-  PT_Uint64,
-  PT_Bool,
-  PT_Ptr,
+  PT_Sint8 = 0,
+  PT_Uint8 = 1,
+  PT_Sint16 = 2,
+  PT_Uint16 = 3,
+  PT_Sint32 = 4,
+  PT_Uint32 = 5,
+  PT_Sint64 = 6,
+  PT_Uint64 = 7,
+  PT_Bool = 8,
+  PT_Ptr = 9,
 };
 
 /// Mapping from primitive types to their representation.
 template <PrimType T> struct PrimConv;
 template <> struct PrimConv<PT_Sint8> { using T = Integral<8, true>; };
 template <> struct PrimConv<PT_Uint8> { using T = Integral<8, false>; };
 template <> struct PrimConv<PT_Sint16> { using T = Integral<16, true>; };
 template <> struct PrimConv<PT_Uint16> { using T = Integral<16, false>; };

clang/lib/AST/Interp/Source.h

 #include "clang/AST/Stmt.h"
 #include "llvm/Support/Endian.h"
 
 namespace clang {
 namespace interp {
 class Function;
 
 /// Pointer into the code segment.
-class CodePtr {
+class CodePtr final {
 public:
   CodePtr() : Ptr(nullptr) {}
 
   CodePtr &operator+=(int32_t Offset) {
     Ptr += Offset;
     return *this;
   }
 
   int32_t operator-(const CodePtr &RHS) const {
     assert(Ptr != nullptr && RHS.Ptr != nullptr && "Invalid code pointer");
     return Ptr - RHS.Ptr;
   }
 
   CodePtr operator-(size_t RHS) const {
     assert(Ptr != nullptr && "Invalid code pointer");
     return CodePtr(Ptr - RHS);
   }
 
   bool operator!=(const CodePtr &RHS) const { return Ptr != RHS.Ptr; }
 
+  operator bool() const { return Ptr; }
+
   /// Reads data and advances the pointer.
   template <typename T> std::enable_if_t<!std::is_pointer<T>::value, T> read() {
     using namespace llvm::support;
     T Value = endian::read<T, endianness::native, 1>(Ptr);
     Ptr += sizeof(T);
     return Value;
   }
 
 private:
   /// Constructor used by Function to generate pointers.
   CodePtr(const char *Ptr) : Ptr(Ptr) {}
 
 private:
   friend class Function;
 
   /// Pointer into the code owned by a function.
   const char *Ptr;
 };
 
 /// Describes the statement/declaration an opcode was generated from.
-class SourceInfo {
+class SourceInfo final {
 public:
   SourceInfo() {}
   SourceInfo(const Stmt *E) : Source(E) {}
   SourceInfo(const Decl *D) : Source(D) {}
 
   SourceLocation getLoc() const;
 
   const Stmt *asStmt() const { return Source.dyn_cast<const Stmt *>(); }

clang/test/AST/Interp/interp.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fexperimental-new-constant-interpreter %s -verify
+
+// expected-no-diagnostics
+
+constexpr bool foo() { return true; }
+constexpr bool bar() { return false; }
+static_assert(foo());
+
+static_assert(5);
+static_assert(!0);
+
+///------------------------------------------------------------------
+/// Unary inv
+static_assert(!false);
+static_assert(!!true);
+static_assert(!bar());
+static_assert(!!foo());
+
+///------------------------------------------------------------------
+/// Return values
+constexpr int get4() { return 4; }
+static_assert(get4() != 5);
+
+
+///------------------------------------------------------------------
+/// Functions calling other functions
+constexpr bool getTrue() { return foo(); }
+constexpr bool getTrue2() { return !bar(); }
+static_assert(getTrue());
+static_assert(getTrue2());
+
+//------------------------------------------------------------------
+// Parameters
+// TODO:
+//template<typename T>
+//constexpr T identity(T t) { return t; }
+//static_assert(identity(true));
+constexpr bool bool_identity(bool b) { return b; }
+static_assert(bool_identity(true));
+static_assert(!bool_identity(false));
+
+constexpr bool inv(bool b) { return !b;}
+static_assert(inv(false));
+
+constexpr int add(int a, int b) { return a + b; }
+static_assert(add(1,2) == 3);
+
+constexpr int sub(int a, int b) { return a - b; }
+static_assert(sub(0, 2) == -2);
+
+
+
+///------------------------------------------------------------------
+/// Global Variables
+constexpr bool t = true;
+constexpr bool f = false;
+constexpr int  n = 13;
+constexpr int zero = 0;
+static_assert(t);
+static_assert(!f);
+static_assert(n);
+static_assert(!zero);
+
+
+///------------------------------------------------------------------
+/// Local variables
+constexpr int assign() {
+  int f = 20;
+  f = 100;
+  return f;
+}
+static_assert(assign() == 100);
+
+
+
+///------------------------------------------------------------------
+/// Pointers
+
+constexpr const int *ptr = nullptr;
+static_assert(ptr == nullptr);
+constexpr const int *const* ptr2 = &ptr;
+static_assert(ptr2 != nullptr);
+
+constexpr const int *zomg = *ptr2;
+static_assert(zomg == nullptr);
+
+constexpr int five = 5;
+constexpr const int *pointer_to_5 = &five;
+constexpr const int five_from_pointer = *pointer_to_5;
+static_assert(five_from_pointer == 5);
+
+
+
+
+
+///------------------------------------------------------------------
+/// If Statements
+constexpr int cond(bool b) {
+  if (b) {
+    return 5;
+  } else {
+    return 3;
+  }
+}
+static_assert(cond(true) == 5);
+static_assert(cond(false) == 3);
+
+
+///------------------------------------------------------------------
+/// Arrays
+constexpr int intarr[] = { 1, 2, 3, 4 };
+static_assert(intarr[0] == 1);
+static_assert(intarr[1] == 2);
+static_assert(intarr[2] == 3);
+static_assert(intarr[3] == 4);
+constexpr int someArr() {
+  int v[] = { 1, 2, 3, 4};
+  return v[0] + v[1] + v[2];
+}
+static_assert(someArr() == 6);
+