/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/lldb/source/Core/Debugger.cpp

Bug Summary

File:	build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/lldb/source/Core/Debugger.cpp
Warning:	line 952, column 5 Potential leak of memory pointed to by 'file_sp._M_refcount._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 Debugger.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 -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/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-16/lib/clang/16.0.0 -isystem /usr/include/libxml2 -D HAVE_ROUND -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/lldb/source/Core -I /build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/lldb/source/Core -I /build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/lldb/include -I tools/lldb/include -I include -I /build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/llvm/include -I /usr/include/python3.9 -I /build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/clang/include -I tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/lldb/source -I tools/lldb/source -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-16/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/= -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 -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-stringop-truncation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/= -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-2022-09-04-125545-48738-1 -x c++ /build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/lldb/source/Core/Debugger.cpp

/build/llvm-toolchain-snapshot-16~++20220904122748+c444af1c20b3/lldb/source/Core/Debugger.cpp

→

1//===-- Debugger.cpp ------------------------------------------------------===//
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 "lldb/Core/Debugger.h"

11#include "lldb/Breakpoint/Breakpoint.h"
12#include "lldb/Core/DebuggerEvents.h"
13#include "lldb/Core/FormatEntity.h"
14#include "lldb/Core/Mangled.h"
15#include "lldb/Core/ModuleList.h"
16#include "lldb/Core/ModuleSpec.h"
17#include "lldb/Core/PluginManager.h"
18#include "lldb/Core/StreamAsynchronousIO.h"
19#include "lldb/Core/StreamFile.h"
20#include "lldb/DataFormatters/DataVisualization.h"
21#include "lldb/Expression/REPL.h"
22#include "lldb/Host/File.h"
23#include "lldb/Host/FileSystem.h"
24#include "lldb/Host/HostInfo.h"
25#include "lldb/Host/Terminal.h"
26#include "lldb/Host/ThreadLauncher.h"
27#include "lldb/Interpreter/CommandInterpreter.h"
28#include "lldb/Interpreter/CommandReturnObject.h"
29#include "lldb/Interpreter/OptionValue.h"
30#include "lldb/Interpreter/OptionValueLanguage.h"
31#include "lldb/Interpreter/OptionValueProperties.h"
32#include "lldb/Interpreter/OptionValueSInt64.h"
33#include "lldb/Interpreter/OptionValueString.h"
34#include "lldb/Interpreter/Property.h"
35#include "lldb/Interpreter/ScriptInterpreter.h"
36#include "lldb/Symbol/Function.h"
37#include "lldb/Symbol/Symbol.h"
38#include "lldb/Symbol/SymbolContext.h"
39#include "lldb/Target/Language.h"
40#include "lldb/Target/Process.h"
41#include "lldb/Target/StructuredDataPlugin.h"
42#include "lldb/Target/Target.h"
43#include "lldb/Target/TargetList.h"
44#include "lldb/Target/Thread.h"
45#include "lldb/Target/ThreadList.h"
46#include "lldb/Utility/AnsiTerminal.h"
47#include "lldb/Utility/Event.h"
48#include "lldb/Utility/LLDBLog.h"
49#include "lldb/Utility/Listener.h"
50#include "lldb/Utility/Log.h"
51#include "lldb/Utility/Reproducer.h"
52#include "lldb/Utility/ReproducerProvider.h"
53#include "lldb/Utility/State.h"
54#include "lldb/Utility/Stream.h"
55#include "lldb/Utility/StreamString.h"

57#if defined(_WIN32)
58#include "lldb/Host/windows/PosixApi.h"
59#include "lldb/Host/windows/windows.h"
60#endif

62#include "llvm/ADT/None.h"
63#include "llvm/ADT/STLExtras.h"
64#include "llvm/ADT/StringRef.h"
65#include "llvm/ADT/iterator.h"
66#include "llvm/Support/DynamicLibrary.h"
67#include "llvm/Support/FileSystem.h"
68#include "llvm/Support/Process.h"
69#include "llvm/Support/ThreadPool.h"
70#include "llvm/Support/Threading.h"
71#include "llvm/Support/raw_ostream.h"

73#include <cstdio>
74#include <cstdlib>
75#include <cstring>
76#include <list>
77#include <memory>
78#include <mutex>
79#include <set>
80#include <string>
81#include <system_error>

83// Includes for pipe()
84#if defined(_WIN32)
85#include <fcntl.h>
86#include <io.h>
87#else
88#include <unistd.h>
89#endif

91namespace lldb_private {
92class Address;
93}

95using namespace lldb;
96using namespace lldb_private;

98static lldb::user_id_t g_unique_id = 1;
99static size_t g_debugger_event_thread_stack_bytes = 8 * 1024 * 1024;

101#pragma mark Static Functions

103typedef std::vector<DebuggerSP> DebuggerList;
104static std::recursive_mutex *g_debugger_list_mutex_ptr =
  nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
106static DebuggerList *g_debugger_list_ptr =
  nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
108static llvm::ThreadPool *g_thread_pool = nullptr;

110static constexpr OptionEnumValueElement g_show_disassembly_enum_values[] = {
  {
      Debugger::eStopDisassemblyTypeNever,
      "never",
      "Never show disassembly when displaying a stop context.",
  },
  {
      Debugger::eStopDisassemblyTypeNoDebugInfo,
      "no-debuginfo",
      "Show disassembly when there is no debug information.",
  },
  {
      Debugger::eStopDisassemblyTypeNoSource,
      "no-source",
      "Show disassembly when there is no source information, or the source "
      "file "
      "is missing when displaying a stop context.",
  },
  {
      Debugger::eStopDisassemblyTypeAlways,
      "always",
      "Always show disassembly when displaying a stop context.",
  },
133};

135static constexpr OptionEnumValueElement g_language_enumerators[] = {
  {
      eScriptLanguageNone,
      "none",
      "Disable scripting languages.",
  },
  {
      eScriptLanguagePython,
      "python",
      "Select python as the default scripting language.",
  },
  {
      eScriptLanguageDefault,
      "default",
      "Select the lldb default as the default scripting language.",
  },
151};

153static constexpr OptionEnumValueElement s_stop_show_column_values[] = {
  {
      eStopShowColumnAnsiOrCaret,
      "ansi-or-caret",
      "Highlight the stop column with ANSI terminal codes when color/ANSI "
      "mode is enabled; otherwise, fall back to using a text-only caret (^) "
      "as if \"caret-only\" mode was selected.",
  },
  {
      eStopShowColumnAnsi,
      "ansi",
      "Highlight the stop column with ANSI terminal codes when running LLDB "
      "with color/ANSI enabled.",
  },
  {
      eStopShowColumnCaret,
      "caret",
      "Highlight the stop column with a caret character (^) underneath the "
      "stop column. This method introduces a new line in source listings "
      "that display thread stop locations.",
  },
  {
      eStopShowColumnNone,
      "none",
      "Do not highlight the stop column.",
  },
179};

181#define LLDB_PROPERTIES_debugger
182#include "CoreProperties.inc"

184enum {
185#define LLDB_PROPERTIES_debugger
186#include "CorePropertiesEnum.inc"
187};

189LoadPluginCallbackType Debugger::g_load_plugin_callback = nullptr;

191Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
                                VarSetOperationType op,
                                llvm::StringRef property_path,
                                llvm::StringRef value) {
bool is_load_script =
    (property_path == "target.load-script-from-symbol-file");
// These properties might change how we visualize data.
bool invalidate_data_vis = (property_path == "escape-non-printables");
invalidate_data_vis |=
    (property_path == "target.max-zero-padding-in-float-format");
if (invalidate_data_vis) {
  DataVisualization::ForceUpdate();
}

TargetSP target_sp;
LoadScriptFromSymFile load_script_old_value = eLoadScriptFromSymFileFalse;
if (is_load_script && exe_ctx->GetTargetSP()) {
  target_sp = exe_ctx->GetTargetSP();
  load_script_old_value =
      target_sp->TargetProperties::GetLoadScriptFromSymbolFile();
}
Status error(Properties::SetPropertyValue(exe_ctx, op, property_path, value));
if (error.Success()) {
  // FIXME it would be nice to have "on-change" callbacks for properties
  if (property_path == g_debugger_properties[ePropertyPrompt].name) {
    llvm::StringRef new_prompt = GetPrompt();
    std::string str = lldb_private::ansi::FormatAnsiTerminalCodes(
        new_prompt, GetUseColor());
    if (str.length())
      new_prompt = str;
    GetCommandInterpreter().UpdatePrompt(new_prompt);
    auto bytes = std::make_unique<EventDataBytes>(new_prompt);
    auto prompt_change_event_sp = std::make_shared<Event>(
        CommandInterpreter::eBroadcastBitResetPrompt, bytes.release());
    GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp);
  } else if (property_path == g_debugger_properties[ePropertyUseColor].name) {
    // use-color changed. Ping the prompt so it can reset the ansi terminal
    // codes.
    SetPrompt(GetPrompt());
  } else if (property_path == g_debugger_properties[ePropertyUseSourceCache].name) {
    // use-source-cache changed. Wipe out the cache contents if it was disabled.
    if (!GetUseSourceCache()) {
      m_source_file_cache.Clear();
    }
  } else if (is_load_script && target_sp &&
             load_script_old_value == eLoadScriptFromSymFileWarn) {
    if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
        eLoadScriptFromSymFileTrue) {
      std::list<Status> errors;
      StreamString feedback_stream;
      if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) {
        Stream &s = GetErrorStream();
        for (auto error : errors) {
          s.Printf("%s\n", error.AsCString());
        }
        if (feedback_stream.GetSize())
          s.PutCString(feedback_stream.GetString());
      }
    }
  }
}
return error;
253}

255bool Debugger::GetAutoConfirm() const {
const uint32_t idx = ePropertyAutoConfirm;
return m_collection_sp->GetPropertyAtIndexAsBoolean(
    nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
259}

261const FormatEntity::Entry *Debugger::GetDisassemblyFormat() const {
const uint32_t idx = ePropertyDisassemblyFormat;
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
264}

266const FormatEntity::Entry *Debugger::GetFrameFormat() const {
const uint32_t idx = ePropertyFrameFormat;
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
269}

271const FormatEntity::Entry *Debugger::GetFrameFormatUnique() const {
const uint32_t idx = ePropertyFrameFormatUnique;
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
274}

276uint32_t Debugger::GetStopDisassemblyMaxSize() const {
const uint32_t idx = ePropertyStopDisassemblyMaxSize;
return m_collection_sp->GetPropertyAtIndexAsUInt64(
    nullptr, idx, g_debugger_properties[idx].default_uint_value);
280}

282bool Debugger::GetNotifyVoid() const {
const uint32_t idx = ePropertyNotiftVoid;
return m_collection_sp->GetPropertyAtIndexAsBoolean(
    nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
286}

288llvm::StringRef Debugger::GetPrompt() const {
const uint32_t idx = ePropertyPrompt;
return m_collection_sp->GetPropertyAtIndexAsString(
    nullptr, idx, g_debugger_properties[idx].default_cstr_value);
292}

294void Debugger::SetPrompt(llvm::StringRef p) {
const uint32_t idx = ePropertyPrompt;
m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
llvm::StringRef new_prompt = GetPrompt();
std::string str =
    lldb_private::ansi::FormatAnsiTerminalCodes(new_prompt, GetUseColor());
if (str.length())
  new_prompt = str;
GetCommandInterpreter().UpdatePrompt(new_prompt);
303}

305llvm::StringRef Debugger::GetReproducerPath() const {
auto &r = repro::Reproducer::Instance();
return r.GetReproducerPath().GetPathAsConstString().AsCString();
308}

310const FormatEntity::Entry *Debugger::GetThreadFormat() const {
const uint32_t idx = ePropertyThreadFormat;
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
313}

315const FormatEntity::Entry *Debugger::GetThreadStopFormat() const {
const uint32_t idx = ePropertyThreadStopFormat;
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
318}

320lldb::ScriptLanguage Debugger::GetScriptLanguage() const {
const uint32_t idx = ePropertyScriptLanguage;
return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration(
    nullptr, idx, g_debugger_properties[idx].default_uint_value);
324}

326bool Debugger::SetScriptLanguage(lldb::ScriptLanguage script_lang) {
const uint32_t idx = ePropertyScriptLanguage;
return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx,
                                                        script_lang);
330}

332lldb::LanguageType Debugger::GetREPLLanguage() const {
const uint32_t idx = ePropertyREPLLanguage;
OptionValueLanguage *value =
    m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage(nullptr, idx);
if (value)
  return value->GetCurrentValue();
return LanguageType();
339}

341bool Debugger::SetREPLLanguage(lldb::LanguageType repl_lang) {
const uint32_t idx = ePropertyREPLLanguage;
return m_collection_sp->SetPropertyAtIndexAsLanguage(nullptr, idx, repl_lang);
344}

346uint32_t Debugger::GetTerminalWidth() const {
const uint32_t idx = ePropertyTerminalWidth;
return m_collection_sp->GetPropertyAtIndexAsSInt64(
    nullptr, idx, g_debugger_properties[idx].default_uint_value);
350}

352bool Debugger::SetTerminalWidth(uint32_t term_width) {
if (auto handler_sp = m_io_handler_stack.Top())
  handler_sp->TerminalSizeChanged();

const uint32_t idx = ePropertyTerminalWidth;
return m_collection_sp->SetPropertyAtIndexAsSInt64(nullptr, idx, term_width);
358}

360bool Debugger::GetUseExternalEditor() const {
const uint32_t idx = ePropertyUseExternalEditor;
return m_collection_sp->GetPropertyAtIndexAsBoolean(
    nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
364}

366bool Debugger::SetUseExternalEditor(bool b) {
const uint32_t idx = ePropertyUseExternalEditor;
return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
369}

371bool Debugger::GetUseColor() const {
const uint32_t idx = ePropertyUseColor;
return m_collection_sp->GetPropertyAtIndexAsBoolean(
    nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
375}

377bool Debugger::SetUseColor(bool b) {
const uint32_t idx = ePropertyUseColor;
bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
SetPrompt(GetPrompt());
return ret;
382}

384bool Debugger::GetShowProgress() const {
const uint32_t idx = ePropertyShowProgress;
return m_collection_sp->GetPropertyAtIndexAsBoolean(
    nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
388}

390bool Debugger::SetShowProgress(bool show_progress) {
const uint32_t idx = ePropertyShowProgress;
return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx,
                                                    show_progress);
394}

396llvm::StringRef Debugger::GetShowProgressAnsiPrefix() const {
const uint32_t idx = ePropertyShowProgressAnsiPrefix;
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
399}

401llvm::StringRef Debugger::GetShowProgressAnsiSuffix() const {
const uint32_t idx = ePropertyShowProgressAnsiSuffix;
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
404}

406bool Debugger::GetUseAutosuggestion() const {
const uint32_t idx = ePropertyShowAutosuggestion;
return m_collection_sp->GetPropertyAtIndexAsBoolean(
    nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
410}

412llvm::StringRef Debugger::GetAutosuggestionAnsiPrefix() const {
const uint32_t idx = ePropertyShowAutosuggestionAnsiPrefix;
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
415}

417llvm::StringRef Debugger::GetAutosuggestionAnsiSuffix() const {
const uint32_t idx = ePropertyShowAutosuggestionAnsiSuffix;
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
420}

422bool Debugger::GetUseSourceCache() const {
const uint32_t idx = ePropertyUseSourceCache;
return m_collection_sp->GetPropertyAtIndexAsBoolean(
    nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
426}

428bool Debugger::SetUseSourceCache(bool b) {
const uint32_t idx = ePropertyUseSourceCache;
bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
if (!ret) {
  m_source_file_cache.Clear();
}
return ret;
435}
436bool Debugger::GetHighlightSource() const {
const uint32_t idx = ePropertyHighlightSource;
return m_collection_sp->GetPropertyAtIndexAsBoolean(
    nullptr, idx, g_debugger_properties[idx].default_uint_value);
440}

442StopShowColumn Debugger::GetStopShowColumn() const {
const uint32_t idx = ePropertyStopShowColumn;
return (lldb::StopShowColumn)m_collection_sp->GetPropertyAtIndexAsEnumeration(
    nullptr, idx, g_debugger_properties[idx].default_uint_value);
446}

448llvm::StringRef Debugger::GetStopShowColumnAnsiPrefix() const {
const uint32_t idx = ePropertyStopShowColumnAnsiPrefix;
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
451}

453llvm::StringRef Debugger::GetStopShowColumnAnsiSuffix() const {
const uint32_t idx = ePropertyStopShowColumnAnsiSuffix;
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
456}

458llvm::StringRef Debugger::GetStopShowLineMarkerAnsiPrefix() const {
const uint32_t idx = ePropertyStopShowLineMarkerAnsiPrefix;
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
461}

463llvm::StringRef Debugger::GetStopShowLineMarkerAnsiSuffix() const {
const uint32_t idx = ePropertyStopShowLineMarkerAnsiSuffix;
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
466}

468uint32_t Debugger::GetStopSourceLineCount(bool before) const {
const uint32_t idx =
    before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter;
return m_collection_sp->GetPropertyAtIndexAsSInt64(
    nullptr, idx, g_debugger_properties[idx].default_uint_value);
473}

475Debugger::StopDisassemblyType Debugger::GetStopDisassemblyDisplay() const {
const uint32_t idx = ePropertyStopDisassemblyDisplay;
return (Debugger::StopDisassemblyType)
    m_collection_sp->GetPropertyAtIndexAsEnumeration(
        nullptr, idx, g_debugger_properties[idx].default_uint_value);
480}

482uint32_t Debugger::GetDisassemblyLineCount() const {
const uint32_t idx = ePropertyStopDisassemblyCount;
return m_collection_sp->GetPropertyAtIndexAsSInt64(
    nullptr, idx, g_debugger_properties[idx].default_uint_value);
486}

488bool Debugger::GetAutoOneLineSummaries() const {
const uint32_t idx = ePropertyAutoOneLineSummaries;
return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
491}

493bool Debugger::GetEscapeNonPrintables() const {
const uint32_t idx = ePropertyEscapeNonPrintables;
return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
496}

498bool Debugger::GetAutoIndent() const {
const uint32_t idx = ePropertyAutoIndent;
return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
501}

503bool Debugger::SetAutoIndent(bool b) {
const uint32_t idx = ePropertyAutoIndent;
return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
506}

508bool Debugger::GetPrintDecls() const {
const uint32_t idx = ePropertyPrintDecls;
return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
511}

513bool Debugger::SetPrintDecls(bool b) {
const uint32_t idx = ePropertyPrintDecls;
return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
516}

518uint32_t Debugger::GetTabSize() const {
const uint32_t idx = ePropertyTabSize;
return m_collection_sp->GetPropertyAtIndexAsUInt64(
    nullptr, idx, g_debugger_properties[idx].default_uint_value);
522}

524bool Debugger::SetTabSize(uint32_t tab_size) {
const uint32_t idx = ePropertyTabSize;
return m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, tab_size);
527}

529#pragma mark Debugger

531// const DebuggerPropertiesSP &
532// Debugger::GetSettings() const
533//{
534//    return m_properties_sp;
535//}
536//

538void Debugger::Initialize(LoadPluginCallbackType load_plugin_callback) {
assert(g_debugger_list_ptr == nullptr &&(static_cast <bool> (g_debugger_list_ptr == nullptr &&
 "Debugger::Initialize called more than once!") ? void (0) : __assert_fail
 ("g_debugger_list_ptr == nullptr && \"Debugger::Initialize called more than once!\""
, "lldb/source/Core/Debugger.cpp", 540, __extension__ __PRETTY_FUNCTION__
))
       "Debugger::Initialize called more than once!")(static_cast <bool> (g_debugger_list_ptr == nullptr &&
 "Debugger::Initialize called more than once!") ? void (0) : __assert_fail
 ("g_debugger_list_ptr == nullptr && \"Debugger::Initialize called more than once!\""
, "lldb/source/Core/Debugger.cpp", 540, __extension__ __PRETTY_FUNCTION__
));
g_debugger_list_mutex_ptr = new std::recursive_mutex();
g_debugger_list_ptr = new DebuggerList();
g_thread_pool = new llvm::ThreadPool(llvm::optimal_concurrency());
g_load_plugin_callback = load_plugin_callback;
545}

547void Debugger::Terminate() {
assert(g_debugger_list_ptr &&(static_cast <bool> (g_debugger_list_ptr && "Debugger::Terminate called without a matching Debugger::Initialize!"
) ? void (0) : __assert_fail ("g_debugger_list_ptr && \"Debugger::Terminate called without a matching Debugger::Initialize!\""
, "lldb/source/Core/Debugger.cpp", 549, __extension__ __PRETTY_FUNCTION__
))
       "Debugger::Terminate called without a matching Debugger::Initialize!")(static_cast <bool> (g_debugger_list_ptr && "Debugger::Terminate called without a matching Debugger::Initialize!"
) ? void (0) : __assert_fail ("g_debugger_list_ptr && \"Debugger::Terminate called without a matching Debugger::Initialize!\""
, "lldb/source/Core/Debugger.cpp", 549, __extension__ __PRETTY_FUNCTION__
));

if (g_thread_pool) {
  // The destructor will wait for all the threads to complete.
  delete g_thread_pool;
}

if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  // Clear our global list of debugger objects
  {
    std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
    for (const auto &debugger : *g_debugger_list_ptr)
      debugger->Clear();
    g_debugger_list_ptr->clear();
  }
}
565}

567void Debugger::SettingsInitialize() { Target::SettingsInitialize(); }

569void Debugger::SettingsTerminate() { Target::SettingsTerminate(); }

571bool Debugger::LoadPlugin(const FileSpec &spec, Status &error) {
if (g_load_plugin_callback) {
  llvm::sys::DynamicLibrary dynlib =
      g_load_plugin_callback(shared_from_this(), spec, error);
  if (dynlib.isValid()) {
    m_loaded_plugins.push_back(dynlib);
    return true;
  }
} else {
  // The g_load_plugin_callback is registered in SBDebugger::Initialize() and
  // if the public API layer isn't available (code is linking against all of
  // the internal LLDB static libraries), then we can't load plugins
  error.SetErrorString("Public API layer is not available");
}
return false;
586}

588static FileSystem::EnumerateDirectoryResult
589LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
                 llvm::StringRef path) {
Status error;

static ConstString g_dylibext(".dylib");
static ConstString g_solibext(".so");

if (!baton)
  return FileSystem::eEnumerateDirectoryResultQuit;

Debugger *debugger = (Debugger *)baton;

namespace fs = llvm::sys::fs;
// If we have a regular file, a symbolic link or unknown file type, try and
// process the file. We must handle unknown as sometimes the directory
// enumeration might be enumerating a file system that doesn't have correct
// file type information.
if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
    ft == fs::file_type::type_unknown) {
  FileSpec plugin_file_spec(path);
  FileSystem::Instance().Resolve(plugin_file_spec);

  if (plugin_file_spec.GetFileNameExtension() != g_dylibext &&
      plugin_file_spec.GetFileNameExtension() != g_solibext) {
    return FileSystem::eEnumerateDirectoryResultNext;
  }

  Status plugin_load_error;
  debugger->LoadPlugin(plugin_file_spec, plugin_load_error);

  return FileSystem::eEnumerateDirectoryResultNext;
} else if (ft == fs::file_type::directory_file ||
           ft == fs::file_type::symlink_file ||
           ft == fs::file_type::type_unknown) {
  // Try and recurse into anything that a directory or symbolic link. We must
  // also do this for unknown as sometimes the directory enumeration might be
  // enumerating a file system that doesn't have correct file type
  // information.
  return FileSystem::eEnumerateDirectoryResultEnter;
}

return FileSystem::eEnumerateDirectoryResultNext;
631}

633void Debugger::InstanceInitialize() {
const bool find_directories = true;
const bool find_files = true;
const bool find_other = true;
char dir_path[PATH_MAX4096];
if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
  if (FileSystem::Instance().Exists(dir_spec) &&
      dir_spec.GetPath(dir_path, sizeof(dir_path))) {
    FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
                                              find_files, find_other,
                                              LoadPluginCallback, this);
  }
}

if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
  if (FileSystem::Instance().Exists(dir_spec) &&
      dir_spec.GetPath(dir_path, sizeof(dir_path))) {
    FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
                                              find_files, find_other,
                                              LoadPluginCallback, this);
  }
}

PluginManager::DebuggerInitialize(*this);
657}

659DebuggerSP Debugger::CreateInstance(lldb::LogOutputCallback log_callback,
                                  void *baton) {
DebuggerSP debugger_sp(new Debugger(log_callback, baton));
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  g_debugger_list_ptr->push_back(debugger_sp);
}
debugger_sp->InstanceInitialize();
return debugger_sp;
668}

670void Debugger::Destroy(DebuggerSP &debugger_sp) {
if (!debugger_sp)
  return;

CommandInterpreter &cmd_interpreter = debugger_sp->GetCommandInterpreter();

if (cmd_interpreter.GetSaveSessionOnQuit()) {
  CommandReturnObject result(debugger_sp->GetUseColor());
  cmd_interpreter.SaveTranscript(result);
  if (result.Succeeded())
    (*debugger_sp->GetAsyncOutputStream()) << result.GetOutputData() << '\n';
  else
    (*debugger_sp->GetAsyncErrorStream()) << result.GetErrorData() << '\n';
}

debugger_sp->Clear();

if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
  for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
    if ((*pos).get() == debugger_sp.get()) {
      g_debugger_list_ptr->erase(pos);
      return;
    }
  }
}
697}

699DebuggerSP Debugger::FindDebuggerWithInstanceName(ConstString instance_name) {
DebuggerSP debugger_sp;
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
  for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
    if ((*pos)->m_instance_name == instance_name) {
      debugger_sp = *pos;
      break;
    }
  }
}
return debugger_sp;
712}

714TargetSP Debugger::FindTargetWithProcessID(lldb::pid_t pid) {
TargetSP target_sp;
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
  for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
    target_sp = (*pos)->GetTargetList().FindTargetWithProcessID(pid);
    if (target_sp)
      break;
  }
}
return target_sp;
726}

728TargetSP Debugger::FindTargetWithProcess(Process *process) {
TargetSP target_sp;
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
  for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
    target_sp = (*pos)->GetTargetList().FindTargetWithProcess(process);
    if (target_sp)
      break;
  }
}
return target_sp;
740}

742ConstString Debugger::GetStaticBroadcasterClass() {
static ConstString class_name("lldb.debugger");
return class_name;
745}

747Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
  : UserID(g_unique_id++),
    Properties(std::make_shared<OptionValueProperties>()),
    m_input_file_sp(std::make_shared<NativeFile>(stdinstdin, false)),
    m_output_stream_sp(std::make_shared<StreamFile>(stdoutstdout, false)),
    m_error_stream_sp(std::make_shared<StreamFile>(stderrstderr, false)),
    m_input_recorder(nullptr),
    m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()),
    m_terminal_state(), m_target_list(*this), m_platform_list(),
    m_listener_sp(Listener::MakeListener("lldb.Debugger")),
    m_source_manager_up(), m_source_file_cache(),
    m_command_interpreter_up(
        std::make_unique<CommandInterpreter>(*this, false)),
    m_io_handler_stack(), m_instance_name(), m_loaded_plugins(),
    m_event_handler_thread(), m_io_handler_thread(),
    m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
    m_broadcaster(m_broadcaster_manager_sp,
                  GetStaticBroadcasterClass().AsCString()),
    m_forward_listener_sp(), m_clear_once() {
m_instance_name.SetString(llvm::formatv("debugger_{0}", GetID()).str());
if (log_callback)
  m_callback_handler_sp =
      std::make_shared<CallbackLogHandler>(log_callback, baton);
m_command_interpreter_up->Initialize();
// Always add our default platform to the platform list
PlatformSP default_platform_sp(Platform::GetHostPlatform());
assert(default_platform_sp)(static_cast <bool> (default_platform_sp) ? void (0) : __assert_fail
 ("default_platform_sp", "lldb/source/Core/Debugger.cpp", 773
, __extension__ __PRETTY_FUNCTION__));
m_platform_list.Append(default_platform_sp, true);

// Create the dummy target.
{
  ArchSpec arch(Target::GetDefaultArchitecture());
  if (!arch.IsValid())
    arch = HostInfo::GetArchitecture();
  assert(arch.IsValid() && "No valid default or host archspec")(static_cast <bool> (arch.IsValid() && "No valid default or host archspec"
) ? void (0) : __assert_fail ("arch.IsValid() && \"No valid default or host archspec\""
, "lldb/source/Core/Debugger.cpp", 781, __extension__ __PRETTY_FUNCTION__
));
  const bool is_dummy_target = true;
  m_dummy_target_sp.reset(
      new Target(*this, arch, default_platform_sp, is_dummy_target));
}
assert(m_dummy_target_sp.get() && "Couldn't construct dummy target?")(static_cast <bool> (m_dummy_target_sp.get() &&
 "Couldn't construct dummy target?") ? void (0) : __assert_fail
 ("m_dummy_target_sp.get() && \"Couldn't construct dummy target?\""
, "lldb/source/Core/Debugger.cpp", 786, __extension__ __PRETTY_FUNCTION__
));

m_collection_sp->Initialize(g_debugger_properties);
m_collection_sp->AppendProperty(
    ConstString("target"),
    ConstString("Settings specify to debugging targets."), true,
    Target::GetGlobalProperties().GetValueProperties());
m_collection_sp->AppendProperty(
    ConstString("platform"), ConstString("Platform settings."), true,
    Platform::GetGlobalPlatformProperties().GetValueProperties());
m_collection_sp->AppendProperty(
    ConstString("symbols"), ConstString("Symbol lookup and cache settings."),
    true, ModuleList::GetGlobalModuleListProperties().GetValueProperties());
if (m_command_interpreter_up) {
  m_collection_sp->AppendProperty(
      ConstString("interpreter"),
      ConstString("Settings specify to the debugger's command interpreter."),
      true, m_command_interpreter_up->GetValueProperties());
}
OptionValueSInt64 *term_width =
    m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64(
        nullptr, ePropertyTerminalWidth);
term_width->SetMinimumValue(10);
term_width->SetMaximumValue(1024);

// Turn off use-color if this is a dumb terminal.
const char *term = getenv("TERM");
if (term && !strcmp(term, "dumb"))
  SetUseColor(false);
// Turn off use-color if we don't write to a terminal with color support.
if (!GetOutputFile().GetIsTerminalWithColors())
  SetUseColor(false);

819#if defined(_WIN32) && defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
// Enabling use of ANSI color codes because LLDB is using them to highlight
// text.
llvm::sys::Process::UseANSIEscapeCodes(true);
823#endif
824}

826Debugger::~Debugger() { Clear(); }

828void Debugger::Clear() {
// Make sure we call this function only once. With the C++ global destructor
// chain having a list of debuggers and with code that can be running on
// other threads, we need to ensure this doesn't happen multiple times.
//
// The following functions call Debugger::Clear():
//     Debugger::~Debugger();
//     static void Debugger::Destroy(lldb::DebuggerSP &debugger_sp);
//     static void Debugger::Terminate();
llvm::call_once(m_clear_once, [this]() {
  ClearIOHandlers();
  StopIOHandlerThread();
  StopEventHandlerThread();
  m_listener_sp->Clear();
  for (TargetSP target_sp : m_target_list.Targets()) {
    if (target_sp) {
      if (ProcessSP process_sp = target_sp->GetProcessSP())
        process_sp->Finalize();
      target_sp->Destroy();
    }
  }
  m_broadcaster_manager_sp->Clear();

  // Close the input file _before_ we close the input read communications
  // class as it does NOT own the input file, our m_input_file does.
  m_terminal_state.Clear();
  GetInputFile().Close();

  m_command_interpreter_up->Clear();
});
858}

860bool Debugger::GetCloseInputOnEOF() const {
//    return m_input_comm.GetCloseOnEOF();
return false;
863}

865void Debugger::SetCloseInputOnEOF(bool b) {
//    m_input_comm.SetCloseOnEOF(b);
867}

869bool Debugger::GetAsyncExecution() {
return !m_command_interpreter_up->GetSynchronous();
871}

873void Debugger::SetAsyncExecution(bool async_execution) {
m_command_interpreter_up->SetSynchronous(!async_execution);
875}

877repro::DataRecorder *Debugger::GetInputRecorder() { return m_input_recorder; }

879static inline int OpenPipe(int fds[2], std::size_t size) {
880#ifdef _WIN32
return _pipe(fds, size, O_BINARY);
882#else
(void)size;
return pipe(fds);
885#endif
886}

888Status Debugger::SetInputString(const char *data) {
Status result;
enum PIPES { READ, WRITE }; // Indexes for the read and write fds
int fds[2] = {-1, -1};

if (data == nullptr) {
1
Assuming the condition is false→
2
←
Taking false branch→
  result.SetErrorString("String data is null");
  return result;
}

size_t size = strlen(data);
if (size == 0) {
3
←
Assuming 'size' is not equal to 0→
4
←
Taking false branch→
  result.SetErrorString("String data is empty");
  return result;
}

if (OpenPipe(fds, size) != 0) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
  result.SetErrorString(
      "can't create pipe file descriptors for LLDB commands");
  return result;
}

int r = write(fds[WRITE], data, size);
(void)r;
// Close the write end of the pipe, so that the command interpreter will exit
// when it consumes all the data.
llvm::sys::Process::SafelyCloseFileDescriptor(fds[WRITE]);

// Open the read file descriptor as a FILE * that we can return as an input
// handle.
FILE *commands_file = fdopen(fds[READ], "rb");
if (commands_file == nullptr) {
7
←
Assuming the condition is false→
8
←
Taking false branch→
  result.SetErrorStringWithFormat("fdopen(%i, \"rb\") failed (errno = %i) "
                                  "when trying to open LLDB commands pipe",
                                  fds[READ], errno(*__errno_location ()));
  llvm::sys::Process::SafelyCloseFileDescriptor(fds[READ]);
  return result;
}

return SetInputFile(
9
←
Calling 'Debugger::SetInputFile'→
    (FileSP)std::make_shared<NativeFile>(commands_file, true));
929}

931Status Debugger::SetInputFile(FileSP file_sp) {
Status error;
repro::DataRecorder *recorder = nullptr;
if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator())
10
←
Assuming 'g' is null→
11
←
Taking false branch→
  recorder = g->GetOrCreate<repro::CommandProvider>().GetNewRecorder();

static std::unique_ptr<repro::MultiLoader<repro::CommandProvider>> loader =
    repro::MultiLoader<repro::CommandProvider>::Create(
        repro::Reproducer::Instance().GetLoader());
if (loader) {
12
←
Taking true branch→
  llvm::Optional<std::string> nextfile = loader->GetNextFile();
  FILE *fh = nextfile ? FileSystem::Instance().Fopen(nextfile->c_str(), "r")
13
←
'?' condition is true→
                      : nullptr;
  // FIXME Jonas Devlieghere: shouldn't this error be propagated out to the
  // reproducer somehow if fh is NULL?
  if (fh) {
14
←
Assuming 'fh' is non-null→
15
←
Taking true branch→
    file_sp = std::make_shared<NativeFile>(fh, true);
16
←
Calling 'make_shared<lldb_private::NativeFile, _IO_FILE *&, bool>'→
34
←
Returned allocated memory→
  }
}

if (!file_sp || !file_sp->IsValid()) {
35
←
Taking true branch→
  error.SetErrorString("invalid file");
36
←
Potential leak of memory pointed to by 'file_sp._M_refcount._M_pi'
  return error;
}

SetInputFile(file_sp, recorder);
return error;
958}

960void Debugger::SetInputFile(FileSP file_sp, repro::DataRecorder *recorder) {
assert(file_sp && file_sp->IsValid())(static_cast <bool> (file_sp && file_sp->IsValid
()) ? void (0) : __assert_fail ("file_sp && file_sp->IsValid()"
, "lldb/source/Core/Debugger.cpp", 961, __extension__ __PRETTY_FUNCTION__
));
m_input_recorder = recorder;
m_input_file_sp = std::move(file_sp);
// Save away the terminal state if that is relevant, so that we can restore
// it in RestoreInputState.
SaveInputTerminalState();
967}

969void Debugger::SetOutputFile(FileSP file_sp) {
assert(file_sp && file_sp->IsValid())(static_cast <bool> (file_sp && file_sp->IsValid
()) ? void (0) : __assert_fail ("file_sp && file_sp->IsValid()"
, "lldb/source/Core/Debugger.cpp", 970, __extension__ __PRETTY_FUNCTION__
));
m_output_stream_sp = std::make_shared<StreamFile>(file_sp);
972}

974void Debugger::SetErrorFile(FileSP file_sp) {
assert(file_sp && file_sp->IsValid())(static_cast <bool> (file_sp && file_sp->IsValid
()) ? void (0) : __assert_fail ("file_sp && file_sp->IsValid()"
, "lldb/source/Core/Debugger.cpp", 975, __extension__ __PRETTY_FUNCTION__
));
m_error_stream_sp = std::make_shared<StreamFile>(file_sp);
977}

979void Debugger::SaveInputTerminalState() {
int fd = GetInputFile().GetDescriptor();
if (fd != File::kInvalidDescriptor)
  m_terminal_state.Save(fd, true);
983}

985void Debugger::RestoreInputTerminalState() { m_terminal_state.Restore(); }

987ExecutionContext Debugger::GetSelectedExecutionContext() {
bool adopt_selected = true;
ExecutionContextRef exe_ctx_ref(GetSelectedTarget().get(), adopt_selected);
return ExecutionContext(exe_ctx_ref);
991}

993void Debugger::DispatchInputInterrupt() {
std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
IOHandlerSP reader_sp(m_io_handler_stack.Top());
if (reader_sp)
  reader_sp->Interrupt();
998}

1000void Debugger::DispatchInputEndOfFile() {
std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
IOHandlerSP reader_sp(m_io_handler_stack.Top());
if (reader_sp)
  reader_sp->GotEOF();
1005}

1007void Debugger::ClearIOHandlers() {
// The bottom input reader should be the main debugger input reader.  We do
// not want to close that one here.
std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
while (m_io_handler_stack.GetSize() > 1) {
  IOHandlerSP reader_sp(m_io_handler_stack.Top());
  if (reader_sp)
    PopIOHandler(reader_sp);
}
1016}

1018void Debugger::RunIOHandlers() {
IOHandlerSP reader_sp = m_io_handler_stack.Top();
while (true) {
  if (!reader_sp)
    break;

  reader_sp->Run();
  {
    std::lock_guard<std::recursive_mutex> guard(
        m_io_handler_synchronous_mutex);

    // Remove all input readers that are done from the top of the stack
    while (true) {
      IOHandlerSP top_reader_sp = m_io_handler_stack.Top();
      if (top_reader_sp && top_reader_sp->GetIsDone())
        PopIOHandler(top_reader_sp);
      else
        break;
    }
    reader_sp = m_io_handler_stack.Top();
  }
}
ClearIOHandlers();
1041}

1043void Debugger::RunIOHandlerSync(const IOHandlerSP &reader_sp) {
std::lock_guard<std::recursive_mutex> guard(m_io_handler_synchronous_mutex);

PushIOHandler(reader_sp);
IOHandlerSP top_reader_sp = reader_sp;

while (top_reader_sp) {
  if (!top_reader_sp)
    break;

  top_reader_sp->Run();

  // Don't unwind past the starting point.
  if (top_reader_sp.get() == reader_sp.get()) {
    if (PopIOHandler(reader_sp))
      break;
  }

  // If we pushed new IO handlers, pop them if they're done or restart the
  // loop to run them if they're not.
  while (true) {
    top_reader_sp = m_io_handler_stack.Top();
    if (top_reader_sp && top_reader_sp->GetIsDone()) {
      PopIOHandler(top_reader_sp);
      // Don't unwind past the starting point.
      if (top_reader_sp.get() == reader_sp.get())
        return;
    } else {
      break;
    }
  }
}
1075}

1077bool Debugger::IsTopIOHandler(const lldb::IOHandlerSP &reader_sp) {
return m_io_handler_stack.IsTop(reader_sp);
1079}

1081bool Debugger::CheckTopIOHandlerTypes(IOHandler::Type top_type,
                                    IOHandler::Type second_top_type) {
return m_io_handler_stack.CheckTopIOHandlerTypes(top_type, second_top_type);
1084}

1086void Debugger::PrintAsync(const char *s, size_t len, bool is_stdout) {
bool printed = m_io_handler_stack.PrintAsync(s, len, is_stdout);
if (!printed) {
  lldb::StreamFileSP stream =
      is_stdout ? m_output_stream_sp : m_error_stream_sp;
  stream->Write(s, len);
}
1093}

1095ConstString Debugger::GetTopIOHandlerControlSequence(char ch) {
return m_io_handler_stack.GetTopIOHandlerControlSequence(ch);
1097}

1099const char *Debugger::GetIOHandlerCommandPrefix() {
return m_io_handler_stack.GetTopIOHandlerCommandPrefix();
1101}

1103const char *Debugger::GetIOHandlerHelpPrologue() {
return m_io_handler_stack.GetTopIOHandlerHelpPrologue();
1105}

1107bool Debugger::RemoveIOHandler(const IOHandlerSP &reader_sp) {
return PopIOHandler(reader_sp);
1109}

1111void Debugger::RunIOHandlerAsync(const IOHandlerSP &reader_sp,
                               bool cancel_top_handler) {
PushIOHandler(reader_sp, cancel_top_handler);
1114}

1116void Debugger::AdoptTopIOHandlerFilesIfInvalid(FileSP &in, StreamFileSP &out,
                                             StreamFileSP &err) {
// Before an IOHandler runs, it must have in/out/err streams. This function
// is called when one ore more of the streams are nullptr. We use the top
// input reader's in/out/err streams, or fall back to the debugger file
// handles, or we fall back onto stdin/stdout/stderr as a last resort.

std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
IOHandlerSP top_reader_sp(m_io_handler_stack.Top());
// If no STDIN has been set, then set it appropriately
if (!in || !in->IsValid()) {
  if (top_reader_sp)
    in = top_reader_sp->GetInputFileSP();
  else
    in = GetInputFileSP();
  // If there is nothing, use stdin
  if (!in)
    in = std::make_shared<NativeFile>(stdinstdin, false);
}
// If no STDOUT has been set, then set it appropriately
if (!out || !out->GetFile().IsValid()) {
  if (top_reader_sp)
    out = top_reader_sp->GetOutputStreamFileSP();
  else
    out = GetOutputStreamSP();
  // If there is nothing, use stdout
  if (!out)
    out = std::make_shared<StreamFile>(stdoutstdout, false);
}
// If no STDERR has been set, then set it appropriately
if (!err || !err->GetFile().IsValid()) {
  if (top_reader_sp)
    err = top_reader_sp->GetErrorStreamFileSP();
  else
    err = GetErrorStreamSP();
  // If there is nothing, use stderr
  if (!err)
    err = std::make_shared<StreamFile>(stderrstderr, false);
}
1155}

1157void Debugger::PushIOHandler(const IOHandlerSP &reader_sp,
                           bool cancel_top_handler) {
if (!reader_sp)
  return;

std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());

// Get the current top input reader...
IOHandlerSP top_reader_sp(m_io_handler_stack.Top());

// Don't push the same IO handler twice...
if (reader_sp == top_reader_sp)
  return;

// Push our new input reader
m_io_handler_stack.Push(reader_sp);
reader_sp->Activate();

// Interrupt the top input reader to it will exit its Run() function and let
// this new input reader take over
if (top_reader_sp) {
  top_reader_sp->Deactivate();
  if (cancel_top_handler)
    top_reader_sp->Cancel();
}
1182}

1184bool Debugger::PopIOHandler(const IOHandlerSP &pop_reader_sp) {
if (!pop_reader_sp)
  return false;

std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());

// The reader on the stop of the stack is done, so let the next read on the
// stack refresh its prompt and if there is one...
if (m_io_handler_stack.IsEmpty())
  return false;

IOHandlerSP reader_sp(m_io_handler_stack.Top());

if (pop_reader_sp != reader_sp)
  return false;

reader_sp->Deactivate();
reader_sp->Cancel();
m_io_handler_stack.Pop();

reader_sp = m_io_handler_stack.Top();
if (reader_sp)
  reader_sp->Activate();

return true;
1209}

1211StreamSP Debugger::GetAsyncOutputStream() {
return std::make_shared<StreamAsynchronousIO>(*this, true, GetUseColor());
1213}

1215StreamSP Debugger::GetAsyncErrorStream() {
return std::make_shared<StreamAsynchronousIO>(*this, false, GetUseColor());
1217}

1219size_t Debugger::GetNumDebuggers() {
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  return g_debugger_list_ptr->size();
}
return 0;
1225}

1227lldb::DebuggerSP Debugger::GetDebuggerAtIndex(size_t index) {
DebuggerSP debugger_sp;

if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  if (index < g_debugger_list_ptr->size())
    debugger_sp = g_debugger_list_ptr->at(index);
}

return debugger_sp;
1237}

1239DebuggerSP Debugger::FindDebuggerWithID(lldb::user_id_t id) {
DebuggerSP debugger_sp;

if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
  for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
    if ((*pos)->GetID() == id) {
      debugger_sp = *pos;
      break;
    }
  }
}
return debugger_sp;
1253}

1255bool Debugger::FormatDisassemblerAddress(const FormatEntity::Entry *format,
                                       const SymbolContext *sc,
                                       const SymbolContext *prev_sc,
                                       const ExecutionContext *exe_ctx,
                                       const Address *addr, Stream &s) {
FormatEntity::Entry format_entry;

if (format == nullptr) {
  if (exe_ctx != nullptr && exe_ctx->HasTargetScope())
    format = exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat();
  if (format == nullptr) {
    FormatEntity::Parse("${addr}: ", format_entry);
    format = &format_entry;
  }
}
bool function_changed = false;
bool initial_function = false;
if (prev_sc && (prev_sc->function || prev_sc->symbol)) {
  if (sc && (sc->function || sc->symbol)) {
    if (prev_sc->symbol && sc->symbol) {
      if (!sc->symbol->Compare(prev_sc->symbol->GetName(),
                               prev_sc->symbol->GetType())) {
        function_changed = true;
      }
    } else if (prev_sc->function && sc->function) {
      if (prev_sc->function->GetMangled() != sc->function->GetMangled()) {
        function_changed = true;
      }
    }
  }
}
// The first context on a list of instructions will have a prev_sc that has
// no Function or Symbol -- if SymbolContext had an IsValid() method, it
// would return false.  But we do get a prev_sc pointer.
if ((sc && (sc->function || sc->symbol)) && prev_sc &&
    (prev_sc->function == nullptr && prev_sc->symbol == nullptr)) {
  initial_function = true;
}
return FormatEntity::Format(*format, s, sc, exe_ctx, addr, nullptr,
                            function_changed, initial_function);
1295}

1297void Debugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
                                void *baton) {
// For simplicity's sake, I am not going to deal with how to close down any
// open logging streams, I just redirect everything from here on out to the
// callback.
m_callback_handler_sp =
    std::make_shared<CallbackLogHandler>(log_callback, baton);
1304}

1306static void PrivateReportProgress(Debugger &debugger, uint64_t progress_id,
                                const std::string &message,
                                uint64_t completed, uint64_t total,
                                bool is_debugger_specific) {
// Only deliver progress events if we have any progress listeners.
const uint32_t event_type = Debugger::eBroadcastBitProgress;
if (!debugger.GetBroadcaster().EventTypeHasListeners(event_type))
  return;
EventSP event_sp(new Event(
    event_type, new ProgressEventData(progress_id, message, completed, total,
                                      is_debugger_specific)));
debugger.GetBroadcaster().BroadcastEvent(event_sp);
1318}

1320void Debugger::ReportProgress(uint64_t progress_id, const std::string &message,
                            uint64_t completed, uint64_t total,
                            llvm::Optional<lldb::user_id_t> debugger_id) {
// Check if this progress is for a specific debugger.
if (debugger_id) {
  // It is debugger specific, grab it and deliver the event if the debugger
  // still exists.
  DebuggerSP debugger_sp = FindDebuggerWithID(*debugger_id);
  if (debugger_sp)
    PrivateReportProgress(*debugger_sp, progress_id, message, completed,
                          total, /*is_debugger_specific*/ true);
  return;
}
// The progress event is not debugger specific, iterate over all debuggers
// and deliver a progress event to each one.
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
  for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos)
    PrivateReportProgress(*(*pos), progress_id, message, completed, total,
                          /*is_debugger_specific*/ false);
}
1342}

1344static void PrivateReportDiagnostic(Debugger &debugger,
                                  DiagnosticEventData::Type type,
                                  std::string message,
                                  bool debugger_specific) {
uint32_t event_type = 0;
switch (type) {
case DiagnosticEventData::Type::Warning:
  event_type = Debugger::eBroadcastBitWarning;
  break;
case DiagnosticEventData::Type::Error:
  event_type = Debugger::eBroadcastBitError;
  break;
}

Broadcaster &broadcaster = debugger.GetBroadcaster();
if (!broadcaster.EventTypeHasListeners(event_type)) {
  // Diagnostics are too important to drop. If nobody is listening, print the
  // diagnostic directly to the debugger's error stream.
  DiagnosticEventData event_data(type, std::move(message), debugger_specific);
  StreamSP stream = debugger.GetAsyncErrorStream();
  event_data.Dump(stream.get());
  return;
}
EventSP event_sp = std::make_shared<Event>(
    event_type,
    new DiagnosticEventData(type, std::move(message), debugger_specific));
broadcaster.BroadcastEvent(event_sp);
1371}

1373void Debugger::ReportDiagnosticImpl(DiagnosticEventData::Type type,
                                  std::string message,
                                  llvm::Optional<lldb::user_id_t> debugger_id,
                                  std::once_flag *once) {
auto ReportDiagnosticLambda = [&]() {
  // Check if this progress is for a specific debugger.
  if (debugger_id) {
    // It is debugger specific, grab it and deliver the event if the debugger
    // still exists.
    DebuggerSP debugger_sp = FindDebuggerWithID(*debugger_id);
    if (debugger_sp)
      PrivateReportDiagnostic(*debugger_sp, type, std::move(message), true);
    return;
  }
  // The progress event is not debugger specific, iterate over all debuggers
  // and deliver a progress event to each one.
  if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
    std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
    for (const auto &debugger : *g_debugger_list_ptr)
      PrivateReportDiagnostic(*debugger, type, message, false);
  }
};

if (once)
  std::call_once(*once, ReportDiagnosticLambda);
else
  ReportDiagnosticLambda();
1400}

1402void Debugger::ReportWarning(std::string message,
                           llvm::Optional<lldb::user_id_t> debugger_id,
                           std::once_flag *once) {
ReportDiagnosticImpl(DiagnosticEventData::Type::Warning, std::move(message),
                     debugger_id, once);
1407}

1409void Debugger::ReportError(std::string message,
                         llvm::Optional<lldb::user_id_t> debugger_id,
                         std::once_flag *once) {

ReportDiagnosticImpl(DiagnosticEventData::Type::Error, std::move(message),
                     debugger_id, once);
1415}

1417void Debugger::ReportSymbolChange(const ModuleSpec &module_spec) {
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
  std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
  for (DebuggerSP debugger_sp : *g_debugger_list_ptr) {
    EventSP event_sp = std::make_shared<Event>(
        Debugger::eBroadcastSymbolChange,
        new SymbolChangeEventData(debugger_sp, module_spec));
    debugger_sp->GetBroadcaster().BroadcastEvent(event_sp);
  }
}
1427}

1429static std::shared_ptr<LogHandler>
1430CreateLogHandler(LogHandlerKind log_handler_kind, int fd, bool should_close,
               size_t buffer_size) {
switch (log_handler_kind) {
case eLogHandlerStream:
  return std::make_shared<StreamLogHandler>(fd, should_close, buffer_size);
case eLogHandlerCircular:
  return std::make_shared<RotatingLogHandler>(buffer_size);
case eLogHandlerSystem:
  return std::make_shared<SystemLogHandler>();
case eLogHandlerCallback:
  return {};
}
return {};
1443}

1445bool Debugger::EnableLog(llvm::StringRef channel,
                       llvm::ArrayRef<const char *> categories,
                       llvm::StringRef log_file, uint32_t log_options,
                       size_t buffer_size, LogHandlerKind log_handler_kind,
                       llvm::raw_ostream &error_stream) {

std::shared_ptr<LogHandler> log_handler_sp;
if (m_callback_handler_sp) {
  log_handler_sp = m_callback_handler_sp;
  // For now when using the callback mode you always get thread & timestamp.
  log_options |=
      LLDB_LOG_OPTION_PREPEND_TIMESTAMP(1u << 4) | LLDB_LOG_OPTION_PREPEND_THREAD_NAME(1U << 6);
} else if (log_file.empty()) {
  log_handler_sp =
      CreateLogHandler(log_handler_kind, GetOutputFile().GetDescriptor(),
                       /*should_close=*/false, buffer_size);
} else {
  auto pos = m_stream_handlers.find(log_file);
  if (pos != m_stream_handlers.end())
    log_handler_sp = pos->second.lock();
  if (!log_handler_sp) {
    File::OpenOptions flags =
        File::eOpenOptionWriteOnly | File::eOpenOptionCanCreate;
    if (log_options & LLDB_LOG_OPTION_APPEND(1U << 8))
      flags |= File::eOpenOptionAppend;
    else
      flags |= File::eOpenOptionTruncate;
    llvm::Expected<FileUP> file = FileSystem::Instance().Open(
        FileSpec(log_file), flags, lldb::eFilePermissionsFileDefault, false);
    if (!file) {
      error_stream << "Unable to open log file '" << log_file
                   << "': " << llvm::toString(file.takeError()) << "\n";
      return false;
    }

    log_handler_sp =
        CreateLogHandler(log_handler_kind, (*file)->GetDescriptor(),
                         /*should_close=*/true, buffer_size);
    m_stream_handlers[log_file] = log_handler_sp;
  }
}
assert(log_handler_sp)(static_cast <bool> (log_handler_sp) ? void (0) : __assert_fail
 ("log_handler_sp", "lldb/source/Core/Debugger.cpp", 1486, __extension__
 __PRETTY_FUNCTION__));

if (log_options == 0)
  log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME(1U << 6);

return Log::EnableLogChannel(log_handler_sp, log_options, channel, categories,
                             error_stream);
1493}

1495ScriptInterpreter *
1496Debugger::GetScriptInterpreter(bool can_create,
                             llvm::Optional<lldb::ScriptLanguage> language) {
std::lock_guard<std::recursive_mutex> locker(m_script_interpreter_mutex);
lldb::ScriptLanguage script_language =
    language ? *language : GetScriptLanguage();

if (!m_script_interpreters[script_language]) {
  if (!can_create)
    return nullptr;
  m_script_interpreters[script_language] =
      PluginManager::GetScriptInterpreterForLanguage(script_language, *this);
}

return m_script_interpreters[script_language].get();
1510}

1512SourceManager &Debugger::GetSourceManager() {
if (!m_source_manager_up)
  m_source_manager_up = std::make_unique<SourceManager>(shared_from_this());
return *m_source_manager_up;
1516}

1518// This function handles events that were broadcast by the process.
1519void Debugger::HandleBreakpointEvent(const EventSP &event_sp) {
using namespace lldb;
const uint32_t event_type =
    Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
        event_sp);

//    if (event_type & eBreakpointEventTypeAdded
//        || event_type & eBreakpointEventTypeRemoved
//        || event_type & eBreakpointEventTypeEnabled
//        || event_type & eBreakpointEventTypeDisabled
//        || event_type & eBreakpointEventTypeCommandChanged
//        || event_type & eBreakpointEventTypeConditionChanged
//        || event_type & eBreakpointEventTypeIgnoreChanged
//        || event_type & eBreakpointEventTypeLocationsResolved)
//    {
//        // Don't do anything about these events, since the breakpoint
//        commands already echo these actions.
//    }
//
if (event_type & eBreakpointEventTypeLocationsAdded) {
  uint32_t num_new_locations =
      Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
          event_sp);
  if (num_new_locations > 0) {
    BreakpointSP breakpoint =
        Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event_sp);
    StreamSP output_sp(GetAsyncOutputStream());
    if (output_sp) {
      output_sp->Printf("%d location%s added to breakpoint %d\n",
                        num_new_locations, num_new_locations == 1 ? "" : "s",
                        breakpoint->GetID());
      output_sp->Flush();
    }
  }
}
//    else if (event_type & eBreakpointEventTypeLocationsRemoved)
//    {
//        // These locations just get disabled, not sure it is worth spamming
//        folks about this on the command line.
//    }
//    else if (event_type & eBreakpointEventTypeLocationsResolved)
//    {
//        // This might be an interesting thing to note, but I'm going to
//        leave it quiet for now, it just looked noisy.
//    }
1564}

1566void Debugger::FlushProcessOutput(Process &process, bool flush_stdout,
                                bool flush_stderr) {
const auto &flush = [&](Stream &stream,
                        size_t (Process::*get)(char *, size_t, Status &)) {
  Status error;
  size_t len;
  char buffer[1024];
  while ((len = (process.*get)(buffer, sizeof(buffer), error)) > 0)
    stream.Write(buffer, len);
  stream.Flush();
};

std::lock_guard<std::mutex> guard(m_output_flush_mutex);
if (flush_stdout)
  flush(*GetAsyncOutputStream(), &Process::GetSTDOUT);
if (flush_stderr)
  flush(*GetAsyncErrorStream(), &Process::GetSTDERR);
1583}

1585// This function handles events that were broadcast by the process.
1586void Debugger::HandleProcessEvent(const EventSP &event_sp) {
using namespace lldb;
const uint32_t event_type = event_sp->GetType();
ProcessSP process_sp =
    (event_type == Process::eBroadcastBitStructuredData)
        ? EventDataStructuredData::GetProcessFromEvent(event_sp.get())
        : Process::ProcessEventData::GetProcessFromEvent(event_sp.get());

StreamSP output_stream_sp = GetAsyncOutputStream();
StreamSP error_stream_sp = GetAsyncErrorStream();
const bool gui_enabled = IsForwardingEvents();

if (!gui_enabled) {
  bool pop_process_io_handler = false;
  assert(process_sp)(static_cast <bool> (process_sp) ? void (0) : __assert_fail
 ("process_sp", "lldb/source/Core/Debugger.cpp", 1600, __extension__
 __PRETTY_FUNCTION__));

  bool state_is_stopped = false;
  const bool got_state_changed =
      (event_type & Process::eBroadcastBitStateChanged) != 0;
  const bool got_stdout = (event_type & Process::eBroadcastBitSTDOUT) != 0;
  const bool got_stderr = (event_type & Process::eBroadcastBitSTDERR) != 0;
  const bool got_structured_data =
      (event_type & Process::eBroadcastBitStructuredData) != 0;

  if (got_state_changed) {
    StateType event_state =
        Process::ProcessEventData::GetStateFromEvent(event_sp.get());
    state_is_stopped = StateIsStoppedState(event_state, false);
  }

  // Display running state changes first before any STDIO
  if (got_state_changed && !state_is_stopped) {
    Process::HandleProcessStateChangedEvent(event_sp, output_stream_sp.get(),
                                            pop_process_io_handler);
  }

  // Now display STDOUT and STDERR
  FlushProcessOutput(*process_sp, got_stdout || got_state_changed,
                     got_stderr || got_state_changed);

  // Give structured data events an opportunity to display.
  if (got_structured_data) {
    StructuredDataPluginSP plugin_sp =
        EventDataStructuredData::GetPluginFromEvent(event_sp.get());
    if (plugin_sp) {
      auto structured_data_sp =
          EventDataStructuredData::GetObjectFromEvent(event_sp.get());
      if (output_stream_sp) {
        StreamString content_stream;
        Status error =
            plugin_sp->GetDescription(structured_data_sp, content_stream);
        if (error.Success()) {
          if (!content_stream.GetString().empty()) {
            // Add newline.
            content_stream.PutChar('\n');
            content_stream.Flush();

            // Print it.
            output_stream_sp->PutCString(content_stream.GetString());
          }
        } else {
          error_stream_sp->Format("Failed to print structured "
                                  "data with plugin {0}: {1}",
                                  plugin_sp->GetPluginName(), error);
        }
      }
    }
  }

  // Now display any stopped state changes after any STDIO
  if (got_state_changed && state_is_stopped) {
    Process::HandleProcessStateChangedEvent(event_sp, output_stream_sp.get(),
                                            pop_process_io_handler);
  }

  output_stream_sp->Flush();
  error_stream_sp->Flush();

  if (pop_process_io_handler)
    process_sp->PopProcessIOHandler();
}
1667}

1669void Debugger::HandleThreadEvent(const EventSP &event_sp) {
// At present the only thread event we handle is the Frame Changed event, and
// all we do for that is just reprint the thread status for that thread.
using namespace lldb;
const uint32_t event_type = event_sp->GetType();
const bool stop_format = true;
if (event_type == Thread::eBroadcastBitStackChanged ||
    event_type == Thread::eBroadcastBitThreadSelected) {
  ThreadSP thread_sp(
      Thread::ThreadEventData::GetThreadFromEvent(event_sp.get()));
  if (thread_sp) {
    thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1, stop_format);
  }
}
1683}

1685bool Debugger::IsForwardingEvents() { return (bool)m_forward_listener_sp; }

1687void Debugger::EnableForwardEvents(const ListenerSP &listener_sp) {
m_forward_listener_sp = listener_sp;
1689}

1691void Debugger::CancelForwardEvents(const ListenerSP &listener_sp) {
m_forward_listener_sp.reset();
1693}

1695lldb::thread_result_t Debugger::DefaultEventHandler() {
ListenerSP listener_sp(GetListener());
ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass());
ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass());
ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass());
BroadcastEventSpec target_event_spec(broadcaster_class_target,
                                     Target::eBroadcastBitBreakpointChanged);

BroadcastEventSpec process_event_spec(
    broadcaster_class_process,
    Process::eBroadcastBitStateChanged | Process::eBroadcastBitSTDOUT |
        Process::eBroadcastBitSTDERR | Process::eBroadcastBitStructuredData);

BroadcastEventSpec thread_event_spec(broadcaster_class_thread,
                                     Thread::eBroadcastBitStackChanged |
                                         Thread::eBroadcastBitThreadSelected);

listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
                                        target_event_spec);
listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
                                        process_event_spec);
listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
                                        thread_event_spec);
listener_sp->StartListeningForEvents(
    m_command_interpreter_up.get(),
    CommandInterpreter::eBroadcastBitQuitCommandReceived |
        CommandInterpreter::eBroadcastBitAsynchronousOutputData |
        CommandInterpreter::eBroadcastBitAsynchronousErrorData);

listener_sp->StartListeningForEvents(
    &m_broadcaster, eBroadcastBitProgress | eBroadcastBitWarning |
                        eBroadcastBitError | eBroadcastSymbolChange);

// Let the thread that spawned us know that we have started up and that we
// are now listening to all required events so no events get missed
m_sync_broadcaster.BroadcastEvent(eBroadcastBitEventThreadIsListening);

bool done = false;
while (!done) {
  EventSP event_sp;
  if (listener_sp->GetEvent(event_sp, llvm::None)) {
    if (event_sp) {
      Broadcaster *broadcaster = event_sp->GetBroadcaster();
      if (broadcaster) {
        uint32_t event_type = event_sp->GetType();
        ConstString broadcaster_class(broadcaster->GetBroadcasterClass());
        if (broadcaster_class == broadcaster_class_process) {
          HandleProcessEvent(event_sp);
        } else if (broadcaster_class == broadcaster_class_target) {
          if (Breakpoint::BreakpointEventData::GetEventDataFromEvent(
                  event_sp.get())) {
            HandleBreakpointEvent(event_sp);
          }
        } else if (broadcaster_class == broadcaster_class_thread) {
          HandleThreadEvent(event_sp);
        } else if (broadcaster == m_command_interpreter_up.get()) {
          if (event_type &
              CommandInterpreter::eBroadcastBitQuitCommandReceived) {
            done = true;
          } else if (event_type &
                     CommandInterpreter::eBroadcastBitAsynchronousErrorData) {
            const char *data = static_cast<const char *>(
                EventDataBytes::GetBytesFromEvent(event_sp.get()));
            if (data && data[0]) {
              StreamSP error_sp(GetAsyncErrorStream());
              if (error_sp) {
                error_sp->PutCString(data);
                error_sp->Flush();
              }
            }
          } else if (event_type & CommandInterpreter::
                                      eBroadcastBitAsynchronousOutputData) {
            const char *data = static_cast<const char *>(
                EventDataBytes::GetBytesFromEvent(event_sp.get()));
            if (data && data[0]) {
              StreamSP output_sp(GetAsyncOutputStream());
              if (output_sp) {
                output_sp->PutCString(data);
                output_sp->Flush();
              }
            }
          }
        } else if (broadcaster == &m_broadcaster) {
          if (event_type & Debugger::eBroadcastBitProgress)
            HandleProgressEvent(event_sp);
          else if (event_type & Debugger::eBroadcastBitWarning)
            HandleDiagnosticEvent(event_sp);
          else if (event_type & Debugger::eBroadcastBitError)
            HandleDiagnosticEvent(event_sp);
        }
      }

      if (m_forward_listener_sp)
        m_forward_listener_sp->AddEvent(event_sp);
    }
  }
}
return {};
1793}

1795bool Debugger::StartEventHandlerThread() {
if (!m_event_handler_thread.IsJoinable()) {
  // We must synchronize with the DefaultEventHandler() thread to ensure it
  // is up and running and listening to events before we return from this
  // function. We do this by listening to events for the
  // eBroadcastBitEventThreadIsListening from the m_sync_broadcaster
  ConstString full_name("lldb.debugger.event-handler");
  ListenerSP listener_sp(Listener::MakeListener(full_name.AsCString()));
  listener_sp->StartListeningForEvents(&m_sync_broadcaster,
                                       eBroadcastBitEventThreadIsListening);

  llvm::StringRef thread_name =
      full_name.GetLength() < llvm::get_max_thread_name_length()
          ? full_name.GetStringRef()
          : "dbg.evt-handler";

  // Use larger 8MB stack for this thread
  llvm::Expected<HostThread> event_handler_thread =
      ThreadLauncher::LaunchThread(
          thread_name, [this] { return DefaultEventHandler(); },
          g_debugger_event_thread_stack_bytes);

  if (event_handler_thread) {
    m_event_handler_thread = *event_handler_thread;
  } else {
    LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",do { ::lldb_private::Log *log_private = (GetLog(LLDBLog::Host
)); if (log_private) log_private->Format("lldb/source/Core/Debugger.cpp"
, __func__, "failed to launch host thread: {}", llvm::toString
(event_handler_thread.takeError())); } while (0)
             llvm::toString(event_handler_thread.takeError()))do { ::lldb_private::Log *log_private = (GetLog(LLDBLog::Host
)); if (log_private) log_private->Format("lldb/source/Core/Debugger.cpp"
, __func__, "failed to launch host thread: {}", llvm::toString
(event_handler_thread.takeError())); } while (0);
  }

  // Make sure DefaultEventHandler() is running and listening to events
  // before we return from this function. We are only listening for events of
  // type eBroadcastBitEventThreadIsListening so we don't need to check the
  // event, we just need to wait an infinite amount of time for it (nullptr
  // timeout as the first parameter)
  lldb::EventSP event_sp;
  listener_sp->GetEvent(event_sp, llvm::None);
}
return m_event_handler_thread.IsJoinable();
1833}

1835void Debugger::StopEventHandlerThread() {
if (m_event_handler_thread.IsJoinable()) {
  GetCommandInterpreter().BroadcastEvent(
      CommandInterpreter::eBroadcastBitQuitCommandReceived);
  m_event_handler_thread.Join(nullptr);
}
1841}

1843lldb::thread_result_t Debugger::IOHandlerThread() {
RunIOHandlers();
StopEventHandlerThread();
return {};
1847}

1849void Debugger::HandleProgressEvent(const lldb::EventSP &event_sp) {
auto *data = ProgressEventData::GetEventDataFromEvent(event_sp.get());
if (!data)
  return;

// Do some bookkeeping for the current event, regardless of whether we're
// going to show the progress.
const uint64_t id = data->GetID();
if (m_current_event_id) {
  Log *log = GetLog(LLDBLog::Events);
  if (log && log->GetVerbose()) {
    StreamString log_stream;
    log_stream.AsRawOstream()
        << static_cast<void *>(this) << " Debugger(" << GetID()
        << ")::HandleProgressEvent( m_current_event_id = "
        << *m_current_event_id << ", data = { ";
    data->Dump(&log_stream);
    log_stream << " } )";
    log->PutString(log_stream.GetString());
  }
  if (id != *m_current_event_id)
    return;
  if (data->GetCompleted() == data->GetTotal())
    m_current_event_id.reset();
} else {
  m_current_event_id = id;
}

// Decide whether we actually are going to show the progress. This decision
// can change between iterations so check it inside the loop.
if (!GetShowProgress())
  return;

// Determine whether the current output file is an interactive terminal with
// color support. We assume that if we support ANSI escape codes we support
// vt100 escape codes.
File &file = GetOutputFile();
if (!file.GetIsInteractive() || !file.GetIsTerminalWithColors())
  return;

StreamSP output = GetAsyncOutputStream();

// Print over previous line, if any.
output->Printf("\r");

if (data->GetCompleted() == data->GetTotal()) {
  // Clear the current line.
  output->Printf("\x1B[2K");
  output->Flush();
  return;
}

// Trim the progress message if it exceeds the window's width and print it.
std::string message = data->GetMessage();
if (data->IsFinite())
  message = llvm::formatv("[{0}/{1}] {2}", data->GetCompleted(),
                          data->GetTotal(), message)
                .str();

// Trim the progress message if it exceeds the window's width and print it.
const uint32_t term_width = GetTerminalWidth();
const uint32_t ellipsis = 3;
if (message.size() + ellipsis >= term_width)
  message = message.substr(0, term_width - ellipsis);

const bool use_color = GetUseColor();
llvm::StringRef ansi_prefix = GetShowProgressAnsiPrefix();
if (!ansi_prefix.empty())
  output->Printf(
      "%s", ansi::FormatAnsiTerminalCodes(ansi_prefix, use_color).c_str());

output->Printf("%s...", message.c_str());

llvm::StringRef ansi_suffix = GetShowProgressAnsiSuffix();
if (!ansi_suffix.empty())
  output->Printf(
      "%s", ansi::FormatAnsiTerminalCodes(ansi_suffix, use_color).c_str());

// Clear until the end of the line.
output->Printf("\x1B[K\r");

// Flush the output.
output->Flush();
1932}

1934void Debugger::HandleDiagnosticEvent(const lldb::EventSP &event_sp) {
auto *data = DiagnosticEventData::GetEventDataFromEvent(event_sp.get());
if (!data)
  return;

StreamSP stream = GetAsyncErrorStream();
data->Dump(stream.get());
1941}

1943bool Debugger::HasIOHandlerThread() { return m_io_handler_thread.IsJoinable(); }

1945bool Debugger::StartIOHandlerThread() {
if (!m_io_handler_thread.IsJoinable()) {
  llvm::Expected<HostThread> io_handler_thread = ThreadLauncher::LaunchThread(
      "lldb.debugger.io-handler", [this] { return IOHandlerThread(); },
      8 * 1024 * 1024); // Use larger 8MB stack for this thread
  if (io_handler_thread) {
    m_io_handler_thread = *io_handler_thread;
  } else {
    LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",do { ::lldb_private::Log *log_private = (GetLog(LLDBLog::Host
)); if (log_private) log_private->Format("lldb/source/Core/Debugger.cpp"
, __func__, "failed to launch host thread: {}", llvm::toString
(io_handler_thread.takeError())); } while (0)
             llvm::toString(io_handler_thread.takeError()))do { ::lldb_private::Log *log_private = (GetLog(LLDBLog::Host
)); if (log_private) log_private->Format("lldb/source/Core/Debugger.cpp"
, __func__, "failed to launch host thread: {}", llvm::toString
(io_handler_thread.takeError())); } while (0);
  }
}
return m_io_handler_thread.IsJoinable();
1958}

1960void Debugger::StopIOHandlerThread() {
if (m_io_handler_thread.IsJoinable()) {
  GetInputFile().Close();
  m_io_handler_thread.Join(nullptr);
}
1965}

1967void Debugger::JoinIOHandlerThread() {
if (HasIOHandlerThread()) {
  thread_result_t result;
  m_io_handler_thread.Join(&result);
  m_io_handler_thread = LLDB_INVALID_HOST_THREAD((lldb::thread_t)__null);
}
1973}

1975Target &Debugger::GetSelectedOrDummyTarget(bool prefer_dummy) {
if (!prefer_dummy) {
  if (TargetSP target = m_target_list.GetSelectedTarget())
    return *target;
}
return GetDummyTarget();
1981}

1983Status Debugger::RunREPL(LanguageType language, const char *repl_options) {
Status err;
FileSpec repl_executable;

if (language == eLanguageTypeUnknown)
  language = GetREPLLanguage();

if (language == eLanguageTypeUnknown) {
  LanguageSet repl_languages = Language::GetLanguagesSupportingREPLs();

  if (auto single_lang = repl_languages.GetSingularLanguage()) {
    language = *single_lang;
  } else if (repl_languages.Empty()) {
    err.SetErrorString(
        "LLDB isn't configured with REPL support for any languages.");
    return err;
  } else {
    err.SetErrorString(
        "Multiple possible REPL languages.  Please specify a language.");
    return err;
  }
}

Target *const target =
    nullptr; // passing in an empty target means the REPL must create one

REPLSP repl_sp(REPL::Create(err, language, this, target, repl_options));

if (!err.Success()) {
  return err;
}

if (!repl_sp) {
  err.SetErrorStringWithFormat("couldn't find a REPL for %s",
                               Language::GetNameForLanguageType(language));
  return err;
}

repl_sp->SetCompilerOptions(repl_options);
repl_sp->RunLoop();

return err;
2025}

2027llvm::ThreadPool &Debugger::GetThreadPool() {
assert(g_thread_pool &&(static_cast <bool> (g_thread_pool && "Debugger::GetThreadPool called before Debugger::Initialize"
) ? void (0) : __assert_fail ("g_thread_pool && \"Debugger::GetThreadPool called before Debugger::Initialize\""
, "lldb/source/Core/Debugger.cpp", 2029, __extension__ __PRETTY_FUNCTION__
))
       "Debugger::GetThreadPool called before Debugger::Initialize")(static_cast <bool> (g_thread_pool && "Debugger::GetThreadPool called before Debugger::Initialize"
) ? void (0) : __assert_fail ("g_thread_pool && \"Debugger::GetThreadPool called before Debugger::Initialize\""
, "lldb/source/Core/Debugger.cpp", 2029, __extension__ __PRETTY_FUNCTION__
));
return *g_thread_pool;
2031}

←

/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)...)
19
←
Calling constructor for '__shared_ptr<lldb_private::NativeFile, __gnu_cxx::_S_atomic>'→
31
←
Returning from constructor for '__shared_ptr<lldb_private::NativeFile, __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},
18
←
Calling constructor for 'shared_ptr<lldb_private::NativeFile>'→
32
←
Returning from constructor for 'shared_ptr<lldb_private::NativeFile>'→
	     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>(),
17
←
Calling 'allocate_shared<lldb_private::NativeFile, std::allocator<lldb_private::NativeFile>, _IO_FILE *&, bool>'→
33
←
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);
21
←
Calling '__allocate_guarded<std::allocator<std::_Sp_counted_ptr_inplace<lldb_private::NativeFile, std::allocator<lldb_private::NativeFile>, __gnu_cxx::_S_atomic>>>'→
29
←
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);
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);
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);
__glibcxx_assert(!extent<_Tp>::value || __i < extent<_Tp>::value);
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);
 __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)...)
20
←
Calling constructor for '__shared_count<__gnu_cxx::_S_atomic>'→
30
←
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) };
22
←
Calling 'allocator_traits::allocate'→
28
←
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); }
23
←
Calling 'new_allocator::allocate'→
27
←
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())
24
←
Taking false branch→
106	  std::__throw_bad_alloc();
107 
108#if __cpp_aligned_new201606L
109	if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__16UL)
25
←
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)));
26
←
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