[ConstExprPreter] Full patch of the interpreter.

[nand]

Summary

Constant expression interpreter - see ConstantInterpreter.rst.

[nand]

Added more features

[nand]

minor fixes

clang/docs/ConstantInterpreter.rst

 TODO
 ====
 
 Missing Language Features
 -------------------------
 
 * Definition of externs must override previous declaration
 * Changing the active field of unions
-* Union copy constructors
 * ``typeid``
 * ``volatile``
 * ``__builtin_constant_p``
 * ``std::initializer_list``
 * lambdas
 * range-based for loops
 * ``vector_size``
 * ``dynamic_cast``
 
 Known Bugs
 ----------
 
-* Pointer comparison for equality needs to narrow/expand pointers
 * If execution fails, memory storing APInts and APFloats is leaked when the stack is cleared

clang/lib/AST/CMakeLists.txt

add_clang_library(clangAST
   ExprConstant.cpp
   ExprCXX.cpp
   ExprObjC.cpp
   ExternalASTMerger.cpp
   ExternalASTSource.cpp
   FormatString.cpp
   InheritViz.cpp
   Interp/Block.cpp
+  Interp/Boolean.cpp
+  Interp/Builtin.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/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/ExprConstant.cpp

public:
     bool checkingForUndefinedBehavior() const override {
       return CheckingForUndefinedBehavior;
     }
 
     EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
         : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
           CallStackDepth(0), NextCallIndex(1),
           StepsLeft(getLangOpts().ConstexprStepLimit),
-          ForceNewConstInterp(getLangOpts().ForceNewConstInterp),
+          ForceNewConstInterp(true || getLangOpts().ForceNewConstInterp),
           EnableNewConstInterp(ForceNewConstInterp ||
                                getLangOpts().EnableNewConstInterp),
           BottomFrame(*this, SourceLocation(), nullptr, nullptr, nullptr),
           EvaluatingDecl((const ValueDecl *)nullptr),
           EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
           HasFoldFailureDiagnostic(false), InConstantContext(false),
           EvalMode(Mode) {}
 
static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This,
 
   // For any other type, in-place evaluation is unimportant.
   return Evaluate(Result, Info, E);
 }
 
 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
 /// lvalue-to-rvalue cast if it is an lvalue.
 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
-   if (Info.EnableNewConstInterp) {
     auto &InterpCtx = Info.Ctx.getInterpContext();
     switch (InterpCtx.evaluateAsRValue(Info, E, Result)) {
     case interp::InterpResult::Success:
       return true;
     case interp::InterpResult::Fail:
       return false;
     case interp::InterpResult::Bail:
       break;
if (Info.EnableNewConstInterp) {
     case interp::InterpResult::Success:
     case interp::InterpResult::Fail:
       return Diags.empty();
     case interp::InterpResult::Bail:
       break;
     }
   }
 
+  // The constexpr VM attempts to compile all methods to bytecode here.
+  if (Info.EnableNewConstInterp) {
+    auto &InterpCtx = Info.Ctx.getInterpContext();
+    switch (InterpCtx.isPotentialConstantExpr(Info, FD)) {
+    case interp::InterpResult::Success:
+    case interp::InterpResult::Fail:
+      return Diags.empty();
+    case interp::InterpResult::Bail:
+      break;
+    }
+  }
+
   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
   const CXXRecordDecl *RD = MD ? MD->getParent()->getCanonicalDecl() : nullptr;
 
   // Fabricate an arbitrary expression on the stack and pretend that it
   // is a temporary being used as the 'this' pointer.
   LValue This;
   ImplicitValueInitExpr VIE(RD ? Info.Ctx.getRecordType(RD) : Info.Ctx.IntTy);
   This.set({&VIE, Info.CurrentCall->Index});

clang/lib/AST/Interp/Block.h

public:
   /// Checks if the block has any live pointers.
   bool hasPointers() const { return Pointers; }
   /// Checks if the block is extern.
   bool isExtern() const { return IsExtern; }
   /// Checks if the block has static storage duration.
   bool isStatic() const { return IsStatic; }
   /// Checks if the block is temporary.
   bool isTemporary() const { return Desc->IsTemporary; }
+  /// Checks if the block is constant.
+  bool isConst() const { return Desc->IsConst; }
   /// Returns the size of the block.
   InterpSize getSize() const { return Desc->getAllocSize(); }
   /// Returns the declaration ID.
   llvm::Optional<unsigned> getDeclID() const { return DeclID; }
 
   /// Returns a pointer to the stored data.
   char *data() { return reinterpret_cast<char *>(this + 1); }
 

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 "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);
+    if (!V && RHS.V)
+      return ComparisonCategoryResult::Less;
+    if (V && !RHS.V)
+      return ComparisonCategoryResult::Greater;
+    return ComparisonCategoryResult::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 typename std::enable_if<std::is_integral<T>::value, Boolean>::type
   from(T Value) {
     return Boolean(Value != 0);
   }
 
   template <unsigned SrcBits, bool SrcSign>
-  static typename std::enable_if<SrcBits != 0, Boolean>::type 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/Builtin.h

+//===--- Builtin.h - Builtins for the constexpr VM --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Builtin dispatch method definition.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_BUILTIN_H
+#define LLVM_CLANG_AST_INTERP_BUILTIN_H
+
+#include "Function.h"
+
+namespace clang {
+namespace interp {
+class InterpState;
+
+bool InterpBuiltin(InterpState &S, CodePtr OpPC, unsigned BuiltinOp);
+
+} // namespace interp
+} // namespace clang
+
+#endif

clang/lib/AST/Interp/Builtin.cpp

+//===--- Builtin.cpp - Builtins for the constexpr VM ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Builtin.h"
+#include "InterpState.h"
+#include "Pointer.h"
+#include "Program.h"
+#include "PrimType.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/Basic/Builtins.h"
+
+using namespace clang;
+using namespace clang::interp;
+
+static bool BuiltinLength(InterpState &S, CodePtr OpPC) {
+  using ResultT = PrimConv<PT_Uint64>::T;
+  // Get the pointer to the string and ensure it's an array of primitives.
+  const auto &Ptr = S.Stk.pop<Pointer>();
+  if (!Ptr.inPrimitiveArray())
+    return false;
+  if (!S.CheckLoad(OpPC, Ptr))
+    return false;
+
+  // Find the null terminator, starting at the pointed element.
+  const unsigned Size = Ptr.getSize() - Ptr.getOffset();
+  char *Data = &Ptr.narrow().deref<char>();
+  switch (Ptr.elemSize()) {
+  case 1:
+    for (unsigned Off = 0, I = 0; Off < Size; Off += 1, ++I) {
+      if (*reinterpret_cast<int8_t *>(Data + Off) == 0) {
+        S.Stk.push<ResultT>(ResultT::from(I));
+        return true;
+      }
+    }
+    break;
+  case 2:
+    for (unsigned Off = 0, I = 0; Off < Size; Off += 2, ++I) {
+      if (*reinterpret_cast<uint16_t *>(Data + Off) == 0) {
+        S.Stk.push<ResultT>(ResultT::from(I));
+        return true;
+      }
+    }
+    break;
+  case 4:
+    for (unsigned Off = 0, I = 0; Off < Size; Off += 4, ++I) {
+      if (*reinterpret_cast<uint32_t *>(Data + Off) == 0) {
+        S.Stk.push<ResultT>(ResultT::from(I));
+        return true;
+      }
+    }
+    break;
+  default:
+    llvm_unreachable("Unsupported character width!");
+  }
+
+  S.FFDiag(S.getSource(OpPC), diag::note_constexpr_access_past_end) << AK_Read;
+  return false;
+}
+
+static void ReportInvalidExpr(InterpState &S, CodePtr OpPC, unsigned Op) {
+  const char *Name = S.getCtx().BuiltinInfo.getName(Op);
+
+  if (S.getLangOpts().CPlusPlus11)
+    S.CCEDiag(S.getSource(OpPC), diag::note_constexpr_invalid_function)
+        << /*isConstexpr*/ 0 << /*isConstructor*/ 0
+        << (std::string("'") + Name + "'");
+  else
+    S.CCEDiag(S.getSource(OpPC), diag::note_invalid_subexpr_in_const_expr);
+}
+
+namespace clang {
+namespace interp {
+
+bool InterpBuiltin(InterpState &S, CodePtr OpPC, unsigned Op) {
+  switch (Op) {
+  case Builtin::BIstrlen:
+  case Builtin::BIwcslen:
+    ReportInvalidExpr(S, OpPC, Op);
+    return BuiltinLength(S, OpPC);
+  case Builtin::BI__builtin_strlen:
+  case Builtin::BI__builtin_wcslen:
+    return BuiltinLength(S, OpPC);
+  default:
+    // Builtin is not constexpr.
+    return false;
+  }
+}
+
+} // namespace interp
+} // namespace clang

clang/lib/AST/Interp/ByteCodeExprGen.h

 
 public:
   /// Initializes the compiler and the backend emitter.
   template <typename... Tys>
   ByteCodeExprGen(Context &Ctx, Program &P, Tys &&... Args)
       : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
 
   // Expression visitors - result returned on stack.
+  bool VisitDeclRefExpr(const DeclRefExpr *E);
   bool VisitCastExpr(const CastExpr *E);
+  bool VisitConstantExpr(const ConstantExpr *E);
   bool VisitIntegerLiteral(const IntegerLiteral *E);
+  bool VisitFloatingLiteral(const FloatingLiteral *E);
+  bool VisitStringLiteral(const StringLiteral *E);
+  bool VisitCharacterLiteral(const CharacterLiteral *E);
+  bool VisitImaginaryLiteral(const ImaginaryLiteral *E);
   bool VisitParenExpr(const ParenExpr *E);
   bool VisitBinaryOperator(const BinaryOperator *E);
+  bool VisitUnaryPostInc(const UnaryOperator *E);
+  bool VisitUnaryPostDec(const UnaryOperator *E);
+  bool VisitUnaryPreInc(const UnaryOperator *E);
+  bool VisitUnaryPreDec(const UnaryOperator *E);
+  bool VisitUnaryAddrOf(const UnaryOperator *E);
+  bool VisitUnaryDeref(const UnaryOperator *E);
+  bool VisitUnaryPlus(const UnaryOperator *E);
+  bool VisitUnaryMinus(const UnaryOperator *E);
+  bool VisitUnaryNot(const UnaryOperator *E);
+  bool VisitUnaryLNot(const UnaryOperator *E);
+  bool VisitUnaryReal(const UnaryOperator *E);
+  bool VisitUnaryImag(const UnaryOperator *E);
+  bool VisitConditionalOperator(const ConditionalOperator *E);
+  bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E);
+  bool VisitMemberExpr(const MemberExpr *E);
+  bool VisitCallExpr(const CallExpr *E);
+  bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
+  bool VisitExprWithCleanups(const ExprWithCleanups *E);
+  bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
+  bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
+  bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E);
+  bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E);
+  bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
+  bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
+  bool VisitOpaqueValueExpr(const OpaqueValueExpr *E);
+  bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E);
+  bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E);
+  bool VisitInitListExpr(const InitListExpr *E);
+  bool VisitTypeTraitExpr(const TypeTraitExpr *E);
+  bool VisitBlockExpr(const BlockExpr *E);
+  bool VisitCXXConstructExpr(const CXXConstructExpr *E);
+  bool VisitCXXMemberCallExpr(const CXXMemberCallExpr *E);
+  bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E);
+  bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E);
+  bool VisitCXXThisExpr(const CXXThisExpr *E);
+  bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E);
+  bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E);
+  bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E);
+  bool VisitCXXThrowExpr(const CXXThrowExpr *E);
+  bool VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E);
+  bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
+  bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E);
+  bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E);
+  bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
+  bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *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);
 
+  /// Perform an action if a record field is found.
+  bool withField(const FieldDecl *F,
+                 llvm::function_ref<bool(const Record::Field *)> GenField);
+
   /// 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 applicable fp semantics.
+  const fltSemantics *getFltSemantics(QualType Ty) {
+    return &Ctx.getASTContext().getFloatTypeSemantics(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 {
+    if (llvm::Optional<PrimType> T = classify(Ty))
+      return T != PT_MemPtr && T != PT_FnPtr;
     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 a base class initializer.
+  bool visitBaseInitializer(const Expr *Init, InitFnRef GenBase);
+
   /// 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.
private:
   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);
+  /// Emits a direct method call.
+  bool emitMethodCall(const CXXMethodDecl *Callee, llvm::Optional<PrimType> T,
+                      const Expr *Call);
+
+  /// Compiles an offset calculator.
+  bool visitOffset(const Expr *Ptr, const Expr *Offset, const Expr *E,
+                   UnaryFn OffsetFn);
+
+  /// Fetches a member of a structure given by a pointer.
+  bool visitIndirectMember(const BinaryOperator *E);
+
+  /// Compiles  simple or compound assignments.
+  bool visitAssign(PrimType T, const BinaryOperator *BO);
+  bool visitShiftAssign(PrimType RHS, BinaryFn F, const BinaryOperator *BO);
+  bool visitCompoundAssign(PrimType RHS, UnaryFn F, const BinaryOperator *BO);
+  bool visitPtrAssign(PrimType RHS, UnaryFn F, const BinaryOperator *BO);
+
+  /// Emits a cast between two types.
+  bool emitConv(PrimType From, QualType FromTy, PrimType To, QualType ToTy,
+                const Expr *Cast);
+
+  bool visitShortCircuit(const BinaryOperator *E);
+
   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,
                         DerefKind AK,
                         llvm::function_ref<bool(PrimType)> Direct,
                         llvm::function_ref<bool(PrimType)> Indirect);
   bool dereferenceVar(const Expr *LV, PrimType T, const VarDecl *PD,
                       DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
                       llvm::function_ref<bool(PrimType)> Indirect);
+  bool dereferenceMember(const MemberExpr *PD, PrimType T, 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);
   }
 
+  /// Compiles a list of arguments.
+  bool visitArguments(QualType CalleeTy, ArrayRef<const Expr *> Args);
+  /// Compiles an argument.
+  bool visitArgument(const Expr *E, bool Discard);
+
+  /// Visits a constant function invocation.
+  bool getPtrConstFn(const FunctionDecl *FD, const Expr *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 string initializer.
+  bool visitStringInitializer(const StringLiteral *S);
+  /// Compiles an array initializer.
+  bool visitArrayInitializer(const ConstantArrayType *AT,
+                             const Expr *E,
+                             llvm::function_ref<const Expr *(uint64_t)> Elem);
+  /// Visits a record initializer.
+  bool visitRecordInitializer(const RecordType *RT, const InitListExpr *List);
+  /// Visits a complex initializer.
+  bool visitComplexInitializer(const ComplexType *CT, const InitListExpr *List);
+
+  /// Visits a cast to complex.
+  bool visitCastToComplex(const CastExpr *CE);
+
+  /// Zero initializer for a record.
+  bool visitZeroInitializer(const Expr *E, const RecordDecl *RD);
+
+  /// Registers an opaque expression.
+  bool visitOpaqueExpr(const OpaqueValueExpr *Expr);
+  /// Visits a conditional operator.
+  bool visitConditionalOperator(const AbstractConditionalOperator *CO);
+
+  /// Materializes a composite.
+  bool materialize(const Expr *Alloc, const Expr *Init, bool IsConst,
+                   bool IsGlobal, bool IsExtended);
+
   /// Emits the initialized pointer.
   bool emitInitFn() {
-    assert(InitFn && "missing initializer");
-    return (*InitFn)();
+    return InitFn ? (*InitFn)() : this->emitTrap(SourceInfo{});
   }
 
+  /// Returns the alignment of a type.
+  CharUnits getAlignOfType(QualType T, bool IsPreferred);
+
+  /// Returns the alignment of an expresion.
+  CharUnits getAlignOfExpr(const Expr *E, bool IsPreferred);
+
 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;
 };
 
 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

 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;
+};
+
+// Scope which initialises a base class.
+template <class Emitter> class BaseScope : public OptionScope<Emitter> {
+public:
+  using ChainedInitFnRef = typename OptionScope<Emitter>::ChainedInitFnRef;
+  using InitKind = typename OptionScope<Emitter>::InitKind;
+  BaseScope(ByteCodeExprGen<Emitter> *Ctx, ChainedInitFnRef FieldFn)
+    : OptionScope<Emitter>(Ctx, FieldFn, InitKind::BASE) {}
+};
+
+// Scope which initialises a union field.
+template <class Emitter> class UnionScope : public OptionScope<Emitter> {
+public:
+  using ChainedInitFnRef = typename OptionScope<Emitter>::ChainedInitFnRef;
+  using InitKind = typename OptionScope<Emitter>::InitKind;
+  UnionScope(ByteCodeExprGen<Emitter> *Ctx, ChainedInitFnRef FieldFn)
+    : OptionScope<Emitter>(Ctx, FieldFn, InitKind::UNION) {}
+};
+
+// Scope which initialises a record field or array element.
+template <class Emitter> class FieldScope : public OptionScope<Emitter> {
+public:
+  using ChainedInitFnRef = typename OptionScope<Emitter>::ChainedInitFnRef;
+  using InitKind = typename OptionScope<Emitter>::InitKind;
+  FieldScope(ByteCodeExprGen<Emitter> *Ctx, ChainedInitFnRef FieldFn)
+    : OptionScope<Emitter>(Ctx, FieldFn, InitKind::ROOT) {}
 };
 
 } // 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()) {
+      return getPtrVarDecl(VD, 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 this->bail(DE);
+  }
+  if (auto *FD = dyn_cast<FunctionDecl>(DE->getDecl())) {
+    if (auto *CD = dyn_cast<CXXMethodDecl>(DE->getDecl()))
+      if (!CD->isStatic())
+        return this->emitConstMem(CD, DE);
+    return getPtrConstFn(FD, DE);
+  }
+  if (auto *FD = dyn_cast<FieldDecl>(DE->getDecl()))
+    return this->emitConstMem(FD, DE);
+
+  // 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 false;
+
+    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->emitCastFP(ArgT, RetT, getIntWidth(RetTy), CE);
+    else
+      return this->emitCast(ArgT, RetT, CE);
+  }
+
+  case CK_FloatingCast:
+  case CK_IntegralToFloating: {
+    if (DiscardResult)
+      return discard(SubExpr);
+
+    if (!visit(SubExpr))
+      return false;
+
+    QualType ArgTy = SubExpr->getType();
+    QualType RetTy = CE->getType();
+    auto ArgT = *classify(ArgTy);
+    return this->emitCastRealFP(ArgT, getFltSemantics(RetTy), CE);
+  }
+
+  case CK_FloatingToIntegral: {
+    if (!visit(SubExpr))
+      return false;
+
+    QualType RetTy = CE->getType();
+    PrimType ArgT = *classify(SubExpr->getType());
+    PrimType RetT = *classify(RetTy);
+    if (isFixedIntegral(RetT)) {
+      if (!this->emitCastRealFPToAluFP(ArgT, RetT, getIntWidth(RetTy), CE))
+        return false;
+    } else {
+      if (!this->emitCastRealFPToAlu(ArgT, RetT, CE))
+        return false;
+    }
+
+    return DiscardResult ? this->emitPop(RetT, CE) : true;
+  }
+
+  case CK_NullToPointer:
+  case CK_NullToMemberPointer:
+    // Emit a null pointer, avoiding redundancy when casting from nullptr.
+    if (!isa<CXXNullPtrLiteralExpr>(SubExpr)) {
+      if (!discard(SubExpr))
+    }
+    if (DiscardResult)
+      return true;
+    return visitZeroInitializer(classifyPrim(CE->getType()), CE);
+
+  case CK_PointerToBoolean: {
+    if (DiscardResult)
+      return discard(SubExpr);
+    else
+      return visit(SubExpr) && this->emitTestPtr(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);
 
+  case CK_IntegralRealToComplex:
+  case CK_FloatingRealToComplex:
+    return visitCastToComplex(CE);
+
+  case CK_DerivedToBase:
+  case CK_UncheckedDerivedToBase: {
+    if (!visit(SubExpr))
+      return false;
+
+    const Record *R = getRecord(SubExpr->getType());
+    if (!R)
+      return false;
+
+    for (auto *Step : CE->path()) {
+      auto *Decl = Step->getType()->getAs<RecordType>()->getDecl();
+
+      const Record::Base *Base;
+      if (Step->isVirtual()) {
+        Base = R->getVirtualBase(Decl);
+        if (!this->emitGetPtrVirtBase(Decl, CE))
+          return false;
+      } else {
+        Base = R->getBase(Decl);
+        if (!this->emitGetPtrBase(Base->Offset, CE))
+          return false;
+      }
+
+      R = Base->R;
+    }
+
+    return DiscardResult ? this->emitPopPtr(CE) : true;
+  }
+
+  case CK_BaseToDerived: {
+    if (!visit(SubExpr))
+      return false;
+    if (!this->emitCastToDerived(CE, CE))
+      return false;
+    return DiscardResult ? this->emitPopPtr(CE) : true;
+  }
+
+  case CK_DerivedToBaseMemberPointer: {
+    if (!visit(SubExpr))
+      return false;
+    for (auto *Step : CE->path()) {
+      auto *R = Step->getType()->getAs<RecordType>()->getDecl();
+      if (!this->emitCastMemberToBase(cast<CXXRecordDecl>(R), CE))
+        return false;
+    }
+    return DiscardResult ? this->emitPopMemPtr(CE) : true;
+  }
+
+  case CK_BaseToDerivedMemberPointer: {
+    if (CE->path_empty())
+      return discard(SubExpr);
+
+    if (!visit(SubExpr))
+      return false;
+
+    // Single cast step from base to derived.
+    auto Step = [this, CE](const Type *T) {
+      auto *R = cast<CXXRecordDecl>(T->getAs<RecordType>()->getDecl());
+      return this->emitCastMemberToDerived(R, CE);
+    };
+
+    // Base-to-derived member pointer casts store the path in derived-to-base
+    // order, so iterate backwards. The CXXBaseSpecifier also provides us with
+    // the wrong end of the derived->base arc, so stagger the path by one class.
+    typedef std::reverse_iterator<CastExpr::path_const_iterator> Rev;
+    for (auto It = Rev(CE->path_end() - 1); It != Rev(CE->path_begin()); ++It) {
+      if (!Step((*It)->getType().getTypePtr()))
+        return false;
+    }
+    // The final type is encoded in the type of the cast.
+    if (!Step(CE->getType()->getAs<MemberPointerType>()->getClass()))
+      return false;
+    return DiscardResult ? this->emitPopMemPtr(CE) : true;
+  }
+
+  case CK_BitCast: {
+    if (!this->Visit(SubExpr))
+      return false;
+    QualType T = CE->getType();
+    if (!T->isVoidPointerType()) {
+      if (T->isMemberFunctionPointerType())
+        return false;
+      if (T->isMemberPointerType())
+        return false;
+      if (T->isFunctionPointerType())
+        return false;
+      return this->emitPointerBitCast(SubExpr);
+    }
+    return true;
+  }
+
+  case CK_IntegralToPointer:
+  case CK_PointerToIntegral: {
+    if (!this->Visit(SubExpr))
+      return false;
+    return this->emitPointerBitCast(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: {
+      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);
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitFloatingLiteral(const FloatingLiteral *E) {
+  if (DiscardResult)
+    return true;
+  return this->emitConstRealFP(E, E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitStringLiteral(const StringLiteral *E) {
+  if (InitFn)
+    return visitStringInitializer(E);
+  if (DiscardResult)
+    return true;
+  return this->emitGetPtrGlobal(P.createGlobalString(E), E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCharacterLiteral(
+    const CharacterLiteral *CE) {
+  if (DiscardResult)
+    return true;
+
+  QualType CharTy = CE->getType();
+  if (Optional<PrimType> T = classify(CharTy)) {
+    const unsigned NumBits = sizeof(unsigned) * CHAR_BIT;
+    APInt Char(NumBits, static_cast<uint64_t>(CE->getValue()), false);
+    return this->emitConst(*T, getIntWidth(CharTy), Char, CE);
+  }
+  return this->bail(CE);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitImaginaryLiteral(
+    const ImaginaryLiteral *E) {
+  const Expr *SubExpr = E->getSubExpr();
+  QualType ElemType = SubExpr->getType();
+
+  PrimType T = classifyPrim(ElemType);
+  ImplicitValueInitExpr ZE(ElemType);
+
+  if (!emitInitFn())
+    return false;
+  if (!visit(&ZE))
+    return false;
+  if (!this->emitInitElem(T, 0, E))
+    return false;
+  if (!visit(SubExpr))
+    return false;
+  return this->emitInitElemPop(T, 1, E);
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitParenExpr(const ParenExpr *PE) {
   return this->Visit(PE->getSubExpr());
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitBinaryOperator(const BinaryOperator *BO) {
   const Expr *LHS = BO->getLHS();
   const Expr *RHS = BO->getRHS();
 
   // Deal with operations which have composite or void types.
   switch (BO->getOpcode()) {
+  case BO_PtrMemD:
+  case BO_PtrMemI:
+    return visitIndirectMember(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) {
     return this->bail(BO);
   }
 
   if (Optional<PrimType> T = classify(BO->getType())) {
+    switch (BO->getOpcode()) {
+    case BO_Assign:
+      return visitAssign(*T, BO);
+
+    case BO_AddAssign:
+      if (LT == PT_Ptr)
+        return visitPtrAssign(*RT, &ByteCodeExprGen::emitAddOffset, BO);
+      else
+        return visitCompoundAssign(*RT, &ByteCodeExprGen::emitAdd, BO);
+    case BO_SubAssign:
+      if (LT == PT_Ptr)
+        return visitPtrAssign(*RT, &ByteCodeExprGen::emitSubOffset, BO);
+      else
+        return visitCompoundAssign(*RT, &ByteCodeExprGen::emitSub, BO);
+
+    case BO_MulAssign:
+      return visitCompoundAssign(*RT, &ByteCodeExprGen::emitMul, BO);
+    case BO_DivAssign:
+      return visitCompoundAssign(*RT, &ByteCodeExprGen::emitDiv, BO);
+    case BO_RemAssign:
+      return visitCompoundAssign(*RT, &ByteCodeExprGen::emitRem, BO);
+    case BO_AndAssign:
+      return visitCompoundAssign(*RT, &ByteCodeExprGen::emitAnd, BO);
+    case BO_XorAssign:
+      return visitCompoundAssign(*RT, &ByteCodeExprGen::emitXor, BO);
+    case BO_OrAssign:
+      return visitCompoundAssign(*RT, &ByteCodeExprGen::emitOr, BO);
+
+    case BO_ShlAssign:
+      if (Ctx.getLangOpts().OpenCL)
+        return this->bail(BO);
+      return visitShiftAssign(*RT, &ByteCodeExprGen::emitShl, BO);
+
+    case BO_ShrAssign:
+      if (Ctx.getLangOpts().OpenCL)
+        return this->bail(BO);
+      return visitShiftAssign(*RT, &ByteCodeExprGen::emitShr, BO);
+
+    case BO_Add: {
+      if (*LT == PT_Ptr && *RT != PT_Ptr)
+        return visitOffset(LHS, RHS, BO, &ByteCodeExprGen::emitAddOffset);
+      if (*LT != PT_Ptr && *RT == PT_Ptr)
+        return visitOffset(RHS, LHS, BO, &ByteCodeExprGen::emitAddOffset);
+      break;
+    }
+    case BO_Sub: {
+      if (*LT == PT_Ptr && *RT == PT_Ptr) {
+        if (!visit(LHS))
+          return false;
+        if (!visit(RHS))
+          return false;
+        if (isFixedIntegral(*T)) {
+          if (!this->emitPtrDiffFP(*T, getIntWidth(BO->getType()), BO))
+            return false;
+        } else {
+          if (!this->emitPtrDiff(*T, BO))
+            return false;
+        }
+        return DiscardResult ? this->emitPop(*T, BO) : true;
+      }
+      if (*LT == PT_Ptr && *RT != PT_Ptr)
+        return visitOffset(LHS, RHS, BO, &ByteCodeExprGen::emitSubOffset);
+      break;
+    }
+
+    case BO_LOr:
+    case BO_LAnd:
+      return visitShortCircuit(BO);
+
+    default:
+      break;
+    }
+
     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_Or:
+      return Discard(this->emitOr(*T, BO));
+    case BO_And:
+      return Discard(this->emitAnd(*T, BO));
+    case BO_Xor:
+      return Discard(this->emitXor(*T, BO));
+    case BO_Rem:
+      return Discard(this->emitRem(*T, BO));
+    case BO_Div:
+      return Discard(this->emitDiv(*T, 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));
+    case BO_Shr:
+      if (Ctx.getLangOpts().OpenCL)
+        return this->bail(BO);
+      return Discard(this->emitShr(*LT, *RT, BO));
+    case BO_Shl:
+      if (Ctx.getLangOpts().OpenCL)
+        return this->bail(BO);
+      return Discard(this->emitShl(*LT, *RT, BO));
     default:
       return this->bail(BO);
     }
   }
 
   return this->bail(BO);
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryPlus(const UnaryOperator *UO) {
+  return this->Visit(UO->getSubExpr());
+}
+
+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>::VisitUnaryDeref(const UnaryOperator *E) {
+  if (!this->Visit(E->getSubExpr()))
+    return false;
+  if (DiscardResult)
+    return true;
+  if (needsAdjust(E->getType()))
+    return this->emitNarrowPtr(E);
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryAddrOf(const UnaryOperator *E) {
+  if (!this->Visit(E->getSubExpr()))
+    return false;
+  if (DiscardResult)
+    return true;
+  if (needsAdjust(E->getType()))
+    return this->emitExpandPtr(E);
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryPostInc(const UnaryOperator *E) {
+  if (!visit(E->getSubExpr()))
+    return false;
+  PrimType T = *classify(E->getType());
+  if (!this->emitPostInc(T, E))
+    return false;
+  return DiscardResult ? this->emitPop(T, E) : true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryPostDec(const UnaryOperator *E) {
+  if (!visit(E->getSubExpr()))
+    return false;
+  PrimType T = *classify(E->getType());
+  if (!this->emitPostDec(T, E))
+    return false;
+  return DiscardResult ? this->emitPop(T, E) : true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryPreInc(const UnaryOperator *E) {
+  if (!visit(E->getSubExpr()))
+    return false;
+  PrimType T = *classify(E->getType());
+  if (!this->emitPreInc(T, E))
+    return false;
+  return DiscardResult ? this->emitPopPtr(E) : true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryPreDec(const UnaryOperator *E) {
+  if (!visit(E->getSubExpr()))
+    return false;
+  PrimType T = *classify(E->getType());
+  if (!this->emitPreDec(T, E))
+    return false;
+  return DiscardResult ? this->emitPopPtr(E) : true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryNot(const UnaryOperator *UO) {
+  if (!this->Visit(UO->getSubExpr()))
+    return false;
+  PrimType T = *classify(UO->getType());
+  return DiscardResult ? true : this->emitNot(T, UO);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryLNot(const UnaryOperator *UO) {
+  if (!this->Visit(UO->getSubExpr()))
+    return false;
+  PrimType T = *classify(UO->getType());
+  return DiscardResult ? true : this->emitLogicalNot(T, UO);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryReal(const UnaryOperator *UO) {
+  const Expr *SubExpr = UO->getSubExpr();
+  if (!isa<ComplexType>(SubExpr->getType()))
+    return this->Visit(SubExpr);
+  if (!visit(SubExpr))
+    return false;
+  if (!this->emitRealElem(UO))
+    return false;
+  return DiscardResult ? this->emitPop(PT_Ptr, UO) : true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryImag(const UnaryOperator *UO) {
+  const Expr *SubExpr = UO->getSubExpr();
+  if (!isa<ComplexType>(SubExpr->getType()))
+    return this->Visit(SubExpr);
+  if (!visit(SubExpr))
+    return false;
+  if (!this->emitImagElem(UO))
+    return false;
+  return DiscardResult ? this->emitPop(PT_Ptr, UO) : true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitConditionalOperator(
+    const ConditionalOperator *CO) {
+  return visitConditionalOperator(CO);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitBinaryConditionalOperator(
+    const BinaryConditionalOperator *BO) {
+  if (!visitOpaqueExpr(BO->getOpaqueValue()))
+    return false;
+  return visitConditionalOperator(BO);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitConditionalOperator(
+    const AbstractConditionalOperator *CO) {
+  if (!visitBool(CO->getCond()))
+    return false;
+  LabelTy LabelFalse = this->getLabel();
+  LabelTy LabelEnd = this->getLabel();
+  if (!this->jumpFalse(LabelFalse))
+    return false;
+  if (!this->Visit(CO->getTrueExpr()))
+    return false;
+  if (!this->jump(LabelEnd))
+    return false;
+  this->emitLabel(LabelFalse);
+  if (!this->Visit(CO->getFalseExpr()))
+    return false;
+  if (!this->fallthrough(LabelEnd))
+    return false;
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitMemberExpr(const MemberExpr *ME) {
+  // Fetch a pointer to the required field.
+  if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
+    return withField(FD, [this, FD, ME](const Record::Field *F) {
+      const bool IsReference = FD->getType()->isReferenceType();
+      if (isa<CXXThisExpr>(ME->getBase())) {
+        if (IsReference) {
+          if (!this->emitGetThisFieldPtr(F->Offset, ME))
+            return false;
+        } else {
+          if (!this->emitGetPtrThisField(F->Offset, ME))
+            return false;
+        }
+      } else {
+        if (!visit(ME->getBase()))
+          return false;
+        if (IsReference) {
+          if (!this->emitGetFieldPopPtr(F->Offset, ME))
+            return false;
+        } else {
+          if (!this->emitGetPtrField(F->Offset, ME))
+            return false;
+        }
+      }
+      return DiscardResult ? this->emitPopPtr(ME) : true;
+    });
+  }
+
+  // Emit the enum constant value of the enum field.
+  if (auto *ED = dyn_cast<EnumConstantDecl>(ME->getMemberDecl()))
+    return this->Visit(ED->getInitExpr());
+
+  // Pointer to static field.
+  if (auto *VD = dyn_cast<VarDecl>(ME->getMemberDecl()))
+    return DiscardResult ? true : getPtrVarDecl(VD, ME);
+
+  // Pointer to static method or method.
+  if (auto *MD = dyn_cast<CXXMethodDecl>(ME->getMemberDecl())) {
+    assert(MD->isStatic() && "Method is not static");
+    return DiscardResult ? true : getPtrConstFn(MD, ME);
+  }
+
+  llvm_unreachable("Invalid member field");
+}
+
+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()) {
+    // If the callee is a builtin, lower args and invoke.
+    if (!visitArguments(CE->getCallee()->getType(), Args))
+      return false;
+    if (!this->emitBuiltin(BuiltinOp, CE))
+      return false;
+    return DiscardResult && T ? this->emitPop(*T, CE) : true;
+  } else if (const FunctionDecl *Callee = CE->getDirectCallee()) {
+    // Emit a direct call if the callee is known.
+    if (isa<CXXMethodDecl>(Callee) && !Callee->isStatic()) {
+      if (!visitArguments(CE->getCallee()->getType(), Args.slice(1)))
+        return false;
+      if (Args.size() < 1 || !visit(Args[0]))
+        return false;
+      return emitMethodCall(dyn_cast<CXXMethodDecl>(Callee), T, CE);
+    } else {
+      // Lower arguments.
+      if (!visitArguments(CE->getCallee()->getType(), Args))
+        return false;
+      return emitFunctionCall(Callee, T, CE);
+    }
+  } else {
+    // Function pointer call.
+    if (!visitArguments(CE->getCallee()->getType(), Args))
+      return false;
+    if (!visit(CE->getCallee()))
+      return false;
+    if (!this->emitIndirectCall(CE))
+      return false;
+    return DiscardResult && T ? this->emitPop(*T, CE) : true;
+  }
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXConstructExpr(
+    const CXXConstructExpr *E) {
+  CXXConstructorDecl *CD = E->getConstructor();
+
+  // Helper to invoke the constructor to initialize the pointer in InitFn.
+  auto InvokeConstructor = [this, E, CD] {
+    auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
+    if (E->requiresZeroInitialization() && CD->isTrivial()) {
+      // Do not invoke constructor, fill in with 0.
+      auto *RT = E->getType()->getAs<RecordType>();
+      return visitZeroInitializer(E, RT->getDecl());
+    } else {
+      // Avoid materialization if elidable.
+      if (E->isElidable()) {
+        if (auto *ME = dyn_cast<MaterializeTemporaryExpr>(E->getArg(0)))
+          return this->Visit(ME->GetTemporaryExpr());
+      }
+
+      // Invoke constructor with 'this' as the pointer.
+      if (!visitArguments(E->getConstructor()->getType(), Args))
+        return false;
+      if (!emitInitFn())
+        return false;
+      return emitMethodCall(E->getConstructor(), {}, E);
+    }
+  };
+
+  // Invoke the constructor on each array element or on the single record.
+  if (auto *CAT = dyn_cast<ConstantArrayType>(E->getType())) {
+    uint64_t NumElems = CAT->getSize().getZExtValue();
+    for (unsigned I = 0; I < NumElems; ++I) {
+      FieldScope<Emitter> Scope(this, [this, I, E](InitFnRef Base) {
+        if (!Base())
+          return false;
+        if (!this->emitConstUint32(I, E))
+          return false;
+        if (!this->emitAddOffsetUint32(E))
+          return false;
+        return this->emitNarrowPtr(E);
+      });
+      if (!InvokeConstructor())
+        return false;
+    }
+    return true;
+  }
+
+  return InvokeConstructor();
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXMemberCallExpr(
+    const CXXMemberCallExpr *CE) {
+  // Emit the pointer to build the return value into.
+  if (InitFn && !emitInitFn())
+    return false;
+
+  // Emit the arguments, this pointer and the call.
+  auto T = classify(CE->getType());
+  auto Args = llvm::makeArrayRef(CE->getArgs(), CE->getNumArgs());
+
+  // Identify member calls with direct targets, invoking them.
+  if (auto *MD = dyn_cast_or_null<CXXMethodDecl>(CE->getDirectCallee())) {
+    if (!visitArguments(MD->getType(), Args))
+      return false;
+
+    // Lower the 'this' pointer.
+    if (!visit(CE->getImplicitObjectArgument()))
+      return false;
+
+    // Direct member call.
+    if (!MD->isVirtual())
+      return emitMethodCall(MD, T, CE);
+
+    // Indirect virtual call.
+    if (!this->emitVirtualInvoke(MD, CE))
+      return false;
+    return DiscardResult && T ? this->emitPop(*T, CE) : true;
+  }
+
+  // Pattern match the callee for indirect calls to avoid materializing
+  // the bound member function pointer on the stack.
+  const Expr *Callee = CE->getCallee();
+  if (Callee->getType()->isSpecificBuiltinType(BuiltinType::BoundMember)) {
+    auto *BO = dyn_cast<BinaryOperator>(Callee->IgnoreParens());
+    switch (BO->getOpcode()) {
+    case BO_PtrMemD:
+    case BO_PtrMemI:
+      if (!visitArguments(BO->getRHS()->getType(), Args))
+        return false;
+      // Emit 'this' pointer.
+      if (!visit(BO->getLHS()))
+        return false;
+      // Emit member function.
+      if (!visit(BO->getRHS()))
+        return false;
+      // Emit invocation.
+      if (!this->emitIndirectInvoke(CE))
+        return false;
+      return DiscardResult && T ? this->emitPop(*T, CE) : true;
+    default:
+      llvm_unreachable("invalid indirect callee");
+    }
+  }
+
+  llvm_unreachable("invalid member call expression callee");
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::emitFunctionCall(const FunctionDecl *Callee,
+                                                Optional<PrimType> T,
+                                                const Expr *E) {
+  if (Expected<Function *> Func = P.getOrCreateFunction(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>::emitMethodCall(const CXXMethodDecl *Callee,
+                                              Optional<PrimType> T,
+                                              const Expr *E) {
+  if (Expected<Function *> Func = P.getOrCreateFunction(Callee)) {
+    if (*Func) {
+      if (!this->emitInvoke(*Func, E))
+        return false;
+    } else {
+      if (!this->emitNoInvoke(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>::VisitArraySubscriptExpr(
+    const ArraySubscriptExpr *E) {
+  if (!visit(E->getBase()))
+    return false;
+  auto *Idx = E->getIdx();
+  if (!visit(Idx))
+    return false;
+  if (!this->emitAddOffset(*classify(Idx->getType()), E))
+    return false;
+  return DiscardResult ? this->emitPopPtr(E) : this->emitNarrowPtr(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitExprWithCleanups(
+    const ExprWithCleanups *CE) {
+  return this->Visit(CE->getSubExpr());
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCompoundLiteralExpr(
+    const CompoundLiteralExpr *E) {
+  return materialize(E, E->getInitializer(),
+                     /*isConst=*/E->getType().isConstQualified(),
+                     /*isGlobal=*/E->isFileScope(),
+                     /*isExtended=*/false);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitMaterializeTemporaryExpr(
+    const MaterializeTemporaryExpr *ME) {
+  const bool IsConst = ME->getType().isConstQualified();
+  const bool IsGlobal = ME->getStorageDuration() == SD_Static;
+  const bool IsExtended = ME->getStorageDuration() == SD_Automatic;
+  return materialize(ME, ME->GetTemporaryExpr(), IsConst, IsGlobal, IsExtended);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::materialize(const Expr *Alloc, const Expr *Init,
+                                           bool IsConst, bool IsGlobal,
+                                           bool IsExtended) {
+  if (IsGlobal) {
+    if (auto I = P.createGlobal(Alloc)) {
+      if (Optional<PrimType> T = classify(Init->getType())) {
+        // Primitive global - compute and set.
+        if (!visit(Init))
+          return false;
+        if (!this->emitInitGlobal(*T, *I, Alloc))
+          return false;
+        return DiscardResult ? true : this->emitGetPtrGlobal(*I, Alloc);
+      } else {
+        // Composite global - initialize in place.
+        if (!visitGlobalInitializer(Init, *I))
+          return false;
+        return DiscardResult ? true : this->emitGetPtrGlobal(*I, Alloc);
+      }
+    }
+  } else {
+    if (Optional<PrimType> T = classify(Init->getType())) {
+      auto I = allocateLocalPrimitive(Init, *T, IsConst, IsExtended);
+      if (!visit(Init))
+        return false;
+      if (!this->emitSetLocal(*T, I, Init))
+        return false;
+      return DiscardResult ? true : this->emitGetPtrLocal(I, Init);
+    } else {
+      // Composite types - allocate storage and initialize it.
+      // This operation leaves a pointer to the temporary on the stack.
+      if (auto I = allocateLocal(Alloc, IsExtended)) {
+        if (!visitLocalInitializer(Init, *I))
+          return false;
+        return DiscardResult ? true : this->emitGetPtrLocal(*I, Alloc);
+      }
+    }
+  }
+  return this->bail(Alloc);
+}
+
+template <class Emitter>
+CharUnits ByteCodeExprGen<Emitter>::getAlignOfType(QualType T,
+                                                   bool IsPreferred) {
+  // C++ [expr.alignof]p3:
+  //     When alignof is applied to a reference type, the result is the
+  //     alignment of the referenced type.
+  if (const ReferenceType *Ref = T->getAs<ReferenceType>())
+    T = Ref->getPointeeType();
+
+  if (T.getQualifiers().hasUnaligned())
+    return CharUnits::One();
+
+  const auto &AST = Ctx.getASTContext();
+  const bool AlignOfReturnsPreferred =
+      AST.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver7;
+
+  // __alignof is defined to return the preferred alignment.
+  // Before 8, clang returned the preferred alignment for alignof and _Alignof
+  // as well.
+  if (IsPreferred || AlignOfReturnsPreferred)
+    return AST.toCharUnitsFromBits(AST.getPreferredTypeAlign(T.getTypePtr()));
+  // alignof and _Alignof are defined to return the ABI alignment.
+  return AST.getTypeAlignInChars(T.getTypePtr());
+}
+
+template <class Emitter>
+CharUnits ByteCodeExprGen<Emitter>::getAlignOfExpr(const Expr *E,
+                                                   bool IsPreferred) {
+  E = E->IgnoreParens();
+
+  // The kinds of expressions that we have special-case logic here for
+  // should be kept up to date with the special checks for those
+  // expressions in Sema.
+
+  // alignof decl is always accepted, even if it doesn't make sense: we default
+  // to 1 in those cases.
+  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
+    return Ctx.getASTContext().getDeclAlign(DRE->getDecl(),
+                                            /*RefAsPointee*/ true);
+
+  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
+    return Ctx.getASTContext().getDeclAlign(ME->getMemberDecl(),
+                                            /*RefAsPointee*/ true);
+
+  return getAlignOfType(E->getType(), IsPreferred);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitImplicitValueInitExpr(
+    const ImplicitValueInitExpr *E) {
+
+  QualType Ty = E->getType();
+  if (auto *AT = Ty->getAs<AtomicType>())
+    Ty = AT->getValueType();
+
+  if (auto T = Ctx.classify(Ty))
+    return DiscardResult ? true : visitZeroInitializer(*T, E);
+
+  if (auto *RT = Ty->getAs<RecordType>())
+    return visitZeroInitializer(E, RT->getDecl());
+
+  if (auto *CAT = dyn_cast<ConstantArrayType>(Ty)) {
+    ImplicitValueInitExpr E(CAT->getElementType());
+    return visitArrayInitializer(CAT, &E, [&E](unsigned) { return &E; });
+  }
+
+  return false;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitSubstNonTypeTemplateParmExpr(
+    const SubstNonTypeTemplateParmExpr *E) {
+  return this->Visit(E->getReplacement());
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitUnaryExprOrTypeTraitExpr(
+    const UnaryExprOrTypeTraitExpr *TE) {
+  switch (TE->getKind()) {
+  case UETT_PreferredAlignOf:
+  case UETT_AlignOf: {
+    const bool IsPreferred = TE->getKind() == UETT_PreferredAlignOf;
+    CharUnits Align;
+    if (TE->isArgumentType())
+      Align = getAlignOfType(TE->getArgumentType(), IsPreferred);
+    else
+      Align = getAlignOfExpr(TE->getArgumentExpr(), IsPreferred);
+    return DiscardResult ? true : emitConst(TE, Align.getQuantity());
+  }
+
+  case UETT_VecStep: {
+    return this->bail(TE);
+  }
+
+  case UETT_SizeOf: {
+    QualType ArgTy = TE->getTypeOfArgument();
+
+    // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
+    //   the result is the size of the referenced type."
+    if (auto *Ref = ArgTy->getAs<ReferenceType>())
+      ArgTy = Ref->getPointeeType();
+
+    CharUnits Size;
+    if (ArgTy->isVoidType() || ArgTy->isFunctionType()) {
+      Size = CharUnits::One();
+    } else if (ArgTy->isDependentType()) {
+      return this->emitTrap(TE);
+    } else if (!ArgTy->isConstantSizeType()) {
+      // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
+      // FIXME: Better diagnostic.
+      return this->emitTrap(TE);
+    } else {
+      Size = Ctx.getASTContext().getTypeSizeInChars(ArgTy);
+    }
+
+    // Emit the size as an integer.
+    return DiscardResult ? true : emitConst(TE, Size.getQuantity());
+  }
+  case UETT_OpenMPRequiredSimdAlign: {
+    return this->bail(TE);
+  }
+  }
+
+  llvm_unreachable("unknown expr/type trait");
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
+  if (DiscardResult)
+    return true;
+  return emitConst(E, E->getPackLength());
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
+  // The opaque expression was evaluated earlier and the pointer was cached in
+  // a local variable. Load the pointer at this point.
+  PrimType Ty;
+  if (Optional<PrimType> T = classify(E->getType())) {
+    Ty = *T;
+  } else {
+    Ty = PT_Ptr;
+  }
+  auto It = OpaqueExprs.find(E);
+  if (It != OpaqueExprs.end()) {
+    return DiscardResult ? true : this->emitGetLocal(Ty, It->second, E);
+  } else {
+    return this->emitTrap(E);
+  }
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitArrayInitLoopExpr(
+    const ArrayInitLoopExpr *E) {
+  // Evaluate the common expression, a pointer to the array copied from.
+  if (auto *C = E->getCommonExpr()) {
+    if (!visitOpaqueExpr(C))
+      return false;
+  }
+
+  // Initialise each element of the array. In this scope, ArrayIndex is set to
+  // refer to the index of the element being initialised in the callback which
+  // returns the initialiser of that element.
+  auto OldArrayIndex = ArrayIndex;
+
+  auto ElemInit = [this, E](uint64_t I) {
+    ArrayIndex = I;
+    return E->getSubExpr();
+  };
+
+  auto *AT = E->getType()->getAsArrayTypeUnsafe();
+  if (!visitArrayInitializer(cast<ConstantArrayType>(AT), E, ElemInit))
+    return false;
+
+  ArrayIndex = OldArrayIndex;
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitArrayInitIndexExpr(
+    const ArrayInitIndexExpr *E) {
+  assert(!DiscardResult && "ArrayInitIndexExpr should not be discarded");
+  return ArrayIndex ? this->emitConst(E, *ArrayIndex) : this->emitTrap(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitInitListExpr(const InitListExpr *E) {
+  // Initialise a scalar with a given value or zero.
+  if (auto T = Ctx.classify(E->getType())) {
+    if (E->getNumInits() == 0)
+      return DiscardResult ? true : visitZeroInitializer(*T, E);
+    if (E->getNumInits() == 1)
+      return this->Visit(E->getInit(0));
+    return false;
+  }
+
+  // Desugar the type and decide which initializer to call based on it.
+  QualType Ty = E->getType();
+  if (auto *AT = dyn_cast<AtomicType>(Ty))
+    Ty = AT->getValueType();
+
+  if (auto *RT = Ty->getAs<RecordType>())
+    return visitRecordInitializer(RT, E);
+
+  if (auto *CT = Ty->getAs<ComplexType>())
+    return visitComplexInitializer(CT, E);
+
+  if (E->isStringLiteralInit()) {
+    auto *S = cast<StringLiteral>(E->getInit(0)->IgnoreParens());
+    return visitStringInitializer(S);
+  }
+
+  if (auto CT = Ty->getAsArrayTypeUnsafe()) {
+    if (auto CAT = dyn_cast<ConstantArrayType>(CT)) {
+      return visitArrayInitializer(CAT, E, [E](uint64_t I) {
+        if (I < E->getNumInits())
+          return E->getInit(I);
+        else
+          return E->getArrayFiller();
+      });
+    }
+  }
+
+  return this->bail(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitTypeTraitExpr(const TypeTraitExpr *E) {
+  return DiscardResult ? true : this->emitConstBool(E->getValue(), E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitBlockExpr(const BlockExpr *E) {
+  if (E->getBlockDecl()->hasCaptures())
+    return this->emitTrap(E);
+  // FIXME: blocks with no captures.
+  return this->bail(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXNullPtrLiteralExpr(
+    const CXXNullPtrLiteralExpr *E) {
+  return DiscardResult ? true : this->emitNullPtr(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXBoolLiteralExpr(
+    const CXXBoolLiteralExpr *B) {
+  return DiscardResult ? true : this->emitConstBool(B->getValue(), B);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXThisExpr(const CXXThisExpr *TE) {
+  if (!this->emitThis(TE))
+    return false;
+  return DiscardResult ? this->emitPopPtr(TE) : true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXDefaultArgExpr(
+    const CXXDefaultArgExpr *DE) {
+  return this->Visit(DE->getExpr());
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXDefaultInitExpr(
+    const CXXDefaultInitExpr *DE) {
+  if (auto *E = DE->getExpr())
+    return this->Visit(E);
+  return this->emitTrap(DE);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXScalarValueInitExpr(
+    const CXXScalarValueInitExpr *E) {
+  QualType Ty = E->getType();
+  if (auto T = Ctx.classify(Ty))
+    return DiscardResult ? true : visitZeroInitializer(*T, E);
+
+  // Complex numbers are not really scalar.
+  if (auto *CT = Ty->getAs<ComplexType>()) {
+    QualType ElemType = CT->getElementType();
+    PrimType T = classifyPrim(ElemType);
+    ImplicitValueInitExpr ZE(ElemType);
+    if (!emitInitFn())
+      return false;
+    if (!visit(&ZE))
+      return false;
+    if (!this->emitInitElem(T, 0, E))
+      return false;
+    if (!visit(&ZE))
+      return false;
+    return this->emitInitElemPop(T, 1, E);
+  }
+  return false;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXThrowExpr(const CXXThrowExpr *E) {
+  return this->emitTrap(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXTemporaryObjectExpr(
+    const CXXTemporaryObjectExpr *E) {
+  // In-place construction, simply invoke constructor.
+  if (InitFn)
+    return VisitCXXConstructExpr(cast<CXXConstructExpr>(E));
+
+  // Allocate a temporary and build into it.
+  if (auto I = allocateLocal(E, /*isExtended=*/false)) {
+    OptionScope<Emitter> Scope(this, InitFnRef{[this, &I, E] {
+      return this->emitGetPtrLocal(*I, E);
+    }});
+    if (!VisitCXXConstructExpr(cast<CXXConstructExpr>(E)))
+      return false;
+    return DiscardResult ? true : this->emitGetPtrLocal(*I, E);
+  }
+  return this->bail(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
+  // TODO: implement typeid.
+  return this->bail(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXReinterpretCastExpr(
+    const CXXReinterpretCastExpr *E) {
+  if (!this->emitReinterpretCastWarning(E))
+    return false;
+  return VisitCastExpr(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXDynamicCastExpr(
+    const CXXDynamicCastExpr *E) {
+  if (!Ctx.getLangOpts().CPlusPlus2a) {
+    if (!this->emitDynamicCastWarning(E))
+      return false;
+  }
+  return VisitCastExpr(E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXInheritedCtorInitExpr(
+    const CXXInheritedCtorInitExpr *E) {
+  auto *Ctor = E->getConstructor();
+
+  // Forward all parameters.
+  unsigned Offset = 0;
+  for (auto *PD : Ctor->parameters()) {
+    PrimType Ty;
+    if (Optional<PrimType> T = classify(PD->getType())) {
+      Ty = *T;
+    } else {
+      Ty = PT_Ptr;
+    }
+    if (!this->emitGetParam(Ty, Offset, E))
+      return false;
+    Offset += align(primSize(Ty));
+  }
+
+  // Invoke the constructor on the same 'this'.
+  return emitInitFn() && emitMethodCall(Ctor, {}, E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXStdInitializerListExpr(
+    const CXXStdInitializerListExpr *E) {
+  auto *AT = getAsConstantArrayType(E->getSubExpr()->getType());
+
+  /// Push the pointer to the std::initializer_list.
+  if (!this->emitInitFn())
+    return false;
+
+
+  Record *R = getRecord(E->getType());
+
+  // std::initializer_list should not have base classes.
+  if (!R || R->getNumBases() != 0 || R->getNumVirtualBases() != 0)
+    return this->emitTrap(E);
+
+  // pointer + pointer or pointer + length
+  if (R->getNumFields() != 2)
+    return this->emitTrap(E);
+
+  // The first field must be a pointer.
+  Record::Field *Fst = R->getField(0);
+  if (Fst->Desc->ElemTy != PT_Ptr)
+    return this->emitTrap(E);
+
+  // Set the first field - either a pointer or an integer.
+  Record::Field *Snd = R->getField(1);
+  if (Optional<PrimType> T = Snd->Desc->ElemTy) {
+    QualType Ty = Snd->Decl->getType();
+    switch (*T) {
+      case PT_Sint8:
+      case PT_Uint8:
+      case PT_Sint16:
+      case PT_Uint16:
+      case PT_Sint32:
+      case PT_Uint32:
+      case PT_Sint64:
+      case PT_Uint64:
+      case PT_SintFP:
+      case PT_UintFP:
+      case PT_Bool:
+        /// Lower the array.
+        if (!visit(E->getSubExpr()))
+          return false;
+        // Set the first field.
+        if (!this->emitInitFieldPtr(Fst->Offset, E))
+          return false;
+        // Set the length.
+        if (!this->emitConst(*T, getIntWidth(Ty), AT->getSize(), E))
+          return false;
+        if (DiscardResult)
+          return this->emitInitFieldPop(*T, Snd->Offset, E);
+        else
+          return this->emitInitField(*T, Snd->Offset, E);
+      case PT_Ptr:
+        /// Lower the array.
+        if (!visit(E->getSubExpr()))
+          return false;
+        if (!this->emitInitFieldPeekPtr(Fst->Offset, E))
+          return false;
+        // Set the end pointer.
+        if (!this->emitConstUint64(AT->getSize().getZExtValue(), E))
+          return false;
+        if (!this->emitAddOffsetUint64(E))
+          return false;
+        if (DiscardResult)
+          return this->emitInitFieldPopPtr(Snd->Offset, E);
+        else
+          return this->emitInitFieldPtr(Snd->Offset, E);
+      default:
+        return this->emitTrap(E);
+    }
+  }
+  return this->emitTrap(E);
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   OptionScope<Emitter> Scope(this, /*discardResult=*/true);
   return this->Visit(E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visit(const Expr *E) {
   OptionScope<Emitter> Scope(this, /*discardResult=*/false);
   return this->Visit(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) {
bool ByteCodeExprGen<Emitter>::visitZeroInitializer(PrimType T, const Expr *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_UintFP:
+    return this->emitZeroFPUintFP(getIntWidth(E->getType()), E);
+  case PT_SintFP:
+    return this->emitZeroFPSintFP(getIntWidth(E->getType()), E);
+  case PT_RealFP:
+    return this->emitZeroRealFP(getFltSemantics(E->getType()), E);
   case PT_Ptr:
     return this->emitNullPtr(E);
+  case PT_FnPtr:
+    return this->emitNullFnPtr(E);
+  case PT_MemPtr:
+    return this->emitNullMemPtr(E);
   }
-  llvm_unreachable("unknown primitive type");
+  return false;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitOffset(const Expr *Ptr, const Expr *Offset,
+                                           const Expr *E, UnaryFn OffsetFn) {
+  if (!visit(Ptr))
+    return false;
+  if (!visit(Offset))
+    return false;
+  if (!(this->*OffsetFn)(*classify(Offset->getType()), E))
+    return false;
+  return DiscardResult ? this->emitPopPtr(E) : true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitIndirectMember(const BinaryOperator *E) {
+  if (!visit(E->getLHS()))
+    return false;
+  if (!visit(E->getRHS()))
+    return false;
+
+  if (!this->emitGetPtrFieldIndirect(E))
+    return false;
+  if (DiscardResult && !this->emitPopPtr(E))
+    return false;
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitAssign(PrimType T,
+                                           const BinaryOperator *BO) {
+  return dereference(
+      BO->getLHS(), DerefKind::Write,
+      [this, BO](PrimType) {
+        // Generate a value to store - will be set.
+        return visit(BO->getRHS());
+      },
+      [this, BO](PrimType T) {
+        // Pointer on stack - compile RHS and assign to pointer.
+        if (!visit(BO->getRHS()))
+          return false;
+
+        if (BO->getLHS()->refersToBitField()) {
+          if (DiscardResult)
+            return this->emitStoreBitFieldPop(T, BO);
+          else
+            return this->emitStoreBitField(T, BO);
+        } else {
+          if (DiscardResult)
+            return this->emitStorePop(T, BO);
+          else
+            return this->emitStore(T, BO);
+        }
+      });
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitShiftAssign(PrimType RHS, BinaryFn F,
+                                                const BinaryOperator *BO) {
+  return dereference(
+      BO->getLHS(), DerefKind::ReadWrite,
+      [this, F, RHS, BO](PrimType LHS) {
+        if (!visit(BO->getRHS()))
+          return false;
+        (this->*F)(LHS, RHS, BO);
+        return true;
+      },
+      [this, F, RHS, BO](PrimType LHS) {
+        if (!this->emitLoad(LHS, BO))
+          return false;
+        if (!visit(BO->getRHS()))
+          return false;
+        if (!(this->*F)(LHS, RHS, BO))
+          return false;
+
+        if (BO->getLHS()->refersToBitField()) {
+          if (DiscardResult)
+            return this->emitStoreBitFieldPop(LHS, BO);
+          else
+            return this->emitStoreBitField(LHS, BO);
+        } else {
+          if (DiscardResult)
+            return this->emitStorePop(LHS, BO);
+          else
+            return this->emitStore(LHS, BO);
+        }
+      });
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitCompoundAssign(PrimType RHS, UnaryFn F,
+                                                   const BinaryOperator *BO) {
+  auto ApplyOperation = [this, F, BO, RHS](PrimType LHS) {
+    auto *ExprRHS = BO->getRHS();
+    auto *ExprLHS = BO->getLHS();
+    if (ExprLHS->getType() == ExprRHS->getType()) {
+      if (!visit(BO->getRHS()))
+        return false;
+      if (!(this->*F)(LHS, BO))
+        return false;
+    } else {
+      if (!emitConv(LHS, ExprLHS->getType(), RHS, ExprRHS->getType(), ExprRHS))
+        return false;
+      if (!visit(ExprRHS))
+        return false;
+      if (!(this->*F)(RHS, BO))
+        return false;
+      if (!emitConv(RHS, ExprRHS->getType(), LHS, ExprLHS->getType(), ExprLHS))
+        return false;
+    }
+    return true;
+  };
+
+  return dereference(
+      BO->getLHS(), DerefKind::ReadWrite, ApplyOperation,
+      [this, BO, &ApplyOperation](PrimType LHS) -> bool {
+        if (!this->emitLoad(LHS, BO))
+          return false;
+        if (!ApplyOperation(LHS))
+          return false;
+
+        if (BO->getLHS()->refersToBitField()) {
+          if (DiscardResult)
+            return this->emitStoreBitFieldPop(LHS, BO);
+          else
+            return this->emitStoreBitField(LHS, BO);
+        } else {
+          if (DiscardResult)
+            return this->emitStorePop(LHS, BO);
+          else
+            return this->emitStore(LHS, BO);
+        }
+      });
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitPtrAssign(PrimType RHS, UnaryFn F,
+                                              const BinaryOperator *BO) {
+  return dereference(
+      BO->getLHS(), DerefKind::ReadWrite,
+      [this, F, BO, RHS](PrimType LHS) {
+        if (!visit(BO->getRHS()))
+          return false;
+        if (!(this->*F)(RHS, BO))
+          return false;
+        return true;
+      },
+      [this, BO, F, RHS](PrimType LHS) -> bool {
+        if (!this->emitLoad(LHS, BO))
+          return false;
+        if (!visit(BO->getRHS()))
+          return false;
+        if (!(this->*F)(RHS, BO))
+          return false;
+
+        if (BO->getLHS()->refersToBitField())
+          return this->bail(BO);
+
+        if (DiscardResult)
+          return this->emitStorePop(LHS, BO);
+        else
+          return this->emitStore(LHS, BO);
+      });
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::emitConv(PrimType LHS, QualType TyLHS,
+                                        PrimType RHS, QualType TyRHS,
+                                        const Expr *Cast) {
+  if (isPrimitiveIntegral(RHS)) {
+    if (isFixedReal(LHS)) {
+      return this->emitCastRealFPToAlu(LHS, RHS, Cast);
+    } else {
+      return this->emitCast(LHS, RHS, Cast);
+    }
+  } else if (isFixedIntegral(RHS)) {
+    if (isFixedReal(LHS)) {
+      return this->emitCastRealFPToAluFP(LHS, RHS, getIntWidth(TyRHS), Cast);
+    } else {
+      return this->emitCastFP(LHS, RHS, getIntWidth(TyRHS), Cast);
+    }
+  } else if (isFixedReal(RHS)) {
+    return this->emitCastRealFP(LHS, getFltSemantics(TyRHS), Cast);
+  }
+  llvm_unreachable("Invalid conversion");
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitShortCircuit(const BinaryOperator *E) {
+  if (!visitBool(E->getLHS()))
+    return false;
+
+  LabelTy Short = this->getLabel();
+  const bool IsTrue = E->getOpcode() == BO_LAnd;
+  if (DiscardResult) {
+    if (!(IsTrue ? this->jumpFalse(Short) : this->jumpTrue(Short)))
+      return false;
+    if (!this->discard(E->getRHS()))
+      return false;
+  } else {
+    if (!this->emitDupBool(E))
+      return false;
+    if (!(IsTrue ? this->jumpFalse(Short) : this->jumpTrue(Short)))
+      return false;
+    if (!this->emitPopBool(E))
+      return false;
+    if (!visitBool(E->getRHS()))
+      return false;
+  }
+  this->fallthrough(Short);
+  return true;
 }
 
 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);
           if (auto *VD = dyn_cast<VarDecl>(DE->getDecl()))
             return dereferenceVar(LV, *T, VD, AK, Direct, Indirect);
         }
       }
+      if (auto *ME = dyn_cast<MemberExpr>(LV)) {
+        if (!ME->getMemberDecl()->getType()->isReferenceType())
+          return dereferenceMember(ME, *T, AK, Direct, Indirect);
+      }
     }
 
     if (!visit(LV))
       return false;
     return Indirect(*T);
   }
 
   return false;
if (!DiscardResult && AK == DerefKind::Read) {
     }
   }
 
   // Value cannot be produced - try to emit pointer.
   return visit(LV) && Indirect(T);
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::dereferenceMember(
+    const MemberExpr *ME, PrimType T, DerefKind AK,
+    llvm::function_ref<bool(PrimType)> Direct,
+    llvm::function_ref<bool(PrimType)> Indirect) {
+  // Fetch or read the required field.
+  if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
+    return withField(FD, [this, ME, AK, T, Direct](const Record::Field *F) {
+      const unsigned Off = F->Offset;
+      if (isa<CXXThisExpr>(ME->getBase())) {
+        switch (AK) {
+        case DerefKind::Read:
+          if (!this->emitGetThisField(T, Off, ME))
+            return false;
+          return DiscardResult ? this->emitPop(T, ME) : true;
+
+        case DerefKind::Write:
+          if (!Direct(T))
+            return false;
+          if (!this->emitSetThisField(T, Off, ME))
+            return false;
+          return DiscardResult ? true : this->emitGetPtrThisField(Off, ME);
+
+        case DerefKind::ReadWrite:
+          if (!this->emitGetThisField(T, Off, ME))
+            return false;
+          if (!Direct(T))
+            return false;
+          if (!this->emitSetThisField(T, Off, ME))
+            return false;
+          return DiscardResult ? true : this->emitGetPtrThisField(Off, ME);
+        }
+      } else {
+        if (!visit(ME->getBase()))
+          return false;
+
+        switch (AK) {
+        case DerefKind::Read:
+          if (!this->emitGetFieldPop(T, Off, ME))
+            return false;
+          return DiscardResult ? this->emitPop(T, ME) : true;
+
+        case DerefKind::Write:
+          if (!Direct(T))
+            return false;
+          if (!this->emitSetField(T, Off, ME))
+            return false;
+          return DiscardResult ? true : this->emitGetPtrField(Off, ME);
+
+        case DerefKind::ReadWrite:
+          if (!this->emitGetField(T, Off, ME))
+            return false;
+          if (!Direct(T))
+            return false;
+          if (!this->emitSetField(T, Off, ME))
+            return false;
+          return DiscardResult ? true : this->emitGetPtrField(Off, ME);
+        }
+      }
+      return false;
+    });
+  }
+
+  // Value cannot be produced - try to emit pointer.
+  return visit(ME) && 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);
   case PT_Uint8:
     return this->emitConstUint8(Value.getZExtValue(), E);
   case PT_Sint16:
     return this->emitConstSint16(Value.getSExtValue(), E);
   case PT_Uint16:
     return this->emitConstUint16(Value.getZExtValue(), E);
   case PT_Sint32:
     return this->emitConstSint32(Value.getSExtValue(), E);
   case PT_Uint32:
     return this->emitConstUint32(Value.getZExtValue(), E);
   case PT_Sint64:
     return this->emitConstSint64(Value.getSExtValue(), E);
   case PT_Uint64:
     return this->emitConstUint64(Value.getZExtValue(), E);
+  case PT_SintFP:
+    return this->emitConstFPSintFP(NumBits, Value.getSExtValue(), E);
+  case PT_UintFP:
+    return this->emitConstFPUintFP(NumBits, Value.getZExtValue(), E);
   case PT_Bool:
     return this->emitConstBool(Value.getBoolValue(), E);
   case PT_Ptr:
+  case PT_FnPtr:
+  case PT_RealFP:
+  case PT_MemPtr:
     llvm_unreachable("Invalid integral type");
     break;
   }
   llvm_unreachable("unknown primitive type");
 }
 
 template <class Emitter>
 unsigned ByteCodeExprGen<Emitter>::allocateLocalPrimitive(DeclTy &&Src,
ByteCodeExprGen<Emitter>::allocateLocal(DeclTy &&Src, bool IsExtended) {
   Scope::Local Local = this->createLocal(D);
   if (Key)
     Locals.insert({Key, Local});
   VarScope->add(Local, IsExtended);
   return Local.Offset;
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::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;
+  }
+
+  return true;
+}
+
+template <class Emitter>
+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);
+
+  // Composite argument - copy construct and push pointer.
+  if (auto I = allocateLocal(E, /*isExtended=*/false)) {
+    if (!visitLocalInitializer(E, *I))
+      return false;
+    return Discard ? true : this->emitGetPtrLocal(*I, E);
+  }
+
+  return this->bail(E);
+}
+
+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>::visitBaseInitializer(const Expr *Init,
+                                                    InitFnRef GenBase) {
+  OptionScope<Emitter> Scope(this, GenBase, InitKind::BASE);
+  return this->Visit(Init);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::getPtrConstFn(const FunctionDecl *FD,
+                                             const Expr *E) {
+  if (Expected<Function *> Func = P.getOrCreateFunction(FD)) {
+    if (*Func)
+      return this->emitConstFn(*Func, E);
+    else
+      return this->emitConstNoFn(FD, E);
+  } else {
+    consumeError(Func.takeError());
+    return this->emitConstNoFn(FD, E);
+  }
+}
+
+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);
+  return false;
 }
 
 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 {};
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitStringInitializer(const StringLiteral *S) {
+  // Find the type to represent characters.
+  const unsigned CharBytes = S->getCharByteWidth();
+  PrimType CharType;
+  switch (CharBytes) {
+  case 1:
+    CharType = PT_Sint8;
+    break;
+  case 2:
+    CharType = PT_Uint16;
+    break;
+  case 4:
+    CharType = PT_Uint32;
+    break;
+  default:
+    llvm_unreachable("Unsupported character width!");
+  }
+
+  if (!emitInitFn())
+    return false;
+
+  // Initialise elements one by one, advancing the pointer.
+  const unsigned NumBits = CharBytes * getCharBit();
+  for (unsigned I = 0, N = S->getLength(); I < N; ++I) {
+    // Set individual characters here.
+    APInt CodeUnit(NumBits, S->getCodeUnit(I));
+    // Lower the code point.
+    if (!emitConst(CharType, NumBits, CodeUnit, S))
+      return false;
+    // Set the character.
+    if (!this->emitInitElem(CharType, I, S))
+      return false;
+  }
+
+  // Set the null terminator.
+  if (!emitConst(CharType, NumBits, APInt(NumBits, 0), S))
+    return false;
+  if (!this->emitInitElemPop(CharType, S->getLength(), S))
+    return false;
+
+  // String was initialised.
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitRecordInitializer(
+    const RecordType *RT, const InitListExpr *List) {
+  auto *R = P.getOrCreateRecord(RT->getDecl());
+  if (!R)
+    return this->bail(List);
+
+  auto InitElem = [this, R](const Record::Field *F, const Expr *E) {
+    if (Optional<PrimType> T = classify(E)) {
+      if (!emitInitFn())
+        return false;
+      if (!visit(E))
+        return false;
+      if (R->isUnion())
+        return this->emitInitFieldActive(*T, F->Offset, E);
+      else if (F->Decl->isBitField())
+        return this->emitInitBitField(*T, F, E);
+      else
+        return this->emitInitFieldPop(*T, F->Offset, E);
+    } else {
+      auto FieldFn = [this, F, E](InitFnRef Ptr) {
+        return Ptr() && this->emitGetPtrField(F->Offset, E);
+      };
+      if (R->isUnion()) {
+        UnionScope<Emitter> Scope(this, FieldFn);
+        return this->Visit(E);
+      } else {
+        FieldScope<Emitter> Scope(this, FieldFn);
+        return this->Visit(E);
+      }
+    }
+  };
+
+  if (R->isUnion()) {
+    if (auto *InitField = List->getInitializedFieldInUnion()) {
+      auto *F = R->getField(InitField);
+      switch (List->getNumInits()) {
+      case 0: {
+        // Clang doesn't provide an initializer - need to default init.
+        ImplicitValueInitExpr Init(InitField->getType());
+        if (!InitElem(F, &Init))
+          return false;
+        break;
+      }
+
+      case 1: {
+        // Initialise the element.
+        if (!InitElem(F, List->getInit(0)))
+          return false;
+        break;
+      }
+
+      default:
+        // Malformed initializer.
+        return false;
+      }
+    }
+  } else {
+    for (unsigned I = 0, N = R->getNumBases(); I < N; ++I) {
+      unsigned Off = R->getBase(I)->Offset;
+      const Expr *Init = List->getInit(I);
+
+      BaseScope<Emitter> Scope(this, [this, Off, Init] (InitFnRef Ptr) {
+        return Ptr() && this->emitGetPtrBase(Off, Init);
+      });
+      if (!this->Visit(Init))
+        return false;
+    }
+    for (unsigned I = 0, N = R->getNumFields(); I < N; ++I) {
+      const Expr * Init = List->getInit(I + R->getNumBases());
+      if (!InitElem(R->getField(I), Init))
+        return false;
+    }
+  }
+
+  switch (Initialiser) {
+  case InitKind::ROOT:
+    // Nothing to initialise.
+    return true;
+  case InitKind::BASE:
+    // Initialise the base class.
+    return this->emitInitFn() && this->emitInitialise(List);
+  case InitKind::UNION:
+    // Activate the union field.
+    return this->emitInitFn() && this->emitActivate(List);
+  }
+  return false;
+}
+
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitComplexInitializer(
+    const ComplexType *CT, const InitListExpr *List) {
+  QualType ElemTy = CT->getElementType();
+
+  ImplicitValueInitExpr ZE(ElemTy);
+  PrimType T = classifyPrim(ElemTy);
+
+  auto InitElem = [this, T](unsigned Index, const Expr *E) -> bool {
+    if (!emitInitFn())
+      return false;
+    if (!visit(E))
+      return false;
+    return this->emitInitElemPop(T, Index, E);
+  };
+
+  switch (List->getNumInits()) {
+  case 0:
+    return InitElem(0, &ZE) && InitElem(1, &ZE);
+  case 1:
+    return this->Visit(List->getInit(0));
+  case 2:
+    return InitElem(0, List->getInit(0)) && InitElem(1, List->getInit(1));
+  default:
+    llvm_unreachable("invalid complex initializer");
+  }
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitCastToComplex(const CastExpr *CE) {
+  QualType SubType = CE->getSubExpr()->getType();
+  PrimType T = classifyPrim(SubType);
+
+  if (!emitInitFn())
+    return false;
+  if (!this->visit(CE->getSubExpr()))
+    return false;
+  if (!this->emitInitElem(T, 0, CE))
+    return false;
+  ImplicitValueInitExpr ZE(SubType);
+  if (!visit(&ZE))
+    return false;
+  return this->emitInitElemPop(T, 1, CE);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitArrayInitializer(
+    const ConstantArrayType *AT,
+    const Expr *List,
+    llvm::function_ref<const Expr *(uint64_t)> Elem) {
+  uint64_t NumElems = AT->getSize().getZExtValue();
+  if (Optional<PrimType> T = classify(AT->getElementType())) {
+    if (NumElems > 0 && !emitInitFn())
+      return false;
+    for (unsigned I = 0; I < NumElems; ++I) {
+      const Expr *ElemInit = Elem(I);
+      // Construct the value.
+      if (!visit(ElemInit))
+        return false;
+      // Set the element.
+      if (I + 1 != NumElems) {
+        if (!this->emitInitElem(*T, I, ElemInit))
+          return false;
+      } else {
+        if (!this->emitInitElemPop(*T, I, ElemInit))
+          return false;
+      }
+    }
+  } else {
+    for (unsigned I = 0; I < NumElems; ++I) {
+      const Expr *ElemInit = Elem(I);
+
+      // Generate a pointer to the field from the array pointer.
+      FieldScope<Emitter> Scope(this, [this, I, ElemInit](InitFnRef Ptr) {
+        if (!Ptr())
+          return false;
+        if (!this->emitConstUint32(I, ElemInit))
+          return false;
+        if (!this->emitAddOffsetUint32(ElemInit))
+          return false;
+        return this->emitNarrowPtr(ElemInit);
+      });
+      if (!this->Visit(ElemInit))
+        return false;
+    }
+  }
+
+  switch (Initialiser) {
+  case InitKind::ROOT:
+    return true;
+  case InitKind::BASE:
+    llvm_unreachable("arrays cannot be base classes");
+  case InitKind::UNION:
+    return this->emitInitFn() && this->emitActivate(List);
+  }
+  return false;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitZeroInitializer(const Expr *E,
+                                                    const RecordDecl *RD) {
+  Record *R = P.getOrCreateRecord(RD);
+  if (!R)
+    return false;
+
+  for (auto &B : R->bases()) {
+    BaseScope<Emitter> Scope(this, [this, &B, E](InitFnRef Ptr) {
+      if (!Ptr())
+        return false;
+      return this->emitGetPtrBase(B.Offset, E);
+    });
+    if (!visitZeroInitializer(E, B.Decl))
+      return false;
+  }
+
+  for (auto &F : R->fields()) {
+    ImplicitValueInitExpr Init(F.Decl->getType());
+    if (Optional<PrimType> T = classify(F.Decl->getType())) {
+      if (!emitInitFn())
+        return false;
+      if (!visitZeroInitializer(*T, &Init))
+        return false;
+      if (F.Decl->isBitField()) {
+        if (!this->emitInitBitField(*T, &F, E))
+          return false;
+      } else {
+        if (!this->emitInitFieldPop(*T, F.Offset, E))
+          return false;
+      }
+    } else {
+      FieldScope<Emitter> Scope(this, [this, &F, E](InitFnRef Ptr) {
+        if (!Ptr())
+          return false;
+        return this->emitGetPtrField(F.Offset, E);
+      });
+      if (!this->Visit(&Init))
+        return false;
+    }
+  }
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::withField(
+    const FieldDecl *F,
+    llvm::function_ref<bool(const Record::Field *)> GenField) {
+  if (auto *R = getRecord(F->getParent()))
+    if (auto *Field = R->getField(F))
+      return GenField(Field);
+  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>();
 }
 
 template <class Emitter>
 Record *ByteCodeExprGen<Emitter>::getRecord(QualType Ty) {
   if (auto *RecordTy = getRecordTy(Ty)) {
     return getRecord(RecordTy->getDecl());
   }
   return nullptr;
 }
 
 template <class Emitter>
 Record *ByteCodeExprGen<Emitter>::getRecord(const RecordDecl *RD) {
   return P.getOrCreateRecord(RD);
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitOpaqueExpr(const OpaqueValueExpr *E) {
+  PrimType Ty;
+  if (Optional<PrimType> T = classify(E->getType())) {
+    Ty = *T;
+  } else {
+    Ty = PT_Ptr;
+  }
+
+  auto Off = allocateLocalPrimitive(E, Ty, /*isConst=*/true);
+  if (!visit(E->getSourceExpr()))
+    return false;
+  this->emitSetLocal(Ty, Off, E);
+  OpaqueExprs.insert({E, Off});
+  return true;
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visitExpr(const Expr *Exp) {
   ExprScope<Emitter> RootScope(this);
-  if (!visit(Exp))
+
+  if (Optional<PrimType> ExpTy = classify(Exp)) {
+    if (Exp->isGLValue()) {
+      // If the expression is an lvalue, dereference it.
+      if (!lvalueToRvalue(Exp, Exp))
         return false;
 
-  if (Optional<PrimType> T = classify(Exp))
-    return this->emitRet(*T, Exp);
-  else
+      // Find the type of the expression.
+      PrimType Ty;
+      if (Optional<PrimType> T = classify(Exp->getType())) {
+        Ty = *T;
+      } else {
+        Ty = PT_Ptr;
+      }
+
+      return this->emitRet(Ty, Exp);
+    } else {
+      // Otherwise, simply evaluate the rvalue.
+      if (!visit(Exp))
+        return false;
+      return this->emitRet(*ExpTy, Exp);
+    }
+  } else {
+    // Composite declaration - allocate a local and initialize it.
+    if (auto I = allocateLocal(Exp, /*isExtended=*/false)) {
+      if (!visitLocalInitializer(Exp, *I))
+        return false;
+      if (!this->emitGetPtrLocal(*I, Exp))
+        return false;
       return this->emitRetValue(Exp);
     }
+    return this->bail(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())) {
       {

clang/lib/AST/Interp/ByteCodeStmtGen.h

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

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

 template <typename T> using Optional = llvm::Optional<T>;
 
 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))
-    return this->bail(MD);
+  if (auto *MD = dyn_cast<CXXMethodDecl>(F)) {
+    const CXXRecordDecl *RD = MD->getParent()->getCanonicalDecl();
+    if (auto *R = this->getRecord(RD)) {
+      if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {
+        // If this is a copy or move constructor for a union, emit a special
+        // opcode since the operation cannot be represented in the AST easily.
+        if (CD->isDefaulted() && CD->isCopyOrMoveConstructor() && RD->isUnion())
+          return this->emitInitUnion(CD) && this->emitRetVoid(CD);
+
+        if (CD->isDelegatingConstructor()) {
+          CXXConstructorDecl::init_const_iterator I = CD->init_begin();
+          {
+            ExprScope<Emitter> InitScope(this);
+            if (!this->visitThisInitializer((*I)->getInit()))
+              return false;
+          }
+        } else {
+          // Compile all member initializers.
+          for (const CXXCtorInitializer *Init : CD->inits()) {
+            if (!visitCtorInit(R, Init))
+              return false;
+          }
+        }
+      }
+    } else {
+      return this->bail(RD);
+    }
+  }
 
   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{});
   else
     return this->emitNoRet(SourceInfo{});
 }
 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitStmt(const Stmt *S) {
   switch (S->getStmtClass()) {
   case Stmt::CompoundStmtClass:
     return visitCompoundStmt(cast<CompoundStmt>(S));
   case Stmt::DeclStmtClass:
     return visitDeclStmt(cast<DeclStmt>(S));
+  case Stmt::ForStmtClass:
+    return visitForStmt(cast<ForStmt>(S));
+  case Stmt::WhileStmtClass:
+    return visitWhileStmt(cast<WhileStmt>(S));
+  case Stmt::DoStmtClass:
+    return visitDoStmt(cast<DoStmt>(S));
   case Stmt::ReturnStmtClass:
     return visitReturnStmt(cast<ReturnStmt>(S));
   case Stmt::IfStmtClass:
     return visitIfStmt(cast<IfStmt>(S));
+  case Stmt::BreakStmtClass:
+    return visitBreakStmt(cast<BreakStmt>(S));
+  case Stmt::ContinueStmtClass:
+    return visitContinueStmt(cast<ContinueStmt>(S));
+  case Stmt::SwitchStmtClass:
+    return visitSwitchStmt(cast<SwitchStmt>(S));
+  case Stmt::CaseStmtClass:
+  case Stmt::DefaultStmtClass:
+    return visitCaseStmt(cast<SwitchCase>(S));
+  case Stmt::CXXForRangeStmtClass:
+    return visitCXXForRangeStmt(cast<CXXForRangeStmt>(S));
   case Stmt::NullStmtClass:
     return true;
   default: {
     if (auto *Exp = dyn_cast<Expr>(S))
       return this->discard(Exp);
     return this->bail(S);
   }
   }
if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
       return this->bail(DD);
     }
   }
 
   return true;
 }
 
 template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitForStmt(const ForStmt *FS) {
+  // Compile the initialisation statement in an outer scope.
+  BlockScope<Emitter> OuterScope(this);
+  if (auto *Init = FS->getInit())
+    if (!visitStmt(Init))
+      return false;
+
+  LabelTy LabelStart = this->getLabel();
+  LabelTy LabelEnd = this->getLabel();
+
+  // Compile the condition, body and increment in the loop scope.
+  this->emitLabel(LabelStart);
+  {
+    BlockScope<Emitter> InnerScope(this);
+
+    if (auto *Cond = FS->getCond()) {
+      if (auto *CondDecl = FS->getConditionVariableDeclStmt())
+        if (!visitDeclStmt(CondDecl))
+          return false;
+
+      if (!this->visit(Cond))
+        return false;
+
+      if (!this->jumpFalse(LabelEnd))
+        return false;
+    }
+
+    if (auto *Body = FS->getBody()) {
+      LabelTy LabelSkip = this->getLabel();
+      LoopScope<Emitter> FlowScope(this, LabelEnd, LabelSkip);
+      if (!visitStmt(Body))
+        return false;
+      this->emitLabel(LabelSkip);
+    }
+
+    if (auto *Inc = FS->getInc()) {
+      ExprScope<Emitter> IncScope(this);
+      if (!this->discard(Inc))
+        return false;
+    }
+    if (!this->jump(LabelStart))
+      return false;
+  }
+  this->emitLabel(LabelEnd);
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitWhileStmt(const WhileStmt *WS) {
+  LabelTy LabelStart = this->getLabel();
+  LabelTy LabelEnd = this->getLabel();
+
+  this->emitLabel(LabelStart);
+  {
+    BlockScope<Emitter> InnerScope(this);
+    if (auto *CondDecl = WS->getConditionVariableDeclStmt())
+      if (!visitDeclStmt(CondDecl))
+        return false;
+
+    if (!this->visit(WS->getCond()))
+      return false;
+
+    if (!this->jumpFalse(LabelEnd))
+      return false;
+
+    {
+      LoopScope<Emitter> FlowScope(this, LabelEnd, LabelStart);
+      if (!visitStmt(WS->getBody()))
+        return false;
+    }
+    if (!this->jump(LabelStart))
+      return false;
+  }
+  this->emitLabel(LabelEnd);
+
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitDoStmt(const DoStmt *DS) {
+  LabelTy LabelStart = this->getLabel();
+  LabelTy LabelEnd = this->getLabel();
+  LabelTy LabelSkip = this->getLabel();
+
+  this->emitLabel(LabelStart);
+  {
+    {
+      LoopScope<Emitter> FlowScope(this, LabelEnd, LabelSkip);
+      if (!visitStmt(DS->getBody()))
+        return false;
+      this->emitLabel(LabelSkip);
+    }
+
+    {
+      ExprScope<Emitter> CondScope(this);
+      if (!this->visitBool(DS->getCond()))
+        return false;
+    }
+
+    if (!this->jumpTrue(LabelStart))
+      return false;
+  }
+  this->emitLabel(LabelEnd);
+
+  return true;
+}
+
+template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitReturnStmt(const ReturnStmt *RS) {
   if (const Expr *RE = RS->getRetValue()) {
     ExprScope<Emitter> RetScope(this);
     if (ReturnType) {
       // Primitive types are simply returned.
       if (!this->visit(RE))
         return false;
       this->emitCleanup();
if (!visitStmt(IS->getThen()))
       return false;
     this->emitLabel(LabelEnd);
   }
 
   return true;
 }
 
 template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitBreakStmt(const BreakStmt *BS) {
+  if (!BreakLabel)
+    return this->bail(BS);
+  return this->jump(*BreakLabel);
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitContinueStmt(const ContinueStmt *CS) {
+  if (!ContinueLabel)
+    return this->bail(CS);
+  return this->jump(*ContinueLabel);
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitSwitchStmt(const SwitchStmt *SS) {
+  BlockScope<Emitter> InnerScope(this);
+
+  if (Optional<PrimType> T = this->classify(SS->getCond()->getType())) {
+    // The condition is stored in a local and fetched for every test.
+    unsigned Off = this->allocateLocalPrimitive(SS->getCond(), *T,
+                                                /*isConst=*/true);
+
+    // Compile the condition in its own scope.
+    {
+      ExprScope<Emitter> CondScope(this);
+      if (const Stmt *CondInit = SS->getInit())
+        if (!visitStmt(SS->getInit()))
+          return false;
+
+      if (const DeclStmt *CondDecl = SS->getConditionVariableDeclStmt())
+        if (!visitDeclStmt(CondDecl))
+          return false;
+
+      if (!this->visit(SS->getCond()))
+        return false;
+
+      if (!this->emitSetLocal(*T, Off, SS->getCond()))
+        return false;
+    }
+
+    LabelTy LabelEnd = this->getLabel();
+
+    // Generate code to inspect all case labels, jumping to the matched one.
+    const DefaultStmt *Default = nullptr;
+    CaseMap Labels;
+    for (auto *SC = SS->getSwitchCaseList(); SC; SC = SC->getNextSwitchCase()) {
+      LabelTy Label = this->getLabel();
+      Labels.insert({SC, Label});
+
+      if (auto *DS = dyn_cast<DefaultStmt>(SC)) {
+        Default = DS;
+        continue;
+      }
+
+      if (auto *CS = dyn_cast<CaseStmt>(SC)) {
+        if (!this->emitGetLocal(*T, Off, CS))
+          return false;
+        if (!this->visit(CS->getLHS()))
+          return false;
+
+        if (auto *RHS = CS->getRHS()) {
+          if (!this->visit(CS->getRHS()))
+            return false;
+          if (!this->emitInRange(*T, CS))
+            return false;
+        } else {
+          if (!this->emitEQ(*T, CS))
+            return false;
+        }
+
+        if (!this->jumpTrue(Label))
+          return false;
+        continue;
+      }
+
+      return this->bail(SS);
+    }
+
+    // If a case wasn't matched, jump to default or skip the body.
+    if (!this->jump(Default ? Labels[Default] : LabelEnd))
+      return false;
+    OptLabelTy DefaultLabel = Default ? Labels[Default] : OptLabelTy{};
+
+    // Compile the body, using labels defined previously.
+    SwitchScope<Emitter> LabelScope(this, std::move(Labels), LabelEnd,
+                                    DefaultLabel);
+    if (!visitStmt(SS->getBody()))
+      return false;
+    this->emitLabel(LabelEnd);
+    return true;
+  } else {
+    return this->bail(SS);
+  }
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitCaseStmt(const SwitchCase *CS) {
+  auto It = CaseLabels.find(CS);
+  if (It == CaseLabels.end())
+    return this->bail(CS);
+
+  this->emitLabel(It->second);
+  return visitStmt(CS->getSubStmt());
+}
+
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitCXXForRangeStmt(const CXXForRangeStmt *FS) {
+  BlockScope<Emitter> Scope(this);
+
+  // Emit the optional init-statement.
+  if (auto *Init = FS->getInit()) {
+    if (!visitStmt(Init))
+      return false;
+  }
+
+  // Initialise the __range variable.
+  if (!visitStmt(FS->getRangeStmt()))
+    return false;
+
+  // Create the __begin and __end iterators.
+  if (!visitStmt(FS->getBeginStmt()) || !visitStmt(FS->getEndStmt()))
+    return false;
+
+  LabelTy LabelStart = this->getLabel();
+  LabelTy LabelEnd = this->getLabel();
+
+  this->emitLabel(LabelStart);
+  {
+    // Lower the condition.
+    if (!this->visitBool(FS->getCond()))
+      return false;
+    if (!this->jumpFalse(LabelEnd))
+      return false;
+
+    // Lower the loop var and body, marking labels for continue/break.
+    {
+      BlockScope<Emitter> InnerScope(this);
+      if (!visitStmt(FS->getLoopVarStmt()))
+        return false;
+
+      LabelTy LabelSkip = this->getLabel();
+      {
+        LoopScope<Emitter> FlowScope(this, LabelEnd, LabelSkip);
+
+        if (!visitStmt(FS->getBody()))
+          return false;
+      }
+      this->emitLabel(LabelSkip);
+    }
+
+    // Increment: ++__begin
+    if (!visitStmt(FS->getInc()))
+      return false;
+    if (!this->jump(LabelStart))
+      return false;
+  }
+  this->emitLabel(LabelEnd);
+  return true;
+}
+
+template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitVarDecl(const VarDecl *VD) {
   auto DT = VD->getType();
 
   if (!VD->hasLocalStorage()) {
     // No code generation required.
     return true;
   }
 
if (Optional<PrimType> T = this->classify(DT)) {
     if (auto Off = this->allocateLocal(VD)) {
       return this->visitLocalInitializer(VD->getInit(), *Off);
     } else {
       return this->bail(VD);
     }
   }
 }
 
+template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitCtorInit(Record *This,
+                                             const CXXCtorInitializer *Ctor) {
+  auto *Init = Ctor->getInit();
+  if (auto *Base = Ctor->getBaseClass()) {
+    auto *Decl = Base->getAs<RecordType>()->getDecl();
+    return this->visitBaseInitializer(Init, [this, &This, Init, Ctor, Decl] {
+      if (Ctor->isBaseVirtual())
+        return this->emitGetPtrThisVirtBase(Decl, Init);
+      else
+        return this->emitGetPtrThisBase(This->getBase(Decl)->Offset, Init);
+    });
+  }
+
+  if (const FieldDecl *FD = Ctor->getMember()) {
+    ExprScope<Emitter> Scope(this);
+    return this->withField(FD, [this, FD, Init, This](const Record::Field *F) {
+      if (Optional<PrimType> T = this->classify(FD->getType())) {
+        // Primitive type, can be computed and set.
+        if (!this->visit(Init))
+          return false;
+        if (This->isUnion())
+          return this->emitInitThisFieldActive(*T, F->Offset, Init);
+        if (F->Decl->isBitField())
+          return this->emitInitThisBitField(*T, F, Init);
+        return this->emitInitThisField(*T, F->Offset, Init);
+      } else {
+        // Nested structures.
+        return this->visitInitializer(Init, [this, F, Init] {
+          return this->emitGetPtrThisField(F->Offset, Init);
+        });
+      }
+    });
+  }
+
+  if (auto *FD = Ctor->getIndirectMember()) {
+    auto *Init = Ctor->getInit();
+    if (Optional<PrimType> T = this->classify(Init->getType())) {
+      ArrayRef<NamedDecl *> Chain = FD->chain();
+      Record *R = This;
+      for (unsigned I = 0, N = Chain.size(); I < N; ++I) {
+        const bool IsUnion = R->isUnion();
+        auto *Member = cast<FieldDecl>(Chain[I]);
+        auto MemberTy = Member->getType();
+
+        auto *FD = R->getField(Member);
+        if (!FD)
+          return this->bail(Member);
+
+        const unsigned Off = FD->Offset;
+        if (I + 1 == N) {
+          // Last member - set the field.
+          if (!this->visit(Init))
+            return false;
+          if (IsUnion) {
+            return this->emitInitFieldActive(*T, Off, Init);
+          } else {
+            return this->emitInitFieldPop(*T, Off, Init);
+          }
+        } else {
+          // Next field must be a record - fetch it.
+          R = this->getRecord(cast<RecordType>(MemberTy)->getDecl());
+          if (!R)
+            return this->bail(Member);
+
+          if (IsUnion) {
+            if (I == 0) {
+              // Base member - activate this pointer.
+              if (!this->emitGetPtrActiveThisField(Off, Member))
+                return false;
+            } else {
+              // Intermediate - active subfield.
+              if (!this->emitGetPtrActiveField(Off, Member))
+                return false;
+            }
+          } else {
+            if (I == 0) {
+              // Base member - get this pointer.
+              if (!this->emitGetPtrThisField(Off, Member))
+                return false;
+            } else {
+              // Intermediate - get pointer.
+              if (!this->emitGetPtrField(Off, Member))
+                return false;
+            }
+          }
+        }
+      }
+    } else {
+      return this->bail(FD);
+    }
+
+    return true;
+  }
+
+  llvm_unreachable("unknown base initializer kind");
+}
+
 namespace clang {
 namespace interp {
 
 template class ByteCodeStmtGen<ByteCodeEmitter>;
 
 } // namespace interp
 } // namespace clang

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"
 
 using namespace clang;
 using namespace clang::interp;
InterpResult Context::evaluateAsInitializer(State &Parent, const VarDecl *VD,
   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()) {
+    if (T->isFunctionPointerType())
+      return PT_FnPtr;
     return PT_Ptr;
   }
 
   if (T->isBooleanType())
     return PT_Bool;
 
   if (T->isSignedIntegerOrEnumerationType()) {
     switch (Ctx.getIntWidth(T)) {
     case 64:
       return PT_Sint64;
     case 32:
       return PT_Sint32;
     case 16:
       return PT_Sint16;
     case 8:
       return PT_Sint8;
     default:
-      return {};
+      return PT_SintFP;
     }
   }
 
   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 {};
+      return PT_UintFP;
     }
   }
 
+  if (T->isRealFloatingType())
+    return PT_RealFP;
+
   if (T->isNullPtrType())
     return PT_Ptr;
 
+  if (T->isMemberPointerType())
+    return PT_MemPtr;
+
+  if (T->isFunctionProtoType())
+    return PT_FnPtr;
+
   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::emitInvoke(Function *Fn, const SourceInfo &Info) {
   if (!isActive())
     return true;
-  using T = typename PrimConv<OpType>::T;
-  return ReturnValue<T>(S.Stk.pop<T>(), Result);
-}
 
-bool EvalEmitter::emitRetVoid(const SourceInfo &Info) { return true; }
+  Pointer This = S.Stk.pop<Pointer>();
+  if (!S.CheckInvoke(OpPC, This))
+    return false;
+  if (S.checkingPotentialConstantExpression())
+    return false;
 
-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 method in its own frame.
+  return executeCall(Fn, std::move(This), 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);
-          }
-        }
+bool EvalEmitter::emitCall(Function *Fn, const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+  if (S.checkingPotentialConstantExpression())
+    return false;
 
-        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));
-        }
+  // Interpret the function in its own frame.
+  return executeCall(Fn, Pointer(), Info);
 
-        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 EvalEmitter::emitVirtualInvoke(const CXXMethodDecl *MD,
+                                    const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+  // Get the this pointer, ensure it's live.
+  Pointer This = S.Stk.pop<Pointer>();
+  if (!S.CheckInvoke(OpPC, This))
+    return false;
+  if (S.checkingPotentialConstantExpression())
+    return false;
 
-      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");
-  };
+  // Dispatch to the virtual method.
+  CurrentSource = Info;
+  const CXXMethodDecl *Override = VirtualLookup(This, MD);
+  if (!S.CheckPure(OpPC, Override))
+    return false;
+  if (Expected<Function *> Func = P.getOrCreateFunction(Override)) {
+    if (*Func) {
+      return executeCall(*Func, std::move(This), Info);
+      return executeNoCall(Override, Info);
+  } else {
+    // Failed to compile method - bail out.
+    return false;
 
+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);
+}
+
+bool EvalEmitter::emitRetVoid(const SourceInfo &Info) { return true; }
+
+bool EvalEmitter::emitRetValue(const SourceInfo &Info) {
   // Return the composite type.
-  const auto &Ptr = S.Stk.pop<Pointer>();
-  return Composite(Ptr.getType(), Ptr, Result);
+  return PointerToValue(S.Stk.pop<Pointer>(), Result);
 }
 
 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");
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) {
+  if (!isActive())
+    return true;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  return executeNoCall(F, Info);
+}
+
+bool EvalEmitter::emitNoInvoke(const CXXMethodDecl *F, const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  return executeNoCall(F, Info);
+}
+
+bool EvalEmitter::emitIndirectCall(const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+
+  const FnPointer &FnPtr = S.Stk.pop<FnPointer>();
+  if (FnPtr.isZero()) {
+    S.FFDiag(Info);
+    return false;
+  }
+
+  if (Function *F = FnPtr.asFunction())
+    return executeCall(F, Pointer(), Info);
+
+  const FunctionDecl *Decl = FnPtr.asDecl();
+  if (Expected<Function *> Func = S.P.getOrCreateFunction(Decl)) {
+    if (*Func)
+      return executeCall(*Func, Pointer(), Info);
+    else
+      return executeNoCall(Decl, Info);
+  } else {
+    consumeError(Func.takeError());
+    return false;
+  }
+}
+
+bool EvalEmitter::emitIndirectInvoke(const SourceInfo &Info) {
+  if (!isActive())
+    return true;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+
+  // Fetch and validate the object and the pointer.
+  const MemberPointer &Field = S.Stk.pop<MemberPointer>();
+  Pointer This = S.Stk.pop<Pointer>();
+  if (!S.CheckInvoke(OpPC, This))
+    return false;
+  if (Field.isZero()) {
+    S.FFDiag(Info);
+    return false;
+  }
+
+  // Fetch a pointer to the member function.
+  const CXXMethodDecl *Method = IndirectLookup(This, Field);
+  if (!Method)
+    return false;
+  if (!S.CheckPure(OpPC, Method))
+    return false;
+
+  // Execute the function.
+  if (Expected<Function *> Func = S.P.getOrCreateFunction(Method)) {
+    if (*Func)
+      return executeCall(*Func, std::move(This), Info);
+    else
+      return executeNoCall(Method, Info);
+  } else {
+    consumeError(Func.takeError());
+    return false;
+  }
+}
+
+bool EvalEmitter::executeCall(Function *F, Pointer &&This,
+                              const SourceInfo &Info) {
+  CurrentSource = Info;
+  if (!S.CheckCallable(OpPC, F))
+    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.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/FixedIntegral.h

+//===--- FixedIntegral.h - Wrapper for fixed precision ints -----*- 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_FIXEDINTEGRAL_H
+#define LLVM_CLANG_AST_INTERP_FIXEDINTEGRAL_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/raw_ostream.h"
+
+namespace clang {
+namespace interp {
+
+using APInt = llvm::APInt;
+using APSInt = llvm::APSInt;
+
+/// Specialisation for fixed precision integers.
+template <bool Signed>
+class FixedIntegral {
+ private:
+  template <bool OtherSigned> friend class FixedIntegral;
+
+  /// Value is stored in an APSInt.
+  APSInt V;
+
+ public:
+  /// Integral initialized to an undefined value.
+  FixedIntegral() : V() {}
+
+  /// Construct an integral from a value based on signedness.
+  explicit FixedIntegral(const APSInt &V) : V(V, !Signed) {}
+
+  bool operator<(const FixedIntegral &RHS) const { return V < RHS.V; }
+  bool operator>(const FixedIntegral &RHS) const { return V > RHS.V; }
+  bool operator<=(const FixedIntegral &RHS) const { return V <= RHS.V; }
+  bool operator>=(const FixedIntegral &RHS) const { return V >= RHS.V; }
+  bool operator==(const FixedIntegral &RHS) const { return V == RHS.V; }
+  bool operator!=(const FixedIntegral &RHS) const { return V != RHS.V; }
+
+  template <typename T>
+  bool operator>(T RHS) const {
+    constexpr bool ArgSigned = std::is_signed<T>::value;
+    return V > APSInt(APInt(V.getBitWidth(), RHS, ArgSigned), !ArgSigned);
+  }
+
+  template <typename T>
+  bool operator<(T RHS) const {
+    constexpr bool ArgSigned = std::is_signed<T>::value;
+    return V < APSInt(APInt(V.getBitWidth(), RHS, ArgSigned), !ArgSigned);
+  }
+
+  FixedIntegral operator+(FixedIntegral RHS) const {
+    return FixedIntegral(V + RHS.V);
+  }
+  FixedIntegral operator-(FixedIntegral RHS) const {
+    return FixedIntegral(V - RHS.V);
+  }
+  FixedIntegral operator*(FixedIntegral RHS) const {
+    return FixedIntegral(V * RHS.V);
+  }
+  FixedIntegral operator/(FixedIntegral RHS) const {
+    return FixedIntegral(V / RHS.V);
+  }
+  FixedIntegral operator%(FixedIntegral RHS) const {
+    return FixedIntegral(V % RHS.V);
+  }
+  FixedIntegral operator&(FixedIntegral RHS) const {
+    return FixedIntegral(V & RHS.V);
+  }
+  FixedIntegral operator|(FixedIntegral RHS) const {
+    return FixedIntegral(V | RHS.V);
+  }
+  FixedIntegral operator^(FixedIntegral RHS) const {
+    return FixedIntegral(V ^ RHS.V);
+  }
+
+  FixedIntegral operator-() const { return FixedIntegral(-V); }
+  FixedIntegral operator~() const { return FixedIntegral(~V); }
+
+  FixedIntegral operator>>(unsigned RHS) const {
+    return FixedIntegral(V >> RHS);
+  }
+  FixedIntegral operator<<(unsigned RHS) const {
+    return FixedIntegral(V << RHS);
+  }
+
+  explicit operator off_t() const {
+    return Signed ? V.getSExtValue() : V.getZExtValue();
+  }
+  explicit operator unsigned() const {
+    return Signed ? V.getZExtValue() : V.getZExtValue();
+  }
+
+  APSInt toAPSInt() const { return V; }
+  APSInt toAPSInt(unsigned NumBits) const {
+    if (Signed)
+      return APSInt(toAPSInt().sextOrTrunc(NumBits), !Signed);
+    else
+      return APSInt(toAPSInt().zextOrTrunc(NumBits), !Signed);
+  }
+  APValue toAPValue() const { return APValue(toAPSInt()); }
+
+  FixedIntegral<false> toUnsigned() const {
+    return FixedIntegral<false>::from(*this, bitWidth());
+  }
+
+  unsigned bitWidth() const { return V.getBitWidth(); }
+
+  bool isZero() const { return V.isNullValue(); }
+
+  bool isMin() const {
+    if (Signed)
+      return V.isMinSignedValue();
+    else
+      return V.isMinValue();
+  }
+
+  bool isMinusOne() const { return Signed && V.isAllOnesValue(); }
+
+  constexpr static bool isSigned() { return Signed; }
+
+  bool isNegative() const { return V.isNegative(); }
+  bool isPositive() const { return !isNegative(); }
+
+  ComparisonCategoryResult compare(const FixedIntegral &RHS) const {
+    if (V < RHS.V) return ComparisonCategoryResult::Less;
+    if (V > RHS.V) return ComparisonCategoryResult::Greater;
+    return ComparisonCategoryResult::Equal;
+  }
+
+  unsigned countLeadingZeros() const { return V.countLeadingZeros(); }
+
+  FixedIntegral truncate(unsigned TruncBits) const {
+    if (TruncBits >= bitWidth()) return *this;
+    return FixedIntegral(V.trunc(TruncBits).extend(bitWidth()));
+  }
+
+  void print(llvm::raw_ostream &OS) const { OS << V; }
+
+  static FixedIntegral min(unsigned NumBits) {
+    if (Signed)
+      return FixedIntegral(APSInt(APInt::getSignedMinValue(NumBits), !Signed));
+    else
+      return FixedIntegral(APSInt(APInt::getMinValue(NumBits), !Signed));
+  }
+
+  static FixedIntegral max(unsigned NumBits) {
+    if (Signed)
+      return FixedIntegral(APSInt(APInt::getSignedMaxValue(NumBits), !Signed));
+    else
+      return FixedIntegral(APSInt(APInt::getMaxValue(NumBits), !Signed));
+  }
+
+  template <typename T>
+  static
+      typename std::enable_if<std::is_integral<T>::value, FixedIntegral>::type
+      from(T Value, unsigned NumBits) {
+    const bool SrcSign = std::is_signed<T>::value;
+    APInt IntVal(NumBits, static_cast<uint64_t>(Value), SrcSign);
+    return FixedIntegral(APSInt(IntVal, !SrcSign));
+  }
+
+  template <unsigned SrcBits, bool SrcSigned>
+  static FixedIntegral from(const Integral<SrcBits, SrcSigned> &I,
+                            unsigned NumBits);
+
+  template <bool SrcSign>
+  static FixedIntegral from(FixedIntegral<SrcSign> Value, unsigned NumBits) {
+    if (SrcSign)
+      return FixedIntegral(APSInt(Value.V.sextOrTrunc(NumBits), !Signed));
+    else
+      return FixedIntegral(APSInt(Value.V.zextOrTrunc(NumBits), !Signed));
+  }
+
+  static FixedIntegral from(Boolean Value, unsigned NumBits) {
+    return FixedIntegral(
+        APSInt(NumBits, static_cast<uint64_t>(!Value.isZero())));
+  }
+
+  static FixedIntegral zero(unsigned NumBits) { return from(0, NumBits); }
+
+  static bool inRange(int64_t Value, unsigned NumBits) {
+    APSInt V(APInt(NumBits, Value, true), false);
+    return min(NumBits).V <= V && V <= max(NumBits).V;
+  }
+
+  static bool increment(FixedIntegral A, FixedIntegral *R) {
+    *R = A + FixedIntegral::from(1, A.bitWidth());
+    return A.isSigned() && !A.isNegative() && R->isNegative();
+  }
+
+  static bool decrement(FixedIntegral A, FixedIntegral *R) {
+    *R = A - FixedIntegral::from(1, A.bitWidth());
+    return !A.isSigned() && A.isNegative() && !R->isNegative();
+  }
+
+  static bool add(FixedIntegral A, FixedIntegral B, unsigned OpBits,
+                  FixedIntegral *R) {
+    APSInt Value(A.V.extend(OpBits) + B.V.extend(OpBits));
+    *R = FixedIntegral(Value.trunc(A.bitWidth()));
+    return R->V.extend(OpBits) != Value;
+  }
+
+  static bool sub(FixedIntegral A, FixedIntegral B, unsigned OpBits,
+                  FixedIntegral *R) {
+    APSInt Value(A.V.extend(OpBits) - B.V.extend(OpBits));
+    *R = FixedIntegral(Value.trunc(A.bitWidth()));
+    return R->V.extend(OpBits) != Value;
+  }
+
+  static bool mul(FixedIntegral A, FixedIntegral B, unsigned OpBits,
+                  FixedIntegral *R) {
+    APSInt Value(A.V.extend(OpBits) * B.V.extend(OpBits));
+    *R = FixedIntegral(Value.trunc(A.bitWidth()));
+    return R->V.extend(OpBits) != Value;
+  }
+};
+
+template <bool Signed>
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, FixedIntegral<Signed> I) {
+  I.print(OS);
+  return OS;
+}
+
+}  // namespace interp
+}  // namespace clang
+
+#endif

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);
+
+  /// Solves an invoke relocation.
+  void relocateInvoke(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);
+}
+
+void Function::relocateInvoke(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_Invoke;
+
+  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 "FixedIntegral.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;
+  if (X < Y) return ComparisonCategoryResult::Less;
+  if (X > Y) return ComparisonCategoryResult::Greater;
   return ComparisonCategoryResult::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 isNegative() const { return V < T(0); }
   bool isPositive() const { return !isNegative(); }
 
   ComparisonCategoryResult compare(const Integral &RHS) const {
     return Compare(V, RHS.V);
   }
 
-  unsigned countLeadingZeros() const { 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 typename std::enable_if<std::is_integral<T>::value, Integral>::type
   from(T Value) {
     return Integral(Value);
   }
 
   template <unsigned SrcBits, bool SrcSign>
-  static typename std::enable_if<SrcBits != 0, Integral>::type
-  from(Integral<SrcBits, SrcSign> Value) {
+  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 FixedIntegral<SrcSign> &Value) {
+    return Integral(Value.toAPSInt().getExtValue());
+  }
+
+  template <bool SrcSign>
+  static Integral from(Integral<0, SrcSign> Value) {
     if (SrcSign)
       return Integral(Value.V.getSExtValue());
     else
       return Integral(Value.V.getZExtValue());
   }
 
+  static Integral 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 typename std::enable_if<std::is_signed<T>::value, bool>::type
   CheckAddUB(T A, T B, T &R) {
     return llvm::AddOverflow<T>(A, B, R);
   }
 
   template <typename T>
   static typename std::enable_if<std::is_unsigned<T>::value, bool>::type

 };
 
 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());
+}
+
+template <bool Signed>
+Boolean Boolean::from(const FixedIntegral<Signed> &V) {
+  return Boolean(!V.isZero());
+}
+
+template <bool DstSigned>
+template <unsigned Bits, bool SrcSigned>
+FixedIntegral<DstSigned> FixedIntegral<DstSigned>::from(
+    const Integral<Bits, SrcSigned> &I, unsigned NumBits) {
+  return FixedIntegral(I.toAPSInt().extOrTrunc(NumBits));
+}
+
+}  // 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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_INTERP_INTERP_H
 #define LLVM_CLANG_AST_INTERP_INTERP_H
 
-#include <limits>
-#include <vector>
+#include "Builtin.h"
 #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;

 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Mul(InterpState &S, CodePtr OpPC) {
   const T &RHS = S.Stk.pop<T>();
   const T &LHS = S.Stk.pop<T>();
   const unsigned Bits = RHS.bitWidth() * 2;
   return AddSubMulHelper<T, T::mul, std::multiplies>(S, OpPC, Bits, LHS, RHS);
 }
 
+template <Real (*Op)(const Real &, const Real &, RoundingMode), RoundingMode M>
+bool RealArithHelper(InterpState &S, CodePtr OpPC) {
+  const Real &RHS = S.Stk.pop<Real>();
+  const Real &LHS = S.Stk.pop<Real>();
+
+  Real Result = Op(LHS, RHS, M);
+  S.Stk.push<Real>(Result);
+  if (!Result.isNaN())
+    return true;
+
+  const SourceInfo &Src = S.getSource(OpPC);
+  S.CCEDiag(Src, diag::note_constexpr_float_arithmetic) << Result.isNaN();
+  return S.noteUndefinedBehavior();
+}
+
+template <> inline bool Add<PT_RealFP>(InterpState &S, CodePtr OpPC) {
+  return RealArithHelper<Real::add, APFloat::rmNearestTiesToEven>(S, OpPC);
+}
+
+template <> inline bool Sub<PT_RealFP>(InterpState &S, CodePtr OpPC) {
+  return RealArithHelper<Real::sub, APFloat::rmNearestTiesToEven>(S, OpPC);
+}
+
+template <> inline bool Mul<PT_RealFP>(InterpState &S, CodePtr OpPC) {
+  return RealArithHelper<Real::mul, APFloat::rmNearestTiesToEven>(S, OpPC);
+}
+
+//===----------------------------------------------------------------------===//
+// Div, Rem
+//===----------------------------------------------------------------------===//
+
+template <typename T, T (*OpFW)(T, T), typename OpAP>
+bool DivRemHelper(InterpState &S, CodePtr OpPC) {
+  const T RHS = S.Stk.pop<T>();
+  const T LHS = S.Stk.pop<T>();
+
+  // Bail on division by zero.
+  if (RHS.isZero()) {
+    S.FFDiag(S.getSource(OpPC), diag::note_expr_divide_by_zero);
+    return false;
+  }
+
+  if (RHS.isSigned()) {
+    // (-MAX - 1) / -1 = MAX + 1 overflows.
+    if (LHS.isMin() && RHS.isMinusOne()) {
+      // Push the truncated value in case the interpreter continues.
+      S.Stk.push<T>(T::min(RHS.bitWidth()));
+
+      // Compute the actual value for the diagnostic.
+      const size_t Bits = RHS.bitWidth() + 1;
+      APSInt Value = OpAP()(LHS.toAPSInt(Bits), RHS.toAPSInt(Bits));
+      return S.reportOverflow(S.getSource(OpPC).asExpr(), Value);
+    }
+  }
+
+  // Safe to execute division here.
+  S.Stk.push<T>(OpFW(LHS, RHS));
+  return true;
+}
+
+template <typename T> T DivFn(T a, T b) { return a / b; }
+
+template <typename T> T RemFn(T a, T b) { return a % b; }
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Div(InterpState &S, CodePtr OpPC) {
+  return DivRemHelper<T, DivFn<T>, std::divides<APSInt>>(S, OpPC);
+}
+
+template <> inline bool Div<PT_RealFP>(InterpState &S, CodePtr OpPC) {
+  const Real RHS = S.Stk.pop<Real>();
+  const Real LHS = S.Stk.pop<Real>();
+
+  if (RHS.isZero()) {
+    S.FFDiag(S.getSource(OpPC), diag::note_expr_divide_by_zero);
+    return false;
+  }
+  S.Stk.push<Real>(Real::div(LHS, RHS, APFloat::rmNearestTiesToEven));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Rem(InterpState &S, CodePtr OpPC) {
+  return DivRemHelper<T, RemFn<T>, std::modulus<APSInt>>(S, OpPC);
+}
+
 //===----------------------------------------------------------------------===//
 // EQ, NE, GT, GE, LT, LE
 //===----------------------------------------------------------------------===//
 
 using CompareFn = llvm::function_ref<bool(ComparisonCategoryResult)>;
 
 template <typename T>
 bool CmpHelper(InterpState &S, CodePtr OpPC, CompareFn Fn) {

 
 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);
+    const SourceInfo &Loc = S.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;
   }
inline bool CmpHelperEQ<Pointer>(InterpState &S, CodePtr OpPC, CompareFn Fn) {
   } 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<MemberPointer>(InterpState &S, CodePtr OpPC,
+                                       CompareFn Fn) {
+  using BoolT = PrimConv<PT_Bool>::T;
+  const auto &RHS = S.Stk.pop<MemberPointer>();
+  const auto &LHS = S.Stk.pop<MemberPointer>();
+
+  auto CheckVirtual = [OpPC, &S](const MemberPointer &Ptr) {
+    if (auto *MD = dyn_cast<CXXMethodDecl>(Ptr.getDecl())) {
+      if (MD->isVirtual()) {
+        const SourceInfo &E = S.getSource(OpPC);
+        S.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
+        return false;
+      }
+    }
+    return true;
+  };
+
+  using CCR = ComparisonCategoryResult;
+  if (!LHS.getDecl() || !RHS.getDecl()) {
+    CCR Result = !LHS.getDecl() && !RHS.getDecl() ? CCR::Equal : CCR::Nonequal;
+    S.Stk.push<BoolT>(BoolT::from(Fn(Result)));
+    return true;
+  }
+
+  if (!CheckVirtual(LHS) || !CheckVirtual(RHS))
+    return false;
+
+  S.Stk.push<BoolT>(BoolT::from(Fn(LHS == RHS ? CCR::Equal : CCR::Nonequal)));
+  return true;
+}
+
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool EQ(InterpState &S, CodePtr OpPC) {
   return CmpHelperEQ<T>(S, OpPC, [](ComparisonCategoryResult R) {
     return R == ComparisonCategoryResult::Equal;
   });
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
bool InRange(InterpState &S, CodePtr OpPC) {
   const T LHS = S.Stk.pop<T>();
   const T Value = S.Stk.pop<T>();
 
   S.Stk.push<bool>(LHS <= Value && Value <= RHS);
   return true;
 }
 
 //===----------------------------------------------------------------------===//
+// Minus, Not, LogicalNot
+//===----------------------------------------------------------------------===//
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Minus(InterpState &S, CodePtr OpPC) {
+  const T &Arg = S.Stk.pop<T>();
+
+  if (Arg.isSigned() && Arg.isMin()) {
+    // Push the truncated value in case the interpreter continues.
+    S.Stk.push<T>(T::min(Arg.bitWidth()));
+
+    // Compute the actual value for the diagnostic.
+    const size_t Bits = Arg.bitWidth() + 1;
+    const APSInt Value = std::negate<APSInt>()(Arg.toAPSInt(Bits));
+    return S.reportOverflow(S.getSource(OpPC).asExpr(), Value);
+  }
+
+  S.Stk.push<T>(std::negate<T>()(Arg));
+  return true;
+}
+
+template <> inline bool Minus<PT_RealFP>(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<Real>(Real::negate(S.Stk.pop<Real>()));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Not(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<T>(~S.Stk.pop<T>());
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool LogicalNot(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<bool>(S.Stk.pop<T>().isZero());
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
 // Dup, Pop, Test
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Dup(InterpState &S, CodePtr OpPC) {
   S.Stk.push<T>(S.Stk.peek<T>());
   return true;
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Pop(InterpState &S, CodePtr OpPC) {
   S.Stk.pop<T>();
   return true;
 }
 
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Test(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<bool>(!S.Stk.pop<T>().isZero());
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 // Const
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Const(InterpState &S, CodePtr OpPC, const T &Arg) {
   S.Stk.push<T>(Arg);
   return true;
 }
 
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool ConstFP(InterpState &S, CodePtr OpPC, uint32_t Bits, uint64_t Value) {
+  S.Stk.push<T>(T::from(Value, Bits));
+  return true;
+}
+
+inline bool ConstRealFP(InterpState &S, CodePtr OpPC,
+                        const FloatingLiteral *Value) {
+  S.Stk.push<Real>(Real::from(Value->getValue(), Value->getSemantics()));
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// ConstFn, ConstNoFn, ConstMem
+//===----------------------------------------------------------------------===//
+
+inline bool ConstFn(InterpState &S, CodePtr OpPC, Function *Fn) {
+  S.Stk.push<FnPointer>(Fn);
+  return true;
+}
+
+inline bool ConstNoFn(InterpState &S, CodePtr OpPC, const FunctionDecl *FD) {
+  // TODO: try to compile and rewrite opcode.
+  S.Stk.push<FnPointer>(FD);
+  return true;
+}
+
+inline bool ConstMem(InterpState &S, CodePtr OpPC, const ValueDecl *VD) {
+  S.Stk.push<MemberPointer>(VD);
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 // Get/Set Local/Param/Global/This
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool GetLocal(InterpState &S, CodePtr OpPC, uint32_t I) {
   S.Stk.push<T>(S.Current->getLocal<T>(I));
   return true;

 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))
+  if (!S.CheckNull(OpPC, Obj, CSK_Field))
+  if (!S.CheckRange(OpPC, Obj, CSK_Field))
     return false;
   const Pointer &Field = Obj.atField(I);
-  if (!CheckLoad(S, OpPC, Field))
+  if (!S.CheckLoad(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))
+  if (!S.CheckNull(OpPC, Obj, CSK_Field))
     return false;
-  if (!CheckRange(S, OpPC, Obj, CSK_Field))
+  if (!S.CheckRange(OpPC, Obj, CSK_Field))
     return false;
   const Pointer &Field = Obj.atField(I);
-  if (!CheckStore(S, OpPC, Field))
+  if (!S.CheckStore(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))
+  if (!S.CheckNull(OpPC, Obj, CSK_Field))
     return false;
-  if (!CheckRange(S, OpPC, Obj, CSK_Field))
+  if (!S.CheckRange(OpPC, Obj, CSK_Field))
     return false;
   const Pointer &Field = Obj.atField(I);
-  if (!CheckLoad(S, OpPC, Field))
+  if (!S.CheckLoad(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))
+  if (!S.CheckThis(OpPC, This))
     return false;
   const Pointer &Field = This.atField(I);
-  if (!CheckLoad(S, OpPC, Field))
+  if (!S.CheckLoad(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))
+  if (!S.CheckThis(OpPC, This))
     return false;
   const Pointer &Field = This.atField(I);
-  if (!CheckStore(S, OpPC, Field))
+  if (!S.CheckStore(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 (isIntegral(Name) && !B->isConst()) {
+    const SourceInfo &E = S.getSource(OpPC);
+    const ValueDecl *VD = B->getDescriptor()->asValueDecl();
+    S.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;
+    S.Note(VD->getLocation(), diag::note_declared_at);
+    return false;
+  }
   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))
+  if (!S.CheckThis(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))
+  if (!S.CheckThis(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))
+  if (!S.CheckThis(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.peek<Pointer>().atField(I);
+  Field.deref<T>() = Value;
+  Field.activate();
+  Field.initialize();
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool InitFieldPop(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 InitFieldPeek(InterpState &S, CodePtr OpPC, uint32_t I) {
+  const T &Value = S.Stk.pop<T>();
+  const Pointer &Field = S.Stk.peek<Pointer>().atField(I);
+  Field.deref<T>() = Value;
+  Field.activate();
+  Field.initialize();
+  S.Stk.push<T>(Value);
+  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;
 }

 
 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))
+  if (!S.CheckNull(OpPC, Ptr, CSK_Field))
     return false;
-  if (!CheckRange(S, OpPC, Ptr, CSK_Field))
+  if (!S.CheckRange(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))
+  if (!S.CheckThis(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))
+  if (!S.CheckNull(OpPC, Ptr, CSK_Field))
     return false;
-  if (!CheckRange(S, OpPC, Ptr, CSK_Field))
+  if (!S.CheckRange(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))
+  if (!S.CheckThis(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))
+  if (!S.CheckNull(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))
+  if (!S.CheckThis(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))
+  if (!S.CheckNull(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))
+  if (!S.CheckThis(OpPC, This))
     return false;
   return VirtBaseHelper(S, OpPC, D, S.Current->getThis());
 }
 
+inline bool GetPtrFieldIndirect(InterpState &S, CodePtr OpPC) {
+  // Fetch a pointer to the member.
+  const MemberPointer &Field = S.Stk.pop<MemberPointer>();
+
+  // Fetch and validate the object.
+  Pointer Ptr = S.Stk.pop<Pointer>();
+  if (!S.CheckNull(OpPC, Ptr, CSK_Field))
+    return false;
+  if (!S.CheckRange(OpPC, Ptr, CSK_Field))
+    return false;
+
+  // Validate the pointer.
+  if (Field.isZero()) {
+    S.FFDiag(S.getSource(OpPC));
+    return false;
+  }
+
+  // Find the correct class in the hierarchy and fetch the pointer.
+  if (auto *Decl = dyn_cast<FieldDecl>(Field.getDecl())) {
+    if (Record *R = PointerLookup(Ptr, Field)) {
+      S.Stk.push<Pointer>(Ptr.atField(R->getField(Decl)->Offset));
+      return true;
+    }
+  }
+
+  S.FFDiag(S.getSource(OpPC));
+  return false;
+}
+
 //===----------------------------------------------------------------------===//
 // 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))
+  if (!S.CheckStore(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))
+  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 InitPop(InterpState &S, CodePtr OpPC) {
   const T &Value = S.Stk.pop<T>();
   const Pointer &Ptr = S.Stk.pop<Pointer>();
-  if (!CheckInit(S, OpPC, Ptr))
+  if (!S.CheckInit(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))
+  if (!S.CheckInit(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))
+  if (!S.CheckInit(OpPC, Ptr))
     return false;
   Ptr.initialize();
   new (&Ptr.deref<T>()) T(Value);
   return true;
 }
 
+inline bool Initialise(InterpState &S, CodePtr OpPC) {
+  S.Stk.pop<Pointer>().initialize();
+  return true;
+}
+
+inline bool Activate(InterpState &S, CodePtr OpPC) {
+  S.Stk.pop<Pointer>().activate();
+  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))
+  if (!S.CheckNull(OpPC, Ptr, CSK_ArrayIndex))
     return false;
-  if (!CheckRange(S, OpPC, Ptr, CSK_ArrayToPointer))
+  if (!S.CheckRange(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))
+  if (!S.CheckArray(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())
+    S.CCEDiag(S.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)
bool AddOffset(InterpState &S, CodePtr OpPC) {
   return OffsetHelper<T, true>(S, OpPC);
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool SubOffset(InterpState &S, CodePtr OpPC) {
   return OffsetHelper<T, false>(S, OpPC);
 }
 
-
 //===----------------------------------------------------------------------===//
 // Destroy
 //===----------------------------------------------------------------------===//
 
 inline bool Destroy(InterpState &S, CodePtr OpPC, uint32_t I) {
   S.Current->destroy(I);
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // Cast, CastFP
 //===----------------------------------------------------------------------===//
 
 template <PrimType TIn, PrimType TOut> bool Cast(InterpState &S, CodePtr OpPC) {
   using T = typename PrimConv<TIn>::T;
   using U = typename PrimConv<TOut>::T;
   S.Stk.push<U>(U::from(S.Stk.pop<T>()));
   return true;
 }
 
+template <PrimType TIn, PrimType TOut>
+bool CastFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
+  using T = typename PrimConv<TIn>::T;
+  using U = typename PrimConv<TOut>::T;
+  S.Stk.push<U>(U::from(S.Stk.pop<T>(), Bits));
+  return true;
+}
+
+template <PrimType TIn>
+bool CastRealFP(InterpState &S, CodePtr OpPC, const fltSemantics *Sema) {
+  using T = typename PrimConv<TIn>::T;
+  S.Stk.push<Real>(Real::from(S.Stk.pop<T>(), *Sema));
+  return true;
+}
+
+template <typename U>
+bool RealToIntHelper(InterpState &S, CodePtr OpPC, const APFloat &Value,
+                     uintptr_t Bits) {
+  APSInt Result(Bits, !U::isSigned());
+  bool Ignored;
+
+  // Conver to int and check for overflow.
+  if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &Ignored) &
+      APFloat::opInvalidOp) {
+    const Expr *E = S.getSource(OpPC).asExpr();
+    S.CCEDiag(E, diag::note_constexpr_overflow) << Value << E->getType();
+    return S.noteUndefinedBehavior();
+  }
+
+  S.Stk.push<U>(Result);
+  return true;
+}
+
+template <PrimType TIn, PrimType TOut>
+bool CastRealFPToAlu(InterpState &S, CodePtr OpPC) {
+  using T = typename PrimConv<TIn>::T;
+  using U = typename PrimConv<TOut>::T;
+  return RealToIntHelper<U>(S, OpPC, S.Stk.pop<T>().toAPFloat(), U::bitWidth());
+}
+
+template <PrimType TIn, PrimType TOut>
+bool CastRealFPToAluFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
+  using T = typename PrimConv<TIn>::T;
+  using U = typename PrimConv<TOut>::T;
+  return RealToIntHelper<U>(S, OpPC, S.Stk.pop<T>().toAPFloat(), Bits);
+}
+
+//===----------------------------------------------------------------------===//
+// CastMemberToBase, CastMemberToDerived
+//===----------------------------------------------------------------------===//
+
+inline bool CastMemberToBase(InterpState &S, CodePtr OpPC,
+                             const CXXRecordDecl *R) {
+  if (S.Stk.peek<MemberPointer>().toBase(R))
+    return true;
+  S.FFDiag(S.getSource(OpPC));
+  return false;
+}
+
+inline bool CastMemberToDerived(InterpState &S, CodePtr OpPC,
+                                const CXXRecordDecl *R) {
+  if (S.Stk.peek<MemberPointer>().toDerived(R))
+    return true;
+  S.FFDiag(S.getSource(OpPC));
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// PointerBitCast, DynCastWarning
+//===----------------------------------------------------------------------===//
+
+inline bool PointerBitCast(InterpState &S, CodePtr OpPC) {
+  auto *E = S.getSource(OpPC).asExpr();
+  if (E->getType()->isVoidPointerType())
+    S.CCEDiag(E, diag::note_constexpr_invalid_cast) << 3 << E->getType();
+  else
+    S.CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
+
+  // TODO: invalidate pointer.
+  return false;
+}
+
+inline bool ReinterpretCastWarning(InterpState &S, CodePtr OpPC) {
+  auto *E = S.getSource(OpPC).asExpr();
+  S.CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
+  return true;
+}
+
+inline bool DynamicCastWarning(InterpState &S, CodePtr OpPC) {
+  auto *E = S.getSource(OpPC).asExpr();
+  S.CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// CastToDerived
+//===----------------------------------------------------------------------===//
+
+inline bool CastToDerived(InterpState &S, CodePtr OpPC, const Expr *E) {
+  QualType Ty = E->getType();
+  if (const PointerType *PT = Ty->getAs<PointerType>())
+    Ty = PT->getPointeeType();
+
+  Pointer Base = S.Stk.pop<Pointer>();
+  if (!S.CheckNull(OpPC, Base, CSK_Derived))
+    return false;
+
+  if (auto *R = S.P.getOrCreateRecord(Ty->getAs<RecordType>()->getDecl())) {
+    // Traverse the chain of bases (actually derived classes).
+    while (Base.isBaseClass()) {
+      // Step to deriving class.
+      Base = Base.getBase();
+
+      // Found the derived class.
+      if (Base.getRecord() == R) {
+        S.Stk.push<Pointer>(std::move(Base));
+        return true;
+      }
+    }
+  }
+
+  // Emit the diagnostic.
+  S.CCEDiag(E, diag::note_constexpr_invalid_downcast) << Base.getType() << Ty;
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// Inc, Dec
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+using IncDecFn = bool (*)(InterpState &, CodePtr, const T &, T &);
+
+template <typename T>
+bool Post(InterpState &S, CodePtr OpPC, AccessKinds AK, IncDecFn<T> Op) {
+  // Bail if not C++14.
+  if (!S.getLangOpts().CPlusPlus14 && !S.keepEvaluatingAfterFailure()) {
+    S.FFDiag(S.getSource(OpPC));
+    return false;
+  }
+
+  // Get the pointer to the object to mutate.
+  const Pointer &Ptr = S.Stk.pop<Pointer>();
+  if (!S.CheckLoad(OpPC, Ptr, AK) || !S.CheckStore(OpPC, Ptr, AK))
+    return false;
+
+  // Return the original value.
+  const T Arg = Ptr.deref<T>();
+  S.Stk.push<T>(Arg);
+
+  // Perform the operation.
+  return Op(S, OpPC, Arg, Ptr.deref<T>());
+}
+
+template <typename T>
+bool Pre(InterpState &S, CodePtr OpPC, AccessKinds AK, IncDecFn<T> Op) {
+  // Bail if not C++14.
+  if (!S.getLangOpts().CPlusPlus14 && !S.keepEvaluatingAfterFailure()) {
+    S.FFDiag(S.getSource(OpPC));
+    return false;
+  }
+
+  // Read the value to mutate.
+  Pointer Ptr = S.Stk.peek<Pointer>();
+  if (!S.CheckLoad(OpPC, Ptr, AK) || !S.CheckStore(OpPC, Ptr, AK))
+    return false;
+
+  // Perform the operation.
+  const T Arg = Ptr.deref<T>();
+  return Op(S, OpPC, Arg, Ptr.deref<T>());
+}
+
+template <typename T, bool (*OpFW)(T A, T *R), template <typename U> class OpAP>
+bool IncDecInt(InterpState &S, CodePtr OpPC, const T &Arg, T &R) {
+  if (std::is_unsigned<T>::value) {
+    // Unsigned increment/decrement is defined to wrap around.
+    R = OpAP<T>()(Arg, T::from(1, Arg.bitWidth()));
+    return true;
+  } else {
+    // Signed increment/decrement is undefined, catch that.
+    if (!OpFW(Arg, &R))
+      return true;
+    // Compute the actual value for the diagnostic.
+    const size_t Bits = R.bitWidth() + 1;
+    APSInt One(APInt(Bits, 1, Arg.isSigned()), !Arg.isSigned());
+    APSInt Value = OpAP<APSInt>()(Arg.toAPSInt(Bits), One);
+    return S.reportOverflow(S.getSource(OpPC).asExpr(), Value);
+  }
+}
+
+template <template <typename U> class Op>
+bool IncDecPtr(InterpState &S, CodePtr OpPC, const Pointer &Arg, Pointer &R) {
+  if (!S.CheckNull(OpPC, Arg, CSK_ArrayIndex))
+    return false;
+  if (!S.CheckArray(OpPC, Arg))
+    return false;
+
+  // Compute the new offset with unsigned wraparound.
+  const int64_t NewIndex = Op<int64_t>()(Arg.getIndex(), 1);
+  const int64_t MaxIndex = Arg.getNumElems();
+
+  // Ensure the new index is in bounds.
+  if (NewIndex < 0 || NewIndex > MaxIndex) {
+    S.CCEDiag(S.getSource(OpPC), diag::note_constexpr_array_index)
+        << Integral<64, true>::from(NewIndex).toAPSInt()
+        << /*array*/ static_cast<int>(!Arg.inArray())
+        << static_cast<unsigned>(MaxIndex);
+    return false;
+  }
+
+  // Compute the offset from the index.
+  R = Arg.atIndex(NewIndex);
+  return true;
+}
+
+template <Real (*Op)(const Real &)>
+bool IncDecReal(InterpState &S, CodePtr OpPC, const Real &Arg, Real &R) {
+  R = Op(Arg);
+  return true;
+}
+
+template <typename T> struct IncOps {
+  static constexpr IncDecFn<T> Fn = IncDecInt<T, T::increment, std::plus>;
+};
+template <> struct IncOps<Pointer> {
+  static constexpr IncDecFn<Pointer> Fn = IncDecPtr<std::plus>;
+};
+template <> struct IncOps<Real> {
+  static constexpr IncDecFn<Real> Fn = IncDecReal<Real::increment>;
+};
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool PostInc(InterpState &S, CodePtr OpPC) {
+  return Post<T>(S, OpPC, AK_Increment, IncOps<T>::Fn);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool PreInc(InterpState &S, CodePtr OpPC) {
+  return Pre<T>(S, OpPC, AK_Increment, IncOps<T>::Fn);
+}
+
+template <typename T> struct DecOps {
+  static constexpr IncDecFn<T> Fn = IncDecInt<T, T::decrement, std::minus>;
+};
+template <> struct DecOps<Pointer> {
+  static constexpr IncDecFn<Pointer> Fn = IncDecPtr<std::minus>;
+};
+template <> struct DecOps<Real> {
+  static constexpr IncDecFn<Real> Fn = IncDecReal<Real::decrement>;
+};
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool PostDec(InterpState &S, CodePtr OpPC) {
+  return Post<T>(S, OpPC, AK_Decrement, DecOps<T>::Fn);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool PreDec(InterpState &S, CodePtr OpPC) {
+  return Pre<T>(S, OpPC, AK_Decrement, DecOps<T>::Fn);
+}
+
+//===----------------------------------------------------------------------===//
+// And, Or, Xor
+//===----------------------------------------------------------------------===//
+
+template <typename T, template <typename U> class Op>
+bool LogicalHelper(InterpState &S, CodePtr OpPC) {
+  const T &RHS = S.Stk.pop<T>();
+  const T &LHS = S.Stk.pop<T>();
+  S.Stk.push<T>(Op<T>()(LHS, RHS));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool And(InterpState &S, CodePtr OpPC) {
+  return LogicalHelper<T, std::bit_and>(S, OpPC);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Or(InterpState &S, CodePtr OpPC) {
+  return LogicalHelper<T, std::bit_or>(S, OpPC);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool Xor(InterpState &S, CodePtr OpPC) {
+  return LogicalHelper<T, std::bit_xor>(S, OpPC);
+}
+
+//===----------------------------------------------------------------------===//
+// Builtin
+//===----------------------------------------------------------------------===//
+
+inline bool Builtin(InterpState &S, CodePtr OpPC, uint32_t I) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  return InterpBuiltin(S, OpPC, I);
+}
+
 //===----------------------------------------------------------------------===//
 // Zero, Nullptr
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Zero(InterpState &S, CodePtr OpPC) {
   S.Stk.push<T>(T::zero());
   return true;
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool ZeroFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
+  S.Stk.push<T>(T::zero(Bits));
+  return true;
+}
+
+inline bool ZeroRealFP(InterpState &S, CodePtr OpPC, const fltSemantics *Sema) {
+  S.Stk.push<Real>(Real::zero(*Sema));
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
 inline bool Null(InterpState &S, CodePtr OpPC) {
   S.Stk.push<T>();
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // This, 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))
+  if (!S.CheckThis(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 Expr *E = S.getSource(OpPC).asExpr();
     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 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);
+      const Expr *E = S.getSource(OpPC).asExpr();
       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);
+      const Expr *E = S.getSource(OpPC).asExpr();
+      S.CCEDiag(E, 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);
+    const SourceInfo &Loc = S.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);
+    const SourceInfo &Loc = S.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));
   }
 }
 
 //===----------------------------------------------------------------------===//

 }
 
 inline bool ExpandPtr(InterpState &S, CodePtr OpPC) {
   const Pointer &Ptr = S.Stk.pop<Pointer>();
   S.Stk.push<Pointer>(Ptr.expand());
   return true;
 }
 
-/// Interpreter entry point.
-bool Interpret(InterpState &S, APValue &Result);
+//===----------------------------------------------------------------------===//
+// PtrDiff
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+bool PtrDiffHelper(InterpState &S, CodePtr OpPC, unsigned BitWidth) {
+  const Pointer &RHS = S.Stk.pop<Pointer>();
+  const Pointer &LHS = S.Stk.pop<Pointer>();
+
+  // Pointers must point to the same object.
+  if (LHS.isZero() || !LHS.isLive()) {
+    S.FFDiag(S.getSource(OpPC).asExpr());
+    return false;
+  }
+  if (RHS.isZero() || !RHS.isLive()) {
+    S.FFDiag(S.getSource(OpPC).asExpr());
+    return false;
+  }
+  if (!Pointer::hasSameBase(LHS, RHS)) {
+    S.FFDiag(S.getSource(OpPC).asExpr());
+    return false;
+  }
+
+  // Pointers must point to the same array.
+  if (!Pointer::hasSameArray(LHS, RHS)) {
+    const Expr *E = S.getSource(OpPC).asExpr();
+    S.CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array);
+    return false;
+  }
+
+  // Compute the difference.
+  auto RHSIndex = static_cast<int64_t>(RHS.getIndex());
+  auto LHSIndex = static_cast<int64_t>(LHS.getIndex());
+  auto Diff = LHSIndex - RHSIndex;
+  S.Stk.push<T>(T::from(Diff, BitWidth));
+
+  if (!T::inRange(Diff, BitWidth)) {
+    auto APDiff = Integral<64, true>::from(Diff).toAPSInt();
+    const Expr *E = S.getSource(OpPC).asExpr();
+    S.CCEDiag(E, diag::note_constexpr_overflow) << APDiff << E->getType();
+    return S.noteUndefinedBehavior();
+  }
+
+  return true;
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool PtrDiff(InterpState &S, CodePtr OpPC) {
+  return PtrDiffHelper<T>(S, OpPC, T::bitWidth());
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool PtrDiffFP(InterpState &S, CodePtr OpPC, uint32_t Bits) {
+  return PtrDiffHelper<T>(S, OpPC, Bits);
+}
+
+//===----------------------------------------------------------------------===//
+// RealElem, ImagElem
+//===----------------------------------------------------------------------===//
+
+inline bool ComplexAccess(InterpState &S, CodePtr OpPC, unsigned Idx,
+                          CheckSubobjectKind CSK) {
+  const auto &Ptr = S.Stk.pop<Pointer>();
+  if (!S.CheckNull(OpPC, Ptr, CSK))
+    return false;
+  if (!S.CheckRange(OpPC, Ptr, CSK))
+    return false;
+  S.Stk.push<Pointer>(Ptr.atIndex(Idx));
+  return true;
+}
+
+inline bool RealElem(InterpState &S, CodePtr OpPC) {
+  return ComplexAccess(S, OpPC, 0, CSK_Real);
+}
+
+inline bool ImagElem(InterpState &S, CodePtr OpPC) {
+  return ComplexAccess(S, OpPC, 1, CSK_Imag);
+}
+
+//===----------------------------------------------------------------------===//
+// Trap
+//===----------------------------------------------------------------------===//
+
+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;
+}
+
+//===----------------------------------------------------------------------===//
+// InitUnion
+//===----------------------------------------------------------------------===//
+
+inline bool InitUnion(InterpState &S, CodePtr OpPC) {
+  const Pointer &Dst = S.Current->getThis();
+  const Pointer &Src = S.Current->getParam<Pointer>(0);
+  if (!S.CheckLoad(OpPC, Src))
+    return false;
+  return CopyUnion(S, OpPC, Src, Dst);
+}
 
 } // 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_ltor_mutable, 1) << 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()) {
       OS << " + " << Index;
       continue;
     }
     OS << ".";
     printDesc(It->getFieldDesc());
   }
 }
 
+template <>
+void print(llvm::raw_ostream &OS, const FnPointer &P, ASTContext &,
+           QualType Ty) {
+  const FunctionDecl *Decl = nullptr;
+  if (Function *F = P.asFunction())
+    Decl = F->getDecl();
+  if (const FunctionDecl *FD = P.asDecl())
+    Decl = FD;
+
+  if (!Decl) {
+    OS << "nullptr";
+    return;
+  }
+
+  if (Ty->isReferenceType()) {
+    OS << Decl->getName();
+  } else {
+    OS << "&" << Decl->getName();
+  }
+}
+
+template <>
+void print(llvm::raw_ostream &OS, const MemberPointer &P, ASTContext &,
+           QualType) {
+  if (const ValueDecl *VD = P.getDecl())
+    OS << '&' << *cast<CXXRecordDecl>(VD->getDeclContext()) << "::" << *VD;
+  else
+    OS << "0";
+  return;
+}
+
 void InterpFrame::describe(llvm::raw_ostream &OS) {
   const FunctionDecl *F = getCallee();
   auto *M = dyn_cast<CXXMethodDecl>(F);
   if (M && M->isInstance() && !isa<CXXConstructorDecl>(F)) {
     print(OS, This, S.getCtx(), S.getCtx().getRecordType(M->getParent()));
     OS << "->";
   }
   OS << *F << "(";

 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;
+}
+
+/// Converts a composite value to an APValue.
+bool PointerToValue(const Pointer &Ptr, APValue &Result);
+
+/// Copies a union.
+bool CopyUnion(InterpState &S, CodePtr OpPC, const Pointer &From,
+               const Pointer &To);
+
+/// Finds the record to which a pointer points and ajudsts this to it.
+Record *PointerLookup(Pointer &This, const MemberPointer &Field);
+
+/// Finds a virtual override and adjusts This to point to the object.
+const CXXMethodDecl *VirtualLookup(Pointer &This, const CXXMethodDecl *MD);
+
+/// Indirect method lookup.
+const CXXMethodDecl *IndirectLookup(Pointer &This, const MemberPointer &Ptr);
+
+} // 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;
+
+//===----------------------------------------------------------------------===//
+// Pointer to APValue conversion
+//===----------------------------------------------------------------------===//
+
+static llvm::APSInt GetInt(PrimType Ty, const Pointer &Ptr) {
+  INT_TYPE_SWITCH(Ty, return Ptr.deref<T>().toAPSInt());
+}
+
+static llvm::APFloat GetFloat(const Pointer &Ptr) {
+  return Ptr.deref<Real>().toAPFloat();
+}
+
+static bool PointerToValue(QualType Ty, const Pointer &Ptr, APValue &Result);
+
+static bool RecordToValue(const Pointer &Ptr, APValue &Result) {
+  auto *Record = Ptr.getRecord();
+  assert(Record && "Missing record descriptor");
+
+  bool Ok = true;
+  if (Record->isUnion()) {
+    const FieldDecl *ActiveField = nullptr;
+    APValue Value;
+    for (auto &F : Record->fields()) {
+      const Pointer &FP = Ptr.atField(F.Offset);
+      if (FP.isActive()) {
+        if (llvm::Optional<PrimType> T = F.Desc->ElemTy) {
+          TYPE_SWITCH(*T, Ok &= PrimitiveToValue<T>(FP.deref<T>(), Value));
+        } else {
+          Ok &= PointerToValue(F.Desc->getType(), FP, Value);
+        }
+        break;
+      }
+    }
+    Result = APValue(ActiveField, Value);
+  } else {
+    unsigned NF = Record->getNumFields();
+    unsigned NB = Record->getNumBases();
+    unsigned NV = Ptr.isBaseClass() ? 0 : Record->getNumVirtualBases();
+
+    Result = APValue(APValue::UninitStruct(), NB, NF);
+
+    for (unsigned I = 0; I < NF; ++I) {
+      const Record::Field *FD = Record->getField(I);
+      const Pointer &FP = Ptr.atField(FD->Offset);
+      APValue &Value = Result.getStructField(I);
+
+      if (llvm::Optional<PrimType> T = FD->Desc->ElemTy) {
+        TYPE_SWITCH(*T, Ok &= PrimitiveToValue<T>(FP.deref<T>(), Value));
+      } else {
+        Ok &= PointerToValue(FD->Decl->getType(), FP, Value);
+      }
+    }
+
+    for (unsigned I = 0; I < NB; ++I) {
+      const Record::Base *BD = Record->getBase(I);
+      const Pointer &BP = Ptr.atField(BD->Offset);
+      Ok &= RecordToValue(BP, Result.getStructBase(I));
+    }
+
+    for (unsigned I = 0; I < NV; ++I) {
+      const Record::Base *VD = Record->getVirtualBase(I);
+      const Pointer &VP = Ptr.atField(VD->Offset);
+      Ok &= RecordToValue(VP, Result.getStructBase(NB + I));
+    }
+  }
+  return Ok;
+}
+
+static bool ArrayToValue(QualType ElemTy, const Pointer &Ptr, APValue &Result) {
+  const size_t NumElems = Ptr.getNumElems();
+  Result = APValue(APValue::UninitArray{}, NumElems, NumElems);
+
+  bool Ok = true;
+  for (unsigned I = 0; I < NumElems; ++I) {
+    APValue &Slot = Result.getArrayInitializedElt(I);
+    const Pointer &EP = Ptr.atIndex(I);
+    if (llvm::Optional<PrimType> T = Ptr.elementPrimType()) {
+      TYPE_SWITCH(*T, Ok &= PrimitiveToValue<T>(EP.deref<T>(), Slot));
+    } else {
+      Ok &= PointerToValue(ElemTy, EP.narrow(), Slot);
+    }
+  }
+  return Ok;
+}
+
+static bool ComplexToValue(const Pointer &Ptr, APValue &Result) {
+  const Pointer &PtrReal = Ptr.atIndex(0);
+  const Pointer &PtrImag = Ptr.atIndex(1);
+  switch (PrimType T = *Ptr.elementPrimType()) {
+    case PT_Sint8:
+    case PT_Uint8:
+    case PT_Sint16:
+    case PT_Uint16:
+    case PT_Sint32:
+    case PT_Uint32:
+    case PT_Sint64:
+    case PT_Uint64:
+    case PT_SintFP:
+    case PT_UintFP:
+      Result = APValue(GetInt(T, PtrReal), GetInt(T, PtrImag));
+      return true;
+
+    case PT_RealFP:
+      Result = APValue(GetFloat(PtrReal), GetFloat(PtrImag));
+      return true;
+
+    default:
+      llvm_unreachable("invalid complex element");
+  }
+}
+
+static bool PointerToValue(QualType Ty, const Pointer &Ptr, APValue &Result) {
+  if (auto *AT = Ty->getAs<AtomicType>()) Ty = AT->getValueType();
+
+  if (Ty->getAs<RecordType>()) return RecordToValue(Ptr, Result);
+
+  if (auto *AT = Ty->getAsArrayTypeUnsafe())
+    return ArrayToValue(AT->getElementType(), Ptr, Result);
+
+  if (Ty->getAs<ComplexType>()) return ComplexToValue(Ptr, Result);
+
+  llvm_unreachable("invalid pointer to convert");
+}
+
+//===----------------------------------------------------------------------===//
+// Pointer deep copy
+//===----------------------------------------------------------------------===//
+
+static bool Copy(InterpState &S, CodePtr OpPC, const Pointer &From,
+                 const Pointer &To);
+
+static bool CopyRecord(InterpState &S, CodePtr OpPC, const Pointer &From,
+                       const Pointer &To) {
+  auto *R = From.getRecord();
+  for (auto &Field : R->fields()) {
+    unsigned Offset = Field.Offset;
+    const auto &ToField = To.atField(Offset);
+    const auto &FromField = From.atField(Offset);
+    if (!Copy(S, OpPC, FromField, ToField)) return false;
+  }
+
+  for (auto &Base : R->bases()) {
+    unsigned Offset = Base.Offset;
+    const auto &ToField = To.atField(Offset);
+    const auto &FromField = From.atField(Offset);
+    if (!CopyRecord(S, OpPC, FromField, ToField)) return false;
+    ToField.initialize();
+  }
+
+  if (!From.isBaseClass()) {
+    for (auto &Virt : R->virtual_bases()) {
+      unsigned Offset = Virt.Offset;
+      const auto &ToField = To.atField(Offset);
+      const auto &FromField = From.atField(Offset);
+      if (!CopyRecord(S, OpPC, FromField, ToField)) return false;
+      ToField.initialize();
+    }
+  }
+
+  return true;
+}
+
+static bool CopyArray(InterpState &S, CodePtr OpPC, const Pointer &From,
+                      const Pointer &To) {
+  if (llvm::Optional<PrimType> T = From.elementPrimType()) {
+    for (unsigned I = 0; I < From.getNumElems(); ++I) {
+      const auto &FromField = From.atIndex(I).narrow();
+      const auto &ToField = To.atIndex(I).narrow();
+      TYPE_SWITCH(*T, ToField.deref<T>() = FromField.deref<T>())
+      ToField.initialize();
+      ToField.activate();
+    }
+  } else {
+    for (unsigned I = 0; I < From.getNumElems(); ++I) {
+      const auto &FromField = From.atIndex(I).narrow();
+      if (!S.CheckLoad(OpPC, FromField)) return false;
+      const auto &ToField = To.atIndex(I).narrow();
+      if (!Copy(S, OpPC, FromField, ToField)) return false;
+      ToField.initialize();
+      ToField.activate();
+    }
+  }
+  return true;
+}
+
+static bool Copy(InterpState &S, CodePtr OpPC, const Pointer &From,
+                 const Pointer &To) {
+  if (From.inArray()) return CopyArray(S, OpPC, From, To);
+
+  if (Record *R = From.getRecord()) {
+    if (R->isUnion())
+      return CopyUnion(S, OpPC, From, To);
+    else
+      return CopyRecord(S, OpPC, From, To);
+  }
+
+  if (llvm::Optional<PrimType> T = From.elementPrimType()) {
+    if (!S.CheckLoad(OpPC, From)) return false;
+    TYPE_SWITCH(*T, To.deref<T>() = From.deref<T>());
+    To.initialize();
+    To.activate();
+    return true;
+  }
+
+  llvm_unreachable("invalid pointer to copy");
+}
+
+namespace clang {
+namespace interp {
+
+bool PointerToValue(const Pointer &Ptr, APValue &Result) {
+  return ::PointerToValue(Ptr.getType(), Ptr, Result);
+}
+
+bool CopyUnion(InterpState &S, CodePtr OpPC, const Pointer &From,
+               const Pointer &To) {
+  for (auto &Field : From.getRecord()->fields()) {
+    unsigned Offset = Field.Offset;
+    const auto &FromField = From.atField(Offset);
+    const auto &ToField = To.atField(Offset);
+    if (!FromField.isActive()) continue;
+    if (!Copy(S, OpPC, FromField, ToField)) return false;
+    ToField.activate();
+    return true;
+  }
+  return true;
+}
+
+const CXXMethodDecl *VirtualLookup(Pointer &This, const CXXMethodDecl *MD) {
+  // Traverse the chain of derived classes, from base to derived.
+  auto *Impl = MD;
+  while (This.isBaseClass() && This.isInitialized()) {
+    // Step into the derived class.
+    This = This.getBase();
+
+    // Fetch the class declaration.
+    Record *R = This.getRecord();
+    assert(R != nullptr && "virtual dispatch allowed only on records");
+    auto *Class = dyn_cast<CXXRecordDecl>(R->getDecl());
+    assert(Class != nullptr && "not a CXX record");
+
+    // Find the most overriden method.
+    auto *Override = MD->getCorrespondingMethodDeclaredInClass(Class, false);
+    if (Override) {
+      Impl = Override;
+    }
+  }
+  return Impl;
+}
+
+Record *PointerLookup(Pointer &This, const MemberPointer &Field) {
+  Record *R = This.getRecord();
+  // Get the offset inside the record.
+  if (Field.isDerived()) {
+    // Walk down the chain to derived classes.
+    for (const CXXRecordDecl *Step : Field.steps()) {
+      if (!This.isBaseClass()) return nullptr;
+
+      This = This.getBase();
+      R = This.getRecord();
+
+      if (R->getDecl() != Step) return nullptr;
+    }
+  } else {
+    // Walk up the chain of base classes.
+    for (const CXXRecordDecl *Step : Field.steps()) {
+      This = This.atField(R->getBase(Step)->Offset);
+      R = This.getRecord();
+    }
+  }
+
+  return R;
+}
+
+const CXXMethodDecl *IndirectLookup(Pointer &This, const MemberPointer &Ptr) {
+  // Find the member and create a function pointer.
+  if (auto *Decl = dyn_cast<CXXMethodDecl>(Ptr.getDecl())) {
+    if (PointerLookup(This, Ptr)) {
+      if (!Decl->isVirtual()) {
+        return Decl;
+      }
+      return VirtualLookup(This, Decl);
+    }
+  }
+  // Not found - bail out.
+  return nullptr;
+}
+
+}  // namespace interp
+}  // namespace clang

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;
+}
+
+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<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))
+    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);
+  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) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+  return HandleCall(S, PC, PC - sizeof(F), F, {});
+}
+
+static bool Invoke(InterpState &S, CodePtr &PC, Function *F) {
+  CodePtr OpPC = PC - sizeof(F);
+
+  // Get the this pointer, ensure it's live.
+  Pointer This = S.Stk.pop<Pointer>();
+  if (!S.CheckInvoke(OpPC, This))
+    return false;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+
+  // Dispatch to the method.
+  return HandleCall(S, PC, PC - sizeof(F), F, std::move(This));
+}
+
+static bool VirtualInvoke(InterpState &S, CodePtr &PC, const CXXMethodDecl *M) {
+  CodePtr OpPC = PC - sizeof(M);
+
+  // Get the this pointer, ensure it's live.
+  Pointer This = S.Stk.pop<Pointer>();
+  if (!S.CheckInvoke(OpPC, This))
+    return false;
+  if (S.checkingPotentialConstantExpression())
+    return false;
+
+  // Dispatch to the virtual method.
+  const CXXMethodDecl *Override = VirtualLookup(This, M);
+  if (!S.CheckPure(OpPC, Override))
+    return false;
+  if (auto Func = S.P.getOrCreateFunction(Override)) {
+    if (*Func) {
+      return HandleCall(S, PC, OpPC, *Func, std::move(This));
+    } else {
+      return HandleNoCall(S, PC, Override);
+    }
+  } else {
+    consumeError(Func.takeError());
+    return false;
+  }
+}
+
+static bool NoCall(InterpState &S, CodePtr &PC, const FunctionDecl *FD) {
+  // Do not execute function calls when checking if expr is constant.
+  if (S.checkingPotentialConstantExpression())
+    return false;
+
+  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, {});
+  } else {
+    // Function was not defined - emit a diagnostic.
+    return HandleNoCall(S, PC, FD);
+  }
+}
+
+static bool NoInvoke(InterpState &S, CodePtr &PC, const CXXMethodDecl *MD) {
+  // Do not execute function calls when checking if expr is constant.
+  if (S.checkingPotentialConstantExpression())
+    return false;
+
+  CodePtr OpPC = PC - sizeof(MD);
+
+  // Access checks.
+  Pointer This = S.Stk.pop<Pointer>();
+  if (!S.CheckInvoke(OpPC, This))
+    return false;
+
+  if (auto *F = S.P.getFunction(MD)) {
+    // Function was defined in the meantime - rewrite opcode.
+    S.Current->getFunction()->relocateInvoke(OpPC, F);
+    return HandleCall(S, PC, OpPC, F, std::move(This));
+  } else {
+    // Function was not defined - emit a diagnostic.
+    return HandleNoCall(S, PC, MD);
+  }
+}
+
+static bool IndirectCall(InterpState &S, CodePtr &PC) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+
+  const auto &FnPtr = S.Stk.pop<FnPointer>();
+  if (FnPtr.isZero()) {
+    S.FFDiag(S.getSource(PC));
+    return false;
+  }
+
+  if (Function *F = FnPtr.asFunction()) {
+    return HandleCall(S, PC, PC, F, {});
+  } else {
+    auto *Decl = FnPtr.asDecl();
+    if (auto Func = S.P.getOrCreateFunction(FnPtr.asDecl())) {
+      if (*Func)
+        return HandleCall(S, PC, PC, *Func, {});
+      else
+        return HandleNoCall(S, PC, FnPtr.asDecl());
+    } else {
+      consumeError(Func.takeError());
+    }
+
+    S.FFDiag(S.getSource(PC), diag::note_constexpr_invalid_function, 1)
+        << Decl->isConstexpr() << isa<CXXConstructorDecl>(Decl) << Decl;
+    S.Note(Decl->getLocation(), diag::note_declared_at);
+    return false;
+  }
+}
+
+static bool IndirectInvoke(InterpState &S, CodePtr &PC) {
+  if (S.checkingPotentialConstantExpression())
+    return false;
+
+  // Fetch and validate the object and the pointer.
+  const MemberPointer &Field = S.Stk.pop<MemberPointer>();
+  Pointer This = S.Stk.pop<Pointer>();
+  if (!S.CheckInvoke(PC, This))
+    return false;
+  if (Field.isZero()) {
+    S.FFDiag(S.getSource(PC));
+    return false;
+  }
+
+  // Fetch a pointer to the member function.
+  const CXXMethodDecl *Method = IndirectLookup(This, Field);
+  if (!Method)
+    return false;
+  if (!S.CheckPure(PC, Method))
+    return false;
+
+  if (Expected<Function *> Func = S.P.getOrCreateFunction(Method)) {
+    if (*Func)
+      return HandleCall(S, PC, PC, *Func, std::move(This));
+    else
+      return HandleNoCall(S, PC, Method);
+  } else {
+    consumeError(Func.takeError());
+    return false;
+  }
+}
+
+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 invoked on an object.
+  bool CheckInvoke(CodePtr PC, const Pointer &Ptr);
+  /// Checks if a value can be initialized.
+  bool CheckInit(CodePtr PC, const Pointer &Ptr);
+  /// Checks if a method can be called.
+  bool CheckCallable(CodePtr PC, Function *F);
+  /// Checks the 'this' pointer.
+  bool CheckThis(CodePtr PC, const Pointer &This);
+  /// Checks if a method is pure virtual.
+  bool CheckPure(CodePtr PC, const CXXMethodDecl *MD);
+
+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::CheckInvoke(CodePtr PC, const Pointer &Ptr) {
+  if (!CheckLive(PC, Ptr, AK_MemberCall))
+    return false;
+  if (!CheckExtern(PC, Ptr))
+    return false;
+  if (!CheckRange(PC, Ptr, AK_MemberCall))
+    return false;
+  return true;
+}
+
+bool InterpState::CheckInit(CodePtr PC, const Pointer &Ptr) {
+  if (!CheckLive(PC, Ptr, AK_Assign))
+    return false;
+  if (!CheckRange(PC, Ptr, AK_Assign))
+    return false;
+  return true;
+}
+
+bool InterpState::CheckCallable(CodePtr PC, Function *F) {
+  if (F->isVirtual()) {
+    if (!getLangOpts().CPlusPlus2a) {
+      CCEDiag(getSource(PC), diag::note_constexpr_virtual_call);
+      return false;
+    }
+  }
+
+  if (!F->isConstexpr()) {
+    if (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())
+        FFDiag(getSource(PC), diag::note_constexpr_invalid_inhctor, 1)
+            << CD->getInheritedConstructor().getConstructor()->getParent();
+      else
+        FFDiag(getSource(PC), diag::note_constexpr_invalid_function, 1)
+            << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
+      Note(DiagDecl->getLocation(), diag::note_declared_at);
+    } else {
+      FFDiag(getSource(PC), diag::note_invalid_subexpr_in_const_expr);
+    }
+    return false;
+  }
+
+  return true;
+}
+
+bool InterpState::CheckThis(CodePtr PC, const Pointer &This) {
+  if (!This.isZero())
+    return true;
+
+  const SourceInfo &I = getSource(PC);
+
+  bool IsImplicit = false;
+  if (auto *E = dyn_cast_or_null<CXXThisExpr>(I.asExpr()))
+    IsImplicit = E->isImplicit();
+
+  if (getLangOpts().CPlusPlus11) {
+    FFDiag(I, diag::note_constexpr_this) << IsImplicit;
+  } else {
+    FFDiag(I);
+  }
+
+  return false;
+}
+
+bool InterpState::CheckPure(CodePtr PC, const CXXMethodDecl *MD) {
+  if (!MD->isPure())
+    return true;
+  const SourceInfo &I = getSource(PC);
+  FFDiag(I, diag::note_constexpr_pure_virtual_call, 1) << MD;
+  Note(MD->getLocation(), diag::note_declared_at);
+  return false;
+}
+
+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) {
+  if (auto ID = Ptr.getDeclID()) {
+    if (!Ptr.isStaticTemporary())
+      return true;
+
+    if (Ptr.getDeclDesc()->getType().isConstQualified())
+      return true;
+
+    if (P.getCurrentDecl() == ID)
+      return true;
+
+    const SourceInfo &I = getSource(PC);
+    FFDiag(I, diag::note_constexpr_access_static_temporary, 1) << AK;
+    Note(Ptr.getDeclLoc(), diag::note_constexpr_temporary_here);
+    return false;
+  }
+  return true;
+}
+
+bool InterpState::CheckGlobal(CodePtr PC, const Pointer &Ptr) {
+  if (auto ID = Ptr.getDeclID()) {
+    if (!Ptr.isStatic())
+      return true;
+
+    if (P.getCurrentDecl() == ID)
+      return true;
+
+    FFDiag(getSource(PC), diag::note_constexpr_modify_global);
+    return false;
+  }
+  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_ltor_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 Sint8 : Type;
 def Uint8 : Type;
 def Sint16 : Type;
 def Uint16 : Type;
 def Sint32 : Type;
 def Uint32 : Type;
 def Sint64 : Type;
 def Uint64 : Type;
+def SintFP : Type;
+def UintFP : Type;
+def RealFP : Type;
 def Ptr : Type;
+def FnPtr : Type;
+def MemPtr : Type;
 
 //===----------------------------------------------------------------------===//
 // Types transferred to the interpreter.
 //===----------------------------------------------------------------------===//
 
 class ArgType { string Name = ?; }
 def ArgSint8 : ArgType { let Name = "int8_t"; }
 def ArgUint8 : ArgType { let Name = "uint8_t"; }
 def ArgSint16 : ArgType { let Name = "int16_t"; }
 def ArgUint16 : ArgType { let Name = "uint16_t"; }
 def ArgSint32 : ArgType { let Name = "int32_t"; }
 def ArgUint32 : ArgType { let Name = "uint32_t"; }
 def ArgSint64 : ArgType { let Name = "int64_t"; }
 def ArgUint64 : ArgType { let Name = "uint64_t"; }
 def ArgBool : ArgType { let Name = "bool"; }
 
 def 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 {
   let Types = [Sint8, Uint8, Sint16, Uint16, Sint32,
                Uint32, Sint64, Uint64, Bool];
 }
 
 def PtrTypeClass : TypeClass {
-  let Types = [Ptr];
+  let Types = [Ptr, FnPtr, MemPtr];
+}
+
+def FPTypeClass : TypeClass {
+  let Types = [SintFP, UintFP];
+}
+
+def RealFPTypeClass : TypeClass {
+  let Types = [RealFP];
+}
+
+def AluFPTypeClass : TypeClass {
+  let Types = !listconcat(AluTypeClass.Types, FPTypeClass.Types);
+}
+
+def AluFPRealFPTypeClass : TypeClass {
+  let Types = !listconcat(AluTypeClass.Types, FPTypeClass.Types,
+                          RealFPTypeClass.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 = [AluFPTypeClass];
+  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;
+}
+
+// [Args..., FnPointer] -> []
+def IndirectCall : Opcode {
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+
+// [Args..., Pointer] -> []
+def Invoke : Opcode {
+  let Args = [ArgFunction];
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+
+// [Args..., Pointer, MemberPtr] -> []
+def IndirectInvoke : Opcode {
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+
+// [Args..., Pointer] -> []
+def VirtualInvoke : Opcode {
+  let Args = [ArgCXXMethodDecl];
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+
+// [Args...] -> []
+def Builtin : Opcode {
+  let Args = [ArgUint32];
+}
+
+//===----------------------------------------------------------------------===//
+// Invalid relocation trap
+//===----------------------------------------------------------------------===//
+
+// [] -> EXIT
+def NoCall : Opcode {
+  let Args = [ArgFunctionDecl];
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+
+// [] -> EXIT
+def NoInvoke : Opcode {
+  let Args = [ArgCXXMethodDecl];
+  let ChangesPC = 1;
+  let HasCustomEval = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // Returns
 //===----------------------------------------------------------------------===//
 
 // [Value] -> []
 def Ret : Opcode {
   let Types = [AllTypeClass];
   let ChangesPC = 1;
   let CanReturn = 1;

 def ConstUint16 : ConstOpcode<Uint16, ArgUint16>;
 def ConstSint32 : ConstOpcode<Sint32, ArgSint32>;
 def ConstUint32 : ConstOpcode<Uint32, ArgUint32>;
 def ConstSint64 : ConstOpcode<Sint64, ArgSint64>;
 def ConstUint64 : ConstOpcode<Uint64, ArgUint64>;
 def ConstBool : ConstOpcode<Bool, ArgBool>;
 
 // [] -> [Integer]
+def ConstFP : Opcode {
+  let Types = [FPTypeClass];
+  let Args = [ArgUint32, ArgUint64];
+  let Name = "ConstFP";
+}
+
+// [] -> [Real]
+def ConstRealFP : Opcode {
+  let Args = [ArgFloatingLiteral];
+}
+
+// [] -> [FnPointer]
+def ConstFn : Opcode {
+  let Args = [ArgFunction];
+}
+
+// [] -> [FnPointer]
+def ConstNoFn : Opcode {
+  let Args = [ArgFunctionDecl];
+}
+
+// [] -> [MemberPointer]
+def ConstMem : Opcode {
+  let Args = [ArgValueDecl];
+}
+
+// [] -> [Integer]
 def Zero : Opcode {
   let Types = [AluTypeClass];
 }
 
+// [] -> [Integer]
+def ZeroFP : Opcode {
+  let Types = [FPTypeClass];
+  let Args = [ArgUint32];
+}
+
+// [] -> [Real]
+def ZeroRealFP : Opcode {
+  let Args = [ArgSema];
+}
+
 // [] -> [Pointer]
 def Null : Opcode {
   let Types = [PtrTypeClass];
 }
 
 //===----------------------------------------------------------------------===//
 // Pointer generation
 //===----------------------------------------------------------------------===//

 // [] -> [Pointer]
 def GetPtrThisVirtBase : Opcode {
   // RecordDecl of base class.
   let Args = [ArgRecordDecl];
 }
 // [] -> [Pointer]
 def This : Opcode;
 
+// [Pointer, MemberPointer] -> [Pointer]
+def GetPtrFieldIndirect : 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 BitFieldOpcode : Opcode {
-  let Types = [AluTypeClass];
+  let Types = [AluFPTypeClass];
   let Args = [ArgRecordField];
   let HasGroup = 1;
 }
 
 // [] -> [Pointer]
 def GetLocal : AccessOpcode { let HasCustomEval = 1; }
 // [] -> [Pointer]
 def SetLocal : AccessOpcode { let HasCustomEval = 1; }

 def SetThisField : AccessOpcode;
 
 // [Value] -> []
 def InitThisField : AccessOpcode;
 // [Value] -> []
 def InitThisFieldActive : AccessOpcode;
 // [Value] -> []
 def InitThisBitField : BitFieldOpcode;
-// [Pointer, Value] -> []
+// [Pointer, Value] -> [Pointer, Value]
+def InitFieldPeek : AccessOpcode;
+// [Pointer, Value] -> [Pointer]
 def InitField : AccessOpcode;
 // [Pointer, Value] -> []
+def InitFieldPop : 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 Types = [AluFPTypeClass];
   let HasGroup = 1;
 }
 
 // [Pointer, Value] -> [Pointer]
 def Store : StoreOpcode {}
 // [Pointer, Value] -> []
 def StorePop : StoreOpcode {}
 

 }
 // [Pointer, Value] -> []
 def InitElemPop : Opcode {
   let Types = [AllTypeClass];
   let Args = [ArgUint32];
   let HasGroup = 1;
 }
 
+// [Pointer] -> []
+def Initialise : Opcode;
+def Activate : Opcode;
+
 //===----------------------------------------------------------------------===//
 // Pointer arithmetic.
 //===----------------------------------------------------------------------===//
 
 // [Pointer, Integral] -> [Pointer]
 def AddOffset : AluOpcode;
 // [Pointer, Integral] -> [Pointer]
 def SubOffset : AluOpcode;
 
+// [Pointer, Pointer] -> [Integral]
+def PtrDiff : Opcode {
+  let Types = [AluTypeClass];
+  let HasGroup = 1;
+}
+// [Pointer, Pointer] -> [Integral]
+def PtrDiffFP : Opcode {
+  let Types = [FPTypeClass];
+  let Args = [ArgUint32];
+  let HasGroup = 1;
+}
+
+def RealElem : Opcode;
+def ImagElem : Opcode;
+
 //===----------------------------------------------------------------------===//
 // Binary operators.
 //===----------------------------------------------------------------------===//
 
 // [Real, Real] -> [Real]
-def Sub : AluOpcode;
-def Add : AluOpcode;
-def Mul : AluOpcode;
+def Sub : AluRealOpcode;
+def Add : AluRealOpcode;
+def Mul : AluRealOpcode;
+def Div : AluRealOpcode;
+// [Integral, Integral] -> [Integral]
+def Rem : AluOpcode;
+def And : AluOpcode;
+def Or : AluOpcode;
+def Xor : AluOpcode;
+
+//===----------------------------------------------------------------------===//
+// Bit shift operators.
+//===----------------------------------------------------------------------===//
+
+class ShiftOpcode : Opcode {
+  let Types = [AluFPTypeClass, AluFPTypeClass];
+  let HasGroup = 1;
+}
+
+// [Integral, Integral] -> [Integral]
+def Shr : ShiftOpcode;
+def Shl : ShiftOpcode;
+
+//===----------------------------------------------------------------------===//
+// Unary operators.
+//===----------------------------------------------------------------------===//
+
+// [Real] -> [Real]
+def Minus : AluRealOpcode;
+// [Integral] -> [Integral]
+def Not : AluOpcode;
+// [Integral] -> [Integral]
+def Test : Opcode {
+  let Types = [AllTypeClass];
+  let HasGroup = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// Logical negation.
+//===----------------------------------------------------------------------===//
+
+// [Value] -> [Bool]
+def LogicalNot : Opcode {
+  let Types = [AllTypeClass];
+  let HasGroup = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// Increment/decrement.
+//===----------------------------------------------------------------------===//
+
+class IncDecOpcode : Opcode {
+  let Types = [ArithTypeClass];
+  let HasGroup = 1;
+}
+
+// [Pointer] -> [Arith]
+def PostInc : IncDecOpcode;
+// [Pointer] -> [Arith]
+def PostDec : IncDecOpcode;
+
+// [Pointer] -> [Pointer]
+def PreInc : IncDecOpcode;
+// [Pointer] -> [Pointer]
+def PreDec : IncDecOpcode;
 
 //===----------------------------------------------------------------------===//
 // Comparison opcodes.
 //===----------------------------------------------------------------------===//
 
 class EqualityOpcode : Opcode {
   let Types = [AllTypeClass];
   let HasGroup = 1;
 }
 
 def EQ : EqualityOpcode;
 def NE : EqualityOpcode;
 
 class ComparisonOpcode : Opcode {
-  let Types = [ComparableTypeClass];
+  let Types = [ArithTypeClass];
   let HasGroup = 1;
 }
 
 def LT : ComparisonOpcode;
 def LE : ComparisonOpcode;
 def GT : ComparisonOpcode;
 def GE : ComparisonOpcode;
 
 //===----------------------------------------------------------------------===//
+// Range test.
+//===----------------------------------------------------------------------===//
+
+// [Real, Real, Real] -> [Bool]
+def InRange : Opcode {
+  let Types = [AluFPTypeClass];
+  let HasGroup = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // 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 = [AluFPTypeClass, AluTypeClass];
+  let HasGroup = 1;
+}
+
+// [Real] -> [Alu]
+def CastRealFPToAlu : Opcode {
+  let Types = [RealFPTypeClass, AluTypeClass];
+  let HasGroup = 1;
+}
+
+// [Real] -> [AluFP]
+def CastRealFPToAluFP : Opcode {
+  let Types = [RealFPTypeClass, AluFPTypeClass];
+  let Args = [ArgUint32];
+  let HasGroup = 1;
+}
+
+// [Value] -> [Value]
+def CastFP : Opcode {
+  let Types = [AluFPTypeClass, FPTypeClass];
+  let Args = [ArgUint32];
+  let HasGroup = 1;
+}
+
+// [Value] -> [Real]
+def CastRealFP : Opcode {
+  let Types = [AluFPRealFPTypeClass];
+  let Args = [ArgSema];
+  let HasGroup = 1;
+}
+
+// [MemberPtr] -> [MemberPtr]
+def CastMemberToDerived : Opcode {
+  let Args = [ArgCXXRecordDecl];
+}
+
+// [MemberPtr] -> [MemberPtr]
+def CastMemberToBase : Opcode {
+  let Args = [ArgCXXRecordDecl];
+}
+
+// [Pointer] -> [Pointer]
+def CastToDerived : Opcode {
+  let Args = [ArgExpr];
+}
+
+// [Pointer] -> [Pointer]
+def PointerBitCast : Opcode {
+  let Args = [];
+}
+
+// [] -> []
+def ReinterpretCastWarning : Opcode;
+def DynamicCastWarning : Opcode;
+
+//===----------------------------------------------------------------------===//
+// Union copy constructor
+//===----------------------------------------------------------------------===//
+
+def InitUnion : Opcode;
+
+//===----------------------------------------------------------------------===//
+// Trap instruction.
+//===----------------------------------------------------------------------===//
+
+def Trap : Opcode;

clang/lib/AST/Interp/Pointer.h

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;
public:
   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;
private:
   unsigned Offset = 0;
 
   /// Previous link in the pointer chain.
   Pointer *Prev = nullptr;
   /// Next link in the pointer chain.
   Pointer *Next = nullptr;
 };
 
+/// Function pointer.
+class FnPointer {
+public:
+  FnPointer();
+  FnPointer(Function *F);
+  FnPointer(const FunctionDecl *FD);
+
+  /// Converts the pointer to an APValue.
+  APValue toAPValue() const;
+
+  /// Checks if the pointer is a null function pointer.
+  bool isZero() const;
+
+  /// Returns the declaration.
+  const FunctionDecl *asDecl() const;
+  /// Returns the function.
+  Function *asFunction() const;
+
+  /// Compares two function pointers.
+  ComparisonCategoryResult compare(const FnPointer &RHS) const;
+
+  /// Prints the pointer.
+  void print(llvm::raw_ostream &OS) const {
+    if (isZero())
+      OS << "nullptr";
+    else
+      OS << *asDecl();
+  }
+
+private:
+  llvm::PointerUnion<const FunctionDecl *, Function *> Pointer;
+};
+
+/// Base class for member and member function pointers.
+class MemberPointer {
+  /// Structure holding intermediary conversion steps.
+  using StepList = SmallVector<const CXXRecordDecl *, 4>;
+  using step_iterator = StepList::const_reverse_iterator;
+
+  /// The declaration to which this pointer points.
+  const ValueDecl *F;
+  /// Flag indicating that the pointer points to a field
+  /// in a class derived from the pointer's class.
+  bool IsDerived = false;
+  /// Chain of derived or base classes to look in.
+  SmallVector<const CXXRecordDecl *, 4> Steps;
+
+public:
+  /// Pointer construction.
+  MemberPointer() : F(nullptr) {}
+  MemberPointer(const ValueDecl *F)
+    : F(F), Steps({cast<CXXRecordDecl>(F->getDeclContext())}) {}
+
+  /// Converts the pointer to an APValue.
+  APValue toAPValue() const { return APValue(F, IsDerived, Steps); }
+
+  /// Checks if the pointer is a null member pointer.
+  bool isZero() const { return !F; }
+
+  /// Checks if the field is of a derived class.
+  bool isDerived() const { return IsDerived; }
+
+  /// Compares two member pointers.
+  bool operator==(const MemberPointer &RHS) const;
+
+  /// Converts to a base pointer, in place.
+  bool toBase(const CXXRecordDecl *B);
+
+  /// Converts to a derived pointer, in place.
+  bool toDerived(const CXXRecordDecl *D);
+
+  /// Returns the underlying declaration.
+  const ValueDecl *getDecl() const { return F; }
+
+  /// Iterators over the conversion chain, excluding the last class.
+  llvm::iterator_range<step_iterator> steps() const {
+    return llvm::make_range(Steps.rbegin() + 1, Steps.rend());
+  }
+
+  /// Prints the pointer.
+  void print(llvm::raw_ostream &OS) const {
+    if (isZero())
+      OS << "nullptr";
+    else
+      OS << *getDecl();
+  }
+};
+
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Pointer &P) {
   P.print(OS);
   return OS;
 }
 
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     const FnPointer &P) {
+  P.print(OS);
+  return OS;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     const MemberPointer &P) {
+  P.print(OS);
+  return OS;
+}
+
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Pointer.cpp

 //===--- Pointer.cpp - Types for the constexpr VM ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Pointer.h"
 #include "Block.h"
 #include "Function.h"
+#include "Pointer.h"
 #include "PrimType.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 Pointer::Pointer(Block *Pointee) : Pointer(Pointee, 0, 0) {}
 
 Pointer::Pointer(const Pointer &P) : Pointer(P.Pointee, P.Base, P.Offset) {}

 
 bool Pointer::hasSameBase(const Pointer &A, const Pointer &B) {
   return A.Pointee == B.Pointee;
 }
 
 bool Pointer::hasSameArray(const Pointer &A, const Pointer &B) {
   return A.Base == B.Base && A.getFieldDesc()->IsArray;
 }
+
+FnPointer::FnPointer() : Pointer(nullptr) {}
+
+FnPointer::FnPointer(Function *F) : Pointer(F) {}
+
+FnPointer::FnPointer(const FunctionDecl *FD) : Pointer(FD) {}
+
+APValue FnPointer::toAPValue() const {
+  APValue::LValueBase Base;
+  llvm::SmallVector<APValue::LValuePathEntry, 5> Path;
+  bool IsNullPtr;
+  bool IsOnePastEnd;
+
+  if (isZero()) {
+    Base = static_cast<const Expr *>(nullptr);
+    IsNullPtr = true;
+    IsOnePastEnd = false;
+  } else {
+    IsNullPtr = false;
+
+    if (const FunctionDecl *FD = asDecl())
+      Base = FD;
+    if (Function *F = asFunction())
+      Base = F->getDecl();
+
+    // TODO: determine IsOnePastEnd
+    IsOnePastEnd = false;
+  }
+
+  return APValue(Base, CharUnits::Zero(), Path, IsOnePastEnd, IsNullPtr);
+}
+
+const FunctionDecl *FnPointer::asDecl() const {
+  if (Function *F = asFunction())
+    return F->getDecl();
+  return Pointer.dyn_cast<const FunctionDecl *>();
+}
+
+Function *FnPointer::asFunction() const {
+  return Pointer.dyn_cast<Function *>();
+}
+
+bool FnPointer::isZero() const { return !Pointer; }
+
+ComparisonCategoryResult FnPointer::compare(const FnPointer &RHS) const {
+  if (asDecl() == RHS.asDecl()) {
+    return ComparisonCategoryResult::Equal;
+  } else {
+    return ComparisonCategoryResult::Nonequal;
+  }
+}
+
+/// Compares two member pointers.
+bool MemberPointer::operator==(const MemberPointer &RHS) const {
+  if (!F || !RHS.F)
+    return !F && !RHS.F;
+  return F == RHS.F && IsDerived == RHS.IsDerived && Steps == RHS.Steps;
+}
+
+/// Converts to a base pointer, in place.
+bool MemberPointer::toBase(const CXXRecordDecl *B) {
+  if (isZero())
+    return true;
+  if (Steps.size() == 1) {
+    IsDerived = true;
+    Steps.push_back(B);
+    return true;
+  }
+  if (IsDerived) {
+    Steps.push_back(B);
+    return true;
+  }
+  if (*(Steps.rbegin() + 1) != B)
+    return false;
+  Steps.pop_back();
+  return true;
+}
+
+/// Converts to a derived pointer, in place.
+bool MemberPointer::toDerived(const CXXRecordDecl *D) {
+  if (isZero())
+    return true;
+  // No dangling derived member - extend path.
+  if (!IsDerived) {
+    Steps.push_back(D);
+    return true;
+  }
+  // The class we are casting to must match the class in the path.
+  // The only path which is allowed is the one that traces back to base.
+  if (*(Steps.rbegin() + 1) != D)
+    return false;
+  Steps.pop_back();
+  if (Steps.size() == 1)
+    IsDerived = false;
+  return true;
+}

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 "FixedIntegral.h"
 #include "Integral.h"
 #include "Pointer.h"
+#include "Real.h"
 
 namespace clang {
 namespace interp {
 
 /// Enumeration of the primitive types of the VM.
 enum PrimType : unsigned {
   PT_Sint8,
   PT_Uint8,
   PT_Sint16,
   PT_Uint16,
   PT_Sint32,
   PT_Uint32,
   PT_Sint64,
   PT_Uint64,
+  PT_SintFP,
+  PT_UintFP,
+  PT_RealFP,
   PT_Bool,
   PT_Ptr,
+  PT_FnPtr,
+  PT_MemPtr,
 };
 
 /// Mapping from primitive types to their representation.
 template <PrimType T> struct PrimConv;
 template <> struct PrimConv<PT_Sint8> { using T = Integral<8, true>; };
 template <> struct PrimConv<PT_Uint8> { using T = Integral<8, false>; };
 template <> struct PrimConv<PT_Sint16> { using T = Integral<16, true>; };
 template <> struct PrimConv<PT_Uint16> { using T = Integral<16, false>; };
 template <> struct PrimConv<PT_Sint32> { using T = Integral<32, true>; };
 template <> struct PrimConv<PT_Uint32> { using T = Integral<32, false>; };
 template <> struct PrimConv<PT_Sint64> { using T = Integral<64, true>; };
 template <> struct PrimConv<PT_Uint64> { using T = Integral<64, false>; };
+template <> struct PrimConv<PT_SintFP> { using T = FixedIntegral<true>; };
+template <> struct PrimConv<PT_UintFP> { using T = FixedIntegral<false>; };
+template <> struct PrimConv<PT_RealFP> { using T = Real; };
 template <> struct PrimConv<PT_Bool> { using T = Boolean; };
 template <> struct PrimConv<PT_Ptr> { using T = Pointer; };
+template <> struct PrimConv<PT_FnPtr> { using T = FnPointer; };
+template <> struct PrimConv<PT_MemPtr> { using T = MemberPointer; };
 
 /// 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) {
+  switch (Type) {
+  case PT_SintFP:
+  case PT_UintFP:
+    return true;
+  default:
+    return false;
+  }
+}
+
+constexpr bool isIntegral(PrimType Type) {
+  return isPrimitiveIntegral(Type) || isFixedIntegral(Type);
+}
+
+inline bool isFixedReal(PrimType Type) {
+  return Type == PT_RealFP;
+}
+
 } // 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_SintFP, B)                                             \
+    TYPE_SWITCH_CASE(PT_UintFP, B)                                             \
+    TYPE_SWITCH_CASE(PT_RealFP, B)                                             \
     TYPE_SWITCH_CASE(PT_Bool, B)                                               \
     TYPE_SWITCH_CASE(PT_Ptr, B)                                                \
+    TYPE_SWITCH_CASE(PT_FnPtr, B)                                              \
+    TYPE_SWITCH_CASE(PT_MemPtr, B)                                             \
   }
 #define COMPOSITE_TYPE_SWITCH(Expr, B, D)                                      \
   switch (Expr) {                                                              \
+    TYPE_SWITCH_CASE(PT_SintFP, B)                                             \
+    TYPE_SWITCH_CASE(PT_UintFP, B)                                             \
+    TYPE_SWITCH_CASE(PT_RealFP, B)                                             \
     TYPE_SWITCH_CASE(PT_Ptr, B)                                                \
+    TYPE_SWITCH_CASE(PT_MemPtr, B)                                             \
     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)                                             \
+    TYPE_SWITCH_CASE(PT_SintFP, B)                                             \
+    TYPE_SWITCH_CASE(PT_UintFP, B)                                             \
     default: llvm_unreachable("not an integer");                               \
   }
+
 #endif

clang/lib/AST/Interp/Program.cpp

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();
+  if (auto *V = dyn_cast<VarDecl>(VD)) {
+    const bool IsConst = V->isConstexpr() || V->getType().isConstQualified();
+    IsStatic = !V->hasLocalStorage();
+    IsExtern = !V->getAnyInitializer() || !IsConst;
   } 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;

clang/lib/AST/Interp/Real.h

+//===--- Real.h - Wrapper for floating types for the VM ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the VM types and helpers operating on types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_REAL_H
+#define LLVM_CLANG_AST_INTERP_REAL_H
+
+#include <cstddef>
+#include <cstdint>
+#include "Integral.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace clang {
+namespace interp {
+
+using APFloat = llvm::APFloat;
+using fltSemantics = llvm::fltSemantics;
+using RoundingMode = APFloat::roundingMode;
+
+class Real {
+  APFloat V;
+
+public:
+  Real() : V(llvm::APFloat::Bogus(), 0) {}
+
+  explicit Real(const APFloat &V) : V(V) {}
+
+  APFloat toAPFloat() const { return V; }
+
+  APValue toAPValue() const { return APValue(toAPFloat()); }
+
+  void print(llvm::raw_ostream &OS) const { V.print(OS); }
+
+  bool isZero() const { return V.isZero(); }
+
+  bool isNaN() const { return V.isNaN(); }
+
+  ComparisonCategoryResult compare(const Real &RHS) const {
+    switch (V.compare(RHS.V)) {
+    case APFloat::cmpEqual:
+      return ComparisonCategoryResult::Equal;
+    case APFloat::cmpLessThan:
+      return ComparisonCategoryResult::Less;
+    case APFloat::cmpGreaterThan:
+      return ComparisonCategoryResult::Greater;
+    case APFloat::cmpUnordered:
+      return ComparisonCategoryResult::Unordered;
+    }
+    llvm_unreachable("invalid comparison result");
+  }
+
+  template <unsigned Bits, bool Sign>
+  static Real from(const Integral<Bits, Sign> &I, const fltSemantics &S) {
+    APFloat Result(S, 1);
+    Result.convertFromAPInt(I.toAPSInt(), I.isSigned(),
+                            APFloat::rmNearestTiesToEven);
+    return Real(Result);
+  }
+
+  template <bool Sign>
+  static Real from(const FixedIntegral<Sign> &I, const llvm::fltSemantics &S) {
+    APFloat Result(S, 1);
+    Result.convertFromAPInt(I.toAPSInt(), I.isSigned(),
+                            APFloat::rmNearestTiesToEven);
+    return Real(Result);
+  }
+
+  static Real from(const APFloat &F, const llvm::fltSemantics &S) {
+    return Real(F);
+  }
+
+  static Real from(const Real &F, const llvm::fltSemantics &S) {
+    APFloat Result = F.V;
+    bool Ignored;
+    Result.convert(S, APFloat::rmNearestTiesToEven, &Ignored);
+    return Real(Result);
+  }
+
+  static Real from(const Boolean &B, const llvm::fltSemantics &S) {
+    return Real(APFloat(S, APInt(1u, static_cast<uint64_t>(!B.isZero()))));
+  }
+
+  static Real zero(const llvm::fltSemantics &S) {
+    return Real(APFloat::getZero(S));
+  }
+
+  static Real increment(const Real &A) {
+    APFloat R = A.V;
+    R.add(APFloat(R.getSemantics(), 1), APFloat::rmNearestTiesToEven);
+    return Real(R);
+  }
+
+  static Real decrement(const Real &A) {
+    APFloat R = A.V;
+    R.subtract(APFloat(R.getSemantics(), 1), APFloat::rmNearestTiesToEven);
+    return Real(R);
+  }
+
+  static Real add(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
+    APFloat Result = LHS.V;
+    Result.add(RHS.V, M);
+    return Real(Result);
+  }
+
+  static Real sub(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
+    APFloat Result = LHS.V;
+    Result.subtract(RHS.V, M);
+    return Real(Result);
+  }
+
+  static Real mul(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
+    APFloat Result = LHS.V;
+    Result.multiply(RHS.V, M);
+    return Real(Result);
+  }
+
+  static Real div(const Real &LHS, const Real &RHS, APFloat::roundingMode M) {
+    APFloat Result = LHS.V;
+    Result.divide(RHS.V, M);
+    return Real(Result);
+  }
+
+  static Real negate(const Real &Arg) {
+    APFloat Result = Arg.V;
+    Result.changeSign();
+    return Real(Result);
+  }
+};
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Real &F) {
+  F.print(OS);
+  return OS;
+}
+
+} // namespace interp
+} // namespace clang
+
+#endif

clang/lib/AST/Interp/Source.h

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

SourceLocation SourceInfo::getLoc() const {
   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/alignof.cpp

+// RUN: %clang_cc1 -triple=x86_64-apple-darwin12 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -triple=x86_64-apple-darwin12 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+
+static_assert(alignof(void *) == 8);

clang/test/AST/Interp/arg_struct.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
-constexpr int cond_then_else(int a, int b) {
-  if (a < b) {
-    return b - a;
-  } else {
-    return a - b;
-  }
+
+struct S {
+  int x = 1;
+};
+
+
+constexpr int callee(S s, S t) {
+  return s.x + t.x;
+
+constexpr int caller(S s) {
+  return callee(s, {});
 }
+
+static_assert(caller({}) == 2);

clang/test/AST/Interp/array.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr int *invalid_offset() { // expected-error {{constexpr function never produces a constant expression}}
+  int arr[3] = {1, 2};
+  return 4 + arr; // expected-note {{cannot refer to element 4 of array of 3 elements in a constant expression}} \
+                                                      // expected-note {{cannot refer to element 4 of array of 3 elements in a constant expression}} \
+                                                      // expected-warning {{address of stack memory associated with local variable 'arr' returned}}
+}
+
+constexpr int *invalid_value = invalid_offset(); // expected-error {{constexpr variable 'invalid_value' must be initialized by a constant expression}}\
+                                                      // expected-note {{in call to 'invalid_offset()'}}

clang/test/AST/Interp/array_in_array.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int f() {
+  int arr[2][2] = { { 1, 2 }, {3, 4 }};
+  return arr[0][0] + arr[0][1] + arr[1][0] + arr[1][1];
+}
+
+constexpr int g() {
+  int arr[2][2] = { { 1, 2 }, {3, 4 }};
+  return *(arr[0] + 0) + *(arr[0] + 1) + *(arr[1] + 0) + *(arr[1] + 1);
+}
+
+using A = int[10];
+using A = int[f()];
+using A = int[g()];

clang/test/AST/Interp/array_loop_init.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+struct S {
+  int x[2];
+
+  constexpr S(int y) : x{y, y} {}
+};
+
+constexpr int f() {
+  S a(1);
+  S b(a);
+  return b.x[0] + b.x[1];
+}
+
+static_assert(f() == 2);
+
+struct P {
+  S s[2];
+
+  constexpr P(int y) : s{y, y} {}
+};
+
+constexpr int g() {
+  P a(1);
+  P b(a);
+
+  return b.s[0].x[0] + b.s[0].x[1] + b.s[1].x[0] + b.s[1].x[1];
+}
+
+static_assert(g() == 4);

clang/test/AST/Interp/bitfield.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct S128 {
+  __int128 n : 3;
+  constexpr S128(__int128 k) : n(k) {}
+};
+static_assert(S128(3).n == 3, "");
+static_assert(S128(4).n == -4, "");
+static_assert(S128(7).n == -1, "");
+static_assert(S128(8).n == 0, "");
+static_assert(S128(-1).n == -1, "");
+static_assert(S128(-8889).n == -1, "");
+
+struct S64 {
+  long long n : 3;
+  constexpr S64(long long k) : n(k) {}
+};
+static_assert(S64(3).n == 3, "");
+static_assert(S64(4).n == -4, "");
+static_assert(S64(7).n == -1, "");
+static_assert(S64(8).n == 0, "");
+static_assert(S64(-1).n == -1, "");
+static_assert(S64(-8889).n == -1, "");
+
+
+
+constexpr int shift_bitfield() {
+  S64 a{1};
+  a.n <<= 1;
+  return a.n;
+}
+static_assert(shift_bitfield() == 2);
+
+
+constexpr int shift_bitfield_trunc() {
+  S64 a{1};
+  a.n <<= 10;
+  return a.n;
+}
+static_assert(shift_bitfield_trunc() == 0);

clang/test/AST/Interp/boolean.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
-constexpr int cond_then_else(int a, int b) {
-  if (a < b) {
-    return b - a;
-  } else {
-    return a - b;
-  }
+constexpr bool get_boolean(int a) {
+  return a < 0 ? true : false;
 }
+
+static_assert(get_boolean(-1));
+static_assert(!get_boolean(1));

clang/test/AST/Interp/bound_member_ptr.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct Indirect {
+  constexpr int f() const { return 2; };
+};
+
+constexpr int (Indirect::*ptrF) () const = &Indirect::f;
+
+using CheckThat = int[2];
+using CheckThat = int[(Indirect().*ptrF)()];

clang/test/AST/Interp/call.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr int callee(int a) {
+  return a + 1000000000; // expected-note {{value 3000000000 is outside the range of representable values of type 'int'}}
+}
+
+constexpr int caller(int a) {
+  return callee(a + 1000000000); // expected-note {{in call to 'callee(2000000000)'}}
+}
+
+constexpr int n = caller(1000000000); // expected-error {{constexpr variable 'n' must be initialized by a constant expression}} \
+                                      // expected-note {{in call to 'caller(1000000000)'}}
+static_assert(caller(0) == 2000000000);

clang/test/AST/Interp/case_range.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int f(int n) {
+  switch (n) {
+    case 0 ... 5: return 1;
+    case 10 ... 20: return 2;
+    default: return 3;
+  }
+}
+
+using A = int[1];
+using A = int[f(2)];
+using B = int[2];
+using B = int[f(12)];
+using C = int[3];
+using C = int[f(22)];

clang/test/AST/Interp/cast.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr unsigned f() {
+  return 100;
+}
+
+static_assert(f() == 100);
+
+static_assert((long long)(unsigned short)-1 == 65535);
+static_assert((long long)(unsigned char)-1 == 255);
+static_assert((long long)(short)-1 == -1);
+static_assert((long long)(char)-1 == -1);

clang/test/AST/Interp/compound_assign.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int MulAssign(int a, int b) {
+  int x = a;
+  return x *= b;
+}
+using ResultMulAssign = int[6];
+using ResultMulAssign = int[MulAssign(3, 2)];
+
+constexpr int DivAssign(int a, int b) {
+  int x = a;
+  return x /= b;
+}
+using ResultDivAssign = int[3];
+using ResultDivAssign = int[DivAssign(6, 2)];
+
+constexpr int RemAssign(int a, int b) {
+  int x = a;
+  return x %= b;
+}
+using ResultRemAssign = int[1];
+using ResultRemAssign = int[RemAssign(5, 2)];
+
+constexpr int AddAssign(int a, int b) {
+  int x = a;
+  return x += b;
+}
+using ResultAddAssign = int[3];
+using ResultAddAssign = int[AddAssign(1, 2)];
+
+constexpr int SubAssign(int a, int b) {
+  int x = a;
+  return x -= b;
+}
+using ResultSubAssign = int[3];
+using ResultSubAssign = int[SubAssign(5, 2)];
+
+constexpr int AndAssign(int a, int b) {
+  int x = a;
+  return x &= b;
+}
+using ResultAndAssign = int[4];
+using ResultAndAssign = int[AndAssign(7, 4)];
+
+constexpr int XorAssign(int a, int b) {
+  int x = a;
+  return x ^= b;
+}
+using ResultXorAssign = int[1];
+using ResultXorAssign = int[XorAssign(5, 4)];
+
+constexpr int OrAssign(int a, int b) {
+  int x = a;
+  return x |= b;
+}
+using ResultOrAssign = int[6];
+using ResultOrAssign = int[OrAssign(4, 2)];
+
+constexpr int ShlAssign(int a, int b) {
+  int x = a;
+  return x <<= b;
+}
+static_assert(ShlAssign(1, 2) == 4);
+
+constexpr int ShrAssign(int a, int b) {
+  int x = a;
+  return x >>= b;
+}
+static_assert(ShrAssign(4, 1) == 2);

clang/test/AST/Interp/cond.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
 constexpr int cond_then_else(int a, int b) {
   if (a < b) {
     return b - a;
   } else {
     return a - b;
   }
 }
+
+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);

clang/test/AST/Interp/default_cons.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
-constexpr int cond_then_else(int a, int b) {
-  if (a < b) {
-    return b - a;
-  } else {
-    return a - b;
-  }
-}
+struct B {
+  int a = 0;
+  int b = 2;
+
+  constexpr int f() const { return a; }
+};
+
+constexpr static B b;
+
+constexpr int c = b.f();

clang/test/AST/Interp/designated_init.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+
+constexpr int uninitialized() {
+  int a[2] = { [0] = a[1] };       // expected-note {{read of object outside its lifetime is not allowed in a constant expression}}\
+                                   // expected-warning {{array designators are a C99 extension}}
+  return a[1];
+}
+
+constexpr int i = uninitialized(); // expected-error {{constexpr variable 'i' must be initialized by a constant expression}}\
+                                   // expected-note {{in call to 'uninitialized()'}}

clang/test/AST/Interp/double_to_int.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr double d = 1e300;
+constexpr char a0 = d;        // expected-error {{must be initialized}} expected-note {{outside the range}}
+constexpr int a1 = d;         // expected-error {{must be initialized}} expected-note {{outside the range}}
+constexpr short a2 = d;       // expected-error {{must be initialized}} expected-note {{outside the range}}
+constexpr long long a3 = d;   // expected-error {{must be initialized}} expected-note {{outside the range}}
+constexpr __int128 a4 = d;    // expected-error {{must be initialized}} expected-note {{outside the range}}

clang/test/AST/Interp/dummy.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+typedef long long size_t;
+
+typedef struct __sFILE {
+  unsigned char *_p;
+  int _w;
+  int _lbfsize;
+} FILE;
+
+// In order to evaluate potentially constant expressions, the interpreter
+// creates a dummy pointer to an external block which cannot be read, but
+// supports pointer derivations.
+int __sputc(int _c, FILE *_p) {
+  if (--_p->_w >= 0)
+    return 1;
+  return 0;
+}
+

clang/test/AST/Interp/enum.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+enum EnumChar : char { ENUM_CHAR = 0 };
+
+enum EnumShort : signed short { ENUM_SHORT = 256 };
+
+enum EnumInt : int { ENUM_INT = 65536 };
+
+enum EnumLong : long { ENUM_LONG = 4294967296};
+
+
+constexpr EnumChar enum_char() {
+  return ENUM_CHAR;
+}
+
+constexpr EnumShort enum_short() {
+  return ENUM_SHORT;
+}
+
+constexpr EnumInt enum_int() {
+  return ENUM_INT;
+}
+
+constexpr EnumLong enum_long() {
+  return ENUM_LONG;
+}

clang/test/AST/Interp/extern.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+
+struct S {
+  int a;
+  int b[10];
+};
+
+extern S s; // expected-note {{declared here}}
+
+constexpr int fail_read_extern = s.a; // expected-error {{constexpr variable 'fail_read_extern' must be initialized by a constant expression}}\
+                                      // expected-note {{read of non-constexpr variable 's' is not allowed in a constant expression}}\

clang/test/AST/Interp/float.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr float a = 16777217;     // expected-warning {{implicit conversion from 'int' to 'const float' changes value from 16777217 to 16777216}}
+
+constexpr float f = 1.0 / 0.0f;   // expected-error {{constexpr variable 'f' must be initialized by a constant expression}}\
+                                  // expected-note {{division by zero}}
+
+static_assert(1 + 2.0f == 3.0f);
+static_assert(4.0f + 1 == 5.0f);
+static_assert(1.0f + 5.0f == 6.0f);
+static_assert(1 + 1.0 == 2.0);
+static_assert(1.0 + 2 == 3.0);
+static_assert(1.0 + 1.0f == 2.0);
+static_assert(1.0f + 1.0 == 2.0);
+static_assert(1.0 + 1.0f == 2.0);
+
+
+constexpr float inc_float() {
+  float x = 3.0f;
+  return ++x;
+}
+static_assert(inc_float() == 4.0f);
+
+constexpr double inc_double() {
+  double x = 3.0;
+  return ++x;
+}
+static_assert(inc_double() == 4.0);
+
+constexpr float dec_float() {
+  float x = 3.0f;
+  return --x;
+}
+static_assert(dec_float() == 2.0f);
+
+constexpr double dec_double() {
+  double x = 3.0;
+  return --x;
+}
+static_assert(dec_double() == 2.0);

clang/test/AST/Interp/flow.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int fn_for_break(int n) {
+  int x = 0;
+  for (int i = 0; i < 20; ++i) {
+    if (i == n)
+      break;
+    x++;
+  }
+  return x;
+}
+using A = int[5];
+using A = int[fn_for_break(5)];
+
+constexpr int fn_for_cont(int n) {
+  int x = 0;
+  for (int i = 0; i < 20; ++i) {
+    if (i < n)
+      continue;
+    x++;
+  }
+  return x;
+}
+using B = int[15];
+using B = int[fn_for_cont(5)];
+
+constexpr int fn_while_break(unsigned n) {
+  int x = 0;
+  int i = 0;
+  while (int next = ++i) {
+    if (next == n) {
+      break;
+    }
+    x++;
+  }
+  return x;
+}
+using C = int[4];
+using C = int[fn_while_break(5)];
+
+constexpr int fn_while_cont(unsigned n) {
+  int x = 0;
+  int i = 0;
+  while (i < 10) {
+    ++i;
+    if (i < n) {
+      continue;
+    }
+    x++;
+  }
+  return x;
+}
+using D = int[6];
+using D = int[fn_while_cont(5)];
+
+constexpr int fn_do_break(unsigned n) {
+  int x = 0;
+  int i = 0;
+  do {
+    if (i == n) {
+      break;
+    }
+    x++;
+    i++;
+  } while (i < 20);
+  return x;
+}
+using E = int[5];
+using E = int[fn_do_break(5)];
+
+constexpr int fn_do_continue(unsigned n) {
+  int x = 0;
+  int i = 0;
+  do {
+    i++;
+    if (i < n) {
+      continue;
+    }
+    x++;
+  } while (i < 20);
+  return x;
+}
+using F = int[16];
+using F = int[fn_do_continue(5)];

clang/test/AST/Interp/for_range.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr bool for_range_init() {
+  int k = 0;
+  for (int arr[3] = {1, 2, 3}; int n : arr) k += n;
+  return k == 6;
+}
+static_assert(for_range_init());
+
+
+constexpr int for_range_break() {
+  int k = 0;
+  int arr[5] = { 0, 0, 0, 1, 3};
+  for (int n : arr) {
+    if (n == 1) {
+      break;
+    }
+    ++k;
+  }
+  return k;
+}
+using A = int[3];
+using A = int[for_range_break()];
+
+constexpr int for_range_continue() {
+  int k = 0;
+  int arr[5] = { 0, 0, 0, 1, 0};
+  for (int n : arr) {
+    if (n == 0) {
+      continue;
+    }
+    ++k;
+  }
+  return k;
+}
+using B = int[1];
+using B = int[for_range_continue()];

clang/test/AST/Interp/funcptr.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -verify
+
+constexpr int f(int a, int b);
+
+constexpr int apply(int (*f)(int, int), int a, int b) {
+  return f(a, b);   // expected-note {{undefined function 'g' cannot be used in a constant expression}}\\
+                    // expected-note {{subexpression not valid in a constant expression}}
+}
+
+constexpr int a = apply(nullptr, 0, 1); // expected-error {{constexpr variable 'a' must be initialized by a constant expression}}\
+                                        // expected-note {{in call to 'apply(nullptr, 0, 1)'}}
+
+constexpr int bind_delayed() {
+  return apply(f, 1, 2);
+}
+
+constexpr int f(int a, int b) {
+  return a + b;
+}
+
+constexpr int bind_now() {
+  return apply(f, 1, 2);
+}
+
+using A = int[3];
+using A = int[bind_delayed()];
+using A = int[bind_now()];
+
+constexpr int g(int a, int b);  // expected-note {{declared here}}
+
+constexpr int bind_never() {
+  return apply(g, 1, 2);        // expected-note {{in call to 'apply(&g, 1, 2)'}}
+}
+
+constexpr int x = bind_never(); // expected-error {{constexpr variable 'x' must be initialized by a constant expression}}\
+                                // expected-note {{in call to 'bind_never()'}}
+
+
+constexpr int (*fnPtr)(int, int) = f;
+static_assert(fnPtr(1, 2) == 3, "oops");
+
+
+static_assert(f != g, "!=");
+static_assert(f != f, "!="); // expected-error {{static_assert failed due to requirement 'f != f' "!="}}
+static_assert(f == f, "!=");
+static_assert(f == g, "!="); // expected-error {{static_assert failed due to requirement 'f == g' "!="}}
+
+static_assert(&f != nullptr, "!=nullptr");
+static_assert(nullptr != &g, "nullptr!=");

clang/test/AST/Interp/global.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int global_prim = 5;
+
+constexpr int get_global_prim() {
+  return global_prim;
+}
+
+static_assert(get_global_prim() == global_prim);
+
+constexpr int global_array[3] = {1, 2, 3};
+
+constexpr int get_global_array() {
+  return global_array[0];
+}
+
+static_assert(get_global_array() == 1);
+
+struct S {
+  int n;
+  constexpr S() : n(5) {}
+};
+
+constexpr S s;
+
+static_assert(s.n == 5);

clang/test/AST/Interp/inheritance.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct A {
+  int x = 1;
+};
+
+struct B {
+  int y = 10;
+};
+
+struct C {
+  int z = 100;
+};
+
+struct D : public A, public B, public C {
+  int w = 1000;
+};
+
+constexpr int f() {
+  D d;
+  return d.x + d.y + d.z + d.w;
+}
+
+using CheckF = int[1111];
+using CheckF = int[f()];

clang/test/AST/Interp/init.cpp

+// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -triple x86_64-linux-gnu
+// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -triple x86_64-linux-gnu -fforce-experimental-new-constant-interpreter
+
+struct S;
+constexpr int extract(const S &s);
+
+struct S {
+  constexpr S() : n(extract(*this)), m(0) {} // expected-note {{in call to 'extract(s1)'}}
+  constexpr S(int k) : n(k), m(extract(*this)) {}
+  int n, m;
+};
+
+constexpr int extract(const S &s) { return s.n; } // expected-note {{read of object outside its lifetime is not allowed in a constant expression}}
+
+void f() {
+  constexpr S s1; // expected-error {{constant expression}} \
+                  // expected-note {{in call to 'S()'}}
+}

clang/test/AST/Interp/init_list_int.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+namespace std {
+  typedef decltype(sizeof(int)) size_t;
+
+  template <class _E>
+  class initializer_list
+  {
+    const _E* __begin_;
+    size_t    __size_;
+
+    constexpr initializer_list(const _E* __b, size_t __s)
+      : __begin_(__b),
+        __size_(__s)
+    {}
+
+  public:
+    typedef _E        value_type;
+    typedef const _E& reference;
+    typedef const _E& const_reference;
+    typedef size_t    size_type;
+
+    typedef const _E* iterator;
+    typedef const _E* const_iterator;
+
+    constexpr initializer_list() : __begin_(nullptr), __size_(0) {}
+
+    constexpr size_t    size()  const {return __size_;}
+    constexpr const _E* begin() const {return __begin_;}
+    constexpr const _E* end()   const {return __begin_ + __size_;}
+  };
+}
+
+namespace InitializerList {
+  constexpr int sum(const int *b, const int *e) {
+    return b != e ? *b + sum(b+1, e) : 0;
+  }
+  constexpr int sum(std::initializer_list<int> ints) {
+    return sum(ints.begin(), ints.end());
+  }
+  static_assert(sum({1, 2, 3, 4, 5}) == 15, "");
+
+  static_assert(*std::initializer_list<int>{1, 2, 3}.begin() == 1, "");
+  static_assert(std::initializer_list<int>{1, 2, 3}.begin()[2] == 3, "");
+}

clang/test/AST/Interp/init_list_ptr.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+namespace std {
+  typedef decltype(sizeof(int)) size_t;
+
+  template <class _E>
+  class initializer_list
+  {
+    const _E* __begin_;
+    const _E* __end_;
+
+    constexpr initializer_list(const _E* __b, const _E* __e)
+      : __begin_(__b),
+        __end_(__e)
+    {}
+
+  public:
+    typedef _E        value_type;
+    typedef const _E& reference;
+    typedef const _E& const_reference;
+    typedef size_t    size_type;
+
+    typedef const _E* iterator;
+    typedef const _E* const_iterator;
+
+    constexpr initializer_list() : __begin_(nullptr), __end_(nullptr) {}
+
+    constexpr size_t    size()  const {return __end_ - __begin_; }
+    constexpr const _E* begin() const {return __begin_;}
+    constexpr const _E* end()   const {return __end_;}
+  };
+}
+
+namespace InitializerList {
+  constexpr int sum(const int *b, const int *e) {
+    return b != e ? *b + sum(b+1, e) : 0;
+  }
+  constexpr int sum(std::initializer_list<int> ints) {
+    return sum(ints.begin(), ints.end());
+  }
+  static_assert(sum({1, 2, 3, 4, 5}) == 15, "");
+
+  static_assert(*std::initializer_list<int>{1, 2, 3}.begin() == 1, "");
+  static_assert(std::initializer_list<int>{1, 2, 3}.begin()[2] == 3, "");
+}

clang/test/AST/Interp/int128.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr __int128 MAX_VALUE = (static_cast<__int128>(0x7FFFFFFFFFFFFFFF) << static_cast<__int128>(64)) | static_cast<__int128>(0xFFFFFFFFFFFFFFFF);
+constexpr __int128 MIN_VALUE = -MAX_VALUE - 1;
+constexpr __int128 add_pos(__int128 a) {
+  return a + a;                                         // expected-note {{value 340282366920938463463374607431768211454 is outside the range of representable values of type '__int128'}}
+}
+
+constexpr __int128 v0 = add_pos(MAX_VALUE);             // expected-error {{constexpr variable 'v0' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'add_pos(170141183460469231731687303715884105727)'}}
+
+constexpr __int128 add_neg(__int128 a) {
+  return a + a;                                         // expected-note {{value -340282366920938463463374607431768211456 is outside the range of representable values of type '__int128'}}
+}
+constexpr __int128 v1 = add_neg(MIN_VALUE);             // expected-error {{constexpr variable 'v1' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'add_neg(-170141183460469231731687303715884105728)'}}
+
+constexpr __int128 sub_neg(__int128 a, __int128 b) {
+  return a - b;                                         // expected-note {{value -340282366920938463463374607431768211455 is outside the range of representable values of type '__int128'}}
+}
+
+constexpr __int128 v2 = sub_neg(MIN_VALUE, MAX_VALUE);  // expected-error {{constexpr variable 'v2' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'sub_neg(-170141183460469231731687303715884105728, 170141183460469231731687303715884105727)'}}
+
+constexpr __int128 sub_pos(__int128 a, __int128 b) {
+  return a - b;                                         // expected-note {{value 340282366920938463463374607431768211455 is outside the range of representable values of type '__int128'}}
+}
+constexpr __int128 v3 = sub_pos(MAX_VALUE, MIN_VALUE);  // expected-error {{constexpr variable 'v3' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'sub_pos(170141183460469231731687303715884105727, -170141183460469231731687303715884105728)'}}
+
+constexpr __int128 mul(__int128 a, __int128 b) {
+  return a * b;                                         // expected-note {{value 28948022309329048855892746252171976962977213799489202546401021394546514198529 is outside the range of representable values of type '__int128'}}
+}
+constexpr __int128 v4 = mul(MAX_VALUE, MAX_VALUE);      // expected-error {{constexpr variable 'v4' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'mul(170141183460469231731687303715884105727, 170141183460469231731687303715884105727)'}}
+
+constexpr __int128 div_0(__int128 a, __int128 b) {
+  return a / b;                                         // expected-note {{division by zero}}
+}
+constexpr __int128 v5 = div_0(1, 0);                    // expected-error {{constexpr variable 'v5' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'div_0(1, 0)'}}
+
+constexpr __int128 mod_0(__int128 a, __int128 b) {
+  return a % b;                                         // expected-note {{division by zero}}
+}
+constexpr __int128 v6 = mod_0(1, 0);                    // expected-error {{constexpr variable 'v6' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'mod_0(1, 0)'}}
+
+constexpr __int128 div_ov(__int128 a, __int128 b) {
+  return a / b;                                         // expected-note {{value 170141183460469231731687303715884105728 is outside the range of representable values of type '__int128'}}
+}
+constexpr __int128 v7 = div_ov(MIN_VALUE, -1);          // expected-error {{constexpr variable 'v7' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'div_ov(-170141183460469231731687303715884105728, -1)'}}
+constexpr __int128 mod_ov(__int128 a, __int128 b) {
+  return a / b;                                         // expected-note {{value 170141183460469231731687303715884105728 is outside the range of representable values of type '__int128'}}
+}
+constexpr __int128 v8 = mod_ov(MIN_VALUE, -1);          // expected-error {{constexpr variable 'v8' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'mod_ov(-170141183460469231731687303715884105728, -1)'}}
+
+constexpr __int128 neg_ov(__int128 a) {
+  return -a;                                            // expected-note {{value 170141183460469231731687303715884105728 is outside the range of representable values of type '__int128'}}
+}
+constexpr __int128 v9 = neg_ov(MIN_VALUE);              // expected-error {{constexpr variable 'v9' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'neg_ov(-170141183460469231731687303715884105728)'}}
+
+static_assert((__int128)-1 == -1);
+static_assert((__int128)(unsigned short)-1 == 65535);

clang/test/AST/Interp/int64.cpp

+// RUN: %clang_cc1 -triple=x86_64-unknown-linux -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -triple=x86_64-unknown-linux -std=c++17 -fsyntax-only %s -verify
+
+constexpr long long MAX_VALUE = 0x7FFFFFFFFFFFFFFF;
+constexpr long long MIN_VALUE = -MAX_VALUE - 1;
+constexpr long long add_pos(long long a) {
+  return a + a;                                         // expected-note {{value 18446744073709551614 is outside the range of representable values of type 'long long'}}
+}
+
+constexpr long long v0 = add_pos(MAX_VALUE);             // expected-error {{constexpr variable 'v0' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'add_pos(9223372036854775807)'}}
+
+constexpr long long add_neg(long long a) {
+  return a + a;                                         // expected-note {{value -18446744073709551616 is outside the range of representable values of type 'long long'}}
+}
+constexpr long long v1 = add_neg(MIN_VALUE);             // expected-error {{constexpr variable 'v1' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'add_neg(-9223372036854775808)'}}
+
+constexpr long long sub_neg(long long a, long long b) {
+  return a - b;                                         // expected-note {{value -18446744073709551615 is outside the range of representable values of type 'long long'}}
+}
+
+constexpr long long v2 = sub_neg(MIN_VALUE, MAX_VALUE);  // expected-error {{constexpr variable 'v2' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'sub_neg(-9223372036854775808, 9223372036854775807)'}}
+
+constexpr long long sub_pos(long long a, long long b) {
+  return a - b;                                         // expected-note {{value 18446744073709551615 is outside the range of representable values of type 'long long'}}
+}
+constexpr long long v3 = sub_pos(MAX_VALUE, MIN_VALUE);  // expected-error {{constexpr variable 'v3' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'sub_pos(9223372036854775807, -9223372036854775808)'}}
+
+constexpr long long mul(long long a, long long b) {
+  return a * b;                                         // expected-note {{value 85070591730234615847396907784232501249 is outside the range of representable values of type 'long long'}}
+}
+constexpr long long v4 = mul(MAX_VALUE, MAX_VALUE);      // expected-error {{constexpr variable 'v4' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'mul(9223372036854775807, 9223372036854775807)'}}
+
+constexpr long long div_0(long long a, long long b) {
+  return a / b;                                         // expected-note {{division by zero}}
+}
+constexpr long long v5 = div_0(1, 0);                    // expected-error {{constexpr variable 'v5' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'div_0(1, 0)'}}
+
+constexpr long long mod_0(long long a, long long b) {
+  return a % b;                                         // expected-note {{division by zero}}
+}
+constexpr long long v6 = mod_0(1, 0);                    // expected-error {{constexpr variable 'v6' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'mod_0(1, 0)'}}
+
+constexpr long long div_ov(long long a, long long b) {
+  return a / b;                                         // expected-note {{value 9223372036854775808 is outside the range of representable values of type 'long long'}}
+}
+constexpr long long v7 = div_ov(MIN_VALUE, -1);          // expected-error {{constexpr variable 'v7' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'div_ov(-9223372036854775808, -1)'}}
+constexpr long long mod_ov(long long a, long long b) {
+  return a / b;                                         // expected-note {{value 9223372036854775808 is outside the range of representable values of type 'long long'}}
+}
+constexpr long long v8 = mod_ov(MIN_VALUE, -1);          // expected-error {{constexpr variable 'v8' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'mod_ov(-9223372036854775808, -1)'}}
+
+constexpr long long neg_ov(long long a) {
+  return -a;                                            // expected-note {{value 9223372036854775808 is outside the range of representable values of type 'long long'}}
+}
+constexpr long long v9 = neg_ov(MIN_VALUE);              // expected-error {{constexpr variable 'v9' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'neg_ov(-9223372036854775808)'}}
+
+constexpr long long sub_zero_min(long long a, long long b) {
+  return a - b;                                         // expected-note {{value 9223372036854775808 is outside the range of representable values of type 'long long'}}
+}
+
+constexpr long long v10 = sub_zero_min(0, MIN_VALUE);  // expected-error {{constexpr variable 'v10' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'sub_zero_min(0, -9223372036854775808)'}}
+
+
+static_assert((long long)-1 == -1);
+static_assert((long long)(unsigned char)-1 == 255);

clang/test/AST/Interp/lifetime.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct S { int x; constexpr S() : x(0) {} };
+
+constexpr int extend_lifetime() {
+  const S &s = S();
+  return s.x;
+}
+
+constexpr int finish_lifetime() {
+  return S().x;
+}
+
+constexpr int extend_integer() {
+  const auto &s = 5;
+  return s;
+}
+using A = int[5];
+using A = int[extend_integer()];

clang/test/AST/Interp/locals.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr void modifier(int *a) {
+  *a = 5; // expected-note {{modification of object of const-qualified type 'const int' is not allowed in a constant expression}}
+}
+
+constexpr bool mod_non_const() {
+  int a = 0;
+  modifier(&a);
+  return a == 5;
+}
+
+static_assert(mod_non_const());
+
+constexpr bool mod_const() {
+  const int a = 0;
+  modifier((int *)&a); // expected-note {{in call to 'modifier(&a)'}}
+  return a == 5;
+}
+
+static_assert(mod_const()); // expected-error {{static_assert expression is not an integral constant expression}} \
+                            // expected-note {{in call to 'mod_const()'}}

clang/test/AST/Interp/logical.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int and_short_circuit() {
+  int a = 0;
+  if (0 && ++a) {
+    return 0;
+  }
+  return a == 0;
+}
+
+static_assert(and_short_circuit());
+
+constexpr int or_short_circuit() {
+  int a = 0;
+  if (1 || ++a) {
+    return a == 0;
+  }
+  return 0;
+}
+
+static_assert(or_short_circuit());

clang/test/AST/Interp/loop.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int sum_pow(int n) {
+  int a = 0;
+  for (int i = 0; i < n; i = i + 1) {
+    for (int j = 0; j < n; j = j + 1) {
+      a = (a + (i % 1000) + (j % 1000)) % 1000;
+    }
+  }
+  return a;
+}
+
+static_assert(sum_pow(2) == 4);
+
+constexpr int loop_cond_var(int n) {
+  int a = 0;
+  for (int i = n; int b = a + 1; i = i + 1) {
+    if (i == 50) {
+      a = 0 - b;
+    }
+  }
+  return a - 1;
+}
+
+static_assert(loop_cond_var(10) == -2);

clang/test/AST/Interp/member_fn.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -verify
+
+struct A {
+  constexpr int a() const { return 1; }
+};
+
+struct B : public A {
+  constexpr int b() const { return 2; }
+};
+
+struct C : public B {
+  constexpr int c() const { return 3; }
+};
+
+constexpr A a{};
+constexpr B b{};
+constexpr C c{};
+
+// Test direct pointers.
+constexpr int (A::*pAa)() const = &A::a;
+static_assert((a.*pAa)() == 1, "");
+
+constexpr int (B::*pBa)() const = &B::a;
+constexpr int (B::*pBb)() const = &B::b;
+static_assert((b.*pBa)() == 1, "");
+static_assert((b.*pBb)() == 2, "");
+
+constexpr int (C::*pCa)() const = &C::a;
+constexpr int (C::*pCb)() const = &C::b;
+constexpr int (C::*pCc)() const = &C::c;
+static_assert((c.*pCa)() == 1, "");
+static_assert((c.*pCb)() == 2, "");
+static_assert((c.*pCc)() == 3, "");
+
+// Cast from base to derived.
+constexpr int (B::*pABa)() const = pAa;
+static_assert((b.*pABa)() == 1, "");
+
+constexpr int (C::*pACa)() const = pAa;
+static_assert((c.*pACa)() == 1, "");
+
+constexpr int (C::*pABCa)() const = pBa;
+static_assert((c.*pABCa)() == 1, "");
+
+constexpr int (C::*pBCa)() const = pBa;
+static_assert((c.*pBCa)() == 1, "");
+
+constexpr int (C::*pBCb)() const = pBb;
+static_assert((c.*pBCb)() == 2, "");
+
+// Cast from derived to base.
+constexpr int (B::*pCBa)() const = (int(B::*)() const)pCa;
+constexpr int (B::*pCBb)() const = (int(B::*)() const)pCb;
+constexpr int (B::*pCBc)() const = (int(B::*)() const)pCc;
+
+constexpr int (A::*pCAa)() const = (int(A::*)() const)pCa;
+constexpr int (A::*pCAb)() const = (int(A::*)() const)pCb;
+constexpr int (A::*pCAc)() const = (int(A::*)() const)pCc;
+
+constexpr int (A::*pCBAa)() const = (int(A::*)() const)pCBa;
+constexpr int (A::*pCBAb)() const = (int(A::*)() const)pCBb;
+constexpr int (A::*pCBAc)() const = (int(A::*)() const)pCBc;
+
+static_assert((c.*pCBa)() == 1, "");
+static_assert((c.*pCBb)() == 2, "");
+static_assert((c.*pCBc)() == 3, "");
+static_assert((c.*pCAa)() == 1, "");
+static_assert((c.*pCAb)() == 2, "");
+static_assert((c.*pCAc)() == 3, "");
+static_assert((c.*pCBAa)() == 1, "");
+static_assert((c.*pCBAb)() == 2, "");
+static_assert((c.*pCBAc)() == 3, "");
+
+static_assert((b.*pCBa)() == 1, "");
+static_assert((b.*pCBb)() == 2, "");
+static_assert((b.*pCBc)() == 3, "");  // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert((b.*pCAa)() == 1, "");
+static_assert((b.*pCAb)() == 2, "");
+static_assert((b.*pCAc)() == 3, "");  // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert((b.*pCBAa)() == 1, "");
+static_assert((b.*pCBAb)() == 2, "");
+static_assert((b.*pCBAc)() == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+
+static_assert((a.*pCAa)() == 1, "");
+static_assert((a.*pCAb)() == 2, "");  // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert((a.*pCAc)() == 3, "");  // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert((a.*pCBAa)() == 1, "");
+static_assert((a.*pCBAb)() == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert((a.*pCBAc)() == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+
+// Cast from B to A.
+constexpr int (A::*qBAa)() const = (int(A::*)() const)pBa;
+constexpr int (A::*qBAb)() const = (int(A::*)() const)pBb;
+
+static_assert((c.*qBAa)() == 1, "");
+static_assert((c.*qBAb)() == 2, "");
+static_assert((b.*qBAa)() == 1, "");
+static_assert((b.*qBAb)() == 2, "");
+static_assert((a.*qBAa)() == 1, "");
+static_assert((a.*qBAb)() == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+
+// Cast from A to B and C.
+constexpr int (B::*qABa)() const = (int(B::*)() const)pAa;
+constexpr int (C::*qACa)() const = (int(C::*)() const)pAa;
+constexpr int (C::*qABCa)() const = (int(C::*)() const)pAa;
+
+static_assert((b.*qABa)() == 1, "");
+static_assert((c.*qACa)() == 1, "");
+static_assert((c.*qABCa)() == 1, "");
+
+// Cast from B to C.
+constexpr int (C::*qBCa)() const = (int(C::*)() const)pBa;
+constexpr int (C::*qBCb)() const = (int(C::*)() const)pBb;
+
+static_assert((c.*qBCa)() == 1, "");
+static_assert((c.*qBCb)() == 2, "");

clang/test/AST/Interp/member_fn_virtual.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// expected-no-diagnostics
+
+struct A {
+  int x = 1;
+  constexpr virtual int f() const { return x; }
+};
+
+constexpr int (A::*pF) () const = &A::f;
+
+struct B : public A {
+  int y = 2;
+  constexpr int f() const override { return y; }
+};
+
+constexpr A a{};
+static_assert((a.*pF)() == 1);
+
+constexpr B b{};
+static_assert((b.*pF)() == 2);
+
+// The constexpr tree evaluator incorrectly marks this as never producing a constant.
+constexpr int invoke_a() { A a{}; return (a.*pF)(); }
+static_assert(invoke_a() == 1);
+
+constexpr int invoke_b() { B b{}; return (b.*pF)(); }
+static_assert(invoke_b() == 2);

clang/test/AST/Interp/member_ptr.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -verify
+
+struct A {
+  int a = 1;
+};
+
+struct B : public A {
+  int b = 2;
+};
+
+struct C : public B {
+  int c = 3;
+};
+
+constexpr A a{};
+constexpr B b{};
+constexpr C c{};
+
+// Test direct pointers.
+constexpr int (A::*pAa) = &A::a;
+static_assert(a.*pAa == 1, "");
+
+constexpr int (B::*pBa) = &B::a;
+constexpr int (B::*pBb) = &B::b;
+static_assert(b.*pBa == 1, "");
+static_assert(b.*pBb == 2, "");
+
+constexpr int (C::*pCa) = &C::a;
+constexpr int (C::*pCb) = &C::b;
+constexpr int (C::*pCc) = &C::c;
+static_assert(c.*pCa == 1, "");
+static_assert(c.*pCb == 2, "");
+static_assert(c.*pCc == 3, "");
+
+// Cast from base to derived.
+constexpr int (B::*pABa) = pAa;
+static_assert(b.*pABa == 1, "");
+
+constexpr int (C::*pACa) = pAa;
+static_assert(c.*pACa == 1, "");
+
+constexpr int (C::*pABCa) = pBa;
+static_assert(c.*pABCa == 1, "");
+
+constexpr int (C::*pBCa) = pBa;
+static_assert(c.*pBCa == 1, "");
+
+constexpr int (C::*pBCb) = pBb;
+static_assert(c.*pBCb == 2, "");
+
+// Cast from C to B and A.
+constexpr int (B::*pCBa) = (int(B::*))pCa;
+constexpr int (B::*pCBb) = (int(B::*))pCb;
+constexpr int (B::*pCBc) = (int(B::*))pCc;
+
+constexpr int (A::*pCAa) = (int(A::*))pCa;
+constexpr int (A::*pCAb) = (int(A::*))pCb;
+constexpr int (A::*pCAc) = (int(A::*))pCc;
+
+constexpr int (A::*pCBAa) = (int(A::*))pCBa;
+constexpr int (A::*pCBAb) = (int(A::*))pCBb;
+constexpr int (A::*pCBAc) = (int(A::*))pCBc;
+
+static_assert(c.*pCBa == 1, "");
+static_assert(c.*pCBb == 2, "");
+static_assert(c.*pCBc == 3, "");
+static_assert(c.*pCAa == 1, "");
+static_assert(c.*pCAb == 2, "");
+static_assert(c.*pCAc == 3, "");
+static_assert(c.*pCBAa == 1, "");
+static_assert(c.*pCBAb == 2, "");
+static_assert(c.*pCBAc == 3, "");
+
+static_assert(b.*pCBa == 1, "");
+static_assert(b.*pCBb == 2, "");
+static_assert(b.*pCBc == 3, "");  // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert(b.*pCAa == 1, "");
+static_assert(b.*pCAb == 2, "");
+static_assert(b.*pCAc == 3, "");  // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert(b.*pCBAa == 1, "");
+static_assert(b.*pCBAb == 2, "");
+static_assert(b.*pCBAc == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+
+static_assert(a.*pCAa == 1, "");
+static_assert(a.*pCAb == 2, "");  // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert(a.*pCAc == 3, "");  // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert(a.*pCBAa == 1, "");
+static_assert(a.*pCBAb == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+static_assert(a.*pCBAc == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+
+// Cast from B to A.
+constexpr int (A::*qBAa) = (int(A::*))pBa;
+constexpr int (A::*qBAb) = (int(A::*))pBb;
+
+static_assert(c.*qBAa == 1, "");
+static_assert(c.*qBAb == 2, "");
+static_assert(b.*qBAa == 1, "");
+static_assert(b.*qBAb == 2, "");
+static_assert(a.*qBAa == 1, "");
+static_assert(a.*qBAb == 2, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+
+// Cast from A to B and C.
+constexpr int (B::*qABa) = (int(B::*))pAa;
+constexpr int (C::*qACa) = (int(C::*))pAa;
+constexpr int (C::*qABCa) = (int(C::*))pAa;
+
+static_assert(b.*qABa == 1, "");
+static_assert(c.*qACa == 1, "");
+static_assert(c.*qABCa == 1, "");
+
+// Cast from B to C.
+constexpr int (C::*qBCa) = (int(C::*))pBa;
+constexpr int (C::*qBCb) = (int(C::*))pBb;
+
+static_assert(c.*qBCa == 1, "");
+static_assert(c.*qBCb == 2, "");

clang/test/AST/Interp/member_ptr_ambiguity.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct A {
+    int x = 1;
+};
+
+struct B {
+    int x = 2;
+};
+
+struct C : public A, public B {
+};
+
+
+constexpr int (C::*pA) = &A::x;
+constexpr int (C::*pB) = &B::x;
+
+constexpr C c;
+
+using Ax = int[1];
+using Ax = int[c.*pA];
+
+
+using Bx = int[2];
+using Bx = int[c.*pB];

clang/test/AST/Interp/member_ptr_derived.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct A {
+  int a = 1;
+};
+
+struct B : A {
+  int b = 2;
+};
+
+struct C : B {
+  int c = 3;
+};
+
+
+constexpr int (A::*pA) = &A::a;
+constexpr int (B::*pB) = &B::a;
+constexpr int (C::*pC) = &C::a;
+
+constexpr A a{};
+constexpr B b{};
+constexpr C c{};
+
+static_assert(b.*pB == 1);
+static_assert(c.*pC == 1);
+static_assert(a.*pA == 1);

clang/test/AST/Interp/member_ptr_explicit_path.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct A {
+    int a = 1;
+};
+
+struct B : public A {
+    int b = 2;
+};
+
+struct C : public A {
+    int c = 2;
+};
+
+struct D : public B, public C {
+    int d = 3;
+};
+
+constexpr int (D::*pB) = (int(B::*))&A::a;

clang/test/AST/Interp/member_ptr_missing.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+struct A {
+    int a = 1;
+};
+
+struct B : public A {
+    int b = 2;
+};
+
+constexpr A a;
+
+constexpr int (A::*pB) = (int(A::*))&B::b;
+static_assert(a.*pB, ""); // expected-error {{static_assert expression is not an integral constant expression}}
+
+constexpr int (A::*pA) = (int(A::*))&B::a;
+static_assert(a.*pA == 1, "");
+
+constexpr B b;
+constexpr int (B::*pBack) = pB;
+static_assert(b.*pBack == 2, "");

clang/test/AST/Interp/member_ptr_print.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions %s -verify
+
+struct A {
+    int field = 0;
+
+    constexpr int fn() { return 0; }
+};
+
+constexpr int call_field(int (A::*p), bool flag = true) {
+    return flag ? throw : 0;                              // expected-note 2{{subexpression not valid in a constant expression}}
+}
+
+constexpr int a0 = call_field(&A::field);                 // expected-error {{constexpr variable 'a0' must be initialized by a constant expression}}\
+                                                          // expected-note {{in call to 'call_field(&A::field, true)'}}
+constexpr int a1 = call_field(nullptr);                   // expected-error {{onstexpr variable 'a1' must be initialized by a constant expression}}\
+                                                          // expected-note {{in call to 'call_field(0, true)'}}
+constexpr int call_fn(int (A::*p)(), bool flag = true) {
+    return flag ? throw : 0;                              // expected-note 2{{subexpression not valid in a constant expression}}
+}
+
+constexpr int a2 = call_fn(&A::fn);                       // expected-error {{constexpr variable 'a2' must be initialized by a constant expression}}\
+                                                          // expected-note {{in call to 'call_fn(&A::fn, true)'}}
+constexpr int a3 = call_fn(nullptr);                      // expected-error {{constexpr variable 'a3' must be initialized by a constant expression}}\
+                                                          // expected-note {{in call to 'call_fn(0, true)'}}

clang/test/AST/Interp/member_ptr_wrong_path.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+struct A {
+    int a = 1;
+};
+
+struct B : public A {
+    int b = 2;
+};
+
+struct C : public A {
+    int c = 2;
+};
+
+struct D : public B, public C {
+    int d = 3;
+};
+
+constexpr D d;
+constexpr int (D::*pB) = (int(C::*))((int(A::*))&B::b); // expected-error {{constexpr variable 'pB' must be initialized by a constant expression}}

clang/test/AST/Interp/method.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct S {
+  const int x;
+  constexpr S() : x(42) {}
+  constexpr int get_x() { return x; }
+};
+
+constexpr int invoke_S_method() {
+  return S().get_x();
+}
+
+using A = int[42];
+using A = int[invoke_S_method()];
+
+struct P {
+  const int x;
+  constexpr P();
+  constexpr int get_x();
+};
+
+constexpr P::P() : x(42) {}
+constexpr int P::get_x() { return x; }
+
+
+constexpr int invoke_P_method() {
+  return P().get_x();
+}
+
+using B = int[42];
+using B = int[invoke_P_method()];

clang/test/AST/Interp/null_method.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+
+struct S {
+  constexpr void f() { }
+};
+
+constexpr void f() { // expected-error {{constexpr function never produces a constant expression}}
+  S *s = nullptr;
+  s->f();           // expected-note {{member call on dereferenced null pointer is not allowed in a constant expression}}
+}

clang/test/AST/Interp/nullptr.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr int nullptr_deref() {   // expected-error {{constexpr function never produces a constant expression}}
+  int *a = nullptr;
+  return *a;                      // expected-note {{read of dereferenced null pointer is not allowed in a constant expression}}
+}
+
+constexpr int zero_deref() {      // expected-error {{constexpr function never produces a constant expression}}
+  int *a = (int*)0;
+  return *a;                      // expected-note {{read of dereferenced null pointer is not allowed in a constant expression}}
+}
+
+constexpr int nullptr_write() {   // expected-error {{constexpr function never produces a constant expression}}
+  int *a = (int*)0;
+  *a = 5;                         // expected-note {{assignment to dereferenced null pointer is not allowed in a constant expression}}
+  return *a;
+}
+
+constexpr int *nullptr_inc() {    // expected-error {{constexpr function never produces a constant expression}}
+  int *a = (int*)nullptr;
+  return a++;                     // expected-note {{cannot perform pointer arithmetic on null pointer}}
+}
+
+constexpr int *nullptr_dec() {    // expected-error {{constexpr function never produces a constant expression}}
+  int *a = (int*)nullptr;
+  return a--;                     // expected-note {{cannot perform pointer arithmetic on null pointer}}
+}
+
+constexpr int *nullptr_offset() { // expected-error {{constexpr function never produces a constant expression}}
+  int *a = (int*)nullptr;
+  return a + 2;                   // expected-note {{cannot perform pointer arithmetic on null pointer}}
+}
+
+constexpr int nullptr_ref_int() { // expected-error {{constexpr function never produces a constant expression}}
+  int *a = nullptr;
+  int &b = *a;
+  return b;                       // expected-note {{read of dereferenced null pointer is not allowed in a constant expression}}
+}
+
+constexpr int nullptr_ref_inc() { // expected-error {{constexpr function never produces a constant expression}}
+  int *a = nullptr;
+  int &b = *a;
+  return b++;                     // expected-note {{increment of dereferenced null pointer is not allowed in a constant expression}}
+}
+
+constexpr int nullptr_ref_dec() { // expected-error {{constexpr function never produces a constant expression}}
+  int *a = nullptr;
+  int &b = *a;
+  return b--;                     // expected-note {{decrement of dereferenced null pointer is not allowed in a constant expression}}
+}

clang/test/AST/Interp/nullptr_struct.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+struct S { int x; constexpr S() : x(0) {} };
+
+constexpr int *nullptr_ptr() {    // expected-error {{constexpr function never produces a constant expression}}
+  S *s = nullptr;
+  return &s->x;                   // expected-note {{cannot access field of null pointer}}
+}
+
+constexpr int nullptr_field() {   // expected-error {{constexpr function never produces a constant expression}}
+  S *s = nullptr;
+  return s->x;                    // expected-note {{cannot access field of null pointer}}
+}

clang/test/AST/Interp/operator.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify -fforce-experimental-new-constant-interpreter
+// expected-no-diagnostics
+
+
+struct S {
+  int X;
+
+  constexpr S(int X) : X(X) {}
+
+  constexpr S operator+(const S& RHS) {
+    return S(X + RHS.X);
+  }
+};
+
+
+static_assert((S(2) + S(3)).X == 5);

clang/test/AST/Interp/overflow.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr int add_pos(int a) {
+  return a + a; // expected-note {{value 4000000000 is outside the range of representable values of type 'int'}}
+}
+
+constexpr int v0 = add_pos(2000000000); // expected-error {{constexpr variable 'v0' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'add_pos(2000000000)'}}
+
+constexpr int add_neg(int a) {
+  return a + a; // expected-note {{value -4000000000 is outside the range of representable values of type 'int'}}
+}
+constexpr int v1 = add_neg(-2000000000); // expected-error {{constexpr variable 'v1' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'add_neg(-2000000000)'}}
+
+constexpr int sub_neg(int a, int b) {
+  return a - b; // expected-note {{value -4000000000 is outside the range of representable values of type 'int'}}
+}
+
+constexpr int v2 = sub_neg(-2000000000, 2000000000); // expected-error {{constexpr variable 'v2' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'sub_neg(-2000000000, 2000000000)'}}
+
+constexpr int sub_pos(int a, int b) {
+  return a - b; // expected-note {{value 4000000000 is outside the range of representable values of type 'int'}}
+}
+constexpr int v3 = sub_pos(2000000000, -2000000000); // expected-error {{constexpr variable 'v3' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'sub_pos(2000000000, -2000000000)'}}
+
+constexpr int mul(int a, int b) {
+  return a * b; // expected-note {{value 4900000000 is outside the range of representable values of type 'int'}}
+}
+constexpr int v4 = mul(70000, 70000); // expected-error {{constexpr variable 'v4' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'mul(70000, 70000)'}}
+
+constexpr int div_0(int a, int b) {
+  return a / b; // expected-note {{division by zero}}
+}
+constexpr int v5 = div_0(1, 0); // expected-error {{constexpr variable 'v5' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'div_0(1, 0)'}}
+
+constexpr int mod_0(int a, int b) {
+  return a % b; // expected-note {{division by zero}}
+}
+constexpr int v6 = mod_0(1, 0); // expected-error {{constexpr variable 'v6' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'mod_0(1, 0)'}}
+
+constexpr int div_ov(int a, int b) {
+  return a / b; // expected-note {{value 2147483648 is outside the range of representable values of type 'int'}}
+}
+constexpr int v7 = div_ov(-2147483647 - 1, -1); // expected-error {{constexpr variable 'v7' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'div_ov(-2147483648, -1)'}}
+constexpr int mod_ov(int a, int b) {
+  return a / b; // expected-note {{value 2147483648 is outside the range of representable values of type 'int'}}
+}
+constexpr int v8 = mod_ov(-2147483647 - 1, -1); // expected-error {{constexpr variable 'v8' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'mod_ov(-2147483648, -1)'}}
+
+constexpr unsigned sub_u(unsigned a) {
+  return 0u - a;
+}
+static_assert(sub_u(2000000000u) == 2294967296u);
+
+constexpr int neg_ov(int a) {
+  return -a; // expected-note {{value 2147483648 is outside the range of representable values of type 'int'}}
+}
+constexpr int v9 = neg_ov(-2147483647 - 1); // expected-error {{constexpr variable 'v9' must be initialized by a constant expression}} \
+                                                        // expected-note {{in call to 'neg_ov(-2147483648)'}}
+
+constexpr unsigned neg_ov_u(unsigned a) {
+  return -a;
+}
+constexpr unsigned v10 = neg_ov_u(2147483647);
+

clang/test/AST/Interp/past_end.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int add_pointer(int *st, int *en) {
+  int sum = 0;
+  for (int *i = st; i < en; i = i + 1) {
+    sum = sum + i[0];
+  }
+  return sum;
+}
+
+constexpr int pointer_adder() {
+  int arr[3] = {1, 2, 3};
+  return add_pointer(arr, arr + 3);
+}
+
+using A = int[6];
+using A = int[pointer_adder()];

clang/test/AST/Interp/ptr.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr int f() {
+  int a = 0;
+  int &b = a;
+  a = 5;
+  b = 7;
+  return b;
+}
+
+static_assert(f() == 7);
+
+constexpr int &g() {
+  int a = 0; // expected-note {{declared here}}
+  return a;  // expected-warning {{reference to stack memory associated with local variable 'a' returned}}
+}
+
+constexpr int h() {
+  return g(); // expected-note {{read of variable whose lifetime has ended}}
+}
+
+constexpr int v0 = h(); // expected-error {{constexpr variable 'v0' must be initialized by a constant expression}} \
+                                                                   // expected-note {{in call to 'h()'}}
+
+constexpr bool compare_valid_ptr() {
+  int a[2] = {};
+  return &a[0] < &a[1];
+}
+
+static_assert(compare_valid_ptr());
+
+constexpr bool compare_ptr(int *a, int *b) {
+  return a < b; // expected-note {{subexpression not valid in a constant expression}} \
+                                                                   // expected-note {{subexpression not valid in a constant expression}} \
+                                                                   // expected-note {{subexpression not valid in a constant expression}}
+}
+
+constexpr int *return_arg(int a) {
+  return &a; // expected-warning {{address of stack memory associated with parameter 'a' returned}}
+}
+
+constexpr int *get_dead_ptr() {
+  int a = 0;
+  return &a; // expected-warning {{address of stack memory associated with local variable 'a' returned}}
+}
+
+constexpr bool compare_dead_lhs() {
+  int b = 2;
+  return compare_ptr(get_dead_ptr(), &b); // expected-note {{in call to 'compare_ptr(&a, &b)'}}
+}
+
+constexpr bool dead_lhs_comparison = compare_dead_lhs(); // expected-error {{constexpr variable 'dead_lhs_comparison' must be initialized by a constant expression}} \
+                                                                   // expected-note {{in call to 'compare_dead_lhs()'}}
+
+constexpr bool compare_dead_rhs() {
+  int a = 2;
+  return compare_ptr(&a, get_dead_ptr()); // expected-note {{in call to 'compare_ptr(&a, &a)'}}
+}
+
+constexpr bool dead_rhs_comparison = compare_dead_rhs(); // expected-error {{constexpr variable 'dead_rhs_comparison' must be initialized by a constant expression}}\
+                                                                 // expected-note {{in call to 'compare_dead_rhs()'}}
+
+constexpr bool compare_dead_lhs_rhs() {
+  return compare_ptr(get_dead_ptr(), get_dead_ptr()); // expected-note {{in call to 'compare_ptr(&a, &a)'}}
+}
+
+constexpr bool dead_lhs_rhs_comparison = compare_dead_lhs_rhs(); // expected-error {{constexpr variable 'dead_lhs_rhs_comparison' must be initialized by a constant expression}}\
+                                                                 // expected-note {{in call to 'compare_dead_lhs_rhs()'}}
+
+constexpr bool compare_invalid_ptr() { // expected-error {{constexpr function never produces a constant expression}}
+  int a = 0;
+  int b = 1;
+  return &a < &b; // expected-note {{subexpression not valid in a constant expression}} \
+                                                                 // expected-note {{subexpression not valid in a constant expression}}
+}
+
+constexpr bool v1 = compare_invalid_ptr(); // expected-error {{constexpr variable 'v1' must be initialized by a constant expression}} \
+                                                                 // expected-note {{in call to 'compare_invalid_ptr()'}}
+
+constexpr int add_callee(int *a, int *b) {
+  return *a + *b;
+}
+
+constexpr int add_caller(int a, int b) {
+  return add_callee(&a, &b);
+}
+
+static_assert(add_caller(2, 3) == 5);
+
+constexpr void ptr_mutate_callee(int *a) {
+  *a = 10;
+}
+
+constexpr int ptr_mutate_caller() {
+  int a = 5;
+  ptr_mutate_callee(&a);
+  return a;
+}
+
+static_assert(ptr_mutate_caller() == 10);
+
+constexpr void ptr_increment() { // expected-error {{constexpr function never produces a constant expression}}
+  int a = 0;
+  int *b = &a;
+  ++b;
+  ++b; // expected-note {{cannot refer to element 2 of non-array object in a constant expression}}
+}
+
+constexpr void ptr_decrement() { // expected-error {{constexpr function never produces a constant expression}}
+  int a = 0;
+  int *b = &a;
+  --b; // expected-note {{cannot refer to element -1 of non-array object in a constant expression}}
+}
+
+constexpr int *dead_ptr_offset() {
+  return get_dead_ptr() + 2;          // expected-note {{cannot refer to element 2 of non-array object in a constant expression}}
+}
+
+constexpr int *v = dead_ptr_offset(); // expected-error {{constexpr variable 'v' must be initialized by a constant expression}}\
+                                      // expected-note {{in call to 'dead_ptr_offset()'}}

clang/test/AST/Interp/ptr_derived_cast.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct A {
+    int a = 0;
+};
+
+struct B : public A { int b = 1;};
+struct C : public B { int c = 2;};
+struct D : public C { int d = 3;};
+
+constexpr D d{};
+constexpr A *ap = (A*)&d;
+constexpr D *dp = (D*)ap;
+static_assert(dp->d == 3);

clang/test/AST/Interp/ptrdiff.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+
+
+constexpr int diff_bad() {                  // expected-error {{constexpr function never produces a constant expression}}
+  int a = 0;
+  int b = 0;
+  return &a - &b;                           // expected-note 2{{subexpression not valid in a constant expression}}
+}
+
+constexpr int bad = diff_bad();             // expected-error {{constexpr variable 'bad' must be initialized by a constant expression}}\
+                                            // expected-note {{in call to 'diff_bad()'}}}
+
+constexpr int diff_bad_array() {            // expected-error {{constexpr function never produces a constant expression}}
+  int a[1] = {0};
+  int b[1] = {0};
+  return &a[0] - &b[0];                     // expected-note 2{{subexpression not valid in a constant expression}}
+}
+
+constexpr int bad_array = diff_bad_array(); // expected-error {{constexpr variable 'bad_array' must be initialized by a constant expression}}\
+                                            // expected-note {{in call to 'diff_bad_array()'}}}
+
+constexpr int diff_pos() {
+  int a[2] = {0, 1};
+  return &a[1] - &a[0];
+}
+
+static_assert(diff_pos() == 1);
+
+constexpr int diff_neg() {
+  int a[2] = {0, 1};
+  return &a[0] - &a[1];
+}
+
+static_assert(diff_neg() == -1);
+
+
+struct S {
+  int a[1] = {1};
+  int b[1] = {2};
+};
+constexpr S s;
+constexpr int diff_different_arrays() {   // expected-error {{constexpr function never produces a constant expression}}
+  return &s.a[0] - &s.b[0];               // expected-note 2{{subtracted pointers are not elements of the same array}}
+}
+
+constexpr int different_arrays = diff_different_arrays(); // expected-error {{constexpr variable 'different_arrays' must be initialized by a constant expression}}\
+                                                          // expected-note {{in call to 'diff_different_arrays()'}}

clang/test/AST/Interp/ptrdiff_overflow.cpp

+// RUN: %clang_cc1 -triple=avr -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -triple=avr -std=c++2a -fsyntax-only %s -verify
+
+
+constexpr int diff() {  // expected-error {{constexpr function never produces a constant expression}}
+  char a[32769] = {0};
+  return &a[32769] - &a[0]; // expected-note {{value 32769 is outside the range of representable values of type 'int'}}
+}

clang/test/AST/Interp/pure_virt_ind.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify -Wno-invalid-constexpr
+
+struct A {
+    constexpr A();
+    constexpr virtual void f() const = 0; // expected-note {{declared here}}
+};
+
+constexpr void (A::*pF)() const = &A::f;
+
+constexpr A::A() {
+  (this->*pF)(); // expected-note {{pure virtual function 'A::f' called}}
+}
+
+struct B : public A { // expected-note {{in call to 'A()'}}
+    constexpr virtual void f() const {};
+};
+
+constexpr B a{}; // expected-error {{constexpr variable 'a' must be initialized by a constant expression}}\
+                 // expected-note {{in call to 'B()'}}

clang/test/AST/Interp/read_only.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+struct S { const int x; int y; constexpr S() : x(0), y(1) {} };
+
+constexpr int mutate_x() {
+  S s;
+  int *x = const_cast<int *>(&s.x);
+  *x = 5;                           // expected-note {{modification of object of const-qualified type 'const int' is not allowed in a constant expression}}
+  return 0;
+}
+
+constexpr int x = mutate_x();   // expected-error {{constexpr variable 'x' must be initialized by a constant expression}}\
+                                    // expected-note {{in call to 'mutate_x()'}}
+
+constexpr int mutate_y() {
+  S s;
+  int *y = const_cast<int *>(&s.y);
+  *y = 5;
+  return *y;
+}
+
+using A = int[5];
+using A = int[mutate_y()];

clang/test/AST/Interp/ref_field.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
-constexpr int cond_then_else(int a, int b) {
-  if (a < b) {
-    return b - a;
-  } else {
-    return a - b;
-  }
-}
+struct AggregateInit {
+  const char &c;
+};
+
+constexpr AggregateInit agg1 = { "hello"[0] };
+
+using A = int[5];
+using A = int[__builtin_strlen(&agg1.c)];

clang/test/AST/Interp/relocation.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr int solved_callee();
+
+constexpr int solved_caller() {
+  return solved_callee();
+}
+
+constexpr int solved_callee() {
+  return 5;
+}
+
+static_assert(solved_caller() == 5);
+
+constexpr int unsolved_callee(); // expected-note {{declared here}}
+
+constexpr int unsolved_caller() {
+  return unsolved_callee(); // expected-note {{undefined function 'unsolved_callee' cannot be used in a constant expression}}
+}
+
+static_assert(unsolved_caller() == 5); // expected-error {{static_assert expression is not an integral constant expression}} \
+                                       // expected-note {{in call to 'unsolved_caller()'}}

clang/test/AST/Interp/return.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr int f(int a) {
+  if (a < 0)
+    return 10;
+} // expected-warning {{control may reach end of non-void function}} \
+                              // expected-note {{control reached end of constexpr function}}
+
+constexpr int g(int a) {
+  return f(a); // expected-note {{in call to 'f(20)'}}
+}
+
+constexpr int h(int a) {
+  return g(a); // expected-note {{in call to 'g(20)'}}
+}
+
+constexpr int i = h(20); // expected-error {{constexpr variable 'i' must be initialized by a constant expression}} \
+                              // expected-note {{in call to 'h(20)'}}

clang/test/AST/Interp/rvo.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
-constexpr int cond_then_else(int a, int b) {
-  if (a < b) {
-    return b - a;
-  } else {
-    return a - b;
-  }
+struct S {
+  int x;
+  constexpr S(int x) : x(x) {}
+};
+
+constexpr S struct_return(int x) {
+  return S(x);
 }
+
+static_assert(struct_return(5).x == 5);

clang/test/AST/Interp/scoping.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter -verify %s
+
+// Clang emits a diagnostic treating 'a' as a subobject, while the interpreter
+// emits what we think is the appropriate diagnostic for local variables.
+
+constexpr int scope_escape() { // expected-error {{constexpr function never produces a constant expression}}
+  int c = 0;
+  int *a = &c;
+  {
+    int b = 0; // expected-note {{declared here}} \
+                                            // expected-note {{declared here}}
+    a = &b;
+  }
+  return *a; // expected-note {{read of variable whose lifetime has ended}}\
+                                            // expected-note {{read of variable whose lifetime has ended}}
+}
+
+constexpr int invalid = scope_escape(); // expected-error {{constexpr variable 'invalid' must be initialized by a constant expression}} \
+                                            // expected-note {{in call to 'scope_escape()'}}
+
+constexpr int scope_inc() { // expected-error {{constexpr function never produces a constant expression}}
+  int a = 0;
+  int *b = &a;
+  int **c = &b;
+  {
+    int *d = &a; // expected-note {{declared here}}\
+                                            // expected-note {{declared here}}
+    c = &d;
+  }
+  (*c)++; // expected-note {{increment of variable whose lifetime has ended}}\
+                                            // expected-note {{increment of variable whose lifetime has ended}}
+  return 1;
+}
+
+constexpr int invalid_inc = scope_inc(); // expected-error {{constexpr variable 'invalid_inc' must be initialized by a constant expression}}\
+                                            // expected-note {{in call to 'scope_inc()'}}
+
+constexpr int scope_offset() {
+  int a = 0;
+  int *b = &a;
+  {
+    int d = 2;
+
+    b = &d;
+  }
+  int *e = b + 1;
+
+  return 1;
+}
+
+constexpr int invalid_off = scope_offset();

clang/test/AST/Interp/selfref.cpp

+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++14 -fsyntax-only %s -verify
+
+constexpr int a[2] = {a[1] + 1, a[0] + 1};
+using A = int[1];
+using A = int[a[0]];
+using B = int[2];
+using B = int[a[1]];
+
+constexpr int f() {
+  constexpr int c[2] = {c[1] + 1, c[0] + 1}; // expected-note {{read of object outside its lifetime is not allowed in a constant expression}}\
+                                             // expected-error {{constexpr variable 'c' must be initialized by a constant expression}}
+  return c[0];
+}
+
+constexpr int b[2][2] = { b[1][1] + 1 };
+using C = int[b[0][0]];
+using C = int[1];

clang/test/AST/Interp/set_field.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
-constexpr int cond_then_else(int a, int b) {
-  if (a < b) {
-    return b - a;
-  } else {
-    return a - b;
-  }
+struct S {
+  int a = 0;
+  int b = 0;
+
+  constexpr S() { b = 2; }
+};
+
+constexpr int set_field() {
+  S s;
+  (s.a = 5) = 6;
+  return s.a + s.b;
 }
+
+static_assert(set_field() == 8);

clang/test/AST/Interp/shift.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fforce-experimental-new-constant-interpreter -verify=all,cpp11 %s
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter -verify=all %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=all,cpp11 %s
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -verify=all %s
+
+constexpr int shls(int a, int b) {
+  return a << b;                  // all-note {{negative shift count -200}}\
+                                  // all-note {{shift count 200 >= width of type 'int' (32 bits)}}\
+                                  // cpp11-note {{left shift of negative value -1}}\
+                                  // cpp11-note {{signed left shift discards bits}}
+}
+
+constexpr int v1 = shls(1, -200); // all-error {{constexpr variable 'v1' must be initialized by a constant expression}}\
+                                  // all-note {{in call to 'shls(1, -200)'}}
+
+constexpr int v0 = shls(1, 200);  // all-error {{constexpr variable 'v0' must be initialized by a constant expression}}\
+                                  // all-note {{in call to 'shls(1, 200)'}}
+
+using A0 = int[8];
+using A0 = int[shls(4, 1)];
+using A1 = int[2];
+using A1 = int[shls(4, -1)];
+
+constexpr int v4 = shls(-1, 1);   // cpp11-error {{constexpr variable 'v4' must be initialized by a constant expression}}\
+                                  // cpp11-note {{in call to 'shls(-1, 1)'}}
+
+constexpr int v5 = shls(128, 30); // cpp11-error {{constexpr variable 'v5' must be initialized by a constant expression}}\
+                                  // cpp11-note {{in call to 'shls(128, 30)'}}
+
+
+constexpr int shrs(int a, int b) {
+  return a >> b;                  // all-note {{negative shift count -200}}\
+                                  // all-note {{shift count 200 >= width of type 'int' (32 bits)}}\
+                                  // all-note {{shift count 32 >= width of type 'int' (32 bits)}}
+}
+
+constexpr int v2 = shrs(1, -200); // all-error {{constexpr variable 'v2' must be initialized by a constant expression}}\
+                                  // all-note {{in call to 'shrs(1, -200)'}}
+
+constexpr int v3 = shrs(1, 200);  // all-error {{constexpr variable 'v3' must be initialized by a constant expression}}\
+                                  // all-note {{in call to 'shrs(1, 200)'}}
+
+using B0 = int[2];
+using B0 = int[shrs(4, 1)];
+using B1 = int[8];
+using B1 = int[shrs(4, -1)];
+
+constexpr int v6 = shrs(1, 32);   // all-error {{constexpr variable 'v6' must be initialized by a constant expression}}\
+                                  // all-note {{in call to 'shrs(1, 32)'}}
+
+static_assert(-1 >> 1 == -1, "");
+static_assert(-1 >> 31 == -1, "");
+static_assert(-2 >> 1 == -1, "");
+static_assert(-3 >> 1 == -2, "");
+static_assert(-4 >> 1 == -2, "");

clang/test/AST/Interp/sizeof.cpp

+// RUN: %clang_cc1 -triple=x86_64-unknown-linux -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -triple=x86_64-unknown-linux -std=c++17 -fsyntax-only %s -verify
+
+static_assert(sizeof(char) == 1);
+static_assert(sizeof(short) == 2);
+static_assert(sizeof(int) == 4);
+static_assert(sizeof(long) == 8);
+static_assert(sizeof(long long) == 8);
+
+struct S; // expected-note {{forward declaration of 'S'}}
+
+constexpr int size_of_bad_struct = sizeof(S); // expected-error {{invalid application of 'sizeof' to an incomplete type 'S'}}
+
+
+template <typename... Ts>
+struct P {
+  static constexpr unsigned n = sizeof...(Ts);
+};
+
+static_assert(P<int, int, int>::n == 3);

clang/test/AST/Interp/stack_trace.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+struct S {
+  const int x;
+  constexpr S() : x(2147483647) {}
+  constexpr int call0() { return x + x; }   // expected-note {{value 4294967294 is outside the range of representable values of type 'int'}}
+  constexpr int call1() { return call0(); } // expected-note {{in call to '&S()->call0()'}}
+  constexpr int call2() { return call1(); } // expected-note {{in call to '&S()->call1()'}}
+};
+
+constexpr int method_root() {
+  return S().call2();   // expected-note {{in call to '&S()->call2()'}}
+}
+
+constexpr int x = method_root();   // expected-error {{constexpr variable 'x' must be initialized by a constant expression}}\
+                                   // expected-note {{in call to 'method_root()'}}
+
+struct P {
+  const int x;
+  constexpr P(int y) : x(y + y) {}; // expected-note {{value 4294967294 is outside the range of representable values of type 'int'}}
+};
+
+constexpr int cons_root() {
+  return P(2147483647).x;       // expected-note {{in call to 'P(2147483647)'}}
+}
+
+constexpr int y = cons_root();  // expected-error {{constexpr variable 'y' must be initialized by a constant expression}}\
+                                // expected-note {{in call to 'cons_root()'}}
+
+
+constexpr int callee_ptr(int *beg, int *end) {
+  const int x = 2147483647;
+  *beg = x + x; // expected-warning {{overflow in expression; result is -2 with type 'int'}}\
+                // expected-note 3{{value 4294967294 is outside the range of representable values of type 'int'}}
+  return *beg;
+}
+
+constexpr int caller_ptr() {
+  int x = 0;
+  return callee_ptr(&x, &x + 1); // expected-note {{in call to 'callee_ptr(&x, &x + 1)'}}
+}
+
+constexpr int z = caller_ptr(); // expected-error {{constexpr variable 'z' must be initialized by a constant expression}}\
+                                // expected-note {{in call to 'caller_ptr()'}}
+
+struct Q {
+  int x;
+  constexpr Q() : x(0) {}
+};
+
+constexpr int caller_field() {
+  Q q;
+  return callee_ptr(&q.x, &q.x + 1); // expected-note {{in call to 'callee_ptr(&q.x, &q.x + 1)'}}
+}
+
+constexpr int a = caller_field();// expected-error {{constexpr variable 'a' must be initialized by a constant expression}}\
+                                 // expected-note {{in call to 'caller_field()'}}
+
+struct R {
+  Q q;
+  constexpr R() : q() {}
+};
+
+
+constexpr int caller_nested_field() {
+  R r;
+  return callee_ptr(&r.q.x, &r.q.x + 1); // expected-note {{in call to 'callee_ptr(&r.q.x, &r.q.x + 1)'}}
+}
+
+constexpr int b = caller_nested_field();// expected-error {{constexpr variable 'b' must be initialized by a constant expression}}\
+                                 // expected-note {{in call to 'caller_nested_field()'}}

clang/test/AST/Interp/string.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr bool streq(const char *a, const char *b) {
+  while (*a && *a == *b)
+    ++a, ++b;
+  return *a == *b;
+}
+
+constexpr bool is_equal() {
+  const char *a = "Hello";
+  const char *b = "Hello";
+  return streq(a, b);
+}
+
+static_assert(is_equal());
+
+constexpr bool not_equal() {
+  const char *a = "HA";
+  const char *b = "HB";
+  return streq(a, b);
+}
+
+static_assert(!streq("HA", "HB"));

clang/test/AST/Interp/struct.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
-constexpr int cond_then_else(int a, int b) {
-  if (a < b) {
-    return b - a;
-  } else {
-    return a - b;
-  }
+struct P {
+  int x;
+  int y;
+
+  constexpr P(int x, int y) : x(x), y(y) {}
+};
+
+constexpr int f() {
+  P p(5, 6);
+  return p.x + p.y;
 }
+
+using A = int[11];
+using A = int[f()];

clang/test/AST/Interp/struct_field_ptr.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+struct S {
+  int x;
+  int y;
+  constexpr S(int x) : x(x), y(0) {}
+};
+
+constexpr int inc_to_end() {
+  S s(5);
+  int *p = &s.x;
+  ++p;
+  return *p;                                     // expected-note {{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}}
+}
+
+constexpr int inc_to_end_val = inc_to_end();     // expected-error {{constexpr variable 'inc_to_end_val' must be initialized by a constant expression}}\
+                                                 // expected-note {{in call to 'inc_to_end()'}}
+
+constexpr int inc_past_end() {
+  S s(5);
+  int *p = &s.x;
+  ++p;
+  ++p;                                           // expected-note {{cannot refer to element 2 of non-array object in a constant expression}}
+  return *p;
+}
+
+constexpr int inc_past_end_val = inc_past_end(); // expected-error {{constexpr variable 'inc_past_end_val' must be initialized by a constant expression}}\
+                                                 // expected-note {{in call to 'inc_past_end()'}}
+
+constexpr int off_past_end() {
+  S s(5);
+  int *p = &s.x;
+  return *(p + 2);                               // expected-note {{cannot refer to element 2 of non-array object in a constant expression}}
+}
+
+constexpr int off_past_end_val = off_past_end(); // expected-error {{constexpr variable 'off_past_end_val' must be initialized by a constant expression}}\
+                                                 // expected-note {{in call to 'off_past_end()'}}
+

clang/test/AST/Interp/struct_in_array.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct S {
+  int x;
+  constexpr S() : x(1) {}
+};
+
+constexpr int f() {
+  S arr[2] = { {} };
+  return arr[0].x + arr[1].x;
+}
+
+using A = int[2];
+using A = int[f()];
+
+constexpr int g(S &s) {
+  return (&s + 1)->x;
+}
+
+constexpr int h() {
+  S arr[2] = {};
+  return g(arr[0]);
+}
+
+using B = int[1];
+using B = int[h()];

clang/test/AST/Interp/struct_init.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
-constexpr int cond_then_else(int a, int b) {
-  if (a < b) {
-    return b - a;
-  } else {
-    return a - b;
-  }
+struct P {
+  int x;
+};
+
+struct Q {
+  int y;
+  P p;
+};
+
+
+constexpr int f() {
+  Q q = { 1, { 2 } };
+  return q.y + q.p.x;
 }
+
+using A = int[3];
+using A = int[f()];

clang/test/AST/Interp/switch-short-logical.c

+// RUN: %clang_cc1 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+extern int g();
+
+void test()
+{
+  int cond;
+  switch (cond) {
+  case 0 && g():
+    break;
+  }
+}

clang/test/AST/Interp/toplevel.cpp

 // RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
 // RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
 // expected-no-diagnostics
 
-constexpr int cond_then_else(int a, int b) {
-  if (a < b) {
-    return b - a;
-  } else {
-    return a - b;
-  }
+constexpr int f(int x) {
+  return x + x;
 }
+
+using A = int[f(f(20)) + 5];

clang/test/AST/Interp/unary.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+constexpr int inc_callee(int a, int b) {
+  return a;
+}
+
+constexpr int inc_caller() {
+  int n = 5;
+  return inc_callee(n++, ++n); // expected-warning {{multiple unsequenced modifications to 'n'}}
+}

clang/test/AST/Interp/union.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+union U {
+  int a;
+  int b;
+};
+
+
+constexpr U u[4] = { { .a = 0 }, { .b = 1 }, { .a = 2 }, { .b = 3 } };
+static_assert((&u[1].b)[1] == 2, ""); // expected-error {{constant expression}} expected-note {{read of dereferenced one-past-the-end pointer}}
+
+constexpr U zero_initialise = {};
+static_assert(zero_initialise.a == 0);

clang/test/AST/Interp/union_copy.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+
+union USimple {
+  int a;
+  int b;
+};
+
+constexpr USimple x1 = {42};
+constexpr USimple y1 = x1;
+static_assert(y1.a == 42, "");
+static_assert(y1.b == 42, ""); // expected-error {{static_assert expression is not an integral constant expression}}\
+                               // expected-note {{read of member 'b' of union with active member 'a' is not allowed in a constant expression}}
+
+struct S {
+  int x;
+  int y;
+};
+
+union UStruct {
+  S s;
+  int x;
+};
+
+constexpr UStruct x2 = {{1, 2}};
+constexpr UStruct y2 = x2;
+
+static_assert(y2.s.x == 1, "");
+static_assert(y2.s.y == 2, "");
+static_assert(y2.x, "");       // expected-error {{static_assert expression is not an integral constant expression}}\
+                               // expected-note {{read of member 'x' of union with active member 's' is not allowed in a constant expression}}
+
+union UArray {
+  int a[10];
+  int b;
+};
+
+constexpr UArray x3 = {{[1] = 3}}; // expected-warning {{array designators are a C99 extension}}
+constexpr UArray y3 = x3;
+
+static_assert(y3.a[0] == 0, "");
+static_assert(y3.a[1] == 3, "");
+static_assert(y3.b, "");       // expected-error {{static_assert expression is not an integral constant expression}}\
+                               // expected-note {{read of member 'b' of union with active member 'a' is not allowed in a constant expression}}

clang/test/AST/Interp/union_copy_non_constexpr.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+
+union E2 {} emptyUnion; // expected-note {{here}}
+
+constexpr E2 copyUnion(emptyUnion); // expected-error {{constant expression}} \
+                                    // expected-note {{read of non-const}} \
+                                    // expected-note {{in call}}

clang/test/AST/Interp/unknown_size.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+
+
+extern int arr[];
+constexpr int *a = arr;
+constexpr int *c = &arr[1]; // expected-error {{constant}} expected-note {{indexing of array without known bound}}
+constexpr int *d = &a[1]; // expected-error {{constant}} expected-note {{indexing of array without known bound}}
+constexpr int *e = a + 1; // expected-error {{constant}} expected-note {{indexing of array without known bound}}
+
+static unsigned __hash_len_0_to_16(const char *__s) {
+  const unsigned char __a = __s[0];
+  return 0;
+}

clang/test/AST/Interp/vararg.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr int f(int a, ...) { return a; }
+
+using A = int[f(0)];
+using A = int[0];
+
+using B = int[f(1, 0)];
+using B = int[1];
+
+using C = int[f(2, "test")];
+using C = int[2];
+
+using D = int[f(3, &f)];
+using D = int[3];

clang/test/AST/Interp/virtual_bases.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct VA { int va; };
+struct VB { int vb; };
+struct A : public virtual VA {};
+struct B : public virtual VB {};
+struct C : public A, public B, public virtual VA {};
+
+C c;
+
+constexpr int *a = &c.va;

clang/test/AST/Interp/virtual_cons.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+struct A {
+  virtual constexpr int f() const { return 1; }
+  int a = f();
+};
+
+struct B : public A {
+  virtual constexpr int f() const { return 2; }
+  int b = f();
+};
+
+struct C : public B {
+  virtual constexpr int f() const { return 3; }
+  int c = f();
+};
+
+constexpr B b{};
+using CheckBa = int[1];
+using CheckBa = int[b.a];
+using CheckBb = int[2];
+using CheckBb = int[b.b];
+
+constexpr C c{};
+using CheckCa = int[1];
+using CheckCa = int[c.a];
+using CheckCb = int[2];
+using CheckCb = int[c.b];
+using CheckCc = int[3];
+using CheckCc = int[c.c];
+
+constexpr A a{};
+using CheckAa = int[1];
+using CheckAa = int[a.a];

clang/test/AST/Interp/void_cond.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr void f(int *a) {
+  *a = 5;
+}
+
+constexpr void g(int *a) {
+  *a = 6;
+}
+
+constexpr int test(bool cond) {
+  int a = 0;
+  cond ? f(&a) : g(&a);
+  return a;
+}
+
+static_assert(test(true) == 5);
+static_assert(test(false) == 6);

clang/test/AST/Interp/vtable.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fforce-experimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+class Base {
+public:
+  virtual constexpr int f() const = 0;
+};
+
+class A : public Base {
+public:
+  int x = 1;
+  constexpr int f() const override { return x; }
+};
+
+class B : public Base {
+public:
+  int x = 2;
+  virtual constexpr int f() const override { return x; }
+};
+
+class C : public B {
+public:
+  int x = 3;
+  constexpr int f() const override { return x; }
+};
+
+class D : public B {
+public:
+  int x = 4;
+  constexpr int f() const override { return x; }
+};
+
+static_assert(A().f() == 1);
+static_assert(B().f() == 2);
+static_assert(C().f() == 3);
+static_assert(D().f() == 4);
+constexpr int call(const Base &b) {
+  return b.f();
+}
+
+static_assert(call(A{}) == 1);
+static_assert(call(B{}) == 2);
+static_assert(call(C{}) == 3);
+static_assert(call(D{}) == 4);

clang/test/SemaCXX/constexpr-many-arguments.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only %s
 // PR13197
 
 struct type1
 {
   constexpr type1(int a0) : my_data{a0} {}
   int my_data[1];
 };
 
 struct type2
 {
   typedef type1 T;
   constexpr type2(T a00, T a01, T a02, T a03, T a04, T a05, T a06, T a07, T a08, T a09,
                        T a10, T a11, T a12, T a13, T a14, T a15, T a16, T a17, T a18, T a19,
-                       T a20, T a21, T a22) 
+                       T a20, T a21, T a22)
     : my_data{a00, a01, a02, a03, a04, a05, a06, a07, a08, a09,
               a10, a11, a12, a13, a14, a15, a16, a17, a18, a19,
               a20, a21, a22}
   {}
   type1 my_data[23];
 };
 
 struct type3
 {
   constexpr type3(type2 a0, type2 a1) : my_data{a0, a1} {}
   type2 my_data[2];
 };
 
 constexpr type3 g
 {
   {
    {0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
    {0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
    {0},{0},{0}
-  }, 
+  },
   {
    {0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
    {0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
    {0},{0},{0}
   }
 };
 

clang/test/SemaCXX/shift.cpp

 
 void vect_shift_1(vec16 *x) { *x = *x << 4; }
 
 void vect_shift_2(vec16 *x, vec16 y) { *x = *x << y; }
 
 void vect_shift_3(vec16 *x, vec8 y) {
   *x = *x << y; // expected-error {{vector operands do not have the same number of elements}}
 }
+static_assert(-1 >> 1 == -1);
+static_assert(-1 >> 31 == -1);
+static_assert(-2 >> 1 == -1);
+static_assert(-3 >> 1 == -2);
+static_assert(-4 >> 1 == -2);