/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp

Bug Summary

File:	clang/lib/CodeGen/CGBlocks.cpp
Warning:	line 597, column 19 Forming reference to null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGBlocks.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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/CodeGen -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D CLANG_ROUND_TRIP_CC1_ARGS=ON -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-08-28-193554-24367-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp

→

1//===--- CGBlocks.cpp - Emit LLVM Code for declarations ---------*- 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 to emit blocks.
10//
11//===----------------------------------------------------------------------===//

13#include "CGBlocks.h"
14#include "CGCXXABI.h"
15#include "CGDebugInfo.h"
16#include "CGObjCRuntime.h"
17#include "CGOpenCLRuntime.h"
18#include "CodeGenFunction.h"
19#include "CodeGenModule.h"
20#include "ConstantEmitter.h"
21#include "TargetInfo.h"
22#include "clang/AST/Attr.h"
23#include "clang/AST/DeclObjC.h"
24#include "clang/CodeGen/ConstantInitBuilder.h"
25#include "llvm/ADT/SmallSet.h"
26#include "llvm/IR/DataLayout.h"
27#include "llvm/IR/Module.h"
28#include "llvm/Support/ScopedPrinter.h"
29#include <algorithm>
30#include <cstdio>

32using namespace clang;
33using namespace CodeGen;

35CGBlockInfo::CGBlockInfo(const BlockDecl *block, StringRef name)
: Name(name), CXXThisIndex(0), CanBeGlobal(false), NeedsCopyDispose(false),
  HasCXXObject(false), UsesStret(false), HasCapturedVariableLayout(false),
  CapturesNonExternalType(false), LocalAddress(Address::invalid()),
  StructureType(nullptr), Block(block) {

// Skip asm prefix, if any.  'name' is usually taken directly from
// the mangled name of the enclosing function.
if (!name.empty() && name[0] == '\01')
  name = name.substr(1);
45}

47// Anchor the vtable to this translation unit.
48BlockByrefHelpers::~BlockByrefHelpers() {}

50/// Build the given block as a global block.
51static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM,
                                      const CGBlockInfo &blockInfo,
                                      llvm::Constant *blockFn);

55/// Build the helper function to copy a block.
56static llvm::Constant *buildCopyHelper(CodeGenModule &CGM,
                                     const CGBlockInfo &blockInfo) {
return CodeGenFunction(CGM).GenerateCopyHelperFunction(blockInfo);
59}

61/// Build the helper function to dispose of a block.
62static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM,
                                        const CGBlockInfo &blockInfo) {
return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo);
65}

67namespace {

69/// Represents a type of copy/destroy operation that should be performed for an
70/// entity that's captured by a block.
71enum class BlockCaptureEntityKind {
CXXRecord, // Copy or destroy
ARCWeak,
ARCStrong,
NonTrivialCStruct,
BlockObject, // Assign or release
None
78};

80/// Represents a captured entity that requires extra operations in order for
81/// this entity to be copied or destroyed correctly.
82struct BlockCaptureManagedEntity {
BlockCaptureEntityKind CopyKind, DisposeKind;
BlockFieldFlags CopyFlags, DisposeFlags;
const BlockDecl::Capture *CI;
const CGBlockInfo::Capture *Capture;

BlockCaptureManagedEntity(BlockCaptureEntityKind CopyType,
                          BlockCaptureEntityKind DisposeType,
                          BlockFieldFlags CopyFlags,
                          BlockFieldFlags DisposeFlags,
                          const BlockDecl::Capture &CI,
                          const CGBlockInfo::Capture &Capture)
    : CopyKind(CopyType), DisposeKind(DisposeType), CopyFlags(CopyFlags),
      DisposeFlags(DisposeFlags), CI(&CI), Capture(&Capture) {}

bool operator<(const BlockCaptureManagedEntity &Other) const {
  return Capture->getOffset() < Other.Capture->getOffset();
}
100};

102enum class CaptureStrKind {
// String for the copy helper.
CopyHelper,
// String for the dispose helper.
DisposeHelper,
// Merge the strings for the copy helper and dispose helper.
Merged
109};

111} // end anonymous namespace

113static void findBlockCapturedManagedEntities(
  const CGBlockInfo &BlockInfo, const LangOptions &LangOpts,
  SmallVectorImpl<BlockCaptureManagedEntity> &ManagedCaptures);

117static std::string getBlockCaptureStr(const BlockCaptureManagedEntity &E,
                                    CaptureStrKind StrKind,
                                    CharUnits BlockAlignment,
                                    CodeGenModule &CGM);

122static std::string getBlockDescriptorName(const CGBlockInfo &BlockInfo,
                                        CodeGenModule &CGM) {
std::string Name = "__block_descriptor_";
Name += llvm::to_string(BlockInfo.BlockSize.getQuantity()) + "_";

if (BlockInfo.needsCopyDisposeHelpers()) {
  if (CGM.getLangOpts().Exceptions)
    Name += "e";
  if (CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
    Name += "a";
  Name += llvm::to_string(BlockInfo.BlockAlign.getQuantity()) + "_";

  SmallVector<BlockCaptureManagedEntity, 4> ManagedCaptures;
  findBlockCapturedManagedEntities(BlockInfo, CGM.getContext().getLangOpts(),
                                   ManagedCaptures);

  for (const BlockCaptureManagedEntity &E : ManagedCaptures) {
    Name += llvm::to_string(E.Capture->getOffset().getQuantity());

    if (E.CopyKind == E.DisposeKind) {
      // If CopyKind and DisposeKind are the same, merge the capture
      // information.
      assert(E.CopyKind != BlockCaptureEntityKind::None &&(static_cast <bool> (E.CopyKind != BlockCaptureEntityKind
::None && "shouldn't see BlockCaptureManagedEntity that is None"
) ? void (0) : __assert_fail ("E.CopyKind != BlockCaptureEntityKind::None && \"shouldn't see BlockCaptureManagedEntity that is None\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 145, __extension__ __PRETTY_FUNCTION__))
             "shouldn't see BlockCaptureManagedEntity that is None")(static_cast <bool> (E.CopyKind != BlockCaptureEntityKind
::None && "shouldn't see BlockCaptureManagedEntity that is None"
) ? void (0) : __assert_fail ("E.CopyKind != BlockCaptureEntityKind::None && \"shouldn't see BlockCaptureManagedEntity that is None\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 145, __extension__ __PRETTY_FUNCTION__));
      Name += getBlockCaptureStr(E, CaptureStrKind::Merged,
                                 BlockInfo.BlockAlign, CGM);
    } else {
      // If CopyKind and DisposeKind are not the same, which can happen when
      // either Kind is None or the captured object is a __strong block,
      // concatenate the copy and dispose strings.
      Name += getBlockCaptureStr(E, CaptureStrKind::CopyHelper,
                                 BlockInfo.BlockAlign, CGM);
      Name += getBlockCaptureStr(E, CaptureStrKind::DisposeHelper,
                                 BlockInfo.BlockAlign, CGM);
    }
  }
  Name += "_";
}

std::string TypeAtEncoding =
    CGM.getContext().getObjCEncodingForBlock(BlockInfo.getBlockExpr());
/// Replace occurrences of '@' with '\1'. '@' is reserved on ELF platforms as
/// a separator between symbol name and symbol version.
std::replace(TypeAtEncoding.begin(), TypeAtEncoding.end(), '@', '\1');
Name += "e" + llvm::to_string(TypeAtEncoding.size()) + "_" + TypeAtEncoding;
Name += "l" + CGM.getObjCRuntime().getRCBlockLayoutStr(CGM, BlockInfo);
return Name;
169}

171/// buildBlockDescriptor - Build the block descriptor meta-data for a block.
172/// buildBlockDescriptor is accessed from 5th field of the Block_literal
173/// meta-data and contains stationary information about the block literal.
174/// Its definition will have 4 (or optionally 6) words.
175/// \code
176/// struct Block_descriptor {
177///   unsigned long reserved;
178///   unsigned long size;  // size of Block_literal metadata in bytes.
179///   void *copy_func_helper_decl;  // optional copy helper.
180///   void *destroy_func_decl; // optional destructor helper.
181///   void *block_method_encoding_address; // @encode for block literal signature.
182///   void *block_layout_info; // encoding of captured block variables.
183/// };
184/// \endcode
185static llvm::Constant *buildBlockDescriptor(CodeGenModule &CGM,
                                          const CGBlockInfo &blockInfo) {
ASTContext &C = CGM.getContext();

llvm::IntegerType *ulong =
  cast<llvm::IntegerType>(CGM.getTypes().ConvertType(C.UnsignedLongTy));
llvm::PointerType *i8p = nullptr;
if (CGM.getLangOpts().OpenCL)
  i8p =
    llvm::Type::getInt8PtrTy(
         CGM.getLLVMContext(), C.getTargetAddressSpace(LangAS::opencl_constant));
else
  i8p = CGM.VoidPtrTy;

std::string descName;

// If an equivalent block descriptor global variable exists, return it.
if (C.getLangOpts().ObjC &&
    CGM.getLangOpts().getGC() == LangOptions::NonGC) {
  descName = getBlockDescriptorName(blockInfo, CGM);
  if (llvm::GlobalValue *desc = CGM.getModule().getNamedValue(descName))
    return llvm::ConstantExpr::getBitCast(desc,
                                          CGM.getBlockDescriptorType());
}

// If there isn't an equivalent block descriptor global variable, create a new
// one.
ConstantInitBuilder builder(CGM);
auto elements = builder.beginStruct();

// reserved
elements.addInt(ulong, 0);

// Size
// FIXME: What is the right way to say this doesn't fit?  We should give
// a user diagnostic in that case.  Better fix would be to change the
// API to size_t.
elements.addInt(ulong, blockInfo.BlockSize.getQuantity());

// Optional copy/dispose helpers.
bool hasInternalHelper = false;
if (blockInfo.needsCopyDisposeHelpers()) {
  // copy_func_helper_decl
  llvm::Constant *copyHelper = buildCopyHelper(CGM, blockInfo);
  elements.add(copyHelper);

  // destroy_func_decl
  llvm::Constant *disposeHelper = buildDisposeHelper(CGM, blockInfo);
  elements.add(disposeHelper);

  if (cast<llvm::Function>(copyHelper->getOperand(0))->hasInternalLinkage() ||
      cast<llvm::Function>(disposeHelper->getOperand(0))
          ->hasInternalLinkage())
    hasInternalHelper = true;
}

// Signature.  Mandatory ObjC-style method descriptor @encode sequence.
std::string typeAtEncoding =
  CGM.getContext().getObjCEncodingForBlock(blockInfo.getBlockExpr());
elements.add(llvm::ConstantExpr::getBitCast(
  CGM.GetAddrOfConstantCString(typeAtEncoding).getPointer(), i8p));

// GC layout.
if (C.getLangOpts().ObjC) {
  if (CGM.getLangOpts().getGC() != LangOptions::NonGC)
    elements.add(CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo));
  else
    elements.add(CGM.getObjCRuntime().BuildRCBlockLayout(CGM, blockInfo));
}
else
  elements.addNullPointer(i8p);

unsigned AddrSpace = 0;
if (C.getLangOpts().OpenCL)
  AddrSpace = C.getTargetAddressSpace(LangAS::opencl_constant);

llvm::GlobalValue::LinkageTypes linkage;
if (descName.empty()) {
  linkage = llvm::GlobalValue::InternalLinkage;
  descName = "__block_descriptor_tmp";
} else if (hasInternalHelper) {
  // If either the copy helper or the dispose helper has internal linkage,
  // the block descriptor must have internal linkage too.
  linkage = llvm::GlobalValue::InternalLinkage;
} else {
  linkage = llvm::GlobalValue::LinkOnceODRLinkage;
}

llvm::GlobalVariable *global =
    elements.finishAndCreateGlobal(descName, CGM.getPointerAlign(),
                                   /*constant*/ true, linkage, AddrSpace);

if (linkage == llvm::GlobalValue::LinkOnceODRLinkage) {
  if (CGM.supportsCOMDAT())
    global->setComdat(CGM.getModule().getOrInsertComdat(descName));
  global->setVisibility(llvm::GlobalValue::HiddenVisibility);
  global->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
}

return llvm::ConstantExpr::getBitCast(global, CGM.getBlockDescriptorType());
285}

287/*
Purely notional variadic template describing the layout of a block.

template <class _ResultType, class... _ParamTypes, class... _CaptureTypes>
struct Block_literal {
  /// Initialized to one of:
  ///   extern void *_NSConcreteStackBlock[];
  ///   extern void *_NSConcreteGlobalBlock[];
  ///
  /// In theory, we could start one off malloc'ed by setting
  /// BLOCK_NEEDS_FREE, giving it a refcount of 1, and using
  /// this isa:
  ///   extern void *_NSConcreteMallocBlock[];
  struct objc_class *isa;

  /// These are the flags (with corresponding bit number) that the
  /// compiler is actually supposed to know about.
  ///  23. BLOCK_IS_NOESCAPE - indicates that the block is non-escaping
  ///  25. BLOCK_HAS_COPY_DISPOSE - indicates that the block
  ///   descriptor provides copy and dispose helper functions
  ///  26. BLOCK_HAS_CXX_OBJ - indicates that there's a captured
  ///   object with a nontrivial destructor or copy constructor
  ///  28. BLOCK_IS_GLOBAL - indicates that the block is allocated
  ///   as global memory
  ///  29. BLOCK_USE_STRET - indicates that the block function
  ///   uses stret, which objc_msgSend needs to know about
  ///  30. BLOCK_HAS_SIGNATURE - indicates that the block has an
  ///   @encoded signature string
  /// And we're not supposed to manipulate these:
  ///  24. BLOCK_NEEDS_FREE - indicates that the block has been moved
  ///   to malloc'ed memory
  ///  27. BLOCK_IS_GC - indicates that the block has been moved to
  ///   to GC-allocated memory
  /// Additionally, the bottom 16 bits are a reference count which
  /// should be zero on the stack.
  int flags;

  /// Reserved;  should be zero-initialized.
  int reserved;

  /// Function pointer generated from block literal.
  _ResultType (*invoke)(Block_literal *, _ParamTypes...);

  /// Block description metadata generated from block literal.
  struct Block_descriptor *block_descriptor;

  /// Captured values follow.
  _CapturesTypes captures...;
};
*/

338namespace {
/// A chunk of data that we actually have to capture in the block.
struct BlockLayoutChunk {
  CharUnits Alignment;
  CharUnits Size;
  Qualifiers::ObjCLifetime Lifetime;
  const BlockDecl::Capture *Capture; // null for 'this'
  llvm::Type *Type;
  QualType FieldType;

  BlockLayoutChunk(CharUnits align, CharUnits size,
                   Qualifiers::ObjCLifetime lifetime,
                   const BlockDecl::Capture *capture,
                   llvm::Type *type, QualType fieldType)
    : Alignment(align), Size(size), Lifetime(lifetime),
      Capture(capture), Type(type), FieldType(fieldType) {}

  /// Tell the block info that this chunk has the given field index.
  void setIndex(CGBlockInfo &info, unsigned index, CharUnits offset) {
    if (!Capture) {
      info.CXXThisIndex = index;
      info.CXXThisOffset = offset;
    } else {
      auto C = CGBlockInfo::Capture::makeIndex(index, offset, FieldType);
      info.Captures.insert({Capture->getVariable(), C});
    }
  }
};

/// Order by 1) all __strong together 2) next, all byfref together 3) next,
/// all __weak together. Preserve descending alignment in all situations.
bool operator<(const BlockLayoutChunk &left, const BlockLayoutChunk &right) {
  if (left.Alignment != right.Alignment)
    return left.Alignment > right.Alignment;

  auto getPrefOrder = [](const BlockLayoutChunk &chunk) {
    if (chunk.Capture && chunk.Capture->isByRef())
      return 1;
    if (chunk.Lifetime == Qualifiers::OCL_Strong)
      return 0;
    if (chunk.Lifetime == Qualifiers::OCL_Weak)
      return 2;
    return 3;
  };

  return getPrefOrder(left) < getPrefOrder(right);
}
385} // end anonymous namespace

387/// Determines if the given type is safe for constant capture in C++.
388static bool isSafeForCXXConstantCapture(QualType type) {
const RecordType *recordType =
  type->getBaseElementTypeUnsafe()->getAs<RecordType>();

// Only records can be unsafe.
if (!recordType) return true;

const auto *record = cast<CXXRecordDecl>(recordType->getDecl());

// Maintain semantics for classes with non-trivial dtors or copy ctors.
if (!record->hasTrivialDestructor()) return false;
if (record->hasNonTrivialCopyConstructor()) return false;

// Otherwise, we just have to make sure there aren't any mutable
// fields that might have changed since initialization.
return !record->hasMutableFields();
404}

406/// It is illegal to modify a const object after initialization.
407/// Therefore, if a const object has a constant initializer, we don't
408/// actually need to keep storage for it in the block; we'll just
409/// rematerialize it at the start of the block function.  This is
410/// acceptable because we make no promises about address stability of
411/// captured variables.
412static llvm::Constant *tryCaptureAsConstant(CodeGenModule &CGM,
                                          CodeGenFunction *CGF,
                                          const VarDecl *var) {
// Return if this is a function parameter. We shouldn't try to
// rematerialize default arguments of function parameters.
if (isa<ParmVarDecl>(var))
17
←
Assuming 'var' is a 'ParmVarDecl'→
18
←
Taking true branch→
  return nullptr;
19
←
Returning null pointer, which participates in a condition later→

QualType type = var->getType();

// We can only do this if the variable is const.
if (!type.isConstQualified()) return nullptr;

// Furthermore, in C++ we have to worry about mutable fields:
// C++ [dcl.type.cv]p4:
//   Except that any class member declared mutable can be
//   modified, any attempt to modify a const object during its
//   lifetime results in undefined behavior.
if (CGM.getLangOpts().CPlusPlus && !isSafeForCXXConstantCapture(type))
  return nullptr;

// If the variable doesn't have any initializer (shouldn't this be
// invalid?), it's not clear what we should do.  Maybe capture as
// zero?
const Expr *init = var->getInit();
if (!init) return nullptr;

return ConstantEmitter(CGM, CGF).tryEmitAbstractForInitializer(*var);
440}

442/// Get the low bit of a nonzero character count.  This is the
443/// alignment of the nth byte if the 0th byte is universally aligned.
444static CharUnits getLowBit(CharUnits v) {
return CharUnits::fromQuantity(v.getQuantity() & (~v.getQuantity() + 1));
446}

448static void initializeForBlockHeader(CodeGenModule &CGM, CGBlockInfo &info,
                           SmallVectorImpl<llvm::Type*> &elementTypes) {

assert(elementTypes.empty())(static_cast <bool> (elementTypes.empty()) ? void (0) :
 __assert_fail ("elementTypes.empty()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 451, __extension__ __PRETTY_FUNCTION__));
if (CGM.getLangOpts().OpenCL) {
  // The header is basically 'struct { int; int; generic void *;
  // custom_fields; }'. Assert that struct is packed.
  auto GenericAS =
      CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic);
  auto GenPtrAlign =
      CharUnits::fromQuantity(CGM.getTarget().getPointerAlign(GenericAS) / 8);
  auto GenPtrSize =
      CharUnits::fromQuantity(CGM.getTarget().getPointerWidth(GenericAS) / 8);
  assert(CGM.getIntSize() <= GenPtrSize)(static_cast <bool> (CGM.getIntSize() <= GenPtrSize)
 ? void (0) : __assert_fail ("CGM.getIntSize() <= GenPtrSize"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 461, __extension__ __PRETTY_FUNCTION__));
  assert(CGM.getIntAlign() <= GenPtrAlign)(static_cast <bool> (CGM.getIntAlign() <= GenPtrAlign
) ? void (0) : __assert_fail ("CGM.getIntAlign() <= GenPtrAlign"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 462, __extension__ __PRETTY_FUNCTION__));
  assert((2 * CGM.getIntSize()).isMultipleOf(GenPtrAlign))(static_cast <bool> ((2 * CGM.getIntSize()).isMultipleOf
(GenPtrAlign)) ? void (0) : __assert_fail ("(2 * CGM.getIntSize()).isMultipleOf(GenPtrAlign)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 463, __extension__ __PRETTY_FUNCTION__));
  elementTypes.push_back(CGM.IntTy); /* total size */
  elementTypes.push_back(CGM.IntTy); /* align */
  elementTypes.push_back(
      CGM.getOpenCLRuntime()
          .getGenericVoidPointerType()); /* invoke function */
  unsigned Offset =
      2 * CGM.getIntSize().getQuantity() + GenPtrSize.getQuantity();
  unsigned BlockAlign = GenPtrAlign.getQuantity();
  if (auto *Helper =
          CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) {
    for (auto I : Helper->getCustomFieldTypes()) /* custom fields */ {
      // TargetOpenCLBlockHelp needs to make sure the struct is packed.
      // If necessary, add padding fields to the custom fields.
      unsigned Align = CGM.getDataLayout().getABITypeAlignment(I);
      if (BlockAlign < Align)
        BlockAlign = Align;
      assert(Offset % Align == 0)(static_cast <bool> (Offset % Align == 0) ? void (0) : __assert_fail
 ("Offset % Align == 0", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 480, __extension__ __PRETTY_FUNCTION__));
      Offset += CGM.getDataLayout().getTypeAllocSize(I);
      elementTypes.push_back(I);
    }
  }
  info.BlockAlign = CharUnits::fromQuantity(BlockAlign);
  info.BlockSize = CharUnits::fromQuantity(Offset);
} else {
  // The header is basically 'struct { void *; int; int; void *; void *; }'.
  // Assert that the struct is packed.
  assert(CGM.getIntSize() <= CGM.getPointerSize())(static_cast <bool> (CGM.getIntSize() <= CGM.getPointerSize
()) ? void (0) : __assert_fail ("CGM.getIntSize() <= CGM.getPointerSize()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 490, __extension__ __PRETTY_FUNCTION__));
  assert(CGM.getIntAlign() <= CGM.getPointerAlign())(static_cast <bool> (CGM.getIntAlign() <= CGM.getPointerAlign
()) ? void (0) : __assert_fail ("CGM.getIntAlign() <= CGM.getPointerAlign()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 491, __extension__ __PRETTY_FUNCTION__));
  assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign()))(static_cast <bool> ((2 * CGM.getIntSize()).isMultipleOf
(CGM.getPointerAlign())) ? void (0) : __assert_fail ("(2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign())"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 492, __extension__ __PRETTY_FUNCTION__));
  info.BlockAlign = CGM.getPointerAlign();
  info.BlockSize = 3 * CGM.getPointerSize() + 2 * CGM.getIntSize();
  elementTypes.push_back(CGM.VoidPtrTy);
  elementTypes.push_back(CGM.IntTy);
  elementTypes.push_back(CGM.IntTy);
  elementTypes.push_back(CGM.VoidPtrTy);
  elementTypes.push_back(CGM.getBlockDescriptorType());
}
501}

503static QualType getCaptureFieldType(const CodeGenFunction &CGF,
                                  const BlockDecl::Capture &CI) {
const VarDecl *VD = CI.getVariable();

// If the variable is captured by an enclosing block or lambda expression,
// use the type of the capture field.
if (CGF.BlockInfo && CI.isNested())
  return CGF.BlockInfo->getCapture(VD).fieldType();
if (auto *FD = CGF.LambdaCaptureFields.lookup(VD))
  return FD->getType();
// If the captured variable is a non-escaping __block variable, the field
// type is the reference type. If the variable is a __block variable that
// already has a reference type, the field type is the variable's type.
return VD->isNonEscapingByref() ?
       CGF.getContext().getLValueReferenceType(VD->getType()) : VD->getType();
518}

520/// Compute the layout of the given block.  Attempts to lay the block
521/// out with minimal space requirements.
522static void computeBlockInfo(CodeGenModule &CGM, CodeGenFunction *CGF,
                           CGBlockInfo &info) {
ASTContext &C = CGM.getContext();
const BlockDecl *block = info.getBlockDecl();

SmallVector<llvm::Type*, 8> elementTypes;
initializeForBlockHeader(CGM, info, elementTypes);
bool hasNonConstantCustomFields = false;
if (auto *OpenCLHelper =
5
←
Assuming 'OpenCLHelper' is null→
        CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper())
  hasNonConstantCustomFields =
      !OpenCLHelper->areAllCustomFieldValuesConstant(info);
if (!block->hasCaptures() && !hasNonConstantCustomFields) {
6
←
Calling 'BlockDecl::hasCaptures'→
9
←
Returning from 'BlockDecl::hasCaptures'→
  info.StructureType =
    llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
  info.CanBeGlobal = true;
  return;
}
else if (C.getLangOpts().ObjC &&
10
←
Assuming field 'ObjC' is 0→
         CGM.getLangOpts().getGC() == LangOptions::NonGC)
  info.HasCapturedVariableLayout = true;

// Collect the layout chunks.
SmallVector<BlockLayoutChunk, 16> layout;
layout.reserve(block->capturesCXXThis() +
               (block->capture_end() - block->capture_begin()));

CharUnits maxFieldAlign;

// First, 'this'.
if (block->capturesCXXThis()) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
  assert(CGF && CGF->CurFuncDecl && isa<CXXMethodDecl>(CGF->CurFuncDecl) &&(static_cast <bool> (CGF && CGF->CurFuncDecl
 && isa<CXXMethodDecl>(CGF->CurFuncDecl) &&
 "Can't capture 'this' outside a method") ? void (0) : __assert_fail
 ("CGF && CGF->CurFuncDecl && isa<CXXMethodDecl>(CGF->CurFuncDecl) && \"Can't capture 'this' outside a method\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 554, __extension__ __PRETTY_FUNCTION__))
         "Can't capture 'this' outside a method")(static_cast <bool> (CGF && CGF->CurFuncDecl
 && isa<CXXMethodDecl>(CGF->CurFuncDecl) &&
 "Can't capture 'this' outside a method") ? void (0) : __assert_fail
 ("CGF && CGF->CurFuncDecl && isa<CXXMethodDecl>(CGF->CurFuncDecl) && \"Can't capture 'this' outside a method\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 554, __extension__ __PRETTY_FUNCTION__));
  QualType thisType = cast<CXXMethodDecl>(CGF->CurFuncDecl)->getThisType();

  // Theoretically, this could be in a different address space, so
  // don't assume standard pointer size/align.
  llvm::Type *llvmType = CGM.getTypes().ConvertType(thisType);
  auto TInfo = CGM.getContext().getTypeInfoInChars(thisType);
  maxFieldAlign = std::max(maxFieldAlign, TInfo.Align);

  layout.push_back(BlockLayoutChunk(TInfo.Align, TInfo.Width,
                                    Qualifiers::OCL_None,
                                    nullptr, llvmType, thisType));
}

// Next, all the block captures.
for (const auto &CI : block->captures()) {
13
←
Assuming '__begin1' is not equal to '__end1'→
  const VarDecl *variable = CI.getVariable();

  if (CI.isEscapingByref()) {
14
←
Assuming the condition is false→
15
←
Taking false branch→
    // We have to copy/dispose of the __block reference.
    info.NeedsCopyDispose = true;

    // Just use void* instead of a pointer to the byref type.
    CharUnits align = CGM.getPointerAlign();
    maxFieldAlign = std::max(maxFieldAlign, align);

    // Since a __block variable cannot be captured by lambdas, its type and
    // the capture field type should always match.
    assert(CGF && getCaptureFieldType(*CGF, CI) == variable->getType() &&(static_cast <bool> (CGF && getCaptureFieldType
(*CGF, CI) == variable->getType() && "capture type differs from the variable type"
) ? void (0) : __assert_fail ("CGF && getCaptureFieldType(*CGF, CI) == variable->getType() && \"capture type differs from the variable type\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 583, __extension__ __PRETTY_FUNCTION__))
           "capture type differs from the variable type")(static_cast <bool> (CGF && getCaptureFieldType
(*CGF, CI) == variable->getType() && "capture type differs from the variable type"
) ? void (0) : __assert_fail ("CGF && getCaptureFieldType(*CGF, CI) == variable->getType() && \"capture type differs from the variable type\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 583, __extension__ __PRETTY_FUNCTION__));
    layout.push_back(BlockLayoutChunk(align, CGM.getPointerSize(),
                                      Qualifiers::OCL_None, &CI,
                                      CGM.VoidPtrTy, variable->getType()));
    continue;
  }

  // Otherwise, build a layout chunk with the size and alignment of
  // the declaration.
  if (llvm::Constant *constant20.1
'constant' is null
1
'constant' is null
 = tryCaptureAsConstant(CGM, CGF, variable)) {
16
←
Calling 'tryCaptureAsConstant'→
20
←
Returning from 'tryCaptureAsConstant'→
21
←
Taking false branch→
    info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant);
    continue;
  }

  QualType VT = getCaptureFieldType(*CGF, CI);
22
←
Forming reference to null pointer

  // If we have a lifetime qualifier, honor it for capture purposes.
  // That includes *not* copying it if it's __unsafe_unretained.
  Qualifiers::ObjCLifetime lifetime = VT.getObjCLifetime();
  if (lifetime) {
    switch (lifetime) {
    case Qualifiers::OCL_None: llvm_unreachable("impossible")::llvm::llvm_unreachable_internal("impossible", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 604);
    case Qualifiers::OCL_ExplicitNone:
    case Qualifiers::OCL_Autoreleasing:
      break;

    case Qualifiers::OCL_Strong:
    case Qualifiers::OCL_Weak:
      info.NeedsCopyDispose = true;
    }

  // Block pointers require copy/dispose.  So do Objective-C pointers.
  } else if (VT->isObjCRetainableType()) {
    // But honor the inert __unsafe_unretained qualifier, which doesn't
    // actually make it into the type system.
     if (VT->isObjCInertUnsafeUnretainedType()) {
      lifetime = Qualifiers::OCL_ExplicitNone;
    } else {
      info.NeedsCopyDispose = true;
      // used for mrr below.
      lifetime = Qualifiers::OCL_Strong;
    }

  // So do types that require non-trivial copy construction.
  } else if (CI.hasCopyExpr()) {
    info.NeedsCopyDispose = true;
    info.HasCXXObject = true;
    if (!VT->getAsCXXRecordDecl()->isExternallyVisible())
      info.CapturesNonExternalType = true;

  // So do C structs that require non-trivial copy construction or
  // destruction.
  } else if (VT.isNonTrivialToPrimitiveCopy() == QualType::PCK_Struct ||
             VT.isDestructedType() == QualType::DK_nontrivial_c_struct) {
    info.NeedsCopyDispose = true;

  // And so do types with destructors.
  } else if (CGM.getLangOpts().CPlusPlus) {
    if (const CXXRecordDecl *record = VT->getAsCXXRecordDecl()) {
      if (!record->hasTrivialDestructor()) {
        info.HasCXXObject = true;
        info.NeedsCopyDispose = true;
        if (!record->isExternallyVisible())
          info.CapturesNonExternalType = true;
      }
    }
  }

  CharUnits size = C.getTypeSizeInChars(VT);
  CharUnits align = C.getDeclAlign(variable);

  maxFieldAlign = std::max(maxFieldAlign, align);

  llvm::Type *llvmType =
    CGM.getTypes().ConvertTypeForMem(VT);

  layout.push_back(
      BlockLayoutChunk(align, size, lifetime, &CI, llvmType, VT));
}

// If that was everything, we're done here.
if (layout.empty()) {
  info.StructureType =
    llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
  info.CanBeGlobal = true;
  return;
}

// Sort the layout by alignment.  We have to use a stable sort here
// to get reproducible results.  There should probably be an
// llvm::array_pod_stable_sort.
llvm::stable_sort(layout);

// Needed for blocks layout info.
info.BlockHeaderForcedGapOffset = info.BlockSize;
info.BlockHeaderForcedGapSize = CharUnits::Zero();

CharUnits &blockSize = info.BlockSize;
info.BlockAlign = std::max(maxFieldAlign, info.BlockAlign);

// Assuming that the first byte in the header is maximally aligned,
// get the alignment of the first byte following the header.
CharUnits endAlign = getLowBit(blockSize);

// If the end of the header isn't satisfactorily aligned for the
// maximum thing, look for things that are okay with the header-end
// alignment, and keep appending them until we get something that's
// aligned right.  This algorithm is only guaranteed optimal if
// that condition is satisfied at some point; otherwise we can get
// things like:
//   header                 // next byte has alignment 4
//   something_with_size_5; // next byte has alignment 1
//   something_with_alignment_8;
// which has 7 bytes of padding, as opposed to the naive solution
// which might have less (?).
if (endAlign < maxFieldAlign) {
  SmallVectorImpl<BlockLayoutChunk>::iterator
    li = layout.begin() + 1, le = layout.end();

  // Look for something that the header end is already
  // satisfactorily aligned for.
  for (; li != le && endAlign < li->Alignment; ++li)
    ;

  // If we found something that's naturally aligned for the end of
  // the header, keep adding things...
  if (li != le) {
    SmallVectorImpl<BlockLayoutChunk>::iterator first = li;
    for (; li != le; ++li) {
      assert(endAlign >= li->Alignment)(static_cast <bool> (endAlign >= li->Alignment) ?
 void (0) : __assert_fail ("endAlign >= li->Alignment",
 "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 712, __extension__ __PRETTY_FUNCTION__));

      li->setIndex(info, elementTypes.size(), blockSize);
      elementTypes.push_back(li->Type);
      blockSize += li->Size;
      endAlign = getLowBit(blockSize);

      // ...until we get to the alignment of the maximum field.
      if (endAlign >= maxFieldAlign) {
        break;
      }
    }
    // Don't re-append everything we just appended.
    layout.erase(first, li);
  }
}

assert(endAlign == getLowBit(blockSize))(static_cast <bool> (endAlign == getLowBit(blockSize)) ?
 void (0) : __assert_fail ("endAlign == getLowBit(blockSize)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 729, __extension__ __PRETTY_FUNCTION__));

// At this point, we just have to add padding if the end align still
// isn't aligned right.
if (endAlign < maxFieldAlign) {
  CharUnits newBlockSize = blockSize.alignTo(maxFieldAlign);
  CharUnits padding = newBlockSize - blockSize;

  // If we haven't yet added any fields, remember that there was an
  // initial gap; this need to go into the block layout bit map.
  if (blockSize == info.BlockHeaderForcedGapOffset) {
    info.BlockHeaderForcedGapSize = padding;
  }

  elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty,
                                              padding.getQuantity()));
  blockSize = newBlockSize;
  endAlign = getLowBit(blockSize); // might be > maxFieldAlign
}

assert(endAlign >= maxFieldAlign)(static_cast <bool> (endAlign >= maxFieldAlign) ? void
 (0) : __assert_fail ("endAlign >= maxFieldAlign", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 749, __extension__ __PRETTY_FUNCTION__));
assert(endAlign == getLowBit(blockSize))(static_cast <bool> (endAlign == getLowBit(blockSize)) ?
 void (0) : __assert_fail ("endAlign == getLowBit(blockSize)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 750, __extension__ __PRETTY_FUNCTION__));
// Slam everything else on now.  This works because they have
// strictly decreasing alignment and we expect that size is always a
// multiple of alignment.
for (SmallVectorImpl<BlockLayoutChunk>::iterator
       li = layout.begin(), le = layout.end(); li != le; ++li) {
  if (endAlign < li->Alignment) {
    // size may not be multiple of alignment. This can only happen with
    // an over-aligned variable. We will be adding a padding field to
    // make the size be multiple of alignment.
    CharUnits padding = li->Alignment - endAlign;
    elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty,
                                                padding.getQuantity()));
    blockSize += padding;
    endAlign = getLowBit(blockSize);
  }
  assert(endAlign >= li->Alignment)(static_cast <bool> (endAlign >= li->Alignment) ?
 void (0) : __assert_fail ("endAlign >= li->Alignment",
 "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 766, __extension__ __PRETTY_FUNCTION__));
  li->setIndex(info, elementTypes.size(), blockSize);
  elementTypes.push_back(li->Type);
  blockSize += li->Size;
  endAlign = getLowBit(blockSize);
}

info.StructureType =
  llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
775}

777/// Emit a block literal expression in the current function.
778llvm::Value *CodeGenFunction::EmitBlockLiteral(const BlockExpr *blockExpr) {
// If the block has no captures, we won't have a pre-computed
// layout for it.
if (!blockExpr->getBlockDecl()->hasCaptures())
  // The block literal is emitted as a global variable, and the block invoke
  // function has to be extracted from its initializer.
  if (llvm::Constant *Block = CGM.getAddrOfGlobalBlockIfEmitted(blockExpr))
    return Block;

CGBlockInfo blockInfo(blockExpr->getBlockDecl(), CurFn->getName());
computeBlockInfo(CGM, this, blockInfo);
blockInfo.BlockExpression = blockExpr;
if (!blockInfo.CanBeGlobal)
  blockInfo.LocalAddress = CreateTempAlloca(blockInfo.StructureType,
                                            blockInfo.BlockAlign, "block");
return EmitBlockLiteral(blockInfo);
794}

796llvm::Value *CodeGenFunction::EmitBlockLiteral(const CGBlockInfo &blockInfo) {
bool IsOpenCL = CGM.getContext().getLangOpts().OpenCL;
auto GenVoidPtrTy =
    IsOpenCL ? CGM.getOpenCLRuntime().getGenericVoidPointerType() : VoidPtrTy;
LangAS GenVoidPtrAddr = IsOpenCL ? LangAS::opencl_generic : LangAS::Default;
auto GenVoidPtrSize = CharUnits::fromQuantity(
    CGM.getTarget().getPointerWidth(
        CGM.getContext().getTargetAddressSpace(GenVoidPtrAddr)) /
    8);
// Using the computed layout, generate the actual block function.
bool isLambdaConv = blockInfo.getBlockDecl()->isConversionFromLambda();
CodeGenFunction BlockCGF{CGM, true};
BlockCGF.SanOpts = SanOpts;
auto *InvokeFn = BlockCGF.GenerateBlockFunction(
    CurGD, blockInfo, LocalDeclMap, isLambdaConv, blockInfo.CanBeGlobal);
auto *blockFn = llvm::ConstantExpr::getPointerCast(InvokeFn, GenVoidPtrTy);

// If there is nothing to capture, we can emit this as a global block.
if (blockInfo.CanBeGlobal)
  return CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression);

// Otherwise, we have to emit this as a local block.

Address blockAddr = blockInfo.LocalAddress;
assert(blockAddr.isValid() && "block has no address!")(static_cast <bool> (blockAddr.isValid() && "block has no address!"
) ? void (0) : __assert_fail ("blockAddr.isValid() && \"block has no address!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 820, __extension__ __PRETTY_FUNCTION__));

llvm::Constant *isa;
llvm::Constant *descriptor;
BlockFlags flags;
if (!IsOpenCL) {
  // If the block is non-escaping, set field 'isa 'to NSConcreteGlobalBlock
  // and set the BLOCK_IS_GLOBAL bit of field 'flags'. Copying a non-escaping
  // block just returns the original block and releasing it is a no-op.
  llvm::Constant *blockISA = blockInfo.getBlockDecl()->doesNotEscape()
                                 ? CGM.getNSConcreteGlobalBlock()
                                 : CGM.getNSConcreteStackBlock();
  isa = llvm::ConstantExpr::getBitCast(blockISA, VoidPtrTy);

  // Build the block descriptor.
  descriptor = buildBlockDescriptor(CGM, blockInfo);

  // Compute the initial on-stack block flags.
  flags = BLOCK_HAS_SIGNATURE;
  if (blockInfo.HasCapturedVariableLayout)
    flags |= BLOCK_HAS_EXTENDED_LAYOUT;
  if (blockInfo.needsCopyDisposeHelpers())
    flags |= BLOCK_HAS_COPY_DISPOSE;
  if (blockInfo.HasCXXObject)
    flags |= BLOCK_HAS_CXX_OBJ;
  if (blockInfo.UsesStret)
    flags |= BLOCK_USE_STRET;
  if (blockInfo.getBlockDecl()->doesNotEscape())
    flags |= BLOCK_IS_NOESCAPE | BLOCK_IS_GLOBAL;
}

auto projectField = [&](unsigned index, const Twine &name) -> Address {
  return Builder.CreateStructGEP(blockAddr, index, name);
};
auto storeField = [&](llvm::Value *value, unsigned index, const Twine &name) {
  Builder.CreateStore(value, projectField(index, name));
};

// Initialize the block header.
{
  // We assume all the header fields are densely packed.
  unsigned index = 0;
  CharUnits offset;
  auto addHeaderField = [&](llvm::Value *value, CharUnits size,
                            const Twine &name) {
    storeField(value, index, name);
    offset += size;
    index++;
  };

  if (!IsOpenCL) {
    addHeaderField(isa, getPointerSize(), "block.isa");
    addHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()),
                   getIntSize(), "block.flags");
    addHeaderField(llvm::ConstantInt::get(IntTy, 0), getIntSize(),
                   "block.reserved");
  } else {
    addHeaderField(
        llvm::ConstantInt::get(IntTy, blockInfo.BlockSize.getQuantity()),
        getIntSize(), "block.size");
    addHeaderField(
        llvm::ConstantInt::get(IntTy, blockInfo.BlockAlign.getQuantity()),
        getIntSize(), "block.align");
  }
  addHeaderField(blockFn, GenVoidPtrSize, "block.invoke");
  if (!IsOpenCL)
    addHeaderField(descriptor, getPointerSize(), "block.descriptor");
  else if (auto *Helper =
               CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) {
    for (auto I : Helper->getCustomFieldValues(*this, blockInfo)) {
      addHeaderField(
          I.first,
          CharUnits::fromQuantity(
              CGM.getDataLayout().getTypeAllocSize(I.first->getType())),
          I.second);
    }
  }
}

// Finally, capture all the values into the block.
const BlockDecl *blockDecl = blockInfo.getBlockDecl();

// First, 'this'.
if (blockDecl->capturesCXXThis()) {
  Address addr =
      projectField(blockInfo.CXXThisIndex, "block.captured-this.addr");
  Builder.CreateStore(LoadCXXThis(), addr);
}

// Next, captured variables.
for (const auto &CI : blockDecl->captures()) {
  const VarDecl *variable = CI.getVariable();
  const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);

  // Ignore constant captures.
  if (capture.isConstant()) continue;

  QualType type = capture.fieldType();

  // This will be a [[type]]*, except that a byref entry will just be
  // an i8**.
  Address blockField = projectField(capture.getIndex(), "block.captured");

  // Compute the address of the thing we're going to move into the
  // block literal.
  Address src = Address::invalid();

  if (blockDecl->isConversionFromLambda()) {
    // The lambda capture in a lambda's conversion-to-block-pointer is
    // special; we'll simply emit it directly.
    src = Address::invalid();
  } else if (CI.isEscapingByref()) {
    if (BlockInfo && CI.isNested()) {
      // We need to use the capture from the enclosing block.
      const CGBlockInfo::Capture &enclosingCapture =
          BlockInfo->getCapture(variable);

      // This is a [[type]]*, except that a byref entry will just be an i8**.
      src = Builder.CreateStructGEP(LoadBlockStruct(),
                                    enclosingCapture.getIndex(),
                                    "block.capture.addr");
    } else {
      auto I = LocalDeclMap.find(variable);
      assert(I != LocalDeclMap.end())(static_cast <bool> (I != LocalDeclMap.end()) ? void (0
) : __assert_fail ("I != LocalDeclMap.end()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 943, __extension__ __PRETTY_FUNCTION__));
      src = I->second;
    }
  } else {
    DeclRefExpr declRef(getContext(), const_cast<VarDecl *>(variable),
                        /*RefersToEnclosingVariableOrCapture*/ CI.isNested(),
                        type.getNonReferenceType(), VK_LValue,
                        SourceLocation());
    src = EmitDeclRefLValue(&declRef).getAddress(*this);
  };

  // For byrefs, we just write the pointer to the byref struct into
  // the block field.  There's no need to chase the forwarding
  // pointer at this point, since we're building something that will
  // live a shorter life than the stack byref anyway.
  if (CI.isEscapingByref()) {
    // Get a void* that points to the byref struct.
    llvm::Value *byrefPointer;
    if (CI.isNested())
      byrefPointer = Builder.CreateLoad(src, "byref.capture");
    else
      byrefPointer = Builder.CreateBitCast(src.getPointer(), VoidPtrTy);

    // Write that void* into the capture field.
    Builder.CreateStore(byrefPointer, blockField);

  // If we have a copy constructor, evaluate that into the block field.
  } else if (const Expr *copyExpr = CI.getCopyExpr()) {
    if (blockDecl->isConversionFromLambda()) {
      // If we have a lambda conversion, emit the expression
      // directly into the block instead.
      AggValueSlot Slot =
          AggValueSlot::forAddr(blockField, Qualifiers(),
                                AggValueSlot::IsDestructed,
                                AggValueSlot::DoesNotNeedGCBarriers,
                                AggValueSlot::IsNotAliased,
                                AggValueSlot::DoesNotOverlap);
      EmitAggExpr(copyExpr, Slot);
    } else {
      EmitSynthesizedCXXCopyCtor(blockField, src, copyExpr);
    }

  // If it's a reference variable, copy the reference into the block field.
  } else if (type->isReferenceType()) {
    Builder.CreateStore(src.getPointer(), blockField);

  // If type is const-qualified, copy the value into the block field.
  } else if (type.isConstQualified() &&
             type.getObjCLifetime() == Qualifiers::OCL_Strong &&
             CGM.getCodeGenOpts().OptimizationLevel != 0) {
    llvm::Value *value = Builder.CreateLoad(src, "captured");
    Builder.CreateStore(value, blockField);

  // If this is an ARC __strong block-pointer variable, don't do a
  // block copy.
  //
  // TODO: this can be generalized into the normal initialization logic:
  // we should never need to do a block-copy when initializing a local
  // variable, because the local variable's lifetime should be strictly
  // contained within the stack block's.
  } else if (type.getObjCLifetime() == Qualifiers::OCL_Strong &&
             type->isBlockPointerType()) {
    // Load the block and do a simple retain.
    llvm::Value *value = Builder.CreateLoad(src, "block.captured_block");
    value = EmitARCRetainNonBlock(value);

    // Do a primitive store to the block field.
    Builder.CreateStore(value, blockField);

  // Otherwise, fake up a POD copy into the block field.
  } else {
    // Fake up a new variable so that EmitScalarInit doesn't think
    // we're referring to the variable in its own initializer.
    ImplicitParamDecl BlockFieldPseudoVar(getContext(), type,
                                          ImplicitParamDecl::Other);

    // We use one of these or the other depending on whether the
    // reference is nested.
    DeclRefExpr declRef(getContext(), const_cast<VarDecl *>(variable),
                        /*RefersToEnclosingVariableOrCapture*/ CI.isNested(),
                        type, VK_LValue, SourceLocation());

    ImplicitCastExpr l2r(ImplicitCastExpr::OnStack, type, CK_LValueToRValue,
                         &declRef, VK_PRValue, FPOptionsOverride());
    // FIXME: Pass a specific location for the expr init so that the store is
    // attributed to a reasonable location - otherwise it may be attributed to
    // locations of subexpressions in the initialization.
    EmitExprAsInit(&l2r, &BlockFieldPseudoVar,
                   MakeAddrLValue(blockField, type, AlignmentSource::Decl),
                   /*captured by init*/ false);
  }

  // Push a cleanup for the capture if necessary.
  if (!blockInfo.NeedsCopyDispose)
    continue;

  // Ignore __block captures; there's nothing special in the on-stack block
  // that we need to do for them.
  if (CI.isByRef())
    continue;

  // Ignore objects that aren't destructed.
  QualType::DestructionKind dtorKind = type.isDestructedType();
  if (dtorKind == QualType::DK_none)
    continue;

  CodeGenFunction::Destroyer *destroyer;

  // Block captures count as local values and have imprecise semantics.
  // They also can't be arrays, so need to worry about that.
  //
  // For const-qualified captures, emit clang.arc.use to ensure the captured
  // object doesn't get released while we are still depending on its validity
  // within the block.
  if (type.isConstQualified() &&
      type.getObjCLifetime() == Qualifiers::OCL_Strong &&
      CGM.getCodeGenOpts().OptimizationLevel != 0) {
    assert(CGM.getLangOpts().ObjCAutoRefCount &&(static_cast <bool> (CGM.getLangOpts().ObjCAutoRefCount
 && "expected ObjC ARC to be enabled") ? void (0) : __assert_fail
 ("CGM.getLangOpts().ObjCAutoRefCount && \"expected ObjC ARC to be enabled\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1061, __extension__ __PRETTY_FUNCTION__))
           "expected ObjC ARC to be enabled")(static_cast <bool> (CGM.getLangOpts().ObjCAutoRefCount
 && "expected ObjC ARC to be enabled") ? void (0) : __assert_fail
 ("CGM.getLangOpts().ObjCAutoRefCount && \"expected ObjC ARC to be enabled\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1061, __extension__ __PRETTY_FUNCTION__));
    destroyer = emitARCIntrinsicUse;
  } else if (dtorKind == QualType::DK_objc_strong_lifetime) {
    destroyer = destroyARCStrongImprecise;
  } else {
    destroyer = getDestroyer(dtorKind);
  }

  CleanupKind cleanupKind = NormalCleanup;
  bool useArrayEHCleanup = needsEHCleanup(dtorKind);
  if (useArrayEHCleanup)
    cleanupKind = NormalAndEHCleanup;

  // Extend the lifetime of the capture to the end of the scope enclosing the
  // block expression except when the block decl is in the list of RetExpr's
  // cleanup objects, in which case its lifetime ends after the full
  // expression.
  auto IsBlockDeclInRetExpr = [&]() {
    auto *EWC = llvm::dyn_cast_or_null<ExprWithCleanups>(RetExpr);
    if (EWC)
      for (auto &C : EWC->getObjects())
        if (auto *BD = C.dyn_cast<BlockDecl *>())
          if (BD == blockDecl)
            return true;
    return false;
  };

  if (IsBlockDeclInRetExpr())
    pushDestroy(cleanupKind, blockField, type, destroyer, useArrayEHCleanup);
  else
    pushLifetimeExtendedDestroy(cleanupKind, blockField, type, destroyer,
                                useArrayEHCleanup);
}

// Cast to the converted block-pointer type, which happens (somewhat
// unfortunately) to be a pointer to function type.
llvm::Value *result = Builder.CreatePointerCast(
    blockAddr.getPointer(), ConvertType(blockInfo.getBlockExpr()->getType()));

if (IsOpenCL) {
  CGM.getOpenCLRuntime().recordBlockInfo(blockInfo.BlockExpression, InvokeFn,
                                         result);
}

return result;
1106}


1109llvm::Type *CodeGenModule::getBlockDescriptorType() {
if (BlockDescriptorType)
  return BlockDescriptorType;

llvm::Type *UnsignedLongTy =
  getTypes().ConvertType(getContext().UnsignedLongTy);

// struct __block_descriptor {
//   unsigned long reserved;
//   unsigned long block_size;
//
//   // later, the following will be added
//
//   struct {
//     void (*copyHelper)();
//     void (*copyHelper)();
//   } helpers;                // !!! optional
//
//   const char *signature;   // the block signature
//   const char *layout;      // reserved
// };
BlockDescriptorType = llvm::StructType::create(
    "struct.__block_descriptor", UnsignedLongTy, UnsignedLongTy);

// Now form a pointer to that.
unsigned AddrSpace = 0;
if (getLangOpts().OpenCL)
  AddrSpace = getContext().getTargetAddressSpace(LangAS::opencl_constant);
BlockDescriptorType = llvm::PointerType::get(BlockDescriptorType, AddrSpace);
return BlockDescriptorType;
1139}

1141llvm::Type *CodeGenModule::getGenericBlockLiteralType() {
if (GenericBlockLiteralType)
  return GenericBlockLiteralType;

llvm::Type *BlockDescPtrTy = getBlockDescriptorType();

if (getLangOpts().OpenCL) {
  // struct __opencl_block_literal_generic {
  //   int __size;
  //   int __align;
  //   __generic void *__invoke;
  //   /* custom fields */
  // };
  SmallVector<llvm::Type *, 8> StructFields(
      {IntTy, IntTy, getOpenCLRuntime().getGenericVoidPointerType()});
  if (auto *Helper = getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) {
    for (auto I : Helper->getCustomFieldTypes())
      StructFields.push_back(I);
  }
  GenericBlockLiteralType = llvm::StructType::create(
      StructFields, "struct.__opencl_block_literal_generic");
} else {
  // struct __block_literal_generic {
  //   void *__isa;
  //   int __flags;
  //   int __reserved;
  //   void (*__invoke)(void *);
  //   struct __block_descriptor *__descriptor;
  // };
  GenericBlockLiteralType =
      llvm::StructType::create("struct.__block_literal_generic", VoidPtrTy,
                               IntTy, IntTy, VoidPtrTy, BlockDescPtrTy);
}

return GenericBlockLiteralType;
1176}

1178RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E,
                                        ReturnValueSlot ReturnValue) {
const auto *BPT = E->getCallee()->getType()->castAs<BlockPointerType>();
llvm::Value *BlockPtr = EmitScalarExpr(E->getCallee());
llvm::Type *GenBlockTy = CGM.getGenericBlockLiteralType();
llvm::Value *Func = nullptr;
QualType FnType = BPT->getPointeeType();
ASTContext &Ctx = getContext();
CallArgList Args;

if (getLangOpts().OpenCL) {
  // For OpenCL, BlockPtr is already casted to generic block literal.

  // First argument of a block call is a generic block literal casted to
  // generic void pointer, i.e. i8 addrspace(4)*
  llvm::Type *GenericVoidPtrTy =
      CGM.getOpenCLRuntime().getGenericVoidPointerType();
  llvm::Value *BlockDescriptor = Builder.CreatePointerCast(
      BlockPtr, GenericVoidPtrTy);
  QualType VoidPtrQualTy = Ctx.getPointerType(
      Ctx.getAddrSpaceQualType(Ctx.VoidTy, LangAS::opencl_generic));
  Args.add(RValue::get(BlockDescriptor), VoidPtrQualTy);
  // And the rest of the arguments.
  EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(), E->arguments());

  // We *can* call the block directly unless it is a function argument.
  if (!isa<ParmVarDecl>(E->getCalleeDecl()))
    Func = CGM.getOpenCLRuntime().getInvokeFunction(E->getCallee());
  else {
    llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 2);
    Func = Builder.CreateAlignedLoad(GenericVoidPtrTy, FuncPtr,
                                     getPointerAlign());
  }
} else {
  // Bitcast the block literal to a generic block literal.
  BlockPtr = Builder.CreatePointerCast(
      BlockPtr, llvm::PointerType::get(GenBlockTy, 0), "block.literal");
  // Get pointer to the block invoke function
  llvm::Value *FuncPtr = Builder.CreateStructGEP(GenBlockTy, BlockPtr, 3);

  // First argument is a block literal casted to a void pointer
  BlockPtr = Builder.CreatePointerCast(BlockPtr, VoidPtrTy);
  Args.add(RValue::get(BlockPtr), Ctx.VoidPtrTy);
  // And the rest of the arguments.
  EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(), E->arguments());

  // Load the function.
  Func = Builder.CreateAlignedLoad(VoidPtrTy, FuncPtr, getPointerAlign());
}

const FunctionType *FuncTy = FnType->castAs<FunctionType>();
const CGFunctionInfo &FnInfo =
  CGM.getTypes().arrangeBlockFunctionCall(Args, FuncTy);

// Cast the function pointer to the right type.
llvm::Type *BlockFTy = CGM.getTypes().GetFunctionType(FnInfo);

llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy);
Func = Builder.CreatePointerCast(Func, BlockFTyPtr);

// Prepare the callee.
CGCallee Callee(CGCalleeInfo(), Func);

// And call the block.
return EmitCall(FnInfo, Callee, ReturnValue, Args);
1243}

1245Address CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable) {
assert(BlockInfo && "evaluating block ref without block information?")(static_cast <bool> (BlockInfo && "evaluating block ref without block information?"
) ? void (0) : __assert_fail ("BlockInfo && \"evaluating block ref without block information?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1246, __extension__ __PRETTY_FUNCTION__));
const CGBlockInfo::Capture &capture = BlockInfo->getCapture(variable);

// Handle constant captures.
if (capture.isConstant()) return LocalDeclMap.find(variable)->second;

Address addr = Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(),
                                       "block.capture.addr");

if (variable->isEscapingByref()) {
  // addr should be a void** right now.  Load, then cast the result
  // to byref*.

  auto &byrefInfo = getBlockByrefInfo(variable);
  addr = Address(Builder.CreateLoad(addr), byrefInfo.ByrefAlignment);

  auto byrefPointerType = llvm::PointerType::get(byrefInfo.Type, 0);
  addr = Builder.CreateBitCast(addr, byrefPointerType, "byref.addr");

  addr = emitBlockByrefAddress(addr, byrefInfo, /*follow*/ true,
                               variable->getName());
}

assert((!variable->isNonEscapingByref() ||(static_cast <bool> ((!variable->isNonEscapingByref(
) || capture.fieldType()->isReferenceType()) && "the capture field of a non-escaping variable should have a "
 "reference type") ? void (0) : __assert_fail ("(!variable->isNonEscapingByref() || capture.fieldType()->isReferenceType()) && \"the capture field of a non-escaping variable should have a \" \"reference type\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1272, __extension__ __PRETTY_FUNCTION__))
        capture.fieldType()->isReferenceType()) &&(static_cast <bool> ((!variable->isNonEscapingByref(
) || capture.fieldType()->isReferenceType()) && "the capture field of a non-escaping variable should have a "
 "reference type") ? void (0) : __assert_fail ("(!variable->isNonEscapingByref() || capture.fieldType()->isReferenceType()) && \"the capture field of a non-escaping variable should have a \" \"reference type\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1272, __extension__ __PRETTY_FUNCTION__))
       "the capture field of a non-escaping variable should have a "(static_cast <bool> ((!variable->isNonEscapingByref(
) || capture.fieldType()->isReferenceType()) && "the capture field of a non-escaping variable should have a "
 "reference type") ? void (0) : __assert_fail ("(!variable->isNonEscapingByref() || capture.fieldType()->isReferenceType()) && \"the capture field of a non-escaping variable should have a \" \"reference type\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1272, __extension__ __PRETTY_FUNCTION__))
       "reference type")(static_cast <bool> ((!variable->isNonEscapingByref(
) || capture.fieldType()->isReferenceType()) && "the capture field of a non-escaping variable should have a "
 "reference type") ? void (0) : __assert_fail ("(!variable->isNonEscapingByref() || capture.fieldType()->isReferenceType()) && \"the capture field of a non-escaping variable should have a \" \"reference type\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1272, __extension__ __PRETTY_FUNCTION__));
if (capture.fieldType()->isReferenceType())
  addr = EmitLoadOfReference(MakeAddrLValue(addr, capture.fieldType()));

return addr;
1277}

1279void CodeGenModule::setAddrOfGlobalBlock(const BlockExpr *BE,
                                       llvm::Constant *Addr) {
bool Ok = EmittedGlobalBlocks.insert(std::make_pair(BE, Addr)).second;
(void)Ok;
assert(Ok && "Trying to replace an already-existing global block!")(static_cast <bool> (Ok && "Trying to replace an already-existing global block!"
) ? void (0) : __assert_fail ("Ok && \"Trying to replace an already-existing global block!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1283, __extension__ __PRETTY_FUNCTION__));
1284}

1286llvm::Constant *
1287CodeGenModule::GetAddrOfGlobalBlock(const BlockExpr *BE,
                                  StringRef Name) {
if (llvm::Constant *Block = getAddrOfGlobalBlockIfEmitted(BE))
1
Assuming 'Block' is null→
2
←
Taking false branch→
  return Block;

CGBlockInfo blockInfo(BE->getBlockDecl(), Name);
blockInfo.BlockExpression = BE;

// Compute information about the layout, etc., of this block.
computeBlockInfo(*this, nullptr, blockInfo);
3
←
Passing null pointer value via 2nd parameter 'CGF'→
4
←
Calling 'computeBlockInfo'→

// Using that metadata, generate the actual block function.
{
  CodeGenFunction::DeclMapTy LocalDeclMap;
  CodeGenFunction(*this).GenerateBlockFunction(
      GlobalDecl(), blockInfo, LocalDeclMap,
      /*IsLambdaConversionToBlock*/ false, /*BuildGlobalBlock*/ true);
}

return getAddrOfGlobalBlockIfEmitted(BE);
1307}

1309static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM,
                                      const CGBlockInfo &blockInfo,
                                      llvm::Constant *blockFn) {
assert(blockInfo.CanBeGlobal)(static_cast <bool> (blockInfo.CanBeGlobal) ? void (0) :
 __assert_fail ("blockInfo.CanBeGlobal", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1312, __extension__ __PRETTY_FUNCTION__));
// Callers should detect this case on their own: calling this function
// generally requires computing layout information, which is a waste of time
// if we've already emitted this block.
assert(!CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression) &&(static_cast <bool> (!CGM.getAddrOfGlobalBlockIfEmitted
(blockInfo.BlockExpression) && "Refusing to re-emit a global block."
) ? void (0) : __assert_fail ("!CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression) && \"Refusing to re-emit a global block.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1317, __extension__ __PRETTY_FUNCTION__))
       "Refusing to re-emit a global block.")(static_cast <bool> (!CGM.getAddrOfGlobalBlockIfEmitted
(blockInfo.BlockExpression) && "Refusing to re-emit a global block."
) ? void (0) : __assert_fail ("!CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression) && \"Refusing to re-emit a global block.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1317, __extension__ __PRETTY_FUNCTION__));

// Generate the constants for the block literal initializer.
ConstantInitBuilder builder(CGM);
auto fields = builder.beginStruct();

bool IsOpenCL = CGM.getLangOpts().OpenCL;
bool IsWindows = CGM.getTarget().getTriple().isOSWindows();
if (!IsOpenCL) {
  // isa
  if (IsWindows)
    fields.addNullPointer(CGM.Int8PtrPtrTy);
  else
    fields.add(CGM.getNSConcreteGlobalBlock());

  // __flags
  BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE;
  if (blockInfo.UsesStret)
    flags |= BLOCK_USE_STRET;

  fields.addInt(CGM.IntTy, flags.getBitMask());

  // Reserved
  fields.addInt(CGM.IntTy, 0);
} else {
  fields.addInt(CGM.IntTy, blockInfo.BlockSize.getQuantity());
  fields.addInt(CGM.IntTy, blockInfo.BlockAlign.getQuantity());
}

// Function
fields.add(blockFn);

if (!IsOpenCL) {
  // Descriptor
  fields.add(buildBlockDescriptor(CGM, blockInfo));
} else if (auto *Helper =
               CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) {
  for (auto I : Helper->getCustomFieldValues(CGM, blockInfo)) {
    fields.add(I);
  }
}

unsigned AddrSpace = 0;
if (CGM.getContext().getLangOpts().OpenCL)
  AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_global);

llvm::GlobalVariable *literal = fields.finishAndCreateGlobal(
    "__block_literal_global", blockInfo.BlockAlign,
    /*constant*/ !IsWindows, llvm::GlobalVariable::InternalLinkage, AddrSpace);

literal->addAttribute("objc_arc_inert");

// Windows does not allow globals to be initialised to point to globals in
// different DLLs.  Any such variables must run code to initialise them.
if (IsWindows) {
  auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
        {}), llvm::GlobalValue::InternalLinkage, ".block_isa_init",
      &CGM.getModule());
  llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry",
        Init));
  b.CreateAlignedStore(CGM.getNSConcreteGlobalBlock(),
                       b.CreateStructGEP(literal->getValueType(), literal, 0),
                       CGM.getPointerAlign().getAsAlign());
  b.CreateRetVoid();
  // We can't use the normal LLVM global initialisation array, because we
  // need to specify that this runs early in library initialisation.
  auto *InitVar = new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
      /*isConstant*/true, llvm::GlobalValue::InternalLinkage,
      Init, ".block_isa_init_ptr");
  InitVar->setSection(".CRT$XCLa");
  CGM.addUsedGlobal(InitVar);
}

// Return a constant of the appropriately-casted type.
llvm::Type *RequiredType =
  CGM.getTypes().ConvertType(blockInfo.getBlockExpr()->getType());
llvm::Constant *Result =
    llvm::ConstantExpr::getPointerCast(literal, RequiredType);
CGM.setAddrOfGlobalBlock(blockInfo.BlockExpression, Result);
if (CGM.getContext().getLangOpts().OpenCL)
  CGM.getOpenCLRuntime().recordBlockInfo(
      blockInfo.BlockExpression,
      cast<llvm::Function>(blockFn->stripPointerCasts()), Result);
return Result;
1401}

1403void CodeGenFunction::setBlockContextParameter(const ImplicitParamDecl *D,
                                             unsigned argNum,
                                             llvm::Value *arg) {
assert(BlockInfo && "not emitting prologue of block invocation function?!")(static_cast <bool> (BlockInfo && "not emitting prologue of block invocation function?!"
) ? void (0) : __assert_fail ("BlockInfo && \"not emitting prologue of block invocation function?!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1406, __extension__ __PRETTY_FUNCTION__));

// Allocate a stack slot like for any local variable to guarantee optimal
// debug info at -O0. The mem2reg pass will eliminate it when optimizing.
Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr");
Builder.CreateStore(arg, alloc);
if (CGDebugInfo *DI = getDebugInfo()) {
  if (CGM.getCodeGenOpts().hasReducedDebugInfo()) {
    DI->setLocation(D->getLocation());
    DI->EmitDeclareOfBlockLiteralArgVariable(
        *BlockInfo, D->getName(), argNum,
        cast<llvm::AllocaInst>(alloc.getPointer()), Builder);
  }
}

SourceLocation StartLoc = BlockInfo->getBlockExpr()->getBody()->getBeginLoc();
ApplyDebugLocation Scope(*this, StartLoc);

// Instead of messing around with LocalDeclMap, just set the value
// directly as BlockPointer.
BlockPointer = Builder.CreatePointerCast(
    arg,
    BlockInfo->StructureType->getPointerTo(
        getContext().getLangOpts().OpenCL
            ? getContext().getTargetAddressSpace(LangAS::opencl_generic)
            : 0),
    "block");
1433}

1435Address CodeGenFunction::LoadBlockStruct() {
assert(BlockInfo && "not in a block invocation function!")(static_cast <bool> (BlockInfo && "not in a block invocation function!"
) ? void (0) : __assert_fail ("BlockInfo && \"not in a block invocation function!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1436, __extension__ __PRETTY_FUNCTION__));
assert(BlockPointer && "no block pointer set!")(static_cast <bool> (BlockPointer && "no block pointer set!"
) ? void (0) : __assert_fail ("BlockPointer && \"no block pointer set!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1437, __extension__ __PRETTY_FUNCTION__));
return Address(BlockPointer, BlockInfo->BlockAlign);
1439}

1441llvm::Function *
1442CodeGenFunction::GenerateBlockFunction(GlobalDecl GD,
                                     const CGBlockInfo &blockInfo,
                                     const DeclMapTy &ldm,
                                     bool IsLambdaConversionToBlock,
                                     bool BuildGlobalBlock) {
const BlockDecl *blockDecl = blockInfo.getBlockDecl();

CurGD = GD;

CurEHLocation = blockInfo.getBlockExpr()->getEndLoc();

BlockInfo = &blockInfo;

// Arrange for local static and local extern declarations to appear
// to be local to this function as well, in case they're directly
// referenced in a block.
for (DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) {
  const auto *var = dyn_cast<VarDecl>(i->first);
  if (var && !var->hasLocalStorage())
    setAddrOfLocalVar(var, i->second);
}

// Begin building the function declaration.

// Build the argument list.
FunctionArgList args;

// The first argument is the block pointer.  Just take it as a void*
// and cast it later.
QualType selfTy = getContext().VoidPtrTy;

// For OpenCL passed block pointer can be private AS local variable or
// global AS program scope variable (for the case with and without captures).
// Generic AS is used therefore to be able to accommodate both private and
// generic AS in one implementation.
if (getLangOpts().OpenCL)
  selfTy = getContext().getPointerType(getContext().getAddrSpaceQualType(
      getContext().VoidTy, LangAS::opencl_generic));

IdentifierInfo *II = &CGM.getContext().Idents.get(".block_descriptor");

ImplicitParamDecl SelfDecl(getContext(), const_cast<BlockDecl *>(blockDecl),
                           SourceLocation(), II, selfTy,
                           ImplicitParamDecl::ObjCSelf);
args.push_back(&SelfDecl);

// Now add the rest of the parameters.
args.append(blockDecl->param_begin(), blockDecl->param_end());

// Create the function declaration.
const FunctionProtoType *fnType = blockInfo.getBlockExpr()->getFunctionType();
const CGFunctionInfo &fnInfo =
  CGM.getTypes().arrangeBlockFunctionDeclaration(fnType, args);
if (CGM.ReturnSlotInterferesWithArgs(fnInfo))
  blockInfo.UsesStret = true;

llvm::FunctionType *fnLLVMType = CGM.getTypes().GetFunctionType(fnInfo);

StringRef name = CGM.getBlockMangledName(GD, blockDecl);
llvm::Function *fn = llvm::Function::Create(
    fnLLVMType, llvm::GlobalValue::InternalLinkage, name, &CGM.getModule());
CGM.SetInternalFunctionAttributes(blockDecl, fn, fnInfo);

if (BuildGlobalBlock) {
  auto GenVoidPtrTy = getContext().getLangOpts().OpenCL
                          ? CGM.getOpenCLRuntime().getGenericVoidPointerType()
                          : VoidPtrTy;
  buildGlobalBlock(CGM, blockInfo,
                   llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy));
}

// Begin generating the function.
StartFunction(blockDecl, fnType->getReturnType(), fn, fnInfo, args,
              blockDecl->getLocation(),
              blockInfo.getBlockExpr()->getBody()->getBeginLoc());

// Okay.  Undo some of what StartFunction did.

// At -O0 we generate an explicit alloca for the BlockPointer, so the RA
// won't delete the dbg.declare intrinsics for captured variables.
llvm::Value *BlockPointerDbgLoc = BlockPointer;
if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
  // Allocate a stack slot for it, so we can point the debugger to it
  Address Alloca = CreateTempAlloca(BlockPointer->getType(),
                                    getPointerAlign(),
                                    "block.addr");
  // Set the DebugLocation to empty, so the store is recognized as a
  // frame setup instruction by llvm::DwarfDebug::beginFunction().
  auto NL = ApplyDebugLocation::CreateEmpty(*this);
  Builder.CreateStore(BlockPointer, Alloca);
  BlockPointerDbgLoc = Alloca.getPointer();
}

// If we have a C++ 'this' reference, go ahead and force it into
// existence now.
if (blockDecl->capturesCXXThis()) {
  Address addr = Builder.CreateStructGEP(
      LoadBlockStruct(), blockInfo.CXXThisIndex, "block.captured-this");
  CXXThisValue = Builder.CreateLoad(addr, "this");
}

// Also force all the constant captures.
for (const auto &CI : blockDecl->captures()) {
  const VarDecl *variable = CI.getVariable();
  const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
  if (!capture.isConstant()) continue;

  CharUnits align = getContext().getDeclAlign(variable);
  Address alloca =
    CreateMemTemp(variable->getType(), align, "block.captured-const");

  Builder.CreateStore(capture.getConstant(), alloca);

  setAddrOfLocalVar(variable, alloca);
}

// Save a spot to insert the debug information for all the DeclRefExprs.
llvm::BasicBlock *entry = Builder.GetInsertBlock();
llvm::BasicBlock::iterator entry_ptr = Builder.GetInsertPoint();
--entry_ptr;

if (IsLambdaConversionToBlock)
  EmitLambdaBlockInvokeBody();
else {
  PGO.assignRegionCounters(GlobalDecl(blockDecl), fn);
  incrementProfileCounter(blockDecl->getBody());
  EmitStmt(blockDecl->getBody());
}

// Remember where we were...
llvm::BasicBlock *resume = Builder.GetInsertBlock();

// Go back to the entry.
++entry_ptr;
Builder.SetInsertPoint(entry, entry_ptr);

// Emit debug information for all the DeclRefExprs.
// FIXME: also for 'this'
if (CGDebugInfo *DI = getDebugInfo()) {
  for (const auto &CI : blockDecl->captures()) {
    const VarDecl *variable = CI.getVariable();
    DI->EmitLocation(Builder, variable->getLocation());

    if (CGM.getCodeGenOpts().hasReducedDebugInfo()) {
      const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
      if (capture.isConstant()) {
        auto addr = LocalDeclMap.find(variable)->second;
        (void)DI->EmitDeclareOfAutoVariable(variable, addr.getPointer(),
                                            Builder);
        continue;
      }

      DI->EmitDeclareOfBlockDeclRefVariable(
          variable, BlockPointerDbgLoc, Builder, blockInfo,
          entry_ptr == entry->end() ? nullptr : &*entry_ptr);
    }
  }
  // Recover location if it was changed in the above loop.
  DI->EmitLocation(Builder,
                   cast<CompoundStmt>(blockDecl->getBody())->getRBracLoc());
}

// And resume where we left off.
if (resume == nullptr)
  Builder.ClearInsertionPoint();
else
  Builder.SetInsertPoint(resume);

FinishFunction(cast<CompoundStmt>(blockDecl->getBody())->getRBracLoc());

return fn;
1613}

1615static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
1616computeCopyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T,
                             const LangOptions &LangOpts) {
if (CI.getCopyExpr()) {
  assert(!CI.isByRef())(static_cast <bool> (!CI.isByRef()) ? void (0) : __assert_fail
 ("!CI.isByRef()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1619, __extension__ __PRETTY_FUNCTION__));
  // don't bother computing flags
  return std::make_pair(BlockCaptureEntityKind::CXXRecord, BlockFieldFlags());
}
BlockFieldFlags Flags;
if (CI.isEscapingByref()) {
  Flags = BLOCK_FIELD_IS_BYREF;
  if (T.isObjCGCWeak())
    Flags |= BLOCK_FIELD_IS_WEAK;
  return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags);
}

Flags = BLOCK_FIELD_IS_OBJECT;
bool isBlockPointer = T->isBlockPointerType();
if (isBlockPointer)
  Flags = BLOCK_FIELD_IS_BLOCK;

switch (T.isNonTrivialToPrimitiveCopy()) {
case QualType::PCK_Struct:
  return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct,
                        BlockFieldFlags());
case QualType::PCK_ARCWeak:
  // We need to register __weak direct captures with the runtime.
  return std::make_pair(BlockCaptureEntityKind::ARCWeak, Flags);
case QualType::PCK_ARCStrong:
  // We need to retain the copied value for __strong direct captures.
  // If it's a block pointer, we have to copy the block and assign that to
  // the destination pointer, so we might as well use _Block_object_assign.
  // Otherwise we can avoid that.
  return std::make_pair(!isBlockPointer ? BlockCaptureEntityKind::ARCStrong
                                        : BlockCaptureEntityKind::BlockObject,
                        Flags);
case QualType::PCK_Trivial:
case QualType::PCK_VolatileTrivial: {
  if (!T->isObjCRetainableType())
    // For all other types, the memcpy is fine.
    return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags());

  // Special rules for ARC captures:
  Qualifiers QS = T.getQualifiers();

  // Non-ARC captures of retainable pointers are strong and
  // therefore require a call to _Block_object_assign.
  if (!QS.getObjCLifetime() && !LangOpts.ObjCAutoRefCount)
    return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags);

  // Otherwise the memcpy is fine.
  return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags());
}
}
llvm_unreachable("after exhaustive PrimitiveCopyKind switch")::llvm::llvm_unreachable_internal("after exhaustive PrimitiveCopyKind switch"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1669);
1670}

1672static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
1673computeDestroyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T,
                                const LangOptions &LangOpts);

1676/// Find the set of block captures that need to be explicitly copied or destroy.
1677static void findBlockCapturedManagedEntities(
  const CGBlockInfo &BlockInfo, const LangOptions &LangOpts,
  SmallVectorImpl<BlockCaptureManagedEntity> &ManagedCaptures) {
for (const auto &CI : BlockInfo.getBlockDecl()->captures()) {
  const VarDecl *Variable = CI.getVariable();
  const CGBlockInfo::Capture &Capture = BlockInfo.getCapture(Variable);
  if (Capture.isConstant())
    continue;

  QualType VT = Capture.fieldType();
  auto CopyInfo = computeCopyInfoForBlockCapture(CI, VT, LangOpts);
  auto DisposeInfo = computeDestroyInfoForBlockCapture(CI, VT, LangOpts);
  if (CopyInfo.first != BlockCaptureEntityKind::None ||
      DisposeInfo.first != BlockCaptureEntityKind::None)
    ManagedCaptures.emplace_back(CopyInfo.first, DisposeInfo.first,
                                 CopyInfo.second, DisposeInfo.second, CI,
                                 Capture);
}

// Sort the captures by offset.
llvm::sort(ManagedCaptures);
1698}

1700namespace {
1701/// Release a __block variable.
1702struct CallBlockRelease final : EHScopeStack::Cleanup {
Address Addr;
BlockFieldFlags FieldFlags;
bool LoadBlockVarAddr, CanThrow;

CallBlockRelease(Address Addr, BlockFieldFlags Flags, bool LoadValue,
                 bool CT)
    : Addr(Addr), FieldFlags(Flags), LoadBlockVarAddr(LoadValue),
      CanThrow(CT) {}

void Emit(CodeGenFunction &CGF, Flags flags) override {
  llvm::Value *BlockVarAddr;
  if (LoadBlockVarAddr) {
    BlockVarAddr = CGF.Builder.CreateLoad(Addr);
    BlockVarAddr = CGF.Builder.CreateBitCast(BlockVarAddr, CGF.VoidPtrTy);
  } else {
    BlockVarAddr = Addr.getPointer();
  }

  CGF.BuildBlockRelease(BlockVarAddr, FieldFlags, CanThrow);
}
1723};
1724} // end anonymous namespace

1726/// Check if \p T is a C++ class that has a destructor that can throw.
1727bool CodeGenFunction::cxxDestructorCanThrow(QualType T) {
if (const auto *RD = T->getAsCXXRecordDecl())
  if (const CXXDestructorDecl *DD = RD->getDestructor())
    return DD->getType()->castAs<FunctionProtoType>()->canThrow();
return false;
1732}

1734// Return a string that has the information about a capture.
1735static std::string getBlockCaptureStr(const BlockCaptureManagedEntity &E,
                                    CaptureStrKind StrKind,
                                    CharUnits BlockAlignment,
                                    CodeGenModule &CGM) {
std::string Str;
ASTContext &Ctx = CGM.getContext();
const BlockDecl::Capture &CI = *E.CI;
QualType CaptureTy = CI.getVariable()->getType();

BlockCaptureEntityKind Kind;
BlockFieldFlags Flags;

// CaptureStrKind::Merged should be passed only when the operations and the
// flags are the same for copy and dispose.
assert((StrKind != CaptureStrKind::Merged ||(static_cast <bool> ((StrKind != CaptureStrKind::Merged
 || (E.CopyKind == E.DisposeKind && E.CopyFlags == E.
DisposeFlags)) && "different operations and flags") ?
 void (0) : __assert_fail ("(StrKind != CaptureStrKind::Merged || (E.CopyKind == E.DisposeKind && E.CopyFlags == E.DisposeFlags)) && \"different operations and flags\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1751, __extension__ __PRETTY_FUNCTION__))
        (E.CopyKind == E.DisposeKind && E.CopyFlags == E.DisposeFlags)) &&(static_cast <bool> ((StrKind != CaptureStrKind::Merged
 || (E.CopyKind == E.DisposeKind && E.CopyFlags == E.
DisposeFlags)) && "different operations and flags") ?
 void (0) : __assert_fail ("(StrKind != CaptureStrKind::Merged || (E.CopyKind == E.DisposeKind && E.CopyFlags == E.DisposeFlags)) && \"different operations and flags\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1751, __extension__ __PRETTY_FUNCTION__))
       "different operations and flags")(static_cast <bool> ((StrKind != CaptureStrKind::Merged
 || (E.CopyKind == E.DisposeKind && E.CopyFlags == E.
DisposeFlags)) && "different operations and flags") ?
 void (0) : __assert_fail ("(StrKind != CaptureStrKind::Merged || (E.CopyKind == E.DisposeKind && E.CopyFlags == E.DisposeFlags)) && \"different operations and flags\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1751, __extension__ __PRETTY_FUNCTION__));

if (StrKind == CaptureStrKind::DisposeHelper) {
  Kind = E.DisposeKind;
  Flags = E.DisposeFlags;
} else {
  Kind = E.CopyKind;
  Flags = E.CopyFlags;
}

switch (Kind) {
case BlockCaptureEntityKind::CXXRecord: {
  Str += "c";
  SmallString<256> TyStr;
  llvm::raw_svector_ostream Out(TyStr);
  CGM.getCXXABI().getMangleContext().mangleTypeName(CaptureTy, Out);
  Str += llvm::to_string(TyStr.size()) + TyStr.c_str();
  break;
}
case BlockCaptureEntityKind::ARCWeak:
  Str += "w";
  break;
case BlockCaptureEntityKind::ARCStrong:
  Str += "s";
  break;
case BlockCaptureEntityKind::BlockObject: {
  const VarDecl *Var = CI.getVariable();
  unsigned F = Flags.getBitMask();
  if (F & BLOCK_FIELD_IS_BYREF) {
    Str += "r";
    if (F & BLOCK_FIELD_IS_WEAK)
      Str += "w";
    else {
      // If CaptureStrKind::Merged is passed, check both the copy expression
      // and the destructor.
      if (StrKind != CaptureStrKind::DisposeHelper) {
        if (Ctx.getBlockVarCopyInit(Var).canThrow())
          Str += "c";
      }
      if (StrKind != CaptureStrKind::CopyHelper) {
        if (CodeGenFunction::cxxDestructorCanThrow(CaptureTy))
          Str += "d";
      }
    }
  } else {
    assert((F & BLOCK_FIELD_IS_OBJECT) && "unexpected flag value")(static_cast <bool> ((F & BLOCK_FIELD_IS_OBJECT) &&
 "unexpected flag value") ? void (0) : __assert_fail ("(F & BLOCK_FIELD_IS_OBJECT) && \"unexpected flag value\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1796, __extension__ __PRETTY_FUNCTION__));
    if (F == BLOCK_FIELD_IS_BLOCK)
      Str += "b";
    else
      Str += "o";
  }
  break;
}
case BlockCaptureEntityKind::NonTrivialCStruct: {
  bool IsVolatile = CaptureTy.isVolatileQualified();
  CharUnits Alignment =
      BlockAlignment.alignmentAtOffset(E.Capture->getOffset());

  Str += "n";
  std::string FuncStr;
  if (StrKind == CaptureStrKind::DisposeHelper)
    FuncStr = CodeGenFunction::getNonTrivialDestructorStr(
        CaptureTy, Alignment, IsVolatile, Ctx);
  else
    // If CaptureStrKind::Merged is passed, use the copy constructor string.
    // It has all the information that the destructor string has.
    FuncStr = CodeGenFunction::getNonTrivialCopyConstructorStr(
        CaptureTy, Alignment, IsVolatile, Ctx);
  // The underscore is necessary here because non-trivial copy constructor
  // and destructor strings can start with a number.
  Str += llvm::to_string(FuncStr.size()) + "_" + FuncStr;
  break;
}
case BlockCaptureEntityKind::None:
  break;
}

return Str;
1829}

1831static std::string getCopyDestroyHelperFuncName(
  const SmallVectorImpl<BlockCaptureManagedEntity> &Captures,
  CharUnits BlockAlignment, CaptureStrKind StrKind, CodeGenModule &CGM) {
assert((StrKind == CaptureStrKind::CopyHelper ||(static_cast <bool> ((StrKind == CaptureStrKind::CopyHelper
 || StrKind == CaptureStrKind::DisposeHelper) && "unexpected CaptureStrKind"
) ? void (0) : __assert_fail ("(StrKind == CaptureStrKind::CopyHelper || StrKind == CaptureStrKind::DisposeHelper) && \"unexpected CaptureStrKind\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1836, __extension__ __PRETTY_FUNCTION__))
        StrKind == CaptureStrKind::DisposeHelper) &&(static_cast <bool> ((StrKind == CaptureStrKind::CopyHelper
 || StrKind == CaptureStrKind::DisposeHelper) && "unexpected CaptureStrKind"
) ? void (0) : __assert_fail ("(StrKind == CaptureStrKind::CopyHelper || StrKind == CaptureStrKind::DisposeHelper) && \"unexpected CaptureStrKind\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1836, __extension__ __PRETTY_FUNCTION__))
       "unexpected CaptureStrKind")(static_cast <bool> ((StrKind == CaptureStrKind::CopyHelper
 || StrKind == CaptureStrKind::DisposeHelper) && "unexpected CaptureStrKind"
) ? void (0) : __assert_fail ("(StrKind == CaptureStrKind::CopyHelper || StrKind == CaptureStrKind::DisposeHelper) && \"unexpected CaptureStrKind\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1836, __extension__ __PRETTY_FUNCTION__));
std::string Name = StrKind == CaptureStrKind::CopyHelper
                       ? "__copy_helper_block_"
                       : "__destroy_helper_block_";
if (CGM.getLangOpts().Exceptions)
  Name += "e";
if (CGM.getCodeGenOpts().ObjCAutoRefCountExceptions)
  Name += "a";
Name += llvm::to_string(BlockAlignment.getQuantity()) + "_";

for (const BlockCaptureManagedEntity &E : Captures) {
  Name += llvm::to_string(E.Capture->getOffset().getQuantity());
  Name += getBlockCaptureStr(E, StrKind, BlockAlignment, CGM);
}

return Name;
1852}

1854static void pushCaptureCleanup(BlockCaptureEntityKind CaptureKind,
                             Address Field, QualType CaptureType,
                             BlockFieldFlags Flags, bool ForCopyHelper,
                             VarDecl *Var, CodeGenFunction &CGF) {
bool EHOnly = ForCopyHelper;

switch (CaptureKind) {
case BlockCaptureEntityKind::CXXRecord:
case BlockCaptureEntityKind::ARCWeak:
case BlockCaptureEntityKind::NonTrivialCStruct:
case BlockCaptureEntityKind::ARCStrong: {
  if (CaptureType.isDestructedType() &&
      (!EHOnly || CGF.needsEHCleanup(CaptureType.isDestructedType()))) {
    CodeGenFunction::Destroyer *Destroyer =
        CaptureKind == BlockCaptureEntityKind::ARCStrong
            ? CodeGenFunction::destroyARCStrongImprecise
            : CGF.getDestroyer(CaptureType.isDestructedType());
    CleanupKind Kind =
        EHOnly ? EHCleanup
               : CGF.getCleanupKind(CaptureType.isDestructedType());
    CGF.pushDestroy(Kind, Field, CaptureType, Destroyer, Kind & EHCleanup);
  }
  break;
}
case BlockCaptureEntityKind::BlockObject: {
  if (!EHOnly || CGF.getLangOpts().Exceptions) {
    CleanupKind Kind = EHOnly ? EHCleanup : NormalAndEHCleanup;
    // Calls to _Block_object_dispose along the EH path in the copy helper
    // function don't throw as newly-copied __block variables always have a
    // reference count of 2.
    bool CanThrow =
        !ForCopyHelper && CGF.cxxDestructorCanThrow(CaptureType);
    CGF.enterByrefCleanup(Kind, Field, Flags, /*LoadBlockVarAddr*/ true,
                          CanThrow);
  }
  break;
}
case BlockCaptureEntityKind::None:
  break;
}
1894}

1896static void setBlockHelperAttributesVisibility(bool CapturesNonExternalType,
                                             llvm::Function *Fn,
                                             const CGFunctionInfo &FI,
                                             CodeGenModule &CGM) {
if (CapturesNonExternalType) {
  CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
} else {
  Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
  Fn->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
  CGM.SetLLVMFunctionAttributes(GlobalDecl(), FI, Fn, /*IsThunk=*/false);
  CGM.SetLLVMFunctionAttributesForDefinition(nullptr, Fn);
}
1908}
1909/// Generate the copy-helper function for a block closure object:
1910///   static void block_copy_helper(block_t *dst, block_t *src);
1911/// The runtime will have previously initialized 'dst' by doing a
1912/// bit-copy of 'src'.
1913///
1914/// Note that this copies an entire block closure object to the heap;
1915/// it should not be confused with a 'byref copy helper', which moves
1916/// the contents of an individual __block variable to the heap.
1917llvm::Constant *
1918CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) {
SmallVector<BlockCaptureManagedEntity, 4> CopiedCaptures;
findBlockCapturedManagedEntities(blockInfo, getLangOpts(), CopiedCaptures);
std::string FuncName =
    getCopyDestroyHelperFuncName(CopiedCaptures, blockInfo.BlockAlign,
                                 CaptureStrKind::CopyHelper, CGM);

if (llvm::GlobalValue *Func = CGM.getModule().getNamedValue(FuncName))
  return llvm::ConstantExpr::getBitCast(Func, VoidPtrTy);

ASTContext &C = getContext();

QualType ReturnTy = C.VoidTy;

FunctionArgList args;
ImplicitParamDecl DstDecl(C, C.VoidPtrTy, ImplicitParamDecl::Other);
args.push_back(&DstDecl);
ImplicitParamDecl SrcDecl(C, C.VoidPtrTy, ImplicitParamDecl::Other);
args.push_back(&SrcDecl);

const CGFunctionInfo &FI =
    CGM.getTypes().arrangeBuiltinFunctionDeclaration(ReturnTy, args);

// FIXME: it would be nice if these were mergeable with things with
// identical semantics.
llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);

llvm::Function *Fn =
  llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
                         FuncName, &CGM.getModule());
if (CGM.supportsCOMDAT())
  Fn->setComdat(CGM.getModule().getOrInsertComdat(FuncName));

SmallVector<QualType, 2> ArgTys;
ArgTys.push_back(C.VoidPtrTy);
ArgTys.push_back(C.VoidPtrTy);

setBlockHelperAttributesVisibility(blockInfo.CapturesNonExternalType, Fn, FI,
                                   CGM);
StartFunction(GlobalDecl(), ReturnTy, Fn, FI, args);
auto AL = ApplyDebugLocation::CreateArtificial(*this);

llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();

Address src = GetAddrOfLocalVar(&SrcDecl);
src = Address(Builder.CreateLoad(src), blockInfo.BlockAlign);
src = Builder.CreateBitCast(src, structPtrTy, "block.source");

Address dst = GetAddrOfLocalVar(&DstDecl);
dst = Address(Builder.CreateLoad(dst), blockInfo.BlockAlign);
dst = Builder.CreateBitCast(dst, structPtrTy, "block.dest");

for (const auto &CopiedCapture : CopiedCaptures) {
  const BlockDecl::Capture &CI = *CopiedCapture.CI;
  const CGBlockInfo::Capture &capture = *CopiedCapture.Capture;
  QualType captureType = CI.getVariable()->getType();
  BlockFieldFlags flags = CopiedCapture.CopyFlags;

  unsigned index = capture.getIndex();
  Address srcField = Builder.CreateStructGEP(src, index);
  Address dstField = Builder.CreateStructGEP(dst, index);

  switch (CopiedCapture.CopyKind) {
  case BlockCaptureEntityKind::CXXRecord:
    // If there's an explicit copy expression, we do that.
    assert(CI.getCopyExpr() && "copy expression for variable is missing")(static_cast <bool> (CI.getCopyExpr() && "copy expression for variable is missing"
) ? void (0) : __assert_fail ("CI.getCopyExpr() && \"copy expression for variable is missing\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 1983, __extension__ __PRETTY_FUNCTION__));
    EmitSynthesizedCXXCopyCtor(dstField, srcField, CI.getCopyExpr());
    break;
  case BlockCaptureEntityKind::ARCWeak:
    EmitARCCopyWeak(dstField, srcField);
    break;
  case BlockCaptureEntityKind::NonTrivialCStruct: {
    // If this is a C struct that requires non-trivial copy construction,
    // emit a call to its copy constructor.
    QualType varType = CI.getVariable()->getType();
    callCStructCopyConstructor(MakeAddrLValue(dstField, varType),
                               MakeAddrLValue(srcField, varType));
    break;
  }
  case BlockCaptureEntityKind::ARCStrong: {
    llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src");
    // At -O0, store null into the destination field (so that the
    // storeStrong doesn't over-release) and then call storeStrong.
    // This is a workaround to not having an initStrong call.
    if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
      auto *ty = cast<llvm::PointerType>(srcValue->getType());
      llvm::Value *null = llvm::ConstantPointerNull::get(ty);
      Builder.CreateStore(null, dstField);
      EmitARCStoreStrongCall(dstField, srcValue, true);

    // With optimization enabled, take advantage of the fact that
    // the blocks runtime guarantees a memcpy of the block data, and
    // just emit a retain of the src field.
    } else {
      EmitARCRetainNonBlock(srcValue);

      // Unless EH cleanup is required, we don't need this anymore, so kill
      // it. It's not quite worth the annoyance to avoid creating it in the
      // first place.
      if (!needsEHCleanup(captureType.isDestructedType()))
        cast<llvm::Instruction>(dstField.getPointer())->eraseFromParent();
    }
    break;
  }
  case BlockCaptureEntityKind::BlockObject: {
    llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src");
    srcValue = Builder.CreateBitCast(srcValue, VoidPtrTy);
    llvm::Value *dstAddr =
        Builder.CreateBitCast(dstField.getPointer(), VoidPtrTy);
    llvm::Value *args[] = {
      dstAddr, srcValue, llvm::ConstantInt::get(Int32Ty, flags.getBitMask())
    };

    if (CI.isByRef() && C.getBlockVarCopyInit(CI.getVariable()).canThrow())
      EmitRuntimeCallOrInvoke(CGM.getBlockObjectAssign(), args);
    else
      EmitNounwindRuntimeCall(CGM.getBlockObjectAssign(), args);
    break;
  }
  case BlockCaptureEntityKind::None:
    continue;
  }

  // Ensure that we destroy the copied object if an exception is thrown later
  // in the helper function.
  pushCaptureCleanup(CopiedCapture.CopyKind, dstField, captureType, flags,
                     /*ForCopyHelper*/ true, CI.getVariable(), *this);
}

FinishFunction();

return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy);
2050}

2052static BlockFieldFlags
2053getBlockFieldFlagsForObjCObjectPointer(const BlockDecl::Capture &CI,
                                     QualType T) {
BlockFieldFlags Flags = BLOCK_FIELD_IS_OBJECT;
if (T->isBlockPointerType())
  Flags = BLOCK_FIELD_IS_BLOCK;
return Flags;
2059}

2061static std::pair<BlockCaptureEntityKind, BlockFieldFlags>
2062computeDestroyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T,
                                const LangOptions &LangOpts) {
if (CI.isEscapingByref()) {
  BlockFieldFlags Flags = BLOCK_FIELD_IS_BYREF;
  if (T.isObjCGCWeak())
    Flags |= BLOCK_FIELD_IS_WEAK;
  return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags);
}

switch (T.isDestructedType()) {
case QualType::DK_cxx_destructor:
  return std::make_pair(BlockCaptureEntityKind::CXXRecord, BlockFieldFlags());
case QualType::DK_objc_strong_lifetime:
  // Use objc_storeStrong for __strong direct captures; the
  // dynamic tools really like it when we do this.
  return std::make_pair(BlockCaptureEntityKind::ARCStrong,
                        getBlockFieldFlagsForObjCObjectPointer(CI, T));
case QualType::DK_objc_weak_lifetime:
  // Support __weak direct captures.
  return std::make_pair(BlockCaptureEntityKind::ARCWeak,
                        getBlockFieldFlagsForObjCObjectPointer(CI, T));
case QualType::DK_nontrivial_c_struct:
  return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct,
                        BlockFieldFlags());
case QualType::DK_none: {
  // Non-ARC captures are strong, and we need to use _Block_object_dispose.
  if (T->isObjCRetainableType() && !T.getQualifiers().hasObjCLifetime() &&
      !LangOpts.ObjCAutoRefCount)
    return std::make_pair(BlockCaptureEntityKind::BlockObject,
                          getBlockFieldFlagsForObjCObjectPointer(CI, T));
  // Otherwise, we have nothing to do.
  return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags());
}
}
llvm_unreachable("after exhaustive DestructionKind switch")::llvm::llvm_unreachable_internal("after exhaustive DestructionKind switch"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 2096);
2097}

2099/// Generate the destroy-helper function for a block closure object:
2100///   static void block_destroy_helper(block_t *theBlock);
2101///
2102/// Note that this destroys a heap-allocated block closure object;
2103/// it should not be confused with a 'byref destroy helper', which
2104/// destroys the heap-allocated contents of an individual __block
2105/// variable.
2106llvm::Constant *
2107CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) {
SmallVector<BlockCaptureManagedEntity, 4> DestroyedCaptures;
findBlockCapturedManagedEntities(blockInfo, getLangOpts(), DestroyedCaptures);
std::string FuncName =
    getCopyDestroyHelperFuncName(DestroyedCaptures, blockInfo.BlockAlign,
                                 CaptureStrKind::DisposeHelper, CGM);

if (llvm::GlobalValue *Func = CGM.getModule().getNamedValue(FuncName))
  return llvm::ConstantExpr::getBitCast(Func, VoidPtrTy);

ASTContext &C = getContext();

QualType ReturnTy = C.VoidTy;

FunctionArgList args;
ImplicitParamDecl SrcDecl(C, C.VoidPtrTy, ImplicitParamDecl::Other);
args.push_back(&SrcDecl);

const CGFunctionInfo &FI =
    CGM.getTypes().arrangeBuiltinFunctionDeclaration(ReturnTy, args);

// FIXME: We'd like to put these into a mergable by content, with
// internal linkage.
llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);

llvm::Function *Fn =
  llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
                         FuncName, &CGM.getModule());
if (CGM.supportsCOMDAT())
  Fn->setComdat(CGM.getModule().getOrInsertComdat(FuncName));

SmallVector<QualType, 1> ArgTys;
ArgTys.push_back(C.VoidPtrTy);

setBlockHelperAttributesVisibility(blockInfo.CapturesNonExternalType, Fn, FI,
                                   CGM);
StartFunction(GlobalDecl(), ReturnTy, Fn, FI, args);
markAsIgnoreThreadCheckingAtRuntime(Fn);

auto AL = ApplyDebugLocation::CreateArtificial(*this);

llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();

Address src = GetAddrOfLocalVar(&SrcDecl);
src = Address(Builder.CreateLoad(src), blockInfo.BlockAlign);
src = Builder.CreateBitCast(src, structPtrTy, "block");

CodeGenFunction::RunCleanupsScope cleanups(*this);

for (const auto &DestroyedCapture : DestroyedCaptures) {
  const BlockDecl::Capture &CI = *DestroyedCapture.CI;
  const CGBlockInfo::Capture &capture = *DestroyedCapture.Capture;
  BlockFieldFlags flags = DestroyedCapture.DisposeFlags;

  Address srcField = Builder.CreateStructGEP(src, capture.getIndex());

  pushCaptureCleanup(DestroyedCapture.DisposeKind, srcField,
                     CI.getVariable()->getType(), flags,
                     /*ForCopyHelper*/ false, CI.getVariable(), *this);
}

cleanups.ForceCleanup();

FinishFunction();

return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy);
2173}

2175namespace {

2177/// Emits the copy/dispose helper functions for a __block object of id type.
2178class ObjectByrefHelpers final : public BlockByrefHelpers {
BlockFieldFlags Flags;

2181public:
ObjectByrefHelpers(CharUnits alignment, BlockFieldFlags flags)
  : BlockByrefHelpers(alignment), Flags(flags) {}

void emitCopy(CodeGenFunction &CGF, Address destField,
              Address srcField) override {
  destField = CGF.Builder.CreateBitCast(destField, CGF.VoidPtrTy);

  srcField = CGF.Builder.CreateBitCast(srcField, CGF.VoidPtrPtrTy);
  llvm::Value *srcValue = CGF.Builder.CreateLoad(srcField);

  unsigned flags = (Flags | BLOCK_BYREF_CALLER).getBitMask();

  llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.Int32Ty, flags);
  llvm::FunctionCallee fn = CGF.CGM.getBlockObjectAssign();

  llvm::Value *args[] = { destField.getPointer(), srcValue, flagsVal };
  CGF.EmitNounwindRuntimeCall(fn, args);
}

void emitDispose(CodeGenFunction &CGF, Address field) override {
  field = CGF.Builder.CreateBitCast(field, CGF.Int8PtrTy->getPointerTo(0));
  llvm::Value *value = CGF.Builder.CreateLoad(field);

  CGF.BuildBlockRelease(value, Flags | BLOCK_BYREF_CALLER, false);
}

void profileImpl(llvm::FoldingSetNodeID &id) const override {
  id.AddInteger(Flags.getBitMask());
}
2211};

2213/// Emits the copy/dispose helpers for an ARC __block __weak variable.
2214class ARCWeakByrefHelpers final : public BlockByrefHelpers {
2215public:
ARCWeakByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {}

void emitCopy(CodeGenFunction &CGF, Address destField,
              Address srcField) override {
  CGF.EmitARCMoveWeak(destField, srcField);
}

void emitDispose(CodeGenFunction &CGF, Address field) override {
  CGF.EmitARCDestroyWeak(field);
}

void profileImpl(llvm::FoldingSetNodeID &id) const override {
  // 0 is distinguishable from all pointers and byref flags
  id.AddInteger(0);
}
2231};

2233/// Emits the copy/dispose helpers for an ARC __block __strong variable
2234/// that's not of block-pointer type.
2235class ARCStrongByrefHelpers final : public BlockByrefHelpers {
2236public:
ARCStrongByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {}

void emitCopy(CodeGenFunction &CGF, Address destField,
              Address srcField) override {
  // Do a "move" by copying the value and then zeroing out the old
  // variable.

  llvm::Value *value = CGF.Builder.CreateLoad(srcField);

  llvm::Value *null =
    llvm::ConstantPointerNull::get(cast<llvm::PointerType>(value->getType()));

  if (CGF.CGM.getCodeGenOpts().OptimizationLevel == 0) {
    CGF.Builder.CreateStore(null, destField);
    CGF.EmitARCStoreStrongCall(destField, value, /*ignored*/ true);
    CGF.EmitARCStoreStrongCall(srcField, null, /*ignored*/ true);
    return;
  }
  CGF.Builder.CreateStore(value, destField);
  CGF.Builder.CreateStore(null, srcField);
}

void emitDispose(CodeGenFunction &CGF, Address field) override {
  CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime);
}

void profileImpl(llvm::FoldingSetNodeID &id) const override {
  // 1 is distinguishable from all pointers and byref flags
  id.AddInteger(1);
}
2267};

2269/// Emits the copy/dispose helpers for an ARC __block __strong
2270/// variable that's of block-pointer type.
2271class ARCStrongBlockByrefHelpers final : public BlockByrefHelpers {
2272public:
ARCStrongBlockByrefHelpers(CharUnits alignment)
  : BlockByrefHelpers(alignment) {}

void emitCopy(CodeGenFunction &CGF, Address destField,
              Address srcField) override {
  // Do the copy with objc_retainBlock; that's all that
  // _Block_object_assign would do anyway, and we'd have to pass the
  // right arguments to make sure it doesn't get no-op'ed.
  llvm::Value *oldValue = CGF.Builder.CreateLoad(srcField);
  llvm::Value *copy = CGF.EmitARCRetainBlock(oldValue, /*mandatory*/ true);
  CGF.Builder.CreateStore(copy, destField);
}

void emitDispose(CodeGenFunction &CGF, Address field) override {
  CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime);
}

void profileImpl(llvm::FoldingSetNodeID &id) const override {
  // 2 is distinguishable from all pointers and byref flags
  id.AddInteger(2);
}
2294};

2296/// Emits the copy/dispose helpers for a __block variable with a
2297/// nontrivial copy constructor or destructor.
2298class CXXByrefHelpers final : public BlockByrefHelpers {
QualType VarType;
const Expr *CopyExpr;

2302public:
CXXByrefHelpers(CharUnits alignment, QualType type,
                const Expr *copyExpr)
  : BlockByrefHelpers(alignment), VarType(type), CopyExpr(copyExpr) {}

bool needsCopy() const override { return CopyExpr != nullptr; }
void emitCopy(CodeGenFunction &CGF, Address destField,
              Address srcField) override {
  if (!CopyExpr) return;
  CGF.EmitSynthesizedCXXCopyCtor(destField, srcField, CopyExpr);
}

void emitDispose(CodeGenFunction &CGF, Address field) override {
  EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin();
  CGF.PushDestructorCleanup(VarType, field);
  CGF.PopCleanupBlocks(cleanupDepth);
}

void profileImpl(llvm::FoldingSetNodeID &id) const override {
  id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
}
2323};

2325/// Emits the copy/dispose helpers for a __block variable that is a non-trivial
2326/// C struct.
2327class NonTrivialCStructByrefHelpers final : public BlockByrefHelpers {
QualType VarType;

2330public:
NonTrivialCStructByrefHelpers(CharUnits alignment, QualType type)
  : BlockByrefHelpers(alignment), VarType(type) {}

void emitCopy(CodeGenFunction &CGF, Address destField,
              Address srcField) override {
  CGF.callCStructMoveConstructor(CGF.MakeAddrLValue(destField, VarType),
                                 CGF.MakeAddrLValue(srcField, VarType));
}

bool needsDispose() const override {
  return VarType.isDestructedType();
}

void emitDispose(CodeGenFunction &CGF, Address field) override {
  EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin();
  CGF.pushDestroy(VarType.isDestructedType(), field, VarType);
  CGF.PopCleanupBlocks(cleanupDepth);
}

void profileImpl(llvm::FoldingSetNodeID &id) const override {
  id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
}
2353};
2354} // end anonymous namespace

2356static llvm::Constant *
2357generateByrefCopyHelper(CodeGenFunction &CGF, const BlockByrefInfo &byrefInfo,
                      BlockByrefHelpers &generator) {
ASTContext &Context = CGF.getContext();

QualType ReturnTy = Context.VoidTy;

FunctionArgList args;
ImplicitParamDecl Dst(Context, Context.VoidPtrTy, ImplicitParamDecl::Other);
args.push_back(&Dst);

ImplicitParamDecl Src(Context, Context.VoidPtrTy, ImplicitParamDecl::Other);
args.push_back(&Src);

const CGFunctionInfo &FI =
    CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(ReturnTy, args);

llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI);

// FIXME: We'd like to put these into a mergable by content, with
// internal linkage.
llvm::Function *Fn =
  llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
                         "__Block_byref_object_copy_", &CGF.CGM.getModule());

SmallVector<QualType, 2> ArgTys;
ArgTys.push_back(Context.VoidPtrTy);
ArgTys.push_back(Context.VoidPtrTy);

CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);

CGF.StartFunction(GlobalDecl(), ReturnTy, Fn, FI, args);
  // Create a scope with an artificial location for the body of this function.
auto AL = ApplyDebugLocation::CreateArtificial(CGF);

if (generator.needsCopy()) {
  llvm::Type *byrefPtrType = byrefInfo.Type->getPointerTo(0);

  // dst->x
  Address destField = CGF.GetAddrOfLocalVar(&Dst);
  destField = Address(CGF.Builder.CreateLoad(destField),
                      byrefInfo.ByrefAlignment);
  destField = CGF.Builder.CreateBitCast(destField, byrefPtrType);
  destField = CGF.emitBlockByrefAddress(destField, byrefInfo, false,
                                        "dest-object");

  // src->x
  Address srcField = CGF.GetAddrOfLocalVar(&Src);
  srcField = Address(CGF.Builder.CreateLoad(srcField),
                     byrefInfo.ByrefAlignment);
  srcField = CGF.Builder.CreateBitCast(srcField, byrefPtrType);
  srcField = CGF.emitBlockByrefAddress(srcField, byrefInfo, false,
                                       "src-object");

  generator.emitCopy(CGF, destField, srcField);
}

CGF.FinishFunction();

return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy);
2416}

2418/// Build the copy helper for a __block variable.
2419static llvm::Constant *buildByrefCopyHelper(CodeGenModule &CGM,
                                          const BlockByrefInfo &byrefInfo,
                                          BlockByrefHelpers &generator) {
CodeGenFunction CGF(CGM);
return generateByrefCopyHelper(CGF, byrefInfo, generator);
2424}

2426/// Generate code for a __block variable's dispose helper.
2427static llvm::Constant *
2428generateByrefDisposeHelper(CodeGenFunction &CGF,
                         const BlockByrefInfo &byrefInfo,
                         BlockByrefHelpers &generator) {
ASTContext &Context = CGF.getContext();
QualType R = Context.VoidTy;

FunctionArgList args;
ImplicitParamDecl Src(CGF.getContext(), Context.VoidPtrTy,
                      ImplicitParamDecl::Other);
args.push_back(&Src);

const CGFunctionInfo &FI =
  CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(R, args);

llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI);

// FIXME: We'd like to put these into a mergable by content, with
// internal linkage.
llvm::Function *Fn =
  llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
                         "__Block_byref_object_dispose_",
                         &CGF.CGM.getModule());

SmallVector<QualType, 1> ArgTys;
ArgTys.push_back(Context.VoidPtrTy);

CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);

CGF.StartFunction(GlobalDecl(), R, Fn, FI, args);
  // Create a scope with an artificial location for the body of this function.
auto AL = ApplyDebugLocation::CreateArtificial(CGF);

if (generator.needsDispose()) {
  Address addr = CGF.GetAddrOfLocalVar(&Src);
  addr = Address(CGF.Builder.CreateLoad(addr), byrefInfo.ByrefAlignment);
  auto byrefPtrType = byrefInfo.Type->getPointerTo(0);
  addr = CGF.Builder.CreateBitCast(addr, byrefPtrType);
  addr = CGF.emitBlockByrefAddress(addr, byrefInfo, false, "object");

  generator.emitDispose(CGF, addr);
}

CGF.FinishFunction();

return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy);
2473}

2475/// Build the dispose helper for a __block variable.
2476static llvm::Constant *buildByrefDisposeHelper(CodeGenModule &CGM,
                                             const BlockByrefInfo &byrefInfo,
                                             BlockByrefHelpers &generator) {
CodeGenFunction CGF(CGM);
return generateByrefDisposeHelper(CGF, byrefInfo, generator);
2481}

2483/// Lazily build the copy and dispose helpers for a __block variable
2484/// with the given information.
2485template <class T>
2486static T *buildByrefHelpers(CodeGenModule &CGM, const BlockByrefInfo &byrefInfo,
                          T &&generator) {
llvm::FoldingSetNodeID id;
generator.Profile(id);

void *insertPos;
BlockByrefHelpers *node
  = CGM.ByrefHelpersCache.FindNodeOrInsertPos(id, insertPos);
if (node) return static_cast<T*>(node);

generator.CopyHelper = buildByrefCopyHelper(CGM, byrefInfo, generator);
generator.DisposeHelper = buildByrefDisposeHelper(CGM, byrefInfo, generator);

T *copy = new (CGM.getContext()) T(std::forward<T>(generator));
CGM.ByrefHelpersCache.InsertNode(copy, insertPos);
return copy;
2502}

2504/// Build the copy and dispose helpers for the given __block variable
2505/// emission.  Places the helpers in the global cache.  Returns null
2506/// if no helpers are required.
2507BlockByrefHelpers *
2508CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType,
                                 const AutoVarEmission &emission) {
const VarDecl &var = *emission.Variable;
assert(var.isEscapingByref() &&(static_cast <bool> (var.isEscapingByref() && "only escaping __block variables need byref helpers"
) ? void (0) : __assert_fail ("var.isEscapingByref() && \"only escaping __block variables need byref helpers\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 2512, __extension__ __PRETTY_FUNCTION__))
       "only escaping __block variables need byref helpers")(static_cast <bool> (var.isEscapingByref() && "only escaping __block variables need byref helpers"
) ? void (0) : __assert_fail ("var.isEscapingByref() && \"only escaping __block variables need byref helpers\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 2512, __extension__ __PRETTY_FUNCTION__));

QualType type = var.getType();

auto &byrefInfo = getBlockByrefInfo(&var);

// The alignment we care about for the purposes of uniquing byref
// helpers is the alignment of the actual byref value field.
CharUnits valueAlignment =
  byrefInfo.ByrefAlignment.alignmentAtOffset(byrefInfo.FieldOffset);

if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) {
  const Expr *copyExpr =
      CGM.getContext().getBlockVarCopyInit(&var).getCopyExpr();
  if (!copyExpr && record->hasTrivialDestructor()) return nullptr;

  return ::buildByrefHelpers(
      CGM, byrefInfo, CXXByrefHelpers(valueAlignment, type, copyExpr));
}

// If type is a non-trivial C struct type that is non-trivial to
// destructly move or destroy, build the copy and dispose helpers.
if (type.isNonTrivialToPrimitiveDestructiveMove() == QualType::PCK_Struct ||
    type.isDestructedType() == QualType::DK_nontrivial_c_struct)
  return ::buildByrefHelpers(
      CGM, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment, type));

// Otherwise, if we don't have a retainable type, there's nothing to do.
// that the runtime does extra copies.
if (!type->isObjCRetainableType()) return nullptr;

Qualifiers qs = type.getQualifiers();

// If we have lifetime, that dominates.
if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) {
  switch (lifetime) {
  case Qualifiers::OCL_None: llvm_unreachable("impossible")::llvm::llvm_unreachable_internal("impossible", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 2548);

  // These are just bits as far as the runtime is concerned.
  case Qualifiers::OCL_ExplicitNone:
  case Qualifiers::OCL_Autoreleasing:
    return nullptr;

  // Tell the runtime that this is ARC __weak, called by the
  // byref routines.
  case Qualifiers::OCL_Weak:
    return ::buildByrefHelpers(CGM, byrefInfo,
                               ARCWeakByrefHelpers(valueAlignment));

  // ARC __strong __block variables need to be retained.
  case Qualifiers::OCL_Strong:
    // Block pointers need to be copied, and there's no direct
    // transfer possible.
    if (type->isBlockPointerType()) {
      return ::buildByrefHelpers(CGM, byrefInfo,
                                 ARCStrongBlockByrefHelpers(valueAlignment));

    // Otherwise, we transfer ownership of the retain from the stack
    // to the heap.
    } else {
      return ::buildByrefHelpers(CGM, byrefInfo,
                                 ARCStrongByrefHelpers(valueAlignment));
    }
  }
  llvm_unreachable("fell out of lifetime switch!")::llvm::llvm_unreachable_internal("fell out of lifetime switch!"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 2576);
}

BlockFieldFlags flags;
if (type->isBlockPointerType()) {
  flags |= BLOCK_FIELD_IS_BLOCK;
} else if (CGM.getContext().isObjCNSObjectType(type) ||
           type->isObjCObjectPointerType()) {
  flags |= BLOCK_FIELD_IS_OBJECT;
} else {
  return nullptr;
}

if (type.isObjCGCWeak())
  flags |= BLOCK_FIELD_IS_WEAK;

return ::buildByrefHelpers(CGM, byrefInfo,
                           ObjectByrefHelpers(valueAlignment, flags));
2594}

2596Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr,
                                             const VarDecl *var,
                                             bool followForward) {
auto &info = getBlockByrefInfo(var);
return emitBlockByrefAddress(baseAddr, info, followForward, var->getName());
2601}

2603Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr,
                                             const BlockByrefInfo &info,
                                             bool followForward,
                                             const llvm::Twine &name) {
// Chase the forwarding address if requested.
if (followForward) {
  Address forwardingAddr = Builder.CreateStructGEP(baseAddr, 1, "forwarding");
  baseAddr = Address(Builder.CreateLoad(forwardingAddr), info.ByrefAlignment);
}

return Builder.CreateStructGEP(baseAddr, info.FieldIndex, name);
2614}

2616/// BuildByrefInfo - This routine changes a __block variable declared as T x
2617///   into:
2618///
2619///      struct {
2620///        void *__isa;
2621///        void *__forwarding;
2622///        int32_t __flags;
2623///        int32_t __size;
2624///        void *__copy_helper;       // only if needed
2625///        void *__destroy_helper;    // only if needed
2626///        void *__byref_variable_layout;// only if needed
2627///        char padding[X];           // only if needed
2628///        T x;
2629///      } x
2630///
2631const BlockByrefInfo &CodeGenFunction::getBlockByrefInfo(const VarDecl *D) {
auto it = BlockByrefInfos.find(D);
if (it != BlockByrefInfos.end())
  return it->second;

llvm::StructType *byrefType =
  llvm::StructType::create(getLLVMContext(),
                           "struct.__block_byref_" + D->getNameAsString());

QualType Ty = D->getType();

CharUnits size;
SmallVector<llvm::Type *, 8> types;

// void *__isa;
types.push_back(Int8PtrTy);
size += getPointerSize();

// void *__forwarding;
types.push_back(llvm::PointerType::getUnqual(byrefType));
size += getPointerSize();

// int32_t __flags;
types.push_back(Int32Ty);
size += CharUnits::fromQuantity(4);

// int32_t __size;
types.push_back(Int32Ty);
size += CharUnits::fromQuantity(4);

// Note that this must match *exactly* the logic in buildByrefHelpers.
bool hasCopyAndDispose = getContext().BlockRequiresCopying(Ty, D);
if (hasCopyAndDispose) {
  /// void *__copy_helper;
  types.push_back(Int8PtrTy);
  size += getPointerSize();

  /// void *__destroy_helper;
  types.push_back(Int8PtrTy);
  size += getPointerSize();
}

bool HasByrefExtendedLayout = false;
Qualifiers::ObjCLifetime Lifetime = Qualifiers::OCL_None;
if (getContext().getByrefLifetime(Ty, Lifetime, HasByrefExtendedLayout) &&
    HasByrefExtendedLayout) {
  /// void *__byref_variable_layout;
  types.push_back(Int8PtrTy);
  size += CharUnits::fromQuantity(PointerSizeInBytes);
}

// T x;
llvm::Type *varTy = ConvertTypeForMem(Ty);

bool packed = false;
CharUnits varAlign = getContext().getDeclAlign(D);
CharUnits varOffset = size.alignTo(varAlign);

// We may have to insert padding.
if (varOffset != size) {
  llvm::Type *paddingTy =
    llvm::ArrayType::get(Int8Ty, (varOffset - size).getQuantity());

  types.push_back(paddingTy);
  size = varOffset;

// Conversely, we might have to prevent LLVM from inserting padding.
} else if (CGM.getDataLayout().getABITypeAlignment(varTy)
             > varAlign.getQuantity()) {
  packed = true;
}
types.push_back(varTy);

byrefType->setBody(types, packed);

BlockByrefInfo info;
info.Type = byrefType;
info.FieldIndex = types.size() - 1;
info.FieldOffset = varOffset;
info.ByrefAlignment = std::max(varAlign, getPointerAlign());

auto pair = BlockByrefInfos.insert({D, info});
assert(pair.second && "info was inserted recursively?")(static_cast <bool> (pair.second && "info was inserted recursively?"
) ? void (0) : __assert_fail ("pair.second && \"info was inserted recursively?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 2713, __extension__ __PRETTY_FUNCTION__));
return pair.first->second;
2715}

2717/// Initialize the structural components of a __block variable, i.e.
2718/// everything but the actual object.
2719void CodeGenFunction::emitByrefStructureInit(const AutoVarEmission &emission) {
// Find the address of the local.
Address addr = emission.Addr;

// That's an alloca of the byref structure type.
llvm::StructType *byrefType = cast<llvm::StructType>(
  cast<llvm::PointerType>(addr.getPointer()->getType())->getElementType());

unsigned nextHeaderIndex = 0;
CharUnits nextHeaderOffset;
auto storeHeaderField = [&](llvm::Value *value, CharUnits fieldSize,
                            const Twine &name) {
  auto fieldAddr = Builder.CreateStructGEP(addr, nextHeaderIndex, name);
  Builder.CreateStore(value, fieldAddr);

  nextHeaderIndex++;
  nextHeaderOffset += fieldSize;
};

// Build the byref helpers if necessary.  This is null if we don't need any.
BlockByrefHelpers *helpers = buildByrefHelpers(*byrefType, emission);

const VarDecl &D = *emission.Variable;
QualType type = D.getType();

bool HasByrefExtendedLayout = false;
Qualifiers::ObjCLifetime ByrefLifetime = Qualifiers::OCL_None;
bool ByRefHasLifetime =
  getContext().getByrefLifetime(type, ByrefLifetime, HasByrefExtendedLayout);

llvm::Value *V;

// Initialize the 'isa', which is just 0 or 1.
int isa = 0;
if (type.isObjCGCWeak())
  isa = 1;
V = Builder.CreateIntToPtr(Builder.getInt32(isa), Int8PtrTy, "isa");
storeHeaderField(V, getPointerSize(), "byref.isa");

// Store the address of the variable into its own forwarding pointer.
storeHeaderField(addr.getPointer(), getPointerSize(), "byref.forwarding");

// Blocks ABI:
//   c) the flags field is set to either 0 if no helper functions are
//      needed or BLOCK_BYREF_HAS_COPY_DISPOSE if they are,
BlockFlags flags;
if (helpers) flags |= BLOCK_BYREF_HAS_COPY_DISPOSE;
if (ByRefHasLifetime) {
  if (HasByrefExtendedLayout) flags |= BLOCK_BYREF_LAYOUT_EXTENDED;
    else switch (ByrefLifetime) {
      case Qualifiers::OCL_Strong:
        flags |= BLOCK_BYREF_LAYOUT_STRONG;
        break;
      case Qualifiers::OCL_Weak:
        flags |= BLOCK_BYREF_LAYOUT_WEAK;
        break;
      case Qualifiers::OCL_ExplicitNone:
        flags |= BLOCK_BYREF_LAYOUT_UNRETAINED;
        break;
      case Qualifiers::OCL_None:
        if (!type->isObjCObjectPointerType() && !type->isBlockPointerType())
          flags |= BLOCK_BYREF_LAYOUT_NON_OBJECT;
        break;
      default:
        break;
    }
  if (CGM.getLangOpts().ObjCGCBitmapPrint) {
    printf("\n Inline flag for BYREF variable layout (%d):", flags.getBitMask());
    if (flags & BLOCK_BYREF_HAS_COPY_DISPOSE)
      printf(" BLOCK_BYREF_HAS_COPY_DISPOSE");
    if (flags & BLOCK_BYREF_LAYOUT_MASK) {
      BlockFlags ThisFlag(flags.getBitMask() & BLOCK_BYREF_LAYOUT_MASK);
      if (ThisFlag ==  BLOCK_BYREF_LAYOUT_EXTENDED)
        printf(" BLOCK_BYREF_LAYOUT_EXTENDED");
      if (ThisFlag ==  BLOCK_BYREF_LAYOUT_STRONG)
        printf(" BLOCK_BYREF_LAYOUT_STRONG");
      if (ThisFlag == BLOCK_BYREF_LAYOUT_WEAK)
        printf(" BLOCK_BYREF_LAYOUT_WEAK");
      if (ThisFlag == BLOCK_BYREF_LAYOUT_UNRETAINED)
        printf(" BLOCK_BYREF_LAYOUT_UNRETAINED");
      if (ThisFlag == BLOCK_BYREF_LAYOUT_NON_OBJECT)
        printf(" BLOCK_BYREF_LAYOUT_NON_OBJECT");
    }
    printf("\n");
  }
}
storeHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()),
                 getIntSize(), "byref.flags");

CharUnits byrefSize = CGM.GetTargetTypeStoreSize(byrefType);
V = llvm::ConstantInt::get(IntTy, byrefSize.getQuantity());
storeHeaderField(V, getIntSize(), "byref.size");

if (helpers) {
  storeHeaderField(helpers->CopyHelper, getPointerSize(),
                   "byref.copyHelper");
  storeHeaderField(helpers->DisposeHelper, getPointerSize(),
                   "byref.disposeHelper");
}

if (ByRefHasLifetime && HasByrefExtendedLayout) {
  auto layoutInfo = CGM.getObjCRuntime().BuildByrefLayout(CGM, type);
  storeHeaderField(layoutInfo, getPointerSize(), "byref.layout");
}
2823}

2825void CodeGenFunction::BuildBlockRelease(llvm::Value *V, BlockFieldFlags flags,
                                      bool CanThrow) {
llvm::FunctionCallee F = CGM.getBlockObjectDispose();
llvm::Value *args[] = {
  Builder.CreateBitCast(V, Int8PtrTy),
  llvm::ConstantInt::get(Int32Ty, flags.getBitMask())
};

if (CanThrow)
  EmitRuntimeCallOrInvoke(F, args);
else
  EmitNounwindRuntimeCall(F, args);
2837}

2839void CodeGenFunction::enterByrefCleanup(CleanupKind Kind, Address Addr,
                                      BlockFieldFlags Flags,
                                      bool LoadBlockVarAddr, bool CanThrow) {
EHStack.pushCleanup<CallBlockRelease>(Kind, Addr, Flags, LoadBlockVarAddr,
                                      CanThrow);
2844}

2846/// Adjust the declaration of something from the blocks API.
2847static void configureBlocksRuntimeObject(CodeGenModule &CGM,
                                       llvm::Constant *C) {
auto *GV = cast<llvm::GlobalValue>(C->stripPointerCasts());

if (CGM.getTarget().getTriple().isOSBinFormatCOFF()) {
  IdentifierInfo &II = CGM.getContext().Idents.get(C->getName());
  TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
  DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);

  assert((isa<llvm::Function>(C->stripPointerCasts()) ||(static_cast <bool> ((isa<llvm::Function>(C->stripPointerCasts
()) || isa<llvm::GlobalVariable>(C->stripPointerCasts
())) && "expected Function or GlobalVariable") ? void
 (0) : __assert_fail ("(isa<llvm::Function>(C->stripPointerCasts()) || isa<llvm::GlobalVariable>(C->stripPointerCasts())) && \"expected Function or GlobalVariable\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 2858, __extension__ __PRETTY_FUNCTION__))
          isa<llvm::GlobalVariable>(C->stripPointerCasts())) &&(static_cast <bool> ((isa<llvm::Function>(C->stripPointerCasts
()) || isa<llvm::GlobalVariable>(C->stripPointerCasts
())) && "expected Function or GlobalVariable") ? void
 (0) : __assert_fail ("(isa<llvm::Function>(C->stripPointerCasts()) || isa<llvm::GlobalVariable>(C->stripPointerCasts())) && \"expected Function or GlobalVariable\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 2858, __extension__ __PRETTY_FUNCTION__))
         "expected Function or GlobalVariable")(static_cast <bool> ((isa<llvm::Function>(C->stripPointerCasts
()) || isa<llvm::GlobalVariable>(C->stripPointerCasts
())) && "expected Function or GlobalVariable") ? void
 (0) : __assert_fail ("(isa<llvm::Function>(C->stripPointerCasts()) || isa<llvm::GlobalVariable>(C->stripPointerCasts())) && \"expected Function or GlobalVariable\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGBlocks.cpp"
, 2858, __extension__ __PRETTY_FUNCTION__));

  const NamedDecl *ND = nullptr;
  for (const auto *Result : DC->lookup(&II))
    if ((ND = dyn_cast<FunctionDecl>(Result)) ||
        (ND = dyn_cast<VarDecl>(Result)))
      break;

  // TODO: support static blocks runtime
  if (GV->isDeclaration() && (!ND || !ND->hasAttr<DLLExportAttr>())) {
    GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
    GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
  } else {
    GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
    GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
  }
}

if (CGM.getLangOpts().BlocksRuntimeOptional && GV->isDeclaration() &&
    GV->hasExternalLinkage())
  GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);

CGM.setDSOLocal(GV);
2881}

2883llvm::FunctionCallee CodeGenModule::getBlockObjectDispose() {
if (BlockObjectDispose)
  return BlockObjectDispose;

llvm::Type *args[] = { Int8PtrTy, Int32Ty };
llvm::FunctionType *fty
  = llvm::FunctionType::get(VoidTy, args, false);
BlockObjectDispose = CreateRuntimeFunction(fty, "_Block_object_dispose");
configureBlocksRuntimeObject(
    *this, cast<llvm::Constant>(BlockObjectDispose.getCallee()));
return BlockObjectDispose;
2894}

2896llvm::FunctionCallee CodeGenModule::getBlockObjectAssign() {
if (BlockObjectAssign)
  return BlockObjectAssign;

llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, Int32Ty };
llvm::FunctionType *fty
  = llvm::FunctionType::get(VoidTy, args, false);
BlockObjectAssign = CreateRuntimeFunction(fty, "_Block_object_assign");
configureBlocksRuntimeObject(
    *this, cast<llvm::Constant>(BlockObjectAssign.getCallee()));
return BlockObjectAssign;
2907}

2909llvm::Constant *CodeGenModule::getNSConcreteGlobalBlock() {
if (NSConcreteGlobalBlock)
  return NSConcreteGlobalBlock;

NSConcreteGlobalBlock = GetOrCreateLLVMGlobal(
    "_NSConcreteGlobalBlock", Int8PtrTy, LangAS::Default, nullptr);
configureBlocksRuntimeObject(*this, NSConcreteGlobalBlock);
return NSConcreteGlobalBlock;
2917}

2919llvm::Constant *CodeGenModule::getNSConcreteStackBlock() {
if (NSConcreteStackBlock)
  return NSConcreteStackBlock;

NSConcreteStackBlock = GetOrCreateLLVMGlobal(
    "_NSConcreteStackBlock", Int8PtrTy, LangAS::Default, nullptr);
configureBlocksRuntimeObject(*this, NSConcreteStackBlock);
return NSConcreteStackBlock;
2927}

←

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h

1//===- Decl.h - Classes for representing declarations -----------*- 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 defines the Decl subclasses.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_AST_DECL_H
14#define LLVM_CLANG_AST_DECL_H

16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTContextAllocate.h"
18#include "clang/AST/DeclAccessPair.h"
19#include "clang/AST/DeclBase.h"
20#include "clang/AST/DeclarationName.h"
21#include "clang/AST/ExternalASTSource.h"
22#include "clang/AST/NestedNameSpecifier.h"
23#include "clang/AST/Redeclarable.h"
24#include "clang/AST/Type.h"
25#include "clang/Basic/AddressSpaces.h"
26#include "clang/Basic/Diagnostic.h"
27#include "clang/Basic/IdentifierTable.h"
28#include "clang/Basic/LLVM.h"
29#include "clang/Basic/Linkage.h"
30#include "clang/Basic/OperatorKinds.h"
31#include "clang/Basic/PartialDiagnostic.h"
32#include "clang/Basic/PragmaKinds.h"
33#include "clang/Basic/SourceLocation.h"
34#include "clang/Basic/Specifiers.h"
35#include "clang/Basic/Visibility.h"
36#include "llvm/ADT/APSInt.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/Compiler.h"
45#include "llvm/Support/TrailingObjects.h"
46#include <cassert>
47#include <cstddef>
48#include <cstdint>
49#include <string>
50#include <utility>

52namespace clang {

54class ASTContext;
55struct ASTTemplateArgumentListInfo;
56class Attr;
57class CompoundStmt;
58class DependentFunctionTemplateSpecializationInfo;
59class EnumDecl;
60class Expr;
61class FunctionTemplateDecl;
62class FunctionTemplateSpecializationInfo;
63class FunctionTypeLoc;
64class LabelStmt;
65class MemberSpecializationInfo;
66class Module;
67class NamespaceDecl;
68class ParmVarDecl;
69class RecordDecl;
70class Stmt;
71class StringLiteral;
72class TagDecl;
73class TemplateArgumentList;
74class TemplateArgumentListInfo;
75class TemplateParameterList;
76class TypeAliasTemplateDecl;
77class TypeLoc;
78class UnresolvedSetImpl;
79class VarTemplateDecl;

81/// The top declaration context.
82class TranslationUnitDecl : public Decl,
                          public DeclContext,
                          public Redeclarable<TranslationUnitDecl> {
using redeclarable_base = Redeclarable<TranslationUnitDecl>;

TranslationUnitDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

TranslationUnitDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

TranslationUnitDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

ASTContext &Ctx;

/// The (most recently entered) anonymous namespace for this
/// translation unit, if one has been created.
NamespaceDecl *AnonymousNamespace = nullptr;

explicit TranslationUnitDecl(ASTContext &ctx);

virtual void anchor();

109public:
using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::getMostRecentDecl;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::isFirstDecl;
using redeclarable_base::redecls;
using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;

ASTContext &getASTContext() const { return Ctx; }

NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }
void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }

static TranslationUnitDecl *Create(ASTContext &C);

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == TranslationUnit; }
static DeclContext *castToDeclContext(const TranslationUnitDecl *D) {
  return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));
}
static TranslationUnitDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));
}
136};

138/// Represents a `#pragma comment` line. Always a child of
139/// TranslationUnitDecl.
140class PragmaCommentDecl final
  : public Decl,
    private llvm::TrailingObjects<PragmaCommentDecl, char> {
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend TrailingObjects;

PragmaMSCommentKind CommentKind;

PragmaCommentDecl(TranslationUnitDecl *TU, SourceLocation CommentLoc,
                  PragmaMSCommentKind CommentKind)
    : Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}

virtual void anchor();

155public:
static PragmaCommentDecl *Create(const ASTContext &C, TranslationUnitDecl *DC,
                                 SourceLocation CommentLoc,
                                 PragmaMSCommentKind CommentKind,
                                 StringRef Arg);
static PragmaCommentDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                             unsigned ArgSize);

PragmaMSCommentKind getCommentKind() const { return CommentKind; }

StringRef getArg() const { return getTrailingObjects<char>(); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == PragmaComment; }
170};

172/// Represents a `#pragma detect_mismatch` line. Always a child of
173/// TranslationUnitDecl.
174class PragmaDetectMismatchDecl final
  : public Decl,
    private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend TrailingObjects;

size_t ValueStart;

PragmaDetectMismatchDecl(TranslationUnitDecl *TU, SourceLocation Loc,
                         size_t ValueStart)
    : Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}

virtual void anchor();

189public:
static PragmaDetectMismatchDecl *Create(const ASTContext &C,
                                        TranslationUnitDecl *DC,
                                        SourceLocation Loc, StringRef Name,
                                        StringRef Value);
static PragmaDetectMismatchDecl *
CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize);

StringRef getName() const { return getTrailingObjects<char>(); }
StringRef getValue() const { return getTrailingObjects<char>() + ValueStart; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == PragmaDetectMismatch; }
203};

205/// Declaration context for names declared as extern "C" in C++. This
206/// is neither the semantic nor lexical context for such declarations, but is
207/// used to check for conflicts with other extern "C" declarations. Example:
208///
209/// \code
210///   namespace N { extern "C" void f(); } // #1
211///   void N::f() {}                       // #2
212///   namespace M { extern "C" void f(); } // #3
213/// \endcode
214///
215/// The semantic context of #1 is namespace N and its lexical context is the
216/// LinkageSpecDecl; the semantic context of #2 is namespace N and its lexical
217/// context is the TU. However, both declarations are also visible in the
218/// extern "C" context.
219///
220/// The declaration at #3 finds it is a redeclaration of \c N::f through
221/// lookup in the extern "C" context.
222class ExternCContextDecl : public Decl, public DeclContext {
explicit ExternCContextDecl(TranslationUnitDecl *TU)
  : Decl(ExternCContext, TU, SourceLocation()),
    DeclContext(ExternCContext) {}

virtual void anchor();

229public:
static ExternCContextDecl *Create(const ASTContext &C,
                                  TranslationUnitDecl *TU);

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ExternCContext; }
static DeclContext *castToDeclContext(const ExternCContextDecl *D) {
  return static_cast<DeclContext *>(const_cast<ExternCContextDecl*>(D));
}
static ExternCContextDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<ExternCContextDecl *>(const_cast<DeclContext*>(DC));
}
242};

244/// This represents a decl that may have a name.  Many decls have names such
245/// as ObjCMethodDecl, but not \@class, etc.
246///
247/// Note that not every NamedDecl is actually named (e.g., a struct might
248/// be anonymous), and not every name is an identifier.
249class NamedDecl : public Decl {
/// The name of this declaration, which is typically a normal
/// identifier but may also be a special kind of name (C++
/// constructor, Objective-C selector, etc.)
DeclarationName Name;

virtual void anchor();

257private:
NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY__attribute__((__pure__));

260protected:
NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
    : Decl(DK, DC, L), Name(N) {}

264public:
/// Get the identifier that names this declaration, if there is one.
///
/// This will return NULL if this declaration has no name (e.g., for
/// an unnamed class) or if the name is a special name (C++ constructor,
/// Objective-C selector, etc.).
IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); }

/// Get the name of identifier for this declaration as a StringRef.
///
/// This requires that the declaration have a name and that it be a simple
/// identifier.
StringRef getName() const {
  assert(Name.isIdentifier() && "Name is not a simple identifier")(static_cast <bool> (Name.isIdentifier() && "Name is not a simple identifier"
) ? void (0) : __assert_fail ("Name.isIdentifier() && \"Name is not a simple identifier\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 277, __extension__ __PRETTY_FUNCTION__));
  return getIdentifier() ? getIdentifier()->getName() : "";
}

/// Get a human-readable name for the declaration, even if it is one of the
/// special kinds of names (C++ constructor, Objective-C selector, etc).
///
/// Creating this name requires expensive string manipulation, so it should
/// be called only when performance doesn't matter. For simple declarations,
/// getNameAsCString() should suffice.
//
// FIXME: This function should be renamed to indicate that it is not just an
// alternate form of getName(), and clients should move as appropriate.
//
// FIXME: Deprecated, move clients to getName().
std::string getNameAsString() const { return Name.getAsString(); }

/// Pretty-print the unqualified name of this declaration. Can be overloaded
/// by derived classes to provide a more user-friendly name when appropriate.
virtual void printName(raw_ostream &os) const;

/// Get the actual, stored name of the declaration, which may be a special
/// name.
///
/// Note that generally in diagnostics, the non-null \p NamedDecl* itself
/// should be sent into the diagnostic instead of using the result of
/// \p getDeclName().
///
/// A \p DeclarationName in a diagnostic will just be streamed to the output,
/// which will directly result in a call to \p DeclarationName::print.
///
/// A \p NamedDecl* in a diagnostic will also ultimately result in a call to
/// \p DeclarationName::print, but with two customisation points along the
/// way (\p getNameForDiagnostic and \p printName). These are used to print
/// the template arguments if any, and to provide a user-friendly name for
/// some entities (such as unnamed variables and anonymous records).
DeclarationName getDeclName() const { return Name; }

/// Set the name of this declaration.
void setDeclName(DeclarationName N) { Name = N; }

/// Returns a human-readable qualified name for this declaration, like
/// A::B::i, for i being member of namespace A::B.
///
/// If the declaration is not a member of context which can be named (record,
/// namespace), it will return the same result as printName().
///
/// Creating this name is expensive, so it should be called only when
/// performance doesn't matter.
void printQualifiedName(raw_ostream &OS) const;
void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;

/// Print only the nested name specifier part of a fully-qualified name,
/// including the '::' at the end. E.g.
///    when `printQualifiedName(D)` prints "A::B::i",
///    this function prints "A::B::".
void printNestedNameSpecifier(raw_ostream &OS) const;
void printNestedNameSpecifier(raw_ostream &OS,
                              const PrintingPolicy &Policy) const;

// FIXME: Remove string version.
std::string getQualifiedNameAsString() const;

/// Appends a human-readable name for this declaration into the given stream.
///
/// This is the method invoked by Sema when displaying a NamedDecl
/// in a diagnostic.  It does not necessarily produce the same
/// result as printName(); for example, class template
/// specializations are printed with their template arguments.
virtual void getNameForDiagnostic(raw_ostream &OS,
                                  const PrintingPolicy &Policy,
                                  bool Qualified) const;

/// Determine whether this declaration, if known to be well-formed within
/// its context, will replace the declaration OldD if introduced into scope.
///
/// A declaration will replace another declaration if, for example, it is
/// a redeclaration of the same variable or function, but not if it is a
/// declaration of a different kind (function vs. class) or an overloaded
/// function.
///
/// \param IsKnownNewer \c true if this declaration is known to be newer
/// than \p OldD (for instance, if this declaration is newly-created).
bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer = true) const;

/// Determine whether this declaration has linkage.
bool hasLinkage() const;

using Decl::isModulePrivate;
using Decl::setModulePrivate;

/// Determine whether this declaration is a C++ class member.
bool isCXXClassMember() const {
  const DeclContext *DC = getDeclContext();

  // C++0x [class.mem]p1:
  //   The enumerators of an unscoped enumeration defined in
  //   the class are members of the class.
  if (isa<EnumDecl>(DC))
    DC = DC->getRedeclContext();

  return DC->isRecord();
}

/// Determine whether the given declaration is an instance member of
/// a C++ class.
bool isCXXInstanceMember() const;

/// Determine if the declaration obeys the reserved identifier rules of the
/// given language.
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const;

/// Determine what kind of linkage this entity has.
///
/// This is not the linkage as defined by the standard or the codegen notion
/// of linkage. It is just an implementation detail that is used to compute
/// those.
Linkage getLinkageInternal() const;

/// Get the linkage from a semantic point of view. Entities in
/// anonymous namespaces are external (in c++98).
Linkage getFormalLinkage() const {
  return clang::getFormalLinkage(getLinkageInternal());
}

/// True if this decl has external linkage.
bool hasExternalFormalLinkage() const {
  return isExternalFormalLinkage(getLinkageInternal());
}

bool isExternallyVisible() const {
  return clang::isExternallyVisible(getLinkageInternal());
}

/// Determine whether this declaration can be redeclared in a
/// different translation unit.
bool isExternallyDeclarable() const {
  return isExternallyVisible() && !getOwningModuleForLinkage();
}

/// Determines the visibility of this entity.
Visibility getVisibility() const {
  return getLinkageAndVisibility().getVisibility();
}

/// Determines the linkage and visibility of this entity.
LinkageInfo getLinkageAndVisibility() const;

/// Kinds of explicit visibility.
enum ExplicitVisibilityKind {
  /// Do an LV computation for, ultimately, a type.
  /// Visibility may be restricted by type visibility settings and
  /// the visibility of template arguments.
  VisibilityForType,

  /// Do an LV computation for, ultimately, a non-type declaration.
  /// Visibility may be restricted by value visibility settings and
  /// the visibility of template arguments.
  VisibilityForValue
};

/// If visibility was explicitly specified for this
/// declaration, return that visibility.
Optional<Visibility>
getExplicitVisibility(ExplicitVisibilityKind kind) const;

/// True if the computed linkage is valid. Used for consistency
/// checking. Should always return true.
bool isLinkageValid() const;

/// True if something has required us to compute the linkage
/// of this declaration.
///
/// Language features which can retroactively change linkage (like a
/// typedef name for linkage purposes) may need to consider this,
/// but hopefully only in transitory ways during parsing.
bool hasLinkageBeenComputed() const {
  return hasCachedLinkage();
}

/// Looks through UsingDecls and ObjCCompatibleAliasDecls for
/// the underlying named decl.
NamedDecl *getUnderlyingDecl() {
  // Fast-path the common case.
  if (this->getKind() != UsingShadow &&
      this->getKind() != ConstructorUsingShadow &&
      this->getKind() != ObjCCompatibleAlias &&
      this->getKind() != NamespaceAlias)
    return this;

  return getUnderlyingDeclImpl();
}
const NamedDecl *getUnderlyingDecl() const {
  return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
}

NamedDecl *getMostRecentDecl() {
  return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());
}
const NamedDecl *getMostRecentDecl() const {
  return const_cast<NamedDecl*>(this)->getMostRecentDecl();
}

ObjCStringFormatFamily getObjCFStringFormattingFamily() const;

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }
484};

486inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {
ND.printName(OS);
return OS;
489}

491/// Represents the declaration of a label.  Labels also have a
492/// corresponding LabelStmt, which indicates the position that the label was
493/// defined at.  For normal labels, the location of the decl is the same as the
494/// location of the statement.  For GNU local labels (__label__), the decl
495/// location is where the __label__ is.
496class LabelDecl : public NamedDecl {
LabelStmt *TheStmt;
StringRef MSAsmName;
bool MSAsmNameResolved = false;

/// For normal labels, this is the same as the main declaration
/// label, i.e., the location of the identifier; for GNU local labels,
/// this is the location of the __label__ keyword.
SourceLocation LocStart;

LabelDecl(DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II,
          LabelStmt *S, SourceLocation StartL)
    : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}

void anchor() override;

512public:
static LabelDecl *Create(ASTContext &C, DeclContext *DC,
                         SourceLocation IdentL, IdentifierInfo *II);
static LabelDecl *Create(ASTContext &C, DeclContext *DC,
                         SourceLocation IdentL, IdentifierInfo *II,
                         SourceLocation GnuLabelL);
static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);

LabelStmt *getStmt() const { return TheStmt; }
void setStmt(LabelStmt *T) { TheStmt = T; }

bool isGnuLocal() const { return LocStart != getLocation(); }
void setLocStart(SourceLocation L) { LocStart = L; }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(LocStart, getLocation());
}

bool isMSAsmLabel() const { return !MSAsmName.empty(); }
bool isResolvedMSAsmLabel() const { return isMSAsmLabel() && MSAsmNameResolved; }
void setMSAsmLabel(StringRef Name);
StringRef getMSAsmLabel() const { return MSAsmName; }
void setMSAsmLabelResolved() { MSAsmNameResolved = true; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Label; }
539};

541/// Represent a C++ namespace.
542class NamespaceDecl : public NamedDecl, public DeclContext,
                    public Redeclarable<NamespaceDecl>
544{
/// The starting location of the source range, pointing
/// to either the namespace or the inline keyword.
SourceLocation LocStart;

/// The ending location of the source range.
SourceLocation RBraceLoc;

/// A pointer to either the anonymous namespace that lives just inside
/// this namespace or to the first namespace in the chain (the latter case
/// only when this is not the first in the chain), along with a
/// boolean value indicating whether this is an inline namespace.
llvm::PointerIntPair<NamespaceDecl *, 1, bool> AnonOrFirstNamespaceAndInline;

NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
              SourceLocation StartLoc, SourceLocation IdLoc,
              IdentifierInfo *Id, NamespaceDecl *PrevDecl);

using redeclarable_base = Redeclarable<NamespaceDecl>;

NamespaceDecl *getNextRedeclarationImpl() override;
NamespaceDecl *getPreviousDeclImpl() override;
NamespaceDecl *getMostRecentDeclImpl() override;

568public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static NamespaceDecl *Create(ASTContext &C, DeclContext *DC,
                             bool Inline, SourceLocation StartLoc,
                             SourceLocation IdLoc, IdentifierInfo *Id,
                             NamespaceDecl *PrevDecl);

static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

/// Returns true if this is an anonymous namespace declaration.
///
/// For example:
/// \code
///   namespace {
///     ...
///   };
/// \endcode
/// q.v. C++ [namespace.unnamed]
bool isAnonymousNamespace() const {
  return !getIdentifier();
}

/// Returns true if this is an inline namespace declaration.
bool isInline() const {
  return AnonOrFirstNamespaceAndInline.getInt();
}

/// Set whether this is an inline namespace declaration.
void setInline(bool Inline) {
  AnonOrFirstNamespaceAndInline.setInt(Inline);
}

/// Returns true if the inline qualifier for \c Name is redundant.
bool isRedundantInlineQualifierFor(DeclarationName Name) const {
  if (!isInline())
    return false;
  auto X = lookup(Name);
  // We should not perform a lookup within a transparent context, so find a
  // non-transparent parent context.
  auto Y = getParent()->getNonTransparentContext()->lookup(Name);
  return std::distance(X.begin(), X.end()) ==
    std::distance(Y.begin(), Y.end());
}

/// Get the original (first) namespace declaration.
NamespaceDecl *getOriginalNamespace();

/// Get the original (first) namespace declaration.
const NamespaceDecl *getOriginalNamespace() const;

/// Return true if this declaration is an original (first) declaration
/// of the namespace. This is false for non-original (subsequent) namespace
/// declarations and anonymous namespaces.
bool isOriginalNamespace() const;

/// Retrieve the anonymous namespace nested inside this namespace,
/// if any.
NamespaceDecl *getAnonymousNamespace() const {
  return getOriginalNamespace()->AnonOrFirstNamespaceAndInline.getPointer();
}

void setAnonymousNamespace(NamespaceDecl *D) {
  getOriginalNamespace()->AnonOrFirstNamespaceAndInline.setPointer(D);
}

/// Retrieves the canonical declaration of this namespace.
NamespaceDecl *getCanonicalDecl() override {
  return getOriginalNamespace();
}
const NamespaceDecl *getCanonicalDecl() const {
  return getOriginalNamespace();
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(LocStart, RBraceLoc);
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LocStart; }
SourceLocation getRBraceLoc() const { return RBraceLoc; }
void setLocStart(SourceLocation L) { LocStart = L; }
void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Namespace; }
static DeclContext *castToDeclContext(const NamespaceDecl *D) {
  return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
}
static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
}
671};

673/// Represent the declaration of a variable (in which case it is
674/// an lvalue) a function (in which case it is a function designator) or
675/// an enum constant.
676class ValueDecl : public NamedDecl {
QualType DeclType;

void anchor() override;

681protected:
ValueDecl(Kind DK, DeclContext *DC, SourceLocation L,
          DeclarationName N, QualType T)
  : NamedDecl(DK, DC, L, N), DeclType(T) {}

686public:
QualType getType() const { return DeclType; }
void setType(QualType newType) { DeclType = newType; }

/// Determine whether this symbol is weakly-imported,
///        or declared with the weak or weak-ref attr.
bool isWeak() const;

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
697};

699/// A struct with extended info about a syntactic
700/// name qualifier, to be used for the case of out-of-line declarations.
701struct QualifierInfo {
NestedNameSpecifierLoc QualifierLoc;

/// The number of "outer" template parameter lists.
/// The count includes all of the template parameter lists that were matched
/// against the template-ids occurring into the NNS and possibly (in the
/// case of an explicit specialization) a final "template <>".
unsigned NumTemplParamLists = 0;

/// A new-allocated array of size NumTemplParamLists,
/// containing pointers to the "outer" template parameter lists.
/// It includes all of the template parameter lists that were matched
/// against the template-ids occurring into the NNS and possibly (in the
/// case of an explicit specialization) a final "template <>".
TemplateParameterList** TemplParamLists = nullptr;

QualifierInfo() = default;
QualifierInfo(const QualifierInfo &) = delete;
QualifierInfo& operator=(const QualifierInfo &) = delete;

/// Sets info about "outer" template parameter lists.
void setTemplateParameterListsInfo(ASTContext &Context,
                                   ArrayRef<TemplateParameterList *> TPLists);
724};

726/// Represents a ValueDecl that came out of a declarator.
727/// Contains type source information through TypeSourceInfo.
728class DeclaratorDecl : public ValueDecl {
// A struct representing a TInfo, a trailing requires-clause and a syntactic
// qualifier, to be used for the (uncommon) case of out-of-line declarations
// and constrained function decls.
struct ExtInfo : public QualifierInfo {
  TypeSourceInfo *TInfo;
  Expr *TrailingRequiresClause = nullptr;
};

llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;

/// The start of the source range for this declaration,
/// ignoring outer template declarations.
SourceLocation InnerLocStart;

bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }
ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }
const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }

747protected:
DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L,
               DeclarationName N, QualType T, TypeSourceInfo *TInfo,
               SourceLocation StartL)
    : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}

753public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

TypeSourceInfo *getTypeSourceInfo() const {
  return hasExtInfo()
    ? getExtInfo()->TInfo
    : DeclInfo.get<TypeSourceInfo*>();
}

void setTypeSourceInfo(TypeSourceInfo *TI) {
  if (hasExtInfo())
    getExtInfo()->TInfo = TI;
  else
    DeclInfo = TI;
}

/// Return start of source range ignoring outer template declarations.
SourceLocation getInnerLocStart() const { return InnerLocStart; }
void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }

/// Return start of source range taking into account any outer template
/// declarations.
SourceLocation getOuterLocStart() const;

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getOuterLocStart();
}

/// Retrieve the nested-name-specifier that qualifies the name of this
/// declaration, if it was present in the source.
NestedNameSpecifier *getQualifier() const {
  return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
                      : nullptr;
}

/// Retrieve the nested-name-specifier (with source-location
/// information) that qualifies the name of this declaration, if it was
/// present in the source.
NestedNameSpecifierLoc getQualifierLoc() const {
  return hasExtInfo() ? getExtInfo()->QualifierLoc
                      : NestedNameSpecifierLoc();
}

void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);

/// \brief Get the constraint-expression introduced by the trailing
/// requires-clause in the function/member declaration, or null if no
/// requires-clause was provided.
Expr *getTrailingRequiresClause() {
  return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
                      : nullptr;
}

const Expr *getTrailingRequiresClause() const {
  return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
                      : nullptr;
}

void setTrailingRequiresClause(Expr *TrailingRequiresClause);

unsigned getNumTemplateParameterLists() const {
  return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
}

TemplateParameterList *getTemplateParameterList(unsigned index) const {
  assert(index < getNumTemplateParameterLists())(static_cast <bool> (index < getNumTemplateParameterLists
()) ? void (0) : __assert_fail ("index < getNumTemplateParameterLists()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 821, __extension__ __PRETTY_FUNCTION__));
  return getExtInfo()->TemplParamLists[index];
}

void setTemplateParameterListsInfo(ASTContext &Context,
                                   ArrayRef<TemplateParameterList *> TPLists);

SourceLocation getTypeSpecStartLoc() const;
SourceLocation getTypeSpecEndLoc() const;

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstDeclarator && K <= lastDeclarator;
}
836};

838/// Structure used to store a statement, the constant value to
839/// which it was evaluated (if any), and whether or not the statement
840/// is an integral constant expression (if known).
841struct EvaluatedStmt {
/// Whether this statement was already evaluated.
bool WasEvaluated : 1;

/// Whether this statement is being evaluated.
bool IsEvaluating : 1;

/// Whether this variable is known to have constant initialization. This is
/// currently only computed in C++, for static / thread storage duration
/// variables that might have constant initialization and for variables that
/// are usable in constant expressions.
bool HasConstantInitialization : 1;

/// Whether this variable is known to have constant destruction. That is,
/// whether running the destructor on the initial value is a side-effect
/// (and doesn't inspect any state that might have changed during program
/// execution). This is currently only computed if the destructor is
/// non-trivial.
bool HasConstantDestruction : 1;

/// In C++98, whether the initializer is an ICE. This affects whether the
/// variable is usable in constant expressions.
bool HasICEInit : 1;
bool CheckedForICEInit : 1;

Stmt *Value;
APValue Evaluated;

EvaluatedStmt()
    : WasEvaluated(false), IsEvaluating(false),
      HasConstantInitialization(false), HasConstantDestruction(false),
      HasICEInit(false), CheckedForICEInit(false) {}
873};

875/// Represents a variable declaration or definition.
876class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
877public:
/// Initialization styles.
enum InitializationStyle {
  /// C-style initialization with assignment
  CInit,

  /// Call-style initialization (C++98)
  CallInit,

  /// Direct list-initialization (C++11)
  ListInit
};

/// Kinds of thread-local storage.
enum TLSKind {
  /// Not a TLS variable.
  TLS_None,

  /// TLS with a known-constant initializer.
  TLS_Static,

  /// TLS with a dynamic initializer.
  TLS_Dynamic
};

/// Return the string used to specify the storage class \p SC.
///
/// It is illegal to call this function with SC == None.
static const char *getStorageClassSpecifierString(StorageClass SC);

907protected:
// A pointer union of Stmt * and EvaluatedStmt *. When an EvaluatedStmt, we
// have allocated the auxiliary struct of information there.
//
// TODO: It is a bit unfortunate to use a PointerUnion inside the VarDecl for
// this as *many* VarDecls are ParmVarDecls that don't have default
// arguments. We could save some space by moving this pointer union to be
// allocated in trailing space when necessary.
using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;

/// The initializer for this variable or, for a ParmVarDecl, the
/// C++ default argument.
mutable InitType Init;

921private:
friend class ASTDeclReader;
friend class ASTNodeImporter;
friend class StmtIteratorBase;

class VarDeclBitfields {
  friend class ASTDeclReader;
  friend class VarDecl;

  unsigned SClass : 3;
  unsigned TSCSpec : 2;
  unsigned InitStyle : 2;

  /// Whether this variable is an ARC pseudo-__strong variable; see
  /// isARCPseudoStrong() for details.
  unsigned ARCPseudoStrong : 1;
};
enum { NumVarDeclBits = 8 };

940protected:
enum { NumParameterIndexBits = 8 };

enum DefaultArgKind {
  DAK_None,
  DAK_Unparsed,
  DAK_Uninstantiated,
  DAK_Normal
};

enum { NumScopeDepthOrObjCQualsBits = 7 };

class ParmVarDeclBitfields {
  friend class ASTDeclReader;
  friend class ParmVarDecl;

  unsigned : NumVarDeclBits;

  /// Whether this parameter inherits a default argument from a
  /// prior declaration.
  unsigned HasInheritedDefaultArg : 1;

  /// Describes the kind of default argument for this parameter. By default
  /// this is none. If this is normal, then the default argument is stored in
  /// the \c VarDecl initializer expression unless we were unable to parse
  /// (even an invalid) expression for the default argument.
  unsigned DefaultArgKind : 2;

  /// Whether this parameter undergoes K&R argument promotion.
  unsigned IsKNRPromoted : 1;

  /// Whether this parameter is an ObjC method parameter or not.
  unsigned IsObjCMethodParam : 1;

  /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
  /// Otherwise, the number of function parameter scopes enclosing
  /// the function parameter scope in which this parameter was
  /// declared.
  unsigned ScopeDepthOrObjCQuals : NumScopeDepthOrObjCQualsBits;

  /// The number of parameters preceding this parameter in the
  /// function parameter scope in which it was declared.
  unsigned ParameterIndex : NumParameterIndexBits;
};

class NonParmVarDeclBitfields {
  friend class ASTDeclReader;
  friend class ImplicitParamDecl;
  friend class VarDecl;

  unsigned : NumVarDeclBits;

  // FIXME: We need something similar to CXXRecordDecl::DefinitionData.
  /// Whether this variable is a definition which was demoted due to
  /// module merge.
  unsigned IsThisDeclarationADemotedDefinition : 1;

  /// Whether this variable is the exception variable in a C++ catch
  /// or an Objective-C @catch statement.
  unsigned ExceptionVar : 1;

  /// Whether this local variable could be allocated in the return
  /// slot of its function, enabling the named return value optimization
  /// (NRVO).
  unsigned NRVOVariable : 1;

  /// Whether this variable is the for-range-declaration in a C++0x
  /// for-range statement.
  unsigned CXXForRangeDecl : 1;

  /// Whether this variable is the for-in loop declaration in Objective-C.
  unsigned ObjCForDecl : 1;

  /// Whether this variable is (C++1z) inline.
  unsigned IsInline : 1;

  /// Whether this variable has (C++1z) inline explicitly specified.
  unsigned IsInlineSpecified : 1;

  /// Whether this variable is (C++0x) constexpr.
  unsigned IsConstexpr : 1;

  /// Whether this variable is the implicit variable for a lambda
  /// init-capture.
  unsigned IsInitCapture : 1;

  /// Whether this local extern variable's previous declaration was
  /// declared in the same block scope. This controls whether we should merge
  /// the type of this declaration with its previous declaration.
  unsigned PreviousDeclInSameBlockScope : 1;

  /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or
  /// something else.
  unsigned ImplicitParamKind : 3;

  unsigned EscapingByref : 1;
};

union {
  unsigned AllBits;
  VarDeclBitfields VarDeclBits;
  ParmVarDeclBitfields ParmVarDeclBits;
  NonParmVarDeclBitfields NonParmVarDeclBits;
};

VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
        SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
        TypeSourceInfo *TInfo, StorageClass SC);

using redeclarable_base = Redeclarable<VarDecl>;

VarDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

VarDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

VarDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

1063public:
using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

static VarDecl *Create(ASTContext &C, DeclContext *DC,
                       SourceLocation StartLoc, SourceLocation IdLoc,
                       IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
                       StorageClass S);

static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

/// Returns the storage class as written in the source. For the
/// computed linkage of symbol, see getLinkage.
StorageClass getStorageClass() const {
  return (StorageClass) VarDeclBits.SClass;
}
void setStorageClass(StorageClass SC);

void setTSCSpec(ThreadStorageClassSpecifier TSC) {
  VarDeclBits.TSCSpec = TSC;
  assert(VarDeclBits.TSCSpec == TSC && "truncation")(static_cast <bool> (VarDeclBits.TSCSpec == TSC &&
 "truncation") ? void (0) : __assert_fail ("VarDeclBits.TSCSpec == TSC && \"truncation\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1092, __extension__ __PRETTY_FUNCTION__));
}
ThreadStorageClassSpecifier getTSCSpec() const {
  return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
}
TLSKind getTLSKind() const;

/// Returns true if a variable with function scope is a non-static local
/// variable.
bool hasLocalStorage() const {
  if (getStorageClass() == SC_None) {
    // OpenCL v1.2 s6.5.3: The __constant or constant address space name is
    // used to describe variables allocated in global memory and which are
    // accessed inside a kernel(s) as read-only variables. As such, variables
    // in constant address space cannot have local storage.
    if (getType().getAddressSpace() == LangAS::opencl_constant)
      return false;
    // Second check is for C++11 [dcl.stc]p4.
    return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
  }

  // Global Named Register (GNU extension)
  if (getStorageClass() == SC_Register && !isLocalVarDeclOrParm())
    return false;

  // Return true for:  Auto, Register.
  // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.

  return getStorageClass() >= SC_Auto;
}

/// Returns true if a variable with function scope is a static local
/// variable.
bool isStaticLocal() const {
  return (getStorageClass() == SC_Static ||
          // C++11 [dcl.stc]p4
          (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))
    && !isFileVarDecl();
}

/// Returns true if a variable has extern or __private_extern__
/// storage.
bool hasExternalStorage() const {
  return getStorageClass() == SC_Extern ||
         getStorageClass() == SC_PrivateExtern;
}

/// Returns true for all variables that do not have local storage.
///
/// This includes all global variables as well as static variables declared
/// within a function.
bool hasGlobalStorage() const { return !hasLocalStorage(); }

/// Get the storage duration of this variable, per C++ [basic.stc].
StorageDuration getStorageDuration() const {
  return hasLocalStorage() ? SD_Automatic :
         getTSCSpec() ? SD_Thread : SD_Static;
}

/// Compute the language linkage.
LanguageLinkage getLanguageLinkage() const;

/// Determines whether this variable is a variable with external, C linkage.
bool isExternC() const;

/// Determines whether this variable's context is, or is nested within,
/// a C++ extern "C" linkage spec.
bool isInExternCContext() const;

/// Determines whether this variable's context is, or is nested within,
/// a C++ extern "C++" linkage spec.
bool isInExternCXXContext() const;

/// Returns true for local variable declarations other than parameters.
/// Note that this includes static variables inside of functions. It also
/// includes variables inside blocks.
///
///   void foo() { int x; static int y; extern int z; }
bool isLocalVarDecl() const {
  if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
    return false;
  if (const DeclContext *DC = getLexicalDeclContext())
    return DC->getRedeclContext()->isFunctionOrMethod();
  return false;
}

/// Similar to isLocalVarDecl but also includes parameters.
bool isLocalVarDeclOrParm() const {
  return isLocalVarDecl() || getKind() == Decl::ParmVar;
}

/// Similar to isLocalVarDecl, but excludes variables declared in blocks.
bool isFunctionOrMethodVarDecl() const {
  if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
    return false;
  const DeclContext *DC = getLexicalDeclContext()->getRedeclContext();
  return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;
}

/// Determines whether this is a static data member.
///
/// This will only be true in C++, and applies to, e.g., the
/// variable 'x' in:
/// \code
/// struct S {
///   static int x;
/// };
/// \endcode
bool isStaticDataMember() const {
  // If it wasn't static, it would be a FieldDecl.
  return getKind() != Decl::ParmVar && getDeclContext()->isRecord();
}

VarDecl *getCanonicalDecl() override;
const VarDecl *getCanonicalDecl() const {
  return const_cast<VarDecl*>(this)->getCanonicalDecl();
}

enum DefinitionKind {
  /// This declaration is only a declaration.
  DeclarationOnly,

  /// This declaration is a tentative definition.
  TentativeDefinition,

  /// This declaration is definitely a definition.
  Definition
};

/// Check whether this declaration is a definition. If this could be
/// a tentative definition (in C), don't check whether there's an overriding
/// definition.
DefinitionKind isThisDeclarationADefinition(ASTContext &) const;
DefinitionKind isThisDeclarationADefinition() const {
  return isThisDeclarationADefinition(getASTContext());
}

/// Check whether this variable is defined in this translation unit.
DefinitionKind hasDefinition(ASTContext &) const;
DefinitionKind hasDefinition() const {
  return hasDefinition(getASTContext());
}

/// Get the tentative definition that acts as the real definition in a TU.
/// Returns null if there is a proper definition available.
VarDecl *getActingDefinition();
const VarDecl *getActingDefinition() const {
  return const_cast<VarDecl*>(this)->getActingDefinition();
}

/// Get the real (not just tentative) definition for this declaration.
VarDecl *getDefinition(ASTContext &);
const VarDecl *getDefinition(ASTContext &C) const {
  return const_cast<VarDecl*>(this)->getDefinition(C);
}
VarDecl *getDefinition() {
  return getDefinition(getASTContext());
}
const VarDecl *getDefinition() const {
  return const_cast<VarDecl*>(this)->getDefinition();
}

/// Determine whether this is or was instantiated from an out-of-line
/// definition of a static data member.
bool isOutOfLine() const override;

/// Returns true for file scoped variable declaration.
bool isFileVarDecl() const {
  Kind K = getKind();
  if (K == ParmVar || K == ImplicitParam)
    return false;

  if (getLexicalDeclContext()->getRedeclContext()->isFileContext())
    return true;

  if (isStaticDataMember())
    return true;

  return false;
}

/// Get the initializer for this variable, no matter which
/// declaration it is attached to.
const Expr *getAnyInitializer() const {
  const VarDecl *D;
  return getAnyInitializer(D);
}

/// Get the initializer for this variable, no matter which
/// declaration it is attached to. Also get that declaration.
const Expr *getAnyInitializer(const VarDecl *&D) const;

bool hasInit() const;
const Expr *getInit() const {
  return const_cast<VarDecl *>(this)->getInit();
}
Expr *getInit();

/// Retrieve the address of the initializer expression.
Stmt **getInitAddress();

void setInit(Expr *I);

/// Get the initializing declaration of this variable, if any. This is
/// usually the definition, except that for a static data member it can be
/// the in-class declaration.
VarDecl *getInitializingDeclaration();
const VarDecl *getInitializingDeclaration() const {
  return const_cast<VarDecl *>(this)->getInitializingDeclaration();
}

/// Determine whether this variable's value might be usable in a
/// constant expression, according to the relevant language standard.
/// This only checks properties of the declaration, and does not check
/// whether the initializer is in fact a constant expression.
///
/// This corresponds to C++20 [expr.const]p3's notion of a
/// "potentially-constant" variable.
bool mightBeUsableInConstantExpressions(const ASTContext &C) const;

/// Determine whether this variable's value can be used in a
/// constant expression, according to the relevant language standard,
/// including checking whether it was initialized by a constant expression.
bool isUsableInConstantExpressions(const ASTContext &C) const;

EvaluatedStmt *ensureEvaluatedStmt() const;
EvaluatedStmt *getEvaluatedStmt() const;

/// Attempt to evaluate the value of the initializer attached to this
/// declaration, and produce notes explaining why it cannot be evaluated.
/// Returns a pointer to the value if evaluation succeeded, 0 otherwise.
APValue *evaluateValue() const;

1325private:
APValue *evaluateValueImpl(SmallVectorImpl<PartialDiagnosticAt> &Notes,
                           bool IsConstantInitialization) const;

1329public:
/// Return the already-evaluated value of this variable's
/// initializer, or NULL if the value is not yet known. Returns pointer
/// to untyped APValue if the value could not be evaluated.
APValue *getEvaluatedValue() const;

/// Evaluate the destruction of this variable to determine if it constitutes
/// constant destruction.
///
/// \pre hasConstantInitialization()
/// \return \c true if this variable has constant destruction, \c false if
///         not.
bool evaluateDestruction(SmallVectorImpl<PartialDiagnosticAt> &Notes) const;

/// Determine whether this variable has constant initialization.
///
/// This is only set in two cases: when the language semantics require
/// constant initialization (globals in C and some globals in C++), and when
/// the variable is usable in constant expressions (constexpr, const int, and
/// reference variables in C++).
bool hasConstantInitialization() const;

/// Determine whether the initializer of this variable is an integer constant
/// expression. For use in C++98, where this affects whether the variable is
/// usable in constant expressions.
bool hasICEInitializer(const ASTContext &Context) const;

/// Evaluate the initializer of this variable to determine whether it's a
/// constant initializer. Should only be called once, after completing the
/// definition of the variable.
bool checkForConstantInitialization(
    SmallVectorImpl<PartialDiagnosticAt> &Notes) const;

void setInitStyle(InitializationStyle Style) {
  VarDeclBits.InitStyle = Style;
}

/// The style of initialization for this declaration.
///
/// C-style initialization is "int x = 1;". Call-style initialization is
/// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
/// the expression inside the parens or a "ClassType(a,b,c)" class constructor
/// expression for class types. List-style initialization is C++11 syntax,
/// e.g. "int x{1};". Clients can distinguish between different forms of
/// initialization by checking this value. In particular, "int x = {1};" is
/// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the
/// Init expression in all three cases is an InitListExpr.
InitializationStyle getInitStyle() const {
  return static_cast<InitializationStyle>(VarDeclBits.InitStyle);
}

/// Whether the initializer is a direct-initializer (list or call).
bool isDirectInit() const {
  return getInitStyle() != CInit;
}

/// If this definition should pretend to be a declaration.
bool isThisDeclarationADemotedDefinition() const {
  return isa<ParmVarDecl>(this) ? false :
    NonParmVarDeclBits.IsThisDeclarationADemotedDefinition;
}

/// This is a definition which should be demoted to a declaration.
///
/// In some cases (mostly module merging) we can end up with two visible
/// definitions one of which needs to be demoted to a declaration to keep
/// the AST invariants.
void demoteThisDefinitionToDeclaration() {
  assert(isThisDeclarationADefinition() && "Not a definition!")(static_cast <bool> (isThisDeclarationADefinition() &&
 "Not a definition!") ? void (0) : __assert_fail ("isThisDeclarationADefinition() && \"Not a definition!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1397, __extension__ __PRETTY_FUNCTION__));
  assert(!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!")(static_cast <bool> (!isa<ParmVarDecl>(this) &&
 "Cannot demote ParmVarDecls!") ? void (0) : __assert_fail ("!isa<ParmVarDecl>(this) && \"Cannot demote ParmVarDecls!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1398, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;
}

/// Determine whether this variable is the exception variable in a
/// C++ catch statememt or an Objective-C \@catch statement.
bool isExceptionVariable() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;
}
void setExceptionVariable(bool EV) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1408, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.ExceptionVar = EV;
}

/// Determine whether this local variable can be used with the named
/// return value optimization (NRVO).
///
/// The named return value optimization (NRVO) works by marking certain
/// non-volatile local variables of class type as NRVO objects. These
/// locals can be allocated within the return slot of their containing
/// function, in which case there is no need to copy the object to the
/// return slot when returning from the function. Within the function body,
/// each return that returns the NRVO object will have this variable as its
/// NRVO candidate.
bool isNRVOVariable() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.NRVOVariable;
}
void setNRVOVariable(bool NRVO) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1426, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.NRVOVariable = NRVO;
}

/// Determine whether this variable is the for-range-declaration in
/// a C++0x for-range statement.
bool isCXXForRangeDecl() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.CXXForRangeDecl;
}
void setCXXForRangeDecl(bool FRD) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1436, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.CXXForRangeDecl = FRD;
}

/// Determine whether this variable is a for-loop declaration for a
/// for-in statement in Objective-C.
bool isObjCForDecl() const {
  return NonParmVarDeclBits.ObjCForDecl;
}

void setObjCForDecl(bool FRD) {
  NonParmVarDeclBits.ObjCForDecl = FRD;
}

/// Determine whether this variable is an ARC pseudo-__strong variable. A
/// pseudo-__strong variable has a __strong-qualified type but does not
/// actually retain the object written into it. Generally such variables are
/// also 'const' for safety. There are 3 cases where this will be set, 1) if
/// the variable is annotated with the objc_externally_retained attribute, 2)
/// if its 'self' in a non-init method, or 3) if its the variable in an for-in
/// loop.
bool isARCPseudoStrong() const { return VarDeclBits.ARCPseudoStrong; }
void setARCPseudoStrong(bool PS) { VarDeclBits.ARCPseudoStrong = PS; }

/// Whether this variable is (C++1z) inline.
bool isInline() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInline;
}
bool isInlineSpecified() const {
  return isa<ParmVarDecl>(this) ? false
                                : NonParmVarDeclBits.IsInlineSpecified;
}
void setInlineSpecified() {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1469, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsInline = true;
  NonParmVarDeclBits.IsInlineSpecified = true;
}
void setImplicitlyInline() {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1474, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsInline = true;
}

/// Whether this variable is (C++11) constexpr.
bool isConstexpr() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;
}
void setConstexpr(bool IC) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1483, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsConstexpr = IC;
}

/// Whether this variable is the implicit variable for a lambda init-capture.
bool isInitCapture() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
}
void setInitCapture(bool IC) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1492, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsInitCapture = IC;
}

/// Determine whether this variable is actually a function parameter pack or
/// init-capture pack.
bool isParameterPack() const;

/// Whether this local extern variable declaration's previous declaration
/// was declared in the same block scope. Only correct in C++.
bool isPreviousDeclInSameBlockScope() const {
  return isa<ParmVarDecl>(this)
             ? false
             : NonParmVarDeclBits.PreviousDeclInSameBlockScope;
}
void setPreviousDeclInSameBlockScope(bool Same) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1508, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.PreviousDeclInSameBlockScope = Same;
}

/// Indicates the capture is a __block variable that is captured by a block
/// that can potentially escape (a block for which BlockDecl::doesNotEscape
/// returns false).
bool isEscapingByref() const;

/// Indicates the capture is a __block variable that is never captured by an
/// escaping block.
bool isNonEscapingByref() const;

void setEscapingByref() {
  NonParmVarDeclBits.EscapingByref = true;
}

/// Determines if this variable's alignment is dependent.
bool hasDependentAlignment() const;

/// Retrieve the variable declaration from which this variable could
/// be instantiated, if it is an instantiation (rather than a non-template).
VarDecl *getTemplateInstantiationPattern() const;

/// If this variable is an instantiated static data member of a
/// class template specialization, returns the templated static data member
/// from which it was instantiated.
VarDecl *getInstantiatedFromStaticDataMember() const;

/// If this variable is an instantiation of a variable template or a
/// static data member of a class template, determine what kind of
/// template specialization or instantiation this is.
TemplateSpecializationKind getTemplateSpecializationKind() const;

/// Get the template specialization kind of this variable for the purposes of
/// template instantiation. This differs from getTemplateSpecializationKind()
/// for an instantiation of a class-scope explicit specialization.
TemplateSpecializationKind
getTemplateSpecializationKindForInstantiation() const;

/// If this variable is an instantiation of a variable template or a
/// static data member of a class template, determine its point of
/// instantiation.
SourceLocation getPointOfInstantiation() const;

/// If this variable is an instantiation of a static data member of a
/// class template specialization, retrieves the member specialization
/// information.
MemberSpecializationInfo *getMemberSpecializationInfo() const;

/// For a static data member that was instantiated from a static
/// data member of a class template, set the template specialiation kind.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
                      SourceLocation PointOfInstantiation = SourceLocation());

/// Specify that this variable is an instantiation of the
/// static data member VD.
void setInstantiationOfStaticDataMember(VarDecl *VD,
                                        TemplateSpecializationKind TSK);

/// Retrieves the variable template that is described by this
/// variable declaration.
///
/// Every variable template is represented as a VarTemplateDecl and a
/// VarDecl. The former contains template properties (such as
/// the template parameter lists) while the latter contains the
/// actual description of the template's
/// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
/// VarDecl that from a VarTemplateDecl, while
/// getDescribedVarTemplate() retrieves the VarTemplateDecl from
/// a VarDecl.
VarTemplateDecl *getDescribedVarTemplate() const;

void setDescribedVarTemplate(VarTemplateDecl *Template);

// Is this variable known to have a definition somewhere in the complete
// program? This may be true even if the declaration has internal linkage and
// has no definition within this source file.
bool isKnownToBeDefined() const;

/// Is destruction of this variable entirely suppressed? If so, the variable
/// need not have a usable destructor at all.
bool isNoDestroy(const ASTContext &) const;

/// Would the destruction of this variable have any effect, and if so, what
/// kind?
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const;

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
1599};

1601class ImplicitParamDecl : public VarDecl {
void anchor() override;

1604public:
/// Defines the kind of the implicit parameter: is this an implicit parameter
/// with pointer to 'this', 'self', '_cmd', virtual table pointers, captured
/// context or something else.
enum ImplicitParamKind : unsigned {
  /// Parameter for Objective-C 'self' argument
  ObjCSelf,

  /// Parameter for Objective-C '_cmd' argument
  ObjCCmd,

  /// Parameter for C++ 'this' argument
  CXXThis,

  /// Parameter for C++ virtual table pointers
  CXXVTT,

  /// Parameter for captured context
  CapturedContext,

  /// Other implicit parameter
  Other,
};

/// Create implicit parameter.
static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
                                 SourceLocation IdLoc, IdentifierInfo *Id,
                                 QualType T, ImplicitParamKind ParamKind);
static ImplicitParamDecl *Create(ASTContext &C, QualType T,
                                 ImplicitParamKind ParamKind);

static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);

ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc,
                  IdentifierInfo *Id, QualType Type,
                  ImplicitParamKind ParamKind)
    : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
              /*TInfo=*/nullptr, SC_None) {
  NonParmVarDeclBits.ImplicitParamKind = ParamKind;
  setImplicit();
}

ImplicitParamDecl(ASTContext &C, QualType Type, ImplicitParamKind ParamKind)
    : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),
              SourceLocation(), /*Id=*/nullptr, Type,
              /*TInfo=*/nullptr, SC_None) {
  NonParmVarDeclBits.ImplicitParamKind = ParamKind;
  setImplicit();
}

/// Returns the implicit parameter kind.
ImplicitParamKind getParameterKind() const {
  return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ImplicitParam; }
1662};

1664/// Represents a parameter to a function.
1665class ParmVarDecl : public VarDecl {
1666public:
enum { MaxFunctionScopeDepth = 255 };
enum { MaxFunctionScopeIndex = 255 };

1670protected:
ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
            SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
            TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
    : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
  assert(ParmVarDeclBits.HasInheritedDefaultArg == false)(static_cast <bool> (ParmVarDeclBits.HasInheritedDefaultArg
 == false) ? void (0) : __assert_fail ("ParmVarDeclBits.HasInheritedDefaultArg == false"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1675, __extension__ __PRETTY_FUNCTION__));
  assert(ParmVarDeclBits.DefaultArgKind == DAK_None)(static_cast <bool> (ParmVarDeclBits.DefaultArgKind == DAK_None
) ? void (0) : __assert_fail ("ParmVarDeclBits.DefaultArgKind == DAK_None"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1676, __extension__ __PRETTY_FUNCTION__));
  assert(ParmVarDeclBits.IsKNRPromoted == false)(static_cast <bool> (ParmVarDeclBits.IsKNRPromoted == false
) ? void (0) : __assert_fail ("ParmVarDeclBits.IsKNRPromoted == false"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1677, __extension__ __PRETTY_FUNCTION__));
  assert(ParmVarDeclBits.IsObjCMethodParam == false)(static_cast <bool> (ParmVarDeclBits.IsObjCMethodParam ==
 false) ? void (0) : __assert_fail ("ParmVarDeclBits.IsObjCMethodParam == false"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1678, __extension__ __PRETTY_FUNCTION__));
  setDefaultArg(DefArg);
}

1682public:
static ParmVarDecl *Create(ASTContext &C, DeclContext *DC,
                           SourceLocation StartLoc,
                           SourceLocation IdLoc, IdentifierInfo *Id,
                           QualType T, TypeSourceInfo *TInfo,
                           StorageClass S, Expr *DefArg);

static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

void setObjCMethodScopeInfo(unsigned parameterIndex) {
  ParmVarDeclBits.IsObjCMethodParam = true;
  setParameterIndex(parameterIndex);
}

void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) {
  assert(!ParmVarDeclBits.IsObjCMethodParam)(static_cast <bool> (!ParmVarDeclBits.IsObjCMethodParam
) ? void (0) : __assert_fail ("!ParmVarDeclBits.IsObjCMethodParam"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1699, __extension__ __PRETTY_FUNCTION__));

  ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth;
  assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth(static_cast <bool> (ParmVarDeclBits.ScopeDepthOrObjCQuals
 == scopeDepth && "truncation!") ? void (0) : __assert_fail
 ("ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth && \"truncation!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1703, __extension__ __PRETTY_FUNCTION__))
         && "truncation!")(static_cast <bool> (ParmVarDeclBits.ScopeDepthOrObjCQuals
 == scopeDepth && "truncation!") ? void (0) : __assert_fail
 ("ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth && \"truncation!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1703, __extension__ __PRETTY_FUNCTION__));

  setParameterIndex(parameterIndex);
}

bool isObjCMethodParameter() const {
  return ParmVarDeclBits.IsObjCMethodParam;
}

/// Determines whether this parameter is destroyed in the callee function.
bool isDestroyedInCallee() const;

unsigned getFunctionScopeDepth() const {
  if (ParmVarDeclBits.IsObjCMethodParam) return 0;
  return ParmVarDeclBits.ScopeDepthOrObjCQuals;
}

static constexpr unsigned getMaxFunctionScopeDepth() {
  return (1u << NumScopeDepthOrObjCQualsBits) - 1;
}

/// Returns the index of this parameter in its prototype or method scope.
unsigned getFunctionScopeIndex() const {
  return getParameterIndex();
}

ObjCDeclQualifier getObjCDeclQualifier() const {
  if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None;
  return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals);
}
void setObjCDeclQualifier(ObjCDeclQualifier QTVal) {
  assert(ParmVarDeclBits.IsObjCMethodParam)(static_cast <bool> (ParmVarDeclBits.IsObjCMethodParam)
 ? void (0) : __assert_fail ("ParmVarDeclBits.IsObjCMethodParam"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1734, __extension__ __PRETTY_FUNCTION__));
  ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal;
}

/// True if the value passed to this parameter must undergo
/// K&R-style default argument promotion:
///
/// C99 6.5.2.2.
///   If the expression that denotes the called function has a type
///   that does not include a prototype, the integer promotions are
///   performed on each argument, and arguments that have type float
///   are promoted to double.
bool isKNRPromoted() const {
  return ParmVarDeclBits.IsKNRPromoted;
}
void setKNRPromoted(bool promoted) {
  ParmVarDeclBits.IsKNRPromoted = promoted;
}

Expr *getDefaultArg();
const Expr *getDefaultArg() const {
  return const_cast<ParmVarDecl *>(this)->getDefaultArg();
}

void setDefaultArg(Expr *defarg);

/// Retrieve the source range that covers the entire default
/// argument.
SourceRange getDefaultArgRange() const;
void setUninstantiatedDefaultArg(Expr *arg);
Expr *getUninstantiatedDefaultArg();
const Expr *getUninstantiatedDefaultArg() const {
  return const_cast<ParmVarDecl *>(this)->getUninstantiatedDefaultArg();
}

/// Determines whether this parameter has a default argument,
/// either parsed or not.
bool hasDefaultArg() const;

/// Determines whether this parameter has a default argument that has not
/// yet been parsed. This will occur during the processing of a C++ class
/// whose member functions have default arguments, e.g.,
/// @code
///   class X {
///   public:
///     void f(int x = 17); // x has an unparsed default argument now
///   }; // x has a regular default argument now
/// @endcode
bool hasUnparsedDefaultArg() const {
  return ParmVarDeclBits.DefaultArgKind == DAK_Unparsed;
}

bool hasUninstantiatedDefaultArg() const {
  return ParmVarDeclBits.DefaultArgKind == DAK_Uninstantiated;
}

/// Specify that this parameter has an unparsed default argument.
/// The argument will be replaced with a real default argument via
/// setDefaultArg when the class definition enclosing the function
/// declaration that owns this default argument is completed.
void setUnparsedDefaultArg() {
  ParmVarDeclBits.DefaultArgKind = DAK_Unparsed;
}

bool hasInheritedDefaultArg() const {
  return ParmVarDeclBits.HasInheritedDefaultArg;
}

void setHasInheritedDefaultArg(bool I = true) {
  ParmVarDeclBits.HasInheritedDefaultArg = I;
}

QualType getOriginalType() const;

/// Sets the function declaration that owns this
/// ParmVarDecl. Since ParmVarDecls are often created before the
/// FunctionDecls that own them, this routine is required to update
/// the DeclContext appropriately.
void setOwningFunction(DeclContext *FD) { setDeclContext(FD); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ParmVar; }

1818private:
enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };

void setParameterIndex(unsigned parameterIndex) {
  if (parameterIndex >= ParameterIndexSentinel) {
    setParameterIndexLarge(parameterIndex);
    return;
  }

  ParmVarDeclBits.ParameterIndex = parameterIndex;
  assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!")(static_cast <bool> (ParmVarDeclBits.ParameterIndex == parameterIndex
 && "truncation!") ? void (0) : __assert_fail ("ParmVarDeclBits.ParameterIndex == parameterIndex && \"truncation!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 1828, __extension__ __PRETTY_FUNCTION__));
}
unsigned getParameterIndex() const {
  unsigned d = ParmVarDeclBits.ParameterIndex;
  return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
}

void setParameterIndexLarge(unsigned parameterIndex);
unsigned getParameterIndexLarge() const;
1837};

1839enum class MultiVersionKind {
None,
Target,
CPUSpecific,
CPUDispatch
1844};

1846/// Represents a function declaration or definition.
1847///
1848/// Since a given function can be declared several times in a program,
1849/// there may be several FunctionDecls that correspond to that
1850/// function. Only one of those FunctionDecls will be found when
1851/// traversing the list of declarations in the context of the
1852/// FunctionDecl (e.g., the translation unit); this FunctionDecl
1853/// contains all of the information known about the function. Other,
1854/// previous declarations of the function are available via the
1855/// getPreviousDecl() chain.
1856class FunctionDecl : public DeclaratorDecl,
                   public DeclContext,
                   public Redeclarable<FunctionDecl> {
// This class stores some data in DeclContext::FunctionDeclBits
// to save some space. Use the provided accessors to access it.
1861public:
/// The kind of templated function a FunctionDecl can be.
enum TemplatedKind {
  // Not templated.
  TK_NonTemplate,
  // The pattern in a function template declaration.
  TK_FunctionTemplate,
  // A non-template function that is an instantiation or explicit
  // specialization of a member of a templated class.
  TK_MemberSpecialization,
  // An instantiation or explicit specialization of a function template.
  // Note: this might have been instantiated from a templated class if it
  // is a class-scope explicit specialization.
  TK_FunctionTemplateSpecialization,
  // A function template specialization that hasn't yet been resolved to a
  // particular specialized function template.
  TK_DependentFunctionTemplateSpecialization
};

/// Stashed information about a defaulted function definition whose body has
/// not yet been lazily generated.
class DefaultedFunctionInfo final
    : llvm::TrailingObjects<DefaultedFunctionInfo, DeclAccessPair> {
  friend TrailingObjects;
  unsigned NumLookups;

public:
  static DefaultedFunctionInfo *Create(ASTContext &Context,
                                       ArrayRef<DeclAccessPair> Lookups);
  /// Get the unqualified lookup results that should be used in this
  /// defaulted function definition.
  ArrayRef<DeclAccessPair> getUnqualifiedLookups() const {
    return {getTrailingObjects<DeclAccessPair>(), NumLookups};
  }
};

1897private:
/// A new[]'d array of pointers to VarDecls for the formal
/// parameters of this function.  This is null if a prototype or if there are
/// no formals.
ParmVarDecl **ParamInfo = nullptr;

/// The active member of this union is determined by
/// FunctionDeclBits.HasDefaultedFunctionInfo.
union {
  /// The body of the function.
  LazyDeclStmtPtr Body;
  /// Information about a future defaulted function definition.
  DefaultedFunctionInfo *DefaultedInfo;
};

unsigned ODRHash;

/// End part of this FunctionDecl's source range.
///
/// We could compute the full range in getSourceRange(). However, when we're
/// dealing with a function definition deserialized from a PCH/AST file,
/// we can only compute the full range once the function body has been
/// de-serialized, so it's far better to have the (sometimes-redundant)
/// EndRangeLoc.
SourceLocation EndRangeLoc;

/// The template or declaration that this declaration
/// describes or was instantiated from, respectively.
///
/// For non-templates, this value will be NULL. For function
/// declarations that describe a function template, this will be a
/// pointer to a FunctionTemplateDecl. For member functions
/// of class template specializations, this will be a MemberSpecializationInfo
/// pointer containing information about the specialization.
/// For function template specializations, this will be a
/// FunctionTemplateSpecializationInfo, which contains information about
/// the template being specialized and the template arguments involved in
/// that specialization.
llvm::PointerUnion<FunctionTemplateDecl *,
                   MemberSpecializationInfo *,
                   FunctionTemplateSpecializationInfo *,
                   DependentFunctionTemplateSpecializationInfo *>
  TemplateOrSpecialization;

/// Provides source/type location info for the declaration name embedded in
/// the DeclaratorDecl base class.
DeclarationNameLoc DNLoc;

/// Specify that this function declaration is actually a function
/// template specialization.
///
/// \param C the ASTContext.
///
/// \param Template the function template that this function template
/// specialization specializes.
///
/// \param TemplateArgs the template arguments that produced this
/// function template specialization from the template.
///
/// \param InsertPos If non-NULL, the position in the function template
/// specialization set where the function template specialization data will
/// be inserted.
///
/// \param TSK the kind of template specialization this is.
///
/// \param TemplateArgsAsWritten location info of template arguments.
///
/// \param PointOfInstantiation point at which the function template
/// specialization was first instantiated.
void setFunctionTemplateSpecialization(ASTContext &C,
                                       FunctionTemplateDecl *Template,
                                     const TemplateArgumentList *TemplateArgs,
                                       void *InsertPos,
                                       TemplateSpecializationKind TSK,
                        const TemplateArgumentListInfo *TemplateArgsAsWritten,
                                       SourceLocation PointOfInstantiation);

/// Specify that this record is an instantiation of the
/// member function FD.
void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
                                      TemplateSpecializationKind TSK);

void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);

// This is unfortunately needed because ASTDeclWriter::VisitFunctionDecl
// need to access this bit but we want to avoid making ASTDeclWriter
// a friend of FunctionDeclBitfields just for this.
bool isDeletedBit() const { return FunctionDeclBits.IsDeleted; }

/// Whether an ODRHash has been stored.
bool hasODRHash() const { return FunctionDeclBits.HasODRHash; }

/// State that an ODRHash has been stored.
void setHasODRHash(bool B = true) { FunctionDeclBits.HasODRHash = B; }

1992protected:
FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
             const DeclarationNameInfo &NameInfo, QualType T,
             TypeSourceInfo *TInfo, StorageClass S, bool UsesFPIntrin,
             bool isInlineSpecified, ConstexprSpecKind ConstexprKind,
             Expr *TrailingRequiresClause = nullptr);

using redeclarable_base = Redeclarable<FunctionDecl>;

FunctionDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

FunctionDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

FunctionDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

2013public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

static FunctionDecl *
Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
       SourceLocation NLoc, DeclarationName N, QualType T,
       TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin = false,
       bool isInlineSpecified = false, bool hasWrittenPrototype = true,
       ConstexprSpecKind ConstexprKind = ConstexprSpecKind::Unspecified,
       Expr *TrailingRequiresClause = nullptr) {
  DeclarationNameInfo NameInfo(N, NLoc);
  return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, SC,
                              UsesFPIntrin, isInlineSpecified,
                              hasWrittenPrototype, ConstexprKind,
                              TrailingRequiresClause);
}

static FunctionDecl *
Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
       const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
       StorageClass SC, bool UsesFPIntrin, bool isInlineSpecified,
       bool hasWrittenPrototype, ConstexprSpecKind ConstexprKind,
       Expr *TrailingRequiresClause);

static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);

DeclarationNameInfo getNameInfo() const {
  return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
}

void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
                          bool Qualified) const override;

void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }

/// Returns the location of the ellipsis of a variadic function.
SourceLocation getEllipsisLoc() const {
  const auto *FPT = getType()->getAs<FunctionProtoType>();
  if (FPT && FPT->isVariadic())
    return FPT->getEllipsisLoc();
  return SourceLocation();
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

// Function definitions.
//
// A function declaration may be:
// - a non defining declaration,
// - a definition. A function may be defined because:
//   - it has a body, or will have it in the case of late parsing.
//   - it has an uninstantiated body. The body does not exist because the
//     function is not used yet, but the declaration is considered a
//     definition and does not allow other definition of this function.
//   - it does not have a user specified body, but it does not allow
//     redefinition, because it is deleted/defaulted or is defined through
//     some other mechanism (alias, ifunc).

/// Returns true if the function has a body.
///
/// The function body might be in any of the (re-)declarations of this
/// function. The variant that accepts a FunctionDecl pointer will set that
/// function declaration to the actual declaration containing the body (if
/// there is one).
bool hasBody(const FunctionDecl *&Definition) const;

bool hasBody() const override {
  const FunctionDecl* Definition;
  return hasBody(Definition);
}

/// Returns whether the function has a trivial body that does not require any
/// specific codegen.
bool hasTrivialBody() const;

/// Returns true if the function has a definition that does not need to be
/// instantiated.
///
/// The variant that accepts a FunctionDecl pointer will set that function
/// declaration to the declaration that is a definition (if there is one).
///
/// \param CheckForPendingFriendDefinition If \c true, also check for friend
///        declarations that were instantiataed from function definitions.
///        Such a declaration behaves as if it is a definition for the
///        purpose of redefinition checking, but isn't actually a "real"
///        definition until its body is instantiated.
bool isDefined(const FunctionDecl *&Definition,
               bool CheckForPendingFriendDefinition = false) const;

bool isDefined() const {
  const FunctionDecl* Definition;
  return isDefined(Definition);
}

/// Get the definition for this declaration.
FunctionDecl *getDefinition() {
  const FunctionDecl *Definition;
  if (isDefined(Definition))
    return const_cast<FunctionDecl *>(Definition);
  return nullptr;
}
const FunctionDecl *getDefinition() const {
  return const_cast<FunctionDecl *>(this)->getDefinition();
}

/// Retrieve the body (definition) of the function. The function body might be
/// in any of the (re-)declarations of this function. The variant that accepts
/// a FunctionDecl pointer will set that function declaration to the actual
/// declaration containing the body (if there is one).
/// NOTE: For checking if there is a body, use hasBody() instead, to avoid
/// unnecessary AST de-serialization of the body.
Stmt *getBody(const FunctionDecl *&Definition) const;

Stmt *getBody() const override {
  const FunctionDecl* Definition;
  return getBody(Definition);
}

/// Returns whether this specific declaration of the function is also a
/// definition that does not contain uninstantiated body.
///
/// This does not determine whether the function has been defined (e.g., in a
/// previous definition); for that information, use isDefined.
///
/// Note: the function declaration does not become a definition until the
/// parser reaches the definition, if called before, this function will return
/// `false`.
bool isThisDeclarationADefinition() const {
  return isDeletedAsWritten() || isDefaulted() ||
         doesThisDeclarationHaveABody() || hasSkippedBody() ||
         willHaveBody() || hasDefiningAttr();
}

/// Determine whether this specific declaration of the function is a friend
/// declaration that was instantiated from a function definition. Such
/// declarations behave like definitions in some contexts.
bool isThisDeclarationInstantiatedFromAFriendDefinition() const;

/// Returns whether this specific declaration of the function has a body.
bool doesThisDeclarationHaveABody() const {
  return (!FunctionDeclBits.HasDefaultedFunctionInfo && Body) ||
         isLateTemplateParsed();
}

void setBody(Stmt *B);
void setLazyBody(uint64_t Offset) {
  FunctionDeclBits.HasDefaultedFunctionInfo = false;
  Body = LazyDeclStmtPtr(Offset);
}

void setDefaultedFunctionInfo(DefaultedFunctionInfo *Info);
DefaultedFunctionInfo *getDefaultedFunctionInfo() const;

/// Whether this function is variadic.
bool isVariadic() const;

/// Whether this function is marked as virtual explicitly.
bool isVirtualAsWritten() const {
  return FunctionDeclBits.IsVirtualAsWritten;
}

/// State that this function is marked as virtual explicitly.
void setVirtualAsWritten(bool V) { FunctionDeclBits.IsVirtualAsWritten = V; }

/// Whether this virtual function is pure, i.e. makes the containing class
/// abstract.
bool isPure() const { return FunctionDeclBits.IsPure; }
void setPure(bool P = true);

/// Whether this templated function will be late parsed.
bool isLateTemplateParsed() const {
  return FunctionDeclBits.IsLateTemplateParsed;
}

/// State that this templated function will be late parsed.
void setLateTemplateParsed(bool ILT = true) {
  FunctionDeclBits.IsLateTemplateParsed = ILT;
}

/// Whether this function is "trivial" in some specialized C++ senses.
/// Can only be true for default constructors, copy constructors,
/// copy assignment operators, and destructors.  Not meaningful until
/// the class has been fully built by Sema.
bool isTrivial() const { return FunctionDeclBits.IsTrivial; }
void setTrivial(bool IT) { FunctionDeclBits.IsTrivial = IT; }

bool isTrivialForCall() const { return FunctionDeclBits.IsTrivialForCall; }
void setTrivialForCall(bool IT) { FunctionDeclBits.IsTrivialForCall = IT; }

/// Whether this function is defaulted. Valid for e.g.
/// special member functions, defaulted comparisions (not methods!).
bool isDefaulted() const { return FunctionDeclBits.IsDefaulted; }
void setDefaulted(bool D = true) { FunctionDeclBits.IsDefaulted = D; }

/// Whether this function is explicitly defaulted.
bool isExplicitlyDefaulted() const {
  return FunctionDeclBits.IsExplicitlyDefaulted;
}

/// State that this function is explicitly defaulted.
void setExplicitlyDefaulted(bool ED = true) {
  FunctionDeclBits.IsExplicitlyDefaulted = ED;
}

/// True if this method is user-declared and was not
/// deleted or defaulted on its first declaration.
bool isUserProvided() const {
  auto *DeclAsWritten = this;
  if (FunctionDecl *Pattern = getTemplateInstantiationPattern())
    DeclAsWritten = Pattern;
  return !(DeclAsWritten->isDeleted() ||
           DeclAsWritten->getCanonicalDecl()->isDefaulted());
}

/// Whether falling off this function implicitly returns null/zero.
/// If a more specific implicit return value is required, front-ends
/// should synthesize the appropriate return statements.
bool hasImplicitReturnZero() const {
  return FunctionDeclBits.HasImplicitReturnZero;
}

/// State that falling off this function implicitly returns null/zero.
/// If a more specific implicit return value is required, front-ends
/// should synthesize the appropriate return statements.
void setHasImplicitReturnZero(bool IRZ) {
  FunctionDeclBits.HasImplicitReturnZero = IRZ;
}

/// Whether this function has a prototype, either because one
/// was explicitly written or because it was "inherited" by merging
/// a declaration without a prototype with a declaration that has a
/// prototype.
bool hasPrototype() const {
  return hasWrittenPrototype() || hasInheritedPrototype();
}

/// Whether this function has a written prototype.
bool hasWrittenPrototype() const {
  return FunctionDeclBits.HasWrittenPrototype;
}

/// State that this function has a written prototype.
void setHasWrittenPrototype(bool P = true) {
  FunctionDeclBits.HasWrittenPrototype = P;
}

/// Whether this function inherited its prototype from a
/// previous declaration.
bool hasInheritedPrototype() const {
  return FunctionDeclBits.HasInheritedPrototype;
}

/// State that this function inherited its prototype from a
/// previous declaration.
void setHasInheritedPrototype(bool P = true) {
  FunctionDeclBits.HasInheritedPrototype = P;
}

/// Whether this is a (C++11) constexpr function or constexpr constructor.
bool isConstexpr() const {
  return getConstexprKind() != ConstexprSpecKind::Unspecified;
}
void setConstexprKind(ConstexprSpecKind CSK) {
  FunctionDeclBits.ConstexprKind = static_cast<uint64_t>(CSK);
}
ConstexprSpecKind getConstexprKind() const {
  return static_cast<ConstexprSpecKind>(FunctionDeclBits.ConstexprKind);
}
bool isConstexprSpecified() const {
  return getConstexprKind() == ConstexprSpecKind::Constexpr;
}
bool isConsteval() const {
  return getConstexprKind() == ConstexprSpecKind::Consteval;
}

/// Whether the instantiation of this function is pending.
/// This bit is set when the decision to instantiate this function is made
/// and unset if and when the function body is created. That leaves out
/// cases where instantiation did not happen because the template definition
/// was not seen in this TU. This bit remains set in those cases, under the
/// assumption that the instantiation will happen in some other TU.
bool instantiationIsPending() const {
  return FunctionDeclBits.InstantiationIsPending;
}

/// State that the instantiation of this function is pending.
/// (see instantiationIsPending)
void setInstantiationIsPending(bool IC) {
  FunctionDeclBits.InstantiationIsPending = IC;
}

/// Indicates the function uses __try.
bool usesSEHTry() const { return FunctionDeclBits.UsesSEHTry; }
void setUsesSEHTry(bool UST) { FunctionDeclBits.UsesSEHTry = UST; }

/// Whether this function has been deleted.
///
/// A function that is "deleted" (via the C++0x "= delete" syntax)
/// acts like a normal function, except that it cannot actually be
/// called or have its address taken. Deleted functions are
/// typically used in C++ overload resolution to attract arguments
/// whose type or lvalue/rvalue-ness would permit the use of a
/// different overload that would behave incorrectly. For example,
/// one might use deleted functions to ban implicit conversion from
/// a floating-point number to an Integer type:
///
/// @code
/// struct Integer {
///   Integer(long); // construct from a long
///   Integer(double) = delete; // no construction from float or double
///   Integer(long double) = delete; // no construction from long double
/// };
/// @endcode
// If a function is deleted, its first declaration must be.
bool isDeleted() const {
  return getCanonicalDecl()->FunctionDeclBits.IsDeleted;
}

bool isDeletedAsWritten() const {
  return FunctionDeclBits.IsDeleted && !isDefaulted();
}

void setDeletedAsWritten(bool D = true) { FunctionDeclBits.IsDeleted = D; }

/// Determines whether this function is "main", which is the
/// entry point into an executable program.
bool isMain() const;

/// Determines whether this function is a MSVCRT user defined entry
/// point.
bool isMSVCRTEntryPoint() const;

/// Determines whether this operator new or delete is one
/// of the reserved global placement operators:
///    void *operator new(size_t, void *);
///    void *operator new[](size_t, void *);
///    void operator delete(void *, void *);
///    void operator delete[](void *, void *);
/// These functions have special behavior under [new.delete.placement]:
///    These functions are reserved, a C++ program may not define
///    functions that displace the versions in the Standard C++ library.
///    The provisions of [basic.stc.dynamic] do not apply to these
///    reserved placement forms of operator new and operator delete.
///
/// This function must be an allocation or deallocation function.
bool isReservedGlobalPlacementOperator() const;

/// Determines whether this function is one of the replaceable
/// global allocation functions:
///    void *operator new(size_t);
///    void *operator new(size_t, const std::nothrow_t &) noexcept;
///    void *operator new[](size_t);
///    void *operator new[](size_t, const std::nothrow_t &) noexcept;
///    void operator delete(void *) noexcept;
///    void operator delete(void *, std::size_t) noexcept;      [C++1y]
///    void operator delete(void *, const std::nothrow_t &) noexcept;
///    void operator delete[](void *) noexcept;
///    void operator delete[](void *, std::size_t) noexcept;    [C++1y]
///    void operator delete[](void *, const std::nothrow_t &) noexcept;
/// These functions have special behavior under C++1y [expr.new]:
///    An implementation is allowed to omit a call to a replaceable global
///    allocation function. [...]
///
/// If this function is an aligned allocation/deallocation function, return
/// the parameter number of the requested alignment through AlignmentParam.
///
/// If this function is an allocation/deallocation function that takes
/// the `std::nothrow_t` tag, return true through IsNothrow,
bool isReplaceableGlobalAllocationFunction(
    Optional<unsigned> *AlignmentParam = nullptr,
    bool *IsNothrow = nullptr) const;

/// Determine if this function provides an inline implementation of a builtin.
bool isInlineBuiltinDeclaration() const;

/// Determine whether this is a destroying operator delete.
bool isDestroyingOperatorDelete() const;

/// Compute the language linkage.
LanguageLinkage getLanguageLinkage() const;

/// Determines whether this function is a function with
/// external, C linkage.
bool isExternC() const;

/// Determines whether this function's context is, or is nested within,
/// a C++ extern "C" linkage spec.
bool isInExternCContext() const;

/// Determines whether this function's context is, or is nested within,
/// a C++ extern "C++" linkage spec.
bool isInExternCXXContext() const;

/// Determines whether this is a global function.
bool isGlobal() const;

/// Determines whether this function is known to be 'noreturn', through
/// an attribute on its declaration or its type.
bool isNoReturn() const;

/// True if the function was a definition but its body was skipped.
bool hasSkippedBody() const { return FunctionDeclBits.HasSkippedBody; }
void setHasSkippedBody(bool Skipped = true) {
  FunctionDeclBits.HasSkippedBody = Skipped;
}

/// True if this function will eventually have a body, once it's fully parsed.
bool willHaveBody() const { return FunctionDeclBits.WillHaveBody; }
void setWillHaveBody(bool V = true) { FunctionDeclBits.WillHaveBody = V; }

/// True if this function is considered a multiversioned function.
bool isMultiVersion() const {
  return getCanonicalDecl()->FunctionDeclBits.IsMultiVersion;
}

/// Sets the multiversion state for this declaration and all of its
/// redeclarations.
void setIsMultiVersion(bool V = true) {
  getCanonicalDecl()->FunctionDeclBits.IsMultiVersion = V;
}

/// Gets the kind of multiversioning attribute this declaration has. Note that
/// this can return a value even if the function is not multiversion, such as
/// the case of 'target'.
MultiVersionKind getMultiVersionKind() const;


/// True if this function is a multiversioned dispatch function as a part of
/// the cpu_specific/cpu_dispatch functionality.
bool isCPUDispatchMultiVersion() const;
/// True if this function is a multiversioned processor specific function as a
/// part of the cpu_specific/cpu_dispatch functionality.
bool isCPUSpecificMultiVersion() const;

/// True if this function is a multiversioned dispatch function as a part of
/// the target functionality.
bool isTargetMultiVersion() const;

/// \brief Get the associated-constraints of this function declaration.
/// Currently, this will either be a vector of size 1 containing the
/// trailing-requires-clause or an empty vector.
///
/// Use this instead of getTrailingRequiresClause for concepts APIs that
/// accept an ArrayRef of constraint expressions.
void getAssociatedConstraints(SmallVectorImpl<const Expr *> &AC) const {
  if (auto *TRC = getTrailingRequiresClause())
    AC.push_back(TRC);
}

void setPreviousDeclaration(FunctionDecl * PrevDecl);

FunctionDecl *getCanonicalDecl() override;
const FunctionDecl *getCanonicalDecl() const {
  return const_cast<FunctionDecl*>(this)->getCanonicalDecl();
}

unsigned getBuiltinID(bool ConsiderWrapperFunctions = false) const;

// ArrayRef interface to parameters.
ArrayRef<ParmVarDecl *> parameters() const {
  return {ParamInfo, getNumParams()};
}
MutableArrayRef<ParmVarDecl *> parameters() {
  return {ParamInfo, getNumParams()};
}

// Iterator access to formal parameters.
using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;

bool param_empty() const { return parameters().empty(); }
param_iterator param_begin() { return parameters().begin(); }
param_iterator param_end() { return parameters().end(); }
param_const_iterator param_begin() const { return parameters().begin(); }
param_const_iterator param_end() const { return parameters().end(); }
size_t param_size() const { return parameters().size(); }

/// Return the number of parameters this function must have based on its
/// FunctionType.  This is the length of the ParamInfo array after it has been
/// created.
unsigned getNumParams() const;

const ParmVarDecl *getParamDecl(unsigned i) const {
  assert(i < getNumParams() && "Illegal param #")(static_cast <bool> (i < getNumParams() && "Illegal param #"
) ? void (0) : __assert_fail ("i < getNumParams() && \"Illegal param #\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 2507, __extension__ __PRETTY_FUNCTION__));
  return ParamInfo[i];
}
ParmVarDecl *getParamDecl(unsigned i) {
  assert(i < getNumParams() && "Illegal param #")(static_cast <bool> (i < getNumParams() && "Illegal param #"
) ? void (0) : __assert_fail ("i < getNumParams() && \"Illegal param #\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 2511, __extension__ __PRETTY_FUNCTION__));
  return ParamInfo[i];
}
void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
  setParams(getASTContext(), NewParamInfo);
}

/// Returns the minimum number of arguments needed to call this function. This
/// may be fewer than the number of function parameters, if some of the
/// parameters have default arguments (in C++).
unsigned getMinRequiredArguments() const;

/// Determine whether this function has a single parameter, or multiple
/// parameters where all but the first have default arguments.
///
/// This notion is used in the definition of copy/move constructors and
/// initializer list constructors. Note that, unlike getMinRequiredArguments,
/// parameter packs are not treated specially here.
bool hasOneParamOrDefaultArgs() const;

/// Find the source location information for how the type of this function
/// was written. May be absent (for example if the function was declared via
/// a typedef) and may contain a different type from that of the function
/// (for example if the function type was adjusted by an attribute).
FunctionTypeLoc getFunctionTypeLoc() const;

QualType getReturnType() const {
  return getType()->castAs<FunctionType>()->getReturnType();
}

/// Attempt to compute an informative source range covering the
/// function return type. This may omit qualifiers and other information with
/// limited representation in the AST.
SourceRange getReturnTypeSourceRange() const;

/// Attempt to compute an informative source range covering the
/// function parameters, including the ellipsis of a variadic function.
/// The source range excludes the parentheses, and is invalid if there are
/// no parameters and no ellipsis.
SourceRange getParametersSourceRange() const;

/// Get the declared return type, which may differ from the actual return
/// type if the return type is deduced.
QualType getDeclaredReturnType() const {
  auto *TSI = getTypeSourceInfo();
  QualType T = TSI ? TSI->getType() : getType();
  return T->castAs<FunctionType>()->getReturnType();
}

/// Gets the ExceptionSpecificationType as declared.
ExceptionSpecificationType getExceptionSpecType() const {
  auto *TSI = getTypeSourceInfo();
  QualType T = TSI ? TSI->getType() : getType();
  const auto *FPT = T->getAs<FunctionProtoType>();
  return FPT ? FPT->getExceptionSpecType() : EST_None;
}

/// Attempt to compute an informative source range covering the
/// function exception specification, if any.
SourceRange getExceptionSpecSourceRange() const;

/// Determine the type of an expression that calls this function.
QualType getCallResultType() const {
  return getType()->castAs<FunctionType>()->getCallResultType(
      getASTContext());
}

/// Returns the storage class as written in the source. For the
/// computed linkage of symbol, see getLinkage.
StorageClass getStorageClass() const {
  return static_cast<StorageClass>(FunctionDeclBits.SClass);
}

/// Sets the storage class as written in the source.
void setStorageClass(StorageClass SClass) {
  FunctionDeclBits.SClass = SClass;
}

/// Determine whether the "inline" keyword was specified for this
/// function.
bool isInlineSpecified() const { return FunctionDeclBits.IsInlineSpecified; }

/// Set whether the "inline" keyword was specified for this function.
void setInlineSpecified(bool I) {
  FunctionDeclBits.IsInlineSpecified = I;
  FunctionDeclBits.IsInline = I;
}

/// Determine whether the function was declared in source context
/// that requires constrained FP intrinsics
bool UsesFPIntrin() const { return FunctionDeclBits.UsesFPIntrin; }

/// Set whether the function was declared in source context
/// that requires constrained FP intrinsics
void setUsesFPIntrin(bool I) { FunctionDeclBits.UsesFPIntrin = I; }

/// Flag that this function is implicitly inline.
void setImplicitlyInline(bool I = true) { FunctionDeclBits.IsInline = I; }

/// Determine whether this function should be inlined, because it is
/// either marked "inline" or "constexpr" or is a member function of a class
/// that was defined in the class body.
bool isInlined() const { return FunctionDeclBits.IsInline; }

bool isInlineDefinitionExternallyVisible() const;

bool isMSExternInline() const;

bool doesDeclarationForceExternallyVisibleDefinition() const;

bool isStatic() const { return getStorageClass() == SC_Static; }

/// Whether this function declaration represents an C++ overloaded
/// operator, e.g., "operator+".
bool isOverloadedOperator() const {
  return getOverloadedOperator() != OO_None;
}

OverloadedOperatorKind getOverloadedOperator() const;

const IdentifierInfo *getLiteralIdentifier() const;

/// If this function is an instantiation of a member function
/// of a class template specialization, retrieves the function from
/// which it was instantiated.
///
/// This routine will return non-NULL for (non-templated) member
/// functions of class templates and for instantiations of function
/// templates. For example, given:
///
/// \code
/// template<typename T>
/// struct X {
///   void f(T);
/// };
/// \endcode
///
/// The declaration for X<int>::f is a (non-templated) FunctionDecl
/// whose parent is the class template specialization X<int>. For
/// this declaration, getInstantiatedFromFunction() will return
/// the FunctionDecl X<T>::A. When a complete definition of
/// X<int>::A is required, it will be instantiated from the
/// declaration returned by getInstantiatedFromMemberFunction().
FunctionDecl *getInstantiatedFromMemberFunction() const;

/// What kind of templated function this is.
TemplatedKind getTemplatedKind() const;

/// If this function is an instantiation of a member function of a
/// class template specialization, retrieves the member specialization
/// information.
MemberSpecializationInfo *getMemberSpecializationInfo() const;

/// Specify that this record is an instantiation of the
/// member function FD.
void setInstantiationOfMemberFunction(FunctionDecl *FD,
                                      TemplateSpecializationKind TSK) {
  setInstantiationOfMemberFunction(getASTContext(), FD, TSK);
}

/// Retrieves the function template that is described by this
/// function declaration.
///
/// Every function template is represented as a FunctionTemplateDecl
/// and a FunctionDecl (or something derived from FunctionDecl). The
/// former contains template properties (such as the template
/// parameter lists) while the latter contains the actual
/// description of the template's
/// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the
/// FunctionDecl that describes the function template,
/// getDescribedFunctionTemplate() retrieves the
/// FunctionTemplateDecl from a FunctionDecl.
FunctionTemplateDecl *getDescribedFunctionTemplate() const;

void setDescribedFunctionTemplate(FunctionTemplateDecl *Template);

/// Determine whether this function is a function template
/// specialization.
bool isFunctionTemplateSpecialization() const {
  return getPrimaryTemplate() != nullptr;
}

/// If this function is actually a function template specialization,
/// retrieve information about this function template specialization.
/// Otherwise, returns NULL.
FunctionTemplateSpecializationInfo *getTemplateSpecializationInfo() const;

/// Determines whether this function is a function template
/// specialization or a member of a class template specialization that can
/// be implicitly instantiated.
bool isImplicitlyInstantiable() const;

/// Determines if the given function was instantiated from a
/// function template.
bool isTemplateInstantiation() const;

/// Retrieve the function declaration from which this function could
/// be instantiated, if it is an instantiation (rather than a non-template
/// or a specialization, for example).
///
/// If \p ForDefinition is \c false, explicit specializations will be treated
/// as if they were implicit instantiations. This will then find the pattern
/// corresponding to non-definition portions of the declaration, such as
/// default arguments and the exception specification.
FunctionDecl *
getTemplateInstantiationPattern(bool ForDefinition = true) const;

/// Retrieve the primary template that this function template
/// specialization either specializes or was instantiated from.
///
/// If this function declaration is not a function template specialization,
/// returns NULL.
FunctionTemplateDecl *getPrimaryTemplate() const;

/// Retrieve the template arguments used to produce this function
/// template specialization from the primary template.
///
/// If this function declaration is not a function template specialization,
/// returns NULL.
const TemplateArgumentList *getTemplateSpecializationArgs() const;

/// Retrieve the template argument list as written in the sources,
/// if any.
///
/// If this function declaration is not a function template specialization
/// or if it had no explicit template argument list, returns NULL.
/// Note that it an explicit template argument list may be written empty,
/// e.g., template<> void foo<>(char* s);
const ASTTemplateArgumentListInfo*
getTemplateSpecializationArgsAsWritten() const;

/// Specify that this function declaration is actually a function
/// template specialization.
///
/// \param Template the function template that this function template
/// specialization specializes.
///
/// \param TemplateArgs the template arguments that produced this
/// function template specialization from the template.
///
/// \param InsertPos If non-NULL, the position in the function template
/// specialization set where the function template specialization data will
/// be inserted.
///
/// \param TSK the kind of template specialization this is.
///
/// \param TemplateArgsAsWritten location info of template arguments.
///
/// \param PointOfInstantiation point at which the function template
/// specialization was first instantiated.
void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template,
              const TemplateArgumentList *TemplateArgs,
              void *InsertPos,
              TemplateSpecializationKind TSK = TSK_ImplicitInstantiation,
              const TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr,
              SourceLocation PointOfInstantiation = SourceLocation()) {
  setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs,
                                    InsertPos, TSK, TemplateArgsAsWritten,
                                    PointOfInstantiation);
}

/// Specifies that this function declaration is actually a
/// dependent function template specialization.
void setDependentTemplateSpecialization(ASTContext &Context,
                           const UnresolvedSetImpl &Templates,
                    const TemplateArgumentListInfo &TemplateArgs);

DependentFunctionTemplateSpecializationInfo *
getDependentSpecializationInfo() const;

/// Determine what kind of template instantiation this function
/// represents.
TemplateSpecializationKind getTemplateSpecializationKind() const;

/// Determine the kind of template specialization this function represents
/// for the purpose of template instantiation.
TemplateSpecializationKind
getTemplateSpecializationKindForInstantiation() const;

/// Determine what kind of template instantiation this function
/// represents.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
                      SourceLocation PointOfInstantiation = SourceLocation());

/// Retrieve the (first) point of instantiation of a function template
/// specialization or a member of a class template specialization.
///
/// \returns the first point of instantiation, if this function was
/// instantiated from a template; otherwise, returns an invalid source
/// location.
SourceLocation getPointOfInstantiation() const;

/// Determine whether this is or was instantiated from an out-of-line
/// definition of a member function.
bool isOutOfLine() const override;

/// Identify a memory copying or setting function.
/// If the given function is a memory copy or setting function, returns
/// the corresponding Builtin ID. If the function is not a memory function,
/// returns 0.
unsigned getMemoryFunctionKind() const;

/// Returns ODRHash of the function.  This value is calculated and
/// stored on first call, then the stored value returned on the other calls.
unsigned getODRHash();

/// Returns cached ODRHash of the function.  This must have been previously
/// computed and stored.
unsigned getODRHash() const;

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstFunction && K <= lastFunction;
}
static DeclContext *castToDeclContext(const FunctionDecl *D) {
  return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
}
static FunctionDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
}
2832};

2834/// Represents a member of a struct/union/class.
2835class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
unsigned BitField : 1;
unsigned Mutable : 1;
mutable unsigned CachedFieldIndex : 30;

/// The kinds of value we can store in InitializerOrBitWidth.
///
/// Note that this is compatible with InClassInitStyle except for
/// ISK_CapturedVLAType.
enum InitStorageKind {
  /// If the pointer is null, there's nothing special.  Otherwise,
  /// this is a bitfield and the pointer is the Expr* storing the
  /// bit-width.
  ISK_NoInit = (unsigned) ICIS_NoInit,

  /// The pointer is an (optional due to delayed parsing) Expr*
  /// holding the copy-initializer.
  ISK_InClassCopyInit = (unsigned) ICIS_CopyInit,

  /// The pointer is an (optional due to delayed parsing) Expr*
  /// holding the list-initializer.
  ISK_InClassListInit = (unsigned) ICIS_ListInit,

  /// The pointer is a VariableArrayType* that's been captured;
  /// the enclosing context is a lambda or captured statement.
  ISK_CapturedVLAType,
};

/// If this is a bitfield with a default member initializer, this
/// structure is used to represent the two expressions.
struct InitAndBitWidth {
  Expr *Init;
  Expr *BitWidth;
};

/// Storage for either the bit-width, the in-class initializer, or
/// both (via InitAndBitWidth), or the captured variable length array bound.
///
/// If the storage kind is ISK_InClassCopyInit or
/// ISK_InClassListInit, but the initializer is null, then this
/// field has an in-class initializer that has not yet been parsed
/// and attached.
// FIXME: Tail-allocate this to reduce the size of FieldDecl in the
// overwhelmingly common case that we have none of these things.
llvm::PointerIntPair<void *, 2, InitStorageKind> InitStorage;

2881protected:
FieldDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
          SourceLocation IdLoc, IdentifierInfo *Id,
          QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
          InClassInitStyle InitStyle)
  : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
    BitField(false), Mutable(Mutable), CachedFieldIndex(0),
    InitStorage(nullptr, (InitStorageKind) InitStyle) {
  if (BW)
    setBitWidth(BW);
}

2893public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static FieldDecl *Create(const ASTContext &C, DeclContext *DC,
                         SourceLocation StartLoc, SourceLocation IdLoc,
                         IdentifierInfo *Id, QualType T,
                         TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
                         InClassInitStyle InitStyle);

static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// Returns the index of this field within its record,
/// as appropriate for passing to ASTRecordLayout::getFieldOffset.
unsigned getFieldIndex() const;

/// Determines whether this field is mutable (C++ only).
bool isMutable() const { return Mutable; }

/// Determines whether this field is a bitfield.
bool isBitField() const { return BitField; }

/// Determines whether this is an unnamed bitfield.
bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }

/// Determines whether this field is a
/// representative for an anonymous struct or union. Such fields are
/// unnamed and are implicitly generated by the implementation to
/// store the data for the anonymous union or struct.
bool isAnonymousStructOrUnion() const;

Expr *getBitWidth() const {
  if (!BitField)
    return nullptr;
  void *Ptr = InitStorage.getPointer();
  if (getInClassInitStyle())
    return static_cast<InitAndBitWidth*>(Ptr)->BitWidth;
  return static_cast<Expr*>(Ptr);
}

unsigned getBitWidthValue(const ASTContext &Ctx) const;

/// Set the bit-field width for this member.
// Note: used by some clients (i.e., do not remove it).
void setBitWidth(Expr *Width) {
  assert(!hasCapturedVLAType() && !BitField &&(static_cast <bool> (!hasCapturedVLAType() && !
BitField && "bit width or captured type already set")
 ? void (0) : __assert_fail ("!hasCapturedVLAType() && !BitField && \"bit width or captured type already set\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 2939, __extension__ __PRETTY_FUNCTION__))
         "bit width or captured type already set")(static_cast <bool> (!hasCapturedVLAType() && !
BitField && "bit width or captured type already set")
 ? void (0) : __assert_fail ("!hasCapturedVLAType() && !BitField && \"bit width or captured type already set\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 2939, __extension__ __PRETTY_FUNCTION__));
  assert(Width && "no bit width specified")(static_cast <bool> (Width && "no bit width specified"
) ? void (0) : __assert_fail ("Width && \"no bit width specified\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 2940, __extension__ __PRETTY_FUNCTION__));
  InitStorage.setPointer(
      InitStorage.getInt()
          ? new (getASTContext())
                InitAndBitWidth{getInClassInitializer(), Width}
          : static_cast<void*>(Width));
  BitField = true;
}

/// Remove the bit-field width from this member.
// Note: used by some clients (i.e., do not remove it).
void removeBitWidth() {
  assert(isBitField() && "no bitfield width to remove")(static_cast <bool> (isBitField() && "no bitfield width to remove"
) ? void (0) : __assert_fail ("isBitField() && \"no bitfield width to remove\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 2952, __extension__ __PRETTY_FUNCTION__));
  InitStorage.setPointer(getInClassInitializer());
  BitField = false;
}

/// Is this a zero-length bit-field? Such bit-fields aren't really bit-fields
/// at all and instead act as a separator between contiguous runs of other
/// bit-fields.
bool isZeroLengthBitField(const ASTContext &Ctx) const;

/// Determine if this field is a subobject of zero size, that is, either a
/// zero-length bit-field or a field of empty class type with the
/// [[no_unique_address]] attribute.
bool isZeroSize(const ASTContext &Ctx) const;

/// Get the kind of (C++11) default member initializer that this field has.
InClassInitStyle getInClassInitStyle() const {
  InitStorageKind storageKind = InitStorage.getInt();
  return (storageKind == ISK_CapturedVLAType
            ? ICIS_NoInit : (InClassInitStyle) storageKind);
}

/// Determine whether this member has a C++11 default member initializer.
bool hasInClassInitializer() const {
  return getInClassInitStyle() != ICIS_NoInit;
}

/// Get the C++11 default member initializer for this member, or null if one
/// has not been set. If a valid declaration has a default member initializer,
/// but this returns null, then we have not parsed and attached it yet.
Expr *getInClassInitializer() const {
  if (!hasInClassInitializer())
    return nullptr;
  void *Ptr = InitStorage.getPointer();
  if (BitField)
    return static_cast<InitAndBitWidth*>(Ptr)->Init;
  return static_cast<Expr*>(Ptr);
}

/// Set the C++11 in-class initializer for this member.
void setInClassInitializer(Expr *Init) {
  assert(hasInClassInitializer() && !getInClassInitializer())(static_cast <bool> (hasInClassInitializer() &&
 !getInClassInitializer()) ? void (0) : __assert_fail ("hasInClassInitializer() && !getInClassInitializer()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 2993, __extension__ __PRETTY_FUNCTION__));
  if (BitField)
    static_cast<InitAndBitWidth*>(InitStorage.getPointer())->Init = Init;
  else
    InitStorage.setPointer(Init);
}

/// Remove the C++11 in-class initializer from this member.
void removeInClassInitializer() {
  assert(hasInClassInitializer() && "no initializer to remove")(static_cast <bool> (hasInClassInitializer() &&
 "no initializer to remove") ? void (0) : __assert_fail ("hasInClassInitializer() && \"no initializer to remove\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 3002, __extension__ __PRETTY_FUNCTION__));
  InitStorage.setPointerAndInt(getBitWidth(), ISK_NoInit);
}

/// Determine whether this member captures the variable length array
/// type.
bool hasCapturedVLAType() const {
  return InitStorage.getInt() == ISK_CapturedVLAType;
}

/// Get the captured variable length array type.
const VariableArrayType *getCapturedVLAType() const {
  return hasCapturedVLAType() ? static_cast<const VariableArrayType *>(
                                    InitStorage.getPointer())
                              : nullptr;
}

/// Set the captured variable length array type for this field.
void setCapturedVLAType(const VariableArrayType *VLAType);

/// Returns the parent of this field declaration, which
/// is the struct in which this field is defined.
///
/// Returns null if this is not a normal class/struct field declaration, e.g.
/// ObjCAtDefsFieldDecl, ObjCIvarDecl.
const RecordDecl *getParent() const {
  return dyn_cast<RecordDecl>(getDeclContext());
}

RecordDecl *getParent() {
  return dyn_cast<RecordDecl>(getDeclContext());
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

/// Retrieves the canonical declaration of this field.
FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
3044};

3046/// An instance of this object exists for each enum constant
3047/// that is defined.  For example, in "enum X {a,b}", each of a/b are
3048/// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
3049/// TagType for the X EnumDecl.
3050class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
Stmt *Init; // an integer constant expression
llvm::APSInt Val; // The value.

3054protected:
EnumConstantDecl(DeclContext *DC, SourceLocation L,
                 IdentifierInfo *Id, QualType T, Expr *E,
                 const llvm::APSInt &V)
  : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {}

3060public:
friend class StmtIteratorBase;

static EnumConstantDecl *Create(ASTContext &C, EnumDecl *DC,
                                SourceLocation L, IdentifierInfo *Id,
                                QualType T, Expr *E,
                                const llvm::APSInt &V);
static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID);

const Expr *getInitExpr() const { return (const Expr*) Init; }
Expr *getInitExpr() { return (Expr*) Init; }
const llvm::APSInt &getInitVal() const { return Val; }

void setInitExpr(Expr *E) { Init = (Stmt*) E; }
void setInitVal(const llvm::APSInt &V) { Val = V; }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

/// Retrieves the canonical declaration of this enumerator.
EnumConstantDecl *getCanonicalDecl() override { return getFirstDecl(); }
const EnumConstantDecl *getCanonicalDecl() const { return getFirstDecl(); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == EnumConstant; }
3085};

3087/// Represents a field injected from an anonymous union/struct into the parent
3088/// scope. These are always implicit.
3089class IndirectFieldDecl : public ValueDecl,
                        public Mergeable<IndirectFieldDecl> {
NamedDecl **Chaining;
unsigned ChainingSize;

IndirectFieldDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
                  DeclarationName N, QualType T,
                  MutableArrayRef<NamedDecl *> CH);

void anchor() override;

3100public:
friend class ASTDeclReader;

static IndirectFieldDecl *Create(ASTContext &C, DeclContext *DC,
                                 SourceLocation L, IdentifierInfo *Id,
                                 QualType T, llvm::MutableArrayRef<NamedDecl *> CH);

static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);

using chain_iterator = ArrayRef<NamedDecl *>::const_iterator;

ArrayRef<NamedDecl *> chain() const {
  return llvm::makeArrayRef(Chaining, ChainingSize);
}
chain_iterator chain_begin() const { return chain().begin(); }
chain_iterator chain_end() const { return chain().end(); }

unsigned getChainingSize() const { return ChainingSize; }

FieldDecl *getAnonField() const {
  assert(chain().size() >= 2)(static_cast <bool> (chain().size() >= 2) ? void (0)
 : __assert_fail ("chain().size() >= 2", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 3120, __extension__ __PRETTY_FUNCTION__));
  return cast<FieldDecl>(chain().back());
}

VarDecl *getVarDecl() const {
  assert(chain().size() >= 2)(static_cast <bool> (chain().size() >= 2) ? void (0)
 : __assert_fail ("chain().size() >= 2", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 3125, __extension__ __PRETTY_FUNCTION__));
  return dyn_cast<VarDecl>(chain().front());
}

IndirectFieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
const IndirectFieldDecl *getCanonicalDecl() const { return getFirstDecl(); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == IndirectField; }
3135};

3137/// Represents a declaration of a type.
3138class TypeDecl : public NamedDecl {
friend class ASTContext;

/// This indicates the Type object that represents
/// this TypeDecl.  It is a cache maintained by
/// ASTContext::getTypedefType, ASTContext::getTagDeclType, and
/// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl.
mutable const Type *TypeForDecl = nullptr;

/// The start of the source range for this declaration.
SourceLocation LocStart;

void anchor() override;

3152protected:
TypeDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
         SourceLocation StartL = SourceLocation())
  : NamedDecl(DK, DC, L, Id), LocStart(StartL) {}

3157public:
// Low-level accessor. If you just want the type defined by this node,
// check out ASTContext::getTypeDeclType or one of
// ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you
// already know the specific kind of node this is.
const Type *getTypeForDecl() const { return TypeForDecl; }
void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LocStart; }
void setLocStart(SourceLocation L) { LocStart = L; }
SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  if (LocStart.isValid())
    return SourceRange(LocStart, getLocation());
  else
    return SourceRange(getLocation());
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstType && K <= lastType; }
3177};

3179/// Base class for declarations which introduce a typedef-name.
3180class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
struct alignas(8) ModedTInfo {
  TypeSourceInfo *first;
  QualType second;
};

/// If int part is 0, we have not computed IsTransparentTag.
/// Otherwise, IsTransparentTag is (getInt() >> 1).
mutable llvm::PointerIntPair<
    llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *>, 2>
    MaybeModedTInfo;

void anchor() override;

3194protected:
TypedefNameDecl(Kind DK, ASTContext &C, DeclContext *DC,
                SourceLocation StartLoc, SourceLocation IdLoc,
                IdentifierInfo *Id, TypeSourceInfo *TInfo)
    : TypeDecl(DK, DC, IdLoc, Id, StartLoc), redeclarable_base(C),
      MaybeModedTInfo(TInfo, 0) {}

using redeclarable_base = Redeclarable<TypedefNameDecl>;

TypedefNameDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

TypedefNameDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

TypedefNameDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

3215public:
using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

bool isModed() const {
  return MaybeModedTInfo.getPointer().is<ModedTInfo *>();
}

TypeSourceInfo *getTypeSourceInfo() const {
  return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->first
                   : MaybeModedTInfo.getPointer().get<TypeSourceInfo *>();
}

QualType getUnderlyingType() const {
  return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->second
                   : MaybeModedTInfo.getPointer()
                         .get<TypeSourceInfo *>()
                         ->getType();
}

void setTypeSourceInfo(TypeSourceInfo *newType) {
  MaybeModedTInfo.setPointer(newType);
}

void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy) {
  MaybeModedTInfo.setPointer(new (getASTContext(), 8)
                                 ModedTInfo({unmodedTSI, modedTy}));
}

/// Retrieves the canonical declaration of this typedef-name.
TypedefNameDecl *getCanonicalDecl() override { return getFirstDecl(); }
const TypedefNameDecl *getCanonicalDecl() const { return getFirstDecl(); }

/// Retrieves the tag declaration for which this is the typedef name for
/// linkage purposes, if any.
///
/// \param AnyRedecl Look for the tag declaration in any redeclaration of
/// this typedef declaration.
TagDecl *getAnonDeclWithTypedefName(bool AnyRedecl = false) const;

/// Determines if this typedef shares a name and spelling location with its
/// underlying tag type, as is the case with the NS_ENUM macro.
bool isTransparentTag() const {
  if (MaybeModedTInfo.getInt())
    return MaybeModedTInfo.getInt() & 0x2;
  return isTransparentTagSlow();
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstTypedefName && K <= lastTypedefName;
}

3276private:
bool isTransparentTagSlow() const;
3278};

3280/// Represents the declaration of a typedef-name via the 'typedef'
3281/// type specifier.
3282class TypedefDecl : public TypedefNameDecl {
TypedefDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
            SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
    : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}

3287public:
static TypedefDecl *Create(ASTContext &C, DeclContext *DC,
                           SourceLocation StartLoc, SourceLocation IdLoc,
                           IdentifierInfo *Id, TypeSourceInfo *TInfo);
static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Typedef; }
3298};

3300/// Represents the declaration of a typedef-name via a C++11
3301/// alias-declaration.
3302class TypeAliasDecl : public TypedefNameDecl {
/// The template for which this is the pattern, if any.
TypeAliasTemplateDecl *Template;

TypeAliasDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
              SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
    : TypedefNameDecl(TypeAlias, C, DC, StartLoc, IdLoc, Id, TInfo),
      Template(nullptr) {}

3311public:
static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC,
                             SourceLocation StartLoc, SourceLocation IdLoc,
                             IdentifierInfo *Id, TypeSourceInfo *TInfo);
static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

TypeAliasTemplateDecl *getDescribedAliasTemplate() const { return Template; }
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT) { Template = TAT; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == TypeAlias; }
3325};

3327/// Represents the declaration of a struct/union/class/enum.
3328class TagDecl : public TypeDecl,
              public DeclContext,
              public Redeclarable<TagDecl> {
// This class stores some data in DeclContext::TagDeclBits
// to save some space. Use the provided accessors to access it.
3333public:
// This is really ugly.
using TagKind = TagTypeKind;

3337private:
SourceRange BraceRange;

// A struct representing syntactic qualifier info,
// to be used for the (uncommon) case of out-of-line declarations.
using ExtInfo = QualifierInfo;

/// If the (out-of-line) tag declaration name
/// is qualified, it points to the qualifier info (nns and range);
/// otherwise, if the tag declaration is anonymous and it is part of
/// a typedef or alias, it points to the TypedefNameDecl (used for mangling);
/// otherwise, if the tag declaration is anonymous and it is used as a
/// declaration specifier for variables, it points to the first VarDecl (used
/// for mangling);
/// otherwise, it is a null (TypedefNameDecl) pointer.
llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;

bool hasExtInfo() const { return TypedefNameDeclOrQualifier.is<ExtInfo *>(); }
ExtInfo *getExtInfo() { return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
const ExtInfo *getExtInfo() const {
  return TypedefNameDeclOrQualifier.get<ExtInfo *>();
}

3360protected:
TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
        SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
        SourceLocation StartL);

using redeclarable_base = Redeclarable<TagDecl>;

TagDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

TagDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

TagDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

/// Completes the definition of this tag declaration.
///
/// This is a helper function for derived classes.
void completeDefinition();

/// True if this decl is currently being defined.
void setBeingDefined(bool V = true) { TagDeclBits.IsBeingDefined = V; }

/// Indicates whether it is possible for declarations of this kind
/// to have an out-of-date definition.
///
/// This option is only enabled when modules are enabled.
void setMayHaveOutOfDateDef(bool V = true) {
  TagDeclBits.MayHaveOutOfDateDef = V;
}

3395public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

SourceRange getBraceRange() const { return BraceRange; }
void setBraceRange(SourceRange R) { BraceRange = R; }

/// Return SourceLocation representing start of source
/// range ignoring outer template declarations.
SourceLocation getInnerLocStart() const { return getBeginLoc(); }

/// Return SourceLocation representing start of source
/// range taking into account any outer template declarations.
SourceLocation getOuterLocStart() const;
SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

TagDecl *getCanonicalDecl() override;
const TagDecl *getCanonicalDecl() const {
  return const_cast<TagDecl*>(this)->getCanonicalDecl();
}

/// Return true if this declaration is a completion definition of the type.
/// Provided for consistency.
bool isThisDeclarationADefinition() const {
  return isCompleteDefinition();
}

/// Return true if this decl has its body fully specified.
bool isCompleteDefinition() const { return TagDeclBits.IsCompleteDefinition; }

/// True if this decl has its body fully specified.
void setCompleteDefinition(bool V = true) {
  TagDeclBits.IsCompleteDefinition = V;
}

/// Return true if this complete decl is
/// required to be complete for some existing use.
bool isCompleteDefinitionRequired() const {
  return TagDeclBits.IsCompleteDefinitionRequired;
}

/// True if this complete decl is
/// required to be complete for some existing use.
void setCompleteDefinitionRequired(bool V = true) {
  TagDeclBits.IsCompleteDefinitionRequired = V;
}

/// Return true if this decl is currently being defined.
bool isBeingDefined() const { return TagDeclBits.IsBeingDefined; }

/// True if this tag declaration is "embedded" (i.e., defined or declared
/// for the very first time) in the syntax of a declarator.
bool isEmbeddedInDeclarator() const {
  return TagDeclBits.IsEmbeddedInDeclarator;
}

/// True if this tag declaration is "embedded" (i.e., defined or declared
/// for the very first time) in the syntax of a declarator.
void setEmbeddedInDeclarator(bool isInDeclarator) {
  TagDeclBits.IsEmbeddedInDeclarator = isInDeclarator;
}

/// True if this tag is free standing, e.g. "struct foo;".
bool isFreeStanding() const { return TagDeclBits.IsFreeStanding; }

/// True if this tag is free standing, e.g. "struct foo;".
void setFreeStanding(bool isFreeStanding = true) {
  TagDeclBits.IsFreeStanding = isFreeStanding;
}

/// Indicates whether it is possible for declarations of this kind
/// to have an out-of-date definition.
///
/// This option is only enabled when modules are enabled.
bool mayHaveOutOfDateDef() const { return TagDeclBits.MayHaveOutOfDateDef; }

/// Whether this declaration declares a type that is
/// dependent, i.e., a type that somehow depends on template
/// parameters.
bool isDependentType() const { return isDependentContext(); }

/// Starts the definition of this tag declaration.
///
/// This method should be invoked at the beginning of the definition
/// of this tag declaration. It will set the tag type into a state
/// where it is in the process of being defined.
void startDefinition();

/// Returns the TagDecl that actually defines this
///  struct/union/class/enum.  When determining whether or not a
///  struct/union/class/enum has a definition, one should use this
///  method as opposed to 'isDefinition'.  'isDefinition' indicates
///  whether or not a specific TagDecl is defining declaration, not
///  whether or not the struct/union/class/enum type is defined.
///  This method returns NULL if there is no TagDecl that defines
///  the struct/union/class/enum.
TagDecl *getDefinition() const;

StringRef getKindName() const {
  return TypeWithKeyword::getTagTypeKindName(getTagKind());
}

TagKind getTagKind() const {
  return static_cast<TagKind>(TagDeclBits.TagDeclKind);
}

void setTagKind(TagKind TK) { TagDeclBits.TagDeclKind = TK; }

bool isStruct() const { return getTagKind() == TTK_Struct; }
bool isInterface() const { return getTagKind() == TTK_Interface; }
bool isClass()  const { return getTagKind() == TTK_Class; }
bool isUnion()  const { return getTagKind() == TTK_Union; }
bool isEnum()   const { return getTagKind() == TTK_Enum; }

/// Is this tag type named, either directly or via being defined in
/// a typedef of this type?
///
/// C++11 [basic.link]p8:
///   A type is said to have linkage if and only if:
///     - it is a class or enumeration type that is named (or has a
///       name for linkage purposes) and the name has linkage; ...
/// C++11 [dcl.typedef]p9:
///   If the typedef declaration defines an unnamed class (or enum),
///   the first typedef-name declared by the declaration to be that
///   class type (or enum type) is used to denote the class type (or
///   enum type) for linkage purposes only.
///
/// C does not have an analogous rule, but the same concept is
/// nonetheless useful in some places.
bool hasNameForLinkage() const {
  return (getDeclName() || getTypedefNameForAnonDecl());
}

TypedefNameDecl *getTypedefNameForAnonDecl() const {
  return hasExtInfo() ? nullptr
                      : TypedefNameDeclOrQualifier.get<TypedefNameDecl *>();
}

void setTypedefNameForAnonDecl(TypedefNameDecl *TDD);

/// Retrieve the nested-name-specifier that qualifies the name of this
/// declaration, if it was present in the source.
NestedNameSpecifier *getQualifier() const {
  return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
                      : nullptr;
}

/// Retrieve the nested-name-specifier (with source-location
/// information) that qualifies the name of this declaration, if it was
/// present in the source.
NestedNameSpecifierLoc getQualifierLoc() const {
  return hasExtInfo() ? getExtInfo()->QualifierLoc
                      : NestedNameSpecifierLoc();
}

void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);

unsigned getNumTemplateParameterLists() const {
  return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
}

TemplateParameterList *getTemplateParameterList(unsigned i) const {
  assert(i < getNumTemplateParameterLists())(static_cast <bool> (i < getNumTemplateParameterLists
()) ? void (0) : __assert_fail ("i < getNumTemplateParameterLists()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 3567, __extension__ __PRETTY_FUNCTION__));
  return getExtInfo()->TemplParamLists[i];
}

void setTemplateParameterListsInfo(ASTContext &Context,
                                   ArrayRef<TemplateParameterList *> TPLists);

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; }

static DeclContext *castToDeclContext(const TagDecl *D) {
  return static_cast<DeclContext *>(const_cast<TagDecl*>(D));
}

static TagDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
}
3585};

3587/// Represents an enum.  In C++11, enums can be forward-declared
3588/// with a fixed underlying type, and in C we allow them to be forward-declared
3589/// with no underlying type as an extension.
3590class EnumDecl : public TagDecl {
// This class stores some data in DeclContext::EnumDeclBits
// to save some space. Use the provided accessors to access it.

/// This represent the integer type that the enum corresponds
/// to for code generation purposes.  Note that the enumerator constants may
/// have a different type than this does.
///
/// If the underlying integer type was explicitly stated in the source
/// code, this is a TypeSourceInfo* for that type. Otherwise this type
/// was automatically deduced somehow, and this is a Type*.
///
/// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in
/// some cases it won't.
///
/// The underlying type of an enumeration never has any qualifiers, so
/// we can get away with just storing a raw Type*, and thus save an
/// extra pointer when TypeSourceInfo is needed.
llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;

/// The integer type that values of this type should
/// promote to.  In C, enumerators are generally of an integer type
/// directly, but gcc-style large enumerators (and all enumerators
/// in C++) are of the enum type instead.
QualType PromotionType;

/// If this enumeration is an instantiation of a member enumeration
/// of a class template specialization, this is the member specialization
/// information.
MemberSpecializationInfo *SpecializationInfo = nullptr;

/// Store the ODRHash after first calculation.
/// The corresponding flag HasODRHash is in EnumDeclBits
/// and can be accessed with the provided accessors.
unsigned ODRHash;

EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
         SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
         bool Scoped, bool ScopedUsingClassTag, bool Fixed);

void anchor() override;

void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
                                  TemplateSpecializationKind TSK);

/// Sets the width in bits required to store all the
/// non-negative enumerators of this enum.
void setNumPositiveBits(unsigned Num) {
  EnumDeclBits.NumPositiveBits = Num;
  assert(EnumDeclBits.NumPositiveBits == Num && "can't store this bitcount")(static_cast <bool> (EnumDeclBits.NumPositiveBits == Num
 && "can't store this bitcount") ? void (0) : __assert_fail
 ("EnumDeclBits.NumPositiveBits == Num && \"can't store this bitcount\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 3639, __extension__ __PRETTY_FUNCTION__));
}

/// Returns the width in bits required to store all the
/// negative enumerators of this enum. (see getNumNegativeBits)
void setNumNegativeBits(unsigned Num) { EnumDeclBits.NumNegativeBits = Num; }

3646public:
/// True if this tag declaration is a scoped enumeration. Only
/// possible in C++11 mode.
void setScoped(bool Scoped = true) { EnumDeclBits.IsScoped = Scoped; }

/// If this tag declaration is a scoped enum,
/// then this is true if the scoped enum was declared using the class
/// tag, false if it was declared with the struct tag. No meaning is
/// associated if this tag declaration is not a scoped enum.
void setScopedUsingClassTag(bool ScopedUCT = true) {
  EnumDeclBits.IsScopedUsingClassTag = ScopedUCT;
}

/// True if this is an Objective-C, C++11, or
/// Microsoft-style enumeration with a fixed underlying type.
void setFixed(bool Fixed = true) { EnumDeclBits.IsFixed = Fixed; }

3663private:
/// True if a valid hash is stored in ODRHash.
bool hasODRHash() const { return EnumDeclBits.HasODRHash; }
void setHasODRHash(bool Hash = true) { EnumDeclBits.HasODRHash = Hash; }

3668public:
friend class ASTDeclReader;

EnumDecl *getCanonicalDecl() override {
  return cast<EnumDecl>(TagDecl::getCanonicalDecl());
}
const EnumDecl *getCanonicalDecl() const {
  return const_cast<EnumDecl*>(this)->getCanonicalDecl();
}

EnumDecl *getPreviousDecl() {
  return cast_or_null<EnumDecl>(
          static_cast<TagDecl *>(this)->getPreviousDecl());
}
const EnumDecl *getPreviousDecl() const {
  return const_cast<EnumDecl*>(this)->getPreviousDecl();
}

EnumDecl *getMostRecentDecl() {
  return cast<EnumDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
}
const EnumDecl *getMostRecentDecl() const {
  return const_cast<EnumDecl*>(this)->getMostRecentDecl();
}

EnumDecl *getDefinition() const {
  return cast_or_null<EnumDecl>(TagDecl::getDefinition());
}

static EnumDecl *Create(ASTContext &C, DeclContext *DC,
                        SourceLocation StartLoc, SourceLocation IdLoc,
                        IdentifierInfo *Id, EnumDecl *PrevDecl,
                        bool IsScoped, bool IsScopedUsingClassTag,
                        bool IsFixed);
static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// When created, the EnumDecl corresponds to a
/// forward-declared enum. This method is used to mark the
/// declaration as being defined; its enumerators have already been
/// added (via DeclContext::addDecl). NewType is the new underlying
/// type of the enumeration type.
void completeDefinition(QualType NewType,
                        QualType PromotionType,
                        unsigned NumPositiveBits,
                        unsigned NumNegativeBits);

// Iterates through the enumerators of this enumeration.
using enumerator_iterator = specific_decl_iterator<EnumConstantDecl>;
using enumerator_range =
    llvm::iterator_range<specific_decl_iterator<EnumConstantDecl>>;

enumerator_range enumerators() const {
  return enumerator_range(enumerator_begin(), enumerator_end());
}

enumerator_iterator enumerator_begin() const {
  const EnumDecl *E = getDefinition();
  if (!E)
    E = this;
  return enumerator_iterator(E->decls_begin());
}

enumerator_iterator enumerator_end() const {
  const EnumDecl *E = getDefinition();
  if (!E)
    E = this;
  return enumerator_iterator(E->decls_end());
}

/// Return the integer type that enumerators should promote to.
QualType getPromotionType() const { return PromotionType; }

/// Set the promotion type.
void setPromotionType(QualType T) { PromotionType = T; }

/// Return the integer type this enum decl corresponds to.
/// This returns a null QualType for an enum forward definition with no fixed
/// underlying type.
QualType getIntegerType() const {
  if (!IntegerType)
    return QualType();
  if (const Type *T = IntegerType.dyn_cast<const Type*>())
    return QualType(T, 0);
  return IntegerType.get<TypeSourceInfo*>()->getType().getUnqualifiedType();
}

/// Set the underlying integer type.
void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); }

/// Set the underlying integer type source info.
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo) { IntegerType = TInfo; }

/// Return the type source info for the underlying integer type,
/// if no type source info exists, return 0.
TypeSourceInfo *getIntegerTypeSourceInfo() const {
  return IntegerType.dyn_cast<TypeSourceInfo*>();
}

/// Retrieve the source range that covers the underlying type if
/// specified.
SourceRange getIntegerTypeRange() const LLVM_READONLY__attribute__((__pure__));

/// Returns the width in bits required to store all the
/// non-negative enumerators of this enum.
unsigned getNumPositiveBits() const { return EnumDeclBits.NumPositiveBits; }

/// Returns the width in bits required to store all the
/// negative enumerators of this enum.  These widths include
/// the rightmost leading 1;  that is:
///
/// MOST NEGATIVE ENUMERATOR     PATTERN     NUM NEGATIVE BITS
/// ------------------------     -------     -----------------
///                       -1     1111111                     1
///                      -10     1110110                     5
///                     -101     1001011                     8
unsigned getNumNegativeBits() const { return EnumDeclBits.NumNegativeBits; }

/// Returns true if this is a C++11 scoped enumeration.
bool isScoped() const { return EnumDeclBits.IsScoped; }

/// Returns true if this is a C++11 scoped enumeration.
bool isScopedUsingClassTag() const {
  return EnumDeclBits.IsScopedUsingClassTag;
}

/// Returns true if this is an Objective-C, C++11, or
/// Microsoft-style enumeration with a fixed underlying type.
bool isFixed() const { return EnumDeclBits.IsFixed; }

unsigned getODRHash();

/// Returns true if this can be considered a complete type.
bool isComplete() const {
  // IntegerType is set for fixed type enums and non-fixed but implicitly
  // int-sized Microsoft enums.
  return isCompleteDefinition() || IntegerType;
}

/// Returns true if this enum is either annotated with
/// enum_extensibility(closed) or isn't annotated with enum_extensibility.
bool isClosed() const;

/// Returns true if this enum is annotated with flag_enum and isn't annotated
/// with enum_extensibility(open).
bool isClosedFlag() const;

/// Returns true if this enum is annotated with neither flag_enum nor
/// enum_extensibility(open).
bool isClosedNonFlag() const;

/// Retrieve the enum definition from which this enumeration could
/// be instantiated, if it is an instantiation (rather than a non-template).
EnumDecl *getTemplateInstantiationPattern() const;

/// Returns the enumeration (declared within the template)
/// from which this enumeration type was instantiated, or NULL if
/// this enumeration was not instantiated from any template.
EnumDecl *getInstantiatedFromMemberEnum() const;

/// If this enumeration is a member of a specialization of a
/// templated class, determine what kind of template specialization
/// or instantiation this is.
TemplateSpecializationKind getTemplateSpecializationKind() const;

/// For an enumeration member that was instantiated from a member
/// enumeration of a templated class, set the template specialiation kind.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
                      SourceLocation PointOfInstantiation = SourceLocation());

/// If this enumeration is an instantiation of a member enumeration of
/// a class template specialization, retrieves the member specialization
/// information.
MemberSpecializationInfo *getMemberSpecializationInfo() const {
  return SpecializationInfo;
}

/// Specify that this enumeration is an instantiation of the
/// member enumeration ED.
void setInstantiationOfMemberEnum(EnumDecl *ED,
                                  TemplateSpecializationKind TSK) {
  setInstantiationOfMemberEnum(getASTContext(), ED, TSK);
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Enum; }
3853};

3855/// Represents a struct/union/class.  For example:
3856///   struct X;                  // Forward declaration, no "body".
3857///   union Y { int A, B; };     // Has body with members A and B (FieldDecls).
3858/// This decl will be marked invalid if *any* members are invalid.
3859class RecordDecl : public TagDecl {
// This class stores some data in DeclContext::RecordDeclBits
// to save some space. Use the provided accessors to access it.
3862public:
friend class DeclContext;
/// Enum that represents the different ways arguments are passed to and
/// returned from function calls. This takes into account the target-specific
/// and version-specific rules along with the rules determined by the
/// language.
enum ArgPassingKind : unsigned {
  /// The argument of this type can be passed directly in registers.
  APK_CanPassInRegs,

  /// The argument of this type cannot be passed directly in registers.
  /// Records containing this type as a subobject are not forced to be passed
  /// indirectly. This value is used only in C++. This value is required by
  /// C++ because, in uncommon situations, it is possible for a class to have
  /// only trivial copy/move constructors even when one of its subobjects has
  /// a non-trivial copy/move constructor (if e.g. the corresponding copy/move
  /// constructor in the derived class is deleted).
  APK_CannotPassInRegs,

  /// The argument of this type cannot be passed directly in registers.
  /// Records containing this type as a subobject are forced to be passed
  /// indirectly.
  APK_CanNeverPassInRegs
};

3887protected:
RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
           SourceLocation StartLoc, SourceLocation IdLoc,
           IdentifierInfo *Id, RecordDecl *PrevDecl);

3892public:
static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
                          SourceLocation StartLoc, SourceLocation IdLoc,
                          IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);

RecordDecl *getPreviousDecl() {
  return cast_or_null<RecordDecl>(
          static_cast<TagDecl *>(this)->getPreviousDecl());
}
const RecordDecl *getPreviousDecl() const {
  return const_cast<RecordDecl*>(this)->getPreviousDecl();
}

RecordDecl *getMostRecentDecl() {
  return cast<RecordDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
}
const RecordDecl *getMostRecentDecl() const {
  return const_cast<RecordDecl*>(this)->getMostRecentDecl();
}

bool hasFlexibleArrayMember() const {
  return RecordDeclBits.HasFlexibleArrayMember;
}

void setHasFlexibleArrayMember(bool V) {
  RecordDeclBits.HasFlexibleArrayMember = V;
}

/// Whether this is an anonymous struct or union. To be an anonymous
/// struct or union, it must have been declared without a name and
/// there must be no objects of this type declared, e.g.,
/// @code
///   union { int i; float f; };
/// @endcode
/// is an anonymous union but neither of the following are:
/// @code
///  union X { int i; float f; };
///  union { int i; float f; } obj;
/// @endcode
bool isAnonymousStructOrUnion() const {
  return RecordDeclBits.AnonymousStructOrUnion;
}

void setAnonymousStructOrUnion(bool Anon) {
  RecordDeclBits.AnonymousStructOrUnion = Anon;
}

bool hasObjectMember() const { return RecordDeclBits.HasObjectMember; }
void setHasObjectMember(bool val) { RecordDeclBits.HasObjectMember = val; }

bool hasVolatileMember() const { return RecordDeclBits.HasVolatileMember; }

void setHasVolatileMember(bool val) {
  RecordDeclBits.HasVolatileMember = val;
}

bool hasLoadedFieldsFromExternalStorage() const {
  return RecordDeclBits.LoadedFieldsFromExternalStorage;
}

void setHasLoadedFieldsFromExternalStorage(bool val) const {
  RecordDeclBits.LoadedFieldsFromExternalStorage = val;
}

/// Functions to query basic properties of non-trivial C structs.
bool isNonTrivialToPrimitiveDefaultInitialize() const {
  return RecordDeclBits.NonTrivialToPrimitiveDefaultInitialize;
}

void setNonTrivialToPrimitiveDefaultInitialize(bool V) {
  RecordDeclBits.NonTrivialToPrimitiveDefaultInitialize = V;
}

bool isNonTrivialToPrimitiveCopy() const {
  return RecordDeclBits.NonTrivialToPrimitiveCopy;
}

void setNonTrivialToPrimitiveCopy(bool V) {
  RecordDeclBits.NonTrivialToPrimitiveCopy = V;
}

bool isNonTrivialToPrimitiveDestroy() const {
  return RecordDeclBits.NonTrivialToPrimitiveDestroy;
}

void setNonTrivialToPrimitiveDestroy(bool V) {
  RecordDeclBits.NonTrivialToPrimitiveDestroy = V;
}

bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
  return RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion;
}

void setHasNonTrivialToPrimitiveDefaultInitializeCUnion(bool V) {
  RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion = V;
}

bool hasNonTrivialToPrimitiveDestructCUnion() const {
  return RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion;
}

void setHasNonTrivialToPrimitiveDestructCUnion(bool V) {
  RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion = V;
}

bool hasNonTrivialToPrimitiveCopyCUnion() const {
  return RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion;
}

void setHasNonTrivialToPrimitiveCopyCUnion(bool V) {
  RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion = V;
}

/// Determine whether this class can be passed in registers. In C++ mode,
/// it must have at least one trivial, non-deleted copy or move constructor.
/// FIXME: This should be set as part of completeDefinition.
bool canPassInRegisters() const {
  return getArgPassingRestrictions() == APK_CanPassInRegs;
}

ArgPassingKind getArgPassingRestrictions() const {
  return static_cast<ArgPassingKind>(RecordDeclBits.ArgPassingRestrictions);
}

void setArgPassingRestrictions(ArgPassingKind Kind) {
  RecordDeclBits.ArgPassingRestrictions = Kind;
}

bool isParamDestroyedInCallee() const {
  return RecordDeclBits.ParamDestroyedInCallee;
}

void setParamDestroyedInCallee(bool V) {
  RecordDeclBits.ParamDestroyedInCallee = V;
}

/// Determines whether this declaration represents the
/// injected class name.
///
/// The injected class name in C++ is the name of the class that
/// appears inside the class itself. For example:
///
/// \code
/// struct C {
///   // C is implicitly declared here as a synonym for the class name.
/// };
///
/// C::C c; // same as "C c;"
/// \endcode
bool isInjectedClassName() const;

/// Determine whether this record is a class describing a lambda
/// function object.
bool isLambda() const;

/// Determine whether this record is a record for captured variables in
/// CapturedStmt construct.
bool isCapturedRecord() const;

/// Mark the record as a record for captured variables in CapturedStmt
/// construct.
void setCapturedRecord();

/// Returns the RecordDecl that actually defines
///  this struct/union/class.  When determining whether or not a
///  struct/union/class is completely defined, one should use this
///  method as opposed to 'isCompleteDefinition'.
///  'isCompleteDefinition' indicates whether or not a specific
///  RecordDecl is a completed definition, not whether or not the
///  record type is defined.  This method returns NULL if there is
///  no RecordDecl that defines the struct/union/tag.
RecordDecl *getDefinition() const {
  return cast_or_null<RecordDecl>(TagDecl::getDefinition());
}

/// Returns whether this record is a union, or contains (at any nesting level)
/// a union member. This is used by CMSE to warn about possible information
/// leaks.
bool isOrContainsUnion() const;

// Iterator access to field members. The field iterator only visits
// the non-static data members of this class, ignoring any static
// data members, functions, constructors, destructors, etc.
using field_iterator = specific_decl_iterator<FieldDecl>;
using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;

field_range fields() const { return field_range(field_begin(), field_end()); }
field_iterator field_begin() const;

field_iterator field_end() const {
  return field_iterator(decl_iterator());
}

// Whether there are any fields (non-static data members) in this record.
bool field_empty() const {
  return field_begin() == field_end();
}

/// Note that the definition of this type is now complete.
virtual void completeDefinition();

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstRecord && K <= lastRecord;
}

/// Get whether or not this is an ms_struct which can
/// be turned on with an attribute, pragma, or -mms-bitfields
/// commandline option.
bool isMsStruct(const ASTContext &C) const;

/// Whether we are allowed to insert extra padding between fields.
/// These padding are added to help AddressSanitizer detect
/// intra-object-overflow bugs.
bool mayInsertExtraPadding(bool EmitRemark = false) const;

/// Finds the first data member which has a name.
/// nullptr is returned if no named data member exists.
const FieldDecl *findFirstNamedDataMember() const;

4113private:
/// Deserialize just the fields.
void LoadFieldsFromExternalStorage() const;
4116};

4118class FileScopeAsmDecl : public Decl {
StringLiteral *AsmString;
SourceLocation RParenLoc;

FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring,
                 SourceLocation StartL, SourceLocation EndL)
  : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}

virtual void anchor();

4128public:
static FileScopeAsmDecl *Create(ASTContext &C, DeclContext *DC,
                                StringLiteral *Str, SourceLocation AsmLoc,
                                SourceLocation RParenLoc);

static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceLocation getAsmLoc() const { return getLocation(); }
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }
SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getAsmLoc(), getRParenLoc());
}

const StringLiteral *getAsmString() const { return AsmString; }
StringLiteral *getAsmString() { return AsmString; }
void setAsmString(StringLiteral *Asm) { AsmString = Asm; }

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == FileScopeAsm; }
4148};

4150/// Represents a block literal declaration, which is like an
4151/// unnamed FunctionDecl.  For example:
4152/// ^{ statement-body }   or   ^(int arg1, float arg2){ statement-body }
4153class BlockDecl : public Decl, public DeclContext {
// This class stores some data in DeclContext::BlockDeclBits
// to save some space. Use the provided accessors to access it.
4156public:
/// A class which contains all the information about a particular
/// captured value.
class Capture {
  enum {
    flag_isByRef = 0x1,
    flag_isNested = 0x2
  };

  /// The variable being captured.
  llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;

  /// The copy expression, expressed in terms of a DeclRef (or
  /// BlockDeclRef) to the captured variable.  Only required if the
  /// variable has a C++ class type.
  Expr *CopyExpr;

public:
  Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
    : VariableAndFlags(variable,
                (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
      CopyExpr(copy) {}

  /// The variable being captured.
  VarDecl *getVariable() const { return VariableAndFlags.getPointer(); }

  /// Whether this is a "by ref" capture, i.e. a capture of a __block
  /// variable.
  bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; }

  bool isEscapingByref() const {
    return getVariable()->isEscapingByref();
  }

  bool isNonEscapingByref() const {
    return getVariable()->isNonEscapingByref();
  }

  /// Whether this is a nested capture, i.e. the variable captured
  /// is not from outside the immediately enclosing function/block.
  bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; }

  bool hasCopyExpr() const { return CopyExpr != nullptr; }
  Expr *getCopyExpr() const { return CopyExpr; }
  void setCopyExpr(Expr *e) { CopyExpr = e; }
};

4203private:
/// A new[]'d array of pointers to ParmVarDecls for the formal
/// parameters of this function.  This is null if a prototype or if there are
/// no formals.
ParmVarDecl **ParamInfo = nullptr;
unsigned NumParams = 0;

Stmt *Body = nullptr;
TypeSourceInfo *SignatureAsWritten = nullptr;

const Capture *Captures = nullptr;
unsigned NumCaptures = 0;

unsigned ManglingNumber = 0;
Decl *ManglingContextDecl = nullptr;

4219protected:
BlockDecl(DeclContext *DC, SourceLocation CaretLoc);

4222public:
static BlockDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L);
static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceLocation getCaretLocation() const { return getLocation(); }

bool isVariadic() const { return BlockDeclBits.IsVariadic; }
void setIsVariadic(bool value) { BlockDeclBits.IsVariadic = value; }

CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; }
Stmt *getBody() const override { return (Stmt*) Body; }
void setBody(CompoundStmt *B) { Body = (Stmt*) B; }

void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; }
TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; }

// ArrayRef access to formal parameters.
ArrayRef<ParmVarDecl *> parameters() const {
  return {ParamInfo, getNumParams()};
}
MutableArrayRef<ParmVarDecl *> parameters() {
  return {ParamInfo, getNumParams()};
}

// Iterator access to formal parameters.
using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;

bool param_empty() const { return parameters().empty(); }
param_iterator param_begin() { return parameters().begin(); }
param_iterator param_end() { return parameters().end(); }
param_const_iterator param_begin() const { return parameters().begin(); }
param_const_iterator param_end() const { return parameters().end(); }
size_t param_size() const { return parameters().size(); }

unsigned getNumParams() const { return NumParams; }

const ParmVarDecl *getParamDecl(unsigned i) const {
  assert(i < getNumParams() && "Illegal param #")(static_cast <bool> (i < getNumParams() && "Illegal param #"
) ? void (0) : __assert_fail ("i < getNumParams() && \"Illegal param #\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4260, __extension__ __PRETTY_FUNCTION__));
  return ParamInfo[i];
}
ParmVarDecl *getParamDecl(unsigned i) {
  assert(i < getNumParams() && "Illegal param #")(static_cast <bool> (i < getNumParams() && "Illegal param #"
) ? void (0) : __assert_fail ("i < getNumParams() && \"Illegal param #\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4264, __extension__ __PRETTY_FUNCTION__));
  return ParamInfo[i];
}

void setParams(ArrayRef<ParmVarDecl *> NewParamInfo);

/// True if this block (or its nested blocks) captures
/// anything of local storage from its enclosing scopes.
bool hasCaptures() const { return NumCaptures || capturesCXXThis(); }
7
←
Assuming field 'NumCaptures' is not equal to 0→
8
←
Returning the value 1, which participates in a condition later→

/// Returns the number of captured variables.
/// Does not include an entry for 'this'.
unsigned getNumCaptures() const { return NumCaptures; }

using capture_const_iterator = ArrayRef<Capture>::const_iterator;

ArrayRef<Capture> captures() const { return {Captures, NumCaptures}; }

capture_const_iterator capture_begin() const { return captures().begin(); }
capture_const_iterator capture_end() const { return captures().end(); }

bool capturesCXXThis() const { return BlockDeclBits.CapturesCXXThis; }
void setCapturesCXXThis(bool B = true) { BlockDeclBits.CapturesCXXThis = B; }

bool blockMissingReturnType() const {
  return BlockDeclBits.BlockMissingReturnType;
}

void setBlockMissingReturnType(bool val = true) {
  BlockDeclBits.BlockMissingReturnType = val;
}

bool isConversionFromLambda() const {
  return BlockDeclBits.IsConversionFromLambda;
}

void setIsConversionFromLambda(bool val = true) {
  BlockDeclBits.IsConversionFromLambda = val;
}

bool doesNotEscape() const { return BlockDeclBits.DoesNotEscape; }
void setDoesNotEscape(bool B = true) { BlockDeclBits.DoesNotEscape = B; }

bool canAvoidCopyToHeap() const {
  return BlockDeclBits.CanAvoidCopyToHeap;
}
void setCanAvoidCopyToHeap(bool B = true) {
  BlockDeclBits.CanAvoidCopyToHeap = B;
}

bool capturesVariable(const VarDecl *var) const;

void setCaptures(ASTContext &Context, ArrayRef<Capture> Captures,
                 bool CapturesCXXThis);

unsigned getBlockManglingNumber() const { return ManglingNumber; }

Decl *getBlockManglingContextDecl() const { return ManglingContextDecl; }

void setBlockMangling(unsigned Number, Decl *Ctx) {
  ManglingNumber = Number;
  ManglingContextDecl = Ctx;
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Block; }
static DeclContext *castToDeclContext(const BlockDecl *D) {
  return static_cast<DeclContext *>(const_cast<BlockDecl*>(D));
}
static BlockDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC));
}
4339};

4341/// Represents the body of a CapturedStmt, and serves as its DeclContext.
4342class CapturedDecl final
  : public Decl,
    public DeclContext,
    private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
4346protected:
size_t numTrailingObjects(OverloadToken<ImplicitParamDecl>) {
  return NumParams;
}

4351private:
/// The number of parameters to the outlined function.
unsigned NumParams;

/// The position of context parameter in list of parameters.
unsigned ContextParam;

/// The body of the outlined function.
llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;

explicit CapturedDecl(DeclContext *DC, unsigned NumParams);

ImplicitParamDecl *const *getParams() const {
  return getTrailingObjects<ImplicitParamDecl *>();
}

ImplicitParamDecl **getParams() {
  return getTrailingObjects<ImplicitParamDecl *>();
}

4371public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend TrailingObjects;

static CapturedDecl *Create(ASTContext &C, DeclContext *DC,
                            unsigned NumParams);
static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                        unsigned NumParams);

Stmt *getBody() const override;
void setBody(Stmt *B);

bool isNothrow() const;
void setNothrow(bool Nothrow = true);

unsigned getNumParams() const { return NumParams; }

ImplicitParamDecl *getParam(unsigned i) const {
  assert(i < NumParams)(static_cast <bool> (i < NumParams) ? void (0) : __assert_fail
 ("i < NumParams", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4390, __extension__ __PRETTY_FUNCTION__));
  return getParams()[i];
}
void setParam(unsigned i, ImplicitParamDecl *P) {
  assert(i < NumParams)(static_cast <bool> (i < NumParams) ? void (0) : __assert_fail
 ("i < NumParams", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4394, __extension__ __PRETTY_FUNCTION__));
  getParams()[i] = P;
}

// ArrayRef interface to parameters.
ArrayRef<ImplicitParamDecl *> parameters() const {
  return {getParams(), getNumParams()};
}
MutableArrayRef<ImplicitParamDecl *> parameters() {
  return {getParams(), getNumParams()};
}

/// Retrieve the parameter containing captured variables.
ImplicitParamDecl *getContextParam() const {
  assert(ContextParam < NumParams)(static_cast <bool> (ContextParam < NumParams) ? void
 (0) : __assert_fail ("ContextParam < NumParams", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4408, __extension__ __PRETTY_FUNCTION__));
  return getParam(ContextParam);
}
void setContextParam(unsigned i, ImplicitParamDecl *P) {
  assert(i < NumParams)(static_cast <bool> (i < NumParams) ? void (0) : __assert_fail
 ("i < NumParams", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4412, __extension__ __PRETTY_FUNCTION__));
  ContextParam = i;
  setParam(i, P);
}
unsigned getContextParamPosition() const { return ContextParam; }

using param_iterator = ImplicitParamDecl *const *;
using param_range = llvm::iterator_range<param_iterator>;

/// Retrieve an iterator pointing to the first parameter decl.
param_iterator param_begin() const { return getParams(); }
/// Retrieve an iterator one past the last parameter decl.
param_iterator param_end() const { return getParams() + NumParams; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Captured; }
static DeclContext *castToDeclContext(const CapturedDecl *D) {
  return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D));
}
static CapturedDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC));
}
4435};

4437/// Describes a module import declaration, which makes the contents
4438/// of the named module visible in the current translation unit.
4439///
4440/// An import declaration imports the named module (or submodule). For example:
4441/// \code
4442///   @import std.vector;
4443/// \endcode
4444///
4445/// Import declarations can also be implicitly generated from
4446/// \#include/\#import directives.
4447class ImportDecl final : public Decl,
                       llvm::TrailingObjects<ImportDecl, SourceLocation> {
friend class ASTContext;
friend class ASTDeclReader;
friend class ASTReader;
friend TrailingObjects;

/// The imported module.
Module *ImportedModule = nullptr;

/// The next import in the list of imports local to the translation
/// unit being parsed (not loaded from an AST file).
///
/// Includes a bit that indicates whether we have source-location information
/// for each identifier in the module name.
///
/// When the bit is false, we only have a single source location for the
/// end of the import declaration.
llvm::PointerIntPair<ImportDecl *, 1, bool> NextLocalImportAndComplete;

ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
           ArrayRef<SourceLocation> IdentifierLocs);

ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
           SourceLocation EndLoc);

ImportDecl(EmptyShell Empty) : Decl(Import, Empty) {}

bool isImportComplete() const { return NextLocalImportAndComplete.getInt(); }

void setImportComplete(bool C) { NextLocalImportAndComplete.setInt(C); }

/// The next import in the list of imports local to the translation
/// unit being parsed (not loaded from an AST file).
ImportDecl *getNextLocalImport() const {
  return NextLocalImportAndComplete.getPointer();
}

void setNextLocalImport(ImportDecl *Import) {
  NextLocalImportAndComplete.setPointer(Import);
}

4489public:
/// Create a new module import declaration.
static ImportDecl *Create(ASTContext &C, DeclContext *DC,
                          SourceLocation StartLoc, Module *Imported,
                          ArrayRef<SourceLocation> IdentifierLocs);

/// Create a new module import declaration for an implicitly-generated
/// import.
static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC,
                                  SourceLocation StartLoc, Module *Imported,
                                  SourceLocation EndLoc);

/// Create a new, deserialized module import declaration.
static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                      unsigned NumLocations);

/// Retrieve the module that was imported by the import declaration.
Module *getImportedModule() const { return ImportedModule; }

/// Retrieves the locations of each of the identifiers that make up
/// the complete module name in the import declaration.
///
/// This will return an empty array if the locations of the individual
/// identifiers aren't available.
ArrayRef<SourceLocation> getIdentifierLocs() const;

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Import; }
4519};

4521/// Represents a C++ Modules TS module export declaration.
4522///
4523/// For example:
4524/// \code
4525///   export void foo();
4526/// \endcode
4527class ExportDecl final : public Decl, public DeclContext {
virtual void anchor();

4530private:
friend class ASTDeclReader;

/// The source location for the right brace (if valid).
SourceLocation RBraceLoc;

ExportDecl(DeclContext *DC, SourceLocation ExportLoc)
    : Decl(Export, DC, ExportLoc), DeclContext(Export),
      RBraceLoc(SourceLocation()) {}

4540public:
static ExportDecl *Create(ASTContext &C, DeclContext *DC,
                          SourceLocation ExportLoc);
static ExportDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceLocation getExportLoc() const { return getLocation(); }
SourceLocation getRBraceLoc() const { return RBraceLoc; }
void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }

bool hasBraces() const { return RBraceLoc.isValid(); }

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  if (hasBraces())
    return RBraceLoc;
  // No braces: get the end location of the (only) declaration in context
  // (if present).
  return decls_empty() ? getLocation() : decls_begin()->getEndLoc();
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getLocation(), getEndLoc());
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Export; }
static DeclContext *castToDeclContext(const ExportDecl *D) {
  return static_cast<DeclContext *>(const_cast<ExportDecl*>(D));
}
static ExportDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<ExportDecl *>(const_cast<DeclContext*>(DC));
}
4571};

4573/// Represents an empty-declaration.
4574class EmptyDecl : public Decl {
EmptyDecl(DeclContext *DC, SourceLocation L) : Decl(Empty, DC, L) {}

virtual void anchor();

4579public:
static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
                         SourceLocation L);
static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Empty; }
4586};

4588/// Insertion operator for diagnostics.  This allows sending NamedDecl's
4589/// into a diagnostic with <<.
4590inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           const NamedDecl *ND) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
                DiagnosticsEngine::ak_nameddecl);
return PD;
4595}

4597template<typename decl_type>
4598void Redeclarable<decl_type>::setPreviousDecl(decl_type *PrevDecl) {
// Note: This routine is implemented here because we need both NamedDecl
// and Redeclarable to be defined.
assert(RedeclLink.isFirst() &&(static_cast <bool> (RedeclLink.isFirst() && "setPreviousDecl on a decl already in a redeclaration chain"
) ? void (0) : __assert_fail ("RedeclLink.isFirst() && \"setPreviousDecl on a decl already in a redeclaration chain\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4602, __extension__ __PRETTY_FUNCTION__))
       "setPreviousDecl on a decl already in a redeclaration chain")(static_cast <bool> (RedeclLink.isFirst() && "setPreviousDecl on a decl already in a redeclaration chain"
) ? void (0) : __assert_fail ("RedeclLink.isFirst() && \"setPreviousDecl on a decl already in a redeclaration chain\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4602, __extension__ __PRETTY_FUNCTION__));

if (PrevDecl) {
  // Point to previous. Make sure that this is actually the most recent
  // redeclaration, or we can build invalid chains. If the most recent
  // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
  First = PrevDecl->getFirstDecl();
  assert(First->RedeclLink.isFirst() && "Expected first")(static_cast <bool> (First->RedeclLink.isFirst() &&
 "Expected first") ? void (0) : __assert_fail ("First->RedeclLink.isFirst() && \"Expected first\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4609, __extension__ __PRETTY_FUNCTION__));
  decl_type *MostRecent = First->getNextRedeclaration();
  RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));

  // If the declaration was previously visible, a redeclaration of it remains
  // visible even if it wouldn't be visible by itself.
  static_cast<decl_type*>(this)->IdentifierNamespace |=
    MostRecent->getIdentifierNamespace() &
    (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
} else {
  // Make this first.
  First = static_cast<decl_type*>(this);
}

// First one will point to this one as latest.
First->RedeclLink.setLatest(static_cast<decl_type*>(this));

assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) ||(static_cast <bool> (!isa<NamedDecl>(static_cast<
decl_type*>(this)) || cast<NamedDecl>(static_cast<
decl_type*>(this))->isLinkageValid()) ? void (0) : __assert_fail
 ("!isa<NamedDecl>(static_cast<decl_type*>(this)) || cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4627, __extension__ __PRETTY_FUNCTION__))
       cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid())(static_cast <bool> (!isa<NamedDecl>(static_cast<
decl_type*>(this)) || cast<NamedDecl>(static_cast<
decl_type*>(this))->isLinkageValid()) ? void (0) : __assert_fail
 ("!isa<NamedDecl>(static_cast<decl_type*>(this)) || cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Decl.h"
, 4627, __extension__ __PRETTY_FUNCTION__));
4628}

4630// Inline function definitions.

4632/// Check if the given decl is complete.
4633///
4634/// We use this function to break a cycle between the inline definitions in
4635/// Type.h and Decl.h.
4636inline bool IsEnumDeclComplete(EnumDecl *ED) {
return ED->isComplete();
4638}

4640/// Check if the given decl is scoped.
4641///
4642/// We use this function to break a cycle between the inline definitions in
4643/// Type.h and Decl.h.
4644inline bool IsEnumDeclScoped(EnumDecl *ED) {
return ED->isScoped();
4646}

4648/// OpenMP variants are mangled early based on their OpenMP context selector.
4649/// The new name looks likes this:
4650///  <name> + OpenMPVariantManglingSeparatorStr + <mangled OpenMP context>
4651static constexpr StringRef getOpenMPVariantManglingSeparatorStr() {
return "$ompvariant";
4653}

4655} // namespace clang

4657#endif // LLVM_CLANG_AST_DECL_H