Compiler.cpp

Go to the documentation of this file.

//===--- Compiler.cpp - Code generator for expressions ---*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "Compiler.h"
#include "../ExprConstShared.h"
#include "ByteCodeEmitter.h"
#include "Context.h"
#include "FixedPoint.h"
#include "Floating.h"
#include "Function.h"
#include "InterpShared.h"
#include "PrimType.h"
#include "Program.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DynamicRecursiveASTVisitor.h"
#include "llvm/Support/SaveAndRestore.h"
 
using namespace clang;
using namespace clang::interp;
 
using APSInt = llvm::APSInt;
 
namespace clang {
namespace interp {
 
static std::optional<bool> getBoolValue(const Expr *E) {
  if (const auto *CE = dyn_cast_if_present<ConstantExpr>(E);
      CE && CE->hasAPValueResult() &&
      CE->getResultAPValueKind() == APValue::ValueKind::Int) {
    return CE->getResultAsAPSInt().getBoolValue();
  }
 
  return std::nullopt;
}
 
/// Check if \c E has side-effects. This is used to avoid some temporary
/// variables and is supposed to be a quick check, not exhaustive. That's why
/// we're not using Expr::HasSideEffects().
static bool isSideEffectFree(const Expr *E) {
  if (isa<IntegerLiteral, FloatingLiteral, CharacterLiteral,
          CXXBoolLiteralExpr>(E))
    return true;
  if (isa<DeclRefExpr>(E))
    return true;
 
  return false;
}
 
/// Whether the CheckArraySize op rejects an array with \p NumElems elements.
static bool exceedsArraySizeLimit(const LangOptions &LangOpts,
                                  uint64_t NumElems) {
  if (NumElems > std::numeric_limits<unsigned>::max())
    return true;
  uint64_t Limit = LangOpts.ConstexprStepLimit;
  return Limit != 0 && NumElems > Limit;
}
 
/// Scope chain managing the variable lifetimes.
template <class Emitter> class VariableScope {
public:
  VariableScope(Compiler<Emitter> *Ctx, ScopeKind Kind = ScopeKind::Block)
      : Ctx(Ctx), Parent(Ctx->VarScope), Kind(Kind) {
    if (Parent)
      this->LocalsAlwaysEnabled = Parent->LocalsAlwaysEnabled;
    Ctx->VarScope = this;
  }
 
  virtual ~VariableScope() { Ctx->VarScope = this->Parent; }
 
  virtual void addLocal(Scope::Local Local) {
    llvm_unreachable("Shouldn't be called");
  }
  /// Like addExtended, but adds to the nearest scope of the given kind.
  void addForScopeKind(const Scope::Local &Local, ScopeKind Kind) {
    VariableScope *P = this;
    while (P) {
      // We found the right scope kind.
      if (P->Kind == Kind) {
        P->addLocal(Local);
        return;
      }
      // If we reached the root scope and we're looking for a Block scope,
      // attach it to the root instead of the current scope.
      if (!P->Parent && Kind == ScopeKind::Block) {
        P->addLocal(Local);
        return;
      }
      P = P->Parent;
      if (!P)
        break;
    }
 
    // Add to this scope.
    this->addLocal(Local);
  }
 
  virtual bool emitDestructors(const Expr *E = nullptr) { return true; }
  virtual bool destroyLocals(const Expr *E = nullptr) { return true; }
  VariableScope *getParent() const { return Parent; }
  ScopeKind getKind() const { return Kind; }
 
  /// Whether locals added to this scope are enabled by default.
  /// This is almost always true, except for the two branches
  /// of a conditional operator.
  bool LocalsAlwaysEnabled = true;
 
protected:
  /// Compiler instance.
  Compiler<Emitter> *Ctx;
  /// Link to the parent scope.
  VariableScope *Parent;
  ScopeKind Kind;
};
 
/// Generic scope for local variables.
template <class Emitter> class LocalScope : public VariableScope<Emitter> {
public:
  LocalScope(Compiler<Emitter> *Ctx, ScopeKind Kind = ScopeKind::Block)
      : VariableScope<Emitter>(Ctx, Kind) {}
 
  /// Emit a Destroy op for this scope.
  ~LocalScope() override {
    if (!Idx || ExplicitlyDestroyed)
      return;
    this->Ctx->emitDestroy(*Idx, SourceInfo{});
    removeStoredOpaqueValues();
  }
  /// Explicit destruction of local variables.
  bool destroyLocals(const Expr *E = nullptr) override {
    if (!Idx)
      return true;
 
    // NB: We are *not* resetting Idx here as to allow multiple
    // calls to destroyLocals().
    bool Success = this->emitDestructors(E);
    this->Ctx->emitDestroy(*Idx, E);
    ExplicitlyDestroyed = true;
    return Success;
  }
 
  void addLocal(Scope::Local Local) override {
    if (!Idx) {
      Idx = static_cast<unsigned>(this->Ctx->Descriptors.size());
      this->Ctx->Descriptors.emplace_back();
    }
 
    Local.EnabledByDefault = this->LocalsAlwaysEnabled;
    this->Ctx->Descriptors[*Idx].emplace_back(Local);
  }
 
  bool emitDestructors(const Expr *E = nullptr) override {
    if (!Idx)
      return true;
 
    // Emit destructor calls for local variables of record
    // type with a destructor.
    for (Scope::Local &Local : llvm::reverse(this->Ctx->Descriptors[*Idx])) {
      if (Local.Desc->hasTrivialDtor())
        continue;
 
      if (!Local.EnabledByDefault) {
        typename Emitter::LabelTy EndLabel = this->Ctx->getLabel();
        if (!this->Ctx->emitGetLocalEnabled(Local.Offset, E))
          return false;
        if (!this->Ctx->jumpFalse(EndLabel, E))
          return false;
 
        if (!this->Ctx->emitGetPtrLocal(Local.Offset, E))
          return false;
 
        if (!this->Ctx->emitDestructionPop(Local.Desc, Local.Desc->getLoc()))
          return false;
 
        this->Ctx->fallthrough(EndLabel);
        this->Ctx->emitLabel(EndLabel);
      } else {
        if (!this->Ctx->emitGetPtrLocal(Local.Offset, E))
          return false;
        if (!this->Ctx->emitDestructionPop(Local.Desc, Local.Desc->getLoc()))
          return false;
      }
 
      removeIfStoredOpaqueValue(Local);
    }
    return true;
  }
 
  void removeStoredOpaqueValues() {
    if (!Idx)
      return;
 
    for (const Scope::Local &Local : this->Ctx->Descriptors[*Idx]) {
      removeIfStoredOpaqueValue(Local);
    }
  }
 
  void removeIfStoredOpaqueValue(const Scope::Local &Local) {
    if (const auto *OVE =
            llvm::dyn_cast_if_present<OpaqueValueExpr>(Local.Desc->asExpr())) {
      this->Ctx->OpaqueExprs.erase(OVE);
    };
  }
 
  /// Index of the scope in the chain.
  UnsignedOrNone Idx = std::nullopt;
  bool ExplicitlyDestroyed = false;
};
 
template <class Emitter> class ArrayIndexScope final {
public:
  ArrayIndexScope(Compiler<Emitter> *Ctx, uint64_t Index) : Ctx(Ctx) {
    OldArrayIndex = Ctx->ArrayIndex;
    Ctx->ArrayIndex = Index;
  }
 
  ~ArrayIndexScope() { Ctx->ArrayIndex = OldArrayIndex; }
 
private:
  Compiler<Emitter> *Ctx;
  std::optional<uint64_t> OldArrayIndex;
};
 
template <class Emitter> class SourceLocScope final {
public:
  SourceLocScope(Compiler<Emitter> *Ctx, const Expr *DefaultExpr) : Ctx(Ctx) {
    assert(DefaultExpr);
    // We only switch if the current SourceLocDefaultExpr is null.
    if (!Ctx->SourceLocDefaultExpr) {
      Enabled = true;
      Ctx->SourceLocDefaultExpr = DefaultExpr;
    }
  }
 
  ~SourceLocScope() {
    if (Enabled)
      Ctx->SourceLocDefaultExpr = nullptr;
  }
 
private:
  Compiler<Emitter> *Ctx;
  bool Enabled = false;
};
 
template <class Emitter> class InitLinkScope final {
public:
  InitLinkScope(Compiler<Emitter> *Ctx, InitLink &&Link) : Ctx(Ctx) {
    Ctx->InitStack.push_back(std::move(Link));
  }
 
  ~InitLinkScope() { this->Ctx->InitStack.pop_back(); }
 
public:
  Compiler<Emitter> *Ctx;
};
 
template <class Emitter> class InitStackScope final {
public:
  InitStackScope(Compiler<Emitter> *Ctx, bool Active)
      : Ctx(Ctx), OldValue(Ctx->InitStackActive), Active(Active) {
    // An explicit initializer nested in a default member initializer still
    // needs the surrounding default initializer's `this` reconstruction.
    Ctx->InitStackActive = OldValue || Active;
    if (Active)
      Ctx->InitStack.push_back(InitLink::DIE());
  }
 
  ~InitStackScope() {
    this->Ctx->InitStackActive = OldValue;
    if (Active)
      Ctx->InitStack.pop_back();
  }
 
private:
  Compiler<Emitter> *Ctx;
  bool OldValue;
  bool Active;
};
 
/// Scope used to handle temporaries in toplevel variable declarations.
template <class Emitter> class DeclScope final : public LocalScope<Emitter> {
public:
  DeclScope(Compiler<Emitter> *Ctx, const VarDecl *VD)
      : LocalScope<Emitter>(Ctx), Scope(Ctx->P),
        OldInitializingDecl(Ctx->InitializingDecl) {
    Ctx->InitializingDecl = VD;
    Ctx->InitStack.push_back(InitLink::Decl(VD));
  }
 
  ~DeclScope() {
    this->Ctx->InitializingDecl = OldInitializingDecl;
    this->Ctx->InitStack.pop_back();
  }
 
private:
  Program::DeclScope Scope;
  const VarDecl *OldInitializingDecl;
};
 
/// Scope used to handle initialization methods.
template <class Emitter> class OptionScope final {
public:
  /// Root constructor, compiling or discarding primitives.
  OptionScope(Compiler<Emitter> *Ctx, bool NewDiscardResult,
              bool NewInitializing, bool NewToLValue)
      : Ctx(Ctx), OldDiscardResult(Ctx->DiscardResult),
        OldInitializing(Ctx->Initializing), OldToLValue(Ctx->ToLValue) {
    Ctx->DiscardResult = NewDiscardResult;
    Ctx->Initializing = NewInitializing;
    Ctx->ToLValue = NewToLValue;
  }
 
  ~OptionScope() {
    Ctx->DiscardResult = OldDiscardResult;
    Ctx->Initializing = OldInitializing;
    Ctx->ToLValue = OldToLValue;
  }
 
private:
  /// Parent context.
  Compiler<Emitter> *Ctx;
  /// Old discard flag to restore.
  bool OldDiscardResult;
  bool OldInitializing;
  bool OldToLValue;
};
 
template <class Emitter>
bool InitLink::emit(Compiler<Emitter> *Ctx, const Expr *E) const {
  switch (Kind) {
  case K_This:
    return Ctx->emitThis(E);
  case K_Field:
    // We're assuming there's a base pointer on the stack already.
    return Ctx->emitGetPtrFieldPop(Offset, E);
  case K_Base:
    return Ctx->emitGetPtrBasePop(Offset, false, E);
  case K_Temp:
    return Ctx->emitGetPtrLocal(Offset, E);
  case K_Decl:
    return Ctx->visitDeclRef(D, E);
  case K_Elem:
    if (!Ctx->emitConstUint32(Offset, E))
      return false;
    return Ctx->emitArrayElemPtrPopUint32(E);
  case K_RVO:
    return Ctx->emitRVOPtr(E);
  case K_InitList:
    return true;
  default:
    llvm_unreachable("Unhandled InitLink kind");
  }
  return true;
}
 
/// Sets the context for break/continue statements.
template <class Emitter> class LoopScope final {
public:
  using LabelTy = typename Compiler<Emitter>::LabelTy;
  using OptLabelTy = typename Compiler<Emitter>::OptLabelTy;
  using LabelInfo = typename Compiler<Emitter>::LabelInfo;
 
  LoopScope(Compiler<Emitter> *Ctx, const Stmt *Name, LabelTy BreakLabel,
            LabelTy ContinueLabel)
      : Ctx(Ctx) {
#ifndef NDEBUG
    for (const LabelInfo &LI : Ctx->LabelInfoStack)
      assert(LI.Name != Name);
#endif
 
    this->Ctx->LabelInfoStack.emplace_back(Name, BreakLabel, ContinueLabel,
                                           /*DefaultLabel=*/std::nullopt,
                                           Ctx->VarScope);
  }
 
  ~LoopScope() { this->Ctx->LabelInfoStack.pop_back(); }
 
private:
  Compiler<Emitter> *Ctx;
};
 
// Sets the context for a switch scope, mapping labels.
template <class Emitter> class SwitchScope final {
public:
  using LabelTy = typename Compiler<Emitter>::LabelTy;
  using OptLabelTy = typename Compiler<Emitter>::OptLabelTy;
  using CaseMap = typename Compiler<Emitter>::CaseMap;
  using LabelInfo = typename Compiler<Emitter>::LabelInfo;
 
  SwitchScope(Compiler<Emitter> *Ctx, const Stmt *Name, CaseMap &&CaseLabels,
              LabelTy BreakLabel, OptLabelTy DefaultLabel)
      : Ctx(Ctx), OldCaseLabels(std::move(this->Ctx->CaseLabels)) {
#ifndef NDEBUG
    for (const LabelInfo &LI : Ctx->LabelInfoStack)
      assert(LI.Name != Name);
#endif
 
    this->Ctx->CaseLabels = std::move(CaseLabels);
    this->Ctx->LabelInfoStack.emplace_back(Name, BreakLabel,
                                           /*ContinueLabel=*/std::nullopt,
                                           DefaultLabel, Ctx->VarScope);
  }
 
  ~SwitchScope() {
    this->Ctx->CaseLabels = std::move(OldCaseLabels);
    this->Ctx->LabelInfoStack.pop_back();
  }
 
private:
  Compiler<Emitter> *Ctx;
  CaseMap OldCaseLabels;
};
 
/// When generating code for e.g. implicit field initializers in constructors,
/// we don't have anything to point to in case the initializer causes an error.
/// In that case, we need to disable location tracking for the initializer so
/// we later point to the call range instead.
template <class Emitter> class LocOverrideScope final {
public:
  LocOverrideScope(Compiler<Emitter> *Ctx, SourceInfo NewValue,
                   bool Enabled = true)
      : Ctx(Ctx), OldFlag(Ctx->LocOverride), Enabled(Enabled) {
 
    if (Enabled)
      Ctx->LocOverride = NewValue;
  }
 
  ~LocOverrideScope() {
    if (Enabled)
      Ctx->LocOverride = OldFlag;
  }
 
private:
  Compiler<Emitter> *Ctx;
  std::optional<SourceInfo> OldFlag;
  bool Enabled;
};
 
} // namespace interp
} // namespace clang
 
template <class Emitter>
bool Compiler<Emitter>::VisitCastExpr(const CastExpr *E) {
  const Expr *SubExpr = E->getSubExpr();
 
  if (DiscardResult)
    return this->delegate(SubExpr);
 
  switch (E->getCastKind()) {
  case CK_LValueToRValue: {
    // This *could* work I guess, but the current interpreter rejects (via
    // checkLiteralType).
    if (!Ctx.getLangOpts().HLSL && E->getType()->isConstantMatrixType())
      return false;
 
    if (ToLValue && E->getType()->isPointerType()) {
      assert(!DiscardResult);
      if (!this->visit(SubExpr))
        return false;
      return this->emitLoadPopL(E);
    }
 
    if (SubExpr->getType().isVolatileQualified())
      return this->emitInvalidCast(CastKind::Volatile, /*Fatal=*/true, E);
 
    OptPrimType SubExprT = classify(SubExpr->getType());
    // Try to load the value directly. This is purely a performance
    // optimization.
    if (SubExprT) {
      if (const auto *DRE = dyn_cast<DeclRefExpr>(SubExpr)) {
        const ValueDecl *D = DRE->getDecl();
        bool IsReference = D->getType()->isReferenceType();
 
        if (!IsReference) {
          if (Context::shouldBeGloballyIndexed(D)) {
            if (auto GlobalIndex = P.getGlobal(D))
              return this->emitGetGlobal(*SubExprT, *GlobalIndex, E);
          } else if (auto It = Locals.find(D); It != Locals.end()) {
            return this->emitGetLocal(*SubExprT, It->second.Offset, E);
          } else if (const auto *PVD = dyn_cast<ParmVarDecl>(D)) {
            if (auto It = this->Params.find(PVD); It != this->Params.end()) {
              return this->emitGetParam(*SubExprT, It->second.Index, E);
            }
          }
        }
      }
    }
 
    // Prepare storage for the result.
    if (!Initializing && !SubExprT) {
      UnsignedOrNone LocalIndex = allocateLocal(SubExpr);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
 
    if (!this->visit(SubExpr))
      return false;
 
    if (SubExprT)
      return this->emitLoadPop(*SubExprT, E);
 
    // If the subexpr type is not primitive, we need to perform a copy here.
    // This happens for example in C when dereferencing a pointer of struct
    // type.
    return this->emitMemcpy(E);
  }
 
  case CK_DerivedToBaseMemberPointer: {
    if (E->containsErrors())
      return false;
    assert(classifyPrim(E) == PT_MemberPtr);
    assert(classifyPrim(SubExpr) == PT_MemberPtr);
 
    if (!this->delegate(SubExpr))
      return false;
 
    const CXXRecordDecl *CurDecl = SubExpr->getType()
                                       ->castAs<MemberPointerType>()
                                       ->getMostRecentCXXRecordDecl();
    for (const CXXBaseSpecifier *B : E->path()) {
      const CXXRecordDecl *ToDecl = B->getType()->getAsCXXRecordDecl();
      unsigned DerivedOffset = Ctx.collectBaseOffset(ToDecl, CurDecl);
 
      if (!this->emitCastMemberPtrBasePop(DerivedOffset, ToDecl, E))
        return false;
      CurDecl = ToDecl;
    }
 
    return true;
  }
 
  case CK_BaseToDerivedMemberPointer: {
    if (E->containsErrors())
      return false;
    assert(classifyPrim(E) == PT_MemberPtr);
    assert(classifyPrim(SubExpr) == PT_MemberPtr);
 
    if (!this->delegate(SubExpr))
      return false;
 
    const CXXRecordDecl *CurDecl = SubExpr->getType()
                                       ->castAs<MemberPointerType>()
                                       ->getMostRecentCXXRecordDecl();
    // 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> ReverseIter;
    for (ReverseIter PathI(E->path_end() - 1), PathE(E->path_begin());
         PathI != PathE; ++PathI) {
      const CXXRecordDecl *ToDecl = (*PathI)->getType()->getAsCXXRecordDecl();
      unsigned DerivedOffset = Ctx.collectBaseOffset(CurDecl, ToDecl);
 
      if (!this->emitCastMemberPtrDerivedPop(-DerivedOffset, ToDecl, E))
        return false;
      CurDecl = ToDecl;
    }
 
    const CXXRecordDecl *ToDecl =
        E->getType()->castAs<MemberPointerType>()->getMostRecentCXXRecordDecl();
    assert(ToDecl != CurDecl);
    unsigned DerivedOffset = Ctx.collectBaseOffset(CurDecl, ToDecl);
 
    if (!this->emitCastMemberPtrDerivedPop(-DerivedOffset, ToDecl, E))
      return false;
 
    return true;
  }
 
  case CK_UncheckedDerivedToBase:
  case CK_DerivedToBase: {
    if (!this->delegate(SubExpr))
      return false;
 
    const auto extractRecordDecl = [](QualType Ty) -> const CXXRecordDecl * {
      if (const auto *PT = dyn_cast<PointerType>(Ty))
        return PT->getPointeeType()->getAsCXXRecordDecl();
      return Ty->getAsCXXRecordDecl();
    };
 
    // FIXME: We can express a series of non-virtual casts as a single
    // GetPtrBasePop op.
    QualType CurType = SubExpr->getType();
    for (const CXXBaseSpecifier *B : E->path()) {
      if (B->isVirtual()) {
        if (!this->emitGetPtrVirtBasePop(extractRecordDecl(B->getType()), E))
          return false;
        CurType = B->getType();
      } else {
        unsigned DerivedOffset = collectBaseOffset(B->getType(), CurType);
        if (!this->emitGetPtrBasePop(
                DerivedOffset, /*NullOK=*/E->getType()->isPointerType(), E))
          return false;
        CurType = B->getType();
      }
    }
 
    return true;
  }
 
  case CK_BaseToDerived: {
    if (!this->delegate(SubExpr))
      return false;
 
    auto unwrapPointerType = [](const Type *T) -> const Type * {
      if (T->isPointerOrReferenceType())
        return T->getPointeeType().getTypePtr();
      return T;
    };
 
    bool NullOK = false;
    const Type *FinalType = E->getType().getTypePtr();
    if (FinalType->isPointerOrReferenceType()) {
      NullOK = true;
      FinalType = FinalType->getPointeeType().getTypePtr();
    }
 
    for (const CXXBaseSpecifier *B :
         llvm::drop_begin(llvm::reverse(E->path()))) {
      const Type *TargetType = unwrapPointerType(B->getType().getTypePtr());
      if (!this->emitGetPtrDerivedPop(NullOK, TargetType, FinalType, E))
        return false;
    }
 
    return this->emitGetPtrDerivedPop(NullOK, FinalType, FinalType, E);
  }
 
  case CK_FloatingCast: {
    // HLSL uses CK_FloatingCast to cast between vectors.
    if (E->getType()->isVectorType())
      return this->emitVectorConversion(E->getSubExpr(), E);
    if (!SubExpr->getType()->isFloatingType() ||
        !E->getType()->isFloatingType())
      return false;
    if (!this->visit(SubExpr))
      return false;
    const auto *TargetSemantics = &Ctx.getFloatSemantics(E->getType());
    return this->emitCastFP(TargetSemantics, getRoundingMode(E), E);
  }
 
  case CK_IntegralToFloating: {
    if (E->getType()->isVectorType())
      return this->emitVectorConversion(E->getSubExpr(), E);
    if (!E->getType()->isRealFloatingType())
      return false;
    if (!this->visit(SubExpr))
      return false;
    const auto *TargetSemantics = &Ctx.getFloatSemantics(E->getType());
    return this->emitCastIntegralFloating(classifyPrim(SubExpr),
                                          TargetSemantics, getFPOptions(E), E);
  }
 
  case CK_FloatingToBoolean: {
    if (E->getType()->isVectorType())
      return this->emitVectorConversion(E->getSubExpr(), E);
    if (!SubExpr->getType()->isRealFloatingType() ||
        !E->getType()->hasBooleanRepresentation())
      return false;
    if (const auto *FL = dyn_cast<FloatingLiteral>(SubExpr))
      return this->emitConstBool(FL->getValue().isNonZero(), E);
    if (!this->visit(SubExpr))
      return false;
    return this->emitCastFloatingIntegralBool(getFPOptions(E), E);
  }
 
  case CK_FloatingToIntegral: {
    if (E->getType()->isVectorType())
      return this->emitVectorConversion(E->getSubExpr(), E);
    if (!E->getType()->isIntegralOrEnumerationType())
      return false;
    if (!this->visit(SubExpr))
      return false;
    PrimType ToT = classifyPrim(E);
    if (ToT == PT_IntAP)
      return this->emitCastFloatingIntegralAP(Ctx.getBitWidth(E->getType()),
                                              getFPOptions(E), E);
    if (ToT == PT_IntAPS)
      return this->emitCastFloatingIntegralAPS(Ctx.getBitWidth(E->getType()),
                                               getFPOptions(E), E);
 
    return this->emitCastFloatingIntegral(ToT, getFPOptions(E), E);
  }
 
  case CK_NullToPointer:
  case CK_NullToMemberPointer: {
    if (!this->discard(SubExpr))
      return false;
    uint64_t Val = Ctx.getASTContext().getTargetNullPointerValue(E->getType());
    return this->emitNull(classifyPrim(E->getType()), Val,
                          E->getType().getTypePtr(), E);
  }
 
  case CK_PointerToIntegral: {
    if (!this->visit(SubExpr))
      return false;
 
    // If SubExpr doesn't result in a pointer, make it one.
    if (PrimType FromT = classifyPrim(SubExpr->getType()); FromT != PT_Ptr) {
      assert(isPtrType(FromT));
      if (!this->emitDecayPtr(FromT, PT_Ptr, E))
        return false;
    }
 
    PrimType T = classifyPrim(E->getType());
    if (T == PT_IntAP)
      return this->emitCastPointerIntegralAP(Ctx.getBitWidth(E->getType()), E);
    if (T == PT_IntAPS)
      return this->emitCastPointerIntegralAPS(Ctx.getBitWidth(E->getType()), E);
    return this->emitCastPointerIntegral(T, E);
  }
 
  case CK_ArrayToPointerDecay: {
    if (!this->visit(SubExpr))
      return false;
    return this->emitArrayDecay(E);
  }
 
  case CK_IntegralToPointer: {
    QualType IntType = SubExpr->getType();
    assert(IntType->isIntegralOrEnumerationType());
    if (!this->visit(SubExpr))
      return false;
    // FIXME: I think the discard is wrong since the int->ptr cast might cause a
    // diagnostic.
    PrimType T = classifyPrim(IntType);
    if (!this->emitGetIntPtr(T, E->getType().getTypePtr(), E))
      return false;
 
    QualType PtrType = E->getType();
    PrimType DestPtrT = classifyPrim(PtrType);
    if (DestPtrT == PT_Ptr)
      return true;
 
    // In case we're converting the integer to a non-Pointer.
    return this->emitDecayPtr(PT_Ptr, DestPtrT, E);
  }
 
  case CK_AtomicToNonAtomic:
  case CK_ConstructorConversion:
  case CK_FunctionToPointerDecay:
  case CK_NonAtomicToAtomic:
  case CK_NoOp:
  case CK_UserDefinedConversion:
  case CK_CPointerToObjCPointerCast:
    return this->delegate(SubExpr);
 
  case CK_AddressSpaceConversion: {
    if (E->containsErrors())
      return false;
 
    if (!this->visit(SubExpr))
      return false;
 
    uint64_t Val;
    if (E->getType()->isPointerType())
      Val = Ctx.getASTContext().getTargetNullPointerValue(E->getType());
    else
      Val = 0;
 
    if (!this->emitCastAddressSpace(Val, E->getType().getTypePtr(), E))
      return false;
    if (DiscardResult)
      return this->emitPopPtr(E);
    return true;
  }
 
  case CK_BitCast: {
    if (E->containsErrors())
      return false;
    QualType ETy = E->getType();
    // Reject bitcasts to atomic types.
    if (ETy->isAtomicType()) {
      if (!this->discard(SubExpr))
        return false;
      return this->emitInvalidCast(CastKind::Reinterpret, /*Fatal=*/true, E);
    }
    QualType SubExprTy = SubExpr->getType();
    OptPrimType FromT = classify(SubExprTy);
    // Casts from integer/vector to vector.
    if (E->getType()->isVectorType())
      return this->emitBuiltinBitCast(E);
 
    OptPrimType ToT = classify(E->getType());
    if (!FromT || !ToT)
      return false;
 
    assert(isPtrType(*FromT));
    assert(isPtrType(*ToT));
    bool SrcIsVoidPtr = SubExprTy->isVoidPointerType();
    if (FromT == ToT) {
      if (E->getType()->isVoidPointerType() &&
          !SubExprTy->isFunctionPointerType()) {
        return this->delegate(SubExpr);
      }
 
      if (!this->visit(SubExpr))
        return false;
      if (!this->emitCheckBitCast(ETy->getPointeeType().getTypePtr(),
                                  SrcIsVoidPtr, E))
        return false;
 
      if (E->getType()->isFunctionPointerType() ||
          SubExprTy->isFunctionPointerType()) {
        return this->emitFnPtrCast(E);
      }
      if (FromT == PT_Ptr)
        return this->emitPtrPtrCast(SubExprTy->isVoidPointerType(),
                                    E->getType().getTypePtr(), E);
      return true;
    }
 
    if (!this->visit(SubExpr))
      return false;
    return this->emitDecayPtr(*FromT, *ToT, E);
  }
  case CK_IntegralToBoolean:
  case CK_FixedPointToBoolean: {
    if (E->getType()->isVectorType())
      return this->emitVectorConversion(E->getSubExpr(), E);
    // HLSL uses this to cast to one-element vectors.
    OptPrimType FromT = classify(SubExpr->getType());
    if (!FromT)
      return false;
 
    if (const auto *IL = dyn_cast<IntegerLiteral>(SubExpr))
      return this->emitConst(IL->getValue(), E);
    if (!this->visit(SubExpr))
      return false;
    return this->emitCast(*FromT, classifyPrim(E), E);
  }
 
  case CK_IntegralCast:
    if (E->getType()->isVectorType())
      return this->emitVectorConversion(E->getSubExpr(), E);
    [[fallthrough]];
  case CK_BooleanToSignedIntegral: {
    OptPrimType FromT = classify(SubExpr->getType());
    OptPrimType ToT = classify(E->getType());
    if (!FromT || !ToT)
      return false;
 
    // Try to emit a casted known constant value directly.
    if (const auto *IL = dyn_cast<IntegerLiteral>(SubExpr)) {
      if (ToT != PT_IntAP && ToT != PT_IntAPS && FromT != PT_IntAP &&
          FromT != PT_IntAPS && !E->getType()->isEnumeralType())
        return this->emitConst(APSInt(IL->getValue(), !isSignedType(*FromT)),
                               E);
      if (!this->emitConst(IL->getValue(), SubExpr))
        return false;
    } else {
      if (!this->visit(SubExpr))
        return false;
    }
 
    // Possibly diagnose casts to enum types if the target type does not
    // have a fixed size.
    if (Ctx.getLangOpts().CPlusPlus && E->getType()->isEnumeralType()) {
      const auto *ED = E->getType()->castAsEnumDecl();
      if (!ED->isFixed()) {
        if (!this->emitCheckEnumValue(*FromT, ED, E))
          return false;
      }
    }
 
    if (ToT == PT_IntAP) {
      if (!this->emitCastAP(*FromT, Ctx.getBitWidth(E->getType()), E))
        return false;
    } else if (ToT == PT_IntAPS) {
      if (!this->emitCastAPS(*FromT, Ctx.getBitWidth(E->getType()), E))
        return false;
    } else {
      if (FromT == ToT)
        return true;
      if (!this->emitCast(*FromT, *ToT, E))
        return false;
    }
    if (E->getCastKind() == CK_BooleanToSignedIntegral)
      return this->emitNeg(*ToT, E);
    return true;
  }
 
  case CK_PointerToBoolean:
    if (!this->visit(SubExpr))
      return false;
    return this->emitIsNonNullPtr(E);
 
  case CK_MemberPointerToBoolean:
    if (!this->visit(SubExpr))
      return false;
    return this->emitIsNonNullMemberPtr(E);
 
  case CK_IntegralComplexToBoolean:
  case CK_FloatingComplexToBoolean: {
    if (!this->visit(SubExpr))
      return false;
    return this->emitComplexBoolCast(SubExpr);
  }
 
  case CK_IntegralComplexToReal:
  case CK_FloatingComplexToReal:
    return this->emitComplexReal(SubExpr);
 
  case CK_IntegralRealToComplex:
  case CK_FloatingRealToComplex: {
    // We're creating a complex value here, so we need to
    // allocate storage for it.
    if (!Initializing) {
      UnsignedOrNone LocalIndex = allocateTemporary(E);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
 
    PrimType T = classifyPrim(SubExpr->getType());
    // Init the complex value to {SubExpr, 0}.
    if (!this->visitArrayElemInit(0, SubExpr, T))
      return false;
    // Zero-init the second element.
    if (!this->visitZeroInitializer(T, SubExpr->getType(), SubExpr))
      return false;
    return this->emitInitElem(T, 1, SubExpr);
  }
 
  case CK_IntegralComplexCast:
  case CK_FloatingComplexCast:
  case CK_IntegralComplexToFloatingComplex:
  case CK_FloatingComplexToIntegralComplex: {
    assert(E->getType()->isAnyComplexType());
    assert(SubExpr->getType()->isAnyComplexType());
    if (!Initializing) {
      UnsignedOrNone LocalIndex = allocateLocal(E);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
 
    // Location for the SubExpr.
    // Since SubExpr is of complex type, visiting it results in a pointer
    // anyway, so we just create a temporary pointer variable.
    unsigned SubExprOffset =
        allocateLocalPrimitive(SubExpr, PT_Ptr, /*IsConst=*/true);
    if (!this->visit(SubExpr))
      return false;
    if (!this->emitSetLocal(PT_Ptr, SubExprOffset, E))
      return false;
 
    PrimType SourceElemT = classifyComplexElementType(SubExpr->getType());
    QualType DestElemType =
        E->getType()->getAs<ComplexType>()->getElementType();
    PrimType DestElemT = classifyPrim(DestElemType);
    // Cast both elements individually.
    for (unsigned I = 0; I != 2; ++I) {
      if (!this->emitGetLocal(PT_Ptr, SubExprOffset, E))
        return false;
      if (!this->emitArrayElemPop(SourceElemT, I, E))
        return false;
 
      // Do the cast.
      if (!this->emitPrimCast(SourceElemT, DestElemT, DestElemType, E))
        return false;
 
      // Save the value.
      if (!this->emitInitElem(DestElemT, I, E))
        return false;
    }
    return true;
  }
 
  case CK_VectorSplat: {
    assert(!canClassify(E->getType()));
    assert(E->getType()->isVectorType());
 
    if (!canClassify(SubExpr->getType()))
      return false;
 
    if (!Initializing) {
      UnsignedOrNone LocalIndex = allocateLocal(E);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
 
    const auto *VT = E->getType()->getAs<VectorType>();
    PrimType ElemT = classifyPrim(SubExpr->getType());
    unsigned ElemOffset =
        allocateLocalPrimitive(SubExpr, ElemT, /*IsConst=*/true);
 
    // Prepare a local variable for the scalar value.
    if (!this->visit(SubExpr))
      return false;
    if (classifyPrim(SubExpr) == PT_Ptr && !this->emitLoadPop(ElemT, E))
      return false;
 
    if (!this->emitSetLocal(ElemT, ElemOffset, E))
      return false;
 
    for (unsigned I = 0; I != VT->getNumElements(); ++I) {
      if (!this->emitGetLocal(ElemT, ElemOffset, E))
        return false;
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
 
    return true;
  }
 
  case CK_HLSLVectorTruncation: {
    assert(SubExpr->getType()->isVectorType());
    if (OptPrimType ResultT = classify(E)) {
      assert(!DiscardResult);
      // Result must be either a float or integer. Take the first element.
      if (!this->visit(SubExpr))
        return false;
      return this->emitArrayElemPop(*ResultT, 0, E);
    }
    // Otherwise, this truncates from one vector type to another.
    assert(E->getType()->isVectorType());
 
    if (!Initializing) {
      UnsignedOrNone LocalIndex = allocateTemporary(E);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
    unsigned ToSize = E->getType()->getAs<VectorType>()->getNumElements();
    assert(SubExpr->getType()->getAs<VectorType>()->getNumElements() > ToSize);
    if (!this->visit(SubExpr))
      return false;
    return this->emitCopyArray(classifyVectorElementType(E->getType()), 0, 0,
                               ToSize, E);
  };
 
  case CK_IntegralToFixedPoint: {
    if (!this->visit(SubExpr))
      return false;
 
    auto Sem =
        Ctx.getASTContext().getFixedPointSemantics(E->getType()).toOpaqueInt();
    if (!this->emitCastIntegralFixedPoint(classifyPrim(SubExpr->getType()), Sem,
                                          E))
      return false;
    if (DiscardResult)
      return this->emitPopFixedPoint(E);
    return true;
  }
  case CK_FloatingToFixedPoint: {
    if (!this->visit(SubExpr))
      return false;
 
    auto Sem =
        Ctx.getASTContext().getFixedPointSemantics(E->getType()).toOpaqueInt();
    if (!this->emitCastFloatingFixedPoint(Sem, E))
      return false;
    if (DiscardResult)
      return this->emitPopFixedPoint(E);
    return true;
  }
  case CK_FixedPointToFloating: {
    if (!this->visit(SubExpr))
      return false;
    const auto *TargetSemantics = &Ctx.getFloatSemantics(E->getType());
    if (!this->emitCastFixedPointFloating(TargetSemantics, E))
      return false;
    if (DiscardResult)
      return this->emitPopFloat(E);
    return true;
  }
  case CK_FixedPointToIntegral: {
    if (!this->visit(SubExpr))
      return false;
    PrimType IntegralT = classifyPrim(E->getType());
    if (!this->emitCastFixedPointIntegral(IntegralT, E))
      return false;
    if (DiscardResult)
      return this->emitPop(IntegralT, E);
    return true;
  }
  case CK_FixedPointCast: {
    if (!this->visit(SubExpr))
      return false;
    auto Sem =
        Ctx.getASTContext().getFixedPointSemantics(E->getType()).toOpaqueInt();
    if (!this->emitCastFixedPoint(Sem, E))
      return false;
    if (DiscardResult)
      return this->emitPopFixedPoint(E);
    return true;
  }
 
  case CK_ToVoid:
    return discard(SubExpr);
 
  case CK_Dynamic:
    llvm_unreachable("CXXDynamicCastExpr has its own function");
 
  case CK_LValueBitCast:
    if (!this->emitInvalidCast(CastKind::ReinterpretLike, /*Fatal=*/false, E))
      return false;
    return this->delegate(SubExpr);
 
  case CK_HLSLArrayRValue: {
    // Non-decaying array rvalue cast - creates an rvalue copy of an lvalue
    // array, similar to LValueToRValue for composite types.
    if (!Initializing) {
      UnsignedOrNone LocalIndex = allocateLocal(E);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
    if (!this->visit(SubExpr))
      return false;
    return this->emitMemcpy(E);
  }
 
  case CK_HLSLMatrixTruncation: {
    assert(SubExpr->getType()->isConstantMatrixType());
    if (OptPrimType ResultT = classify(E)) {
      assert(!DiscardResult);
      // Result must be either a float or integer. Take the first element.
      if (!this->visit(SubExpr))
        return false;
      return this->emitArrayElemPop(*ResultT, 0, E);
    }
    // Otherwise, this truncates to a a constant matrix type.
    assert(E->getType()->isConstantMatrixType());
 
    if (!Initializing) {
      UnsignedOrNone LocalIndex = allocateTemporary(E);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
    unsigned ToSize =
        E->getType()->getAs<ConstantMatrixType>()->getNumElementsFlattened();
    if (!this->visit(SubExpr))
      return false;
    return this->emitCopyArray(classifyMatrixElementType(SubExpr->getType()), 0,
                               0, ToSize, E);
  }
 
  case CK_HLSLAggregateSplatCast: {
    // Aggregate splat cast: convert a scalar value to one of an aggregate type
    // by replicating and casting the scalar to every element of the destination
    // aggregate (vector, matrix, array, or struct).
    assert(canClassify(SubExpr->getType()));
 
    if (!Initializing) {
      UnsignedOrNone LocalIndex = allocateLocal(E);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
 
    // The scalar to be splatted is stored in a local to be repeatedly loaded
    // once for every scalar element of the destination.
    PrimType SrcElemT = classifyPrim(SubExpr->getType());
    unsigned SrcOffset =
        allocateLocalPrimitive(SubExpr, SrcElemT, /*IsConst=*/true);
 
    if (!this->visit(SubExpr))
      return false;
    if (!this->emitSetLocal(SrcElemT, SrcOffset, E))
      return false;
 
    // Recursively splat the scalar into every element of the destination.
    return emitHLSLAggregateSplat(SrcElemT, SrcOffset, E->getType(), E);
  }
 
  case CK_HLSLElementwiseCast: {
    // Elementwise cast: flatten the elements of one aggregate source type and
    // store to a destination scalar or aggregate type of the same or fewer
    // number of elements. Casts are inserted element-wise to convert each
    // source scalar element to its corresponding destination scalar element.
    QualType SrcType = SubExpr->getType();
    QualType DestType = E->getType();
 
    if (OptPrimType DestT = classify(DestType)) {
      // When the destination is a scalar, we only need the first scalar
      // element of the source.
      unsigned SrcPtrOffset =
          allocateLocalPrimitive(SubExpr, PT_Ptr, /*IsConst=*/true);
      if (!this->visit(SubExpr))
        return false;
      if (!this->emitSetLocal(PT_Ptr, SrcPtrOffset, E))
        return false;
 
      SmallVector<HLSLFlatElement, 1> Elements;
      if (!emitHLSLFlattenAggregate(SrcType, SrcPtrOffset, Elements, 1, E))
        return false;
      if (Elements.empty())
        return false;
 
      const HLSLFlatElement &Src = Elements[0];
      if (!this->emitGetLocal(Src.Type, Src.LocalOffset, E))
        return false;
      return this->emitPrimCast(Src.Type, *DestT, DestType, E);
    }
 
    if (!Initializing) {
      UnsignedOrNone LocalIndex = allocateLocal(E);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
 
    unsigned SrcOffset =
        allocateLocalPrimitive(SubExpr, PT_Ptr, /*IsConst=*/true);
    if (!this->visit(SubExpr))
      return false;
    if (!this->emitSetLocal(PT_Ptr, SrcOffset, E))
      return false;
 
    // Only flatten as many source elements as the destination requires.
    unsigned ElemCount = countHLSLFlatElements(DestType);
 
    SmallVector<HLSLFlatElement, 16> Elements;
    Elements.reserve(ElemCount);
    if (!emitHLSLFlattenAggregate(SrcType, SrcOffset, Elements, ElemCount, E))
      return false;
 
    // Sema is expected to reject an elementwise cast whose source has fewer
    // scalar elements than the destination.
    assert(Elements.size() == ElemCount &&
           "Source type has fewer scalar elements than the destination type");
 
    return emitHLSLConstructAggregate(DestType, Elements, E);
  }
 
  case CK_ToUnion: {
    const FieldDecl *UnionField = E->getTargetUnionField();
    const Record *R = this->getRecord(E->getType());
    assert(R);
    const Record::Field *RF = R->getField(UnionField);
 
    if (OptPrimType PT = RF->T) {
      if (!this->visit(SubExpr))
        return false;
      if (RF->isBitField())
        return this->emitInitBitFieldActivate(*PT, RF->Offset, RF->bitWidth(),
                                              E);
      return this->emitInitFieldActivate(*PT, RF->Offset, E);
    }
 
    if (!this->emitGetPtrField(RF->Offset, E))
      return false;
    if (!this->emitActivate(E))
      return false;
    return this->visitInitializerPop(SubExpr);
  }
 
  default:
    return this->emitInvalid(E);
  }
  llvm_unreachable("Unhandled clang::CastKind enum");
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E) {
  return this->emitBuiltinBitCast(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitIntegerLiteral(const IntegerLiteral *LE) {
  if (DiscardResult)
    return true;
 
  return this->emitConst(LE->getValue(), LE);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitFloatingLiteral(const FloatingLiteral *E) {
  if (DiscardResult)
    return true;
 
  APFloat F = E->getValue();
  return this->emitFloat(F, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitImaginaryLiteral(const ImaginaryLiteral *E) {
  assert(E->getType()->isAnyComplexType());
  if (DiscardResult)
    return true;
 
  if (!Initializing) {
    UnsignedOrNone LocalIndex = allocateTemporary(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
 
  const Expr *SubExpr = E->getSubExpr();
  PrimType SubExprT = classifyPrim(SubExpr->getType());
 
  if (!this->visitZeroInitializer(SubExprT, SubExpr->getType(), SubExpr))
    return false;
  if (!this->emitInitElem(SubExprT, 0, SubExpr))
    return false;
  return this->visitArrayElemInit(1, SubExpr, SubExprT);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitFixedPointLiteral(const FixedPointLiteral *E) {
  assert(E->getType()->isFixedPointType());
  assert(classifyPrim(E) == PT_FixedPoint);
 
  if (DiscardResult)
    return true;
 
  auto Sem = Ctx.getASTContext().getFixedPointSemantics(E->getType());
  APInt Value = E->getValue();
  return this->emitConstFixedPoint(FixedPoint(Value, Sem), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitParenExpr(const ParenExpr *E) {
  return this->delegate(E->getSubExpr());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitBinaryOperator(const BinaryOperator *E) {
  // Need short-circuiting for these.
  if (E->isLogicalOp() && !E->getType()->isVectorType())
    return this->VisitLogicalBinOp(E);
 
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
 
  // Handle comma operators. Just discard the LHS
  // and delegate to RHS.
  if (E->isCommaOp()) {
    if (!this->discard(LHS))
      return false;
    if (RHS->getType()->isVoidType())
      return this->discard(RHS);
 
    return this->delegate(RHS);
  }
 
  if (E->getType()->isAnyComplexType())
    return this->VisitComplexBinOp(E);
  if (E->getType()->isVectorType())
    return this->VisitVectorBinOp(E);
  if ((LHS->getType()->isAnyComplexType() ||
       RHS->getType()->isAnyComplexType()) &&
      E->isComparisonOp())
    return this->emitComplexComparison(LHS, RHS, E);
  if (LHS->getType()->isFixedPointType() || RHS->getType()->isFixedPointType())
    return this->VisitFixedPointBinOp(E);
 
  if (E->isPtrMemOp()) {
    if (E->containsErrors())
      return false;
 
    if (!this->visit(LHS))
      return false;
 
    if (!this->visit(RHS))
      return false;
 
    if (!this->emitToMemberPtr(E))
      return false;
 
    if (classifyPrim(E) == PT_MemberPtr)
      return true;
 
    if (!this->emitCastMemberPtrPtr(E))
      return false;
    return DiscardResult ? this->emitPopPtr(E) : true;
  }
 
  // Typecheck the args.
  OptPrimType LT = classify(LHS);
  OptPrimType RT = classify(RHS);
  OptPrimType T = classify(E->getType());
 
  // Special case for C++'s three-way/spaceship operator <=>, which
  // returns a std::{strong,weak,partial}_ordering (which is a class, so doesn't
  // have a PrimType).
  if (!T && E->getOpcode() == BO_Cmp) {
    if (DiscardResult)
      return true;
    const ComparisonCategoryInfo *CmpInfo =
        Ctx.getASTContext().CompCategories.lookupInfoForType(E->getType());
    assert(CmpInfo);
 
    // We need a temporary variable holding our return value.
    if (!Initializing) {
      UnsignedOrNone ResultIndex = this->allocateLocal(E);
      if (!this->emitGetPtrLocal(*ResultIndex, E))
        return false;
    }
 
    if (!visit(LHS) || !visit(RHS))
      return false;
 
    return this->emitCMP3(*LT, CmpInfo, E);
  }
 
  if (!LT || !RT || !T)
    return false;
 
  // Pointer arithmetic special case.
  if (E->getOpcode() == BO_Add || E->getOpcode() == BO_Sub) {
    if (isPtrType(*T) || (isPtrType(*LT) && isPtrType(*RT)))
      return this->VisitPointerArithBinOp(E);
  }
 
  if (E->getOpcode() == BO_Assign)
    return this->visitAssignment(LHS, RHS, E);
 
  if (!visit(LHS) || !visit(RHS))
    return false;
 
  // For languages such as C, cast the result of one
  // of our comparision opcodes to T (which is usually int).
  auto MaybeCastToBool = [this, T, E](bool Result) {
    if (!Result)
      return false;
    if (DiscardResult)
      return this->emitPopBool(E);
    if (T != PT_Bool)
      return this->emitCast(PT_Bool, *T, E);
    return true;
  };
 
  auto Discard = [this, T, E](bool Result) {
    if (!Result)
      return false;
    return DiscardResult ? this->emitPop(*T, E) : true;
  };
 
  switch (E->getOpcode()) {
  case BO_EQ:
    return MaybeCastToBool(this->emitEQ(*LT, E));
  case BO_NE:
    return MaybeCastToBool(this->emitNE(*LT, E));
  case BO_LT:
    return MaybeCastToBool(this->emitLT(*LT, E));
  case BO_LE:
    return MaybeCastToBool(this->emitLE(*LT, E));
  case BO_GT:
    return MaybeCastToBool(this->emitGT(*LT, E));
  case BO_GE:
    return MaybeCastToBool(this->emitGE(*LT, E));
  case BO_Sub:
    if (E->getType()->isFloatingType())
      return Discard(this->emitSubf(getFPOptions(E), E));
    return Discard(this->emitSub(*T, E));
  case BO_Add:
    if (E->getType()->isFloatingType())
      return Discard(this->emitAddf(getFPOptions(E), E));
    return Discard(this->emitAdd(*T, E));
  case BO_Mul:
    if (E->getType()->isFloatingType())
      return Discard(this->emitMulf(getFPOptions(E), E));
    return Discard(this->emitMul(*T, E));
  case BO_Rem:
    return Discard(this->emitRem(*T, E));
  case BO_Div:
    if (E->getType()->isFloatingType())
      return Discard(this->emitDivf(getFPOptions(E), E));
    return Discard(this->emitDiv(*T, E));
  case BO_And:
    return Discard(this->emitBitAnd(*T, E));
  case BO_Or:
    return Discard(this->emitBitOr(*T, E));
  case BO_Shl:
    return Discard(this->emitShl(*LT, *RT, E));
  case BO_Shr:
    return Discard(this->emitShr(*LT, *RT, E));
  case BO_Xor:
    return Discard(this->emitBitXor(*T, E));
  case BO_LOr:
  case BO_LAnd:
    llvm_unreachable("Already handled earlier");
  default:
    return false;
  }
 
  llvm_unreachable("Unhandled binary op");
}
 
/// Perform addition/subtraction of a pointer and an integer or
/// subtraction of two pointers.
template <class Emitter>
bool Compiler<Emitter>::VisitPointerArithBinOp(const BinaryOperator *E) {
  BinaryOperatorKind Op = E->getOpcode();
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
 
  if ((Op != BO_Add && Op != BO_Sub) ||
      (!LHS->getType()->isPointerType() && !RHS->getType()->isPointerType()))
    return false;
 
  OptPrimType LT = classify(LHS);
  OptPrimType RT = classify(RHS);
 
  if (!LT || !RT)
    return false;
 
  // Visit the given pointer expression and optionally convert to a PT_Ptr.
  auto visitAsPointer = [&](const Expr *E, PrimType T) -> bool {
    if (!this->visit(E))
      return false;
    if (T != PT_Ptr)
      return this->emitDecayPtr(T, PT_Ptr, E);
    return true;
  };
 
  if (LHS->getType()->isPointerType() && RHS->getType()->isPointerType()) {
    if (Op != BO_Sub)
      return false;
 
    assert(E->getType()->isIntegerType());
    if (!visitAsPointer(RHS, *RT) || !visitAsPointer(LHS, *LT))
      return false;
 
    QualType ElemType = LHS->getType()->getPointeeType();
    CharUnits ElemTypeSize;
    if (ElemType->isVoidType() || ElemType->isFunctionType())
      ElemTypeSize = CharUnits::One();
    else
      ElemTypeSize = Ctx.getASTContext().getTypeSizeInChars(ElemType);
 
    PrimType IntT = classifyPrim(E->getType());
    if (!this->emitSubPtr(IntT, ElemTypeSize.getQuantity(), E))
      return false;
    return DiscardResult ? this->emitPop(IntT, E) : true;
  }
 
  PrimType OffsetType;
  if (LHS->getType()->isIntegerType()) {
    if (!visitAsPointer(RHS, *RT))
      return false;
    if (!this->visit(LHS))
      return false;
    OffsetType = *LT;
  } else if (RHS->getType()->isIntegerType()) {
    if (!visitAsPointer(LHS, *LT))
      return false;
    if (!this->visit(RHS))
      return false;
    OffsetType = *RT;
  } else {
    return false;
  }
 
  // Do the operation and optionally transform to
  // result pointer type.
  switch (Op) {
  case BO_Add:
    if (!this->emitAddOffset(OffsetType, E))
      return false;
    break;
  case BO_Sub:
    if (!this->emitSubOffset(OffsetType, E))
      return false;
    break;
  default:
    return false;
  }
 
  PrimType ExprT = classifyPrim(E);
  if (ExprT != PT_Ptr) {
    if (!this->emitDecayPtr(PT_Ptr, ExprT, E))
      return false;
  }
 
  if (DiscardResult)
    return this->emitPop(ExprT, E);
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitLogicalBinOp(const BinaryOperator *E) {
  assert(E->isLogicalOp());
  BinaryOperatorKind Op = E->getOpcode();
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
 
  if (Op == BO_LOr) {
    // Logical OR. Visit LHS and only evaluate RHS if LHS was FALSE.
    LabelTy LabelTrue = this->getLabel();
    LabelTy LabelEnd = this->getLabel();
 
    if (!this->visitBool(LHS))
      return false;
    if (!this->jumpTrue(LabelTrue, E))
      return false;
 
    if (!this->visitBool(RHS))
      return false;
    if (!this->jump(LabelEnd, E))
      return false;
 
    this->emitLabel(LabelTrue);
    this->emitConstBool(true, E);
    this->fallthrough(LabelEnd);
    this->emitLabel(LabelEnd);
 
  } else {
    assert(Op == BO_LAnd);
    // Logical AND.
    // Visit LHS. Only visit RHS if LHS was TRUE.
    LabelTy LabelFalse = this->getLabel();
    LabelTy LabelEnd = this->getLabel();
 
    if (!this->visitBool(LHS))
      return false;
    if (!this->jumpFalse(LabelFalse, E))
      return false;
 
    if (!this->visitBool(RHS))
      return false;
    if (!this->jump(LabelEnd, E))
      return false;
 
    this->emitLabel(LabelFalse);
    this->emitConstBool(false, E);
    this->fallthrough(LabelEnd);
    this->emitLabel(LabelEnd);
  }
 
  if (DiscardResult)
    return this->emitPopBool(E);
 
  // For C, cast back to integer type.
  if (!E->getType()->isBooleanType()) {
    PrimType T = classifyPrim(E->getType());
    return this->emitCast(PT_Bool, T, E);
  }
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitComplexBinOp(const BinaryOperator *E) {
  // Prepare storage for result.
  if (!Initializing) {
    UnsignedOrNone LocalIndex = allocateTemporary(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
 
  // Both LHS and RHS might _not_ be of complex type, but one of them
  // needs to be.
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
 
  PrimType ResultElemT = this->classifyComplexElementType(E->getType());
  unsigned ResultOffset = ~0u;
  if (!DiscardResult)
    ResultOffset = this->allocateLocalPrimitive(E, PT_Ptr, /*IsConst=*/true);
 
  // Save result pointer in ResultOffset
  if (!this->DiscardResult) {
    if (!this->emitDupPtr(E))
      return false;
    if (!this->emitSetLocal(PT_Ptr, ResultOffset, E))
      return false;
  }
  QualType LHSType = LHS->getType();
  if (const auto *AT = LHSType->getAs<AtomicType>())
    LHSType = AT->getValueType();
  QualType RHSType = RHS->getType();
  if (const auto *AT = RHSType->getAs<AtomicType>())
    RHSType = AT->getValueType();
 
  bool LHSIsComplex = LHSType->isAnyComplexType();
  unsigned LHSOffset;
  bool RHSIsComplex = RHSType->isAnyComplexType();
 
  // For ComplexComplex Mul, we have special ops to make their implementation
  // easier.
  BinaryOperatorKind Op = E->getOpcode();
  if (Op == BO_Mul && LHSIsComplex && RHSIsComplex) {
    assert(classifyPrim(LHSType->getAs<ComplexType>()->getElementType()) ==
           classifyPrim(RHSType->getAs<ComplexType>()->getElementType()));
    PrimType ElemT =
        classifyPrim(LHSType->getAs<ComplexType>()->getElementType());
    if (!this->visit(LHS))
      return false;
    if (!this->visit(RHS))
      return false;
    if (!this->emitMulc(ElemT, E))
      return false;
    if (DiscardResult)
      return this->emitPopPtr(E);
    return true;
  }
 
  if (Op == BO_Div && RHSIsComplex) {
    QualType ElemQT = RHSType->getAs<ComplexType>()->getElementType();
    PrimType ElemT = classifyPrim(ElemQT);
    // If the LHS is not complex, we still need to do the full complex
    // division, so just stub create a complex value and stub it out with
    // the LHS and a zero.
 
    if (!LHSIsComplex) {
      // This is using the RHS type for the fake-complex LHS.
      UnsignedOrNone LocalIndex = allocateTemporary(RHS);
      if (!LocalIndex)
        return false;
      LHSOffset = *LocalIndex;
 
      if (!this->emitGetPtrLocal(LHSOffset, E))
        return false;
 
      if (!this->visit(LHS))
        return false;
      // real is LHS
      if (!this->emitInitElem(ElemT, 0, E))
        return false;
      // imag is zero
      if (!this->visitZeroInitializer(ElemT, ElemQT, E))
        return false;
      if (!this->emitInitElem(ElemT, 1, E))
        return false;
    } else {
      if (!this->visit(LHS))
        return false;
    }
 
    if (!this->visit(RHS))
      return false;
    if (!this->emitDivc(ElemT, E))
      return false;
    if (DiscardResult)
      return this->emitPopPtr(E);
    return true;
  }
 
  // Evaluate LHS and save value to LHSOffset.
  if (LHSType->isAnyComplexType()) {
    LHSOffset = this->allocateLocalPrimitive(LHS, PT_Ptr, /*IsConst=*/true);
    if (!this->visit(LHS))
      return false;
    if (!this->emitSetLocal(PT_Ptr, LHSOffset, E))
      return false;
  } else {
    PrimType LHST = classifyPrim(LHSType);
    LHSOffset = this->allocateLocalPrimitive(LHS, LHST, /*IsConst=*/true);
    if (!this->visit(LHS))
      return false;
    if (!this->emitSetLocal(LHST, LHSOffset, E))
      return false;
  }
 
  // Same with RHS.
  unsigned RHSOffset;
  if (RHSType->isAnyComplexType()) {
    RHSOffset = this->allocateLocalPrimitive(RHS, PT_Ptr, /*IsConst=*/true);
    if (!this->visit(RHS))
      return false;
    if (!this->emitSetLocal(PT_Ptr, RHSOffset, E))
      return false;
  } else {
    PrimType RHST = classifyPrim(RHSType);
    RHSOffset = this->allocateLocalPrimitive(RHS, RHST, /*IsConst=*/true);
    if (!this->visit(RHS))
      return false;
    if (!this->emitSetLocal(RHST, RHSOffset, E))
      return false;
  }
 
  // For both LHS and RHS, either load the value from the complex pointer, or
  // directly from the local variable. For index 1 (i.e. the imaginary part),
  // just load 0 and do the operation anyway.
  auto loadComplexValue = [this](bool IsComplex, bool LoadZero,
                                 unsigned ElemIndex, unsigned Offset,
                                 const Expr *E) -> bool {
    if (IsComplex) {
      if (!this->emitGetLocal(PT_Ptr, Offset, E))
        return false;
      return this->emitArrayElemPop(classifyComplexElementType(E->getType()),
                                    ElemIndex, E);
    }
    if (ElemIndex == 0 || !LoadZero)
      return this->emitGetLocal(classifyPrim(E->getType()), Offset, E);
    return this->visitZeroInitializer(classifyPrim(E->getType()), E->getType(),
                                      E);
  };
 
  // Now we can get pointers to the LHS and RHS from the offsets above.
  for (unsigned ElemIndex = 0; ElemIndex != 2; ++ElemIndex) {
    // Result pointer for the store later.
    if (!this->DiscardResult) {
      if (!this->emitGetLocal(PT_Ptr, ResultOffset, E))
        return false;
    }
 
    // The actual operation.
    switch (Op) {
    case BO_Add:
      if (!loadComplexValue(LHSIsComplex, true, ElemIndex, LHSOffset, LHS))
        return false;
 
      if (!loadComplexValue(RHSIsComplex, true, ElemIndex, RHSOffset, RHS))
        return false;
      if (ResultElemT == PT_Float) {
        if (!this->emitAddf(getFPOptions(E), E))
          return false;
      } else {
        if (!this->emitAdd(ResultElemT, E))
          return false;
      }
      break;
    case BO_Sub:
      if (!loadComplexValue(LHSIsComplex, true, ElemIndex, LHSOffset, LHS))
        return false;
 
      if (!loadComplexValue(RHSIsComplex, true, ElemIndex, RHSOffset, RHS))
        return false;
      if (ResultElemT == PT_Float) {
        if (!this->emitSubf(getFPOptions(E), E))
          return false;
      } else {
        if (!this->emitSub(ResultElemT, E))
          return false;
      }
      break;
    case BO_Mul:
      if (!loadComplexValue(LHSIsComplex, false, ElemIndex, LHSOffset, LHS))
        return false;
 
      if (!loadComplexValue(RHSIsComplex, false, ElemIndex, RHSOffset, RHS))
        return false;
 
      if (ResultElemT == PT_Float) {
        if (!this->emitMulf(getFPOptions(E), E))
          return false;
      } else {
        if (!this->emitMul(ResultElemT, E))
          return false;
      }
      break;
    case BO_Div:
      assert(!RHSIsComplex);
      if (!loadComplexValue(LHSIsComplex, false, ElemIndex, LHSOffset, LHS))
        return false;
 
      if (!loadComplexValue(RHSIsComplex, false, ElemIndex, RHSOffset, RHS))
        return false;
 
      if (ResultElemT == PT_Float) {
        if (!this->emitDivf(getFPOptions(E), E))
          return false;
      } else {
        if (!this->emitDiv(ResultElemT, E))
          return false;
      }
      break;
 
    default:
      return false;
    }
 
    if (!this->DiscardResult) {
      // Initialize array element with the value we just computed.
      if (!this->emitInitElemPop(ResultElemT, ElemIndex, E))
        return false;
    } else {
      if (!this->emitPop(ResultElemT, E))
        return false;
      // Remove the Complex temporary pointer we created ourselves at the
      // beginning of this function.
      if (!Initializing)
        return this->emitPopPtr(E);
    }
  }
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitVectorBinOp(const BinaryOperator *E) {
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
  assert(!E->isCommaOp() &&
         "Comma op should be handled in VisitBinaryOperator");
 
  QualType LHSType = LHS->getType();
  if (const auto *AT = LHSType->getAs<AtomicType>())
    LHSType = AT->getValueType();
  QualType RHSType = RHS->getType();
  if (const auto *AT = RHSType->getAs<AtomicType>())
    RHSType = AT->getValueType();
  assert(E->getType()->isVectorType());
  assert(LHSType->isVectorType());
  assert(RHSType->isVectorType());
 
  // We can only handle vectors with primitive element types.
  if (!canClassify(LHSType->castAs<VectorType>()->getElementType()))
    return false;
 
  // Prepare storage for result.
  if (!Initializing && !E->isCompoundAssignmentOp() && !E->isAssignmentOp()) {
    UnsignedOrNone LocalIndex = allocateTemporary(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
 
  const auto *VecTy = E->getType()->getAs<VectorType>();
  auto Op = E->isCompoundAssignmentOp()
                ? BinaryOperator::getOpForCompoundAssignment(E->getOpcode())
                : E->getOpcode();
 
  PrimType ElemT = this->classifyVectorElementType(LHSType);
  PrimType RHSElemT = this->classifyVectorElementType(RHSType);
  PrimType ResultElemT = this->classifyVectorElementType(E->getType());
 
  if (E->getOpcode() == BO_Assign) {
    assert(Ctx.getASTContext().hasSameUnqualifiedType(
        LHSType->castAs<VectorType>()->getElementType(),
        RHSType->castAs<VectorType>()->getElementType()));
    if (!this->visit(LHS))
      return false;
    if (!this->visit(RHS))
      return false;
    if (!this->emitCopyArray(ElemT, 0, 0, VecTy->getNumElements(), E))
      return false;
    if (DiscardResult)
      return this->emitPopPtr(E);
    return true;
  }
 
  // Evaluate LHS and save value to LHSOffset.
  unsigned LHSOffset =
      this->allocateLocalPrimitive(LHS, PT_Ptr, /*IsConst=*/true);
  if (!this->visit(LHS))
    return false;
  if (!this->emitSetLocal(PT_Ptr, LHSOffset, E))
    return false;
 
  // Evaluate RHS and save value to RHSOffset.
  unsigned RHSOffset =
      this->allocateLocalPrimitive(RHS, PT_Ptr, /*IsConst=*/true);
  if (!this->visit(RHS))
    return false;
  if (!this->emitSetLocal(PT_Ptr, RHSOffset, E))
    return false;
 
  if (E->isCompoundAssignmentOp() && !this->emitGetLocal(PT_Ptr, LHSOffset, E))
    return false;
 
  // BitAdd/BitOr/BitXor/Shl/Shr doesn't support bool type, we need perform the
  // integer promotion.
  bool NeedIntPromot = ElemT == PT_Bool && (E->isBitwiseOp() || E->isShiftOp());
  QualType PromotTy;
  PrimType PromotT = PT_Bool;
  PrimType OpT = ElemT;
  if (NeedIntPromot) {
    PromotTy =
        Ctx.getASTContext().getPromotedIntegerType(Ctx.getASTContext().BoolTy);
    PromotT = classifyPrim(PromotTy);
    OpT = PromotT;
  }
 
  auto getElem = [=](unsigned Offset, PrimType ElemT, unsigned Index) {
    if (!this->emitGetLocal(PT_Ptr, Offset, E))
      return false;
    if (!this->emitArrayElemPop(ElemT, Index, E))
      return false;
    if (E->isLogicalOp()) {
      if (!this->emitPrimCast(ElemT, PT_Bool, Ctx.getASTContext().BoolTy, E))
        return false;
      if (!this->emitPrimCast(PT_Bool, ResultElemT, VecTy->getElementType(), E))
        return false;
    } else if (NeedIntPromot) {
      if (!this->emitPrimCast(ElemT, PromotT, PromotTy, E))
        return false;
    }
    return true;
  };
 
#define EMIT_ARITH_OP(OP)                                                      \
  {                                                                            \
    if (ElemT == PT_Float) {                                                   \
      if (!this->emit##OP##f(getFPOptions(E), E))                              \
        return false;                                                          \
    } else {                                                                   \
      if (!this->emit##OP(ElemT, E))                                           \
        return false;                                                          \
    }                                                                          \
    break;                                                                     \
  }
 
  for (unsigned I = 0; I != VecTy->getNumElements(); ++I) {
    if (!getElem(LHSOffset, ElemT, I))
      return false;
    if (!getElem(RHSOffset, RHSElemT, I))
      return false;
    switch (Op) {
    case BO_Add:
      EMIT_ARITH_OP(Add)
    case BO_Sub:
      EMIT_ARITH_OP(Sub)
    case BO_Mul:
      EMIT_ARITH_OP(Mul)
    case BO_Div:
      EMIT_ARITH_OP(Div)
    case BO_Rem:
      if (!this->emitRem(ElemT, E))
        return false;
      break;
    case BO_And:
      if (!this->emitBitAnd(OpT, E))
        return false;
      break;
    case BO_Or:
      if (!this->emitBitOr(OpT, E))
        return false;
      break;
    case BO_Xor:
      if (!this->emitBitXor(OpT, E))
        return false;
      break;
    case BO_Shl:
      if (!this->emitShl(OpT, RHSElemT, E))
        return false;
      break;
    case BO_Shr:
      if (!this->emitShr(OpT, RHSElemT, E))
        return false;
      break;
    case BO_EQ:
      if (!this->emitEQ(ElemT, E))
        return false;
      break;
    case BO_NE:
      if (!this->emitNE(ElemT, E))
        return false;
      break;
    case BO_LE:
      if (!this->emitLE(ElemT, E))
        return false;
      break;
    case BO_LT:
      if (!this->emitLT(ElemT, E))
        return false;
      break;
    case BO_GE:
      if (!this->emitGE(ElemT, E))
        return false;
      break;
    case BO_GT:
      if (!this->emitGT(ElemT, E))
        return false;
      break;
    case BO_LAnd:
      // a && b is equivalent to a!=0 & b!=0
      if (!this->emitBitAnd(ResultElemT, E))
        return false;
      break;
    case BO_LOr:
      // a || b is equivalent to a!=0 | b!=0
      if (!this->emitBitOr(ResultElemT, E))
        return false;
      break;
    default:
      return this->emitInvalid(E);
    }
 
    // The result of the comparison is a vector of the same width and number
    // of elements as the comparison operands with a signed integral element
    // type.
    //
    // https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html
    if (E->isComparisonOp()) {
      if (!this->emitPrimCast(PT_Bool, ResultElemT, VecTy->getElementType(), E))
        return false;
      if (!this->emitNeg(ResultElemT, E))
        return false;
    }
 
    // If we performed an integer promotion, we need to cast the compute result
    // into result vector element type.
    if (NeedIntPromot &&
        !this->emitPrimCast(PromotT, ResultElemT, VecTy->getElementType(), E))
      return false;
 
    // Initialize array element with the value we just computed.
    if (!this->emitInitElem(ResultElemT, I, E))
      return false;
  }
 
  if (DiscardResult && E->isCompoundAssignmentOp() && !this->emitPopPtr(E))
    return false;
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitFixedPointBinOp(const BinaryOperator *E) {
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
  const ASTContext &ASTCtx = Ctx.getASTContext();
 
  assert(LHS->getType()->isFixedPointType() ||
         RHS->getType()->isFixedPointType());
 
  auto LHSSema = ASTCtx.getFixedPointSemantics(LHS->getType());
  auto LHSSemaInt = LHSSema.toOpaqueInt();
  auto RHSSema = ASTCtx.getFixedPointSemantics(RHS->getType());
  auto RHSSemaInt = RHSSema.toOpaqueInt();
 
  if (!this->visit(LHS))
    return false;
  if (!LHS->getType()->isFixedPointType()) {
    if (!this->emitCastIntegralFixedPoint(classifyPrim(LHS->getType()),
                                          LHSSemaInt, E))
      return false;
  }
 
  if (!this->visit(RHS))
    return false;
  if (!RHS->getType()->isFixedPointType()) {
    if (!this->emitCastIntegralFixedPoint(classifyPrim(RHS->getType()),
                                          RHSSemaInt, E))
      return false;
  }
 
  // Convert the result to the target semantics.
  auto ConvertResult = [&](bool R) -> bool {
    if (!R)
      return false;
    auto ResultSema = ASTCtx.getFixedPointSemantics(E->getType()).toOpaqueInt();
    auto CommonSema = LHSSema.getCommonSemantics(RHSSema).toOpaqueInt();
    if (ResultSema != CommonSema)
      return this->emitCastFixedPoint(ResultSema, E);
    return true;
  };
 
  auto MaybeCastToBool = [&](bool Result) {
    if (!Result)
      return false;
    PrimType T = classifyPrim(E);
    if (DiscardResult)
      return this->emitPop(T, E);
    if (T != PT_Bool)
      return this->emitCast(PT_Bool, T, E);
    return true;
  };
 
  switch (E->getOpcode()) {
  case BO_EQ:
    return MaybeCastToBool(this->emitEQFixedPoint(E));
  case BO_NE:
    return MaybeCastToBool(this->emitNEFixedPoint(E));
  case BO_LT:
    return MaybeCastToBool(this->emitLTFixedPoint(E));
  case BO_LE:
    return MaybeCastToBool(this->emitLEFixedPoint(E));
  case BO_GT:
    return MaybeCastToBool(this->emitGTFixedPoint(E));
  case BO_GE:
    return MaybeCastToBool(this->emitGEFixedPoint(E));
  case BO_Add:
    return ConvertResult(this->emitAddFixedPoint(E));
  case BO_Sub:
    return ConvertResult(this->emitSubFixedPoint(E));
  case BO_Mul:
    return ConvertResult(this->emitMulFixedPoint(E));
  case BO_Div:
    return ConvertResult(this->emitDivFixedPoint(E));
  case BO_Shl:
    return ConvertResult(this->emitShiftFixedPoint(/*Left=*/true, E));
  case BO_Shr:
    return ConvertResult(this->emitShiftFixedPoint(/*Left=*/false, E));
 
  default:
    return this->emitInvalid(E);
  }
 
  llvm_unreachable("unhandled binop opcode");
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitFixedPointUnaryOperator(const UnaryOperator *E) {
  const Expr *SubExpr = E->getSubExpr();
  assert(SubExpr->getType()->isFixedPointType());
 
  switch (E->getOpcode()) {
  case UO_Plus:
    return this->delegate(SubExpr);
  case UO_Minus:
    if (!this->visit(SubExpr))
      return false;
    if (!this->emitNegFixedPoint(E))
      return false;
    if (DiscardResult)
      return this->emitPopFixedPoint(E);
    return true;
  default:
    return false;
  }
 
  llvm_unreachable("Unhandled unary opcode");
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitImplicitValueInitExpr(
    const ImplicitValueInitExpr *E) {
  if (DiscardResult)
    return true;
 
  QualType QT = E->getType();
 
  if (OptPrimType T = classify(QT))
    return this->visitZeroInitializer(*T, QT, E);
 
  if (QT->isRecordType()) {
    const RecordDecl *RD = QT->getAsRecordDecl();
    assert(RD);
    if (RD->isInvalidDecl())
      return false;
 
    const Record *R = getRecord(QT);
    if (!R)
      return false;
 
    assert(Initializing);
    return this->visitZeroRecordInitializer(R, E);
  }
 
  if (QT->isIncompleteArrayType())
    return true;
 
  if (QT->isArrayType())
    return this->visitZeroArrayInitializer(QT, E);
 
  if (const auto *ComplexTy = E->getType()->getAs<ComplexType>()) {
    assert(Initializing);
    QualType ElemQT = ComplexTy->getElementType();
    PrimType ElemT = classifyPrim(ElemQT);
    for (unsigned I = 0; I < 2; ++I) {
      if (!this->visitZeroInitializer(ElemT, ElemQT, E))
        return false;
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
    return true;
  }
 
  if (const auto *VecT = E->getType()->getAs<VectorType>()) {
    unsigned NumVecElements = VecT->getNumElements();
    QualType ElemQT = VecT->getElementType();
    PrimType ElemT = classifyPrim(ElemQT);
 
    for (unsigned I = 0; I < NumVecElements; ++I) {
      if (!this->visitZeroInitializer(ElemT, ElemQT, E))
        return false;
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
    return true;
  }
 
  if (const auto *MT = E->getType()->getAs<ConstantMatrixType>()) {
    unsigned NumElems = MT->getNumElementsFlattened();
    QualType ElemQT = MT->getElementType();
    PrimType ElemT = classifyPrim(ElemQT);
 
    for (unsigned I = 0; I != NumElems; ++I) {
      if (!this->visitZeroInitializer(ElemT, ElemQT, E))
        return false;
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
    return true;
  }
 
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
  if (E->getType()->isVoidType() || E->containsErrors())
    return false;
 
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
  const Expr *Index = E->getIdx();
  const Expr *Base = E->getBase();
 
  // C++17's rules require us to evaluate the LHS first, regardless of which
  // side is the base.
  bool Success = true;
  for (const Expr *SubExpr : {LHS, RHS}) {
    if (!this->visit(SubExpr)) {
      Success = false;
      continue;
    }
 
    // Expand the base if this is a subscript on a
    // pointer expression.
    if (SubExpr == Base && Base->getType()->isPointerType()) {
      if (!this->emitExpandPtr(E))
        Success = false;
    }
  }
 
  if (!Success)
    return false;
 
  OptPrimType IndexT = classify(Index->getType());
  // In error-recovery cases, the index expression has a dependent type.
  if (!IndexT)
    return this->emitError(E);
  // If the index is first, we need to change that.
  if (LHS == Index) {
    if (!this->emitFlip(PT_Ptr, *IndexT, E))
      return false;
  }
 
  if (!this->emitArrayElemPtrPop(*IndexT, E))
    return false;
  if (DiscardResult)
    return this->emitPopPtr(E);
 
  if (E->isGLValue())
    return true;
 
  OptPrimType T = classifyPrim(E);
  return this->emitLoadPop(*T, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitInitList(ArrayRef<const Expr *> Inits,
                                      const Expr *ArrayFiller, const Expr *E) {
  InitLinkScope<Emitter> ILS(this, InitLink::InitList());
 
  QualType QT = E->getType();
  if (const auto *AT = QT->getAs<AtomicType>())
    QT = AT->getValueType();
 
  if (QT->isVoidType()) {
    if (Inits.size() == 0)
      return true;
    return this->emitInvalid(E);
  }
 
  // Primitive values. A discarded one can simply discard each initializer;
  // there is no object to establish.
  if (OptPrimType T = classify(QT)) {
    if (DiscardResult) {
      for (const Expr *Init : Inits) {
        if (!this->discard(Init))
          return false;
      }
      return true;
    }
    if (Inits.size() == 0)
      return this->visitZeroInitializer(*T, QT, E);
    assert(Inits.size() == 1);
    return this->delegate(Inits[0]);
  }
 
  assert(!canClassify(E->getType()));
 
  // A composite prvalue needs somewhere to live even when it is discarded: a
  // default member initializer may read subobjects initialized earlier in this
  // same list, so those have to actually be written and `this` has to denote
  // the object. Materialize one and initialize into it.
  if (DiscardResult && !Initializing) {
    UnsignedOrNone LocalIndex = allocateLocal(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
    InitLinkScope<Emitter> ILS2(this, InitLink::Temp(*LocalIndex));
    return this->visitInitializerPop(E);
  }
 
  if (QT->isRecordType()) {
    const Record *R = getRecord(QT);
 
    if (Inits.size() == 1 && E->getType() == Inits[0]->getType())
      return this->delegate(Inits[0]);
 
    if (!R)
      return false;
 
    auto initPrimitiveField = [=](const Record::Field *FieldToInit,
                                  const Expr *Init, PrimType T,
                                  bool Activate = false) -> bool {
      bool DefaultInit = isa<CXXDefaultInitExpr>(Init);
      InitStackScope<Emitter> ISS(this, DefaultInit);
 
      if (DefaultInit && !this->emitStartFieldInit(FieldToInit->Offset, Init))
        return false;
 
      if (!this->visit(Init))
        return false;
 
      if (DefaultInit && !this->emitEndInit(Init))
        return false;
 
      bool BitField = FieldToInit->isBitField();
      if (BitField && Activate)
        return this->emitInitBitFieldActivate(T, FieldToInit->Offset,
                                              FieldToInit->bitWidth(), E);
      if (BitField)
        return this->emitInitBitField(T, FieldToInit->Offset,
                                      FieldToInit->bitWidth(), E);
      if (Activate)
        return this->emitInitFieldActivate(T, FieldToInit->Offset, E);
      return this->emitInitField(T, FieldToInit->Offset, E);
    };
 
    auto initCompositeField = [=](const Record::Field *FieldToInit,
                                  const Expr *Init,
                                  bool Activate = false) -> bool {
      InitStackScope<Emitter> ISS(this, isa<CXXDefaultInitExpr>(Init));
      InitLinkScope<Emitter> ILS(this, InitLink::Field(FieldToInit->Offset));
 
      // Non-primitive case. Get a pointer to the field-to-initialize
      // on the stack and recurse into visitInitializer().
      if (!this->emitGetPtrField(FieldToInit->Offset, Init))
        return false;
 
      if (Activate && !this->emitActivate(E))
        return false;
 
      if (!this->emitStartInit(Init))
        return false;
 
      return this->visitInitializerPop(Init) && this->emitEndInit(Init);
    };
 
    if (R->isUnion()) {
      if (Inits.size() == 0) {
        if (!this->visitZeroRecordInitializer(R, E))
          return false;
      } else {
        const Expr *Init = Inits[0];
        const FieldDecl *FToInit = nullptr;
        if (const auto *ILE = dyn_cast<InitListExpr>(E))
          FToInit = ILE->getInitializedFieldInUnion();
        else
          FToInit = cast<CXXParenListInitExpr>(E)->getInitializedFieldInUnion();
 
        const Record::Field *FieldToInit = R->getField(FToInit);
        if (OptPrimType T = classify(Init)) {
          if (!initPrimitiveField(FieldToInit, Init, *T, /*Activate=*/true))
            return false;
        } else {
          if (!initCompositeField(FieldToInit, Init, /*Activate=*/true))
            return false;
        }
      }
      return this->emitFinishInit(E);
    }
 
    assert(!R->isUnion());
    for (unsigned BI = 0; BI != R->getNumBases(); ++BI) {
      const Expr *Init = Inits[BI];
      const Record::Base *B = R->getBase(BI);
      InitStackScope<Emitter> ISS(this, isa<CXXDefaultInitExpr>(Init));
      InitLinkScope<Emitter> ILS(this, InitLink::Base(B->Offset));
      if (!this->emitGetPtrBase(B->Offset, Init))
        return false;
      if (!this->visitInitializerPop(Init))
        return false;
    }
 
    unsigned FieldIndex = 0;
    for (unsigned FI = R->getNumBases(); FI != Inits.size();) {
      const Record::Field *FieldToInit = R->getField(FieldIndex);
      if (FieldToInit->isUnnamedBitField()) {
        ++FieldIndex;
        continue;
      }
 
      const Expr *Init = Inits[FI];
      // If this is a child of a DesignatedInitUpdateExpr, skip elements which
      // aren't supposed to be modified.
      if (isa<NoInitExpr>(Init)) {
        ++FieldIndex;
        ++FI;
        continue;
      }
 
      if (OptPrimType T = classify(Init)) {
        if (!initPrimitiveField(FieldToInit, Init, *T))
          return false;
      } else if (!initCompositeField(FieldToInit, Init)) {
        return false;
      }
 
      ++FI;
      ++FieldIndex;
    }
 
    assert(R->getNumVirtualBases() == 0);
 
    return this->emitFinishInit(E);
  }
 
  if (QT->isArrayType()) {
    const ConstantArrayType *CAT =
        Ctx.getASTContext().getAsConstantArrayType(QT);
    uint64_t NumElems = CAT->getZExtSize();
 
    if (Initializing &&
        (!InitializingDecl || InitializingDecl->hasLocalStorage()) &&
        !this->emitCheckArrayDestSize(NumElems, E))
      return false;
 
    if (Inits.size() == 1 && QT == Inits[0]->getType())
      return this->delegate(Inits[0]);
 
    OptPrimType InitT = classify(CAT->getElementType());
    unsigned ElementIndex = 0;
    for (const Expr *Init : Inits) {
      if (const auto *EmbedS =
              dyn_cast<EmbedExpr>(Init->IgnoreParenImpCasts())) {
        PrimType TargetT = classifyPrim(Init->getType());
 
        auto Eval = [&](const IntegerLiteral *IL, unsigned ElemIndex) {
          if (TargetT == PT_Float) {
            if (!this->emitConst(IL->getValue(), classifyPrim(IL), Init))
              return false;
            const auto *Sem = &Ctx.getFloatSemantics(CAT->getElementType());
            if (!this->emitCastIntegralFloating(classifyPrim(IL), Sem,
                                                getFPOptions(E), E))
              return false;
          } else {
            if (!this->emitConst(IL->getValue(), TargetT, Init))
              return false;
          }
          return this->emitInitElem(TargetT, ElemIndex, IL);
        };
        if (!EmbedS->doForEachDataElement(Eval, ElementIndex))
          return false;
      } else if (isa<NoInitExpr>(Init)) {
        // If this is a child of a DesignatedInitUpdateExpr, skip elements which
        // aren't supposed to be modified.
        ++ElementIndex;
      } else {
        if (!this->visitArrayElemInit(ElementIndex, Init, InitT))
          return false;
        ++ElementIndex;
      }
    }
 
    // Expand the filler expression.
    // FIXME: This should go away.
    if (ArrayFiller && !isa<NoInitExpr>(ArrayFiller)) {
      for (; ElementIndex != NumElems; ++ElementIndex) {
        if (!this->visitArrayElemInit(ElementIndex, ArrayFiller, InitT))
          return false;
      }
    }
 
    return this->emitFinishInit(E);
  }
 
  if (const auto *ComplexTy = QT->getAs<ComplexType>()) {
    unsigned NumInits = Inits.size();
 
    if (NumInits == 1)
      return this->delegate(Inits[0]);
 
    QualType ElemQT = ComplexTy->getElementType();
    PrimType ElemT = classifyPrim(ElemQT);
    if (NumInits == 0) {
      // Zero-initialize both elements.
      for (unsigned I = 0; I < 2; ++I) {
        if (!this->visitZeroInitializer(ElemT, ElemQT, E))
          return false;
        if (!this->emitInitElem(ElemT, I, E))
          return false;
      }
    } else if (NumInits == 2) {
      unsigned InitIndex = 0;
      for (const Expr *Init : Inits) {
        if (!this->visit(Init))
          return false;
 
        if (!this->emitInitElem(ElemT, InitIndex, E))
          return false;
        ++InitIndex;
      }
    }
    return true;
  }
 
  if (const auto *VecT = QT->getAs<VectorType>()) {
    unsigned NumVecElements = VecT->getNumElements();
    assert(NumVecElements >= Inits.size());
 
    QualType ElemQT = VecT->getElementType();
    PrimType ElemT = classifyPrim(ElemQT);
 
    // All initializer elements.
    unsigned InitIndex = 0;
    for (const Expr *Init : Inits) {
      if (!this->visit(Init))
        return false;
 
      // If the initializer is of vector type itself, we have to deconstruct
      // that and initialize all the target fields from the initializer fields.
      if (const auto *InitVecT = Init->getType()->getAs<VectorType>()) {
        if (!this->emitCopyArray(ElemT, 0, InitIndex,
                                 InitVecT->getNumElements(), E))
          return false;
        InitIndex += InitVecT->getNumElements();
      } else {
        if (!this->emitInitElem(ElemT, InitIndex, E))
          return false;
        ++InitIndex;
      }
    }
 
    assert(InitIndex <= NumVecElements);
 
    // Fill the rest with zeroes.
    for (; InitIndex != NumVecElements; ++InitIndex) {
      if (!this->visitZeroInitializer(ElemT, ElemQT, E))
        return false;
      if (!this->emitInitElem(ElemT, InitIndex, E))
        return false;
    }
    return true;
  }
 
  if (const auto *MT = QT->getAs<ConstantMatrixType>()) {
    unsigned NumElems = MT->getNumElementsFlattened();
    assert(Inits.size() == NumElems);
 
    QualType ElemQT = MT->getElementType();
    PrimType ElemT = classifyPrim(ElemQT);
 
    // Matrix initializer list elements are in row-major order, which matches
    // the matrix APValue convention and therefore no index remapping is
    // required.
    for (unsigned I = 0; I != NumElems; ++I) {
      if (!this->visit(Inits[I]))
        return false;
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
    return true;
  }
 
  return false;
}
 
/// Pointer to the array(not the element!) must be on the stack when calling
/// this.
template <class Emitter>
bool Compiler<Emitter>::visitArrayElemInit(unsigned ElemIndex, const Expr *Init,
                                           OptPrimType InitT) {
  if (InitT) {
    // Visit the primitive element like normal.
    if (!this->visit(Init))
      return false;
    return this->emitInitElem(*InitT, ElemIndex, Init);
  }
 
  InitLinkScope<Emitter> ILS(this, InitLink::Elem(ElemIndex));
  // Advance the pointer currently on the stack to the given
  // dimension.
  if (!this->emitConstUint32(ElemIndex, Init))
    return false;
  if (!this->emitArrayElemPtrUint32(Init))
    return false;
  return this->visitInitializerPop(Init);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitCallArgs(ArrayRef<const Expr *> Args,
                                      const FunctionDecl *FuncDecl,
                                      bool Activate, bool IsOperatorCall) {
  assert(VarScope->getKind() == ScopeKind::Call);
  llvm::BitVector NonNullArgs;
  if (FuncDecl && FuncDecl->hasAttr<NonNullAttr>())
    NonNullArgs = collectNonNullArgs(FuncDecl, Args);
 
  bool ExplicitMemberFn = false;
  if (const auto *MD = dyn_cast_if_present<CXXMethodDecl>(FuncDecl))
    ExplicitMemberFn = MD->isExplicitObjectMemberFunction();
 
  unsigned ArgIndex = 0;
  for (const Expr *Arg : Args) {
    if (canClassify(Arg)) {
      if (!this->visit(Arg))
        return false;
    } else {
 
      DeclOrExpr Source = Arg;
      if (FuncDecl) {
        // Try to use the parameter declaration instead of the argument
        // expression as a source.
        unsigned DeclIndex = ArgIndex - IsOperatorCall + ExplicitMemberFn;
        if (DeclIndex < FuncDecl->getNumParams())
          Source = FuncDecl->getParamDecl(ArgIndex - IsOperatorCall +
                                          ExplicitMemberFn);
      }
 
      UnsignedOrNone LocalIndex =
          allocateLocal(Source, Arg->getType(), ScopeKind::Call);
      if (!LocalIndex)
        return false;
 
      if (!this->emitGetPtrLocal(*LocalIndex, Arg))
        return false;
      InitLinkScope<Emitter> ILS(this, InitLink::Temp(*LocalIndex));
      if (!this->visitInitializer(Arg))
        return false;
    }
 
    if (ArgIndex == 1 && Activate) {
      if (!this->emitActivate(Arg))
        return false;
    }
 
    if (!NonNullArgs.empty() && NonNullArgs[ArgIndex]) {
      PrimType ArgT = classify(Arg).value_or(PT_Ptr);
      if (ArgT == PT_Ptr) {
        if (!this->emitCheckNonNullArg(ArgT, Arg))
          return false;
      }
    }
 
    ++ArgIndex;
  }
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitInitListExpr(const InitListExpr *E) {
  return this->visitInitList(E->inits(), E->getArrayFiller(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXParenListInitExpr(
    const CXXParenListInitExpr *E) {
  return this->visitInitList(E->getInitExprs(), E->getArrayFiller(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitSubstNonTypeTemplateParmExpr(
    const SubstNonTypeTemplateParmExpr *E) {
  return this->delegate(E->getReplacement());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitConstantExpr(const ConstantExpr *E) {
  if (!E->hasAPValueResult())
    return this->delegate(E->getSubExpr());
 
  // Emitting an APValue never has side effects.
  if (DiscardResult)
    return true;
 
  if (OptPrimType T = classify(E)) {
    // Try to emit the APValue directly, without visiting the subexpr.
    // This will only fail if we can't emit the APValue, so won't emit any
    // diagnostics or any double values.
    return this->visitAPValue(E->getAPValueResult(), *T, E);
  }
 
  if (!Initializing) {
    UnsignedOrNone LocalIndex = allocateLocal(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
  return this->visitAPValueInitializer(E->getAPValueResult(), E, E->getType());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitEmbedExpr(const EmbedExpr *E) {
  auto It = E->begin();
  return this->visit(*It);
}
 
static CharUnits alignOfType(QualType T, const ASTContext &ASTCtx,
                             UnaryExprOrTypeTrait Kind) {
  // C++ [expr.alignof]p3:
  //     When alignof is applied to a reference type, the result is the
  //     alignment of the referenced type.
  if (const auto *Ref = T->getAs<ReferenceType>())
    T = Ref->getPointeeType();
 
  if (T.getQualifiers().hasUnaligned())
    return CharUnits::One();
 
  bool AlignOfReturnsPreferred =
      ASTCtx.getLangOpts().isCompatibleWith(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 (Kind == UETT_PreferredAlignOf || AlignOfReturnsPreferred)
    return ASTCtx.toCharUnitsFromBits(ASTCtx.getPreferredTypeAlign(T));
 
  return ASTCtx.getTypeAlignInChars(T);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitUnaryExprOrTypeTraitExpr(
    const UnaryExprOrTypeTraitExpr *E) {
 
  UnaryExprOrTypeTrait Kind = E->getKind();
  const ASTContext &ASTCtx = Ctx.getASTContext();
 
  if (Kind == UETT_SizeOf || Kind == UETT_DataSizeOf) {
    QualType ArgType = E->getTypeOfArgument();
 
    // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
    //   the result is the size of the referenced type."
    if (const auto *Ref = ArgType->getAs<ReferenceType>())
      ArgType = Ref->getPointeeType();
 
    CharUnits Size;
    if (ArgType->isVoidType() || ArgType->isFunctionType())
      Size = CharUnits::One();
    else {
      if (ArgType->isDependentType() || !ArgType->isConstantSizeType())
        return this->emitInvalid(E);
 
      if (Kind == UETT_SizeOf)
        Size = ASTCtx.getTypeSizeInChars(ArgType);
      else
        Size = ASTCtx.getTypeInfoDataSizeInChars(ArgType).Width;
    }
 
    if (DiscardResult)
      return true;
 
    return this->emitConst(Size.getQuantity(), E);
  }
 
  if (Kind == UETT_CountOf) {
    QualType Ty = E->getTypeOfArgument();
    assert(Ty->isArrayType());
 
    // We don't need to worry about array element qualifiers, so getting the
    // unsafe array type is fine.
    if (const auto *CAT =
            dyn_cast<ConstantArrayType>(Ty->getAsArrayTypeUnsafe())) {
      if (DiscardResult)
        return true;
      return this->emitConst(CAT->getSize(), E);
    }
 
    assert(!Ty->isConstantSizeType());
 
    // If it's a variable-length array type, we need to check whether it is a
    // multidimensional array. If so, we need to check the size expression of
    // the VLA to see if it's a constant size. If so, we can return that value.
    const auto *VAT = ASTCtx.getAsVariableArrayType(Ty);
    assert(VAT);
    if (VAT->getElementType()->isArrayType()) {
      std::optional<APSInt> Res =
          VAT->getSizeExpr()
              ? VAT->getSizeExpr()->getIntegerConstantExpr(ASTCtx)
              : std::nullopt;
      if (Res) {
        if (DiscardResult)
          return true;
        return this->emitConst(*Res, E);
      }
    }
  }
 
  if (Kind == UETT_AlignOf || Kind == UETT_PreferredAlignOf) {
    CharUnits Size;
 
    if (E->isArgumentType()) {
      QualType ArgType = E->getTypeOfArgument();
 
      Size = alignOfType(ArgType, ASTCtx, Kind);
    } else {
      // Argument is an expression, not a type.
      const Expr *Arg = E->getArgumentExpr()->IgnoreParens();
 
      if (Arg->getType()->isDependentType())
        return false;
 
      // 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 auto *DRE = dyn_cast<DeclRefExpr>(Arg))
        Size = ASTCtx.getDeclAlign(DRE->getDecl(),
                                   /*ForAlignOf=*/true);
      else if (const auto *ME = dyn_cast<MemberExpr>(Arg))
        Size = ASTCtx.getDeclAlign(ME->getMemberDecl(),
                                   /*ForAlignOf=*/true);
      else
        Size = alignOfType(Arg->getType(), ASTCtx, Kind);
    }
 
    if (DiscardResult)
      return true;
 
    return this->emitConst(Size.getQuantity(), E);
  }
 
  if (Kind == UETT_VectorElements) {
    if (E->containsErrors())
      return false;
 
    if (const auto *VT = E->getTypeOfArgument()->getAs<VectorType>())
      return this->emitConst(VT->getNumElements(), E);
    assert(E->getTypeOfArgument()->isSizelessVectorType());
    return this->emitSizelessVectorElementSize(E);
  }
 
  if (Kind == UETT_VecStep) {
    if (const auto *VT = E->getTypeOfArgument()->getAs<VectorType>()) {
      unsigned N = VT->getNumElements();
 
      // The vec_step built-in functions that take a 3-component
      // vector return 4. (OpenCL 1.1 spec 6.11.12)
      if (N == 3)
        N = 4;
 
      return this->emitConst(N, E);
    }
    return this->emitConst(1, E);
  }
 
  if (Kind == UETT_OpenMPRequiredSimdAlign) {
    if (E->containsErrors())
      return false;
    assert(E->isArgumentType());
    unsigned Bits = ASTCtx.getOpenMPDefaultSimdAlign(E->getArgumentType());
 
    return this->emitConst(ASTCtx.toCharUnitsFromBits(Bits).getQuantity(), E);
  }
 
  if (Kind == UETT_PtrAuthTypeDiscriminator) {
    if (E->getArgumentType()->isDependentType())
      return this->emitInvalid(E);
 
    return this->emitConst(
        const_cast<ASTContext &>(ASTCtx).getPointerAuthTypeDiscriminator(
            E->getArgumentType()),
        E);
  }
 
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitMemberExpr(const MemberExpr *E) {
  // 'Base.Member'
  const Expr *Base = E->getBase();
  const ValueDecl *Member = E->getMemberDecl();
 
  if (DiscardResult)
    return this->discard(Base);
 
  if (const auto *VD = dyn_cast<VarDecl>(Member)) {
    // If the member is a VarDecl, this is a static variable.
    // We need to try to lazily evaluate its initializer here since the
    // variable might've been deserialized and not registered
    // as a global variable yet.
    if (VD->getInit() && !VD->getInit()->isValueDependent())
      VD->evaluateValue();
    if (auto GlobalIndex = P.getGlobal(VD)) {
      if (!this->emitGetPtrGlobal(*GlobalIndex, E))
        return false;
      if (Member->getType()->isReferenceType())
        return this->emitLoadPopPtr(E);
      return true;
    }
    return false;
  }
 
  if (!isa<FieldDecl>(Member)) {
    // A non-static member function access only makes sense as part of the
    // enclosing call here. Don't try to evaluate it in isolation.
    if (const auto *MD = dyn_cast<CXXMethodDecl>(Member);
        MD && !MD->isStatic()) {
      return false;
    }
 
    if (!this->discard(Base) && !this->emitSideEffect(E))
      return false;
 
    return this->visitDeclRef(Member, E);
  }
 
  if (!this->visit(Base))
    return false;
 
  // Base above gives us a pointer on the stack.
  const auto *FD = cast<FieldDecl>(Member);
  const RecordDecl *RD = FD->getParent();
  const Record *R = getRecord(RD);
  if (!R)
    return false;
  const Record::Field *F = R->getField(FD);
 
  // MemberExprs are almost always lvalues, in which case we don't need to
  // do the load. But sometimes they aren't.
  const auto maybeLoadValue = [&]() -> bool {
    if (E->isGLValue())
      return true;
    if (OptPrimType T = classify(E))
      return this->emitLoadPop(*T, E);
    return false;
  };
 
  // Leave a pointer to the field on the stack.
  if (F->Decl->getType()->isReferenceType())
    return this->emitGetFieldPop(PT_Ptr, F->Offset, E) && maybeLoadValue();
  return this->emitGetPtrFieldPop(F->Offset, E) && maybeLoadValue();
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) {
  assert(!DiscardResult);
  // ArrayIndex might not be set if a ArrayInitIndexExpr is being evaluated
  // stand-alone, e.g. via EvaluateAsInt().
  if (!ArrayIndex)
    return false;
  return this->emitConst(*ArrayIndex, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) {
  assert(Initializing);
  assert(!DiscardResult);
 
  const Expr *Common = E->getCommonExpr();
  const Expr *SubExpr = E->getSubExpr();
  OptPrimType SubExprT = classify(SubExpr);
  size_t Size = E->getArraySize().getZExtValue();
  if (exceedsArraySizeLimit(Ctx.getLangOpts(), Size))
    return this->emitCheckArraySize(Size, E);
 
  if (SubExprT) {
    // Unwrap the OpaqueValueExpr so we don't cache something we won't reuse.
    Common = cast<OpaqueValueExpr>(Common)->getSourceExpr();
 
    if (!this->visit(Common))
      return false;
    return this->emitCopyArray(*SubExprT, 0, 0, Size, E);
  }
 
  // We visit the common opaque expression here once so we have its value
  // cached.
  if (!this->discard(Common))
    return false;
 
  // TODO: This compiles to quite a lot of bytecode if the array is larger.
  //   Investigate compiling this to a loop.
 
  // So, every iteration, we execute an assignment here
  // where the LHS is on the stack (the target array)
  // and the RHS is our SubExpr.
  for (size_t I = 0; I != Size; ++I) {
    ArrayIndexScope<Emitter> IndexScope(this, I);
    LocalScope<Emitter> BS(this, ScopeKind::FullExpression);
 
    if (!this->visitArrayElemInit(I, SubExpr, SubExprT))
      return false;
    if (!BS.destroyLocals())
      return false;
  }
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
  const Expr *SourceExpr = E->getSourceExpr();
  if (!SourceExpr)
    return false;
 
  if (Initializing) {
    assert(!DiscardResult);
    return this->visitInitializer(SourceExpr);
  }
 
  PrimType SubExprT = classify(SourceExpr).value_or(PT_Ptr);
  if (auto It = OpaqueExprs.find(E); It != OpaqueExprs.end()) {
    if (DiscardResult)
      return true;
    return this->emitGetLocal(SubExprT, It->second, E);
  }
 
  if (!this->visit(SourceExpr))
    return false;
 
  // At this point we either have the evaluated source expression or a pointer
  // to an object on the stack. We want to create a local variable that stores
  // this value.
  unsigned LocalIndex = allocateLocalPrimitive(E, SubExprT, /*IsConst=*/true);
  if (!this->emitSetLocal(SubExprT, LocalIndex, E))
    return false;
 
  // This is cleaned up when the local variable is destroyed.
  OpaqueExprs.insert({E, LocalIndex});
 
  // Here the local variable is created but the value is removed from the stack,
  // so we put it back if the caller needs it.
  if (!DiscardResult)
    return this->emitGetLocal(SubExprT, LocalIndex, E);
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitAbstractConditionalOperator(
    const AbstractConditionalOperator *E) {
  const Expr *Condition = E->getCond();
  const Expr *TrueExpr = E->getTrueExpr();
  const Expr *FalseExpr = E->getFalseExpr();
 
  if (std::optional<bool> BoolValue = getBoolValue(Condition)) {
    if (*BoolValue)
      return this->delegate(TrueExpr);
    return this->delegate(FalseExpr);
  }
 
  bool IsBcpCall = false;
  if (const auto *CE = dyn_cast<CallExpr>(Condition->IgnoreParenCasts());
      CE && CE->getBuiltinCallee() == Builtin::BI__builtin_constant_p) {
    IsBcpCall = true;
  }
 
  LabelTy LabelEnd = this->getLabel();   // Label after the operator.
  LabelTy LabelFalse = this->getLabel(); // Label for the false expr.
 
  if (IsBcpCall) {
    if (!this->emitPushIgnoreDiags(E))
      return false;
  }
 
  if (!this->visitBool(Condition)) {
    // If the condition failed and we're checking for undefined behavior
    // (which only happens with EvalEmitter) check the TrueExpr and FalseExpr
    // as well.
    if (this->checkingForUndefinedBehavior()) {
      if (!this->discard(TrueExpr))
        return false;
      if (!this->discard(FalseExpr))
        return false;
    }
    return false;
  }
 
  // The TrueExpr and FalseExpr of a conditional operator do _not_ create a
  // scope, which means the local variables created within them unconditionally
  // always exist. However, we need to later differentiate which branch was
  // taken and only destroy the varibles of the active branch. This is what the
  // "enabled" flags on local variables are used for.
  llvm::SaveAndRestore LAAA(this->VarScope->LocalsAlwaysEnabled,
                            /*NewValue=*/false);
 
  if (!this->jumpFalse(LabelFalse, E))
    return false;
  if (!this->delegate(TrueExpr))
    return false;
 
  if (!this->jump(LabelEnd, E))
    return false;
  this->emitLabel(LabelFalse);
  if (!this->delegate(FalseExpr))
    return false;
 
  this->fallthrough(LabelEnd);
  this->emitLabel(LabelEnd);
 
  if (IsBcpCall)
    return this->emitPopIgnoreDiags(E);
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitStringLiteral(const StringLiteral *E) {
  if (DiscardResult)
    return true;
 
  if (!Initializing)
    return this->emitGetStringPtr(E, E);
 
  // We are initializing an array on the stack.
  const ConstantArrayType *CAT =
      Ctx.getASTContext().getAsConstantArrayType(E->getType());
  assert(CAT && "a string literal that's not a constant array?");
 
  // If the initializer string is too long, a diagnostic has already been
  // emitted. Read only the array length from the string literal.
  unsigned ArraySize = CAT->getZExtSize();
  unsigned N = std::min(ArraySize, E->getLength());
  unsigned CharWidth = E->getCharByteWidth();
 
  for (unsigned I = 0; I != N; ++I) {
    uint32_t CodeUnit = E->getCodeUnit(I);
 
    if (CharWidth == 1) {
      this->emitConstSint8(CodeUnit, E);
      this->emitInitElemSint8(I, E);
    } else if (CharWidth == 2) {
      this->emitConstUint16(CodeUnit, E);
      this->emitInitElemUint16(I, E);
    } else if (CharWidth == 4) {
      this->emitConstUint32(CodeUnit, E);
      this->emitInitElemUint32(I, E);
    } else {
      llvm_unreachable("unsupported character width");
    }
  }
 
  // Fill up the rest of the char array with NUL bytes.
  for (unsigned I = N; I != ArraySize; ++I) {
    if (CharWidth == 1) {
      this->emitConstSint8(0, E);
      this->emitInitElemSint8(I, E);
    } else if (CharWidth == 2) {
      this->emitConstUint16(0, E);
      this->emitInitElemUint16(I, E);
    } else if (CharWidth == 4) {
      this->emitConstUint32(0, E);
      this->emitInitElemUint32(I, E);
    } else {
      llvm_unreachable("unsupported character width");
    }
  }
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitObjCStringLiteral(const ObjCStringLiteral *E) {
  if (DiscardResult)
    return true;
  return this->emitDummyPtr(E, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
  auto &A = Ctx.getASTContext();
  std::string Str;
  A.getObjCEncodingForType(E->getEncodedType(), Str);
  StringLiteral *SL =
      StringLiteral::Create(A, Str, StringLiteralKind::Ordinary,
                            /*Pascal=*/false, E->getType(), E->getAtLoc());
  return this->delegate(SL);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitSYCLUniqueStableNameExpr(
    const SYCLUniqueStableNameExpr *E) {
  if (DiscardResult)
    return true;
 
  assert(!Initializing);
 
  auto &A = Ctx.getASTContext();
  std::string ResultStr = E->ComputeName(A);
 
  QualType CharTy = A.CharTy.withConst();
  APInt Size(A.getTypeSize(A.getSizeType()), ResultStr.size() + 1);
  QualType ArrayTy = A.getConstantArrayType(CharTy, Size, nullptr,
                                            ArraySizeModifier::Normal, 0);
 
  StringLiteral *SL =
      StringLiteral::Create(A, ResultStr, StringLiteralKind::Ordinary,
                            /*Pascal=*/false, ArrayTy, E->getLocation());
  return this->emitGetStringPtr(SL, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCharacterLiteral(const CharacterLiteral *E) {
  if (DiscardResult)
    return true;
  return this->emitConst(E->getValue(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitFloatCompoundAssignOperator(
    const CompoundAssignOperator *E) {
 
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
  QualType LHSType = LHS->getType();
  QualType LHSComputationType = E->getComputationLHSType();
  QualType ResultType = E->getComputationResultType();
  OptPrimType LT = classify(LHSComputationType);
  OptPrimType RT = classify(ResultType);
 
  assert(ResultType->isFloatingType());
 
  if (!LT || !RT)
    return false;
 
  PrimType LHST = classifyPrim(LHSType);
 
  if (isSideEffectFree(RHS)) {
    if (!visit(LHS))
      return false;
    if (!this->emitLoad(LHST, E))
      return false;
    // If necessary, convert LHS to its computation type.
    if (!this->emitPrimCast(LHST, classifyPrim(LHSComputationType),
                            LHSComputationType, E))
      return false;
    if (!visit(RHS))
      return false;
 
  } else {
    // C++17 onwards require that we evaluate the RHS first.
    // Compute RHS and save it in a temporary variable so we can
    // load it again later.
    if (!visit(RHS))
      return false;
 
    unsigned TempOffset =
        this->allocateLocalPrimitive(E, *RT, /*IsConst=*/true);
    if (!this->emitSetLocal(*RT, TempOffset, E))
      return false;
 
    // First, visit LHS.
    if (!visit(LHS))
      return false;
    if (!this->emitLoad(LHST, E))
      return false;
 
    // If necessary, convert LHS to its computation type.
    if (!this->emitPrimCast(LHST, classifyPrim(LHSComputationType),
                            LHSComputationType, E))
      return false;
 
    // Now load RHS.
    if (!this->emitGetLocal(*RT, TempOffset, E))
      return false;
  }
 
  switch (E->getOpcode()) {
  case BO_AddAssign:
    if (!this->emitAddf(getFPOptions(E), E))
      return false;
    break;
  case BO_SubAssign:
    if (!this->emitSubf(getFPOptions(E), E))
      return false;
    break;
  case BO_MulAssign:
    if (!this->emitMulf(getFPOptions(E), E))
      return false;
    break;
  case BO_DivAssign:
    if (!this->emitDivf(getFPOptions(E), E))
      return false;
    break;
  default:
    return false;
  }
 
  if (!this->emitPrimCast(classifyPrim(ResultType), LHST, LHS->getType(), E))
    return false;
 
  if (DiscardResult)
    return this->emitStorePop(LHST, E);
  return this->emitStore(LHST, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitPointerCompoundAssignOperator(
    const CompoundAssignOperator *E) {
  BinaryOperatorKind Op = E->getOpcode();
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
  OptPrimType LT = classify(LHS->getType());
  OptPrimType RT = classify(RHS->getType());
 
  if (Op != BO_AddAssign && Op != BO_SubAssign)
    return false;
 
  if (!LT || !RT)
    return false;
 
  if (!visit(LHS))
    return false;
 
  if (!this->emitLoad(*LT, LHS))
    return false;
 
  if (!visit(RHS))
    return false;
 
  if (Op == BO_AddAssign) {
    if (!this->emitAddOffset(*RT, E))
      return false;
  } else {
    if (!this->emitSubOffset(*RT, E))
      return false;
  }
 
  if (DiscardResult)
    return this->emitStorePopPtr(E);
  return this->emitStorePtr(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCompoundAssignOperator(
    const CompoundAssignOperator *E) {
  if (E->getType()->isVectorType())
    return VisitVectorBinOp(E);
 
  const Expr *LHS = E->getLHS();
  const Expr *RHS = E->getRHS();
  OptPrimType LHSComputationT = classify(E->getComputationLHSType());
  OptPrimType LT = classify(LHS->getType());
  OptPrimType RT = classify(RHS->getType());
  OptPrimType ResultT = classify(E->getType());
 
  if (!Ctx.getLangOpts().CPlusPlus14)
    return this->visit(RHS) && this->visit(LHS) && this->emitError(E);
 
  if (!LT || !RT || !ResultT || !LHSComputationT)
    return false;
 
  // Handle floating point operations separately here, since they
  // require special care.
  if (ResultT == PT_Float || RT == PT_Float)
    return VisitFloatCompoundAssignOperator(E);
 
  if (E->getType()->isPointerType())
    return VisitPointerCompoundAssignOperator(E);
 
  assert(!E->getType()->isPointerType() && "Handled above");
  assert(!E->getType()->isFloatingType() && "Handled above");
 
  if (isSideEffectFree(RHS)) {
    if (!visit(LHS))
      return false;
    if (!this->emitLoad(*LT, E))
      return false;
    if (LT != LHSComputationT &&
        !this->emitIntegralCast(*LT, *LHSComputationT,
                                E->getComputationLHSType(), E))
      return false;
    if (!visit(RHS))
      return false;
  } else {
    // C++17 onwards require that we evaluate the RHS first.
    // Compute RHS and save it in a temporary variable so we can
    // load it again later.
    // FIXME: Compound assignments are unsequenced in C, so we might
    //   have to figure out how to reject them.
    if (!visit(RHS))
      return false;
 
    unsigned TempOffset =
        this->allocateLocalPrimitive(E, *RT, /*IsConst=*/true);
 
    if (!this->emitSetLocal(*RT, TempOffset, E))
      return false;
 
    // Get LHS pointer, load its value and cast it to the
    // computation type if necessary.
    if (!visit(LHS))
      return false;
    if (!this->emitLoad(*LT, E))
      return false;
    if (LT != LHSComputationT &&
        !this->emitIntegralCast(*LT, *LHSComputationT,
                                E->getComputationLHSType(), E))
      return false;
 
    // Get the RHS value on the stack.
    if (!this->emitGetLocal(*RT, TempOffset, E))
      return false;
  }
 
  // Perform operation.
  switch (E->getOpcode()) {
  case BO_AddAssign:
    if (!this->emitAdd(*LHSComputationT, E))
      return false;
    break;
  case BO_SubAssign:
    if (!this->emitSub(*LHSComputationT, E))
      return false;
    break;
  case BO_MulAssign:
    if (!this->emitMul(*LHSComputationT, E))
      return false;
    break;
  case BO_DivAssign:
    if (!this->emitDiv(*LHSComputationT, E))
      return false;
    break;
  case BO_RemAssign:
    if (!this->emitRem(*LHSComputationT, E))
      return false;
    break;
  case BO_ShlAssign:
    if (!this->emitShl(*LHSComputationT, *RT, E))
      return false;
    break;
  case BO_ShrAssign:
    if (!this->emitShr(*LHSComputationT, *RT, E))
      return false;
    break;
  case BO_AndAssign:
    if (!this->emitBitAnd(*LHSComputationT, E))
      return false;
    break;
  case BO_XorAssign:
    if (!this->emitBitXor(*LHSComputationT, E))
      return false;
    break;
  case BO_OrAssign:
    if (!this->emitBitOr(*LHSComputationT, E))
      return false;
    break;
  default:
    llvm_unreachable("Unimplemented compound assign operator");
  }
 
  // And now cast from LHSComputationT to ResultT.
  if (ResultT != LHSComputationT &&
      !this->emitIntegralCast(*LHSComputationT, *ResultT, E->getType(), E))
    return false;
 
  // And store the result in LHS.
  if (DiscardResult) {
    if (LHS->refersToBitField())
      return this->emitStoreBitFieldPop(*ResultT, E);
    return this->emitStorePop(*ResultT, E);
  }
  if (LHS->refersToBitField())
    return this->emitStoreBitField(*ResultT, E);
  return this->emitStore(*ResultT, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitExprWithCleanups(const ExprWithCleanups *E) {
  LocalScope<Emitter> ES(this, ScopeKind::FullExpression);
  const Expr *SubExpr = E->getSubExpr();
 
  return this->delegate(SubExpr) && ES.destroyLocals(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitMaterializeTemporaryExpr(
    const MaterializeTemporaryExpr *E) {
  if (Initializing) {
    // We already have a value, just initialize that.
    return this->delegate(E->getSubExpr());
  }
  // If we don't end up using the materialized temporary anyway, don't
  // bother creating it.
  if (DiscardResult)
    return this->discard(E->getSubExpr());
 
  SmallVector<const Expr *, 2> CommaLHSs;
  SmallVector<SubobjectAdjustment, 2> Adjustments;
  const Expr *Inner;
  if (!Ctx.getLangOpts().CPlusPlus11)
    Inner =
        E->getSubExpr()->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
  else
    Inner = E->getSubExpr();
 
  // If we passed any comma operators, evaluate their LHSs.
  for (const Expr *LHS : CommaLHSs) {
    if (!this->discard(LHS))
      return false;
  }
 
  // FIXME: Find a test case where Adjustments matters.
 
  // When we're extending a global variable *or* the storage duration of
  // the temporary is explicitly static, create a global variable.
  OptPrimType InnerT = classify(Inner);
  const ValueDecl *ExtendingDecl = E->getExtendingDecl();
  bool IsStatic = E->getStorageDuration() == SD_Static;
  if (IsStatic ||
      (ExtendingDecl && Context::shouldBeGloballyIndexed(ExtendingDecl))) {
 
    if (this->constantFolding())
      return false;
 
    UnsignedOrNone GlobalIndex = P.createGlobal(E, Inner->getType());
    if (!GlobalIndex)
      return false;
 
    const LifetimeExtendedTemporaryDecl *TempDecl =
        E->getLifetimeExtendedTemporaryDecl();
 
    if (InnerT) {
      if (!this->visit(Inner))
        return false;
 
      if (IsStatic) {
        assert(TempDecl);
        if (!this->emitInitGlobalTemp(*InnerT, *GlobalIndex, TempDecl, E))
          return false;
      } else {
        if (!this->emitInitGlobal(*InnerT, *GlobalIndex, E))
          return false;
      }
      return this->emitGetPtrGlobal(*GlobalIndex, E);
    }
 
    if (!this->checkLiteralType(Inner))
      return false;
    // Non-primitive values.
    if (!this->emitGetPtrGlobal(*GlobalIndex, E))
      return false;
    if (!this->visitInitializer(Inner))
      return false;
    if (IsStatic) {
      assert(TempDecl);
      return this->emitInitGlobalTempComp(TempDecl, E);
    }
    return true;
  }
 
  ScopeKind VarScope = E->getStorageDuration() == SD_FullExpression
                           ? ScopeKind::FullExpression
                           : ScopeKind::Block;
 
  // For everyhing else, use local variables.
  if (InnerT) {
    bool IsConst = Inner->getType().isConstQualified();
    bool IsVolatile = Inner->getType().isVolatileQualified();
    unsigned LocalIndex =
        allocateLocalPrimitive(E, *InnerT, IsConst, IsVolatile, VarScope);
    if (!this->VarScope->LocalsAlwaysEnabled &&
        !this->emitEnableLocal(LocalIndex, E))
      return false;
 
    if (!this->visit(Inner))
      return false;
    if (!this->emitSetLocal(*InnerT, LocalIndex, E))
      return false;
 
    return this->emitGetPtrLocal(LocalIndex, E);
  }
 
  if (!this->checkLiteralType(Inner))
    return false;
 
  if (UnsignedOrNone LocalIndex =
          allocateLocal(E, Inner->getType(), VarScope)) {
    InitLinkScope<Emitter> ILS(this, InitLink::Temp(*LocalIndex));
 
    if (!this->VarScope->LocalsAlwaysEnabled &&
        !this->emitEnableLocal(*LocalIndex, E))
      return false;
 
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
    return this->visitInitializer(Inner);
  }
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXBindTemporaryExpr(
    const CXXBindTemporaryExpr *E) {
  const Expr *SubExpr = E->getSubExpr();
 
  if (Initializing)
    return this->delegate(SubExpr);
 
  // Make sure we create a temporary even if we're discarding, since that will
  // make sure we will also call the destructor.
 
  if (!this->visit(SubExpr))
    return false;
 
  if (DiscardResult)
    return this->emitPopPtr(E);
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
  const Expr *Init = E->getInitializer();
  if (DiscardResult)
    return this->discard(Init);
 
  if (Initializing) {
    // We already have a value, just initialize that.
    return this->visitInitializer(Init);
  }
 
  OptPrimType T = classify(E->getType());
  if (E->isFileScope()) {
    // Avoid creating a variable if this is a primitive RValue anyway.
    if (T && !E->isLValue())
      return this->delegate(Init);
 
    UnsignedOrNone GlobalIndex = P.createGlobal(E, E->getType());
    if (!GlobalIndex)
      return false;
 
    if (!this->emitGetPtrGlobal(*GlobalIndex, E))
      return false;
 
    // Since this is a global variable, we might've already seen,
    // don't do it again.
    if (P.isGlobalInitialized(*GlobalIndex))
      return true;
 
    if (T) {
      if (!this->visit(Init))
        return false;
      return this->emitInitGlobal(*T, *GlobalIndex, E);
    }
 
    return this->visitInitializer(Init);
  }
 
  // Otherwise, use a local variable.
  if (T && !E->isLValue()) {
    // For primitive types, we just visit the initializer.
    return this->delegate(Init);
  }
 
  unsigned LocalIndex;
  if (T)
    LocalIndex = this->allocateLocalPrimitive(Init, *T, /*IsConst=*/false);
  else if (UnsignedOrNone MaybeIndex = this->allocateLocal(Init))
    LocalIndex = *MaybeIndex;
  else
    return false;
 
  if (!this->emitGetPtrLocal(LocalIndex, E))
    return false;
 
  if (T)
    return this->visit(Init) && this->emitInit(*T, E);
  return this->visitInitializer(Init);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitTypeTraitExpr(const TypeTraitExpr *E) {
  if (DiscardResult)
    return true;
  if (E->isStoredAsBoolean()) {
    if (E->getType()->isBooleanType())
      return this->emitConstBool(E->getBoolValue(), E);
    return this->emitConst(E->getBoolValue(), E);
  }
  if (E->isStoredAsComparisonResult()) {
    const ComparisonCategoryInfo &CmpInfo =
        Ctx.getASTContext().CompCategories.getInfoForType(E->getType());
    const auto Result =
        ComparisonCategoryResult(E->getAPValue().getInt().getZExtValue());
    const Record *R = getRecord(E->getType());
    if (!R || R->getNumFields() == 0)
      return false;
    const Record::Field *Field = R->getField(0U);
    assert(Field->T);
    if (!this->emitConst(CmpInfo.getValueInfo(Result)->getIntValue(), *Field->T,
                         E))
      return false;
    return this->emitInitField(*Field->T, Field->Offset, E);
  }
 
  PrimType T = classifyPrim(E->getType());
  return this->visitAPValue(E->getAPValue(), T, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
  if (DiscardResult)
    return true;
  return this->emitConst(E->getValue(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitLambdaExpr(const LambdaExpr *E) {
  if (DiscardResult)
    return true;
 
  assert(Initializing);
  const Record *R = P.getOrCreateRecord(E->getLambdaClass());
  if (!R)
    return false;
 
  auto *CaptureInitIt = E->capture_init_begin();
  // Initialize all fields (which represent lambda captures) of the
  // record with their initializers.
  for (const Record::Field &F : R->fields()) {
    const Expr *Init = *CaptureInitIt;
    if (!Init || Init->containsErrors())
      continue;
    ++CaptureInitIt;
 
    if (OptPrimType T = classify(Init)) {
      if (!this->visit(Init))
        return false;
 
      if (!this->emitInitField(*T, F.Offset, E))
        return false;
    } else {
      if (!this->emitGetPtrField(F.Offset, E))
        return false;
 
      if (!this->visitInitializerPop(Init))
        return false;
    }
  }
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitPredefinedExpr(const PredefinedExpr *E) {
  if (DiscardResult)
    return true;
 
  if (!Initializing)
    return this->emitGetStringPtr(E, E);
  return this->delegate(E->getFunctionName());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXThrowExpr(const CXXThrowExpr *E) {
  if (E->getSubExpr() && !this->discard(E->getSubExpr()))
    return false;
 
  return this->emitInvalid(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXReinterpretCastExpr(
    const CXXReinterpretCastExpr *E) {
  const Expr *SubExpr = E->getSubExpr();
 
  OptPrimType FromT = classify(SubExpr);
  OptPrimType ToT = classify(E);
 
  if (!FromT || !ToT)
    return this->emitInvalidCast(CastKind::Reinterpret, /*Fatal=*/true, E);
 
  if (FromT == PT_Ptr || ToT == PT_Ptr) {
    auto CastKind = isIntegerType(*ToT) ? CastKind::ReinterpretPtrToInt
                                        : CastKind::Reinterpret;
    if (!this->emitInvalidCast(CastKind, /*Fatal=*/false, E))
      return false;
    if (E->getCastKind() == CK_LValueBitCast)
      return this->delegate(SubExpr);
    return this->VisitCastExpr(E);
  }
 
  // Try to actually do the cast.
  bool Fatal = (ToT != FromT);
  if (!this->emitInvalidCast(CastKind::Reinterpret, Fatal, E))
    return false;
 
  return this->VisitCastExpr(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
  if (!Ctx.getLangOpts().CPlusPlus20) {
    if (!this->emitInvalidCast(CastKind::Dynamic, /*Fatal=*/false, E))
      return false;
  }
 
  if (E->getCastKind() != CK_Dynamic)
    return this->VisitCastExpr(E);
 
  QualType DestType = E->getType();
  // "target type must be a reference or pointer type to a defined class"
  if (DestType->isRecordType()) {
    assert(E->isGLValue());
  } else {
    assert(DestType->isPointerOrReferenceType());
    assert(DestType->isVoidPointerType() ||
           DestType->getPointeeType()->isRecordType());
    DestType = DestType->getPointeeType();
  }
 
  if (!this->visit(E->getSubExpr()))
    return false;
  if (!this->emitDynamicCast(DestType.getTypePtr(),
                             /*IsReferenceCast=*/E->isGLValue(), E))
    return false;
 
  if (DiscardResult)
    return this->emitPopPtr(E);
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
  assert(E->getType()->isBooleanType());
 
  if (DiscardResult)
    return true;
  return this->emitConstBool(E->getValue(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXConstructExpr(const CXXConstructExpr *E) {
  QualType T = E->getType();
  assert(!canClassify(T));
 
  if (T->isRecordType()) {
    const CXXConstructorDecl *Ctor = E->getConstructor();
 
    // If we're discarding a construct expression, we still need
    // to allocate a variable and call the constructor and destructor.
    if (DiscardResult) {
      if (Ctor->isTrivial())
        return true;
      assert(!Initializing);
      UnsignedOrNone LocalIndex = allocateLocal(E);
 
      if (!LocalIndex)
        return false;
 
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
 
    // Trivial copy/move constructor. Avoid copy.
    if (Ctor->isDefaulted() && Ctor->isCopyOrMoveConstructor() &&
        Ctor->isTrivial() &&
        E->getArg(0)->isTemporaryObject(Ctx.getASTContext(),
                                        T->getAsCXXRecordDecl()))
      return this->visitInitializer(E->getArg(0));
 
    // Zero initialization.
    bool ZeroInit = E->requiresZeroInitialization();
    if (ZeroInit) {
      const Record *R = getRecord(E->getType());
      if (!R)
        return false;
 
      if (!this->visitZeroRecordInitializer(R, E))
        return false;
 
      // If the constructor is trivial anyway, we're done.
      if (Ctor->isTrivial())
        return true;
    }
 
    // Trivial default constructors might never be implicitly defined by the
    // AST, so we need to special-case them here.
    if (Ctor->isTrivial() && Ctor->isDefaultConstructor()) {
      if (!this->emitDefaultInit(Ctor, E))
        return false;
      if (DiscardResult)
        return this->emitPopPtr(E);
      return true;
    }
 
    // Avoid materializing a temporary for an elidable copy/move constructor.
    if (!ZeroInit && E->isElidable()) {
      const Expr *SrcObj = E->getArg(0);
      assert(SrcObj->isTemporaryObject(Ctx.getASTContext(), Ctor->getParent()));
      assert(Ctx.getASTContext().hasSameUnqualifiedType(E->getType(),
                                                        SrcObj->getType()));
      if (const auto *ME = dyn_cast<MaterializeTemporaryExpr>(SrcObj)) {
        if (!this->emitCheckFunctionDecl(Ctor, E))
          return false;
        return this->visitInitializer(ME->getSubExpr());
      }
    }
 
    const Function *Func = getFunction(Ctor);
 
    if (!Func)
      return false;
 
    assert(Func->hasThisPointer());
    assert(!Func->hasRVO());
 
    //  The This pointer is already on the stack because this is an initializer,
    //  but we need to dup() so the call() below has its own copy.
    if (!this->emitDupPtr(E))
      return false;
 
    // Constructor arguments.
    for (const auto *Arg : E->arguments()) {
      if (!this->visit(Arg))
        return false;
    }
 
    if (Func->isVariadic()) {
      uint32_t VarArgSize = 0;
      unsigned NumParams = Func->getNumWrittenParams();
      for (unsigned I = NumParams, N = E->getNumArgs(); I != N; ++I) {
        VarArgSize +=
            align(primSize(classify(E->getArg(I)->getType()).value_or(PT_Ptr)));
      }
      if (!this->emitCallVar(Func, VarArgSize, E))
        return false;
    } else {
      if (!this->emitCall(Func, 0, E)) {
        // When discarding, we don't need the result anyway, so clean up
        // the instance dup we did earlier in case surrounding code wants
        // to keep evaluating.
        if (DiscardResult)
          (void)this->emitPopPtr(E);
        return false;
      }
    }
 
    if (DiscardResult)
      return this->emitPopPtr(E);
    return true;
  }
 
  if (T->isArrayType()) {
    const Function *Func = getFunction(E->getConstructor());
    if (!Func)
      return false;
 
    if (!this->emitDupPtr(E))
      return false;
 
    std::function<bool(QualType)> initArrayDimension;
    initArrayDimension = [&](QualType T) -> bool {
      if (!T->isArrayType()) {
        // Constructor arguments.
        for (const auto *Arg : E->arguments()) {
          if (!this->visit(Arg))
            return false;
        }
 
        return this->emitCall(Func, 0, E);
      }
 
      const ConstantArrayType *CAT =
          Ctx.getASTContext().getAsConstantArrayType(T);
      if (!CAT)
        return false;
      QualType ElemTy = CAT->getElementType();
      uint64_t NumElems = CAT->getZExtSize();
      if (exceedsArraySizeLimit(Ctx.getLangOpts(), NumElems))
        return this->emitCheckArraySize(NumElems, E);
      for (uint64_t I = 0; I != NumElems; ++I) {
        if (!this->emitConstUint64(I, E))
          return false;
        if (!this->emitArrayElemPtrUint64(E))
          return false;
        if (!initArrayDimension(ElemTy))
          return false;
      }
      return this->emitPopPtr(E);
    };
 
    return initArrayDimension(E->getType());
  }
 
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitSourceLocExpr(const SourceLocExpr *E) {
  if (DiscardResult)
    return true;
 
  const APValue Val =
      E->EvaluateInContext(Ctx.getASTContext(), SourceLocDefaultExpr);
 
  // Things like __builtin_LINE().
  if (E->getType()->isIntegerType()) {
    assert(Val.isInt());
    const APSInt &I = Val.getInt();
    return this->emitConst(I, E);
  }
  // Otherwise, the APValue is an LValue, with only one element.
  // Theoretically, we don't need the APValue at all of course.
  assert(E->getType()->isPointerType());
  assert(Val.isLValue());
  const APValue::LValueBase &Base = Val.getLValueBase();
  if (const Expr *LValueExpr = Base.dyn_cast<const Expr *>())
    return this->visit(LValueExpr);
 
  // Otherwise, we have a decl (which is the case for
  // __builtin_source_location).
  assert(Base.is<const ValueDecl *>());
  assert(Val.getLValuePath().size() == 0);
  const auto *BaseDecl = Base.dyn_cast<const ValueDecl *>();
  assert(BaseDecl);
 
  auto *UGCD = cast<UnnamedGlobalConstantDecl>(BaseDecl);
 
  UnsignedOrNone GlobalIndex = P.getOrCreateGlobal(UGCD);
  if (!GlobalIndex)
    return false;
 
  if (!this->emitGetPtrGlobal(*GlobalIndex, E))
    return false;
 
  const Record *R = getRecord(E->getType());
  const APValue &V = UGCD->getValue();
  for (unsigned I = 0, N = R->getNumFields(); I != N; ++I) {
    const Record::Field *F = R->getField(I);
    const APValue &FieldValue = V.getStructField(I);
 
    if (!this->visitAPValue(FieldValue, *F->T, E))
      return false;
    if (!this->emitInitField(*F->T, F->Offset, E))
      return false;
  }
 
  // Leave the pointer to the global on the stack.
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitOffsetOfExpr(const OffsetOfExpr *E) {
  unsigned N = E->getNumComponents();
  if (N == 0)
    return false;
 
  for (unsigned I = 0; I != N; ++I) {
    const OffsetOfNode &Node = E->getComponent(I);
    if (Node.getKind() == OffsetOfNode::Array) {
      const Expr *ArrayIndexExpr = E->getIndexExpr(Node.getArrayExprIndex());
      PrimType IndexT = classifyPrim(ArrayIndexExpr->getType());
 
      if (DiscardResult) {
        if (!this->discard(ArrayIndexExpr))
          return false;
        continue;
      }
 
      if (IndexT == PT_IntAP || IndexT == PT_IntAPS) {
        if (!this->visit(ArrayIndexExpr))
          return false;
        if (!this->emitCastAPToOffsetIndex(IndexT, E))
          return false;
        continue;
      }
      if (!this->visit(ArrayIndexExpr))
        return false;
      // Cast to Sint64.
      if (IndexT != PT_Sint64) {
        if (!this->emitCast(IndexT, PT_Sint64, E))
          return false;
      }
    }
  }
 
  if (DiscardResult)
    return true;
 
  PrimType T = classifyPrim(E->getType());
  return this->emitOffsetOf(T, E, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXScalarValueInitExpr(
    const CXXScalarValueInitExpr *E) {
  QualType Ty = E->getType();
 
  if (DiscardResult || Ty->isVoidType())
    return true;
 
  if (OptPrimType T = classify(Ty))
    return this->visitZeroInitializer(*T, Ty, E);
 
  if (Ty->isAnyComplexType() || Ty->isVectorType()) {
    if (!Initializing) {
      UnsignedOrNone LocalIndex = allocateLocal(E);
      if (!LocalIndex)
        return false;
      if (!this->emitGetPtrLocal(*LocalIndex, E))
        return false;
    }
 
    QualType ElemQT;
    unsigned NumElems;
    if (const auto *CT = Ty->getAs<ComplexType>()) {
      NumElems = 2;
      ElemQT = CT->getElementType();
    } else {
      const auto *VT = Ty->castAs<VectorType>();
      NumElems = VT->getNumElements();
      ElemQT = VT->getElementType();
    }
 
    PrimType ElemT = classifyPrim(ElemQT);
 
    // Initialize all fields to 0.
    for (unsigned I = 0; I != NumElems; ++I) {
      if (!this->visitZeroInitializer(ElemT, ElemQT, E))
        return false;
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
    return true;
  }
 
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
  return this->emitConst(E->getPackLength(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitGenericSelectionExpr(
    const GenericSelectionExpr *E) {
  return this->delegate(E->getResultExpr());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitChooseExpr(const ChooseExpr *E) {
  return this->delegate(E->getChosenSubExpr());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
  if (DiscardResult)
    return true;
 
  return this->emitConst(E->getValue(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXInheritedCtorInitExpr(
    const CXXInheritedCtorInitExpr *E) {
  const CXXConstructorDecl *Ctor = E->getConstructor();
 
  if (Ctor->isTrivial())
    return true;
 
  const Function *F = this->getFunction(Ctor);
  if (!F)
    return false;
  assert(!F->hasRVO());
  assert(F->hasThisPointer());
 
  if (!this->emitDupPtr(SourceInfo{}))
    return false;
 
  // Forward all arguments of the current function (which should be a
  // constructor itself) to the inherited ctor.
  // This is necessary because the calling code has pushed the pointer
  // of the correct base for  us already, but the arguments need
  // to come after.
  unsigned ParamIndex = 0;
  for (const ParmVarDecl *PD : Ctor->parameters()) {
    PrimType PT = this->classify(PD->getType()).value_or(PT_Ptr);
 
    if (!this->emitGetParam(PT, ParamIndex, E))
      return false;
    ++ParamIndex;
  }
 
  return this->emitCall(F, 0, E);
}
 
// FIXME: This function has become rather unwieldy, especially
// the part where we initialize an array allocation of dynamic size.
template <class Emitter>
bool Compiler<Emitter>::VisitCXXNewExpr(const CXXNewExpr *E) {
  assert(classifyPrim(E->getType()) == PT_Ptr);
  const Expr *Init = E->getInitializer();
  QualType ElementType = E->getAllocatedType();
  OptPrimType ElemT = classify(ElementType);
  unsigned PlacementArgs = E->getNumPlacementArgs();
  const FunctionDecl *OperatorNew = E->getOperatorNew();
  const Expr *PlacementDest = nullptr;
  bool IsNoThrow = false;
 
  if (E->containsErrors())
    return false;
 
  if (PlacementArgs != 0) {
    // FIXME: There is no restriction on this, but it's not clear that any
    // other form makes any sense. We get here for cases such as:
    //
    //   new (std::align_val_t{N}) X(int)
    //
    // (which should presumably be valid only if N is a multiple of
    // alignof(int), and in any case can't be deallocated unless N is
    // alignof(X) and X has new-extended alignment).
    if (PlacementArgs == 1) {
      const Expr *Arg1 = E->getPlacementArg(0);
      if (OperatorNew->isReservedGlobalPlacementOperator()) {
        if (!this->emitCheckPlacementNew(E, E))
          return false;
        PlacementDest = Arg1;
      } else if (
          Arg1->getType()->isNothrowT() &&
          OperatorNew
              ->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
        if (!this->discard(Arg1))
          return false;
        IsNoThrow = true;
      } else {
        // Any other placement list is invalid. This includes a user-declared
        // allocation function taking std::nothrow_t, e.g. by value.
        return this->emitInvalidNewDeleteExpr(E, E);
      }
    } else {
      // Always invalid.
      return this->emitInvalid(E);
    }
  } else if (!OperatorNew
                  ->isUsableAsGlobalAllocationFunctionInConstantEvaluation())
    return this->emitInvalidNewDeleteExpr(E, E);
 
  const Descriptor *Desc;
  if (!PlacementDest) {
    if (ElemT) {
      if (E->isArray())
        Desc = nullptr; // We're not going to use it in this case.
      else
        Desc = P.createDescriptor(E, *ElemT);
    } else {
      Desc = P.createDescriptor(E, ElementType.getTypePtr(), /*IsConst=*/false,
                                /*IsTemporary=*/false, /*IsMutable=*/false,
                                /*IsVolatile=*/false, Init);
    }
  }
 
  if (E->isArray()) {
    std::optional<const Expr *> ArraySizeExpr = E->getArraySize();
    if (!ArraySizeExpr)
      return false;
 
    const Expr *Stripped = *ArraySizeExpr;
    for (; auto *ICE = dyn_cast<ImplicitCastExpr>(Stripped);
         Stripped = ICE->getSubExpr())
      if (ICE->getCastKind() != CK_NoOp &&
          ICE->getCastKind() != CK_IntegralCast)
        break;
 
    PrimType SizeT = classifyPrim(Stripped->getType());
 
    // Save evaluated array size to a variable.
    unsigned ArrayLen =
        allocateLocalPrimitive(Stripped, SizeT, /*IsConst=*/false);
    if (!this->visit(Stripped))
      return false;
    if (!this->emitSetLocal(SizeT, ArrayLen, E))
      return false;
 
    if (PlacementDest) {
      if (!this->visit(PlacementDest))
        return false;
      if (!this->emitGetLocal(SizeT, ArrayLen, E))
        return false;
      if (!this->emitCheckNewTypeMismatchArray(SizeT, E, E))
        return false;
    } else {
      if (!this->emitGetLocal(SizeT, ArrayLen, E))
        return false;
 
      if (ElemT) {
        // N primitive elements.
        if (!this->emitAllocN(SizeT, *ElemT, E, IsNoThrow, E))
          return false;
      } else {
        // N Composite elements.
        if (!this->emitAllocCN(SizeT, Desc, IsNoThrow, E))
          return false;
      }
    }
 
    if (Init) {
      QualType InitType = Init->getType();
      size_t StaticInitElems = 0;
      const Expr *DynamicInit = nullptr;
      OptPrimType ElemT;
 
      if (const ConstantArrayType *CAT =
              Ctx.getASTContext().getAsConstantArrayType(InitType)) {
        StaticInitElems = CAT->getZExtSize();
        // Initialize the first S element from the initializer.
        if (!this->visitInitializer(Init))
          return false;
 
        if (const auto *ILE = dyn_cast<InitListExpr>(Init)) {
          if (ILE->hasArrayFiller())
            DynamicInit = ILE->getArrayFiller();
          else if (StaticInitElems > 0 && isa<StringLiteral>(ILE->getInit(0)))
            ElemT = classifyPrim(CAT->getElementType());
        }
      }
 
      // The initializer initializes a certain number of elements, S.
      // However, the complete number of elements, N, might be larger than that.
      // In this case, we need to get an initializer for the remaining elements.
      // There are three cases:
      //   1) For the form 'new Struct[n];', the initializer is a
      //      CXXConstructExpr and its type is an IncompleteArrayType.
      //   2) For the form 'new Struct[n]{1,2,3}', the initializer is an
      //      InitListExpr and the initializer for the remaining elements
      //      is the array filler.
      //   3) StringLiterals don't have an array filler, so we need to zero
      //      the remaining elements.
 
      if (DynamicInit || ElemT || InitType->isIncompleteArrayType()) {
        const Function *CtorFunc = nullptr;
        if (const auto *CE = dyn_cast<CXXConstructExpr>(Init)) {
          CtorFunc = getFunction(CE->getConstructor());
          if (!CtorFunc)
            return false;
        } else if (!DynamicInit && !ElemT)
          DynamicInit = Init;
 
        LabelTy EndLabel = this->getLabel();
        LabelTy StartLabel = this->getLabel();
 
        // In the nothrow case, the alloc above might have returned nullptr.
        // Don't call any constructors that case.
        if (IsNoThrow) {
          if (!this->emitDupPtr(E))
            return false;
          if (!this->emitIsNonNullPtr(E))
            return false;
          if (!this->jumpFalse(EndLabel, E))
            return false;
        }
 
        // Create loop variables.
        unsigned Iter =
            allocateLocalPrimitive(Stripped, SizeT, /*IsConst=*/false);
        if (!this->emitConst(StaticInitElems, SizeT, E))
          return false;
        if (!this->emitSetLocal(SizeT, Iter, E))
          return false;
 
        this->fallthrough(StartLabel);
        this->emitLabel(StartLabel);
        // Condition. Iter < ArrayLen?
        if (!this->emitGetLocal(SizeT, Iter, E))
          return false;
        if (!this->emitGetLocal(SizeT, ArrayLen, E))
          return false;
        if (!this->emitLT(SizeT, E))
          return false;
        if (!this->jumpFalse(EndLabel, E))
          return false;
 
        // Pointer to the allocated array is already on the stack.
        if (!this->emitGetLocal(SizeT, Iter, E))
          return false;
        if (!this->emitArrayElemPtr(SizeT, E))
          return false;
 
        if (isa_and_nonnull<ImplicitValueInitExpr>(DynamicInit) &&
            DynamicInit->getType()->isArrayType()) {
          QualType ElemType =
              DynamicInit->getType()->getAsArrayTypeUnsafe()->getElementType();
          if (OptPrimType InitT = classify(ElemType)) {
            if (!this->visitZeroInitializer(*InitT, ElemType, E))
              return false;
            if (!this->emitStorePop(*InitT, E))
              return false;
          } else {
            assert(ElemType->isArrayType());
            if (!this->visitZeroArrayInitializer(ElemType, E))
              return false;
          }
        } else if (DynamicInit) {
          if (OptPrimType InitT = classify(DynamicInit)) {
            if (!this->visit(DynamicInit))
              return false;
            if (!this->emitStorePop(*InitT, E))
              return false;
          } else {
            if (!this->visitInitializerPop(DynamicInit))
              return false;
          }
        } else if (ElemT) {
          if (!this->visitZeroInitializer(
                  *ElemT, InitType->getAsArrayTypeUnsafe()->getElementType(),
                  Init))
            return false;
          if (!this->emitStorePop(*ElemT, E))
            return false;
        } else {
          assert(CtorFunc);
          if (!this->emitCall(CtorFunc, 0, E))
            return false;
        }
 
        // ++Iter;
        if (!this->emitGetPtrLocal(Iter, E))
          return false;
        if (!this->emitIncPop(SizeT, false, E))
          return false;
 
        if (!this->jump(StartLabel, E))
          return false;
 
        this->fallthrough(EndLabel);
        this->emitLabel(EndLabel);
      }
    }
  } else { // Non-array.
    if (PlacementDest) {
      if (!this->visit(PlacementDest))
        return false;
      if (!this->emitCheckNewTypeMismatch(E, E))
        return false;
 
    } else {
      // Allocate just one element.
      if (!this->emitAlloc(Desc, E))
        return false;
    }
 
    if (Init) {
      if (ElemT) {
        if (!this->visit(Init))
          return false;
 
        if (!this->emitInit(*ElemT, E))
          return false;
      } else {
        // Composite.
        if (!this->visitInitializer(Init))
          return false;
      }
    }
  }
 
  if (DiscardResult)
    return this->emitPopPtr(E);
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXDeleteExpr(const CXXDeleteExpr *E) {
  if (E->containsErrors())
    return false;
  const FunctionDecl *OperatorDelete = E->getOperatorDelete();
 
  if (!OperatorDelete->isUsableAsGlobalAllocationFunctionInConstantEvaluation())
    return this->emitInvalidNewDeleteExpr(E, E);
 
  // Arg must be an lvalue.
  if (!this->visit(E->getArgument()))
    return false;
 
  return this->emitFree(E->isArrayForm(), E->isGlobalDelete(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitBlockExpr(const BlockExpr *E) {
  if (DiscardResult)
    return true;
 
  const Function *Func = nullptr;
  if (const Function *F = Ctx.getOrCreateObjCBlock(E))
    Func = F;
 
  if (!Func)
    return false;
  return this->emitGetFnPtr(Func, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
  const Type *TypeInfoType = E->getType().getTypePtr();
 
  auto canonType = [](const Type *T) {
    return T->getCanonicalTypeUnqualified().getTypePtr();
  };
 
  if (!E->isPotentiallyEvaluated()) {
    if (DiscardResult)
      return true;
 
    if (E->isTypeOperand())
      return this->emitGetTypeid(
          canonType(E->getTypeOperand(Ctx.getASTContext()).getTypePtr()),
          TypeInfoType, E);
 
    return this->emitGetTypeid(
        canonType(E->getExprOperand()->getType().getTypePtr()), TypeInfoType,
        E);
  }
 
  // Otherwise, we need to evaluate the expression operand.
  assert(E->getExprOperand());
  assert(E->getExprOperand()->isLValue());
 
  if (!Ctx.getLangOpts().CPlusPlus20 && !this->emitDiagTypeid(E))
    return false;
 
  if (!this->visit(E->getExprOperand()))
    return false;
 
  if (!this->emitGetTypeidPtr(TypeInfoType, E))
    return false;
  if (DiscardResult)
    return this->emitPopPtr(E);
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitObjCDictionaryLiteral(
    const ObjCDictionaryLiteral *E) {
  if (E->isExpressibleAsConstantInitializer())
    return this->emitDummyPtr(E, E);
  return this->emitError(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitObjCArrayLiteral(const ObjCArrayLiteral *E) {
  if (E->isExpressibleAsConstantInitializer())
    return this->emitDummyPtr(E, E);
  return this->emitError(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXReflectExpr(const CXXReflectExpr *E) {
  if (DiscardResult)
    return true;
 
  switch (E->getKind()) {
  case ReflectionKind::Null: {
    assert(false && "null reflection can't be constructed from parsing a "
                    "reflection operand");
    return false;
  }
  case ReflectionKind::Type: {
    return this->emitReflectValue(E->getKind(), E->getOpaqueValue(), E);
  }
  }
 
  assert(false && "unknown or unimplemented reflection entities");
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
  assert(Ctx.getLangOpts().CPlusPlus);
  return this->emitConstBool(E->getValue(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
  if (DiscardResult)
    return true;
  assert(!Initializing);
 
  const MSGuidDecl *GuidDecl = E->getGuidDecl();
  const RecordDecl *RD = GuidDecl->getType()->getAsRecordDecl();
  assert(RD);
  // If the definiton of the result type is incomplete, just return a dummy.
  // If (and when) that is read from, we will fail, but not now.
  if (!RD->isCompleteDefinition())
    return this->emitDummyPtr(GuidDecl, E);
 
  UnsignedOrNone GlobalIndex = P.getOrCreateGlobal(GuidDecl);
  if (!GlobalIndex)
    return false;
  if (!this->emitGetPtrGlobal(*GlobalIndex, E))
    return false;
 
  assert(this->getRecord(E->getType()));
 
  const APValue &V = GuidDecl->getAsAPValue();
  if (V.getKind() == APValue::None)
    return true;
 
  assert(V.isStruct());
  assert(V.getStructNumBases() == 0);
  if (!this->visitAPValueInitializer(V, E, E->getType()))
    return false;
 
  return this->emitFinishInit(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitRequiresExpr(const RequiresExpr *E) {
  assert(classifyPrim(E->getType()) == PT_Bool);
  if (E->isValueDependent())
    return false;
  if (DiscardResult)
    return true;
  return this->emitConstBool(E->isSatisfied(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitConceptSpecializationExpr(
    const ConceptSpecializationExpr *E) {
  assert(classifyPrim(E->getType()) == PT_Bool);
  if (DiscardResult)
    return true;
  return this->emitConstBool(E->isSatisfied(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXRewrittenBinaryOperator(
    const CXXRewrittenBinaryOperator *E) {
  return this->delegate(E->getSemanticForm());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
 
  for (const Expr *SemE : E->semantics()) {
    if (auto *OVE = dyn_cast<OpaqueValueExpr>(SemE)) {
      if (SemE == E->getResultExpr())
        return false;
 
      if (OVE->isUnique())
        continue;
 
      if (!this->discard(OVE))
        return false;
    } else if (SemE == E->getResultExpr()) {
      if (!this->delegate(SemE))
        return false;
    } else {
      if (!this->discard(SemE))
        return false;
    }
  }
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitPackIndexingExpr(const PackIndexingExpr *E) {
  return this->delegate(E->getSelectedExpr());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitRecoveryExpr(const RecoveryExpr *E) {
  return this->emitError(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitAddrLabelExpr(const AddrLabelExpr *E) {
  assert(E->getType()->isVoidPointerType());
  if (DiscardResult)
    return true;
 
  return this->emitDummyPtr(E, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::emitVectorConversion(const Expr *Src, const Expr *E) {
  if (Src->containsErrors())
    return false;
 
  const auto *VT = E->getType()->castAs<VectorType>();
  QualType ElemType = VT->getElementType();
  PrimType ElemT = classifyPrim(ElemType);
  QualType SrcType = Src->getType();
  PrimType SrcElemT = classifyVectorElementType(SrcType);
 
  if (!Initializing) {
    UnsignedOrNone LocalIndex = allocateLocal(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
 
  unsigned SrcOffset =
      this->allocateLocalPrimitive(Src, PT_Ptr, /*IsConst=*/true);
  if (!this->visit(Src))
    return false;
  if (!this->emitSetLocal(PT_Ptr, SrcOffset, E))
    return false;
 
  for (unsigned I = 0; I != VT->getNumElements(); ++I) {
    if (!this->emitGetLocal(PT_Ptr, SrcOffset, E))
      return false;
    if (!this->emitArrayElemPop(SrcElemT, I, E))
      return false;
 
    // Cast to the desired result element type.
    if (SrcElemT != ElemT) {
      if (!this->emitPrimCast(SrcElemT, ElemT, ElemType, E))
        return false;
    } else if (ElemType->isFloatingType() && SrcType != ElemType) {
      const auto *TargetSemantics = &Ctx.getFloatSemantics(ElemType);
      if (!this->emitCastFP(TargetSemantics, getRoundingMode(E), E))
        return false;
    }
    if (!this->emitInitElem(ElemT, I, E))
      return false;
  }
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitConvertVectorExpr(const ConvertVectorExpr *E) {
  return emitVectorConversion(E->getSrcExpr(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitShuffleVectorExpr(const ShuffleVectorExpr *E) {
  // FIXME: Unary shuffle with mask not currently supported.
  if (E->getNumSubExprs() == 2)
    return this->emitInvalid(E);
 
  assert(E->getNumSubExprs() > 2);
 
  const Expr *Vecs[] = {E->getExpr(0), E->getExpr(1)};
  const VectorType *VT = Vecs[0]->getType()->castAs<VectorType>();
  PrimType ElemT = classifyPrim(VT->getElementType());
  unsigned NumInputElems = VT->getNumElements();
  unsigned NumOutputElems = E->getNumSubExprs() - 2;
  assert(NumOutputElems > 0);
 
  if (!Initializing) {
    UnsignedOrNone LocalIndex = allocateLocal(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
 
  // Save both input vectors to a local variable.
  unsigned VectorOffsets[2];
  for (unsigned I = 0; I != 2; ++I) {
    VectorOffsets[I] =
        this->allocateLocalPrimitive(Vecs[I], PT_Ptr, /*IsConst=*/true);
    if (!this->visit(Vecs[I]))
      return false;
    if (!this->emitSetLocal(PT_Ptr, VectorOffsets[I], E))
      return false;
  }
  for (unsigned I = 0; I != NumOutputElems; ++I) {
    APSInt ShuffleIndex = E->getShuffleMaskIdx(I);
    assert(ShuffleIndex >= -1);
    if (ShuffleIndex == -1)
      return this->emitInvalidShuffleVectorIndex(I, E);
 
    assert(ShuffleIndex < (NumInputElems * 2));
    if (!this->emitGetLocal(PT_Ptr,
                            VectorOffsets[ShuffleIndex >= NumInputElems], E))
      return false;
    unsigned InputVectorIndex = ShuffleIndex.getZExtValue() % NumInputElems;
    if (!this->emitArrayElemPop(ElemT, InputVectorIndex, E))
      return false;
 
    if (!this->emitInitElem(ElemT, I, E))
      return false;
  }
 
  if (DiscardResult)
    return this->emitPopPtr(E);
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitExtVectorElementExpr(
    const ExtVectorElementExpr *E) {
  const Expr *Base = E->getBase();
  assert(
      Base->getType()->isVectorType() ||
      Base->getType()->getAs<PointerType>()->getPointeeType()->isVectorType());
 
  SmallVector<uint32_t, 4> Indices;
  E->getEncodedElementAccess(Indices);
 
  if (Indices.size() == 1) {
    if (!this->visit(Base))
      return false;
 
    if (E->isGLValue()) {
      if (!this->emitConstUint32(Indices[0], E))
        return false;
      return this->emitArrayElemPtrPop(PT_Uint32, E);
    }
    // Else, also load the value.
    return this->emitArrayElemPop(classifyPrim(E->getType()), Indices[0], E);
  }
 
  // Create a local variable for the base.
  unsigned BaseOffset = allocateLocalPrimitive(Base, PT_Ptr, /*IsConst=*/true);
  if (!this->visit(Base))
    return false;
  if (!this->emitSetLocal(PT_Ptr, BaseOffset, E))
    return false;
 
  // Now the vector variable for the return value.
  if (!Initializing) {
    UnsignedOrNone ResultIndex = allocateLocal(E);
    if (!ResultIndex)
      return false;
    if (!this->emitGetPtrLocal(*ResultIndex, E))
      return false;
  }
 
  assert(Indices.size() == E->getType()->getAs<VectorType>()->getNumElements());
 
  PrimType ElemT =
      classifyPrim(E->getType()->getAs<VectorType>()->getElementType());
  uint32_t DstIndex = 0;
  for (uint32_t I : Indices) {
    if (!this->emitGetLocal(PT_Ptr, BaseOffset, E))
      return false;
    if (!this->emitArrayElemPop(ElemT, I, E))
      return false;
    if (!this->emitInitElem(ElemT, DstIndex, E))
      return false;
    ++DstIndex;
  }
 
  // Leave the result pointer on the stack.
  assert(!DiscardResult);
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
  const Expr *SubExpr = E->getSubExpr();
  if (!E->isExpressibleAsConstantInitializer())
    return this->discard(SubExpr) && this->emitInvalid(E);
 
  if (DiscardResult)
    return true;
 
  assert(classifyPrim(E) == PT_Ptr);
  return this->emitDummyPtr(E, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXStdInitializerListExpr(
    const CXXStdInitializerListExpr *E) {
  const Expr *SubExpr = E->getSubExpr();
  const ConstantArrayType *ArrayType =
      Ctx.getASTContext().getAsConstantArrayType(SubExpr->getType());
  const Record *R = getRecord(E->getType());
  assert(SubExpr->isGLValue());
  assert(!canClassify(E->getType()));
 
  if (!Initializing) {
    UnsignedOrNone LocalIndex = allocateLocal(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
 
  if (!this->visit(SubExpr))
    return false;
  if (!this->emitConstUint8(0, E))
    return false;
  if (!this->emitArrayElemPtrPopUint8(E))
    return false;
  if (!this->emitInitFieldPtr(R->getField(0u)->Offset, E))
    return false;
 
  PrimType SecondFieldT = *R->getField(1u)->T;
  if (isIntegerOrBoolType(SecondFieldT)) {
    if (!this->emitConst(ArrayType->getSize(), SecondFieldT, E))
      return false;
    if (!this->emitInitField(SecondFieldT, R->getField(1u)->Offset, E))
      return false;
    if (DiscardResult)
      return this->emitPopPtr(E);
    return true;
  }
  assert(SecondFieldT == PT_Ptr);
 
  if (!this->emitGetFieldPtr(R->getField(0u)->Offset, E))
    return false;
  if (!this->emitExpandPtr(E))
    return false;
  if (!this->emitConst(ArrayType->getSize(), PT_Uint64, E))
    return false;
  if (!this->emitArrayElemPtrPop(PT_Uint64, E))
    return false;
 
  if (!this->emitInitFieldPtr(R->getField(1u)->Offset, E))
    return false;
  if (DiscardResult)
    return this->emitPopPtr(E);
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitStmtExpr(const StmtExpr *E) {
  LocalScope<Emitter> BS(this);
  llvm::SaveAndRestore StmtExprSAR(this->InStmtExpr, true);
 
  const CompoundStmt *CS = E->getSubStmt();
  const Stmt *Result = CS->body_back();
  for (const Stmt *S : CS->body()) {
    if (S != Result) {
      if (!this->visitStmt(S))
        return false;
      continue;
    }
 
    assert(S == Result);
    if (const Expr *ResultExpr = dyn_cast<Expr>(S))
      return this->delegate(ResultExpr);
    if (!this->visitStmt(S))
      return false;
    return this->emitUnsupported(E);
  }
 
  return BS.destroyLocals();
}
 
template <class Emitter> bool Compiler<Emitter>::discard(const Expr *E) {
  OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/true,
                             /*NewInitializing=*/false, /*ToLValue=*/false);
  return this->Visit(E);
}
 
template <class Emitter> bool Compiler<Emitter>::delegate(const Expr *E) {
  // We're basically doing:
  // OptionScope<Emitter> Scope(this, DicardResult, Initializing, ToLValue);
  // but that's unnecessary of course.
  return this->Visit(E);
}
 
static const Expr *stripCheckedDerivedToBaseCasts(const Expr *E) {
  if (const auto *PE = dyn_cast<ParenExpr>(E))
    return stripCheckedDerivedToBaseCasts(PE->getSubExpr());
 
  if (const auto *CE = dyn_cast<CastExpr>(E);
      CE &&
      (CE->getCastKind() == CK_DerivedToBase || CE->getCastKind() == CK_NoOp))
    return stripCheckedDerivedToBaseCasts(CE->getSubExpr());
 
  return E;
}
 
static const Expr *stripDerivedToBaseCasts(const Expr *E) {
  if (const auto *PE = dyn_cast<ParenExpr>(E))
    return stripDerivedToBaseCasts(PE->getSubExpr());
 
  if (const auto *CE = dyn_cast<CastExpr>(E);
      CE && (CE->getCastKind() == CK_DerivedToBase ||
             CE->getCastKind() == CK_UncheckedDerivedToBase ||
             CE->getCastKind() == CK_NoOp))
    return stripDerivedToBaseCasts(CE->getSubExpr());
 
  return E;
}
 
template <class Emitter> bool Compiler<Emitter>::visit(const Expr *E) {
  if (E->getType().isNull())
    return false;
 
  if (E->getType()->isVoidType())
    return this->discard(E);
 
  // Create local variable to hold the return value.
  if (!E->isGLValue() && !canClassify(E->getType())) {
    UnsignedOrNone LocalIndex = allocateLocal(
        stripDerivedToBaseCasts(E), QualType(), ScopeKind::FullExpression);
    if (!LocalIndex)
      return false;
 
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
    InitLinkScope<Emitter> ILS(this, InitLink::Temp(*LocalIndex));
    return this->visitInitializer(E);
  }
 
  //  Otherwise,we have a primitive return value, produce the value directly
  //  and push it on the stack.
  OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/false,
                             /*NewInitializing=*/false, /*ToLValue=*/ToLValue);
  return this->Visit(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitInitializer(const Expr *E) {
  assert(!canClassify(E->getType()));
 
  OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/false,
                             /*NewInitializing=*/true, /*ToLValue=*/false);
  return this->Visit(E) && this->emitFinishInit(E);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitInitializerPop(const Expr *E) {
  assert(!canClassify(E->getType()));
 
  OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/false,
                             /*NewInitializing=*/true, /*ToLValue=*/false);
  return this->Visit(E) && this->emitFinishInitPop(E);
}
 
template <class Emitter> bool Compiler<Emitter>::visitAsLValue(const Expr *E) {
  OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/false,
                             /*NewInitializing=*/false, /*ToLValue=*/true);
  return this->Visit(E);
}
 
template <class Emitter> bool Compiler<Emitter>::visitBool(const Expr *E) {
  OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/false,
                             /*NewInitializing=*/false, /*ToLValue=*/ToLValue);
 
  OptPrimType T = classify(E->getType());
  if (!T) {
    // Convert complex values to bool.
    if (E->getType()->isAnyComplexType()) {
      if (!this->visit(E))
        return false;
      return this->emitComplexBoolCast(E);
    }
    return false;
  }
 
  if (!this->visit(E))
    return false;
 
  if (T == PT_Bool)
    return true;
 
  // Convert pointers to bool.
  if (T == PT_Ptr)
    return this->emitIsNonNullPtr(E);
 
  // Or Floats.
  if (T == PT_Float)
    return this->emitCastFloatingIntegralBool(getFPOptions(E), E);
 
  // Or anything else we can.
  return this->emitCast(*T, PT_Bool, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitZeroInitializer(PrimType T, QualType QT,
                                             const Expr *E) {
  if (const auto *AT = QT->getAs<AtomicType>())
    QT = AT->getValueType();
 
  switch (T) {
  case PT_Bool:
    return this->emitZeroBool(E);
  case PT_Sint8:
    return this->emitZeroSint8(E);
  case PT_Uint8:
    return this->emitZeroUint8(E);
  case PT_Sint16:
    return this->emitZeroSint16(E);
  case PT_Uint16:
    return this->emitZeroUint16(E);
  case PT_Sint32:
    return this->emitZeroSint32(E);
  case PT_Uint32:
    return this->emitZeroUint32(E);
  case PT_Sint64:
    return this->emitZeroSint64(E);
  case PT_Uint64:
    return this->emitZeroUint64(E);
  case PT_IntAP:
    return this->emitZeroIntAP(Ctx.getBitWidth(QT), E);
  case PT_IntAPS:
    return this->emitZeroIntAPS(Ctx.getBitWidth(QT), E);
  case PT_Ptr:
    return this->emitNullPtr(Ctx.getASTContext().getTargetNullPointerValue(QT),
                             nullptr, E);
  case PT_MemberPtr:
    return this->emitNullMemberPtr(0, nullptr, E);
  case PT_Float: {
    APFloat F = APFloat::getZero(Ctx.getFloatSemantics(QT));
    return this->emitFloat(F, E);
  }
  case PT_FixedPoint: {
    auto Sem = Ctx.getASTContext().getFixedPointSemantics(QT);
    return this->emitConstFixedPoint(FixedPoint::zero(Sem), E);
  }
  case PT_Reflect:
    return this->emitReflectValue(ReflectionKind::Null, nullptr, E);
  }
  llvm_unreachable("unknown primitive type");
}
 
template <class Emitter>
bool Compiler<Emitter>::visitZeroRecordInitializer(const Record *R,
                                                   const Expr *E,
                                                   bool IsCompleteClass) {
  assert(E);
  assert(R);
  // Fields
  for (const Record::Field &Field : R->fields()) {
    if (Field.isUnnamedBitField())
      continue;
 
    const Descriptor *D = Field.Desc;
    if (D->isPrimitive()) {
      QualType QT = D->getType();
      PrimType T = D->getPrimType();
      if (!this->visitZeroInitializer(T, QT, E))
        return false;
      if (R->isUnion()) {
        if (!this->emitInitFieldActivate(T, Field.Offset, E))
          return false;
        break;
      }
      if (!this->emitInitField(T, Field.Offset, E))
        return false;
      continue;
    }
 
    if (!this->emitGetPtrField(Field.Offset, E))
      return false;
 
    if (D->isPrimitiveArray()) {
      QualType ET = D->getElemQualType();
      PrimType T = D->getPrimType();
      for (uint32_t I = 0, N = D->getNumElems(); I != N; ++I) {
        if (!this->visitZeroInitializer(T, ET, E))
          return false;
        if (!this->emitInitElem(T, I, E))
          return false;
      }
    } else if (D->isCompositeArray()) {
      // Can't be a vector or complex field.
      if (!this->visitZeroArrayInitializer(D->getType(), E))
        return false;
    } else if (D->isRecord()) {
      if (!this->visitZeroRecordInitializer(D->ElemRecord, E))
        return false;
    } else
      return false;
 
    // C++11 [dcl.init]p5: If T is a (possibly cv-qualified) union type, the
    // object's first non-static named data member is zero-initialized
    if (R->isUnion()) {
      if (!this->emitFinishInitActivatePop(E))
        return false;
      break;
    }
    if (!this->emitFinishInitPop(E))
      return false;
  }
 
  for (const Record::Base &B : R->bases()) {
    if (!this->emitGetPtrBase(B.Offset, E))
      return false;
    if (!this->visitZeroRecordInitializer(B.R, E, /*IsCompleteClass=*/false))
      return false;
    if (!this->emitFinishInitPop(E))
      return false;
  }
 
  if (IsCompleteClass) {
    for (const Record::Base &B : R->virtual_bases()) {
      if (!this->emitGetPtrVirtBase(cast<CXXRecordDecl>(B.R->getDecl()), E))
        return false;
      if (!this->visitZeroRecordInitializer(B.R, E, /*IsCompleteClass=*/false))
        return false;
      if (!this->emitFinishInitPop(E))
        return false;
    }
  }
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitZeroArrayInitializer(QualType T, const Expr *E) {
  assert(T->isArrayType() || T->isAnyComplexType() || T->isVectorType());
  const ArrayType *AT = T->getAsArrayTypeUnsafe();
  QualType ElemType = AT->getElementType();
  size_t NumElems = cast<ConstantArrayType>(AT)->getZExtSize();
 
  if (OptPrimType ElemT = classify(ElemType)) {
    for (size_t I = 0; I != NumElems; ++I) {
      if (!this->visitZeroInitializer(*ElemT, ElemType, E))
        return false;
      if (!this->emitInitElem(*ElemT, I, E))
        return false;
    }
    return true;
  }
  if (ElemType->isRecordType()) {
    const Record *R = getRecord(ElemType);
    if (!R)
      return false;
 
    for (size_t I = 0; I != NumElems; ++I) {
      if (!this->emitConstUint32(I, E))
        return false;
      if (!this->emitArrayElemPtr(PT_Uint32, E))
        return false;
      if (!this->visitZeroRecordInitializer(R, E))
        return false;
      if (!this->emitPopPtr(E))
        return false;
    }
    return true;
  }
  if (ElemType->isArrayType()) {
    for (size_t I = 0; I != NumElems; ++I) {
      if (!this->emitConstUint32(I, E))
        return false;
      if (!this->emitArrayElemPtr(PT_Uint32, E))
        return false;
      if (!this->visitZeroArrayInitializer(ElemType, E))
        return false;
      if (!this->emitPopPtr(E))
        return false;
    }
    return true;
  }
 
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitAssignment(const Expr *LHS, const Expr *RHS,
                                        const Expr *E) {
  if (!canClassify(E->getType()))
    return false;
 
  bool NeedsFlip = !isSideEffectFree(RHS);
  if (!NeedsFlip) {
    if (!this->visit(LHS))
      return false;
    if (!this->visit(RHS))
      return false;
  } else {
    if (!this->visit(RHS))
      return false;
    if (!this->visit(LHS))
      return false;
  }
 
  if (LHS->getType().isVolatileQualified())
    return this->emitInvalidStore(LHS->getType().getTypePtr(), E);
 
  // We don't support assignments in C.
  if (!Ctx.getLangOpts().CPlusPlus && !this->emitInvalid(E))
    return false;
 
  PrimType RHT = classifyPrim(RHS);
  bool Activates = refersToUnion(LHS);
  bool BitField = LHS->refersToBitField();
 
  if (NeedsFlip && !this->emitFlip(PT_Ptr, RHT, E))
    return false;
 
  if (DiscardResult) {
    if (BitField && Activates)
      return this->emitStoreBitFieldActivatePop(RHT, E);
    if (BitField)
      return this->emitStoreBitFieldPop(RHT, E);
    if (Activates)
      return this->emitStoreActivatePop(RHT, E);
    // Otherwise, regular non-activating store.
    return this->emitStorePop(RHT, E);
  }
 
  auto maybeLoad = [&](bool Result) -> bool {
    if (!Result)
      return false;
    // Assignments aren't necessarily lvalues in C.
    // Load from them in that case.
    if (!E->isLValue())
      return this->emitLoadPop(RHT, E);
    return true;
  };
 
  if (BitField && Activates)
    return maybeLoad(this->emitStoreBitFieldActivate(RHT, E));
  if (BitField)
    return maybeLoad(this->emitStoreBitField(RHT, E));
  if (Activates)
    return maybeLoad(this->emitStoreActivate(RHT, E));
  // Otherwise, regular non-activating store.
  return maybeLoad(this->emitStore(RHT, E));
}
 
template <class Emitter>
template <typename T>
bool Compiler<Emitter>::emitConst(T Value, PrimType Ty, SourceInfo Info) {
  switch (Ty) {
  case PT_Sint8:
    return this->emitConstSint8(Value, Info);
  case PT_Uint8:
    return this->emitConstUint8(Value, Info);
  case PT_Sint16:
    return this->emitConstSint16(Value, Info);
  case PT_Uint16:
    return this->emitConstUint16(Value, Info);
  case PT_Sint32:
    return this->emitConstSint32(Value, Info);
  case PT_Uint32:
    return this->emitConstUint32(Value, Info);
  case PT_Sint64:
    return this->emitConstSint64(Value, Info);
  case PT_Uint64:
    return this->emitConstUint64(Value, Info);
  case PT_Bool:
    return this->emitConstBool(Value, Info);
  case PT_Ptr:
  case PT_MemberPtr:
  case PT_Float:
  case PT_IntAP:
  case PT_IntAPS:
  case PT_FixedPoint:
  case PT_Reflect:
    llvm_unreachable("Invalid integral type");
    break;
  }
  llvm_unreachable("unknown primitive type");
}
 
template <class Emitter>
template <typename T>
bool Compiler<Emitter>::emitConst(T Value, const Expr *E) {
  return this->emitConst(Value, classifyPrim(E->getType()), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::emitConst(const APSInt &Value, PrimType Ty,
                                  SourceInfo Info) {
  if (Ty == PT_IntAPS)
    return this->emitConstIntAPS(Value, Info);
  if (Ty == PT_IntAP)
    return this->emitConstIntAP(Value, Info);
 
  if (Value.isSigned())
    return this->emitConst(Value.getSExtValue(), Ty, Info);
  return this->emitConst(Value.getZExtValue(), Ty, Info);
}
 
template <class Emitter>
bool Compiler<Emitter>::emitConst(const APInt &Value, PrimType Ty,
                                  SourceInfo Info) {
  if (Ty == PT_IntAPS)
    return this->emitConstIntAPS(Value, Info);
  if (Ty == PT_IntAP)
    return this->emitConstIntAP(Value, Info);
 
  if (isSignedType(Ty))
    return this->emitConst(Value.getSExtValue(), Ty, Info);
  return this->emitConst(Value.getZExtValue(), Ty, Info);
}
 
template <class Emitter>
bool Compiler<Emitter>::emitConst(const APSInt &Value, const Expr *E) {
  return this->emitConst(Value, classifyPrim(E->getType()), E);
}
 
template <class Emitter>
unsigned Compiler<Emitter>::allocateLocalPrimitive(DeclOrExpr Src, PrimType Ty,
                                                   bool IsConst,
                                                   bool IsVolatile,
                                                   ScopeKind SC) {
  // FIXME: There are cases where Src.isExpr() is wrong, e.g.
  //   (int){12} in C. Consider using Expr::isTemporaryObject() instead
  //   or isa<MaterializeTemporaryExpr>().
  Descriptor *D = P.createDescriptor(Src, Ty, nullptr, IsConst, Src.isExpr(),
                                     /*IsMutable=*/false, IsVolatile);
  D->IsConstexprUnknown = this->VariablesAreConstexprUnknown;
  Scope::Local Local = this->createLocal(D);
  if (auto *VD = Src.asValueDecl())
    Locals.insert({VD, Local});
  VarScope->addForScopeKind(Local, SC);
  return Local.Offset;
}
 
template <class Emitter>
UnsignedOrNone Compiler<Emitter>::allocateLocal(DeclOrExpr Src, QualType Ty,
                                                ScopeKind SC) {
  const ValueDecl *Key = nullptr;
  const Expr *Init = nullptr;
  bool IsTemporary = false;
  if (auto *VD = Src.asValueDecl()) {
    Key = VD;
 
    if (const auto *VarD = dyn_cast<VarDecl>(VD))
      Init = VarD->getInit();
  }
  if (const auto *E = Src.asExpr()) {
    IsTemporary = true;
    if (Ty.isNull())
      Ty = E->getType();
  }
 
  Descriptor *D = P.createDescriptor(
      Src, Ty.getTypePtr(), Ty.isConstQualified(), IsTemporary,
      /*IsMutable=*/false, /*IsVolatile=*/Ty.isVolatileQualified(), Init);
  if (!D)
    return std::nullopt;
  D->IsConstexprUnknown = this->VariablesAreConstexprUnknown;
 
  Scope::Local Local = this->createLocal(D);
  if (Key)
    Locals.insert({Key, Local});
  VarScope->addForScopeKind(Local, SC);
  return Local.Offset;
}
 
template <class Emitter>
UnsignedOrNone Compiler<Emitter>::allocateTemporary(const Expr *E) {
  QualType Ty = E->getType();
  assert(!Ty->isRecordType());
 
  Descriptor *D = P.createDescriptor(E, Ty.getTypePtr(), Ty.isConstQualified(),
                                     /*IsTemporary=*/true);
 
  if (!D)
    return std::nullopt;
 
  Scope::Local Local = this->createLocal(D);
  VariableScope<Emitter> *S = VarScope;
  assert(S);
  // Attach to topmost scope.
  while (S->getParent())
    S = S->getParent();
  assert(S && !S->getParent());
  S->addLocal(Local);
  return Local.Offset;
}
 
template <class Emitter>
const RecordType *Compiler<Emitter>::getRecordTy(QualType Ty) {
  if (const PointerType *PT = dyn_cast<PointerType>(Ty))
    return PT->getPointeeType()->getAsCanonical<RecordType>();
  return Ty->getAsCanonical<RecordType>();
}
 
template <class Emitter> Record *Compiler<Emitter>::getRecord(QualType Ty) {
  if (const auto *RecordTy = getRecordTy(Ty))
    return getRecord(RecordTy->getDecl()->getDefinitionOrSelf());
  return nullptr;
}
 
template <class Emitter>
Record *Compiler<Emitter>::getRecord(const RecordDecl *RD) {
  return P.getOrCreateRecord(RD);
}
 
template <class Emitter>
const Function *Compiler<Emitter>::getFunction(const FunctionDecl *FD) {
  return Ctx.getOrCreateFunction(FD);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitExpr(const Expr *E, bool DestroyToplevelScope) {
  assert(E);
  assert(!E->getType().isNull());
  LocalScope<Emitter> RootScope(this, ScopeKind::FullExpression);
 
  auto maybeDestroyLocals = [&]() -> bool {
    if (DestroyToplevelScope)
      return RootScope.destroyLocals() && this->emitCheckAllocations(E);
    return this->emitCheckAllocations(E);
  };
 
  // Void expressions.
  if (E->getType()->isVoidType()) {
    if (!visit(E))
      return false;
    return this->emitRetVoid(E) && maybeDestroyLocals();
  }
 
  // Expressions with a primitive return type.
  if (OptPrimType T = classify(E)) {
    if (!visit(E))
      return false;
 
    return this->emitRet(*T, E) && maybeDestroyLocals();
  }
 
  // Expressions with a composite return type.
  // For us, that means everything we don't
  // have a PrimType for.
  if (UnsignedOrNone LocalOffset = this->allocateLocal(E)) {
    InitLinkScope<Emitter> ILS(this, InitLink::Temp(*LocalOffset));
    if (!this->emitGetPtrLocal(*LocalOffset, E))
      return false;
 
    if (!visitInitializer(E))
      return false;
    // We are destroying the locals AFTER the Ret op.
    // The Ret op needs to copy the (alive) values, but the
    // destructors may still turn the entire expression invalid.
    return this->emitRetValue(E) && maybeDestroyLocals();
  }
 
  return maybeDestroyLocals() && false;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitLValueExpr(const Expr *E,
                                        bool DestroyToplevelScope) {
  OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/false,
                             /*NewInitializing=*/false, /*ToLValue=*/true);
 
  return this->visitExpr(E, DestroyToplevelScope);
}
 
template <class Emitter>
VarCreationState Compiler<Emitter>::visitDecl(const VarDecl *VD) {
 
  auto R = this->visitVarDecl(VD, VD->getInit(), /*Toplevel=*/true);
 
  if (R.notCreated())
    return R;
 
  if (R)
    return true;
 
  if (!R && Context::shouldBeGloballyIndexed(VD)) {
    if (auto GlobalIndex = P.getGlobal(VD)) {
      Block *GlobalBlock = P.getGlobal(*GlobalIndex);
      auto &GD = GlobalBlock->getBlockDesc<GlobalInlineDescriptor>();
 
      GD.InitState = GlobalInitState::InitializerFailed;
      GlobalBlock->invokeDtor();
    }
  }
 
  return R;
}
 
/// Toplevel visitDeclAndReturn().
/// We get here from evaluateAsInitializer().
/// We need to evaluate the initializer and return its value.
template <class Emitter>
bool Compiler<Emitter>::visitDeclAndReturn(const VarDecl *VD, const Expr *Init,
                                           bool ConstantContext) {
  // We only create variables if we're evaluating in a constant context.
  // Otherwise, just evaluate the initializer and return it.
  if (!ConstantContext) {
    DeclScope<Emitter> LS(this, VD);
    if (!this->visit(Init))
      return false;
    return this->emitRet(classify(Init).value_or(PT_Ptr), VD) &&
           LS.destroyLocals() && this->emitCheckAllocations(VD);
  }
 
  LocalScope<Emitter> VDScope(this);
  if (!this->visitVarDecl(VD, Init, /*Toplevel=*/true))
    return false;
 
  OptPrimType VarT = classify(VD->getType());
  bool IsReference = VD->getType()->isReferenceType();
  if (Context::shouldBeGloballyIndexed(VD)) {
    auto GlobalIndex = P.getGlobal(VD);
    assert(GlobalIndex); // visitVarDecl() didn't return false.
    if (VarT) {
      if (!this->emitGetGlobalUnchecked(*VarT, *GlobalIndex, VD))
        return false;
    } else {
      if (!this->emitGetPtrGlobal(*GlobalIndex, VD))
        return false;
    }
  } else {
    auto Local = Locals.find(VD);
    assert(Local != Locals.end()); // Same here.
    if (VarT) {
      if (IsReference) {
        if (!this->emitGetRefLocal(Local->second.Offset, VD))
          return false;
      } else if (!this->emitGetLocal(*VarT, Local->second.Offset, VD))
        return false;
    } else {
      if (!this->emitGetPtrLocal(Local->second.Offset, VD))
        return false;
    }
  }
 
  // Return the value.
  if (!this->emitRet(VarT.value_or(PT_Ptr), VD)) {
    // If the Ret above failed and this is a global variable. Mark it as
    // uninitialized, even if everything else succeeded.
    if (Context::shouldBeGloballyIndexed(VD)) {
      auto GlobalIndex = P.getGlobal(VD);
      assert(GlobalIndex);
      Block *GlobalBlock = P.getGlobal(*GlobalIndex);
      auto &GD = GlobalBlock->getBlockDesc<GlobalInlineDescriptor>();
 
      GD.InitState = GlobalInitState::InitializerFailed;
      GlobalBlock->invokeDtor();
    }
    return false;
  }
 
  return VDScope.destroyLocals() && this->emitCheckAllocations(VD);
}
 
template <class Emitter>
VarCreationState Compiler<Emitter>::visitVarDecl(const VarDecl *VD,
                                                 const Expr *Init,
                                                 bool Toplevel) {
  QualType VarTy = VD->getType();
  // We don't know what to do with these, so just return false.
  if (VarTy.isNull())
    return false;
 
  // This case is EvalEmitter-only. If we won't create any instructions for the
  // initializer anyway, don't bother creating the variable in the first place.
  if (!this->isActive())
    return VarCreationState::NotCreated();
 
  OptPrimType VarT = classify(VD->getType());
 
  if (Init && Init->isValueDependent())
    return false;
 
  if (Context::shouldBeGloballyIndexed(VD)) {
    auto checkDecl = [&]() -> bool {
      bool NeedsOp = !Toplevel && VD->isLocalVarDecl() && VD->isStaticLocal();
      return !NeedsOp || this->emitCheckDecl(VD, VD);
    };
 
    DeclScope<Emitter> LocalScope(this, VD);
    UnsignedOrNone GlobalIndex = P.getGlobal(VD);
    if (GlobalIndex) {
      // The global was previously created but the initializer failed.
      if (!P.getGlobal(*GlobalIndex)->isInitialized())
        return false;
      // We've already seen and initialized this global.
      if (P.isGlobalInitialized(*GlobalIndex))
        return checkDecl();
      // The previous attempt at initialization might've been unsuccessful,
      // so let's try this one.
    } else if ((GlobalIndex =
                    P.createGlobal(VD, Init, VariablesAreConstexprUnknown))) {
    } else {
      return false;
    }
    if (!Init)
      return true;
 
    if (!checkDecl())
      return false;
 
    if (VarT) {
      if (!this->visit(Init))
        return false;
 
      return this->emitInitGlobal(*VarT, *GlobalIndex, VD);
    }
 
    if (!this->emitGetPtrGlobal(*GlobalIndex, Init))
      return false;
 
    if (!this->emitStartInit(Init))
      return false;
 
    if (!visitInitializer(Init))
      return false;
 
    if (!this->emitEndInit(Init))
      return false;
 
    return this->emitFinishInitGlobal(Init);
  }
  // Local variables.
  InitLinkScope<Emitter> ILS(this, InitLink::Decl(VD));
 
  if (VarT) {
    unsigned Offset = this->allocateLocalPrimitive(
        VD, *VarT, VarTy.isConstQualified(), VarTy.isVolatileQualified(),
        ScopeKind::Block);
 
    if (!Init || Init->getType()->isVoidType())
      return true;
 
    // If this is a toplevel declaration, create a scope for the
    // initializer.
    if (Toplevel) {
      LocalScope<Emitter> Scope(this);
      if (!this->visit(Init))
        return false;
      return this->emitSetLocal(*VarT, Offset, VD) && Scope.destroyLocals();
    }
    if (!this->visit(Init))
      return false;
 
    if (VarTy->isReferenceType()) {
      // [C++26][decl.ref]
      // The object designated by such a glvalue can be outside its lifetime
      // Because a null pointer value or a pointer past the end of an object
      // does not point to an object, a reference in a well-defined program
      // cannot refer to such things;
      assert(classifyPrim(VarTy) == PT_Ptr);
      if (!this->emitCheckRefInit(Init))
        return false;
    }
 
    return this->emitSetLocal(*VarT, Offset, VD);
  }
  // Local composite variables.
  if (UnsignedOrNone Offset =
          this->allocateLocal(VD, VarTy, ScopeKind::Block)) {
    if (!Init)
      return true;
 
    if (!this->emitGetPtrLocal(*Offset, Init))
      return false;
 
    return visitInitializerPop(Init);
  }
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitDtorCall(const VarDecl *VD, const APValue &Value) {
  assert(!canClassify(VD->getType()));
 
  DeclScope<Emitter> LocalScope(this, VD);
  // Create a local variable to use as the instance.
  QualType Ty = VD->getType();
  Descriptor *D =
      P.createDescriptor(VD, Ty.getTypePtr(), /*IsConst=*/Ty.isConstQualified(),
                         /*IsTemporary=*/false, /*IsMutable=*/false,
                         /*IsVolatile=*/Ty.isVolatileQualified(), nullptr);
  if (!D)
    return false;
 
  // FIXME: Would be nice if we didn't allocate the descriptor at all in this
  // case.
  if (D->hasTrivialDtor())
    return true;
 
  Scope::Local Local = this->createLocal(D);
  Locals.insert({VD, Local});
  VarScope->addForScopeKind(Local, ScopeKind::Block);
 
  if (!this->emitGetPtrLocal(Local.Offset, VD))
    return false;
 
  if (!this->visitAPValueInitializer(Value, VD, Ty))
    return false;
 
  return this->emitDestructionPop(D, VD);
}
 
class ParamFinder : public ConstDynamicRecursiveASTVisitor {
public:
  llvm::SmallPtrSet<const ParmVarDecl *, 1> FoundParams;
  explicit ParamFinder() {}
 
  bool VisitDeclRefExpr(const DeclRefExpr *E) override {
    if (const auto *P = dyn_cast<ParmVarDecl>(E->getDecl()))
      FoundParams.insert(P);
    return true;
  }
};
 
/// Evaluate the \p Condition as if it was in the body of \p Callee.
/// Specifically, all the parameters of the callee are available to use
/// for the condition, and their values are given by \p Args (and \p This).
///
// Since this is a somewhat niche feature, we're abusing a few other mechanisms
// to implement this.
//
// We don't create an actual function frame but instead register the parameters
// as local variables.
//
// So we evaluate something like:
//
// bool thisfunc() {
//    auto Arg0 = Args[0];
//    ...
//    return Condition;
// }
//
template <class Emitter>
bool Compiler<Emitter>::visitWithSubstitutions(const FunctionDecl *Callee,
                                               ArrayRef<const Expr *> Args,
                                               const Expr *This,
                                               const Expr *Condition) {
  // Instead of evaluating all parameters and trying to ignore failure,
  // we collect all the parameters used in the condition and only evaluate
  // those. Note that we still ignore failure in the loop below because the
  // failure might be inconsequential in the end,
  // e.g. in the case of `true || x`.
  ParamFinder PF;
  PF.TraverseStmt(Condition);
 
  LocalScope<Emitter> ArgScope(this);
  for (const ParmVarDecl *PVD : PF.FoundParams) {
    unsigned ParamIndex = 0;
    for (const ParmVarDecl *P : Callee->parameters()) {
      if (P == PVD)
        break;
      ++ParamIndex;
    }
 
    const Expr *Arg = Args[ParamIndex];
    const ParmVarDecl *Param = Callee->getParamDecl(ParamIndex);
    if (OptPrimType ParamT = classify(Param->getType())) {
      unsigned ArgOffset =
          allocateLocalPrimitive(Param, *ParamT, /*IsConst=*/true);
      if (!this->visit(Arg))
        continue;
      if (!this->emitSetLocal(*ParamT, ArgOffset, Arg))
        return false;
    } else {
      UnsignedOrNone ArgOffset = this->allocateLocal(Param, Param->getType());
      if (!ArgOffset)
        return false;
      if (!this->emitGetPtrLocal(*ArgOffset, Arg))
        return false;
      if (!this->visitInitializerPop(Arg))
        continue;
    }
  }
 
  if (This) {
    // We abuse the init stack for this and tell it to use
    // either a local variable or another decl for the This pointer.
    this->InitStackActive = true;
 
    if (This->getType()->isPointerType()) {
      // Nothing to do here, the evaluation will fail if the instance
      // pointer is used.
    } else if (const auto *DRE = dyn_cast<DeclRefExpr>(This)) {
      InitStack.push_back(InitLink::Decl(DRE->getDecl()));
    } else {
      assert(!canClassify(This->getType()));
      UnsignedOrNone ArgOffset = this->allocateLocal(This, This->getType());
      if (!ArgOffset)
        return false;
      if (!this->emitGetPtrLocal(*ArgOffset, This))
        return false;
      if (!this->visitInitializerPop(This))
        return false;
      this->InitStack.push_back(InitLink::Temp(*ArgOffset));
    }
  }
 
  // Destruction of the argument values is part of the callee frame,
  // so we simply ignore them here.
  this->VarScope = nullptr;
 
  LocalScope<Emitter> RetScope(this);
  if (!this->visit(Condition))
    return false;
  if (!RetScope.destroyLocals())
    return false;
 
  // Result of the condition should be on the stack.
  return this->emitRet(PT_Bool, Condition);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitAPValue(const APValue &Val, PrimType ValType,
                                     SourceInfo Info) {
  assert(!Val.isIndeterminate() && "Needs to be checked before");
  assert(!DiscardResult);
  if (Val.isInt())
    return this->emitConst(Val.getInt(), ValType, Info);
  if (Val.isFloat())
    return this->emitFloat(Val.getFloat(), Info);
 
  if (Val.isMemberPointer()) {
    if (const ValueDecl *MemberDecl = Val.getMemberPointerDecl()) {
      if (!this->emitGetMemberPtr(MemberDecl, Info))
        return false;
 
      bool IsDerived = Val.isMemberPointerToDerivedMember();
      // Apply the member pointer path.
      for (const CXXRecordDecl *PathEntry : Val.getMemberPointerPath()) {
        if (!this->emitCopyMemberPtrPath(PathEntry, IsDerived, Info))
          return false;
      }
 
      return true;
    }
    return this->emitNullMemberPtr(0, nullptr, Info);
  }
 
  if (Val.isLValue()) {
    if (Val.isNullPointer())
      return this->emitNull(ValType, 0, nullptr, Info);
 
    APValue::LValueBase Base = Val.getLValueBase();
    QualType EntryType;
    if (const Expr *BaseExpr = Base.dyn_cast<const Expr *>()) {
      if (!this->visit(BaseExpr))
        return false;
      EntryType = BaseExpr->getType();
    } else if (const auto *VD = Base.dyn_cast<const ValueDecl *>()) {
      if (!this->visitDeclRef(VD, Info.asExpr()))
        return false;
      EntryType = VD->getType();
    } else if (Base.is<TypeInfoLValue>()) {
      // The type_info object for the type the lvalue describes.
      const Type *OperandType = Base.get<TypeInfoLValue>()
                                    .getType()
                                    ->getCanonicalTypeUnqualified()
                                    .getTypePtr();
      EntryType = Base.getTypeInfoType();
      if (!this->emitGetTypeid(OperandType, EntryType.getTypePtr(), Info))
        return false;
    } else if (!Base) {
      // An integer cast to a pointer.
      const Expr *E = Info.asExpr();
      if (!E)
        return false;
      QualType PtrType = E->isGLValue()
                             ? Ctx.getASTContext().getPointerType(E->getType())
                             : E->getType();
      uint64_t Offset = Val.getLValueOffset().getQuantity();
      if (!this->emitConstUint64(Offset, Info))
        return false;
      if (!this->emitGetIntPtrUint64(PtrType.getTypePtr(), Info))
        return false;
      EntryType = PtrType->getPointeeType();
    } else {
      return false;
    }
 
    if (Val.hasLValuePath()) {
      for (auto &Entry : Val.getLValuePath()) {
        if (EntryType->isArrayType()) {
          uint64_t Index = Entry.getAsArrayIndex();
          QualType ElemType =
              EntryType->getAsArrayTypeUnsafe()->getElementType();
          if (!this->emitConst(Index, PT_Uint64, Info))
            return false;
          if (!this->emitArrayElemPtrPop(PT_Uint64, Info))
            return false;
          EntryType = ElemType;
        } else {
          assert(EntryType->isRecordType());
          const Record *EntryRecord = getRecord(EntryType);
          if (!EntryRecord)
            return false;
 
          const Decl *BaseOrMember = Entry.getAsBaseOrMember().getPointer();
          if (const auto *FD = dyn_cast<FieldDecl>(BaseOrMember)) {
            unsigned EntryOffset = EntryRecord->getField(FD)->Offset;
            if (!this->emitGetPtrFieldPop(EntryOffset, Info))
              return false;
            EntryType = FD->getType();
          } else {
            const auto *Base = cast<CXXRecordDecl>(BaseOrMember);
            if (const Record::Base *B = EntryRecord->getBaseOrNull(Base)) {
              if (!this->emitGetPtrBasePop(B->Offset, /*NullOK=*/false, Info))
                return false;
            } else {
              // Must be a virtual base.
              assert(EntryRecord->findVirtualBase(Base));
              if (!this->emitGetPtrVirtBasePop(Base, Info))
                return false;
            }
            EntryType = Ctx.getASTContext().getCanonicalTagType(Base);
          }
        }
      }
    }
 
    if (isPtrType(ValType))
      return true;
 
    // A pointer cast to an integer is stored as an lvalue; cast it the same
    // way the source expression does.
    if (ValType == PT_IntAP || ValType == PT_IntAPS) {
      const Expr *E = Info.asExpr();
      if (!E)
        return false;
      uint32_t BitWidth = Ctx.getBitWidth(E->getType());
      return ValType == PT_IntAP
                 ? this->emitCastPointerIntegralAP(BitWidth, Info)
                 : this->emitCastPointerIntegralAPS(BitWidth, Info);
    }
    return this->emitCastPointerIntegral(ValType, Info);
  }
 
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitAPValueInitializer(const APValue &Val,
                                                SourceInfo Info, QualType T,
                                                bool IsCompleteClass) {
  if (Val.isStruct()) {
    const Record *R = this->getRecord(T);
    assert(R);
 
    assert(R->getNumBases() == Val.getStructNumBases());
    if (IsCompleteClass)
      assert(R->getNumVirtualBases() == Val.getStructNumVirtualBases());
 
    for (unsigned I = 0, N = Val.getStructNumBases(); I != N; ++I) {
      const APValue &B = Val.getStructBase(I);
      if (B.isIndeterminate())
        continue;
      const Record::Base *RB = R->getBase(I);
      QualType BaseType = Ctx.getASTContext().getCanonicalTagType(RB->Decl);
 
      if (!this->emitGetPtrBase(RB->Offset, Info))
        return false;
      if (!this->visitAPValueInitializer(B, Info, BaseType,
                                         /*IsCompleteClass=*/false))
        return false;
      if (!this->emitFinishInitPop(Info))
        return false;
    }
 
    for (unsigned I = 0, N = Val.getStructNumFields(); I != N; ++I) {
      const APValue &F = Val.getStructField(I);
      if (F.isIndeterminate())
        continue;
      const Record::Field *RF = R->getField(I);
      QualType FieldType = RF->Decl->getType();
      // Fields.
      if (OptPrimType PT = RF->T) {
        if (!this->visitAPValue(F, *PT, Info))
          return false;
        if (!this->emitInitField(*PT, RF->Offset, Info))
          return false;
      } else {
        if (!this->emitGetPtrField(RF->Offset, Info))
          return false;
        if (!this->visitAPValueInitializer(F, Info, FieldType))
          return false;
        if (!this->emitFinishInitPop(Info))
          return false;
      }
    }
 
    // Virtual Bases.
    if (IsCompleteClass) {
      for (unsigned I = 0, N = Val.getStructNumVirtualBases(); I != N; ++I) {
        const APValue &B = Val.getStructVirtualBase(I);
        if (B.isIndeterminate())
          continue;
        const Record::Base *RB = R->getVirtualBase(I);
        QualType BaseType = Ctx.getASTContext().getCanonicalTagType(RB->Decl);
 
        if (!this->emitGetPtrVirtBase(cast<CXXRecordDecl>(RB->R->getDecl()),
                                      Info))
          return false;
        if (!this->visitAPValueInitializer(B, Info, BaseType,
                                           /*IsCompleteClass=*/false))
          return false;
        if (!this->emitFinishInitPop(Info))
          return false;
      }
    }
 
    return true;
  }
  if (Val.isUnion()) {
    const FieldDecl *UnionField = Val.getUnionField();
    if (!UnionField)
      return true;
    const Record *R = this->getRecord(T);
    assert(R);
    const APValue &F = Val.getUnionValue();
    if (F.isIndeterminate())
      return true;
    const Record::Field *RF = R->getField(UnionField);
    QualType FieldType = RF->Decl->getType();
 
    if (OptPrimType PT = RF->T) {
      if (!this->visitAPValue(F, *PT, Info))
        return false;
      if (RF->isBitField())
        return this->emitInitBitFieldActivate(*PT, RF->Offset, RF->bitWidth(),
                                              Info);
      return this->emitInitFieldActivate(*PT, RF->Offset, Info);
    }
 
    if (!this->emitGetPtrField(RF->Offset, Info))
      return false;
    if (!this->emitActivate(Info))
      return false;
    if (!this->visitAPValueInitializer(F, Info, FieldType))
      return false;
    return this->emitPopPtr(Info);
  }
  if (Val.isArray()) {
    unsigned InitializedElems = Val.getArrayInitializedElts();
    const auto *ArrType = T->getAsArrayTypeUnsafe();
    QualType ElemType = ArrType->getElementType();
    OptPrimType ElemT = classify(ElemType);
 
    for (unsigned A = 0, AN = Val.getArraySize(); A != AN; ++A) {
      const APValue &Elem = A >= InitializedElems
                                ? Val.getArrayFiller()
                                : Val.getArrayInitializedElt(A);
      if (Elem.isIndeterminate())
        continue;
 
      if (ElemT) {
        if (!this->visitAPValue(Elem, *ElemT, Info))
          return false;
        if (!this->emitInitElem(*ElemT, A, Info))
          return false;
      } else {
        if (!this->emitConstUint32(A, Info))
          return false;
        if (!this->emitArrayElemPtrUint32(Info))
          return false;
        if (!this->visitAPValueInitializer(Elem, Info, ElemType))
          return false;
        if (!this->emitPopPtr(Info))
          return false;
      }
    }
    return true;
  }
  if (Val.isComplexFloat()) {
    assert(T->isComplexType());
    if (!this->emitFloat(Val.getComplexFloatReal(), Info))
      return false;
    if (!this->emitInitElemFloat(0, Info))
      return false;
    if (!this->emitFloat(Val.getComplexFloatImag(), Info))
      return false;
    if (!this->emitInitElemFloat(1, Info))
      return false;
    return true;
  }
  if (Val.isComplexInt()) {
    assert(T->isComplexIntegerType());
    PrimType IntT = classifyPrim(T->castAs<ComplexType>()->getElementType());
    if (!this->emitConst(Val.getComplexIntReal(), IntT, Info))
      return false;
    if (!this->emitInitElem(IntT, 0, Info))
      return false;
    if (!this->emitConst(Val.getComplexIntImag(), IntT, Info))
      return false;
    if (!this->emitInitElem(IntT, 1, Info))
      return false;
    return true;
  }
  if (Val.isVector()) {
    assert(T->isVectorType());
    PrimType ElemT = classifyPrim(T->castAs<VectorType>()->getElementType());
    for (unsigned I = 0, N = Val.getVectorLength(); I != N; ++I) {
      const APValue &Elem = Val.getVectorElt(I);
      if (Elem.isIndeterminate())
        continue;
      if (!this->visitAPValue(Elem, ElemT, Info))
        return false;
      if (!this->emitInitElem(ElemT, I, Info))
        return false;
    }
    return true;
  }
 
  // TODO: Other types.
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::registerRedecl(const VarDecl *VD, const APValue &Val) {
  if (P.getGlobal(VD))
    return true;
 
  UnsignedOrNone GlobalIndex = P.createGlobal(VD, /*Init=*/nullptr);
  if (!GlobalIndex) {
    llvm_unreachable("Why didn't that work?");
  }
 
  assert(canClassify(VD->getType()) &&
         "registerRedecl should only be called with primitive values");
 
  PrimType T = classifyPrim(VD->getType());
  if (!visitAPValue(Val, T, VD))
    return false;
  return this->emitInitGlobal(T, *GlobalIndex, {});
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitBuiltinCallExpr(const CallExpr *E,
                                             unsigned BuiltinID) {
  const ASTContext &ASTCtx = Ctx.getASTContext();
 
  // BuiltinID is the raw ID baked into the bytecode. The "is constant
  // evaluated" gate needs the raw ID so that auxiliary-target IDs resolve into
  // the correct (aux-target) builtin records.
  if (!Ctx.getASTContext().BuiltinInfo.isConstantEvaluated(BuiltinID))
    return this->emitInvalid(E);
 
  // Convert an auxiliary x86 target builtin ID to its canonical X86::BI* value
  // so the target-specific cases below (and the handlers they call) match. This
  // is a cheap integer operation (a single comparison for the common,
  // target-independent case); we deliberately avoid re-deriving the ID from the
  // call expression, which is comparatively slow.
  BuiltinID = ConvertBuiltinIDToX86BuiltinID(ASTCtx, BuiltinID);
 
  if (BuiltinID == Builtin::BI__builtin_constant_p) {
    // Void argument is always invalid and harder to handle later.
    if (E->getArg(0)->getType()->isVoidType()) {
      if (DiscardResult)
        return true;
      return this->emitConst(0, E);
    }
 
    if (!this->emitStartSpeculation(E))
      return false;
    LabelTy EndLabel = this->getLabel();
    if (!this->speculate(E, EndLabel))
      return false;
    if (!this->emitEndSpeculation(E))
      return false;
    this->fallthrough(EndLabel);
    if (DiscardResult)
      return this->emitPop(classifyPrim(E), E);
    return true;
  }
 
  // For these, we're expected to ultimately return an APValue pointing
  // to the CallExpr. This is needed to get the correct codegen.
  if (BuiltinID == Builtin::BI__builtin___CFStringMakeConstantString ||
      BuiltinID == Builtin::BI__builtin___NSStringMakeConstantString ||
      BuiltinID == Builtin::BI__builtin_ptrauth_sign_constant ||
      BuiltinID == Builtin::BI__builtin_function_start) {
    if (DiscardResult)
      return true;
    return this->emitDummyPtr(E, E);
  }
 
  QualType ReturnType = E->getType();
  OptPrimType ReturnT = classify(E);
 
  // Non-primitive return type. Prepare storage.
  if (!Initializing && !ReturnT && !ReturnType->isVoidType()) {
    UnsignedOrNone LocalIndex = allocateLocal(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
 
  // Prepare function arguments including special cases.
  switch (BuiltinID) {
  case Builtin::BI__builtin_object_size:
  case Builtin::BI__builtin_dynamic_object_size: {
    assert(E->getNumArgs() == 2);
    const Expr *Arg0 = E->getArg(0);
    if (Arg0->isGLValue()) {
      if (!this->visit(Arg0))
        return false;
 
    } else {
      if (!this->visitAsLValue(ignorePointerCastsAndParens(Arg0)))
        return false;
    }
    if (!this->visit(E->getArg(1)))
      return false;
 
  } break;
  case Builtin::BI__assume:
  case Builtin::BI__builtin_assume:
    // Argument is not evaluated.
    break;
  case Builtin::BI__atomic_is_lock_free:
  case Builtin::BI__atomic_always_lock_free: {
    assert(E->getNumArgs() == 2);
    if (!this->visit(E->getArg(0)))
      return false;
    if (!this->visitAsLValue(E->getArg(1)))
      return false;
  } break;
 
  default:
    if (!Context::isUnevaluatedBuiltin(BuiltinID)) {
      // Put arguments on the stack.
      for (const auto *Arg : E->arguments()) {
        if (!this->visit(Arg))
          return false;
      }
    }
  }
 
  if (!this->emitCallBI(E, BuiltinID, E))
    return false;
 
  if (DiscardResult && !ReturnType->isVoidType())
    return this->emitPop(ReturnT.value_or(PT_Ptr), E);
 
  return true;
}
 
static bool isTrivialMemoryOperation(const CXXMethodDecl *MD) {
  if (!MD || !MD->isDefaulted())
    return false;
  if (!MD->isCopyAssignmentOperator() && !MD->isMoveAssignmentOperator())
    return false;
  return MD->getParent()->isUnion() ||
         (MD->isTrivial() && isReadByLvalueToRvalueConversion(MD->getParent()));
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCallExpr(const CallExpr *E) {
  if (E->containsErrors())
    return false;
  const FunctionDecl *FuncDecl = E->getDirectCallee();
 
  if (FuncDecl) {
    if (unsigned BuiltinID = FuncDecl->getBuiltinID())
      return VisitBuiltinCallExpr(E, BuiltinID);
 
    // Calls to replaceable operator new/operator delete.
    if (FuncDecl->isUsableAsGlobalAllocationFunctionInConstantEvaluation()) {
      if (FuncDecl->getDeclName().isAnyOperatorNew())
        return VisitBuiltinCallExpr(E, Builtin::BI__builtin_operator_new);
      assert(FuncDecl->getDeclName().getCXXOverloadedOperator() == OO_Delete ||
             FuncDecl->getDeclName().getCXXOverloadedOperator() ==
                 OO_Array_Delete);
      return VisitBuiltinCallExpr(E, Builtin::BI__builtin_operator_delete);
    }
 
    // Explicit calls to trivial destructors
    if (const auto *DD = dyn_cast<CXXDestructorDecl>(FuncDecl);
        DD && DD->isTrivial()) {
      const auto *MemberCall = cast<CXXMemberCallExpr>(E);
      if (!this->visit(MemberCall->getImplicitObjectArgument()))
        return false;
      return this->emitCheckDestruction(E) && this->emitEndLifetime(E) &&
             this->emitPopPtr(E);
    }
  }
 
  LocalScope<Emitter> CallScope(this, ScopeKind::Call);
  ArrayRef<const Expr *> Args(E->getArgs(), E->getNumArgs());
  bool ActivateLHS = false;
 
  // Emit a special op for trivial copy/move operators.
  if (isTrivialMemoryOperation(dyn_cast_if_present<CXXMethodDecl>(FuncDecl))) {
    const Function *Func = getFunction(FuncDecl);
    if (!Func)
      return false;
 
    if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E);
        OCE && OCE->isAssignmentOp()) {
      const CXXRecordDecl *LHSRecord = Args[0]->getType()->getAsCXXRecordDecl();
      ActivateLHS = LHSRecord && LHSRecord->hasTrivialDefaultConstructor();
    }
    if (const auto *MCE = dyn_cast<CXXMemberCallExpr>(E))
      if (!this->visit(MCE->getImplicitObjectArgument()))
        return false;
 
    if (!this->visitCallArgs(Args, FuncDecl, /*ActivateLHS=*/ActivateLHS,
                             isa<CXXOperatorCallExpr>(E)))
      return false;
 
    if (!this->emitTrivialCopy(ActivateLHS, Func, E))
      return false;
 
    if (!DiscardResult)
      return CallScope.destroyLocals();
    return this->emitPopPtr(E) && CallScope.destroyLocals();
  }
 
  QualType ReturnType = E->getCallReturnType(Ctx.getASTContext());
  OptPrimType T = classify(ReturnType);
  bool HasRVO = !ReturnType->isVoidType() && !T;
 
  if (HasRVO) {
    if (DiscardResult) {
      // If we need to discard the return value but the function returns its
      // value via an RVO pointer, we need to create one such pointer just
      // for this call.
      if (UnsignedOrNone LocalIndex = allocateLocal(E)) {
        if (!this->emitGetPtrLocal(*LocalIndex, E))
          return false;
      }
    } else {
      // We need the result. Prepare a pointer to return or
      // dup the current one.
      if (!Initializing) {
        if (UnsignedOrNone LocalIndex = allocateLocal(E)) {
          if (!this->emitGetPtrLocal(*LocalIndex, E))
            return false;
        }
      }
      if (!this->emitDupPtr(E))
        return false;
    }
  }
 
  const Expr *ReversedArgs[2];
  bool IsAssignmentOperatorCall = false;
  if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E);
      OCE && OCE->isAssignmentOp()) {
    // Just like with regular assignments, we need to special-case assignment
    // operators here and evaluate the RHS (the second arg) before the LHS (the
    // first arg). We fix this by using a Flip op later.
    assert(Args.size() == 2);
    const CXXRecordDecl *LHSRecord = Args[0]->getType()->getAsCXXRecordDecl();
    ActivateLHS = LHSRecord && LHSRecord->hasTrivialDefaultConstructor();
    IsAssignmentOperatorCall = true;
    ReversedArgs[0] = Args[1];
    ReversedArgs[1] = Args[0];
    Args = ReversedArgs;
  }
 
  // Calling a static operator will still
  // pass the instance, but we don't need it.
  // Discard it here.
  if (isa<CXXOperatorCallExpr>(E)) {
    if (const auto *MD = dyn_cast_if_present<CXXMethodDecl>(FuncDecl);
        MD && MD->isStatic()) {
      if (!this->discard(E->getArg(0)))
        return false;
      // Drop first arg.
      Args = Args.drop_front();
    }
  }
 
  bool Devirtualized = false;
  UnsignedOrNone CalleeOffset = std::nullopt;
  // Add the (optional, implicit) This pointer.
  if (const auto *MC = dyn_cast<CXXMemberCallExpr>(E)) {
    if (!FuncDecl && classifyPrim(E->getCallee()) == PT_MemberPtr) {
      // If we end up creating a CallPtr op for this, we need the base of the
      // member pointer as the instance pointer, and later extract the function
      // decl as the function pointer.
      const Expr *Callee = E->getCallee();
      CalleeOffset =
          this->allocateLocalPrimitive(Callee, PT_MemberPtr, /*IsConst=*/true);
      if (!this->visit(Callee))
        return false;
      if (!this->emitSetLocal(PT_MemberPtr, *CalleeOffset, E))
        return false;
      if (!this->emitGetLocal(PT_MemberPtr, *CalleeOffset, E))
        return false;
      if (!this->emitGetMemberPtrBase(E))
        return false;
    } else {
      const auto *InstancePtr = MC->getImplicitObjectArgument();
      if (isa_and_nonnull<CXXDestructorDecl>(CompilingFunction) ||
          isa_and_nonnull<CXXConstructorDecl>(CompilingFunction)) {
        const auto *Stripped = stripCheckedDerivedToBaseCasts(InstancePtr);
        if (isa<CXXThisExpr>(Stripped)) {
          FuncDecl =
              cast<CXXMethodDecl>(FuncDecl)->getCorrespondingMethodInClass(
                  Stripped->getType()->getPointeeType()->getAsCXXRecordDecl());
          Devirtualized = true;
          if (!this->visit(Stripped))
            return false;
        } else {
          if (!this->visit(InstancePtr))
            return false;
        }
      } else {
        if (!this->visit(InstancePtr))
          return false;
      }
    }
  } else if (const auto *PD =
                 dyn_cast<CXXPseudoDestructorExpr>(E->getCallee())) {
    if (!this->emitCheckPseudoDtor(E))
      return false;
    const Expr *Base = PD->getBase();
    // E.g. `using T = int; 0.~T();`.
    if (OptPrimType BaseT = classify(Base); !BaseT || BaseT != PT_Ptr)
      return this->discard(Base);
    if (!this->visit(Base))
      return false;
    return this->emitPseudoDtor(E);
  } else if (!FuncDecl) {
    const Expr *Callee = E->getCallee();
    CalleeOffset =
        this->allocateLocalPrimitive(Callee, PT_Ptr, /*IsConst=*/true);
    if (!this->visit(Callee))
      return false;
    if (!this->emitSetLocal(PT_Ptr, *CalleeOffset, E))
      return false;
  }
 
  if (!this->visitCallArgs(Args, FuncDecl, ActivateLHS,
                           isa<CXXOperatorCallExpr>(E)))
    return false;
 
  // Undo the argument reversal we did earlier.
  if (IsAssignmentOperatorCall) {
    assert(Args.size() == 2);
    PrimType Arg1T = classify(Args[0]).value_or(PT_Ptr);
    PrimType Arg2T = classify(Args[1]).value_or(PT_Ptr);
    if (!this->emitFlip(Arg2T, Arg1T, E))
      return false;
  }
 
  if (FuncDecl) {
    const Function *Func = getFunction(FuncDecl);
    if (!Func)
      return false;
 
    // In error cases, the function may be called with fewer arguments than
    // parameters.
    if (E->getNumArgs() < Func->getNumWrittenParams())
      return false;
 
    assert(HasRVO == Func->hasRVO());
 
    bool HasQualifier = false;
    if (const auto *ME = dyn_cast<MemberExpr>(E->getCallee()))
      HasQualifier = ME->hasQualifier();
 
    bool IsVirtual = false;
    if (const auto *MD = dyn_cast<CXXMethodDecl>(FuncDecl))
      IsVirtual = !Devirtualized && MD->isVirtual();
 
    // In any case call the function. The return value will end up on the stack
    // and if the function has RVO, we already have the pointer on the stack to
    // write the result into.
    if (IsVirtual && !HasQualifier) {
      uint32_t VarArgSize = 0;
      unsigned NumParams =
          Func->getNumWrittenParams() +
          (isa<CXXOperatorCallExpr>(E) && Func->hasImplicitThisPointer());
      for (unsigned I = NumParams, N = E->getNumArgs(); I != N; ++I)
        VarArgSize += align(primSize(classify(E->getArg(I)).value_or(PT_Ptr)));
 
      if (!this->emitCallVirt(Func, VarArgSize, E))
        return false;
    } else if (Func->isVariadic()) {
      uint32_t VarArgSize = 0;
      unsigned NumParams =
          Func->getNumWrittenParams() +
          (isa<CXXOperatorCallExpr>(E) && Func->hasImplicitThisPointer());
      for (unsigned I = NumParams, N = E->getNumArgs(); I != N; ++I)
        VarArgSize += align(primSize(classify(E->getArg(I)).value_or(PT_Ptr)));
      if (!this->emitCallVar(Func, VarArgSize, E))
        return false;
    } else {
      if (!this->emitCall(Func, 0, E))
        return false;
    }
  } else {
    // Indirect call. Visit the callee, which will leave a FunctionPointer on
    // the stack. Cleanup of the returned value if necessary will be done after
    // the function call completed.
 
    // Sum the size of all args from the call expr.
    uint32_t ArgSize = 0;
    for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
      ArgSize += align(primSize(classify(E->getArg(I)).value_or(PT_Ptr)));
 
    // Get the callee, either from a member pointer or function pointer saved in
    // CalleeOffset.
    if (isa<CXXMemberCallExpr>(E) && CalleeOffset) {
      if (!this->emitGetLocal(PT_MemberPtr, *CalleeOffset, E))
        return false;
      if (!this->emitGetMemberPtrDecl(E))
        return false;
    } else {
      if (!this->emitGetLocal(PT_Ptr, *CalleeOffset, E))
        return false;
    }
    if (!this->emitCallPtr(ArgSize, E, E))
      return false;
  }
 
  // Cleanup for discarded return values.
  if (DiscardResult && !ReturnType->isVoidType() && T)
    return this->emitPop(*T, E) && CallScope.destroyLocals();
 
  return CallScope.destroyLocals();
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
  SourceLocScope<Emitter> SLS(this, E);
 
  return this->delegate(E->getExpr());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) {
  SourceLocScope<Emitter> SLS(this, E);
 
  return this->delegate(E->getExpr());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
  if (DiscardResult)
    return true;
 
  return this->emitConstBool(E->getValue(), E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXNullPtrLiteralExpr(
    const CXXNullPtrLiteralExpr *E) {
  if (DiscardResult)
    return true;
 
  uint64_t Val = Ctx.getASTContext().getTargetNullPointerValue(E->getType());
  return this->emitNullPtr(Val, nullptr, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitGNUNullExpr(const GNUNullExpr *E) {
  if (DiscardResult)
    return true;
 
  assert(E->getType()->isIntegerType());
 
  PrimType T = classifyPrim(E->getType());
  return this->emitZero(T, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitCXXThisExpr(const CXXThisExpr *E) {
  if (DiscardResult)
    return true;
 
  if constexpr (!std::is_same_v<Emitter, EvalEmitter>) {
    if (this->LambdaThisCapture.Offset > 0) {
      if (this->LambdaThisCapture.IsPtr)
        return this->emitGetThisFieldPtr(this->LambdaThisCapture.Offset, E);
      return this->emitGetPtrThisField(this->LambdaThisCapture.Offset, E);
    }
  }
 
  // In some circumstances, the 'this' pointer does not actually refer to the
  // instance pointer of the current function frame, but e.g. to the declaration
  // currently being initialized. Here we emit the necessary instruction(s) for
  // this scenario.
  if (!InitStackActive || InitStack.empty())
    return this->emitThis(E);
 
  // If our init stack is, for example:
  // 0 Stack: 3 (decl)
  // 1 Stack: 6 (init list)
  // 2 Stack: 1 (field)
  // 3 Stack: 6 (init list)
  // 4 Stack: 1 (field)
  //
  // We want to find the LAST element in it that's an init list,
  // which is marked with the K_InitList marker. The index right
  // before that points to an init list. We need to find the
  // elements before the K_InitList element that point to a base
  // (e.g. a decl or This), optionally followed by field, elem, etc.
  // In the example above, we want to emit elements [0..2].
  unsigned StartIndex = 0;
  unsigned EndIndex = 0;
  // Find the init list.
  for (StartIndex = InitStack.size() - 1; StartIndex > 0; --StartIndex) {
    if (InitStack[StartIndex].Kind == InitLink::K_DIE) {
      EndIndex = StartIndex;
      --StartIndex;
      break;
    }
  }
 
  // Walk backwards to find the base.
  for (; StartIndex > 0; --StartIndex) {
    if (InitStack[StartIndex].Kind == InitLink::K_InitList)
      continue;
 
    if (InitStack[StartIndex].Kind != InitLink::K_Field &&
        InitStack[StartIndex].Kind != InitLink::K_Elem &&
        InitStack[StartIndex].Kind != InitLink::K_Base &&
        InitStack[StartIndex].Kind != InitLink::K_DIE)
      break;
  }
 
  if (StartIndex == 0 && EndIndex == 0)
    EndIndex = InitStack.size() - 1;
 
  assert(InitStack[StartIndex].Kind == InitLink::K_Decl ||
         InitStack[StartIndex].Kind == InitLink::K_This ||
         InitStack[StartIndex].Kind == InitLink::K_Temp ||
         InitStack[StartIndex].Kind == InitLink::K_RVO);
 
  // NOTE: This could be StartIndex < EndIndex, but we're also abusing the
  // InitStack mechanism in visitWithSubstitutions to have the This pointer
  // _just_ be a local variable.
  assert(StartIndex <= EndIndex);
 
  // Emit the instructions.
  for (unsigned I = StartIndex; I != (EndIndex + 1); ++I) {
    if (InitStack[I].Kind == InitLink::K_InitList ||
        InitStack[I].Kind == InitLink::K_DIE)
      continue;
    if (!InitStack[I].template emit<Emitter>(this, E))
      return false;
  }
  return true;
}
 
template <class Emitter> bool Compiler<Emitter>::visitStmt(const Stmt *S) {
  switch (S->getStmtClass()) {
  case Stmt::CompoundStmtClass:
    return visitCompoundStmt(cast<CompoundStmt>(S));
  case Stmt::DeclStmtClass:
    return visitDeclStmt(cast<DeclStmt>(S), /*EvaluateConditionDecl=*/true);
  case Stmt::ReturnStmtClass:
    return visitReturnStmt(cast<ReturnStmt>(S));
  case Stmt::IfStmtClass:
    return visitIfStmt(cast<IfStmt>(S));
  case Stmt::WhileStmtClass:
    return visitWhileStmt(cast<WhileStmt>(S));
  case Stmt::DoStmtClass:
    return visitDoStmt(cast<DoStmt>(S));
  case Stmt::ForStmtClass:
    return visitForStmt(cast<ForStmt>(S));
  case Stmt::CXXForRangeStmtClass:
    return visitCXXForRangeStmt(cast<CXXForRangeStmt>(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:
    return visitCaseStmt(cast<CaseStmt>(S));
  case Stmt::DefaultStmtClass:
    return visitDefaultStmt(cast<DefaultStmt>(S));
  case Stmt::AttributedStmtClass:
    return visitAttributedStmt(cast<AttributedStmt>(S));
  case Stmt::CXXTryStmtClass:
    return visitCXXTryStmt(cast<CXXTryStmt>(S));
  case Stmt::NullStmtClass:
    return true;
  // Always invalid statements.
  case Stmt::GCCAsmStmtClass:
  case Stmt::MSAsmStmtClass:
  case Stmt::GotoStmtClass:
    return this->emitInvalid(S);
  case Stmt::LabelStmtClass:
    return this->visitStmt(cast<LabelStmt>(S)->getSubStmt());
  case Stmt::CXXExpansionStmtInstantiationClass:
    return this->visitCXXExpansionStmtInstantiation(
        cast<CXXExpansionStmtInstantiation>(S));
  default: {
    if (const auto *E = dyn_cast<Expr>(S))
      return this->discard(E);
    return false;
  }
  }
}
 
template <class Emitter>
bool Compiler<Emitter>::visitCompoundStmt(const CompoundStmt *S) {
  LocalScope<Emitter> Scope(this);
  for (const auto *InnerStmt : S->body())
    if (!visitStmt(InnerStmt))
      return false;
  return Scope.destroyLocals();
}
 
template <class Emitter>
bool Compiler<Emitter>::maybeEmitDeferredVarInit(const VarDecl *VD) {
  if (auto *DD = dyn_cast_if_present<DecompositionDecl>(VD)) {
    for (auto *BD : DD->flat_bindings())
      if (auto *KD = BD->getHoldingVar();
          KD && !this->visitVarDecl(KD, KD->getInit()))
        return false;
  }
  return true;
}
 
static bool hasTrivialDefaultCtorParent(const FieldDecl *FD) {
  assert(FD);
  assert(FD->getParent()->isUnion());
  const CXXRecordDecl *CXXRD =
      FD->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
  return !CXXRD || CXXRD->hasTrivialDefaultConstructor();
}
 
template <class Emitter> bool Compiler<Emitter>::refersToUnion(const Expr *E) {
  for (;;) {
    if (const auto *ME = dyn_cast<MemberExpr>(E)) {
      if (const auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
          FD && FD->getParent()->isUnion() && hasTrivialDefaultCtorParent(FD))
        return true;
      E = ME->getBase();
      continue;
    }
 
    if (const auto *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
      E = ASE->getBase()->IgnoreImplicit();
      continue;
    }
 
    if (const auto *ICE = dyn_cast<ImplicitCastExpr>(E);
        ICE && (ICE->getCastKind() == CK_NoOp ||
                ICE->getCastKind() == CK_DerivedToBase ||
                ICE->getCastKind() == CK_UncheckedDerivedToBase)) {
      E = ICE->getSubExpr();
      continue;
    }
 
    if (const auto *This = dyn_cast<CXXThisExpr>(E)) {
      const auto *ThisRecord =
          This->getType()->getPointeeType()->getAsRecordDecl();
      if (!ThisRecord->isUnion())
        return false;
      // Otherwise, always activate if we're in the ctor.
      if (const auto *Ctor =
              dyn_cast_if_present<CXXConstructorDecl>(CompilingFunction))
        return Ctor->getParent() == ThisRecord;
      return false;
    }
 
    break;
  }
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitDeclStmt(const DeclStmt *DS,
                                      bool EvaluateConditionDecl) {
  for (const auto *D : DS->decls()) {
    if (isa<StaticAssertDecl, TagDecl, TypedefNameDecl, BaseUsingDecl,
            FunctionDecl, NamespaceAliasDecl, UsingDirectiveDecl>(D))
      continue;
 
    if (const auto *ESD = dyn_cast<CXXExpansionStmtDecl>(D)) {
      assert(ESD->getInstantiations() && "not expanded?");
      if (!this->visitStmt(ESD->getInstantiations()))
        return false;
      continue;
    }
 
    const auto *VD = dyn_cast<VarDecl>(D);
    if (!VD)
      return false;
    if (!this->visitVarDecl(VD, VD->getInit()))
      return false;
 
    // Register decomposition decl holding vars.
    if (EvaluateConditionDecl && !this->maybeEmitDeferredVarInit(VD))
      return false;
  }
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitReturnStmt(const ReturnStmt *RS) {
  if (this->InStmtExpr)
    return this->emitUnsupported(RS);
 
  if (const Expr *RE = RS->getRetValue()) {
    LocalScope<Emitter> RetScope(this);
    if (ReturnType) {
      // Primitive types are simply returned.
      if (!this->visit(RE))
        return false;
      this->emitCleanup();
      return this->emitRet(*ReturnType, RS);
    }
 
    if (RE->getType()->isVoidType()) {
      if (!this->visit(RE))
        return false;
    } else {
      if (RE->containsErrors())
        return false;
 
      InitLinkScope<Emitter> ILS(this, InitLink::RVO());
      // RVO - construct the value in the return location.
      if (!this->emitRVOPtr(RE))
        return false;
      if (!this->visitInitializerPop(RE))
        return false;
 
      this->emitCleanup();
      return this->emitRetVoid(RS);
    }
  }
 
  // Void return.
  this->emitCleanup();
  return this->emitRetVoid(RS);
}
 
template <class Emitter> bool Compiler<Emitter>::visitIfStmt(const IfStmt *IS) {
  LocalScope<Emitter> IfScope(this);
 
  auto visitChildStmt = [&](const Stmt *S) -> bool {
    LocalScope<Emitter> SScope(this);
    if (!visitStmt(S))
      return false;
    return SScope.destroyLocals();
  };
 
  if (auto *CondInit = IS->getInit()) {
    if (!visitStmt(CondInit))
      return false;
  }
 
  if (const DeclStmt *CondDecl = IS->getConditionVariableDeclStmt()) {
    if (!visitDeclStmt(CondDecl))
      return false;
  }
 
  // Save ourselves compiling some code and the jumps, etc. if the condition is
  // stataically known to be either true or false. We could look at more cases
  // here, but I think all the ones that actually happen are using a
  // ConstantExpr.
  if (std::optional<bool> BoolValue = getBoolValue(IS->getCond())) {
    if (*BoolValue)
      return visitChildStmt(IS->getThen());
    if (const Stmt *Else = IS->getElse())
      return visitChildStmt(Else);
    return true;
  }
 
  // Otherwise, compile the condition.
  if (IS->isNonNegatedConsteval()) {
    if (!this->emitIsConstantContext(IS))
      return false;
  } else if (IS->isNegatedConsteval()) {
    if (!this->emitIsConstantContext(IS))
      return false;
    if (!this->emitInv(IS))
      return false;
  } else {
    LocalScope<Emitter> CondScope(this, ScopeKind::FullExpression);
    if (!this->visitBool(IS->getCond()))
      return false;
    if (!CondScope.destroyLocals())
      return false;
  }
 
  if (!this->maybeEmitDeferredVarInit(IS->getConditionVariable()))
    return false;
 
  if (const Stmt *Else = IS->getElse()) {
    LabelTy LabelElse = this->getLabel();
    LabelTy LabelEnd = this->getLabel();
    if (!this->jumpFalse(LabelElse, IS))
      return false;
    if (!visitChildStmt(IS->getThen()))
      return false;
    if (!this->jump(LabelEnd, IS))
      return false;
    this->emitLabel(LabelElse);
    if (!visitChildStmt(Else))
      return false;
    this->emitLabel(LabelEnd);
  } else {
    LabelTy LabelEnd = this->getLabel();
    if (!this->jumpFalse(LabelEnd, IS))
      return false;
    if (!visitChildStmt(IS->getThen()))
      return false;
    this->emitLabel(LabelEnd);
  }
 
  if (!IfScope.destroyLocals())
    return false;
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitWhileStmt(const WhileStmt *S) {
  const Expr *Cond = S->getCond();
  const Stmt *Body = S->getBody();
 
  LabelTy CondLabel = this->getLabel(); // Label before the condition.
  LabelTy EndLabel = this->getLabel();  // Label after the loop.
  LocalScope<Emitter> WholeLoopScope(this);
  LoopScope<Emitter> LS(this, S, EndLabel, CondLabel);
 
  this->fallthrough(CondLabel);
  this->emitLabel(CondLabel);
 
  // Start of the loop body {
  LocalScope<Emitter> CondScope(this);
 
  if (const DeclStmt *CondDecl = S->getConditionVariableDeclStmt()) {
    if (!visitDeclStmt(CondDecl))
      return false;
  }
 
  if (!this->visitBool(Cond))
    return false;
 
  if (!this->maybeEmitDeferredVarInit(S->getConditionVariable()))
    return false;
 
  if (!this->jumpFalse(EndLabel, S))
    return false;
 
  if (!this->visitStmt(Body))
    return false;
 
  if (!CondScope.destroyLocals())
    return false;
  // } End of loop body.
 
  if (!this->jump(CondLabel, S))
    return false;
  this->fallthrough(EndLabel);
  this->emitLabel(EndLabel);
 
  return CondScope.destroyLocals() && WholeLoopScope.destroyLocals();
}
 
template <class Emitter> bool Compiler<Emitter>::visitDoStmt(const DoStmt *S) {
  const Expr *Cond = S->getCond();
  const Stmt *Body = S->getBody();
 
  LabelTy StartLabel = this->getLabel();
  LabelTy EndLabel = this->getLabel();
  LabelTy CondLabel = this->getLabel();
  LocalScope<Emitter> WholeLoopScope(this);
  LoopScope<Emitter> LS(this, S, EndLabel, CondLabel);
 
  this->fallthrough(StartLabel);
  this->emitLabel(StartLabel);
 
  {
    LocalScope<Emitter> CondScope(this);
    if (!this->visitStmt(Body))
      return false;
    this->fallthrough(CondLabel);
    this->emitLabel(CondLabel);
    if (!this->visitBool(Cond))
      return false;
 
    if (!CondScope.destroyLocals())
      return false;
  }
  if (!this->jumpTrue(StartLabel, S))
    return false;
 
  this->fallthrough(EndLabel);
  this->emitLabel(EndLabel);
  return WholeLoopScope.destroyLocals();
}
 
template <class Emitter>
bool Compiler<Emitter>::visitForStmt(const ForStmt *S) {
  // for (Init; Cond; Inc) { Body }
  const Stmt *Init = S->getInit();
  const Expr *Cond = S->getCond();
  const Expr *Inc = S->getInc();
  const Stmt *Body = S->getBody();
 
  LabelTy EndLabel = this->getLabel();
  LabelTy CondLabel = this->getLabel();
  LabelTy IncLabel = this->getLabel();
 
  LocalScope<Emitter> WholeLoopScope(this);
  if (Init && !this->visitStmt(Init))
    return false;
 
  // Start of the loop body {
  this->fallthrough(CondLabel);
  this->emitLabel(CondLabel);
 
  LocalScope<Emitter> CondScope(this);
  LoopScope<Emitter> LS(this, S, EndLabel, IncLabel);
  if (const DeclStmt *CondDecl = S->getConditionVariableDeclStmt()) {
    if (!visitDeclStmt(CondDecl))
      return false;
  }
 
  if (Cond) {
    if (!this->visitBool(Cond))
      return false;
    if (!this->jumpFalse(EndLabel, S))
      return false;
  }
  if (!this->maybeEmitDeferredVarInit(S->getConditionVariable()))
    return false;
 
  if (Body && !this->visitStmt(Body))
    return false;
 
  this->fallthrough(IncLabel);
  this->emitLabel(IncLabel);
  if (Inc && !this->discard(Inc))
    return false;
 
  if (!CondScope.destroyLocals())
    return false;
  if (!this->jump(CondLabel, S))
    return false;
  // } End of loop body.
 
  this->emitLabel(EndLabel);
  // If we jumped out of the loop above, we still need to clean up the condition
  // scope.
  return CondScope.destroyLocals() && WholeLoopScope.destroyLocals();
}
 
template <class Emitter>
bool Compiler<Emitter>::visitCXXForRangeStmt(const CXXForRangeStmt *S) {
  const Stmt *Init = S->getInit();
  const Expr *Cond = S->getCond();
  const Expr *Inc = S->getInc();
  const Stmt *Body = S->getBody();
  const Stmt *BeginStmt = S->getBeginStmt();
  const Stmt *RangeStmt = S->getRangeStmt();
  const Stmt *EndStmt = S->getEndStmt();
 
  LabelTy EndLabel = this->getLabel();
  LabelTy CondLabel = this->getLabel();
  LabelTy IncLabel = this->getLabel();
  LocalScope<Emitter> WholeLoopScope(this);
  LoopScope<Emitter> LS(this, S, EndLabel, IncLabel);
 
  // Emit declarations needed in the loop.
  if (Init && !this->visitStmt(Init))
    return false;
  if (!this->visitStmt(RangeStmt))
    return false;
  if (!this->visitStmt(BeginStmt))
    return false;
  if (!this->visitStmt(EndStmt))
    return false;
 
  LocalScope<Emitter> CondScope(this);
  // Now the condition as well as the loop variable assignment.
  this->fallthrough(CondLabel);
  this->emitLabel(CondLabel);
  if (!this->visitBool(Cond))
    return false;
  if (!this->jumpFalse(EndLabel, S))
    return false;
 
  if (!this->visitDeclStmt(S->getLoopVarStmt(), /*EvaluateConditionDecl=*/true))
    return false;
 
  // Body.
  {
    if (!this->visitStmt(Body))
      return false;
 
    this->fallthrough(IncLabel);
    this->emitLabel(IncLabel);
    if (!this->discard(Inc))
      return false;
  }
 
  if (!CondScope.destroyLocals())
    return false;
  if (!this->jump(CondLabel, S))
    return false;
 
  this->fallthrough(EndLabel);
  this->emitLabel(EndLabel);
  return WholeLoopScope.destroyLocals();
}
 
template <class Emitter>
bool Compiler<Emitter>::visitBreakStmt(const BreakStmt *S) {
  if (LabelInfoStack.empty())
    return false;
 
  OptLabelTy TargetLabel = std::nullopt;
  const Stmt *TargetLoop = S->getNamedLoopOrSwitch();
  const VariableScope<Emitter> *BreakScope = nullptr;
 
  if (!TargetLoop) {
    for (const auto &LI : llvm::reverse(LabelInfoStack)) {
      if (LI.BreakLabel) {
        TargetLabel = *LI.BreakLabel;
        BreakScope = LI.BreakOrContinueScope;
        break;
      }
    }
  } else {
    for (const auto &LI : LabelInfoStack) {
      if (LI.Name == TargetLoop) {
        TargetLabel = *LI.BreakLabel;
        BreakScope = LI.BreakOrContinueScope;
        break;
      }
    }
  }
 
  // Faulty break statement (e.g. label redefined or named loops disabled).
  if (!TargetLabel)
    return false;
 
  for (VariableScope<Emitter> *C = this->VarScope; C != BreakScope;
       C = C->getParent()) {
    if (!C->destroyLocals())
      return false;
  }
 
  return this->jump(*TargetLabel, S);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitContinueStmt(const ContinueStmt *S) {
  if (LabelInfoStack.empty())
    return false;
 
  OptLabelTy TargetLabel = std::nullopt;
  const Stmt *TargetLoop = S->getNamedLoopOrSwitch();
  const VariableScope<Emitter> *ContinueScope = nullptr;
 
  if (!TargetLoop) {
    for (const auto &LI : llvm::reverse(LabelInfoStack)) {
      if (LI.ContinueLabel) {
        TargetLabel = *LI.ContinueLabel;
        ContinueScope = LI.BreakOrContinueScope;
        break;
      }
    }
  } else {
    for (auto LI : LabelInfoStack) {
      if (LI.Name == TargetLoop) {
        TargetLabel = *LI.ContinueLabel;
        ContinueScope = LI.BreakOrContinueScope;
        break;
      }
    }
  }
 
  if (!TargetLabel)
    return false;
 
  for (VariableScope<Emitter> *C = VarScope; C != ContinueScope;
       C = C->getParent()) {
    if (!C->destroyLocals())
      return false;
  }
 
  return this->jump(*TargetLabel, S);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitSwitchStmt(const SwitchStmt *S) {
  const Expr *Cond = S->getCond();
  if (Cond->containsErrors())
    return false;
 
  PrimType CondT = this->classifyPrim(Cond->getType());
  LocalScope<Emitter> LS(this);
  llvm::SaveAndRestore StmtExprSAR(this->SwitchInStmtExpr, this->InStmtExpr);
 
  LabelTy EndLabel = this->getLabel();
  UnsignedOrNone DefaultLabel = std::nullopt;
  unsigned CondVar =
      this->allocateLocalPrimitive(Cond, CondT, /*IsConst=*/true);
 
  if (const auto *CondInit = S->getInit())
    if (!visitStmt(CondInit))
      return false;
 
  if (const DeclStmt *CondDecl = S->getConditionVariableDeclStmt())
    if (!visitDeclStmt(CondDecl))
      return false;
 
  // Initialize condition variable.
  if (!this->visit(Cond))
    return false;
  if (!this->emitSetLocal(CondT, CondVar, S))
    return false;
 
  if (!this->maybeEmitDeferredVarInit(S->getConditionVariable()))
    return false;
 
  CaseMap CaseLabels;
  // Create labels and comparison ops for all case statements.
  for (const SwitchCase *SC = S->getSwitchCaseList(); SC;
       SC = SC->getNextSwitchCase()) {
    if (const auto *CS = dyn_cast<CaseStmt>(SC)) {
      CaseLabels[SC] = this->getLabel();
 
      if (CS->caseStmtIsGNURange()) {
        LabelTy EndOfRangeCheck = this->getLabel();
        const Expr *Low = CS->getLHS();
        const Expr *High = CS->getRHS();
        if (Low->isValueDependent() || High->isValueDependent())
          return false;
 
        if (!this->emitGetLocal(CondT, CondVar, CS))
          return false;
        if (!this->visit(Low))
          return false;
        PrimType LT = this->classifyPrim(Low->getType());
        if (!this->emitGE(LT, S))
          return false;
        if (!this->jumpFalse(EndOfRangeCheck, S))
          return false;
 
        if (!this->emitGetLocal(CondT, CondVar, CS))
          return false;
        if (!this->visit(High))
          return false;
        PrimType HT = this->classifyPrim(High->getType());
        if (!this->emitLE(HT, S))
          return false;
        if (!this->jumpTrue(CaseLabels[CS], S))
          return false;
        this->emitLabel(EndOfRangeCheck);
        continue;
      }
 
      const Expr *Value = CS->getLHS();
      if (Value->isValueDependent())
        return false;
      PrimType ValueT = this->classifyPrim(Value->getType());
 
      // Compare the case statement's value to the switch condition.
      if (!this->emitGetLocal(CondT, CondVar, CS))
        return false;
      if (!this->visit(Value))
        return false;
 
      // Compare and jump to the case label.
      if (!this->emitEQ(ValueT, S))
        return false;
      if (!this->jumpTrue(CaseLabels[CS], S))
        return false;
    } else {
      assert(!DefaultLabel);
      DefaultLabel = this->getLabel();
    }
  }
 
  // If none of the conditions above were true, fall through to the default
  // statement or jump after the switch statement.
  if (DefaultLabel) {
    if (!this->jump(*DefaultLabel, S))
      return false;
  } else {
    if (!this->jump(EndLabel, S))
      return false;
  }
 
  SwitchScope<Emitter> SS(this, S, std::move(CaseLabels), EndLabel,
                          DefaultLabel);
  if (!this->visitStmt(S->getBody()))
    return false;
  this->fallthrough(EndLabel);
  this->emitLabel(EndLabel);
 
  return LS.destroyLocals();
}
 
template <class Emitter>
bool Compiler<Emitter>::visitCaseStmt(const CaseStmt *S) {
  this->fallthrough(CaseLabels[S]);
  this->emitLabel(CaseLabels[S]);
 
  // We can't jump from an outer switch statement to a case label
  // that's inside a StmtExpr.
  if (this->InStmtExpr && !this->SwitchInStmtExpr)
    return this->emitUnsupported(S);
 
  return this->visitStmt(S->getSubStmt());
}
 
template <class Emitter>
bool Compiler<Emitter>::visitDefaultStmt(const DefaultStmt *S) {
  if (LabelInfoStack.empty())
    return false;
 
  LabelTy DefaultLabel;
  for (const LabelInfo &LI : llvm::reverse(LabelInfoStack)) {
    if (LI.DefaultLabel) {
      DefaultLabel = *LI.DefaultLabel;
      break;
    }
  }
 
  this->emitLabel(DefaultLabel);
  return this->visitStmt(S->getSubStmt());
}
 
template <class Emitter>
bool Compiler<Emitter>::visitAttributedStmt(const AttributedStmt *S) {
  const Stmt *SubStmt = S->getSubStmt();
 
  bool IsMSVCConstexprAttr = isa<ReturnStmt>(SubStmt) &&
                             hasSpecificAttr<MSConstexprAttr>(S->getAttrs());
 
  if (IsMSVCConstexprAttr && !this->emitPushMSVCCE(S))
    return false;
 
  if (this->Ctx.getLangOpts().CXXAssumptions &&
      !this->Ctx.getLangOpts().MSVCCompat) {
    for (const Attr *A : S->getAttrs()) {
      auto *AA = dyn_cast<CXXAssumeAttr>(A);
      if (!AA)
        continue;
 
      assert(isa<NullStmt>(SubStmt));
 
      const Expr *Assumption = AA->getAssumption();
      if (Assumption->isValueDependent())
        return false;
 
      if (Assumption->HasSideEffects(this->Ctx.getASTContext()))
        continue;
 
      // Evaluate assumption.
      if (!this->visitBool(Assumption))
        return false;
 
      if (!this->emitAssume(Assumption))
        return false;
    }
  }
 
  // Ignore other attributes.
  if (!this->visitStmt(SubStmt))
    return false;
 
  if (IsMSVCConstexprAttr)
    return this->emitPopMSVCCE(S);
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitCXXTryStmt(const CXXTryStmt *S) {
  // Ignore all handlers.
  return this->visitStmt(S->getTryBlock());
}
 
/// template for (auto x : {1, 2}) {}
///
/// This is not a loop from an AST perspective at all since it has already
/// been instantiated to a list of compound statements.
///
/// Since we can have control flow in those compound statements, we need to
/// handle it mostly like a loop though.
template <class Emitter>
bool Compiler<Emitter>::visitCXXExpansionStmtInstantiation(
    const CXXExpansionStmtInstantiation *S) {
  LocalScope<Emitter> WholeLoopScope(this, ScopeKind::Block);
 
  for (const Stmt *PreambleStmt : S->getPreambleStmts()) {
    if (!this->visitDeclStmt(cast<DeclStmt>(PreambleStmt), true))
      return false;
  }
 
  LabelTy EndLabel = this->getLabel();
  for (const Stmt *Instantiation : S->getInstantiations()) {
    LabelTy ContinueLabel = this->getLabel();
    LoopScope<Emitter> LS(this, S, EndLabel, ContinueLabel);
 
    if (!this->visitStmt(Instantiation))
      return false;
    this->emitLabel(ContinueLabel);
  }
 
  this->emitLabel(EndLabel);
 
  return WholeLoopScope.destroyLocals();
}
 
template <class Emitter>
bool Compiler<Emitter>::emitLambdaStaticInvokerBody(const CXXMethodDecl *MD) {
  assert(MD->isLambdaStaticInvoker());
  assert(MD->hasBody());
  assert(cast<CompoundStmt>(MD->getBody())->body_empty());
 
  const CXXRecordDecl *ClosureClass = MD->getParent();
  const FunctionDecl *LambdaCallOp;
  assert(ClosureClass->captures().empty());
  if (ClosureClass->isGenericLambda()) {
    LambdaCallOp = ClosureClass->getLambdaCallOperator();
    assert(MD->isFunctionTemplateSpecialization() &&
           "A generic lambda's static-invoker function must be a "
           "template specialization");
    const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs();
    FunctionTemplateDecl *CallOpTemplate =
        LambdaCallOp->getDescribedFunctionTemplate();
    llvm::FoldingSetInsertToken InsertToken;
    const FunctionDecl *CorrespondingCallOpSpecialization =
        CallOpTemplate->findSpecialization(TAL->asArray(), InsertToken);
    assert(CorrespondingCallOpSpecialization);
    LambdaCallOp = CorrespondingCallOpSpecialization;
  } else {
    LambdaCallOp = ClosureClass->getLambdaCallOperator();
  }
  assert(ClosureClass->captures().empty());
  const Function *Func = this->getFunction(LambdaCallOp);
  if (!Func)
    return false;
  assert(Func->hasThisPointer());
  assert(Func->getNumParams() == (MD->getNumParams() + 1 + Func->hasRVO()));
 
  if (Func->hasRVO()) {
    if (!this->emitRVOPtr(MD))
      return false;
  }
 
  // The lambda call operator needs an instance pointer, but we don't have
  // one here, and we don't need one either because the lambda cannot have
  // any captures, as verified above. Emit a null pointer. This is then
  // special-cased when interpreting to not emit any misleading diagnostics.
  if (!this->emitNullPtr(0, nullptr, MD))
    return false;
 
  // Forward all arguments from the static invoker to the lambda call operator.
  for (const ParmVarDecl *PVD : MD->parameters()) {
    auto It = this->Params.find(PVD);
    assert(It != this->Params.end());
 
    // We do the lvalue-to-rvalue conversion manually here, so no need
    // to care about references.
    PrimType ParamType = this->classify(PVD->getType()).value_or(PT_Ptr);
    if (!this->emitGetParam(ParamType, It->second.Index, MD))
      return false;
  }
 
  if (!this->emitCall(Func, 0, LambdaCallOp))
    return false;
 
  this->emitCleanup();
  if (ReturnType)
    return this->emitRet(*ReturnType, MD);
 
  // Nothing to do, since we emitted the RVO pointer above.
  return this->emitRetVoid(MD);
}
 
template <class Emitter>
bool Compiler<Emitter>::checkLiteralType(const Expr *E) {
  if (Ctx.getLangOpts().CPlusPlus23)
    return true;
 
  if (!E->isPRValue() || E->getType()->isLiteralType(Ctx.getASTContext()))
    return true;
 
  return this->emitCheckLiteralType(E->getType().getTypePtr(), E);
}
 
static bool initNeedsOverridenLoc(const CXXCtorInitializer *Init) {
  const Expr *InitExpr = Init->getInit();
 
  if (!Init->isWritten() && !Init->isInClassMemberInitializer() &&
      !isa<CXXConstructExpr>(InitExpr))
    return true;
 
  if (const auto *CE = dyn_cast<CXXConstructExpr>(InitExpr)) {
    const CXXConstructorDecl *Ctor = CE->getConstructor();
    if (Ctor->isDefaulted() && Ctor->isCopyOrMoveConstructor() &&
        Ctor->isTrivial())
      return true;
  }
 
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::compileConstructor(const CXXConstructorDecl *Ctor) {
  assert(!ReturnType);
 
  // Only start the lifetime of the instance pointer.
  if (!this->emitStartThisLifetime1(Ctor))
    return false;
 
  auto emitFieldInitializer = [&](const Record::Field *F, unsigned FieldOffset,
                                  const Expr *InitExpr,
                                  bool Activate = false) -> bool {
    // We don't know what to do with these, so just return false.
    if (InitExpr->getType().isNull())
      return false;
 
    if (OptPrimType T = this->classify(InitExpr)) {
      if (Activate && !this->emitActivateThisField(FieldOffset, InitExpr))
        return false;
 
      if (!this->visit(InitExpr))
        return false;
 
      if (F->isBitField())
        return this->emitInitThisBitField(*T, FieldOffset, F->bitWidth(),
                                          InitExpr);
      return this->emitInitThisField(*T, FieldOffset, InitExpr);
    }
    // Non-primitive case. Get a pointer to the field-to-initialize
    // on the stack and call visitInitialzer() for it.
    InitLinkScope<Emitter> FieldScope(this, InitLink::Field(F->Offset));
    if (!this->emitGetPtrThisField(FieldOffset, InitExpr))
      return false;
 
    if (Activate && !this->emitActivate(InitExpr))
      return false;
 
    return this->visitInitializerPop(InitExpr);
  };
 
  const RecordDecl *RD = Ctor->getParent();
  const Record *R = this->getRecord(RD);
  if (!R)
    return false;
  bool IsUnion = R->isUnion();
 
  // Default union copy and move ctors are special.
  if (IsUnion && Ctor->isCopyOrMoveConstructor() && Ctor->isDefaulted()) {
    LocOverrideScope<Emitter> LOS(this, SourceInfo{});
 
    // No special case for NumFields == 0 here, so the Memcpy op
    // below also does its checks in those cases.
 
    assert(cast<CompoundStmt>(Ctor->getBody())->body_empty());
    if (!this->emitThis(Ctor))
      return false;
 
    if (!this->emitGetParam(PT_Ptr, /*ParamIndex=*/0, Ctor))
      return false;
 
    return this->emitMemcpy(Ctor) && this->emitPopPtr(Ctor) &&
           this->emitRetVoid(Ctor);
  }
 
  unsigned FieldInits = 0;
  InitLinkScope<Emitter> InitScope(this, InitLink::This());
  // First, initialize virtual bases if the records has them.
  if (R->getNumVirtualBases() > 0) {
    if (!this->emitThis(Ctor))
      return false;
    LabelTy AfterVirtBasesLabel = this->getLabel();
 
    // If the instance pointer is a base class, skip the virtual bases.
    if (!this->emitIsBaseClass({}))
      return false;
    if (!this->jumpTrue(AfterVirtBasesLabel, {}))
      return false;
 
    for (const auto *Init : Ctor->inits()) {
      if (const Type *Base = Init->getBaseClass();
          Base && Init->isBaseVirtual()) {
        const auto *BaseDecl = Base->getAsCXXRecordDecl();
        assert(BaseDecl);
        assert(R->findVirtualBase(BaseDecl));
        if (!this->emitGetPtrThisVirtBase(BaseDecl, Ctor))
          return false;
        if (!this->visitInitializerPop(Init->getInit()))
          return false;
      }
    }
 
    this->fallthrough(AfterVirtBasesLabel);
    this->emitLabel(AfterVirtBasesLabel);
 
    if (!this->emitPopPtr(Ctor))
      return false;
  }
 
  for (const auto *Init : Ctor->inits()) {
    // Scope needed for the initializers.
    LocalScope<Emitter> Scope(this, ScopeKind::FullExpression);
 
    const Expr *InitExpr = Init->getInit();
    if (const FieldDecl *Member = Init->getMember()) {
      const Record::Field *F = R->getField(Member);
 
      LocOverrideScope<Emitter> LOS(this, SourceInfo{},
                                    initNeedsOverridenLoc(Init));
      if (!emitFieldInitializer(F, F->Offset, InitExpr, IsUnion))
        return false;
      ++FieldInits;
    } else if (const Type *Base = Init->getBaseClass()) {
      const auto *BaseDecl = Base->getAsCXXRecordDecl();
      assert(BaseDecl);
 
      if (Init->isBaseVirtual()) {
        // See above.
        continue;
      } else {
        // Base class initializer.
        // Get This Base and call initializer on it.
        const Record::Base *B = R->getBase(BaseDecl);
        assert(B);
        if (!this->emitGetPtrThisBase(B->Offset, InitExpr))
          return false;
      }
 
      if (!this->visitInitializerPop(InitExpr))
        return false;
    } else if (const IndirectFieldDecl *IFD = Init->getIndirectMember()) {
      LocOverrideScope<Emitter> LOS(this, SourceInfo{},
                                    initNeedsOverridenLoc(Init));
      unsigned ChainSize = IFD->getChainingSize();
      assert(ChainSize >= 2);
 
      unsigned NestedFieldOffset = 0;
      const Record::Field *NestedField = nullptr;
      for (unsigned I = 0; I != ChainSize; ++I) {
        const auto *FD = cast<FieldDecl>(IFD->chain()[I]);
        const Record *FieldRecord = this->P.getOrCreateRecord(FD->getParent());
        assert(FieldRecord);
 
        NestedField = FieldRecord->getField(FD);
        assert(NestedField);
        IsUnion = IsUnion || FieldRecord->isUnion();
 
        NestedFieldOffset += NestedField->Offset;
 
        // Add a new InitChainLink for the record, but not for the final field.
        if (I != ChainSize - 1)
          InitStack.push_back(InitLink::Field(NestedField->Offset));
      }
      assert(NestedField);
 
      InitStackScope<Emitter> ISS(this, isa<CXXDefaultInitExpr>(InitExpr));
      if (!emitFieldInitializer(NestedField, NestedFieldOffset, InitExpr,
                                IsUnion))
        return false;
 
      // Mark all chain links as initialized.
      unsigned InitFieldOffset = 0;
      for (const NamedDecl *ND : IFD->chain().drop_back()) {
        const auto *FD = cast<FieldDecl>(ND);
        const Record *FieldRecord = this->P.getOrCreateRecord(FD->getParent());
        assert(FieldRecord);
        NestedField = FieldRecord->getField(FD);
        InitFieldOffset += NestedField->Offset;
        assert(NestedField);
        if (!this->emitGetPtrThisField(InitFieldOffset, InitExpr))
          return false;
        if (!this->emitFinishInitPop(InitExpr))
          return false;
      }
 
      InitStack.pop_back_n(ChainSize - 1);
 
    } else {
      assert(Init->isDelegatingInitializer());
      if (!this->emitThis(InitExpr))
        return false;
      if (!this->visitInitializerPop(Init->getInit()))
        return false;
    }
 
    if (!Scope.destroyLocals())
      return false;
  }
 
  if (FieldInits != R->getNumFields()) {
    assert(FieldInits < R->getNumFields());
    // Start the lifetime of all members.
    if (!this->emitStartThisLifetime(Ctor))
      return false;
  }
 
  if (const Stmt *Body = Ctor->getBody()) {
    // Only emit the CtorCheck op for non-empty CompoundStmt bodies.
    // For non-CompoundStmts, always assume they are non-empty and emit it.
    if (const auto *CS = dyn_cast<CompoundStmt>(Body)) {
      if (!CS->body_empty() && !this->emitCtorCheck(SourceInfo{}))
        return false;
    } else {
      if (!this->emitCtorCheck(SourceInfo{}))
        return false;
    }
 
    if (!visitStmt(Body))
      return false;
  }
 
  return this->emitRetVoid(SourceInfo{});
}
 
template <class Emitter>
bool Compiler<Emitter>::compileDestructor(const CXXDestructorDecl *Dtor) {
  const RecordDecl *RD = Dtor->getParent();
  const Record *R = this->getRecord(RD);
  if (!R)
    return false;
 
  if (!Dtor->isTrivial() && Dtor->getBody()) {
    if (!this->visitStmt(Dtor->getBody()))
      return false;
  }
 
  if (!this->emitThis(Dtor))
    return false;
 
  if (!this->emitCheckDestruction(Dtor))
    return false;
 
  assert(R);
  if (!R->isUnion()) {
 
    LocOverrideScope<Emitter> LOS(this, SourceInfo{});
    // First, destroy all fields.
    for (const Record::Field &Field : llvm::reverse(R->fields())) {
      const Descriptor *D = Field.Desc;
      if (D->hasTrivialDtor())
        continue;
      if (!this->emitGetPtrField(Field.Offset, SourceInfo{}))
        return false;
      if (!this->emitDestructionPop(D, SourceInfo{}))
        return false;
    }
  }
 
  for (const Record::Base &Base : llvm::reverse(R->bases())) {
    if (Base.R->hasTrivialDtor())
      continue;
    if (!this->emitGetPtrBase(Base.Offset, SourceInfo{}))
      return false;
    if (!this->emitRecordDestructionPop(Base.R, {}))
      return false;
  }
 
  if (R->getNumVirtualBases() > 0) {
    LabelTy EndLabel = this->getLabel();
    // If this is a base class, skip the virtual bases.
    if (!this->emitIsBaseClass({}))
      return false;
    if (!this->jumpTrue(EndLabel, {}))
      return false;
 
    for (const Record::Base &Base : llvm::reverse(R->virtual_bases())) {
      if (Base.R->hasTrivialDtor())
        continue;
      if (!this->emitGetPtrVirtBase(cast<CXXRecordDecl>(Base.R->getDecl()),
                                    SourceInfo{}))
        return false;
      if (!this->emitRecordDestructionPop(Base.R, {}))
        return false;
    }
 
    this->fallthrough(EndLabel);
    this->emitLabel(EndLabel);
  }
 
  if (!this->emitMarkDestroyed(Dtor))
    return false;
 
  return this->emitPopPtr(Dtor) && this->emitRetVoid(Dtor);
}
 
template <class Emitter>
bool Compiler<Emitter>::compileUnionAssignmentOperator(
    const CXXMethodDecl *MD) {
  if (!this->emitThis(MD))
    return false;
 
  if (!this->emitGetParam(PT_Ptr, /*ParamIndex=*/0, MD))
    return false;
 
  return this->emitMemcpy(MD) && this->emitRet(PT_Ptr, MD);
}
 
template <class Emitter>
bool Compiler<Emitter>::visitFunc(const FunctionDecl *F) {
  if (F->getReturnType()->isDependentType())
    return false;
 
  // Classify the return type.
  ReturnType = this->classify(F->getReturnType());
 
  this->CompilingFunction = F;
 
  if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(F))
    return this->compileConstructor(Ctor);
  if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(F))
    return this->compileDestructor(Dtor);
 
  // Emit custom code if this is a lambda static invoker.
  if (const auto *MD = dyn_cast<CXXMethodDecl>(F)) {
    const RecordDecl *RD = MD->getParent();
 
    if (RD->isUnion() &&
        (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()))
      return this->compileUnionAssignmentOperator(MD);
 
    if (MD->isLambdaStaticInvoker())
      return this->emitLambdaStaticInvokerBody(MD);
  }
 
  // Regular functions.
  if (const 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{});
  return this->emitNoRet(SourceInfo{});
}
 
static uint32_t getBitWidth(const Expr *E) {
  assert(E->refersToBitField());
  const auto *ME = cast<MemberExpr>(E);
  const auto *FD = cast<FieldDecl>(ME->getMemberDecl());
  return FD->getBitWidthValue();
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitUnaryOperator(const UnaryOperator *E) {
  if (E->containsErrors())
    return false;
 
  const Expr *SubExpr = E->getSubExpr();
  if (SubExpr->getType()->isAnyComplexType())
    return this->VisitComplexUnaryOperator(E);
  if (SubExpr->getType()->isVectorType())
    return this->VisitVectorUnaryOperator(E);
  if (SubExpr->getType()->isFixedPointType())
    return this->VisitFixedPointUnaryOperator(E);
  OptPrimType T = classify(SubExpr->getType());
 
  switch (E->getOpcode()) {
  case UO_PostInc: { // x++
    if (!Ctx.getLangOpts().CPlusPlus14)
      return this->emitInvalid(E);
    if (!T)
      return this->emitError(E);
 
    if (!this->visit(SubExpr))
      return false;
 
    if (T == PT_Ptr) {
      if (!this->emitIncPtr(E))
        return false;
 
      return DiscardResult ? this->emitPopPtr(E) : true;
    }
 
    if (T == PT_Float)
      return DiscardResult ? this->emitIncfPop(getFPOptions(E), E)
                           : this->emitIncf(getFPOptions(E), E);
 
    if (SubExpr->refersToBitField())
      return DiscardResult ? this->emitIncPopBitfield(*T, E->canOverflow(),
                                                      getBitWidth(SubExpr), E)
                           : this->emitIncBitfield(*T, E->canOverflow(),
                                                   getBitWidth(SubExpr), E);
 
    return DiscardResult ? this->emitIncPop(*T, E->canOverflow(), E)
                         : this->emitInc(*T, E->canOverflow(), E);
  }
  case UO_PostDec: { // x--
    if (!Ctx.getLangOpts().CPlusPlus14)
      return this->emitInvalid(E);
    if (!T)
      return this->emitError(E);
 
    if (!this->visit(SubExpr))
      return false;
 
    if (T == PT_Ptr) {
      if (!this->emitDecPtr(E))
        return false;
 
      return DiscardResult ? this->emitPopPtr(E) : true;
    }
 
    if (T == PT_Float)
      return DiscardResult ? this->emitDecfPop(getFPOptions(E), E)
                           : this->emitDecf(getFPOptions(E), E);
 
    if (SubExpr->refersToBitField()) {
      return DiscardResult ? this->emitDecPopBitfield(*T, E->canOverflow(),
                                                      getBitWidth(SubExpr), E)
                           : this->emitDecBitfield(*T, E->canOverflow(),
                                                   getBitWidth(SubExpr), E);
    }
 
    return DiscardResult ? this->emitDecPop(*T, E->canOverflow(), E)
                         : this->emitDec(*T, E->canOverflow(), E);
  }
  case UO_PreInc: { // ++x
    if (!Ctx.getLangOpts().CPlusPlus14)
      return this->emitInvalid(E);
    if (!T)
      return this->emitError(E);
 
    if (!this->visit(SubExpr))
      return false;
 
    if (T == PT_Ptr) {
      if (!this->emitLoadPtr(E))
        return false;
      if (!this->emitConstUint8(1, E))
        return false;
      if (!this->emitAddOffsetUint8(E))
        return false;
      return DiscardResult ? this->emitStorePopPtr(E) : this->emitStorePtr(E);
    }
 
    // Post-inc and pre-inc are the same if the value is to be discarded.
    if (DiscardResult) {
      if (T == PT_Float)
        return this->emitIncfPop(getFPOptions(E), E);
      if (SubExpr->refersToBitField())
        return DiscardResult ? this->emitIncPopBitfield(*T, E->canOverflow(),
                                                        getBitWidth(SubExpr), E)
                             : this->emitIncBitfield(*T, E->canOverflow(),
                                                     getBitWidth(SubExpr), E);
      return this->emitIncPop(*T, E->canOverflow(), E);
    }
 
    if (T == PT_Float) {
      const auto &TargetSemantics = Ctx.getFloatSemantics(E->getType());
      if (!this->emitLoadFloat(E))
        return false;
      APFloat F(TargetSemantics, 1);
      if (!this->emitFloat(F, E))
        return false;
 
      if (!this->emitAddf(getFPOptions(E), E))
        return false;
      if (!this->emitStoreFloat(E))
        return false;
    } else if (SubExpr->refersToBitField()) {
      assert(isIntegerOrBoolType(*T));
      if (!this->emitPreIncBitfield(*T, E->canOverflow(), getBitWidth(SubExpr),
                                    E))
        return false;
    } else {
      assert(isIntegerOrBoolType(*T));
      if (!this->emitPreInc(*T, E->canOverflow(), E))
        return false;
    }
    return E->isGLValue() || this->emitLoadPop(*T, E);
  }
  case UO_PreDec: { // --x
    if (!Ctx.getLangOpts().CPlusPlus14)
      return this->emitInvalid(E);
    if (!T)
      return this->emitError(E);
 
    if (!this->visit(SubExpr))
      return false;
 
    if (T == PT_Ptr) {
      if (!this->emitLoadPtr(E))
        return false;
      if (!this->emitConstUint8(1, E))
        return false;
      if (!this->emitSubOffsetUint8(E))
        return false;
      return DiscardResult ? this->emitStorePopPtr(E) : this->emitStorePtr(E);
    }
 
    // Post-dec and pre-dec are the same if the value is to be discarded.
    if (DiscardResult) {
      if (T == PT_Float)
        return this->emitDecfPop(getFPOptions(E), E);
      if (SubExpr->refersToBitField())
        return DiscardResult ? this->emitDecPopBitfield(*T, E->canOverflow(),
                                                        getBitWidth(SubExpr), E)
                             : this->emitDecBitfield(*T, E->canOverflow(),
                                                     getBitWidth(SubExpr), E);
      return this->emitDecPop(*T, E->canOverflow(), E);
    }
 
    if (T == PT_Float) {
      const auto &TargetSemantics = Ctx.getFloatSemantics(E->getType());
      if (!this->emitLoadFloat(E))
        return false;
      APFloat F(TargetSemantics, 1);
      if (!this->emitFloat(F, E))
        return false;
 
      if (!this->emitSubf(getFPOptions(E), E))
        return false;
      if (!this->emitStoreFloat(E))
        return false;
    } else if (SubExpr->refersToBitField()) {
      assert(isIntegerOrBoolType(*T));
      if (!this->emitPreDecBitfield(*T, E->canOverflow(), getBitWidth(SubExpr),
                                    E))
        return false;
    } else {
      assert(isIntegerOrBoolType(*T));
      if (!this->emitPreDec(*T, E->canOverflow(), E))
        return false;
    }
    return E->isGLValue() || this->emitLoadPop(*T, E);
  }
  case UO_LNot: // !x
    if (!T)
      return this->emitError(E);
 
    if (DiscardResult)
      return this->discard(SubExpr);
 
    if (!this->visitBool(SubExpr))
      return false;
 
    if (!this->emitInv(E))
      return false;
 
    if (PrimType ET = classifyPrim(E->getType()); ET != PT_Bool)
      return this->emitCast(PT_Bool, ET, E);
    return true;
  case UO_Minus: // -x
    if (!T)
      return this->emitError(E);
 
    if (!this->visit(SubExpr))
      return false;
    return DiscardResult ? this->emitPop(*T, E) : this->emitNeg(*T, E);
  case UO_Plus: // +x
    if (!T)
      return this->emitError(E);
 
    if (!this->visit(SubExpr)) // noop
      return false;
    return DiscardResult ? this->emitPop(*T, E) : true;
  case UO_AddrOf: // &x
    if (E->getType()->isMemberPointerType()) {
      // C++11 [expr.unary.op]p3 has very strict rules on how the address of a
      // member can be formed.
      if (DiscardResult)
        return true;
      return this->emitGetMemberPtr(cast<DeclRefExpr>(SubExpr)->getDecl(), E);
    }
    // [C11 6.5.3.2p3]: if the operand of '&' is the result of a unary '*'
    // operator, neither operator is evaluated and the result is as if both
    // were omitted. So '&*q' is just 'q' with no dereference; delegate to the
    // pointer operand directly instead of to the '*' (which would emit a null
    // check), so that e.g. '&*(int *)0' is not rejected.
    if (!Ctx.getLangOpts().CPlusPlus) {
      const Expr *Sub = SubExpr->IgnoreParens();
 
      if (const auto *Deref = dyn_cast<UnaryOperator>(Sub);
          Deref && Deref->getOpcode() == UO_Deref) {
        if (DiscardResult)
          return this->discard(Deref->getSubExpr());
        return this->visit(Deref->getSubExpr()) && this->emitAddrOf(E);
      }
    }
    // We should already have a pointer when we get here.
    if (DiscardResult)
      return this->discard(SubExpr);
    return this->delegate(SubExpr) && this->emitAddrOf(E);
  case UO_Deref: // *x
    if (DiscardResult)
      return this->discard(SubExpr);
 
    if (!this->visit(SubExpr))
      return false;
 
    if (!SubExpr->getType()->isFunctionPointerType() && !this->emitCheckNull(E))
      return false;
 
    if (classifyPrim(SubExpr) == PT_Ptr)
      return this->emitNarrowPtr(E);
    return true;
 
  case UO_Not: // ~x
    if (!T)
      return this->emitError(E);
 
    if (!this->visit(SubExpr))
      return false;
    return DiscardResult ? this->emitPop(*T, E) : this->emitComp(*T, E);
  case UO_Real: // __real x
    if (!T)
      return false;
    return this->delegate(SubExpr);
  case UO_Imag: { // __imag x
    if (!T)
      return false;
    if (!this->discard(SubExpr))
      return false;
    return DiscardResult
               ? true
               : this->visitZeroInitializer(*T, SubExpr->getType(), SubExpr);
  }
  case UO_Extension:
    return this->delegate(SubExpr);
  case UO_Coawait:
    assert(false && "Unhandled opcode");
  }
 
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitComplexUnaryOperator(const UnaryOperator *E) {
  const Expr *SubExpr = E->getSubExpr();
  assert(SubExpr->getType()->isAnyComplexType());
 
  if (DiscardResult)
    return this->discard(SubExpr);
 
  OptPrimType ResT = classify(E);
  auto prepareResult = [=]() -> bool {
    if (!ResT && !Initializing) {
      UnsignedOrNone LocalIndex = allocateLocal(SubExpr);
      if (!LocalIndex)
        return false;
      return this->emitGetPtrLocal(*LocalIndex, E);
    }
 
    return true;
  };
 
  // The offset of the temporary, if we created one.
  unsigned SubExprOffset = ~0u;
  auto createTemp = [=, &SubExprOffset]() -> bool {
    SubExprOffset =
        this->allocateLocalPrimitive(SubExpr, PT_Ptr, /*IsConst=*/true);
    if (!this->visit(SubExpr))
      return false;
    return this->emitSetLocal(PT_Ptr, SubExprOffset, E);
  };
 
  PrimType ElemT = classifyComplexElementType(SubExpr->getType());
  auto getElem = [=](unsigned Offset, unsigned Index) -> bool {
    if (!this->emitGetLocal(PT_Ptr, Offset, E))
      return false;
    return this->emitArrayElemPop(ElemT, Index, E);
  };
 
  switch (E->getOpcode()) {
  case UO_Minus: // -x
    if (!prepareResult())
      return false;
    if (!createTemp())
      return false;
    for (unsigned I = 0; I != 2; ++I) {
      if (!getElem(SubExprOffset, I))
        return false;
      if (!this->emitNeg(ElemT, E))
        return false;
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
    break;
 
  case UO_Plus:   // +x
  case UO_AddrOf: // &x
  case UO_Deref:  // *x
    return this->delegate(SubExpr);
 
  case UO_LNot:
    if (!this->visit(SubExpr))
      return false;
    if (!this->emitComplexBoolCast(SubExpr))
      return false;
    if (!this->emitInv(E))
      return false;
    if (PrimType ET = classifyPrim(E->getType()); ET != PT_Bool)
      return this->emitCast(PT_Bool, ET, E);
    return true;
 
  case UO_Real:
    return this->emitComplexReal(SubExpr);
 
  case UO_Imag:
    if (!this->visit(SubExpr))
      return false;
 
    if (SubExpr->isLValue()) {
      if (!this->emitConstUint8(1, E))
        return false;
      return this->emitArrayElemPtrPopUint8(E);
    }
 
    // Since our _Complex implementation does not map to a primitive type,
    // we sometimes have to do the lvalue-to-rvalue conversion here manually.
    return this->emitArrayElemPop(classifyPrim(E->getType()), 1, E);
 
  case UO_Not: // ~x
    if (!this->delegate(SubExpr))
      return false;
    // Negate the imaginary component.
    if (!this->emitArrayElem(ElemT, 1, E))
      return false;
    if (!this->emitNeg(ElemT, E))
      return false;
    if (!this->emitInitElem(ElemT, 1, E))
      return false;
    return DiscardResult ? this->emitPopPtr(E) : true;
 
  case UO_Extension:
    return this->delegate(SubExpr);
 
  default:
    return this->emitInvalid(E);
  }
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitVectorUnaryOperator(const UnaryOperator *E) {
  const Expr *SubExpr = E->getSubExpr();
  assert(SubExpr->getType()->isVectorType());
 
  if (DiscardResult)
    return this->discard(SubExpr);
 
  auto UnaryOp = E->getOpcode();
  if (UnaryOp == UO_Extension)
    return this->delegate(SubExpr);
 
  if (UnaryOp != UO_Plus && UnaryOp != UO_Minus && UnaryOp != UO_LNot &&
      UnaryOp != UO_Not && UnaryOp != UO_AddrOf)
    return this->emitInvalid(E);
 
  // Nothing to do here.
  if (UnaryOp == UO_Plus || UnaryOp == UO_AddrOf)
    return this->delegate(SubExpr);
 
  if (!Initializing) {
    UnsignedOrNone LocalIndex = allocateLocal(SubExpr);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
 
  // The offset of the temporary, if we created one.
  unsigned SubExprOffset =
      this->allocateLocalPrimitive(SubExpr, PT_Ptr, /*IsConst=*/true);
  if (!this->visit(SubExpr))
    return false;
  if (!this->emitSetLocal(PT_Ptr, SubExprOffset, E))
    return false;
 
  const auto *VecTy = SubExpr->getType()->getAs<VectorType>();
  PrimType ElemT = classifyVectorElementType(SubExpr->getType());
  auto getElem = [=](unsigned Offset, unsigned Index) -> bool {
    if (!this->emitGetLocal(PT_Ptr, Offset, E))
      return false;
    return this->emitArrayElemPop(ElemT, Index, E);
  };
 
  switch (UnaryOp) {
  case UO_Minus:
    for (unsigned I = 0; I != VecTy->getNumElements(); ++I) {
      if (!getElem(SubExprOffset, I))
        return false;
      if (!this->emitNeg(ElemT, E))
        return false;
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
    break;
  case UO_LNot: { // !x
    // In C++, the logic operators !, &&, || are available for vectors. !v is
    // equivalent to v == 0.
    //
    // The result of the comparison is a vector of the same width and number of
    // elements as the comparison operands with a signed integral element type.
    //
    // https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html
    QualType ResultVecTy = E->getType();
    PrimType ResultVecElemT =
        classifyPrim(ResultVecTy->getAs<VectorType>()->getElementType());
    for (unsigned I = 0; I != VecTy->getNumElements(); ++I) {
      if (!getElem(SubExprOffset, I))
        return false;
      // operator ! on vectors returns -1 for 'truth', so negate it.
      if (!this->emitPrimCast(ElemT, PT_Bool, Ctx.getASTContext().BoolTy, E))
        return false;
      if (!this->emitInv(E))
        return false;
      if (!this->emitPrimCast(PT_Bool, ElemT, VecTy->getElementType(), E))
        return false;
      if (!this->emitNeg(ElemT, E))
        return false;
      if (ElemT != ResultVecElemT &&
          !this->emitPrimCast(ElemT, ResultVecElemT, ResultVecTy, E))
        return false;
      if (!this->emitInitElem(ResultVecElemT, I, E))
        return false;
    }
    break;
  }
  case UO_Not: // ~x
    for (unsigned I = 0; I != VecTy->getNumElements(); ++I) {
      if (!getElem(SubExprOffset, I))
        return false;
      if (ElemT == PT_Bool) {
        if (!this->emitInv(E))
          return false;
      } else {
        if (!this->emitComp(ElemT, E))
          return false;
      }
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
    break;
  default:
    llvm_unreachable("Unsupported unary operators should be handled up front");
  }
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::visitDeclRef(const ValueDecl *D, const Expr *E) {
  if (const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
    if (DiscardResult)
      return true;
    return this->emitConst(ECD->getInitVal(), E);
  }
  if (const auto *FuncDecl = dyn_cast<FunctionDecl>(D)) {
    if (DiscardResult)
      return true;
    const Function *F = getFunction(FuncDecl);
    return F && this->emitGetFnPtr(F, E);
  }
  if (const auto *TPOD = dyn_cast<TemplateParamObjectDecl>(D)) {
    TPOD = TPOD->getFirstDecl();
    if (DiscardResult)
      return true;
    if (UnsignedOrNone GlobalIndex = P.getGlobal(TPOD))
      return this->emitGetPtrGlobal(*GlobalIndex, E);
 
    if (UnsignedOrNone Index = P.getOrCreateGlobal(TPOD)) {
      if (OptPrimType T = classify(TPOD->getType())) {
        if (!this->visitAPValue(TPOD->getValue(), *T, E))
          return false;
        return this->emitInitGlobal(*T, *Index, E);
      }
 
      if (!this->emitGetPtrGlobal(*Index, E))
        return false;
      if (!this->visitAPValueInitializer(TPOD->getValue(), E, TPOD->getType()))
        return false;
      return this->emitFinishInit(E);
    }
    return false;
  }
 
  // References are implemented via pointers, so when we see a DeclRefExpr
  // pointing to a reference, we need to get its value directly (i.e. the
  // pointer to the actual value) instead of a pointer to the pointer to the
  // value.
  QualType DeclType = D->getType();
  bool IsReference = DeclType->isReferenceType();
 
  auto maybePopPtr = [&]() -> bool {
    if (DiscardResult)
      return this->emitPopPtr(E);
    return true;
  };
 
  // Function parameters.
  // Note that it's important to check them first since we might have a local
  // variable created for a ParmVarDecl as well.
  if (const auto *PVD = dyn_cast<ParmVarDecl>(D)) {
    if (DiscardResult)
      return true;
 
    if (Ctx.getLangOpts().CPlusPlus && !Ctx.getLangOpts().CPlusPlus11 &&
        !DeclType->isIntegralOrEnumerationType()) {
      return this->emitInvalidDeclRef(cast<DeclRefExpr>(E),
                                      /*InitializerFailed=*/false, E);
    }
    if (auto It = this->Params.find(PVD); It != this->Params.end()) {
      if (IsReference || !It->second.IsPtr)
        return this->emitGetParam(classifyPrim(E), It->second.Index, E);
 
      return this->emitGetPtrParam(It->second.Index, E);
    }
 
    if (!Ctx.getLangOpts().CPlusPlus23 && IsReference && !Locals.contains(D))
      return this->emitInvalidDeclRef(cast<DeclRefExpr>(E),
                                      /*InitializerFailed=*/false, E);
  }
 
  // Local variables.
  if (auto It = Locals.find(D); It != Locals.end()) {
    const unsigned Offset = It->second.Offset;
    if (IsReference) {
      assert(classifyPrim(E) == PT_Ptr);
      return this->emitGetRefLocal(Offset, E) && maybePopPtr();
    }
    return this->emitGetPtrLocal(Offset, E) && maybePopPtr();
  }
  // Global variables.
  if (auto GlobalIndex = P.getGlobal(D)) {
    if (IsReference) {
      if (!Ctx.getLangOpts().CPlusPlus11)
        return this->emitGetGlobal(classifyPrim(E), *GlobalIndex, E);
      if (!Ctx.getLangOpts().CPlusPlus23)
        return this->emitGetGlobalUnchecked(classifyPrim(E), *GlobalIndex, E);
 
      return this->emitGetRefGlobal(*GlobalIndex, E) && maybePopPtr();
    }
 
    return this->emitGetPtrGlobal(*GlobalIndex, E) && maybePopPtr();
  }
 
  // In case we need to re-visit a declaration.
  auto revisit = [&](const VarDecl *VD,
                     bool IsConstexprUnknown = true) -> bool {
    llvm::SaveAndRestore CURS(this->VariablesAreConstexprUnknown,
                              IsConstexprUnknown);
    if constexpr (std::is_same_v<Emitter, EvalEmitter>) {
      if (!this->emitPushCC(VD->hasConstantInitialization(), E))
        return false;
    }
    auto VarState = this->visitDecl(VD);
 
    if constexpr (std::is_same_v<Emitter, EvalEmitter>) {
      if (!this->emitPopCC(E))
        return false;
    }
 
    if (VarState.notCreated())
      return true;
    if (!VarState)
      return false;
    // Retry.
    return this->visitDeclRef(D, E);
  };
 
  if constexpr (!std::is_same_v<Emitter, EvalEmitter>) {
    // Lambda captures.
    if (auto It = this->LambdaCaptures.find(D);
        It != this->LambdaCaptures.end()) {
      auto [Offset, IsPtr] = It->second;
 
      if (IsPtr)
        return this->emitGetThisFieldPtr(Offset, E) && maybePopPtr();
      return this->emitGetPtrThisField(Offset, E) && maybePopPtr();
    }
  }
 
  if (const auto *DRE = dyn_cast<DeclRefExpr>(E);
      DRE && DRE->refersToEnclosingVariableOrCapture()) {
    if (const auto *VD = dyn_cast<VarDecl>(D); VD && VD->isInitCapture())
      return revisit(VD);
  }
 
  if (const auto *BD = dyn_cast<BindingDecl>(D))
    return this->delegate(BD->getBinding());
 
  // Avoid infinite recursion.
  if (D == InitializingDecl) {
    if (DiscardResult)
      return true;
    return this->emitDummyPtr(D, E);
  }
 
  // Try to lazily visit (or emit dummy pointers for) declarations
  // we haven't seen yet.
  const auto *VD = dyn_cast<VarDecl>(D);
  if (!VD)
    return this->emitError(E);
 
  // For C.
  if (!Ctx.getLangOpts().CPlusPlus) {
    if (VD->getInit() && !VD->getInit()->isValueDependent() &&
        DeclType.isConstant(Ctx.getASTContext()) && !VD->isWeak() &&
        VD->evaluateValue())
      return revisit(VD, /*IsConstexprUnknown=*/false);
 
    if (DiscardResult)
      return true;
    return this->emitDummyPtr(D, E);
  }
 
  // ... and C++.
  const auto typeShouldBeVisited = [&](QualType T) -> bool {
    if (T.isConstant(Ctx.getASTContext()))
      return true;
    return T->isReferenceType();
  };
 
  if ((VD->hasGlobalStorage() || VD->isStaticDataMember()) &&
      typeShouldBeVisited(DeclType)) {
    if (const Expr *Init = VD->getAnyInitializer();
        Init && !Init->isValueDependent()) {
      // Whether or not the evaluation is successul doesn't really matter
      // here -- we will create a global variable in any case, and that
      // will have the state of initializer evaluation attached.
      Expr::EvalResult Result;
      (void)Init->EvaluateAsInitializer(Ctx.getASTContext(), VD, Result, true);
      return this->visitDeclRef(D, E);
    }
    return revisit(VD, !VD->isConstexpr() && DeclType->isReferenceType());
  }
 
  // FIXME: The evaluateValue() check here is a little ridiculous, since
  // it will ultimately call into Context::evaluateAsInitializer(). In
  // other words, we're evaluating the initializer, just to know if we can
  // evaluate the initializer.
  if (VD->isLocalVarDecl() && typeShouldBeVisited(DeclType) && VD->getInit() &&
      !VD->getInit()->isValueDependent()) {
    if (VD->evaluateValue()) {
      bool IsConstexprUnknown = !DeclType.isConstant(Ctx.getASTContext()) &&
                                !DeclType->isReferenceType();
      // Revisit the variable declaration, but make sure it's associated with a
      // different evaluation, so e.g. mutable reads don't work on it.
      EvalIDScope _(Ctx);
      return revisit(VD, IsConstexprUnknown);
    } else if (Ctx.getLangOpts().CPlusPlus23 && IsReference)
      return revisit(VD, /*IsConstexprUnknown=*/true);
 
    if (IsReference)
      return this->emitInvalidDeclRef(cast<DeclRefExpr>(E),
                                      /*InitializerFailed=*/true, E);
  }
 
  if (DiscardResult)
    return true;
  return this->emitDummyPtr(
      D, E, Ctx.getLangOpts().CPlusPlus23 && DeclType->isReferenceType());
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitDeclRefExpr(const DeclRefExpr *E) {
  const auto *D = E->getDecl();
  return this->visitDeclRef(D, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::VisitDesignatedInitUpdateExpr(
    const DesignatedInitUpdateExpr *E) {
  if (!this->visitInitializer(E->getBase()))
    return false;
  return this->visitInitializer(E->getUpdater());
}
 
template <class Emitter> bool Compiler<Emitter>::emitCleanup() {
  for (VariableScope<Emitter> *C = VarScope; C; C = C->getParent()) {
    if (!C->destroyLocals())
      return false;
  }
  return true;
}
 
template <class Emitter>
unsigned Compiler<Emitter>::collectBaseOffset(const QualType BaseType,
                                              const QualType DerivedType) {
  const auto extractRecordDecl = [](QualType Ty) -> const CXXRecordDecl * {
    if (const auto *R = Ty->getPointeeCXXRecordDecl())
      return R;
    return Ty->getAsCXXRecordDecl();
  };
  const CXXRecordDecl *BaseDecl = extractRecordDecl(BaseType);
  const CXXRecordDecl *DerivedDecl = extractRecordDecl(DerivedType);
 
  return Ctx.collectBaseOffset(BaseDecl, DerivedDecl);
}
 
/// Emit casts from a PrimType to another PrimType.
template <class Emitter>
bool Compiler<Emitter>::emitPrimCast(PrimType FromT, PrimType ToT,
                                     QualType ToQT, const Expr *E) {
 
  if (FromT == PT_Float) {
    // Floating to floating.
    if (ToT == PT_Float) {
      const llvm::fltSemantics *ToSem = &Ctx.getFloatSemantics(ToQT);
      return this->emitCastFP(ToSem, getRoundingMode(E), E);
    }
 
    if (ToT == PT_IntAP)
      return this->emitCastFloatingIntegralAP(Ctx.getBitWidth(ToQT),
                                              getFPOptions(E), E);
    if (ToT == PT_IntAPS)
      return this->emitCastFloatingIntegralAPS(Ctx.getBitWidth(ToQT),
                                               getFPOptions(E), E);
 
    // Float to integral.
    if (isIntegerOrBoolType(ToT) || ToT == PT_Bool)
      return this->emitCastFloatingIntegral(ToT, getFPOptions(E), E);
  }
 
  if (isIntegerOrBoolType(FromT) || FromT == PT_Bool) {
    if (ToT == PT_IntAP)
      return this->emitCastAP(FromT, Ctx.getBitWidth(ToQT), E);
    if (ToT == PT_IntAPS)
      return this->emitCastAPS(FromT, Ctx.getBitWidth(ToQT), E);
 
    // Integral to integral.
    if (isIntegerOrBoolType(ToT) || ToT == PT_Bool)
      return FromT != ToT ? this->emitCast(FromT, ToT, E) : true;
 
    if (ToT == PT_Float) {
      // Integral to floating.
      const llvm::fltSemantics *ToSem = &Ctx.getFloatSemantics(ToQT);
      return this->emitCastIntegralFloating(FromT, ToSem, getFPOptions(E), E);
    }
  }
 
  return false;
}
 
template <class Emitter>
bool Compiler<Emitter>::emitIntegralCast(PrimType FromT, PrimType ToT,
                                         QualType ToQT, const Expr *E) {
  assert(FromT != ToT);
 
  if (ToT == PT_IntAP)
    return this->emitCastAP(FromT, Ctx.getBitWidth(ToQT), E);
  if (ToT == PT_IntAPS)
    return this->emitCastAPS(FromT, Ctx.getBitWidth(ToQT), E);
 
  return this->emitCast(FromT, ToT, E);
}
 
/// Emits __real(SubExpr)
template <class Emitter>
bool Compiler<Emitter>::emitComplexReal(const Expr *SubExpr) {
  assert(SubExpr->getType()->isAnyComplexType());
 
  if (DiscardResult)
    return this->discard(SubExpr);
 
  if (!this->visit(SubExpr))
    return false;
  if (SubExpr->isLValue()) {
    if (!this->emitConstUint8(0, SubExpr))
      return false;
    return this->emitArrayElemPtrPopUint8(SubExpr);
  }
 
  // Rvalue, load the actual element.
  return this->emitArrayElemPop(classifyComplexElementType(SubExpr->getType()),
                                0, SubExpr);
}
 
template <class Emitter>
bool Compiler<Emitter>::emitComplexBoolCast(const Expr *E) {
  assert(!DiscardResult);
  PrimType ElemT = classifyComplexElementType(E->getType());
  // We emit the expression (__real(E) != 0 || __imag(E) != 0)
  // for us, that means (bool)E[0] || (bool)E[1]
  if (!this->emitArrayElem(ElemT, 0, E))
    return false;
  if (ElemT == PT_Float) {
    if (!this->emitCastFloatingIntegral(PT_Bool, getFPOptions(E), E))
      return false;
  } else {
    if (!this->emitCast(ElemT, PT_Bool, E))
      return false;
  }
 
  // We now have the bool value of E[0] on the stack.
  LabelTy LabelTrue = this->getLabel();
  if (!this->jumpTrue(LabelTrue, E))
    return false;
 
  if (!this->emitArrayElemPop(ElemT, 1, E))
    return false;
  if (ElemT == PT_Float) {
    if (!this->emitCastFloatingIntegral(PT_Bool, getFPOptions(E), E))
      return false;
  } else {
    if (!this->emitCast(ElemT, PT_Bool, E))
      return false;
  }
  // Leave the boolean value of E[1] on the stack.
  LabelTy EndLabel = this->getLabel();
  this->jump(EndLabel, E);
 
  this->emitLabel(LabelTrue);
  if (!this->emitPopPtr(E))
    return false;
  if (!this->emitConstBool(true, E))
    return false;
 
  this->fallthrough(EndLabel);
  this->emitLabel(EndLabel);
 
  return true;
}
 
template <class Emitter>
bool Compiler<Emitter>::emitComplexComparison(const Expr *LHS, const Expr *RHS,
                                              const BinaryOperator *E) {
  assert(E->isComparisonOp());
  assert(!Initializing);
  if (DiscardResult)
    return this->discard(LHS) && this->discard(RHS);
 
  PrimType ElemT;
  bool LHSIsComplex;
  unsigned LHSOffset;
  if (LHS->getType()->isAnyComplexType()) {
    LHSIsComplex = true;
    ElemT = classifyComplexElementType(LHS->getType());
    LHSOffset = allocateLocalPrimitive(LHS, PT_Ptr, /*IsConst=*/true);
    if (!this->visit(LHS))
      return false;
    if (!this->emitSetLocal(PT_Ptr, LHSOffset, E))
      return false;
  } else {
    LHSIsComplex = false;
    PrimType LHST = classifyPrim(LHS->getType());
    LHSOffset = this->allocateLocalPrimitive(LHS, LHST, /*IsConst=*/true);
    if (!this->visit(LHS))
      return false;
    if (!this->emitSetLocal(LHST, LHSOffset, E))
      return false;
  }
 
  bool RHSIsComplex;
  unsigned RHSOffset;
  if (RHS->getType()->isAnyComplexType()) {
    RHSIsComplex = true;
    ElemT = classifyComplexElementType(RHS->getType());
    RHSOffset = allocateLocalPrimitive(RHS, PT_Ptr, /*IsConst=*/true);
    if (!this->visit(RHS))
      return false;
    if (!this->emitSetLocal(PT_Ptr, RHSOffset, E))
      return false;
  } else {
    RHSIsComplex = false;
    PrimType RHST = classifyPrim(RHS->getType());
    RHSOffset = this->allocateLocalPrimitive(RHS, RHST, /*IsConst=*/true);
    if (!this->visit(RHS))
      return false;
    if (!this->emitSetLocal(RHST, RHSOffset, E))
      return false;
  }
 
  auto getElem = [&](unsigned LocalOffset, unsigned Index,
                     bool IsComplex) -> bool {
    if (IsComplex) {
      if (!this->emitGetLocal(PT_Ptr, LocalOffset, E))
        return false;
      return this->emitArrayElemPop(ElemT, Index, E);
    }
    return this->emitGetLocal(ElemT, LocalOffset, E);
  };
 
  for (unsigned I = 0; I != 2; ++I) {
    // Get both values.
    if (!getElem(LHSOffset, I, LHSIsComplex))
      return false;
    if (!getElem(RHSOffset, I, RHSIsComplex))
      return false;
    // And compare them.
    if (!this->emitEQ(ElemT, E))
      return false;
 
    if (!this->emitCastBoolUint8(E))
      return false;
  }
 
  // We now have two bool values on the stack. Compare those.
  if (!this->emitAddUint8(E))
    return false;
  if (!this->emitConstUint8(2, E))
    return false;
 
  if (E->getOpcode() == BO_EQ) {
    if (!this->emitEQUint8(E))
      return false;
  } else if (E->getOpcode() == BO_NE) {
    if (!this->emitNEUint8(E))
      return false;
  } else
    return false;
 
  // In C, this returns an int.
  if (PrimType ResT = classifyPrim(E->getType()); ResT != PT_Bool)
    return this->emitCast(PT_Bool, ResT, E);
  return true;
}
 
/// When calling this, we have a pointer of the local-to-destroy
/// on the stack.
/// Emit destruction of record types (or arrays of record types).
template <class Emitter>
bool Compiler<Emitter>::emitRecordDestructionPop(const Record *R,
                                                 SourceInfo Loc) {
  assert(R);
  assert(!R->hasTrivialDtor());
  const CXXDestructorDecl *Dtor = R->getDestructor();
  assert(Dtor);
  const Function *DtorFunc = getFunction(Dtor);
  if (!DtorFunc)
    return false;
  assert(DtorFunc->hasThisPointer());
  assert(DtorFunc->getNumParams() == 1);
  return this->emitCall(DtorFunc, 0, Loc);
}
/// When calling this, we have a pointer of the local-to-destroy
/// on the stack.
/// Emit destruction of record types (or arrays of record types).
template <class Emitter>
bool Compiler<Emitter>::emitDestructionPop(const Descriptor *Desc,
                                           SourceInfo Loc) {
  assert(Desc);
  assert(!Desc->hasTrivialDtor());
 
  // Arrays.
  if (Desc->isArray()) {
    const Descriptor *ElemDesc = Desc->ElemDesc;
    assert(ElemDesc);
 
    unsigned N = Desc->getNumElems();
    if (N == 0)
      return this->emitPopPtr(Loc);
 
    for (ssize_t I = N - 1; I >= 1; --I) {
      if (!this->emitConstUint64(I, Loc))
        return false;
      if (!this->emitArrayElemPtrUint64(Loc))
        return false;
      if (!this->emitDestructionPop(ElemDesc, Loc))
        return false;
    }
    // Last iteration, removes the instance pointer from the stack.
    if (!this->emitConstUint64(0, Loc))
      return false;
    if (!this->emitArrayElemPtrPopUint64(Loc))
      return false;
    return this->emitDestructionPop(ElemDesc, Loc);
  }
 
  assert(Desc->ElemRecord);
  assert(!Desc->ElemRecord->hasTrivialDtor());
  return this->emitRecordDestructionPop(Desc->ElemRecord, Loc);
}
 
/// Create a dummy pointer for the given decl (or expr) and
/// push a pointer to it on the stack.
template <class Emitter>
bool Compiler<Emitter>::emitDummyPtr(DeclOrExpr D, const Expr *E, bool CU) {
  assert(!DiscardResult && "Should've been checked before");
  return this->emitGetOpaquePtr(D, CU, E);
}
 
template <class Emitter>
bool Compiler<Emitter>::emitFloat(const APFloat &F, SourceInfo Info) {
  if (Floating::singleWord(F.getSemantics()))
    return this->emitConstFloat(Floating(F), Info);
 
  APInt I = F.bitcastToAPInt();
  return this->emitConstFloat(
      Floating(const_cast<uint64_t *>(I.getRawData()),
               llvm::APFloatBase::SemanticsToEnum(F.getSemantics())),
      Info);
}
 
//  This function is constexpr if and only if To, From, and the types of
//  all subobjects of To and From are types T such that...
//  (3.1) - is_union_v<T> is false;
//  (3.2) - is_pointer_v<T> is false;
//  (3.3) - is_member_pointer_v<T> is false;
//  (3.4) - is_volatile_v<T> is false; and
//  (3.5) - T has no non-static data members of reference type
template <class Emitter>
bool Compiler<Emitter>::emitBuiltinBitCast(const CastExpr *E) {
  const Expr *SubExpr = E->getSubExpr();
  QualType FromType = SubExpr->getType();
  QualType ToType = E->getType();
  OptPrimType ToT = classify(ToType);
 
  assert(!ToType->isReferenceType());
 
  // Prepare storage for the result in case we discard.
  if (DiscardResult && !Initializing && !ToT) {
    UnsignedOrNone LocalIndex = allocateLocal(E);
    if (!LocalIndex)
      return false;
    if (!this->emitGetPtrLocal(*LocalIndex, E))
      return false;
  }
 
  // Get a pointer to the value-to-cast on the stack.
  // For CK_LValueToRValueBitCast, this is always an lvalue and
  // we later assume it to be one (i.e. a PT_Ptr). However,
  // we call this function for other utility methods where
  // a bitcast might be useful, so convert it to a PT_Ptr in that case.
  if (SubExpr->isGLValue() || FromType->isVectorType()) {
    if (!this->visit(SubExpr))
      return false;
  } else if (OptPrimType FromT = classify(SubExpr)) {
    unsigned TempOffset =
        allocateLocalPrimitive(SubExpr, *FromT, /*IsConst=*/true);
    if (!this->visit(SubExpr))
      return false;
    if (!this->emitSetLocal(*FromT, TempOffset, E))
      return false;
    if (!this->emitGetPtrLocal(TempOffset, E))
      return false;
  } else {
    return false;
  }
 
  if (!ToT) {
    if (!this->emitBitCast(E))
      return false;
    return DiscardResult ? this->emitPopPtr(E) : true;
  }
  assert(ToT);
 
  const llvm::fltSemantics *TargetSemantics = nullptr;
  if (ToT == PT_Float)
    TargetSemantics = &Ctx.getFloatSemantics(ToType);
 
  // Conversion to a primitive type. FromType can be another
  // primitive type, or a record/array.
  bool ToTypeIsUChar = (ToType->isSpecificBuiltinType(BuiltinType::UChar) ||
                        ToType->isSpecificBuiltinType(BuiltinType::Char_U));
  uint32_t ResultBitWidth = std::max(Ctx.getBitWidth(ToType), 8u);
 
  if (!this->emitBitCastPrim(*ToT, ToTypeIsUChar || ToType->isStdByteType(),
                             ResultBitWidth, TargetSemantics,
                             ToType.getTypePtr(), E))
    return false;
 
  if (DiscardResult)
    return this->emitPop(*ToT, E);
 
  return true;
}
 
/// Replicate a scalar value into every scalar element of an aggregate.
/// The scalar is stored in a local at \p SrcOffset and a pointer to the
/// destination must be on top of the interpreter stack. Each element receives
/// the scalar, cast to its own type.
template <class Emitter>
bool Compiler<Emitter>::emitHLSLAggregateSplat(PrimType SrcT,
                                               unsigned SrcOffset,
                                               QualType DestType,
                                               const Expr *E) {
  // Vectors and matrices are treated as flat sequences of elements.
  unsigned NumElems = 0;
  QualType ElemType;
  if (const auto *VT = DestType->getAs<VectorType>()) {
    NumElems = VT->getNumElements();
    ElemType = VT->getElementType();
  } else if (const auto *MT = DestType->getAs<ConstantMatrixType>()) {
    NumElems = MT->getNumElementsFlattened();
    ElemType = MT->getElementType();
  }
  if (NumElems > 0) {
    PrimType ElemT = classifyPrim(ElemType);
    for (unsigned I = 0; I != NumElems; ++I) {
      if (!this->emitGetLocal(SrcT, SrcOffset, E))
        return false;
      if (!this->emitPrimCast(SrcT, ElemT, ElemType, E))
        return false;
      if (!this->emitInitElem(ElemT, I, E))
        return false;
    }
    return true;
  }
 
  // Arrays: primitive elements are filled directly; composite elements
  // require recursion into each sub-aggregate.
  if (const auto *AT = DestType->getAsArrayTypeUnsafe()) {
    const auto *CAT = cast<ConstantArrayType>(AT);
    QualType ArrElemType = CAT->getElementType();
    unsigned ArrSize = CAT->getZExtSize();
 
    if (OptPrimType ElemT = classify(ArrElemType)) {
      for (unsigned I = 0; I != ArrSize; ++I) {
        if (!this->emitGetLocal(SrcT, SrcOffset, E))
          return false;
        if (!this->emitPrimCast(SrcT, *ElemT, ArrElemType, E))
          return false;
        if (!this->emitInitElem(*ElemT, I, E))
          return false;
      }
    } else {
      for (unsigned I = 0; I != ArrSize; ++I) {
        if (!this->emitConstUint32(I, E))
          return false;
        if (!this->emitArrayElemPtrUint32(E))
          return false;
        if (!emitHLSLAggregateSplat(SrcT, SrcOffset, ArrElemType, E))
          return false;
        if (!this->emitFinishInitPop(E))
          return false;
      }
    }
    return true;
  }
 
  // Records: fill base classes first, then named fields in declaration
  // order.
  if (DestType->isRecordType()) {
    const Record *R = getRecord(DestType);
    if (!R)
      return false;
 
    if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(R->getDecl())) {
      for (const CXXBaseSpecifier &BS : CXXRD->bases()) {
        const Record::Base *B = R->getBase(BS.getType());
        assert(B);
        if (!this->emitGetPtrBase(B->Offset, E))
          return false;
        if (!emitHLSLAggregateSplat(SrcT, SrcOffset, BS.getType(), E))
          return false;
        if (!this->emitFinishInitPop(E))
          return false;
      }
    }
 
    for (const Record::Field &F : R->fields()) {
      if (F.isUnnamedBitField())
        continue;
 
      QualType FieldType = F.Decl->getType();
      if (OptPrimType FieldT = F.T) {
        if (!this->emitGetLocal(SrcT, SrcOffset, E))
          return false;
        if (!this->emitPrimCast(SrcT, *FieldT, FieldType, E))
          return false;
        if (F.isBitField()) {
          if (!this->emitInitBitField(*FieldT, F.Offset, F.bitWidth(), E))
            return false;
        } else {
          if (!this->emitInitField(*FieldT, F.Offset, E))
            return false;
        }
      } else {
        if (!this->emitGetPtrField(F.Offset, E))
          return false;
        if (!emitHLSLAggregateSplat(SrcT, SrcOffset, FieldType, E))
          return false;
        if (!this->emitPopPtr(E))
          return false;
      }
    }
    return true;
  }
 
  return false;
}
 
/// Return the total number of scalar elements in a type. This is used
/// to cap how many source elements are extracted during an elementwise cast,
/// so we never flatten more than the destination can hold.
template <class Emitter>
unsigned Compiler<Emitter>::countHLSLFlatElements(QualType Ty) {
  // Vector and matrix types are treated as flat sequences of elements.
  if (const auto *VT = Ty->getAs<VectorType>())
    return VT->getNumElements();
  if (const auto *MT = Ty->getAs<ConstantMatrixType>())
    return MT->getNumElementsFlattened();
  // Arrays: total count is array size * scalar elements per element.
  if (const auto *AT = Ty->getAsArrayTypeUnsafe()) {
    const auto *CAT = cast<ConstantArrayType>(AT);
    return CAT->getZExtSize() * countHLSLFlatElements(CAT->getElementType());
  }
  // Records: sum scalar element counts of base classes and named fields.
  if (Ty->isRecordType()) {
    const Record *R = getRecord(Ty);
    if (!R)
      return 0;
    unsigned Count = 0;
    if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(R->getDecl())) {
      for (const CXXBaseSpecifier &BS : CXXRD->bases())
        Count += countHLSLFlatElements(BS.getType());
    }
    for (const Record::Field &F : R->fields()) {
      if (F.isUnnamedBitField())
        continue;
      Count += countHLSLFlatElements(F.Decl->getType());
    }
    return Count;
  }
  // Scalar primitive types contribute one element.
  if (canClassify(Ty))
    return 1;
  return 0;
}
 
/// Walk a source aggregate and extract every scalar element into its own local
/// variable. The results are appended to \p Elements in declaration order,
/// stopping once \p MaxElements have been collected. A pointer to the
/// source aggregate must be stored in the local at \p SrcOffset.
template <class Emitter>
bool Compiler<Emitter>::emitHLSLFlattenAggregate(
    QualType SrcType, unsigned SrcOffset,
    SmallVectorImpl<HLSLFlatElement> &Elements, unsigned MaxElements,
    const Expr *E) {
 
  // Save a scalar value from the stack into a new local and record it.
  auto saveToLocal = [&](PrimType T) -> bool {
    unsigned Offset = allocateLocalPrimitive(E, T, /*IsConst=*/true);
    if (!this->emitSetLocal(T, Offset, E))
      return false;
    Elements.push_back({Offset, T});
    return true;
  };
 
  // Save a pointer from the stack into a new local for later use.
  auto savePtrToLocal = [&]() -> UnsignedOrNone {
    unsigned Offset = allocateLocalPrimitive(E, PT_Ptr, /*IsConst=*/true);
    if (!this->emitSetLocal(PT_Ptr, Offset, E))
      return std::nullopt;
    return Offset;
  };
 
  // Vectors and matrices are flat sequences of elements.
  unsigned NumElems = 0;
  QualType ElemType;
  if (const auto *VT = SrcType->getAs<VectorType>()) {
    NumElems = VT->getNumElements();
    ElemType = VT->getElementType();
  } else if (const auto *MT = SrcType->getAs<ConstantMatrixType>()) {
    NumElems = MT->getNumElementsFlattened();
    ElemType = MT->getElementType();
  }
  if (NumElems > 0) {
    PrimType ElemT = classifyPrim(ElemType);
    for (unsigned I = 0; I != NumElems && Elements.size() < MaxElements; ++I) {
      if (!this->emitGetLocal(PT_Ptr, SrcOffset, E))
        return false;
      if (!this->emitArrayElemPop(ElemT, I, E))
        return false;
      if (!saveToLocal(ElemT))
        return false;
    }
    return true;
  }
 
  // Arrays: primitive elements are extracted directly; composite elements
  // require recursion into each sub-aggregate.
  if (const auto *AT = SrcType->getAsArrayTypeUnsafe()) {
    const auto *CAT = cast<ConstantArrayType>(AT);
    QualType ArrElemType = CAT->getElementType();
    unsigned ArrSize = CAT->getZExtSize();
 
    if (OptPrimType ElemT = classify(ArrElemType)) {
      for (unsigned I = 0; I != ArrSize && Elements.size() < MaxElements; ++I) {
        if (!this->emitGetLocal(PT_Ptr, SrcOffset, E))
          return false;
        if (!this->emitArrayElemPop(*ElemT, I, E))
          return false;
        if (!saveToLocal(*ElemT))
          return false;
      }
    } else {
      for (unsigned I = 0; I != ArrSize && Elements.size() < MaxElements; ++I) {
        if (!this->emitGetLocal(PT_Ptr, SrcOffset, E))
          return false;
        if (!this->emitConstUint32(I, E))
          return false;
        if (!this->emitArrayElemPtrPopUint32(E))
          return false;
        UnsignedOrNone ElemPtrOffset = savePtrToLocal();
        if (!ElemPtrOffset)
          return false;
        if (!emitHLSLFlattenAggregate(ArrElemType, *ElemPtrOffset, Elements,
                                      MaxElements, E))
          return false;
      }
    }
    return true;
  }
 
  // Records: base classes come first, then named fields in declaration
  // order.
  if (SrcType->isRecordType()) {
    const Record *R = getRecord(SrcType);
    if (!R)
      return false;
 
    if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(R->getDecl())) {
      for (const CXXBaseSpecifier &BS : CXXRD->bases()) {
        if (Elements.size() >= MaxElements)
          break;
        const Record::Base *B = R->getBase(BS.getType());
        assert(B);
        if (!this->emitGetLocal(PT_Ptr, SrcOffset, E))
          return false;
        if (!this->emitGetPtrBasePop(B->Offset, /*NullOK=*/false, E))
          return false;
        UnsignedOrNone BasePtrOffset = savePtrToLocal();
        if (!BasePtrOffset)
          return false;
        if (!emitHLSLFlattenAggregate(BS.getType(), *BasePtrOffset, Elements,
                                      MaxElements, E))
          return false;
      }
    }
 
    for (const Record::Field &F : R->fields()) {
      if (Elements.size() >= MaxElements)
        break;
      if (F.isUnnamedBitField())
        continue;
 
      QualType FieldType = F.Decl->getType();
      if (!this->emitGetLocal(PT_Ptr, SrcOffset, E))
        return false;
      if (!this->emitGetPtrFieldPop(F.Offset, E))
        return false;
 
      if (OptPrimType FieldT = F.T) {
        if (!this->emitLoadPop(*FieldT, E))
          return false;
        if (!saveToLocal(*FieldT))
          return false;
      } else {
        UnsignedOrNone FieldPtrOffset = savePtrToLocal();
        if (!FieldPtrOffset)
          return false;
        if (!emitHLSLFlattenAggregate(FieldType, *FieldPtrOffset, Elements,
                                      MaxElements, E))
          return false;
      }
    }
    return true;
  }
 
  return false;
}
 
/// Populate an HLSL aggregate from a flat list of previously extracted source
/// elements, casting each to the corresponding destination element type.
/// \p ElemIdx tracks the current position in \p Elements and is advanced as
/// elements are consumed. A pointer to the destination must be on top of the
/// interpreter stack.
template <class Emitter>
bool Compiler<Emitter>::emitHLSLConstructAggregate(
    QualType DestType, ArrayRef<HLSLFlatElement> Elements, unsigned &ElemIdx,
    const Expr *E) {
 
  // Consume the next source element, cast it, and leave it on the stack.
  auto loadAndCast = [&](PrimType DestT, QualType DestQT) -> bool {
    const auto &Src = Elements[ElemIdx++];
    if (!this->emitGetLocal(Src.Type, Src.LocalOffset, E))
      return false;
    return this->emitPrimCast(Src.Type, DestT, DestQT, E);
  };
 
  // Vectors and matrices are flat sequences of elements.
  unsigned NumElems = 0;
  QualType ElemType;
  if (const auto *VT = DestType->getAs<VectorType>()) {
    NumElems = VT->getNumElements();
    ElemType = VT->getElementType();
  } else if (const auto *MT = DestType->getAs<ConstantMatrixType>()) {
    NumElems = MT->getNumElementsFlattened();
    ElemType = MT->getElementType();
  }
  if (NumElems > 0) {
    PrimType DestElemT = classifyPrim(ElemType);
    for (unsigned I = 0; I != NumElems; ++I) {
      if (!loadAndCast(DestElemT, ElemType))
        return false;
      if (!this->emitInitElem(DestElemT, I, E))
        return false;
    }
    return true;
  }
 
  // Arrays: primitive elements are filled directly; composite elements
  // require recursion into each sub-aggregate.
  if (const auto *AT = DestType->getAsArrayTypeUnsafe()) {
    const auto *CAT = cast<ConstantArrayType>(AT);
    QualType ArrElemType = CAT->getElementType();
    unsigned ArrSize = CAT->getZExtSize();
 
    if (OptPrimType ElemT = classify(ArrElemType)) {
      for (unsigned I = 0; I != ArrSize; ++I) {
        if (!loadAndCast(*ElemT, ArrElemType))
          return false;
        if (!this->emitInitElem(*ElemT, I, E))
          return false;
      }
    } else {
      for (unsigned I = 0; I != ArrSize; ++I) {
        if (!this->emitConstUint32(I, E))
          return false;
        if (!this->emitArrayElemPtrUint32(E))
          return false;
        if (!emitHLSLConstructAggregate(ArrElemType, Elements, ElemIdx, E))
          return false;
        if (!this->emitFinishInitPop(E))
          return false;
      }
    }
    return true;
  }
 
  // Records: base classes come first, then named fields in declaration
  // order.
  if (DestType->isRecordType()) {
    const Record *R = getRecord(DestType);
    if (!R)
      return false;
 
    if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(R->getDecl())) {
      for (const CXXBaseSpecifier &BS : CXXRD->bases()) {
        const Record::Base *B = R->getBase(BS.getType());
        assert(B);
        if (!this->emitGetPtrBase(B->Offset, E))
          return false;
        if (!emitHLSLConstructAggregate(BS.getType(), Elements, ElemIdx, E))
          return false;
        if (!this->emitFinishInitPop(E))
          return false;
      }
    }
 
    for (const Record::Field &F : R->fields()) {
      if (F.isUnnamedBitField())
        continue;
 
      QualType FieldType = F.Decl->getType();
      if (OptPrimType FieldT = F.T) {
        if (!loadAndCast(*FieldT, FieldType))
          return false;
        if (F.isBitField()) {
          if (!this->emitInitBitField(*FieldT, F.Offset, F.bitWidth(), E))
            return false;
        } else {
          if (!this->emitInitField(*FieldT, F.Offset, E))
            return false;
        }
      } else {
        if (!this->emitGetPtrField(F.Offset, E))
          return false;
        if (!emitHLSLConstructAggregate(FieldType, Elements, ElemIdx, E))
          return false;
        if (!this->emitPopPtr(E))
          return false;
      }
    }
    return true;
  }
 
  return false;
}
 
namespace clang {
namespace interp {
 
template class Compiler<ByteCodeEmitter>;
template class Compiler<EvalEmitter>;
 
} // namespace interp
} // namespace clang