diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -139,6 +139,12 @@
 
 } // namespace comments
 
+namespace interp {
+
+class Context;
+
+} // namespace interp
+
 struct TypeInfo {
   uint64_t Width = 0;
   unsigned Align = 0;
@@ -564,6 +570,7 @@
   const TargetInfo *Target = nullptr;
   const TargetInfo *AuxTarget = nullptr;
   clang::PrintingPolicy PrintingPolicy;
+  std::unique_ptr<interp::Context> InterpContext;
 
 public:
   IdentifierTable &Idents;
@@ -573,6 +580,9 @@
   IntrusiveRefCntPtr<ExternalASTSource> ExternalSource;
   ASTMutationListener *Listener = nullptr;
 
+  /// Returns the clang bytecode interpreter context.
+  interp::Context &getInterpContext();
+
   /// Container for either a single DynTypedNode or for an ArrayRef to
   /// DynTypedNode. For use with ParentMap.
   class DynTypedNodeList {
diff --git a/clang/include/clang/Basic/DiagnosticASTKinds.td b/clang/include/clang/Basic/DiagnosticASTKinds.td
--- a/clang/include/clang/Basic/DiagnosticASTKinds.td
+++ b/clang/include/clang/Basic/DiagnosticASTKinds.td
@@ -228,6 +228,8 @@
 def note_constexpr_bit_cast_indet_dest : Note<
   "indeterminate value can only initialize an object of type 'unsigned char'"
   "%select{, 'char',|}1 or 'std::byte'; %0 is invalid">;
+def err_experimental_clang_interp_failed : Error<
+  "the experimental clang interpreter failed to evaluate an expression">;
 
 def warn_integer_constant_overflow : Warning<
   "overflow in expression; result is %0 with type %1">,
diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
--- a/clang/include/clang/Basic/LangOptions.def
+++ b/clang/include/clang/Basic/LangOptions.def
@@ -288,6 +288,10 @@
                "maximum constexpr call depth")
 BENIGN_LANGOPT(ConstexprStepLimit, 32, 1048576,
                "maximum constexpr evaluation steps")
+BENIGN_LANGOPT(EnableNewConstInterp, 1, 0,
+               "enable the experimental new constant interpreter")
+BENIGN_LANGOPT(ForceNewConstInterp, 1, 0,
+               "force the use of the experimental new constant interpreter")
 BENIGN_LANGOPT(BracketDepth, 32, 256,
                "maximum bracket nesting depth")
 BENIGN_LANGOPT(NumLargeByValueCopy, 32, 0,
diff --git a/clang/include/clang/Basic/OptionalDiagnostic.h b/clang/include/clang/Basic/OptionalDiagnostic.h
new file mode 100644
--- /dev/null
+++ b/clang/include/clang/Basic/OptionalDiagnostic.h
@@ -0,0 +1,78 @@
+//===- OptionalDiagnostic.h - An optional diagnostic ------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// Implements a partial diagnostic which may not be emitted.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_BASIC_OPTIONALDIAGNOSTIC_H
+#define LLVM_CLANG_BASIC_OPTIONALDIAGNOSTIC_H
+
+#include "clang/AST/APValue.h"
+#include "clang/Basic/PartialDiagnostic.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang {
+
+/// A partial diagnostic which we might know in advance that we are not going
+/// to emit.
+class OptionalDiagnostic {
+  PartialDiagnostic *Diag;
+
+public:
+  explicit OptionalDiagnostic(PartialDiagnostic *Diag = nullptr) : Diag(Diag) {}
+
+  template <typename T> OptionalDiagnostic &operator<<(const T &v) {
+    if (Diag)
+      *Diag << v;
+    return *this;
+  }
+
+  OptionalDiagnostic &operator<<(const llvm::APSInt &I) {
+    if (Diag) {
+      SmallVector<char, 32> Buffer;
+      I.toString(Buffer);
+      *Diag << StringRef(Buffer.data(), Buffer.size());
+    }
+    return *this;
+  }
+
+  OptionalDiagnostic &operator<<(const llvm::APFloat &F) {
+    if (Diag) {
+      // FIXME: Force the precision of the source value down so we don't
+      // print digits which are usually useless (we don't really care here if
+      // we truncate a digit by accident in edge cases).  Ideally,
+      // APFloat::toString would automatically print the shortest
+      // representation which rounds to the correct value, but it's a bit
+      // tricky to implement. Could use std::to_chars.
+      unsigned precision = llvm::APFloat::semanticsPrecision(F.getSemantics());
+      precision = (precision * 59 + 195) / 196;
+      SmallVector<char, 32> Buffer;
+      F.toString(Buffer, precision);
+      *Diag << StringRef(Buffer.data(), Buffer.size());
+    }
+    return *this;
+  }
+
+  OptionalDiagnostic &operator<<(const APFixedPoint &FX) {
+    if (Diag) {
+      SmallVector<char, 32> Buffer;
+      FX.toString(Buffer);
+      *Diag << StringRef(Buffer.data(), Buffer.size());
+    }
+    return *this;
+  }
+};
+
+} // namespace clang
+
+#endif
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -833,6 +833,10 @@
 def fconstant_string_class_EQ : Joined<["-"], "fconstant-string-class=">, Group<f_Group>;
 def fconstexpr_depth_EQ : Joined<["-"], "fconstexpr-depth=">, Group<f_Group>;
 def fconstexpr_steps_EQ : Joined<["-"], "fconstexpr-steps=">, Group<f_Group>;
+def fexperimental_new_constant_interpreter : Flag<["-"], "fexperimental-new-constant-interpreter">, Group<f_Group>,
+  HelpText<"Enable the experimental new constant interpreter">, Flags<[CC1Option]>;
+def fforce_experimental_new_constant_interpreter : Flag<["-"], "fforce-experimental-new-constant-interpreter">, Group<f_Group>,
+  HelpText<"Force the use of the experimental new const interpreter, failing on missing features">, Flags<[CC1Option]>;
 def fconstexpr_backtrace_limit_EQ : Joined<["-"], "fconstexpr-backtrace-limit=">,
                                     Group<f_Group>;
 def fno_crash_diagnostics : Flag<["-"], "fno-crash-diagnostics">, Group<f_clang_Group>, Flags<[NoArgumentUnused, CoreOption]>,
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -12,6 +12,7 @@
 
 #include "clang/AST/ASTContext.h"
 #include "CXXABI.h"
+#include "Interp/Context.h"
 #include "clang/AST/APValue.h"
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/AST/ASTTypeTraits.h"
@@ -737,6 +738,13 @@
   llvm_unreachable("Invalid CXXABI type!");
 }
 
+interp::Context &ASTContext::getInterpContext() {
+  if (!InterpContext) {
+    InterpContext.reset(new interp::Context(*this));
+  }
+  return *InterpContext.get();
+}
+
 static const LangASMap *getAddressSpaceMap(const TargetInfo &T,
                                            const LangOptions &LOpts) {
   if (LOpts.FakeAddressSpaceMap) {
diff --git a/clang/lib/AST/CMakeLists.txt b/clang/lib/AST/CMakeLists.txt
--- a/clang/lib/AST/CMakeLists.txt
+++ b/clang/lib/AST/CMakeLists.txt
@@ -4,6 +4,8 @@
   Support
   )
 
+add_subdirectory(Interp)
+
 add_clang_library(clangAST
   APValue.cpp
   ASTConsumer.cpp
@@ -81,5 +83,6 @@
 
   LINK_LIBS
   clangBasic
+  clangInterp
   clangLex
   )
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -32,13 +32,16 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "Interp/Context.h"
+#include "Interp/Frame.h"
+#include "Interp/State.h"
 #include "clang/AST/APValue.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTLambda.h"
+#include "clang/AST/CXXInheritance.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/CurrentSourceLocExprScope.h"
-#include "clang/AST/CXXInheritance.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/OSLog.h"
 #include "clang/AST/RecordLayout.h"
@@ -46,6 +49,7 @@
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/FixedPoint.h"
+#include "clang/Basic/OptionalDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallBitVector.h"
@@ -66,8 +70,8 @@
 
 namespace {
   struct LValue;
-  struct CallStackFrame;
-  struct EvalInfo;
+  class CallStackFrame;
+  class EvalInfo;
 
   using SourceLocExprScopeGuard =
       CurrentSourceLocExprScope::SourceLocExprScopeGuard;
@@ -222,12 +226,6 @@
     return MostDerivedLength;
   }
 
-  // The order of this enum is important for diagnostics.
-  enum CheckSubobjectKind {
-    CSK_Base, CSK_Derived, CSK_Field, CSK_ArrayToPointer, CSK_ArrayIndex,
-    CSK_Real, CSK_Imag
-  };
-
   /// A path from a glvalue to a subobject of that glvalue.
   struct SubobjectDesignator {
     /// True if the subobject was named in a manner not supported by C++11. Such
@@ -480,7 +478,8 @@
   };
 
   /// A stack frame in the constexpr call stack.
-  struct CallStackFrame {
+  class CallStackFrame : public interp::Frame {
+  public:
     EvalInfo &Info;
 
     /// Parent - The caller of this stack frame.
@@ -574,6 +573,12 @@
     }
 
     APValue &createTemporary(const void *Key, bool IsLifetimeExtended);
+
+    void describe(llvm::raw_ostream &OS) override;
+
+    Frame *getCaller() const override { return Caller; }
+    SourceLocation getCallLocation() const override { return CallLoc; }
+    const FunctionDecl *getCallee() const override { return Callee; }
   };
 
   /// Temporarily override 'this'.
@@ -592,59 +597,6 @@
     const LValue *OldThis;
   };
 
-  /// A partial diagnostic which we might know in advance that we are not going
-  /// to emit.
-  class OptionalDiagnostic {
-    PartialDiagnostic *Diag;
-
-  public:
-    explicit OptionalDiagnostic(PartialDiagnostic *Diag = nullptr)
-      : Diag(Diag) {}
-
-    template<typename T>
-    OptionalDiagnostic &operator<<(const T &v) {
-      if (Diag)
-        *Diag << v;
-      return *this;
-    }
-
-    OptionalDiagnostic &operator<<(const APSInt &I) {
-      if (Diag) {
-        SmallVector<char, 32> Buffer;
-        I.toString(Buffer);
-        *Diag << StringRef(Buffer.data(), Buffer.size());
-      }
-      return *this;
-    }
-
-    OptionalDiagnostic &operator<<(const APFloat &F) {
-      if (Diag) {
-        // FIXME: Force the precision of the source value down so we don't
-        // print digits which are usually useless (we don't really care here if
-        // we truncate a digit by accident in edge cases).  Ideally,
-        // APFloat::toString would automatically print the shortest
-        // representation which rounds to the correct value, but it's a bit
-        // tricky to implement.
-        unsigned precision =
-            llvm::APFloat::semanticsPrecision(F.getSemantics());
-        precision = (precision * 59 + 195) / 196;
-        SmallVector<char, 32> Buffer;
-        F.toString(Buffer, precision);
-        *Diag << StringRef(Buffer.data(), Buffer.size());
-      }
-      return *this;
-    }
-
-    OptionalDiagnostic &operator<<(const APFixedPoint &FX) {
-      if (Diag) {
-        SmallVector<char, 32> Buffer;
-        FX.toString(Buffer);
-        *Diag << StringRef(Buffer.data(), Buffer.size());
-      }
-      return *this;
-    }
-  };
-
   /// A cleanup, and a flag indicating whether it is lifetime-extended.
   class Cleanup {
     llvm::PointerIntPair<APValue*, 1, bool> Value;
@@ -707,7 +659,8 @@
   /// rules.  For example, the RHS of (0 && foo()) is not evaluated.  We can
   /// evaluate the expression regardless of what the RHS is, but C only allows
   /// certain things in certain situations.
-  struct EvalInfo {
+  class EvalInfo : public interp::State {
+  public:
     ASTContext &Ctx;
 
     /// EvalStatus - Contains information about the evaluation.
@@ -727,6 +680,13 @@
     /// we will evaluate.
     unsigned StepsLeft;
 
+    /// Force the use of the experimental new constant interpreter, bailing out
+    /// with an error if a feature is not supported.
+    bool ForceNewConstInterp;
+
+    /// Enable the experimental new constant interpreter.
+    bool EnableNewConstInterp;
+
     /// BottomFrame - The frame in which evaluation started. This must be
     /// initialized after CurrentCall and CallStackDepth.
     CallStackFrame BottomFrame;
@@ -837,7 +797,7 @@
 
     /// Are we checking whether the expression is a potential constant
     /// expression?
-    bool checkingPotentialConstantExpression() const {
+    bool checkingPotentialConstantExpression() const override {
       return EvalMode == EM_PotentialConstantExpression ||
              EvalMode == EM_PotentialConstantExpressionUnevaluated;
     }
@@ -845,25 +805,28 @@
     /// Are we checking an expression for overflow?
     // FIXME: We should check for any kind of undefined or suspicious behavior
     // in such constructs, not just overflow.
-    bool checkingForOverflow() { return EvalMode == EM_EvaluateForOverflow; }
+    bool checkingForOverflow() const override {
+      return EvalMode == EM_EvaluateForOverflow;
+    }
 
     EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
-      : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
-        CallStackDepth(0), NextCallIndex(1),
-        StepsLeft(getLangOpts().ConstexprStepLimit),
-        BottomFrame(*this, SourceLocation(), nullptr, nullptr, nullptr),
-        EvaluatingDecl((const ValueDecl *)nullptr),
-        EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
-        HasFoldFailureDiagnostic(false),
-        InConstantContext(false), EvalMode(Mode) {}
+        : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
+          CallStackDepth(0), NextCallIndex(1),
+          StepsLeft(getLangOpts().ConstexprStepLimit),
+          ForceNewConstInterp(getLangOpts().ForceNewConstInterp),
+          EnableNewConstInterp(ForceNewConstInterp ||
+                               getLangOpts().EnableNewConstInterp),
+          BottomFrame(*this, SourceLocation(), nullptr, nullptr, nullptr),
+          EvaluatingDecl((const ValueDecl *)nullptr),
+          EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
+          HasFoldFailureDiagnostic(false), InConstantContext(false),
+          EvalMode(Mode) {}
 
     void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value) {
       EvaluatingDecl = Base;
       EvaluatingDeclValue = &Value;
     }
 
-    const LangOptions &getLangOpts() const { return Ctx.getLangOpts(); }
-
     bool CheckCallLimit(SourceLocation Loc) {
       // Don't perform any constexpr calls (other than the call we're checking)
       // when checking a potential constant expression.
@@ -907,118 +870,52 @@
     }
 
   private:
-    /// Add a diagnostic to the diagnostics list.
-    PartialDiagnostic &addDiag(SourceLocation Loc, diag::kind DiagId) {
-      PartialDiagnostic PD(DiagId, Ctx.getDiagAllocator());
-      EvalStatus.Diag->push_back(std::make_pair(Loc, PD));
-      return EvalStatus.Diag->back().second;
-    }
-
-    /// Add notes containing a call stack to the current point of evaluation.
-    void addCallStack(unsigned Limit);
-
-  private:
-    OptionalDiagnostic Diag(SourceLocation Loc, diag::kind DiagId,
-                            unsigned ExtraNotes, bool IsCCEDiag) {
-
-      if (EvalStatus.Diag) {
-        // If we have a prior diagnostic, it will be noting that the expression
-        // isn't a constant expression. This diagnostic is more important,
-        // unless we require this evaluation to produce a constant expression.
-        //
-        // FIXME: We might want to show both diagnostics to the user in
-        // EM_ConstantFold mode.
-        if (!EvalStatus.Diag->empty()) {
-          switch (EvalMode) {
-          case EM_ConstantFold:
-          case EM_IgnoreSideEffects:
-          case EM_EvaluateForOverflow:
-            if (!HasFoldFailureDiagnostic)
-              break;
-            // We've already failed to fold something. Keep that diagnostic.
-            LLVM_FALLTHROUGH;
-          case EM_ConstantExpression:
-          case EM_PotentialConstantExpression:
-          case EM_ConstantExpressionUnevaluated:
-          case EM_PotentialConstantExpressionUnevaluated:
-            HasActiveDiagnostic = false;
-            return OptionalDiagnostic();
-          }
+    interp::Frame *getCurrentFrame() override { return CurrentCall; }
+    const interp::Frame *getBottomFrame() const override { return &BottomFrame; }
+
+    bool hasActiveDiagnostic() override { return HasActiveDiagnostic; }
+    void setActiveDiagnostic(bool Flag) override { HasActiveDiagnostic = Flag; }
+
+    void setFoldFailureDiagnostic(bool Flag) override {
+      HasFoldFailureDiagnostic = Flag;
+    }
+
+    Expr::EvalStatus &getEvalStatus() const override { return EvalStatus; }
+
+    ASTContext &getCtx() const override { return Ctx; }
+
+    // If we have a prior diagnostic, it will be noting that the expression
+    // isn't a constant expression. This diagnostic is more important,
+    // unless we require this evaluation to produce a constant expression.
+    //
+    // FIXME: We might want to show both diagnostics to the user in
+    // EM_ConstantFold mode.
+    bool hasPriorDiagnostic() override {
+      if (!EvalStatus.Diag->empty()) {
+        switch (EvalMode) {
+        case EM_ConstantFold:
+        case EM_IgnoreSideEffects:
+        case EM_EvaluateForOverflow:
+          if (!HasFoldFailureDiagnostic)
+            break;
+          // We've already failed to fold something. Keep that diagnostic.
+          LLVM_FALLTHROUGH;
+        case EM_ConstantExpression:
+        case EM_PotentialConstantExpression:
+        case EM_ConstantExpressionUnevaluated:
+        case EM_PotentialConstantExpressionUnevaluated:
+          setActiveDiagnostic(false);
+          return true;
         }
-
-        unsigned CallStackNotes = CallStackDepth - 1;
-        unsigned Limit = Ctx.getDiagnostics().getConstexprBacktraceLimit();
-        if (Limit)
-          CallStackNotes = std::min(CallStackNotes, Limit + 1);
-        if (checkingPotentialConstantExpression())
-          CallStackNotes = 0;
-
-        HasActiveDiagnostic = true;
-        HasFoldFailureDiagnostic = !IsCCEDiag;
-        EvalStatus.Diag->clear();
-        EvalStatus.Diag->reserve(1 + ExtraNotes + CallStackNotes);
-        addDiag(Loc, DiagId);
-        if (!checkingPotentialConstantExpression())
-          addCallStack(Limit);
-        return OptionalDiagnostic(&(*EvalStatus.Diag)[0].second);
       }
-      HasActiveDiagnostic = false;
-      return OptionalDiagnostic();
-    }
-  public:
-    // Diagnose that the evaluation could not be folded (FF => FoldFailure)
-    OptionalDiagnostic
-    FFDiag(SourceLocation Loc,
-          diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
-          unsigned ExtraNotes = 0) {
-      return Diag(Loc, DiagId, ExtraNotes, false);
-    }
-
-    OptionalDiagnostic FFDiag(const Expr *E, diag::kind DiagId
-                              = diag::note_invalid_subexpr_in_const_expr,
-                            unsigned ExtraNotes = 0) {
-      if (EvalStatus.Diag)
-        return Diag(E->getExprLoc(), DiagId, ExtraNotes, /*IsCCEDiag*/false);
-      HasActiveDiagnostic = false;
-      return OptionalDiagnostic();
-    }
-
-    /// Diagnose that the evaluation does not produce a C++11 core constant
-    /// expression.
-    ///
-    /// FIXME: Stop evaluating if we're in EM_ConstantExpression or
-    /// EM_PotentialConstantExpression mode and we produce one of these.
-    OptionalDiagnostic CCEDiag(SourceLocation Loc, diag::kind DiagId
-                                 = diag::note_invalid_subexpr_in_const_expr,
-                               unsigned ExtraNotes = 0) {
-      // Don't override a previous diagnostic. Don't bother collecting
-      // diagnostics if we're evaluating for overflow.
-      if (!EvalStatus.Diag || !EvalStatus.Diag->empty()) {
-        HasActiveDiagnostic = false;
-        return OptionalDiagnostic();
-      }
-      return Diag(Loc, DiagId, ExtraNotes, true);
-    }
-    OptionalDiagnostic CCEDiag(const Expr *E, diag::kind DiagId
-                                 = diag::note_invalid_subexpr_in_const_expr,
-                               unsigned ExtraNotes = 0) {
-      return CCEDiag(E->getExprLoc(), DiagId, ExtraNotes);
-    }
-    /// Add a note to a prior diagnostic.
-    OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId) {
-      if (!HasActiveDiagnostic)
-        return OptionalDiagnostic();
-      return OptionalDiagnostic(&addDiag(Loc, DiagId));
+      return false;
     }
 
-    /// Add a stack of notes to a prior diagnostic.
-    void addNotes(ArrayRef<PartialDiagnosticAt> Diags) {
-      if (HasActiveDiagnostic) {
-        EvalStatus.Diag->insert(EvalStatus.Diag->end(),
-                                Diags.begin(), Diags.end());
-      }
+    unsigned getCallStackDepth() override {
+      return CallStackDepth;
     }
 
+  public:
     /// Should we continue evaluation after encountering a side-effect that we
     /// couldn't model?
     bool keepEvaluatingAfterSideEffect() {
@@ -1064,14 +961,14 @@
     /// Note that we hit something that was technically undefined behavior, but
     /// that we can evaluate past it (such as signed overflow or floating-point
     /// division by zero.)
-    bool noteUndefinedBehavior() {
+    bool noteUndefinedBehavior() override {
       EvalStatus.HasUndefinedBehavior = true;
       return keepEvaluatingAfterUndefinedBehavior();
     }
 
     /// Should we continue evaluation as much as possible after encountering a
     /// construct which can't be reduced to a value?
-    bool keepEvaluatingAfterFailure() {
+    bool keepEvaluatingAfterFailure() const override {
       if (!StepsLeft)
         return false;
 
@@ -1321,62 +1218,6 @@
   return Result;
 }
 
-static void describeCall(CallStackFrame *Frame, raw_ostream &Out);
-
-void EvalInfo::addCallStack(unsigned Limit) {
-  // Determine which calls to skip, if any.
-  unsigned ActiveCalls = CallStackDepth - 1;
-  unsigned SkipStart = ActiveCalls, SkipEnd = SkipStart;
-  if (Limit && Limit < ActiveCalls) {
-    SkipStart = Limit / 2 + Limit % 2;
-    SkipEnd = ActiveCalls - Limit / 2;
-  }
-
-  // Walk the call stack and add the diagnostics.
-  unsigned CallIdx = 0;
-  for (CallStackFrame *Frame = CurrentCall; Frame != &BottomFrame;
-       Frame = Frame->Caller, ++CallIdx) {
-    // Skip this call?
-    if (CallIdx >= SkipStart && CallIdx < SkipEnd) {
-      if (CallIdx == SkipStart) {
-        // Note that we're skipping calls.
-        addDiag(Frame->CallLoc, diag::note_constexpr_calls_suppressed)
-          << unsigned(ActiveCalls - Limit);
-      }
-      continue;
-    }
-
-    // Use a different note for an inheriting constructor, because from the
-    // user's perspective it's not really a function at all.
-    if (auto *CD = dyn_cast_or_null<CXXConstructorDecl>(Frame->Callee)) {
-      if (CD->isInheritingConstructor()) {
-        addDiag(Frame->CallLoc, diag::note_constexpr_inherited_ctor_call_here)
-          << CD->getParent();
-        continue;
-      }
-    }
-
-    SmallVector<char, 128> Buffer;
-    llvm::raw_svector_ostream Out(Buffer);
-    describeCall(Frame, Out);
-    addDiag(Frame->CallLoc, diag::note_constexpr_call_here) << Out.str();
-  }
-}
-
-/// Kinds of access we can perform on an object, for diagnostics. Note that
-/// we consider a member function call to be a kind of access, even though
-/// it is not formally an access of the object, because it has (largely) the
-/// same set of semantic restrictions.
-enum AccessKinds {
-  AK_Read,
-  AK_Assign,
-  AK_Increment,
-  AK_Decrement,
-  AK_MemberCall,
-  AK_DynamicCast,
-  AK_TypeId,
-};
-
 static bool isModification(AccessKinds AK) {
   switch (AK) {
   case AK_Read:
@@ -1744,36 +1585,36 @@
 }
 
 /// Produce a string describing the given constexpr call.
-static void describeCall(CallStackFrame *Frame, raw_ostream &Out) {
+void CallStackFrame::describe(raw_ostream &Out) {
   unsigned ArgIndex = 0;
-  bool IsMemberCall = isa<CXXMethodDecl>(Frame->Callee) &&
-                      !isa<CXXConstructorDecl>(Frame->Callee) &&
-                      cast<CXXMethodDecl>(Frame->Callee)->isInstance();
+  bool IsMemberCall = isa<CXXMethodDecl>(Callee) &&
+                      !isa<CXXConstructorDecl>(Callee) &&
+                      cast<CXXMethodDecl>(Callee)->isInstance();
 
   if (!IsMemberCall)
-    Out << *Frame->Callee << '(';
+    Out << *Callee << '(';
 
-  if (Frame->This && IsMemberCall) {
+  if (This && IsMemberCall) {
     APValue Val;
-    Frame->This->moveInto(Val);
-    Val.printPretty(Out, Frame->Info.Ctx,
-                    Frame->This->Designator.MostDerivedType);
+    This->moveInto(Val);
+    Val.printPretty(Out, Info.Ctx,
+                    This->Designator.MostDerivedType);
     // FIXME: Add parens around Val if needed.
-    Out << "->" << *Frame->Callee << '(';
+    Out << "->" << *Callee << '(';
     IsMemberCall = false;
   }
 
-  for (FunctionDecl::param_const_iterator I = Frame->Callee->param_begin(),
-       E = Frame->Callee->param_end(); I != E; ++I, ++ArgIndex) {
+  for (FunctionDecl::param_const_iterator I = Callee->param_begin(),
+       E = Callee->param_end(); I != E; ++I, ++ArgIndex) {
     if (ArgIndex > (unsigned)IsMemberCall)
       Out << ", ";
 
     const ParmVarDecl *Param = *I;
-    const APValue &Arg = Frame->Arguments[ArgIndex];
-    Arg.printPretty(Out, Frame->Info.Ctx, Param->getType());
+    const APValue &Arg = Arguments[ArgIndex];
+    Arg.printPretty(Out, Info.Ctx, Param->getType());
 
     if (ArgIndex == 0 && IsMemberCall)
-      Out << "->" << *Frame->Callee << '(';
+      Out << "->" << *Callee << '(';
   }
 
   Out << ')';
@@ -12273,6 +12114,18 @@
 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
 /// lvalue-to-rvalue cast if it is an lvalue.
 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
+   if (Info.EnableNewConstInterp) {
+    auto &InterpCtx = Info.Ctx.getInterpContext();
+    switch (InterpCtx.evaluateAsRValue(Info, E, Result)) {
+    case interp::InterpResult::Success:
+      return true;
+    case interp::InterpResult::Fail:
+      return false;
+    case interp::InterpResult::Bail:
+      break;
+    }
+  }
+
   if (E->getType().isNull())
     return false;
 
@@ -12480,11 +12333,26 @@
   Expr::EvalStatus EStatus;
   EStatus.Diag = &Notes;
 
-  EvalInfo InitInfo(Ctx, EStatus, VD->isConstexpr()
+  EvalInfo Info(Ctx, EStatus, VD->isConstexpr()
                                       ? EvalInfo::EM_ConstantExpression
                                       : EvalInfo::EM_ConstantFold);
-  InitInfo.setEvaluatingDecl(VD, Value);
-  InitInfo.InConstantContext = true;
+  Info.setEvaluatingDecl(VD, Value);
+  Info.InConstantContext = true;
+
+  if (Info.EnableNewConstInterp) {
+    auto &InterpCtx = const_cast<ASTContext &>(Ctx).getInterpContext();
+    switch (InterpCtx.evaluateAsInitializer(Info, VD, Value)) {
+    case interp::InterpResult::Fail:
+      // Bail out if an error was encountered.
+      return false;
+    case interp::InterpResult::Success:
+      // Evaluation succeeded and value was set.
+      return true;
+    case interp::InterpResult::Bail:
+      // Evaluate the value again for the tree evaluator to use.
+      break;
+    }
+  }
 
   LValue LVal;
   LVal.set(VD);
@@ -12496,18 +12364,17 @@
   if (Ctx.getLangOpts().CPlusPlus && !VD->hasLocalStorage() &&
       !VD->getType()->isReferenceType()) {
     ImplicitValueInitExpr VIE(VD->getType());
-    if (!EvaluateInPlace(Value, InitInfo, LVal, &VIE,
+    if (!EvaluateInPlace(Value, Info, LVal, &VIE,
                          /*AllowNonLiteralTypes=*/true))
       return false;
   }
 
-  if (!EvaluateInPlace(Value, InitInfo, LVal, this,
+  if (!EvaluateInPlace(Value, Info, LVal, this,
                        /*AllowNonLiteralTypes=*/true) ||
       EStatus.HasSideEffects)
     return false;
 
-  return CheckConstantExpression(InitInfo, VD->getLocation(), VD->getType(),
-                                 Value);
+  return CheckConstantExpression(Info, VD->getLocation(), VD->getType(), Value);
 }
 
 /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
@@ -13182,6 +13049,18 @@
                 EvalInfo::EM_PotentialConstantExpression);
   Info.InConstantContext = true;
 
+  // The constexpr VM attempts to compile all methods to bytecode here.
+  if (Info.EnableNewConstInterp) {
+    auto &InterpCtx = Info.Ctx.getInterpContext();
+    switch (InterpCtx.isPotentialConstantExpr(Info, FD)) {
+    case interp::InterpResult::Success:
+    case interp::InterpResult::Fail:
+      return Diags.empty();
+    case interp::InterpResult::Bail:
+      break;
+    }
+  }
+
   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
   const CXXRecordDecl *RD = MD ? MD->getParent()->getCanonicalDecl() : nullptr;
 
diff --git a/clang/lib/AST/Interp/Builtin.h b/clang/lib/AST/Interp/Builtin.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Builtin.h
@@ -0,0 +1,27 @@
+//===--- Builtin.h - Builtins for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Builtin dispatch method definition.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_BUILTIN_H
+#define LLVM_CLANG_AST_INTERP_BUILTIN_H
+
+#include "Function.h"
+
+namespace clang {
+namespace interp {
+class InterpState;
+
+bool InterpBuiltin(InterpState &S, CodePtr OpPC, unsigned BuiltinOp);
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Builtin.cpp b/clang/lib/AST/Interp/Builtin.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Builtin.cpp
@@ -0,0 +1,103 @@
+//===--- Builtin.cpp - Builtins for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Builtin.h"
+#include "Interp.h"
+#include "InterpState.h"
+#include "Pointer.h"
+#include "Program.h"
+#include "Type.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/Basic/Builtins.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+static bool BuiltinLength(InterpState &S, CodePtr OpPC) {
+  using ResultT = PrimConv<PT_Uint64>::T;
+
+  // Get the pointer to the string and ensure it's an array of primitives.
+  const auto &Ptr = S.Stk.pop<Pointer>();
+  if (!CheckLive(S, OpPC, Ptr, AK_Read))
+    return false;
+  if (!CheckRange(S, OpPC, Ptr, AK_Read))
+    return false;
+
+  Descriptor *D = Ptr.getFieldDesc();
+  if (!D->IsArray || D->ElemDesc)
+    return false;
+
+  // Find the null terminator, starting at the pointed element.
+  const unsigned Size = D->Size - Ptr.getOffset();
+  char *Data = &Ptr.deref<char>();
+  switch (D->ElemSize) {
+  case 1:
+    for (unsigned Off = 0, I = 0; Off < Size; Off += 1, ++I) {
+      if (*reinterpret_cast<int8_t *>(Data + Off) == 0) {
+        S.Stk.push<ResultT>(ResultT::from(I));
+        return true;
+      }
+    }
+    break;
+  case 2:
+    for (unsigned Off = 0, I = 0; Off < Size; Off += 2, ++I) {
+      if (*reinterpret_cast<uint16_t *>(Data + Off) == 0) {
+        S.Stk.push<ResultT>(ResultT::from(I));
+        return true;
+      }
+    }
+    break;
+  case 4:
+    for (unsigned Off = 0, I = 0; Off < Size; Off += 4, ++I) {
+      if (*reinterpret_cast<uint32_t *>(Data + Off) == 0) {
+        S.Stk.push<ResultT>(ResultT::from(I));
+        return true;
+      }
+    }
+    break;
+  default:
+    llvm_unreachable("Unsupported character width!");
+  }
+
+  const SourceInfo &Loc = S.Current->getSource(OpPC);
+  S.FFDiag(Loc, diag::note_constexpr_access_past_end) << AK_Read;
+  return false;
+}
+
+static void ReportInvalidExpr(InterpState &S, CodePtr OpPC, unsigned Op) {
+  const char *Name = S.getCtx().BuiltinInfo.getName(Op);
+  const SourceInfo &Loc = S.Current->getSource(OpPC);
+
+  if (S.getLangOpts().CPlusPlus11)
+    S.CCEDiag(Loc, diag::note_constexpr_invalid_function)
+        << /*isConstexpr*/ 0 << /*isConstructor*/ 0
+        << (std::string("'") + Name + "'");
+  else
+    S.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
+}
+
+namespace clang {
+namespace interp {
+
+bool InterpBuiltin(InterpState &S, CodePtr OpPC, unsigned Op) {
+  switch (Op) {
+  case Builtin::BIstrlen:
+  case Builtin::BIwcslen:
+    ReportInvalidExpr(S, OpPC, Op);
+    return BuiltinLength(S, OpPC);
+  case Builtin::BI__builtin_strlen:
+  case Builtin::BI__builtin_wcslen:
+    return BuiltinLength(S, OpPC);
+  default:
+    // Builtin is not constexpr.
+    return false;
+  }
+}
+
+} // namespace interp
+} // namespace clang
diff --git a/clang/lib/AST/Interp/ByteCodeEmitter.h b/clang/lib/AST/Interp/ByteCodeEmitter.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/ByteCodeEmitter.h
@@ -0,0 +1,112 @@
+//===--- ByteCodeEmitter.h - Instruction emitter 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 instruction emitters.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_LINKEMITTER_H
+#define LLVM_CLANG_AST_INTERP_LINKEMITTER_H
+
+#include "ByteCodeGenError.h"
+#include "Context.h"
+#include "InterpStack.h"
+#include "InterpState.h"
+#include "Program.h"
+#include "Source.h"
+#include "Type.h"
+#include "llvm/Support/Error.h"
+
+namespace clang {
+namespace interp {
+class Context;
+class SourceInfo;
+enum Opcode : uint32_t;
+
+/// An emitter which links the program to bytecode for later use.
+class ByteCodeEmitter {
+protected:
+  using LabelTy = uint32_t;
+  using AddrTy = uintptr_t;
+  using Local = Scope::Local;
+
+public:
+  /// Compiles the function into the module.
+  llvm::Expected<Function *> compileFunc(const FunctionDecl *F);
+
+protected:
+  ByteCodeEmitter(Context &Ctx, Program &P) : Ctx(Ctx), P(P) {}
+
+  virtual ~ByteCodeEmitter() {}
+
+  /// Define a label.
+  void emitLabel(LabelTy Label);
+  /// Create a label.
+  LabelTy getLabel() { return ++NextLabel; }
+
+  /// Methods implemented by the compiler.
+  virtual bool compile(const FunctionDecl *E) = 0;
+  virtual bool compile(const Expr *E) = 0;
+  virtual bool compile(const VarDecl *E) = 0;
+
+  /// Bails out if a given node cannot be compiled.
+  bool bail(const Stmt *S) { return bail(S->getBeginLoc()); }
+  bool bail(const Decl *D) { return bail(D->getBeginLoc()); }
+  bool bail(const SourceLocation &Loc);
+
+  /// Emits jumps.
+  bool jumpTrue(const LabelTy &Label);
+  bool jumpFalse(const LabelTy &Label);
+  bool jump(const LabelTy &Label);
+  bool fallthrough(const LabelTy &Label);
+
+  /// Callback for local registration.
+  Local createLocal(Descriptor *D);
+
+  /// Parameter indices.
+  llvm::DenseMap<const ParmVarDecl *, unsigned> Params;
+  /// Local descriptors.
+  llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
+
+private:
+  /// Current compilation context.
+  Context &Ctx;
+  /// Program to link to.
+  Program &P;
+  /// Index of the next available label.
+  LabelTy NextLabel = 0;
+  /// Offset of the next local variable.
+  unsigned NextLocalOffset = 0;
+  /// Location of a failure.
+  llvm::Optional<SourceLocation> BailLocation;
+  /// Label information for linker.
+  llvm::DenseMap<LabelTy, unsigned> LabelOffsets;
+  /// Location of label relocations.
+  llvm::DenseMap<LabelTy, llvm::SmallVector<unsigned, 5>> LabelRelocs;
+  /// Program code.
+  std::vector<char> Code;
+  /// Opcode to expression mapping.
+  SourceMap SrcMap;
+
+  /// Returns the offset for a jump or records a relocation.
+  int32_t getOffset(LabelTy Label);
+
+  /// Emits an opcode.
+  template <typename... Tys>
+  bool emitOp(Opcode Op, const Tys &... Args, const SourceInfo &L);
+
+protected:
+#define GET_LINK_PROTO
+#include "Opcodes.inc"
+#undef GET_LINK_PROTO
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/ByteCodeEmitter.cpp b/clang/lib/AST/Interp/ByteCodeEmitter.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/ByteCodeEmitter.cpp
@@ -0,0 +1,174 @@
+//===--- ByteCodeEmitter.cpp - Instruction emitter 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "ByteCodeEmitter.h"
+#include "Context.h"
+#include "Opcode.h"
+#include "Program.h"
+#include "clang/AST/DeclCXX.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+using APSInt = llvm::APSInt;
+using Error = llvm::Error;
+
+Expected<Function *> ByteCodeEmitter::compileFunc(const FunctionDecl *F) {
+  // Do not try to compile undefined functions.
+  if (!F->isDefined(F) || (!F->hasBody() && F->willHaveBody()))
+    return nullptr;
+
+  // Set up argument indices.
+  unsigned ParamOffset = 0;
+  SmallVector<PrimType, 8> ParamTypes;
+  llvm::DenseMap<unsigned, Function::ParamDescriptor> ParamDescriptors;
+
+  // If the return is not a primitive, a pointer to the storage where the value
+  // is initialized in is passed as the first argument.
+  if (Ctx.isComposite(F->getReturnType())) {
+    ParamTypes.push_back(PT_Ptr);
+    ParamOffset += align(primSize(PT_Ptr));
+  }
+
+  // Assign descriptors to all parameters.
+  // Composite objects are lowered to pointers.
+  for (const ParmVarDecl *PD : F->parameters()) {
+    PrimType Ty;
+    if (llvm::Optional<PrimType> T = Ctx.classify(PD->getType())) {
+      Ty = *T;
+    } else {
+      Ty = PT_Ptr;
+    }
+
+    Descriptor *Desc = P.createDescriptor(PD, Ty);
+    ParamDescriptors.insert({ParamOffset, {Ty, Desc}});
+    Params.insert({PD, ParamOffset});
+    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() || !compile(F)) {
+    // Return a dummy function if compilation failed.
+    if (BailLocation)
+      return llvm::make_error<ByteCodeGenError>(*BailLocation);
+    else
+      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.
+    Func->setCode(NextLocalOffset, std::move(Code), std::move(SrcMap),
+                  std::move(Scopes));
+    return Func;
+  }
+}
+
+Scope::Local ByteCodeEmitter::createLocal(Descriptor *D) {
+  NextLocalOffset += sizeof(Block);
+  unsigned Location = NextLocalOffset;
+  NextLocalOffset += align(D->AllocSize);
+  return {Location, D};
+}
+
+void ByteCodeEmitter::emitLabel(LabelTy Label) {
+  const size_t Target = Code.size();
+  LabelOffsets.insert({Label, Target});
+  auto It = LabelRelocs.find(Label);
+  if (It != LabelRelocs.end()) {
+    for (unsigned Reloc : It->second) {
+      using namespace llvm::support;
+
+      /// Rewrite the operand of all jumps to this label.
+      void *Location = Code.data() + Reloc - sizeof(int32_t);
+      const int32_t Offset = Target - static_cast<int64_t>(Reloc);
+      endian::write<int32_t, endianness::native, 1>(Location, Offset);
+    }
+    LabelRelocs.erase(It);
+  }
+}
+
+int32_t ByteCodeEmitter::getOffset(LabelTy Label) {
+  // Compute the PC offset which the jump is relative to.
+  const int64_t Position = Code.size() + sizeof(Opcode) + sizeof(int32_t);
+
+  // If target is known, compute jump offset.
+  auto It = LabelOffsets.find(Label);
+  if (It != LabelOffsets.end()) {
+    return It->second - Position;
+  }
+
+  // Otherwise, record relocation and return dummy offset.
+  LabelRelocs[Label].push_back(Position);
+  return 0ull;
+}
+
+bool ByteCodeEmitter::bail(const SourceLocation &Loc) {
+  if (!BailLocation)
+    BailLocation = Loc;
+  return false;
+}
+
+template <typename... Tys>
+bool ByteCodeEmitter::emitOp(Opcode Op, const Tys &... Args, const SourceInfo &SI) {
+  bool Success = true;
+
+  /// Helper to write bytecode and bail out if 32-bit offsets become invalid.
+  auto emit = [this, &Success](const char *Data, size_t Size) {
+    if (Code.size() + Size > std::numeric_limits<unsigned>::max()) {
+      Success = false;
+      return;
+    }
+    Code.insert(Code.end(), Data, Data + Size);
+  };
+
+  /// The opcode is followed by arguments. The source info is
+  /// attached to the address after the opcode.
+  emit(reinterpret_cast<const char *>(&Op), sizeof(Opcode));
+  if (SI)
+    SrcMap.emplace_back(Code.size(), SI);
+
+  /// The initializer list forces the expression to be evaluated
+  /// for each argument in the variadic template, in order.
+  (void)std::initializer_list<int>{
+      (emit(reinterpret_cast<const char *>(&Args), sizeof(Args)), 0)...};
+
+  return Success;
+}
+
+bool ByteCodeEmitter::jumpTrue(const LabelTy &Label) {
+  return emitJt(getOffset(Label), SourceInfo{});
+}
+
+bool ByteCodeEmitter::jumpFalse(const LabelTy &Label) {
+  return emitJf(getOffset(Label), SourceInfo{});
+}
+
+bool ByteCodeEmitter::jump(const LabelTy &Label) {
+  return emitJmp(getOffset(Label), SourceInfo{});
+}
+
+bool ByteCodeEmitter::fallthrough(const LabelTy &Label) {
+  emitLabel(Label);
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Opcode emitters
+//===----------------------------------------------------------------------===//
+
+#define GET_LINK_IMPL
+#include "Opcodes.inc"
+#undef GET_LINK_IMPL
diff --git a/clang/lib/AST/Interp/ByteCodeGen.h b/clang/lib/AST/Interp/ByteCodeGen.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/ByteCodeGen.h
@@ -0,0 +1,205 @@
+//===--- ByteCodeGen.h - Code Generator for the constexpr 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 constexpr bytecode compiler.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_BYTECODEGEN_H
+#define LLVM_CLANG_AST_INTERP_BYTECODEGEN_H
+
+#include "EvalEmitter.h"
+#include "ByteCodeEmitter.h"
+#include "Pointer.h"
+#include "Record.h"
+#include "Type.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/StmtVisitor.h"
+#include "llvm/ADT/Optional.h"
+
+namespace clang {
+class QualType;
+
+namespace interp {
+class Function;
+class State;
+
+template <class Emitter> class LocalScope;
+template <class Emitter> class LoopScope;
+template <class Emitter> class SwitchScope;
+template <class Emitter> class RecordScope;
+template <class Emitter> class CompilerScope;
+
+/// Compilation context for a constexpr function.
+template <class Emitter>
+class ByteCodeGen : public ConstStmtVisitor<ByteCodeGen<Emitter>, bool>,
+                 public Emitter {
+  using NullaryFn = bool (ByteCodeGen::*)(const SourceInfo &);
+  using UnaryFn = bool (ByteCodeGen::*)(PrimType, const SourceInfo &);
+  using BinaryFn = bool (ByteCodeGen::*)(PrimType, PrimType, const SourceInfo &);
+
+  using LabelTy = typename Emitter::LabelTy;
+  using OptLabelTy = llvm::Optional<LabelTy>;
+  using CaseMap = llvm::DenseMap<const SwitchCase *, LabelTy>;
+
+  using AddrTy = typename Emitter::AddrTy;
+
+  /// Current compilation context.
+  Context &Ctx;
+  /// Program to link to.
+  Program &P;
+
+public:
+  /// Initializes the compiler and the backend emitter.
+  template <typename... Tys>
+  ByteCodeGen(Context &Ctx, Program &P, Tys &&... Args)
+      : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
+
+  // Expression visitors - result returned on stack.
+  bool VisitCastExpr(const CastExpr *CE);
+  bool VisitIntegerLiteral(const IntegerLiteral *E);
+  bool VisitParenExpr(const ParenExpr *PE);
+  bool VisitBinaryOperator(const BinaryOperator *BO);
+
+private:
+  // Statement visitors.
+  bool visit(const Stmt *S);
+  bool visitCompoundStmt(const CompoundStmt *S);
+  bool visitDeclStmt(const DeclStmt *DS);
+  bool visitReturnStmt(const ReturnStmt *RS);
+  bool visitIfStmt(const IfStmt *IS);
+
+  /// Evaluates an expr for side effects and discards the result.
+  bool discard(const Expr *E);
+  bool discardBinaryOperator(const BinaryOperator *BO);
+
+  /// Visits an expression and converts it to a boolean.
+  bool visitBool(const Expr *E);
+
+  enum class AccessKind {
+    /// Value is read and pushed to stack.
+    Read,
+    /// Direct method generates a value which is written. Returns pointer.
+    Write,
+    /// Direct method generates a value which is written.
+    WriteVoid,
+    /// Direct method receives the value, pushes mutated value. Returns pointer.
+    ReadWrite,
+    /// Direct method receives the value, pushes mutated copy.
+    ReadWriteVoid
+  };
+
+  /// Method to directly load a value. If the value can be fetched directly,
+  /// the direct handler is called. Otherwise, a pointer is left on the stack
+  /// and the indirect handler is expected to operate on that.
+  bool dereference(const Expr *LV, AccessKind AK,
+                   llvm::function_ref<bool(PrimType)> Direct,
+                   llvm::function_ref<bool(PrimType)> Indirect);
+  bool dereferenceParam(const Expr *LV, const ParmVarDecl *PD, AccessKind AK,
+                        llvm::function_ref<bool(PrimType)> Direct,
+                        llvm::function_ref<bool(PrimType)> Indirect);
+  bool dereferenceVar(const Expr *LV, const VarDecl *PD, AccessKind AK,
+                      llvm::function_ref<bool(PrimType)> Direct,
+                      llvm::function_ref<bool(PrimType)> Indirect);
+  bool dereferenceMember(const MemberExpr *PD, AccessKind AK,
+                         llvm::function_ref<bool(PrimType)> Direct,
+                         llvm::function_ref<bool(PrimType)> Indirect);
+
+  /// Compiles a variable declaration.
+  bool visitVarDecl(const VarDecl *VD);
+
+protected:
+  bool compile(const FunctionDecl *F) override;
+  bool compile(const Expr *E) override;
+  bool compile(const VarDecl *VD) override;
+
+private:
+  friend class CompilerScope<Emitter>;
+  friend class LocalScope<Emitter>;
+  friend class RecordScope<Emitter>;
+  friend class LoopScope<Emitter>;
+  friend class SwitchScope<Emitter>;
+
+  /// Returns the size int bits of an integer.
+  unsigned getIntWidth(QualType Ty) {
+    auto &ASTContext = Ctx.getASTContext();
+    return ASTContext.getIntWidth(Ty);
+  }
+  /// Returns the value of CHAR_BIT.
+  unsigned getCharBit() const {
+    auto &ASTContext = Ctx.getASTContext();
+    return ASTContext.getTargetInfo().getCharWidth();
+  }
+
+  /// Manages the range of a pointer, expanding/narrowing it.
+  bool adjustRange(const Expr *E, NullaryFn EmitOp);
+
+  /// Emits an APInt constant.
+  bool emitConst(PrimType T, unsigned NumBits, const llvm::APInt &Value,
+                 const Expr *E);
+
+  /// Emits an integer constant.
+  template<typename T>
+  bool emitConst(const Expr *E, T Value) {
+    QualType Ty = E->getType();
+    unsigned NumBits = getIntWidth(Ty);
+    APInt WrappedValue(NumBits, Value, std::is_signed<T>::value);
+    return emitConst(*Ctx.classify(Ty), NumBits, WrappedValue, E);
+  }
+
+  /// 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,
+                                         bool IsExtended = false);
+
+  /// Allocates a global primitive value.
+  unsigned allocateGlobalPrimitive(const VarDecl *VD, PrimType Ty,
+                                   bool IsMutable);
+  /// Allocates a space storing a global given its type.
+  llvm::Optional<unsigned> allocateGlobal(const VarDecl *VD);
+
+  /// Returns a record type from a record or pointer type.
+  const RecordType *getRecordTy(QualType Ty);
+
+  /// Returns a record from a record or pointer type.
+  Record *getRecord(QualType Ty);
+
+  /// Variable to storage mapping.
+  llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
+
+  /// OpaqueValueExpr to location mapping.
+  llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
+
+  /// Current scope.
+  CompilerScope<Emitter> *Top = nullptr;
+
+  /// Current argument index.
+  llvm::Optional<uint64_t> ArrayIndex;
+
+  /// Switch case mapping.
+  CaseMap CaseLabels;
+
+  /// Point to break to.
+  OptLabelTy BreakLabel;
+  /// Point to continue to.
+  OptLabelTy ContinueLabel;
+  /// Default case label.
+  OptLabelTy DefaultLabel;
+};
+
+extern template class ByteCodeGen<ByteCodeEmitter>;
+extern template class ByteCodeGen<EvalEmitter>;
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/ByteCodeGen.cpp b/clang/lib/AST/Interp/ByteCodeGen.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/ByteCodeGen.cpp
@@ -0,0 +1,858 @@
+//===--- ByteCodeGen.cpp - Code Generator for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "ByteCodeGen.h"
+#include "ByteCodeGenError.h"
+#include "Context.h"
+#include "EvalEmitter.h"
+#include "Function.h"
+#include "ByteCodeEmitter.h"
+#include "Opcode.h"
+#include "Program.h"
+#include "State.h"
+#include "Type.h"
+#include "llvm/ADT/SmallBitVector.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+using APSInt = llvm::APSInt;
+template <typename T> using Expected = llvm::Expected<T>;
+
+namespace clang {
+namespace interp {
+
+/// Scope chain managing the compiler state.
+///
+/// Classes deriving from this override certain parts of the compiler
+/// state to deal with block scopes, break/continue labels and cases.
+template <class Emitter> class CompilerScope {
+public:
+  virtual ~CompilerScope() { Ctx->Top = this->Parent; }
+
+  void add(const Scope::Local &Local, bool IsExtended) {
+    if (IsExtended)
+      this->addExtended(Local);
+    else
+      this->addLocal(Local);
+  }
+
+  virtual void addLocal(const Scope::Local &Local) {
+    if (this->Parent)
+      this->Parent->addLocal(Local);
+  }
+
+  virtual void addExtended(const Scope::Local &Local) {
+    if (this->Parent)
+      this->Parent->addExtended(Local);
+  }
+
+  virtual void emitDestruction() {}
+
+  CompilerScope *getParent() { return Parent; }
+
+protected:
+  CompilerScope(ByteCodeGen<Emitter> *Ctx) : Ctx(Ctx), Parent(Ctx->Top) {
+    Ctx->Top = this;
+  }
+
+  /// ByteCodeGen instance.
+  ByteCodeGen<Emitter> *Ctx;
+  /// Link to the parent scope.
+  CompilerScope *Parent;
+};
+
+/// Scope for local variables.
+///
+/// When the scope is destroyed, instructions are emitted to tear down
+/// all variables declared in this scope.
+template <class Emitter> class LocalScope : public CompilerScope<Emitter> {
+public:
+  LocalScope(ByteCodeGen<Emitter> *Ctx) : CompilerScope<Emitter>(Ctx) {}
+
+  ~LocalScope() override { this->emitDestruction(); }
+
+  void addLocal(const Scope::Local &Local) override {
+    if (!Idx.hasValue()) {
+      Idx = this->Ctx->Descriptors.size();
+      this->Ctx->Descriptors.emplace_back();
+    }
+
+    this->Ctx->Descriptors[*Idx].emplace_back(Local);
+  }
+
+  void emitDestruction() override {
+    if (!Idx.hasValue())
+      return;
+    this->Ctx->emitDestroy(*Idx, SourceInfo{});
+  }
+
+protected:
+  /// Index of the scope in the chain.
+  llvm::Optional<unsigned> Idx;
+};
+
+/// Scope for storage declared in a compound statement.
+template <class Emitter> class BlockScope final : public LocalScope<Emitter> {
+public:
+  BlockScope(ByteCodeGen<Emitter> *Ctx) : LocalScope<Emitter>(Ctx) {}
+
+  void addExtended(const Scope::Local &Local) override {
+    llvm_unreachable("Cannot create temporaries in full scopes");
+  }
+};
+
+/// Expression scope which tracks potentially lifetime extended
+/// temporaries which are hoisted to the parent scope on exit.
+template <class Emitter> class ExprScope final : public LocalScope<Emitter> {
+public:
+  ExprScope(ByteCodeGen<Emitter> *Ctx) : LocalScope<Emitter>(Ctx) {}
+
+  void addExtended(const Scope::Local &Local) override {
+    this->Parent->addLocal(Local);
+  }
+};
+
+/// Scope used to handle temporaries in toplevel variable declarations.
+template <class Emitter> class DeclScope final : public LocalScope<Emitter> {
+public:
+  DeclScope(ByteCodeGen<Emitter> *Ctx) : LocalScope<Emitter>(Ctx) {}
+
+  void addExtended(const Scope::Local &Local) override {
+    return this->addLocal(Local);
+  }
+};
+
+/// Sets the context for break/continue statements.
+template <class Emitter>
+class LoopScope final : public CompilerScope<Emitter> {
+public:
+  using LabelTy = typename ByteCodeGen<Emitter>::LabelTy;
+  using OptLabelTy = typename ByteCodeGen<Emitter>::OptLabelTy;
+
+  LoopScope(ByteCodeGen<Emitter> *Ctx, LabelTy BreakLabel,
+            LabelTy ContinueLabel)
+      : CompilerScope<Emitter>(Ctx), OldBreakLabel(Ctx->BreakLabel),
+        OldContinueLabel(Ctx->ContinueLabel) {
+    this->Ctx->BreakLabel = BreakLabel;
+    this->Ctx->ContinueLabel = ContinueLabel;
+  }
+
+  ~LoopScope() {
+    this->Ctx->BreakLabel = OldBreakLabel;
+    this->Ctx->ContinueLabel = OldContinueLabel;
+  }
+
+private:
+  OptLabelTy OldBreakLabel;
+  OptLabelTy OldContinueLabel;
+};
+
+// Sets the context for a switch scope, mapping labels.
+template <class Emitter>
+class SwitchScope final : public CompilerScope<Emitter> {
+public:
+  using LabelTy = typename ByteCodeGen<Emitter>::LabelTy;
+  using OptLabelTy = typename ByteCodeGen<Emitter>::OptLabelTy;
+  using CaseMap = typename ByteCodeGen<Emitter>::CaseMap;
+
+  SwitchScope(ByteCodeGen<Emitter> *Ctx, CaseMap &&CaseLabels,
+              LabelTy BreakLabel, OptLabelTy DefaultLabel)
+      : CompilerScope<Emitter>(Ctx), OldBreakLabel(Ctx->BreakLabel),
+        OldDefaultLabel(this->Ctx->DefaultLabel),
+        OldCaseLabels(std::move(this->Ctx->CaseLabels)) {
+    this->Ctx->BreakLabel = BreakLabel;
+    this->Ctx->DefaultLabel = DefaultLabel;
+    this->Ctx->CaseLabels = std::move(CaseLabels);
+  }
+
+  ~SwitchScope() {
+    this->Ctx->BreakLabel = OldBreakLabel;
+    this->Ctx->DefaultLabel = OldDefaultLabel;
+    this->Ctx->CaseLabels = std::move(OldCaseLabels);
+  }
+
+private:
+  OptLabelTy OldBreakLabel;
+  OptLabelTy OldDefaultLabel;
+  CaseMap OldCaseLabels;
+};
+
+} // namespace interp
+} // namespace clang
+
+template <class Emitter> bool ByteCodeGen<Emitter>::visit(const Stmt *S) {
+  switch (S->getStmtClass()) {
+  case Stmt::CompoundStmtClass:
+    return visitCompoundStmt(cast<CompoundStmt>(S));
+  case Stmt::DeclStmtClass:
+    return visitDeclStmt(cast<DeclStmt>(S));
+  case Stmt::ReturnStmtClass:
+    return visitReturnStmt(cast<ReturnStmt>(S));
+  case Stmt::IfStmtClass:
+    return visitIfStmt(cast<IfStmt>(S));
+  case Stmt::NullStmtClass:
+    return true;
+  default: {
+    if (auto *Exp = dyn_cast<Expr>(S)) {
+      if (Exp->getType()->isVoidType()) {
+        return this->Visit(Exp);
+      }
+      return discard(Exp);
+    }
+    return this->bail(S);
+  }
+  }
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::visitCompoundStmt(const CompoundStmt *CompoundStmt) {
+  BlockScope<Emitter> Scope(this);
+  for (auto *InnerStmt : CompoundStmt->body())
+    if (!visit(InnerStmt))
+      return false;
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeGen<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 ByteCodeGen<Emitter>::visitReturnStmt(const ReturnStmt *RS) {
+  if (const Expr *RE = RS->getRetValue()) {
+    ExprScope<Emitter> RetScope(this);
+    QualType RT = RE->getType();
+    if (Ctx.isComposite(RT)) {
+      return this->bail(RS);
+    } else {
+      // Primitive types are simply returned.
+      if (llvm::Optional<PrimType> T = Ctx.classify(RE)) {
+        if (!this->Visit(RE))
+          return false;
+        for (CompilerScope<Emitter> *C = Top; C; C = C->getParent())
+          C->emitDestruction();
+        if (!this->emitRet(*T, RS))
+          return false;
+        return true;
+      }
+    }
+    return this->bail(RS);
+  } else {
+    for (CompilerScope<Emitter> *C = Top; C; C = C->getParent())
+      C->emitDestruction();
+    if (!this->emitRetVoid(RS))
+      return false;
+    return true;
+  }
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::visitIfStmt(const IfStmt *IS) {
+  BlockScope<Emitter> IfScope(this);
+  if (auto *CondInit = IS->getInit())
+    if (!visit(IS->getInit()))
+      return false;
+
+  if (const DeclStmt *CondDecl = IS->getConditionVariableDeclStmt())
+    if (!visitDeclStmt(CondDecl))
+      return false;
+
+  if (!visitBool(IS->getCond()))
+    return false;
+
+  if (const Stmt *Else = IS->getElse()) {
+    LabelTy LabelElse = this->getLabel();
+    LabelTy LabelEnd = this->getLabel();
+    if (!this->jumpFalse(LabelElse))
+      return false;
+    if (!visit(IS->getThen()))
+      return false;
+    if (!this->jump(LabelEnd))
+      return false;
+    this->emitLabel(LabelElse);
+    if (!visit(Else))
+      return false;
+    this->emitLabel(LabelEnd);
+  } else {
+    LabelTy LabelEnd = this->getLabel();
+    if (!this->jumpFalse(LabelEnd))
+      return false;
+    if (!visit(IS->getThen()))
+      return false;
+    this->emitLabel(LabelEnd);
+  }
+
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
+  auto *SubExpr = CE->getSubExpr();
+  switch (CE->getCastKind()) {
+
+  case CK_LValueToRValue: {
+    return dereference(
+        CE->getSubExpr(), AccessKind::Read,
+        [](PrimType) {
+          // Value loaded - nothing to do here.
+          return true;
+        },
+        [this, CE](PrimType T) {
+          // Pointer on stack - dereference it.
+          return this->emitLoadPop(T, CE);
+        });
+  }
+
+  case CK_FunctionToPointerDecay:
+  case CK_ArrayToPointerDecay:
+  case CK_UserDefinedConversion:
+  case CK_NoOp: {
+    return this->Visit(SubExpr);
+  }
+
+  default: {
+    // TODO: implement other casts.
+    return this->bail(CE);
+  }
+  }
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::VisitIntegerLiteral(const IntegerLiteral *LE) {
+  auto Val = LE->getValue();
+
+  QualType LitTy = LE->getType();
+  if (llvm::Optional<PrimType> T = Ctx.classify(LitTy))
+    return emitConst(*T, getIntWidth(LitTy), LE->getValue(), LE);
+  return this->bail(LE);
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::VisitParenExpr(const ParenExpr *PE) {
+  return this->Visit(PE->getSubExpr());
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::VisitBinaryOperator(const BinaryOperator *BO) {
+  // Typecheck the args.
+  const Expr *LHS = BO->getLHS();
+  llvm::Optional<PrimType> TypeLHS = Ctx.classify(LHS->getType());
+  if (!TypeLHS) {
+    return this->bail(BO);
+  }
+  const Expr *RHS = BO->getRHS();
+  llvm::Optional<PrimType> TypeRHS = Ctx.classify(RHS->getType());
+  if (!TypeRHS) {
+    return this->bail(BO);
+  }
+
+  if (llvm::Optional<PrimType> T = Ctx.classify(BO->getType())) {
+    switch (BO->getOpcode()) {
+    case BO_Comma: {
+      if (!discard(LHS))
+        return false;
+      if (!this->Visit(RHS))
+        return false;
+      return true;
+    }
+
+    default:
+      break;
+    }
+
+    if (!this->Visit(LHS))
+      return false;
+    if (!this->Visit(RHS))
+      return false;
+
+    switch (BO->getOpcode()) {
+    case BO_EQ:
+      return this->emitEQ(*TypeLHS, BO);
+    case BO_NE:
+      return this->emitNE(*TypeLHS, BO);
+    case BO_LT:
+      return this->emitLT(*TypeLHS, BO);
+    case BO_LE:
+      return this->emitLE(*TypeLHS, BO);
+    case BO_GT:
+      return this->emitGT(*TypeLHS, BO);
+    case BO_GE:
+      return this->emitGE(*TypeLHS, BO);
+    case BO_Rem:
+      return this->emitRem(*T, BO);
+    case BO_Div:
+      return this->emitDiv(*T, BO);
+    case BO_Sub:
+      return this->emitSub(*T, BO);
+    case BO_Add:
+      return this->emitAdd(*T, BO);
+    case BO_Mul:
+      return this->emitMul(*T, BO);
+    default:
+      return this->bail(BO);
+    }
+  }
+
+  return this->bail(BO);
+}
+
+template <class Emitter> bool ByteCodeGen<Emitter>::discard(const Expr *DE) {
+  switch (DE->getStmtClass()) {
+  case Stmt::BinaryOperatorClass:
+    return discardBinaryOperator(static_cast<const BinaryOperator *>(DE));
+  default:
+    if (!this->Visit(DE))
+      return false;
+    if (llvm::Optional<PrimType> T = Ctx.classify(DE))
+      return this->emitPop(*T, DE);
+    break;
+  }
+
+  return this->bail(DE);
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::discardBinaryOperator(const BinaryOperator *BO) {
+  // Typecheck the args.
+  auto *LHS = BO->getLHS();
+  auto TypeLHS = Ctx.classify(LHS->getType());
+  if (!TypeLHS) {
+    return this->bail(BO);
+  }
+  auto *RHS = BO->getRHS();
+  auto TypeRHS = Ctx.classify(RHS->getType());
+  if (!TypeRHS) {
+    return this->bail(BO);
+  }
+
+  // Peephole optimisations.
+  if (llvm::Optional<PrimType> T = Ctx.classify(BO->getType())) {
+    // Handle operations with mixed types.
+    switch (BO->getOpcode()) {
+    case BO_Comma:
+      if (!discard(LHS))
+        return false;
+      if (!discard(RHS))
+        return false;
+      return true;
+    default:
+      break;
+    }
+
+    if (!this->Visit(BO))
+      return false;
+    return this->emitPop(*T, BO);
+  } else {
+    return this->bail(BO);
+  }
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::visitBool(const Expr *E) {
+  return this->Visit(E);
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::dereference(
+    const Expr *LV, AccessKind AK, llvm::function_ref<bool(PrimType)> Direct,
+    llvm::function_ref<bool(PrimType)> Indirect) {
+  if (auto *DE = dyn_cast<DeclRefExpr>(LV)) {
+    if (!DE->getDecl()->getType()->isReferenceType()) {
+      if (auto *PD = dyn_cast<ParmVarDecl>(DE->getDecl()))
+        return dereferenceParam(LV, PD, AK, Direct, Indirect);
+      if (auto *VD = dyn_cast<VarDecl>(DE->getDecl()))
+        return dereferenceVar(LV, VD, AK, Direct, Indirect);
+    }
+  }
+
+  if (auto *ME = dyn_cast<MemberExpr>(LV))
+    return dereferenceMember(ME, AK, Direct, Indirect);
+
+  if (llvm::Optional<PrimType> T = Ctx.classify(LV->getType())) {
+    if (!this->Visit(LV))
+      return false;
+    return Indirect(*T);
+  }
+  return false;
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::dereferenceParam(
+    const Expr *LV, const ParmVarDecl *PD, AccessKind AK,
+    llvm::function_ref<bool(PrimType)> Direct,
+    llvm::function_ref<bool(PrimType)> Indirect) {
+  llvm::Optional<PrimType> T = Ctx.classify(LV->getType());
+  if (!T)
+    return this->bail(LV);
+
+  auto It = this->Params.find(PD);
+  if (It != this->Params.end()) {
+    unsigned Idx = It->second;
+    switch (AK) {
+    case AccessKind::Read:
+      if (!this->emitGetParam(*T, Idx, LV))
+        return false;
+      break;
+    case AccessKind::Write:
+      if (!Direct(*T))
+        return false;
+      if (!this->emitSetParam(*T, Idx, LV))
+        return false;
+      if (!this->emitGetPtrParam(Idx, LV))
+        return false;
+      break;
+    case AccessKind::WriteVoid:
+      if (!Direct(*T))
+        return false;
+      if (!this->emitSetParam(*T, Idx, LV))
+        return false;
+      break;
+    case AccessKind::ReadWrite:
+      if (!this->emitGetParam(*T, Idx, LV))
+        return false;
+      if (!Direct(*T))
+        return false;
+      if (!this->emitSetParam(*T, Idx, LV))
+        return false;
+      if (!this->emitGetPtrParam(Idx, LV))
+        return false;
+      break;
+    case AccessKind::ReadWriteVoid:
+      if (!this->emitGetParam(*T, Idx, LV))
+        return false;
+      if (!Direct(*T))
+        return false;
+      if (!this->emitSetParam(*T, Idx, LV))
+        return false;
+      break;
+    }
+    return true;
+  }
+
+  // If the param is a pointer, we can dereference a dummy value.
+  if (PD->getType()->hasPointerRepresentation()) {
+    if (AK == AccessKind::Read) {
+      if (auto Idx = this->P.getOrCreateExtern(PD))
+        return this->emitGetPtrGlobal(*Idx, PD);
+    }
+    return Direct(*T);
+  }
+
+  // Value cannot be produced - try to emit pointer.
+  if (!this->Visit(LV))
+    return false;
+  return Indirect(*T);
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::dereferenceVar(
+    const Expr *LV, const VarDecl *VD, AccessKind AK,
+    llvm::function_ref<bool(PrimType)> Direct,
+    llvm::function_ref<bool(PrimType)> Indirect) {
+  llvm::Optional<PrimType> T = Ctx.classify(LV->getType());
+  if (!T)
+    return this->bail(LV);
+
+  auto It = Locals.find(VD);
+  if (It != Locals.end()) {
+    const auto &L = It->second;
+    switch (AK) {
+    case AccessKind::Read: {
+      if (!this->emitGetLocal(*T, L.Offset, LV))
+        return false;
+      break;
+    }
+    case AccessKind::Write: {
+      if (!Direct(*T))
+        return false;
+      if (!this->emitSetLocal(*T, L.Offset, LV))
+        return false;
+      if (!this->emitGetPtrLocal(L.Offset, LV))
+        return false;
+      break;
+    }
+    case AccessKind::WriteVoid: {
+      if (!Direct(*T))
+        return false;
+      if (!this->emitSetLocal(*T, L.Offset, LV))
+        return false;
+      break;
+    }
+    case AccessKind::ReadWrite: {
+      if (!this->emitGetLocal(*T, L.Offset, LV))
+        return false;
+      if (!Direct(*T))
+        return false;
+      if (!this->emitSetLocal(*T, L.Offset, LV))
+        return false;
+      if (!this->emitGetPtrLocal(L.Offset, LV))
+        return false;
+      break;
+    }
+    case AccessKind::ReadWriteVoid: {
+      if (!this->emitGetLocal(*T, L.Offset, LV))
+        return false;
+      if (!Direct(*T))
+        return false;
+      if (!this->emitSetLocal(*T, L.Offset, LV))
+        return false;
+      break;
+    }
+    }
+    return true;
+  }
+
+  // If the declaration is a constant value, emit it here even
+  // though the declaration was not evaluated in the current scope.
+  // The access mode can only be read in this case.
+  if (VD->hasLocalStorage() && VD->hasInit()) {
+    QualType VT = VD->getType();
+    const bool IsRead = AK == AccessKind::Read;
+    if (VT.isConstQualified() && VT->isFundamentalType() && IsRead) {
+      if (!this->Visit(VD->getInit()))
+        return false;
+      return Direct(*T);
+    }
+  }
+
+  // Value cannot be produced - try to emit pointer.
+  if (!this->Visit(LV))
+    return false;
+  return Indirect(*T);
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::dereferenceMember(
+    const MemberExpr *ME, AccessKind AK,
+    llvm::function_ref<bool(PrimType)> Direct,
+    llvm::function_ref<bool(PrimType)> Indirect) {
+  // Classify the field type.
+  llvm::Optional<PrimType> T = Ctx.classify(ME->getType());
+  if (!T)
+    return this->bail(ME);
+
+  // Return the record descriptor.
+  auto *R = getRecord(ME->getBase()->getType());
+  if (!R)
+    return this->bail(ME);
+
+  // TODO: read field.
+  return this->bail(ME);
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::visitVarDecl(const VarDecl *VD) {
+  auto DT = VD->getType();
+
+  if (!VD->hasLocalStorage()) {
+    // No code generation required.
+    return true;
+  }
+
+  // Integers, pointers, primitives.
+  if (llvm::Optional<PrimType> T = Ctx.classify(DT)) {
+    auto Off = allocateLocalPrimitive(VD, *T, !DT.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);
+  } else {
+    // Composite types - allocate storage and initialize it.
+    return this->bail(VD);
+  }
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::adjustRange(const Expr *E, NullaryFn EmitOp) {
+  if (!Ctx.isComposite(E->getType()))
+    return true;
+  return (this->*EmitOp)(E);
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::emitConst(PrimType T, unsigned NumBits,
+                                     const APInt &Value, const Expr *E) {
+  switch (T) {
+  case PT_Sint8:
+    return this->emitConstSint8(Value.getSExtValue(), E);
+  case PT_Uint8:
+    return this->emitConstUint8(Value.getZExtValue(), E);
+  case PT_Sint16:
+    return this->emitConstSint16(Value.getSExtValue(), E);
+  case PT_Uint16:
+    return this->emitConstUint16(Value.getZExtValue(), E);
+  case PT_Sint32:
+    return this->emitConstSint32(Value.getSExtValue(), E);
+  case PT_Uint32:
+    return this->emitConstUint32(Value.getZExtValue(), E);
+  case PT_Sint64:
+    return this->emitConstSint64(Value.getSExtValue(), E);
+  case PT_Uint64:
+    return this->emitConstUint64(Value.getZExtValue(), E);
+  case PT_Bool:
+    return this->emitConstBool(Value.getBoolValue(), E);
+  case PT_Ptr:
+    llvm_unreachable("Invalid integral type");
+    break;
+  }
+}
+
+template <class Emitter>
+unsigned
+ByteCodeGen<Emitter>::allocateLocalPrimitive(DeclTy &&Decl, PrimType Ty,
+                                             bool IsMutable, bool IsExtended) {
+  Descriptor *D = P.createDescriptor(std::move(Decl), Ty, IsMutable,
+                                     Decl.is<const Expr *>());
+  Scope::Local Local = this->createLocal(D);
+  if (auto *VD = Decl.dyn_cast<const ValueDecl *>())
+    Locals.insert({VD, Local});
+  Top->add(Local, IsExtended);
+  return Local.Offset;
+}
+
+template <class Emitter>
+llvm::Optional<unsigned> ByteCodeGen<Emitter>::allocateLocal(DeclTy &&Decl,
+                                                             bool IsExtended) {
+  QualType Ty;
+
+  const ValueDecl *Key = nullptr;
+  bool IsTemporary = false;
+  if (auto *VD = Decl.dyn_cast<const ValueDecl *>()) {
+    Key = VD;
+    Ty = VD->getType();
+  }
+  if (auto *E = Decl.dyn_cast<const Expr *>()) {
+    IsTemporary = true;
+    Ty = E->getType();
+  }
+
+  Descriptor *D = P.createDescriptor(std::move(Decl), Ty.getTypePtr(),
+                                     !Ty.isConstQualified(), IsTemporary);
+  if (!D)
+    return {};
+
+  Scope::Local Local = this->createLocal(D);
+  if (Key)
+    Locals.insert({Key, Local});
+  Top->add(Local, IsExtended);
+  return Local.Offset;
+}
+
+template <class Emitter>
+unsigned ByteCodeGen<Emitter>::allocateGlobalPrimitive(const VarDecl *VD,
+                                                       PrimType Ty,
+                                                       bool IsMutable) {
+  Descriptor *D = P.createDescriptor(VD, Ty, IsMutable);
+  return P.emitGlobal(VD, D);
+}
+
+template <class Emitter>
+llvm::Optional<unsigned>
+ByteCodeGen<Emitter>::allocateGlobal(const VarDecl *VD) {
+  Descriptor *D = P.createDescriptor(VD, VD->getType().getTypePtr(),
+                                     !VD->getType().isConstQualified());
+  if (!D)
+    return {};
+  return P.emitGlobal(VD, D);
+}
+
+template <class Emitter>
+const RecordType *ByteCodeGen<Emitter>::getRecordTy(QualType Ty) {
+  if (auto *PT = dyn_cast<PointerType>(Ty))
+    return PT->getPointeeType()->getAs<RecordType>();
+  else
+    return Ty->getAs<RecordType>();
+}
+
+template <class Emitter>
+Record *ByteCodeGen<Emitter>::getRecord(QualType Ty) {
+  if (auto *RecordTy = getRecordTy(Ty)) {
+    return P.getOrCreateRecord(RecordTy->getDecl());
+  }
+  return nullptr;
+}
+
+template <class Emitter> bool ByteCodeGen<Emitter>::compile(const Expr *Exp) {
+  ExprScope<Emitter> RootScope(this);
+  if (!this->ConstStmtVisitor<ByteCodeGen<Emitter>, bool>::Visit(Exp))
+    return false;
+
+  if (llvm::Optional<PrimType> T = Ctx.classify(Exp))
+    return this->emitRet(*T, Exp);
+  return false;
+}
+
+template <class Emitter>
+bool ByteCodeGen<Emitter>::compile(const FunctionDecl *F) {
+  // Set up fields and context if a constructor.
+  if (auto *MD = dyn_cast<CXXMethodDecl>(F))
+    return this->bail(MD);
+
+  if (auto *Body = F->getBody())
+    if (!visit(Body))
+      return false;
+
+  // Emit a guard return to protect against a code path missing one.
+  if (F->getReturnType()->isVoidType())
+    return this->emitRetVoid(SourceInfo{});
+  else
+    return this->emitNoRet(SourceInfo{});
+}
+
+template <class Emitter> bool ByteCodeGen<Emitter>::compile(const VarDecl *VD) {
+  auto VT = VD->getType();
+  auto Init = VD->getInit();
+
+  DeclScope<Emitter> LocalScope(this);
+
+  if (llvm::Optional<PrimType> T = Ctx.classify(VT)) {
+    // Primitive declarations - compute the value and set it.
+    if (!this->ConstStmtVisitor<ByteCodeGen<Emitter>, bool>::Visit(Init))
+      return false;
+
+    // If the declaration is global, save the value for later use.
+    unsigned I = allocateGlobalPrimitive(VD, *T, !VT.isConstQualified());
+    if (!this->emitDup(*T, VD))
+      return false;
+    if (!this->emitInitGlobal(*T, I, VD))
+      return false;
+    return this->emitRet(*T, VD);
+  } else {
+    // Composite declarations - allocate storage and initialize it.
+    return this->bail(VD);
+  }
+}
+
+namespace clang {
+namespace interp {
+
+template class ByteCodeGen<ByteCodeEmitter>;
+template class ByteCodeGen<EvalEmitter>;
+
+} // namespace interp
+} // namespace clang
diff --git a/clang/lib/AST/Interp/ByteCodeGenError.h b/clang/lib/AST/Interp/ByteCodeGenError.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/ByteCodeGenError.h
@@ -0,0 +1,46 @@
+//===--- ByteCodeGenError.h - Byte code generation error ----------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_BYTECODEGENERROR_H
+#define LLVM_CLANG_AST_INTERP_BYTECODEGENERROR_H
+
+#include "clang/AST/Decl.h"
+#include "clang/AST/Stmt.h"
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/Support/Error.h"
+
+namespace clang {
+namespace interp {
+
+/// Error thrown by the compiler.
+struct ByteCodeGenError : public llvm::ErrorInfo<ByteCodeGenError> {
+public:
+  ByteCodeGenError(SourceLocation Loc) : Loc(Loc) {}
+  ByteCodeGenError(const Stmt *S) : ByteCodeGenError(S->getBeginLoc()) {}
+  ByteCodeGenError(const Decl *D) : ByteCodeGenError(D->getBeginLoc()) {}
+
+  void log(raw_ostream &OS) const override { OS << "unimplemented feature"; }
+
+  const SourceLocation &getLoc() const { return Loc; }
+
+  static char ID;
+
+private:
+  // Start of the item where the error occurred.
+  SourceLocation Loc;
+
+  // Users are not expected to use error_code.
+  std::error_code convertToErrorCode() const override {
+    return llvm::inconvertibleErrorCode();
+  }
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/ByteCodeGenError.cpp b/clang/lib/AST/Interp/ByteCodeGenError.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/ByteCodeGenError.cpp
@@ -0,0 +1,14 @@
+//===--- ByteCodeGenError.h - Byte code generation error --------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "ByteCodeGenError.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+char ByteCodeGenError::ID;
diff --git a/clang/lib/AST/Interp/CMakeLists.txt b/clang/lib/AST/Interp/CMakeLists.txt
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/CMakeLists.txt
@@ -0,0 +1,33 @@
+set(LLVM_LINK_COMPONENTS
+  )
+
+clang_tablegen(Opcodes.inc
+  -gen-clang-opcodes
+  SOURCE Opcodes.td
+  TARGET Opcodes)
+
+add_clang_library(clangInterp
+  Builtin.cpp
+  ByteCodeEmitter.cpp
+  ByteCodeGen.cpp
+  ByteCodeGenError.cpp
+  Context.cpp
+  Descriptor.cpp
+  Disasm.cpp
+  EvalEmitter.cpp
+  Frame.cpp
+  Function.cpp
+  Interp.cpp
+  InterpFrame.cpp
+  InterpStack.cpp
+  InterpState.cpp
+  Pointer.cpp
+  Program.cpp
+  Record.cpp
+  Source.cpp
+  State.cpp
+  Type.cpp
+
+  DEPENDS
+  Opcodes
+  )
diff --git a/clang/lib/AST/Interp/Context.h b/clang/lib/AST/Interp/Context.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Context.h
@@ -0,0 +1,102 @@
+//===--- Context.h - Context for the constexpr 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 constexpr execution context.
+//
+// The execution context manages cached bytecode and the global context.
+// It invokes the compiler and interpreter, propagating errors.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_CONTEXT_H
+#define LLVM_CLANG_AST_INTERP_CONTEXT_H
+
+#include "Context.h"
+#include "InterpStack.h"
+#include "clang/AST/APValue.h"
+#include "llvm/ADT/PointerIntPair.h"
+
+namespace clang {
+class ASTContext;
+class LangOptions;
+class Stmt;
+class FunctionDecl;
+class VarDecl;
+
+namespace interp {
+class Function;
+class Program;
+class State;
+enum PrimType : unsigned;
+
+/// Wrapper around interpreter termination results.
+enum class InterpResult {
+  /// Interpreter successfully computed a value.
+  Success,
+  /// Interpreter encountered an error and quit.
+  Fail,
+  /// Interpreter encountered an unimplemented feature, AST fallback.
+  Bail,
+};
+
+/// Holds all information required to evaluate constexpr code in a module.
+class Context {
+public:
+  /// Initialises the constexpr VM.
+  Context(ASTContext &Ctx);
+
+  /// Cleans up the constexpr VM.
+  ~Context();
+
+  /// Checks if a function is a potential constant expression.
+  InterpResult isPotentialConstantExpr(State &Parent,
+                                       const FunctionDecl *FnDecl);
+
+  /// Evaluates a toplevel expression as an rvalue.
+  InterpResult evaluateAsRValue(State &Parent, const Expr *E, APValue &Result);
+
+  /// Evaluates a toplevel initializer.
+  InterpResult evaluateAsInitializer(State &Parent, const VarDecl *VD,
+                                     APValue &Result);
+
+  /// Returns the AST context.
+  ASTContext &getASTContext() const { return Ctx; }
+  /// Returns the language options.
+  const LangOptions &getLangOpts() const;
+  /// Returns the interpreter stack.
+  InterpStack &getStack() { return Stk; }
+
+  /// Classifies an expression.
+  llvm::Optional<PrimType> classify(QualType T);
+  /// Classifies a type.
+  llvm::Optional<PrimType> classify(const Expr *E);
+  /// Checks if a type cannot be mapped to a VM type.
+  bool isComposite(QualType T) const;
+
+private:
+  /// Runs a function.
+  InterpResult Run(State &Parent, Function *Func, APValue &Result);
+
+  /// Checks a result fromt the interpreter.
+  InterpResult Check(State &Parent, llvm::Expected<bool> &&R);
+
+private:
+  /// Current compilation context.
+  ASTContext &Ctx;
+  /// Flag to indicate if the use of the interpreter is mandatory.
+  bool ForceInterp;
+  /// Interpreter stack, shared across invocations.
+  InterpStack Stk;
+  /// Constexpr program.
+  std::unique_ptr<Program> P;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Context.cpp b/clang/lib/AST/Interp/Context.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Context.cpp
@@ -0,0 +1,151 @@
+//===--- Context.cpp - Context for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Context.h"
+#include "ByteCodeGen.h"
+#include "EvalEmitter.h"
+#include "Interp.h"
+#include "InterpFrame.h"
+#include "InterpStack.h"
+#include "ByteCodeEmitter.h"
+#include "Program.h"
+#include "Type.h"
+#include "clang/AST/Expr.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+Context::Context(ASTContext &Ctx)
+    : Ctx(Ctx), ForceInterp(getLangOpts().ForceNewConstInterp),
+      P(new Program(*this)) {}
+
+Context::~Context() {}
+
+InterpResult Context::isPotentialConstantExpr(State &Parent,
+                                              const FunctionDecl *FD) {
+  Function *Func = P->getFunction(FD);
+  if (!Func) {
+    if (auto R = ByteCodeGen<ByteCodeEmitter>(*this, *P).compileFunc(FD)) {
+      Func = *R;
+    } else if (ForceInterp) {
+      handleAllErrors(R.takeError(), [&Parent](ByteCodeGenError &Err) {
+        Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
+      });
+      return InterpResult::Fail;
+    } else {
+      consumeError(R.takeError());
+      return InterpResult::Bail;
+    }
+  }
+
+  if (!Func->isConstexpr())
+    return InterpResult::Fail;
+
+  APValue Dummy;
+  return Run(Parent, Func, Dummy);
+}
+
+InterpResult Context::evaluateAsRValue(State &Parent, const Expr *E,
+                                       APValue &Result) {
+  assert(Stk.size() == 0 && "empty stack expected by evaluator");
+  ByteCodeGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
+  return Check(Parent, C.interpretExpr(E));
+}
+
+InterpResult Context::evaluateAsInitializer(State &Parent, const VarDecl *VD,
+                                            APValue &Result) {
+  assert(Stk.size() == 0 && "empty stack expected by evaluator");
+  ByteCodeGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
+  return Check(Parent, C.interpretDecl(VD));
+}
+
+const LangOptions &Context::getLangOpts() const { return Ctx.getLangOpts(); }
+
+llvm::Optional<PrimType> Context::classify(QualType T) {
+  if (T->isReferenceType())
+    return PT_Ptr;
+
+  if (T->isBooleanType())
+    return PT_Bool;
+
+  if (T->isSignedIntegerOrEnumerationType()) {
+    switch (Ctx.getIntWidth(T)) {
+    case 64:
+      return PT_Sint64;
+    case 32:
+      return PT_Sint32;
+    case 16:
+      return PT_Sint16;
+    case 8:
+      return PT_Sint8;
+    }
+  }
+
+  if (T->isUnsignedIntegerOrEnumerationType()) {
+    switch (Ctx.getIntWidth(T)) {
+    case 64:
+      return PT_Uint64;
+    case 32:
+      return PT_Uint32;
+    case 16:
+      return PT_Uint16;
+    case 8:
+      return PT_Uint8;
+    }
+  }
+
+  if (T->isNullPtrType())
+    return PT_Ptr;
+
+  if (T->isPointerType())
+    return PT_Ptr;
+
+  return {};
+}
+
+llvm::Optional<PrimType> Context::classify(const Expr *E) {
+  if (E->isGLValue())
+    return PT_Ptr;
+  return classify(E->getType());
+}
+
+bool Context::isComposite(QualType T) const {
+  if (T->isFundamentalType())
+    return false;
+  if (T->isEnumeralType())
+    return false;
+  if (T->hasPointerRepresentation())
+    return false;
+  if (T->isFunctionProtoType())
+    return false;
+  return true;
+}
+
+InterpResult 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 InterpResult::Success;
+  } else {
+    return InterpResult::Fail;
+  }
+}
+
+InterpResult Context::Check(State &Parent, llvm::Expected<bool> &&R) {
+  if (R) {
+    return *R ? InterpResult::Success : InterpResult::Fail;
+  } else if (ForceInterp) {
+    handleAllErrors(R.takeError(), [&Parent](ByteCodeGenError &Err) {
+      Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
+    });
+    return InterpResult::Fail;
+  } else {
+    consumeError(R.takeError());
+    return InterpResult::Bail;
+  }
+}
diff --git a/clang/lib/AST/Interp/Descriptor.h b/clang/lib/AST/Interp/Descriptor.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Descriptor.h
@@ -0,0 +1,158 @@
+//===--- Descriptor.h - Types for the constexpr 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 descriptors which characterise allocations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_DESCRIPTOR_H
+#define LLVM_CLANG_AST_INTERP_DESCRIPTOR_H
+
+#include "clang/AST/Decl.h"
+#include "clang/AST/Expr.h"
+
+namespace clang {
+namespace interp {
+class Block;
+class Record;
+struct Descriptor;
+enum PrimType : unsigned;
+
+using DeclTy = llvm::PointerUnion<const ValueDecl *, const Expr *>;
+
+/// Invoked whenever a block is created. The constructor method fills in the
+/// inline descriptors of all fields and array elements. It also initializes
+/// all the fields which contain non-trivial types.
+using BlockCtorFn = void (*)(Block *Storage, char *FieldPtr, bool IsMutable,
+                             bool IsActive, Descriptor *FieldDesc);
+
+/// Invoked when a block is destroyed. Invokes the destructors of all
+/// non-trivial nested fields of arrays and records.
+using BlockDtorFn = void (*)(Block *Storage, char *FieldPtr,
+                             Descriptor *FieldDesc);
+
+/// Invoked when a block with pointers referencing it goes out of scope. Such
+/// blocks are persisted: the move function copies all inline descriptors and
+/// non-trivial fields, as existing pointers might need to reference those
+/// 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 {
+  /// 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.
+  const InterpSize AllocSize;
+  /// Pointer to the record, if block contains records.
+  Record *const ElemRecord = nullptr;
+  /// Descriptor of the array element.
+  Descriptor *const ElemDesc = nullptr;
+  /// Flag indicating if the block is mutable.
+  const bool IsMutable = false;
+  /// Flag indicating if the block is a temporary.
+  const bool IsTemporary = false;
+  /// Flag indicating if the block is an array.
+  const bool IsArray = false;
+
+  /// Storage management methods.
+  const BlockCtorFn CtorFn = nullptr;
+  const BlockDtorFn DtorFn = nullptr;
+  const BlockMoveFn MoveFn = nullptr;
+
+  QualType getType() const;
+  SourceLocation getLocation() const;
+
+  /// Allocates a descriptor for a primitive.
+  Descriptor(const DeclTy &D, PrimType Type, bool IsMutable, bool IsTemporary);
+
+  /// Allocates a descriptor for an array of primitives.
+  Descriptor(const DeclTy &D, PrimType Type, size_t NumElems, bool IsMutable,
+             bool IsTemporary);
+
+  /// Allocates a descriptor for an array of composites.
+  Descriptor(const DeclTy &D, Descriptor *Elem, unsigned NumElems,
+             bool IsMutable, bool IsTemporary);
+
+  /// Allocates a descriptor for a record.
+  Descriptor(const DeclTy &D, Record *R, bool IsMutable, bool IsTemporary);
+
+  /// Returns the number of elements stored in the block.
+  size_t getNumElems() const { return Size / ElemSize; }
+
+  /// Checks if the descriptor is of an array of primitives.
+  bool isPrimitiveArray() const { return IsArray && !ElemDesc; }
+};
+
+/// Inline descriptor embedded in structures and arrays.
+///
+/// Such descriptors precede all composite array elements and structure fields.
+/// If the base of a pointer is not zero, the base points to the end of this
+/// structure. The offset field is used to traverse the pointer chain up
+/// to the root structure which allocated the object.
+struct InlineDescriptor {
+  /// Offset inside the structure/array.
+  unsigned Offset;
+
+  /// Flag indicating if the field is mutable or not.
+  /// Relevant for primitive fields.
+  unsigned IsMutable : 1;
+  /// Flag indicating if the field was initialized.
+  /// Relevant for primitive record fields.
+  unsigned IsInitialized : 1;
+  /// Flag indicating if the field is an embedded base class.
+  unsigned IsBase : 1;
+  /// Flag indicating if the field is the active member of a union.
+  unsigned IsActive : 1;
+
+  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 initialied, the pointer to
+/// this structure is 0. If the object was fully initialized, the pointer is -1.
+struct InitMap {
+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);
+
+  /// Returns a pointer to storage.
+  T *data();
+
+public:
+  /// Initializes an element. Returns true when object if fully initialized.
+  bool initialize(unsigned I);
+
+  /// Checks if an element was initialized.
+  bool isInitialized(unsigned I);
+
+  /// Allocates a map holding N elements.
+  static InitMap *allocate(unsigned N);
+
+private:
+  /// Number of fields initialized.
+  unsigned UninitFields;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Descriptor.cpp b/clang/lib/AST/Interp/Descriptor.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Descriptor.cpp
@@ -0,0 +1,287 @@
+//===--- Descriptor.cpp - Types for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Descriptor.h"
+#include "Pointer.h"
+#include "Record.h"
+#include "Type.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+template<typename T>
+static void ctorTy(Block *, char *Ptr, bool, bool, Descriptor *) {
+  new (Ptr) T();
+}
+
+template<typename T>
+static void dtorTy(Block *, char *Ptr, Descriptor *) {
+  reinterpret_cast<T *>(Ptr)->~T();
+}
+
+template<typename T>
+static void moveTy(Block *, char *Src, char *Dst, Descriptor *) {
+  auto *SrcPtr = reinterpret_cast<T *>(Src);
+  auto *DstPtr = reinterpret_cast<T *>(Dst);
+  new (DstPtr) T(std::move(*SrcPtr));
+}
+
+template<typename T>
+static void ctorArrayTy(Block *, char *Ptr, bool, bool, Descriptor *D) {
+  for (unsigned I = 0, NE = D->getNumElems(); I < NE; ++I) {
+    new (&reinterpret_cast<T *>(Ptr)[I]) T();
+  }
+}
+
+template<typename T>
+static void dtorArrayTy(Block *, char *Ptr, Descriptor *D) {
+  for (unsigned I = 0, NE = D->getNumElems(); I < NE; ++I) {
+    reinterpret_cast<T *>(Ptr)[I].~T();
+  }
+}
+
+template<typename T>
+static void moveArrayTy(Block *, char *Src, char *Dst, Descriptor *D) {
+  for (unsigned I = 0, NE = D->getNumElems(); I < NE; ++I) {
+    auto *SrcPtr = &reinterpret_cast<T *>(Src)[I];
+    auto *DstPtr = &reinterpret_cast<T *>(Dst)[I];
+    new (DstPtr) T(std::move(*SrcPtr));
+  }
+}
+
+static void ctorArrayDesc(Block *B, char *Ptr, bool IsMutable, bool IsActive,
+                          Descriptor *D) {
+  const unsigned NumElems = D->getNumElems();
+  const unsigned ElemSize = D->ElemDesc->AllocSize + sizeof(InlineDescriptor);
+
+  unsigned ElemOffset = 0;
+  for (unsigned I = 0; I < NumElems; ++I, ElemOffset += ElemSize) {
+    auto *ElemPtr = Ptr + ElemOffset;
+    auto *Desc = reinterpret_cast<InlineDescriptor *>(ElemPtr);
+    auto *ElemLoc = reinterpret_cast<char *>(Desc + 1);
+    auto *SD = D->ElemDesc;
+
+    Desc->Offset = ElemOffset + sizeof(InlineDescriptor);
+    Desc->Desc = SD;
+    Desc->IsMutable = IsMutable && D->IsMutable;
+    Desc->IsInitialized = true;
+    Desc->IsBase = false;
+    Desc->IsActive = IsActive;
+    if (auto Fn = D->ElemDesc->CtorFn)
+      Fn(B, ElemLoc, Desc->IsMutable, IsActive, D->ElemDesc);
+  }
+}
+
+static void dtorArrayDesc(Block *B, char *Ptr, Descriptor *D) {
+  const unsigned NumElems = D->getNumElems();
+  const unsigned ElemSize = D->ElemDesc->AllocSize + sizeof(InlineDescriptor);
+
+  unsigned ElemOffset = 0;
+  for (unsigned I = 0; I < NumElems; ++I, ElemOffset += ElemSize) {
+    auto *ElemPtr = Ptr + ElemOffset;
+    auto *Desc = reinterpret_cast<InlineDescriptor *>(ElemPtr);
+    auto *ElemLoc = reinterpret_cast<char *>(Desc + 1);
+    if (auto Fn = D->ElemDesc->DtorFn)
+      Fn(B, ElemLoc, D->ElemDesc);
+  }
+}
+
+static void moveArrayDesc(Block *B, char *Src, char *Dst, Descriptor *D) {
+  const unsigned NumElems = D->getNumElems();
+  const unsigned ElemSize = D->ElemDesc->AllocSize + sizeof(InlineDescriptor);
+
+  unsigned ElemOffset = 0;
+  for (unsigned I = 0; I < NumElems; ++I, ElemOffset += ElemSize) {
+    auto *SrcPtr = Src + ElemOffset;
+    auto *DstPtr = Dst + ElemOffset;
+
+    auto *SrcDesc = reinterpret_cast<InlineDescriptor *>(SrcPtr);
+    auto *SrcElemLoc = reinterpret_cast<char *>(SrcDesc + 1);
+    auto *DstDesc = reinterpret_cast<InlineDescriptor *>(DstPtr);
+    auto *DstElemLoc = reinterpret_cast<char *>(DstDesc + 1);
+
+    *DstDesc = *SrcDesc;
+    if (auto Fn = D->ElemDesc->MoveFn)
+      Fn(B, SrcElemLoc, DstElemLoc, D->ElemDesc);
+  }
+}
+
+static void ctorRecord(Block *B, char *Ptr, bool IsMutable, bool IsActive,
+                       Descriptor *D) {
+  const bool IsUnion = D->ElemRecord->isUnion();
+  auto CtorSub = [=](unsigned SubOff, Descriptor *SubDesc, bool IsBase) {
+    auto *Desc = reinterpret_cast<InlineDescriptor *>(Ptr + SubOff) - 1;
+    Desc->Offset = SubOff;
+    Desc->Desc = SubDesc;
+    Desc->IsMutable = IsMutable && SubDesc->IsMutable;
+    Desc->IsInitialized = B->isStatic() || SubDesc->IsArray;
+    Desc->IsBase = IsBase;
+    Desc->IsActive = IsActive && !IsUnion;
+    if (auto Fn = SubDesc->CtorFn)
+      Fn(B, Ptr + SubOff, Desc->IsMutable, Desc->IsActive, SubDesc);
+  };
+  for (const auto &B : D->ElemRecord->bases())
+    CtorSub(B.Offset, B.Desc, /*isBase=*/true);
+  for (const auto &F : D->ElemRecord->fields())
+    CtorSub(F.Offset, F.Desc, /*isBase=*/false);
+  for (const auto &V : D->ElemRecord->virtual_bases())
+    CtorSub(V.Offset, V.Desc, /*isBase=*/true);
+}
+
+static void dtorRecord(Block *B, char *Ptr, Descriptor *D) {
+  auto DtorSub = [=](unsigned SubOff, Descriptor *SubDesc) {
+    if (auto Fn = SubDesc->DtorFn)
+      Fn(B, Ptr + SubOff, SubDesc);
+  };
+  for (const auto &F : D->ElemRecord->bases())
+    DtorSub(F.Offset, F.Desc);
+  for (const auto &F : D->ElemRecord->fields())
+    DtorSub(F.Offset, F.Desc);
+  for (const auto &F : D->ElemRecord->virtual_bases())
+    DtorSub(F.Offset, F.Desc);
+}
+
+static void moveRecord(Block *B, char *Src, char *Dst, Descriptor *D) {
+  for (const auto &F : D->ElemRecord->fields()) {
+    auto FieldOff = F.Offset;
+    auto FieldDesc = F.Desc;
+
+    *(reinterpret_cast<Descriptor **>(Dst + FieldOff) - 1) = FieldDesc;
+    if (auto Fn = FieldDesc->MoveFn)
+      Fn(B, Src + FieldOff, Dst + FieldOff, FieldDesc);
+  }
+}
+
+static BlockCtorFn getCtorPrim(PrimType Type) {
+  switch (Type) {
+  case PT_Ptr:    return ctorTy<PrimConv<PT_Ptr>::T>;
+  default:        return nullptr;
+  }
+}
+
+static BlockDtorFn getDtorPrim(PrimType Type) {
+  switch (Type) {
+  case PT_Ptr:    return dtorTy<PrimConv<PT_Ptr>::T>;
+  default:        return nullptr;
+  }
+}
+
+static BlockMoveFn getMovePrim(PrimType Type) {
+  switch (Type) {
+  case PT_Ptr:    return moveTy<PrimConv<PT_Ptr>::T>;
+  default:        return nullptr;
+  }
+}
+
+static BlockCtorFn getCtorArrayPrim(PrimType Type) {
+  switch (Type) {
+  case PT_Ptr:    return ctorArrayTy<PrimConv<PT_Ptr>::T>;
+  default:        return nullptr;
+  }
+}
+
+static BlockDtorFn getDtorArrayPrim(PrimType Type) {
+  switch (Type) {
+  case PT_Ptr:    return dtorArrayTy<PrimConv<PT_Ptr>::T>;
+  default:        return nullptr;
+  }
+}
+
+static BlockMoveFn getMoveArrayPrim(PrimType Type) {
+  switch (Type) {
+  case PT_Ptr:    return moveArrayTy<PrimConv<PT_Ptr>::T>;
+  default:        return nullptr;
+  }
+}
+
+Descriptor::Descriptor(const DeclTy &D, PrimType Type, bool IsMutable,
+                       bool IsTemporary)
+    : Source(D), ElemSize(primSize(Type)), Size(ElemSize), AllocSize(Size),
+      IsMutable(IsMutable), IsTemporary(IsTemporary), CtorFn(getCtorPrim(Type)),
+      DtorFn(getDtorPrim(Type)), MoveFn(getMovePrim(Type)) {
+  assert(ElemSize != 0 && "Invalid element size");
+  assert(Size != 0 && "Invalid block size");
+}
+
+Descriptor::Descriptor(const DeclTy &D, PrimType Type, size_t NumElems,
+                       bool IsMutable, bool IsTemporary)
+    : Source(D), ElemSize(primSize(Type)), Size(ElemSize * NumElems),
+      AllocSize(align(Size) + sizeof(InitMap *)), IsMutable(IsMutable),
+      IsTemporary(IsTemporary), IsArray(true), CtorFn(getCtorArrayPrim(Type)),
+      DtorFn(getDtorArrayPrim(Type)), MoveFn(getMoveArrayPrim(Type)) {
+  assert(ElemSize != 0 && "Invalid element size");
+  assert(Size != 0 && "Invalid block size");
+}
+
+Descriptor::Descriptor(const DeclTy &D, Descriptor *Elem, unsigned NumElems,
+                       bool IsMutable, bool IsTemporary)
+    : Source(D), ElemSize(Elem->AllocSize + sizeof(InlineDescriptor)),
+      Size(ElemSize * NumElems), AllocSize(Size), ElemDesc(Elem),
+      IsMutable(IsMutable), IsTemporary(IsTemporary), IsArray(true),
+      CtorFn(ctorArrayDesc), DtorFn(dtorArrayDesc), MoveFn(moveArrayDesc) {
+  assert(ElemSize != 0 && "Invalid element size");
+  assert(Size != 0 && "Invalid block size");
+}
+
+Descriptor::Descriptor(const DeclTy &D, Record *R, bool IsMutable,
+                       bool IsTemporary)
+    : Source(D), ElemSize(R->getFullSize()), Size(ElemSize), AllocSize(Size),
+      ElemRecord(R), IsMutable(true), IsTemporary(IsTemporary),
+      CtorFn(ctorRecord), DtorFn(dtorRecord), MoveFn(moveRecord) {
+  assert(ElemSize != 0 && "Invalid element size");
+  assert(Size != 0 && "Invalid block size");
+}
+
+QualType Descriptor::getType() const {
+  if (auto *D = Source.dyn_cast<const ValueDecl *>())
+    return D->getType();
+  if (auto *E = Source.dyn_cast<const Expr *>())
+    return E->getType();
+  llvm_unreachable("Invalid descriptor type");
+}
+
+SourceLocation Descriptor::getLocation() const {
+  if (auto *D = Source.dyn_cast<const ValueDecl *>())
+    return D->getLocation();
+  if (auto *E = Source.dyn_cast<const Expr *>())
+    return E->getExprLoc();
+  llvm_unreachable("Invalid descriptor type");
+}
+
+InitMap::InitMap(unsigned N) : UninitFields(N) {
+  for (unsigned I = 0; I < N / PER_FIELD; ++I) {
+    data()[I] = 0;
+  }
+}
+
+InitMap::T *InitMap::data() {
+  auto *Start = reinterpret_cast<char *>(this) + align(sizeof(InitMap));
+  return reinterpret_cast<T *>(Start);
+}
+
+bool InitMap::initialize(unsigned I) {
+  unsigned Bucket = I / PER_FIELD;
+  unsigned Mask = 1ull << static_cast<uint64_t>(I % PER_FIELD);
+  if (!(data()[Bucket] & Mask)) {
+    data()[Bucket] |= Mask;
+    UninitFields -= 1;
+  }
+  return UninitFields == 0;
+}
+
+bool InitMap::isInitialized(unsigned I) {
+  unsigned Bucket = I / PER_FIELD;
+  unsigned Mask = 1ull << static_cast<uint64_t>(I % PER_FIELD);
+  return data()[Bucket] & Mask;
+}
+
+InitMap *InitMap::allocate(unsigned N) {
+  const size_t NumFields = ((N + PER_FIELD - 1) / PER_FIELD);
+  const size_t Size = align(sizeof(InitMap)) + NumFields * PER_FIELD;
+  return new (malloc(Size)) InitMap(N);
+}
diff --git a/clang/lib/AST/Interp/Disasm.cpp b/clang/lib/AST/Interp/Disasm.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Disasm.cpp
@@ -0,0 +1,69 @@
+//===--- Disasm.cpp - Disassembler for bytecode functions -------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Dump method for Function which disassembles the bytecode.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Function.h"
+#include "Opcode.h"
+#include "Program.h"
+#include "Type.h"
+#include "clang/AST/DeclCXX.h"
+#include "llvm/Support/Compiler.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+LLVM_DUMP_METHOD void Function::dump() const { dump(llvm::errs()); }
+
+LLVM_DUMP_METHOD void Function::dump(llvm::raw_ostream &OS) const {
+  if (F) {
+    if (auto *Cons = dyn_cast<CXXConstructorDecl>(F)) {
+      StringRef Name = Cons->getParent()->getName();
+      OS << Name << "::" << Name << ":\n";
+    } else {
+      OS << F->getName() << ":\n";
+    }
+  } else {
+    OS << "<<expr>>\n";
+  }
+
+  OS << "frame size: " << getFrameSize() << "\n";
+  OS << "arg size:   " << getArgSize() << "\n";
+  OS << "rvo:        " << hasRVO() << "\n";
+
+  auto PrintName = [&OS](const char *Name) {
+    OS << Name;
+    for (long I = 0, N = strlen(Name); I < 30 - N; ++I) {
+      OS << ' ';
+    }
+  };
+
+  for (CodePtr Start = getCodeBegin(), PC = Start; PC != getCodeEnd();) {
+    size_t Addr = PC - Start;
+    auto Op = PC.read<Opcode>();
+    OS << llvm::format("%8d", Addr) << " ";
+    switch (Op) {
+#define GET_DISASM
+#include "Opcodes.inc"
+#undef GET_DISASM
+    }
+  }
+}
+
+LLVM_DUMP_METHOD void Program::dump() const { dump(llvm::errs()); }
+
+LLVM_DUMP_METHOD void Program::dump(llvm::raw_ostream &OS) const {
+  for (auto &Func : Funcs) {
+    Func.second->dump();
+  }
+  for (auto &Anon : AnonFuncs) {
+    Anon->dump();
+  }
+}
diff --git a/clang/lib/AST/Interp/EvalEmitter.h b/clang/lib/AST/Interp/EvalEmitter.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/EvalEmitter.h
@@ -0,0 +1,125 @@
+//===--- EvalEmitter.h - Instruction emitter 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 instruction emitters.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_EVALEMITTER_H
+#define LLVM_CLANG_AST_INTERP_EVALEMITTER_H
+
+#include "ByteCodeGenError.h"
+#include "Context.h"
+#include "InterpStack.h"
+#include "InterpState.h"
+#include "Program.h"
+#include "Source.h"
+#include "Type.h"
+#include "llvm/Support/Error.h"
+
+namespace clang {
+class FunctionDecl;
+namespace interp {
+class Context;
+class Function;
+class InterpState;
+class Program;
+class SourceInfo;
+enum Opcode : uint32_t;
+
+/// An emitter which evaluates opcodes as they are emitted.
+class EvalEmitter : public SourceMapper {
+public:
+  using LabelTy = uint32_t;
+  using AddrTy = uintptr_t;
+  using Local = Scope::Local;
+
+  llvm::Expected<bool> interpretExpr(const Expr *E);
+  llvm::Expected<bool> interpretDecl(const VarDecl *VD);
+
+protected:
+  EvalEmitter(Context &Ctx, Program &P, State &Parent, InterpStack &Stk,
+              APValue &Result);
+
+  virtual ~EvalEmitter() {}
+
+  /// Define a label.
+  void emitLabel(LabelTy Label);
+  /// Create a label.
+  LabelTy getLabel();
+
+  /// Methods implemented by the compiler.
+  virtual bool compile(const FunctionDecl *E) = 0;
+  virtual bool compile(const Expr *E) = 0;
+  virtual bool compile(const VarDecl *VD) = 0;
+
+  bool bail(const Stmt *S) { return bail(S->getBeginLoc()); }
+  bool bail(const Decl *D) { return bail(D->getBeginLoc()); }
+  bool bail(const SourceLocation &Loc);
+
+  /// Emits jumps.
+  bool jumpTrue(const LabelTy &Label);
+  bool jumpFalse(const LabelTy &Label);
+  bool jump(const LabelTy &Label);
+  bool fallthrough(const LabelTy &Label);
+
+  /// Callback for registering a local.
+  Local createLocal(Descriptor *D);
+
+  /// Returns the source location of the current opcode.
+  SourceInfo getSource(Function *F, CodePtr PC) const override {
+    return F ? F->getSource(PC) : CurrentSource;
+  }
+
+  /// Parameter indices.
+  llvm::DenseMap<const ParmVarDecl *, unsigned> Params;
+  /// Local descriptors.
+  llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
+
+private:
+  /// Current compilation context.
+  Context &Ctx;
+  /// Current program.
+  Program &P;
+  /// Callee evaluation state.
+  InterpState S;
+  /// Location to write the result to.
+  APValue &Result;
+
+  /// Temporaries which require storage.
+  llvm::DenseMap<unsigned, std::unique_ptr<char[]>> Locals;
+
+  // The emitter always tracks the current instruction and sets OpPC to a token
+  // value which is mapped to the location of the opcode being evaluated.
+  CodePtr OpPC;
+  /// Location of a failure.
+  llvm::Optional<SourceLocation> BailLocation;
+  /// Location of the current instruction.
+  SourceInfo CurrentSource;
+
+  /// Next label ID to generate - first label is 1.
+  LabelTy NextLabel = 1;
+  /// Label being executed - 0 is the entry label.
+  LabelTy CurrentLabel = 0;
+  /// Active block which should be executed.
+  LabelTy ActiveLabel = 0;
+
+  /// Since expressions can only jump forward, predicated execution is
+  /// used to deal with if-else statements.
+  bool isActive() { return CurrentLabel == ActiveLabel; }
+
+protected:
+#define GET_EVAL_PROTO
+#include "Opcodes.inc"
+#undef GET_EVAL_PROTO
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/EvalEmitter.cpp b/clang/lib/AST/Interp/EvalEmitter.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/EvalEmitter.cpp
@@ -0,0 +1,164 @@
+//===--- EvalEmitter.cpp - Instruction emitter 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "EvalEmitter.h"
+#include "Context.h"
+#include "Interp.h"
+#include "Opcode.h"
+#include "Program.h"
+#include "clang/AST/DeclCXX.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+using APSInt = llvm::APSInt;
+template <typename T> using Expected = llvm::Expected<T>;
+
+EvalEmitter::EvalEmitter(Context &Ctx, Program &P, State &Parent,
+                         InterpStack &Stk, APValue &Result)
+    : Ctx(Ctx), P(P), S(Parent, P, Stk, Ctx, this), Result(Result) {
+  // Create a dummy frame for the interpreter which does not have locals.
+  S.Current = new InterpFrame(S, nullptr, nullptr, CodePtr(), Pointer());
+}
+
+llvm::Expected<bool> EvalEmitter::interpretExpr(const Expr *E) {
+  if (this->compile(E))
+    return true;
+  if (BailLocation)
+    return llvm::make_error<ByteCodeGenError>(*BailLocation);
+  return false;
+}
+
+llvm::Expected<bool> EvalEmitter::interpretDecl(const VarDecl *VD) {
+  if (this->compile(VD))
+    return true;
+  if (BailLocation)
+    return llvm::make_error<ByteCodeGenError>(*BailLocation);
+  return false;
+}
+
+void EvalEmitter::emitLabel(LabelTy Label) {
+  CurrentLabel = Label;
+}
+
+EvalEmitter::LabelTy EvalEmitter::getLabel() { return NextLabel++; }
+
+Scope::Local EvalEmitter::createLocal(Descriptor *D) {
+  // Allocate memory for a local.
+  auto Memory = llvm::make_unique<char[]>(sizeof(Block) + D->AllocSize);
+  auto *B = new (Memory.get()) Block(D, /*isStatic=*/false);
+  B->invokeCtor();
+
+  // Register the local.
+  unsigned Off = Locals.size();
+  Locals.insert({Off, std::move(Memory)});
+  return {Off, D};
+}
+
+bool EvalEmitter::bail(const SourceLocation &Loc) {
+  if (!BailLocation)
+    BailLocation = Loc;
+  return false;
+}
+
+bool EvalEmitter::jumpTrue(const LabelTy &Label) {
+  if (isActive()) {
+    if (S.Stk.pop<bool>())
+      ActiveLabel = Label;
+  }
+  return true;
+}
+
+bool EvalEmitter::jumpFalse(const LabelTy &Label) {
+  if (isActive()) {
+    if (!S.Stk.pop<bool>())
+      ActiveLabel = Label;
+  }
+  return true;
+}
+
+bool EvalEmitter::jump(const LabelTy &Label) {
+  if (isActive())
+    CurrentLabel = ActiveLabel = Label;
+  return true;
+}
+
+bool EvalEmitter::fallthrough(const LabelTy &Label) {
+  if (isActive())
+    ActiveLabel = Label;
+  CurrentLabel = Label;
+  return true;
+}
+
+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);
+}
+
+bool EvalEmitter::emitRetVoid(const SourceInfo &Info) { return true; }
+
+bool EvalEmitter::emitGetPtrLocal(const uint32_t &I, const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+
+  auto It = Locals.find(I);
+  assert(It != Locals.end() && "Missing local variable");
+  S.Stk.push<Pointer>(reinterpret_cast<Block *>(It->second.get()));
+  return true;
+}
+
+template <PrimType OpType>
+bool EvalEmitter::emitGetLocal(const uint32_t &I, const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+
+  using T = typename PrimConv<OpType>::T;
+
+  auto It = Locals.find(I);
+  assert(It != Locals.end() && "Missing local variable");
+  auto *B = reinterpret_cast<Block *>(It->second.get());
+  S.Stk.push<T>(*reinterpret_cast<T *>(B + 1));
+  return true;
+}
+
+template <PrimType OpType>
+bool EvalEmitter::emitSetLocal(const uint32_t &I, const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+
+  using T = typename PrimConv<OpType>::T;
+
+  auto It = Locals.find(I);
+  assert(It != Locals.end() && "Missing local variable");
+  auto *B = reinterpret_cast<Block *>(It->second.get());
+  *reinterpret_cast<T *>(B + 1) = S.Stk.pop<T>();
+  return true;
+}
+
+bool EvalEmitter::emitDestroy(const uint32_t &I, const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+
+  for (auto &Local : Descriptors[I]) {
+    auto It = Locals.find(Local.Offset);
+    assert(It != Locals.end() && "Missing local variable");
+    S.deallocate(reinterpret_cast<Block *>(It->second.get()));
+  }
+
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Opcode evaluators
+//===----------------------------------------------------------------------===//
+
+#define GET_EVAL_IMPL
+#include "Opcodes.inc"
+#undef GET_EVAL_IMPL
diff --git a/clang/lib/AST/Interp/Frame.h b/clang/lib/AST/Interp/Frame.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Frame.h
@@ -0,0 +1,45 @@
+//===--- Frame.h - Call frame for the VM and AST Walker ---------*- 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 base class of interpreter and evaluator stack frames.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_FRAME_H
+#define LLVM_CLANG_AST_INTERP_FRAME_H
+
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace clang {
+class FunctionDecl;
+
+namespace interp {
+
+/// Base class for stack frames, shared between VM and walker.
+class Frame {
+public:
+  virtual ~Frame();
+
+  /// Generates a human-readable description of the call site.
+  virtual void describe(llvm::raw_ostream &OS) = 0;
+
+  /// Returns a pointer to the caller frame.
+  virtual Frame *getCaller() const = 0;
+
+  /// Returns the location of the call site.
+  virtual SourceLocation getCallLocation() const = 0;
+
+  /// Returns the called function's declaration.
+  virtual const FunctionDecl *getCallee() const = 0;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Frame.cpp b/clang/lib/AST/Interp/Frame.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Frame.cpp
@@ -0,0 +1,14 @@
+//===--- Frame.cpp - Call frame for the VM and AST Walker -------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Frame.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+Frame::~Frame() {}
diff --git a/clang/lib/AST/Interp/Function.h b/clang/lib/AST/Interp/Function.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Function.h
@@ -0,0 +1,160 @@
+//===--- Function.h - Bytecode function 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 Function class which holds all bytecode function-specific data.
+//
+// The scope class which describes local variables is also defined here.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_FUNCTION_H
+#define LLVM_CLANG_AST_INTERP_FUNCTION_H
+
+#include "Pointer.h"
+#include "Source.h"
+#include "clang/AST/Decl.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace clang {
+namespace interp {
+class Program;
+class ByteCodeEmitter;
+enum PrimType : uint32_t;
+
+/// Describes a scope block.
+///
+/// The block gathers all the descriptors of the locals defined in this block.
+class Scope {
+public:
+  /// Information about a local's storage.
+  struct Local {
+    /// Offset of the local in frame.
+    unsigned Offset;
+    /// Descriptor of the local.
+    Descriptor *Desc;
+  };
+
+  using LocalVectorTy = llvm::SmallVector<Local, 8>;
+
+  Scope(LocalVectorTy &&Descriptors) : Descriptors(std::move(Descriptors)) {}
+
+  llvm::iterator_range<LocalVectorTy::iterator> locals() {
+    return llvm::make_range(Descriptors.begin(), Descriptors.end());
+  }
+
+private:
+  /// Object descriptors in this block.
+  LocalVectorTy Descriptors;
+};
+
+/// Bytecode function.
+///
+/// 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
+  unsigned getArgSize() const { return ArgSize; }
+
+  /// Returns a pointer to the start of the code.
+  CodePtr getCodeBegin() const;
+  /// Returns a pointer to the end of the code.
+  CodePtr getCodeEnd() const;
+
+  /// Returns the original FunctionDecl.
+  const FunctionDecl *getDecl() const { return F; }
+
+  /// Returns the lcoation.
+  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(); }
+
+  /// Range over the scope blocks.
+  llvm::iterator_range<llvm::SmallVector<Scope, 2>::iterator> scopes() {
+    return llvm::make_range(Scopes.begin(), Scopes.end());
+  }
+
+  /// Range over argument types.
+  using arg_reverse_iterator = SmallVectorImpl<PrimType>::reverse_iterator;
+  llvm::iterator_range<arg_reverse_iterator> args_reverse() {
+    return llvm::make_range(ParamTypes.rbegin(), ParamTypes.rend());
+  }
+
+  /// Returns a specific scope.
+  Scope &getScope(unsigned Idx) { return Scopes[Idx]; }
+
+  /// Returns the source information at a given PC.
+  SourceInfo getSource(CodePtr PC) const;
+
+  /// Checks if the function is valid to call in constexpr.
+  bool isConstexpr() const { return IsValid; }
+
+  /// Checks if the function is virtual.
+  bool isVirtual() const;
+
+private:
+  /// Construct a function representing an actual function.
+  Function(Program &P, const FunctionDecl *F, unsigned ArgSize,
+           llvm::SmallVector<PrimType, 8> &&ParamTypes,
+           llvm::DenseMap<unsigned, ParamDescriptor> &&Params);
+
+  /// Sets the code of a function.
+  void setCode(unsigned NewFrameSize, std::vector<char> &&NewCode, SourceMap &&NewSrcMap,
+               llvm::SmallVector<Scope, 2> &&NewScopes) {
+    FrameSize = NewFrameSize;
+    Code = std::move(NewCode);
+    SrcMap = std::move(NewSrcMap);
+    Scopes = std::move(NewScopes);
+    IsValid = true;
+  }
+
+private:
+  friend class Program;
+  friend class ByteCodeEmitter;
+
+  /// Program reference.
+  Program &P;
+  /// Location of the executed code.
+  SourceLocation Loc;
+  /// Declaration this function was compiled from.
+  const FunctionDecl *F;
+  /// Local area size: storage + metadata.
+  unsigned FrameSize;
+  /// Size of the argument stack.
+  unsigned ArgSize;
+  /// Program code.
+  std::vector<char> Code;
+  /// Opcode-to-expression mapping.
+  SourceMap SrcMap;
+  /// List of block descriptors.
+  llvm::SmallVector<Scope, 2> Scopes;
+  /// List of argument types.
+  llvm::SmallVector<PrimType, 8> ParamTypes;
+  /// Map from byte offset to parameter descriptor.
+  llvm::DenseMap<unsigned, ParamDescriptor> Params;
+  /// Flag to indicate if the function is valid.
+  bool IsValid = false;
+
+public:
+  /// Dumps the disassembled bytecode to \c llvm::errs().
+  void dump() const;
+  void dump(llvm::raw_ostream &OS) const;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Function.cpp b/clang/lib/AST/Interp/Function.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Function.cpp
@@ -0,0 +1,48 @@
+//===--- Function.h - Bytecode function 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Function.h"
+#include "Program.h"
+#include "Opcode.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+
+using namespace clang;
+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();
+  using Elem = std::pair<unsigned, SourceInfo>;
+  auto It = std::lower_bound(SrcMap.begin(), SrcMap.end(), Elem{Offset, {}},
+                             [](Elem A, Elem B) { return A.first < B.first; });
+  if (It == SrcMap.end() || It->first != Offset)
+    llvm::report_fatal_error("missing source location");
+  return It->second;
+}
+
+bool Function::isVirtual() const {
+  if (auto *M = dyn_cast<CXXMethodDecl>(F))
+    return M->isVirtual();
+  return false;
+}
diff --git a/clang/lib/AST/Interp/Integral.h b/clang/lib/AST/Interp/Integral.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Integral.h
@@ -0,0 +1,449 @@
+//===--- Integral.h - Wrapper for numeric types 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 VM types and helpers operating on types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_NUMBER_H
+#define LLVM_CLANG_AST_INTERP_NUMBER_H
+
+#include "clang/AST/ComparisonCategories.h"
+#include "llvm/ADT/APSInt.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstddef>
+#include <cstdint>
+
+namespace clang {
+namespace interp {
+
+using APInt = llvm::APInt;
+using APSInt = llvm::APSInt;
+
+/// Helper to compare two comparable types.
+template <typename T>
+ComparisonCategoryResult Compare(const T &X, const T &Y) {
+  if (X < Y)
+    return ComparisonCategoryResult::Less;
+  if (X > Y)
+    return ComparisonCategoryResult::Greater;
+  return ComparisonCategoryResult::Equal;
+}
+
+/// Wrapper around numeric types.
+///
+/// These wrappers are required to shared an interface between APSint and
+/// builtin primitive numeral types, while optimising for storage and
+/// allowing methods operating on primitive type to compile to fast code.
+template <unsigned Bits, bool Signed> class Integral {
+private:
+  template <unsigned OtherBits, bool OtherSigned> friend class Integral;
+
+  // Helper structure to select the representation.
+  template <unsigned B, bool S> struct Repr;
+  template <> struct Repr<1, false> { using Type = bool; };
+  template <> struct Repr<8, false> { using Type = uint8_t; };
+  template <> struct Repr<16, false> { using Type = uint16_t; };
+  template <> struct Repr<32, false> { using Type = uint32_t; };
+  template <> struct Repr<64, false> { using Type = uint64_t; };
+  template <> struct Repr<8, true> { using Type = int8_t; };
+  template <> struct Repr<16, true> { using Type = int16_t; };
+  template <> struct Repr<32, true> { using Type = int32_t; };
+  template <> struct Repr<64, true> { using Type = int64_t; };
+
+  /// Helper structure to select the min value.
+  template <unsigned B, bool S> struct Limits {
+    using Type = typename Repr<Bits, Signed>::Type;
+    static const auto Min = std::numeric_limits<Type>::min();
+    static const auto Max = std::numeric_limits<Type>::max();
+  };
+  template <> struct Limits<1, false> {
+    static const bool Min = false;
+    static const bool Max = true;
+  };
+
+  // The primitive representing the integral.
+  using T = typename Repr<Bits, Signed>::Type;
+  T V;
+
+  /// Primitive representing limits.
+  using Limit = Limits<Bits, Signed>;
+
+  /// Construct an integral from anything that is convertible to storage.
+  template <typename T> explicit Integral(T V) : V(V) {}
+
+public:
+  /// Zero-initializes an integral.
+  Integral() : V(0) {}
+
+  /// Constructs an integral from another integral.
+  template <unsigned SrcBits, bool SrcSign>
+  explicit Integral(Integral<SrcBits, SrcSign> V) : V(V.V) {}
+
+  /// Construct an integral from a value based on signedness.
+  explicit Integral(const APSInt &V)
+      : V(V.isSigned() ? V.getSExtValue() : V.getZExtValue()) {}
+
+  bool operator<(Integral RHS) const { return V < RHS.V; }
+  bool operator>(Integral RHS) const { return V > RHS.V; }
+  bool operator<=(Integral RHS) const { return V <= RHS.V; }
+  bool operator>=(Integral RHS) const { return V >= RHS.V; }
+  bool operator==(Integral RHS) const { return V == RHS.V; }
+  bool operator!=(Integral RHS) const { return V != RHS.V; }
+
+  bool operator>(unsigned RHS) const {
+    return V >= 0 && static_cast<unsigned>(V) > RHS;
+  }
+
+  Integral operator+(Integral RHS) const { return Integral(V + RHS.V); }
+  Integral operator-(Integral RHS) const { return Integral(V - RHS.V); }
+  Integral operator*(Integral RHS) const { return Integral(V * RHS.V); }
+  Integral operator/(Integral RHS) const { return Integral(V / RHS.V); }
+  Integral operator%(Integral RHS) const { return Integral(V % RHS.V); }
+  Integral operator&(Integral RHS) const { return Integral(V & RHS.V); }
+  Integral operator|(Integral RHS) const { return Integral(V | RHS.V); }
+  Integral operator^(Integral RHS) const { return Integral(V ^ RHS.V); }
+
+  Integral operator-() const { return Integral(-V); }
+  Integral operator~() const { return Integral(~V); }
+
+  Integral operator>>(unsigned RHS) const { return Integral(V >> RHS); }
+  Integral operator<<(unsigned RHS) const { return Integral(V << RHS); }
+
+  template <unsigned DstBits, bool DstSign>
+  explicit operator Integral<DstBits, DstSign>() const {
+    return Integral<DstBits, DstSign>(V);
+  }
+
+  explicit operator unsigned() const { return V; }
+  explicit operator int64_t() const { return V; }
+  explicit operator uint64_t() const { return V; }
+
+  APSInt toAPSInt() const { return APSInt(APInt(Bits, V, Signed), !Signed); }
+  APSInt toAPSInt(unsigned NumBits) const {
+    return APSInt(APInt(NumBits, V, Signed), !Signed);
+  }
+
+  Integral<Bits, false> toUnsigned() const {
+    return Integral<Bits, false>(*this);
+  }
+
+  constexpr static unsigned bitWidth() { return Bits; }
+
+  bool isZero() const { return !V; }
+
+  bool isMin() const { return *this == min(bitWidth()); }
+
+  bool isMinusOne() const { return Signed && V == T(-1); }
+
+  constexpr static bool isSigned() { return Signed; }
+
+  bool isNegative() const { return V < T(0); }
+  bool isPositive() const { return !isNegative(); }
+
+  ComparisonCategoryResult compare(const Integral &RHS) const {
+    return Compare(V, RHS.V);
+  }
+
+  unsigned countLeadingZeros() const {
+    unsigned LeadingZeros = __builtin_clzll(V);
+    constexpr auto FullBits = std::numeric_limits<unsigned long long>::digits;
+    return LeadingZeros - (FullBits - bitWidth());
+  }
+
+  void print(llvm::raw_ostream &OS) const { OS << V; }
+
+  static Integral min(unsigned NumBits) {
+    return Integral(Limit::Min);
+  }
+  static Integral max(unsigned NumBits) {
+    return Integral(Limit::Max);
+  }
+
+  template <typename T>
+  static typename std::enable_if<std::is_integral<T>::value, Integral>::type
+  from(T Value) {
+    return Integral(Value);
+  }
+
+  template <unsigned SrcBits, bool SrcSign>
+  static typename std::enable_if<SrcBits != 0, Integral>::type
+  from(Integral<SrcBits, SrcSign> Value) {
+    return Integral(Value.V);
+  }
+
+  template <bool SrcSign> static Integral from(Integral<0, SrcSign> Value) {
+    if (SrcSign)
+      return Integral(Value.V.getSExtValue());
+    else
+      return Integral(Value.V.getZExtValue());
+  }
+
+  static Integral zero() { return from(0); }
+
+  template <typename T> static Integral from(T Value, unsigned NumBits) {
+    return Integral(Value);
+  }
+
+  static bool inRange(int64_t Value, unsigned NumBits) {
+    return CheckRange<T, Limit::Min, Limit::Max>(Value);
+  }
+
+  static bool increment(Integral A, Integral *R) {
+    return add(A, Integral(T(1)), A.bitWidth(), R);
+  }
+
+  static bool decrement(Integral A, Integral *R) {
+    return sub(A, Integral(T(1)), A.bitWidth(), R);
+  }
+
+  static bool add(Integral A, Integral B, unsigned OpBits, Integral *R) {
+    return CheckAddUB(A.V, B.V, R->V);
+  }
+
+  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);
+  }
+
+private:
+  template <typename T>
+  static typename std::enable_if<std::is_signed<T>::value, bool>::type
+  CheckAddUB(T A, T B, T &R) {
+    return llvm::AddOverflow<T>(A, B, R);
+  }
+
+  template <typename T>
+  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
+  CheckAddUB(T A, T B, T &R) {
+    R = A + B;
+    return false;
+  }
+
+  template <typename T>
+  static typename std::enable_if<std::is_signed<T>::value, bool>::type
+  CheckSubUB(T A, T B, T &R) {
+    return llvm::SubOverflow<T>(A, B, R);
+  }
+
+  template <typename T>
+  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
+  CheckSubUB(T A, T B, T &R) {
+    R = A - B;
+    return false;
+  }
+
+  template <typename T>
+  static typename std::enable_if<std::is_signed<T>::value, bool>::type
+  CheckMulUB(T A, T B, T &R) {
+    return llvm::MulOverflow<T>(A, B, R);
+  }
+
+  template <typename T>
+  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
+  CheckMulUB(T A, T B, T &R) {
+    R = A * B;
+    return false;
+  }
+
+  template <typename T, T Min, T Max>
+  static typename std::enable_if<std::is_signed<T>::value, bool>::type
+  CheckRange(int64_t V) {
+    return Min <= V && V <= Max;
+  }
+
+  template <typename T, T Min, T Max>
+  static typename std::enable_if<std::is_unsigned<T>::value, bool>::type
+  CheckRange(int64_t V) {
+    return V >= 0 && static_cast<uint64_t>(V) <= Max;
+  }
+};
+
+/// Specialisation for fixed precision integers.
+template <bool Signed> class Integral<0, Signed> {
+private:
+  template <unsigned OtherBits, bool OtherSigned> friend class Integral;
+
+  /// Value is stored in an APSInt.
+  APSInt V;
+
+public:
+  /// Integral initialized to an undefined value.
+  Integral() : V() {}
+
+  /// Construct an integral from a value based on signedness.
+  explicit Integral(const APSInt &V) : V(V, !Signed) {}
+
+  bool operator<(const Integral &RHS) const { return V < RHS.V; }
+  bool operator>(const Integral &RHS) const { return V > RHS.V; }
+  bool operator<=(const Integral &RHS) const { return V <= RHS.V; }
+  bool operator>=(const Integral &RHS) const { return V >= RHS.V; }
+  bool operator==(const Integral &RHS) const { return V == RHS.V; }
+  bool operator!=(const Integral &RHS) const { return V != RHS.V; }
+
+  template <typename T>
+  bool operator>(T RHS) const {
+    constexpr bool ArgSigned = std::is_signed<T>::value;
+    return V > APSInt(APInt(V.getBitWidth(), RHS, ArgSigned), !ArgSigned);
+  }
+
+  template <typename T>
+  bool operator<(T RHS) const {
+    constexpr bool ArgSigned = std::is_signed<T>::value;
+    return V < APSInt(APInt(V.getBitWidth(), RHS, ArgSigned), !ArgSigned);
+  }
+
+  Integral operator+(const Integral &RHS) const { return Integral(V + RHS.V); }
+  Integral operator-(const Integral &RHS) const { return Integral(V - RHS.V); }
+  Integral operator*(const Integral &RHS) const { return Integral(V * RHS.V); }
+  Integral operator/(const Integral &RHS) const { return Integral(V / RHS.V); }
+  Integral operator%(const Integral &RHS) const { return Integral(V % RHS.V); }
+  Integral operator&(const Integral &RHS) const { return Integral(V & RHS.V); }
+  Integral operator|(const Integral &RHS) const { return Integral(V | RHS.V); }
+  Integral operator^(const Integral &RHS) const { return Integral(V ^ RHS.V); }
+
+  Integral operator-() const { return Integral(-V); }
+  Integral operator~() const { return Integral(~V); }
+
+  Integral operator>>(unsigned RHS) const { return Integral(V >> RHS); }
+  Integral operator<<(unsigned RHS) const { return Integral(V << RHS); }
+
+  explicit operator off_t() const {
+    return Signed ? V.getSExtValue() : V.getZExtValue();
+  }
+  explicit operator unsigned() const {
+    return Signed ? V.getZExtValue() : V.getZExtValue();
+  }
+
+  APSInt toAPSInt() const { return V; }
+  APSInt toAPSInt(unsigned NumBits) const {
+    if (Signed)
+      return APSInt(V.sextOrTrunc(NumBits), !Signed);
+    else
+      return APSInt(V.zextOrTrunc(NumBits), !Signed);
+  }
+
+  Integral<0, false> toUnsigned() const {
+    return Integral<0, false>::from(*this, bitWidth());
+  }
+
+  unsigned bitWidth() const { return V.getBitWidth(); }
+
+  bool isZero() const { return V.isNullValue(); }
+
+  bool isMin() const {
+    if (Signed)
+      return V.isMinSignedValue();
+    else
+      return V.isMinValue();
+  }
+
+  bool isMinusOne() const { return Signed && V.isAllOnesValue(); }
+
+  bool isSigned() const { return Signed; }
+
+  bool isNegative() const { return V.isNegative(); }
+  bool isPositive() const { return !isNegative(); }
+
+  ComparisonCategoryResult compare(const Integral &RHS) const {
+    if (V < RHS.V)
+      return ComparisonCategoryResult::Less;
+    if (V > RHS.V)
+      return ComparisonCategoryResult::Greater;
+    return ComparisonCategoryResult::Equal;
+  }
+
+  unsigned countLeadingZeros() const { return V.countLeadingZeros(); }
+
+  void print(llvm::raw_ostream &OS) const { OS << V; }
+
+  static Integral min(unsigned NumBits) {
+    if (Signed)
+      return Integral(APSInt(APInt::getSignedMinValue(NumBits), !Signed));
+    else
+      return Integral(APSInt(APInt::getMinValue(NumBits), !Signed));
+  }
+
+  static Integral max(unsigned NumBits) {
+    if (Signed)
+      return Integral(APSInt(APInt::getSignedMaxValue(NumBits), !Signed));
+    else
+      return Integral(APSInt(APInt::getMaxValue(NumBits), !Signed));
+  }
+
+  template <typename T>
+  static typename std::enable_if<std::is_integral<T>::value, Integral>::type
+  from(T Value, unsigned NumBits) {
+    const bool SrcSign = std::is_signed<T>::value;
+    return Integral(APSInt(APInt(NumBits, Value, SrcSign), !SrcSign));
+  }
+
+  template <unsigned SrcBits, bool SrcSign>
+  static typename std::enable_if<SrcBits != 0, Integral>::type
+  from(Integral<SrcBits, SrcSign> Value, unsigned NumBits) {
+    return Integral(APSInt(APInt(NumBits, Value.V, SrcSign), !SrcSign));
+  }
+
+  template <bool SrcSign>
+  static Integral from(Integral<0, SrcSign> Value, unsigned NumBits) {
+    if (SrcSign)
+      return Integral(APSInt(Value.V.sextOrTrunc(NumBits), !Signed));
+    else
+      return Integral(APSInt(Value.V.zextOrTrunc(NumBits), !Signed));
+  }
+
+  static Integral zero(unsigned NumBits) { return from(0, NumBits); }
+
+  static bool inRange(int64_t Value, unsigned NumBits) {
+    APSInt V(APInt(NumBits, Value, true), false);
+    return min(NumBits).V <= V && V <= max(NumBits).V;
+  }
+
+  static bool increment(Integral A, Integral *R) {
+    *R = A + Integral::from(1, A.bitWidth());
+    return A.isSigned() && !A.isNegative() && R->isNegative();
+  }
+
+  static bool decrement(Integral A, Integral *R) {
+    *R = A - Integral::from(1, A.bitWidth());
+    return !A.isSigned() && A.isNegative() && !R->isNegative();
+  }
+
+  static bool add(Integral A, Integral B, unsigned OpBits, Integral *R) {
+    APSInt Value(A.V.extend(OpBits) + B.V.extend(OpBits));
+    *R = Integral(Value.trunc(A.bitWidth()));
+    return R->V.extend(OpBits) != Value;
+  }
+
+  static bool sub(Integral A, Integral B, unsigned OpBits, Integral *R) {
+    APSInt Value(A.V.extend(OpBits) - B.V.extend(OpBits));
+    *R = Integral(Value.trunc(A.bitWidth()));
+    return R->V.extend(OpBits) != Value;
+  }
+
+  static bool mul(Integral A, Integral B, unsigned OpBits, Integral *R) {
+    APSInt Value(A.V.extend(OpBits) * B.V.extend(OpBits));
+    *R = Integral(Value.trunc(A.bitWidth()));
+    return R->V.extend(OpBits) != Value;
+  }
+};
+
+template <unsigned Bits, bool Signed>
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Integral<Bits, Signed> I) {
+  I.print(OS);
+  return OS;
+}
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Interp.h b/clang/lib/AST/Interp/Interp.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Interp.h
@@ -0,0 +1,1193 @@
+//===--- Interp.h - Interpreter for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Definition of the interpreter state and entry point.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_INTERP_H
+#define LLVM_CLANG_AST_INTERP_INTERP_H
+
+#include "Builtin.h"
+#include "Function.h"
+#include "InterpFrame.h"
+#include "InterpStack.h"
+#include "InterpState.h"
+#include "Opcode.h"
+#include "Program.h"
+#include "State.h"
+#include "Type.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"
+#include <limits>
+#include <vector>
+
+namespace clang {
+namespace interp {
+
+using APInt = llvm::APInt;
+using APSInt = llvm::APSInt;
+
+/// Convers a value to an APValue.
+template <typename T> bool ReturnValue(const T &V, APValue &R) {
+  R = APValue(V.toAPSInt());
+  return true;
+}
+
+template <> inline bool ReturnValue<Real>(const Real &V, APValue &R) {
+  R = APValue(V.toAPFloat());
+  return true;
+}
+
+template <> inline bool ReturnValue<Pointer>(const Pointer &Ptr, APValue &R) {
+  R = Ptr.toAPValue();
+  return true;
+}
+
+template <>
+inline bool ReturnValue<FnPointer>(const FnPointer &Ptr, APValue &R) {
+  R = Ptr.toAPValue();
+  return true;
+}
+
+/// Checks if a pointer is live and accesible.
+bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
+               AccessKinds AK);
+
+/// Checks if a pointer is null.
+bool CheckNull(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
+               CheckSubobjectKind CSK);
+
+/// Checks if a pointer is in range.
+bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
+                AccessKinds AK);
+
+/// Checks if a pointer points to a mutable location.
+bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr);
+
+
+/// Checks if a value can be loaded from a block.
+bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr);
+
+/// Checks if a value can be stored in a block.
+bool CheckStore(InterpState &S, CodePtr OpPC, const Pointer &Ptr);
+
+/// Checks if a value can be initialized.
+bool CheckInit(InterpState &S, CodePtr OpPC, const Pointer &Ptr);
+
+/// Checks if a method can be called.
+bool CheckCallable(InterpState &S, CodePtr OpPC, Function *F);
+
+template <typename T> inline bool IsTrue(const T &V) { return !V.isZero(); }
+template <> inline bool IsTrue(const Pointer &V) { return !V.isNull(); }
+template <> inline bool IsTrue(const FnPointer &V) { return !V.isNull(); }
+/// Finds a virtual override and adjusts This to point to the object.
+const CXXMethodDecl *VirtualLookup(Pointer &This, uintptr_t Fn);
+
+//===----------------------------------------------------------------------===//
+// Add, Sub, Mul
+//===----------------------------------------------------------------------===//
+
+template <typename T, bool (*OpFW)(T, T, unsigned, T *),
+          template <typename U> class OpAP>
+bool AddSubMulHelper(InterpState &S, CodePtr OpPC, unsigned Bits, const T &LHS,
+                     const T &RHS) {
+  // Fast path - add the numbers with fixed width.
+  T Result;
+  if (!OpFW(LHS, RHS, Bits, &Result)) {
+    S.Stk.push<T>(Result);
+    return true;
+  }
+
+  // If for some reason evaluation continues, use the truncated results.
+  S.Stk.push<T>(Result);
+
+  // Slow path - compute the result using another bit of precision.
+  APSInt Value = OpAP<APSInt>()(LHS.toAPSInt(Bits), RHS.toAPSInt(Bits));
+
+  // Report undefined behaviour, stopping if required.
+  const Expr *E = S.Current->getExpr(OpPC);
+  QualType Type = E->getType();
+  if (S.checkingForOverflow()) {
+    auto Trunc = Value.trunc(Result.bitWidth()).toString(10);
+    auto Loc = E->getExprLoc();
+    S.report(Loc, diag::warn_integer_constant_overflow) << Trunc << Type;
+    return true;
+  } else {
+    S.CCEDiag(E, diag::note_constexpr_overflow) << Value << Type;
+    return S.noteUndefinedBehavior();
+  }
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Add(InterpState &S, CodePtr OpPC) {
+  const T &RHS = S.Stk.pop<T>();
+  const T &LHS = S.Stk.pop<T>();
+  const unsigned Bits = RHS.bitWidth() + 1;
+  return AddSubMulHelper<T, T::add, std::plus>(S, OpPC, Bits, LHS, RHS);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Sub(InterpState &S, CodePtr OpPC) {
+  const T &RHS = S.Stk.pop<T>();
+  const T &LHS = S.Stk.pop<T>();
+  const unsigned Bits = RHS.bitWidth() + 1;
+  return AddSubMulHelper<T, T::sub, std::minus>(S, OpPC, Bits, LHS, RHS);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+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);
+}
+
+//===----------------------------------------------------------------------===//
+// Div, Rem
+//===----------------------------------------------------------------------===//
+
+template <typename T, T (*OpFW)(T, T), typename OpAP>
+bool DivRemHelper(InterpState &S, CodePtr OpPC) {
+  const T RHS = S.Stk.pop<T>();
+  const T LHS = S.Stk.pop<T>();
+
+  // Bail on division by zero.
+  if (RHS.isZero()) {
+    S.FFDiag(S.Current->getSource(OpPC), diag::note_expr_divide_by_zero);
+    return false;
+  }
+
+  if (RHS.isSigned()) {
+    // (-MAX - 1) / -1 = MAX + 1 overflows.
+    if (LHS.isMin() && RHS.isMinusOne()) {
+      // Push the truncated value in case the interpreter continues.
+      S.Stk.push<T>(T::min(RHS.bitWidth()));
+
+      // Compute the actual value for the diagnostic.
+      const size_t Bits = RHS.bitWidth() + 1;
+      APSInt Value = OpAP()(LHS.toAPSInt(Bits), RHS.toAPSInt(Bits));
+      return S.reportOverflow(S.Current->getExpr(OpPC), Value);
+    }
+  }
+
+  // Safe to execute division here.
+  S.Stk.push<T>(OpFW(LHS, RHS));
+  return true;
+}
+
+template <typename T> T DivFn(T a, T b) { return a / b; }
+
+template <typename T> T RemFn(T a, T b) { return a % b; }
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Div(InterpState &S, CodePtr OpPC) {
+  return DivRemHelper<T, DivFn<T>, std::divides<APSInt>>(S, OpPC);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Rem(InterpState &S, CodePtr OpPC) {
+  return DivRemHelper<T, RemFn<T>, std::modulus<APSInt>>(S, OpPC);
+}
+
+//===----------------------------------------------------------------------===//
+// 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;
+  const T &RHS = S.Stk.pop<T>();
+  const T &LHS = S.Stk.pop<T>();
+  S.Stk.push<BoolT>(BoolT::from(Fn(LHS.compare(RHS))));
+  return true;
+}
+
+template <typename T>
+bool CmpHelperEQ(InterpState &S, CodePtr OpPC, CompareFn Fn) {
+  return CmpHelper<T>(S, OpPC, Fn);
+}
+
+template <>
+inline bool CmpHelper<Pointer>(InterpState &S, CodePtr OpPC, CompareFn Fn) {
+  using BoolT = PrimConv<PT_Bool>::T;
+  const Pointer &RHS = S.Stk.pop<Pointer>();
+  const Pointer &LHS = S.Stk.pop<Pointer>();
+
+  if (!Pointer::hasSameBase(LHS, RHS)) {
+    const SourceInfo &Loc = S.Current->getSource(OpPC);
+    S.FFDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
+    return false;
+  } else {
+    unsigned VL = LHS.getByteOffset();
+    unsigned VR = RHS.getByteOffset();
+    S.Stk.push<BoolT>(BoolT::from(Fn(Compare(VL, VR))));
+    return true;
+  }
+}
+
+template <>
+inline bool CmpHelperEQ<Pointer>(InterpState &S, CodePtr OpPC, CompareFn Fn) {
+  using BoolT = PrimConv<PT_Bool>::T;
+  const Pointer &RHS = S.Stk.pop<Pointer>();
+  const Pointer &LHS = S.Stk.pop<Pointer>();
+
+  if (!Pointer::hasSameBase(LHS, RHS)) {
+    S.Stk.push<BoolT>(BoolT::from(Fn(ComparisonCategoryResult::Unordered)));
+    return true;
+  } else {
+    unsigned VL = LHS.getByteOffset();
+    unsigned VR = RHS.getByteOffset();
+    S.Stk.push<BoolT>(BoolT::from(Fn(Compare(VL, VR))));
+    return true;
+  }
+}
+
+template <>
+inline bool CmpHelperEQ<FnPointer>(InterpState &S, CodePtr OpPC, CompareFn Fn) {
+  using BoolT = PrimConv<PT_Bool>::T;
+  const FnPointer &RHS = S.Stk.pop<FnPointer>();
+  const FnPointer &LHS = S.Stk.pop<FnPointer>();
+  if (LHS.asDecl() == RHS.asDecl())
+    S.Stk.push<BoolT>(BoolT::from(Fn(ComparisonCategoryResult::Equal)));
+  else
+    S.Stk.push<BoolT>(BoolT::from(Fn(ComparisonCategoryResult::Nonequal)));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool EQ(InterpState &S, CodePtr OpPC) {
+  return CmpHelperEQ<T>(S, OpPC, [](ComparisonCategoryResult R) {
+    return R == ComparisonCategoryResult::Equal;
+  });
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool NE(InterpState &S, CodePtr OpPC) {
+  return CmpHelperEQ<T>(S, OpPC, [](ComparisonCategoryResult R) {
+    return R != ComparisonCategoryResult::Equal;
+  });
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool LT(InterpState &S, CodePtr OpPC) {
+  return CmpHelper<T>(S, OpPC, [](ComparisonCategoryResult R) {
+    return R == ComparisonCategoryResult::Less;
+  });
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool LE(InterpState &S, CodePtr OpPC) {
+  return CmpHelper<T>(S, OpPC, [](ComparisonCategoryResult R) {
+    return R == ComparisonCategoryResult::Less ||
+           R == ComparisonCategoryResult::Equal;
+  });
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool GT(InterpState &S, CodePtr OpPC) {
+  return CmpHelper<T>(S, OpPC, [](ComparisonCategoryResult R) {
+    return R == ComparisonCategoryResult::Greater;
+  });
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool GE(InterpState &S, CodePtr OpPC) {
+  return CmpHelper<T>(S, OpPC, [](ComparisonCategoryResult R) {
+    return R == ComparisonCategoryResult::Greater ||
+           R == ComparisonCategoryResult::Equal;
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// InRange
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool InRange(InterpState &S, CodePtr OpPC) {
+  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;
+}
+
+//===----------------------------------------------------------------------===//
+// Minus, Not, LogicalNot
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Minus(InterpState &S, CodePtr OpPC) {
+  const T &Arg = S.Stk.pop<T>();
+
+  if (Arg.isSigned() && Arg.isMin()) {
+    // Push the truncated value in case the interpreter continues.
+    S.Stk.push<T>(T::min(Arg.bitWidth()));
+
+    // Compute the actual value for the diagnostic.
+    const size_t Bits = Arg.bitWidth() + 1;
+    const APSInt Value = std::negate<APSInt>()(Arg.toAPSInt(Bits));
+    return S.reportOverflow(S.Current->getExpr(OpPC), Value);
+  }
+
+  S.Stk.push<T>(std::negate<T>()(Arg));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Not(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<T>(~S.Stk.pop<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool LogicalNot(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<bool>(!IsTrue<T>(S.Stk.pop<T>()));
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Dup, Pop, Test
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Dup(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<T>(S.Stk.peek<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Pop(InterpState &S, CodePtr OpPC) {
+  S.Stk.pop<T>();
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Test(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<bool>(IsTrue<T>(S.Stk.pop<T>()));
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Const, ConstFP
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Const(InterpState &S, CodePtr OpPC, const T &Arg) {
+  S.Stk.push<T>(Arg);
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Get/Set Local/Param/Global/This
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool GetLocal(InterpState &S, CodePtr OpPC, uint32_t I) {
+  S.Stk.push<T>(S.Current->getLocal<T>(I));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool SetLocal(InterpState &S, CodePtr OpPC, uint32_t I) {
+  S.Current->setLocal<T>(I, S.Stk.pop<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool GetParam(InterpState &S, CodePtr OpPC, uint32_t I) {
+  if (S.checkingPotentialConstantExpression()) {
+    return false;
+  }
+  S.Stk.push<T>(S.Current->getParam<T>(I));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool SetParam(InterpState &S, CodePtr OpPC, uint32_t I) {
+  S.Current->setParam<T>(I, S.Stk.pop<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool GetField(InterpState &S, CodePtr OpPC, uint32_t I) {
+  const Pointer &Obj = S.Stk.peek<Pointer>();
+  if (!CheckNull(S, OpPC, Obj, CSK_Field))
+      return false;
+  const Pointer &Field = Obj.atField(I);
+  if (!CheckLoad(S, OpPC, Field))
+    return false;
+  S.Stk.push<T>(Field.deref<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool SetField(InterpState &S, CodePtr OpPC, uint32_t I) {
+  const T &Value = S.Stk.pop<T>();
+  const Pointer &Obj = S.Stk.peek<Pointer>();
+  if (!CheckNull(S, OpPC, Obj, CSK_Field))
+    return false;
+  const Pointer &Field = Obj.atField(I);
+  if (!CheckStore(S, OpPC, Field))
+    return false;
+  Field.deref<T>() = Value;
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool GetFieldPop(InterpState &S, CodePtr OpPC, uint32_t I) {
+  const Pointer &Obj = S.Stk.pop<Pointer>();
+  if (!CheckNull(S, OpPC, Obj, CSK_Field))
+    return false;
+  const Pointer &Field = Obj.atField(I);
+  if (!CheckLoad(S, OpPC, Field))
+    return false;
+  S.Stk.push<T>(Field.deref<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool SetFieldPop(InterpState &S, CodePtr OpPC, uint32_t I) {
+  const T &Value = S.Stk.pop<T>();
+  const Pointer &Obj = S.Stk.pop<Pointer>();
+  if (!CheckNull(S, OpPC, Obj, CSK_Field))
+    return false;
+  const Pointer &Field = Obj.atField(I);
+  if (!CheckStore(S, OpPC, Field))
+    return false;
+  Field.deref<T>() = Value;
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool GetThisField(InterpState &S, CodePtr OpPC, uint32_t I) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  const Pointer &Field = S.Current->getThis().atField(I);
+  if (!CheckLoad(S, OpPC, Field))
+    return false;
+  S.Stk.push<T>(Field.deref<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool SetThisField(InterpState &S, CodePtr OpPC, uint32_t I) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  const T &Value = S.Stk.pop<T>();
+  const Pointer &Field = S.Current->getThis().atField(I);
+  if (!CheckStore(S, OpPC, Field))
+    return false;
+  Field.deref<T>() = Value;
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool GetGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
+  S.Stk.push<T>(S.P.getGlobal<T>(I));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool InitGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
+  S.P.setGlobal<T>(I, S.Stk.pop<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool InitThisField(InterpState &S, CodePtr OpPC, uint32_t I) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  const Pointer &Field = S.Current->getThis().atField(I);
+  Field.deref<T>() = S.Stk.pop<T>();
+  Field.initialize();
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool InitThisFieldActive(InterpState &S, CodePtr OpPC, uint32_t I) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  const Pointer &Field = S.Current->getThis().atField(I);
+  Field.deref<T>() = S.Stk.pop<T>();
+  Field.activate();
+  Field.initialize();
+  return true;
+}
+
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool InitField(InterpState &S, CodePtr OpPC, uint32_t I) {
+  const T &Value = S.Stk.pop<T>();
+  const Pointer &Field = S.Stk.pop<Pointer>().atField(I);
+  Field.deref<T>() = Value;
+  Field.activate();
+  Field.initialize();
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool InitFieldActive(InterpState &S, CodePtr OpPC, uint32_t I) {
+  const T &Value = S.Stk.pop<T>();
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  const Pointer &Field = Ptr.atField(I);
+  Field.deref<T>() = Value;
+  Field.activate();
+  Field.initialize();
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// GetPtr Local/Param/Global/Field/This
+//===----------------------------------------------------------------------===//
+
+inline bool GetPtrLocal(InterpState &S, CodePtr OpPC, uint32_t I) {
+  S.Stk.push<Pointer>(S.Current->getLocalPointer(I));
+  return true;
+}
+
+inline bool GetPtrParam(InterpState &S, CodePtr OpPC, uint32_t I) {
+  if (S.checkingPotentialConstantExpression()) {
+    return false;
+  }
+  S.Stk.push<Pointer>(S.Current->getParamPointer(I));
+  return true;
+}
+
+inline bool GetPtrGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
+  S.Stk.push<Pointer>(S.P.getPtrGlobal(I));
+  return true;
+}
+
+inline bool GetPtrField(InterpState &S, CodePtr OpPC, uint32_t Off) {
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  if (!CheckNull(S, OpPC, Ptr, CSK_Field))
+    return false;
+  S.Stk.push<Pointer>(Ptr.atField(Off));
+  return true;
+}
+
+inline bool GetPtrThisField(InterpState &S, CodePtr OpPC, uint32_t Off) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  const Pointer &Ptr = S.Current->getThis();
+  if (!CheckNull(S, OpPC, Ptr, CSK_Field))
+    return false;
+  S.Stk.push<Pointer>(Ptr.atField(Off));
+  return true;
+}
+
+inline bool GetPtrActiveField(InterpState &S, CodePtr OpPC, uint32_t Off) {
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  if (!CheckNull(S, OpPC, Ptr, CSK_Field))
+    return false;
+  Pointer Field = Ptr.atField(Off);
+  Ptr.deactivate();
+  Field.activate();
+  S.Stk.push<Pointer>(std::move(Field));
+  return true;
+}
+
+inline bool GetPtrActiveThisField(InterpState &S, CodePtr OpPC, uint32_t Off) {
+ if (S.checkingPotentialConstantExpression())
+    return false;
+  const Pointer &This = S.Current->getThis();
+  if (!CheckNull(S, OpPC, This, CSK_Field))
+    return false;
+  Pointer Field = This.atField(Off);
+  This.deactivate();
+  Field.activate();
+  S.Stk.push<Pointer>(std::move(Field));
+  return true;
+}
+
+inline bool GetPtrBase(InterpState &S, CodePtr OpPC, uint32_t Off) {
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  if (!CheckNull(S, OpPC, Ptr, CSK_Base))
+    return false;
+  S.Stk.push<Pointer>(Ptr.atField(Off).narrow());
+  return true;
+}
+
+inline bool GetPtrThisBase(InterpState &S, CodePtr OpPC, uint32_t Off) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  const Pointer &Ptr = S.Current->getThis();
+  if (!CheckNull(S, OpPC, Ptr, CSK_Base))
+    return false;
+  S.Stk.push<Pointer>(Ptr.atField(Off).narrow());
+  return true;
+}
+
+inline bool VirtBaseHelper(InterpState &S, CodePtr OpPC, uintptr_t D,
+                           const Pointer &Ptr) {
+  if (!CheckNull(S, OpPC, Ptr, CSK_Base))
+    return false;
+
+  Pointer Base = Ptr;
+  while (Base.isBaseClass())
+    Base = Base.getBase();
+
+  auto *Decl = reinterpret_cast<const RecordDecl *>(D);
+  auto *Field = Base.getFieldDesc()->ElemRecord->getVirtualBase(Decl);
+  S.Stk.push<Pointer>(Base.atField(Field->Offset).narrow());
+  return true;
+}
+
+inline bool GetPtrVirtBase(InterpState &S, CodePtr OpPC, uintptr_t D) {
+  return VirtBaseHelper(S, OpPC, D, S.Stk.pop<Pointer>());
+}
+
+inline bool GetPtrThisVirtBase(InterpState &S, CodePtr OpPC, uintptr_t D) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  return VirtBaseHelper(S, OpPC, D, S.Current->getThis());
+}
+
+//===----------------------------------------------------------------------===//
+// Load, Store, Init
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Load(InterpState &S, CodePtr OpPC) {
+  const Pointer &Ptr = S.Stk.peek<Pointer>();
+  if (!CheckLoad(S, OpPC, Ptr))
+    return false;
+  S.Stk.push<T>(Ptr.deref<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+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;
+}
+
+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;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool StorePop(InterpState &S, CodePtr OpPC) {
+  const T &Value = S.Stk.pop<T>();
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  if (!CheckStore(S, OpPC, Ptr))
+    return false;
+  Ptr.deref<T>() = Value;
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Init(InterpState &S, CodePtr OpPC) {
+  const T &Value = S.Stk.pop<T>();
+  const Pointer &Ptr = S.Stk.peek<Pointer>();
+  if (!CheckInit(S, OpPC, Ptr)) {
+    return false;
+  }
+  Ptr.initialize();
+  Ptr.deref<T>() = Value;
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool InitPop(InterpState &S, CodePtr OpPC) {
+  const T &Value = S.Stk.pop<T>();
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  if (!CheckInit(S, OpPC, Ptr)) {
+    return false;
+  }
+  Ptr.deref<T>() = Value;
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// AddOffset, SubOffset
+//===----------------------------------------------------------------------===//
+
+template <class T, bool Add> bool OffsetHelper(InterpState &S, CodePtr OpPC) {
+  // Fetch the pointer and the offset.
+  const T &Offset = S.Stk.pop<T>();
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  if (!CheckNull(S, OpPC, Ptr, CSK_ArrayIndex)) {
+    return false;
+  }
+
+  // Get a version of the index comparable to the type.
+  T Index = T::from(Ptr.getIndex(), Offset.bitWidth());
+
+  // Compute the largest index into the array.
+  unsigned MaxIndex = Ptr.size() / Ptr.elemSize();
+
+  // Helper to report an invalid offset, computed as APSInt.
+  auto InvalidOffset = [&]() {
+    const unsigned Bits = Offset.bitWidth();
+    APSInt APOffset(Offset.toUnsigned().toAPSInt().zext(Bits + 2), false);
+    APSInt APIndex(Index.toUnsigned().toAPSInt().zext(Bits + 2), false);
+
+    APSInt NewIndex = Add ? (APIndex + APOffset) : (APIndex - APOffset);
+    S.CCEDiag(S.Current->getSource(OpPC), diag::note_constexpr_array_index)
+        << NewIndex
+        << /*array*/ static_cast<int>(!Ptr.isArray())
+        << static_cast<unsigned>(MaxIndex);
+    return false;
+  };
+
+  // If the new offset would be negative, bail out.
+  if (Add && Offset.isNegative() && (Offset.isMin() || -Offset > Index))
+    return InvalidOffset();
+  if (!Add && Offset.isPositive() && Index < Offset)
+    return InvalidOffset();
+
+  // If the new offset would be out of bounds, bail out.
+  unsigned MaxOffset = MaxIndex - Ptr.getIndex();
+  if (Add && Offset.isPositive() && Offset > MaxOffset)
+    return InvalidOffset();
+  if (!Add && Offset.isNegative() && (Offset.isMin() || -Offset > MaxOffset))
+    return InvalidOffset();
+
+  // Offset is valid - compute it on unsigned.
+  int64_t WideIndex = static_cast<int64_t>(Index);
+  int64_t WideOffset = static_cast<int64_t>(Offset);
+  int64_t Result = Add ? (WideIndex + WideOffset) : (WideIndex - WideOffset);
+  unsigned NewIndex = static_cast<unsigned>(Result);
+  S.Stk.push<Pointer>(Ptr.atOffset(NewIndex * Ptr.elemSize()));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool AddOffset(InterpState &S, CodePtr OpPC) {
+  return OffsetHelper<T, true>(S, OpPC);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool SubOffset(InterpState &S, CodePtr OpPC) {
+  return OffsetHelper<T, false>(S, OpPC);
+}
+
+
+//===----------------------------------------------------------------------===//
+// Destroy
+//===----------------------------------------------------------------------===//
+
+inline bool Destroy(InterpState &S, CodePtr OpPC, uint32_t I) {
+  S.Current->destroy(I);
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Cast, CastFP
+//===----------------------------------------------------------------------===//
+
+template <PrimType TIn, PrimType TOut> bool Cast(InterpState &S, CodePtr OpPC) {
+  using T = typename PrimConv<TIn>::T;
+  using U = typename PrimConv<TOut>::T;
+  S.Stk.push<U>(U::from(S.Stk.pop<T>()));
+  return true;
+}
+
+template <PrimType TIn, PrimType TOut>
+bool CastFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
+  using T = typename PrimConv<TIn>::T;
+  using U = typename PrimConv<TOut>::T;
+  S.Stk.push<U>(U::from(S.Stk.pop<T>(), Bits));
+  return true;
+}
+
+template <PrimType TIn>
+bool CastRealFP(InterpState &S, CodePtr OpPC, uintptr_t I) {
+  using T = typename PrimConv<TIn>::T;
+  const auto &Sema = *reinterpret_cast<const fltSemantics *>(I);
+  S.Stk.push<Real>(Real::from(S.Stk.pop<T>(), Sema));
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Inc, Dec
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+using IncDecFn = bool (*) (InterpState &, CodePtr, const T&, T&);
+
+template <typename T>
+bool Post(InterpState &S, CodePtr OpPC, AccessKinds AK, IncDecFn<T> Op) {
+  // Bail if not C++14.
+  if (!S.getLangOpts().CPlusPlus14 && !S.keepEvaluatingAfterFailure()) {
+    S.FFDiag(S.Current->getSource(OpPC));
+    return false;
+  }
+
+  // Get the pointer to the object to mutate.
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  if (!CheckLive(S, OpPC, Ptr, AK))
+    return false;
+  if (!CheckMutable(S, OpPC, Ptr))
+    return false;
+
+  T Arg = Ptr.deref<T>();
+  S.Stk.push<T>(Arg);
+
+  T R;
+  if (!Op(S, OpPC, Arg, R))
+    return false;
+  Ptr.deref<T>() = R;
+  return true;
+}
+
+template <typename T, bool (*OpFW)(T A, T *R), template <typename U> class OpAP>
+bool IncDecInt(InterpState &S, CodePtr OpPC, const T &Arg, T &R) {
+  if (std::is_unsigned<T>::value) {
+    // Unsigned increment/decrement is defined to wrap around.
+    R = OpAP<T>()(Arg, T::from(1, Arg.bitWidth()));
+    return true;
+  } else {
+    // Signed increment/decrement is undefined, catch that.
+    if (!OpFW(Arg, &R))
+      return true;
+    // Compute the actual value for the diagnostic.
+    const size_t Bits = R.bitWidth() + 1;
+    APSInt One(APInt(Bits, 1, Arg.isSigned()), !Arg.isSigned());
+    APSInt Value = OpAP<APSInt>()(Arg.toAPSInt(Bits), One);
+    return S.reportOverflow(S.Current->getExpr(OpPC), Value);
+  }
+}
+
+template <template <typename U> class Op>
+bool IncDecPtr(InterpState &S, CodePtr OpPC, const Pointer &Arg, Pointer &R) {
+  if (!CheckNull(S, OpPC, Arg, CSK_ArrayIndex))
+    return false;
+
+  // Compute the new offset with unsigned wraparound.
+  int64_t NewIndex = Op<int64_t>()(Arg.getIndex(), 1);
+  int64_t MaxIndex = Arg.size() / Arg.elemSize();
+
+  // Ensure the new index is in bounds.
+  if (NewIndex < 0 || NewIndex > MaxIndex) {
+     S.CCEDiag(S.Current->getSource(OpPC), diag::note_constexpr_array_index)
+        << Integral<64, true>::from(NewIndex).toAPSInt()
+        << /*array*/ static_cast<int>(!Arg.isArray())
+        << static_cast<unsigned>(MaxIndex);
+    return false;
+  }
+
+  // Compute the offset from the index.
+  R = Arg.atOffset(NewIndex * Arg.elemSize());
+  return true;
+}
+
+template <Real (*Op) (const Real &)>
+bool IncDecReal(InterpState &S, CodePtr OpPC, const Real &Arg, Real &R) {
+  R = Op(Arg);
+  return true;
+}
+
+template <typename T> struct IncOps {
+  static constexpr IncDecFn<T> Fn = IncDecInt<T, T::increment, std::plus>;
+};
+template <> struct IncOps<Pointer> {
+  static constexpr IncDecFn<Pointer> Fn = IncDecPtr<std::plus>;
+};
+template <> struct IncOps<Real> {
+  static constexpr IncDecFn<Real> Fn = IncDecReal<Real::increment>;
+};
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Inc(InterpState &S, CodePtr OpPC) {
+  return Post<T>(S, OpPC, AK_Increment, IncOps<T>::Fn);
+}
+
+template <typename T> struct DecOps {
+  static constexpr IncDecFn<T> Fn = IncDecInt<T, T::decrement, std::minus>;
+};
+template <> struct DecOps<Pointer> {
+  static constexpr IncDecFn<Pointer> Fn = IncDecPtr<std::minus>;
+};
+template <> struct DecOps<Real> {
+  static constexpr IncDecFn<Real> Fn = IncDecReal<Real::decrement>;
+};
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Dec(InterpState &S, CodePtr OpPC) {
+  return Post<T>(S, OpPC, AK_Decrement, DecOps<T>::Fn);
+}
+
+
+//===----------------------------------------------------------------------===//
+// And, Or, Xor
+//===----------------------------------------------------------------------===//
+
+template <typename T, template <typename U> class Op>
+bool LogicalHelper(InterpState &S, CodePtr OpPC) {
+  const T &RHS = S.Stk.pop<T>();
+  const T &LHS = S.Stk.pop<T>();
+  S.Stk.push<T>(Op<T>()(LHS, RHS));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool And(InterpState &S, CodePtr OpPC) {
+  return LogicalHelper<T, std::bit_and>(S, OpPC);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Or(InterpState &S, CodePtr OpPC) {
+  return LogicalHelper<T, std::bit_or>(S, OpPC);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Xor(InterpState &S, CodePtr OpPC) {
+  return LogicalHelper<T, std::bit_xor>(S, OpPC);
+}
+
+//===----------------------------------------------------------------------===//
+// Builtin
+//===----------------------------------------------------------------------===//
+
+inline bool Builtin(InterpState &S, CodePtr OpPC, uint32_t I) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  return InterpBuiltin(S, OpPC, I);
+}
+
+//===----------------------------------------------------------------------===//
+// Zero, Nullptr
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Zero(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<T>(T::zero());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool ZeroFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
+  S.Stk.push<T>(T::zero(Bits));
+  return true;
+}
+
+inline bool ZeroRealFP(InterpState &S, CodePtr OpPC, uintptr_t I) {
+  const auto &Sema = *reinterpret_cast<const fltSemantics *>(I);
+  S.Stk.push<Real>(Real::zero(Sema));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+inline bool Null(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<T>();
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// This
+//===----------------------------------------------------------------------===//
+
+inline bool This(InterpState &S, CodePtr OpPC) {
+  // Cannot read 'this' in this mode.
+  if (S.checkingPotentialConstantExpression()) {
+    return false;
+  }
+
+  S.Stk.push<Pointer>(S.Current->getThis());
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Shr, Shl
+//===----------------------------------------------------------------------===//
+
+template <PrimType TR, PrimType TL, class T = typename PrimConv<TR>::T>
+unsigned Trunc(InterpState &S, CodePtr OpPC, unsigned Bits, const T &V) {
+  // C++11 [expr.shift]p1: Shift width must be less than the bit width of
+  // the shifted type.
+  if (V >= T::from(Bits, V.bitWidth())) {
+    const Expr *E = S.Current->getExpr(OpPC);
+    const APSInt Val = V.toAPSInt();
+    QualType Ty = E->getType();
+    S.CCEDiag(E, diag::note_constexpr_large_shift) << Val << Ty << Bits;
+    return Bits;
+  } else {
+    return static_cast<unsigned>(V);
+  }
+}
+
+template <PrimType TL, PrimType TR, typename T = typename PrimConv<TL>::T>
+inline bool ShiftRight(InterpState &S, CodePtr OpPC, const T &V, unsigned RHS) {
+  if (RHS >= V.bitWidth()) {
+    S.Stk.push<T>(T::from(0, V.bitWidth()));
+  } else {
+    S.Stk.push<T>(T::from(V.toUnsigned() >> RHS, V.bitWidth()));
+  }
+  return true;
+}
+
+template <PrimType TL, PrimType TR, typename T = typename PrimConv<TL>::T>
+inline bool ShiftLeft(InterpState &S, CodePtr OpPC, const T &V, unsigned RHS) {
+  if (V.isSigned() && !S.getLangOpts().CPlusPlus2a) {
+    // C++11 [expr.shift]p2: A signed left shift must have a non-negative
+    // operand, and must not overflow the corresponding unsigned type.
+    // C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to
+    // E1 x 2^E2 module 2^N.
+    if (V.isNegative()) {
+      const Expr *E = S.Current->getExpr(OpPC);
+      S.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << V.toAPSInt();
+    } else if (V.countLeadingZeros() < RHS) {
+      S.CCEDiag(S.Current->getExpr(OpPC), diag::note_constexpr_lshift_discards);
+    }
+  }
+  if (RHS >= V.bitWidth()) {
+    S.Stk.push<T>(T::from(0, V.bitWidth()));
+  } else {
+    S.Stk.push<T>(T::from(V.toUnsigned() << RHS, V.bitWidth()));
+  }
+  return true;
+}
+
+template <PrimType TL, PrimType TR>
+inline bool Shr(InterpState &S, CodePtr OpPC) {
+  const auto &RHS = S.Stk.pop<typename PrimConv<TR>::T>();
+  const auto &LHS = S.Stk.pop<typename PrimConv<TL>::T>();
+  const unsigned Bits = LHS.bitWidth();
+
+  if (RHS.isSigned() && RHS.isNegative()) {
+    const SourceInfo &Loc = S.Current->getSource(OpPC);
+    S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
+    return ShiftLeft<TL, TR>(S, OpPC, LHS, Trunc<TR, TL>(S, OpPC, Bits, -RHS));
+  } else {
+    return ShiftRight<TL, TR>(S, OpPC, LHS, Trunc<TR, TL>(S, OpPC, Bits, RHS));
+  }
+}
+
+template <PrimType TL, PrimType TR>
+inline bool Shl(InterpState &S, CodePtr OpPC) {
+  const auto &RHS = S.Stk.pop<typename PrimConv<TR>::T>();
+  const auto &LHS = S.Stk.pop<typename PrimConv<TL>::T>();
+  const unsigned Bits = LHS.bitWidth();
+
+  if (RHS.isSigned() && RHS.isNegative()) {
+    const SourceInfo &Loc = S.Current->getSource(OpPC);
+    S.CCEDiag(Loc, diag::note_constexpr_negative_shift) << RHS.toAPSInt();
+    return ShiftRight<TL, TR>(S, OpPC, LHS, Trunc<TR, TL>(S, OpPC, Bits, -RHS));
+  } else {
+    return ShiftLeft<TL, TR>(S, OpPC, LHS, Trunc<TR, TL>(S, OpPC, Bits, RHS));
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// NoRet
+//===----------------------------------------------------------------------===//
+
+inline bool NoRet(InterpState &S, CodePtr OpPC) {
+  SourceLocation EndLoc = S.Current->getCallee()->getEndLoc();
+  S.FFDiag(EndLoc, diag::note_constexpr_no_return);
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// NarrowPtr, ExpandPtr
+//===----------------------------------------------------------------------===//
+
+inline bool NarrowPtr(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<Pointer>(S.Stk.pop<Pointer>().narrow());
+  return true;
+}
+
+inline bool ExpandPtr(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<Pointer>(S.Stk.pop<Pointer>().expand());
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// PtrDiff
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+bool PtrDiffHelper(InterpState &S, CodePtr OpPC, unsigned BitWidth) {
+  const Pointer &RHS = S.Stk.pop<Pointer>();
+  const Pointer &LHS = S.Stk.pop<Pointer>();
+
+  // Pointers must point to the same object.
+  if (LHS.isNull() || !LHS.isLive()) {
+    S.FFDiag(S.Current->getExpr(OpPC));
+    return false;
+  }
+  if (RHS.isNull() || !RHS.isLive()) {
+    S.FFDiag(S.Current->getExpr(OpPC));
+    return false;
+  }
+  if (!Pointer::hasSameBase(LHS, RHS)) {
+    S.FFDiag(S.Current->getExpr(OpPC));
+    return false;
+  }
+
+  // Pointers must point to the same array.
+  if (!Pointer::hasSameArray(LHS, RHS)) {
+    const Expr *E = S.Current->getExpr(OpPC);
+    S.CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array);
+    return false;
+  }
+
+  // Compute the difference.
+  auto RHSIndex = static_cast<int64_t>(RHS.getIndex());
+  auto LHSIndex = static_cast<int64_t>(LHS.getIndex());
+  auto Diff = LHSIndex - RHSIndex;
+
+  S.Stk.push<T>(T::from(Diff, BitWidth));
+
+  if (!T::inRange(Diff, BitWidth)) {
+    auto APDiff = Integral<64, true>::from(Diff).toAPSInt();
+    const Expr *E = S.Current->getExpr(OpPC);
+    S.CCEDiag(E, diag::note_constexpr_overflow) << APDiff << E->getType();
+    return S.noteUndefinedBehavior();
+  }
+
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool PtrDiff(InterpState &S, CodePtr OpPC) {
+  return PtrDiffHelper<T>(S, OpPC, T::bitWidth());
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool PtrDiffFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
+  return PtrDiffHelper<T>(S, OpPC, Bits);
+}
+
+//===----------------------------------------------------------------------===//
+// Trap
+//===----------------------------------------------------------------------===//
+
+inline bool Trap(InterpState &S, CodePtr OpPC) {
+  const SourceLocation &Loc = S.Current->getLocation(OpPC);
+  S.FFDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
+  return false;
+}
+
+/// Interpreter entry point.
+bool Interpret(InterpState &S, APValue &Result);
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Interp.cpp b/clang/lib/AST/Interp/Interp.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Interp.cpp
@@ -0,0 +1,330 @@
+//===--- InterpState.cpp - Interpreter for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Interp.h"
+#include "Function.h"
+#include "InterpFrame.h"
+#include "InterpStack.h"
+#include "Opcode.h"
+#include "Program.h"
+#include "State.h"
+#include "Type.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTDiagnostic.h"
+#include "clang/AST/CXXInheritance.h"
+#include "clang/AST/Expr.h"
+#include "llvm/ADT/APSInt.h"
+#include <limits>
+#include <vector>
+
+using namespace clang;
+using namespace clang::interp;
+
+//===----------------------------------------------------------------------===//
+// Ret
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+static bool Ret(InterpState &S, CodePtr &PC, APValue &Result) {
+  S.CallStackDepth--;
+  const T &Ret = S.Stk.pop<T>();
+
+  assert(S.Current->getFrameOffset() == S.Stk.size() && "Invalid frame");
+  if (!S.checkingPotentialConstantExpression())
+    S.Current->popArgs();
+
+  if (InterpFrame *Caller = S.Current->Caller) {
+    PC = S.Current->getRetPC();
+    delete S.Current;
+    S.Current = Caller;
+    S.Stk.push<T>(Ret);
+  } else {
+    delete S.Current;
+    S.Current = nullptr;
+    if (!ReturnValue<T>(Ret, Result))
+      return false;
+  }
+  return true;
+}
+
+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) {
+    PC = S.Current->getRetPC();
+    delete S.Current;
+    S.Current = Caller;
+  } else {
+    delete S.Current;
+    S.Current = nullptr;
+  }
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Jmp, Jt, Jf
+//===----------------------------------------------------------------------===//
+
+static bool Jmp(InterpState &S, CodePtr &PC, int32_t Offset) {
+  PC += Offset;
+  return true;
+}
+
+static bool Jt(InterpState &S, CodePtr &PC, int32_t Offset) {
+  if (S.Stk.pop<bool>()) {
+    PC += Offset;
+  }
+  return true;
+}
+
+static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset) {
+  if (!S.Stk.pop<bool>()) {
+    PC += Offset;
+  }
+  return true;
+}
+
+namespace clang {
+namespace interp {
+
+bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
+               AccessKinds AK) {
+  const auto &Src = S.Current->getSource(OpPC);
+  if (Ptr.isNull()) {
+
+    if (Ptr.isField())
+      S.FFDiag(Src, diag::note_constexpr_null_subobject) << CSK_Field;
+    else
+      S.FFDiag(Src, diag::note_constexpr_access_null) << AK;
+
+    return false;
+  }
+
+  if (!Ptr.isLive()) {
+    bool IsTemp = Ptr.isTemporary();
+
+    S.FFDiag(Src, diag::note_constexpr_lifetime_ended, 1) << AK << !IsTemp;
+
+    if (IsTemp)
+      S.Note(Ptr.getDeclLoc(), diag::note_constexpr_temporary_here);
+    else
+      S.Note(Ptr.getDeclLoc(), diag::note_declared_at);
+
+    return false;
+  }
+
+  return true;
+}
+
+bool CheckNull(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
+               CheckSubobjectKind CSK) {
+  if (!Ptr.isNull())
+    return true;
+  const SourceInfo &Loc = S.Current->getSource(OpPC);
+  S.FFDiag(Loc, diag::note_constexpr_null_subobject) << CSK;
+  return false;
+}
+
+bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
+                AccessKinds AK) {
+  if (Ptr.inRange())
+    return true;
+  const SourceInfo &Loc = S.Current->getSource(OpPC);
+  S.FFDiag(Loc, diag::note_constexpr_access_past_end) << AK;
+  return false;
+}
+
+bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
+  assert(Ptr.isLive() && "Pointer is not live");
+  if (Ptr.isMutable()) {
+    return true;
+  }
+
+  const QualType Ty = Ptr.getType();
+  const SourceInfo &Loc = S.Current->getSource(OpPC);
+  S.FFDiag(Loc, diag::note_constexpr_modify_const_type) << Ty;
+  return false;
+}
+
+static bool CheckExtern(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
+  if (!Ptr.isExtern())
+    return true;
+
+  auto *VD = Ptr.getDeclDesc()->Source.dyn_cast<const ValueDecl *>();
+  const SourceInfo &Loc = S.Current->getSource(OpPC);
+  S.FFDiag(Loc, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
+  S.Note(VD->getLocation(), diag::note_declared_at);
+  return false;
+}
+
+static bool CheckInitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
+                             AccessKinds AK) {
+  if (Ptr.isInitialized())
+    return true;
+  if (!S.checkingPotentialConstantExpression()) {
+    const SourceInfo &Loc = S.Current->getSource(OpPC);
+    S.FFDiag(Loc, diag::note_constexpr_access_uninit) << AK << false;
+  }
+  return false;
+}
+
+static bool CheckActive(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
+                        AccessKinds AK) {
+  if (Ptr.isActive())
+    return true;
+
+  auto GetField = [](const Pointer &Ptr) -> const FieldDecl * {
+    auto *Decl = Ptr.getFieldDesc()->Source.dyn_cast<const ValueDecl *>();
+    return dyn_cast<FieldDecl>(Decl);
+  };
+
+  // Get the inactive field descriptor.
+  const FieldDecl *InactiveField = GetField(Ptr);
+
+  // Walk up the pointer chain to find the union which is not active.
+  Pointer U = Ptr.getBase();
+  while (!U.isActive()) {
+    U = U.getBase();
+  }
+
+  // Find the active field of the union.
+  Record *R = U.getFieldDesc()->ElemRecord;
+  assert(R && R->isUnion() && "Not a union");
+  const FieldDecl *ActiveField = nullptr;
+  for (unsigned I = 0, N = R->getNumFields(); I < N; ++I) {
+    const Pointer &Field = U.atField(R->getField(I)->Offset);
+    if (Field.isActive()) {
+      ActiveField = GetField(Field);
+      break;
+    }
+  }
+
+  const SourceInfo &Loc = S.Current->getSource(OpPC);
+  S.FFDiag(Loc, diag::note_constexpr_access_inactive_union_member)
+      << AK << InactiveField << !ActiveField << ActiveField;
+  return false;
+}
+
+bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
+  if (!CheckLive(S, OpPC, Ptr, AK_Read))
+    return false;
+  if (!CheckExtern(S, OpPC, Ptr))
+    return false;
+  if (!CheckRange(S, OpPC, Ptr, AK_Read))
+    return false;
+  if (!CheckInitialized(S, OpPC, Ptr, AK_Read))
+    return false;
+  if (!CheckActive(S, OpPC, Ptr, AK_Read))
+    return false;
+  return true;
+}
+
+bool CheckStore(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
+  if (!CheckLive(S, OpPC, Ptr, AK_Assign))
+    return false;
+  if (!CheckRange(S, OpPC, Ptr, AK_Assign))
+    return false;
+  if (!CheckMutable(S, OpPC, Ptr))
+    return false;
+  return true;
+}
+
+bool CheckInit(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
+  if (!CheckLive(S, OpPC, Ptr, AK_Assign))
+    return false;
+  if (!CheckRange(S, OpPC, Ptr, AK_Assign))
+    return false;
+  return true;
+}
+
+bool CheckCallable(InterpState &S, CodePtr OpPC, Function *F) {
+  const SourceLocation &Loc = S.Current->getLocation(OpPC);
+
+  if (F->isVirtual()) {
+    if (!S.getLangOpts().CPlusPlus2a) {
+      S.CCEDiag(Loc, diag::note_constexpr_virtual_call);
+      return false;
+    }
+  }
+
+  if (!F->isConstexpr()) {
+    if (S.getLangOpts().CPlusPlus11) {
+      const FunctionDecl *DiagDecl = F->getDecl();
+
+      // If this function is not constexpr because it is an inherited
+      // non-constexpr constructor, diagnose that directly.
+      auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
+      if (CD && CD->isInheritingConstructor()) {
+        auto *Inherited = CD->getInheritedConstructor().getConstructor();
+        if (!Inherited->isConstexpr())
+          DiagDecl = CD = Inherited;
+      }
+
+      // FIXME: If DiagDecl is an implicitly-declared special member function
+      // or an inheriting constructor, we should be much more explicit about why
+      // it's not constexpr.
+      if (CD && CD->isInheritingConstructor())
+        S.FFDiag(Loc, diag::note_constexpr_invalid_inhctor, 1)
+          << CD->getInheritedConstructor().getConstructor()->getParent();
+      else
+        S.FFDiag(Loc, diag::note_constexpr_invalid_function, 1)
+          << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
+      S.Note(DiagDecl->getLocation(), diag::note_declared_at);
+    } else {
+      S.FFDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
+    }
+    return false;
+  }
+
+  return true;
+}
+
+const CXXMethodDecl *VirtualLookup(Pointer &This, uintptr_t Fn) {
+  // Traverse the chain of derived classes, from base to derived.
+  auto *Method = reinterpret_cast<const CXXMethodDecl *>(Fn);
+  auto *Impl = Method;
+  while (This.isBaseClass()) {
+    // Step into the derived class.
+    This = This.getBase();
+
+    // Fetch the class declaration.
+    Record *R = This.getFieldDesc()->ElemRecord;
+    assert(R != nullptr && "virtual dispatch allowed only on records");
+    auto *Class = dyn_cast<CXXRecordDecl>(R->getDecl());
+    assert(Class != nullptr && "not a CXX record");
+
+    // Find the most overriden method.
+    auto *O = Method->getCorrespondingMethodDeclaredInClass(Class, false);
+    if (O) {
+      Impl = O;
+    }
+  }
+  return Impl;
+}
+
+bool Interpret(InterpState &S, APValue &Result) {
+  CodePtr PC = S.Current->getPC();
+
+  for (;;) {
+    auto Op = PC.read<Opcode>();
+    CodePtr OpPC = PC;
+
+    switch (Op) {
+#define GET_INTERP
+#include "Opcodes.inc"
+#undef GET_INTERP
+    }
+  }
+}
+
+} // namespace interp
+} // namespace clang
diff --git a/clang/lib/AST/Interp/InterpFrame.h b/clang/lib/AST/Interp/InterpFrame.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/InterpFrame.h
@@ -0,0 +1,153 @@
+//===--- InterpFrame.h - Call Frame 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 class storing information about stack frames in the interpreter.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_INTERPFRAME_H
+#define LLVM_CLANG_AST_INTERP_INTERPFRAME_H
+
+#include "Frame.h"
+#include "Pointer.h"
+#include "Program.h"
+#include "State.h"
+#include <cstdint>
+#include <vector>
+
+namespace clang {
+namespace interp {
+class Function;
+class InterpState;
+
+/// Frame storing local variables.
+class InterpFrame final : public Frame {
+public:
+  /// The frame of the previous function.
+  InterpFrame *Caller;
+
+  /// Creates a new frame for a method call.
+  InterpFrame(InterpState &S, Function *Func, InterpFrame *Caller,
+              CodePtr RetPC, Pointer &&This);
+
+  /// Destroys the frame, killing all live pointers to stack slots.
+  ~InterpFrame();
+
+  /// Invokes the destructors for a scope.
+  void destroy(unsigned Idx);
+
+  /// Pops the arguments off the stack.
+  void popArgs();
+
+  /// Describes the frame with arguments for diagnostic purposes.
+  void describe(llvm::raw_ostream &OS);
+
+  /// Returns the parent frame object.
+  Frame *getCaller() const;
+
+  /// Returns the location of the call to the frame.
+  SourceLocation getCallLocation() const;
+
+  /// Returns the caller.
+  const FunctionDecl *getCallee() const;
+
+  /// Returns the current function.
+  Function *getFunction() const { return Func; }
+
+  /// Returns the offset on the stack at which the frame starts.
+  size_t getFrameOffset() const { return FrameOffset; }
+
+  /// Returns the value of a local variable.
+  template <typename T> const T &getLocal(unsigned Offset) {
+    return localRef<T>(Offset);
+  }
+
+  /// Mutates a local variable.
+  template <typename T> void setLocal(unsigned Offset, const T &Value) {
+    localRef<T>(Offset) = Value;
+  }
+
+  /// Returns a pointer to a local variables.
+  Pointer getLocalPointer(unsigned Offset);
+
+  /// Returns the value of an argument.
+  template <typename T> const T &getParam(unsigned Offset) {
+    auto Pt = Params.find(Offset);
+    if (Pt == Params.end()) {
+      return stackRef<T>(Offset);
+    } else {
+      return Pointer(reinterpret_cast<Block *>(Pt->second.get())).deref<T>();
+    }
+  }
+
+  /// Mutates a local copy of a parameter.
+  template <typename T> void setParam(unsigned Offset, const T &Value) {
+     getParamPointer(Offset).deref<T>() = Value;
+  }
+
+  /// Returns a pointer to an argument - lazily creates a block.
+  Pointer getParamPointer(unsigned Offset);
+
+  /// Returns the 'this' pointer.
+  const Pointer &getThis() const { return This; }
+
+  /// Checks if the frame is a root frame - return should quit the interpreter.
+  bool isRoot() const { return !Func; }
+
+  /// Returns the PC of the frame's code start.
+  CodePtr getPC() const { return Func->getCodeBegin(); }
+
+  /// Returns the return address of the frame.
+  CodePtr getRetPC() const { return RetPC; }
+
+  /// Map a location to a source.
+  virtual SourceInfo getSource(CodePtr PC) const;
+  const Expr *getExpr(CodePtr PC) const;
+  SourceLocation getLocation(CodePtr PC) const;
+
+private:
+  /// Returns an original argument from the stack.
+  template <typename T> const T &stackRef(unsigned Offset) {
+    return *reinterpret_cast<const T *>(Args - ArgSize + Offset);
+  }
+
+  /// Returns an offset to a local.
+  template <typename T> T &localRef(unsigned Offset) {
+    return *reinterpret_cast<T *>(Locals.get() + Offset);
+  }
+
+  /// Returns a pointer to a local's block.
+  void *localBlock(unsigned Offset) {
+    return Locals.get() + Offset - sizeof(Block);
+  }
+
+private:
+  /// Reference to the interpreter state.
+  InterpState &S;
+  /// Reference to the function being executed.
+  Function *Func;
+  /// Current object pointer for methods.
+  Pointer This;
+  /// Return address.
+  CodePtr RetPC;
+  /// The size of all the arguments.
+  const unsigned ArgSize;
+  /// Pointer to the arguments in the callee's frame.
+  char *Args = nullptr;
+  /// Fixed, initial storage for known local variables.
+  std::unique_ptr<char[]> Locals;
+  /// Offset on the stack at entry.
+  const size_t FrameOffset;
+  /// Mapping from arg offsets to their argument blocks.
+  llvm::DenseMap<unsigned, std::unique_ptr<char[]>> Params;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/InterpFrame.cpp b/clang/lib/AST/Interp/InterpFrame.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/InterpFrame.cpp
@@ -0,0 +1,199 @@
+//===--- InterpFrame.cpp - Call Frame 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "InterpFrame.h"
+#include "Function.h"
+#include "Interp.h"
+#include "InterpStack.h"
+#include "Program.h"
+#include "Type.h"
+#include "clang/AST/DeclCXX.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+InterpFrame::InterpFrame(InterpState &S, Function *Func, InterpFrame *Caller,
+                         CodePtr RetPC, Pointer &&This)
+    : Caller(Caller), S(S), Func(Func), This(std::move(This)), RetPC(RetPC),
+      ArgSize(Func ? Func->getArgSize() : 0),
+      Args(static_cast<char *>(S.Stk.top())), FrameOffset(S.Stk.size()) {
+  if (Func) {
+    if (unsigned FrameSize = Func->getFrameSize()) {
+      Locals = llvm::make_unique<char[]>(FrameSize);
+      for (auto &Scope : Func->scopes()) {
+        for (auto &Local : Scope.locals()) {
+          Block *B = new (localBlock(Local.Offset)) Block(Local.Desc);
+          B->invokeCtor();
+        }
+      }
+    }
+  }
+}
+
+InterpFrame::~InterpFrame() {
+  for (auto &Param : Params) {
+    S.deallocate(reinterpret_cast<Block *>(Param.second.get()));
+  }
+}
+
+void InterpFrame::destroy(unsigned Idx) {
+  for (auto &Local : Func->getScope(Idx).locals()) {
+    S.deallocate(reinterpret_cast<Block *>(localBlock(Local.Offset)));
+  }
+}
+
+void InterpFrame::popArgs() {
+  for (PrimType Ty : Func->args_reverse())
+    TYPE_SWITCH(Ty, S.Stk.discard<T>());
+}
+
+template <typename T>
+static void print(llvm::raw_ostream &OS, const T &V, ASTContext &, bool) {
+  OS << V;
+}
+
+template <>
+void print(llvm::raw_ostream &OS, const Pointer &P, ASTContext &Ctx,
+           bool IsReference) {
+  if (P.isNull()) {
+    OS << "nullptr";
+    return;
+  }
+
+  auto printDesc = [&OS, &Ctx](Descriptor *Desc) {
+    if (auto *D = Desc->Source.dyn_cast<const ValueDecl *>()) {
+      OS << *D;
+      return;
+    }
+    if (auto *E = Desc->Source.dyn_cast<const Expr *>()) {
+      E->printPretty(OS, nullptr, Ctx.getPrintingPolicy());
+      return;
+    }
+    llvm_unreachable("Invalid descriptor type");
+  };
+
+  if (!IsReference)
+    OS << "&";
+  llvm::SmallVector<Pointer, 2> Levels;
+  for (Pointer F = P; F.isField(); F = F.getBase())
+    Levels.push_back(F);
+
+  printDesc(P.getDeclDesc());
+  for (auto It = Levels.rbegin(); It != Levels.rend(); ++It) {
+    OS << ".";
+    printDesc(It->getFieldDesc());
+  }
+
+  if (int64_t Index = P.getIndex())
+    OS << " + " << Index;
+}
+
+template <>
+void print(llvm::raw_ostream &OS, const FnPointer &P, ASTContext &,
+           bool IsReference) {
+  const FunctionDecl *Decl = nullptr;
+  if (Function *F = P.asFunction())
+    Decl = F->getDecl();
+  if (const FunctionDecl *FD = P.asDecl())
+    Decl = FD;
+
+  if (!Decl) {
+    OS << "nullptr";
+    return;
+  }
+
+  if (IsReference) {
+    OS << Decl->getName();
+  } else {
+    OS << "&" << Decl->getName();
+  }
+}
+
+void InterpFrame::describe(llvm::raw_ostream &OS) {
+  const FunctionDecl *F = getCallee();
+  auto *M = dyn_cast<CXXMethodDecl>(F);
+  if (M && M->isInstance() && !isa<CXXConstructorDecl>(F)) {
+    print(OS, This, S.getCtx(), /*isReference*/false);
+    OS << "->";
+  }
+  OS << *F << "(";
+  unsigned Off = Func->hasRVO() ? primSize(PT_Ptr) : 0;
+  for (unsigned I = 0, N = F->getNumParams(); I < N; ++I) {
+    QualType Ty = F->getParamDecl(I)->getType();
+    const bool IsReference = Ty->isReferenceType();
+
+    PrimType PrimTy;
+    if (llvm::Optional<PrimType> T = S.Ctx.classify(Ty)) {
+      PrimTy = *T;
+    } else {
+      PrimTy = PT_Ptr;
+    }
+
+    TYPE_SWITCH(PrimTy, print(OS, stackRef<T>(Off), S.getCtx(), IsReference));
+    Off += align(primSize(PrimTy));
+    if (I + 1 != N)
+      OS << ", ";
+  }
+  OS << ")";
+}
+
+Frame *InterpFrame::getCaller() const {
+  if (Caller->Caller)
+    return Caller;
+  return S.getSplitFrame();
+}
+
+SourceLocation InterpFrame::getCallLocation() const {
+  if (!Caller->Func)
+    return S.getLocation(nullptr, {});
+  return S.getLocation(Caller->Func, RetPC - sizeof(uintptr_t));
+}
+
+const FunctionDecl *InterpFrame::getCallee() const {
+  return Func->getDecl();
+}
+
+Pointer InterpFrame::getLocalPointer(unsigned Offset) {
+  assert(Offset < Func->getFrameSize() && "Invalid local offset.");
+  return Pointer(
+      reinterpret_cast<Block *>(Locals.get() + Offset - sizeof(Block)));
+}
+
+Pointer InterpFrame::getParamPointer(unsigned Off) {
+  // Return the block if it was created previously.
+  auto Pt = Params.find(Off);
+  if (Pt != Params.end()) {
+    return Pointer(reinterpret_cast<Block *>(Pt->second.get()));
+  }
+
+  // Allocate memory to store the parameter and the block metadata.
+  const auto &Desc = Func->getParamDescriptor(Off);
+  size_t BlockSize = sizeof(Block) + Desc.second->AllocSize;
+  auto Memory = llvm::make_unique<char[]>(BlockSize);
+  auto *B = new (Memory.get()) Block(Desc.second);
+
+  // Copy the initial value.
+  TYPE_SWITCH(Desc.first, new (B->data()) T(stackRef<T>(Off)));
+
+  // Record the param.
+  Params.insert({Off, std::move(Memory)});
+  return Pointer(B);
+}
+
+SourceInfo InterpFrame::getSource(CodePtr PC) const {
+  return S.getSource(Func, PC);
+}
+
+const Expr *InterpFrame::getExpr(CodePtr PC) const {
+  return S.getExpr(Func, PC);
+}
+
+SourceLocation InterpFrame::getLocation(CodePtr PC) const {
+  return S.getLocation(Func, PC);
+}
+
diff --git a/clang/lib/AST/Interp/InterpStack.h b/clang/lib/AST/Interp/InterpStack.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/InterpStack.h
@@ -0,0 +1,113 @@
+//===--- 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 <memory>
+
+namespace clang {
+namespace interp {
+
+/// Stack frame storing temporaries and parameters.
+class InterpStack final {
+public:
+  InterpStack() {}
+
+  /// Destroys the stack, freeing up storage.
+  ~InterpStack();
+
+  /// Constructs a value in place on the top of the stack.
+  template <typename T, typename... Tys> void push(Tys &&... Args) {
+    new (grow(aligned_size<T>())) T(std::forward<Tys>(Args)...);
+  }
+
+  /// Returns the value from the top of the stack and removes it.
+  template <typename T> T pop() {
+    auto *Ptr = &peek<T>();
+    auto Value = std::move(*Ptr);
+    Ptr->~T();
+    shrink(aligned_size<T>());
+    return Value;
+  }
+
+  /// Discards the top value from the stack.
+  template <typename T> void discard() {
+    auto *Ptr = &peek<T>();
+    Ptr->~T();
+    shrink(aligned_size<T>());
+  }
+
+  /// Returns a reference to the value on the top of the stack.
+  template <typename T> T &peek() {
+    return *reinterpret_cast<T *>(peek(aligned_size<T>()));
+  }
+
+  /// 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; }
+
+  /// Clears the stack without calling any destructors.
+  void clear();
+
+private:
+  /// All stack slots are aligned to the native pointer alignment for storage.
+  template <typename T> constexpr size_t aligned_size() const {
+    static_assert(alignof(void *) % alignof(T) == 0, "invalid alignment");
+    return ((sizeof(T) + alignof(void *) - 1) / alignof(void *)) *
+           alignof(void *);
+  }
+
+  /// Grows the stack to accomodate a value and returns a pointer to it.
+  void *grow(size_t Size);
+  /// Returns a pointer from the top of the stack.
+  void *peek(size_t Size);
+  /// Shrinks the stack.
+  void shrink(size_t Size);
+
+  /// Allocate stack space in 1Mb chunks.
+  static constexpr size_t ChunkSize = 1024 * 1024;
+
+  /// Metadata for each stack chunk.
+  ///
+  /// The stack is composed of a linked list of chunks. Whenever an allocation
+  /// is out of bounds, a new chunk is linked. When a chunk becomes empty,
+  /// it is not immediately freed: a chunk is deallocated only when the
+  /// predecessor becomes empty.
+  struct StackChunk {
+    StackChunk *Next;
+    StackChunk *Prev;
+    char *End;
+
+    StackChunk(StackChunk *Prev = nullptr)
+        : Next(nullptr), Prev(Prev), End(reinterpret_cast<char *>(this + 1)) {}
+
+    /// Returns the size of the chunk, minus the header.
+    size_t size() { return End - start(); }
+
+    /// Returns a pointer to the start of the data region.
+    char *start() { return reinterpret_cast<char *>(this + 1); }
+  };
+  static_assert(sizeof(StackChunk) < ChunkSize, "Invalid chunk size");
+
+  /// First chunk on the stack.
+  StackChunk *Chunk = nullptr;
+  /// Total size of the stack.
+  size_t StackSize = 0;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/InterpStack.cpp b/clang/lib/AST/Interp/InterpStack.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/InterpStack.cpp
@@ -0,0 +1,76 @@
+//===--- InterpStack.cpp - 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "InterpStack.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+InterpStack::~InterpStack() {
+  clear();
+}
+
+void InterpStack::clear() {
+  if (Chunk && Chunk->Next)
+    free(Chunk->Next);
+  if (Chunk)
+    free(Chunk);
+  Chunk = nullptr;
+  StackSize = 0;
+}
+
+void *InterpStack::grow(size_t Size) {
+  assert(Size < ChunkSize - sizeof(StackChunk) && "Object too large");
+
+  if (!Chunk || sizeof(StackChunk) + Chunk->size() + Size > ChunkSize) {
+    if (Chunk && Chunk->Next) {
+      Chunk = Chunk->Next;
+    } else {
+      StackChunk *Next = new (malloc(ChunkSize)) StackChunk(Chunk);
+      if (Chunk)
+        Chunk->Next = Next;
+      Chunk = Next;
+    }
+  }
+
+  auto *Object = reinterpret_cast<void *>(Chunk->End);
+  Chunk->End += Size;
+  StackSize += Size;
+  return Object;
+}
+
+void *InterpStack::peek(size_t Size) {
+  assert(Chunk && "Stack is empty!");
+
+  StackChunk *Ptr = Chunk;
+  while (Size > Ptr->size()) {
+    Size -= Ptr->size();
+    Ptr = Ptr->Prev;
+    assert(Ptr && "Offset too large");
+  }
+
+  return reinterpret_cast<void *>(Ptr->End - Size);
+}
+
+void InterpStack::shrink(size_t Size) {
+  assert(Chunk && "Chunk is empty!");
+
+  while (Size > Chunk->size()) {
+    Size -= Chunk->size();
+    if (Chunk->Next) {
+      free(Chunk->Next);
+      Chunk->Next = nullptr;
+    }
+    Chunk->End = Chunk->start();
+    Chunk = Chunk->Prev;
+    assert(Chunk && "Offset too large");
+  }
+
+  Chunk->End -= Size;
+  StackSize -= Size;
+}
diff --git a/clang/lib/AST/Interp/InterpState.h b/clang/lib/AST/Interp/InterpState.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/InterpState.h
@@ -0,0 +1,112 @@
+//===--- InterpState.h - Interpreter state for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Definition of the interpreter state and entry point.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_INTERPSTATE_H
+#define LLVM_CLANG_AST_INTERP_INTERPSTATE_H
+
+#include "Context.h"
+#include "Function.h"
+#include "InterpStack.h"
+#include "State.h"
+#include "clang/AST/APValue.h"
+#include "clang/AST/ASTDiagnostic.h"
+#include "clang/AST/Expr.h"
+#include "clang/Basic/OptionalDiagnostic.h"
+
+namespace clang {
+namespace interp {
+class Context;
+class Function;
+class InterpStack;
+class InterpFrame;
+class SourceMapper;
+
+/// Interpreter context.
+class InterpState final : public State, public SourceMapper {
+public:
+  InterpState(State &Parent, Program &P, InterpStack &Stk, Context &Ctx,
+              SourceMapper *M = nullptr);
+
+  ~InterpState();
+
+  // Stack frame accessors.
+  Frame *getSplitFrame() { return Parent.getCurrentFrame(); }
+  Frame *getCurrentFrame() override;
+  unsigned getCallStackDepth() override { return CallStackDepth; }
+  const Frame *getBottomFrame() const override {
+    return Parent.getBottomFrame();
+  }
+
+  // Acces objects from the walker context.
+  Expr::EvalStatus &getEvalStatus() const override {
+    return Parent.getEvalStatus();
+  }
+  ASTContext &getCtx() const override { return Parent.getCtx(); }
+
+  // Forward status checks and updates to the walker.
+  bool checkingForOverflow() const override {
+    return Parent.checkingForOverflow();
+  }
+  bool keepEvaluatingAfterFailure() const override {
+    return Parent.keepEvaluatingAfterFailure();
+  }
+  bool checkingPotentialConstantExpression() const override {
+    return Parent.checkingPotentialConstantExpression();
+  }
+  bool noteUndefinedBehavior() override {
+    return Parent.noteUndefinedBehavior();
+  }
+  bool hasActiveDiagnostic() override { return Parent.hasActiveDiagnostic(); }
+  void setActiveDiagnostic(bool Flag) override {
+    Parent.setActiveDiagnostic(Flag);
+  }
+  void setFoldFailureDiagnostic(bool Flag) override {
+    Parent.setFoldFailureDiagnostic(Flag);
+  }
+  bool hasPriorDiagnostic() override { return Parent.hasPriorDiagnostic(); }
+
+  /// Reports overflow and return true if evaluation should continue.
+  bool reportOverflow(const Expr *E, const llvm::APSInt &Value);
+
+  /// 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;
+  /// Dead block chain.
+  DeadBlock *DeadBlocks = nullptr;
+  /// Reference to the offset-source mapping.
+  SourceMapper *M;
+
+public:
+  /// Reference to the module containing all bytecode.
+  Program &P;
+  /// Temporary stack.
+  InterpStack &Stk;
+  /// Interpreter Context.
+  Context &Ctx;
+  /// The current frame.
+  InterpFrame *Current = nullptr;
+  /// Call stack depth.
+  unsigned CallStackDepth;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/InterpState.cpp b/clang/lib/AST/Interp/InterpState.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/InterpState.cpp
@@ -0,0 +1,76 @@
+//===--- InterpState.cpp - Interpreter for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "InterpState.h"
+#include "Function.h"
+#include "InterpFrame.h"
+#include "InterpStack.h"
+#include "Opcode.h"
+#include "Program.h"
+#include "State.h"
+#include "Type.h"
+#include <limits>
+
+using namespace clang;
+using namespace clang::interp;
+
+using APSInt = llvm::APSInt;
+
+InterpState::InterpState(State &Parent, Program &P, InterpStack &Stk,
+                         Context &Ctx, SourceMapper *M)
+    : Parent(Parent), M(M), P(P), Stk(Stk), Ctx(Ctx), Current(nullptr),
+      CallStackDepth(Parent.getCallStackDepth() + 1) {}
+
+InterpState::~InterpState() {
+  while (Current) {
+    InterpFrame *Next = Current->Caller;
+    delete Current;
+    Current = Next;
+  }
+
+  while (DeadBlocks) {
+    DeadBlock *Next = DeadBlocks->Next;
+    free(DeadBlocks);
+    DeadBlocks = Next;
+  }
+
+  Stk.clear();
+}
+
+Frame *InterpState::getCurrentFrame() {
+  if (Current && Current->Caller) {
+    return Current;
+  } else {
+    return Parent.getCurrentFrame();
+  }
+}
+
+bool InterpState::reportOverflow(const Expr *E, const llvm::APSInt &Value) {
+  QualType Type = E->getType();
+  CCEDiag(E, diag::note_constexpr_overflow) << Value << Type;
+  return noteUndefinedBehavior();
+}
+
+void InterpState::deallocate(Block *B) {
+  Descriptor *Desc = B->getDescriptor();
+  if (B->hasPointers()) {
+    size_t Size = B->getSize();
+
+    // Allocate a new block, transferring over pointers.
+    char *Memory = reinterpret_cast<char *>(malloc(sizeof(DeadBlock) + Size));
+    auto *D = new (Memory) DeadBlock(DeadBlocks, B);
+
+    // Move data from one block to another.
+    if (Desc->MoveFn)
+      Desc->MoveFn(B, B->data(), D->data(), Desc);
+  } else {
+    // Free storage, if necessary.
+    if (Desc->DtorFn)
+      Desc->DtorFn(B, B->data(), Desc);
+  }
+}
diff --git a/clang/lib/AST/Interp/Opcode.h b/clang/lib/AST/Interp/Opcode.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Opcode.h
@@ -0,0 +1,30 @@
+//===--- Opcode.h - Opcodes for the constexpr 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 all opcodes executed by the VM and emitted by the compiler.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_OPCODE_H
+#define LLVM_CLANG_AST_INTERP_OPCODE_H
+
+#include <cstdint>
+
+namespace clang {
+namespace interp {
+
+enum Opcode : uint32_t {
+#define GET_OPCODE_NAMES
+#include "Opcodes.inc"
+#undef GET_OPCODE_NAMES
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Opcodes.td b/clang/lib/AST/Interp/Opcodes.td
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Opcodes.td
@@ -0,0 +1,357 @@
+//===--- Opcodes.td - Opcode defitions for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Helper file used to generate opcodes, the interpreter and the disassembler.
+//
+//===----------------------------------------------------------------------===//
+
+
+//===----------------------------------------------------------------------===//
+// Types evaluated by the interpreter.
+//===----------------------------------------------------------------------===//
+
+class Type;
+def Bool : Type;
+def Sint8 : Type;
+def Uint8 : Type;
+def Sint16 : Type;
+def Uint16 : Type;
+def Sint32 : Type;
+def Uint32 : Type;
+def Sint64 : Type;
+def Uint64 : Type;
+def Ptr : Type;
+
+//===----------------------------------------------------------------------===//
+// Types transferred to the interpreter.
+//===----------------------------------------------------------------------===//
+
+class ArgType { string Name = ?; }
+def ArgSint8 : ArgType { let Name = "int8_t"; }
+def ArgUint8 : ArgType { let Name = "uint8_t"; }
+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 ArgPtr : ArgType { let Name = "uintptr_t"; }
+
+//===----------------------------------------------------------------------===//
+// Classes of types intructions operate on.
+//===----------------------------------------------------------------------===//
+
+class TypeClass {
+  list<Type> Types;
+}
+
+def AluTypeClass : TypeClass {
+  let Types = [Sint8, Uint8, Sint16, Uint16, Sint32,
+               Uint32, Sint64, Uint64, Bool];
+}
+
+def PtrTypeClass : TypeClass {
+  let Types = [Ptr];
+}
+
+def AllTypeClass : TypeClass {
+  let Types = !listconcat(AluTypeClass.Types, PtrTypeClass.Types);
+}
+
+def ArithTypeClass : TypeClass {
+  let Types = !listconcat(AluTypeClass.Types, [Ptr]);
+}
+
+class SingletonTypeClass<Type Ty> : TypeClass {
+  let Types = [Ty];
+}
+
+//===----------------------------------------------------------------------===//
+// Record describing all opcodes.
+//===----------------------------------------------------------------------===//
+
+class Opcode {
+  list<TypeClass> Types = [];
+  list<ArgType> Args = [];
+  string Name = "";
+  bit CanReturn = 0;
+  bit ChangesPC = 0;
+  bit HasCustomLink = 0;
+  bit HasCustomEval = 0;
+  bit HasGroup = 0;
+}
+
+class AluOpcode : Opcode {
+  let Types = [AluTypeClass];
+  let HasGroup = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// Jump opcodes
+//===----------------------------------------------------------------------===//
+
+class JumpOpcode : Opcode {
+  let Args = [ArgSint32];
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+
+// [] -> []
+def Jmp : JumpOpcode;
+// [Bool] -> [], jumps if true.
+def Jt : JumpOpcode;
+// [Bool] -> [], jumps if false.
+def Jf : JumpOpcode;
+
+//===----------------------------------------------------------------------===//
+// Returns
+//===----------------------------------------------------------------------===//
+
+// [Value] -> []
+def Ret : Opcode {
+  let Types = [AllTypeClass];
+  let ChangesPC = 1;
+  let CanReturn = 1;
+  let HasGroup = 1;
+  let HasCustomEval = 1;
+}
+// [] -> []
+def RetVoid : Opcode {
+  let CanReturn = 1;
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+// [] -> EXIT
+def NoRet : Opcode {}
+
+//===----------------------------------------------------------------------===//
+// Frame management
+//===----------------------------------------------------------------------===//
+
+// [] -> []
+def Destroy : Opcode {
+  let Args = [ArgUint32];
+  let HasCustomEval = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// Constants
+//===----------------------------------------------------------------------===//
+
+class ConstOpcode<Type Ty, ArgType ArgTy> : Opcode {
+  let Types = [SingletonTypeClass<Ty>];
+  let Args = [ArgTy];
+  let Name = "Const";
+}
+
+// [] -> []
+def ConstSint8 : ConstOpcode<Sint8, ArgSint8>;
+def ConstUint8 : ConstOpcode<Uint8, ArgUint8>;
+def ConstSint16 : ConstOpcode<Sint16, ArgSint16>;
+def ConstUint16 : ConstOpcode<Uint16, ArgUint16>;
+def ConstSint32 : ConstOpcode<Sint32, ArgSint32>;
+def ConstUint32 : ConstOpcode<Uint32, ArgUint32>;
+def ConstSint64 : ConstOpcode<Sint64, ArgSint64>;
+def ConstUint64 : ConstOpcode<Uint64, ArgUint64>;
+def ConstBool : ConstOpcode<Bool, ArgBool>;
+
+// [] -> []
+def Zero : Opcode {
+  let Types = [AluTypeClass];
+}
+
+// [] -> []
+def Null : Opcode {
+  let Types = [PtrTypeClass];
+}
+
+//===----------------------------------------------------------------------===//
+// Pointer generation
+//===----------------------------------------------------------------------===//
+
+// [] -> [Pointer]
+def GetPtrLocal : Opcode {
+  let Args = [ArgUint32];
+  bit HasCustomEval = 1;
+}
+// [] -> [Pointer]
+def GetPtrParam : Opcode {
+  let Args = [ArgUint32];
+}
+// [] -> [Pointer]
+def GetPtrGlobal : Opcode {
+  let Args = [ArgUint32];
+}
+// [Pointer] -> [Pointer]
+def GetPtrField : Opcode {
+  let Args = [ArgUint32];
+}
+// [Pointer] -> [Pointer]
+def GetPtrActiveField : Opcode {
+  let Args = [ArgUint32];
+}
+// [] -> [Pointer]
+def GetPtrActiveThisField : Opcode {
+  let Args = [ArgUint32];
+}
+// [] -> [Pointer]
+def GetPtrThisField : Opcode {
+  let Args = [ArgUint32];
+}
+// [Pointer] -> [Pointer]
+def GetPtrBase : Opcode {
+  let Args = [ArgUint32];
+}
+// [Pointer] -> [Pointer]
+def GetPtrVirtBase : Opcode {
+  let Args = [ArgPtr];
+}
+// [] -> [Pointer]
+def GetPtrThisBase : Opcode {
+  let Args = [ArgUint32];
+}
+// [] -> [Pointer]
+def GetPtrThisVirtBase : Opcode {
+  let Args = [ArgPtr];
+}
+// [] -> [Pointer]
+def This : Opcode;
+
+// [Pointer] -> [Pointer]
+def NarrowPtr : Opcode;
+// [Pointer] -> [Pointer]
+def ExpandPtr : Opcode;
+
+//===----------------------------------------------------------------------===//
+// Direct field accessors
+//===----------------------------------------------------------------------===//
+
+class AccessOpcode : Opcode {
+  let Types = [AllTypeClass];
+  let Args = [ArgUint32];
+  let HasGroup = 1;
+}
+
+// [] -> [Pointer]
+def GetLocal : AccessOpcode { let HasCustomEval = 1; }
+// [] -> [Pointer]
+def SetLocal : AccessOpcode { let HasCustomEval = 1; }
+
+// [] -> [Value]
+def GetGlobal : AccessOpcode;
+// [] -> [Value]
+def InitGlobal : AccessOpcode;
+
+// [] -> [Value]
+def GetParam : AccessOpcode;
+// [Value] -> []
+def SetParam : AccessOpcode;
+
+// [Pointer, Value] -> [Pointer]
+def SetField : AccessOpcode;
+// [Pointer] -> [Pointer, Value]
+def GetField : AccessOpcode;
+// [Pointer] -> [Value]
+def GetFieldPop : AccessOpcode;
+// [Pointer, Value] -> []
+def SetFieldPop : AccessOpcode;
+// [Value] -> []
+def SetThisField : AccessOpcode;
+// [] -> [Value]
+def GetThisField : AccessOpcode;
+
+// [Value] -> []
+def InitThisField : AccessOpcode;
+// [Value] -> []
+def InitThisFieldActive : AccessOpcode;
+// [Pointer, Value] -> []
+def InitField : AccessOpcode;
+// [Pointer, Value] -> []
+def InitFieldActive : AccessOpcode;
+
+
+//===----------------------------------------------------------------------===//
+// Pointer access
+//===----------------------------------------------------------------------===//
+
+class LoadOpcode : Opcode {
+  let Types = [AllTypeClass];
+  let HasGroup = 1;
+}
+
+// [Pointer] -> [Pointer, Value]
+def Load : LoadOpcode {}
+// [Pointer] -> [Value]
+def LoadPop : LoadOpcode {}
+
+class StoreOpcode : Opcode {
+  let Types = [AllTypeClass];
+  let HasGroup = 1;
+}
+
+// [Pointer, Value] -> [Pointer]
+def Store : StoreOpcode {}
+// [Pointer, Value] -> []
+def StorePop : StoreOpcode {}
+
+// [Pointer, Value] -> [Pointer]
+def Init : StoreOpcode {}
+// [Pointer, Value] -> []
+def InitPop : StoreOpcode {}
+
+//===----------------------------------------------------------------------===//
+// Binary operators.
+//===----------------------------------------------------------------------===//
+
+// [Real, Real] -> [Real]
+def Sub : AluOpcode;
+def Add : AluOpcode;
+def Mul : AluOpcode;
+def Div : AluOpcode;
+
+// [Integral, Integral] -> [Integral]
+def Rem : AluOpcode;
+
+//===----------------------------------------------------------------------===//
+// Comparison opcodes.
+//===----------------------------------------------------------------------===//
+
+class EqualityOpcode : Opcode {
+  let Types = [AllTypeClass];
+  let HasGroup = 1;
+}
+
+def EQ : EqualityOpcode;
+def NE : EqualityOpcode;
+
+class ComparisonOpcode : Opcode {
+  let Types = [ArithTypeClass];
+  let HasGroup = 1;
+}
+
+def LT : ComparisonOpcode;
+def LE : ComparisonOpcode;
+def GT : ComparisonOpcode;
+def GE : ComparisonOpcode;
+
+//===----------------------------------------------------------------------===//
+// Stack management.
+//===----------------------------------------------------------------------===//
+
+// [Value] -> []
+def Pop : Opcode {
+  let Types = [AllTypeClass];
+  let HasGroup = 1;
+}
+
+// [Value] -> [Value, Value]
+def Dup : Opcode {
+  let Types = [AllTypeClass];
+  let HasGroup = 1;
+}
diff --git a/clang/lib/AST/Interp/Pointer.h b/clang/lib/AST/Interp/Pointer.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Pointer.h
@@ -0,0 +1,325 @@
+//===--- Pointer.h - Types for the constexpr 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 classes responsible for pointer tracking.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_POINTER_H
+#define LLVM_CLANG_AST_INTERP_POINTER_H
+
+#include "Descriptor.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Expr.h"
+#include "llvm/ADT/PointerUnion.h"
+
+namespace clang {
+namespace interp {
+class Block;
+class DeadBlock;
+class Context;
+class InterpState;
+class Pointer;
+class Function;
+enum PrimType : unsigned;
+
+/// A memory block, either on the stack or in the heap.
+///
+/// The storage described by the block immediately follows it in memory.
+class Block {
+public:
+  // Creates a new block.
+  Block(Descriptor *Desc, bool IsStatic = false, bool IsExtern = false)
+      : IsStatic(IsStatic), IsExtern(IsExtern), Desc(Desc) {}
+
+  /// Returns the block's descriptor.
+  Descriptor *getDescriptor() const { return Desc; }
+  /// Checks if the block has any live pointers.
+  bool hasPointers() const { return Pointers; }
+  /// Checks if the block is extern.
+  bool isExtern() const { return IsExtern; }
+  /// Checks if the block has static storage duration.
+  bool isStatic() const { return IsStatic; }
+  /// Returns the size of the block.
+  InterpSize getSize() const { return Desc->AllocSize; }
+
+  /// Returns a pointer to the stored data.
+  char *data() { return reinterpret_cast<char *>(this + 1); }
+
+  /// Invokes the constructor.
+  void invokeCtor() {
+    if (Desc->CtorFn)
+      Desc->CtorFn(this, data(), Desc->IsMutable, /*isActive=*/true, Desc);
+  }
+
+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) {}
+
+  // Deletes a dead block at the end of its lifetime.
+  void cleanup();
+
+  // Pointer chain management.
+  void addPointer(Pointer *P);
+  void removePointer(Pointer *P);
+  void movePointer(Pointer *From, Pointer *To);
+
+  /// Start of the chain of pointers.
+  Pointer *Pointers = nullptr;
+  /// Flag indicating if the block has static storage duration.
+  bool IsStatic = false;
+  /// Flag indicating if the block is an extern.
+  bool IsExtern = false;
+  /// Flag indicating if the pointer is dead.
+  bool IsDead = false;
+  /// Pointer to the stack slot descriptor.
+  Descriptor *Desc;
+};
+
+/// Descriptor for a dead block.
+///
+/// Dead blocks are chained in a double-linked list to deallocate them
+/// whenever pointers become dead.
+class DeadBlock {
+public:
+  /// Copies the block.
+  DeadBlock(DeadBlock *&Root, Block *Blk);
+
+  /// Returns a pointer to the stored data.
+  char *data() { return B.data(); }
+
+private:
+  friend class Block;
+  friend class InterpState;
+
+  void free();
+
+  /// Root pointer of the list.
+  DeadBlock *&Root;
+  /// Previous block in the list.
+  DeadBlock *Prev;
+  /// Next block in the list.
+  DeadBlock *Next;
+
+  /// Actual block storing data and tracking pointers.
+  Block B;
+};
+
+/// A pointer to a memory block, live or dead.
+///
+/// This object can be allocated into interpreter stack frames. If pointing to
+/// a live block, it is a link in the chain of pointers pointing to the block.
+class Pointer {
+public:
+  Pointer() {}
+  Pointer(Block *B);
+  Pointer(const Pointer &P);
+  Pointer(Pointer &&P);
+  ~Pointer();
+
+  void operator=(const Pointer &P);
+  void operator=(Pointer &&P);
+
+  /// Converts the pointer to an APValue.
+  APValue toAPValue() const;
+
+  /// Offsets a pointer inside an array.
+  Pointer atOffset(unsigned Off) const {
+    if (getFieldDesc()->ElemDesc)
+      Off += sizeof(InlineDescriptor);
+    return Pointer(Pointee, Base, Base + Off);
+  }
+
+  /// Creates a pointer to a field.
+  Pointer atField(unsigned Off) const {
+    unsigned Field = Offset + Off;
+    return Pointer(Pointee, Field, Field);
+  }
+
+  /// Narrows a pointer to a field.
+  Pointer narrow() const {
+    return Pointer(Pointee, Offset, Offset);
+  }
+
+  /// Expands a pointer to the container.
+  Pointer expand() const {
+    if (Base == 0)
+      return *this;
+    unsigned NewBase = Base - getInlineDescriptor()->Offset;
+    return Pointer(Pointee, NewBase, Offset);
+  }
+
+  /// Checks if the pointer is null.
+  bool isNull() const { return Pointee == nullptr; }
+  /// Checks if the pointer is live.
+  bool isLive() const { return Pointee && !Pointee->IsDead; }
+  /// Checks if the item is a field in an object.
+  bool isField() const { return Base != 0; }
+
+  /// Accessor for information about the declaration site.
+  Descriptor *getDeclDesc() const { return Pointee->Desc; }
+  SourceLocation getDeclLoc() const { return getDeclDesc()->getLocation(); }
+
+  /// Returns a pointer to the object of which this pointer is a field.
+  Pointer getBase() const {
+    assert(Base != 0 && "Not a nested pointer");
+    unsigned NewBase = Base - getInlineDescriptor()->Offset;
+    return Pointer(Pointee, NewBase, NewBase);
+  }
+
+  /// Accessors for information about the innermost field.
+  Descriptor *getFieldDesc() const {
+    if (Base == 0)
+      return getDeclDesc();
+    return getInlineDescriptor()->Desc;
+  }
+
+  /// Returns the type of the innermost field.
+  QualType getType() const { return getFieldDesc()->getType(); }
+  /// Returns the element size of the innermost field.
+  size_t elemSize() const { return getFieldDesc()->ElemSize; }
+  /// Returns the total size of the innermost field.
+  size_t size() const { return getFieldDesc()->Size; }
+  /// Checks if the innermost field is an array.
+  bool isArray() const { return getFieldDesc()->IsArray; }
+  /// Checks if the storage is extern.
+  bool isExtern() const { return Pointee->isExtern(); }
+
+  /// Checks if an object or a subfield is mutable.
+  bool isMutable() const {
+    if (Base == 0)
+      return getDeclDesc()->IsMutable;
+    return getInlineDescriptor()->IsMutable;
+  }
+
+  /// Checks if an object was initialized.
+  bool isInitialized() const;
+
+  /// Checks if the object is active.
+  bool isActive() const {
+    if (Base == 0)
+      return true;
+    return getInlineDescriptor()->IsActive;
+  }
+
+  /// Checks if a structure is a base class.
+  bool isBaseClass() const {
+    if (Base == 0)
+      return false;
+    return getInlineDescriptor()->IsBase;
+  }
+
+  /// Checks if the object is a union.
+  bool isUnion() const;
+
+  /// Returns the offset into an array.
+  unsigned getOffset() const {
+    if (Offset > Base && getFieldDesc()->ElemDesc)
+      return Offset - Base - sizeof(InlineDescriptor);
+    return Offset - Base;
+  }
+  /// Returns the byte offset from the start.
+  unsigned getByteOffset() const {
+    return Offset;
+  }
+  /// Returns the index into an array.
+  int64_t getIndex() const {
+    if (auto ElemSize = elemSize())
+      return getOffset() / ElemSize;
+    return 0;
+  }
+  /// Checks if the index is one past end.
+  bool isOnePastEnd() const {
+    return elemSize() == getOffset();
+  }
+  /// Checks if the declaration is a temporary.
+  bool isTemporary() const { return getDeclDesc()->IsTemporary; }
+
+  /// Checks if the pointer is in range.
+  bool inRange() const { return Offset < Base + size(); }
+
+  /// Dereferences the pointer, if it's live.
+  template <typename T> T &deref() const {
+    assert(isLive() && "Invalid pointer");
+    return *reinterpret_cast<T *>(Pointee->data() + Offset);
+  }
+
+  /// Initializes a field.
+  void initialize() const;
+  /// Activats a field.
+  void activate() const;
+  /// Deactivates an entire strurcutre.
+  void deactivate() const;
+
+  /// Checks if two pointers are comparable.
+  static bool hasSameBase(const Pointer &A, const Pointer &B);
+  /// Checks if two pointers can be subtracted.
+  static bool hasSameArray(const Pointer &A, const Pointer &B);
+
+private:
+  friend class Block;
+  friend class DeadBlock;
+
+  Pointer(Block *Pointee, unsigned Base, unsigned Offset);
+
+  /// Returns the embedded descriptor preceding a field.
+  InlineDescriptor *getInlineDescriptor() const {
+    assert(Base != 0 && "Not a nested pointer");
+    return reinterpret_cast<InlineDescriptor *>(Pointee->data() + Base) - 1;
+  }
+
+  /// Returns a reference to the pointer which stores the initialization map.
+  InitMap *&getInitMap() const {
+    auto AllocSize = getFieldDesc()->AllocSize;
+    auto *ArrayStart = Pointee->data() + Base;
+    return *(reinterpret_cast<InitMap **>(ArrayStart + AllocSize) - 1);
+  }
+
+  /// The block the pointer is pointing to.
+  Block *Pointee = nullptr;
+  /// Start of the current subfield.
+  unsigned Base = 0;
+  /// Offset into the block.
+  unsigned Offset = 0;
+
+  /// Previous link in the pointer chain.
+  Pointer *Prev = nullptr;
+  /// Next link in the pointer chain.
+  Pointer *Next = nullptr;
+};
+
+/// Function pointer.
+class FnPointer {
+public:
+  FnPointer();
+  FnPointer(Function *F);
+  FnPointer(const FunctionDecl *FD);
+
+  /// Converts the pointer to an APValue.
+  APValue toAPValue() const;
+
+  /// Checks if the pointer is a null function pointer.
+  bool isNull() const;
+
+  /// Returns the declaration.
+  const FunctionDecl *asDecl() const;
+  /// Returns the function.
+  Function *asFunction() const;
+
+private:
+  llvm::PointerUnion<const FunctionDecl *, Function *> Pointer;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Pointer.cpp b/clang/lib/AST/Interp/Pointer.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Pointer.cpp
@@ -0,0 +1,292 @@
+//===--- Pointer.cpp - Types for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Pointer.h"
+#include "Function.h"
+#include "Type.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+void Block::addPointer(Pointer *P) {
+  if (IsStatic)
+    return;
+  if (Pointers)
+    Pointers->Prev = P;
+  P->Next = Pointers;
+  P->Prev = nullptr;
+  Pointers = P;
+}
+
+void Block::removePointer(Pointer *P) {
+  if (IsStatic)
+    return;
+  if (Pointers == P)
+    Pointers = P->Next;
+  if (P->Prev)
+    P->Prev->Next = P->Next;
+  if (P->Next)
+    P->Next->Prev = P->Prev;
+}
+
+void Block::cleanup() {
+  if (Pointers == nullptr && IsDead)
+    (reinterpret_cast<DeadBlock *>(this + 1) - 1)->free();
+}
+
+void Block::movePointer(Pointer *From, Pointer *To) {
+  if (IsStatic)
+    return;
+  To->Prev = From->Prev;
+  if (To->Prev)
+    To->Prev->Next = To;
+  To->Next = From->Next;
+  if (To->Next)
+    To->Next->Prev = To;
+  if (Pointers == From)
+    Pointers = To;
+
+  From->Prev = nullptr;
+  From->Next = nullptr;
+}
+
+DeadBlock::DeadBlock(DeadBlock *&Root, Block *Blk)
+    : Root(Root), B(Blk->Desc, Blk->IsStatic, Blk->IsExtern, /*isDead=*/true) {
+  // Add the block to the chain of dead blocks.
+  if (Root)
+    Root->Prev = this;
+
+  Next = Root;
+  Prev = nullptr;
+  Root = this;
+
+  // Transfer pointers.
+  B.Pointers = Blk->Pointers;
+  for (Pointer *P = Blk->Pointers; P; P = P->Next)
+    P->Pointee = &B;
+}
+
+void DeadBlock::free() {
+  if (Prev)
+    Prev->Next = Next;
+  if (Next)
+    Next->Prev = Prev;
+  if (Root == this)
+    Root = Next;
+  ::free(this);
+}
+
+Pointer::Pointer(Block *Pointee) : Pointer(Pointee, 0, 0) {}
+
+Pointer::Pointer(const Pointer &P) : Pointer(P.Pointee, P.Base, P.Offset) {}
+
+Pointer::Pointer(Pointer &&P)
+    : Pointee(P.Pointee), Base(P.Base), Offset(P.Offset) {
+  if (Pointee)
+    Pointee->movePointer(&P, this);
+}
+
+Pointer::Pointer(Block *Pointee, unsigned Base, unsigned Offset)
+    : Pointee(Pointee), Base(Base), Offset(Offset) {
+  assert(Base % alignof(void *) == 0 && "Invalid alignment");
+  if (Pointee)
+    Pointee->addPointer(this);
+}
+
+Pointer::~Pointer() {
+  if (Pointee) {
+    Pointee->removePointer(this);
+    Pointee->cleanup();
+  }
+}
+
+void Pointer::operator=(const Pointer &P) {
+  Block *Old = Pointee;
+
+  if (Pointee)
+    Pointee->removePointer(this);
+
+  Offset = P.Offset;
+  Base = P.Base;
+
+  Pointee = P.Pointee;
+  if (Pointee)
+    Pointee->addPointer(this);
+
+  if (Old)
+    Old->cleanup();
+}
+
+void Pointer::operator=(Pointer &&P) {
+  Block *Old = Pointee;
+
+  if (Pointee)
+    Pointee->removePointer(this);
+
+  Offset = P.Offset;
+  Base = P.Base;
+
+  Pointee = P.Pointee;
+  if (Pointee)
+    Pointee->movePointer(&P, this);
+
+  if (Old)
+    Old->cleanup();
+}
+
+APValue Pointer::toAPValue() const {
+  APValue::LValueBase Base;
+  llvm::SmallVector<APValue::LValuePathEntry, 5> Path;
+  CharUnits Offset;
+  bool IsNullPtr;
+  bool IsOnePastEnd;
+
+  if (isNull()) {
+    Base = static_cast<const Expr *>(nullptr);
+    IsNullPtr = true;
+    IsOnePastEnd = false;
+    Offset = CharUnits::Zero();
+  } else {
+    // Build the lvalue base from the block.
+    Descriptor *Desc = getDeclDesc();
+    if (auto *VD = Desc->Source.dyn_cast<const ValueDecl *>())
+      Base = VD;
+    else if (auto *E = Desc->Source.dyn_cast<const Expr *>())
+      Base = E;
+    else
+      llvm_unreachable("Invalid descriptor type");
+
+    // TODO: compute the offset into the object.
+    Offset = CharUnits::Zero();
+
+    // Build the path into the object.
+    Pointer Ptr = *this;
+    while (Ptr.isField()) {
+      if (int64_t Index = Ptr.getIndex())
+        Path.push_back(APValue::LValuePathEntry::ArrayIndex(Index));
+
+      // TODO: figure out if base is virtual
+      bool IsVirtual = false;
+
+      // Create a path entry for the field.
+      Descriptor *Desc = Ptr.getFieldDesc();
+      const ValueDecl *Decl = Desc->Source.dyn_cast<const ValueDecl *>();
+      Path.push_back(APValue::LValuePathEntry({Decl, IsVirtual}));
+      Ptr = Ptr.getBase();
+    }
+
+    IsNullPtr = false;
+    IsOnePastEnd = isOnePastEnd();
+  }
+
+  return APValue(Base, Offset, Path, IsOnePastEnd, IsNullPtr);
+}
+
+bool Pointer::isInitialized() const {
+  assert(Pointee && "Cannot check if null pointer was initialized");
+  if (Pointee->IsStatic)
+    return true;
+
+  Descriptor *Desc = getFieldDesc();
+  if (Desc->isPrimitiveArray()) {
+    // Primitive array field are stored in a bitset.
+    InitMap *Map = getInitMap();
+    if (!Map)
+      return false;
+    if (Map == (InitMap *)-1)
+      return true;
+    return Map->isInitialized(getIndex());
+  } else {
+    // Field has its bit in an inline descriptor.
+    return Base == 0 || getInlineDescriptor()->IsInitialized;
+  }
+}
+
+void Pointer::initialize() const {
+  assert(Pointee && "Cannot initialize null pointer");
+  Descriptor *Desc = getFieldDesc();
+  if (Desc->isPrimitiveArray()) {
+    if (!Pointee->IsStatic) {
+      // Primitive array initializer.
+      InitMap *&Map = getInitMap();
+      if (Map == (InitMap *)-1)
+        return;
+      if (Map == nullptr)
+        Map = InitMap::allocate(Desc->getNumElems());
+      if (Map->initialize(getIndex())) {
+        free(Map);
+        Map = (InitMap *)-1;
+      }
+    }
+  } else {
+    // Field has its bit in an inline descriptor.
+    assert(Base != 0 && "Only composite fields can be initialised");
+    getInlineDescriptor()->IsInitialized = true;
+  }
+}
+
+void Pointer::activate() const {
+  // Field has its bit in an inline descriptor.
+  assert(Base != 0 && "Only composite fields can be initialised");
+  getInlineDescriptor()->IsActive = true;
+}
+
+void Pointer::deactivate() const {
+  // TODO: this only appears in constructors, so nothing to deactivate.
+}
+
+bool Pointer::hasSameBase(const Pointer &A, const Pointer &B) {
+  return A.Pointee == B.Pointee;
+}
+
+bool Pointer::hasSameArray(const Pointer &A, const Pointer &B) {
+  return A.Base == B.Base && A.getFieldDesc()->IsArray;
+}
+
+FnPointer::FnPointer() : Pointer(nullptr) {}
+
+FnPointer::FnPointer(Function *F) : Pointer(F) {}
+
+FnPointer::FnPointer(const FunctionDecl *FD) : Pointer(FD) {}
+
+APValue FnPointer::toAPValue() const {
+  APValue::LValueBase Base;
+  llvm::SmallVector<APValue::LValuePathEntry, 5> Path;
+  bool IsNullPtr;
+  bool IsOnePastEnd;
+
+  if (isNull()) {
+    Base = static_cast<const Expr *>(nullptr);
+    IsNullPtr = true;
+    IsOnePastEnd = false;
+  } else {
+    IsNullPtr = false;
+
+    if (const FunctionDecl *FD = asDecl())
+      Base = FD;
+    if (Function *F = asFunction())
+      Base = F->getDecl();
+
+    // TODO: determine IsOnePastEnd
+    IsOnePastEnd = false;
+  }
+
+  return APValue(Base, CharUnits::Zero(), Path, IsOnePastEnd, IsNullPtr);
+}
+
+const FunctionDecl *FnPointer::asDecl() const {
+  if (Function *F = asFunction())
+    return F->getDecl();
+  return Pointer.dyn_cast<const FunctionDecl *>();
+}
+
+Function *FnPointer::asFunction() const {
+  return Pointer.dyn_cast<Function *>();
+}
+
+bool FnPointer::isNull() const { return !Pointer; }
diff --git a/clang/lib/AST/Interp/Program.h b/clang/lib/AST/Interp/Program.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Program.h
@@ -0,0 +1,176 @@
+//===--- Program.h - Bytecode for the constexpr 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 a program which organises and links multiple bytecode functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_PROGRAM_H
+#define LLVM_CLANG_AST_INTERP_PROGRAM_H
+
+#include "Function.h"
+#include "Pointer.h"
+#include "Record.h"
+#include "Source.h"
+#include "Type.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Allocator.h"
+#include <map>
+#include <vector>
+
+namespace clang {
+class RecordDecl;
+class Expr;
+class FunctionDecl;
+class Stmt;
+class StringLiteral;
+class VarDecl;
+
+namespace interp {
+class Context;
+class State;
+class Record;
+class Scope;
+
+/// The program contains and links the bytecode for all functions.
+class Program {
+public:
+  Program(Context &Ctx) : Ctx(Ctx) {}
+
+  /// Emits a string literal among global data.
+  unsigned emitString(const StringLiteral *S);
+
+  /// Emits a global storing a composite value.
+  unsigned emitGlobal(const void *VD, Descriptor *D, bool IsExtern = false);
+
+  /// Returns a pointer to a global.
+  Pointer getPtrGlobal(unsigned Idx);
+
+  /// Returns the value of a global.
+  template <typename T>
+  T getGlobal(unsigned Idx) {
+    assert(Idx < Globals.size());
+    return *reinterpret_cast<T *>(Globals[Idx]->data());
+  }
+
+  /// Sets the value of a global.
+  template <typename T>
+  void setGlobal(unsigned Idx, const T &Value) {
+    assert(Idx < Globals.size());
+    *reinterpret_cast<T *>(Globals[Idx]->data()) = Value;
+  }
+
+  /// Finds a global's index.
+  llvm::Optional<unsigned> findGlobal(const VarDecl *VD);
+
+  /// Returns or creates an extern's index.
+  llvm::Optional<unsigned> getOrCreateExtern(const ValueDecl *VD);
+
+  /// Creates a new function from a code range.
+  template <typename... Ts>
+  Function *createFunction(const FunctionDecl *Def, Ts &&... Args) {
+    auto *Func = new Function(*this, Def, std::forward<Ts>(Args)...);
+    Funcs.insert({Def, std::unique_ptr<Function>(Func)});
+    return Func;
+  }
+  /// Creates an anonymous function.
+  template <typename... Ts>
+  Function *createFunction(Ts &&... Args) {
+    auto *Func = new Function(*this, std::forward<Ts>(Args)...);
+    AnonFuncs.emplace_back(Func);
+    return Func;
+  }
+
+  /// Returns a function.
+  Function *getFunction(const FunctionDecl *F);
+
+  /// Returns a pointer to a function if it exists and can be compiled.
+  /// If a function couldn't be compiled, an error is returned.
+  /// If a function was not yet defined, a null pointer is returned.
+  llvm::Expected<Function *> getOrCreateFunction(const FunctionDecl *F);
+
+  /// Returns a record or creates one if it does not exist.
+  Record *getOrCreateRecord(const RecordDecl *RD);
+
+  /// Creates a descriptor for a primitive type.
+  Descriptor *createDescriptor(const DeclTy &D, PrimType Type,
+                               bool IsMutable = true,
+                               bool IsTemporary = false) {
+    return allocateDescriptor(std::move(D), Type, IsMutable, IsTemporary);
+  }
+
+  /// Creates a descriptor for a composite type.
+  Descriptor *createDescriptor(const DeclTy &D, const Type *Ty,
+                               bool IsMutable = true, bool IsTemporary = false);
+
+private:
+  /// Reference to the VM context.
+  Context &Ctx;
+  /// Mapping from decls to cached bytecode functions.
+  llvm::DenseMap<const FunctionDecl *, std::unique_ptr<Function>> Funcs;
+  /// List of anonymous functions.
+  std::vector<std::unique_ptr<Function>> AnonFuncs;
+
+  /// Function relocation locations.
+  llvm::DenseMap<const FunctionDecl *, std::vector<unsigned>> Relocs;
+
+  /// Custom allocator for global storage.
+  using PoolAllocTy = llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator>;
+
+  /// Descriptor + storage for a global object.
+  ///
+  /// Global objects never go out of scope, thus they do not track pointers.
+  class Global {
+  public:
+    /// Create a global descriptor for string literals.
+    Global(Descriptor *D, bool IsExtern) : B(D, /*isStatic=*/true, IsExtern) {}
+
+    /// Allocates the global in the pool, reserving storate for data.
+    void *operator new(size_t Meta, PoolAllocTy &Alloc, size_t Data) {
+      return Alloc.Allocate(Meta + Data, alignof(void *));
+    }
+
+    /// Return a pointer to the data.
+    char *data() { return B.data(); }
+    /// Return a pointer to the block.
+    Block *block() { return &B; }
+
+  private:
+    /// Required metadata - does not actually track pointers.
+    Block B;
+  };
+
+  /// Allocator for globals.
+  PoolAllocTy Allocator;
+
+  /// Global objects.
+  std::vector<Global *> Globals;
+  /// Cached global indices.
+  llvm::DenseMap<const void *, unsigned> GlobalIndices;
+
+  /// Mapping from decls to record metadata.
+  llvm::DenseMap<const RecordDecl *, Record *> Records;
+
+  /// Creates a new descriptor.
+  template <typename... Ts>
+  Descriptor *allocateDescriptor(Ts &&... Args) {
+    return new (Allocator) Descriptor(std::forward<Ts>(Args)...);
+  }
+
+public:
+  /// Dumps the disassembled bytecode to \c llvm::errs().
+  void dump() const;
+  void dump(llvm::raw_ostream &OS) const;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Program.cpp b/clang/lib/AST/Interp/Program.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Program.cpp
@@ -0,0 +1,242 @@
+//===--- Program.cpp - Bytecode for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Program.h"
+#include "ByteCodeGen.h"
+#include "Context.h"
+#include "Function.h"
+#include "Opcode.h"
+#include "Type.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+unsigned Program::emitString(const StringLiteral *S) {
+  const size_t CharWidth = S->getCharByteWidth();
+  const size_t DataSize = S->getLength() * CharWidth;
+  const size_t Sz = DataSize + CharWidth;
+
+  PrimType CharType;
+  switch (CharWidth) {
+  case 1:
+    CharType = PT_Sint8;
+    break;
+  case 2:
+    CharType = PT_Uint16;
+    break;
+  case 4:
+    CharType = PT_Uint32;
+    break;
+  default:
+    llvm_unreachable("Unsupported character width!");
+  }
+
+  // Create a descriptor for the string.
+  Descriptor *D = allocateDescriptor(S, CharType, S->getLength() + 1,
+                                     /*isMutable=*/false,
+                                     /*isTemporary=*/false);
+
+  // Allocate storage for the string.
+  // The byte length does not include the null terminator.
+  unsigned I = Globals.size();
+  auto *G = new (Allocator, Sz) Global(D, /*isExtern=*/false);
+  Globals.push_back(G);
+
+  // Copy the string into storage.
+  auto *Buffer = reinterpret_cast<char *>(G->data());
+  memcpy(Buffer, S->getBytes().begin(), DataSize);
+  memset(Buffer + DataSize, 0, CharWidth);
+
+  return I;
+}
+
+unsigned Program::emitGlobal(const void *VD, Descriptor *D, bool IsExtern) {
+  unsigned I = Globals.size();
+
+  auto *G = new (Allocator, D->AllocSize) Global(D, IsExtern);
+  G->block()->invokeCtor();
+
+  Globals.push_back(G);
+  GlobalIndices[VD] = I;
+
+  return I;
+}
+
+Pointer Program::getPtrGlobal(unsigned Idx) {
+  assert(Idx < Globals.size());
+  return Pointer(Globals[Idx]->block());
+}
+
+llvm::Optional<unsigned> Program::findGlobal(const VarDecl *VD) {
+  auto It = GlobalIndices.find(VD);
+  if (It == GlobalIndices.end())
+    return {};
+  return It->second;
+}
+
+llvm::Optional<unsigned> Program::getOrCreateExtern(const ValueDecl *VD) {
+  auto It = GlobalIndices.find(VD);
+  if (It != GlobalIndices.end())
+    return It->second;
+
+  QualType Ty = VD->getType();
+  Descriptor *Desc;
+
+  const bool IsMutable = !Ty.isConstQualified();
+  if (auto T = Ctx.classify(Ty)) {
+    Desc = createDescriptor(VD, *T, IsMutable);
+  } else {
+    Desc = createDescriptor(VD, Ty.getTypePtr(), IsMutable);
+  }
+
+  if (!Desc)
+    return {};
+
+  return emitGlobal(VD, Desc, /*isExtern=*/true);
+}
+
+Function *Program::getFunction(const FunctionDecl *F) {
+  F = F->getDefinition();
+  auto It = Funcs.find(F);
+  return It == Funcs.end() ? nullptr : It->second.get();
+}
+
+llvm::Expected<Function *> Program::getOrCreateFunction(const FunctionDecl *F) {
+  if (Function *Func = getFunction(F)) {
+    return Func;
+  }
+
+  // Try to compile the function if it wasn't compiled yet.
+  if (const FunctionDecl *FD = F->getDefinition()) {
+    return ByteCodeGen<ByteCodeEmitter>(Ctx, *this).compileFunc(FD);
+  }
+
+  // A relocation which traps if not resolved.
+  return nullptr;
+}
+
+Record *Program::getOrCreateRecord(const RecordDecl *RD) {
+  // Use the actual definition as a key.
+  RD = RD->getDefinition();
+  if (!RD)
+    return nullptr;
+
+  // Deduplicate records.
+  auto It = Records.find(RD);
+  if (It != Records.end()) {
+    return It->second;
+  }
+
+  // Number of bytes required by fields and base classes.
+  unsigned Size = 0;
+  // Number of bytes required by virtual base.
+  unsigned VirtualSize = 0;
+
+  // Reserve space for base classes.
+  Record::BaseList Bases;
+  Record::VirtualBaseList VirtualBases;
+  if (auto *CD = dyn_cast<CXXRecordDecl>(RD)) {
+    for (const CXXBaseSpecifier &Spec : CD->bases()) {
+      // Get the base class record and descriptor.
+      const RecordDecl *BD = Spec.getType()->getAs<RecordType>()->getDecl();
+      Record *BR = getOrCreateRecord(BD);
+      if (!BR)
+        return nullptr;
+
+      Descriptor *Desc = allocateDescriptor(nullptr, BR, /*isMutable=*/true,
+                                            /*isTemporary=*/false);
+      if (!Desc)
+        return nullptr;
+
+      // Collect the class among based or virtual bases.
+      if (Spec.isVirtual()) {
+        VirtualSize += align(sizeof(InlineDescriptor));
+        VirtualBases.push_back({BD, VirtualSize, Desc, BR});
+        VirtualSize += align(BR->getSize());
+      } else {
+        Size += align(sizeof(InlineDescriptor));
+        Bases.push_back({BD, Size, Desc, BR});
+        Size += align(BR->getSize());
+      }
+
+      // Collect nested virtual bases.
+      for (const Record::Base &VBR : BR->virtual_bases()) {
+        VirtualSize += sizeof(InlineDescriptor);
+        VirtualBases.push_back({VBR.Decl, VirtualSize, VBR.Desc, VBR.Record});
+        VirtualSize += VBR.Record->getSize();
+      }
+    }
+  }
+
+  // Reserve space for fields.
+  Record::FieldList Fields;
+  for (const FieldDecl *FD : RD->fields()) {
+    // Reserve space for the field's descriptor and the offset.
+    Size += align(sizeof(InlineDescriptor));
+
+    // Classify the field and add its metadata.
+    QualType FT = FD->getType();
+    const bool IsMutable = !FT.isConstQualified();
+    Descriptor *Desc;
+    if (llvm::Optional<PrimType> T = Ctx.classify(FT)) {
+      Desc = createDescriptor(FD, *T, IsMutable);
+    } else {
+      Desc = createDescriptor(FD, FT.getTypePtr(), IsMutable);
+    }
+    if (!Desc)
+      return nullptr;
+    Fields.push_back({FD, Size, Desc});
+    Size += align(Desc->AllocSize);
+  }
+
+  Record *R = new (Allocator) Record(RD, std::move(Bases), std::move(Fields),
+                                     std::move(VirtualBases), VirtualSize,
+                                     std::max<size_t>(Size, alignof(void *)));
+  Records.insert({RD, R});
+  return R;
+}
+
+Descriptor *Program::createDescriptor(const DeclTy &D, const Type *Ty,
+                                      bool IsMutable, bool IsTemporary) {
+  // Classes and structures.
+  if (auto *RT = Ty->getAs<RecordType>()) {
+    if (auto *Record = getOrCreateRecord(RT->getDecl()))
+      return allocateDescriptor(D, Record, IsMutable, IsTemporary);
+  }
+
+  // Arrays.
+  if (auto ArrayType = Ty->getAsArrayTypeUnsafe()) {
+    if (auto CAT = dyn_cast<ConstantArrayType>(ArrayType)) {
+      size_t NumElems = CAT->getSize().getZExtValue();
+      if (llvm::Optional<PrimType> T = Ctx.classify(CAT->getElementType())) {
+        // Arrays of primitives.
+        unsigned ElemSize = primSize(*T);
+        if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems) {
+          return {};
+        }
+        return allocateDescriptor(D, *T, NumElems, IsMutable, IsTemporary);
+      } else {
+        // Arrays of composites. In this case, the array is a list of pointers,
+        // followed by the actual elements.
+        QualType ElemTy = CAT->getElementType();
+        Descriptor *Desc =
+            createDescriptor(D, ElemTy.getTypePtr(), IsMutable, IsTemporary);
+        if (!Desc)
+          return nullptr;
+        InterpSize ElemSize = Desc->AllocSize + sizeof(InlineDescriptor);
+        if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems)
+          return {};
+        return allocateDescriptor(D, Desc, NumElems, IsMutable, IsTemporary);
+      }
+    }
+  }
+
+  return nullptr;
+}
diff --git a/clang/lib/AST/Interp/Real.h b/clang/lib/AST/Interp/Real.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Real.h
@@ -0,0 +1,131 @@
+//===--- Real.h - Wrapper for floating types 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 VM types and helpers operating on types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_REAL_H
+#define LLVM_CLANG_AST_INTERP_REAL_H
+
+#include "llvm/ADT/APFloat.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstddef>
+#include <cstdint>
+
+namespace clang {
+namespace interp {
+
+using APFloat = llvm::APFloat;
+using fltSemantics = llvm::fltSemantics;
+using RoundingMode = APFloat::roundingMode;
+
+class Real {
+  APFloat V;
+
+public:
+  Real() : V(llvm::APFloat::Bogus(), 0) {}
+
+  explicit Real(const APFloat &V) : V(V) {}
+
+  APFloat toAPFloat() const { return V; }
+
+  void print(llvm::raw_ostream &OS) const { V.print(OS); }
+
+  bool isZero() const { return V.isZero(); }
+
+  bool isNaN() const { return V.isNaN(); }
+
+  ComparisonCategoryResult compare(const Real &RHS) const {
+    switch (V.compare(RHS.V)) {
+    case APFloat::cmpEqual:
+      return ComparisonCategoryResult::Equal;
+    case APFloat::cmpLessThan:
+      return ComparisonCategoryResult::Less;
+    case APFloat::cmpGreaterThan:
+      return ComparisonCategoryResult::Greater;
+    case APFloat::cmpUnordered:
+      return ComparisonCategoryResult::Unordered;
+    }
+  }
+
+  template <unsigned Bits, bool Sign>
+  static Real from(const Integral<Bits, Sign> &I, const fltSemantics &S) {
+    APFloat Result(S, 1);
+    Result.convertFromAPInt(I.toAPSInt(), I.isSigned(),
+                            APFloat::rmNearestTiesToEven);
+    return Real(Result);
+  }
+
+  static Real from(const APFloat &F, const llvm::fltSemantics &S) {
+    return Real(F);
+  }
+
+  static Real zero(const llvm::fltSemantics &S) {
+    return Real(APFloat::getZero(S));
+  }
+
+  static Real from(const Real &F, const llvm::fltSemantics &S) {
+    APFloat Result = F.V;
+    bool Ignored;
+    Result.convert(S, APFloat::rmNearestTiesToEven, &Ignored);
+    return Real(Result);
+  }
+
+  static Real increment(const Real &A) {
+    APFloat R = A.V;
+    R.add(APFloat(R.getSemantics(), 1), APFloat::rmNearestTiesToEven);
+    return Real(R);
+  }
+
+  static Real decrement(const Real &A) {
+    APFloat R = A.V;
+    R.subtract(APFloat(R.getSemantics(), 1), APFloat::rmNearestTiesToEven);
+    return Real(R);
+  }
+
+  static Real add(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
+    APFloat Result = LHS.V;
+    Result.add(RHS.V, M);
+    return Real(Result);
+  }
+
+  static Real sub(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
+    APFloat Result = LHS.V;
+    Result.subtract(RHS.V, M);
+    return Real(Result);
+  }
+
+  static Real mul(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
+    APFloat Result = LHS.V;
+    Result.multiply(RHS.V, M);
+    return Real(Result);
+  }
+
+  static Real div(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
+    APFloat Result = LHS.V;
+    Result.divide(RHS.V, M);
+    return Real(Result);
+  }
+
+  static Real negate(const Real &Arg) {
+    APFloat Result = Arg.V;
+    Result.changeSign();
+    return Real(Result);
+  }
+};
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Real &F) {
+  F.print(OS);
+  return OS;
+}
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Record.h b/clang/lib/AST/Interp/Record.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Record.h
@@ -0,0 +1,118 @@
+//===--- Record.h - struct and class metadata 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
+//
+//===----------------------------------------------------------------------===//
+//
+// A record is part of a program to describe the layout and methods of a struct.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_RECORD_H
+#define LLVM_CLANG_AST_INTERP_RECORD_H
+
+#include "Pointer.h"
+
+namespace clang {
+namespace interp {
+class Program;
+
+/// Structure/Class descriptor.
+class Record {
+public:
+  /// Describes a record field.
+  struct Field {
+    const FieldDecl *Decl;
+    unsigned Offset;
+    Descriptor *Desc;
+  };
+
+  /// Describes a base class.
+  struct Base {
+    const RecordDecl *Decl;
+    unsigned Offset;
+    Descriptor *Desc;
+    Record *Record;
+  };
+
+  /// Mapping from identifiers to field descriptors.
+  using FieldList = llvm::SmallVector<Field, 8>;
+  /// Mapping from identifiers to base classes.
+  using BaseList = llvm::SmallVector<Base, 8>;
+  /// List of virtual base classes.
+  using VirtualBaseList = llvm::SmallVector<Base, 2>;
+
+public:
+  /// Returns the underlying declaration.
+  const RecordDecl *getDecl() const { return Decl; }
+  /// Checks if the record is a union.
+  bool isUnion() const { return getDecl()->isUnion(); }
+  /// Returns the size of the record.
+  unsigned getSize() const { return BaseSize; }
+  /// Returns the full size of the record, including records.
+  unsigned getFullSize() const { return BaseSize + VirtualSize; }
+  /// Returns a field.
+  const Field *getField(const FieldDecl *FD) const;
+  /// Returns a base descriptor.
+  const Base *getBase(const RecordDecl *FD) const;
+  /// Returns a virtual base descriptor.
+  const Base *getVirtualBase(const RecordDecl *RD) const;
+
+  using const_field_iter = FieldList::const_iterator;
+  llvm::iterator_range<const_field_iter> fields() const {
+    return llvm::make_range(Fields.begin(), Fields.end());
+  }
+
+  unsigned getNumFields() { return Fields.size(); }
+  Field *getField(unsigned I) { return &Fields[I]; }
+
+  using const_base_iter = BaseList::const_iterator;
+  llvm::iterator_range<const_base_iter> bases() const {
+    return llvm::make_range(Bases.begin(), Bases.end());
+  }
+
+  unsigned getNumBases() { return Bases.size(); }
+  Base *getBase(unsigned I) { return &Bases[I]; }
+
+  using const_virtual_iter = VirtualBaseList::const_iterator;
+  llvm::iterator_range<const_virtual_iter> virtual_bases() const {
+    return llvm::make_range(VirtualBases.begin(), VirtualBases.end());
+  }
+
+private:
+  /// Constructor used by Program to create record descriptors.
+  Record(const RecordDecl *, BaseList &&Bases, FieldList &&Fields,
+         VirtualBaseList &&VirtualBases, unsigned VirtualSize,
+         unsigned BaseSize);
+
+private:
+  friend class Program;
+
+  /// Original declaration.
+  const RecordDecl *Decl;
+  /// List of all base classes.
+  BaseList Bases;
+  /// List of all the fields in the record.
+  FieldList Fields;
+  /// List o fall virtual bases.
+  VirtualBaseList VirtualBases;
+
+  /// Mapping from declarations to bases.
+  llvm::DenseMap<const RecordDecl *, Base *> BaseMap;
+  /// Mapping from field identifiers to descriptors.
+  llvm::DenseMap<const FieldDecl *, Field *> FieldMap;
+  /// Mapping from declarations to virtual bases.
+  llvm::DenseMap<const RecordDecl *, Base *> VirtualBaseMap;
+  /// Mapping from
+  /// Size of the structure.
+  unsigned BaseSize;
+  /// Size of all virtual bases.
+  unsigned VirtualSize;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Record.cpp b/clang/lib/AST/Interp/Record.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Record.cpp
@@ -0,0 +1,46 @@
+//===--- Record.cpp - struct and class metadata 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Record.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+Record::Record(const RecordDecl *Decl, BaseList &&SrcBases,
+               FieldList &&SrcFields, VirtualBaseList &&SrcVirtualBases,
+               unsigned VirtualSize, unsigned BaseSize)
+    : Decl(Decl), Bases(std::move(SrcBases)), Fields(std::move(SrcFields)),
+      BaseSize(BaseSize), VirtualSize(VirtualSize) {
+  for (Base &V : SrcVirtualBases)
+    VirtualBases.push_back({ V.Decl, V.Offset + BaseSize, V.Desc, V.Record });
+
+  for (Base &B : Bases)
+    BaseMap[B.Decl] = &B;
+  for (Field &F : Fields)
+    FieldMap[F.Decl] = &F;
+  for (Base &V : VirtualBases)
+    VirtualBaseMap[V.Decl] = &V;
+}
+
+const Record::Field *Record::getField(const FieldDecl *FD) const {
+  auto It = FieldMap.find(FD);
+  assert(It != FieldMap.end() && "Missing field");
+  return It->second;
+}
+
+const Record::Base *Record::getBase(const RecordDecl *FD) const {
+  auto It = BaseMap.find(FD);
+  assert(It != BaseMap.end() && "Missing base");
+  return It->second;
+}
+
+const Record::Base *Record::getVirtualBase(const RecordDecl *FD) const {
+  auto It = VirtualBaseMap.find(FD);
+  assert(It != VirtualBaseMap.end() && "Missing virtual base");
+  return It->second;
+}
diff --git a/clang/lib/AST/Interp/Source.h b/clang/lib/AST/Interp/Source.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Source.h
@@ -0,0 +1,103 @@
+//===--- Source.h - Source location provider 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 a program which organises and links multiple bytecode functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_SOURCE_H
+#define LLVM_CLANG_AST_INTERP_SOURCE_H
+
+#include "clang/AST/Decl.h"
+#include "clang/AST/Stmt.h"
+#include "llvm/Support/Endian.h"
+
+namespace clang {
+namespace interp {
+class Function;
+
+/// Pointer into the code segment.
+class CodePtr {
+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; }
+
+  /// Reads data and advances the pointer.
+  template <typename T> 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 {
+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 *>(); }
+  const Decl *asDecl() const { return Source.dyn_cast<const Decl *>(); }
+  const Expr *asExpr() const;
+
+  operator bool() const { return !Source.isNull(); }
+
+private:
+  llvm::PointerUnion<const Decl *, const Stmt *> Source;
+};
+
+using SourceMap = std::vector<std::pair<unsigned, SourceInfo>>;
+
+/// Interface for classes which map locations to sources.
+class SourceMapper {
+public:
+  virtual ~SourceMapper() {}
+
+  /// Returns source information for a given PC in a function.
+  virtual SourceInfo getSource(Function *F, CodePtr PC) const = 0;
+
+  /// Returns the expression if an opcode belongs to one, null otherwise.
+  const Expr *getExpr(Function *F, CodePtr PC) const;
+  /// Returns the location from which an opcode originates.
+  SourceLocation getLocation(Function *F, CodePtr PC) const;
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/Source.cpp b/clang/lib/AST/Interp/Source.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Source.cpp
@@ -0,0 +1,39 @@
+//===--- Source.cpp - Source expression tracking ----------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Source.h"
+#include "clang/AST/Expr.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+SourceLocation SourceInfo::getLoc() const {
+  if (const Expr *E = asExpr())
+    return E->getExprLoc();
+  if (const Stmt *S = asStmt())
+    return S->getBeginLoc();
+  if (const Decl *D = asDecl())
+    return D->getBeginLoc();
+  return SourceLocation();
+}
+
+const Expr *SourceInfo::asExpr() const {
+  if (auto *S = Source.dyn_cast<const Stmt *>())
+    return dyn_cast<Expr>(S);
+  return nullptr;
+}
+
+const Expr *SourceMapper::getExpr(Function *F, CodePtr PC) const {
+  if (const Expr *E = getSource(F, PC).asExpr())
+    return E;
+  llvm::report_fatal_error("missing source expression");
+}
+
+SourceLocation SourceMapper::getLocation(Function *F, CodePtr PC) const {
+  return getSource(F, PC).getLoc();
+}
diff --git a/clang/lib/AST/Interp/State.h b/clang/lib/AST/Interp/State.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/State.h
@@ -0,0 +1,130 @@
+//===--- State.h - State chain for the VM and AST Walker --------*- 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 base class of the interpreter and evaluator state.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_STATE_H
+#define LLVM_CLANG_AST_INTERP_STATE_H
+
+#include "clang/AST/ASTDiagnostic.h"
+#include "clang/AST/Expr.h"
+#include "clang/Basic/OptionalDiagnostic.h"
+
+namespace clang {
+
+/// Kinds of access we can perform on an object, for diagnostics. Note that
+/// we consider a member function call to be a kind of access, even though
+/// it is not formally an access of the object, because it has (largely) the
+/// same set of semantic restrictions.
+enum AccessKinds {
+  AK_Read,
+  AK_Assign,
+  AK_Increment,
+  AK_Decrement,
+  AK_MemberCall,
+  AK_DynamicCast,
+  AK_TypeId,
+};
+
+// The order of this enum is important for diagnostics.
+enum CheckSubobjectKind {
+  CSK_Base,
+  CSK_Derived,
+  CSK_Field,
+  CSK_ArrayToPointer,
+  CSK_ArrayIndex,
+  CSK_Real,
+  CSK_Imag
+};
+
+namespace interp {
+class Frame;
+class SourceInfo;
+
+/// Interface for the VM to interact with the AST walker's context.
+class State {
+public:
+  virtual ~State();
+
+  virtual bool checkingForOverflow() const = 0;
+  virtual bool checkingPotentialConstantExpression() const = 0;
+  virtual bool noteUndefinedBehavior() = 0;
+  virtual bool keepEvaluatingAfterFailure() const = 0;
+  virtual Frame *getCurrentFrame() = 0;
+  virtual const Frame *getBottomFrame() const = 0;
+  virtual bool hasActiveDiagnostic() = 0;
+  virtual void setActiveDiagnostic(bool Flag) = 0;
+  virtual void setFoldFailureDiagnostic(bool Flag) = 0;
+  virtual Expr::EvalStatus &getEvalStatus() const = 0;
+  virtual ASTContext &getCtx() const = 0;
+  virtual bool hasPriorDiagnostic() = 0;
+  virtual unsigned getCallStackDepth() = 0;
+
+public:
+  // Diagnose that the evaluation could not be folded (FF => FoldFailure)
+  OptionalDiagnostic
+  FFDiag(SourceLocation Loc,
+         diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
+         unsigned ExtraNotes = 0);
+
+  OptionalDiagnostic
+  FFDiag(const Expr *E,
+         diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
+         unsigned ExtraNotes = 0);
+
+  OptionalDiagnostic
+  FFDiag(const SourceInfo &SI,
+         diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
+         unsigned ExtraNotes = 0);
+
+  /// Diagnose that the evaluation does not produce a C++11 core constant
+  /// expression.
+  ///
+  /// FIXME: Stop evaluating if we're in EM_ConstantExpression or
+  /// EM_PotentialConstantExpression mode and we produce one of these.
+  OptionalDiagnostic
+  CCEDiag(SourceLocation Loc,
+          diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
+          unsigned ExtraNotes = 0);
+
+  OptionalDiagnostic
+  CCEDiag(const Expr *E,
+          diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
+          unsigned ExtraNotes = 0);
+
+  OptionalDiagnostic
+  CCEDiag(const SourceInfo &SI,
+          diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
+          unsigned ExtraNotes = 0);
+
+  /// Add a note to a prior diagnostic.
+  OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId);
+
+  /// Add a stack of notes to a prior diagnostic.
+  void addNotes(ArrayRef<PartialDiagnosticAt> Diags);
+
+  /// Directly reports a diagnostic message.
+  DiagnosticBuilder report(SourceLocation Loc, diag::kind DiagId);
+
+  const LangOptions &getLangOpts() const;
+
+private:
+  void addCallStack(unsigned Limit);
+
+  PartialDiagnostic &addDiag(SourceLocation Loc, diag::kind DiagId);
+
+  OptionalDiagnostic diag(SourceLocation Loc, diag::kind DiagId,
+                          unsigned ExtraNotes, bool IsCCEDiag);
+};
+
+} // namespace interp
+} // namespace clang
+
+#endif
diff --git a/clang/lib/AST/Interp/State.cpp b/clang/lib/AST/Interp/State.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/State.cpp
@@ -0,0 +1,158 @@
+//===--- State.cpp - State chain for the VM and AST Walker ------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "State.h"
+#include "Frame.h"
+#include "Program.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/CXXInheritance.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+State::~State() {}
+
+OptionalDiagnostic State::FFDiag(SourceLocation Loc, diag::kind DiagId,
+                                 unsigned ExtraNotes) {
+  return diag(Loc, DiagId, ExtraNotes, false);
+}
+
+OptionalDiagnostic State::FFDiag(const Expr *E, diag::kind DiagId,
+                                 unsigned ExtraNotes) {
+  if (getEvalStatus().Diag)
+    return diag(E->getExprLoc(), DiagId, ExtraNotes, false);
+  setActiveDiagnostic(false);
+  return OptionalDiagnostic();
+}
+
+OptionalDiagnostic State::FFDiag(const SourceInfo &SI, diag::kind DiagId,
+                                 unsigned ExtraNotes) {
+  if (getEvalStatus().Diag)
+    return diag(SI.getLoc(), DiagId, ExtraNotes, false);
+  setActiveDiagnostic(false);
+  return OptionalDiagnostic();
+}
+
+OptionalDiagnostic State::CCEDiag(SourceLocation Loc, diag::kind DiagId,
+                                  unsigned ExtraNotes) {
+  // Don't override a previous diagnostic. Don't bother collecting
+  // diagnostics if we're evaluating for overflow.
+  if (!getEvalStatus().Diag || !getEvalStatus().Diag->empty()) {
+    setActiveDiagnostic(false);
+    return OptionalDiagnostic();
+  }
+  return diag(Loc, DiagId, ExtraNotes, true);
+}
+
+OptionalDiagnostic State::CCEDiag(const Expr *E, diag::kind DiagId,
+                                  unsigned ExtraNotes) {
+  return CCEDiag(E->getExprLoc(), DiagId, ExtraNotes);
+}
+
+OptionalDiagnostic State::CCEDiag(const SourceInfo &SI, diag::kind DiagId,
+                                  unsigned ExtraNotes) {
+  return CCEDiag(SI.getLoc(), DiagId, ExtraNotes);
+}
+
+OptionalDiagnostic State::Note(SourceLocation Loc, diag::kind DiagId) {
+  if (!hasActiveDiagnostic())
+    return OptionalDiagnostic();
+  return OptionalDiagnostic(&addDiag(Loc, DiagId));
+}
+
+void State::addNotes(ArrayRef<PartialDiagnosticAt> Diags) {
+  if (hasActiveDiagnostic()) {
+    getEvalStatus().Diag->insert(getEvalStatus().Diag->end(), Diags.begin(),
+                                 Diags.end());
+  }
+}
+
+DiagnosticBuilder State::report(SourceLocation Loc, diag::kind DiagId) {
+  return getCtx().getDiagnostics().Report(Loc, DiagId);
+}
+
+/// Add a diagnostic to the diagnostics list.
+PartialDiagnostic &State::addDiag(SourceLocation Loc, diag::kind DiagId) {
+  PartialDiagnostic PD(DiagId, getCtx().getDiagAllocator());
+  getEvalStatus().Diag->push_back(std::make_pair(Loc, PD));
+  return getEvalStatus().Diag->back().second;
+}
+
+OptionalDiagnostic State::diag(SourceLocation Loc, diag::kind DiagId,
+                               unsigned ExtraNotes, bool IsCCEDiag) {
+  Expr::EvalStatus &EvalStatus = getEvalStatus();
+  if (EvalStatus.Diag) {
+    if (hasPriorDiagnostic()) {
+      return OptionalDiagnostic();
+    }
+
+    unsigned CallStackNotes = getCallStackDepth() - 1;
+    unsigned Limit = getCtx().getDiagnostics().getConstexprBacktraceLimit();
+    if (Limit)
+      CallStackNotes = std::min(CallStackNotes, Limit + 1);
+    if (checkingPotentialConstantExpression())
+      CallStackNotes = 0;
+
+    setActiveDiagnostic(true);
+    setFoldFailureDiagnostic(!IsCCEDiag);
+    EvalStatus.Diag->clear();
+    EvalStatus.Diag->reserve(1 + ExtraNotes + CallStackNotes);
+    addDiag(Loc, DiagId);
+    if (!checkingPotentialConstantExpression()) {
+      addCallStack(Limit);
+    }
+    return OptionalDiagnostic(&(*EvalStatus.Diag)[0].second);
+  }
+  setActiveDiagnostic(false);
+  return OptionalDiagnostic();
+}
+
+const LangOptions &State::getLangOpts() const { return getCtx().getLangOpts(); }
+
+void State::addCallStack(unsigned Limit) {
+  // Determine which calls to skip, if any.
+  unsigned ActiveCalls = getCallStackDepth() - 1;
+  unsigned SkipStart = ActiveCalls, SkipEnd = SkipStart;
+  if (Limit && Limit < ActiveCalls) {
+    SkipStart = Limit / 2 + Limit % 2;
+    SkipEnd = ActiveCalls - Limit / 2;
+  }
+
+  // Walk the call stack and add the diagnostics.
+  unsigned CallIdx = 0;
+  Frame *Top = getCurrentFrame();
+  const Frame *Bottom = getBottomFrame();
+  for (Frame *F = Top; F != Bottom; F = F->getCaller(), ++CallIdx) {
+    SourceLocation CallLocation = F->getCallLocation();
+
+    // Skip this call?
+    if (CallIdx >= SkipStart && CallIdx < SkipEnd) {
+      if (CallIdx == SkipStart) {
+        // Note that we're skipping calls.
+        addDiag(CallLocation, diag::note_constexpr_calls_suppressed)
+            << unsigned(ActiveCalls - Limit);
+      }
+      continue;
+    }
+
+    // Use a different note for an inheriting constructor, because from the
+    // user's perspective it's not really a function at all.
+    if (auto *CD = dyn_cast_or_null<CXXConstructorDecl>(F->getCallee())) {
+      if (CD->isInheritingConstructor()) {
+        addDiag(CallLocation, diag::note_constexpr_inherited_ctor_call_here)
+            << CD->getParent();
+        continue;
+      }
+    }
+
+    SmallVector<char, 128> Buffer;
+    llvm::raw_svector_ostream Out(Buffer);
+    F->describe(Out);
+    addDiag(CallLocation, diag::note_constexpr_call_here) << Out.str();
+  }
+}
diff --git a/clang/lib/AST/Interp/Type.h b/clang/lib/AST/Interp/Type.h
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Type.h
@@ -0,0 +1,79 @@
+//===--- Type.h - Types for the constexpr 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 VM types and helpers operating on types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_TYPE_H
+#define LLVM_CLANG_AST_INTERP_TYPE_H
+
+#include "Integral.h"
+#include "Pointer.h"
+#include "Real.h"
+#include <cstddef>
+#include <cstdint>
+#include <climits>
+
+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,
+};
+
+/// 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>; };
+template <> struct PrimConv<PT_Sint32> { using T = Integral<32, true>; };
+template <> struct PrimConv<PT_Uint32> { using T = Integral<32, false>; };
+template <> struct PrimConv<PT_Sint64> { using T = Integral<64, true>; };
+template <> struct PrimConv<PT_Uint64> { using T = Integral<64, false>; };
+template <> struct PrimConv<PT_Bool> { using T = Integral<1, false>; };
+template <> struct PrimConv<PT_Ptr> { using T = Pointer; };
+
+/// Returns the size of a primitive type in bytes.
+size_t primSize(PrimType Type);
+
+/// Aligns a size to the pointer alignment.
+constexpr size_t align(size_t Size) {
+  return ((Size + alignof(void *) - 1) / alignof(void *)) * alignof(void *);
+}
+
+} // namespace interp
+} // namespace clang
+
+/// Helper macro to simplify type switches.
+/// The macro implicitly exposes a type T in the scope of the inner block.
+#define TYPE_SWITCH(Expr, B)                                                   \
+  switch (Expr) {                                                              \
+  case PT_Sint8:  {using T = PrimConv<PT_Sint8>::T;  do{B;}while(0); break; }  \
+  case PT_Uint8:  {using T = PrimConv<PT_Uint8>::T;  do{B;}while(0); break; }  \
+  case PT_Sint16: {using T = PrimConv<PT_Sint16>::T; do{B;}while(0); break; }  \
+  case PT_Uint16: {using T = PrimConv<PT_Uint16>::T; do{B;}while(0); break; }  \
+  case PT_Sint32: {using T = PrimConv<PT_Sint32>::T; do{B;}while(0); break; }  \
+  case PT_Uint32: {using T = PrimConv<PT_Uint32>::T; do{B;}while(0); break; }  \
+  case PT_Sint64: {using T = PrimConv<PT_Sint64>::T; do{B;}while(0); break; }  \
+  case PT_Uint64: {using T = PrimConv<PT_Uint64>::T; do{B;}while(0); break; }  \
+  case PT_Bool:   {using T = PrimConv<PT_Bool>::T;   do{B;}while(0); break; }  \
+  case PT_Ptr:    {using T = PrimConv<PT_Ptr>::T;    do{B;}while(0); break; }  \
+  }
+#endif
diff --git a/clang/lib/AST/Interp/Type.cpp b/clang/lib/AST/Interp/Type.cpp
new file mode 100644
--- /dev/null
+++ b/clang/lib/AST/Interp/Type.cpp
@@ -0,0 +1,22 @@
+//===--- Type.cpp - Types for the constexpr 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Type.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+namespace clang {
+namespace interp {
+
+size_t primSize(PrimType Type) {
+  TYPE_SWITCH(Type, return sizeof(T));
+}
+
+} // namespace interp
+} // namespace clang
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -4429,6 +4429,12 @@
     CmdArgs.push_back(A->getValue());
   }
 
+  if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
+    CmdArgs.push_back("-fexperimental-new-constant-interpreter");
+
+  if (Args.hasArg(options::OPT_fforce_experimental_new_constant_interpreter))
+    CmdArgs.push_back("-fforce-experimental-new-constant-interpreter");
+
   if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
     CmdArgs.push_back("-fbracket-depth");
     CmdArgs.push_back(A->getValue());
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -2752,6 +2752,10 @@
       getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
   Opts.ConstexprStepLimit =
       getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
+  Opts.EnableNewConstInterp =
+      Args.hasArg(OPT_fexperimental_new_constant_interpreter);
+  Opts.ForceNewConstInterp =
+      Args.hasArg(OPT_fforce_experimental_new_constant_interpreter);
   Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags);
   Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
   Opts.NumLargeByValueCopy =
diff --git a/clang/test/AST/Interp/cond.cpp b/clang/test/AST/Interp/cond.cpp
new file mode 100644
--- /dev/null
+++ b/clang/test/AST/Interp/cond.cpp
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int cond_then_else(int a, int b) {
+  if (a < b) {
+    return b - a;
+  } else {
+    return a - b;
+  }
+}
diff --git a/clang/test/SemaCXX/constexpr-ackermann.cpp b/clang/test/SemaCXX/constexpr-ackermann.cpp
--- a/clang/test/SemaCXX/constexpr-ackermann.cpp
+++ b/clang/test/SemaCXX/constexpr-ackermann.cpp
@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -std=c++11 -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-clang-interpreter %s
 
 constexpr unsigned long long A(unsigned long long m, unsigned long long n) {
   return m == 0 ? n + 1 : n == 0 ? A(m-1, 1) : A(m - 1, A(m, n - 1));
diff --git a/clang/test/SemaCXX/constexpr-duffs-device.cpp b/clang/test/SemaCXX/constexpr-duffs-device.cpp
--- a/clang/test/SemaCXX/constexpr-duffs-device.cpp
+++ b/clang/test/SemaCXX/constexpr-duffs-device.cpp
@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -std=c++1y -verify %s
+// RUN: %clang_cc1 -std=c++1y -fsyntax-only -fforce-experimental-clang-interpreter %s
 
 // expected-no-diagnostics
 constexpr void copy(const char *from, unsigned long count, char *to) {
diff --git a/clang/test/SemaCXX/constexpr-factorial.cpp b/clang/test/SemaCXX/constexpr-factorial.cpp
--- a/clang/test/SemaCXX/constexpr-factorial.cpp
+++ b/clang/test/SemaCXX/constexpr-factorial.cpp
@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -std=c++11 -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-clang-interpreter %s
 
 constexpr unsigned oddfac(unsigned n) {
   return n == 1 ? 1 : n * oddfac(n-2);
diff --git a/clang/test/SemaCXX/constexpr-many-arguments.cpp b/clang/test/SemaCXX/constexpr-many-arguments.cpp
--- a/clang/test/SemaCXX/constexpr-many-arguments.cpp
+++ b/clang/test/SemaCXX/constexpr-many-arguments.cpp
@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -std=c++11 -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-clang-interpreter %s
 // PR13197
 
 struct type1
@@ -12,7 +13,7 @@
   typedef type1 T;
   constexpr type2(T a00, T a01, T a02, T a03, T a04, T a05, T a06, T a07, T a08, T a09,
                        T a10, T a11, T a12, T a13, T a14, T a15, T a16, T a17, T a18, T a19,
-                       T a20, T a21, T a22) 
+                       T a20, T a21, T a22)
     : my_data{a00, a01, a02, a03, a04, a05, a06, a07, a08, a09,
               a10, a11, a12, a13, a14, a15, a16, a17, a18, a19,
               a20, a21, a22}
@@ -32,7 +33,7 @@
    {0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
    {0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
    {0},{0},{0}
-  }, 
+  },
   {
    {0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
    {0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
diff --git a/clang/test/SemaCXX/constexpr-nqueens.cpp b/clang/test/SemaCXX/constexpr-nqueens.cpp
--- a/clang/test/SemaCXX/constexpr-nqueens.cpp
+++ b/clang/test/SemaCXX/constexpr-nqueens.cpp
@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -std=c++11 -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-clang-interpreter %s
 
 typedef unsigned long uint64_t;
 
diff --git a/clang/test/SemaCXX/constexpr-turing.cpp b/clang/test/SemaCXX/constexpr-turing.cpp
--- a/clang/test/SemaCXX/constexpr-turing.cpp
+++ b/clang/test/SemaCXX/constexpr-turing.cpp
@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -verify -std=c++11 %s
+// RUN: %clang_cc1 -verify -std=c++11 -fforce-experimental-clang-interpreter %s
 // expected-no-diagnostics
 
 // A direct proof that constexpr is Turing-complete, once DR1454 is implemented.
diff --git a/clang/test/SemaCXX/constexpr-unsigned-high-bit.cpp b/clang/test/SemaCXX/constexpr-unsigned-high-bit.cpp
--- a/clang/test/SemaCXX/constexpr-unsigned-high-bit.cpp
+++ b/clang/test/SemaCXX/constexpr-unsigned-high-bit.cpp
@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -std=c++14 -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fforce-experimental-clang-interpreter %s
 
 #include <limits.h>
 
diff --git a/clang/utils/TableGen/CMakeLists.txt b/clang/utils/TableGen/CMakeLists.txt
--- a/clang/utils/TableGen/CMakeLists.txt
+++ b/clang/utils/TableGen/CMakeLists.txt
@@ -8,6 +8,7 @@
   ClangCommentHTMLTagsEmitter.cpp
   ClangDataCollectorsEmitter.cpp
   ClangDiagnosticsEmitter.cpp
+  ClangOpcodesEmitter.cpp
   ClangOpenCLBuiltinEmitter.cpp
   ClangOptionDocEmitter.cpp
   ClangSACheckersEmitter.cpp
diff --git a/clang/utils/TableGen/ClangOpcodesEmitter.cpp b/clang/utils/TableGen/ClangOpcodesEmitter.cpp
new file mode 100644
--- /dev/null
+++ b/clang/utils/TableGen/ClangOpcodesEmitter.cpp
@@ -0,0 +1,360 @@
+//=== ClangOpcodesEmitter.cpp - constexpr interpreter opcodes ---*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// These tablegen backends emit Clang AST node tables
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/StringMatcher.h"
+#include "llvm/TableGen/TableGenBackend.h"
+
+using namespace llvm;
+
+namespace {
+class ClangOpcodesEmitter {
+  RecordKeeper &Records;
+  Record Root;
+  unsigned NumTypes;
+
+public:
+  ClangOpcodesEmitter(RecordKeeper &R)
+    : Records(R), Root("Opcode", SMLoc(), R),
+      NumTypes(Records.getAllDerivedDefinitions("Type").size()) {}
+
+  void run(raw_ostream &OS);
+
+private:
+  /// Emits the opcode name for the opcode enum.
+  /// The name is obtained by concatenating the name with the list of types.
+  void EmitEnum(raw_ostream &OS, StringRef N, Record *R);
+
+  /// Emits the switch case and the invocation in the interpreter.
+  void EmitInterp(raw_ostream &OS, StringRef N, Record *R);
+
+  /// Emits the disassembler.
+  void EmitDisasm(raw_ostream &OS, StringRef N, Record *R);
+
+  /// Emits the byte code emitter method.
+  void EmitEmitter(raw_ostream &OS, StringRef N, Record *R);
+
+  /// Emits the prototype.
+  void EmitProto(raw_ostream &OS, StringRef N, Record *R);
+
+  /// Emits the prototype to dispatch from a type.
+  void EmitGroup(raw_ostream &OS, StringRef N, Record *R);
+
+  /// Emits the evaluator method.
+  void EmitEval(raw_ostream &OS, StringRef N, Record *R);
+
+  void PrintTypes(raw_ostream &OS, ArrayRef<Record *> Types);
+};
+
+void Enumerate(const Record *R,
+               StringRef N,
+               std::function<void(ArrayRef<Record *>, Twine)> &&F) {
+  llvm::SmallVector<Record *, 2> TypePath;
+  auto *Types = R->getValueAsListInit("Types");
+
+  std::function<void(size_t, const Twine &)> Rec;
+  Rec = [&TypePath, Types, &Rec, &F](size_t I, const Twine &ID) {
+    if (I >= Types->size()) {
+      F(TypePath, ID);
+      return;
+    }
+
+    if (auto *TypeClass = dyn_cast<DefInit>(Types->getElement(I))) {
+      for (auto *Type : TypeClass->getDef()->getValueAsListOfDefs("Types")) {
+        TypePath.push_back(Type);
+        Rec(I + 1, ID + Type->getName());
+        TypePath.pop_back();
+      }
+    } else {
+      PrintFatalError("Expected a type class");
+    }
+  };
+  Rec(0, N);
+}
+
+} // namespace
+
+void ClangOpcodesEmitter::run(raw_ostream &OS) {
+  for (auto *Opcode : Records.getAllDerivedDefinitions(Root.getName())) {
+    // The name is the record name, unless overriden.
+    StringRef N = Opcode->getValueAsString("Name");
+    if (N.empty())
+      N = Opcode->getName();
+
+    EmitEnum(OS, N, Opcode);
+    EmitInterp(OS, N, Opcode);
+    EmitDisasm(OS, N, Opcode);
+    EmitProto(OS, N, Opcode);
+    EmitGroup(OS, N, Opcode);
+    EmitEmitter(OS, N, Opcode);
+    EmitEval(OS, N, Opcode);
+  }
+}
+
+void ClangOpcodesEmitter::EmitEnum(raw_ostream &OS, StringRef N, Record *R) {
+  OS << "#ifdef GET_OPCODE_NAMES\n";
+  Enumerate(R, N, [&OS](ArrayRef<Record *>, const Twine &ID) {
+    OS << "OP_" << ID << ",\n";
+  });
+  OS << "#endif\n";
+}
+
+void ClangOpcodesEmitter::EmitInterp(raw_ostream &OS, StringRef N, Record *R) {
+  OS << "#ifdef GET_INTERP\n";
+
+  Enumerate(R, N, [this, R, &OS, &N](ArrayRef<Record *> TS, const Twine &ID) {
+    bool CanReturn = R->getValueAsBit("CanReturn");
+    bool ChangesPC = R->getValueAsBit("ChangesPC");
+    auto Args = R->getValueAsListOfDefs("Args");
+
+    OS << "case OP_" << ID << ": {\n";
+
+    // Emit calls to read arguments.
+    for (size_t I = 0, N = Args.size(); I < N; ++I) {
+      OS << "\tauto V" << I;
+      OS << " = ";
+      OS << "PC.read<" << Args[I]->getValueAsString("Name") << ">();\n";
+    }
+
+    // Emit a call to the template method and pass arguments.
+    OS << "\tif (!" << N;
+    PrintTypes(OS, TS);
+    OS << "(S";
+    if (ChangesPC)
+      OS << ", PC";
+    else
+      OS << ", OpPC";
+    if (CanReturn)
+      OS << ", Result";
+    for (size_t I = 0, N = Args.size(); I < N; ++I)
+      OS << ", V" << I;
+    OS << "))\n";
+    OS << "\t\treturn false;\n";
+
+    // Bail out if interpreter returned.
+    if (CanReturn) {
+      OS << "\tif (!S.Current || S.Current->isRoot())\n";
+      OS << "\t\treturn true;\n";
+    }
+
+    OS << "\tcontinue;\n";
+    OS << "}\n";
+  });
+  OS << "#endif\n";
+}
+
+void ClangOpcodesEmitter::EmitDisasm(raw_ostream &OS, StringRef N, Record *R) {
+  OS << "#ifdef GET_DISASM\n";
+  Enumerate(R, N, [R, &OS](ArrayRef<Record *>, const Twine &ID) {
+    OS << "case OP_" << ID << ":\n";
+    OS << "\tPrintName(\"" << ID << "\");\n";
+    OS << "\tOS << \"\\t\"";
+
+    for (auto *Arg : R->getValueAsListOfDefs("Args"))
+      OS << " << PC.read<" << Arg->getValueAsString("Name") << ">() << \" \"";
+
+    OS << "<< \"\\n\";\n";
+    OS << "\tcontinue;\n";
+  });
+  OS << "#endif\n";
+}
+
+void ClangOpcodesEmitter::EmitEmitter(raw_ostream &OS, StringRef N, Record *R) {
+  if (R->getValueAsBit("HasCustomLink"))
+    return;
+
+  OS << "#ifdef GET_LINK_IMPL\n";
+  Enumerate(R, N, [R, &OS](ArrayRef<Record *>, const Twine &ID) {
+    auto Args = R->getValueAsListOfDefs("Args");
+
+    // Emit the list of arguments.
+    OS << "bool ByteCodeEmitter::emit" << ID << "(";
+    for (size_t I = 0, N = Args.size(); I < N; ++I)
+      OS << "const " << Args[I]->getValueAsString("Name") << " &A" << I << ",";
+    OS << "const SourceInfo &L) {\n";
+
+    // Emit a call to write the opcodes.
+    OS << "\treturn emitOp<";
+    for (size_t I = 0, N = Args.size(); I < N; ++I) {
+      if (I != 0)
+        OS << ", ";
+      OS << Args[I]->getValueAsString("Name");
+    }
+    OS << ">(OP_" << ID;
+    for (size_t I = 0, N = Args.size(); I < N; ++I)
+      OS << ", A" << I;
+    OS << ", L);\n";
+    OS << "}\n";
+  });
+  OS << "#endif\n";
+}
+
+void ClangOpcodesEmitter::EmitProto(raw_ostream &OS, StringRef N, Record *R) {
+  OS << "#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)\n";
+  auto Args = R->getValueAsListOfDefs("Args");
+  Enumerate(R, N, [&OS, &Args](ArrayRef<Record *> TS, const Twine &ID) {
+    OS << "bool emit" << ID << "(";
+    for (auto *Arg : Args)
+      OS << "const " << Arg->getValueAsString("Name") << " &, ";
+    OS << "const SourceInfo &);\n";
+  });
+
+  // Emit a template method for custom emitters to have less to implement.
+  auto TypeCount = R->getValueAsListInit("Types")->size();
+  if (R->getValueAsBit("HasCustomEval") && TypeCount) {
+    OS << "#if defined(GET_EVAL_PROTO)\n";
+    OS << "template<";
+    for (size_t I = 0; I < TypeCount; ++I) {
+      if (I != 0)
+        OS << ", ";
+      OS << "PrimType";
+    }
+    OS << ">\n";
+    OS << "bool emit" << N << "(";
+    for (auto *Arg : Args)
+      OS << "const " << Arg->getValueAsString("Name") << " &,";
+    OS << "const SourceInfo &);\n";
+    OS << "#endif\n";
+  }
+
+  OS << "#endif\n";
+}
+
+void ClangOpcodesEmitter::EmitGroup(raw_ostream &OS, StringRef N, Record *R) {
+  if (!R->getValueAsBit("HasGroup"))
+    return;
+
+  auto *Types = R->getValueAsListInit("Types");
+  auto Args = R->getValueAsListOfDefs("Args");
+
+  // Emit the prototype of the group emitter in the header.
+  OS << "#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)\n";
+  OS << "bool emit" << N << "(";
+  for (size_t I = 0, N = Types->size(); I < N; ++I)
+    OS << "PrimType, ";
+  for (auto *Arg : Args)
+    OS << "const " << Arg->getValueAsString("Name") << " &, ";
+  OS << "const SourceInfo &I);\n";
+  OS << "#endif\n";
+
+  // Emit the dispatch implementation in the source.
+  OS << "#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)\n";
+  OS << "bool \n";
+  OS << "#if defined(GET_EVAL_IMPL)\n";
+  OS << "EvalEmitter\n";
+  OS << "#else\n";
+  OS << "ByteCodeEmitter\n";
+  OS << "#endif\n";
+  OS << "::emit" << N << "(";
+  for (size_t I = 0, N = Types->size(); I < N; ++I)
+    OS << "PrimType T" << I << ", ";
+  for (size_t I = 0, N = Args.size(); I < N; ++I)
+    OS << "const " << Args[I]->getValueAsString("Name") << " &A" << I << ", ";
+  OS << "const SourceInfo &I) {\n";
+
+  std::function<void(size_t, const Twine &)> Rec;
+  llvm::SmallVector<Record *, 2> TS;
+  Rec = [this, &Rec, &OS, Types, &Args, R, &TS, N](size_t I, const Twine &ID) {
+    if (I >= Types->size()) {
+      // Print a call to the emitter method.
+      // Custom evaluator methods dispatch to template methods.
+      if (R->getValueAsBit("HasCustomEval")) {
+        OS << "#ifdef GET_LINK_IMPL\n";
+        OS << "return emit" << ID << "\n";
+        OS << "#else\n";
+        OS << "return emit" << N;
+        PrintTypes(OS, TS);
+        OS << "\n#endif\n";
+      } else {
+        OS << "return emit" << ID;
+      }
+
+      OS << "(";
+      for (size_t I = 0; I < Args.size(); ++I) {
+        OS << "A" << I << ", ";
+      }
+      OS << "I);\n";
+      return;
+    }
+
+    // Print a switch statement selecting T.
+    if (auto *TypeClass = dyn_cast<DefInit>(Types->getElement(I))) {
+      OS << "switch (T" << I << "){\n";
+      auto Cases = TypeClass->getDef()->getValueAsListOfDefs("Types");
+      for (auto *Case : Cases) {
+        OS << "case PT_" << Case->getName() << ":\n";
+        TS.push_back(Case);
+        Rec(I + 1, ID + Case->getName());
+        TS.pop_back();
+      }
+      // Emit a default case if not all types are present.
+      if (Cases.size() < NumTypes) {
+        OS << "default: llvm_unreachable(\"invalid\");\n";
+      }
+      OS << "}\n";
+    } else {
+      PrintFatalError("Expected a type class");
+    }
+  };
+  Rec(0, N);
+
+  OS << "}\n";
+  OS << "#endif\n";
+}
+
+void ClangOpcodesEmitter::EmitEval(raw_ostream &OS, StringRef N, Record *R) {
+  if (R->getValueAsBit("HasCustomEval"))
+    return;
+
+  OS << "#ifdef GET_EVAL_IMPL\n";
+  Enumerate(R, N, [this, R, &N, &OS](ArrayRef<Record *> TS, const Twine &ID) {
+    auto Args = R->getValueAsListOfDefs("Args");
+
+    OS << "bool EvalEmitter::emit" << ID << "(";
+    for (size_t I = 0, N = Args.size(); I < N; ++I)
+      OS << "const " << Args[I]->getValueAsString("Name") << " &A" << I << ",";
+    OS << "const SourceInfo &L) {\n";
+    OS << "if (!isActive()) return true;\n";
+    OS << "CurrentSource = L;\n";
+
+    OS << "return " << N;
+    PrintTypes(OS, TS);
+    OS << "(S, OpPC";
+    for (size_t I = 0, N = Args.size(); I < N; ++I)
+      OS << ", A" << I;
+    OS << ");\n";
+    OS << "}\n";
+  });
+
+  OS << "#endif\n";
+}
+
+void ClangOpcodesEmitter::PrintTypes(raw_ostream &OS, ArrayRef<Record *> Types) {
+  if (Types.empty())
+    return;
+  OS << "<";
+  for (size_t I = 0, N = Types.size(); I < N; ++I) {
+    if (I != 0)
+      OS << ", ";
+    OS << "PT_" << Types[I]->getName();
+  }
+  OS << ">";
+}
+
+namespace clang {
+
+void EmitClangOpcodes(RecordKeeper &Records, raw_ostream &OS) {
+  ClangOpcodesEmitter(Records).run(OS);
+}
+
+} // end namespace clang
diff --git a/clang/utils/TableGen/TableGen.cpp b/clang/utils/TableGen/TableGen.cpp
--- a/clang/utils/TableGen/TableGen.cpp
+++ b/clang/utils/TableGen/TableGen.cpp
@@ -47,6 +47,7 @@
   GenClangCommentNodes,
   GenClangDeclNodes,
   GenClangStmtNodes,
+  GenClangOpcodes,
   GenClangSACheckers,
   GenClangCommentHTMLTags,
   GenClangCommentHTMLTagsProperties,
@@ -129,6 +130,8 @@
                    "Generate Clang AST declaration nodes"),
         clEnumValN(GenClangStmtNodes, "gen-clang-stmt-nodes",
                    "Generate Clang AST statement nodes"),
+        clEnumValN(GenClangOpcodes, "gen-clang-opcodes",
+                   "Generate Clang constexpr interpreter opcodes"),
         clEnumValN(GenClangSACheckers, "gen-clang-sa-checkers",
                    "Generate Clang Static Analyzer checkers"),
         clEnumValN(GenClangCommentHTMLTags, "gen-clang-comment-html-tags",
@@ -251,6 +254,9 @@
   case GenClangStmtNodes:
     EmitClangASTNodes(Records, OS, "Stmt", "");
     break;
+  case GenClangOpcodes:
+    EmitClangOpcodes(Records, OS);
+    break;
   case GenClangSACheckers:
     EmitClangSACheckers(Records, OS);
     break;
diff --git a/clang/utils/TableGen/TableGenBackends.h b/clang/utils/TableGen/TableGenBackends.h
--- a/clang/utils/TableGen/TableGenBackends.h
+++ b/clang/utils/TableGen/TableGenBackends.h
@@ -77,6 +77,7 @@
                                  llvm::raw_ostream &OS);
 void EmitClangCommentCommandList(llvm::RecordKeeper &Records,
                                  llvm::raw_ostream &OS);
+void EmitClangOpcodes(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
 void EmitNeon(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitFP16(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);