/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/libclang/Indexing.cpp

Bug Summary

File:	tools/clang/tools/libclang/Indexing.cpp
Warning:	line 381, column 16 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Indexing.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D CLANG_TOOL_EXTRA_BUILD -D _CINDEX_LIB_ -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/tools/libclang -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/libclang -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/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-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/tools/libclang -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/libclang/Indexing.cpp

/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/libclang/Indexing.cpp

→

1//===- CIndexHigh.cpp - Higher level API functions ------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#include "CIndexDiagnostic.h"
11#include "CIndexer.h"
12#include "CLog.h"
13#include "CXCursor.h"
14#include "CXIndexDataConsumer.h"
15#include "CXSourceLocation.h"
16#include "CXString.h"
17#include "CXTranslationUnit.h"
18#include "clang/AST/ASTConsumer.h"
19#include "clang/Frontend/ASTUnit.h"
20#include "clang/Frontend/CompilerInstance.h"
21#include "clang/Frontend/CompilerInvocation.h"
22#include "clang/Frontend/FrontendAction.h"
23#include "clang/Frontend/Utils.h"
24#include "clang/Index/IndexingAction.h"
25#include "clang/Lex/HeaderSearch.h"
26#include "clang/Lex/PPCallbacks.h"
27#include "clang/Lex/PPConditionalDirectiveRecord.h"
28#include "clang/Lex/Preprocessor.h"
29#include "clang/Lex/PreprocessorOptions.h"
30#include "llvm/Support/CrashRecoveryContext.h"
31#include "llvm/Support/MemoryBuffer.h"
32#include "llvm/Support/Mutex.h"
33#include "llvm/Support/MutexGuard.h"
34#include <cstdio>
35#include <utility>

37using namespace clang;
38using namespace clang::index;
39using namespace cxtu;
40using namespace cxindex;

42namespace {

44//===----------------------------------------------------------------------===//
45// Skip Parsed Bodies
46//===----------------------------------------------------------------------===//

48/// \brief A "region" in source code identified by the file/offset of the
49/// preprocessor conditional directive that it belongs to.
50/// Multiple, non-consecutive ranges can be parts of the same region.
51///
52/// As an example of different regions separated by preprocessor directives:
53///
54/// \code
55///   #1
56/// #ifdef BLAH
57///   #2
58/// #ifdef CAKE
59///   #3
60/// #endif
61///   #2
62/// #endif
63///   #1
64/// \endcode
65///
66/// There are 3 regions, with non-consecutive parts:
67///   #1 is identified as the beginning of the file
68///   #2 is identified as the location of "#ifdef BLAH"
69///   #3 is identified as the location of "#ifdef CAKE"
70///
71class PPRegion {
llvm::sys::fs::UniqueID UniqueID;
time_t ModTime;
unsigned Offset;
75public:
PPRegion() : UniqueID(0, 0), ModTime(), Offset() {}
PPRegion(llvm::sys::fs::UniqueID UniqueID, unsigned offset, time_t modTime)
    : UniqueID(UniqueID), ModTime(modTime), Offset(offset) {}

const llvm::sys::fs::UniqueID &getUniqueID() const { return UniqueID; }
unsigned getOffset() const { return Offset; }
time_t getModTime() const { return ModTime; }

bool isInvalid() const { return *this == PPRegion(); }

friend bool operator==(const PPRegion &lhs, const PPRegion &rhs) {
  return lhs.UniqueID == rhs.UniqueID && lhs.Offset == rhs.Offset &&
         lhs.ModTime == rhs.ModTime;
}
90};

92typedef llvm::DenseSet<PPRegion> PPRegionSetTy;

94} // end anonymous namespace

96namespace llvm {
template <> struct isPodLike<PPRegion> {
  static const bool value = true;
};

template <>
struct DenseMapInfo<PPRegion> {
  static inline PPRegion getEmptyKey() {
    return PPRegion(llvm::sys::fs::UniqueID(0, 0), unsigned(-1), 0);
  }
  static inline PPRegion getTombstoneKey() {
    return PPRegion(llvm::sys::fs::UniqueID(0, 0), unsigned(-2), 0);
  }

  static unsigned getHashValue(const PPRegion &S) {
    llvm::FoldingSetNodeID ID;
    const llvm::sys::fs::UniqueID &UniqueID = S.getUniqueID();
    ID.AddInteger(UniqueID.getFile());
    ID.AddInteger(UniqueID.getDevice());
    ID.AddInteger(S.getOffset());
    ID.AddInteger(S.getModTime());
    return ID.ComputeHash();
  }

  static bool isEqual(const PPRegion &LHS, const PPRegion &RHS) {
    return LHS == RHS;
  }
};
124}

126namespace {

128class SessionSkipBodyData {
llvm::sys::Mutex Mux;
PPRegionSetTy ParsedRegions;

132public:
SessionSkipBodyData() : Mux(/*recursive=*/false) {}
~SessionSkipBodyData() {
  //llvm::errs() << "RegionData: " << Skipped.size() << " - " << Skipped.getMemorySize() << "\n";
}

void copyTo(PPRegionSetTy &Set) {
  llvm::MutexGuard MG(Mux);
  Set = ParsedRegions;
}

void update(ArrayRef<PPRegion> Regions) {
  llvm::MutexGuard MG(Mux);
  ParsedRegions.insert(Regions.begin(), Regions.end());
}
147};

149class TUSkipBodyControl {
SessionSkipBodyData &SessionData;
PPConditionalDirectiveRecord &PPRec;
Preprocessor &PP;

PPRegionSetTy ParsedRegions;
SmallVector<PPRegion, 32> NewParsedRegions;
PPRegion LastRegion;
bool LastIsParsed;

159public:
TUSkipBodyControl(SessionSkipBodyData &sessionData,
                  PPConditionalDirectiveRecord &ppRec,
                  Preprocessor &pp)
  : SessionData(sessionData), PPRec(ppRec), PP(pp) {
  SessionData.copyTo(ParsedRegions);
}

bool isParsed(SourceLocation Loc, FileID FID, const FileEntry *FE) {
  PPRegion region = getRegion(Loc, FID, FE);
  if (region.isInvalid())
    return false;

  // Check common case, consecutive functions in the same region.
  if (LastRegion == region)
    return LastIsParsed;

  LastRegion = region;
  LastIsParsed = ParsedRegions.count(region);
  if (!LastIsParsed)
    NewParsedRegions.push_back(region);
  return LastIsParsed;
}

void finished() {
  SessionData.update(NewParsedRegions);
}

187private:
PPRegion getRegion(SourceLocation Loc, FileID FID, const FileEntry *FE) {
  SourceLocation RegionLoc = PPRec.findConditionalDirectiveRegionLoc(Loc);
  if (RegionLoc.isInvalid()) {
    if (isParsedOnceInclude(FE)) {
      const llvm::sys::fs::UniqueID &ID = FE->getUniqueID();
      return PPRegion(ID, 0, FE->getModificationTime());
    }
    return PPRegion();
  }

  const SourceManager &SM = PPRec.getSourceManager();
  assert(RegionLoc.isFileID())(static_cast <bool> (RegionLoc.isFileID()) ? void (0) :
 __assert_fail ("RegionLoc.isFileID()", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/libclang/Indexing.cpp"
, 199, __extension__ __PRETTY_FUNCTION__));
  FileID RegionFID;
  unsigned RegionOffset;
  std::tie(RegionFID, RegionOffset) = SM.getDecomposedLoc(RegionLoc);

  if (RegionFID != FID) {
    if (isParsedOnceInclude(FE)) {
      const llvm::sys::fs::UniqueID &ID = FE->getUniqueID();
      return PPRegion(ID, 0, FE->getModificationTime());
    }
    return PPRegion();
  }

  const llvm::sys::fs::UniqueID &ID = FE->getUniqueID();
  return PPRegion(ID, RegionOffset, FE->getModificationTime());
}

bool isParsedOnceInclude(const FileEntry *FE) {
  return PP.getHeaderSearchInfo().isFileMultipleIncludeGuarded(FE);
}
219};

221//===----------------------------------------------------------------------===//
222// IndexPPCallbacks
223//===----------------------------------------------------------------------===//

225class IndexPPCallbacks : public PPCallbacks {
Preprocessor &PP;
CXIndexDataConsumer &DataConsumer;
bool IsMainFileEntered;

230public:
IndexPPCallbacks(Preprocessor &PP, CXIndexDataConsumer &dataConsumer)
  : PP(PP), DataConsumer(dataConsumer), IsMainFileEntered(false) { }

void FileChanged(SourceLocation Loc, FileChangeReason Reason,
               SrcMgr::CharacteristicKind FileType, FileID PrevFID) override {
  if (IsMainFileEntered)
    return;

  SourceManager &SM = PP.getSourceManager();
  SourceLocation MainFileLoc = SM.getLocForStartOfFile(SM.getMainFileID());

  if (Loc == MainFileLoc && Reason == PPCallbacks::EnterFile) {
    IsMainFileEntered = true;
    DataConsumer.enteredMainFile(SM.getFileEntryForID(SM.getMainFileID()));
  }
}

void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                        StringRef FileName, bool IsAngled,
                        CharSourceRange FilenameRange, const FileEntry *File,
                        StringRef SearchPath, StringRef RelativePath,
                        const Module *Imported) override {
  bool isImport = (IncludeTok.is(tok::identifier) &&
          IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import);
  DataConsumer.ppIncludedFile(HashLoc, FileName, File, isImport, IsAngled,
                          Imported);
}

/// MacroDefined - This hook is called whenever a macro definition is seen.
void MacroDefined(const Token &Id, const MacroDirective *MD) override {}

/// MacroUndefined - This hook is called whenever a macro #undef is seen.
/// MI is released immediately following this callback.
void MacroUndefined(const Token &MacroNameTok,
                    const MacroDefinition &MD,
                    const MacroDirective *UD) override {}

/// MacroExpands - This is called by when a macro invocation is found.
void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                  SourceRange Range, const MacroArgs *Args) override {}

/// SourceRangeSkipped - This hook is called when a source range is skipped.
/// \param Range The SourceRange that was skipped. The range begins at the
/// #if/#else directive and ends after the #endif/#else directive.
void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override {
}
277};

279//===----------------------------------------------------------------------===//
280// IndexingConsumer
281//===----------------------------------------------------------------------===//

283class IndexingConsumer : public ASTConsumer {
CXIndexDataConsumer &DataConsumer;
TUSkipBodyControl *SKCtrl;

287public:
IndexingConsumer(CXIndexDataConsumer &dataConsumer, TUSkipBodyControl *skCtrl)
  : DataConsumer(dataConsumer), SKCtrl(skCtrl) { }

// ASTConsumer Implementation

void Initialize(ASTContext &Context) override {
  DataConsumer.setASTContext(Context);
  DataConsumer.startedTranslationUnit();
}

void HandleTranslationUnit(ASTContext &Ctx) override {
  if (SKCtrl)
    SKCtrl->finished();
}

bool HandleTopLevelDecl(DeclGroupRef DG) override {
  return !DataConsumer.shouldAbort();
}

bool shouldSkipFunctionBody(Decl *D) override {
  if (!SKCtrl) {
    // Always skip bodies.
    return true;
  }

  const SourceManager &SM = DataConsumer.getASTContext().getSourceManager();
  SourceLocation Loc = D->getLocation();
  if (Loc.isMacroID())
    return false;
  if (SM.isInSystemHeader(Loc))
    return true; // always skip bodies from system headers.

  FileID FID;
  unsigned Offset;
  std::tie(FID, Offset) = SM.getDecomposedLoc(Loc);
  // Don't skip bodies from main files; this may be revisited.
  if (SM.getMainFileID() == FID)
    return false;
  const FileEntry *FE = SM.getFileEntryForID(FID);
  if (!FE)
    return false;

  return SKCtrl->isParsed(Loc, FID, FE);
}
332};

334//===----------------------------------------------------------------------===//
335// CaptureDiagnosticConsumer
336//===----------------------------------------------------------------------===//

338class CaptureDiagnosticConsumer : public DiagnosticConsumer {
SmallVector<StoredDiagnostic, 4> Errors;
340public:

void HandleDiagnostic(DiagnosticsEngine::Level level,
                      const Diagnostic &Info) override {
  if (level >= DiagnosticsEngine::Error)
    Errors.push_back(StoredDiagnostic(level, Info));
}
347};

349//===----------------------------------------------------------------------===//
350// IndexingFrontendAction
351//===----------------------------------------------------------------------===//

353class IndexingFrontendAction : public ASTFrontendAction {
std::shared_ptr<CXIndexDataConsumer> DataConsumer;

SessionSkipBodyData *SKData;
std::unique_ptr<TUSkipBodyControl> SKCtrl;

359public:
IndexingFrontendAction(std::shared_ptr<CXIndexDataConsumer> dataConsumer,
                       SessionSkipBodyData *skData)
    : DataConsumer(std::move(dataConsumer)), SKData(skData) {}

std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                               StringRef InFile) override {
  PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();

  if (!PPOpts.ImplicitPCHInclude.empty()) {
1
Assuming the condition is false→
2
←
Taking false branch→
    DataConsumer->importedPCH(
                      CI.getFileManager().getFile(PPOpts.ImplicitPCHInclude));
  }

  DataConsumer->setASTContext(CI.getASTContext());
  Preprocessor &PP = CI.getPreprocessor();
  PP.addPPCallbacks(llvm::make_unique<IndexPPCallbacks>(PP, *DataConsumer));
  DataConsumer->setPreprocessor(CI.getPreprocessorPtr());

  if (SKData) {
3
←
Assuming the condition is true→
4
←
Taking true branch→
    auto *PPRec = new PPConditionalDirectiveRecord(PP.getSourceManager());
5
←
Memory is allocated→
    PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(PPRec));
6
←
Calling '~unique_ptr'→
11
←
Returning from '~unique_ptr'→
    SKCtrl = llvm::make_unique<TUSkipBodyControl>(*SKData, *PPRec, PP);
12
←
Use of memory after it is freed
  }

  return llvm::make_unique<IndexingConsumer>(*DataConsumer, SKCtrl.get());
}

TranslationUnitKind getTranslationUnitKind() override {
  if (DataConsumer->shouldIndexImplicitTemplateInsts())
    return TU_Complete;
  else
    return TU_Prefix;
}
bool hasCodeCompletionSupport() const override { return false; }
394};

396//===----------------------------------------------------------------------===//
397// clang_indexSourceFileUnit Implementation
398//===----------------------------------------------------------------------===//

400static IndexingOptions getIndexingOptionsFromCXOptions(unsigned index_options) {
IndexingOptions IdxOpts;
if (index_options & CXIndexOpt_IndexFunctionLocalSymbols)
  IdxOpts.IndexFunctionLocals = true;
return IdxOpts;
405}

407struct IndexSessionData {
CXIndex CIdx;
std::unique_ptr<SessionSkipBodyData> SkipBodyData;

explicit IndexSessionData(CXIndex cIdx)
  : CIdx(cIdx), SkipBodyData(new SessionSkipBodyData) {}
413};

415} // anonymous namespace

417static CXErrorCode clang_indexSourceFile_Impl(
  CXIndexAction cxIdxAction, CXClientData client_data,
  IndexerCallbacks *client_index_callbacks, unsigned index_callbacks_size,
  unsigned index_options, const char *source_filename,
  const char *const *command_line_args, int num_command_line_args,
  ArrayRef<CXUnsavedFile> unsaved_files, CXTranslationUnit *out_TU,
  unsigned TU_options) {
if (out_TU)
  *out_TU = nullptr;
bool requestedToGetTU = (out_TU != nullptr);

if (!cxIdxAction) {
  return CXError_InvalidArguments;
}
if (!client_index_callbacks || index_callbacks_size == 0) {
  return CXError_InvalidArguments;
}

IndexerCallbacks CB;
memset(&CB, 0, sizeof(CB));
unsigned ClientCBSize = index_callbacks_size < sizeof(CB)
                                ? index_callbacks_size : sizeof(CB);
memcpy(&CB, client_index_callbacks, ClientCBSize);

IndexSessionData *IdxSession = static_cast<IndexSessionData *>(cxIdxAction);
CIndexer *CXXIdx = static_cast<CIndexer *>(IdxSession->CIdx);

if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
  setThreadBackgroundPriority();

bool CaptureDiagnostics = !Logger::isLoggingEnabled();

CaptureDiagnosticConsumer *CaptureDiag = nullptr;
if (CaptureDiagnostics)
  CaptureDiag = new CaptureDiagnosticConsumer();

// Configure the diagnostics.
IntrusiveRefCntPtr<DiagnosticsEngine>
  Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions,
                                            CaptureDiag,
                                            /*ShouldOwnClient=*/true));

// Recover resources if we crash before exiting this function.
llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
  llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
  DiagCleanup(Diags.get());

std::unique_ptr<std::vector<const char *>> Args(
    new std::vector<const char *>());

// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> >
  ArgsCleanup(Args.get());

Args->insert(Args->end(), command_line_args,
             command_line_args + num_command_line_args);

// The 'source_filename' argument is optional.  If the caller does not
// specify it then it is assumed that the source file is specified
// in the actual argument list.
// Put the source file after command_line_args otherwise if '-x' flag is
// present it will be unused.
if (source_filename)
  Args->push_back(source_filename);

std::shared_ptr<CompilerInvocation> CInvok =
    createInvocationFromCommandLine(*Args, Diags);

if (!CInvok)
  return CXError_Failure;

// Recover resources if we crash before exiting this function.
llvm::CrashRecoveryContextCleanupRegistrar<
    std::shared_ptr<CompilerInvocation>,
    llvm::CrashRecoveryContextDestructorCleanup<
        std::shared_ptr<CompilerInvocation>>>
    CInvokCleanup(&CInvok);

if (CInvok->getFrontendOpts().Inputs.empty())
  return CXError_Failure;

typedef SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 8> MemBufferOwner;
std::unique_ptr<MemBufferOwner> BufOwner(new MemBufferOwner);

// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<MemBufferOwner> BufOwnerCleanup(
    BufOwner.get());

for (auto &UF : unsaved_files) {
  std::unique_ptr<llvm::MemoryBuffer> MB =
      llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
  CInvok->getPreprocessorOpts().addRemappedFile(UF.Filename, MB.get());
  BufOwner->push_back(std::move(MB));
}

// Since libclang is primarily used by batch tools dealing with
// (often very broken) source code, where spell-checking can have a
// significant negative impact on performance (particularly when 
// precompiled headers are involved), we disable it.
CInvok->getLangOpts()->SpellChecking = false;

if (index_options & CXIndexOpt_SuppressWarnings)
  CInvok->getDiagnosticOpts().IgnoreWarnings = true;

// Make sure to use the raw module format.
CInvok->getHeaderSearchOpts().ModuleFormat =
  CXXIdx->getPCHContainerOperations()->getRawReader().getFormat();

auto Unit = ASTUnit::create(CInvok, Diags, CaptureDiagnostics,
                            /*UserFilesAreVolatile=*/true);
if (!Unit)
  return CXError_InvalidArguments;

auto *UPtr = Unit.get();
std::unique_ptr<CXTUOwner> CXTU(
    new CXTUOwner(MakeCXTranslationUnit(CXXIdx, std::move(Unit))));

// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<CXTUOwner>
  CXTUCleanup(CXTU.get());

// Enable the skip-parsed-bodies optimization only for C++; this may be
// revisited.
bool SkipBodies = (index_options & CXIndexOpt_SkipParsedBodiesInSession) &&
    CInvok->getLangOpts()->CPlusPlus;
if (SkipBodies)
  CInvok->getFrontendOpts().SkipFunctionBodies = true;

auto DataConsumer =
  std::make_shared<CXIndexDataConsumer>(client_data, CB, index_options,
                                        CXTU->getTU());
auto InterAction = llvm::make_unique<IndexingFrontendAction>(DataConsumer,
                       SkipBodies ? IdxSession->SkipBodyData.get() : nullptr);
std::unique_ptr<FrontendAction> IndexAction;
IndexAction = createIndexingAction(DataConsumer,
                              getIndexingOptionsFromCXOptions(index_options),
                                   std::move(InterAction));

// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<FrontendAction>
  IndexActionCleanup(IndexAction.get());

bool Persistent = requestedToGetTU;
bool OnlyLocalDecls = false;
bool PrecompilePreamble = false;
bool CreatePreambleOnFirstParse = false;
bool CacheCodeCompletionResults = false;
PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts(); 
PPOpts.AllowPCHWithCompilerErrors = true;

if (requestedToGetTU) {
  OnlyLocalDecls = CXXIdx->getOnlyLocalDecls();
  PrecompilePreamble = TU_options & CXTranslationUnit_PrecompiledPreamble;
  CreatePreambleOnFirstParse =
      TU_options & CXTranslationUnit_CreatePreambleOnFirstParse;
  // FIXME: Add a flag for modules.
  CacheCodeCompletionResults
    = TU_options & CXTranslationUnit_CacheCompletionResults;
}

if (TU_options & CXTranslationUnit_DetailedPreprocessingRecord) {
  PPOpts.DetailedRecord = true;
}

if (!requestedToGetTU && !CInvok->getLangOpts()->Modules)
  PPOpts.DetailedRecord = false;

// Unless the user specified that they want the preamble on the first parse
// set it up to be created on the first reparse. This makes the first parse
// faster, trading for a slower (first) reparse.
unsigned PrecompilePreambleAfterNParses =
    !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse;
DiagnosticErrorTrap DiagTrap(*Diags);
bool Success = ASTUnit::LoadFromCompilerInvocationAction(
    std::move(CInvok), CXXIdx->getPCHContainerOperations(), Diags,
    IndexAction.get(), UPtr, Persistent, CXXIdx->getClangResourcesPath(),
    OnlyLocalDecls, CaptureDiagnostics, PrecompilePreambleAfterNParses,
    CacheCodeCompletionResults,
    /*IncludeBriefCommentsInCodeCompletion=*/false,
    /*UserFilesAreVolatile=*/true);
if (DiagTrap.hasErrorOccurred() && CXXIdx->getDisplayDiagnostics())
  printDiagsToStderr(UPtr);

if (isASTReadError(UPtr))
  return CXError_ASTReadError;

if (!Success)
  return CXError_Failure;

if (out_TU)
  *out_TU = CXTU->takeTU();

return CXError_Success;
610}

612//===----------------------------------------------------------------------===//
613// clang_indexTranslationUnit Implementation
614//===----------------------------------------------------------------------===//

616static void indexPreprocessingRecord(ASTUnit &Unit, CXIndexDataConsumer &IdxCtx) {
Preprocessor &PP = Unit.getPreprocessor();
if (!PP.getPreprocessingRecord())
  return;

// FIXME: Only deserialize inclusion directives.

bool isModuleFile = Unit.isModuleFile();
for (PreprocessedEntity *PPE : Unit.getLocalPreprocessingEntities()) {
  if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
    SourceLocation Loc = ID->getSourceRange().getBegin();
    // Modules have synthetic main files as input, give an invalid location
    // if the location points to such a file.
    if (isModuleFile && Unit.isInMainFileID(Loc))
      Loc = SourceLocation();
    IdxCtx.ppIncludedFile(Loc, ID->getFileName(),
                          ID->getFile(),
                          ID->getKind() == InclusionDirective::Import,
                          !ID->wasInQuotes(), ID->importedModule());
  }
}
637}

639static CXErrorCode clang_indexTranslationUnit_Impl(
  CXIndexAction idxAction, CXClientData client_data,
  IndexerCallbacks *client_index_callbacks, unsigned index_callbacks_size,
  unsigned index_options, CXTranslationUnit TU) {
// Check arguments.
if (isNotUsableTU(TU)) {
  LOG_BAD_TU(TU)do { if (clang::cxindex::LogRef Log = clang::cxindex::Logger::
make(__func__)) { *Log << "called with a bad TU: " <<
 TU; } } while(false);
  return CXError_InvalidArguments;
}
if (!client_index_callbacks || index_callbacks_size == 0) {
  return CXError_InvalidArguments;
}

CIndexer *CXXIdx = TU->CIdx;
if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
  setThreadBackgroundPriority();

IndexerCallbacks CB;
memset(&CB, 0, sizeof(CB));
unsigned ClientCBSize = index_callbacks_size < sizeof(CB)
                                ? index_callbacks_size : sizeof(CB);
memcpy(&CB, client_index_callbacks, ClientCBSize);

auto DataConsumer = std::make_shared<CXIndexDataConsumer>(client_data, CB,
                                                          index_options, TU);

ASTUnit *Unit = cxtu::getASTUnit(TU);
if (!Unit)
  return CXError_Failure;

ASTUnit::ConcurrencyCheck Check(*Unit);

if (const FileEntry *PCHFile = Unit->getPCHFile())
  DataConsumer->importedPCH(PCHFile);

FileManager &FileMgr = Unit->getFileManager();

if (Unit->getOriginalSourceFileName().empty())
  DataConsumer->enteredMainFile(nullptr);
else
  DataConsumer->enteredMainFile(FileMgr.getFile(Unit->getOriginalSourceFileName()));

DataConsumer->setASTContext(Unit->getASTContext());
DataConsumer->startedTranslationUnit();

indexPreprocessingRecord(*Unit, *DataConsumer);
indexASTUnit(*Unit, DataConsumer, getIndexingOptionsFromCXOptions(index_options));
DataConsumer->indexDiagnostics();

return CXError_Success;
689}

691//===----------------------------------------------------------------------===//
692// libclang public APIs.
693//===----------------------------------------------------------------------===//

695int clang_index_isEntityObjCContainerKind(CXIdxEntityKind K) {
return CXIdxEntity_ObjCClass <= K && K <= CXIdxEntity_ObjCCategory;
697}

699const CXIdxObjCContainerDeclInfo *
700clang_index_getObjCContainerDeclInfo(const CXIdxDeclInfo *DInfo) {
if (!DInfo)
  return nullptr;

const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
if (const ObjCContainerDeclInfo *
      ContInfo = dyn_cast<ObjCContainerDeclInfo>(DI))
  return &ContInfo->ObjCContDeclInfo;

return nullptr;
710}

712const CXIdxObjCInterfaceDeclInfo *
713clang_index_getObjCInterfaceDeclInfo(const CXIdxDeclInfo *DInfo) {
if (!DInfo)
  return nullptr;

const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
if (const ObjCInterfaceDeclInfo *
      InterInfo = dyn_cast<ObjCInterfaceDeclInfo>(DI))
  return &InterInfo->ObjCInterDeclInfo;

return nullptr;
723}

725const CXIdxObjCCategoryDeclInfo *
726clang_index_getObjCCategoryDeclInfo(const CXIdxDeclInfo *DInfo){
if (!DInfo)
  return nullptr;

const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
if (const ObjCCategoryDeclInfo *
      CatInfo = dyn_cast<ObjCCategoryDeclInfo>(DI))
  return &CatInfo->ObjCCatDeclInfo;

return nullptr;
736}

738const CXIdxObjCProtocolRefListInfo *
739clang_index_getObjCProtocolRefListInfo(const CXIdxDeclInfo *DInfo) {
if (!DInfo)
  return nullptr;

const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);

if (const ObjCInterfaceDeclInfo *
      InterInfo = dyn_cast<ObjCInterfaceDeclInfo>(DI))
  return InterInfo->ObjCInterDeclInfo.protocols;

if (const ObjCProtocolDeclInfo *
      ProtInfo = dyn_cast<ObjCProtocolDeclInfo>(DI))
  return &ProtInfo->ObjCProtoRefListInfo;

if (const ObjCCategoryDeclInfo *CatInfo = dyn_cast<ObjCCategoryDeclInfo>(DI))
  return CatInfo->ObjCCatDeclInfo.protocols;

return nullptr;
757}

759const CXIdxObjCPropertyDeclInfo *
760clang_index_getObjCPropertyDeclInfo(const CXIdxDeclInfo *DInfo) {
if (!DInfo)
  return nullptr;

const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
if (const ObjCPropertyDeclInfo *PropInfo = dyn_cast<ObjCPropertyDeclInfo>(DI))
  return &PropInfo->ObjCPropDeclInfo;

return nullptr;
769}

771const CXIdxIBOutletCollectionAttrInfo *
772clang_index_getIBOutletCollectionAttrInfo(const CXIdxAttrInfo *AInfo) {
if (!AInfo)
  return nullptr;

const AttrInfo *DI = static_cast<const AttrInfo *>(AInfo);
if (const IBOutletCollectionInfo *
      IBInfo = dyn_cast<IBOutletCollectionInfo>(DI))
  return &IBInfo->IBCollInfo;

return nullptr;
782}

784const CXIdxCXXClassDeclInfo *
785clang_index_getCXXClassDeclInfo(const CXIdxDeclInfo *DInfo) {
if (!DInfo)
  return nullptr;

const DeclInfo *DI = static_cast<const DeclInfo *>(DInfo);
if (const CXXClassDeclInfo *ClassInfo = dyn_cast<CXXClassDeclInfo>(DI))
  return &ClassInfo->CXXClassInfo;

return nullptr;
794}

796CXIdxClientContainer
797clang_index_getClientContainer(const CXIdxContainerInfo *info) {
if (!info)
  return nullptr;
const ContainerInfo *Container = static_cast<const ContainerInfo *>(info);
return Container->IndexCtx->getClientContainerForDC(Container->DC);
802}

804void clang_index_setClientContainer(const CXIdxContainerInfo *info,
                                  CXIdxClientContainer client) {
if (!info)
  return;
const ContainerInfo *Container = static_cast<const ContainerInfo *>(info);
Container->IndexCtx->addContainerInMap(Container->DC, client);
810}

812CXIdxClientEntity clang_index_getClientEntity(const CXIdxEntityInfo *info) {
if (!info)
  return nullptr;
const EntityInfo *Entity = static_cast<const EntityInfo *>(info);
return Entity->IndexCtx->getClientEntity(Entity->Dcl);
817}

819void clang_index_setClientEntity(const CXIdxEntityInfo *info,
                               CXIdxClientEntity client) {
if (!info)
  return;
const EntityInfo *Entity = static_cast<const EntityInfo *>(info);
Entity->IndexCtx->setClientEntity(Entity->Dcl, client);
825}

827CXIndexAction clang_IndexAction_create(CXIndex CIdx) {
return new IndexSessionData(CIdx);
829}

831void clang_IndexAction_dispose(CXIndexAction idxAction) {
if (idxAction)
  delete static_cast<IndexSessionData *>(idxAction);
834}

836int clang_indexSourceFile(CXIndexAction idxAction,
                        CXClientData client_data,
                        IndexerCallbacks *index_callbacks,
                        unsigned index_callbacks_size,
                        unsigned index_options,
                        const char *source_filename,
                        const char * const *command_line_args,
                        int num_command_line_args,
                        struct CXUnsavedFile *unsaved_files,
                        unsigned num_unsaved_files,
                        CXTranslationUnit *out_TU,
                        unsigned TU_options) {
SmallVector<const char *, 4> Args;
Args.push_back("clang");
Args.append(command_line_args, command_line_args + num_command_line_args);
return clang_indexSourceFileFullArgv(
    idxAction, client_data, index_callbacks, index_callbacks_size,
    index_options, source_filename, Args.data(), Args.size(), unsaved_files,
    num_unsaved_files, out_TU, TU_options);
855}

857int clang_indexSourceFileFullArgv(
  CXIndexAction idxAction, CXClientData client_data,
  IndexerCallbacks *index_callbacks, unsigned index_callbacks_size,
  unsigned index_options, const char *source_filename,
  const char *const *command_line_args, int num_command_line_args,
  struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
  CXTranslationUnit *out_TU, unsigned TU_options) {
LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) {
  *Log << source_filename << ": ";
  for (int i = 0; i != num_command_line_args; ++i)
    *Log << command_line_args[i] << " ";
}

if (num_unsaved_files && !unsaved_files)
  return CXError_InvalidArguments;

CXErrorCode result = CXError_Failure;
auto IndexSourceFileImpl = [=, &result]() {
  result = clang_indexSourceFile_Impl(
      idxAction, client_data, index_callbacks, index_callbacks_size,
      index_options, source_filename, command_line_args,
      num_command_line_args,
      llvm::makeArrayRef(unsaved_files, num_unsaved_files), out_TU,
      TU_options);
};

llvm::CrashRecoveryContext CRC;

if (!RunSafely(CRC, IndexSourceFileImpl)) {
  fprintf(stderrstderr, "libclang: crash detected during indexing source file: {\n");
  fprintf(stderrstderr, "  'source_filename' : '%s'\n", source_filename);
  fprintf(stderrstderr, "  'command_line_args' : [");
  for (int i = 0; i != num_command_line_args; ++i) {
    if (i)
      fprintf(stderrstderr, ", ");
    fprintf(stderrstderr, "'%s'", command_line_args[i]);
  }
  fprintf(stderrstderr, "],\n");
  fprintf(stderrstderr, "  'unsaved_files' : [");
  for (unsigned i = 0; i != num_unsaved_files; ++i) {
    if (i)
      fprintf(stderrstderr, ", ");
    fprintf(stderrstderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
            unsaved_files[i].Length);
  }
  fprintf(stderrstderr, "],\n");
  fprintf(stderrstderr, "  'options' : %d,\n", TU_options);
  fprintf(stderrstderr, "}\n");
  
  return 1;
} else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
  if (out_TU)
    PrintLibclangResourceUsage(*out_TU);
}

return result;
913}

915int clang_indexTranslationUnit(CXIndexAction idxAction,
                             CXClientData client_data,
                             IndexerCallbacks *index_callbacks,
                             unsigned index_callbacks_size,
                             unsigned index_options,
                             CXTranslationUnit TU) {
LOG_FUNC_SECTIONif (clang::cxindex::LogRef Log = clang::cxindex::Logger::make
(__func__)) {
  *Log << TU;
}

CXErrorCode result;
auto IndexTranslationUnitImpl = [=, &result]() {
  result = clang_indexTranslationUnit_Impl(
      idxAction, client_data, index_callbacks, index_callbacks_size,
      index_options, TU);
};

llvm::CrashRecoveryContext CRC;

if (!RunSafely(CRC, IndexTranslationUnitImpl)) {
  fprintf(stderrstderr, "libclang: crash detected during indexing TU\n");
  
  return 1;
}

return result;
941}

943void clang_indexLoc_getFileLocation(CXIdxLoc location,
                                  CXIdxClientFile *indexFile,
                                  CXFile *file,
                                  unsigned *line,
                                  unsigned *column,
                                  unsigned *offset) {
if (indexFile) *indexFile = nullptr;
if (file)   *file = nullptr;
if (line)   *line = 0;
if (column) *column = 0;
if (offset) *offset = 0;

SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
if (!location.ptr_data[0] || Loc.isInvalid())
  return;

CXIndexDataConsumer &DataConsumer =
    *static_cast<CXIndexDataConsumer*>(location.ptr_data[0]);
DataConsumer.translateLoc(Loc, indexFile, file, line, column, offset);
962}

964CXSourceLocation clang_indexLoc_getCXSourceLocation(CXIdxLoc location) {
SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
if (!location.ptr_data[0] || Loc.isInvalid())
  return clang_getNullLocation();

CXIndexDataConsumer &DataConsumer =
    *static_cast<CXIndexDataConsumer*>(location.ptr_data[0]);
return cxloc::translateSourceLocation(DataConsumer.getASTContext(), Loc);
972}


←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/unique_ptr.h

1// unique_ptr implementation -*- C++ -*-

3// Copyright (C) 2008-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file bits/unique_ptr.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

30#ifndef _UNIQUE_PTR_H1
31#define _UNIQUE_PTR_H1 1

33#include <bits/c++config.h>
34#include <debug/assertions.h>
35#include <type_traits>
36#include <utility>
37#include <tuple>
38#include <bits/stl_function.h>
39#include <bits/functional_hash.h>

41namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
42{
43_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

50#if _GLIBCXX_USE_DEPRECATED1
template<typename> class auto_ptr;
52#endif

/// Primary template of default_delete, used by unique_ptr
template<typename _Tp>
  struct default_delete
  {
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, @p _Up,
     * only if @p _Up* is convertible to @p _Tp*.
     */
    template<typename _Up, typename = typename
      enable_if<is_convertible<_Up*, _Tp*>::value>::type>
      default_delete(const default_delete<_Up>&) noexcept { }

    /// Calls @c delete @p __ptr
    void
    operator()(_Tp* __ptr) const
    {
static_assert(!is_void<_Tp>::value,
      "can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete __ptr;
9
←
Memory is released→
    }
  };

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
/// Specialization for arrays, default_delete.
template<typename _Tp>
  struct default_delete<_Tp[]>
  {
  public:
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, such as
     * a const-qualified version of @p _Tp.
     *
     * Conversions from types derived from @c _Tp are not allowed because
     * it is unsafe to @c delete[] an array of derived types through a
     * pointer to the base type.
     */
    template<typename _Up, typename = typename
      enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
      default_delete(const default_delete<_Up[]>&) noexcept { }

    /// Calls @c delete[] @p __ptr
    template<typename _Up>
    typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr) const
    {
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete [] __ptr;
    }
  };

template <typename _Tp, typename _Dp>
  class __uniq_ptr_impl
  {
    template <typename _Up, typename _Ep, typename = void>
struct _Ptr
{
 using type = _Up*;
};

    template <typename _Up, typename _Ep>
struct
_Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
{
 using type = typename remove_reference<_Ep>::type::pointer;
};

  public:
    using _DeleterConstraint = enable_if<
      __and_<__not_<is_pointer<_Dp>>,
      is_default_constructible<_Dp>>::value>;

    using pointer = typename _Ptr<_Tp, _Dp>::type;

    __uniq_ptr_impl() = default;
    __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

    template<typename _Del>
    __uniq_ptr_impl(pointer __p, _Del&& __d)
: _M_t(__p, std::forward<_Del>(__d)) { }

    pointer&   _M_ptr() { return std::get<0>(_M_t); }
    pointer    _M_ptr() const { return std::get<0>(_M_t); }
    _Dp&       _M_deleter() { return std::get<1>(_M_t); }
    const _Dp& _M_deleter() const { return std::get<1>(_M_t); }

  private:
    tuple<pointer, _Dp> _M_t;
  };

/// 20.7.1.2 unique_ptr for single objects.
template <typename _Tp, typename _Dp = default_delete<_Tp>>
  class unique_ptr
  {
    template <class _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_impl<_Tp, _Dp> _M_t;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep>
using __safe_conversion_up = __and_<
       is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
              __not_<is_array<_Up>>,
              __or_<__and_<is_reference<deleter_type>,
                           is_same<deleter_type, _Ep>>,
                    __and_<__not_<is_reference<deleter_type>>,
                           is_convertible<_Ep, deleter_type>>
              >
            >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr() noexcept
: _M_t()
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    unique_ptr(pointer __p,
 typename conditional<is_reference<deleter_type>::value,
   deleter_type, const deleter_type&>::type __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  An rvalue reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    unique_ptr(pointer __p,
 typename remove_reference<deleter_type>::type&& __d) noexcept
    : _M_t(std::move(__p), std::move(__d))
    { static_assert(!std::is_reference<deleter_type>::value,
      "rvalue deleter bound to reference"); }

    /// Creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }

    // Move constructors.

    /// Move constructor.
    unique_ptr(unique_ptr&& __u) noexcept
    : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }

    /** @brief Converting constructor from another type
     *
     * Requires that the pointer owned by @p __u is convertible to the
     * type of pointer owned by this object, @p __u does not own an array,
     * and @p __u has a compatible deleter type.
     */
    template<typename _Up, typename _Ep, typename = _Require<
             __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

256#if _GLIBCXX_USE_DEPRECATED1
    /// Converting constructor from @c auto_ptr
    template<typename _Up, typename = _Require<
      is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
261#endif

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr() noexcept
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
7
←
Taking true branch→
 get_deleter()(__ptr);
8
←
Calling 'default_delete::operator()'→
10
←
Returning; memory was released via 2nd parameter→
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * @param __u  The object to transfer ownership from.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&& __u) noexcept
    {
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
    }

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to a non-array object.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
      typename enable_if< __and_<
        __safe_conversion_up<_Up, _Ep>,
        is_assignable<deleter_type&, _Ep&&>
        >::value,
        unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Dereference the stored pointer.
    typename add_lvalue_reference<element_type>::type
    operator*() const
    {
__glibcxx_assert(get() != pointer());
return *get();
    }

    /// Return the stored pointer.
    pointer
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
return get();
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    {
pointer __p = get();
_M_t._M_ptr() = pointer();
return __p;
    }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    void
    reset(pointer __p = pointer()) noexcept
    {
using std::swap;
swap(_M_t._M_ptr(), __p);
if (__p != pointer())
 get_deleter()(__p);
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
using std::swap;
swap(_M_t, __u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
};

/// 20.7.1.3 unique_ptr for array objects with a runtime length
// [unique.ptr.runtime]
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
template<typename _Tp, typename _Dp>
  class unique_ptr<_Tp[], _Dp>
  {
    template <typename _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_impl<_Tp, _Dp> _M_t;

    template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;

    // like is_base_of<_Tp, _Up> but false if unqualified types are the same
    template<typename _Up>
using __is_derived_Tp
 = __and_< is_base_of<_Tp, _Up>,
    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep,
             typename _Up_up = unique_ptr<_Up, _Ep>,
      typename _Up_element_type = typename _Up_up::element_type>
using __safe_conversion_up = __and_<
        is_array<_Up>,
        is_same<pointer, element_type*>,
        is_same<typename _Up_up::pointer, _Up_element_type*>,
        is_convertible<_Up_element_type(*)[], element_type(*)[]>,
        __or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>,
              __and_<__not_<is_reference<deleter_type>>,
                     is_convertible<_Ep, deleter_type>>>
      >;

    // helper template for detecting a safe conversion from a raw pointer
    template<typename _Up>
      using __safe_conversion_raw = __and_<
        __or_<__or_<is_same<_Up, pointer>,
                    is_same<_Up, nullptr_t>>,
              __and_<is_pointer<_Up>,
                     is_same<pointer, element_type*>,
                     is_convertible<
                       typename remove_pointer<_Up>::type(*)[],
                       element_type(*)[]>
              >
        >
      >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr() noexcept
: _M_t()
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Up,
      typename _Vp = _Dp,
      typename = _DeleterConstraint<_Vp>,
      typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
explicit
unique_ptr(_Up __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Up,
             typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
    unique_ptr(_Up __p,
               typename conditional<is_reference<deleter_type>::value,
               deleter_type, const deleter_type&>::type __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Up,
             typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
    unique_ptr(_Up __p, typename
 remove_reference<deleter_type>::type&& __d) noexcept
    : _M_t(std::move(__p), std::move(__d))
    { static_assert(!is_reference<deleter_type>::value,
      "rvalue deleter bound to reference"); }

    /// Move constructor.
    unique_ptr(unique_ptr&& __u) noexcept
    : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }

    /// Creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }

    template<typename _Up, typename _Ep,
      typename = _Require<__safe_conversion_up<_Up, _Ep>>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr()
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(__ptr);
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * @param __u  The object to transfer ownership from.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&& __u) noexcept
    {
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
    }

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to an array object.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
typename
enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
                       is_assignable<deleter_type&, _Ep&&>
                >::value,
                unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Access an element of owned array.
    typename std::add_lvalue_reference<element_type>::type
    operator[](size_t __i) const
    {
__glibcxx_assert(get() != pointer());
return get()[__i];
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    {
pointer __p = get();
_M_t._M_ptr() = pointer();
return __p;
    }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    template <typename _Up,
              typename = _Require<
                __or_<is_same<_Up, pointer>,
                      __and_<is_same<pointer, element_type*>,
                             is_pointer<_Up>,
                             is_convertible<
                               typename remove_pointer<_Up>::type(*)[],
                               element_type(*)[]
                             >
                      >
                >
             >>
    void
    reset(_Up __p) noexcept
    {
pointer __ptr = __p;
using std::swap;
swap(_M_t._M_ptr(), __ptr);
if (__ptr != nullptr)
 get_deleter()(__ptr);
    }

    void reset(nullptr_t = nullptr) noexcept
    {
      reset(pointer());
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
using std::swap;
swap(_M_t, __u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };

template<typename _Tp, typename _Dp>
  inline
663#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
  // Constrained free swap overload, see p0185r1
  typename enable_if<__is_swappable<_Dp>::value>::type
666#else
  void
668#endif
  swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
  { __x.swap(__y); }

673#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
template<typename _Tp, typename _Dp>
  typename enable_if<!__is_swappable<_Dp>::value>::type
  swap(unique_ptr<_Tp, _Dp>&,
unique_ptr<_Tp, _Dp>&) = delete;
678#endif

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() == __y.get(); }

template<typename _Tp, typename _Dp>
  inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return !__x; }

template<typename _Tp, typename _Dp>
  inline bool
  operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return !__x; }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() != __y.get(); }

template<typename _Tp, typename _Dp>
  inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return (bool)__x; }

template<typename _Tp, typename _Dp>
  inline bool
  operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return (bool)__x; }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  {
    typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
                typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
    return std::less<_CT>()(__x.get(), __y.get());
  }

template<typename _Tp, typename _Dp>
  inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr); }

template<typename _Tp, typename _Dp>
  inline bool
  operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get()); }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__y < __x); }

template<typename _Tp, typename _Dp>
  inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(nullptr < __x); }

template<typename _Tp, typename _Dp>
  inline bool
  operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(__x < nullptr); }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  { return (__y < __x); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get()); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr); }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__x < __y); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(__x < nullptr); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(nullptr < __x); }

/// std::hash specialization for unique_ptr.
template<typename _Tp, typename _Dp>
  struct hash<unique_ptr<_Tp, _Dp>>
  : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
  private __poison_hash<typename unique_ptr<_Tp, _Dp>::pointer>
  {
    size_t
    operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
    {
typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
    }
  };

805#if __cplusplus201103L > 201103L

807#define __cpp_lib_make_unique 201304

template<typename _Tp>
  struct _MakeUniq
  { typedef unique_ptr<_Tp> __single_object; };

template<typename _Tp>
  struct _MakeUniq<_Tp[]>
  { typedef unique_ptr<_Tp[]> __array; };

template<typename _Tp, size_t _Bound>
  struct _MakeUniq<_Tp[_Bound]>
  { struct __invalid_type { }; };

/// std::make_unique for single objects
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__single_object
  make_unique(_Args&&... __args)
  { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

/// std::make_unique for arrays of unknown bound
template<typename _Tp>
  inline typename _MakeUniq<_Tp>::__array
  make_unique(size_t __num)
  { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }

/// Disable std::make_unique for arrays of known bound
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__invalid_type
  make_unique(_Args&&...) = delete;
837#endif

// @} group pointer_abstractions

841_GLIBCXX_END_NAMESPACE_VERSION
842} // namespace

844#endif /* _UNIQUE_PTR_H */