[ConstExprPreter] Implemented function calls and if statements

[nand]

Summary

Added support for compiling functions, function calls and if statements,
enabling minimal useful expressions such as the ones in cond.cpp.

Also removed instructions which were accidentally comitted in the previous patch.

The patch also reorganises some files - interpreter is not in InterpLoop.cpp,
while the opcodes are defined in Interp.h or in the Opcodes folder.

[nand]

removed unnecessary braces

[nand]

ping

[nand]

ping

[nand]

ping

[nand]

ping

[nand]

ping

[nand]

rebase

[nand]

ping

[nand]

ping

[nand]

ping

clang/lib/AST/CMakeLists.txt

add_clang_library(clangAST
   ExprConcepts.cpp
   ExprConstant.cpp
   ExprCXX.cpp
   ExprObjC.cpp
   ExternalASTMerger.cpp
   ExternalASTSource.cpp
   FormatString.cpp
   InheritViz.cpp
+  Interp/Boolean.cpp
   Interp/ByteCodeEmitter.cpp
   Interp/ByteCodeExprGen.cpp
   Interp/ByteCodeGenError.cpp
   Interp/ByteCodeStmtGen.cpp
   Interp/Context.cpp
   Interp/Descriptor.cpp
   Interp/Disasm.cpp
   Interp/EvalEmitter.cpp
   Interp/Frame.cpp
   Interp/Function.cpp
-  Interp/Interp.cpp
+  Interp/InterpLoop.cpp
   Interp/InterpBlock.cpp
   Interp/InterpFrame.cpp
+  Interp/InterpHelper.cpp
   Interp/InterpStack.cpp
   Interp/InterpState.cpp
   Interp/Pointer.cpp
   Interp/PrimType.cpp
   Interp/Program.cpp
   Interp/Record.cpp
   Interp/Source.cpp
   Interp/State.cpp

clang/lib/AST/Interp/Boolean.h

 //===--- Boolean.h - Wrapper for boolean 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_INTERP_BOOLEAN_H
 #define LLVM_CLANG_AST_INTERP_BOOLEAN_H
 
 #include <cstddef>
 #include <cstdint>
-#include "Integral.h"
+#include "CmpResult.h"
 #include "clang/AST/APValue.h"
 #include "clang/AST/ComparisonCategories.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace interp {
 
+template <unsigned Bits, bool Signed> class Integral;
+template <bool Signed> class FixedIntegral;
+
 /// Wrapper around boolean types.
 class Boolean {
  private:
   /// Underlying boolean.
   bool V;
 
   /// Construct a wrapper from a boolean.
   explicit Boolean(bool V) : V(V) {}
 
  public:
   /// Zero-initializes a boolean.
   Boolean() : V(false) {}
 
+  /// Initializes a boolean from an APSInt.
+  explicit Boolean(const llvm::APSInt &V) : V(V != 0) {}
+
   bool operator<(Boolean RHS) const { return V < RHS.V; }
   bool operator>(Boolean RHS) const { return V > RHS.V; }
   bool operator<=(Boolean RHS) const { return V <= RHS.V; }
   bool operator>=(Boolean RHS) const { return V >= RHS.V; }
   bool operator==(Boolean RHS) const { return V == RHS.V; }
   bool operator!=(Boolean RHS) const { return V != RHS.V; }
 
   bool operator>(unsigned RHS) const { return static_cast<unsigned>(V) > RHS; }
 
-  Boolean operator-() const { return Boolean(V); }
+  Boolean operator+(Boolean RHS) const { return Boolean(V | RHS.V); }
+  Boolean operator-(Boolean RHS) const { return Boolean(V ^ RHS.V); }
+  Boolean operator*(Boolean RHS) const { return Boolean(V & RHS.V); }
+  Boolean operator/(Boolean RHS) const { return Boolean(V); }
+  Boolean operator%(Boolean RHS) const { return Boolean(V % RHS.V); }
+  Boolean operator&(Boolean RHS) const { return Boolean(V & RHS.V); }
+  Boolean operator|(Boolean RHS) const { return Boolean(V | RHS.V); }
+  Boolean operator^(Boolean RHS) const { return Boolean(V ^ RHS.V); }
+
+  Boolean operator-() const { return *this; }
   Boolean operator~() const { return Boolean(true); }
 
+  Boolean operator>>(unsigned RHS) const { return Boolean(V && RHS == 0); }
+  Boolean operator<<(unsigned RHS) const { return *this; }
+
   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(1, static_cast<uint64_t>(V), false), true);
+  llvm::APSInt toAPSInt() const {
+    return llvm::APSInt(llvm::APInt(1, static_cast<uint64_t>(V), false), true);
   }
-  APSInt toAPSInt(unsigned NumBits) const {
-    return APSInt(toAPSInt().zextOrTrunc(NumBits), true);
+  llvm::APSInt toAPSInt(unsigned NumBits) const {
+    return llvm::APSInt(toAPSInt().zextOrTrunc(NumBits), true);
   }
   APValue toAPValue() const { return APValue(toAPSInt()); }
 
   Boolean toUnsigned() const { return *this; }
 
   constexpr static unsigned bitWidth() { return true; }
   bool isZero() const { return !V; }
+  bool isTrue() const { return !isZero(); }
+  bool isFalse() const { return isZero(); }
   bool isMin() const { return isZero(); }
 
   constexpr static bool isMinusOne() { return false; }
 
   constexpr static bool isSigned() { return false; }
 
   constexpr static bool isNegative() { return false; }
   constexpr static bool isPositive() { return !isNegative(); }
 
-  ComparisonCategoryResult compare(const Boolean &RHS) const {
-    return Compare(V, RHS.V);
+  CmpResult compare(const Boolean &RHS) const {
+    if (!V && RHS.V)
+      return CmpResult::Less;
+    if (V && !RHS.V)
+      return CmpResult::Greater;
+    return CmpResult::Equal;
   }
 
   unsigned countLeadingZeros() const { return V ? 0 : 1; }
 
   Boolean truncate(unsigned TruncBits) const { return *this; }
 
   void print(llvm::raw_ostream &OS) const { OS << (V ? "true" : "false"); }
 
   static Boolean min(unsigned NumBits) { return Boolean(false); }
   static Boolean max(unsigned NumBits) { return Boolean(true); }
 
   template <typename T>
   static std::enable_if_t<std::is_integral<T>::value, Boolean> from(T Value) {
     return Boolean(Value != 0);
   }
 
   template <unsigned SrcBits, bool SrcSign>
-  static std::enable_if_t<SrcBits != 0, Boolean>
-  from(Integral<SrcBits, SrcSign> Value) {
-    return Boolean(!Value.isZero());
-  }
+  static Boolean from(const Integral<SrcBits, SrcSign> &Value);
 
   template <bool SrcSign>
-  static Boolean from(Integral<0, SrcSign> Value) {
-    return Boolean(!Value.isZero());
-  }
+  static Boolean from(const FixedIntegral<SrcSign> &I);
+
+  static Boolean from(Boolean Value) { return Value; }
 
-  static Boolean zero() { return from(false); }
+  static Boolean zero() { return Boolean(false); }
 
   template <typename T>
   static Boolean from(T Value, unsigned NumBits) {
     return Boolean(Value);
   }
 
   static bool inRange(int64_t Value, unsigned NumBits) {
     return Value == 0 || Value == 1;
   }
 
   static bool increment(Boolean A, Boolean *R) {
     *R = Boolean(true);
     return false;
   }
 
   static bool decrement(Boolean A, Boolean *R) {
     llvm_unreachable("Cannot decrement booleans");
   }
 
   static bool add(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
-    *R = Boolean(A.V || B.V);
+    *R = Boolean(A.V | B.V);
     return false;
   }
 
   static bool sub(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
     *R = Boolean(A.V ^ B.V);
     return false;
   }
 
   static bool mul(Boolean A, Boolean B, unsigned OpBits, Boolean *R) {
-    *R = Boolean(A.V && B.V);
+    *R = Boolean(A.V & B.V);
     return false;
   }
 };
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Boolean &B) {
   B.print(OS);
   return OS;
 }
 
 }  // namespace interp
 }  // namespace clang
 
 #endif

clang/lib/AST/Interp/Boolean.cpp

+//===--- Boolean.cpp - Wrapper for boolean types ----------------*- 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
+//
+//===----------------------------------------------------------------------===//

clang/lib/AST/Interp/ByteCodeEmitter.h

protected:
   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) {}
+  ByteCodeEmitter(Context &Ctx, Program &P, State &S) : Ctx(Ctx), P(P) {}
 
   virtual ~ByteCodeEmitter() {}
 
   /// Define a label.
   void emitLabel(LabelTy Label);
   /// Create a label.
   LabelTy getLabel() { return ++NextLabel; }
 

clang/lib/AST/Interp/ByteCodeExprGen.h

 
 namespace interp {
 class Function;
 class State;
 
 template <class Emitter> class LocalScope;
 template <class Emitter> class RecordScope;
 template <class Emitter> class VariableScope;
-template <class Emitter> class DeclScope;
 template <class Emitter> class OptionScope;
 
 /// Compilation context for expressions.
 template <class Emitter>
 class ByteCodeExprGen : public ConstStmtVisitor<ByteCodeExprGen<Emitter>, bool>,
                         public Emitter {
 protected:
   // Emitters for opcodes of various arities.
   using NullaryFn = bool (ByteCodeExprGen::*)(const SourceInfo &);
   using UnaryFn = bool (ByteCodeExprGen::*)(PrimType, const SourceInfo &);
   using BinaryFn = bool (ByteCodeExprGen::*)(PrimType, PrimType,
                                              const SourceInfo &);
 
   // Aliases for types defined in the emitter.
   using LabelTy = typename Emitter::LabelTy;
   using AddrTy = typename Emitter::AddrTy;
 
   // Reference to a function generating the pointer of an initialized object.s
   using InitFnRef = std::function<bool()>;
 
   /// Current compilation context.
   Context &Ctx;
   /// Program to link to.
   Program &P;
+  /// Execution state.
+  State &S;
 
 public:
   /// Initializes the compiler and the backend emitter.
   template <typename... Tys>
-  ByteCodeExprGen(Context &Ctx, Program &P, Tys &&... Args)
-      : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
+  ByteCodeExprGen(Context &Ctx, Program &P, State &S, Tys &&... Args)
+      : Emitter(Ctx, P, S, Args...), Ctx(Ctx), P(P), S(S) {}
 
   // Expression visitors - result returned on stack.
+  bool VisitDeclRefExpr(const DeclRefExpr *E);
   bool VisitCastExpr(const CastExpr *E);
+  bool VisitConstantExpr(const ConstantExpr *E);
   bool VisitIntegerLiteral(const IntegerLiteral *E);
   bool VisitParenExpr(const ParenExpr *E);
   bool VisitBinaryOperator(const BinaryOperator *E);
+  bool VisitUnaryMinus(const UnaryOperator *E);
+  bool VisitCallExpr(const CallExpr *E);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();
 
-  /// 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);
-  Record *getRecord(const RecordDecl *RD);
-
   /// Returns the size int bits of an integer.
   unsigned getIntWidth(QualType Ty) {
-    auto &ASTContext = Ctx.getASTContext();
-    return ASTContext.getIntWidth(Ty);
+    return Ctx.getASTContext().getIntWidth(Ty);
   }
-
   /// Returns the value of CHAR_BIT.
   unsigned getCharBit() const {
-    auto &ASTContext = Ctx.getASTContext();
-    return ASTContext.getTargetInfo().getCharWidth();
+    return Ctx.getASTContext().getTargetInfo().getCharWidth();
+  }
+
+  /// Canonicalizes an array type.
+  const ConstantArrayType *getAsConstantArrayType(QualType AT) {
+    return Ctx.getASTContext().getAsConstantArrayType(AT);
   }
 
   /// Classifies a type.
   llvm::Optional<PrimType> classify(const Expr *E) const {
     return E->isGLValue() ? PT_Ptr : classify(E->getType());
   }
   llvm::Optional<PrimType> classify(QualType Ty) const {
     return Ctx.classify(Ty);
   }
 
   /// Checks if a pointer needs adjustment.
   bool needsAdjust(QualType Ty) const {
+    // TODO: member pointers and functions do not need adjustment.
     return true;
   }
 
   /// Classifies a known primitive type
   PrimType classifyPrim(QualType Ty) const {
     if (auto T = classify(Ty)) {
       return *T;
     }
     llvm_unreachable("not a primitive type");
   }
 
   /// Evaluates an expression for side effects and discards the result.
   bool discard(const Expr *E);
   /// Evaluates an expression and places result on stack.
   bool visit(const Expr *E);
-  /// Compiles an initializer for a local.
-  bool visitInitializer(const Expr *E, InitFnRef GenPtr);
 
   /// Visits an expression and converts it to a boolean.
   bool visitBool(const Expr *E);
 
-  /// Visits an initializer for a local.
-  bool visitLocalInitializer(const Expr *Init, unsigned I) {
-    return visitInitializer(Init, [this, I, Init] {
-      return this->emitGetPtrLocal(I, Init);
-    });
-  }
-
-  /// Visits an initializer for a global.
-  bool visitGlobalInitializer(const Expr *Init, unsigned I) {
-    return visitInitializer(Init, [this, I, Init] {
-      return this->emitGetPtrGlobal(I, Init);
-    });
-  }
-
-  /// Visits a delegated initializer.
-  bool visitThisInitializer(const Expr *I) {
-    return visitInitializer(I, [this, I] { return this->emitThis(I); });
-  }
-
   /// 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);
 
 private:
   friend class VariableScope<Emitter>;
   friend class LocalScope<Emitter>;
   friend class RecordScope<Emitter>;
-  friend class DeclScope<Emitter>;
   friend class OptionScope<Emitter>;
 
-  /// Emits a zero initializer.
-  bool visitZeroInitializer(PrimType T, const Expr *E);
+  /// Emits a direct function call.
+  bool emitFunctionCall(const FunctionDecl *Callee, llvm::Optional<PrimType> T,
+                        const Expr *Call);
 
   enum class DerefKind {
     /// Value is read and pushed to stack.
     Read,
     /// Direct method generates a value which is written. Returns pointer.
     Write,
     /// Direct method receives the value, pushes mutated value. Returns pointer.
     ReadWrite,
   };
 
   /// 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, DerefKind AK,
                    llvm::function_ref<bool(PrimType)> Direct,
                    llvm::function_ref<bool(PrimType)> Indirect);
-  bool dereferenceParam(const Expr *LV, PrimType T, const ParmVarDecl *PD,
+  bool dereferenceParam(const DeclRefExpr *LV, PrimType T, const ParmVarDecl *PD,
                         DerefKind AK,
                         llvm::function_ref<bool(PrimType)> Direct,
                         llvm::function_ref<bool(PrimType)> Indirect);
-  bool dereferenceVar(const Expr *LV, PrimType T, const VarDecl *PD,
+  bool dereferenceVar(const DeclRefExpr *LV, PrimType T, const VarDecl *PD,
                       DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
                       llvm::function_ref<bool(PrimType)> Indirect);
 
+  /// Converts an lvalue to an rvalue.
+  bool lvalueToRvalue(const Expr *LV, const Expr *E);
+
   /// 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);
   }
 
-  /// Returns a pointer to a variable declaration.
-  bool getPtrVarDecl(const VarDecl *VD, const Expr *E);
-
-  /// Returns the index of a global.
-  llvm::Optional<unsigned> getGlobalIdx(const VarDecl *VD);
+  /// Compiles a list of arguments.
+  bool visitArguments(QualType CalleeTy, ArrayRef<const Expr *> Args);
+  /// Compiles an argument.
+  bool visitArgument(const Expr *E, bool Discard);
 
   /// Emits the initialized pointer.
   bool emitInitFn() {
-    assert(InitFn && "missing initializer");
-    return (*InitFn)();
+    return InitFn ? (*InitFn)() : this->emitTrap(SourceInfo{});
   }
 
 protected:
   /// Variable to storage mapping.
   llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
 
-  /// OpaqueValueExpr to location mapping.
-  llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
-
   /// Current scope.
   VariableScope<Emitter> *VarScope = nullptr;
 
   /// Current argument index.
   llvm::Optional<uint64_t> ArrayIndex;
 
   /// Flag indicating if return value is to be discarded.
   bool DiscardResult = false;
 
   /// Expression being initialized.
   llvm::Optional<InitFnRef> InitFn = {};
+
+  /// Enumeration of initializer kinds.
+  enum class InitKind {
+    /// Regular invocation.
+    ROOT,
+    /// Base class initializer.
+    BASE,
+    /// Activates a union field.
+    UNION,
+  };
+
+  /// Initialiser kinds for the current object.
+  InitKind Initialiser = InitKind::ROOT;
+
+  /// Mapping from var decls to captured fields.
+  llvm::DenseMap<const VarDecl *, FieldDecl *> CaptureFields;
+  /// Override for 'this' captured by lambdas.
+  llvm::Optional<FieldDecl *> CaptureThis;
 };
 
 extern template class ByteCodeExprGen<ByteCodeEmitter>;
 extern template class ByteCodeExprGen<EvalEmitter>;
 
 /// Scope chain managing the variable lifetimes.
 template <class Emitter> class VariableScope {
 public:

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 //===--- ByteCodeExprGen.cpp - Code generator for expressions ---*- 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 "ByteCodeExprGen.h"
 #include "ByteCodeEmitter.h"
 #include "ByteCodeGenError.h"
 #include "Context.h"
 #include "Function.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "State.h"
+#include "clang/AST/RecordLayout.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 using APSInt = llvm::APSInt;
 template <typename T> using Expected = llvm::Expected<T>;
 template <typename T> using Optional = llvm::Optional<T>;
 
 namespace clang {
 namespace interp {
 
-/// Scope used to handle temporaries in toplevel variable declarations.
-template <class Emitter> class DeclScope final : public LocalScope<Emitter> {
-public:
-  DeclScope(ByteCodeExprGen<Emitter> *Ctx, const VarDecl *VD)
-      : LocalScope<Emitter>(Ctx), Scope(Ctx->P, VD) {}
-
-  void addExtended(const Scope::Local &Local) override {
-    return this->addLocal(Local);
-  }
-
-private:
-  Program::DeclScope Scope;
-};
-
 /// Scope used to handle initialization methods.
 template <class Emitter> class OptionScope {
 public:
   using InitFnRef = typename ByteCodeExprGen<Emitter>::InitFnRef;
+  using InitKind = typename ByteCodeExprGen<Emitter>::InitKind;
   using ChainedInitFnRef = std::function<bool(InitFnRef)>;
 
   /// Root constructor, compiling or discarding primitives.
   OptionScope(ByteCodeExprGen<Emitter> *Ctx, bool NewDiscardResult)
       : Ctx(Ctx), OldDiscardResult(Ctx->DiscardResult),
-        OldInitFn(std::move(Ctx->InitFn)) {
+        OldInitFn(std::move(Ctx->InitFn)),
+        OldInitialiser(Ctx->Initialiser) {
     Ctx->DiscardResult = NewDiscardResult;
     Ctx->InitFn = llvm::Optional<InitFnRef>{};
+    Ctx->Initialiser = InitKind::ROOT;
   }
 
   /// Root constructor, setting up compilation state.
-  OptionScope(ByteCodeExprGen<Emitter> *Ctx, InitFnRef NewInitFn)
+  OptionScope(ByteCodeExprGen<Emitter> *Ctx, InitFnRef NewInitFn,
+              InitKind NewInitialiser = InitKind::ROOT)
       : Ctx(Ctx), OldDiscardResult(Ctx->DiscardResult),
-        OldInitFn(std::move(Ctx->InitFn)) {
+        OldInitFn(std::move(Ctx->InitFn)),
+        OldInitialiser(Ctx->Initialiser) {
     Ctx->DiscardResult = true;
     Ctx->InitFn = NewInitFn;
+    Ctx->Initialiser = NewInitialiser;
   }
 
+  ~OptionScope() {
+    Ctx->DiscardResult = OldDiscardResult;
+    Ctx->InitFn = std::move(OldInitFn);
+    Ctx->Initialiser = OldInitialiser;
+  }
+
+protected:
   /// Extends the chain of initialisation pointers.
-  OptionScope(ByteCodeExprGen<Emitter> *Ctx, ChainedInitFnRef NewInitFn)
+  OptionScope(ByteCodeExprGen<Emitter> *Ctx, ChainedInitFnRef NewInitFn,
+              InitKind NewInitialiser)
       : Ctx(Ctx), OldDiscardResult(Ctx->DiscardResult),
-        OldInitFn(std::move(Ctx->InitFn)) {
+        OldInitFn(std::move(Ctx->InitFn)), OldInitialiser(Ctx->Initialiser) {
     assert(OldInitFn && "missing initializer");
     Ctx->InitFn = [this, NewInitFn] { return NewInitFn(*OldInitFn); };
-  }
-
-  ~OptionScope() {
-    Ctx->DiscardResult = OldDiscardResult;
-    Ctx->InitFn = std::move(OldInitFn);
+    Ctx->Initialiser = NewInitialiser;
   }
 
 private:
   /// Parent context.
   ByteCodeExprGen<Emitter> *Ctx;
   /// Old discard flag to restore.
   bool OldDiscardResult;
   /// Old pointer emitter to restore.
   llvm::Optional<InitFnRef> OldInitFn;
+  /// Base flag to restore.
+  InitKind OldInitialiser;
 };
 
 } // namespace interp
 } // namespace clang
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitDeclRefExpr(const DeclRefExpr *DE) {
+  if (DiscardResult)
+    return true;
+
+  if (auto *PD = dyn_cast<ParmVarDecl>(DE->getDecl())) {
+    QualType Ty = PD->getType();
+    auto It = this->Params.find(PD);
+    if (It == this->Params.end()) {
+      // Pointers to parameters are not constant expressions.
+      return this->emitTrap(DE);
+    } else {
+      // Generate a pointer to a parameter.
+      if (Ty->isReferenceType() || !classify(Ty))
+        return this->emitGetParamPtr(It->second, DE);
+      else
+        return this->emitGetPtrParam(It->second, DE);
+    }
+  }
+  if (auto *VD = dyn_cast<VarDecl>(DE->getDecl())) {
+    auto It = Locals.find(VD);
+    if (It == Locals.end()) {
+      // TODO: access globals.
+      return this->bail(DE);
+    } else {
+      // Generate a pointer to a local.
+      if (VD->getType()->isReferenceType())
+        return this->emitGetLocal(PT_Ptr, It->second.Offset, DE);
+      else
+        return this->emitGetPtrLocal(It->second.Offset, DE);
+    }
+  }
+  if (auto *ED = dyn_cast<EnumConstantDecl>(DE->getDecl())) {
+    QualType Ty = ED->getType();
+    if (Optional<PrimType> T = classify(Ty))
+      return this->emitConst(*T, getIntWidth(Ty), ED->getInitVal(), DE);
+    return false;
+  }
+  if (auto *BD = dyn_cast<BindingDecl>(DE->getDecl()))
+    return this->Visit(BD->getBinding());
+
+  // TODO: compile other decls.
+  return this->bail(DE);
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
   auto *SubExpr = CE->getSubExpr();
   switch (CE->getCastKind()) {
 
-  case CK_LValueToRValue: {
-    return dereference(
-        CE->getSubExpr(), DerefKind::Read,
-        [](PrimType) {
-          // Value loaded - nothing to do here.
-          return true;
-        },
-        [this, CE](PrimType T) {
-          // Pointer on stack - dereference it.
-          if (!this->emitLoadPop(T, CE))
-            return false;
-          return DiscardResult ? this->emitPop(T, CE) : true;
-        });
+  case CK_LValueToRValue:
+    return lvalueToRvalue(CE->getSubExpr(), CE);
+
+  case CK_IntegralToBoolean: {
+    if (DiscardResult)
+      return discard(SubExpr);
+
+    if (!visit(SubExpr))
+
+    return this->emitTest(*classify(SubExpr->getType()), CE);
+  }
+
+  case CK_IntegralCast: {
+    if (DiscardResult)
+      return discard(SubExpr);
+
+    if (!visit(SubExpr))
+      return false;
+
+    QualType ArgTy = SubExpr->getType();
+    QualType RetTy = CE->getType();
+    auto ArgT = *classify(ArgTy);
+    auto RetT = *classify(RetTy);
+    if (isFixedIntegral(RetT))
+      return this->bail(CE);
+    else
+      return this->emitCast(ArgT, RetT, CE);
+  }
+
+  case CK_PointerToBoolean: {
+    if (DiscardResult)
+      return discard(SubExpr);
+    if (!visit(SubExpr))
+      return false;
+    if (auto T = classify(SubExpr->getType()))
+      return this->emitTest(*T, CE);
+    return this->emitTrap(CE);
   }
 
   case CK_ArrayToPointerDecay:
   case CK_AtomicToNonAtomic:
   case CK_ConstructorConversion:
   case CK_FunctionToPointerDecay:
   case CK_NonAtomicToAtomic:
   case CK_NoOp:
   case CK_UserDefinedConversion:
     return this->Visit(SubExpr);
 
   case CK_ToVoid:
     return discard(SubExpr);
 
   default: {
     // TODO: implement other casts.
     return this->bail(CE);
   }
   }
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitConstantExpr(const ConstantExpr *CE) {
+  if (DiscardResult)
+    return true;
+
+  switch (CE->getResultStorageKind()) {
+    case ConstantExpr::RSK_Int64: {
+      if (!CE->isRValue())
+        return this->Visit(CE->getSubExpr());
+      QualType Ty = CE->getType();
+      PrimType T = *classify(Ty);
+      return this->emitConst(T, getIntWidth(Ty), CE->getResultAsAPSInt(), CE);
+    }
+
+    case ConstantExpr::RSK_APValue:
+      return this->bail(CE);
+
+    case ConstantExpr::RSK_None:
+      return this->Visit(CE->getSubExpr());
+  }
+  return false;
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitIntegerLiteral(const IntegerLiteral *LE) {
   if (DiscardResult)
     return true;
 
   auto Val = LE->getValue();
   QualType LitTy = LE->getType();
   if (Optional<PrimType> T = classify(LitTy))
     return emitConst(*T, getIntWidth(LitTy), LE->getValue(), LE);
-  return this->bail(LE);
+  return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitParenExpr(const ParenExpr *PE) {
   return this->Visit(PE->getSubExpr());
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitBinaryOperator(const BinaryOperator *BO) {
   const Expr *LHS = BO->getLHS();
   const Expr *RHS = BO->getRHS();
 
   // Deal with operations which have composite or void types.
   switch (BO->getOpcode()) {
+  case BO_PtrMemD:
+  case BO_PtrMemI:
+    return this->bail(BO);
+  case BO_Cmp:
+    return this->bail(BO);
   case BO_Comma:
     if (!discard(LHS))
       return false;
     if (!this->Visit(RHS))
       return false;
     return true;
   default:
     break;
   }
 
   // Typecheck the args.
   Optional<PrimType> LT = classify(LHS->getType());
   Optional<PrimType> RT = classify(RHS->getType());
-  if (!LT || !RT) {
+  Optional<PrimType> T = classify(BO->getType());
+  if (!LT || !RT || !T)
+    return this->bail(BO);
+
+  switch (BO->getOpcode()) {
+  case BO_Add: {
+    if (isPointer(*LT) && !isPointer(*RT))
       return this->bail(BO);
+    if (isPointer(*RT) && !isPointer(*LT))
+      return this->bail(BO);
+    break;
+  }
+  case BO_Sub: {
+    if (isPointer(*LT) && isPointer(*RT))
+      return this->bail(BO);
+    if (isPointer(*LT) && isPointer(*RT))
+      return this->bail(BO);
+    break;
+  }
+
+  case BO_LOr:
+  case BO_LAnd:
+    return this->bail(BO);
+
+  default:
+    break;
   }
 
-  if (Optional<PrimType> T = classify(BO->getType())) {
-    if (!visit(LHS))
-      return false;
-    if (!visit(RHS))
-      return false;
 
-    auto Discard = [this, T, BO](bool Result) {
-      if (!Result)
-        return false;
-      return DiscardResult ? this->emitPop(*T, BO) : true;
-    };
 
-    switch (BO->getOpcode()) {
-    case BO_EQ:
-      return Discard(this->emitEQ(*LT, BO));
-    case BO_NE:
-      return Discard(this->emitNE(*LT, BO));
-    case BO_LT:
-      return Discard(this->emitLT(*LT, BO));
-    case BO_LE:
-      return Discard(this->emitLE(*LT, BO));
-    case BO_GT:
-      return Discard(this->emitGT(*LT, BO));
-    case BO_GE:
-      return Discard(this->emitGE(*LT, BO));
-    case BO_Sub:
-      return Discard(this->emitSub(*T, BO));
-    case BO_Add:
-      return Discard(this->emitAdd(*T, BO));
-    case BO_Mul:
-      return Discard(this->emitMul(*T, BO));
-    default:
-      return this->bail(BO);
-    }
-  }
+  case BO_EQ: return Discard(this->emitEQ(*LT, *T, BO));
+  case BO_NE: return Discard(this->emitNE(*LT, *T, BO));
+  case BO_LT: return Discard(this->emitLT(*LT, *T, BO));
+  case BO_LE: return Discard(this->emitLE(*LT, *T, BO));
+  case BO_GT: return Discard(this->emitGT(*LT, *T, BO));
+  case BO_GE: return Discard(this->emitGE(*LT, *T, BO));
+  case BO_Sub: return Discard(this->emitSub(*T, BO));
+  case BO_Add: return Discard(this->emitAdd(*T, BO));
 
-  return this->bail(BO);
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryMinus(const UnaryOperator *UM) {
+  if (!visit(UM->getSubExpr()))
+    return false;
+
+  if (Optional<PrimType> T = classify(UM->getType())) {
+    if (!this->emitMinus(*T, UM))
+      return false;
+    return DiscardResult ? this->emitPop(*T, UM) : true;
+  }
+
+  return this->bail(UM);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCallExpr(const CallExpr *CE) {
+  // Emit the pointer to build the return value into.
+  if (InitFn && !emitInitFn())
+    return false;
+
+  auto Args = llvm::makeArrayRef(CE->getArgs(), CE->getNumArgs());
+  auto T = classify(CE->getCallReturnType(Ctx.getASTContext()));
+
+  // Emit the call.
+  if (unsigned BuiltinOp = CE->getBuiltinCallee()) {
+    // TODO: implement builtins.
+    return this->bail(CE);
+  } else if (const FunctionDecl *Callee = CE->getDirectCallee()) {
+    // Emit a direct call if the callee is known.
+    if (isa<CXXMethodDecl>(Callee) && !Callee->isStatic()) {
+      return this->bail(CE);
+    } else {
+      // Lower arguments.
+      if (!visitArguments(CE->getCallee()->getType(), Args))
+        return false;
+      return emitFunctionCall(Callee, T, CE);
+    }
+  } else {
+    // TODO: implement indirect calls.
+    return this->bail(CE);
+  }
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::emitFunctionCall(const FunctionDecl *Callee,
+                                                Optional<PrimType> T,
+                                                const Expr *E) {
+  if (Expected<Function *> Func = P.getOrCreateFunction(S, Callee)) {
+    if (*Func) {
+      if (!this->emitCall(*Func, E))
+        return false;
+    } else {
+      if (!this->emitNoCall(Callee, E))
+        return false;
+    }
+  } else {
+    consumeError(Func.takeError());
+    return this->bail(E);
+  }
+  return DiscardResult && T ? this->emitPop(*T, E) : true;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
+  QualType Ty = E->getType();
+  if (Ty->isVoidType() || !E->isRValue() || classify(Ty)) {
     OptionScope<Emitter> Scope(this, /*discardResult=*/true);
     return this->Visit(E);
   }
+  // TODO: implement composite initializers.
+  return this->bail(E);
+}
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visit(const Expr *E) {
+  if (!E->isRValue() || classify(E->getType())) {
     OptionScope<Emitter> Scope(this, /*discardResult=*/false);
     return this->Visit(E);
   }
+  // TODO: complex value initializers.
+  return this->bail(E);
+}
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visitBool(const Expr *E) {
   if (Optional<PrimType> T = classify(E->getType())) {
-    return visit(E);
+    if (!visit(E))
+      return false;
+    return (*T != PT_Bool) ? this->emitTest(*T, E) : true;
   } else {
     return this->bail(E);
   }
 }
 
 template <class Emitter>
-bool ByteCodeExprGen<Emitter>::visitZeroInitializer(PrimType T, const Expr *E) {
-  switch (T) {
-  case PT_Bool:
-    return this->emitZeroBool(E);
-  case PT_Sint8:
-    return this->emitZeroSint8(E);
-  case PT_Uint8:
-    return this->emitZeroUint8(E);
-  case PT_Sint16:
-    return this->emitZeroSint16(E);
-  case PT_Uint16:
-    return this->emitZeroUint16(E);
-  case PT_Sint32:
-    return this->emitZeroSint32(E);
-  case PT_Uint32:
-    return this->emitZeroUint32(E);
-  case PT_Sint64:
-    return this->emitZeroSint64(E);
-  case PT_Uint64:
-    return this->emitZeroUint64(E);
-  case PT_Ptr:
-    return this->emitNullPtr(E);
-  }
-  llvm_unreachable("unknown primitive type");
-}
-
-template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereference(
     const Expr *LV, DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
     llvm::function_ref<bool(PrimType)> Indirect) {
   if (Optional<PrimType> T = classify(LV->getType())) {
     if (!LV->refersToBitField()) {
       // Only primitive, non bit-field types can be dereferenced directly.
       if (auto *DE = dyn_cast<DeclRefExpr>(LV)) {
         if (!DE->getDecl()->getType()->isReferenceType()) {
           if (auto *PD = dyn_cast<ParmVarDecl>(DE->getDecl()))
-            return dereferenceParam(LV, *T, PD, AK, Direct, Indirect);
+            return dereferenceParam(DE, *T, PD, AK, Direct, Indirect);
           if (auto *VD = dyn_cast<VarDecl>(DE->getDecl()))
-            return dereferenceVar(LV, *T, VD, AK, Direct, Indirect);
-        }
+            return dereferenceVar(DE, *T, VD, AK, Direct, Indirect);
+        }
+      if (auto *ME = dyn_cast<MemberExpr>(LV)) {
+        if (!ME->getMemberDecl()->getType()->isReferenceType())
+          return this->bail(LV);
       }
     }
 
     if (!visit(LV))
       return false;
     return Indirect(*T);
   }
 
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereferenceParam(
-    const Expr *LV, PrimType T, const ParmVarDecl *PD, DerefKind AK,
+    const DeclRefExpr *LV, PrimType T, const ParmVarDecl *PD, DerefKind AK,
     llvm::function_ref<bool(PrimType)> Direct,
     llvm::function_ref<bool(PrimType)> Indirect) {
   auto It = this->Params.find(PD);
   if (It != this->Params.end()) {
     unsigned Idx = It->second;
     switch (AK) {
     case DerefKind::Read:
       return DiscardResult ? true : this->emitGetParam(T, Idx, LV);
case DerefKind::ReadWrite:
         return false;
       if (!this->emitSetParam(T, Idx, LV))
         return false;
       return DiscardResult ? true : this->emitGetPtrParam(Idx, LV);
     }
     return true;
   }
 
-  // If the param is a pointer, we can dereference a dummy value.
-  if (!DiscardResult && T == PT_Ptr && AK == DerefKind::Read) {
-    if (auto Idx = P.getOrCreateDummy(PD))
-      return this->emitGetPtrGlobal(*Idx, PD);
-    return false;
-  }
-
-  // Value cannot be produced - try to emit pointer and do stuff with it.
-  return visit(LV) && Indirect(T);
+  // TODO: try to produce a pointer to read from/write to.
+  return this->bail(LV);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereferenceVar(
-    const Expr *LV, PrimType T, const VarDecl *VD, DerefKind AK,
+    const DeclRefExpr *LV, PrimType T, const VarDecl *VD, DerefKind AK,
     llvm::function_ref<bool(PrimType)> Direct,
     llvm::function_ref<bool(PrimType)> Indirect) {
   auto It = Locals.find(VD);
   if (It != Locals.end()) {
     const auto &L = It->second;
     switch (AK) {
     case DerefKind::Read:
       if (!this->emitGetLocal(T, L.Offset, LV))
case DerefKind::ReadWrite:
       if (!this->emitGetLocal(T, L.Offset, LV))
         return false;
       if (!Direct(T))
         return false;
       if (!this->emitSetLocal(T, L.Offset, LV))
         return false;
       return DiscardResult ? true : this->emitGetPtrLocal(L.Offset, LV);
     }
-  } else if (auto Idx = getGlobalIdx(VD)) {
-    switch (AK) {
-    case DerefKind::Read:
-      if (!this->emitGetGlobal(T, *Idx, LV))
-        return false;
-      return DiscardResult ? this->emitPop(T, LV) : true;
-
-    case DerefKind::Write:
-      if (!Direct(T))
-        return false;
-      if (!this->emitSetGlobal(T, *Idx, LV))
-        return false;
-      return DiscardResult ? true : this->emitGetPtrGlobal(*Idx, LV);
-
-    case DerefKind::ReadWrite:
-      if (!this->emitGetGlobal(T, *Idx, LV))
-        return false;
-      if (!Direct(T))
-        return false;
-      if (!this->emitSetGlobal(T, *Idx, LV))
-        return false;
-      return DiscardResult ? true : this->emitGetPtrGlobal(*Idx, LV);
-    }
   }
 
-  // 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 (!DiscardResult && AK == DerefKind::Read) {
-    if (VD->hasLocalStorage() && VD->hasInit() && !VD->isConstexpr()) {
-      QualType VT = VD->getType();
-      if (VT.isConstQualified() && VT->isFundamentalType())
-        return this->Visit(VD->getInit());
-    }
-  }
+  // TODO: handle globals.
+  return this->bail(LV);
 
-  // Value cannot be produced - try to emit pointer.
-  return visit(LV) && Indirect(T);
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::lvalueToRvalue(const Expr *LV, const Expr *E) {
+  return dereference(
+      LV, DerefKind::Read,
+      [](PrimType) {
+        // Value loaded - nothing to do here.
+        return true;
+      },
+      [this, E](PrimType T) {
+        // Pointer on stack - dereference it.
+        return this->emitLoadPop(T, E);
+      });
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::emitConst(PrimType T, unsigned NumBits,
                                          const APInt &Value, const Expr *E) {
   switch (T) {
   case PT_Sint8:
     return this->emitConstSint8(Value.getSExtValue(), E);
unsigned ByteCodeExprGen<Emitter>::allocateLocalPrimitive(DeclTy &&Src,
   Scope::Local Local = this->createLocal(D);
   if (auto *VD = dyn_cast_or_null<ValueDecl>(Src.dyn_cast<const Decl *>()))
     Locals.insert({VD, Local});
   VarScope->add(Local, IsExtended);
   return Local.Offset;
 }
 
 template <class Emitter>
-llvm::Optional<unsigned>
-ByteCodeExprGen<Emitter>::allocateLocal(DeclTy &&Src, bool IsExtended) {
-  QualType Ty;
-
-  const ValueDecl *Key = nullptr;
-  bool IsTemporary = false;
-  if (auto *VD = dyn_cast_or_null<ValueDecl>(Src.dyn_cast<const Decl *>())) {
-    Key = VD;
-    Ty = VD->getType();
-  }
-  if (auto *E = Src.dyn_cast<const Expr *>()) {
-    IsTemporary = true;
-    Ty = E->getType();
-  }
-
-  Descriptor *D = P.createDescriptor(Src, Ty.getTypePtr(),
-                                     Ty.isConstQualified(), IsTemporary);
-  if (!D)
-    return {};
-
-  Scope::Local Local = this->createLocal(D);
-  if (Key)
-    Locals.insert({Key, Local});
-  VarScope->add(Local, IsExtended);
-  return Local.Offset;
-}
-
-template <class Emitter>
-bool ByteCodeExprGen<Emitter>::visitInitializer(
-    const Expr *Init, InitFnRef InitFn) {
-  OptionScope<Emitter> Scope(this, InitFn);
-  return this->Visit(Init);
-}
-
-template <class Emitter>
-bool ByteCodeExprGen<Emitter>::getPtrVarDecl(const VarDecl *VD, const Expr *E) {
-  // Generate a pointer to the local, loading refs.
-  if (Optional<unsigned> Idx = getGlobalIdx(VD)) {
-    if (VD->getType()->isReferenceType())
-      return this->emitGetGlobalPtr(*Idx, E);
-    else
-      return this->emitGetPtrGlobal(*Idx, E);
-  }
-  return this->bail(VD);
-}
-
-template <class Emitter>
-llvm::Optional<unsigned>
-ByteCodeExprGen<Emitter>::getGlobalIdx(const VarDecl *VD) {
-  if (VD->isConstexpr()) {
-    // Constexpr decl - it must have already been defined.
-    return P.getGlobal(VD);
-  }
-  if (!VD->hasLocalStorage()) {
-    // Not constexpr, but a global var - can have pointer taken.
-    Program::DeclScope Scope(P, VD);
-    return P.getOrCreateGlobal(VD);
-  }
-  return {};
+bool ByteCodeExprGen<Emitter>::visitArguments(QualType CalleeTy,
+                                              ArrayRef<const Expr *> Args) {
+  if (auto *MemberTy = CalleeTy->getAs<MemberPointerType>())
+    CalleeTy = MemberTy->getPointeeType();
+  if (auto *PtrTy = CalleeTy->getAs<PointerType>())
+    CalleeTy = PtrTy->getPointeeType();
+
+  if (auto *Ty = CalleeTy->getAs<FunctionProtoType>()) {
+    unsigned NumParams = Ty->getNumParams();
+    for (unsigned I = 0, N = Args.size(); I < N; ++I)
+      if (!visitArgument(Args[I], I >= NumParams))
+        return false;
+  } else {
+    for (unsigned I = 0, N = Args.size(); I < N; ++I)
+      if (!visitArgument(Args[I], /*discard=*/true))
+        return false;
   }
 
-template <class Emitter>
-const RecordType *ByteCodeExprGen<Emitter>::getRecordTy(QualType Ty) {
-  if (auto *PT = dyn_cast<PointerType>(Ty))
-    return PT->getPointeeType()->getAs<RecordType>();
-  else
-    return Ty->getAs<RecordType>();
+  return true;
 }
 
 template <class Emitter>
-Record *ByteCodeExprGen<Emitter>::getRecord(QualType Ty) {
-  if (auto *RecordTy = getRecordTy(Ty)) {
-    return getRecord(RecordTy->getDecl());
-  }
-  return nullptr;
-}
+bool ByteCodeExprGen<Emitter>::visitArgument(const Expr *E, bool Discard) {
+  // Primitive or pointer argument - leave it on the stack.
+  if (Optional<PrimType> T = classify(E))
+    return Discard ? discard(E) : visit(E);
 
-template <class Emitter>
-Record *ByteCodeExprGen<Emitter>::getRecord(const RecordDecl *RD) {
-  return P.getOrCreateRecord(RD);
+  // TODO: composite arguments.
+  return this->bail(E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visitExpr(const Expr *Exp) {
   ExprScope<Emitter> RootScope(this);
-  if (!visit(Exp))
-    return false;
-
-  if (Optional<PrimType> T = classify(Exp))
-    return this->emitRet(*T, Exp);
-  else
-    return this->emitRetValue(Exp);
-}
 
-template <class Emitter>
-bool ByteCodeExprGen<Emitter>::visitDecl(const VarDecl *VD) {
-  const Expr *Init = VD->getInit();
-
-  if (Optional<unsigned> I = P.createGlobal(VD)) {
-    if (Optional<PrimType> T = classify(VD->getType())) {
-      {
-        // Primitive declarations - compute the value and set it.
-        DeclScope<Emitter> LocalScope(this, VD);
-        if (!visit(Init))
-          return false;
-      }
+  if (Optional<PrimType> ExpTy = classify(Exp)) {
+    if (Exp->isGLValue()) {
+      // If the expression is an lvalue, dereference it.
+      if (!lvalueToRvalue(Exp, Exp))
 
-      // If the declaration is global, save the value for later use.
-      if (!this->emitDup(*T, VD))
-        return false;
-      if (!this->emitInitGlobal(*T, *I, VD))
-        return false;
-      return this->emitRet(*T, VD);
+      // Find the type of the expression.
+      PrimType Ty;
+      if (Optional<PrimType> T = classify(Exp->getType())) {
+        Ty = *T;
       } else {
-      {
-        // Composite declarations - allocate storage and initialize it.
-        DeclScope<Emitter> LocalScope(this, VD);
-        if (!visitGlobalInitializer(Init, *I))
-          return false;
+        Ty = PT_Ptr;
       }
 
-      // Return a pointer to the global.
-      if (!this->emitGetPtrGlobal(*I, VD))
+      return this->emitRet(Ty, Exp);
+    } else {
+      // Otherwise, simply evaluate the rvalue.
+      if (!visit(Exp))
         return false;
-      return this->emitRetValue(VD);
-    }
-  }
+      return this->emitRet(*ExpTy, Exp);
+    }
+  } else {
+    // TODO: implement composite initializers.
+    return this->bail(Exp);
 
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitDecl(const VarDecl *VD) {
+  // TODO: implement global declarations.
   return this->bail(VD);
 }
 
 template <class Emitter>
 void ByteCodeExprGen<Emitter>::emitCleanup() {
   for (VariableScope<Emitter> *C = VarScope; C; C = C->getParent())
     C->emitDestruction();
 }

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

 #include "ByteCodeEmitter.h"
 #include "ByteCodeGenError.h"
 #include "Context.h"
 #include "Function.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "State.h"
 #include "clang/Basic/LLVM.h"
+#include "clang/AST/ASTLambda.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 namespace clang {
 namespace interp {
 
 /// Scope managing label targets.
 template <class Emitter> class LabelScope {
 public:
-  virtual ~LabelScope() {  }
-
 protected:
   LabelScope(ByteCodeStmtGen<Emitter> *Ctx) : Ctx(Ctx) {}
+
   /// ByteCodeStmtGen instance.
   ByteCodeStmtGen<Emitter> *Ctx;
 };
 
 /// Sets the context for break/continue statements.
 template <class Emitter> class LoopScope final : public LabelScope<Emitter> {
 public:
   using LabelTy = typename ByteCodeStmtGen<Emitter>::LabelTy;

 } // namespace clang
 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitFunc(const FunctionDecl *F) {
   // Classify the return type.
   ReturnType = this->classify(F->getReturnType());
 
   // Set up fields and context if a constructor.
-  if (auto *MD = dyn_cast<CXXMethodDecl>(F))
+  if (auto *MD = dyn_cast<CXXMethodDecl>(F)) {
+    // TODO: implement constructor lowering
     return this->bail(MD);
+  }
 
   if (auto *Body = F->getBody())
     if (!visitStmt(Body))
       return false;
 
   // Emit a guard return to protect against a code path missing one.
   if (F->getReturnType()->isVoidType())
     return this->emitRetVoid(SourceInfo{});
if (const Expr *RE = RS->getRetValue()) {
     ExprScope<Emitter> RetScope(this);
     if (ReturnType) {
       // Primitive types are simply returned.
       if (!this->visit(RE))
         return false;
       this->emitCleanup();
       return this->emitRet(*ReturnType, RS);
     } else {
-      // RVO - construct the value in the return location.
-      auto ReturnLocation = [this, RE] { return this->emitGetParamPtr(0, RE); };
-      if (!this->visitInitializer(RE, ReturnLocation))
-        return false;
-      this->emitCleanup();
-      return this->emitRetVoid(RS);
+      // TODO: RVO - construct the value in the return location.
+      return this->bail(RS);
     }
   } else {
     this->emitCleanup();
     if (!this->emitRetVoid(RS))
       return false;
     return true;
   }
 }
if (Optional<PrimType> T = this->classify(DT)) {
     {
       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.
-    if (auto Off = this->allocateLocal(VD)) {
-      return this->visitLocalInitializer(VD->getInit(), *Off);
-    } else {
-      return this->bail(VD);
-    }
-  }
-}
+    // TODO: implement composite initialisers.
 
 namespace clang {
 namespace interp {
 
 template class ByteCodeStmtGen<ByteCodeEmitter>;
 
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/CmpResult.h

+//===--- CmpResult.h - Enumeration of comparison results --------*- 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_CMPRESULT_H
+#define LLVM_CLANG_AST_INTERP_CMPRESULT_H
+
+#include "clang/AST/ComparisonCategories.h"
+
+namespace clang {
+namespace interp {
+
+enum class CmpResult {
+  Unequal,
+  Less,
+  Equal,
+  Greater,
+  Unordered,
+};
+
+inline ComparisonCategoryResult ToCCR(CmpResult Result) {
+  switch (Result) {
+  case CmpResult::Unequal:
+    llvm_unreachable("should never produce Unequal for three-way comparison");
+  case CmpResult::Less:
+    return ComparisonCategoryResult::Less;
+  case CmpResult::Equal:
+    return ComparisonCategoryResult::Equal;
+  case CmpResult::Greater:
+    return ComparisonCategoryResult::Greater;
+  case CmpResult::Unordered:
+    return ComparisonCategoryResult::Unordered;
+  }
+  llvm_unreachable("invalid result");
+}
+
+} // namespace interp
+}  // namespace clang
+
+#endif
+

clang/lib/AST/Interp/Context.h

 //===----------------------------------------------------------------------===//
 
 #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 "clang/Basic/LangOptions.h"
 #include "llvm/ADT/PointerIntPair.h"
 
 namespace clang {
 class ASTContext;
 class LangOptions;
 class Stmt;
 class FunctionDecl;
 class VarDecl;
public:
   ASTContext &getASTContext() const { return Ctx; }
   /// Returns the language options.
   const LangOptions &getLangOpts() const;
   /// Returns the interpreter stack.
   InterpStack &getStack() { return Stk; }
   /// Returns CHAR_BIT.
   unsigned getCharBit() const;
 
+  /// Checks is language mode is OpenCL.
+  bool isOpenCL() { return getLangOpts().OpenCL; }
+  /// Checks is language mode is C++20.
+  bool isCPlusPlus2a() { return getLangOpts().CPlusPlus2a; }
+
   /// Classifies an expression.
   llvm::Optional<PrimType> classify(QualType T);
 
 private:
   /// Runs a function.
   bool Run(State &Parent, Function *Func, APValue &Result);
 
   /// Checks a result fromt the interpreter.

clang/lib/AST/Interp/Context.cpp

 //===--- 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 "ByteCodeEmitter.h"
 #include "ByteCodeExprGen.h"
 #include "ByteCodeStmtGen.h"
 #include "EvalEmitter.h"
-#include "Interp.h"
+#include "InterpLoop.h"
 #include "InterpFrame.h"
 #include "InterpStack.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "clang/AST/Expr.h"
 #include "clang/Basic/TargetInfo.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 Context::Context(ASTContext &Ctx) : Ctx(Ctx), P(new Program(*this)) {}
 
 Context::~Context() {}
 
 bool Context::isPotentialConstantExpr(State &Parent, const FunctionDecl *FD) {
   Function *Func = P->getFunction(FD);
   if (!Func) {
-    if (auto R = ByteCodeStmtGen<ByteCodeEmitter>(*this, *P).compileFunc(FD)) {
+    ByteCodeStmtGen<ByteCodeEmitter> C(*this, *P, Parent);
+    if (auto R = C.compileFunc(FD)) {
       Func = *R;
     } else {
       handleAllErrors(R.takeError(), [&Parent](ByteCodeGenError &Err) {
         Parent.FFDiag(Err.getLoc(), diag::err_experimental_clang_interp_failed);
       });
       return false;
     }
   }
bool Context::evaluateAsInitializer(State &Parent, const VarDecl *VD,
                                     APValue &Result) {
   ByteCodeExprGen<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() || T->isPointerType()) {
+  // Pointer type check.
+  if (T->isReferenceType())
+    return PT_Ptr;
+  if (T->isPointerType())
+    return PT_Ptr;
+  if (T->isNullPtrType())
     return PT_Ptr;
-  }
 
+  // Boolean check.
   if (T->isBooleanType())
     return PT_Bool;
 
+  // Signed integral type check.
   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;
     default:
       return {};
     }
   }
 
+  // Unsigned integral type check.
   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;
     default:
       return {};
     }
   }
 
-  if (T->isNullPtrType())
-    return PT_Ptr;
-
+  // Atomic types are simply unwrapped.
   if (auto *AT = dyn_cast<AtomicType>(T))
     return classify(AT->getValueType());
 
   return {};
 }
 
 unsigned Context::getCharBit() const {
   return Ctx.getTargetInfo().getCharWidth();

clang/lib/AST/Interp/Descriptor.h

 public:
   /// Token to denote structures of unknown size.
   struct UnknownSize {};
 
   /// Pointer to the record, if block contains records.
   Record *const ElemRecord = nullptr;
   /// Descriptor of the array element.
   Descriptor *const ElemDesc = nullptr;
+  /// Type of primitive elements.
+  llvm::Optional<PrimType> ElemTy = {};
   /// Flag indicating if the block is mutable.
   const bool IsConst = false;
   /// Flag indicating if a field 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;

clang/lib/AST/Interp/Descriptor.cpp

 
 static BlockMoveFn getMoveArrayPrim(PrimType Type) {
   COMPOSITE_TYPE_SWITCH(Type, return moveArrayTy<T>, return nullptr);
 }
 
 Descriptor::Descriptor(const DeclTy &D, PrimType Type, bool IsConst,
                        bool IsTemporary, bool IsMutable)
     : Source(D), ElemSize(primSize(Type)), Size(ElemSize), AllocSize(Size),
-      IsConst(IsConst), IsMutable(IsMutable), IsTemporary(IsTemporary),
-      CtorFn(getCtorPrim(Type)), DtorFn(getDtorPrim(Type)),
-      MoveFn(getMovePrim(Type)) {
+      ElemTy(Type), IsConst(IsConst), IsMutable(IsMutable),
+      IsTemporary(IsTemporary), CtorFn(getCtorPrim(Type)),
+      DtorFn(getDtorPrim(Type)), MoveFn(getMovePrim(Type)) {
   assert(Source && "Missing source");
 }
 
 Descriptor::Descriptor(const DeclTy &D, PrimType Type, size_t NumElems,
                        bool IsConst, bool IsTemporary, bool IsMutable)
     : Source(D), ElemSize(primSize(Type)), Size(ElemSize * NumElems),
-      AllocSize(align(Size) + sizeof(InitMap *)), IsConst(IsConst),
-      IsMutable(IsMutable), IsTemporary(IsTemporary), IsArray(true),
-      CtorFn(getCtorArrayPrim(Type)), DtorFn(getDtorArrayPrim(Type)),
-      MoveFn(getMoveArrayPrim(Type)) {
+      AllocSize(align(Size) + sizeof(InitMap *)), ElemTy(Type),
+      IsConst(IsConst), IsMutable(IsMutable), IsTemporary(IsTemporary),
+      IsArray(true), CtorFn(getCtorArrayPrim(Type)),
+      DtorFn(getDtorArrayPrim(Type)), MoveFn(getMoveArrayPrim(Type)) {
   assert(Source && "Missing source");
 }
 
 Descriptor::Descriptor(const DeclTy &D, PrimType Type, bool IsTemporary,
                        UnknownSize)
     : Source(D), ElemSize(primSize(Type)), Size(UnknownSizeMark),
-      AllocSize(alignof(void *)), IsConst(true), IsMutable(false),
+      AllocSize(alignof(void *)), ElemTy(Type), IsConst(true), IsMutable(false),
       IsTemporary(IsTemporary), IsArray(true), CtorFn(getCtorArrayPrim(Type)),
       DtorFn(getDtorArrayPrim(Type)), MoveFn(getMoveArrayPrim(Type)) {
   assert(Source && "Missing source");
 }
 
 Descriptor::Descriptor(const DeclTy &D, Descriptor *Elem, unsigned NumElems,
                        bool IsConst, bool IsTemporary, bool IsMutable)
     : Source(D), ElemSize(Elem->getAllocSize() + sizeof(InlineDescriptor)),

clang/lib/AST/Interp/EvalEmitter.h

private:
   /// 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; }
 
   /// Helper to invoke a method.
-  bool ExecuteCall(Function *F, Pointer &&This, const SourceInfo &Info);
+  bool executeCall(Function *F, Pointer &&This, const SourceInfo &Info);
   /// Helper to emit a diagnostic on a missing method.
-  bool ExecuteNoCall(const FunctionDecl *F, const SourceInfo &Info);
+  bool executeNoCall(const FunctionDecl *F, const SourceInfo &Info);
 
 protected:
 #define GET_EVAL_PROTO
 #include "Opcodes.inc"
 #undef GET_EVAL_PROTO
 };
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/EvalEmitter.cpp

 //===--- 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 "InterpHelper.h"
+#include "InterpLoop.h"
 #include "Opcode.h"
 #include "Program.h"
 #include "clang/AST/DeclCXX.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 using APSInt = llvm::APSInt;

 llvm::Expected<bool> EvalEmitter::interpretDecl(const VarDecl *VD) {
   if (this->visitDecl(VD))
     return true;
   if (BailLocation)
     return llvm::make_error<ByteCodeGenError>(*BailLocation);
   return false;
 }
 
-void EvalEmitter::emitLabel(LabelTy Label) {
-  CurrentLabel = Label;
-}
+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 = std::make_unique<char[]>(sizeof(Block) + D->getAllocSize());
   auto *B = new (Memory.get()) Block(D, /*isStatic=*/false);
   B->invokeCtor();

 
 bool EvalEmitter::fallthrough(const LabelTy &Label) {
   if (isActive())
     ActiveLabel = Label;
   CurrentLabel = Label;
   return true;
 }
 
-template <PrimType OpType> bool EvalEmitter::emitRet(const SourceInfo &Info) {
+bool EvalEmitter::emitCall(Function *Fn, const SourceInfo &Info) {
+  CurrentSource = 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::emitRetValue(const SourceInfo &Info) {
-  // Method to recursively traverse composites.
-  std::function<bool(QualType, const Pointer &, APValue &)> Composite;
-  Composite = [this, &Composite](QualType Ty, const Pointer &Ptr, APValue &R) {
-    if (auto *AT = Ty->getAs<AtomicType>())
-      Ty = AT->getValueType();
-
-    if (auto *RT = Ty->getAs<RecordType>()) {
-      auto *Record = Ptr.getRecord();
-      assert(Record && "Missing record descriptor");
-
-      bool Ok = true;
-      if (RT->getDecl()->isUnion()) {
-        const FieldDecl *ActiveField = nullptr;
-        APValue Value;
-        for (auto &F : Record->fields()) {
-          const Pointer &FP = Ptr.atField(F.Offset);
-          QualType FieldTy = F.Decl->getType();
-          if (FP.isActive()) {
-            if (llvm::Optional<PrimType> T = Ctx.classify(FieldTy)) {
-              TYPE_SWITCH(*T, Ok &= ReturnValue<T>(FP.deref<T>(), Value));
-            } else {
-              Ok &= Composite(FieldTy, FP, Value);
-            }
-            break;
-          }
-        }
-        R = APValue(ActiveField, Value);
-      } else {
-        unsigned NF = Record->getNumFields();
-        unsigned NB = Record->getNumBases();
-        unsigned NV = Ptr.isBaseClass() ? 0 : Record->getNumVirtualBases();
-
-        R = APValue(APValue::UninitStruct(), NB, NF);
-
-        for (unsigned I = 0; I < NF; ++I) {
-          const Record::Field *FD = Record->getField(I);
-          QualType FieldTy = FD->Decl->getType();
-          const Pointer &FP = Ptr.atField(FD->Offset);
-          APValue &Value = R.getStructField(I);
+  // Interpret the function in its own frame.
+  return executeCall(Fn, Pointer(), Info);
 
-          if (llvm::Optional<PrimType> T = Ctx.classify(FieldTy)) {
-            TYPE_SWITCH(*T, Ok &= ReturnValue<T>(FP.deref<T>(), Value));
-          } else {
-            Ok &= Composite(FieldTy, FP, Value);
-          }
-        }
-
-        for (unsigned I = 0; I < NB; ++I) {
-          const Record::Base *BD = Record->getBase(I);
-          QualType BaseTy = Ctx.getASTContext().getRecordType(BD->Decl);
-          const Pointer &BP = Ptr.atField(BD->Offset);
-          Ok &= Composite(BaseTy, BP, R.getStructBase(I));
-        }
-
-        for (unsigned I = 0; I < NV; ++I) {
-          const Record::Base *VD = Record->getVirtualBase(I);
-          QualType VirtBaseTy = Ctx.getASTContext().getRecordType(VD->Decl);
-          const Pointer &VP = Ptr.atField(VD->Offset);
-          Ok &= Composite(VirtBaseTy, VP, R.getStructBase(NB + I));
-        }
-      }
-      return Ok;
-    }
-    if (auto *AT = Ty->getAsArrayTypeUnsafe()) {
-      const size_t NumElems = Ptr.getNumElems();
-      QualType ElemTy = AT->getElementType();
-      R = APValue(APValue::UninitArray{}, NumElems, NumElems);
-
-      bool Ok = true;
-      for (unsigned I = 0; I < NumElems; ++I) {
-        APValue &Slot = R.getArrayInitializedElt(I);
-        const Pointer &EP = Ptr.atIndex(I);
-        if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {
-          TYPE_SWITCH(*T, Ok &= ReturnValue<T>(EP.deref<T>(), Slot));
-        } else {
-          Ok &= Composite(ElemTy, EP.narrow(), Slot);
-        }
-      }
-      return Ok;
-    }
-    llvm_unreachable("invalid value to return");
-  };
+template <PrimType OpType> bool EvalEmitter::emitRet(const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+  using T = typename PrimConv<OpType>::T;
+  return PrimitiveToValue<T>(S.Stk.pop<T>(), Result);
 
-  // Return the composite type.
-  const auto &Ptr = S.Stk.pop<Pointer>();
-  return Composite(Ptr.getType(), Ptr, Result);
-}
+bool EvalEmitter::emitRetVoid(const SourceInfo &Info) { return true; }
 
 bool EvalEmitter::emitGetPtrLocal(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()));
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;
 }
 
+bool EvalEmitter::emitNoCall(const FunctionDecl *F, const SourceInfo &Info) {
+  CurrentSource = Info;
+  if (!isActive())
+    return true;
+  return executeNoCall(F, Info);
+}
+
+bool EvalEmitter::executeCall(Function *F, Pointer &&This,
+                              const SourceInfo &Info) {
+  if (!S.CheckCallable(OpPC, F->getDecl()))
+    return false;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  S.Current = new InterpFrame(S, F, S.Current, OpPC, std::move(This));
+  return Interpret(S, Result);
+}
+
+bool EvalEmitter::executeNoCall(const FunctionDecl *F, const SourceInfo &Info) {
+  if (!S.CheckCallable(OpPC, F))
+    return false;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  if (S.getLangOpts().CPlusPlus11) {
+    S.FFDiag(Info, diag::note_constexpr_invalid_function, 1)
+        << F->isConstexpr() << (bool)dyn_cast<CXXConstructorDecl>(F) << F;
+    S.Note(F->getLocation(), diag::note_declared_at);
+  } else {
+    S.FFDiag(Info, diag::note_invalid_subexpr_in_const_expr);
+  }
+  return false;
+}
+
 //===----------------------------------------------------------------------===//
 // Opcode evaluators
 //===----------------------------------------------------------------------===//
 
 #define GET_EVAL_IMPL
 #include "Opcodes.inc"
 #undef GET_EVAL_IMPL

clang/lib/AST/Interp/Function.h

public:
   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]; }
 
+  /// Solves a call relocation.
+  void relocateCall(CodePtr Loc, Function *Callee);
+
   /// 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;
-
   /// Checks if the function is a constructor.
   bool isConstructor() const { return isa<CXXConstructorDecl>(F); }
 
+  /// Checks if the function was default.
+  bool isDefaulted() const { return F->isDefaulted(); }
+
 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,

clang/lib/AST/Interp/Function.cpp

 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;
 }
 
+void Function::relocateCall(CodePtr Loc, Function *Callee) {
+  using namespace llvm::support;
+
+  char *Ptr = Code.data() + (Loc - getCodeBegin());
+  const auto Addr = reinterpret_cast<uintptr_t>(Callee);
+  *(reinterpret_cast<Opcode *>(Ptr) - 1) = OP_Call;
+
+  endian::write<uintptr_t, endianness::native, 1>(Ptr, Addr);
+}
+
 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");
+  assert(It != SrcMap.end() && It->first == Offset);
   return It->second;
 }
-
-bool Function::isVirtual() const {
-  if (auto *M = dyn_cast<CXXMethodDecl>(F))
-    return M->isVirtual();
-  return false;
-}

clang/lib/AST/Interp/Integral.h

 //===--- 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_INTEGRAL_H
 #define LLVM_CLANG_AST_INTERP_INTEGRAL_H
 
-#include "clang/AST/ComparisonCategories.h"
+#include <cstddef>
+#include <cstdint>
+#include "Boolean.h"
 #include "clang/AST/APValue.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;
+CmpResult Compare(const T &X, const T &Y) {
+  if (X < Y) return CmpResult::Less;
+  if (X > Y) return CmpResult::Greater;
+  return CmpResult::Equal;
 }
 
 // Helper structure to select the representation.
-template <unsigned Bits, bool Signed> struct Repr;
-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; };
+template <unsigned Bits, bool Signed>
+struct Repr;
+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;
+};
 
 /// 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 {
+template <unsigned Bits, bool Signed>
+class Integral {
  private:
-  template <unsigned OtherBits, bool OtherSigned> friend class Integral;
+  template <unsigned OtherBits, bool OtherSigned>
+  friend class Integral;
 
   // The primitive representing the integral.
   using T = typename Repr<Bits, Signed>::Type;
   T V;
 
   /// Primitive representing limits.
-  static const auto Min = std::numeric_limits<T>::min();
-  static const auto Max = std::numeric_limits<T>::max();
+  static constexpr auto Min = std::numeric_limits<T>::min();
+  static constexpr auto Max = std::numeric_limits<T>::max();
 
   /// Construct an integral from anything that is convertible to storage.
-  template <typename T> explicit Integral(T V) : V(V) {}
+  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; }
public:
 
   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 {
+  CmpResult compare(const Integral &RHS) const {
     return Compare(V, RHS.V);
   }
 
-  unsigned countLeadingZeros() const { return llvm::countLeadingZeros<T>(V); }
+  unsigned countLeadingZeros() const {
+    return llvm::countLeadingZeros(toUnsigned().V);
+  }
 
   Integral truncate(unsigned TruncBits) const {
-    if (TruncBits >= Bits)
-      return *this;
+    if (TruncBits >= Bits) return *this;
     const T BitMask = (T(1) << T(TruncBits)) - 1;
     const T SignBit = T(1) << (TruncBits - 1);
     const T ExtMask = ~BitMask;
     return Integral((V & BitMask) | (Signed && (V & SignBit) ? ExtMask : 0));
   }
 
   void print(llvm::raw_ostream &OS) const { OS << V; }
 
-  static Integral min(unsigned NumBits) {
-    return Integral(Min);
-  }
-  static Integral max(unsigned NumBits) {
-    return Integral(Max);
-  }
+  static Integral min(unsigned NumBits) { return Integral(Min); }
+  static Integral max(unsigned NumBits) { return Integral(Max); }
 
   template <typename T>
   static std::enable_if_t<std::is_integral<T>::value, Integral> from(T Value) {
     return Integral(Value);
   }
 
   template <unsigned SrcBits, bool SrcSign>
-  static std::enable_if_t<SrcBits != 0, Integral>
-  from(Integral<SrcBits, SrcSign> Value) {
+  static Integral from(const Integral<SrcBits, SrcSign> &Value) {
     return Integral(Value.V);
   }
 
-  template <bool SrcSign> static Integral from(Integral<0, SrcSign> Value) {
+  template <bool SrcSign> 
+  static Integral from(const Integral<0, SrcSign> &Value) {
     if (SrcSign)
       return Integral(Value.V.getSExtValue());
     else
       return Integral(Value.V.getZExtValue());
   }
 
+  static Integral from(Boolean Value) { return Integral(!Value.isZero()); }
+
   static Integral zero() { return from(0); }
 
-  template <typename T> static Integral from(T Value, unsigned NumBits) {
+  template <typename T> 
+  static Integral from(T Value, unsigned NumBits) {
     return Integral(Value);
   }
 
   static bool inRange(int64_t Value, unsigned NumBits) {
     return CheckRange<T, Min, Max>(Value);
   }
 
   static bool increment(Integral A, Integral *R) {
public:
   static bool sub(Integral A, Integral B, unsigned OpBits, Integral *R) {
     return CheckSubUB(A.V, B.V, R->V);
   }
 
   static bool mul(Integral A, Integral B, unsigned OpBits, Integral *R) {
     return CheckMulUB(A.V, B.V, R->V);
   }
 
  private:
   template <typename T>
   static std::enable_if_t<std::is_signed<T>::value, bool> CheckAddUB(T A, T B,
                                                                      T &R) {
     return llvm::AddOverflow<T>(A, B, R);
   }
 
   template <typename T>
   static std::enable_if_t<std::is_unsigned<T>::value, bool> CheckAddUB(T A, T B,

 };
 
 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
+template <unsigned Bits, bool Signed>
+Boolean Boolean::from(const Integral<Bits, Signed> &V) {
+  return Boolean(!V.isZero());
+}
+
+}  // namespace interp
+}  // namespace clang
 
 #endif

clang/lib/AST/Interp/Interp.h

 //===--- 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.
+// Implementation of the opcodes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_INTERP_INTERP_H
 #define LLVM_CLANG_AST_INTERP_INTERP_H
 
-#include <limits>
-#include <vector>
 #include "Function.h"
 #include "InterpFrame.h"
+#include "InterpHelper.h"
 #include "InterpStack.h"
 #include "InterpState.h"
 #include "Opcode.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "State.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/Expr.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/Support/Endian.h"
+#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 = V.toAPValue();
-  return true;
-}
-
-/// Checks if the variable has externally defined storage.
-bool CheckExtern(InterpState &S, CodePtr OpPC, const Pointer &Ptr);
-
-/// Checks if the array is offsetable.
-bool CheckArray(InterpState &S, CodePtr OpPC, const Pointer &Ptr);
-
-/// 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 field from which a pointer is going to be derived is valid.
-bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
-                CheckSubobjectKind CSK);
-
-/// Checks if a pointer points to const storage.
-bool CheckConst(InterpState &S, CodePtr OpPC, const Pointer &Ptr);
-
-/// Checks if a pointer points to a mutable field.
-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 method can be invoked on an object.
-bool CheckInvoke(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);
-
-/// Checks the 'this' pointer.
-bool CheckThis(InterpState &S, CodePtr OpPC, const Pointer &This);
-
-/// Checks if a method is pure virtual.
-bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD);
-
-template <typename T> inline bool IsTrue(const T &V) { return !V.isZero(); }
-
 //===----------------------------------------------------------------------===//
 // 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);
+  const Expr *E = S.getSource(OpPC).asExpr();
   QualType Type = E->getType();
   if (S.checkingForUndefinedBehavior()) {
     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;

 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);
 }
 
 //===----------------------------------------------------------------------===//
-// EQ, NE, GT, GE, LT, LE
+// Minus, Test
 //===----------------------------------------------------------------------===//
 
-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 (LHS.isZero() && RHS.isZero()) {
-    S.Stk.push<BoolT>(BoolT::from(Fn(ComparisonCategoryResult::Equal)));
-    return true;
-  }
-
-  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 <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;
-  });
+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.getSource(OpPC).asExpr(), Value);
   }
 
-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;
-  });
+  S.Stk.push<T>(std::negate<T>()(Arg));
+  return true;
 }
 
-//===----------------------------------------------------------------------===//
-// 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);
+bool Test(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<Boolean>(Boolean::from(!S.Stk.pop<T>().isZero()));
   return true;
 }
 
 //===----------------------------------------------------------------------===//
-// Dup, Pop, Test
+// Dup, Pop
 //===----------------------------------------------------------------------===//
 
 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 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;
-  if (!CheckRange(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;
-  if (!CheckRange(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;
-  if (!CheckRange(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 GetThisField(InterpState &S, CodePtr OpPC, uint32_t I) {
-  if (S.checkingPotentialConstantExpression())
-    return false;
-  const Pointer &This = S.Current->getThis();
-  if (!CheckThis(S, OpPC, This))
-    return false;
-  const Pointer &Field = This.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 &This = S.Current->getThis();
-  if (!CheckThis(S, OpPC, This))
-    return false;
-  const Pointer &Field = This.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) {
-  auto *B = S.P.getGlobal(I);
-  if (B->isExtern())
-    return false;
-  S.Stk.push<T>(B->deref<T>());
-  return true;
-}
-
-template <PrimType Name, class T = typename PrimConv<Name>::T>
-bool SetGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
-  // TODO: emit warning.
-  return false;
-}
-
-template <PrimType Name, class T = typename PrimConv<Name>::T>
-bool InitGlobal(InterpState &S, CodePtr OpPC, uint32_t I) {
-  S.P.getGlobal(I)->deref<T>() = S.Stk.pop<T>();
-  return true;
-}
-
-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 &This = S.Current->getThis();
-  if (!CheckThis(S, OpPC, This))
-    return false;
-  const Pointer &Field = This.atField(I);
-  Field.deref<T>() = S.Stk.pop<T>();
-  Field.initialize();
-  return true;
-}
-
-template <PrimType Name, class T = typename PrimConv<Name>::T>
-bool InitThisBitField(InterpState &S, CodePtr OpPC, const Record::Field *F) {
-  if (S.checkingPotentialConstantExpression())
-    return false;
-  const Pointer &This = S.Current->getThis();
-  if (!CheckThis(S, OpPC, This))
-    return false;
-  const Pointer &Field = This.atField(F->Offset);
-  const auto &Value = S.Stk.pop<T>();
-  Field.deref<T>() = Value.truncate(F->Decl->getBitWidthValue(S.getCtx()));
-  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 &This = S.Current->getThis();
-  if (!CheckThis(S, OpPC, This))
-    return false;
-  const Pointer &Field = This.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 InitBitField(InterpState &S, CodePtr OpPC, const Record::Field *F) {
-  const T &Value = S.Stk.pop<T>();
-  const Pointer &Field = S.Stk.pop<Pointer>().atField(F->Offset);
-  Field.deref<T>() = Value.truncate(F->Decl->getBitWidthValue(S.getCtx()));
-  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;
-  if (!CheckExtern(S, OpPC, Ptr))
-    return false;
-  if (!CheckRange(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 &This = S.Current->getThis();
-  if (!CheckThis(S, OpPC, This))
-    return false;
-  S.Stk.push<Pointer>(This.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;
-  if (!CheckRange(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 (!CheckThis(S, OpPC, This))
-    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));
-  return true;
-}
-
-inline bool GetPtrThisBase(InterpState &S, CodePtr OpPC, uint32_t Off) {
-  if (S.checkingPotentialConstantExpression())
-    return false;
-  const Pointer &This = S.Current->getThis();
-  if (!CheckThis(S, OpPC, This))
-    return false;
-  S.Stk.push<Pointer>(This.atField(Off));
-  return true;
-}
-
-inline bool VirtBaseHelper(InterpState &S, CodePtr OpPC, const RecordDecl *Decl,
-                           const Pointer &Ptr) {
-  Pointer Base = Ptr;
-  while (Base.isBaseClass())
-    Base = Base.getBase();
-
-  auto *Field = Base.getRecord()->getVirtualBase(Decl);
-  S.Stk.push<Pointer>(Base.atField(Field->Offset));
-  return true;
-}
-
-inline bool GetPtrVirtBase(InterpState &S, CodePtr OpPC, const RecordDecl *D) {
-  const Pointer &Ptr = S.Stk.pop<Pointer>();
-  if (!CheckNull(S, OpPC, Ptr, CSK_Base))
-    return false;
-  return VirtBaseHelper(S, OpPC, D, Ptr);
-}
-
-inline bool GetPtrThisVirtBase(InterpState &S, CodePtr OpPC,
-                               const RecordDecl *D) {
-  if (S.checkingPotentialConstantExpression())
-    return false;
-  const Pointer &This = S.Current->getThis();
-  if (!CheckThis(S, OpPC, This))
-    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))
+  if (!S.CheckLoad(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))
+  if (!S.CheckLoad(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))
+  if (!S.CheckStore(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 StoreBitField(InterpState &S, CodePtr OpPC) {
-  const T &Value = S.Stk.pop<T>();
-  const Pointer &Ptr = S.Stk.peek<Pointer>();
-  if (!CheckStore(S, OpPC, Ptr))
+  if (!S.CheckStore(OpPC, Ptr))
     return false;
-  if (auto *FD = Ptr.getField()) {
-    Ptr.deref<T>() = Value.truncate(FD->getBitWidthValue(S.getCtx()));
-  } else {
-    Ptr.deref<T>() = Value;
-  }
-  return true;
-}
-
-template <PrimType Name, class T = typename PrimConv<Name>::T>
-bool StoreBitFieldPop(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;
-  if (auto *FD = Ptr.getField()) {
-    Ptr.deref<T>() = Value.truncate(FD->getBitWidthValue(S.getCtx()));
-  } else {
-    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.initialize();
-  new (&Ptr.deref<T>()) T(Value);
-  return true;
-}
-
-template <PrimType Name, class T = typename PrimConv<Name>::T>
-bool InitElem(InterpState &S, CodePtr OpPC, uint32_t Idx) {
-  const T &Value = S.Stk.pop<T>();
-  const Pointer &Ptr = S.Stk.peek<Pointer>().atIndex(Idx);
-  if (!CheckInit(S, OpPC, Ptr))
-    return false;
-  Ptr.initialize();
-  new (&Ptr.deref<T>()) T(Value);
-  return true;
-}
-
-template <PrimType Name, class T = typename PrimConv<Name>::T>
-bool InitElemPop(InterpState &S, CodePtr OpPC, uint32_t Idx) {
-  const T &Value = S.Stk.pop<T>();
-  const Pointer &Ptr = S.Stk.pop<Pointer>().atIndex(Idx);
-  if (!CheckInit(S, OpPC, Ptr))
-    return false;
-  Ptr.initialize();
-  new (&Ptr.deref<T>()) 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;
-  if (!CheckRange(S, OpPC, Ptr, CSK_ArrayToPointer))
-    return false;
-
-  // Get a version of the index comparable to the type.
-  T Index = T::from(Ptr.getIndex(), Offset.bitWidth());
-  // A zero offset does not change the pointer, but in the case of an array
-  // it has to be adjusted to point to the first element instead of the array.
-  if (Offset.isZero()) {
-    S.Stk.push<Pointer>(Index.isZero() ? Ptr.atIndex(0) : Ptr);
-    return true;
-  }
-  // Arrays of unknown bounds cannot have pointers into them.
-  if (!CheckArray(S, OpPC, Ptr))
-    return false;
-
-  // Compute the largest index into the array.
-  unsigned MaxIndex = Ptr.getNumElems();
-
-  // Helper to report an invalid offset, computed as APSInt.
-  auto InvalidOffset = [&]() {
-    const unsigned Bits = Offset.bitWidth();
-    APSInt APOffset(Offset.toAPSInt().extend(Bits + 2), false);
-    APSInt APIndex(Index.toAPSInt().extend(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.inArray())
-        << 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);
-  S.Stk.push<Pointer>(Ptr.atIndex(static_cast<unsigned>(Result)));
-  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
+// Cast
 //===----------------------------------------------------------------------===//
 
 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 Name, class T = typename PrimConv<Name>::T>
 inline bool Null(InterpState &S, CodePtr OpPC) {
   S.Stk.push<T>();
   return true;
 }
 
 //===----------------------------------------------------------------------===//
-// This, ImplicitThis
-//===----------------------------------------------------------------------===//
-
-inline bool This(InterpState &S, CodePtr OpPC) {
-  // Cannot read 'this' in this mode.
-  if (S.checkingPotentialConstantExpression()) {
-    return false;
-  }
-
-  const Pointer &This = S.Current->getThis();
-  if (!CheckThis(S, OpPC, This))
-    return false;
-
-  S.Stk.push<Pointer>(This);
-  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 (Bits > 1 && 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 >> 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 (V.bitWidth() == 1) {
-    S.Stk.push<T>(V);
-  } else 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
+// Trap
 //===----------------------------------------------------------------------===//
 
-inline bool NarrowPtr(InterpState &S, CodePtr OpPC) {
-  const Pointer &Ptr = S.Stk.pop<Pointer>();
-  S.Stk.push<Pointer>(Ptr.narrow());
-  return true;
-}
-
-inline bool ExpandPtr(InterpState &S, CodePtr OpPC) {
-  const Pointer &Ptr = S.Stk.pop<Pointer>();
-  S.Stk.push<Pointer>(Ptr.expand());
-  return true;
+inline bool Trap(InterpState &S, CodePtr OpPC) {
+  const SourceLocation &Loc = S.getSource(OpPC).getLoc();
+  S.FFDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
+  return false;
 }
 
-/// Interpreter entry point.
-bool Interpret(InterpState &S, APValue &Result);
+#include "Opcodes/Comparison.h"
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Interp.cpp

-//===--- 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 <limits>
-#include <vector>
-#include "Function.h"
-#include "InterpFrame.h"
-#include "InterpStack.h"
-#include "Opcode.h"
-#include "PrimType.h"
-#include "Program.h"
-#include "State.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/ASTDiagnostic.h"
-#include "clang/AST/CXXInheritance.h"
-#include "clang/AST/Expr.h"
-#include "clang/AST/ExprCXX.h"
-#include "llvm/ADT/APSInt.h"
-
-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;
-}
-
-static bool RetValue(InterpState &S, CodePtr &Pt, APValue &Result) {
-  llvm::report_fatal_error("Interpreter cannot return values");
-}
-
-//===----------------------------------------------------------------------===//
-// 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;
-}
-
-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;
-
-  // Get the inactive field descriptor.
-  const FieldDecl *InactiveField = Ptr.getField();
-
-  // 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.getRecord();
-  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 = Field.getField();
-      break;
-    }
-  }
-
-  const SourceInfo &Loc = S.Current->getSource(OpPC);
-  S.FFDiag(Loc, diag::note_constexpr_access_inactive_union_member)
-      << AK << InactiveField << !ActiveField << ActiveField;
-  return false;
-}
-
-static bool CheckTemporary(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
-                           AccessKinds AK) {
-  if (auto ID = Ptr.getDeclID()) {
-    if (!Ptr.isStaticTemporary())
-      return true;
-
-    if (Ptr.getDeclDesc()->getType().isConstQualified())
-      return true;
-
-    if (S.P.getCurrentDecl() == ID)
-      return true;
-
-    const SourceInfo &E = S.Current->getSource(OpPC);
-    S.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
-    S.Note(Ptr.getDeclLoc(), diag::note_constexpr_temporary_here);
-    return false;
-  }
-  return true;
-}
-
-static bool CheckGlobal(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
-  if (auto ID = Ptr.getDeclID()) {
-    if (!Ptr.isStatic())
-      return true;
-
-    if (S.P.getCurrentDecl() == ID)
-      return true;
-
-    S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_modify_global);
-    return false;
-  }
-  return true;
-}
-
-namespace clang {
-namespace interp {
-
-bool CheckExtern(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
-  if (!Ptr.isExtern())
-    return true;
-
-  if (!S.checkingPotentialConstantExpression()) {
-    auto *VD = Ptr.getDeclDesc()->asValueDecl();
-    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;
-}
-
-bool CheckArray(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
-  if (!Ptr.isUnknownSizeArray())
-    return true;
-  const SourceInfo &E = S.Current->getSource(OpPC);
-  S.FFDiag(E, diag::note_constexpr_unsized_array_indexed);
-  return false;
-}
-
-bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
-               AccessKinds AK) {
-  const auto &Src = S.Current->getSource(OpPC);
-  if (Ptr.isZero()) {
-
-    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.isZero())
-    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.isOnePastEnd())
-    return true;
-  const SourceInfo &Loc = S.Current->getSource(OpPC);
-  S.FFDiag(Loc, diag::note_constexpr_access_past_end) << AK;
-  return false;
-}
-
-bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
-                CheckSubobjectKind CSK) {
-  if (!Ptr.isElementPastEnd())
-    return true;
-  const SourceInfo &Loc = S.Current->getSource(OpPC);
-  S.FFDiag(Loc, diag::note_constexpr_past_end_subobject) << CSK;
-  return false;
-}
-
-bool CheckConst(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
-  assert(Ptr.isLive() && "Pointer is not live");
-  if (!Ptr.isConst()) {
-    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;
-}
-
-bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
-  assert(Ptr.isLive() && "Pointer is not live");
-  if (!Ptr.isMutable()) {
-    return true;
-  }
-
-  const SourceInfo &Loc = S.Current->getSource(OpPC);
-  const FieldDecl *Field = Ptr.getField();
-  S.FFDiag(Loc, diag::note_constexpr_access_mutable, 1) << AK_Read << Field;
-  S.Note(Field->getLocation(), diag::note_declared_at);
-  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;
-  if (!CheckTemporary(S, OpPC, Ptr, AK_Read))
-    return false;
-  if (!CheckMutable(S, OpPC, Ptr))
-    return false;
-  return true;
-}
-
-bool CheckStore(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
-  if (!CheckLive(S, OpPC, Ptr, AK_Assign))
-    return false;
-  if (!CheckExtern(S, OpPC, Ptr))
-    return false;
-  if (!CheckRange(S, OpPC, Ptr, AK_Assign))
-    return false;
-  if (!CheckGlobal(S, OpPC, Ptr))
-    return false;
-  if (!CheckConst(S, OpPC, Ptr))
-    return false;
-  return true;
-}
-
-bool CheckInvoke(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
-  if (!CheckLive(S, OpPC, Ptr, AK_MemberCall))
-    return false;
-  if (!CheckExtern(S, OpPC, Ptr))
-    return false;
-  if (!CheckRange(S, OpPC, Ptr, AK_MemberCall))
-    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;
-}
-
-bool CheckThis(InterpState &S, CodePtr OpPC, const Pointer &This) {
-  if (!This.isZero())
-    return true;
-
-  const SourceInfo &Loc = S.Current->getSource(OpPC);
-
-  bool IsImplicit = false;
-  if (auto *E = dyn_cast_or_null<CXXThisExpr>(Loc.asExpr()))
-    IsImplicit = E->isImplicit();
-
-  if (S.getLangOpts().CPlusPlus11)
-    S.FFDiag(Loc, diag::note_constexpr_this) << IsImplicit;
-  else
-    S.FFDiag(Loc);
-
-  return false;
-}
-
-bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD) {
-  if (!MD->isPure())
-    return true;
-  const SourceInfo &E = S.Current->getSource(OpPC);
-  S.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << MD;
-  S.Note(MD->getLocation(), diag::note_declared_at);
-  return false;
-}
-bool Interpret(InterpState &S, APValue &Result) {
-  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

clang/lib/AST/Interp/InterpFrame.h

public:
   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 interp caller object.
+  InterpFrame *getInterpCaller() { return Caller; }
+
   /// 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; }
public:
   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) {

clang/lib/AST/Interp/InterpFrame.cpp

 //===--- 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 "InterpState.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "clang/AST/DeclCXX.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 InterpFrame::InterpFrame(InterpState &S, Function *Func, InterpFrame *Caller,
if (unsigned FrameSize = Func->getFrameSize()) {
       }
     }
   }
 }
 
 InterpFrame::~InterpFrame() {
   if (Func && Func->isConstructor() && This.isBaseClass())
     This.initialize();
+
+  if (Func && Func->isConstructor()) {
+    if (This.isBaseClass()) {
+      // Base classes must set their initialised flag.
+      This.initialize();
+    } else if (!This.isRoot()) {
+      // Records in unions must be activated.
+      if (auto *R = This.getBase().getRecord()) {
+        if (R->isUnion())
+          This.activate();
+      }
+    }
+  }
+
   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)));
   }
if (auto *E = Desc->asExpr()) {
       return;
     }
     llvm_unreachable("Invalid descriptor type");
   };
 
   if (!Ty->isReferenceType())
     OS << "&";
   llvm::SmallVector<Pointer, 2> Levels;
-  for (Pointer F = P; !F.isRoot(); ) {
+  for (Pointer F = P; !F.isRoot(); F = F.getContainingObject())
     Levels.push_back(F);
-    F = F.isArrayElement() ? F.getArray().expand() : F.getBase();
-  }
 
   printDesc(P.getDeclDesc());
   for (auto It = Levels.rbegin(); It != Levels.rend(); ++It) {
     if (It->inArray()) {
       OS << "[" << It->expand().getIndex() << "]";
       continue;
     }
     if (auto Index = It->getIndex()) {

 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));
+    return S.getSource(nullptr, {}).getLoc();
+  return S.getSource(Caller->Func, RetPC - sizeof(uintptr_t)).getLoc();
 }
 
 const FunctionDecl *InterpFrame::getCallee() const {
-  return Func->getDecl();
+  return Func ? Func->getDecl() : nullptr;
 }
 
 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) {
 
   // 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);
-}
-

clang/lib/AST/Interp/InterpHelper.h

+//===--- HeapUtils.h - Utilities to handle the heap -------------*- 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_INTERPHELPER_H
+#define LLVM_CLANG_AST_INTERP_INTERPHELPER_H
+
+#include "Pointer.h"
+#include "Source.h"
+
+namespace clang {
+namespace interp {
+
+/// Convers a primitive value to an APValue.
+template <typename T> bool PrimitiveToValue(const T &V, APValue &R) {
+  R = V.toAPValue();
+  return true;
+}
+
+} // namespace interp
+} // namespace clang
+
+#endif

clang/lib/AST/Interp/InterpHelper.cpp

+//===--- InterpHelper.cpp - Auxiliary utilities -----------------*- 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 "InterpHelper.h"
+#include "InterpState.h"
+#include "PrimType.h"
+#include "Record.h"
+#include "clang/AST/Type.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/APSInt.h"
+
+using namespace clang;
+using namespace interp;

clang/lib/AST/Interp/InterpLoop.h

+//===--- InterpLoop.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_INTERPLOOP_H
+#define LLVM_CLANG_AST_INTERP_INTERPLOOP_H
+
+#include "InterpState.h"
+
+namespace clang {
+namespace interp {
+
+/// Interpreter entry point.
+bool Interpret(InterpState &S, APValue &Result);
+
+} // namespace interp
+} // namespace clang
+
+#endif
+

clang/lib/AST/Interp/InterpLoop.cpp

+//===--- InterpLoop.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Definition of the interpreter state and entry point.
+//
+//===----------------------------------------------------------------------===//
+
+#include "InterpLoop.h"
+#include "Function.h"
+#include "Interp.h"
+#include "InterpFrame.h"
+#include "InterpHelper.h"
+#include "InterpStack.h"
+#include "Opcode.h"
+#include "PrimType.h"
+#include "Program.h"
+#include "State.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTDiagnostic.h"
+#include "clang/AST/CXXInheritance.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/ExprCXX.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 (!PrimitiveToValue<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<Boolean>().isTrue())
+    PC += Offset;
+  return true;
+}
+
+static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset) {
+  if (S.Stk.pop<Boolean>().isFalse())
+    PC += Offset;
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// Call, NoCall, Invoke, NoInvoke, IndirectInvoke
+//===----------------------------------------------------------------------===//
+
+static bool HandleCall(InterpState &S, CodePtr &PC, CodePtr OpPC, Function *F,
+                       Pointer &&This) {
+  if (!S.CheckCallable(OpPC, F->getDecl()))
+    return false;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+
+  // Adjust the state.
+  S.CallStackDepth++;
+
+  // Construct a new frame.
+  S.Current = new InterpFrame(S, F, S.Current, PC, std::move(This));
+
+  // Transfer control to the callee.
+  PC = F->getCodeBegin();
+  return true;
+}
+
+static bool HandleNoCall(InterpState &S, CodePtr PC, const FunctionDecl *FD) {
+  CodePtr OpPC = PC - sizeof(FD);
+  if (!S.CheckCallable(OpPC, FD))
+    return false;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  const SourceInfo &CallLoc = S.getSource(OpPC);
+  if (S.getLangOpts().CPlusPlus11) {
+    S.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1)
+        << FD->isConstexpr() << isa<CXXConstructorDecl>(FD) << FD;
+    S.Note(FD->getLocation(), diag::note_declared_at);
+  } else {
+    S.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
+  }
+  return false;
+}
+
+static bool Call(InterpState &S, CodePtr &PC, Function *F) {
+  return HandleCall(S, PC, PC - sizeof(F), F, {});
+}
+
+static bool NoCall(InterpState &S, CodePtr &PC, const FunctionDecl *FD) {
+  CodePtr OpPC = PC - sizeof(FD);
+
+  // Function was not defined - emit a diagnostic.
+  if (auto *F = S.P.getFunction(FD)) {
+    // Function was defined in the meantime - rewrite opcode.
+    S.Current->getFunction()->relocateCall(OpPC, F);
+    return HandleCall(S, PC, OpPC, F, {});
+  }
+  // Function was not defined - emit a diagnostic.
+  return HandleNoCall(S, PC, FD);
+}
+
+namespace clang {
+namespace interp {
+
+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

clang/lib/AST/Interp/InterpState.h

 namespace interp {
 class Context;
 class Function;
 class InterpStack;
 class InterpFrame;
 class SourceMapper;
 
 /// Interpreter context.
-class InterpState final : public State, public SourceMapper {
+class InterpState final : public State {
 public:
   InterpState(State &Parent, Program &P, InterpStack &Stk, Context &Ctx,
               SourceMapper *M = nullptr);
 
   ~InterpState();
 
   // Stack frame accessors.
   Frame *getSplitFrame() { return Parent.getCurrentFrame(); }
public:
 
   /// 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 {
+  SourceInfo getSource(Function *F, CodePtr PC) const {
     return M ? M->getSource(F, PC) : F->getSource(PC);
   }
 
+  /// Maps the location to the innermost non-default action.
+  SourceInfo getSource(CodePtr PC) const;
+
+public:
+  /// Checks if the array is offsetable.
+  bool CheckArray(CodePtr PC, const Pointer &Ptr);
+  /// Checks if a pointer is live and accesible.
+  bool CheckLive(CodePtr PC, const Pointer &Ptr, AccessKinds AK);
+  /// Checks if a pointer is null.
+  bool CheckNull(CodePtr PC, const Pointer &Ptr, CheckSubobjectKind CSK);
+  /// Checks if a pointer is in range.
+  bool CheckRange(CodePtr PC, const Pointer &Ptr, AccessKinds AK);
+  /// Checks if a field from which a pointer is going to be derived is valid.
+  bool CheckRange(CodePtr PC, const Pointer &Ptr, CheckSubobjectKind CSK);
+  /// Checks if a value can be loaded from a block.
+  bool CheckLoad(CodePtr PC, const Pointer &Ptr, AccessKinds AK = AK_Read);
+  /// Checks if a value can be stored in a block.
+  bool CheckStore(CodePtr PC, const Pointer &Ptr, AccessKinds AK = AK_Assign);
+  /// Checks if a method can be called.
+  bool CheckCallable(CodePtr PC, const FunctionDecl *FD);
+
+private:
+  /// Checks if an extern is being accessed.
+  bool CheckExtern(CodePtr PC, const Pointer &Ptr);
+  /// Checks if storage was initialized.
+  bool CheckInitialized(CodePtr PC, const Pointer &Ptr,  AccessKinds AK);
+  /// Checks if a field is active if in a union.
+  bool CheckActive(CodePtr PC, const Pointer &Ptr, AccessKinds AK);
+  /// Checks if a termpoary is accessed.
+  bool CheckTemporary(CodePtr PC, const Pointer &Ptr, AccessKinds AK);
+  /// Checks if a global is illegally accessed.
+  bool CheckGlobal(CodePtr PC, const Pointer &Ptr);
+  /// Checks if a mutable field is accessed.
+  bool CheckMutable(CodePtr PC, const Pointer &Ptr);
+  /// Checks if a pointer points to const storage.
+  bool CheckConst(CodePtr PC, const Pointer &Ptr);
+
 private:
   /// AST Walker state.
   State &Parent;
   /// Dead block chain.
   DeadBlock *DeadBlocks = nullptr;
   /// Reference to the offset-source mapping.
   SourceMapper *M;
 

clang/lib/AST/Interp/InterpState.cpp

 //===--- 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 <limits>
 #include "Function.h"
 #include "InterpFrame.h"
 #include "InterpStack.h"
 #include "Opcode.h"
-#include "PrimType.h"
 #include "Program.h"
 #include "State.h"
+#include "clang/AST/ExprCXX.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 using APSInt = llvm::APSInt;
 
 InterpState::InterpState(State &Parent, Program &P, InterpStack &Stk,
                          Context &Ctx, SourceMapper *M)
if (B->hasPointers()) {
     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);
   }
 }
+
+SourceInfo InterpState::getSource(CodePtr PC) const {
+  for (InterpFrame *F = Current; F; F = F->getInterpCaller()) {
+    Function *Fn = F->getFunction();
+    if (!Fn)
+      break;
+    if (!Fn->isDefaulted())
+      return getSource(Fn, PC);
+    PC = F->getRetPC();
+  }
+  return getSource(nullptr, {});
+}
+
+bool InterpState::CheckArray(CodePtr PC, const Pointer &Ptr) {
+  if (!Ptr.isUnknownSizeArray())
+    return true;
+  const SourceInfo &I = getSource(PC);
+  FFDiag(I, diag::note_constexpr_unsized_array_indexed);
+  return false;
+}
+
+bool InterpState::CheckLive(CodePtr PC, const Pointer &Ptr, AccessKinds AK) {
+  if (Ptr.isZero()) {
+    const SourceInfo &I = getSource(PC);
+    if (Ptr.isField())
+      FFDiag(I, diag::note_constexpr_null_subobject) << CSK_Field;
+    else
+      FFDiag(I, diag::note_constexpr_access_null) << AK;
+
+    return false;
+  }
+
+  if (!Ptr.isLive()) {
+    bool IsTemp = Ptr.isTemporary();
+    const SourceInfo &I = getSource(PC);
+    FFDiag(I, diag::note_constexpr_lifetime_ended, 1) << AK << !IsTemp;
+
+    if (IsTemp)
+      Note(Ptr.getDeclLoc(), diag::note_constexpr_temporary_here);
+    else
+      Note(Ptr.getDeclLoc(), diag::note_declared_at);
+
+    return false;
+  }
+
+  return true;
+}
+
+bool InterpState::CheckNull(CodePtr PC, const Pointer &Ptr,
+                            CheckSubobjectKind CSK) {
+  if (!Ptr.isZero())
+    return true;
+  const SourceInfo &I = getSource(PC);
+  FFDiag(I, diag::note_constexpr_null_subobject) << CSK;
+  return false;
+}
+
+bool InterpState::CheckRange(CodePtr PC, const Pointer &Ptr, AccessKinds AK) {
+  if (!Ptr.isOnePastEnd())
+    return true;
+  const SourceInfo &I = getSource(PC);
+  FFDiag(I, diag::note_constexpr_access_past_end) << AK;
+  return false;
+}
+
+bool InterpState::CheckRange(CodePtr PC, const Pointer &Ptr,
+                             CheckSubobjectKind CSK) {
+  if (!Ptr.isElementPastEnd())
+    return true;
+  const SourceInfo &I = getSource(PC);
+  FFDiag(I, diag::note_constexpr_past_end_subobject) << CSK;
+  return false;
+}
+
+bool InterpState::CheckLoad(CodePtr PC, const Pointer &Ptr, AccessKinds AK) {
+  if (!CheckLive(PC, Ptr, AK))
+    return false;
+  if (!CheckExtern(PC, Ptr))
+    return false;
+  if (!CheckRange(PC, Ptr, AK))
+    return false;
+  if (!CheckInitialized(PC, Ptr, AK))
+    return false;
+  if (!CheckActive(PC, Ptr, AK))
+    return false;
+  if (!CheckTemporary(PC, Ptr, AK))
+    return false;
+  if (!CheckMutable(PC, Ptr))
+    return false;
+  return true;
+}
+
+bool InterpState::CheckStore(CodePtr PC, const Pointer &Ptr, AccessKinds AK) {
+  if (!CheckLive(PC, Ptr, AK))
+    return false;
+  if (!CheckExtern(PC, Ptr))
+    return false;
+  if (!CheckRange(PC, Ptr, AK))
+    return false;
+  if (!CheckGlobal(PC, Ptr))
+    return false;
+  if (!CheckConst(PC, Ptr))
+    return false;
+  return true;
+}
+
+bool InterpState::CheckCallable(CodePtr PC, const FunctionDecl *FD) {
+  if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
+    if (MD->isVirtual()) {
+      if (!getLangOpts().CPlusPlus2a) {
+        CCEDiag(getSource(PC), diag::note_constexpr_virtual_call);
+        return false;
+      }
+    }
+  }
+
+  if (!FD->isConstexpr()) {
+    if (getLangOpts().CPlusPlus11) {
+      // If this function is not constexpr because it is an inherited
+      // non-constexpr constructor, diagnose that directly.
+      auto *CD = dyn_cast<CXXConstructorDecl>(FD);
+      if (CD && CD->isInheritingConstructor()) {
+        auto *Inherited = CD->getInheritedConstructor().getConstructor();
+        if (!Inherited->isConstexpr())
+          FD = CD = Inherited;
+      }
+
+      // FIXME: If FD 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())
+        FFDiag(getSource(PC), diag::note_constexpr_invalid_inhctor, 1)
+            << CD->getInheritedConstructor().getConstructor()->getParent();
+      else
+        FFDiag(getSource(PC), diag::note_constexpr_invalid_function, 1)
+            << FD->isConstexpr() << (bool)CD << FD;
+      Note(FD->getLocation(), diag::note_declared_at);
+    } else {
+      FFDiag(getSource(PC), diag::note_invalid_subexpr_in_const_expr);
+    }
+    return false;
+  }
+
+  return true;
+}
+
+bool InterpState::CheckExtern(CodePtr PC, const Pointer &Ptr) {
+  if (!Ptr.isExtern())
+    return true;
+
+  if (!checkingPotentialConstantExpression()) {
+    auto *VD = Ptr.getDeclDesc()->asValueDecl();
+    const SourceInfo &I = getSource(PC);
+    FFDiag(I, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
+    Note(VD->getLocation(), diag::note_declared_at);
+  }
+  return false;
+}
+
+bool InterpState::CheckInitialized(CodePtr PC, const Pointer &Ptr,
+                                   AccessKinds AK) {
+  if (Ptr.isInitialized())
+    return true;
+  if (!checkingPotentialConstantExpression()) {
+    const SourceInfo &I = getSource(PC);
+    FFDiag(I, diag::note_constexpr_access_uninit) << AK << false;
+  }
+  return false;
+}
+
+bool InterpState::CheckActive(CodePtr PC, const Pointer &Ptr,
+                              AccessKinds AK) {
+  if (Ptr.isActive())
+    return true;
+
+  // Get the inactive field descriptor.
+  const FieldDecl *InactiveField = Ptr.getField();
+
+  // 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.getRecord();
+  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 = Field.getField();
+      break;
+    }
+  }
+
+  const SourceInfo &I = getSource(PC);
+  FFDiag(I, diag::note_constexpr_access_inactive_union_member)
+      << AK << InactiveField << !ActiveField << ActiveField;
+  return false;
+}
+
+bool InterpState::CheckTemporary(CodePtr PC, const Pointer &Ptr,
+                                 AccessKinds AK) {
+  // TODO: implement check
+  return true;
+}
+
+bool InterpState::CheckGlobal(CodePtr PC, const Pointer &Ptr) {
+  // TODO: implement check
+  return true;
+}
+
+bool InterpState::CheckMutable(CodePtr PC, const Pointer &Ptr) {
+  assert(Ptr.isLive() && "Pointer is not live");
+  if (!Ptr.isMutable()) {
+    return true;
+  }
+
+  Pointer FieldPtr = Ptr;
+  const FieldDecl *MutableField = nullptr;
+  do {
+    MutableField = FieldPtr.getField();
+    if (MutableField && MutableField->isMutable())
+      break;
+    FieldPtr = FieldPtr.getContainingObject();
+  } while (!FieldPtr.isRoot());
+  assert(MutableField && "missing mutable field");
+
+  const SourceInfo &I = getSource(PC);
+  FFDiag(I, diag::note_constexpr_access_mutable, 1) << Ptr.getField();
+  Note(MutableField->getLocation(), diag::note_declared_at);
+  return false;
+}
+
+bool InterpState::CheckConst(CodePtr PC, const Pointer &Ptr) {
+  assert(Ptr.isLive() && "Pointer is not live");
+  if (!Ptr.isConst()) {
+    return true;
+  }
+
+  const QualType Ty = Ptr.getType();
+  const SourceInfo &I = getSource(PC);
+  FFDiag(I, diag::note_constexpr_modify_const_type) << Ty;
+  return false;
+}

clang/lib/AST/Interp/Opcodes.td

 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 ArgGlobal : ArgType { let Name = "GlobalLocation"; }
 
 def ArgFunction : ArgType { let Name = "Function *"; }
 def ArgRecord : ArgType { let Name = "Record *"; }
 
-def ArgSema : ArgType { let Name = "const fltSemantics *"; }
+def ArgSema : ArgType { let Name = "const llvm::fltSemantics *"; }
 
 def ArgExpr : ArgType { let Name = "const Expr *"; }
 def ArgFloatingLiteral : ArgType { let Name = "const FloatingLiteral *"; }
 def ArgCXXMethodDecl : ArgType { let Name = "const CXXMethodDecl *"; }
 def ArgFunctionDecl : ArgType { let Name = "const FunctionDecl *"; }
 def ArgRecordDecl : ArgType { let Name = "const RecordDecl *"; }
 def ArgCXXRecordDecl : ArgType { let Name = "const CXXRecordDecl *"; }
 def ArgValueDecl : ArgType { let Name = "const ValueDecl *"; }
 def ArgRecordField : ArgType { let Name = "const Record::Field *"; }
 
 //===----------------------------------------------------------------------===//
 // Classes of types intructions operate on.
 //===----------------------------------------------------------------------===//
 
 class TypeClass {
   list<Type> Types;
 }
 
-def AluTypeClass : TypeClass {
+def IntTypeClass : TypeClass {
   let Types = [Sint8, Uint8, Sint16, Uint16, Sint32,
                Uint32, Sint64, Uint64, Bool];
 }
 
 def PtrTypeClass : TypeClass {
   let Types = [Ptr];
 }
 
+def FPTypeClass : TypeClass {
+  let Types = IntTypeClass.Types;
+}
+
+def AluFPRealFPTypeClass : TypeClass {
+  let Types = IntTypeClass.Types;
+}
+
 def AllTypeClass : TypeClass {
-  let Types = !listconcat(AluTypeClass.Types, PtrTypeClass.Types);
+  let Types = !listconcat(AluFPRealFPTypeClass.Types, PtrTypeClass.Types);
 }
 
-def ComparableTypeClass : TypeClass {
-  let Types = !listconcat(AluTypeClass.Types, [Ptr]);
+def ArithTypeClass : TypeClass {
+  let Types = !listconcat(AluFPRealFPTypeClass.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 Types = [FPTypeClass];
+  let HasGroup = 1;
+}
+
+class AluRealOpcode : Opcode {
+  let Types = [AluFPRealFPTypeClass];
   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;
 
 //===----------------------------------------------------------------------===//
+// Call opcodes
+//
+// The default calling convention, which does not support varargs, pops the
+// arguments on exit. Vararg functions require arguments to be caller-popped.
+//
+//===----------------------------------------------------------------------===//
+
+// [Args...] -> []
+def Call : Opcode {
+  let Args = [ArgFunction];
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// Invalid relocation trap
+//===----------------------------------------------------------------------===//
+
+// [] -> EXIT
+def NoCall : Opcode {
+  let Args = [ArgFunctionDecl];
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // 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;
 }
-// [Value] -> []
-def RetValue : Opcode {
-  let CanReturn = 1;
-  let ChangesPC = 1;
-  let HasCustomEval = 1;
-}
 // [] -> EXIT
 def NoRet : Opcode {}
 
 //===----------------------------------------------------------------------===//
 // Frame management
 //===----------------------------------------------------------------------===//
 
 // [] -> []

 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>;
 
 // [] -> [Integer]
 def Zero : Opcode {
-  let Types = [AluTypeClass];
+  let Types = [IntTypeClass];
 }
 
 // [] -> [Pointer]
 def Null : Opcode {
   let Types = [PtrTypeClass];
 }
 
 //===----------------------------------------------------------------------===//
 // Pointer generation
 //===----------------------------------------------------------------------===//
 
 // [] -> [Pointer]
 def GetPtrLocal : Opcode {
   // Offset of local.
   let Args = [ArgUint32];
   bit HasCustomEval = 1;
 }
 // [] -> [Pointer]
 def GetPtrParam : Opcode {
   // Offset of parameter.
   let Args = [ArgUint32];
 }
-// [] -> [Pointer]
-def GetPtrGlobal : Opcode {
-  // Index of global.
-  let Args = [ArgUint32];
-}
-// [Pointer] -> [Pointer]
-def GetPtrField : Opcode {
-  // Offset of field.
-  let Args = [ArgUint32];
-}
-// [Pointer] -> [Pointer]
-def GetPtrActiveField : Opcode {
-  // Offset of field.
-  let Args = [ArgUint32];
-}
-// [] -> [Pointer]
-def GetPtrActiveThisField : Opcode {
-  // Offset of field.
-  let Args = [ArgUint32];
-}
-// [] -> [Pointer]
-def GetPtrThisField : Opcode {
-  // Offset of field.
-  let Args = [ArgUint32];
-}
-// [Pointer] -> [Pointer]
-def GetPtrBase : Opcode {
-  // Offset of field, which is a base.
-  let Args = [ArgUint32];
-}
-// [Pointer] -> [Pointer]
-def GetPtrVirtBase : Opcode {
-  // RecordDecl of base class.
-  let Args = [ArgRecordDecl];
-}
-// [] -> [Pointer]
-def GetPtrThisBase : Opcode {
-  // Offset of field, which is a base.
-  let Args = [ArgUint32];
-}
-// [] -> [Pointer]
-def GetPtrThisVirtBase : Opcode {
-  // RecordDecl of base class.
-  let Args = [ArgRecordDecl];
-}
-// [] -> [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;
 }
 
+class GlobalOpcode : Opcode {
+  let Types = [AllTypeClass];
+  let Args = [ArgGlobal];
+  let HasGroup = 1;
+}
+
 class BitFieldOpcode : Opcode {
-  let Types = [AluTypeClass];
+  let Types = [FPTypeClass];
   let Args = [ArgRecordField];
   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 SetGlobal : AccessOpcode;
-
-// [] -> [Value]
 def GetParam : AccessOpcode;
 // [Value] -> []
 def SetParam : AccessOpcode;
 
-// [Pointer] -> [Pointer, Value]
-def GetField : AccessOpcode;
-// [Pointer] -> [Value]
-def GetFieldPop : AccessOpcode;
-// [] -> [Value]
-def GetThisField : AccessOpcode;
-
-// [Pointer, Value] -> [Pointer]
-def SetField : AccessOpcode;
-// [Value] -> []
-def SetThisField : AccessOpcode;
-
-// [Value] -> []
-def InitThisField : AccessOpcode;
-// [Value] -> []
-def InitThisFieldActive : AccessOpcode;
-// [Value] -> []
-def InitThisBitField : BitFieldOpcode;
-// [Pointer, Value] -> []
-def InitField : AccessOpcode;
-// [Pointer, Value] -> []
-def InitBitField : BitFieldOpcode;
-// [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;
 }
 
-class StoreBitFieldOpcode : Opcode {
-  let Types = [AluTypeClass];
-  let HasGroup = 1;
-}
-
 // [Pointer, Value] -> [Pointer]
 def Store : StoreOpcode {}
 // [Pointer, Value] -> []
 def StorePop : StoreOpcode {}
 
-// [Pointer, Value] -> [Pointer]
-def StoreBitField : StoreBitFieldOpcode {}
-// [Pointer, Value] -> []
-def StoreBitFieldPop : StoreBitFieldOpcode {}
-
-// [Pointer, Value] -> []
-def InitPop : StoreOpcode {}
-// [Pointer, Value] -> [Pointer]
-def InitElem : Opcode {
-  let Types = [AllTypeClass];
-  let Args = [ArgUint32];
-  let HasGroup = 1;
-}
-// [Pointer, Value] -> []
-def InitElemPop : Opcode {
-  let Types = [AllTypeClass];
-  let Args = [ArgUint32];
-  let HasGroup = 1;
-}
-
-//===----------------------------------------------------------------------===//
-// Pointer arithmetic.
-//===----------------------------------------------------------------------===//
-
-// [Pointer, Integral] -> [Pointer]
-def AddOffset : AluOpcode;
-// [Pointer, Integral] -> [Pointer]
-def SubOffset : AluOpcode;
-
 //===----------------------------------------------------------------------===//
 // Binary operators.
 //===----------------------------------------------------------------------===//
 
 // [Real, Real] -> [Real]
-def Sub : AluOpcode;
-def Add : AluOpcode;
-def Mul : AluOpcode;
+def Sub : AluRealOpcode;
+def Add : AluRealOpcode;
+def Mul : AluRealOpcode;
 
 //===----------------------------------------------------------------------===//
-// Comparison opcodes.
+// Unary operators.
 //===----------------------------------------------------------------------===//
 
-class EqualityOpcode : Opcode {
+// [Real] -> [Real]
+def Minus : AluRealOpcode;
+// [Integral] -> [Integral]
+def Test : Opcode {
   let Types = [AllTypeClass];
   let HasGroup = 1;
 }
 
-def EQ : EqualityOpcode;
-def NE : EqualityOpcode;
+//===----------------------------------------------------------------------===//
+// Comparison opcodes.
+//===----------------------------------------------------------------------===//
+
 
 class ComparisonOpcode : Opcode {
-  let Types = [ComparableTypeClass];
+  let Types = [AllTypeClass, IntTypeClass];
   let HasGroup = 1;
 }
 
+def EQ : ComparisonOpcode;
+def NE : ComparisonOpcode;
 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;
 }
+
+//===----------------------------------------------------------------------===//
+// Cast operators
+//===----------------------------------------------------------------------===//
+
+// [Value] -> [Value]
+def Cast : Opcode {
+  let Types = [FPTypeClass, IntTypeClass];
+  let HasGroup = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// Trap instruction.
+//===----------------------------------------------------------------------===//
+
+def Trap : Opcode;

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

+//===--- Comparison.h - Comparison instructions 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Implementation of the comparison opcodes: EQ, NE, GT, GE, LT, LE, InRange
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_OPCODES_COMPARISON_H
+#define LLVM_CLANG_AST_INTERP_OPCODES_COMPARISON_H
+
+namespace detail {
+
+inline llvm::Optional<CmpResult> CmpPointer(InterpState &S, CodePtr OpPC,
+                                            const Pointer &LHS,
+                                            const Pointer &RHS) {
+  if (!LHS.hasSameBase(RHS)) {
+    const SourceInfo &Loc = S.getSource(OpPC);
+    S.FFDiag(Loc, diag::note_constexpr_pointer_comparison_unspecified);
+    return {};
+  } else {
+    return LHS.compare(RHS);
+  }
+}
+
+
+template <PrimType Name, typename T = typename PrimConv<Name>::T>
+typename std::enable_if<!isPointer(Name), llvm::Optional<CmpResult>>::type
+CmpOrdered(InterpState &S, CodePtr OpPC, const T &LHS, const T &RHS) {
+  return LHS.compare(RHS);
+}
+
+template <PrimType Name, typename T = typename PrimConv<Name>::T>
+typename std::enable_if<!isPointer(Name), llvm::Optional<CmpResult>>::type
+CmpEquality(InterpState &S, CodePtr OpPC, const T &LHS, const T &RHS) {
+  return LHS.compare(RHS);
+}
+
+template <PrimType Name, typename T = typename PrimConv<Name>::T>
+typename std::enable_if<isPointer(Name), llvm::Optional<CmpResult>>::type
+CmpOrdered(InterpState &S, CodePtr OpPC, const T &LHS, const T &RHS) {
+  // Do not allow comparisons of weak pointers.
+  if (LHS.isWeak() || RHS.isWeak())
+    return {};
+
+  // Handle comparisons to null pointers.
+  const bool LHSZero = LHS.isZero();
+  const bool RHSZero = RHS.isZero();
+  if (LHSZero && RHSZero)
+    return CmpResult::Equal;
+  if (LHSZero && RHS.isNonZero())
+    return CmpResult::Unequal;
+  if (RHSZero && LHS.isNonZero())
+    return CmpResult::Unequal;
+
+  // Handle general ordering.
+  return CmpPointer(S, OpPC, LHS, RHS);
+}
+
+template <PrimType Name, typename T = typename PrimConv<Name>::T>
+typename std::enable_if<isPointer(Name), llvm::Optional<CmpResult>>::type
+CmpEquality(InterpState &S, CodePtr OpPC, const T &LHS, const T &RHS) {
+  // Do not allow comparisons of weak pointers.
+  if (LHS.isWeak() || RHS.isWeak())
+    return {};
+  return LHS == RHS ? CmpResult::Equal : CmpResult::Unequal;
+}
+
+template <PrimType Name>
+llvm::Optional<CmpResult> CmpWrapperOrdered(InterpState &S, CodePtr OpPC) {
+  using T = typename PrimConv<Name>::T;
+  const T &RHS = S.Stk.pop<T>();
+  const T &LHS = S.Stk.pop<T>();
+  return CmpOrdered<Name>(S, OpPC, LHS, RHS);
+}
+
+template <PrimType Name>
+llvm::Optional<CmpResult> CmpWrapperEquality(InterpState &S, CodePtr OpPC) {
+  using T = typename PrimConv<Name>::T;
+  const T &RHS = S.Stk.pop<T>();
+  const T &LHS = S.Stk.pop<T>();
+  return CmpEquality<Name>(S, OpPC, LHS, RHS);
+}
+
+} // namespace detail
+
+template <PrimType Name, PrimType Flag> bool EQ(InterpState &S, CodePtr OpPC) {
+  using FlagTy = typename PrimConv<Flag>::T;
+  if (auto R = detail::CmpWrapperEquality<Name>(S, OpPC)) {
+    bool Result = *R == CmpResult::Equal;
+    S.Stk.push<FlagTy>(FlagTy::from(Result));
+    return true;
+  }
+  return false;
+}
+
+template <PrimType Name, PrimType Flag> bool NE(InterpState &S, CodePtr OpPC) {
+  using FlagTy = typename PrimConv<Flag>::T;
+  if (auto R = detail::CmpWrapperEquality<Name>(S, OpPC)) {
+    bool Result = *R != CmpResult::Equal;
+    S.Stk.push<FlagTy>(FlagTy::from(Result));
+    return true;
+  }
+  return false;
+}
+
+template <PrimType Name, PrimType Flag> bool LT(InterpState &S, CodePtr OpPC) {
+  using FlagTy = typename PrimConv<Flag>::T;
+  if (auto R = detail::CmpWrapperOrdered<Name>(S, OpPC)) {
+    bool Result = *R == CmpResult::Less;
+    S.Stk.push<FlagTy>(FlagTy::from(Result));
+    return true;
+  }
+  return false;
+}
+
+template <PrimType Name, PrimType Flag> bool LE(InterpState &S, CodePtr OpPC) {
+  using FlagTy = typename PrimConv<Flag>::T;
+  if (auto R = detail::CmpWrapperOrdered<Name>(S, OpPC)) {
+    bool Result = *R == CmpResult::Less || *R == CmpResult::Equal;
+    S.Stk.push<FlagTy>(FlagTy::from(Result));
+    return true;
+  }
+  return false;
+}
+
+template <PrimType Name, PrimType Flag> bool GT(InterpState &S, CodePtr OpPC) {
+  using FlagTy = typename PrimConv<Flag>::T;
+  if (auto R = detail::CmpWrapperOrdered<Name>(S, OpPC)) {
+    bool Result = *R == CmpResult::Greater;
+    S.Stk.push<FlagTy>(FlagTy::from(Result));
+    return true;
+  }
+  return false;
+}
+
+template <PrimType Name, PrimType Flag> bool GE(InterpState &S, CodePtr OpPC) {
+  using FlagTy = typename PrimConv<Flag>::T;
+  if (auto R = detail::CmpWrapperOrdered<Name>(S, OpPC)) {
+    bool Result = *R == CmpResult::Greater || *R == CmpResult::Equal;
+    S.Stk.push<FlagTy>(FlagTy::from(Result));
+    return true;
+  }
+  return false;
+}
+
+#endif
+

clang/lib/AST/Interp/Pointer.h

 //===--- 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 "CmpResult.h"
 #include "InterpBlock.h"
-#include "clang/AST/ComparisonCategories.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace interp {
if (isElementPastEnd()) {
       unsigned Adjust;
       if (inPrimitiveArray())
         Adjust = sizeof(InitMap *);
       else
         Adjust = sizeof(InlineDescriptor);
       return Pointer(Pointee, Base, Base + getSize() + Adjust);
     }
 
-    // Do not step out of array elements.
+    // Do not step out of array elements, but step from first to root.
     if (Base != Offset)
-      return *this;
+      return getOffset() == 0 ? Pointer(Pointee, Base, Base) : *this;
 
     // If at base, point to an array of base types.
     if (Base == 0)
       return Pointer(Pointee, RootPtrMark, 0);
 
     // Step into the containing array, if inside one.
     unsigned Next = Base - getInlineDesc()->Offset;
     Descriptor *Desc = Next == 0 ? getDeclDesc() : getDescriptor(Next)->Desc;
     if (!Desc->IsArray)
       return *this;
     return Pointer(Pointee, Next, Offset);
   }
 
+  /// Compares two pointers for equality.
+  bool operator==(const Pointer &RHS) const;
+
   /// Checks if the pointer is null.
   bool isZero() const { return Pointee == nullptr; }
+  /// Checks if the pointer is not null.
+  bool isNonZero() 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 && Base != RootPtrMark; }
+  /// Checks if the pointer is weak.
+  bool isWeak() const { return false; }
 
   /// 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 {
     if (Base == RootPtrMark) {
       assert(Offset == PastEndMark && "cannot get base of a block");
       return Pointer(Pointee, Base, 0);
     }
     assert(Offset == Base && "not an inner field");
     unsigned NewBase = Base - getInlineDesc()->Offset;
     return Pointer(Pointee, NewBase, NewBase);
   }
   /// Returns the parent array.
   Pointer getArray() const {
     if (Base == RootPtrMark) {
       assert(Offset != 0 && Offset != PastEndMark && "not an array element");
       return Pointer(Pointee, Base, 0);
     }
     assert(Offset != Base && "not an array element");
     return Pointer(Pointee, Base, Base);
   }
+  /// Returns the containing object.
+  Pointer getContainingObject() const {
+    return isArrayElement() ? getArray() : getBase();
+  }
 
   /// Accessors for information about the innermost field.
   Descriptor *getFieldDesc() const {
     if (Base == 0 || Base == RootPtrMark)
       return getDeclDesc();
     return getInlineDesc()->Desc;
   }
 
bool isUnknownSizeArray() const {
     return getFieldDesc()->isUnknownSizeArray();
   }
   /// Checks if the pointer points to an array.
   bool isArrayElement() const { return Base != Offset; }
   /// Pointer points directly to a block.
   bool isRoot() const {
     return (Base == 0 || Base == RootPtrMark) && Offset == 0;
   }
-
+  /// Returns the element type, if a primitive.
+  llvm::Optional<PrimType> elementPrimType() const {
+    return getFieldDesc()->ElemTy;
+  }
   /// Returns the record descriptor of a class.
   Record *getRecord() const { return getFieldDesc()->ElemRecord; }
   /// Returns the field information.
   const FieldDecl *getField() const { return getFieldDesc()->asFieldDecl(); }
 
   /// Checks if the object is a union.
   bool isUnion() const;
 
public:
   bool isConst() const {
     return Base == 0 ? getDeclDesc()->IsConst : getInlineDesc()->IsConst;
   }
 
   /// Returns the declaration ID.
   llvm::Optional<unsigned> getDeclID() const { return Pointee->getDeclID(); }
 
   /// Returns the byte offset from the start.
-  unsigned getByteOffset() const {
-    return Offset;
-  }
+  unsigned getByteOffset() const { return Offset; }
 
   /// Returns the number of elements.
   unsigned getNumElems() const { return getSize() / elemSize(); }
 
   /// Returns the index into an array.
   int64_t getIndex() const {
     if (isElementPastEnd())
       return 1;
public:
   /// 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);
+  bool hasSameBase(const Pointer &B) const;
   /// Checks if two pointers can be subtracted.
-  static bool hasSameArray(const Pointer &A, const Pointer &B);
+  bool hasSameArray(const Pointer &B) const;
+  /// Compares two pointers from the same block.
+  CmpResult compare(const Pointer &RHS) const;
 
   /// Prints the pointer.
   void print(llvm::raw_ostream &OS) const {
     OS << "{" << Base << ", " << Offset << ", ";
     if (Pointee)
       OS << Pointee->getSize();
     else
       OS << "nullptr";

clang/lib/AST/Interp/Pointer.cpp

void Pointer::activate() const {
   assert(Base != 0 && "Only composite fields can be initialised");
   getInlineDesc()->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::hasSameBase(const Pointer &B) const {
+  return Pointee == B.Pointee;
 }
 
-bool Pointer::hasSameArray(const Pointer &A, const Pointer &B) {
-  return A.Base == B.Base && A.getFieldDesc()->IsArray;
+bool Pointer::hasSameArray(const Pointer &B) const {
+  return Base == B.Base && getFieldDesc()->IsArray;
+}
+
+CmpResult Pointer::compare(const Pointer &RHS) const {
+  return Compare(Offset, RHS.Offset);
+}
+
+bool Pointer::operator==(const Pointer &RHS) const {
+  return Base == RHS.Base && Offset == RHS.Offset;
 }

clang/lib/AST/Interp/PrimType.h

-//===--- PrimType.h - Types for the constexpr VM --------------------*- C++ -*-===//
+//===--- PrimType.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
+#ifndef LLVM_CLANG_AST_INTERP_PRIMTYPE_H
+#define LLVM_CLANG_AST_INTERP_PRIMTYPE_H
 
 #include <climits>
 #include <cstddef>
 #include <cstdint>
 #include "Boolean.h"
 #include "Integral.h"
 #include "Pointer.h"
 

 /// 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 *);
 }
 
-inline bool isPrimitiveIntegral(PrimType Type) {
+constexpr bool isPrimitiveIntegral(PrimType Type) {
   switch (Type) {
   case PT_Bool:
   case PT_Sint8:
   case PT_Uint8:
   case PT_Sint16:
   case PT_Uint16:
   case PT_Sint32:
   case PT_Uint32:
   case PT_Sint64:
   case PT_Uint64:
     return true;
   default:
     return false;
   }
 }
 
+constexpr bool isFixedIntegral(PrimType Type) {
+  // TODO: add fixed integral types here.
+  switch (Type) {
+  default:
+    return false;
+  }
+}
+
+constexpr bool isIntegral(PrimType Type) {
+  return isPrimitiveIntegral(Type) || isFixedIntegral(Type);
+}
+
+inline bool isFixedReal(PrimType Type) {
+  // TODO: add fixed real types here.
+  return false;
+}
+
+constexpr bool isPointer(PrimType Type) {
+  // TODO: add other pointer types here.
+  switch (Type) {
+    case PT_Ptr:
+      return true;
+    default:
+      return false;
+  }
+}
+
 } // 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_CASE(Name, B) \
   case Name: { using T = PrimConv<Name>::T; do {B;} while(0); break; }
-#define TYPE_SWITCH(Expr, B)                                                   \
-  switch (Expr) {                                                              \
-    TYPE_SWITCH_CASE(PT_Sint8, B)                                              \
-    TYPE_SWITCH_CASE(PT_Uint8, B)                                              \
-    TYPE_SWITCH_CASE(PT_Sint16, B)                                             \
-    TYPE_SWITCH_CASE(PT_Uint16, B)                                             \
-    TYPE_SWITCH_CASE(PT_Sint32, B)                                             \
-    TYPE_SWITCH_CASE(PT_Uint32, B)                                             \
-    TYPE_SWITCH_CASE(PT_Sint64, B)                                             \
-    TYPE_SWITCH_CASE(PT_Uint64, B)                                             \
-    TYPE_SWITCH_CASE(PT_Bool, B)                                               \
+#define NUMERIC_CASES(B)                                                       \
+  TYPE_SWITCH_CASE(PT_Sint8, B)                                                \
+  TYPE_SWITCH_CASE(PT_Uint8, B)                                                \
+  TYPE_SWITCH_CASE(PT_Sint16, B)                                               \
+  TYPE_SWITCH_CASE(PT_Uint16, B)                                               \
+  TYPE_SWITCH_CASE(PT_Sint32, B)                                               \
+  TYPE_SWITCH_CASE(PT_Uint32, B)                                               \
+  TYPE_SWITCH_CASE(PT_Sint64, B)                                               \
+  TYPE_SWITCH_CASE(PT_Uint64, B)                                               \
+  TYPE_SWITCH_CASE(PT_Bool, B)
+#define TYPE_SWITCH(Expr, B)                                                   \
+  switch (Expr) {                                                              \
+    NUMERIC_CASES(B)                                                           \
     TYPE_SWITCH_CASE(PT_Ptr, B)                                                \
   }
 #define COMPOSITE_TYPE_SWITCH(Expr, B, D)                                      \
   switch (Expr) {                                                              \
     TYPE_SWITCH_CASE(PT_Ptr, B)                                                \
-    default: do { D; } while(0); break;                                        \
+    default: do { D; } while (0); break;                                       \
   }
 #define INT_TYPE_SWITCH(Expr, B)                                               \
   switch (Expr) {                                                              \
     TYPE_SWITCH_CASE(PT_Sint8, B)                                              \
     TYPE_SWITCH_CASE(PT_Uint8, B)                                              \
     TYPE_SWITCH_CASE(PT_Sint16, B)                                             \
     TYPE_SWITCH_CASE(PT_Uint16, B)                                             \
     TYPE_SWITCH_CASE(PT_Sint32, B)                                             \
     TYPE_SWITCH_CASE(PT_Uint32, B)                                             \
     TYPE_SWITCH_CASE(PT_Sint64, B)                                             \
     TYPE_SWITCH_CASE(PT_Uint64, B)                                             \
     default: llvm_unreachable("not an integer");                               \
   }
+
 #endif

clang/lib/AST/Interp/Program.h

 //===--- 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 <map>
-#include <vector>
 #include "Function.h"
 #include "Pointer.h"
 #include "PrimType.h"
 #include "Record.h"
 #include "Source.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;
+class Program;
 
-/// The program contains and links the bytecode for all functions.
-class Program {
+/// Type used to reference a global.
+class GlobalLocation {
 public:
-  Program(Context &Ctx) : Ctx(Ctx) {}
+  GlobalLocation() : Index(static_cast<unsigned>(-1)) {}
+  GlobalLocation(unsigned Index) : Index(Index) {}
 
-  /// Emits a string literal among global data.
-  unsigned createGlobalString(const StringLiteral *S);
+  void print(llvm::raw_ostream &OS) { OS << "{" << Index << "}"; }
 
-  /// Returns a pointer to a global.
-  Pointer getPtrGlobal(unsigned Idx);
+private:
+  friend class Program;
+  unsigned Index;
+};
 
-  /// Returns the value of a global.
-  Block *getGlobal(unsigned Idx) {
-    assert(Idx < Globals.size());
-    return Globals[Idx]->block();
-  }
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, GlobalLocation G) {
+  G.print(OS);
+  return OS;
 
-  /// Finds a global's index.
-  llvm::Optional<unsigned> getGlobal(const ValueDecl *VD);
-
-  /// Returns or creates a global an creates an index to it.
-  llvm::Optional<unsigned> getOrCreateGlobal(const ValueDecl *VD);
-
-  /// Returns or creates a dummy value for parameters.
-  llvm::Optional<unsigned> getOrCreateDummy(const ParmVarDecl *PD);
-
-  /// Creates a global and returns its index.
-  llvm::Optional<unsigned> createGlobal(const ValueDecl *VD);
-
-  /// Creates a global from a lifetime-extended temporary.
-  llvm::Optional<unsigned> createGlobal(const Expr *E);
+/// The program contains and links the bytecode for all functions.
+class Program {
+public:
+  Program(Context &Ctx) : Ctx(Ctx) {}
 
   /// 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) {
+  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);
+  llvm::Expected<Function *> getOrCreateFunction(State &S,
+                                                 const FunctionDecl *F);
 
   /// Creates a descriptor for a primitive type.
   Descriptor *createDescriptor(const DeclTy &D, PrimType Type,
-                               bool IsConst = false,
-                               bool IsTemporary = false,
+                               bool IsConst = false, bool IsTemporary = false,
                                bool IsMutable = false) {
     return allocateDescriptor(D, Type, IsConst, IsTemporary, IsMutable);
   }
 
-  /// Creates a descriptor for a composite type.
-  Descriptor *createDescriptor(const DeclTy &D, const Type *Ty,
-                               bool IsConst = false, bool IsTemporary = false,
-                               bool IsMutable = false);
-
-  /// Context to manage declaration lifetimes.
-  class DeclScope {
-  public:
-    DeclScope(Program &P, const VarDecl *VD) : P(P) { P.startDeclaration(VD); }
-    ~DeclScope() { P.endDeclaration(); }
-
-  private:
-    Program &P;
-  };
-
-  /// Returns the current declaration ID.
-  llvm::Optional<unsigned> getCurrentDecl() const {
-    if (CurrentDeclaration == NoDeclaration)
-      return llvm::Optional<unsigned>{};
-    return LastDeclaration;
-  }
-
 private:
   friend class DeclScope;
-
-  llvm::Optional<unsigned> createGlobal(const DeclTy &D, QualType Ty,
-                                        bool IsStatic, bool IsExtern);
-
-  /// 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.
-    template <typename... Tys>
-    Global(Tys... Args) : B(std::forward<Tys>(Args)...) {}
-
-    /// 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;
-
-  /// Dummy parameter to generate pointers from.
-  llvm::DenseMap<const ParmVarDecl *, unsigned> DummyParams;
-
   /// Creates a new descriptor.
-  template <typename... Ts>
-  Descriptor *allocateDescriptor(Ts &&... Args) {
+  template <typename... Ts> Descriptor *allocateDescriptor(Ts &&... Args) {
     return new (Allocator) Descriptor(std::forward<Ts>(Args)...);
   }
 
-  /// No declaration ID.
-  static constexpr unsigned NoDeclaration = (unsigned)-1;
-  /// Last declaration ID.
-  unsigned LastDeclaration = 0;
-  /// Current declaration ID.
-  unsigned CurrentDeclaration = NoDeclaration;
-
-  /// Starts evaluating a declaration.
-  void startDeclaration(const VarDecl *Decl) {
-    LastDeclaration += 1;
-    CurrentDeclaration = LastDeclaration;
-  }
-
-  /// Ends a global declaration.
-  void endDeclaration() {
-    CurrentDeclaration = NoDeclaration;
-  }
-
 public:
   /// Dumps the disassembled bytecode to \c llvm::errs().
   void dump() const;
   void dump(llvm::raw_ostream &OS) const;
 };
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Program.cpp

 #include "Opcode.h"
 #include "PrimType.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 
 using namespace clang;
 using namespace clang::interp;
 
-unsigned Program::createGlobalString(const StringLiteral *S) {
-  const size_t CharWidth = S->getCharByteWidth();
-  const size_t BitWidth = CharWidth * Ctx.getCharBit();
-
-  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 *Desc = allocateDescriptor(S, CharType, S->getLength() + 1,
-                                        /*isConst=*/true,
-                                        /*isTemporary=*/false,
-                                        /*isMutable=*/false);
-
-  // Allocate storage for the string.
-  // The byte length does not include the null terminator.
-  unsigned I = Globals.size();
-  unsigned Sz = Desc->getAllocSize();
-  auto *G = new (Allocator, Sz) Global(Desc, /*isStatic=*/true,
-                                       /*isExtern=*/false);
-  Globals.push_back(G);
-
-  // Construct the string in storage.
-  const Pointer Ptr(G->block());
-  for (unsigned I = 0, N = S->getLength(); I <= N; ++I) {
-    Pointer Field = Ptr.atIndex(I).narrow();
-    const uint32_t CodePoint = I == N ? 0 : S->getCodeUnit(I);
-    switch (CharType) {
-      case PT_Sint8: {
-        using T = PrimConv<PT_Sint8>::T;
-        Field.deref<T>() = T::from(CodePoint, BitWidth);
-        break;
-      }
-      case PT_Uint16: {
-        using T = PrimConv<PT_Uint16>::T;
-        Field.deref<T>() = T::from(CodePoint, BitWidth);
-        break;
-      }
-      case PT_Uint32: {
-        using T = PrimConv<PT_Uint32>::T;
-        Field.deref<T>() = T::from(CodePoint, BitWidth);
-        break;
-      }
-      default:
-        llvm_unreachable("unsupported character type");
-    }
-  }
-  return I;
-}
-
-Pointer Program::getPtrGlobal(unsigned Idx) {
-  assert(Idx < Globals.size());
-  return Pointer(Globals[Idx]->block());
-}
-
-llvm::Optional<unsigned> Program::getGlobal(const ValueDecl *VD) {
-  auto It = GlobalIndices.find(VD);
-  if (It != GlobalIndices.end())
-    return It->second;
-
-  // Find any previous declarations which were aleady evaluated.
-  llvm::Optional<unsigned> Index;
-  for (const Decl *P = VD; P; P = P->getPreviousDecl()) {
-    auto It = GlobalIndices.find(P);
-    if (It != GlobalIndices.end()) {
-      Index = It->second;
-      break;
-    }
-  }
-
-  // Map the decl to the existing index.
-  if (Index) {
-    GlobalIndices[VD] = *Index;
-    return {};
-  }
-
-  return Index;
-}
-
-llvm::Optional<unsigned> Program::getOrCreateGlobal(const ValueDecl *VD) {
-  if (auto Idx = getGlobal(VD))
-    return Idx;
-
-  if (auto Idx = createGlobal(VD)) {
-    GlobalIndices[VD] = *Idx;
-    return Idx;
-  }
-  return {};
-}
-
-llvm::Optional<unsigned> Program::getOrCreateDummy(const ParmVarDecl *PD) {
-  auto &ASTCtx = Ctx.getASTContext();
-
-  // Create a pointer to an incomplete array of the specified elements.
-  QualType ElemTy = PD->getType()->castAs<PointerType>()->getPointeeType();
-  QualType Ty = ASTCtx.getIncompleteArrayType(ElemTy, ArrayType::Normal, 0);
-
-  // Dedup blocks since they are immutable and pointers cannot be compared.
-  auto It = DummyParams.find(PD);
-  if (It != DummyParams.end())
-    return It->second;
-
-  if (auto Idx = createGlobal(PD, Ty, /*isStatic=*/true, /*isExtern=*/true)) {
-    DummyParams[PD] = *Idx;
-    return Idx;
-  }
-  return {};
-}
-
-llvm::Optional<unsigned> Program::createGlobal(const ValueDecl *VD) {
-  bool IsStatic, IsExtern;
-  if (auto *Var = dyn_cast<VarDecl>(VD)) {
-    IsStatic = !Var->hasLocalStorage();
-    IsExtern = !Var->getAnyInitializer();
-  } else {
-    IsStatic = false;
-    IsExtern = true;
-  }
-  if (auto Idx = createGlobal(VD, VD->getType(), IsStatic, IsExtern)) {
-    for (const Decl *P = VD; P; P = P->getPreviousDecl())
-      GlobalIndices[P] = *Idx;
-    return *Idx;
-  }
-  return {};
-}
-
-llvm::Optional<unsigned> Program::createGlobal(const Expr *E) {
-  return createGlobal(E, E->getType(), /*isStatic=*/true, /*isExtern=*/false);
-}
-
-llvm::Optional<unsigned> Program::createGlobal(const DeclTy &D, QualType Ty,
-                                               bool IsStatic, bool IsExtern) {
-  // Create a descriptor for the global.
-  Descriptor *Desc;
-  const bool IsConst = Ty.isConstQualified();
-  const bool IsTemporary = D.dyn_cast<const Expr *>();
-  if (auto T = Ctx.classify(Ty)) {
-    Desc = createDescriptor(D, *T, IsConst, IsTemporary);
-  } else {
-    Desc = createDescriptor(D, Ty.getTypePtr(), IsConst, IsTemporary);
-  }
-  if (!Desc)
-    return {};
-
-  // Allocate a block for storage.
-  unsigned I = Globals.size();
-
-  auto *G = new (Allocator, Desc->getAllocSize())
-      Global(getCurrentDecl(), Desc, IsStatic, IsExtern);
-  G->block()->invokeCtor();
-
-  Globals.push_back(G);
-
-  return I;
-}
-
 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)) {
+llvm::Expected<Function *> Program::getOrCreateFunction(State &S,
+                                                        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 ByteCodeStmtGen<ByteCodeEmitter>(Ctx, *this).compileFunc(FD);
+    return ByteCodeStmtGen<ByteCodeEmitter>(Ctx, *this, S).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 VirtSize = 0;
-
-  // Helper to get a base descriptor.
-  auto GetBaseDesc = [this](const RecordDecl *BD, Record *BR) -> Descriptor * {
-    if (!BR)
-      return nullptr;
-    return allocateDescriptor(BD, BR, /*isConst=*/false,
-                              /*isTemporary=*/false,
-                              /*isMutable=*/false);
-  };
-
-  // Reserve space for base classes.
-  Record::BaseList Bases;
-  Record::VirtualBaseList VirtBases;
-  if (auto *CD = dyn_cast<CXXRecordDecl>(RD)) {
-    for (const CXXBaseSpecifier &Spec : CD->bases()) {
-      if (Spec.isVirtual())
-        continue;
-
-      const RecordDecl *BD = Spec.getType()->castAs<RecordType>()->getDecl();
-      Record *BR = getOrCreateRecord(BD);
-      if (Descriptor *Desc = GetBaseDesc(BD, BR)) {
-        Size += align(sizeof(InlineDescriptor));
-        Bases.push_back({BD, Size, Desc, BR});
-        Size += align(BR->getSize());
-        continue;
-      }
-      return nullptr;
-    }
-
-    for (const CXXBaseSpecifier &Spec : CD->vbases()) {
-      const RecordDecl *BD = Spec.getType()->castAs<RecordType>()->getDecl();
-      Record *BR = getOrCreateRecord(BD);
-
-      if (Descriptor *Desc = GetBaseDesc(BD, BR)) {
-        VirtSize += align(sizeof(InlineDescriptor));
-        VirtBases.push_back({BD, VirtSize, Desc, BR});
-        VirtSize += align(BR->getSize());
-        continue;
-      }
-      return nullptr;
-    }
-  }
-
-  // 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 IsConst = FT.isConstQualified();
-    const bool IsMutable = FD->isMutable();
-    Descriptor *Desc;
-    if (llvm::Optional<PrimType> T = Ctx.classify(FT)) {
-      Desc = createDescriptor(FD, *T, IsConst, /*isTemporary=*/false,
-                              IsMutable);
-    } else {
-      Desc = createDescriptor(FD, FT.getTypePtr(), IsConst,
-                              /*isTemporary=*/false, IsMutable);
-    }
-    if (!Desc)
-      return nullptr;
-    Fields.push_back({FD, Size, Desc});
-    Size += align(Desc->getAllocSize());
-  }
-
-  Record *R = new (Allocator) Record(RD, std::move(Bases), std::move(Fields),
-                                     std::move(VirtBases), VirtSize, Size);
-  Records.insert({RD, R});
-  return R;
-}
-
-Descriptor *Program::createDescriptor(const DeclTy &D, const Type *Ty,
-                                      bool IsConst, bool IsTemporary,
-                                      bool IsMutable) {
-  // Classes and structures.
-  if (auto *RT = Ty->getAs<RecordType>()) {
-    if (auto *Record = getOrCreateRecord(RT->getDecl()))
-      return allocateDescriptor(D, Record, IsConst, IsTemporary, IsMutable);
-  }
-
-  // Arrays.
-  if (auto ArrayType = Ty->getAsArrayTypeUnsafe()) {
-    QualType ElemTy = ArrayType->getElementType();
-    // Array of well-known bounds.
-    if (auto CAT = dyn_cast<ConstantArrayType>(ArrayType)) {
-      size_t NumElems = CAT->getSize().getZExtValue();
-      if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {
-        // Arrays of primitives.
-        unsigned ElemSize = primSize(*T);
-        if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems) {
-          return {};
-        }
-        return allocateDescriptor(D, *T, NumElems, IsConst, IsTemporary,
-                                  IsMutable);
-      } else {
-        // Arrays of composites. In this case, the array is a list of pointers,
-        // followed by the actual elements.
-        Descriptor *Desc =
-            createDescriptor(D, ElemTy.getTypePtr(), IsConst, IsTemporary);
-        if (!Desc)
-          return nullptr;
-        InterpSize ElemSize = Desc->getAllocSize() + sizeof(InlineDescriptor);
-        if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems)
-          return {};
-        return allocateDescriptor(D, Desc, NumElems, IsConst, IsTemporary,
-                                  IsMutable);
-      }
-    }
-
-    // Array of unknown bounds - cannot be accessed and pointer arithmetic
-    // is forbidden on pointers to such objects.
-    if (isa<IncompleteArrayType>(ArrayType)) {
-      if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {
-        return allocateDescriptor(D, *T, IsTemporary,
-                                  Descriptor::UnknownSize{});
-      } else {
-        Descriptor *Desc =
-            createDescriptor(D, ElemTy.getTypePtr(), IsConst, IsTemporary);
-        if (!Desc)
-          return nullptr;
-        return allocateDescriptor(D, Desc, IsTemporary,
-                                  Descriptor::UnknownSize{});
-      }
-    }
-  }
-
-  // Atomic types.
-  if (auto *AT = Ty->getAs<AtomicType>()) {
-    const Type *InnerTy = AT->getValueType().getTypePtr();
-    return createDescriptor(D, InnerTy, IsConst, IsTemporary, IsMutable);
-  }
-
-  // Complex types - represented as arrays of elements.
-  if (auto *CT = Ty->getAs<ComplexType>()) {
-    PrimType ElemTy = *Ctx.classify(CT->getElementType());
-    return allocateDescriptor(D, ElemTy, 2, IsConst, IsTemporary, IsMutable);
-  }
-
-  return nullptr;
-}

clang/lib/AST/Interp/Source.h

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() {
-    T Value = ReadHelper<T>(Ptr);
+    T Result;
+    memcpy(&Result, Ptr, sizeof(T));
     Ptr += sizeof(T);
-    return Value;
+    return Result;
   }
 
 private:
   /// Constructor used by Function to generate pointers.
   CodePtr(const char *Ptr) : Ptr(Ptr) {}
 
-  /// Helper to decode a value or a pointer.
-  template <typename T>
-  static std::enable_if_t<!std::is_pointer<T>::value, T>
-  ReadHelper(const char *Ptr) {
-    using namespace llvm::support;
-    return endian::read<T, endianness::native, 1>(Ptr);
-  }
-
-  template <typename T>
-  static std::enable_if_t<std::is_pointer<T>::value, T>
-  ReadHelper(const char *Ptr) {
-    using namespace llvm::support;
-    auto Punned = endian::read<uintptr_t, endianness::native, 1>(Ptr);
-    return reinterpret_cast<T>(Punned);
-  }
-
 private:
   friend class Function;
 
   /// Pointer into the code owned by a function.
   const char *Ptr;
 };
 
 /// Describes the statement/declaration an opcode was generated from.

 
 /// 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

clang/lib/AST/Interp/Source.cpp

 //===--- 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 "Program.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();
-}

clang/test/AST/Interp/cond.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fexperimental-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;
   }
 }
+
+static_assert(cond_then_else(10, 20) == 10);
+static_assert(cond_then_else(30, 10) == 20);
+
+constexpr int cond_empty_then(int a) {
+  if (a < 0)
+    ;
+  return 1;
+}
+
+static_assert(cond_empty_then(0) == 1);
+
+constexpr int cond_else(int a) {
+  if (a < 0)
+    return 10;
+  return 1;
+}
+
+static_assert(cond_else(-1) == 10);
+static_assert(cond_else(1) == 1);
+
+constexpr int cond_decl(int a) {
+  if (int b = a + 1)
+    return b - 1;
+  else
+    return b + 1;
+}
+
+static_assert(cond_decl(-1) == 1);
+static_assert(cond_decl(5) == 5);
+
+constexpr int cond_decl_init(int a) {
+  if (int b = a + 1; b != 0)
+    return b - 1;
+  else
+    return b + 1;
+}
+
+static_assert(cond_decl_init(-1) == 1);
+static_assert(cond_decl_init(5) == 5);