/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGException.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGException.cpp
Warning:	line 1298, column 36 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGException.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGException.cpp

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGException.cpp

→

1//===--- CGException.cpp - Emit LLVM Code for C++ exceptions ----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This contains code dealing with C++ exception related code generation.
10//
11//===----------------------------------------------------------------------===//

13#include "CGCXXABI.h"
14#include "CGCleanup.h"
15#include "CGObjCRuntime.h"
16#include "CodeGenFunction.h"
17#include "ConstantEmitter.h"
18#include "TargetInfo.h"
19#include "clang/AST/Mangle.h"
20#include "clang/AST/StmtCXX.h"
21#include "clang/AST/StmtObjC.h"
22#include "clang/AST/StmtVisitor.h"
23#include "clang/Basic/DiagnosticSema.h"
24#include "clang/Basic/TargetBuiltins.h"
25#include "llvm/IR/IntrinsicInst.h"
26#include "llvm/IR/Intrinsics.h"
27#include "llvm/IR/IntrinsicsWebAssembly.h"
28#include "llvm/Support/SaveAndRestore.h"

30using namespace clang;
31using namespace CodeGen;

33static llvm::FunctionCallee getFreeExceptionFn(CodeGenModule &CGM) {
// void __cxa_free_exception(void *thrown_exception);

llvm::FunctionType *FTy =
  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);

return CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception");
40}

42static llvm::FunctionCallee getSehTryBeginFn(CodeGenModule &CGM) {
llvm::FunctionType *FTy =
    llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
return CGM.CreateRuntimeFunction(FTy, "llvm.seh.try.begin");
46}

48static llvm::FunctionCallee getSehTryEndFn(CodeGenModule &CGM) {
llvm::FunctionType *FTy =
    llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
return CGM.CreateRuntimeFunction(FTy, "llvm.seh.try.end");
52}

54static llvm::FunctionCallee getUnexpectedFn(CodeGenModule &CGM) {
// void __cxa_call_unexpected(void *thrown_exception);

llvm::FunctionType *FTy =
  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);

return CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected");
61}

63llvm::FunctionCallee CodeGenModule::getTerminateFn() {
// void __terminate();

llvm::FunctionType *FTy =
  llvm::FunctionType::get(VoidTy, /*isVarArg=*/false);

StringRef name;

// In C++, use std::terminate().
if (getLangOpts().CPlusPlus &&
    getTarget().getCXXABI().isItaniumFamily()) {
  name = "_ZSt9terminatev";
} else if (getLangOpts().CPlusPlus &&
           getTarget().getCXXABI().isMicrosoft()) {
  if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
    name = "__std_terminate";
  else
    name = "?terminate@@YAXXZ";
} else if (getLangOpts().ObjC &&
           getLangOpts().ObjCRuntime.hasTerminate())
  name = "objc_terminate";
else
  name = "abort";
return CreateRuntimeFunction(FTy, name);
87}

89static llvm::FunctionCallee getCatchallRethrowFn(CodeGenModule &CGM,
                                               StringRef Name) {
llvm::FunctionType *FTy =
  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);

return CGM.CreateRuntimeFunction(FTy, Name);
95}

97const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", nullptr };
98const EHPersonality
99EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", nullptr };
100const EHPersonality
101EHPersonality::GNU_C_SEH = { "__gcc_personality_seh0", nullptr };
102const EHPersonality
103EHPersonality::NeXT_ObjC = { "__objc_personality_v0", nullptr };
104const EHPersonality
105EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", nullptr };
106const EHPersonality
107EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", nullptr };
108const EHPersonality
109EHPersonality::GNU_CPlusPlus_SEH = { "__gxx_personality_seh0", nullptr };
110const EHPersonality
111EHPersonality::GNU_ObjC = {"__gnu_objc_personality_v0", "objc_exception_throw"};
112const EHPersonality
113EHPersonality::GNU_ObjC_SJLJ = {"__gnu_objc_personality_sj0", "objc_exception_throw"};
114const EHPersonality
115EHPersonality::GNU_ObjC_SEH = {"__gnu_objc_personality_seh0", "objc_exception_throw"};
116const EHPersonality
117EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", nullptr };
118const EHPersonality
119EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", nullptr };
120const EHPersonality
121EHPersonality::MSVC_except_handler = { "_except_handler3", nullptr };
122const EHPersonality
123EHPersonality::MSVC_C_specific_handler = { "__C_specific_handler", nullptr };
124const EHPersonality
125EHPersonality::MSVC_CxxFrameHandler3 = { "__CxxFrameHandler3", nullptr };
126const EHPersonality
127EHPersonality::GNU_Wasm_CPlusPlus = { "__gxx_wasm_personality_v0", nullptr };
128const EHPersonality EHPersonality::XL_CPlusPlus = {"__xlcxx_personality_v1",
                                                 nullptr};

131static const EHPersonality &getCPersonality(const TargetInfo &Target,
                                          const LangOptions &L) {
const llvm::Triple &T = Target.getTriple();
if (T.isWindowsMSVCEnvironment())
  return EHPersonality::MSVC_CxxFrameHandler3;
if (L.hasSjLjExceptions())
  return EHPersonality::GNU_C_SJLJ;
if (L.hasDWARFExceptions())
  return EHPersonality::GNU_C;
if (L.hasSEHExceptions())
  return EHPersonality::GNU_C_SEH;
return EHPersonality::GNU_C;
143}

145static const EHPersonality &getObjCPersonality(const TargetInfo &Target,
                                             const LangOptions &L) {
const llvm::Triple &T = Target.getTriple();
if (T.isWindowsMSVCEnvironment())
  return EHPersonality::MSVC_CxxFrameHandler3;

switch (L.ObjCRuntime.getKind()) {
case ObjCRuntime::FragileMacOSX:
  return getCPersonality(Target, L);
case ObjCRuntime::MacOSX:
case ObjCRuntime::iOS:
case ObjCRuntime::WatchOS:
  return EHPersonality::NeXT_ObjC;
case ObjCRuntime::GNUstep:
  if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7))
    return EHPersonality::GNUstep_ObjC;
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case ObjCRuntime::GCC:
case ObjCRuntime::ObjFW:
  if (L.hasSjLjExceptions())
    return EHPersonality::GNU_ObjC_SJLJ;
  if (L.hasSEHExceptions())
    return EHPersonality::GNU_ObjC_SEH;
  return EHPersonality::GNU_ObjC;
}
llvm_unreachable("bad runtime kind")__builtin_unreachable();
171}

173static const EHPersonality &getCXXPersonality(const TargetInfo &Target,
                                            const LangOptions &L) {
const llvm::Triple &T = Target.getTriple();
if (T.isWindowsMSVCEnvironment())
  return EHPersonality::MSVC_CxxFrameHandler3;
if (T.isOSAIX())
  return EHPersonality::XL_CPlusPlus;
if (L.hasSjLjExceptions())
  return EHPersonality::GNU_CPlusPlus_SJLJ;
if (L.hasDWARFExceptions())
  return EHPersonality::GNU_CPlusPlus;
if (L.hasSEHExceptions())
  return EHPersonality::GNU_CPlusPlus_SEH;
if (L.hasWasmExceptions())
  return EHPersonality::GNU_Wasm_CPlusPlus;
return EHPersonality::GNU_CPlusPlus;
189}

191/// Determines the personality function to use when both C++
192/// and Objective-C exceptions are being caught.
193static const EHPersonality &getObjCXXPersonality(const TargetInfo &Target,
                                               const LangOptions &L) {
if (Target.getTriple().isWindowsMSVCEnvironment())
  return EHPersonality::MSVC_CxxFrameHandler3;

switch (L.ObjCRuntime.getKind()) {
// In the fragile ABI, just use C++ exception handling and hope
// they're not doing crazy exception mixing.
case ObjCRuntime::FragileMacOSX:
  return getCXXPersonality(Target, L);

// The ObjC personality defers to the C++ personality for non-ObjC
// handlers.  Unlike the C++ case, we use the same personality
// function on targets using (backend-driven) SJLJ EH.
case ObjCRuntime::MacOSX:
case ObjCRuntime::iOS:
case ObjCRuntime::WatchOS:
  return getObjCPersonality(Target, L);

case ObjCRuntime::GNUstep:
  return EHPersonality::GNU_ObjCXX;

// The GCC runtime's personality function inherently doesn't support
// mixed EH.  Use the ObjC personality just to avoid returning null.
case ObjCRuntime::GCC:
case ObjCRuntime::ObjFW:
  return getObjCPersonality(Target, L);
}
llvm_unreachable("bad runtime kind")__builtin_unreachable();
222}

224static const EHPersonality &getSEHPersonalityMSVC(const llvm::Triple &T) {
if (T.getArch() == llvm::Triple::x86)
  return EHPersonality::MSVC_except_handler;
return EHPersonality::MSVC_C_specific_handler;
228}

230const EHPersonality &EHPersonality::get(CodeGenModule &CGM,
                                      const FunctionDecl *FD) {
const llvm::Triple &T = CGM.getTarget().getTriple();
const LangOptions &L = CGM.getLangOpts();
const TargetInfo &Target = CGM.getTarget();

// Functions using SEH get an SEH personality.
if (FD && FD->usesSEHTry())
  return getSEHPersonalityMSVC(T);

if (L.ObjC)
  return L.CPlusPlus ? getObjCXXPersonality(Target, L)
                     : getObjCPersonality(Target, L);
return L.CPlusPlus ? getCXXPersonality(Target, L)
                   : getCPersonality(Target, L);
245}

247const EHPersonality &EHPersonality::get(CodeGenFunction &CGF) {
const auto *FD = CGF.CurCodeDecl;
// For outlined finallys and filters, use the SEH personality in case they
// contain more SEH. This mostly only affects finallys. Filters could
// hypothetically use gnu statement expressions to sneak in nested SEH.
FD = FD ? FD : CGF.CurSEHParent;
return get(CGF.CGM, dyn_cast_or_null<FunctionDecl>(FD));
254}

256static llvm::FunctionCallee getPersonalityFn(CodeGenModule &CGM,
                                           const EHPersonality &Personality) {
return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true),
                                 Personality.PersonalityFn,
                                 llvm::AttributeList(), /*Local=*/true);
261}

263static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM,
                                      const EHPersonality &Personality) {
llvm::FunctionCallee Fn = getPersonalityFn(CGM, Personality);
llvm::PointerType* Int8PtrTy = llvm::PointerType::get(
    llvm::Type::getInt8Ty(CGM.getLLVMContext()),
    CGM.getDataLayout().getProgramAddressSpace());

return llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(Fn.getCallee()),
                                      Int8PtrTy);
272}

274/// Check whether a landingpad instruction only uses C++ features.
275static bool LandingPadHasOnlyCXXUses(llvm::LandingPadInst *LPI) {
for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) {
  // Look for something that would've been returned by the ObjC
  // runtime's GetEHType() method.
  llvm::Value *Val = LPI->getClause(I)->stripPointerCasts();
  if (LPI->isCatch(I)) {
    // Check if the catch value has the ObjC prefix.
    if (llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Val))
      // ObjC EH selector entries are always global variables with
      // names starting like this.
      if (GV->getName().startswith("OBJC_EHTYPE"))
        return false;
  } else {
    // Check if any of the filter values have the ObjC prefix.
    llvm::Constant *CVal = cast<llvm::Constant>(Val);
    for (llvm::User::op_iterator
            II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) {
      if (llvm::GlobalVariable *GV =
          cast<llvm::GlobalVariable>((*II)->stripPointerCasts()))
        // ObjC EH selector entries are always global variables with
        // names starting like this.
        if (GV->getName().startswith("OBJC_EHTYPE"))
          return false;
    }
  }
}
return true;
302}

304/// Check whether a personality function could reasonably be swapped
305/// for a C++ personality function.
306static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) {
for (llvm::User *U : Fn->users()) {
  // Conditionally white-list bitcasts.
  if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(U)) {
    if (CE->getOpcode() != llvm::Instruction::BitCast) return false;
    if (!PersonalityHasOnlyCXXUses(CE))
      return false;
    continue;
  }

  // Otherwise it must be a function.
  llvm::Function *F = dyn_cast<llvm::Function>(U);
  if (!F) return false;

  for (auto BB = F->begin(), E = F->end(); BB != E; ++BB) {
    if (BB->isLandingPad())
      if (!LandingPadHasOnlyCXXUses(BB->getLandingPadInst()))
        return false;
  }
}

return true;
328}

330/// Try to use the C++ personality function in ObjC++.  Not doing this
331/// can cause some incompatibilities with gcc, which is more
332/// aggressive about only using the ObjC++ personality in a function
333/// when it really needs it.
334void CodeGenModule::SimplifyPersonality() {
// If we're not in ObjC++ -fexceptions, there's nothing to do.
if (!LangOpts.CPlusPlus || !LangOpts.ObjC || !LangOpts.Exceptions)
  return;

// Both the problem this endeavors to fix and the way the logic
// above works is specific to the NeXT runtime.
if (!LangOpts.ObjCRuntime.isNeXTFamily())
  return;

const EHPersonality &ObjCXX = EHPersonality::get(*this, /*FD=*/nullptr);
const EHPersonality &CXX = getCXXPersonality(getTarget(), LangOpts);
if (&ObjCXX == &CXX)
  return;

assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 &&((void)0)
       "Different EHPersonalities using the same personality function.")((void)0);

llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn);

// Nothing to do if it's unused.
if (!Fn || Fn->use_empty()) return;

// Can't do the optimization if it has non-C++ uses.
if (!PersonalityHasOnlyCXXUses(Fn)) return;

// Create the C++ personality function and kill off the old
// function.
llvm::FunctionCallee CXXFn = getPersonalityFn(*this, CXX);

// This can happen if the user is screwing with us.
if (Fn->getType() != CXXFn.getCallee()->getType())
  return;

Fn->replaceAllUsesWith(CXXFn.getCallee());
Fn->eraseFromParent();
370}

372/// Returns the value to inject into a selector to indicate the
373/// presence of a catch-all.
374static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) {
// Possibly we should use @llvm.eh.catch.all.value here.
return llvm::ConstantPointerNull::get(CGF.Int8PtrTy);
377}

379namespace {
/// A cleanup to free the exception object if its initialization
/// throws.
struct FreeException final : EHScopeStack::Cleanup {
  llvm::Value *exn;
  FreeException(llvm::Value *exn) : exn(exn) {}
  void Emit(CodeGenFunction &CGF, Flags flags) override {
    CGF.EmitNounwindRuntimeCall(getFreeExceptionFn(CGF.CGM), exn);
  }
};
389} // end anonymous namespace

391// Emits an exception expression into the given location.  This
392// differs from EmitAnyExprToMem only in that, if a final copy-ctor
393// call is required, an exception within that copy ctor causes
394// std::terminate to be invoked.
395void CodeGenFunction::EmitAnyExprToExn(const Expr *e, Address addr) {
// Make sure the exception object is cleaned up if there's an
// exception during initialization.
pushFullExprCleanup<FreeException>(EHCleanup, addr.getPointer());
EHScopeStack::stable_iterator cleanup = EHStack.stable_begin();

// __cxa_allocate_exception returns a void*;  we need to cast this
// to the appropriate type for the object.
llvm::Type *ty = ConvertTypeForMem(e->getType())->getPointerTo();
Address typedAddr = Builder.CreateBitCast(addr, ty);

// FIXME: this isn't quite right!  If there's a final unelided call
// to a copy constructor, then according to [except.terminate]p1 we
// must call std::terminate() if that constructor throws, because
// technically that copy occurs after the exception expression is
// evaluated but before the exception is caught.  But the best way
// to handle that is to teach EmitAggExpr to do the final copy
// differently if it can't be elided.
EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(),
                 /*IsInit*/ true);

// Deactivate the cleanup block.
DeactivateCleanupBlock(cleanup,
                       cast<llvm::Instruction>(typedAddr.getPointer()));
419}

421Address CodeGenFunction::getExceptionSlot() {
if (!ExceptionSlot)
  ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot");
return Address(ExceptionSlot, getPointerAlign());
425}

427Address CodeGenFunction::getEHSelectorSlot() {
if (!EHSelectorSlot)
  EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot");
return Address(EHSelectorSlot, CharUnits::fromQuantity(4));
431}

433llvm::Value *CodeGenFunction::getExceptionFromSlot() {
return Builder.CreateLoad(getExceptionSlot(), "exn");
435}

437llvm::Value *CodeGenFunction::getSelectorFromSlot() {
return Builder.CreateLoad(getEHSelectorSlot(), "sel");
439}

441void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E,
                                     bool KeepInsertionPoint) {
if (const Expr *SubExpr = E->getSubExpr()) {
  QualType ThrowType = SubExpr->getType();
  if (ThrowType->isObjCObjectPointerType()) {
    const Stmt *ThrowStmt = E->getSubExpr();
    const ObjCAtThrowStmt S(E->getExprLoc(), const_cast<Stmt *>(ThrowStmt));
    CGM.getObjCRuntime().EmitThrowStmt(*this, S, false);
  } else {
    CGM.getCXXABI().emitThrow(*this, E);
  }
} else {
  CGM.getCXXABI().emitRethrow(*this, /*isNoReturn=*/true);
}

// throw is an expression, and the expression emitters expect us
// to leave ourselves at a valid insertion point.
if (KeepInsertionPoint)
  EmitBlock(createBasicBlock("throw.cont"));
460}

462void CodeGenFunction::EmitStartEHSpec(const Decl *D) {
if (!CGM.getLangOpts().CXXExceptions)
  return;

const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
if (!FD) {
  // Check if CapturedDecl is nothrow and create terminate scope for it.
  if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
    if (CD->isNothrow())
      EHStack.pushTerminate();
  }
  return;
}
const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
if (!Proto)
  return;

ExceptionSpecificationType EST = Proto->getExceptionSpecType();
if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) {
  // noexcept functions are simple terminate scopes.
  if (!getLangOpts().EHAsynch) // -EHa: HW exception still can occur
    EHStack.pushTerminate();
} else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
  // TODO: Revisit exception specifications for the MS ABI.  There is a way to
  // encode these in an object file but MSVC doesn't do anything with it.
  if (getTarget().getCXXABI().isMicrosoft())
    return;
  // In Wasm EH we currently treat 'throw()' in the same way as 'noexcept'. In
  // case of throw with types, we ignore it and print a warning for now.
  // TODO Correctly handle exception specification in Wasm EH
  if (CGM.getLangOpts().hasWasmExceptions()) {
    if (EST == EST_DynamicNone)
      EHStack.pushTerminate();
    else
      CGM.getDiags().Report(D->getLocation(),
                            diag::warn_wasm_dynamic_exception_spec_ignored)
          << FD->getExceptionSpecSourceRange();
    return;
  }
  // Currently Emscripten EH only handles 'throw()' but not 'throw' with
  // types. 'throw()' handling will be done in JS glue code so we don't need
  // to do anything in that case. Just print a warning message in case of
  // throw with types.
  // TODO Correctly handle exception specification in Emscripten EH
  if (getTarget().getCXXABI() == TargetCXXABI::WebAssembly &&
      CGM.getLangOpts().getExceptionHandling() ==
          LangOptions::ExceptionHandlingKind::None &&
      EST == EST_Dynamic)
    CGM.getDiags().Report(D->getLocation(),
                          diag::warn_wasm_dynamic_exception_spec_ignored)
        << FD->getExceptionSpecSourceRange();

  unsigned NumExceptions = Proto->getNumExceptions();
  EHFilterScope *Filter = EHStack.pushFilter(NumExceptions);

  for (unsigned I = 0; I != NumExceptions; ++I) {
    QualType Ty = Proto->getExceptionType(I);
    QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType();
    llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType,
                                                      /*ForEH=*/true);
    Filter->setFilter(I, EHType);
  }
}
525}

527/// Emit the dispatch block for a filter scope if necessary.
528static void emitFilterDispatchBlock(CodeGenFunction &CGF,
                                  EHFilterScope &filterScope) {
llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock();
if (!dispatchBlock) return;
if (dispatchBlock->use_empty()) {
  delete dispatchBlock;
  return;
}

CGF.EmitBlockAfterUses(dispatchBlock);

// If this isn't a catch-all filter, we need to check whether we got
// here because the filter triggered.
if (filterScope.getNumFilters()) {
  // Load the selector value.
  llvm::Value *selector = CGF.getSelectorFromSlot();
  llvm::BasicBlock *unexpectedBB = CGF.createBasicBlock("ehspec.unexpected");

  llvm::Value *zero = CGF.Builder.getInt32(0);
  llvm::Value *failsFilter =
      CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails");
  CGF.Builder.CreateCondBr(failsFilter, unexpectedBB,
                           CGF.getEHResumeBlock(false));

  CGF.EmitBlock(unexpectedBB);
}

// Call __cxa_call_unexpected.  This doesn't need to be an invoke
// because __cxa_call_unexpected magically filters exceptions
// according to the last landing pad the exception was thrown
// into.  Seriously.
llvm::Value *exn = CGF.getExceptionFromSlot();
CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn)
  ->setDoesNotReturn();
CGF.Builder.CreateUnreachable();
563}

565void CodeGenFunction::EmitEndEHSpec(const Decl *D) {
if (!CGM.getLangOpts().CXXExceptions)
  return;

const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
if (!FD) {
  // Check if CapturedDecl is nothrow and pop terminate scope for it.
  if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
    if (CD->isNothrow() && !EHStack.empty())
      EHStack.popTerminate();
  }
  return;
}
const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
if (!Proto)
  return;

ExceptionSpecificationType EST = Proto->getExceptionSpecType();
if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot &&
    !EHStack.empty() /* possible empty when under async exceptions */) {
  EHStack.popTerminate();
} else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
  // TODO: Revisit exception specifications for the MS ABI.  There is a way to
  // encode these in an object file but MSVC doesn't do anything with it.
  if (getTarget().getCXXABI().isMicrosoft())
    return;
  // In wasm we currently treat 'throw()' in the same way as 'noexcept'. In
  // case of throw with types, we ignore it and print a warning for now.
  // TODO Correctly handle exception specification in wasm
  if (CGM.getLangOpts().hasWasmExceptions()) {
    if (EST == EST_DynamicNone)
      EHStack.popTerminate();
    return;
  }
  EHFilterScope &filterScope = cast<EHFilterScope>(*EHStack.begin());
  emitFilterDispatchBlock(*this, filterScope);
  EHStack.popFilter();
}
603}

605void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) {
EnterCXXTryStmt(S);
EmitStmt(S.getTryBlock());
ExitCXXTryStmt(S);
1
Calling 'CodeGenFunction::ExitCXXTryStmt'→
609}

611void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
unsigned NumHandlers = S.getNumHandlers();
EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers);

for (unsigned I = 0; I != NumHandlers; ++I) {
  const CXXCatchStmt *C = S.getHandler(I);

  llvm::BasicBlock *Handler = createBasicBlock("catch");
  if (C->getExceptionDecl()) {
    // FIXME: Dropping the reference type on the type into makes it
    // impossible to correctly implement catch-by-reference
    // semantics for pointers.  Unfortunately, this is what all
    // existing compilers do, and it's not clear that the standard
    // personality routine is capable of doing this right.  See C++ DR 388:
    //   http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388
    Qualifiers CaughtTypeQuals;
    QualType CaughtType = CGM.getContext().getUnqualifiedArrayType(
        C->getCaughtType().getNonReferenceType(), CaughtTypeQuals);

    CatchTypeInfo TypeInfo{nullptr, 0};
    if (CaughtType->isObjCObjectPointerType())
      TypeInfo.RTTI = CGM.getObjCRuntime().GetEHType(CaughtType);
    else
      TypeInfo = CGM.getCXXABI().getAddrOfCXXCatchHandlerType(
          CaughtType, C->getCaughtType());
    CatchScope->setHandler(I, TypeInfo, Handler);
  } else {
    // No exception decl indicates '...', a catch-all.
    CatchScope->setHandler(I, CGM.getCXXABI().getCatchAllTypeInfo(), Handler);
    // Under async exceptions, catch(...) need to catch HW exception too
    // Mark scope with SehTryBegin as a SEH __try scope
    if (getLangOpts().EHAsynch)
      EmitRuntimeCallOrInvoke(getSehTryBeginFn(CGM));
  }
}
646}

648llvm::BasicBlock *
649CodeGenFunction::getEHDispatchBlock(EHScopeStack::stable_iterator si) {
if (EHPersonality::get(*this).usesFuncletPads())
  return getFuncletEHDispatchBlock(si);

// The dispatch block for the end of the scope chain is a block that
// just resumes unwinding.
if (si == EHStack.stable_end())
  return getEHResumeBlock(true);

// Otherwise, we should look at the actual scope.
EHScope &scope = *EHStack.find(si);

llvm::BasicBlock *dispatchBlock = scope.getCachedEHDispatchBlock();
if (!dispatchBlock) {
  switch (scope.getKind()) {
  case EHScope::Catch: {
    // Apply a special case to a single catch-all.
    EHCatchScope &catchScope = cast<EHCatchScope>(scope);
    if (catchScope.getNumHandlers() == 1 &&
        catchScope.getHandler(0).isCatchAll()) {
      dispatchBlock = catchScope.getHandler(0).Block;

    // Otherwise, make a dispatch block.
    } else {
      dispatchBlock = createBasicBlock("catch.dispatch");
    }
    break;
  }

  case EHScope::Cleanup:
    dispatchBlock = createBasicBlock("ehcleanup");
    break;

  case EHScope::Filter:
    dispatchBlock = createBasicBlock("filter.dispatch");
    break;

  case EHScope::Terminate:
    dispatchBlock = getTerminateHandler();
    break;
  }
  scope.setCachedEHDispatchBlock(dispatchBlock);
}
return dispatchBlock;
693}

695llvm::BasicBlock *
696CodeGenFunction::getFuncletEHDispatchBlock(EHScopeStack::stable_iterator SI) {
// Returning nullptr indicates that the previous dispatch block should unwind
// to caller.
if (SI == EHStack.stable_end())
  return nullptr;

// Otherwise, we should look at the actual scope.
EHScope &EHS = *EHStack.find(SI);

llvm::BasicBlock *DispatchBlock = EHS.getCachedEHDispatchBlock();
if (DispatchBlock)
  return DispatchBlock;

if (EHS.getKind() == EHScope::Terminate)
  DispatchBlock = getTerminateFunclet();
else
  DispatchBlock = createBasicBlock();
CGBuilderTy Builder(*this, DispatchBlock);

switch (EHS.getKind()) {
case EHScope::Catch:
  DispatchBlock->setName("catch.dispatch");
  break;

case EHScope::Cleanup:
  DispatchBlock->setName("ehcleanup");
  break;

case EHScope::Filter:
  llvm_unreachable("exception specifications not handled yet!")__builtin_unreachable();

case EHScope::Terminate:
  DispatchBlock->setName("terminate");
  break;
}
EHS.setCachedEHDispatchBlock(DispatchBlock);
return DispatchBlock;
733}

735/// Check whether this is a non-EH scope, i.e. a scope which doesn't
736/// affect exception handling.  Currently, the only non-EH scopes are
737/// normal-only cleanup scopes.
738static bool isNonEHScope(const EHScope &S) {
switch (S.getKind()) {
case EHScope::Cleanup:
  return !cast<EHCleanupScope>(S).isEHCleanup();
case EHScope::Filter:
case EHScope::Catch:
case EHScope::Terminate:
  return false;
}

llvm_unreachable("Invalid EHScope Kind!")__builtin_unreachable();
749}

751llvm::BasicBlock *CodeGenFunction::getInvokeDestImpl() {
assert(EHStack.requiresLandingPad())((void)0);
assert(!EHStack.empty())((void)0);

// If exceptions are disabled/ignored and SEH is not in use, then there is no
// invoke destination. SEH "works" even if exceptions are off. In practice,
// this means that C++ destructors and other EH cleanups don't run, which is
// consistent with MSVC's behavior, except in the presence of -EHa
const LangOptions &LO = CGM.getLangOpts();
if (!LO.Exceptions || LO.IgnoreExceptions) {
  if (!LO.Borland && !LO.MicrosoftExt)
    return nullptr;
  if (!currentFunctionUsesSEHTry())
    return nullptr;
}

// CUDA device code doesn't have exceptions.
if (LO.CUDA && LO.CUDAIsDevice)
  return nullptr;

// Check the innermost scope for a cached landing pad.  If this is
// a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad.
llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad();
if (LP) return LP;

const EHPersonality &Personality = EHPersonality::get(*this);

if (!CurFn->hasPersonalityFn())
  CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality));

if (Personality.usesFuncletPads()) {
  // We don't need separate landing pads in the funclet model.
  LP = getEHDispatchBlock(EHStack.getInnermostEHScope());
} else {
  // Build the landing pad for this scope.
  LP = EmitLandingPad();
}

assert(LP)((void)0);

// Cache the landing pad on the innermost scope.  If this is a
// non-EH scope, cache the landing pad on the enclosing scope, too.
for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) {
  ir->setCachedLandingPad(LP);
  if (!isNonEHScope(*ir)) break;
}

return LP;
799}

801llvm::BasicBlock *CodeGenFunction::EmitLandingPad() {
assert(EHStack.requiresLandingPad())((void)0);
assert(!CGM.getLangOpts().IgnoreExceptions &&((void)0)
       "LandingPad should not be emitted when -fignore-exceptions are in "((void)0)
       "effect.")((void)0);
EHScope &innermostEHScope = *EHStack.find(EHStack.getInnermostEHScope());
switch (innermostEHScope.getKind()) {
case EHScope::Terminate:
  return getTerminateLandingPad();

case EHScope::Catch:
case EHScope::Cleanup:
case EHScope::Filter:
  if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad())
    return lpad;
}

// Save the current IR generation state.
CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP();
auto DL = ApplyDebugLocation::CreateDefaultArtificial(*this, CurEHLocation);

// Create and configure the landing pad.
llvm::BasicBlock *lpad = createBasicBlock("lpad");
EmitBlock(lpad);

llvm::LandingPadInst *LPadInst =
    Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0);

llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0);
Builder.CreateStore(LPadExn, getExceptionSlot());
llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1);
Builder.CreateStore(LPadSel, getEHSelectorSlot());

// Save the exception pointer.  It's safe to use a single exception
// pointer per function because EH cleanups can never have nested
// try/catches.
// Build the landingpad instruction.

// Accumulate all the handlers in scope.
bool hasCatchAll = false;
bool hasCleanup = false;
bool hasFilter = false;
SmallVector<llvm::Value*, 4> filterTypes;
llvm::SmallPtrSet<llvm::Value*, 4> catchTypes;
for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); I != E;
     ++I) {

  switch (I->getKind()) {
  case EHScope::Cleanup:
    // If we have a cleanup, remember that.
    hasCleanup = (hasCleanup || cast<EHCleanupScope>(*I).isEHCleanup());
    continue;

  case EHScope::Filter: {
    assert(I.next() == EHStack.end() && "EH filter is not end of EH stack")((void)0);
    assert(!hasCatchAll && "EH filter reached after catch-all")((void)0);

    // Filter scopes get added to the landingpad in weird ways.
    EHFilterScope &filter = cast<EHFilterScope>(*I);
    hasFilter = true;

    // Add all the filter values.
    for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i)
      filterTypes.push_back(filter.getFilter(i));
    goto done;
  }

  case EHScope::Terminate:
    // Terminate scopes are basically catch-alls.
    assert(!hasCatchAll)((void)0);
    hasCatchAll = true;
    goto done;

  case EHScope::Catch:
    break;
  }

  EHCatchScope &catchScope = cast<EHCatchScope>(*I);
  for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) {
    EHCatchScope::Handler handler = catchScope.getHandler(hi);
    assert(handler.Type.Flags == 0 &&((void)0)
           "landingpads do not support catch handler flags")((void)0);

    // If this is a catch-all, register that and abort.
    if (!handler.Type.RTTI) {
      assert(!hasCatchAll)((void)0);
      hasCatchAll = true;
      goto done;
    }

    // Check whether we already have a handler for this type.
    if (catchTypes.insert(handler.Type.RTTI).second)
      // If not, add it directly to the landingpad.
      LPadInst->addClause(handler.Type.RTTI);
  }
}

done:
// If we have a catch-all, add null to the landingpad.
assert(!(hasCatchAll && hasFilter))((void)0);
if (hasCatchAll) {
  LPadInst->addClause(getCatchAllValue(*this));

// If we have an EH filter, we need to add those handlers in the
// right place in the landingpad, which is to say, at the end.
} else if (hasFilter) {
  // Create a filter expression: a constant array indicating which filter
  // types there are. The personality routine only lands here if the filter
  // doesn't match.
  SmallVector<llvm::Constant*, 8> Filters;
  llvm::ArrayType *AType =
    llvm::ArrayType::get(!filterTypes.empty() ?
                           filterTypes[0]->getType() : Int8PtrTy,
                         filterTypes.size());

  for (unsigned i = 0, e = filterTypes.size(); i != e; ++i)
    Filters.push_back(cast<llvm::Constant>(filterTypes[i]));
  llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters);
  LPadInst->addClause(FilterArray);

  // Also check whether we need a cleanup.
  if (hasCleanup)
    LPadInst->setCleanup(true);

// Otherwise, signal that we at least have cleanups.
} else if (hasCleanup) {
  LPadInst->setCleanup(true);
}

assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) &&((void)0)
       "landingpad instruction has no clauses!")((void)0);

// Tell the backend how to generate the landing pad.
Builder.CreateBr(getEHDispatchBlock(EHStack.getInnermostEHScope()));

// Restore the old IR generation state.
Builder.restoreIP(savedIP);

return lpad;
940}

942static void emitCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope) {
llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock();
assert(DispatchBlock)((void)0);

CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP();
CGF.EmitBlockAfterUses(DispatchBlock);

llvm::Value *ParentPad = CGF.CurrentFuncletPad;
if (!ParentPad)
  ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext());
llvm::BasicBlock *UnwindBB =
    CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope());

unsigned NumHandlers = CatchScope.getNumHandlers();
llvm::CatchSwitchInst *CatchSwitch =
    CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);

// Test against each of the exception types we claim to catch.
for (unsigned I = 0; I < NumHandlers; ++I) {
  const EHCatchScope::Handler &Handler = CatchScope.getHandler(I);

  CatchTypeInfo TypeInfo = Handler.Type;
  if (!TypeInfo.RTTI)
    TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy);

  CGF.Builder.SetInsertPoint(Handler.Block);

  if (EHPersonality::get(CGF).isMSVCXXPersonality()) {
    CGF.Builder.CreateCatchPad(
        CatchSwitch, {TypeInfo.RTTI, CGF.Builder.getInt32(TypeInfo.Flags),
                      llvm::Constant::getNullValue(CGF.VoidPtrTy)});
  } else {
    CGF.Builder.CreateCatchPad(CatchSwitch, {TypeInfo.RTTI});
  }

  CatchSwitch->addHandler(Handler.Block);
}
CGF.Builder.restoreIP(SavedIP);
980}

982// Wasm uses Windows-style EH instructions, but it merges all catch clauses into
983// one big catchpad, within which we use Itanium's landingpad-style selector
984// comparison instructions.
985static void emitWasmCatchPadBlock(CodeGenFunction &CGF,
                                EHCatchScope &CatchScope) {
llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock();
assert(DispatchBlock)((void)0);

CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP();
CGF.EmitBlockAfterUses(DispatchBlock);

llvm::Value *ParentPad = CGF.CurrentFuncletPad;
if (!ParentPad)
  ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext());
llvm::BasicBlock *UnwindBB =
    CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope());

unsigned NumHandlers = CatchScope.getNumHandlers();
llvm::CatchSwitchInst *CatchSwitch =
    CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);

// We don't use a landingpad instruction, so generate intrinsic calls to
// provide exception and selector values.
llvm::BasicBlock *WasmCatchStartBlock = CGF.createBasicBlock("catch.start");
CatchSwitch->addHandler(WasmCatchStartBlock);
CGF.EmitBlockAfterUses(WasmCatchStartBlock);

// Create a catchpad instruction.
SmallVector<llvm::Value *, 4> CatchTypes;
for (unsigned I = 0, E = NumHandlers; I < E; ++I) {
  const EHCatchScope::Handler &Handler = CatchScope.getHandler(I);
  CatchTypeInfo TypeInfo = Handler.Type;
  if (!TypeInfo.RTTI)
    TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy);
  CatchTypes.push_back(TypeInfo.RTTI);
}
auto *CPI = CGF.Builder.CreateCatchPad(CatchSwitch, CatchTypes);

// Create calls to wasm.get.exception and wasm.get.ehselector intrinsics.
// Before they are lowered appropriately later, they provide values for the
// exception and selector.
llvm::Function *GetExnFn =
    CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception);
llvm::Function *GetSelectorFn =
    CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_ehselector);
llvm::CallInst *Exn = CGF.Builder.CreateCall(GetExnFn, CPI);
CGF.Builder.CreateStore(Exn, CGF.getExceptionSlot());
llvm::CallInst *Selector = CGF.Builder.CreateCall(GetSelectorFn, CPI);

llvm::Function *TypeIDFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);

// If there's only a single catch-all, branch directly to its handler.
if (CatchScope.getNumHandlers() == 1 &&
    CatchScope.getHandler(0).isCatchAll()) {
  CGF.Builder.CreateBr(CatchScope.getHandler(0).Block);
  CGF.Builder.restoreIP(SavedIP);
  return;
}

// Test against each of the exception types we claim to catch.
for (unsigned I = 0, E = NumHandlers;; ++I) {
  assert(I < E && "ran off end of handlers!")((void)0);
  const EHCatchScope::Handler &Handler = CatchScope.getHandler(I);
  CatchTypeInfo TypeInfo = Handler.Type;
  if (!TypeInfo.RTTI)
    TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy);

  // Figure out the next block.
  llvm::BasicBlock *NextBlock;

  bool EmitNextBlock = false, NextIsEnd = false;

  // If this is the last handler, we're at the end, and the next block is a
  // block that contains a call to the rethrow function, so we can unwind to
  // the enclosing EH scope. The call itself will be generated later.
  if (I + 1 == E) {
    NextBlock = CGF.createBasicBlock("rethrow");
    EmitNextBlock = true;
    NextIsEnd = true;

    // If the next handler is a catch-all, we're at the end, and the
    // next block is that handler.
  } else if (CatchScope.getHandler(I + 1).isCatchAll()) {
    NextBlock = CatchScope.getHandler(I + 1).Block;
    NextIsEnd = true;

    // Otherwise, we're not at the end and we need a new block.
  } else {
    NextBlock = CGF.createBasicBlock("catch.fallthrough");
    EmitNextBlock = true;
  }

  // Figure out the catch type's index in the LSDA's type table.
  llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(TypeIDFn, TypeInfo.RTTI);
  TypeIndex->setDoesNotThrow();

  llvm::Value *MatchesTypeIndex =
      CGF.Builder.CreateICmpEQ(Selector, TypeIndex, "matches");
  CGF.Builder.CreateCondBr(MatchesTypeIndex, Handler.Block, NextBlock);

  if (EmitNextBlock)
    CGF.EmitBlock(NextBlock);
  if (NextIsEnd)
    break;
}

CGF.Builder.restoreIP(SavedIP);
1089}

1091/// Emit the structure of the dispatch block for the given catch scope.
1092/// It is an invariant that the dispatch block already exists.
1093static void emitCatchDispatchBlock(CodeGenFunction &CGF,
                                 EHCatchScope &catchScope) {
if (EHPersonality::get(CGF).isWasmPersonality())
  return emitWasmCatchPadBlock(CGF, catchScope);
if (EHPersonality::get(CGF).usesFuncletPads())
  return emitCatchPadBlock(CGF, catchScope);

llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock();
assert(dispatchBlock)((void)0);

// If there's only a single catch-all, getEHDispatchBlock returned
// that catch-all as the dispatch block.
if (catchScope.getNumHandlers() == 1 &&
    catchScope.getHandler(0).isCatchAll()) {
  assert(dispatchBlock == catchScope.getHandler(0).Block)((void)0);
  return;
}

CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP();
CGF.EmitBlockAfterUses(dispatchBlock);

// Select the right handler.
llvm::Function *llvm_eh_typeid_for =
  CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);

// Load the selector value.
llvm::Value *selector = CGF.getSelectorFromSlot();

// Test against each of the exception types we claim to catch.
for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) {
  assert(i < e && "ran off end of handlers!")((void)0);
  const EHCatchScope::Handler &handler = catchScope.getHandler(i);

  llvm::Value *typeValue = handler.Type.RTTI;
  assert(handler.Type.Flags == 0 &&((void)0)
         "landingpads do not support catch handler flags")((void)0);
  assert(typeValue && "fell into catch-all case!")((void)0);
  typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy);

  // Figure out the next block.
  bool nextIsEnd;
  llvm::BasicBlock *nextBlock;

  // If this is the last handler, we're at the end, and the next
  // block is the block for the enclosing EH scope.
  if (i + 1 == e) {
    nextBlock = CGF.getEHDispatchBlock(catchScope.getEnclosingEHScope());
    nextIsEnd = true;

  // If the next handler is a catch-all, we're at the end, and the
  // next block is that handler.
  } else if (catchScope.getHandler(i+1).isCatchAll()) {
    nextBlock = catchScope.getHandler(i+1).Block;
    nextIsEnd = true;

  // Otherwise, we're not at the end and we need a new block.
  } else {
    nextBlock = CGF.createBasicBlock("catch.fallthrough");
    nextIsEnd = false;
  }

  // Figure out the catch type's index in the LSDA's type table.
  llvm::CallInst *typeIndex =
    CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue);
  typeIndex->setDoesNotThrow();

  llvm::Value *matchesTypeIndex =
    CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches");
  CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock);

  // If the next handler is a catch-all, we're completely done.
  if (nextIsEnd) {
    CGF.Builder.restoreIP(savedIP);
    return;
  }
  // Otherwise we need to emit and continue at that block.
  CGF.EmitBlock(nextBlock);
}
1171}

1173void CodeGenFunction::popCatchScope() {
EHCatchScope &catchScope = cast<EHCatchScope>(*EHStack.begin());
if (catchScope.hasEHBranches())
  emitCatchDispatchBlock(*this, catchScope);
EHStack.popCatch();
1178}

1180void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
unsigned NumHandlers = S.getNumHandlers();
EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin());
2
←
The object is a 'EHCatchScope'→
assert(CatchScope.getNumHandlers() == NumHandlers)((void)0);
llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock();

// If the catch was not required, bail out now.
if (!CatchScope.hasEHBranches()) {
3
←
Calling 'EHScope::hasEHBranches'→
11
←
Returning from 'EHScope::hasEHBranches'→
12
←
Taking false branch→
  CatchScope.clearHandlerBlocks();
  EHStack.popCatch();
  return;
}

// Emit the structure of the EH dispatch for this catch.
emitCatchDispatchBlock(*this, CatchScope);

// Copy the handler blocks off before we pop the EH stack.  Emitting
// the handlers might scribble on this memory.
SmallVector<EHCatchScope::Handler, 8> Handlers(
    CatchScope.begin(), CatchScope.begin() + NumHandlers);

EHStack.popCatch();

// The fall-through block.
llvm::BasicBlock *ContBB = createBasicBlock("try.cont");

// We just emitted the body of the try; jump to the continue block.
if (HaveInsertPoint())
13
←
Taking false branch→
  Builder.CreateBr(ContBB);

// Determine if we need an implicit rethrow for all these catch handlers;
// see the comment below.
bool doImplicitRethrow = false;
if (IsFnTryBlock13.1
'IsFnTryBlock' is false
1
'IsFnTryBlock' is false
1
'IsFnTryBlock' is false
)
14
←
Taking false branch→
  doImplicitRethrow = isa<CXXDestructorDecl>(CurCodeDecl) ||
                      isa<CXXConstructorDecl>(CurCodeDecl);

// Wasm uses Windows-style EH instructions, but merges all catch clauses into
// one big catchpad. So we save the old funclet pad here before we traverse
// each catch handler.
SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad(
    CurrentFuncletPad);
llvm::BasicBlock *WasmCatchStartBlock = nullptr;
15
←
'WasmCatchStartBlock' initialized to a null pointer value→
if (EHPersonality::get(*this).isWasmPersonality()) {
16
←
Assuming the condition is false→
17
←
Taking false branch→
  auto *CatchSwitch =
      cast<llvm::CatchSwitchInst>(DispatchBlock->getFirstNonPHI());
  WasmCatchStartBlock = CatchSwitch->hasUnwindDest()
                            ? CatchSwitch->getSuccessor(1)
                            : CatchSwitch->getSuccessor(0);
  auto *CPI = cast<llvm::CatchPadInst>(WasmCatchStartBlock->getFirstNonPHI());
  CurrentFuncletPad = CPI;
}

// Perversely, we emit the handlers backwards precisely because we
// want them to appear in source order.  In all of these cases, the
// catch block will have exactly one predecessor, which will be a
// particular block in the catch dispatch.  However, in the case of
// a catch-all, one of the dispatch blocks will branch to two
// different handlers, and EmitBlockAfterUses will cause the second
// handler to be moved before the first.
bool HasCatchAll = false;
for (unsigned I = NumHandlers; I != 0; --I) {
18
←
Loop condition is false. Execution continues on line 1291→
  HasCatchAll |= Handlers[I - 1].isCatchAll();
  llvm::BasicBlock *CatchBlock = Handlers[I-1].Block;
  EmitBlockAfterUses(CatchBlock);

  // Catch the exception if this isn't a catch-all.
  const CXXCatchStmt *C = S.getHandler(I-1);

  // Enter a cleanup scope, including the catch variable and the
  // end-catch.
  RunCleanupsScope CatchScope(*this);

  // Initialize the catch variable and set up the cleanups.
  SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad(
      CurrentFuncletPad);
  CGM.getCXXABI().emitBeginCatch(*this, C);

  // Emit the PGO counter increment.
  incrementProfileCounter(C);

  // Perform the body of the catch.
  EmitStmt(C->getHandlerBlock());

  // [except.handle]p11:
  //   The currently handled exception is rethrown if control
  //   reaches the end of a handler of the function-try-block of a
  //   constructor or destructor.

  // It is important that we only do this on fallthrough and not on
  // return.  Note that it's illegal to put a return in a
  // constructor function-try-block's catch handler (p14), so this
  // really only applies to destructors.
  if (doImplicitRethrow && HaveInsertPoint()) {
    CGM.getCXXABI().emitRethrow(*this, /*isNoReturn*/false);
    Builder.CreateUnreachable();
    Builder.ClearInsertionPoint();
  }

  // Fall out through the catch cleanups.
  CatchScope.ForceCleanup();

  // Branch out of the try.
  if (HaveInsertPoint())
    Builder.CreateBr(ContBB);
}

// Because in wasm we merge all catch clauses into one big catchpad, in case
// none of the types in catch handlers matches after we test against each of
// them, we should unwind to the next EH enclosing scope. We generate a call
// to rethrow function here to do that.
if (EHPersonality::get(*this).isWasmPersonality() && !HasCatchAll19.1
'HasCatchAll' is false
1
'HasCatchAll' is false
1
'HasCatchAll' is false
) {
19
←
Assuming the condition is true→
20
←
Taking true branch→
  assert(WasmCatchStartBlock)((void)0);
  // Navigate for the "rethrow" block we created in emitWasmCatchPadBlock().
  // Wasm uses landingpad-style conditional branches to compare selectors, so
  // we follow the false destination for each of the cond branches to reach
  // the rethrow block.
  llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock;
21
←
'RethrowBlock' initialized to a null pointer value→
  while (llvm::Instruction *TI = RethrowBlock->getTerminator()) {
22
←
Called C++ object pointer is null
    auto *BI = cast<llvm::BranchInst>(TI);
    assert(BI->isConditional())((void)0);
    RethrowBlock = BI->getSuccessor(1);
  }
  assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty())((void)0);
  Builder.SetInsertPoint(RethrowBlock);
  llvm::Function *RethrowInCatchFn =
      CGM.getIntrinsic(llvm::Intrinsic::wasm_rethrow);
  EmitNoreturnRuntimeCallOrInvoke(RethrowInCatchFn, {});
}

EmitBlock(ContBB);
incrementProfileCounter(&S);
1312}

1314namespace {
struct CallEndCatchForFinally final : EHScopeStack::Cleanup {
  llvm::Value *ForEHVar;
  llvm::FunctionCallee EndCatchFn;
  CallEndCatchForFinally(llvm::Value *ForEHVar,
                         llvm::FunctionCallee EndCatchFn)
      : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {}

  void Emit(CodeGenFunction &CGF, Flags flags) override {
    llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch");
    llvm::BasicBlock *CleanupContBB =
      CGF.createBasicBlock("finally.cleanup.cont");

    llvm::Value *ShouldEndCatch =
      CGF.Builder.CreateFlagLoad(ForEHVar, "finally.endcatch");
    CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB);
    CGF.EmitBlock(EndCatchBB);
    CGF.EmitRuntimeCallOrInvoke(EndCatchFn); // catch-all, so might throw
    CGF.EmitBlock(CleanupContBB);
  }
};

struct PerformFinally final : EHScopeStack::Cleanup {
  const Stmt *Body;
  llvm::Value *ForEHVar;
  llvm::FunctionCallee EndCatchFn;
  llvm::FunctionCallee RethrowFn;
  llvm::Value *SavedExnVar;

  PerformFinally(const Stmt *Body, llvm::Value *ForEHVar,
                 llvm::FunctionCallee EndCatchFn,
                 llvm::FunctionCallee RethrowFn, llvm::Value *SavedExnVar)
      : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),
        RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}

  void Emit(CodeGenFunction &CGF, Flags flags) override {
    // Enter a cleanup to call the end-catch function if one was provided.
    if (EndCatchFn)
      CGF.EHStack.pushCleanup<CallEndCatchForFinally>(NormalAndEHCleanup,
                                                      ForEHVar, EndCatchFn);

    // Save the current cleanup destination in case there are
    // cleanups in the finally block.
    llvm::Value *SavedCleanupDest =
      CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(),
                             "cleanup.dest.saved");

    // Emit the finally block.
    CGF.EmitStmt(Body);

    // If the end of the finally is reachable, check whether this was
    // for EH.  If so, rethrow.
    if (CGF.HaveInsertPoint()) {
      llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow");
      llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont");

      llvm::Value *ShouldRethrow =
        CGF.Builder.CreateFlagLoad(ForEHVar, "finally.shouldthrow");
      CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB);

      CGF.EmitBlock(RethrowBB);
      if (SavedExnVar) {
        CGF.EmitRuntimeCallOrInvoke(RethrowFn,
          CGF.Builder.CreateAlignedLoad(CGF.Int8PtrTy, SavedExnVar,
                                        CGF.getPointerAlign()));
      } else {
        CGF.EmitRuntimeCallOrInvoke(RethrowFn);
      }
      CGF.Builder.CreateUnreachable();

      CGF.EmitBlock(ContBB);

      // Restore the cleanup destination.
      CGF.Builder.CreateStore(SavedCleanupDest,
                              CGF.getNormalCleanupDestSlot());
    }

    // Leave the end-catch cleanup.  As an optimization, pretend that
    // the fallthrough path was inaccessible; we've dynamically proven
    // that we're not in the EH case along that path.
    if (EndCatchFn) {
      CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
      CGF.PopCleanupBlock();
      CGF.Builder.restoreIP(SavedIP);
    }

    // Now make sure we actually have an insertion point or the
    // cleanup gods will hate us.
    CGF.EnsureInsertPoint();
  }
};
1405} // end anonymous namespace

1407/// Enters a finally block for an implementation using zero-cost
1408/// exceptions.  This is mostly general, but hard-codes some
1409/// language/ABI-specific behavior in the catch-all sections.
1410void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF, const Stmt *body,
                                       llvm::FunctionCallee beginCatchFn,
                                       llvm::FunctionCallee endCatchFn,
                                       llvm::FunctionCallee rethrowFn) {
assert((!!beginCatchFn) == (!!endCatchFn) &&((void)0)
       "begin/end catch functions not paired")((void)0);
assert(rethrowFn && "rethrow function is required")((void)0);

BeginCatchFn = beginCatchFn;

// The rethrow function has one of the following two types:
//   void (*)()
//   void (*)(void*)
// In the latter case we need to pass it the exception object.
// But we can't use the exception slot because the @finally might
// have a landing pad (which would overwrite the exception slot).
llvm::FunctionType *rethrowFnTy = rethrowFn.getFunctionType();
SavedExnVar = nullptr;
if (rethrowFnTy->getNumParams())
  SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn");

// A finally block is a statement which must be executed on any edge
// out of a given scope.  Unlike a cleanup, the finally block may
// contain arbitrary control flow leading out of itself.  In
// addition, finally blocks should always be executed, even if there
// are no catch handlers higher on the stack.  Therefore, we
// surround the protected scope with a combination of a normal
// cleanup (to catch attempts to break out of the block via normal
// control flow) and an EH catch-all (semantically "outside" any try
// statement to which the finally block might have been attached).
// The finally block itself is generated in the context of a cleanup
// which conditionally leaves the catch-all.

// Jump destination for performing the finally block on an exception
// edge.  We'll never actually reach this block, so unreachable is
// fine.
RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock());

// Whether the finally block is being executed for EH purposes.
ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh");
CGF.Builder.CreateFlagStore(false, ForEHVar);

// Enter a normal cleanup which will perform the @finally block.
CGF.EHStack.pushCleanup<PerformFinally>(NormalCleanup, body,
                                        ForEHVar, endCatchFn,
                                        rethrowFn, SavedExnVar);

// Enter a catch-all scope.
llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall");
EHCatchScope *catchScope = CGF.EHStack.pushCatch(1);
catchScope->setCatchAllHandler(0, catchBB);
1461}

1463void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) {
// Leave the finally catch-all.
EHCatchScope &catchScope = cast<EHCatchScope>(*CGF.EHStack.begin());
llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block;

CGF.popCatchScope();

// If there are any references to the catch-all block, emit it.
if (catchBB->use_empty()) {
  delete catchBB;
} else {
  CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP();
  CGF.EmitBlock(catchBB);

  llvm::Value *exn = nullptr;

  // If there's a begin-catch function, call it.
  if (BeginCatchFn) {
    exn = CGF.getExceptionFromSlot();
    CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn);
  }

  // If we need to remember the exception pointer to rethrow later, do so.
  if (SavedExnVar) {
    if (!exn) exn = CGF.getExceptionFromSlot();
    CGF.Builder.CreateAlignedStore(exn, SavedExnVar, CGF.getPointerAlign());
  }

  // Tell the cleanups in the finally block that we're do this for EH.
  CGF.Builder.CreateFlagStore(true, ForEHVar);

  // Thread a jump through the finally cleanup.
  CGF.EmitBranchThroughCleanup(RethrowDest);

  CGF.Builder.restoreIP(savedIP);
}

// Finally, leave the @finally cleanup.
CGF.PopCleanupBlock();
1502}

1504llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() {
if (TerminateLandingPad)
  return TerminateLandingPad;

CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();

// This will get inserted at the end of the function.
TerminateLandingPad = createBasicBlock("terminate.lpad");
Builder.SetInsertPoint(TerminateLandingPad);

// Tell the backend that this is a landing pad.
const EHPersonality &Personality = EHPersonality::get(*this);

if (!CurFn->hasPersonalityFn())
  CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality));

llvm::LandingPadInst *LPadInst =
    Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0);
LPadInst->addClause(getCatchAllValue(*this));

llvm::Value *Exn = nullptr;
if (getLangOpts().CPlusPlus)
  Exn = Builder.CreateExtractValue(LPadInst, 0);
llvm::CallInst *terminateCall =
    CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn);
terminateCall->setDoesNotReturn();
Builder.CreateUnreachable();

// Restore the saved insertion state.
Builder.restoreIP(SavedIP);

return TerminateLandingPad;
1536}

1538llvm::BasicBlock *CodeGenFunction::getTerminateHandler() {
if (TerminateHandler)
  return TerminateHandler;

// Set up the terminate handler.  This block is inserted at the very
// end of the function by FinishFunction.
TerminateHandler = createBasicBlock("terminate.handler");
CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
Builder.SetInsertPoint(TerminateHandler);

llvm::Value *Exn = nullptr;
if (getLangOpts().CPlusPlus)
  Exn = getExceptionFromSlot();
llvm::CallInst *terminateCall =
    CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn);
terminateCall->setDoesNotReturn();
Builder.CreateUnreachable();

// Restore the saved insertion state.
Builder.restoreIP(SavedIP);

return TerminateHandler;
1560}

1562llvm::BasicBlock *CodeGenFunction::getTerminateFunclet() {
assert(EHPersonality::get(*this).usesFuncletPads() &&((void)0)
       "use getTerminateLandingPad for non-funclet EH")((void)0);

llvm::BasicBlock *&TerminateFunclet = TerminateFunclets[CurrentFuncletPad];
if (TerminateFunclet)
  return TerminateFunclet;

CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();

// Set up the terminate handler.  This block is inserted at the very
// end of the function by FinishFunction.
TerminateFunclet = createBasicBlock("terminate.handler");
Builder.SetInsertPoint(TerminateFunclet);

// Create the cleanuppad using the current parent pad as its token. Use 'none'
// if this is a top-level terminate scope, which is the common case.
SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad(
    CurrentFuncletPad);
llvm::Value *ParentPad = CurrentFuncletPad;
if (!ParentPad)
  ParentPad = llvm::ConstantTokenNone::get(CGM.getLLVMContext());
CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad);

// Emit the __std_terminate call.
llvm::CallInst *terminateCall =
    CGM.getCXXABI().emitTerminateForUnexpectedException(*this, nullptr);
terminateCall->setDoesNotReturn();
Builder.CreateUnreachable();

// Restore the saved insertion state.
Builder.restoreIP(SavedIP);

return TerminateFunclet;
1596}

1598llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) {
if (EHResumeBlock) return EHResumeBlock;

CGBuilderTy::InsertPoint SavedIP = Builder.saveIP();

// We emit a jump to a notional label at the outermost unwind state.
EHResumeBlock = createBasicBlock("eh.resume");
Builder.SetInsertPoint(EHResumeBlock);

const EHPersonality &Personality = EHPersonality::get(*this);

// This can always be a call because we necessarily didn't find
// anything on the EH stack which needs our help.
const char *RethrowName = Personality.CatchallRethrowFn;
if (RethrowName != nullptr && !isCleanup) {
  EmitRuntimeCall(getCatchallRethrowFn(CGM, RethrowName),
                  getExceptionFromSlot())->setDoesNotReturn();
  Builder.CreateUnreachable();
  Builder.restoreIP(SavedIP);
  return EHResumeBlock;
}

// Recreate the landingpad's return value for the 'resume' instruction.
llvm::Value *Exn = getExceptionFromSlot();
llvm::Value *Sel = getSelectorFromSlot();

llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType());
llvm::Value *LPadVal = llvm::UndefValue::get(LPadType);
LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val");
LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val");

Builder.CreateResume(LPadVal);
Builder.restoreIP(SavedIP);
return EHResumeBlock;
1632}

1634void CodeGenFunction::EmitSEHTryStmt(const SEHTryStmt &S) {
EnterSEHTryStmt(S);
{
  JumpDest TryExit = getJumpDestInCurrentScope("__try.__leave");

  SEHTryEpilogueStack.push_back(&TryExit);

  llvm::BasicBlock *TryBB = nullptr;
  // IsEHa: emit an invoke to _seh_try_begin() runtime for -EHa
  if (getLangOpts().EHAsynch) {
    EmitRuntimeCallOrInvoke(getSehTryBeginFn(CGM));
    if (SEHTryEpilogueStack.size() == 1) // outermost only
      TryBB = Builder.GetInsertBlock();
  }

  EmitStmt(S.getTryBlock());

  // Volatilize all blocks in Try, till current insert point
  if (TryBB) {
    llvm::SmallPtrSet<llvm::BasicBlock *, 10> Visited;
    VolatilizeTryBlocks(TryBB, Visited);
  }

  SEHTryEpilogueStack.pop_back();

  if (!TryExit.getBlock()->use_empty())
    EmitBlock(TryExit.getBlock(), /*IsFinished=*/true);
  else
    delete TryExit.getBlock();
}
ExitSEHTryStmt(S);
1665}

1667//  Recursively walk through blocks in a _try
1668//      and make all memory instructions volatile
1669void CodeGenFunction::VolatilizeTryBlocks(
  llvm::BasicBlock *BB, llvm::SmallPtrSet<llvm::BasicBlock *, 10> &V) {
if (BB == SEHTryEpilogueStack.back()->getBlock() /* end of Try */ ||
    !V.insert(BB).second /* already visited */ ||
    !BB->getParent() /* not emitted */ || BB->empty())
  return;

if (!BB->isEHPad()) {
  for (llvm::BasicBlock::iterator J = BB->begin(), JE = BB->end(); J != JE;
       ++J) {
    if (auto LI = dyn_cast<llvm::LoadInst>(J)) {
      LI->setVolatile(true);
    } else if (auto SI = dyn_cast<llvm::StoreInst>(J)) {
      SI->setVolatile(true);
    } else if (auto* MCI = dyn_cast<llvm::MemIntrinsic>(J)) {
      MCI->setVolatile(llvm::ConstantInt::get(Builder.getInt1Ty(), 1));
    }
  }
}
const llvm::Instruction *TI = BB->getTerminator();
if (TI) {
  unsigned N = TI->getNumSuccessors();
  for (unsigned I = 0; I < N; I++)
    VolatilizeTryBlocks(TI->getSuccessor(I), V);
}
1694}

1696namespace {
1697struct PerformSEHFinally final : EHScopeStack::Cleanup {
llvm::Function *OutlinedFinally;
PerformSEHFinally(llvm::Function *OutlinedFinally)
    : OutlinedFinally(OutlinedFinally) {}

void Emit(CodeGenFunction &CGF, Flags F) override {
  ASTContext &Context = CGF.getContext();
  CodeGenModule &CGM = CGF.CGM;

  CallArgList Args;

  // Compute the two argument values.
  QualType ArgTys[2] = {Context.UnsignedCharTy, Context.VoidPtrTy};
  llvm::Value *FP = nullptr;
  // If CFG.IsOutlinedSEHHelper is true, then we are within a finally block.
  if (CGF.IsOutlinedSEHHelper) {
    FP = &CGF.CurFn->arg_begin()[1];
  } else {
    llvm::Function *LocalAddrFn =
        CGM.getIntrinsic(llvm::Intrinsic::localaddress);
    FP = CGF.Builder.CreateCall(LocalAddrFn);
  }

  llvm::Value *IsForEH =
      llvm::ConstantInt::get(CGF.ConvertType(ArgTys[0]), F.isForEHCleanup());

  // Except _leave and fall-through at the end, all other exits in a _try
  //   (return/goto/continue/break) are considered as abnormal terminations
  //   since _leave/fall-through is always Indexed 0,
  //   just use NormalCleanupDestSlot (>= 1 for goto/return/..),
  //   as 1st Arg to indicate abnormal termination
  if (!F.isForEHCleanup() && F.hasExitSwitch()) {
    Address Addr = CGF.getNormalCleanupDestSlot();
    llvm::Value *Load = CGF.Builder.CreateLoad(Addr, "cleanup.dest");
    llvm::Value *Zero = llvm::Constant::getNullValue(CGM.Int32Ty);
    IsForEH = CGF.Builder.CreateICmpNE(Load, Zero);
  }

  Args.add(RValue::get(IsForEH), ArgTys[0]);
  Args.add(RValue::get(FP), ArgTys[1]);

  // Arrange a two-arg function info and type.
  const CGFunctionInfo &FnInfo =
      CGM.getTypes().arrangeBuiltinFunctionCall(Context.VoidTy, Args);

  auto Callee = CGCallee::forDirect(OutlinedFinally);
  CGF.EmitCall(FnInfo, Callee, ReturnValueSlot(), Args);
}
1745};
1746} // end anonymous namespace

1748namespace {
1749/// Find all local variable captures in the statement.
1750struct CaptureFinder : ConstStmtVisitor<CaptureFinder> {
CodeGenFunction &ParentCGF;
const VarDecl *ParentThis;
llvm::SmallSetVector<const VarDecl *, 4> Captures;
Address SEHCodeSlot = Address::invalid();
CaptureFinder(CodeGenFunction &ParentCGF, const VarDecl *ParentThis)
    : ParentCGF(ParentCGF), ParentThis(ParentThis) {}

// Return true if we need to do any capturing work.
bool foundCaptures() {
  return !Captures.empty() || SEHCodeSlot.isValid();
}

void Visit(const Stmt *S) {
  // See if this is a capture, then recurse.
  ConstStmtVisitor<CaptureFinder>::Visit(S);
  for (const Stmt *Child : S->children())
    if (Child)
      Visit(Child);
}

void VisitDeclRefExpr(const DeclRefExpr *E) {
  // If this is already a capture, just make sure we capture 'this'.
  if (E->refersToEnclosingVariableOrCapture())
    Captures.insert(ParentThis);

  const auto *D = dyn_cast<VarDecl>(E->getDecl());
  if (D && D->isLocalVarDeclOrParm() && D->hasLocalStorage())
    Captures.insert(D);
}

void VisitCXXThisExpr(const CXXThisExpr *E) {
  Captures.insert(ParentThis);
}

void VisitCallExpr(const CallExpr *E) {
  // We only need to add parent frame allocations for these builtins in x86.
  if (ParentCGF.getTarget().getTriple().getArch() != llvm::Triple::x86)
    return;

  unsigned ID = E->getBuiltinCallee();
  switch (ID) {
  case Builtin::BI__exception_code:
  case Builtin::BI_exception_code:
    // This is the simple case where we are the outermost finally. All we
    // have to do here is make sure we escape this and recover it in the
    // outlined handler.
    if (!SEHCodeSlot.isValid())
      SEHCodeSlot = ParentCGF.SEHCodeSlotStack.back();
    break;
  }
}
1802};
1803} // end anonymous namespace

1805Address CodeGenFunction::recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF,
                                                 Address ParentVar,
                                                 llvm::Value *ParentFP) {
llvm::CallInst *RecoverCall = nullptr;
CGBuilderTy Builder(*this, AllocaInsertPt);
if (auto *ParentAlloca = dyn_cast<llvm::AllocaInst>(ParentVar.getPointer())) {
  // Mark the variable escaped if nobody else referenced it and compute the
  // localescape index.
  auto InsertPair = ParentCGF.EscapedLocals.insert(
      std::make_pair(ParentAlloca, ParentCGF.EscapedLocals.size()));
  int FrameEscapeIdx = InsertPair.first->second;
  // call i8* @llvm.localrecover(i8* bitcast(@parentFn), i8* %fp, i32 N)
  llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration(
      &CGM.getModule(), llvm::Intrinsic::localrecover);
  llvm::Constant *ParentI8Fn =
      llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy);
  RecoverCall = Builder.CreateCall(
      FrameRecoverFn, {ParentI8Fn, ParentFP,
                       llvm::ConstantInt::get(Int32Ty, FrameEscapeIdx)});

} else {
  // If the parent didn't have an alloca, we're doing some nested outlining.
  // Just clone the existing localrecover call, but tweak the FP argument to
  // use our FP value. All other arguments are constants.
  auto *ParentRecover =
      cast<llvm::IntrinsicInst>(ParentVar.getPointer()->stripPointerCasts());
  assert(ParentRecover->getIntrinsicID() == llvm::Intrinsic::localrecover &&((void)0)
         "expected alloca or localrecover in parent LocalDeclMap")((void)0);
  RecoverCall = cast<llvm::CallInst>(ParentRecover->clone());
  RecoverCall->setArgOperand(1, ParentFP);
  RecoverCall->insertBefore(AllocaInsertPt);
}

// Bitcast the variable, rename it, and insert it in the local decl map.
llvm::Value *ChildVar =
    Builder.CreateBitCast(RecoverCall, ParentVar.getType());
ChildVar->setName(ParentVar.getName());
return Address(ChildVar, ParentVar.getAlignment());
1843}

1845void CodeGenFunction::EmitCapturedLocals(CodeGenFunction &ParentCGF,
                                       const Stmt *OutlinedStmt,
                                       bool IsFilter) {
// Find all captures in the Stmt.
CaptureFinder Finder(ParentCGF, ParentCGF.CXXABIThisDecl);
Finder.Visit(OutlinedStmt);

// We can exit early on x86_64 when there are no captures. We just have to
// save the exception code in filters so that __exception_code() works.
if (!Finder.foundCaptures() &&
    CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
  if (IsFilter)
    EmitSEHExceptionCodeSave(ParentCGF, nullptr, nullptr);
  return;
}

llvm::Value *EntryFP = nullptr;
CGBuilderTy Builder(CGM, AllocaInsertPt);
if (IsFilter && CGM.getTarget().getTriple().getArch() == llvm::Triple::x86) {
  // 32-bit SEH filters need to be careful about FP recovery.  The end of the
  // EH registration is passed in as the EBP physical register.  We can
  // recover that with llvm.frameaddress(1).
  EntryFP = Builder.CreateCall(
      CGM.getIntrinsic(llvm::Intrinsic::frameaddress, AllocaInt8PtrTy),
      {Builder.getInt32(1)});
} else {
  // Otherwise, for x64 and 32-bit finally functions, the parent FP is the
  // second parameter.
  auto AI = CurFn->arg_begin();
  ++AI;
  EntryFP = &*AI;
}

llvm::Value *ParentFP = EntryFP;
if (IsFilter) {
  // Given whatever FP the runtime provided us in EntryFP, recover the true
  // frame pointer of the parent function. We only need to do this in filters,
  // since finally funclets recover the parent FP for us.
  llvm::Function *RecoverFPIntrin =
      CGM.getIntrinsic(llvm::Intrinsic::eh_recoverfp);
  llvm::Constant *ParentI8Fn =
      llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy);
  ParentFP = Builder.CreateCall(RecoverFPIntrin, {ParentI8Fn, EntryFP});

  // if the parent is a _finally, the passed-in ParentFP is the FP
  // of parent _finally, not Establisher's FP (FP of outermost function).
  // Establkisher FP is 2nd paramenter passed into parent _finally.
  // Fortunately, it's always saved in parent's frame. The following
  // code retrieves it, and escapes it so that spill instruction won't be
  // optimized away.
  if (ParentCGF.ParentCGF != nullptr) {
    // Locate and escape Parent's frame_pointer.addr alloca
    // Depending on target, should be 1st/2nd one in LocalDeclMap.
    // Let's just scan for ImplicitParamDecl with VoidPtrTy.
    llvm::AllocaInst *FramePtrAddrAlloca = nullptr;
    for (auto &I : ParentCGF.LocalDeclMap) {
      const VarDecl *D = cast<VarDecl>(I.first);
      if (isa<ImplicitParamDecl>(D) &&
          D->getType() == getContext().VoidPtrTy) {
        assert(D->getName().startswith("frame_pointer"))((void)0);
        FramePtrAddrAlloca = cast<llvm::AllocaInst>(I.second.getPointer());
        break;
      }
    }
    assert(FramePtrAddrAlloca)((void)0);
    auto InsertPair = ParentCGF.EscapedLocals.insert(
        std::make_pair(FramePtrAddrAlloca, ParentCGF.EscapedLocals.size()));
    int FrameEscapeIdx = InsertPair.first->second;

    // an example of a filter's prolog::
    // %0 = call i8* @llvm.eh.recoverfp(bitcast(@"?fin$0@0@main@@"),..)
    // %1 = call i8* @llvm.localrecover(bitcast(@"?fin$0@0@main@@"),..)
    // %2 = bitcast i8* %1 to i8**
    // %3 = load i8*, i8* *%2, align 8
    //   ==> %3 is the frame-pointer of outermost host function
    llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration(
        &CGM.getModule(), llvm::Intrinsic::localrecover);
    llvm::Constant *ParentI8Fn =
        llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy);
    ParentFP = Builder.CreateCall(
        FrameRecoverFn, {ParentI8Fn, ParentFP,
                         llvm::ConstantInt::get(Int32Ty, FrameEscapeIdx)});
    ParentFP = Builder.CreateBitCast(ParentFP, CGM.VoidPtrPtrTy);
    ParentFP = Builder.CreateLoad(Address(ParentFP, getPointerAlign()));
  }
}

// Create llvm.localrecover calls for all captures.
for (const VarDecl *VD : Finder.Captures) {
  if (VD->getType()->isVariablyModifiedType()) {
    CGM.ErrorUnsupported(VD, "VLA captured by SEH");
    continue;
  }
  assert((isa<ImplicitParamDecl>(VD) || VD->isLocalVarDeclOrParm()) &&((void)0)
         "captured non-local variable")((void)0);

  auto L = ParentCGF.LambdaCaptureFields.find(VD);
  if (L != ParentCGF.LambdaCaptureFields.end()) {
    LambdaCaptureFields[VD] = L->second;
    continue;
  }

  // If this decl hasn't been declared yet, it will be declared in the
  // OutlinedStmt.
  auto I = ParentCGF.LocalDeclMap.find(VD);
  if (I == ParentCGF.LocalDeclMap.end())
    continue;

  Address ParentVar = I->second;
  Address Recovered =
      recoverAddrOfEscapedLocal(ParentCGF, ParentVar, ParentFP);
  setAddrOfLocalVar(VD, Recovered);

  if (isa<ImplicitParamDecl>(VD)) {
    CXXABIThisAlignment = ParentCGF.CXXABIThisAlignment;
    CXXThisAlignment = ParentCGF.CXXThisAlignment;
    CXXABIThisValue = Builder.CreateLoad(Recovered, "this");
    if (ParentCGF.LambdaThisCaptureField) {
      LambdaThisCaptureField = ParentCGF.LambdaThisCaptureField;
      // We are in a lambda function where "this" is captured so the
      // CXXThisValue need to be loaded from the lambda capture
      LValue ThisFieldLValue =
          EmitLValueForLambdaField(LambdaThisCaptureField);
      if (!LambdaThisCaptureField->getType()->isPointerType()) {
        CXXThisValue = ThisFieldLValue.getAddress(*this).getPointer();
      } else {
        CXXThisValue = EmitLoadOfLValue(ThisFieldLValue, SourceLocation())
                           .getScalarVal();
      }
    } else {
      CXXThisValue = CXXABIThisValue;
    }
  }
}

if (Finder.SEHCodeSlot.isValid()) {
  SEHCodeSlotStack.push_back(
      recoverAddrOfEscapedLocal(ParentCGF, Finder.SEHCodeSlot, ParentFP));
}

if (IsFilter)
  EmitSEHExceptionCodeSave(ParentCGF, ParentFP, EntryFP);
1987}

1989/// Arrange a function prototype that can be called by Windows exception
1990/// handling personalities. On Win64, the prototype looks like:
1991/// RetTy func(void *EHPtrs, void *ParentFP);
1992void CodeGenFunction::startOutlinedSEHHelper(CodeGenFunction &ParentCGF,
                                           bool IsFilter,
                                           const Stmt *OutlinedStmt) {
SourceLocation StartLoc = OutlinedStmt->getBeginLoc();

// Get the mangled function name.
SmallString<128> Name;
{
  llvm::raw_svector_ostream OS(Name);
  const NamedDecl *ParentSEHFn = ParentCGF.CurSEHParent;
  assert(ParentSEHFn && "No CurSEHParent!")((void)0);
  MangleContext &Mangler = CGM.getCXXABI().getMangleContext();
  if (IsFilter)
    Mangler.mangleSEHFilterExpression(ParentSEHFn, OS);
  else
    Mangler.mangleSEHFinallyBlock(ParentSEHFn, OS);
}

FunctionArgList Args;
if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 || !IsFilter) {
  // All SEH finally functions take two parameters. Win64 filters take two
  // parameters. Win32 filters take no parameters.
  if (IsFilter) {
    Args.push_back(ImplicitParamDecl::Create(
        getContext(), /*DC=*/nullptr, StartLoc,
        &getContext().Idents.get("exception_pointers"),
        getContext().VoidPtrTy, ImplicitParamDecl::Other));
  } else {
    Args.push_back(ImplicitParamDecl::Create(
        getContext(), /*DC=*/nullptr, StartLoc,
        &getContext().Idents.get("abnormal_termination"),
        getContext().UnsignedCharTy, ImplicitParamDecl::Other));
  }
  Args.push_back(ImplicitParamDecl::Create(
      getContext(), /*DC=*/nullptr, StartLoc,
      &getContext().Idents.get("frame_pointer"), getContext().VoidPtrTy,
      ImplicitParamDecl::Other));
}

QualType RetTy = IsFilter ? getContext().LongTy : getContext().VoidTy;

const CGFunctionInfo &FnInfo =
  CGM.getTypes().arrangeBuiltinFunctionDeclaration(RetTy, Args);

llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
llvm::Function *Fn = llvm::Function::Create(
    FnTy, llvm::GlobalValue::InternalLinkage, Name.str(), &CGM.getModule());

IsOutlinedSEHHelper = true;

StartFunction(GlobalDecl(), RetTy, Fn, FnInfo, Args,
              OutlinedStmt->getBeginLoc(), OutlinedStmt->getBeginLoc());
CurSEHParent = ParentCGF.CurSEHParent;

CGM.SetInternalFunctionAttributes(GlobalDecl(), CurFn, FnInfo);
EmitCapturedLocals(ParentCGF, OutlinedStmt, IsFilter);
2048}

2050/// Create a stub filter function that will ultimately hold the code of the
2051/// filter expression. The EH preparation passes in LLVM will outline the code
2052/// from the main function body into this stub.
2053llvm::Function *
2054CodeGenFunction::GenerateSEHFilterFunction(CodeGenFunction &ParentCGF,
                                         const SEHExceptStmt &Except) {
const Expr *FilterExpr = Except.getFilterExpr();
startOutlinedSEHHelper(ParentCGF, true, FilterExpr);

// Emit the original filter expression, convert to i32, and return.
llvm::Value *R = EmitScalarExpr(FilterExpr);
R = Builder.CreateIntCast(R, ConvertType(getContext().LongTy),
                          FilterExpr->getType()->isSignedIntegerType());
Builder.CreateStore(R, ReturnValue);

FinishFunction(FilterExpr->getEndLoc());

return CurFn;
2068}

2070llvm::Function *
2071CodeGenFunction::GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF,
                                          const SEHFinallyStmt &Finally) {
const Stmt *FinallyBlock = Finally.getBlock();
startOutlinedSEHHelper(ParentCGF, false, FinallyBlock);

// Emit the original filter expression, convert to i32, and return.
EmitStmt(FinallyBlock);

FinishFunction(FinallyBlock->getEndLoc());

return CurFn;
2082}

2084void CodeGenFunction::EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF,
                                             llvm::Value *ParentFP,
                                             llvm::Value *EntryFP) {
// Get the pointer to the EXCEPTION_POINTERS struct. This is returned by the
// __exception_info intrinsic.
if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
  // On Win64, the info is passed as the first parameter to the filter.
  SEHInfo = &*CurFn->arg_begin();
  SEHCodeSlotStack.push_back(
      CreateMemTemp(getContext().IntTy, "__exception_code"));
} else {
  // On Win32, the EBP on entry to the filter points to the end of an
  // exception registration object. It contains 6 32-bit fields, and the info
  // pointer is stored in the second field. So, GEP 20 bytes backwards and
  // load the pointer.
  SEHInfo = Builder.CreateConstInBoundsGEP1_32(Int8Ty, EntryFP, -20);
  SEHInfo = Builder.CreateBitCast(SEHInfo, Int8PtrTy->getPointerTo());
  SEHInfo = Builder.CreateAlignedLoad(Int8PtrTy, SEHInfo, getPointerAlign());
  SEHCodeSlotStack.push_back(recoverAddrOfEscapedLocal(
      ParentCGF, ParentCGF.SEHCodeSlotStack.back(), ParentFP));
}

// Save the exception code in the exception slot to unify exception access in
// the filter function and the landing pad.
// struct EXCEPTION_POINTERS {
//   EXCEPTION_RECORD *ExceptionRecord;
//   CONTEXT *ContextRecord;
// };
// int exceptioncode = exception_pointers->ExceptionRecord->ExceptionCode;
llvm::Type *RecordTy = CGM.Int32Ty->getPointerTo();
llvm::Type *PtrsTy = llvm::StructType::get(RecordTy, CGM.VoidPtrTy);
llvm::Value *Ptrs = Builder.CreateBitCast(SEHInfo, PtrsTy->getPointerTo());
llvm::Value *Rec = Builder.CreateStructGEP(PtrsTy, Ptrs, 0);
Rec = Builder.CreateAlignedLoad(RecordTy, Rec, getPointerAlign());
llvm::Value *Code = Builder.CreateAlignedLoad(Int32Ty, Rec, getIntAlign());
assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except")((void)0);
Builder.CreateStore(Code, SEHCodeSlotStack.back());
2121}

2123llvm::Value *CodeGenFunction::EmitSEHExceptionInfo() {
// Sema should diagnose calling this builtin outside of a filter context, but
// don't crash if we screw up.
if (!SEHInfo)
  return llvm::UndefValue::get(Int8PtrTy);
assert(SEHInfo->getType() == Int8PtrTy)((void)0);
return SEHInfo;
2130}

2132llvm::Value *CodeGenFunction::EmitSEHExceptionCode() {
assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except")((void)0);
return Builder.CreateLoad(SEHCodeSlotStack.back());
2135}

2137llvm::Value *CodeGenFunction::EmitSEHAbnormalTermination() {
// Abnormal termination is just the first parameter to the outlined finally
// helper.
auto AI = CurFn->arg_begin();
return Builder.CreateZExt(&*AI, Int32Ty);
2142}

2144void CodeGenFunction::pushSEHCleanup(CleanupKind Kind,
                                   llvm::Function *FinallyFunc) {
EHStack.pushCleanup<PerformSEHFinally>(Kind, FinallyFunc);
2147}

2149void CodeGenFunction::EnterSEHTryStmt(const SEHTryStmt &S) {
CodeGenFunction HelperCGF(CGM, /*suppressNewContext=*/true);
HelperCGF.ParentCGF = this;
if (const SEHFinallyStmt *Finally = S.getFinallyHandler()) {
  // Outline the finally block.
  llvm::Function *FinallyFunc =
      HelperCGF.GenerateSEHFinallyFunction(*this, *Finally);

  // Push a cleanup for __finally blocks.
  EHStack.pushCleanup<PerformSEHFinally>(NormalAndEHCleanup, FinallyFunc);
  return;
}

// Otherwise, we must have an __except block.
const SEHExceptStmt *Except = S.getExceptHandler();
assert(Except)((void)0);
EHCatchScope *CatchScope = EHStack.pushCatch(1);
SEHCodeSlotStack.push_back(
    CreateMemTemp(getContext().IntTy, "__exception_code"));

// If the filter is known to evaluate to 1, then we can use the clause
// "catch i8* null". We can't do this on x86 because the filter has to save
// the exception code.
llvm::Constant *C =
  ConstantEmitter(*this).tryEmitAbstract(Except->getFilterExpr(),
                                         getContext().IntTy);
if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 && C &&
    C->isOneValue()) {
  CatchScope->setCatchAllHandler(0, createBasicBlock("__except"));
  return;
}

// In general, we have to emit an outlined filter function. Use the function
// in place of the RTTI typeinfo global that C++ EH uses.
llvm::Function *FilterFunc =
    HelperCGF.GenerateSEHFilterFunction(*this, *Except);
llvm::Constant *OpaqueFunc =
    llvm::ConstantExpr::getBitCast(FilterFunc, Int8PtrTy);
CatchScope->setHandler(0, OpaqueFunc, createBasicBlock("__except.ret"));
2188}

2190void CodeGenFunction::ExitSEHTryStmt(const SEHTryStmt &S) {
// Just pop the cleanup if it's a __finally block.
if (S.getFinallyHandler()) {
  PopCleanupBlock();
  return;
}

// IsEHa: emit an invoke _seh_try_end() to mark end of FT flow
if (getLangOpts().EHAsynch && Builder.GetInsertBlock()) {
  llvm::FunctionCallee SehTryEnd = getSehTryEndFn(CGM);
  EmitRuntimeCallOrInvoke(SehTryEnd);
}

// Otherwise, we must have an __except block.
const SEHExceptStmt *Except = S.getExceptHandler();
assert(Except && "__try must have __finally xor __except")((void)0);
EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin());

// Don't emit the __except block if the __try block lacked invokes.
// TODO: Model unwind edges from instructions, either with iload / istore or
// a try body function.
if (!CatchScope.hasEHBranches()) {
  CatchScope.clearHandlerBlocks();
  EHStack.popCatch();
  SEHCodeSlotStack.pop_back();
  return;
}

// The fall-through block.
llvm::BasicBlock *ContBB = createBasicBlock("__try.cont");

// We just emitted the body of the __try; jump to the continue block.
if (HaveInsertPoint())
  Builder.CreateBr(ContBB);

// Check if our filter function returned true.
emitCatchDispatchBlock(*this, CatchScope);

// Grab the block before we pop the handler.
llvm::BasicBlock *CatchPadBB = CatchScope.getHandler(0).Block;
EHStack.popCatch();

EmitBlockAfterUses(CatchPadBB);

// __except blocks don't get outlined into funclets, so immediately do a
// catchret.
llvm::CatchPadInst *CPI =
    cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHI());
llvm::BasicBlock *ExceptBB = createBasicBlock("__except");
Builder.CreateCatchRet(CPI, ExceptBB);
EmitBlock(ExceptBB);

// On Win64, the exception code is returned in EAX. Copy it into the slot.
if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
  llvm::Function *SEHCodeIntrin =
      CGM.getIntrinsic(llvm::Intrinsic::eh_exceptioncode);
  llvm::Value *Code = Builder.CreateCall(SEHCodeIntrin, {CPI});
  Builder.CreateStore(Code, SEHCodeSlotStack.back());
}

// Emit the __except body.
EmitStmt(Except->getBlock());

// End the lifetime of the exception code.
SEHCodeSlotStack.pop_back();

if (HaveInsertPoint())
  Builder.CreateBr(ContBB);

EmitBlock(ContBB);
2260}

2262void CodeGenFunction::EmitSEHLeaveStmt(const SEHLeaveStmt &S) {
// If this code is reachable then emit a stop point (if generating
// debug info). We have to do this ourselves because we are on the
// "simple" statement path.
if (HaveInsertPoint())
  EmitStopPoint(&S);

// This must be a __leave from a __finally block, which we warn on and is UB.
// Just emit unreachable.
if (!isSEHTryScope()) {
  Builder.CreateUnreachable();
  Builder.ClearInsertionPoint();
  return;
}

EmitBranchThroughCleanup(*SEHTryEpilogueStack.back());
2278}

←

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGCleanup.h

→

1//===-- CGCleanup.h - Classes for cleanups IR generation --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// These classes support the generation of LLVM IR for cleanups.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H
14#define LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H

16#include "EHScopeStack.h"

18#include "Address.h"
19#include "llvm/ADT/SmallPtrSet.h"
20#include "llvm/ADT/SmallVector.h"

22namespace llvm {
23class BasicBlock;
24class Value;
25class ConstantInt;
26class AllocaInst;
27}

29namespace clang {
30class FunctionDecl;
31namespace CodeGen {
32class CodeGenModule;
33class CodeGenFunction;

35/// The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the
36/// type of a catch handler, so we use this wrapper.
37struct CatchTypeInfo {
llvm::Constant *RTTI;
unsigned Flags;
40};

42/// A protected scope for zero-cost EH handling.
43class EHScope {
llvm::BasicBlock *CachedLandingPad;
llvm::BasicBlock *CachedEHDispatchBlock;

EHScopeStack::stable_iterator EnclosingEHScope;

class CommonBitFields {
  friend class EHScope;
  unsigned Kind : 3;
};
enum { NumCommonBits = 3 };

55protected:
class CatchBitFields {
  friend class EHCatchScope;
  unsigned : NumCommonBits;

  unsigned NumHandlers : 32 - NumCommonBits;
};

class CleanupBitFields {
  friend class EHCleanupScope;
  unsigned : NumCommonBits;

  /// Whether this cleanup needs to be run along normal edges.
  unsigned IsNormalCleanup : 1;

  /// Whether this cleanup needs to be run along exception edges.
  unsigned IsEHCleanup : 1;

  /// Whether this cleanup is currently active.
  unsigned IsActive : 1;

  /// Whether this cleanup is a lifetime marker
  unsigned IsLifetimeMarker : 1;

  /// Whether the normal cleanup should test the activation flag.
  unsigned TestFlagInNormalCleanup : 1;

  /// Whether the EH cleanup should test the activation flag.
  unsigned TestFlagInEHCleanup : 1;

  /// The amount of extra storage needed by the Cleanup.
  /// Always a multiple of the scope-stack alignment.
  unsigned CleanupSize : 12;
};

class FilterBitFields {
  friend class EHFilterScope;
  unsigned : NumCommonBits;

  unsigned NumFilters : 32 - NumCommonBits;
};

union {
  CommonBitFields CommonBits;
  CatchBitFields CatchBits;
  CleanupBitFields CleanupBits;
  FilterBitFields FilterBits;
};

104public:
enum Kind { Cleanup, Catch, Terminate, Filter };

EHScope(Kind kind, EHScopeStack::stable_iterator enclosingEHScope)
  : CachedLandingPad(nullptr), CachedEHDispatchBlock(nullptr),
    EnclosingEHScope(enclosingEHScope) {
  CommonBits.Kind = kind;
}

Kind getKind() const { return static_cast<Kind>(CommonBits.Kind); }

llvm::BasicBlock *getCachedLandingPad() const {
  return CachedLandingPad;
}

void setCachedLandingPad(llvm::BasicBlock *block) {
  CachedLandingPad = block;
}

llvm::BasicBlock *getCachedEHDispatchBlock() const {
  return CachedEHDispatchBlock;
}

void setCachedEHDispatchBlock(llvm::BasicBlock *block) {
  CachedEHDispatchBlock = block;
}

bool hasEHBranches() const {
  if (llvm::BasicBlock *block = getCachedEHDispatchBlock())
4
←
Assuming 'block' is non-null→
5
←
Taking true branch→
    return !block->use_empty();
6
←
Calling 'Value::use_empty'→
9
←
Returning from 'Value::use_empty'→
10
←
Returning the value 1, which participates in a condition later→
  return false;
}

EHScopeStack::stable_iterator getEnclosingEHScope() const {
  return EnclosingEHScope;
}
140};

142/// A scope which attempts to handle some, possibly all, types of
143/// exceptions.
144///
145/// Objective C \@finally blocks are represented using a cleanup scope
146/// after the catch scope.
147class EHCatchScope : public EHScope {
// In effect, we have a flexible array member
//   Handler Handlers[0];
// But that's only standard in C99, not C++, so we have to do
// annoying pointer arithmetic instead.

153public:
struct Handler {
  /// A type info value, or null (C++ null, not an LLVM null pointer)
  /// for a catch-all.
  CatchTypeInfo Type;

  /// The catch handler for this type.
  llvm::BasicBlock *Block;

  bool isCatchAll() const { return Type.RTTI == nullptr; }
};

165private:
friend class EHScopeStack;

Handler *getHandlers() {
  return reinterpret_cast<Handler*>(this+1);
}

const Handler *getHandlers() const {
  return reinterpret_cast<const Handler*>(this+1);
}

176public:
static size_t getSizeForNumHandlers(unsigned N) {
  return sizeof(EHCatchScope) + N * sizeof(Handler);
}

EHCatchScope(unsigned numHandlers,
             EHScopeStack::stable_iterator enclosingEHScope)
  : EHScope(Catch, enclosingEHScope) {
  CatchBits.NumHandlers = numHandlers;
  assert(CatchBits.NumHandlers == numHandlers && "NumHandlers overflow?")((void)0);
}

unsigned getNumHandlers() const {
  return CatchBits.NumHandlers;
}

void setCatchAllHandler(unsigned I, llvm::BasicBlock *Block) {
  setHandler(I, CatchTypeInfo{nullptr, 0}, Block);
}

void setHandler(unsigned I, llvm::Constant *Type, llvm::BasicBlock *Block) {
  assert(I < getNumHandlers())((void)0);
  getHandlers()[I].Type = CatchTypeInfo{Type, 0};
  getHandlers()[I].Block = Block;
}

void setHandler(unsigned I, CatchTypeInfo Type, llvm::BasicBlock *Block) {
  assert(I < getNumHandlers())((void)0);
  getHandlers()[I].Type = Type;
  getHandlers()[I].Block = Block;
}

const Handler &getHandler(unsigned I) const {
  assert(I < getNumHandlers())((void)0);
  return getHandlers()[I];
}

// Clear all handler blocks.
// FIXME: it's better to always call clearHandlerBlocks in DTOR and have a
// 'takeHandler' or some such function which removes ownership from the
// EHCatchScope object if the handlers should live longer than EHCatchScope.
void clearHandlerBlocks() {
  for (unsigned I = 0, N = getNumHandlers(); I != N; ++I)
    delete getHandler(I).Block;
}

typedef const Handler *iterator;
iterator begin() const { return getHandlers(); }
iterator end() const { return getHandlers() + getNumHandlers(); }

static bool classof(const EHScope *Scope) {
  return Scope->getKind() == Catch;
}
229};

231/// A cleanup scope which generates the cleanup blocks lazily.
232class alignas(8) EHCleanupScope : public EHScope {
/// The nearest normal cleanup scope enclosing this one.
EHScopeStack::stable_iterator EnclosingNormal;

/// The nearest EH scope enclosing this one.
EHScopeStack::stable_iterator EnclosingEH;

/// The dual entry/exit block along the normal edge.  This is lazily
/// created if needed before the cleanup is popped.
llvm::BasicBlock *NormalBlock;

/// An optional i1 variable indicating whether this cleanup has been
/// activated yet.
llvm::AllocaInst *ActiveFlag;

/// Extra information required for cleanups that have resolved
/// branches through them.  This has to be allocated on the side
/// because everything on the cleanup stack has be trivially
/// movable.
struct ExtInfo {
  /// The destinations of normal branch-afters and branch-throughs.
  llvm::SmallPtrSet<llvm::BasicBlock*, 4> Branches;

  /// Normal branch-afters.
  SmallVector<std::pair<llvm::BasicBlock*,llvm::ConstantInt*>, 4>
    BranchAfters;
};
mutable struct ExtInfo *ExtInfo;

/// The number of fixups required by enclosing scopes (not including
/// this one).  If this is the top cleanup scope, all the fixups
/// from this index onwards belong to this scope.
unsigned FixupDepth;

struct ExtInfo &getExtInfo() {
  if (!ExtInfo) ExtInfo = new struct ExtInfo();
  return *ExtInfo;
}

const struct ExtInfo &getExtInfo() const {
  if (!ExtInfo) ExtInfo = new struct ExtInfo();
  return *ExtInfo;
}

276public:
/// Gets the size required for a lazy cleanup scope with the given
/// cleanup-data requirements.
static size_t getSizeForCleanupSize(size_t Size) {
  return sizeof(EHCleanupScope) + Size;
}

size_t getAllocatedSize() const {
  return sizeof(EHCleanupScope) + CleanupBits.CleanupSize;
}

EHCleanupScope(bool isNormal, bool isEH, unsigned cleanupSize,
               unsigned fixupDepth,
               EHScopeStack::stable_iterator enclosingNormal,
               EHScopeStack::stable_iterator enclosingEH)
    : EHScope(EHScope::Cleanup, enclosingEH),
      EnclosingNormal(enclosingNormal), NormalBlock(nullptr),
      ActiveFlag(nullptr), ExtInfo(nullptr), FixupDepth(fixupDepth) {
  CleanupBits.IsNormalCleanup = isNormal;
  CleanupBits.IsEHCleanup = isEH;
  CleanupBits.IsActive = true;
  CleanupBits.IsLifetimeMarker = false;
  CleanupBits.TestFlagInNormalCleanup = false;
  CleanupBits.TestFlagInEHCleanup = false;
  CleanupBits.CleanupSize = cleanupSize;

  assert(CleanupBits.CleanupSize == cleanupSize && "cleanup size overflow")((void)0);
}

void Destroy() {
  delete ExtInfo;
}
// Objects of EHCleanupScope are not destructed. Use Destroy().
~EHCleanupScope() = delete;

bool isNormalCleanup() const { return CleanupBits.IsNormalCleanup; }
llvm::BasicBlock *getNormalBlock() const { return NormalBlock; }
void setNormalBlock(llvm::BasicBlock *BB) { NormalBlock = BB; }

bool isEHCleanup() const { return CleanupBits.IsEHCleanup; }

bool isActive() const { return CleanupBits.IsActive; }
void setActive(bool A) { CleanupBits.IsActive = A; }

bool isLifetimeMarker() const { return CleanupBits.IsLifetimeMarker; }
void setLifetimeMarker() { CleanupBits.IsLifetimeMarker = true; }

bool hasActiveFlag() const { return ActiveFlag != nullptr; }
Address getActiveFlag() const {
  return Address(ActiveFlag, CharUnits::One());
}
void setActiveFlag(Address Var) {
  assert(Var.getAlignment().isOne())((void)0);
  ActiveFlag = cast<llvm::AllocaInst>(Var.getPointer());
}

void setTestFlagInNormalCleanup() {
  CleanupBits.TestFlagInNormalCleanup = true;
}
bool shouldTestFlagInNormalCleanup() const {
  return CleanupBits.TestFlagInNormalCleanup;
}

void setTestFlagInEHCleanup() {
  CleanupBits.TestFlagInEHCleanup = true;
}
bool shouldTestFlagInEHCleanup() const {
  return CleanupBits.TestFlagInEHCleanup;
}

unsigned getFixupDepth() const { return FixupDepth; }
EHScopeStack::stable_iterator getEnclosingNormalCleanup() const {
  return EnclosingNormal;
}

size_t getCleanupSize() const { return CleanupBits.CleanupSize; }
void *getCleanupBuffer() { return this + 1; }

EHScopeStack::Cleanup *getCleanup() {
  return reinterpret_cast<EHScopeStack::Cleanup*>(getCleanupBuffer());
}

/// True if this cleanup scope has any branch-afters or branch-throughs.
bool hasBranches() const { return ExtInfo && !ExtInfo->Branches.empty(); }

/// Add a branch-after to this cleanup scope.  A branch-after is a
/// branch from a point protected by this (normal) cleanup to a
/// point in the normal cleanup scope immediately containing it.
/// For example,
///   for (;;) { A a; break; }
/// contains a branch-after.
///
/// Branch-afters each have their own destination out of the
/// cleanup, guaranteed distinct from anything else threaded through
/// it.  Therefore branch-afters usually force a switch after the
/// cleanup.
void addBranchAfter(llvm::ConstantInt *Index,
                    llvm::BasicBlock *Block) {
  struct ExtInfo &ExtInfo = getExtInfo();
  if (ExtInfo.Branches.insert(Block).second)
    ExtInfo.BranchAfters.push_back(std::make_pair(Block, Index));
}

/// Return the number of unique branch-afters on this scope.
unsigned getNumBranchAfters() const {
  return ExtInfo ? ExtInfo->BranchAfters.size() : 0;
}

llvm::BasicBlock *getBranchAfterBlock(unsigned I) const {
  assert(I < getNumBranchAfters())((void)0);
  return ExtInfo->BranchAfters[I].first;
}

llvm::ConstantInt *getBranchAfterIndex(unsigned I) const {
  assert(I < getNumBranchAfters())((void)0);
  return ExtInfo->BranchAfters[I].second;
}

/// Add a branch-through to this cleanup scope.  A branch-through is
/// a branch from a scope protected by this (normal) cleanup to an
/// enclosing scope other than the immediately-enclosing normal
/// cleanup scope.
///
/// In the following example, the branch through B's scope is a
/// branch-through, while the branch through A's scope is a
/// branch-after:
///   for (;;) { A a; B b; break; }
///
/// All branch-throughs have a common destination out of the
/// cleanup, one possibly shared with the fall-through.  Therefore
/// branch-throughs usually don't force a switch after the cleanup.
///
/// \return true if the branch-through was new to this scope
bool addBranchThrough(llvm::BasicBlock *Block) {
  return getExtInfo().Branches.insert(Block).second;
}

/// Determines if this cleanup scope has any branch throughs.
bool hasBranchThroughs() const {
  if (!ExtInfo) return false;
  return (ExtInfo->BranchAfters.size() != ExtInfo->Branches.size());
}

static bool classof(const EHScope *Scope) {
  return (Scope->getKind() == Cleanup);
}
422};
423// NOTE: there's a bunch of different data classes tacked on after an
424// EHCleanupScope. It is asserted (in EHScopeStack::pushCleanup*) that
425// they don't require greater alignment than ScopeStackAlignment. So,
426// EHCleanupScope ought to have alignment equal to that -- not more
427// (would be misaligned by the stack allocator), and not less (would
428// break the appended classes).
429static_assert(alignof(EHCleanupScope) == EHScopeStack::ScopeStackAlignment,
            "EHCleanupScope expected alignment");

432/// An exceptions scope which filters exceptions thrown through it.
433/// Only exceptions matching the filter types will be permitted to be
434/// thrown.
435///
436/// This is used to implement C++ exception specifications.
437class EHFilterScope : public EHScope {
// Essentially ends in a flexible array member:
// llvm::Value *FilterTypes[0];

llvm::Value **getFilters() {
  return reinterpret_cast<llvm::Value**>(this+1);
}

llvm::Value * const *getFilters() const {
  return reinterpret_cast<llvm::Value* const *>(this+1);
}

449public:
EHFilterScope(unsigned numFilters)
  : EHScope(Filter, EHScopeStack::stable_end()) {
  FilterBits.NumFilters = numFilters;
  assert(FilterBits.NumFilters == numFilters && "NumFilters overflow")((void)0);
}

static size_t getSizeForNumFilters(unsigned numFilters) {
  return sizeof(EHFilterScope) + numFilters * sizeof(llvm::Value*);
}

unsigned getNumFilters() const { return FilterBits.NumFilters; }

void setFilter(unsigned i, llvm::Value *filterValue) {
  assert(i < getNumFilters())((void)0);
  getFilters()[i] = filterValue;
}

llvm::Value *getFilter(unsigned i) const {
  assert(i < getNumFilters())((void)0);
  return getFilters()[i];
}

static bool classof(const EHScope *scope) {
  return scope->getKind() == Filter;
}
475};

477/// An exceptions scope which calls std::terminate if any exception
478/// reaches it.
479class EHTerminateScope : public EHScope {
480public:
EHTerminateScope(EHScopeStack::stable_iterator enclosingEHScope)
  : EHScope(Terminate, enclosingEHScope) {}
static size_t getSize() { return sizeof(EHTerminateScope); }

static bool classof(const EHScope *scope) {
  return scope->getKind() == Terminate;
}
488};

490/// A non-stable pointer into the scope stack.
491class EHScopeStack::iterator {
char *Ptr;

friend class EHScopeStack;
explicit iterator(char *Ptr) : Ptr(Ptr) {}

497public:
iterator() : Ptr(nullptr) {}

EHScope *get() const {
  return reinterpret_cast<EHScope*>(Ptr);
}

EHScope *operator->() const { return get(); }
EHScope &operator*() const { return *get(); }

iterator &operator++() {
  size_t Size;
  switch (get()->getKind()) {
  case EHScope::Catch:
    Size = EHCatchScope::getSizeForNumHandlers(
        static_cast<const EHCatchScope *>(get())->getNumHandlers());
    break;

  case EHScope::Filter:
    Size = EHFilterScope::getSizeForNumFilters(
        static_cast<const EHFilterScope *>(get())->getNumFilters());
    break;

  case EHScope::Cleanup:
    Size = static_cast<const EHCleanupScope *>(get())->getAllocatedSize();
    break;

  case EHScope::Terminate:
    Size = EHTerminateScope::getSize();
    break;
  }
  Ptr += llvm::alignTo(Size, ScopeStackAlignment);
  return *this;
}

iterator next() {
  iterator copy = *this;
  ++copy;
  return copy;
}

iterator operator++(int) {
  iterator copy = *this;
  operator++();
  return copy;
}

bool encloses(iterator other) const { return Ptr >= other.Ptr; }
bool strictlyEncloses(iterator other) const { return Ptr > other.Ptr; }

bool operator==(iterator other) const { return Ptr == other.Ptr; }
bool operator!=(iterator other) const { return Ptr != other.Ptr; }
549};

551inline EHScopeStack::iterator EHScopeStack::begin() const {
return iterator(StartOfData);
553}

555inline EHScopeStack::iterator EHScopeStack::end() const {
return iterator(EndOfBuffer);
557}

559inline void EHScopeStack::popCatch() {
assert(!empty() && "popping exception stack when not empty")((void)0);

EHCatchScope &scope = cast<EHCatchScope>(*begin());
InnermostEHScope = scope.getEnclosingEHScope();
deallocate(EHCatchScope::getSizeForNumHandlers(scope.getNumHandlers()));
565}

567inline void EHScopeStack::popTerminate() {
assert(!empty() && "popping exception stack when not empty")((void)0);

EHTerminateScope &scope = cast<EHTerminateScope>(*begin());
InnermostEHScope = scope.getEnclosingEHScope();
deallocate(EHTerminateScope::getSize());
573}

575inline EHScopeStack::iterator EHScopeStack::find(stable_iterator sp) const {
assert(sp.isValid() && "finding invalid savepoint")((void)0);
assert(sp.Size <= stable_begin().Size && "finding savepoint after pop")((void)0);
return iterator(EndOfBuffer - sp.Size);
579}

581inline EHScopeStack::stable_iterator
582EHScopeStack::stabilize(iterator ir) const {
assert(StartOfData <= ir.Ptr && ir.Ptr <= EndOfBuffer)((void)0);
return stable_iterator(EndOfBuffer - ir.Ptr);
585}

587/// The exceptions personality for a function.
588struct EHPersonality {
const char *PersonalityFn;

// If this is non-null, this personality requires a non-standard
// function for rethrowing an exception after a catchall cleanup.
// This function must have prototype void(void*).
const char *CatchallRethrowFn;

static const EHPersonality &get(CodeGenModule &CGM, const FunctionDecl *FD);
static const EHPersonality &get(CodeGenFunction &CGF);

static const EHPersonality GNU_C;
static const EHPersonality GNU_C_SJLJ;
static const EHPersonality GNU_C_SEH;
static const EHPersonality GNU_ObjC;
static const EHPersonality GNU_ObjC_SJLJ;
static const EHPersonality GNU_ObjC_SEH;
static const EHPersonality GNUstep_ObjC;
static const EHPersonality GNU_ObjCXX;
static const EHPersonality NeXT_ObjC;
static const EHPersonality GNU_CPlusPlus;
static const EHPersonality GNU_CPlusPlus_SJLJ;
static const EHPersonality GNU_CPlusPlus_SEH;
static const EHPersonality MSVC_except_handler;
static const EHPersonality MSVC_C_specific_handler;
static const EHPersonality MSVC_CxxFrameHandler3;
static const EHPersonality GNU_Wasm_CPlusPlus;
static const EHPersonality XL_CPlusPlus;

/// Does this personality use landingpads or the family of pad instructions
/// designed to form funclets?
bool usesFuncletPads() const {
  return isMSVCPersonality() || isWasmPersonality();
}

bool isMSVCPersonality() const {
  return this == &MSVC_except_handler || this == &MSVC_C_specific_handler ||
         this == &MSVC_CxxFrameHandler3;
}

bool isWasmPersonality() const { return this == &GNU_Wasm_CPlusPlus; }

bool isMSVCXXPersonality() const { return this == &MSVC_CxxFrameHandler3; }
631};
632}
633}

635#endif

←

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include/llvm/IR/Value.h

1//===- llvm/Value.h - Definition of the Value class -------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares the Value class.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_IR_VALUE_H
14#define LLVM_IR_VALUE_H

16#include "llvm-c/Types.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/ADT/iterator_range.h"
20#include "llvm/IR/Use.h"
21#include "llvm/Support/Alignment.h"
22#include "llvm/Support/CBindingWrapping.h"
23#include "llvm/Support/Casting.h"
24#include <cassert>
25#include <iterator>
26#include <memory>

28namespace llvm {

30class APInt;
31class Argument;
32class BasicBlock;
33class Constant;
34class ConstantData;
35class ConstantAggregate;
36class DataLayout;
37class Function;
38class GlobalAlias;
39class GlobalIFunc;
40class GlobalIndirectSymbol;
41class GlobalObject;
42class GlobalValue;
43class GlobalVariable;
44class InlineAsm;
45class Instruction;
46class LLVMContext;
47class MDNode;
48class Module;
49class ModuleSlotTracker;
50class raw_ostream;
51template<typename ValueTy> class StringMapEntry;
52class Twine;
53class Type;
54class User;

56using ValueName = StringMapEntry<Value *>;

58//===----------------------------------------------------------------------===//
59//                                 Value Class
60//===----------------------------------------------------------------------===//

62/// LLVM Value Representation
63///
64/// This is a very important LLVM class. It is the base class of all values
65/// computed by a program that may be used as operands to other values. Value is
66/// the super class of other important classes such as Instruction and Function.
67/// All Values have a Type. Type is not a subclass of Value. Some values can
68/// have a name and they belong to some Module.  Setting the name on the Value
69/// automatically updates the module's symbol table.
70///
71/// Every value has a "use list" that keeps track of which other Values are
72/// using this Value.  A Value can also have an arbitrary number of ValueHandle
73/// objects that watch it and listen to RAUW and Destroy events.  See
74/// llvm/IR/ValueHandle.h for details.
75class Value {
Type *VTy;
Use *UseList;

friend class ValueAsMetadata; // Allow access to IsUsedByMD.
friend class ValueHandleBase;

const unsigned char SubclassID;   // Subclass identifier (for isa/dyn_cast)
unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this?

85protected:
/// Hold subclass data that can be dropped.
///
/// This member is similar to SubclassData, however it is for holding
/// information which may be used to aid optimization, but which may be
/// cleared to zero without affecting conservative interpretation.
unsigned char SubclassOptionalData : 7;

93private:
/// Hold arbitrary subclass data.
///
/// This member is defined by this class, but is not used for anything.
/// Subclasses can use it to hold whatever state they find useful.  This
/// field is initialized to zero by the ctor.
unsigned short SubclassData;

101protected:
/// The number of operands in the subclass.
///
/// This member is defined by this class, but not used for anything.
/// Subclasses can use it to store their number of operands, if they have
/// any.
///
/// This is stored here to save space in User on 64-bit hosts.  Since most
/// instances of Value have operands, 32-bit hosts aren't significantly
/// affected.
///
/// Note, this should *NOT* be used directly by any class other than User.
/// User uses this value to find the Use list.
enum : unsigned { NumUserOperandsBits = 27 };
unsigned NumUserOperands : NumUserOperandsBits;

// Use the same type as the bitfield above so that MSVC will pack them.
unsigned IsUsedByMD : 1;
unsigned HasName : 1;
unsigned HasMetadata : 1; // Has metadata attached to this?
unsigned HasHungOffUses : 1;
unsigned HasDescriptor : 1;

124private:
template <typename UseT> // UseT == 'Use' or 'const Use'
class use_iterator_impl {
  friend class Value;

  UseT *U;

  explicit use_iterator_impl(UseT *u) : U(u) {}

public:
  using iterator_category = std::forward_iterator_tag;
  using value_type = UseT *;
  using difference_type = std::ptrdiff_t;
  using pointer = value_type *;
  using reference = value_type &;

  use_iterator_impl() : U() {}

  bool operator==(const use_iterator_impl &x) const { return U == x.U; }
  bool operator!=(const use_iterator_impl &x) const { return !operator==(x); }

  use_iterator_impl &operator++() { // Preincrement
    assert(U && "Cannot increment end iterator!")((void)0);
    U = U->getNext();
    return *this;
  }

  use_iterator_impl operator++(int) { // Postincrement
    auto tmp = *this;
    ++*this;
    return tmp;
  }

  UseT &operator*() const {
    assert(U && "Cannot dereference end iterator!")((void)0);
    return *U;
  }

  UseT *operator->() const { return &operator*(); }

  operator use_iterator_impl<const UseT>() const {
    return use_iterator_impl<const UseT>(U);
  }
};

template <typename UserTy> // UserTy == 'User' or 'const User'
class user_iterator_impl {
  use_iterator_impl<Use> UI;
  explicit user_iterator_impl(Use *U) : UI(U) {}
  friend class Value;

public:
  using iterator_category = std::forward_iterator_tag;
  using value_type = UserTy *;
  using difference_type = std::ptrdiff_t;
  using pointer = value_type *;
  using reference = value_type &;

  user_iterator_impl() = default;

  bool operator==(const user_iterator_impl &x) const { return UI == x.UI; }
  bool operator!=(const user_iterator_impl &x) const { return !operator==(x); }

  /// Returns true if this iterator is equal to user_end() on the value.
  bool atEnd() const { return *this == user_iterator_impl(); }

  user_iterator_impl &operator++() { // Preincrement
    ++UI;
    return *this;
  }

  user_iterator_impl operator++(int) { // Postincrement
    auto tmp = *this;
    ++*this;
    return tmp;
  }

  // Retrieve a pointer to the current User.
  UserTy *operator*() const {
    return UI->getUser();
  }

  UserTy *operator->() const { return operator*(); }

  operator user_iterator_impl<const UserTy>() const {
    return user_iterator_impl<const UserTy>(*UI);
  }

  Use &getUse() const { return *UI; }
};

215protected:
Value(Type *Ty, unsigned scid);

/// Value's destructor should be virtual by design, but that would require
/// that Value and all of its subclasses have a vtable that effectively
/// duplicates the information in the value ID. As a size optimization, the
/// destructor has been protected, and the caller should manually call
/// deleteValue.
~Value(); // Use deleteValue() to delete a generic Value.

225public:
Value(const Value &) = delete;
Value &operator=(const Value &) = delete;

/// Delete a pointer to a generic Value.
void deleteValue();

/// Support for debugging, callable in GDB: V->dump()
void dump() const;

/// Implement operator<< on Value.
/// @{
void print(raw_ostream &O, bool IsForDebug = false) const;
void print(raw_ostream &O, ModuleSlotTracker &MST,
           bool IsForDebug = false) const;
/// @}

/// Print the name of this Value out to the specified raw_ostream.
///
/// This is useful when you just want to print 'int %reg126', not the
/// instruction that generated it. If you specify a Module for context, then
/// even constanst get pretty-printed; for example, the type of a null
/// pointer is printed symbolically.
/// @{
void printAsOperand(raw_ostream &O, bool PrintType = true,
                    const Module *M = nullptr) const;
void printAsOperand(raw_ostream &O, bool PrintType,
                    ModuleSlotTracker &MST) const;
/// @}

/// All values are typed, get the type of this value.
Type *getType() const { return VTy; }

/// All values hold a context through their type.
LLVMContext &getContext() const;

// All values can potentially be named.
bool hasName() const { return HasName; }
ValueName *getValueName() const;
void setValueName(ValueName *VN);

266private:
void destroyValueName();
enum class ReplaceMetadataUses { No, Yes };
void doRAUW(Value *New, ReplaceMetadataUses);
void setNameImpl(const Twine &Name);

272public:
/// Return a constant reference to the value's name.
///
/// This guaranteed to return the same reference as long as the value is not
/// modified.  If the value has a name, this does a hashtable lookup, so it's
/// not free.
StringRef getName() const;

/// Change the name of the value.
///
/// Choose a new unique name if the provided name is taken.
///
/// \param Name The new name; or "" if the value's name should be removed.
void setName(const Twine &Name);

/// Transfer the name from V to this value.
///
/// After taking V's name, sets V's name to empty.
///
/// \note It is an error to call V->takeName(V).
void takeName(Value *V);

294#ifndef NDEBUG1
std::string getNameOrAsOperand() const;
296#endif

/// Change all uses of this to point to a new Value.
///
/// Go through the uses list for this definition and make each use point to
/// "V" instead of "this".  After this completes, 'this's use list is
/// guaranteed to be empty.
void replaceAllUsesWith(Value *V);

/// Change non-metadata uses of this to point to a new Value.
///
/// Go through the uses list for this definition and make each use point to
/// "V" instead of "this". This function skips metadata entries in the list.
void replaceNonMetadataUsesWith(Value *V);

/// Go through the uses list for this definition and make each use point
/// to "V" if the callback ShouldReplace returns true for the given Use.
/// Unlike replaceAllUsesWith() this function does not support basic block
/// values.
void replaceUsesWithIf(Value *New,
                       llvm::function_ref<bool(Use &U)> ShouldReplace);

/// replaceUsesOutsideBlock - Go through the uses list for this definition and
/// make each use point to "V" instead of "this" when the use is outside the
/// block. 'This's use list is expected to have at least one element.
/// Unlike replaceAllUsesWith() this function does not support basic block
/// values.
void replaceUsesOutsideBlock(Value *V, BasicBlock *BB);

//----------------------------------------------------------------------
// Methods for handling the chain of uses of this Value.
//
// Materializing a function can introduce new uses, so these methods come in
// two variants:
// The methods that start with materialized_ check the uses that are
// currently known given which functions are materialized. Be very careful
// when using them since you might not get all uses.
// The methods that don't start with materialized_ assert that modules is
// fully materialized.
void assertModuleIsMaterializedImpl() const;
// This indirection exists so we can keep assertModuleIsMaterializedImpl()
// around in release builds of Value.cpp to be linked with other code built
// in debug mode. But this avoids calling it in any of the release built code.
void assertModuleIsMaterialized() const {
340#ifndef NDEBUG1
  assertModuleIsMaterializedImpl();
342#endif
}

bool use_empty() const {
  assertModuleIsMaterialized();
  return UseList == nullptr;
7
←
Assuming the condition is false→
8
←
Returning zero, which participates in a condition later→
}

bool materialized_use_empty() const {
  return UseList == nullptr;
}

using use_iterator = use_iterator_impl<Use>;
using const_use_iterator = use_iterator_impl<const Use>;

use_iterator materialized_use_begin() { return use_iterator(UseList); }
const_use_iterator materialized_use_begin() const {
  return const_use_iterator(UseList);
}
use_iterator use_begin() {
  assertModuleIsMaterialized();
  return materialized_use_begin();
}
const_use_iterator use_begin() const {
  assertModuleIsMaterialized();
  return materialized_use_begin();
}
use_iterator use_end() { return use_iterator(); }
const_use_iterator use_end() const { return const_use_iterator(); }
iterator_range<use_iterator> materialized_uses() {
  return make_range(materialized_use_begin(), use_end());
}
iterator_range<const_use_iterator> materialized_uses() const {
  return make_range(materialized_use_begin(), use_end());
}
iterator_range<use_iterator> uses() {
  assertModuleIsMaterialized();
  return materialized_uses();
}
iterator_range<const_use_iterator> uses() const {
  assertModuleIsMaterialized();
  return materialized_uses();
}

bool user_empty() const {
  assertModuleIsMaterialized();
  return UseList == nullptr;
}

using user_iterator = user_iterator_impl<User>;
using const_user_iterator = user_iterator_impl<const User>;

user_iterator materialized_user_begin() { return user_iterator(UseList); }
const_user_iterator materialized_user_begin() const {
  return const_user_iterator(UseList);
}
user_iterator user_begin() {
  assertModuleIsMaterialized();
  return materialized_user_begin();
}
const_user_iterator user_begin() const {
  assertModuleIsMaterialized();
  return materialized_user_begin();
}
user_iterator user_end() { return user_iterator(); }
const_user_iterator user_end() const { return const_user_iterator(); }
User *user_back() {
  assertModuleIsMaterialized();
  return *materialized_user_begin();
}
const User *user_back() const {
  assertModuleIsMaterialized();
  return *materialized_user_begin();
}
iterator_range<user_iterator> materialized_users() {
  return make_range(materialized_user_begin(), user_end());
}
iterator_range<const_user_iterator> materialized_users() const {
  return make_range(materialized_user_begin(), user_end());
}
iterator_range<user_iterator> users() {
  assertModuleIsMaterialized();
  return materialized_users();
}
iterator_range<const_user_iterator> users() const {
  assertModuleIsMaterialized();
  return materialized_users();
}

/// Return true if there is exactly one use of this value.
///
/// This is specialized because it is a common request and does not require
/// traversing the whole use list.
bool hasOneUse() const { return hasSingleElement(uses()); }

/// Return true if this Value has exactly N uses.
bool hasNUses(unsigned N) const;

/// Return true if this value has N uses or more.
///
/// This is logically equivalent to getNumUses() >= N.
bool hasNUsesOrMore(unsigned N) const;

/// Return true if there is exactly one user of this value.
///
/// Note that this is not the same as "has one use". If a value has one use,
/// then there certainly is a single user. But if value has several uses,
/// it is possible that all uses are in a single user, or not.
///
/// This check is potentially costly, since it requires traversing,
/// in the worst case, the whole use list of a value.
bool hasOneUser() const;

/// Return true if there is exactly one use of this value that cannot be
/// dropped.
///
/// This is specialized because it is a common request and does not require
/// traversing the whole use list.
Use *getSingleUndroppableUse();
const Use *getSingleUndroppableUse() const {
  return const_cast<Value *>(this)->getSingleUndroppableUse();
}

/// Return true if there this value.
///
/// This is specialized because it is a common request and does not require
/// traversing the whole use list.
bool hasNUndroppableUses(unsigned N) const;

/// Return true if this value has N uses or more.
///
/// This is logically equivalent to getNumUses() >= N.
bool hasNUndroppableUsesOrMore(unsigned N) const;

/// Remove every uses that can safely be removed.
///
/// This will remove for example uses in llvm.assume.
/// This should be used when performing want to perform a tranformation but
/// some Droppable uses pervent it.
/// This function optionally takes a filter to only remove some droppable
/// uses.
void dropDroppableUses(llvm::function_ref<bool(const Use *)> ShouldDrop =
                           [](const Use *) { return true; });

/// Remove every use of this value in \p User that can safely be removed.
void dropDroppableUsesIn(User &Usr);

/// Remove the droppable use \p U.
static void dropDroppableUse(Use &U);

/// Check if this value is used in the specified basic block.
bool isUsedInBasicBlock(const BasicBlock *BB) const;

/// This method computes the number of uses of this Value.
///
/// This is a linear time operation.  Use hasOneUse, hasNUses, or
/// hasNUsesOrMore to check for specific values.
unsigned getNumUses() const;

/// This method should only be used by the Use class.
void addUse(Use &U) { U.addToList(&UseList); }

/// Concrete subclass of this.
///
/// An enumeration for keeping track of the concrete subclass of Value that
/// is actually instantiated. Values of this enumeration are kept in the
/// Value classes SubclassID field. They are used for concrete type
/// identification.
enum ValueTy {
511#define HANDLE_VALUE(Name) Name##Val,
512#include "llvm/IR/Value.def"

  // Markers:
515#define HANDLE_CONSTANT_MARKER(Marker, Constant) Marker = Constant##Val,
516#include "llvm/IR/Value.def"
};

/// Return an ID for the concrete type of this object.
///
/// This is used to implement the classof checks.  This should not be used
/// for any other purpose, as the values may change as LLVM evolves.  Also,
/// note that for instructions, the Instruction's opcode is added to
/// InstructionVal. So this means three things:
/// # there is no value with code InstructionVal (no opcode==0).
/// # there are more possible values for the value type than in ValueTy enum.
/// # the InstructionVal enumerator must be the highest valued enumerator in
///   the ValueTy enum.
unsigned getValueID() const {
  return SubclassID;
}

/// Return the raw optional flags value contained in this value.
///
/// This should only be used when testing two Values for equivalence.
unsigned getRawSubclassOptionalData() const {
  return SubclassOptionalData;
}

/// Clear the optional flags contained in this value.
void clearSubclassOptionalData() {
  SubclassOptionalData = 0;
}

/// Check the optional flags for equality.
bool hasSameSubclassOptionalData(const Value *V) const {
  return SubclassOptionalData == V->SubclassOptionalData;
}

/// Return true if there is a value handle associated with this value.
bool hasValueHandle() const { return HasValueHandle; }

/// Return true if there is metadata referencing this value.
bool isUsedByMetadata() const { return IsUsedByMD; }

// Return true if this value is only transitively referenced by metadata.
bool isTransitiveUsedByMetadataOnly() const;

559protected:
/// Get the current metadata attachments for the given kind, if any.
///
/// These functions require that the value have at most a single attachment
/// of the given kind, and return \c nullptr if such an attachment is missing.
/// @{
MDNode *getMetadata(unsigned KindID) const;
MDNode *getMetadata(StringRef Kind) const;
/// @}

/// Appends all attachments with the given ID to \c MDs in insertion order.
/// If the Value has no attachments with the given ID, or if ID is invalid,
/// leaves MDs unchanged.
/// @{
void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const;
/// @}

/// Appends all metadata attached to this value to \c MDs, sorting by
/// KindID. The first element of each pair returned is the KindID, the second
/// element is the metadata value. Attachments with the same ID appear in
/// insertion order.
void
getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;

/// Return true if this value has any metadata attached to it.
bool hasMetadata() const { return (bool)HasMetadata; }

/// Return true if this value has the given type of metadata attached.
/// @{
bool hasMetadata(unsigned KindID) const {
  return getMetadata(KindID) != nullptr;
}
bool hasMetadata(StringRef Kind) const {
  return getMetadata(Kind) != nullptr;
}
/// @}

/// Set a particular kind of metadata attachment.
///
/// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
/// replacing it if it already exists.
/// @{
void setMetadata(unsigned KindID, MDNode *Node);
void setMetadata(StringRef Kind, MDNode *Node);
/// @}

/// Add a metadata attachment.
/// @{
void addMetadata(unsigned KindID, MDNode &MD);
void addMetadata(StringRef Kind, MDNode &MD);
/// @}

/// Erase all metadata attachments with the given kind.
///
/// \returns true if any metadata was removed.
bool eraseMetadata(unsigned KindID);

/// Erase all metadata attached to this Value.
void clearMetadata();

620public:
/// Return true if this value is a swifterror value.
///
/// swifterror values can be either a function argument or an alloca with a
/// swifterror attribute.
bool isSwiftError() const;

/// Strip off pointer casts, all-zero GEPs and address space casts.
///
/// Returns the original uncasted value.  If this is called on a non-pointer
/// value, it returns 'this'.
const Value *stripPointerCasts() const;
Value *stripPointerCasts() {
  return const_cast<Value *>(
      static_cast<const Value *>(this)->stripPointerCasts());
}

/// Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
///
/// Returns the original uncasted value.  If this is called on a non-pointer
/// value, it returns 'this'.
const Value *stripPointerCastsAndAliases() const;
Value *stripPointerCastsAndAliases() {
  return const_cast<Value *>(
      static_cast<const Value *>(this)->stripPointerCastsAndAliases());
}

/// Strip off pointer casts, all-zero GEPs and address space casts
/// but ensures the representation of the result stays the same.
///
/// Returns the original uncasted value with the same representation. If this
/// is called on a non-pointer value, it returns 'this'.
const Value *stripPointerCastsSameRepresentation() const;
Value *stripPointerCastsSameRepresentation() {
  return const_cast<Value *>(static_cast<const Value *>(this)
                                 ->stripPointerCastsSameRepresentation());
}

/// Strip off pointer casts, all-zero GEPs, single-argument phi nodes and
/// invariant group info.
///
/// Returns the original uncasted value.  If this is called on a non-pointer
/// value, it returns 'this'. This function should be used only in
/// Alias analysis.
const Value *stripPointerCastsForAliasAnalysis() const;
Value *stripPointerCastsForAliasAnalysis() {
  return const_cast<Value *>(static_cast<const Value *>(this)
                                 ->stripPointerCastsForAliasAnalysis());
}

/// Strip off pointer casts and all-constant inbounds GEPs.
///
/// Returns the original pointer value.  If this is called on a non-pointer
/// value, it returns 'this'.
const Value *stripInBoundsConstantOffsets() const;
Value *stripInBoundsConstantOffsets() {
  return const_cast<Value *>(
            static_cast<const Value *>(this)->stripInBoundsConstantOffsets());
}

/// Accumulate the constant offset this value has compared to a base pointer.
/// Only 'getelementptr' instructions (GEPs) are accumulated but other
/// instructions, e.g., casts, are stripped away as well.
/// The accumulated constant offset is added to \p Offset and the base
/// pointer is returned.
///
/// The APInt \p Offset has to have a bit-width equal to the IntPtr type for
/// the address space of 'this' pointer value, e.g., use
/// DataLayout::getIndexTypeSizeInBits(Ty).
///
/// If \p AllowNonInbounds is true, offsets in GEPs are stripped and
/// accumulated even if the GEP is not "inbounds".
///
/// If \p ExternalAnalysis is provided it will be used to calculate a offset
/// when a operand of GEP is not constant.
/// For example, for a value \p ExternalAnalysis might try to calculate a
/// lower bound. If \p ExternalAnalysis is successful, it should return true.
///
/// If this is called on a non-pointer value, it returns 'this' and the
/// \p Offset is not modified.
///
/// Note that this function will never return a nullptr. It will also never
/// manipulate the \p Offset in a way that would not match the difference
/// between the underlying value and the returned one. Thus, if no constant
/// offset was found, the returned value is the underlying one and \p Offset
/// is unchanged.
const Value *stripAndAccumulateConstantOffsets(
    const DataLayout &DL, APInt &Offset, bool AllowNonInbounds,
    function_ref<bool(Value &Value, APInt &Offset)> ExternalAnalysis =
        nullptr) const;
Value *stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset,
                                         bool AllowNonInbounds) {
  return const_cast<Value *>(
      static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets(
          DL, Offset, AllowNonInbounds));
}

/// This is a wrapper around stripAndAccumulateConstantOffsets with the
/// in-bounds requirement set to false.
const Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
                                                       APInt &Offset) const {
  return stripAndAccumulateConstantOffsets(DL, Offset,
                                           /* AllowNonInbounds */ false);
}
Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
                                                 APInt &Offset) {
  return stripAndAccumulateConstantOffsets(DL, Offset,
                                           /* AllowNonInbounds */ false);
}

/// Strip off pointer casts and inbounds GEPs.
///
/// Returns the original pointer value.  If this is called on a non-pointer
/// value, it returns 'this'.
const Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func =
                                      [](const Value *) {}) const;
inline Value *stripInBoundsOffsets(function_ref<void(const Value *)> Func =
                                [](const Value *) {}) {
  return const_cast<Value *>(
      static_cast<const Value *>(this)->stripInBoundsOffsets(Func));
}

/// Return true if the memory object referred to by V can by freed in the
/// scope for which the SSA value defining the allocation is statically
/// defined.  E.g.  deallocation after the static scope of a value does not
/// count, but a deallocation before that does.
bool canBeFreed() const;

/// Returns the number of bytes known to be dereferenceable for the
/// pointer value.
///
/// If CanBeNull is set by this function the pointer can either be null or be
/// dereferenceable up to the returned number of bytes.
///
/// IF CanBeFreed is true, the pointer is known to be dereferenceable at
/// point of definition only.  Caller must prove that allocation is not
/// deallocated between point of definition and use.
uint64_t getPointerDereferenceableBytes(const DataLayout &DL,
                                        bool &CanBeNull,
                                        bool &CanBeFreed) const;

/// Returns an alignment of the pointer value.
///
/// Returns an alignment which is either specified explicitly, e.g. via
/// align attribute of a function argument, or guaranteed by DataLayout.
Align getPointerAlignment(const DataLayout &DL) const;

/// Translate PHI node to its predecessor from the given basic block.
///
/// If this value is a PHI node with CurBB as its parent, return the value in
/// the PHI node corresponding to PredBB.  If not, return ourself.  This is
/// useful if you want to know the value something has in a predecessor
/// block.
const Value *DoPHITranslation(const BasicBlock *CurBB,
                              const BasicBlock *PredBB) const;
Value *DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) {
  return const_cast<Value *>(
           static_cast<const Value *>(this)->DoPHITranslation(CurBB, PredBB));
}

/// The maximum alignment for instructions.
///
/// This is the greatest alignment value supported by load, store, and alloca
/// instructions, and global values.
static const unsigned MaxAlignmentExponent = 29;
static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent;

/// Mutate the type of this Value to be of the specified type.
///
/// Note that this is an extremely dangerous operation which can create
/// completely invalid IR very easily.  It is strongly recommended that you
/// recreate IR objects with the right types instead of mutating them in
/// place.
void mutateType(Type *Ty) {
  VTy = Ty;
}

/// Sort the use-list.
///
/// Sorts the Value's use-list by Cmp using a stable mergesort.  Cmp is
/// expected to compare two \a Use references.
template <class Compare> void sortUseList(Compare Cmp);

/// Reverse the use-list.
void reverseUseList();

806private:
/// Merge two lists together.
///
/// Merges \c L and \c R using \c Cmp.  To enable stable sorts, always pushes
/// "equal" items from L before items from R.
///
/// \return the first element in the list.
///
/// \note Completely ignores \a Use::Prev (doesn't read, doesn't update).
template <class Compare>
static Use *mergeUseLists(Use *L, Use *R, Compare Cmp) {
  Use *Merged;
  Use **Next = &Merged;

  while (true) {
    if (!L) {
      *Next = R;
      break;
    }
    if (!R) {
      *Next = L;
      break;
    }
    if (Cmp(*R, *L)) {
      *Next = R;
      Next = &R->Next;
      R = R->Next;
    } else {
      *Next = L;
      Next = &L->Next;
      L = L->Next;
    }
  }

  return Merged;
}

843protected:
unsigned short getSubclassDataFromValue() const { return SubclassData; }
void setValueSubclassData(unsigned short D) { SubclassData = D; }
846};

848struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } };

850/// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
851/// Those don't work because Value and Instruction's destructors are protected,
852/// aren't virtual, and won't destroy the complete object.
853using unique_value = std::unique_ptr<Value, ValueDeleter>;

855inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
V.print(OS);
return OS;
858}

860void Use::set(Value *V) {
if (Val) removeFromList();
Val = V;
if (V) V->addUse(*this);
864}

866Value *Use::operator=(Value *RHS) {
set(RHS);
return RHS;
869}

871const Use &Use::operator=(const Use &RHS) {
set(RHS.Val);
return *this;
874}

876template <class Compare> void Value::sortUseList(Compare Cmp) {
if (!UseList || !UseList->Next)
  // No need to sort 0 or 1 uses.
  return;

// Note: this function completely ignores Prev pointers until the end when
// they're fixed en masse.

// Create a binomial vector of sorted lists, visiting uses one at a time and
// merging lists as necessary.
const unsigned MaxSlots = 32;
Use *Slots[MaxSlots];

// Collect the first use, turning it into a single-item list.
Use *Next = UseList->Next;
UseList->Next = nullptr;
unsigned NumSlots = 1;
Slots[0] = UseList;

// Collect all but the last use.
while (Next->Next) {
  Use *Current = Next;
  Next = Current->Next;

  // Turn Current into a single-item list.
  Current->Next = nullptr;

  // Save Current in the first available slot, merging on collisions.
  unsigned I;
  for (I = 0; I < NumSlots; ++I) {
    if (!Slots[I])
      break;

    // Merge two lists, doubling the size of Current and emptying slot I.
    //
    // Since the uses in Slots[I] originally preceded those in Current, send
    // Slots[I] in as the left parameter to maintain a stable sort.
    Current = mergeUseLists(Slots[I], Current, Cmp);
    Slots[I] = nullptr;
  }
  // Check if this is a new slot.
  if (I == NumSlots) {
    ++NumSlots;
    assert(NumSlots <= MaxSlots && "Use list bigger than 2^32")((void)0);
  }

  // Found an open slot.
  Slots[I] = Current;
}

// Merge all the lists together.
assert(Next && "Expected one more Use")((void)0);
assert(!Next->Next && "Expected only one Use")((void)0);
UseList = Next;
for (unsigned I = 0; I < NumSlots; ++I)
  if (Slots[I])
    // Since the uses in Slots[I] originally preceded those in UseList, send
    // Slots[I] in as the left parameter to maintain a stable sort.
    UseList = mergeUseLists(Slots[I], UseList, Cmp);

// Fix the Prev pointers.
for (Use *I = UseList, **Prev = &UseList; I; I = I->Next) {
  I->Prev = Prev;
  Prev = &I->Next;
}
941}

943// isa - Provide some specializations of isa so that we don't have to include
944// the subtype header files to test to see if the value is a subclass...
945//
946template <> struct isa_impl<Constant, Value> {
static inline bool doit(const Value &Val) {
  static_assert(Value::ConstantFirstVal == 0, "Val.getValueID() >= Value::ConstantFirstVal");
  return Val.getValueID() <= Value::ConstantLastVal;
}
951};

953template <> struct isa_impl<ConstantData, Value> {
static inline bool doit(const Value &Val) {
  return Val.getValueID() >= Value::ConstantDataFirstVal &&
         Val.getValueID() <= Value::ConstantDataLastVal;
}
958};

960template <> struct isa_impl<ConstantAggregate, Value> {
static inline bool doit(const Value &Val) {
  return Val.getValueID() >= Value::ConstantAggregateFirstVal &&
         Val.getValueID() <= Value::ConstantAggregateLastVal;
}
965};

967template <> struct isa_impl<Argument, Value> {
static inline bool doit (const Value &Val) {
  return Val.getValueID() == Value::ArgumentVal;
}
971};

973template <> struct isa_impl<InlineAsm, Value> {
static inline bool doit(const Value &Val) {
  return Val.getValueID() == Value::InlineAsmVal;
}
977};

979template <> struct isa_impl<Instruction, Value> {
static inline bool doit(const Value &Val) {
  return Val.getValueID() >= Value::InstructionVal;
}
983};

985template <> struct isa_impl<BasicBlock, Value> {
static inline bool doit(const Value &Val) {
  return Val.getValueID() == Value::BasicBlockVal;
}
989};

991template <> struct isa_impl<Function, Value> {
static inline bool doit(const Value &Val) {
  return Val.getValueID() == Value::FunctionVal;
}
995};

997template <> struct isa_impl<GlobalVariable, Value> {
static inline bool doit(const Value &Val) {
  return Val.getValueID() == Value::GlobalVariableVal;
}
1001};

1003template <> struct isa_impl<GlobalAlias, Value> {
static inline bool doit(const Value &Val) {
  return Val.getValueID() == Value::GlobalAliasVal;
}
1007};

1009template <> struct isa_impl<GlobalIFunc, Value> {
static inline bool doit(const Value &Val) {
  return Val.getValueID() == Value::GlobalIFuncVal;
}
1013};

1015template <> struct isa_impl<GlobalIndirectSymbol, Value> {
static inline bool doit(const Value &Val) {
  return isa<GlobalAlias>(Val) || isa<GlobalIFunc>(Val);
}
1019};

1021template <> struct isa_impl<GlobalValue, Value> {
static inline bool doit(const Value &Val) {
  return isa<GlobalObject>(Val) || isa<GlobalIndirectSymbol>(Val);
}
1025};

1027template <> struct isa_impl<GlobalObject, Value> {
static inline bool doit(const Value &Val) {
  return isa<GlobalVariable>(Val) || isa<Function>(Val);
}
1031};

1033// Create wrappers for C Binding types (see CBindingWrapping.h).
1034DEFINE_ISA_CONVERSION_FUNCTIONS(Value, LLVMValueRef)inline Value *unwrap(LLVMValueRef P) { return reinterpret_cast
<Value*>(P); } inline LLVMValueRef wrap(const Value *P)
 { return reinterpret_cast<LLVMValueRef>(const_cast<
Value*>(P)); } template<typename T> inline T *unwrap
(LLVMValueRef P) { return cast<T>(unwrap(P)); }

1036// Specialized opaque value conversions.
1037inline Value **unwrap(LLVMValueRef *Vals) {
return reinterpret_cast<Value**>(Vals);
1039}

1041template<typename T>
1042inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
1043#ifndef NDEBUG1
for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
  unwrap<T>(*I); // For side effect of calling assert on invalid usage.
1046#endif
(void)Length;
return reinterpret_cast<T**>(Vals);
1049}

1051inline LLVMValueRef *wrap(const Value **Vals) {
return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
1053}

1055} // end namespace llvm

1057#endif // LLVM_IR_VALUE_H