/build/source/clang-tools-extra/clangd/ClangdServer.cpp

Bug Summary

File:	build/source/clang-tools-extra/clangd/ClangdServer.cpp
Warning:	line 372, column 10 Potential leak of memory pointed to by field '_M_pi'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ClangdServer.cpp -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 -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D CLANG_REPOSITORY_STRING="++20230331100734+94a74b9dbb5c-1~exp1~20230331220852.1199" -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/tools/extra/clangd -I /build/source/clang-tools-extra/clangd -I /build/source/clang-tools-extra/clangd/../include-cleaner/include -I tools/clang/tools/extra/clangd/../clang-tidy -I /build/source/clang/include -I tools/clang/include -I include -I /build/source/llvm/include -I /build/source/clang-tools-extra/pseudo/lib/../include -D _FORTIFY_SOURCE=2 -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-17/lib/clang/17/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 -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1680300532 -O2 -Wno-unused-command-line-argument -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 -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -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-2023-04-01-083001-16331-1 -x c++ /build/source/clang-tools-extra/clangd/ClangdServer.cpp

/build/source/clang-tools-extra/clangd/ClangdServer.cpp

→

1//===--- ClangdServer.cpp - Main clangd server code --------------*- 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//===-------------------------------------------------------------------===//

9#include "ClangdServer.h"
10#include "CodeComplete.h"
11#include "Config.h"
12#include "Diagnostics.h"
13#include "DumpAST.h"
14#include "FindSymbols.h"
15#include "Format.h"
16#include "HeaderSourceSwitch.h"
17#include "InlayHints.h"
18#include "ParsedAST.h"
19#include "Preamble.h"
20#include "Protocol.h"
21#include "SemanticHighlighting.h"
22#include "SemanticSelection.h"
23#include "SourceCode.h"
24#include "TUScheduler.h"
25#include "XRefs.h"
26#include "index/CanonicalIncludes.h"
27#include "index/FileIndex.h"
28#include "index/Merge.h"
29#include "index/StdLib.h"
30#include "refactor/Rename.h"
31#include "refactor/Tweak.h"
32#include "support/Cancellation.h"
33#include "support/Logger.h"
34#include "support/MemoryTree.h"
35#include "support/ThreadsafeFS.h"
36#include "support/Trace.h"
37#include "clang/Format/Format.h"
38#include "clang/Lex/Preprocessor.h"
39#include "clang/Tooling/CompilationDatabase.h"
40#include "clang/Tooling/Core/Replacement.h"
41#include "llvm/ADT/ArrayRef.h"
42#include "llvm/ADT/STLExtras.h"
43#include "llvm/ADT/StringRef.h"
44#include "llvm/Support/Error.h"
45#include "llvm/Support/Path.h"
46#include "llvm/Support/raw_ostream.h"
47#include <algorithm>
48#include <chrono>
49#include <future>
50#include <memory>
51#include <mutex>
52#include <optional>
53#include <string>
54#include <type_traits>

56namespace clang {
57namespace clangd {
58namespace {

60// Update the FileIndex with new ASTs and plumb the diagnostics responses.
61struct UpdateIndexCallbacks : public ParsingCallbacks {
UpdateIndexCallbacks(FileIndex *FIndex,
                     ClangdServer::Callbacks *ServerCallbacks,
                     const ThreadsafeFS &TFS, AsyncTaskRunner *Tasks)
    : FIndex(FIndex), ServerCallbacks(ServerCallbacks), TFS(TFS),
      Stdlib{std::make_shared<StdLibSet>()}, Tasks(Tasks) {}

void onPreambleAST(PathRef Path, llvm::StringRef Version,
                   const CompilerInvocation &CI, ASTContext &Ctx,
                   Preprocessor &PP,
                   const CanonicalIncludes &CanonIncludes) override {
  // If this preamble uses a standard library we haven't seen yet, index it.
  if (FIndex)
    if (auto Loc = Stdlib->add(*CI.getLangOpts(), PP.getHeaderSearchInfo()))
      indexStdlib(CI, std::move(*Loc));

  if (FIndex)
    FIndex->updatePreamble(Path, Version, Ctx, PP, CanonIncludes);
}

void indexStdlib(const CompilerInvocation &CI, StdLibLocation Loc) {
  // This task is owned by Tasks, which outlives the TUScheduler and
  // therefore the UpdateIndexCallbacks.
  // We must be careful that the references we capture outlive TUScheduler.
  auto Task = [LO(*CI.getLangOpts()), Loc(std::move(Loc)),
               CI(std::make_unique<CompilerInvocation>(CI)),
               // External values that outlive ClangdServer
               TFS(&TFS),
               // Index outlives TUScheduler (declared first)
               FIndex(FIndex),
               // shared_ptr extends lifetime
               Stdlib(Stdlib)]() mutable {
    IndexFileIn IF;
    IF.Symbols = indexStandardLibrary(std::move(CI), Loc, *TFS);
    if (Stdlib->isBest(LO))
      FIndex->updatePreamble(std::move(IF));
  };
  if (Tasks)
    // This doesn't have a semaphore to enforce -j, but it's rare.
    Tasks->runAsync("IndexStdlib", std::move(Task));
  else
    Task();
}

void onMainAST(PathRef Path, ParsedAST &AST, PublishFn Publish) override {
  if (FIndex)
    FIndex->updateMain(Path, AST);

  assert(AST.getDiagnostics() &&(static_cast <bool> (AST.getDiagnostics() && "We issue callback only with fresh preambles"
) ? void (0) : __assert_fail ("AST.getDiagnostics() && \"We issue callback only with fresh preambles\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 110, __extension__
 __PRETTY_FUNCTION__))
         "We issue callback only with fresh preambles")(static_cast <bool> (AST.getDiagnostics() && "We issue callback only with fresh preambles"
) ? void (0) : __assert_fail ("AST.getDiagnostics() && \"We issue callback only with fresh preambles\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 110, __extension__
 __PRETTY_FUNCTION__));
  std::vector<Diag> Diagnostics = *AST.getDiagnostics();
  if (ServerCallbacks)
    Publish([&]() {
      ServerCallbacks->onDiagnosticsReady(Path, AST.version(),
                                          std::move(Diagnostics));
    });
}

void onFailedAST(PathRef Path, llvm::StringRef Version,
                 std::vector<Diag> Diags, PublishFn Publish) override {
  if (ServerCallbacks)
    Publish(
        [&]() { ServerCallbacks->onDiagnosticsReady(Path, Version, Diags); });
}

void onFileUpdated(PathRef File, const TUStatus &Status) override {
  if (ServerCallbacks)
    ServerCallbacks->onFileUpdated(File, Status);
}

void onPreamblePublished(PathRef File) override {
  if (ServerCallbacks)
    ServerCallbacks->onSemanticsMaybeChanged(File);
}

136private:
FileIndex *FIndex;
ClangdServer::Callbacks *ServerCallbacks;
const ThreadsafeFS &TFS;
std::shared_ptr<StdLibSet> Stdlib;
AsyncTaskRunner *Tasks;
142};

144class DraftStoreFS : public ThreadsafeFS {
145public:
DraftStoreFS(const ThreadsafeFS &Base, const DraftStore &Drafts)
    : Base(Base), DirtyFiles(Drafts) {}

149private:
llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> viewImpl() const override {
  auto OFS = llvm::makeIntrusiveRefCnt<llvm::vfs::OverlayFileSystem>(
      Base.view(std::nullopt));
  OFS->pushOverlay(DirtyFiles.asVFS());
  return OFS;
}

const ThreadsafeFS &Base;
const DraftStore &DirtyFiles;
159};

161} // namespace

163ClangdServer::Options ClangdServer::optsForTest() {
ClangdServer::Options Opts;
Opts.UpdateDebounce = DebouncePolicy::fixed(/*zero*/ {});
Opts.StorePreamblesInMemory = true;
Opts.AsyncThreadsCount = 4; // Consistent!
return Opts;
169}

171ClangdServer::Options::operator TUScheduler::Options() const {
TUScheduler::Options Opts;
Opts.AsyncThreadsCount = AsyncThreadsCount;
Opts.RetentionPolicy = RetentionPolicy;
Opts.StorePreamblesInMemory = StorePreamblesInMemory;
Opts.UpdateDebounce = UpdateDebounce;
Opts.ContextProvider = ContextProvider;
Opts.PreambleThrottler = PreambleThrottler;
return Opts;
180}

182ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
                         const ThreadsafeFS &TFS, const Options &Opts,
                         Callbacks *Callbacks)
  : FeatureModules(Opts.FeatureModules), CDB(CDB), TFS(TFS),
    DynamicIdx(Opts.BuildDynamicSymbolIndex ? new FileIndex() : nullptr),
    ClangTidyProvider(Opts.ClangTidyProvider),
    UseDirtyHeaders(Opts.UseDirtyHeaders),
    LineFoldingOnly(Opts.LineFoldingOnly),
    PreambleParseForwardingFunctions(Opts.PreambleParseForwardingFunctions),
    ImportInsertions(Opts.ImportInsertions),
    WorkspaceRoot(Opts.WorkspaceRoot),
    Transient(Opts.ImplicitCancellation ? TUScheduler::InvalidateOnUpdate
                                        : TUScheduler::NoInvalidation),
    DirtyFS(std::make_unique<DraftStoreFS>(TFS, DraftMgr)) {
if (Opts.AsyncThreadsCount != 0)
  IndexTasks.emplace();
// Pass a callback into `WorkScheduler` to extract symbols from a newly
// parsed file and rebuild the file index synchronously each time an AST
// is parsed.
WorkScheduler.emplace(CDB, TUScheduler::Options(Opts),
                      std::make_unique<UpdateIndexCallbacks>(
                          DynamicIdx.get(), Callbacks, TFS,
                          IndexTasks ? &*IndexTasks : nullptr));
// Adds an index to the stack, at higher priority than existing indexes.
auto AddIndex = [&](SymbolIndex *Idx) {
  if (this->Index != nullptr) {
    MergedIdx.push_back(std::make_unique<MergedIndex>(Idx, this->Index));
    this->Index = MergedIdx.back().get();
  } else {
    this->Index = Idx;
  }
};
if (Opts.StaticIndex)
  AddIndex(Opts.StaticIndex);
if (Opts.BackgroundIndex) {
  BackgroundIndex::Options BGOpts;
  BGOpts.ThreadPoolSize = std::max(Opts.AsyncThreadsCount, 1u);
  BGOpts.OnProgress = [Callbacks](BackgroundQueue::Stats S) {
    if (Callbacks)
      Callbacks->onBackgroundIndexProgress(S);
  };
  BGOpts.ContextProvider = Opts.ContextProvider;
  BackgroundIdx = std::make_unique<BackgroundIndex>(
      TFS, CDB,
      BackgroundIndexStorage::createDiskBackedStorageFactory(
          [&CDB](llvm::StringRef File) { return CDB.getProjectInfo(File); }),
      std::move(BGOpts));
  AddIndex(BackgroundIdx.get());
}
if (DynamicIdx)
  AddIndex(DynamicIdx.get());

if (Opts.FeatureModules) {
  FeatureModule::Facilities F{
      *this->WorkScheduler,
      this->Index,
      this->TFS,
  };
  for (auto &Mod : *Opts.FeatureModules)
    Mod.initialize(F);
}
243}

245ClangdServer::~ClangdServer() {
// Destroying TUScheduler first shuts down request threads that might
// otherwise access members concurrently.
// (Nobody can be using TUScheduler because we're on the main thread).
WorkScheduler.reset();
// Now requests have stopped, we can shut down feature modules.
if (FeatureModules) {
  for (auto &Mod : *FeatureModules)
    Mod.stop();
  for (auto &Mod : *FeatureModules)
    Mod.blockUntilIdle(Deadline::infinity());
}
257}

259void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents,
                             llvm::StringRef Version,
                             WantDiagnostics WantDiags, bool ForceRebuild) {
std::string ActualVersion = DraftMgr.addDraft(File, Version, Contents);
ParseOptions Opts;
Opts.PreambleParseForwardingFunctions = PreambleParseForwardingFunctions;
Opts.ImportInsertions = ImportInsertions;

// Compile command is set asynchronously during update, as it can be slow.
ParseInputs Inputs;
Inputs.TFS = &getHeaderFS();
Inputs.Contents = std::string(Contents);
Inputs.Version = std::move(ActualVersion);
Inputs.ForceRebuild = ForceRebuild;
Inputs.Opts = std::move(Opts);
Inputs.Index = Index;
Inputs.ClangTidyProvider = ClangTidyProvider;
Inputs.FeatureModules = FeatureModules;
bool NewFile = WorkScheduler->update(File, Inputs, WantDiags);
// If we loaded Foo.h, we want to make sure Foo.cpp is indexed.
if (NewFile && BackgroundIdx)
  BackgroundIdx->boostRelated(File);
281}

283void ClangdServer::reparseOpenFilesIfNeeded(
  llvm::function_ref<bool(llvm::StringRef File)> Filter) {
// Reparse only opened files that were modified.
for (const Path &FilePath : DraftMgr.getActiveFiles())
  if (Filter(FilePath))
    if (auto Draft = DraftMgr.getDraft(FilePath)) // else disappeared in race?
      addDocument(FilePath, *Draft->Contents, Draft->Version,
                  WantDiagnostics::Auto);
291}

293std::shared_ptr<const std::string> ClangdServer::getDraft(PathRef File) const {
auto Draft = DraftMgr.getDraft(File);
if (!Draft)
  return nullptr;
return std::move(Draft->Contents);
298}

300std::function<Context(PathRef)>
301ClangdServer::createConfiguredContextProvider(const config::Provider *Provider,
                                            Callbacks *Publish) {
if (!Provider)
1
Assuming 'Provider' is non-null→
2
←
Taking false branch→
  return [](llvm::StringRef) { return Context::current().clone(); };

struct Impl {
  const config::Provider *Provider;
  ClangdServer::Callbacks *Publish;
  std::mutex PublishMu;

  Impl(const config::Provider *Provider, ClangdServer::Callbacks *Publish)
      : Provider(Provider), Publish(Publish) {}

  Context operator()(llvm::StringRef File) {
    config::Params Params;
    // Don't reread config files excessively often.
    // FIXME: when we see a config file change event, use the event timestamp?
    Params.FreshTime =
        std::chrono::steady_clock::now() - std::chrono::seconds(5);
    llvm::SmallString<256> PosixPath;
    if (!File.empty()) {
      assert(llvm::sys::path::is_absolute(File))(static_cast <bool> (llvm::sys::path::is_absolute(File)
) ? void (0) : __assert_fail ("llvm::sys::path::is_absolute(File)"
, "clang-tools-extra/clangd/ClangdServer.cpp", 322, __extension__
 __PRETTY_FUNCTION__));
      llvm::sys::path::native(File, PosixPath, llvm::sys::path::Style::posix);
      Params.Path = PosixPath.str();
    }

    llvm::StringMap<std::vector<Diag>> ReportableDiagnostics;
    Config C = Provider->getConfig(Params, [&](const llvm::SMDiagnostic &D) {
      // Create the map entry even for note diagnostics we don't report.
      // This means that when the file is parsed with no warnings, we
      // publish an empty set of diagnostics, clearing any the client has.
      handleDiagnostic(D, !Publish || D.getFilename().empty()
                              ? nullptr
                              : &ReportableDiagnostics[D.getFilename()]);
    });
    // Blindly publish diagnostics for the (unopened) parsed config files.
    // We must avoid reporting diagnostics for *the same file* concurrently.
    // Source diags are published elsewhere, but those are different files.
    if (!ReportableDiagnostics.empty()) {
      std::lock_guard<std::mutex> Lock(PublishMu);
      for (auto &Entry : ReportableDiagnostics)
        Publish->onDiagnosticsReady(Entry.first(), /*Version=*/"",
                                    std::move(Entry.second));
    }
    return Context::current().derive(Config::Key, std::move(C));
  }

  void handleDiagnostic(const llvm::SMDiagnostic &D,
                        std::vector<Diag> *ClientDiagnostics) {
    switch (D.getKind()) {
    case llvm::SourceMgr::DK_Error:
      elog("config error at {0}:{1}:{2}: {3}", D.getFilename(), D.getLineNo(),
           D.getColumnNo(), D.getMessage());
      break;
    case llvm::SourceMgr::DK_Warning:
      log("config warning at {0}:{1}:{2}: {3}", D.getFilename(),
          D.getLineNo(), D.getColumnNo(), D.getMessage());
      break;
    case llvm::SourceMgr::DK_Note:
    case llvm::SourceMgr::DK_Remark:
      vlog("config note at {0}:{1}:{2}: {3}", D.getFilename(), D.getLineNo(),
           D.getColumnNo(), D.getMessage());
      ClientDiagnostics = nullptr; // Don't emit notes as LSP diagnostics.
      break;
    }
    if (ClientDiagnostics)
      ClientDiagnostics->push_back(toDiag(D, Diag::ClangdConfig));
  }
};

// Copyable wrapper.
return [I(std::make_shared<Impl>(Provider, Publish))](llvm::StringRef Path) {
3
←
Calling 'make_shared<Impl, const clang::clangd::config::Provider *&, clang::clangd::ClangdServer::Callbacks *&>'→
21
←
Returned allocated memory→
22
←
Potential leak of memory pointed to by field '_M_pi'
  return (*I)(Path);
};
375}

377void ClangdServer::removeDocument(PathRef File) {
DraftMgr.removeDraft(File);
WorkScheduler->remove(File);
380}

382void ClangdServer::codeComplete(PathRef File, Position Pos,
                              const clangd::CodeCompleteOptions &Opts,
                              Callback<CodeCompleteResult> CB) {
// Copy completion options for passing them to async task handler.
auto CodeCompleteOpts = Opts;
if (!CodeCompleteOpts.Index) // Respect overridden index.
  CodeCompleteOpts.Index = Index;

auto Task = [Pos, CodeCompleteOpts, File = File.str(), CB = std::move(CB),
             this](llvm::Expected<InputsAndPreamble> IP) mutable {
  if (!IP)
    return CB(IP.takeError());
  if (auto Reason = isCancelled())
    return CB(llvm::make_error<CancelledError>(Reason));

  std::optional<SpeculativeFuzzyFind> SpecFuzzyFind;
  if (!IP->Preamble) {
    // No speculation in Fallback mode, as it's supposed to be much faster
    // without compiling.
    vlog("Build for file {0} is not ready. Enter fallback mode.", File);
  } else if (CodeCompleteOpts.Index) {
    SpecFuzzyFind.emplace();
    {
      std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex);
      SpecFuzzyFind->CachedReq = CachedCompletionFuzzyFindRequestByFile[File];
    }
  }
  ParseInputs ParseInput{IP->Command, &getHeaderFS(), IP->Contents.str()};
  // FIXME: Add traling new line if there is none at eof, workaround a crash,
  // see https://github.com/clangd/clangd/issues/332
  if (!IP->Contents.endswith("\n"))
    ParseInput.Contents.append("\n");
  ParseInput.Index = Index;

  CodeCompleteOpts.MainFileSignals = IP->Signals;
  CodeCompleteOpts.AllScopes = Config::current().Completion.AllScopes;
  // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
  // both the old and the new version in case only one of them matches.
  CodeCompleteResult Result = clangd::codeComplete(
      File, Pos, IP->Preamble, ParseInput, CodeCompleteOpts,
      SpecFuzzyFind ? &*SpecFuzzyFind : nullptr);
  {
    clang::clangd::trace::Span Tracer("Completion results callback");
    CB(std::move(Result));
  }
  if (SpecFuzzyFind && SpecFuzzyFind->NewReq) {
    std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex);
    CachedCompletionFuzzyFindRequestByFile[File] = *SpecFuzzyFind->NewReq;
  }
  // SpecFuzzyFind is only destroyed after speculative fuzzy find finishes.
  // We don't want `codeComplete` to wait for the async call if it doesn't use
  // the result (e.g. non-index completion, speculation fails), so that `CB`
  // is called as soon as results are available.
};

// We use a potentially-stale preamble because latency is critical here.
WorkScheduler->runWithPreamble(
    "CodeComplete", File,
    (Opts.RunParser == CodeCompleteOptions::AlwaysParse)
        ? TUScheduler::Stale
        : TUScheduler::StaleOrAbsent,
    std::move(Task));
444}

446void ClangdServer::signatureHelp(PathRef File, Position Pos,
                               MarkupKind DocumentationFormat,
                               Callback<SignatureHelp> CB) {

auto Action = [Pos, File = File.str(), CB = std::move(CB),
               DocumentationFormat,
               this](llvm::Expected<InputsAndPreamble> IP) mutable {
  if (!IP)
    return CB(IP.takeError());

  const auto *PreambleData = IP->Preamble;
  if (!PreambleData)
    return CB(error("Failed to parse includes"));

  ParseInputs ParseInput{IP->Command, &getHeaderFS(), IP->Contents.str()};
  // FIXME: Add traling new line if there is none at eof, workaround a crash,
  // see https://github.com/clangd/clangd/issues/332
  if (!IP->Contents.endswith("\n"))
    ParseInput.Contents.append("\n");
  ParseInput.Index = Index;
  CB(clangd::signatureHelp(File, Pos, *PreambleData, ParseInput,
                           DocumentationFormat));
};

// Unlike code completion, we wait for a preamble here.
WorkScheduler->runWithPreamble("SignatureHelp", File, TUScheduler::Stale,
                               std::move(Action));
473}

475void ClangdServer::formatFile(PathRef File, std::optional<Range> Rng,
                            Callback<tooling::Replacements> CB) {
auto Code = getDraft(File);
if (!Code)
  return CB(llvm::make_error<LSPError>("trying to format non-added document",
                                       ErrorCode::InvalidParams));
tooling::Range RequestedRange;
if (Rng) {
  llvm::Expected<size_t> Begin = positionToOffset(*Code, Rng->start);
  if (!Begin)
    return CB(Begin.takeError());
  llvm::Expected<size_t> End = positionToOffset(*Code, Rng->end);
  if (!End)
    return CB(End.takeError());
  RequestedRange = tooling::Range(*Begin, *End - *Begin);
} else {
  RequestedRange = tooling::Range(0, Code->size());
}

// Call clang-format.
auto Action = [File = File.str(), Code = std::move(*Code),
               Ranges = std::vector<tooling::Range>{RequestedRange},
               CB = std::move(CB), this]() mutable {
  format::FormatStyle Style = getFormatStyleForFile(File, Code, TFS);
  tooling::Replacements IncludeReplaces =
      format::sortIncludes(Style, Code, Ranges, File);
  auto Changed = tooling::applyAllReplacements(Code, IncludeReplaces);
  if (!Changed)
    return CB(Changed.takeError());

  CB(IncludeReplaces.merge(format::reformat(
      Style, *Changed,
      tooling::calculateRangesAfterReplacements(IncludeReplaces, Ranges),
      File)));
};
WorkScheduler->runQuick("Format", File, std::move(Action));
511}

513void ClangdServer::formatOnType(PathRef File, Position Pos,
                              StringRef TriggerText,
                              Callback<std::vector<TextEdit>> CB) {
auto Code = getDraft(File);
if (!Code)
  return CB(llvm::make_error<LSPError>("trying to format non-added document",
                                       ErrorCode::InvalidParams));
llvm::Expected<size_t> CursorPos = positionToOffset(*Code, Pos);
if (!CursorPos)
  return CB(CursorPos.takeError());
auto Action = [File = File.str(), Code = std::move(*Code),
               TriggerText = TriggerText.str(), CursorPos = *CursorPos,
               CB = std::move(CB), this]() mutable {
  auto Style = format::getStyle(format::DefaultFormatStyle, File,
                                format::DefaultFallbackStyle, Code,
                                TFS.view(/*CWD=*/std::nullopt).get());
  if (!Style)
    return CB(Style.takeError());

  std::vector<TextEdit> Result;
  for (const tooling::Replacement &R :
       formatIncremental(Code, CursorPos, TriggerText, *Style))
    Result.push_back(replacementToEdit(Code, R));
  return CB(Result);
};
WorkScheduler->runQuick("FormatOnType", File, std::move(Action));
539}

541void ClangdServer::prepareRename(PathRef File, Position Pos,
                               std::optional<std::string> NewName,
                               const RenameOptions &RenameOpts,
                               Callback<RenameResult> CB) {
auto Action = [Pos, File = File.str(), CB = std::move(CB),
               NewName = std::move(NewName),
               RenameOpts](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  // prepareRename is latency-sensitive: we don't query the index, as we
  // only need main-file references
  auto Results =
      clangd::rename({Pos, NewName.value_or("__clangd_rename_placeholder"),
                      InpAST->AST, File, /*FS=*/nullptr,
                      /*Index=*/nullptr, RenameOpts});
  if (!Results) {
    // LSP says to return null on failure, but that will result in a generic
    // failure message. If we send an LSP error response, clients can surface
    // the message to users (VSCode does).
    return CB(Results.takeError());
  }
  return CB(*Results);
};
WorkScheduler->runWithAST("PrepareRename", File, std::move(Action));
565}

567void ClangdServer::rename(PathRef File, Position Pos, llvm::StringRef NewName,
                        const RenameOptions &Opts,
                        Callback<RenameResult> CB) {
auto Action = [File = File.str(), NewName = NewName.str(), Pos, Opts,
               CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  // Tracks number of files edited per invocation.
  static constexpr trace::Metric RenameFiles("rename_files",
                                             trace::Metric::Distribution);
  if (!InpAST)
    return CB(InpAST.takeError());
  auto R = clangd::rename({Pos, NewName, InpAST->AST, File,
                           DirtyFS->view(std::nullopt), Index, Opts});
  if (!R)
    return CB(R.takeError());

  if (Opts.WantFormat) {
    auto Style = getFormatStyleForFile(File, InpAST->Inputs.Contents,
                                       *InpAST->Inputs.TFS);
    llvm::Error Err = llvm::Error::success();
    for (auto &E : R->GlobalChanges)
      Err =
          llvm::joinErrors(reformatEdit(E.getValue(), Style), std::move(Err));

    if (Err)
      return CB(std::move(Err));
  }
  RenameFiles.record(R->GlobalChanges.size());
  return CB(*R);
};
WorkScheduler->runWithAST("Rename", File, std::move(Action));
598}

600// May generate several candidate selections, due to SelectionTree ambiguity.
601// vector of pointers because GCC doesn't like non-copyable Selection.
602static llvm::Expected<std::vector<std::unique_ptr<Tweak::Selection>>>
603tweakSelection(const Range &Sel, const InputsAndAST &AST,
             llvm::vfs::FileSystem *FS) {
auto Begin = positionToOffset(AST.Inputs.Contents, Sel.start);
if (!Begin)
  return Begin.takeError();
auto End = positionToOffset(AST.Inputs.Contents, Sel.end);
if (!End)
  return End.takeError();
std::vector<std::unique_ptr<Tweak::Selection>> Result;
SelectionTree::createEach(
    AST.AST.getASTContext(), AST.AST.getTokens(), *Begin, *End,
    [&](SelectionTree T) {
      Result.push_back(std::make_unique<Tweak::Selection>(
          AST.Inputs.Index, AST.AST, *Begin, *End, std::move(T), FS));
      return false;
    });
assert(!Result.empty() && "Expected at least one SelectionTree")(static_cast <bool> (!Result.empty() && "Expected at least one SelectionTree"
) ? void (0) : __assert_fail ("!Result.empty() && \"Expected at least one SelectionTree\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 619, __extension__
 __PRETTY_FUNCTION__));
return std::move(Result);
621}

623void ClangdServer::enumerateTweaks(
  PathRef File, Range Sel, llvm::unique_function<bool(const Tweak &)> Filter,
  Callback<std::vector<TweakRef>> CB) {
// Tracks number of times a tweak has been offered.
static constexpr trace::Metric TweakAvailable(
    "tweak_available", trace::Metric::Counter, "tweak_id");
auto Action = [Sel, CB = std::move(CB), Filter = std::move(Filter),
               FeatureModules(this->FeatureModules)](
                  Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  auto Selections = tweakSelection(Sel, *InpAST, /*FS=*/nullptr);
  if (!Selections)
    return CB(Selections.takeError());
  std::vector<TweakRef> Res;
  // Don't allow a tweak to fire more than once across ambiguous selections.
  llvm::DenseSet<llvm::StringRef> PreparedTweaks;
  auto DeduplicatingFilter = [&](const Tweak &T) {
    return Filter(T) && !PreparedTweaks.count(T.id());
  };
  for (const auto &Sel : *Selections) {
    for (auto &T : prepareTweaks(*Sel, DeduplicatingFilter, FeatureModules)) {
      Res.push_back({T->id(), T->title(), T->kind()});
      PreparedTweaks.insert(T->id());
      TweakAvailable.record(1, T->id());
    }
  }

  CB(std::move(Res));
};

WorkScheduler->runWithAST("EnumerateTweaks", File, std::move(Action),
                          Transient);
656}

658void ClangdServer::applyTweak(PathRef File, Range Sel, StringRef TweakID,
                            Callback<Tweak::Effect> CB) {
// Tracks number of times a tweak has been attempted.
static constexpr trace::Metric TweakAttempt(
    "tweak_attempt", trace::Metric::Counter, "tweak_id");
// Tracks number of times a tweak has failed to produce edits.
static constexpr trace::Metric TweakFailed(
    "tweak_failed", trace::Metric::Counter, "tweak_id");
TweakAttempt.record(1, TweakID);
auto Action = [File = File.str(), Sel, TweakID = TweakID.str(),
               CB = std::move(CB),
               this](Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  auto FS = DirtyFS->view(std::nullopt);
  auto Selections = tweakSelection(Sel, *InpAST, FS.get());
  if (!Selections)
    return CB(Selections.takeError());
  std::optional<llvm::Expected<Tweak::Effect>> Effect;
  // Try each selection, take the first one that prepare()s.
  // If they all fail, Effect will hold get the last error.
  for (const auto &Selection : *Selections) {
    auto T = prepareTweak(TweakID, *Selection, FeatureModules);
    if (T) {
      Effect = (*T)->apply(*Selection);
      break;
    }
    Effect = T.takeError();
  }
  assert(Effect && "Expected at least one selection")(static_cast <bool> (Effect && "Expected at least one selection"
) ? void (0) : __assert_fail ("Effect && \"Expected at least one selection\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 687, __extension__
 __PRETTY_FUNCTION__));
  if (*Effect && (*Effect)->FormatEdits) {
    // Format tweaks that require it centrally here.
    for (auto &It : (*Effect)->ApplyEdits) {
      Edit &E = It.second;
      format::FormatStyle Style =
          getFormatStyleForFile(File, E.InitialCode, TFS);
      if (llvm::Error Err = reformatEdit(E, Style))
        elog("Failed to format {0}: {1}", It.first(), std::move(Err));
    }
  } else {
    TweakFailed.record(1, TweakID);
  }
  return CB(std::move(*Effect));
};
WorkScheduler->runWithAST("ApplyTweak", File, std::move(Action));
703}

705void ClangdServer::locateSymbolAt(PathRef File, Position Pos,
                                Callback<std::vector<LocatedSymbol>> CB) {
auto Action = [Pos, CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::locateSymbolAt(InpAST->AST, Pos, Index));
};

WorkScheduler->runWithAST("Definitions", File, std::move(Action));
715}

717void ClangdServer::switchSourceHeader(
  PathRef Path, Callback<std::optional<clangd::Path>> CB) {
// We want to return the result as fast as possible, strategy is:
//  1) use the file-only heuristic, it requires some IO but it is much
//     faster than building AST, but it only works when .h/.cc files are in
//     the same directory.
//  2) if 1) fails, we use the AST&Index approach, it is slower but supports
//     different code layout.
if (auto CorrespondingFile =
        getCorrespondingHeaderOrSource(Path, TFS.view(std::nullopt)))
  return CB(std::move(CorrespondingFile));
auto Action = [Path = Path.str(), CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(getCorrespondingHeaderOrSource(Path, InpAST->AST, Index));
};
WorkScheduler->runWithAST("SwitchHeaderSource", Path, std::move(Action));
735}

737void ClangdServer::findDocumentHighlights(
  PathRef File, Position Pos, Callback<std::vector<DocumentHighlight>> CB) {
auto Action =
    [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::findDocumentHighlights(InpAST->AST, Pos));
    };

WorkScheduler->runWithAST("Highlights", File, std::move(Action), Transient);
747}

749void ClangdServer::findHover(PathRef File, Position Pos,
                           Callback<std::optional<HoverInfo>> CB) {
auto Action = [File = File.str(), Pos, CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  format::FormatStyle Style = getFormatStyleForFile(
      File, InpAST->Inputs.Contents, *InpAST->Inputs.TFS);
  CB(clangd::getHover(InpAST->AST, Pos, std::move(Style), Index));
};

WorkScheduler->runWithAST("Hover", File, std::move(Action), Transient);
761}

763void ClangdServer::typeHierarchy(PathRef File, Position Pos, int Resolve,
                               TypeHierarchyDirection Direction,
                               Callback<std::vector<TypeHierarchyItem>> CB) {
auto Action = [File = File.str(), Pos, Resolve, Direction, CB = std::move(CB),
               this](Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::getTypeHierarchy(InpAST->AST, Pos, Resolve, Direction, Index,
                              File));
};

WorkScheduler->runWithAST("TypeHierarchy", File, std::move(Action));
775}

777void ClangdServer::superTypes(
  const TypeHierarchyItem &Item,
  Callback<std::optional<std::vector<TypeHierarchyItem>>> CB) {
WorkScheduler->run("typeHierarchy/superTypes", /*Path=*/"",
                   [=, CB = std::move(CB)]() mutable {
                     CB(clangd::superTypes(Item, Index));
                   });
784}

786void ClangdServer::subTypes(const TypeHierarchyItem &Item,
                          Callback<std::vector<TypeHierarchyItem>> CB) {
WorkScheduler->run(
    "typeHierarchy/subTypes", /*Path=*/"",
    [=, CB = std::move(CB)]() mutable { CB(clangd::subTypes(Item, Index)); });
791}

793void ClangdServer::resolveTypeHierarchy(
  TypeHierarchyItem Item, int Resolve, TypeHierarchyDirection Direction,
  Callback<std::optional<TypeHierarchyItem>> CB) {
WorkScheduler->run(
    "Resolve Type Hierarchy", "", [=, CB = std::move(CB)]() mutable {
      clangd::resolveTypeHierarchy(Item, Resolve, Direction, Index);
      CB(Item);
    });
801}

803void ClangdServer::prepareCallHierarchy(
  PathRef File, Position Pos, Callback<std::vector<CallHierarchyItem>> CB) {
auto Action = [File = File.str(), Pos,
               CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::prepareCallHierarchy(InpAST->AST, Pos, File));
};
WorkScheduler->runWithAST("CallHierarchy", File, std::move(Action));
812}

814void ClangdServer::incomingCalls(
  const CallHierarchyItem &Item,
  Callback<std::vector<CallHierarchyIncomingCall>> CB) {
WorkScheduler->run("Incoming Calls", "",
                   [CB = std::move(CB), Item, this]() mutable {
                     CB(clangd::incomingCalls(Item, Index));
                   });
821}

823void ClangdServer::inlayHints(PathRef File, std::optional<Range> RestrictRange,
                            Callback<std::vector<InlayHint>> CB) {
auto Action = [RestrictRange(std::move(RestrictRange)),
               CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::inlayHints(InpAST->AST, std::move(RestrictRange)));
};
WorkScheduler->runWithAST("InlayHints", File, std::move(Action), Transient);
832}

834void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
// FIXME: Do nothing for now. This will be used for indexing and potentially
// invalidating other caches.
837}

839void ClangdServer::workspaceSymbols(
  llvm::StringRef Query, int Limit,
  Callback<std::vector<SymbolInformation>> CB) {
WorkScheduler->run(
    "getWorkspaceSymbols", /*Path=*/"",
    [Query = Query.str(), Limit, CB = std::move(CB), this]() mutable {
      CB(clangd::getWorkspaceSymbols(Query, Limit, Index,
                                     WorkspaceRoot.value_or("")));
    });
848}

850void ClangdServer::documentSymbols(llvm::StringRef File,
                                 Callback<std::vector<DocumentSymbol>> CB) {
auto Action =
    [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::getDocumentSymbols(InpAST->AST));
    };
WorkScheduler->runWithAST("DocumentSymbols", File, std::move(Action),
                          Transient);
860}

862void ClangdServer::foldingRanges(llvm::StringRef File,
                               Callback<std::vector<FoldingRange>> CB) {
auto Code = getDraft(File);
if (!Code)
  return CB(llvm::make_error<LSPError>(
      "trying to compute folding ranges for non-added document",
      ErrorCode::InvalidParams));
auto Action = [LineFoldingOnly = LineFoldingOnly, CB = std::move(CB),
               Code = std::move(*Code)]() mutable {
  CB(clangd::getFoldingRanges(Code, LineFoldingOnly));
};
// We want to make sure folding ranges are always available for all the open
// files, hence prefer runQuick to not wait for operations on other files.
WorkScheduler->runQuick("FoldingRanges", File, std::move(Action));
876}

878void ClangdServer::findType(llvm::StringRef File, Position Pos,
                          Callback<std::vector<LocatedSymbol>> CB) {
auto Action =
    [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::findType(InpAST->AST, Pos));
    };
WorkScheduler->runWithAST("FindType", File, std::move(Action));
887}

889void ClangdServer::findImplementations(
  PathRef File, Position Pos, Callback<std::vector<LocatedSymbol>> CB) {
auto Action = [Pos, CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::findImplementations(InpAST->AST, Pos, Index));
};

WorkScheduler->runWithAST("Implementations", File, std::move(Action));
899}

901void ClangdServer::findReferences(PathRef File, Position Pos, uint32_t Limit,
                                bool AddContainer,
                                Callback<ReferencesResult> CB) {
auto Action = [Pos, Limit, AddContainer, CB = std::move(CB),
               this](llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  CB(clangd::findReferences(InpAST->AST, Pos, Limit, Index, AddContainer));
};

WorkScheduler->runWithAST("References", File, std::move(Action));
912}

914void ClangdServer::symbolInfo(PathRef File, Position Pos,
                            Callback<std::vector<SymbolDetails>> CB) {
auto Action =
    [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::getSymbolInfo(InpAST->AST, Pos));
    };

WorkScheduler->runWithAST("SymbolInfo", File, std::move(Action));
924}

926void ClangdServer::semanticRanges(PathRef File,
                                const std::vector<Position> &Positions,
                                Callback<std::vector<SelectionRange>> CB) {
auto Action = [Positions, CB = std::move(CB)](
                  llvm::Expected<InputsAndAST> InpAST) mutable {
  if (!InpAST)
    return CB(InpAST.takeError());
  std::vector<SelectionRange> Result;
  for (const auto &Pos : Positions) {
    if (auto Range = clangd::getSemanticRanges(InpAST->AST, Pos))
      Result.push_back(std::move(*Range));
    else
      return CB(Range.takeError());
  }
  CB(std::move(Result));
};
WorkScheduler->runWithAST("SemanticRanges", File, std::move(Action));
943}

945void ClangdServer::documentLinks(PathRef File,
                               Callback<std::vector<DocumentLink>> CB) {
auto Action =
    [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::getDocumentLinks(InpAST->AST));
    };
WorkScheduler->runWithAST("DocumentLinks", File, std::move(Action),
                          Transient);
955}

957void ClangdServer::semanticHighlights(
  PathRef File, Callback<std::vector<HighlightingToken>> CB) {
auto Action =
    [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      CB(clangd::getSemanticHighlightings(InpAST->AST));
    };
WorkScheduler->runWithAST("SemanticHighlights", File, std::move(Action),
                          Transient);
967}

969void ClangdServer::getAST(PathRef File, std::optional<Range> R,
                        Callback<std::optional<ASTNode>> CB) {
auto Action =
    [R, CB(std::move(CB))](llvm::Expected<InputsAndAST> Inputs) mutable {
      if (!Inputs)
        return CB(Inputs.takeError());
      if (!R) {
        // It's safe to pass in the TU, as dumpAST() does not
        // deserialize the preamble.
        auto Node = DynTypedNode::create(
            *Inputs->AST.getASTContext().getTranslationUnitDecl());
        return CB(dumpAST(Node, Inputs->AST.getTokens(),
                          Inputs->AST.getASTContext()));
      }
      unsigned Start, End;
      if (auto Offset = positionToOffset(Inputs->Inputs.Contents, R->start))
        Start = *Offset;
      else
        return CB(Offset.takeError());
      if (auto Offset = positionToOffset(Inputs->Inputs.Contents, R->end))
        End = *Offset;
      else
        return CB(Offset.takeError());
      bool Success = SelectionTree::createEach(
          Inputs->AST.getASTContext(), Inputs->AST.getTokens(), Start, End,
          [&](SelectionTree T) {
            if (const SelectionTree::Node *N = T.commonAncestor()) {
              CB(dumpAST(N->ASTNode, Inputs->AST.getTokens(),
                         Inputs->AST.getASTContext()));
              return true;
            }
            return false;
          });
      if (!Success)
        CB(std::nullopt);
    };
WorkScheduler->runWithAST("GetAST", File, std::move(Action));
1006}

1008void ClangdServer::customAction(PathRef File, llvm::StringRef Name,
                              Callback<InputsAndAST> Action) {
WorkScheduler->runWithAST(Name, File, std::move(Action));
1011}

1013void ClangdServer::diagnostics(PathRef File, Callback<std::vector<Diag>> CB) {
auto Action =
    [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
      if (!InpAST)
        return CB(InpAST.takeError());
      if (auto Diags = InpAST->AST.getDiagnostics())
        return CB(*Diags);
      // FIXME: Use ServerCancelled error once it is settled in LSP-3.17.
      return CB(llvm::make_error<LSPError>("server is busy parsing includes",
                                           ErrorCode::InternalError));
    };

WorkScheduler->runWithAST("Diagnostics", File, std::move(Action));
1026}

1028llvm::StringMap<TUScheduler::FileStats> ClangdServer::fileStats() const {
return WorkScheduler->fileStats();
1030}

1032[[nodiscard]] bool
1033ClangdServer::blockUntilIdleForTest(std::optional<double> TimeoutSeconds) {
// Order is important here: we don't want to block on A and then B,
// if B might schedule work on A.

1037#if defined(__has_feature)0 &&                                                  \
  (__has_feature(address_sanitizer)0 || __has_feature(hwaddress_sanitizer)0 || \
   __has_feature(memory_sanitizer)0 || __has_feature(thread_sanitizer)0)
(*TimeoutSeconds) *= 10;
1041#endif

// Nothing else can schedule work on TUScheduler, because it's not threadsafe
// and we're blocking the main thread.
if (!WorkScheduler->blockUntilIdle(timeoutSeconds(TimeoutSeconds)))
  return false;
// TUScheduler is the only thing that starts background indexing work.
if (IndexTasks && !IndexTasks->wait(timeoutSeconds(TimeoutSeconds)))
  return false;

// Unfortunately we don't have strict topological order between the rest of
// the components. E.g. CDB broadcast triggers backrgound indexing.
// This queries the CDB which may discover new work if disk has changed.
//
// So try each one a few times in a loop.
// If there are no tricky interactions then all after the first are no-ops.
// Then on the last iteration, verify they're idle without waiting.
//
// There's a small chance they're juggling work and we didn't catch them :-(
for (std::optional<double> Timeout :
     {TimeoutSeconds, TimeoutSeconds, std::optional<double>(0)}) {
  if (!CDB.blockUntilIdle(timeoutSeconds(Timeout)))
    return false;
  if (BackgroundIdx && !BackgroundIdx->blockUntilIdleForTest(Timeout))
    return false;
  if (FeatureModules && llvm::any_of(*FeatureModules, [&](FeatureModule &M) {
        return !M.blockUntilIdle(timeoutSeconds(Timeout));
      }))
    return false;
}

assert(WorkScheduler->blockUntilIdle(Deadline::zero()) &&(static_cast <bool> (WorkScheduler->blockUntilIdle(Deadline
::zero()) && "Something scheduled work while we're blocking the main thread!"
) ? void (0) : __assert_fail ("WorkScheduler->blockUntilIdle(Deadline::zero()) && \"Something scheduled work while we're blocking the main thread!\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 1073, __extension__
 __PRETTY_FUNCTION__))
       "Something scheduled work while we're blocking the main thread!")(static_cast <bool> (WorkScheduler->blockUntilIdle(Deadline
::zero()) && "Something scheduled work while we're blocking the main thread!"
) ? void (0) : __assert_fail ("WorkScheduler->blockUntilIdle(Deadline::zero()) && \"Something scheduled work while we're blocking the main thread!\""
, "clang-tools-extra/clangd/ClangdServer.cpp", 1073, __extension__
 __PRETTY_FUNCTION__));
return true;
1075}

1077void ClangdServer::profile(MemoryTree &MT) const {
if (DynamicIdx)
  DynamicIdx->profile(MT.child("dynamic_index"));
if (BackgroundIdx)
  BackgroundIdx->profile(MT.child("background_index"));
WorkScheduler->profile(MT.child("tuscheduler"));
1083}
1084} // namespace clangd
1085} // namespace clang

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/shared_ptr.h

→

1// shared_ptr and weak_ptr implementation -*- C++ -*-

3// Copyright (C) 2007-2020 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// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

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

49#ifndef _SHARED_PTR_H1
50#define _SHARED_PTR_H1 1

52#include <bits/shared_ptr_base.h>

54namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
55{
56_GLIBCXX_BEGIN_NAMESPACE_VERSION

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

// 20.7.2.2.11 shared_ptr I/O

/// Write the stored pointer to an ostream.
/// @relates shared_ptr
template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
  inline std::basic_ostream<_Ch, _Tr>&
  operator<<(std::basic_ostream<_Ch, _Tr>& __os,
      const __shared_ptr<_Tp, _Lp>& __p)
  {
    __os << __p.get();
    return __os;
  }

template<typename _Del, typename _Tp, _Lock_policy _Lp>
  inline _Del*
  get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
  {
80#if __cpp_rtti199711L
    return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
82#else
    return 0;
84#endif
  }

/// 20.7.2.2.10 shared_ptr get_deleter

/// If `__p` has a deleter of type `_Del`, return a pointer to it.
/// @relates shared_ptr
template<typename _Del, typename _Tp>
  inline _Del*
  get_deleter(const shared_ptr<_Tp>& __p) noexcept
  {
95#if __cpp_rtti199711L
    return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
97#else
    return 0;
99#endif
  }

/**
 *  @brief  A smart pointer with reference-counted copy semantics.
 *
 * A `shared_ptr` object is either empty or _owns_ a pointer passed
 * to the constructor. Copies of a `shared_ptr` share ownership of
 * the same pointer. When the last `shared_ptr` that owns the pointer
 * is destroyed or reset, the owned pointer is freed (either by `delete`
 * or by invoking a custom deleter that was passed to the constructor).
 *
 * A `shared_ptr` also stores another pointer, which is usually
 * (but not always) the same pointer as it owns. The stored pointer
 * can be retrieved by calling the `get()` member function.
 *
 * The equality and relational operators for `shared_ptr` only compare
 * the stored pointer returned by `get()`, not the owned pointer.
 * To test whether two `shared_ptr` objects share ownership of the same
 * pointer see `std::shared_ptr::owner_before` and `std::owner_less`.
*/
template<typename _Tp>
  class shared_ptr : public __shared_ptr<_Tp>
  {
    template<typename... _Args>
using _Constructible = typename enable_if<
 is_constructible<__shared_ptr<_Tp>, _Args...>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
>::type;

  public:

    /// The type pointed to by the stored pointer, remove_extent_t<_Tp>
    using element_type = typename __shared_ptr<_Tp>::element_type;

138#if __cplusplus201703L >= 201703L
139# define __cpp_lib_shared_ptr_weak_type201606 201606
    /// The corresponding weak_ptr type for this shared_ptr
    using weak_type = weak_ptr<_Tp>;
142#endif
    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count()==0 && get()==0
     */
    constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }

    shared_ptr(const shared_ptr&) noexcept = default; ///< Copy constructor

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
     *  @param  __p  A pointer that is convertible to element_type*.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
     */
    template<typename _Yp, typename = _Constructible<_Yp*>>
explicit
shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter,
      typename = _Constructible<_Yp*, _Deleter>>
shared_ptr(_Yp* __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter>
shared_ptr(nullptr_t __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _Constructible<_Yp*, _Deleter, _Alloc>>
shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter, typename _Alloc>
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    // Aliasing constructor

    /**
     *  @brief  Constructs a `shared_ptr` instance that stores `__p`
     *          and shares ownership with `__r`.
     *  @param  __r  A `shared_ptr`.
     *  @param  __p  A pointer that will remain valid while `*__r` is valid.
     *  @post   `get() == __p && use_count() == __r.use_count()`
     *
     *  This can be used to construct a `shared_ptr` to a sub-object
     *  of an object managed by an existing `shared_ptr`. The complete
     *  object will remain valid while any `shared_ptr` owns it, even
     *  if they don't store a pointer to the complete object.
     *
     * @code
     * shared_ptr<pair<int,int>> pii(new pair<int,int>());
     * shared_ptr<int> pi(pii, &pii->first);
     * assert(pii.use_count() == 2);
     * @endcode
     */
    template<typename _Yp>
shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
: __shared_ptr<_Tp>(__r, __p) { }

259#if __cplusplus201703L > 201703L
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2996. Missing rvalue overloads for shared_ptr operations
    /**
     *  @brief  Constructs a `shared_ptr` instance that stores `__p`
     *          and shares ownership with `__r`.
     *  @param  __r  A `shared_ptr`.
     *  @param  __p  A pointer that will remain valid while `*__r` is valid.
     *  @post   `get() == __p && !__r.use_count() && !__r.get()`
     *
     *  This can be used to construct a `shared_ptr` to a sub-object
     *  of an object managed by an existing `shared_ptr`. The complete
     *  object will remain valid while any `shared_ptr` owns it, even
     *  if they don't store a pointer to the complete object.
     *
     * @code
     * shared_ptr<pair<int,int>> pii(new pair<int,int>());
     * shared_ptr<int> pi1(pii, &pii->first);
     * assert(pii.use_count() == 2);
     * shared_ptr<int> pi2(std::move(pii), &pii->second);
     * assert(pii.use_count() == 0);
     * @endcode
     */
    template<typename _Yp>
shared_ptr(shared_ptr<_Yp>&& __r, element_type* __p) noexcept
: __shared_ptr<_Tp>(std::move(__r), __p) { }
285#endif
    /**
     *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
     *          otherwise construct a %shared_ptr that shares ownership
     *          with @a __r.
     *  @param  __r  A %shared_ptr.
     *  @post   get() == __r.get() && use_count() == __r.use_count()
     */
    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
shared_ptr(const shared_ptr<_Yp>& __r) noexcept
      : __shared_ptr<_Tp>(__r) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    shared_ptr(shared_ptr&& __r) noexcept
    : __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
shared_ptr(shared_ptr<_Yp>&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
     *          and stores a copy of the pointer stored in @a __r.
     *  @param  __r  A weak_ptr.
     *  @post   use_count() == __r.use_count()
     *  @throw  bad_weak_ptr when __r.expired(),
     *          in which case the constructor has no effect.
     */
    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
explicit shared_ptr(const weak_ptr<_Yp>& __r)
: __shared_ptr<_Tp>(__r) { }

327#if _GLIBCXX_USE_DEPRECATED1
328#pragma GCC diagnostic push
329#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
shared_ptr(auto_ptr<_Yp>&& __r);
332#pragma GCC diagnostic pop
333#endif

    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2399. shared_ptr's constructor from unique_ptr should be constrained
    template<typename _Yp, typename _Del,
      typename = _Constructible<unique_ptr<_Yp, _Del>>>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }

342#if __cplusplus201703L <= 201402L && _GLIBCXX_USE_DEPRECATED1
    // This non-standard constructor exists to support conversions that
    // were possible in C++11 and C++14 but are ill-formed in C++17.
    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
_Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { }
350#endif

    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count() == 0 && get() == nullptr
     */
    constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }

    shared_ptr& operator=(const shared_ptr&) noexcept = default;

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(__r);
 return *this;
}

368#if _GLIBCXX_USE_DEPRECATED1
369#pragma GCC diagnostic push
370#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    template<typename _Yp>
_Assignable<auto_ptr<_Yp>>
operator=(auto_ptr<_Yp>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}
378#pragma GCC diagnostic pop
379#endif

    shared_ptr&
    operator=(shared_ptr&& __r) noexcept
    {
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
    }

    template<class _Yp>
_Assignable<shared_ptr<_Yp>>
operator=(shared_ptr<_Yp>&& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    template<typename _Yp, typename _Del>
_Assignable<unique_ptr<_Yp, _Del>>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

  private:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
: __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
6
←
Calling constructor for '__shared_ptr<Impl, __gnu_cxx::_S_atomic>'→
18
←
Returning from constructor for '__shared_ptr<Impl, __gnu_cxx::_S_atomic>'→
{ }

    template<typename _Yp, typename _Alloc, typename... _Args>
friend shared_ptr<_Yp>
allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is non-standard, it is used by weak_ptr::lock().
    shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
    : __shared_ptr<_Tp>(__r, std::nothrow) { }

    friend class weak_ptr<_Tp>;
  };

422#if __cpp_deduction_guides201703L >= 201606
template<typename _Tp>
  shared_ptr(weak_ptr<_Tp>) ->  shared_ptr<_Tp>;
template<typename _Tp, typename _Del>
  shared_ptr(unique_ptr<_Tp, _Del>) ->  shared_ptr<_Tp>;
427#endif

// 20.7.2.2.7 shared_ptr comparisons

/// @relates shared_ptr @{

/// Equality operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() == __b.get(); }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !__a; }

445#ifdef __cpp_lib_three_way_comparison
template<typename _Tp, typename _Up>
  inline strong_ordering
  operator<=>(const shared_ptr<_Tp>& __a,
const shared_ptr<_Up>& __b) noexcept
  { return compare_three_way()(__a.get(), __b.get()); }

template<typename _Tp>
  inline strong_ordering
  operator<=>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  {
    using pointer = typename shared_ptr<_Tp>::element_type*;
    return compare_three_way()(__a.get(), static_cast<pointer>(nullptr));
  }
459#else
/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !__a; }

/// Inequality operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() != __b.get(); }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return (bool)__a; }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return (bool)__a; }

/// Relational operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    using _Up_elt = typename shared_ptr<_Up>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

/// Relational operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__b < __a); }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !(nullptr < __a); }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !(__a < nullptr); }

/// Relational operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return (__b < __a); }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return __a < nullptr; }

/// Relational operator for shared_ptr objects, compares the stored pointers
template<typename _Tp, typename _Up>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__a < __b); }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !(__a < nullptr); }

/// shared_ptr comparison with nullptr
template<typename _Tp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !(nullptr < __a); }
566#endif

// 20.7.2.2.8 shared_ptr specialized algorithms.

/// Swap overload for shared_ptr
template<typename _Tp>
  inline void
  swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts.

/// Convert type of `shared_ptr`, via `static_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

/// Convert type of `shared_ptr`, via `const_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

/// Convert type of `shared_ptr`, via `dynamic_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

607#if __cplusplus201703L >= 201703L
/// Convert type of `shared_ptr`, via `reinterpret_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }

617#if __cplusplus201703L > 201703L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2996. Missing rvalue overloads for shared_ptr operations

/// Convert type of `shared_ptr` rvalue, via `static_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  static_pointer_cast(shared_ptr<_Up>&& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(std::move(__r),
 static_cast<typename _Sp::element_type*>(__r.get()));
  }

/// Convert type of `shared_ptr` rvalue, via `const_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  const_pointer_cast(shared_ptr<_Up>&& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(std::move(__r),
 const_cast<typename _Sp::element_type*>(__r.get()));
  }

/// Convert type of `shared_ptr` rvalue, via `dynamic_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(std::move(__r), __p);
    return _Sp();
  }

/// Convert type of `shared_ptr` rvalue, via `reinterpret_cast`
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(std::move(__r),
 reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
661#endif // C++20
662#endif // C++17

// @}

/**
 * @brief  A non-owning observer for a pointer owned by a shared_ptr
 *
 * A weak_ptr provides a safe alternative to a raw pointer when you want
 * a non-owning reference to an object that is managed by a shared_ptr.
 *
 * Unlike a raw pointer, a weak_ptr can be converted to a new shared_ptr
 * that shares ownership with every other shared_ptr that already owns
 * the pointer. In other words you can upgrade from a non-owning "weak"
 * reference to an owning shared_ptr, without having access to any of
 * the existing shared_ptr objects.
 *
 * Also unlike a raw pointer, a weak_ptr does not become "dangling" after
 * the object it points to has been destroyed. Instead, a weak_ptr
 * becomes _expired_ and can no longer be converted to a shared_ptr that
 * owns the freed pointer, so you cannot accidentally access the pointed-to
 * object after it has been destroyed.
 */
template<typename _Tp>
  class weak_ptr : public __weak_ptr<_Tp>
  {
    template<typename _Arg>
using _Constructible = typename enable_if<
 is_constructible<__weak_ptr<_Tp>, _Arg>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
>::type;

  public:
    constexpr weak_ptr() noexcept = default;

    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
weak_ptr(const shared_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(const weak_ptr&) noexcept = default;

    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
weak_ptr(const weak_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(weak_ptr&&) noexcept = default;

    template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
weak_ptr(weak_ptr<_Yp>&& __r) noexcept
: __weak_ptr<_Tp>(std::move(__r)) { }

    weak_ptr&
    operator=(const weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<const weak_ptr<_Yp>&>
operator=(const weak_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    weak_ptr&
    operator=(weak_ptr&& __r) noexcept = default;

    template<typename _Yp>
_Assignable<weak_ptr<_Yp>>
operator=(weak_ptr<_Yp>&& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    shared_ptr<_Tp>
    lock() const noexcept
    { return shared_ptr<_Tp>(*this, std::nothrow); }
  };

752#if __cpp_deduction_guides201703L >= 201606
template<typename _Tp>
  weak_ptr(shared_ptr<_Tp>) ->  weak_ptr<_Tp>;
755#endif

// 20.7.2.3.6 weak_ptr specialized algorithms.
/// Swap overload for weak_ptr
/// @relates weak_ptr
template<typename _Tp>
  inline void
  swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }


/// Primary template owner_less
template<typename _Tp = void>
  struct owner_less;

/// Void specialization of owner_less compares either shared_ptr or weak_ptr
template<>
  struct owner_less<void> : _Sp_owner_less<void, void>
  { };

/// Partial specialization of owner_less for shared_ptr.
template<typename _Tp>
  struct owner_less<shared_ptr<_Tp>>
  : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
  { };

/// Partial specialization of owner_less for weak_ptr.
template<typename _Tp>
  struct owner_less<weak_ptr<_Tp>>
  : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
  { };

/**
 *  @brief Base class allowing use of member function shared_from_this.
 */
template<typename _Tp>
  class enable_shared_from_this
  {
  protected:
    constexpr enable_shared_from_this() noexcept { }

    enable_shared_from_this(const enable_shared_from_this&) noexcept { }

    enable_shared_from_this&
    operator=(const enable_shared_from_this&) noexcept
    { return *this; }

    ~enable_shared_from_this() { }

  public:
    shared_ptr<_Tp>
    shared_from_this()
    { return shared_ptr<_Tp>(this->_M_weak_this); }

    shared_ptr<const _Tp>
    shared_from_this() const
    { return shared_ptr<const _Tp>(this->_M_weak_this); }

813#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
814#define __cpp_lib_enable_shared_from_this201603 201603
    weak_ptr<_Tp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    weak_ptr<const _Tp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
822#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    // Found by ADL when this is an associated class.
    friend const enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<>&,
		     const enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable weak_ptr<_Tp>  _M_weak_this;
  };

/// @relates shared_ptr @{

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __a     An allocator.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  An exception thrown from @a _Alloc::allocate or from the
 *          constructor of @a _Tp.
 *
 *  A copy of @a __a will be used to allocate memory for the shared_ptr
 *  and the new object.
 */
template<typename _Tp, typename _Alloc, typename... _Args>
  inline shared_ptr<_Tp>
  allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
5
←
Calling constructor for 'shared_ptr<Impl>'→
19
←
Returning from constructor for 'shared_ptr<Impl>'→
	     std::forward<_Args>(__args)...);
  }

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  std::bad_alloc, or an exception thrown from the
 *          constructor of @a _Tp.
 */
template<typename _Tp, typename... _Args>
  inline shared_ptr<_Tp>
  make_shared(_Args&&... __args)
  {
    typedef typename std::remove_cv<_Tp>::type _Tp_nc;
    return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
4
←
Calling 'allocate_shared<Impl, std::allocator<Impl>, const clang::clangd::config::Provider *&, clang::clangd::ClangdServer::Callbacks *&>'→
20
←
Returned allocated memory→
		       std::forward<_Args>(__args)...);
  }

/// std::hash specialization for shared_ptr.
template<typename _Tp>
  struct hash<shared_ptr<_Tp>>
  : public __hash_base<size_t, shared_ptr<_Tp>>
  {
    size_t
    operator()(const shared_ptr<_Tp>& __s) const noexcept
    {
return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
    }
  };

// @} relates shared_ptr
// @} group pointer_abstractions

894#if __cplusplus201703L >= 201703L
namespace __detail::__variant
{
  template<typename> struct _Never_valueless_alt; // see <variant>

  // Provide the strong exception-safety guarantee when emplacing a
  // shared_ptr into a variant.
  template<typename _Tp>
    struct _Never_valueless_alt<std::shared_ptr<_Tp>>
    : std::true_type
    { };

  // Provide the strong exception-safety guarantee when emplacing a
  // weak_ptr into a variant.
  template<typename _Tp>
    struct _Never_valueless_alt<std::weak_ptr<_Tp>>
    : std::true_type
    { };
}  // namespace __detail::__variant
913#endif // C++17

915_GLIBCXX_END_NAMESPACE_VERSION
916} // namespace

918#endif // _SHARED_PTR_H

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/shared_ptr_base.h

→

1// shared_ptr and weak_ptr implementation details -*- C++ -*-

3// Copyright (C) 2007-2020 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// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

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

49#ifndef _SHARED_PTR_BASE_H1
50#define _SHARED_PTR_BASE_H1 1

52#include <typeinfo>
53#include <bits/allocated_ptr.h>
54#include <bits/refwrap.h>
55#include <bits/stl_function.h>
56#include <ext/aligned_buffer.h>
57#if __cplusplus201703L > 201703L
58# include <compare>
59#endif

61namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
62{
63_GLIBCXX_BEGIN_NAMESPACE_VERSION

65#if _GLIBCXX_USE_DEPRECATED1
66#pragma GCC diagnostic push
67#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template<typename> class auto_ptr;
69#pragma GCC diagnostic pop
70#endif

/**
 *  @brief  Exception possibly thrown by @c shared_ptr.
 *  @ingroup exceptions
 */
class bad_weak_ptr : public std::exception
{
public:
  virtual char const* what() const noexcept;

  virtual ~bad_weak_ptr() noexcept;
};

// Substitute for bad_weak_ptr object in the case of -fno-exceptions.
inline void
__throw_bad_weak_ptr()
{ _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr())(__builtin_abort()); }

using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
using __gnu_cxx::_S_single;
using __gnu_cxx::_S_mutex;
using __gnu_cxx::_S_atomic;

// Empty helper class except when the template argument is _S_mutex.
template<_Lock_policy _Lp>
  class _Mutex_base
  {
  protected:
    // The atomic policy uses fully-fenced builtins, single doesn't care.
    enum { _S_need_barriers = 0 };
  };

template<>
  class _Mutex_base<_S_mutex>
  : public __gnu_cxx::__mutex
  {
  protected:
    // This policy is used when atomic builtins are not available.
    // The replacement atomic operations might not have the necessary
    // memory barriers.
    enum { _S_need_barriers = 1 };
  };

template<_Lock_policy _Lp = __default_lock_policy>
  class _Sp_counted_base
  : public _Mutex_base<_Lp>
  {
  public:
    _Sp_counted_base() noexcept
    : _M_use_count(1), _M_weak_count(1) { }

    virtual
    ~_Sp_counted_base() noexcept
    { }

    // Called when _M_use_count drops to zero, to release the resources
    // managed by *this.
    virtual void
    _M_dispose() noexcept = 0;

    // Called when _M_weak_count drops to zero.
    virtual void
    _M_destroy() noexcept
    { delete this; }

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept = 0;

    void
    _M_add_ref_copy()
    { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }

    void
    _M_add_ref_lock();

    bool
    _M_add_ref_lock_nothrow();

    void
    _M_release() noexcept
    {
      // Be race-detector-friendly.  For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
   _M_dispose();
   // There must be a memory barrier between dispose() and destroy()
   // to ensure that the effects of dispose() are observed in the
   // thread that runs destroy().
   // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
   if (_Mutex_base<_Lp>::_S_need_barriers)
     {
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }

          // Be race-detector-friendly.  For more info see bits/c++config.
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
   if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
				       -1) == 1)
            {
              _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
       _M_destroy();
            }
 }
    }

    void
    _M_weak_add_ref() noexcept
    { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }

    void
    _M_weak_release() noexcept
    {
      // Be race-detector-friendly. For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
   if (_Mutex_base<_Lp>::_S_need_barriers)
     {
       // See _M_release(),
       // destroy() must observe results of dispose()
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }
   _M_destroy();
 }
    }

    long
    _M_get_use_count() const noexcept
    {
      // No memory barrier is used here so there is no synchronization
      // with other threads.
      return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED0);
    }

  private:
    _Sp_counted_base(_Sp_counted_base const&) = delete;
    _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;

    _Atomic_word  _M_use_count;     // #shared
    _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
  };

template<>
  inline void
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock()
  {
    if (_M_use_count == 0)
__throw_bad_weak_ptr();
    ++_M_use_count;
  }

template<>
  inline void
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 __throw_bad_weak_ptr();
}
  }

template<>
  inline void
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   __throw_bad_weak_ptr();
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
  }

template<>
  inline bool
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock_nothrow()
  {
    if (_M_use_count == 0)
return false;
    ++_M_use_count;
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock_nothrow()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 return false;
}
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock_nothrow()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   return false;
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
    return true;
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_add_ref_copy()
  { ++_M_use_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_release() noexcept
  {
    if (--_M_use_count == 0)
      {
        _M_dispose();
        if (--_M_weak_count == 0)
          _M_destroy();
      }
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
  { ++_M_weak_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_release() noexcept
  {
    if (--_M_weak_count == 0)
      _M_destroy();
  }

template<>
  inline long
  _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
  { return _M_use_count; }


// Forward declarations.
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __shared_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __weak_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __enable_shared_from_this;

template<typename _Tp>
  class shared_ptr;

template<typename _Tp>
  class weak_ptr;

template<typename _Tp>
  struct owner_less;

template<typename _Tp>
  class enable_shared_from_this;

template<_Lock_policy _Lp = __default_lock_policy>
  class __weak_count;

template<_Lock_policy _Lp = __default_lock_policy>
  class __shared_count;


// Counted ptr with no deleter or allocator support
template<typename _Ptr, _Lock_policy _Lp>
  class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
  {
  public:
    explicit
    _Sp_counted_ptr(_Ptr __p) noexcept
    : _M_ptr(__p) { }

    virtual void
    _M_dispose() noexcept
    { delete _M_ptr; }

    virtual void
    _M_destroy() noexcept
    { delete this; }

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept
    { return nullptr; }

    _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
    _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;

  private:
    _Ptr             _M_ptr;
  };

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }

template<int _Nm, typename _Tp,
  bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
  struct _Sp_ebo_helper;

/// Specialization using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
  };

/// Specialization not using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, false>
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh)
    { return __eboh._M_tp; }

  private:
    _Tp _M_tp;
  };

// Support for custom deleter and/or allocator
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Deleter>	_Del_base;
typedef _Sp_ebo_helper<1, _Alloc>	_Alloc_base;

    public:
_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
{ }

_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }

_Ptr _M_ptr;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
    : _M_impl(__p, std::move(__d), _Alloc()) { }

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
    : _M_impl(__p, std::move(__d), __a) { }

    ~_Sp_counted_deleter() noexcept { }

    virtual void
    _M_dispose() noexcept
    { _M_impl._M_del()(_M_impl._M_ptr); }

    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_deleter();
    }

    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept
    {
487#if __cpp_rtti199711L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2400. shared_ptr's get_deleter() should use addressof()
      return __ti == typeid(_Deleter)
 ? std::__addressof(_M_impl._M_del())
 : nullptr;
493#else
      return nullptr;
495#endif
    }

  private:
    _Impl _M_impl;
  };

// helpers for make_shared / allocate_shared

struct _Sp_make_shared_tag
{
private:
  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
    friend class _Sp_counted_ptr_inplace;

  static const type_info&
  _S_ti() noexcept _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
  {
    alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { };
    return reinterpret_cast<const type_info&>(__tag);
  }

  static bool _S_eq(const type_info&) noexcept;
};

template<typename _Alloc>
  struct _Sp_alloc_shared_tag
  {
    const _Alloc& _M_a;
  };

template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Alloc>	_A_base;

    public:
explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }

_Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }

__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;

    // Alloc parameter is not a reference so doesn't alias anything in __args
    template<typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _M_impl(__a)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2070.  allocate_shared should use allocator_traits<A>::construct
 allocator_traits<_Alloc>::construct(__a, _M_ptr(),
     std::forward<_Args>(__args)...); // might throw
}

    ~_Sp_counted_ptr_inplace() noexcept { }

    virtual void
    _M_dispose() noexcept
    {
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
    }

    // Override because the allocator needs to know the dynamic type
    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_ptr_inplace();
    }

  private:
    friend class __shared_count<_Lp>; // To be able to call _M_ptr().

    // No longer used, but code compiled against old libstdc++ headers
    // might still call it from __shared_ptr ctor to get the pointer out.
    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept override
    {
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
   ||
587#if __cpp_rtti199711L
   __ti == typeid(_Sp_make_shared_tag)
589#else
   _Sp_make_shared_tag::_S_eq(__ti)
591#endif
  )
 return __ptr;
return nullptr;
    }

    _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }

    _Impl _M_impl;
  };

// The default deleter for shared_ptr<T[]> and shared_ptr<T[N]>.
struct __sp_array_delete
{
  template<typename _Yp>
    void operator()(_Yp* __p) const { delete[] __p; }
};

template<_Lock_policy _Lp>
  class __shared_count
  {
    template<typename _Tp>
struct __not_alloc_shared_tag { using type = void; };

    template<typename _Tp>
struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };

  public:
    constexpr __shared_count() noexcept : _M_pi(0)
    { }

    template<typename _Ptr>
      explicit
__shared_count(_Ptr __p) : _M_pi(0)
{
 __tryif (true)
   {
     _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
   }
 __catch(...)if (false)
   {
     delete __p;
     __throw_exception_again;
   }
}

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ false_type)
: __shared_count(__p)
{ }

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ true_type)
: __shared_count(__p, __sp_array_delete{}, allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter,
      typename = typename __not_alloc_shared_tag<_Deleter>::type>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter, typename _Alloc,
      typename = typename __not_alloc_shared_tag<_Deleter>::type>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
 typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
 __tryif (true)
   {
     typename _Sp_cd_type::__allocator_type __a2(__a);
     auto __guard = std::__allocate_guarded(__a2);
     _Sp_cd_type* __mem = __guard.get();
     ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
     _M_pi = __mem;
     __guard = nullptr;
   }
 __catch(...)if (false)
   {
     __d(__p); // Call _Deleter on __p.
     __throw_exception_again;
   }
}

    template<typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
       _Args&&... __args)
{
 typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
 typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
 auto __guard = std::__allocate_guarded(__a2);
8
←
Calling '__allocate_guarded<std::allocator<std::_Sp_counted_ptr_inplace<Impl, std::allocator<Impl>, __gnu_cxx::_S_atomic>>>'→
16
←
Returned allocated memory→
 _Sp_cp_type* __mem = __guard.get();
 auto __pi = ::new (__mem)
   _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
 __guard = nullptr;
 _M_pi = __pi;
 __p = __pi->_M_ptr();
}

689#if _GLIBCXX_USE_DEPRECATED1
690#pragma GCC diagnostic push
691#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    // Special case for auto_ptr<_Tp> to provide the strong guarantee.
    template<typename _Tp>
      explicit
__shared_count(std::auto_ptr<_Tp>&& __r);
696#pragma GCC diagnostic pop
697#endif

    // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
    template<typename _Tp, typename _Del>
      explicit
__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2415. Inconsistency between unique_ptr and shared_ptr
 if (__r.get() == nullptr)
   return;

 using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
 using _Del2 = typename conditional<is_reference<_Del>::value,
     reference_wrapper<typename remove_reference<_Del>::type>,
     _Del>::type;
 using _Sp_cd_type
   = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
 using _Alloc = allocator<_Sp_cd_type>;
 using _Alloc_traits = allocator_traits<_Alloc>;
 _Alloc __a;
 _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
 _Alloc_traits::construct(__a, __mem, __r.release(),
		   __r.get_deleter());  // non-throwing
 _M_pi = __mem;
}

    // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
    explicit __shared_count(const __weak_count<_Lp>& __r);

    // Does not throw if __r._M_get_use_count() == 0, caller must check.
    explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);

    ~__shared_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_release();
    }

    __shared_count(const __shared_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != 0)
 _M_pi->_M_add_ref_copy();
    }

    __shared_count&
    operator=(const __shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
 {
   if (__tmp != 0)
     __tmp->_M_add_ref_copy();
   if (_M_pi != 0)
     _M_pi->_M_release();
   _M_pi = __tmp;
 }
return *this;
    }

    void
    _M_swap(__shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_unique() const noexcept
    { return this->_M_get_use_count() == 1; }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }

    bool
    _M_less(const __shared_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __weak_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __shared_count& __a, const __shared_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __weak_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };


template<_Lock_policy _Lp>
  class __weak_count
  {
  public:
    constexpr __weak_count() noexcept : _M_pi(nullptr)
    { }

    __weak_count(const __shared_count<_Lp>& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(const __weak_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(__weak_count&& __r) noexcept
    : _M_pi(__r._M_pi)
    { __r._M_pi = nullptr; }

    ~__weak_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
    }

    __weak_count&
    operator=(const __shared_count<_Lp>& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(const __weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(__weak_count&& __r) noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __r._M_pi;
      __r._M_pi = nullptr;
return *this;
    }

    void
    _M_swap(__weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_less(const __weak_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __shared_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __weak_count& __a, const __weak_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __shared_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
_M_pi->_M_add_ref_lock();
    else
__throw_bad_weak_ptr();
  }

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::
  __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
if (!_M_pi->_M_add_ref_lock_nothrow())
 _M_pi = nullptr;
  }

918#define __cpp_lib_shared_ptr_arrays201611L 201611L

// Helper traits for shared_ptr of array:

// A pointer type Y* is said to be compatible with a pointer type T* when
// either Y* is convertible to T* or Y is U[N] and T is U cv [].
template<typename _Yp_ptr, typename _Tp_ptr>
  struct __sp_compatible_with
  : false_type
  { };

template<typename _Yp, typename _Tp>
  struct __sp_compatible_with<_Yp*, _Tp*>
  : is_convertible<_Yp*, _Tp*>::type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
  : true_type
  { };

// Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N].
template<typename _Up, size_t _Nm, typename _Yp, typename = void>
  struct __sp_is_constructible_arrN
  : false_type
  { };

template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
  : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
  { };

// Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[].
template<typename _Up, typename _Yp, typename = void>
  struct __sp_is_constructible_arr
  : false_type
  { };

template<typename _Up, typename _Yp>
  struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
  : is_convertible<_Yp(*)[], _Up(*)[]>::type
  { };

// Trait to check if shared_ptr<T> can be constructed from Y*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible;

// When T is U[N], Y(*)[N] shall be convertible to T*;
template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible<_Up[_Nm], _Yp>
  : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
  { };

// when T is U[], Y(*)[] shall be convertible to T*;
template<typename _Up, typename _Yp>
  struct __sp_is_constructible<_Up[], _Yp>
  : __sp_is_constructible_arr<_Up, _Yp>::type
  { };

// otherwise, Y* shall be convertible to T*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible
  : is_convertible<_Yp*, _Tp*>::type
  { };


// Define operator* and operator-> for shared_ptr<T>.
template<typename _Tp, _Lock_policy _Lp,
  bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
  class __shared_ptr_access
  {
  public:
    using element_type = _Tp;

    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr)do { if (! (_M_get() != nullptr)) std::__replacement_assert("/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/shared_ptr_base.h"
, 1010, __PRETTY_FUNCTION__, "_M_get() != nullptr"); } while (
false);
return *_M_get();
    }

    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

// Define operator-> for shared_ptr<cv void>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, false, true>
  {
  public:
    using element_type = _Tp;

    element_type*
    operator->() const noexcept
    {
auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
_GLIBCXX_DEBUG_PEDASSERT(__ptr != nullptr);
return __ptr;
    }
  };

// Define operator[] for shared_ptr<T[]> and shared_ptr<T[N]>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, true, false>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

1050#if __cplusplus201703L <= 201402L
    [[__deprecated__("shared_ptr<T[]>::operator* is absent from C++17")]]
    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr)do { if (! (_M_get() != nullptr)) std::__replacement_assert("/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/shared_ptr_base.h"
, 1055, __PRETTY_FUNCTION__, "_M_get() != nullptr"); } while (
false);
return *_M_get();
    }

    [[__deprecated__("shared_ptr<T[]>::operator-> is absent from C++17")]]
    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }
1066#endif

    element_type&
    operator[](ptrdiff_t __i) const
    {
__glibcxx_assert(_M_get() != nullptr)do { if (! (_M_get() != nullptr)) std::__replacement_assert("/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/shared_ptr_base.h"
, 1071, __PRETTY_FUNCTION__, "_M_get() != nullptr"); } while (
false);
__glibcxx_assert(!extent<_Tp>::value || __i < extent<_Tp>::value)do { if (! (!extent<_Tp>::value || __i < extent<_Tp
>::value)) std::__replacement_assert("/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/shared_ptr_base.h"
, 1072, __PRETTY_FUNCTION__, "!extent<_Tp>::value || __i < extent<_Tp>::value"
); } while (false);
return _M_get()[__i];
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr
  : public __shared_ptr_access<_Tp, _Lp>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

  private:
    // Constraint for taking ownership of a pointer of type _Yp*:
    template<typename _Yp>
using _SafeConv
 = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;

    // Constraint for construction from shared_ptr and weak_ptr:
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __shared_ptr&>;

    // Constraint for construction from unique_ptr:
    template<typename _Yp, typename _Del, typename _Res = void,
      typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
using _UniqCompatible = typename enable_if<__and_<
 __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
 >::value, _Res>::type;

    // Constraint for assignment from unique_ptr:
    template<typename _Yp, typename _Del>
using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;

  public:

1117#if __cplusplus201703L > 201402L
    using weak_type = __weak_ptr<_Tp, _Lp>;
1119#endif

    constexpr __shared_ptr() noexcept
    : _M_ptr(0), _M_refcount()
    { }

    template<typename _Yp, typename = _SafeConv<_Yp>>
explicit
__shared_ptr(_Yp* __p)
: _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
{
 static_assert( !is_void<_Yp>::value, "incomplete type" );
 static_assert( sizeof(_Yp) > 0, "incomplete type" );
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d)
: _M_ptr(__p), _M_refcount(__p, std::move(__d))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Deleter>
__shared_ptr(nullptr_t __p, _Deleter __d)
: _M_ptr(0), _M_refcount(__p, std::move(__d))
{ }

    template<typename _Deleter, typename _Alloc>
      __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
{ }

    // Aliasing constructor
    template<typename _Yp>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
     element_type* __p) noexcept
: _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
{ }

    // Aliasing constructor
    template<typename _Yp>
__shared_ptr(__shared_ptr<_Yp, _Lp>&& __r,
     element_type* __p) noexcept
: _M_ptr(__p), _M_refcount()
{
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = 0;
}

    __shared_ptr(const __shared_ptr&) noexcept = default;
    __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
    ~__shared_ptr() = default;

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __shared_ptr(__shared_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount()
    {
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
    }

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = 0;
}

    template<typename _Yp, typename = _Compatible<_Yp>>
explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
: _M_refcount(__r._M_refcount) // may throw
{
 // It is now safe to copy __r._M_ptr, as
 // _M_refcount(__r._M_refcount) did not throw.
 _M_ptr = __r._M_ptr;
}

    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
      typename = _UniqCompatible<_Yp, _Del>>
__shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = __to_address(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}

1225#if __cplusplus201703L <= 201402L && _GLIBCXX_USE_DEPRECATED1
  protected:
    // If an exception is thrown this constructor has no effect.
    template<typename _Tp1, typename _Del,
      typename enable_if<__and_<
 __not_<is_array<_Tp>>, is_array<_Tp1>,
        is_convertible<typename unique_ptr<_Tp1, _Del>::pointer, _Tp*>
      >::value, bool>::type = true>
__shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = __to_address(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}
  public:
1241#endif

1243#if _GLIBCXX_USE_DEPRECATED1
1244#pragma GCC diagnostic push
1245#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    // Postcondition: use_count() == 1 and __r.get() == 0
    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(auto_ptr<_Yp>&& __r);
1249#pragma GCC diagnostic pop
1250#endif

    constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
 return *this;
}

1263#if _GLIBCXX_USE_DEPRECATED1
1264#pragma GCC diagnostic push
1265#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    template<typename _Yp>
_Assignable<_Yp>
operator=(auto_ptr<_Yp>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}
1273#pragma GCC diagnostic pop
1274#endif

    __shared_ptr&
    operator=(__shared_ptr&& __r) noexcept
    {
__shared_ptr(std::move(__r)).swap(*this);
return *this;
    }

    template<class _Yp>
_Assignable<_Yp>
operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    template<typename _Yp, typename _Del>
_UniqAssignable<_Yp, _Del>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    void
    reset() noexcept
    { __shared_ptr().swap(*this); }

    template<typename _Yp>
_SafeConv<_Yp>
reset(_Yp* __p) // _Yp must be complete.
{
 // Catch self-reset errors.
 __glibcxx_assert(__p == 0 || __p != _M_ptr)do { if (! (__p == 0 || __p != _M_ptr)) std::__replacement_assert
("/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/shared_ptr_base.h"
, 1308, __PRETTY_FUNCTION__, "__p == 0 || __p != _M_ptr"); } while
 (false);
 __shared_ptr(__p).swap(*this);
}

    template<typename _Yp, typename _Deleter>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d)
{ __shared_ptr(__p, std::move(__d)).swap(*this); }

    template<typename _Yp, typename _Deleter, typename _Alloc>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d, _Alloc __a)
      { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }

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

    /// Return true if the stored pointer is not null.
    explicit operator bool() const // never throws
    { return _M_ptr == 0 ? false : true; }

    /// Return true if use_count() == 1.
    bool
    unique() const noexcept
    { return _M_refcount._M_unique(); }

    /// If *this owns a pointer, return the number of owners, otherwise zero.
    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    /// Exchange both the owned pointer and the stored pointer.
    void
    swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
    {
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
    }

    /** @brief Define an ordering based on ownership.
     *
     * This function defines a strict weak ordering between two shared_ptr
     * or weak_ptr objects, such that one object is less than the other
     * unless they share ownership of the same pointer, or are both empty.
     * @{
    */
    template<typename _Tp1>
bool
owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }
    // @}

  protected:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
: _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
7
←
Calling constructor for '__shared_count<__gnu_cxx::_S_atomic>'→
17
←
Returning from constructor for '__shared_count<__gnu_cxx::_S_atomic>'→
{ _M_enable_shared_from_this_with(_M_ptr); }

    template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
      typename... _Args>
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is used by __weak_ptr::lock() and
    // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t).
    __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
    : _M_refcount(__r._M_refcount, std::nothrow)
    {
_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
    }

    friend class __weak_ptr<_Tp, _Lp>;

  private:

    template<typename _Yp>
using __esft_base_t = decltype(__enable_shared_from_this_base(
     std::declval<const __shared_count<_Lp>&>(),
     std::declval<_Yp*>()));

    // Detect an accessible and unambiguous enable_shared_from_this base.
    template<typename _Yp, typename = void>
struct __has_esft_base
: false_type { };

    template<typename _Yp>
struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
: __not_<is_array<_Tp>> { }; // No enable shared_from_this for arrays

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp* __p) noexcept
{
 if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
   __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
}

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<!__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp*) noexcept
{ }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_refcount._M_get_deleter(__ti); }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;

    template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;

    template<typename _Del, typename _Tp1>
friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;

    element_type*	   _M_ptr;         // Contained pointer.
    __shared_count<_Lp>  _M_refcount;    // Reference counter.
  };


// 20.7.2.2.7 shared_ptr comparisons
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() == __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !__a; }

1448#ifdef __cpp_lib_three_way_comparison
template<typename _Tp, typename _Up, _Lock_policy _Lp>
  inline strong_ordering
  operator<=>(const __shared_ptr<_Tp, _Lp>& __a,
const __shared_ptr<_Up, _Lp>& __b) noexcept
  { return compare_three_way()(__a.get(), __b.get()); }

template<typename _Tp, _Lock_policy _Lp>
  inline strong_ordering
  operator<=>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  {
    using pointer = typename __shared_ptr<_Tp, _Lp>::element_type*;
    return compare_three_way()(__a.get(), static_cast<pointer>(nullptr));
  }
1462#else
template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !__a; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() != __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return (bool)__a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return (bool)__a; }

template<typename _Tp, typename _Up, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a,
     const __shared_ptr<_Up, _Lp>& __b) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(nullptr < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(__a < nullptr); }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp1, _Lp>& __a,
     const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return (__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return __a < nullptr; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__a < __b); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(__a < nullptr); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(nullptr < __a); }
1558#endif // three-way comparison

// 20.7.2.2.8 shared_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// static_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// const_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// dynamic_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

1609#if __cplusplus201703L > 201402L
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
1617#endif

template<typename _Tp, _Lock_policy _Lp>
  class __weak_ptr
  {
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __weak_ptr&>;

  public:
    using element_type = typename remove_extent<_Tp>::type;

    constexpr __weak_ptr() noexcept
    : _M_ptr(nullptr), _M_refcount()
    { }

    __weak_ptr(const __weak_ptr&) noexcept = default;

    ~__weak_ptr() = default;

    // The "obvious" converting constructor implementation:
    //
    //  template<typename _Tp1>
    //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
    //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
    //    { }
    //
    // has a serious problem.
    //
    //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
    //  conversion may require access to *__r._M_ptr (virtual inheritance).
    //
    // It is not possible to avoid spurious access violations since
    // in multithreaded programs __r._M_ptr may be invalidated at any point.
    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
: _M_refcount(__r._M_refcount)
      { _M_ptr = __r.lock().get(); }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __weak_ptr(__weak_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
    { __r._M_ptr = nullptr; }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
      { __r._M_ptr = nullptr; }

    __weak_ptr&
    operator=(const __weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = __r._M_refcount;
 return *this;
}

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount;
 return *this;
}

    __weak_ptr&
    operator=(__weak_ptr&& __r) noexcept
    {
_M_ptr = __r._M_ptr;
_M_refcount = std::move(__r._M_refcount);
__r._M_ptr = nullptr;
return *this;
    }

    template<typename _Yp>
_Assignable<_Yp>
operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = std::move(__r._M_refcount);
 __r._M_ptr = nullptr;
 return *this;
}

    __shared_ptr<_Tp, _Lp>
    lock() const noexcept
    { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }

    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    bool
    expired() const noexcept
    { return _M_refcount._M_get_use_count() == 0; }

    template<typename _Tp1>
bool
owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    void
    reset() noexcept
    { __weak_ptr().swap(*this); }

    void
    swap(__weak_ptr& __s) noexcept
    {
std::swap(_M_ptr, __s._M_ptr);
_M_refcount._M_swap(__s._M_refcount);
    }

  private:
    // Used by __enable_shared_from_this.
    void
    _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
    {
if (use_count() == 0)
 {
   _M_ptr = __ptr;
   _M_refcount = __refcount;
 }
    }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
    friend class __enable_shared_from_this<_Tp, _Lp>;
    friend class enable_shared_from_this<_Tp>;

    element_type*	 _M_ptr;         // Contained pointer.
    __weak_count<_Lp>  _M_refcount;    // Reference counter.
  };

// 20.7.2.3.6 weak_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

template<typename _Tp, typename _Tp1>
  struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
  {
    bool
    operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }
  };

template<>
  struct _Sp_owner_less<void, void>
  {
    template<typename _Tp, typename _Up>
auto
operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
-> decltype(__lhs.owner_before(__rhs))
{ return __lhs.owner_before(__rhs); }

    using is_transparent = void;
  };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__shared_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
  { };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__weak_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
  { };


template<typename _Tp, _Lock_policy _Lp>
  class __enable_shared_from_this
  {
  protected:
    constexpr __enable_shared_from_this() noexcept { }

    __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }

    __enable_shared_from_this&
    operator=(const __enable_shared_from_this&) noexcept
    { return *this; }

    ~__enable_shared_from_this() { }

  public:
    __shared_ptr<_Tp, _Lp>
    shared_from_this()
    { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }

    __shared_ptr<const _Tp, _Lp>
    shared_from_this() const
    { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }

1836#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
    __weak_ptr<_Tp, _Lp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    __weak_ptr<const _Tp, _Lp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
1844#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    friend const __enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<_Lp>&,
		     const __enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
  };

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
  typename _Alloc, typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a},
		    std::forward<_Args>(__args)...);
  }

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
  typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __make_shared(_Args&&... __args)
  {
    typedef typename std::remove_const<_Tp>::type _Tp_nc;
    return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
			      std::forward<_Args>(__args)...);
  }

/// std::hash specialization for __shared_ptr.
template<typename _Tp, _Lock_policy _Lp>
  struct hash<__shared_ptr<_Tp, _Lp>>
  : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
  {
    size_t
    operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
    {
return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
   __s.get());
    }
  };

1895_GLIBCXX_END_NAMESPACE_VERSION
1896} // namespace

1898#endif // _SHARED_PTR_BASE_H

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/allocated_ptr.h

→

1// Guarded Allocation -*- C++ -*-
2 
3// Copyright (C) 2014-2020 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.
10 
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.
15 
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.
19 
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/>.
24 
25/** @file bits/allocated_ptr.h
26 *  This is an internal header file, included by other library headers.
27 *  Do not attempt to use it directly. @headername{memory}
28 */
29 
30#ifndef _ALLOCATED_PTR_H1
31#define _ALLOCATED_PTR_H1 1
32 
33#if __cplusplus201703L < 201103L
34# include <bits/c++0xwarning.h>
35#else
36# include <type_traits>
37# include <bits/ptr_traits.h>
38# include <bits/alloc_traits.h>
39 
40namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
41{
42_GLIBCXX_BEGIN_NAMESPACE_VERSION
43 
44  /// Non-standard RAII type for managing pointers obtained from allocators.
45  template<typename _Alloc>
46    struct __allocated_ptr
47    {
48      using pointer = typename allocator_traits<_Alloc>::pointer;
49      using value_type = typename allocator_traits<_Alloc>::value_type;
50 
51      /// Take ownership of __ptr
52      __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
53      : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr)
54      { }
55 
56      /// Convert __ptr to allocator's pointer type and take ownership of it
57      template<typename _Ptr,
58	       typename _Req = _Require<is_same<_Ptr, value_type*>>>
59      __allocated_ptr(_Alloc& __a, _Ptr __ptr)
60      : _M_alloc(std::__addressof(__a)),
61	_M_ptr(pointer_traits<pointer>::pointer_to(*__ptr))
62      { }
63 
64      /// Transfer ownership of the owned pointer
65      __allocated_ptr(__allocated_ptr&& __gd) noexcept
66      : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr)
67      { __gd._M_ptr = nullptr; }
68 
69      /// Deallocate the owned pointer
70      ~__allocated_ptr()
71      {
72	if (_M_ptr != nullptr)
73	  std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
74      }
75 
76      /// Release ownership of the owned pointer
77      __allocated_ptr&
78      operator=(std::nullptr_t) noexcept
79      {
80	_M_ptr = nullptr;
81	return *this;
82      }
83 
84      /// Get the address that the owned pointer refers to.
85      value_type* get() { return std::__to_address(_M_ptr); }
86 
87    private:
88      _Alloc* _M_alloc;
89      pointer _M_ptr;
90    };
91 
92  /// Allocate space for a single object using __a
93  template<typename _Alloc>
94    __allocated_ptr<_Alloc>
95    __allocate_guarded(_Alloc& __a)
96    {
97      return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) };
9
←
Calling 'allocator_traits::allocate'→
15
←
Returned allocated memory→
98    }
99 
100_GLIBCXX_END_NAMESPACE_VERSION
101} // namespace std
102 
103#endif
104#endif

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/alloc_traits.h

→

1// Allocator traits -*- C++ -*-

3// Copyright (C) 2011-2020 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/alloc_traits.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

30#ifndef _ALLOC_TRAITS_H1
31#define _ALLOC_TRAITS_H1 1

33#include <bits/stl_construct.h>
34#include <bits/memoryfwd.h>
35#if __cplusplus201703L >= 201103L
36# include <bits/allocator.h>
37# include <bits/ptr_traits.h>
38# include <ext/numeric_traits.h>
39#endif

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

45#if __cplusplus201703L >= 201103L
46#define __cpp_lib_allocator_traits_is_always_equal201411 201411

struct __allocator_traits_base
{
  template<typename _Tp, typename _Up, typename = void>
    struct __rebind : __replace_first_arg<_Tp, _Up> { };

  template<typename _Tp, typename _Up>
    struct __rebind<_Tp, _Up,
      __void_t<typename _Tp::template rebind<_Up>::other>>
    { using type = typename _Tp::template rebind<_Up>::other; };

protected:
  template<typename _Tp>
    using __pointer = typename _Tp::pointer;
  template<typename _Tp>
    using __c_pointer = typename _Tp::const_pointer;
  template<typename _Tp>
    using __v_pointer = typename _Tp::void_pointer;
  template<typename _Tp>
    using __cv_pointer = typename _Tp::const_void_pointer;
  template<typename _Tp>
    using __pocca = typename _Tp::propagate_on_container_copy_assignment;
  template<typename _Tp>
    using __pocma = typename _Tp::propagate_on_container_move_assignment;
  template<typename _Tp>
    using __pocs = typename _Tp::propagate_on_container_swap;
  template<typename _Tp>
    using __equal = typename _Tp::is_always_equal;
};

template<typename _Alloc, typename _Up>
  using __alloc_rebind
    = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;

/**
 * @brief  Uniform interface to all allocator types.
 * @ingroup allocators
*/
template<typename _Alloc>
  struct allocator_traits : __allocator_traits_base
  {
    /// The allocator type
    typedef _Alloc allocator_type;
    /// The allocated type
    typedef typename _Alloc::value_type value_type;

    /**
     * @brief   The allocator's pointer type.
     *
     * @c Alloc::pointer if that type exists, otherwise @c value_type*
    */
    using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;

  private:
    // Select _Func<_Alloc> or pointer_traits<pointer>::rebind<_Tp>
    template<template<typename> class _Func, typename _Tp, typename = void>
struct _Ptr
{
 using type = typename pointer_traits<pointer>::template rebind<_Tp>;
};

    template<template<typename> class _Func, typename _Tp>
struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
{
 using type = _Func<_Alloc>;
};

    // Select _A2::difference_type or pointer_traits<_Ptr>::difference_type
    template<typename _A2, typename _PtrT, typename = void>
struct _Diff
{ using type = typename pointer_traits<_PtrT>::difference_type; };

    template<typename _A2, typename _PtrT>
struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
{ using type = typename _A2::difference_type; };

    // Select _A2::size_type or make_unsigned<_DiffT>::type
    template<typename _A2, typename _DiffT, typename = void>
struct _Size : make_unsigned<_DiffT> { };

    template<typename _A2, typename _DiffT>
struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
{ using type = typename _A2::size_type; };

  public:
    /**
     * @brief   The allocator's const pointer type.
     *
     * @c Alloc::const_pointer if that type exists, otherwise
     * <tt> pointer_traits<pointer>::rebind<const value_type> </tt>
    */
    using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;

    /**
     * @brief   The allocator's void pointer type.
     *
     * @c Alloc::void_pointer if that type exists, otherwise
     * <tt> pointer_traits<pointer>::rebind<void> </tt>
    */
    using void_pointer = typename _Ptr<__v_pointer, void>::type;

    /**
     * @brief   The allocator's const void pointer type.
     *
     * @c Alloc::const_void_pointer if that type exists, otherwise
     * <tt> pointer_traits<pointer>::rebind<const void> </tt>
    */
    using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;

    /**
     * @brief   The allocator's difference type
     *
     * @c Alloc::difference_type if that type exists, otherwise
     * <tt> pointer_traits<pointer>::difference_type </tt>
    */
    using difference_type = typename _Diff<_Alloc, pointer>::type;

    /**
     * @brief   The allocator's size type
     *
     * @c Alloc::size_type if that type exists, otherwise
     * <tt> make_unsigned<difference_type>::type </tt>
    */
    using size_type = typename _Size<_Alloc, difference_type>::type;

    /**
     * @brief   How the allocator is propagated on copy assignment
     *
     * @c Alloc::propagate_on_container_copy_assignment if that type exists,
     * otherwise @c false_type
    */
    using propagate_on_container_copy_assignment
= __detected_or_t<false_type, __pocca, _Alloc>;

    /**
     * @brief   How the allocator is propagated on move assignment
     *
     * @c Alloc::propagate_on_container_move_assignment if that type exists,
     * otherwise @c false_type
    */
    using propagate_on_container_move_assignment
= __detected_or_t<false_type, __pocma, _Alloc>;

    /**
     * @brief   How the allocator is propagated on swap
     *
     * @c Alloc::propagate_on_container_swap if that type exists,
     * otherwise @c false_type
    */
    using propagate_on_container_swap
= __detected_or_t<false_type, __pocs, _Alloc>;

    /**
     * @brief   Whether all instances of the allocator type compare equal.
     *
     * @c Alloc::is_always_equal if that type exists,
     * otherwise @c is_empty<Alloc>::type
    */
    using is_always_equal
= __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;

    template<typename _Tp>
using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
    template<typename _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;

  private:
    template<typename _Alloc2>
static constexpr auto
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
-> decltype(__a.allocate(__n, __hint))
{ return __a.allocate(__n, __hint); }

    template<typename _Alloc2>
static constexpr pointer
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
{ return __a.allocate(__n); }

    template<typename _Tp, typename... _Args>
struct __construct_helper
{
 template<typename _Alloc2,
   typename = decltype(std::declval<_Alloc2*>()->construct(
  std::declval<_Tp*>(), std::declval<_Args>()...))>
   static true_type __test(int);

 template<typename>
   static false_type __test(...);

 using type = decltype(__test<_Alloc>(0));
};

    template<typename _Tp, typename... _Args>
using __has_construct
 = typename __construct_helper<_Tp, _Args...>::type;

    template<typename _Tp, typename... _Args>
static _GLIBCXX14_CONSTEXPRconstexpr _Require<__has_construct<_Tp, _Args...>>
_S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...)))
{ __a.construct(__p, std::forward<_Args>(__args)...); }

    template<typename _Tp, typename... _Args>
static _GLIBCXX14_CONSTEXPRconstexpr
_Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
	       is_constructible<_Tp, _Args...>>>
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value)
{
256#if __cplusplus201703L <= 201703L
 ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
258#else
 std::construct_at(__p, std::forward<_Args>(__args)...);
260#endif
}

    template<typename _Alloc2, typename _Tp>
static _GLIBCXX14_CONSTEXPRconstexpr auto
_S_destroy(_Alloc2& __a, _Tp* __p, int)
noexcept(noexcept(__a.destroy(__p)))
-> decltype(__a.destroy(__p))
{ __a.destroy(__p); }

    template<typename _Alloc2, typename _Tp>
static _GLIBCXX14_CONSTEXPRconstexpr void
_S_destroy(_Alloc2&, _Tp* __p, ...)
noexcept(std::is_nothrow_destructible<_Tp>::value)
{ std::_Destroy(__p); }

    template<typename _Alloc2>
static constexpr auto
_S_max_size(_Alloc2& __a, int)
-> decltype(__a.max_size())
{ return __a.max_size(); }

    template<typename _Alloc2>
static constexpr size_type
_S_max_size(_Alloc2&, ...)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2466. allocator_traits::max_size() default behavior is incorrect
 return __gnu_cxx::__numeric_traits<size_type>::__max
   / sizeof(value_type);
}

    template<typename _Alloc2>
static constexpr auto
_S_select(_Alloc2& __a, int)
-> decltype(__a.select_on_container_copy_construction())
{ return __a.select_on_container_copy_construction(); }

    template<typename _Alloc2>
static constexpr _Alloc2
_S_select(_Alloc2& __a, ...)
{ return __a; }

  public:

    /**
     *  @brief  Allocate memory.
     *  @param  __a  An allocator.
     *  @param  __n  The number of objects to allocate space for.
     *
     *  Calls @c a.allocate(n)
    */
    _GLIBCXX_NODISCARD[[__nodiscard__]] static _GLIBCXX20_CONSTEXPR pointer
    allocate(_Alloc& __a, size_type __n)
    { return __a.allocate(__n); }

    /**
     *  @brief  Allocate memory.
     *  @param  __a  An allocator.
     *  @param  __n  The number of objects to allocate space for.
     *  @param  __hint Aid to locality.
     *  @return Memory of suitable size and alignment for @a n objects
     *          of type @c value_type
     *
     *  Returns <tt> a.allocate(n, hint) </tt> if that expression is
     *  well-formed, otherwise returns @c a.allocate(n)
    */
    _GLIBCXX_NODISCARD[[__nodiscard__]] static _GLIBCXX20_CONSTEXPR pointer
    allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
    { return _S_allocate(__a, __n, __hint, 0); }

    /**
     *  @brief  Deallocate memory.
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to the memory to deallocate.
     *  @param  __n  The number of objects space was allocated for.
     *
     *  Calls <tt> a.deallocate(p, n) </tt>
    */
    static _GLIBCXX20_CONSTEXPR void
    deallocate(_Alloc& __a, pointer __p, size_type __n)
    { __a.deallocate(__p, __n); }

    /**
     *  @brief  Construct an object of type @a _Tp
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to memory of suitable size and alignment for Tp
     *  @param  __args Constructor arguments.
     *
     *  Calls <tt> __a.construct(__p, std::forward<Args>(__args)...) </tt>
     *  if that expression is well-formed, otherwise uses placement-new
     *  to construct an object of type @a _Tp at location @a __p from the
     *  arguments @a __args...
    */
    template<typename _Tp, typename... _Args>
static _GLIBCXX20_CONSTEXPR auto
construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
noexcept(noexcept(_S_construct(__a, __p,
		       std::forward<_Args>(__args)...)))
-> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
{ _S_construct(__a, __p, std::forward<_Args>(__args)...); }

    /**
     *  @brief  Destroy an object of type @a _Tp
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to the object to destroy
     *
     *  Calls @c __a.destroy(__p) if that expression is well-formed,
     *  otherwise calls @c __p->~_Tp()
    */
    template<typename _Tp>
static _GLIBCXX20_CONSTEXPR void
destroy(_Alloc& __a, _Tp* __p)
noexcept(noexcept(_S_destroy(__a, __p, 0)))
{ _S_destroy(__a, __p, 0); }

    /**
     *  @brief  The maximum supported allocation size
     *  @param  __a  An allocator.
     *  @return @c __a.max_size() or @c numeric_limits<size_type>::max()
     *
     *  Returns @c __a.max_size() if that expression is well-formed,
     *  otherwise returns @c numeric_limits<size_type>::max()
    */
    static _GLIBCXX20_CONSTEXPR size_type
    max_size(const _Alloc& __a) noexcept
    { return _S_max_size(__a, 0); }

    /**
     *  @brief  Obtain an allocator to use when copying a container.
     *  @param  __rhs  An allocator.
     *  @return @c __rhs.select_on_container_copy_construction() or @a __rhs
     *
     *  Returns @c __rhs.select_on_container_copy_construction() if that
     *  expression is well-formed, otherwise returns @a __rhs
    */
    static _GLIBCXX20_CONSTEXPR _Alloc
    select_on_container_copy_construction(const _Alloc& __rhs)
    { return _S_select(__rhs, 0); }
  };

401#if __cplusplus201703L > 201703L
402# define __cpp_lib_constexpr_dynamic_alloc 201907L
403#endif

/// Partial specialization for std::allocator.
template<typename _Tp>
  struct allocator_traits<allocator<_Tp>>
  {
    /// The allocator type
    using allocator_type = allocator<_Tp>;

    /// The allocated type
    using value_type = _Tp;

    /// The allocator's pointer type.
    using pointer = _Tp*;

    /// The allocator's const pointer type.
    using const_pointer = const _Tp*;

    /// The allocator's void pointer type.
    using void_pointer = void*;

    /// The allocator's const void pointer type.
    using const_void_pointer = const void*;

    /// The allocator's difference type
    using difference_type = std::ptrdiff_t;

    /// The allocator's size type
    using size_type = std::size_t;

    /// How the allocator is propagated on copy assignment
    using propagate_on_container_copy_assignment = false_type;

    /// How the allocator is propagated on move assignment
    using propagate_on_container_move_assignment = true_type;

    /// How the allocator is propagated on swap
    using propagate_on_container_swap = false_type;

    /// Whether all instances of the allocator type compare equal.
    using is_always_equal = true_type;

    template<typename _Up>
using rebind_alloc = allocator<_Up>;

    template<typename _Up>
using rebind_traits = allocator_traits<allocator<_Up>>;

    /**
     *  @brief  Allocate memory.
     *  @param  __a  An allocator.
     *  @param  __n  The number of objects to allocate space for.
     *
     *  Calls @c a.allocate(n)
    */
    _GLIBCXX_NODISCARD[[__nodiscard__]] static _GLIBCXX20_CONSTEXPR pointer
    allocate(allocator_type& __a, size_type __n)
    { return __a.allocate(__n); }
10
←
Calling 'new_allocator::allocate'→
14
←
Returned allocated memory→

    /**
     *  @brief  Allocate memory.
     *  @param  __a  An allocator.
     *  @param  __n  The number of objects to allocate space for.
     *  @param  __hint Aid to locality.
     *  @return Memory of suitable size and alignment for @a n objects
     *          of type @c value_type
     *
     *  Returns <tt> a.allocate(n, hint) </tt>
    */
    _GLIBCXX_NODISCARD[[__nodiscard__]] static _GLIBCXX20_CONSTEXPR pointer
    allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
    {
475#if __cplusplus201703L <= 201703L
return __a.allocate(__n, __hint);
477#else
return __a.allocate(__n);
479#endif
    }

    /**
     *  @brief  Deallocate memory.
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to the memory to deallocate.
     *  @param  __n  The number of objects space was allocated for.
     *
     *  Calls <tt> a.deallocate(p, n) </tt>
    */
    static _GLIBCXX20_CONSTEXPR void
    deallocate(allocator_type& __a, pointer __p, size_type __n)
    { __a.deallocate(__p, __n); }

    /**
     *  @brief  Construct an object of type `_Up`
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to memory of suitable size and alignment for
     *	       an object of type `_Up`.
     *  @param  __args Constructor arguments.
     *
     *  Calls `__a.construct(__p, std::forward<_Args>(__args)...)`
     *  in C++11, C++14 and C++17. Changed in C++20 to call
     *  `std::construct_at(__p, std::forward<_Args>(__args)...)` instead.
    */
    template<typename _Up, typename... _Args>
static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
  _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
511#if __cplusplus201703L <= 201703L
 __a.construct(__p, std::forward<_Args>(__args)...);
513#else
 std::construct_at(__p, std::forward<_Args>(__args)...);
515#endif
}

    /**
     *  @brief  Destroy an object of type @a _Up
     *  @param  __a  An allocator.
     *  @param  __p  Pointer to the object to destroy
     *
     *  Calls @c __a.destroy(__p).
    */
    template<typename _Up>
static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
530#if __cplusplus201703L <= 201703L
 __a.destroy(__p);
532#else
 std::destroy_at(__p);
534#endif
}

    /**
     *  @brief  The maximum supported allocation size
     *  @param  __a  An allocator.
     *  @return @c __a.max_size()
    */
    static _GLIBCXX20_CONSTEXPR size_type
    max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
    {
545#if __cplusplus201703L <= 201703L
return __a.max_size();
547#else
return size_t(-1) / sizeof(value_type);
549#endif
    }

    /**
     *  @brief  Obtain an allocator to use when copying a container.
     *  @param  __rhs  An allocator.
     *  @return @c __rhs
    */
    static _GLIBCXX20_CONSTEXPR allocator_type
    select_on_container_copy_construction(const allocator_type& __rhs)
    { return __rhs; }
  };

562#if __cplusplus201703L < 201703L
template<typename _Alloc>
  inline void
  __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
  { __one = __two; }

template<typename _Alloc>
  inline void
  __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
  { }
572#endif

template<typename _Alloc>
  _GLIBCXX14_CONSTEXPRconstexpr inline void
  __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
  {
    typedef allocator_traits<_Alloc> __traits;
    typedef typename __traits::propagate_on_container_copy_assignment __pocca;
580#if __cplusplus201703L >= 201703L
    if constexpr (__pocca::value)
__one = __two;
583#else
    __do_alloc_on_copy(__one, __two, __pocca());
585#endif
  }

template<typename _Alloc>
  constexpr _Alloc
  __alloc_on_copy(const _Alloc& __a)
  {
    typedef allocator_traits<_Alloc> __traits;
    return __traits::select_on_container_copy_construction(__a);
  }

596#if __cplusplus201703L < 201703L
template<typename _Alloc>
  inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
  { __one = std::move(__two); }

template<typename _Alloc>
  inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
  { }
604#endif

template<typename _Alloc>
  _GLIBCXX14_CONSTEXPRconstexpr inline void
  __alloc_on_move(_Alloc& __one, _Alloc& __two)
  {
    typedef allocator_traits<_Alloc> __traits;
    typedef typename __traits::propagate_on_container_move_assignment __pocma;
612#if __cplusplus201703L >= 201703L
    if constexpr (__pocma::value)
__one = std::move(__two);
615#else
    __do_alloc_on_move(__one, __two, __pocma());
617#endif
  }

620#if __cplusplus201703L < 201703L
template<typename _Alloc>
  inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
  {
    using std::swap;
    swap(__one, __two);
  }

template<typename _Alloc>
  inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
  { }
631#endif

template<typename _Alloc>
  _GLIBCXX14_CONSTEXPRconstexpr inline void
  __alloc_on_swap(_Alloc& __one, _Alloc& __two)
  {
    typedef allocator_traits<_Alloc> __traits;
    typedef typename __traits::propagate_on_container_swap __pocs;
639#if __cplusplus201703L >= 201703L
    if constexpr (__pocs::value)
{
 using std::swap;
 swap(__one, __two);
}
645#else
    __do_alloc_on_swap(__one, __two, __pocs());
647#endif
  }

template<typename _Alloc, typename _Tp,
  typename _ValueT = __remove_cvref_t<typename _Alloc::value_type>,
  typename = void>
  struct __is_alloc_insertable_impl
  : false_type
  { };

template<typename _Alloc, typename _Tp, typename _ValueT>
  struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT,
    __void_t<decltype(allocator_traits<_Alloc>::construct(
   std::declval<_Alloc&>(), std::declval<_ValueT*>(),
   std::declval<_Tp>()))>>
  : true_type
  { };

// true if _Alloc::value_type is CopyInsertable into containers using _Alloc
// (might be wrong if _Alloc::construct exists but is not constrained,
// i.e. actually trying to use it would still be invalid. Use with caution.)
template<typename _Alloc>
  struct __is_copy_insertable
  : __is_alloc_insertable_impl<_Alloc,
		 typename _Alloc::value_type const&>::type
  { };

// std::allocator<_Tp> just requires CopyConstructible
template<typename _Tp>
  struct __is_copy_insertable<allocator<_Tp>>
  : is_copy_constructible<_Tp>
  { };

// true if _Alloc::value_type is MoveInsertable into containers using _Alloc
// (might be wrong if _Alloc::construct exists but is not constrained,
// i.e. actually trying to use it would still be invalid. Use with caution.)
template<typename _Alloc>
  struct __is_move_insertable
  : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type
  { };

// std::allocator<_Tp> just requires MoveConstructible
template<typename _Tp>
  struct __is_move_insertable<allocator<_Tp>>
  : is_move_constructible<_Tp>
  { };

// Trait to detect Allocator-like types.
template<typename _Alloc, typename = void>
  struct __is_allocator : false_type { };

template<typename _Alloc>
  struct __is_allocator<_Alloc,
    __void_t<typename _Alloc::value_type,
      decltype(std::declval<_Alloc&>().allocate(size_t{}))>>
  : true_type { };

template<typename _Alloc>
  using _RequireAllocator
    = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;

template<typename _Alloc>
  using _RequireNotAllocator
    = typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type;
711#endif // C++11

/**
 * Destroy a range of objects using the supplied allocator.  For
 * non-default allocators we do not optimize away invocation of
 * destroy() even if _Tp has a trivial destructor.
 */

template<typename _ForwardIterator, typename _Allocator>
  void
  _Destroy(_ForwardIterator __first, _ForwardIterator __last,
    _Allocator& __alloc)
  {
    for (; __first != __last; ++__first)
725#if __cplusplus201703L < 201103L
__alloc.destroy(std::__addressof(*__first));
727#else
allocator_traits<_Allocator>::destroy(__alloc,
			      std::__addressof(*__first));
730#endif
  }

template<typename _ForwardIterator, typename _Tp>
  inline void
  _Destroy(_ForwardIterator __first, _ForwardIterator __last,
    allocator<_Tp>&)
  {
    _Destroy(__first, __last);
  }

741_GLIBCXX_END_NAMESPACE_VERSION
742} // namespace std
743#endif // _ALLOC_TRAITS_H

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/ext/new_allocator.h

1// Allocator that wraps operator new -*- C++ -*-
2 
3// Copyright (C) 2001-2020 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.
10 
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.
15 
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.
19 
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/>.
24 
25/** @file ext/new_allocator.h
26 *  This file is a GNU extension to the Standard C++ Library.
27 */
28 
29#ifndef _NEW_ALLOCATOR_H1
30#define _NEW_ALLOCATOR_H1 1
31 
32#include <bits/c++config.h>
33#include <new>
34#include <bits/functexcept.h>
35#include <bits/move.h>
36#if __cplusplus201703L >= 201103L
37#include <type_traits>
38#endif
39 
40namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
41{
42_GLIBCXX_BEGIN_NAMESPACE_VERSION
43 
44  /**
45   *  @brief  An allocator that uses global new, as per [20.4].
46   *  @ingroup allocators
47   *
48   *  This is precisely the allocator defined in the C++ Standard.
49   *    - all allocation calls operator new
50   *    - all deallocation calls operator delete
51   *
52   *  @tparam  _Tp  Type of allocated object.
53   */
54  template<typename _Tp>
55    class new_allocator
56    {
57    public:
58      typedef _Tp        value_type;
59      typedef std::size_t     size_type;
60      typedef std::ptrdiff_t  difference_type;
61#if __cplusplus201703L <= 201703L
62      typedef _Tp*       pointer;
63      typedef const _Tp* const_pointer;
64      typedef _Tp&       reference;
65      typedef const _Tp& const_reference;
66 
67      template<typename _Tp1>
68	struct rebind
69	{ typedef new_allocator<_Tp1> other; };
70#endif
71 
72#if __cplusplus201703L >= 201103L
73      // _GLIBCXX_RESOLVE_LIB_DEFECTS
74      // 2103. propagate_on_container_move_assignment
75      typedef std::true_type propagate_on_container_move_assignment;
76#endif
77 
78      _GLIBCXX20_CONSTEXPR
79      new_allocator() _GLIBCXX_USE_NOEXCEPTnoexcept { }
80 
81      _GLIBCXX20_CONSTEXPR
82      new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPTnoexcept { }
83 
84      template<typename _Tp1>
85	_GLIBCXX20_CONSTEXPR
86	new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPTnoexcept { }
87 
88#if __cplusplus201703L <= 201703L
89      ~new_allocator() _GLIBCXX_USE_NOEXCEPTnoexcept { }
90 
91      pointer
92      address(reference __x) const _GLIBCXX_NOEXCEPTnoexcept
93      { return std::__addressof(__x); }
94 
95      const_pointer
96      address(const_reference __x) const _GLIBCXX_NOEXCEPTnoexcept
97      { return std::__addressof(__x); }
98#endif
99 
100      // NB: __n is permitted to be 0.  The C++ standard says nothing
101      // about what the return value is when __n == 0.
102      _GLIBCXX_NODISCARD[[__nodiscard__]] _Tp*
103      allocate(size_type __n, const void* = static_cast<const void*>(0))
104      {
105	if (__n > this->_M_max_size())
11
←
Taking false branch→
106	  std::__throw_bad_alloc();
107 
108#if __cpp_aligned_new201606L
109	if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__16UL)
12
←
Taking false branch→
110	  {
111	    std::align_val_t __al = std::align_val_t(alignof(_Tp));
112	    return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
113	  }
114#endif
115	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
13
←
Memory is allocated→
116      }
117 
118      // __p is not permitted to be a null pointer.
119      void
120      deallocate(_Tp* __p, size_type __t)
121      {
122#if __cpp_aligned_new201606L
123	if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__16UL)
124	  {
125	    ::operator delete(__p,
126# if __cpp_sized_deallocation
127			      __t * sizeof(_Tp),
128# endif
129			      std::align_val_t(alignof(_Tp)));
130	    return;
131	  }
132#endif
133	::operator delete(__p
134#if __cpp_sized_deallocation
135			  , __t * sizeof(_Tp)
136#endif
137			 );
138      }
139 
140#if __cplusplus201703L <= 201703L
141      size_type
142      max_size() const _GLIBCXX_USE_NOEXCEPTnoexcept
143      { return _M_max_size(); }
144 
145#if __cplusplus201703L >= 201103L
146      template<typename _Up, typename... _Args>
147	void
148	construct(_Up* __p, _Args&&... __args)
149	noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
150	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
151 
152      template<typename _Up>
153	void
154	destroy(_Up* __p)
155	noexcept(std::is_nothrow_destructible<_Up>::value)
156	{ __p->~_Up(); }
157#else
158      // _GLIBCXX_RESOLVE_LIB_DEFECTS
159      // 402. wrong new expression in [some_] allocator::construct
160      void
161      construct(pointer __p, const _Tp& __val)
162      { ::new((void *)__p) _Tp(__val); }
163 
164      void
165      destroy(pointer __p) { __p->~_Tp(); }
166#endif
167#endif // ! C++20
168 
169      template<typename _Up>
170	friend _GLIBCXX20_CONSTEXPR bool
171	operator==(const new_allocator&, const new_allocator<_Up>&)
172	_GLIBCXX_NOTHROWnoexcept
173	{ return true; }
174 
175#if __cpp_impl_three_way_comparison < 201907L
176      template<typename _Up>
177	friend _GLIBCXX20_CONSTEXPR bool
178	operator!=(const new_allocator&, const new_allocator<_Up>&)
179	_GLIBCXX_NOTHROWnoexcept
180	{ return false; }
181#endif
182 
183    private:
184      _GLIBCXX_CONSTEXPRconstexpr size_type
185      _M_max_size() const _GLIBCXX_USE_NOEXCEPTnoexcept
186      {
187#if __PTRDIFF_MAX__9223372036854775807L < __SIZE_MAX__18446744073709551615UL
188	return std::size_t(__PTRDIFF_MAX__9223372036854775807L) / sizeof(_Tp);
189#else
190	return std::size_t(-1) / sizeof(_Tp);
191#endif
192      }
193    };
194 
195_GLIBCXX_END_NAMESPACE_VERSION
196} // namespace
197 
198#endif