/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Commands/CommandObjectType.cpp

Bug Summary

File:	tools/lldb/source/Commands/CommandObjectType.cpp
Warning:	line 67, column 29 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CommandObjectType.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D LLDB_USE_BUILTIN_DEMANGLER -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/source/Commands -I /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Commands -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/source/Commands -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Commands/CommandObjectType.cpp

/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Commands/CommandObjectType.cpp

→

1//===-- CommandObjectType.cpp -----------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#include "CommandObjectType.h"

12// C Includes
13// C++ Includes
14#include <algorithm>
15#include <cctype>
16#include <functional>

18// Project includes
19#include "lldb/Core/Debugger.h"
20#include "lldb/Core/IOHandler.h"
21#include "lldb/Core/State.h"
22#include "lldb/DataFormatters/DataVisualization.h"
23#include "lldb/Host/OptionParser.h"
24#include "lldb/Interpreter/CommandInterpreter.h"
25#include "lldb/Interpreter/CommandObject.h"
26#include "lldb/Interpreter/CommandReturnObject.h"
27#include "lldb/Interpreter/OptionGroupFormat.h"
28#include "lldb/Interpreter/OptionValueBoolean.h"
29#include "lldb/Interpreter/OptionValueLanguage.h"
30#include "lldb/Interpreter/OptionValueString.h"
31#include "lldb/Interpreter/Options.h"
32#include "lldb/Symbol/Symbol.h"
33#include "lldb/Target/Language.h"
34#include "lldb/Target/Process.h"
35#include "lldb/Target/StackFrame.h"
36#include "lldb/Target/Target.h"
37#include "lldb/Target/Thread.h"
38#include "lldb/Target/ThreadList.h"
39#include "lldb/Utility/ConstString.h"
40#include "lldb/Utility/RegularExpression.h"
41#include "lldb/Utility/StringList.h"

43// Other libraries and framework includes
44#include "llvm/ADT/STLExtras.h"

46using namespace lldb;
47using namespace lldb_private;

49class ScriptAddOptions {
50public:
TypeSummaryImpl::Flags m_flags;
StringList m_target_types;
bool m_regex;
ConstString m_name;
std::string m_category;

ScriptAddOptions(const TypeSummaryImpl::Flags &flags, bool regx,
                 const ConstString &name, std::string catg)
    : m_flags(flags), m_regex(regx), m_name(name), m_category(catg) {}

typedef std::shared_ptr<ScriptAddOptions> SharedPointer;
62};

64class SynthAddOptions {
65public:
bool m_skip_pointers;
bool m_skip_references;
bool m_cascade;
bool m_regex;
StringList m_target_types;
std::string m_category;

SynthAddOptions(bool sptr, bool sref, bool casc, bool regx, std::string catg)
    : m_skip_pointers(sptr), m_skip_references(sref), m_cascade(casc),
      m_regex(regx), m_target_types(), m_category(catg) {}

typedef std::shared_ptr<SynthAddOptions> SharedPointer;
78};

80static bool WarnOnPotentialUnquotedUnsignedType(Args &command,
                                              CommandReturnObject &result) {
if (command.empty())
  return false;

for (auto entry : llvm::enumerate(command.entries().drop_back())) {
  if (entry.value().ref != "unsigned")
    continue;
  auto next = command.entries()[entry.index() + 1].ref;
  if (next == "int" || next == "short" || next == "char" || next == "long") {
    result.AppendWarningWithFormat(
        "unsigned %s being treated as two types. if you meant the combined "
        "type "
        "name use  quotes, as in \"unsigned %s\"\n",
        next.str().c_str(), next.str().c_str());
    return true;
  }
}
return false;
99}

101static OptionDefinition g_type_summary_add_options[] = {
  // clang-format off
{ LLDB_OPT_SET_ALL0xFFFFFFFFU,                false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,           "Add this to the given category instead of the default one." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU,                false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,        "If true, cascade through typedef chains." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU,                false, "no-value",        'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't show the value, just show the summary, for this type." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU,                false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for pointers-to-type objects." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU,                false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for references-to-type objects." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU,                false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Type names are actually regular expressions." },
{ LLDB_OPT_SET_1(1U << 0),                  true,  "inline-children", 'c', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "If true, inline all child values into summary string." },
{ LLDB_OPT_SET_1(1U << 0),                  false, "omit-names",      'O', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "If true, omit value names in the summary display." },
{ LLDB_OPT_SET_2(1U << 1),                  true,  "summary-string",  's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeSummaryString,  "Summary string used to display text and object contents." },
{ LLDB_OPT_SET_3(1U << 2),                  false, "python-script",   'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonScript,   "Give a one-liner Python script as part of the command." },
{ LLDB_OPT_SET_3(1U << 2),                  false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonFunction, "Give the name of a Python function to use for this type." },
{ LLDB_OPT_SET_3(1U << 2),                  false, "input-python",    'P', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Input Python code to use for this type manually." },
{ LLDB_OPT_SET_2(1U << 1) | LLDB_OPT_SET_3(1U << 2), false, "expand",          'e', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Expand aggregate data types to show children on separate lines." },
{ LLDB_OPT_SET_2(1U << 1) | LLDB_OPT_SET_3(1U << 2), false, "hide-empty",      'h', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Do not expand aggregate data types with no children." },
{ LLDB_OPT_SET_2(1U << 1) | LLDB_OPT_SET_3(1U << 2), false, "name",            'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,           "A name for this summary string." }
  // clang-format on
119};

121class CommandObjectTypeSummaryAdd : public CommandObjectParsed,
                                  public IOHandlerDelegateMultiline {
123private:
class CommandOptions : public Options {
public:
  CommandOptions(CommandInterpreter &interpreter) : Options() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override;

  void OptionParsingStarting(ExecutionContext *execution_context) override;

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_summary_add_options);
  }

  // Instance variables to hold the values for command options.

  TypeSummaryImpl::Flags m_flags;
  bool m_regex;
  std::string m_format_string;
  ConstString m_name;
  std::string m_python_script;
  std::string m_python_function;
  bool m_is_add_script;
  std::string m_category;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

bool Execute_ScriptSummary(Args &command, CommandReturnObject &result);

bool Execute_StringSummary(Args &command, CommandReturnObject &result);

159public:
enum SummaryFormatType { eRegularSummary, eRegexSummary, eNamedSummary };

CommandObjectTypeSummaryAdd(CommandInterpreter &interpreter);

~CommandObjectTypeSummaryAdd() override = default;

void IOHandlerActivated(IOHandler &io_handler) override {
  static const char *g_summary_addreader_instructions =
      "Enter your Python command(s). Type 'DONE' to end.\n"
      "def function (valobj,internal_dict):\n"
      "     \"\"\"valobj: an SBValue which you want to provide a summary "
      "for\n"
      "        internal_dict: an LLDB support object not to be used\"\"\"\n";

  StreamFileSP output_sp(io_handler.GetOutputStreamFile());
  if (output_sp) {
    output_sp->PutCString(g_summary_addreader_instructions);
    output_sp->Flush();
  }
}

void IOHandlerInputComplete(IOHandler &io_handler,
                            std::string &data) override {
  StreamFileSP error_sp = io_handler.GetErrorStreamFile();

185#ifndef LLDB_DISABLE_PYTHON
  ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
  if (interpreter) {
    StringList lines;
    lines.SplitIntoLines(data);
    if (lines.GetSize() > 0) {
      ScriptAddOptions *options_ptr =
          ((ScriptAddOptions *)io_handler.GetUserData());
      if (options_ptr) {
        ScriptAddOptions::SharedPointer options(
            options_ptr); // this will ensure that we get rid of the pointer
                          // when going out of scope

        ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
        if (interpreter) {
          std::string funct_name_str;
          if (interpreter->GenerateTypeScriptFunction(lines,
                                                      funct_name_str)) {
            if (funct_name_str.empty()) {
              error_sp->Printf("unable to obtain a valid function name from "
                               "the script interpreter.\n");
              error_sp->Flush();
            } else {
              // now I have a valid function name, let's add this as script
              // for every type in the list

              TypeSummaryImplSP script_format;
              script_format.reset(new ScriptSummaryFormat(
                  options->m_flags, funct_name_str.c_str(),
                  lines.CopyList("    ").c_str()));

              Status error;

              for (size_t i = 0; i < options->m_target_types.GetSize(); i++) {
                const char *type_name =
                    options->m_target_types.GetStringAtIndex(i);
                CommandObjectTypeSummaryAdd::AddSummary(
                    ConstString(type_name), script_format,
                    (options->m_regex
                         ? CommandObjectTypeSummaryAdd::eRegexSummary
                         : CommandObjectTypeSummaryAdd::eRegularSummary),
                    options->m_category, &error);
                if (error.Fail()) {
                  error_sp->Printf("error: %s", error.AsCString());
                  error_sp->Flush();
                }
              }

              if (options->m_name) {
                CommandObjectTypeSummaryAdd::AddSummary(
                    options->m_name, script_format,
                    CommandObjectTypeSummaryAdd::eNamedSummary,
                    options->m_category, &error);
                if (error.Fail()) {
                  CommandObjectTypeSummaryAdd::AddSummary(
                      options->m_name, script_format,
                      CommandObjectTypeSummaryAdd::eNamedSummary,
                      options->m_category, &error);
                  if (error.Fail()) {
                    error_sp->Printf("error: %s", error.AsCString());
                    error_sp->Flush();
                  }
                } else {
                  error_sp->Printf("error: %s", error.AsCString());
                  error_sp->Flush();
                }
              } else {
                if (error.AsCString()) {
                  error_sp->Printf("error: %s", error.AsCString());
                  error_sp->Flush();
                }
              }
            }
          } else {
            error_sp->Printf("error: unable to generate a function.\n");
            error_sp->Flush();
          }
        } else {
          error_sp->Printf("error: no script interpreter.\n");
          error_sp->Flush();
        }
      } else {
        error_sp->Printf("error: internal synchronization information "
                         "missing or invalid.\n");
        error_sp->Flush();
      }
    } else {
      error_sp->Printf("error: empty function, didn't add python command.\n");
      error_sp->Flush();
    }
  } else {
    error_sp->Printf(
        "error: script interpreter missing, didn't add python command.\n");
    error_sp->Flush();
  }
280#endif // LLDB_DISABLE_PYTHON
  io_handler.SetIsDone(true);
}

static bool AddSummary(ConstString type_name, lldb::TypeSummaryImplSP entry,
                       SummaryFormatType type, std::string category,
                       Status *error = nullptr);

288protected:
bool DoExecute(Args &command, CommandReturnObject &result) override;
290};

292static const char *g_synth_addreader_instructions =
  "Enter your Python command(s). Type 'DONE' to end.\n"
  "You must define a Python class with these methods:\n"
  "    def __init__(self, valobj, dict):\n"
  "    def num_children(self):\n"
  "    def get_child_at_index(self, index):\n"
  "    def get_child_index(self, name):\n"
  "    def update(self):\n"
  "        '''Optional'''\n"
  "class synthProvider:\n";

303static OptionDefinition g_type_synth_add_options[] = {
  // clang-format off
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,     "If true, cascade through typedef chains." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Don't use this format for pointers-to-type objects." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Don't use this format for references-to-type objects." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,        "Add this to the given category instead of the default one." },
{ LLDB_OPT_SET_2(1U << 1),   false, "python-class",    'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonClass, "Use this Python class to produce synthetic children." },
{ LLDB_OPT_SET_3(1U << 2),   false, "input-python",    'P', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Type Python code to generate a class that provides synthetic children." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Type names are actually regular expressions." }
  // clang-format on
313};

315class CommandObjectTypeSynthAdd : public CommandObjectParsed,
                                public IOHandlerDelegateMultiline {
317private:
class CommandOptions : public Options {
public:
  CommandOptions() : Options() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;
    bool success;

    switch (short_option) {
    case 'C':
      m_cascade = Args::StringToBoolean(option_arg, true, &success);
      if (!success)
        error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                       option_arg.str().c_str());
      break;
    case 'P':
      handwrite_python = true;
      break;
    case 'l':
      m_class_name = std::string(option_arg);
      is_class_based = true;
      break;
    case 'p':
      m_skip_pointers = true;
      break;
    case 'r':
      m_skip_references = true;
      break;
    case 'w':
      m_category = std::string(option_arg);
      break;
    case 'x':
      m_regex = true;
      break;
    default:
      error.SetErrorStringWithFormat("unrecognized option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_cascade = true;
    m_class_name = "";
    m_skip_pointers = false;
    m_skip_references = false;
    m_category = "default";
    is_class_based = false;
    handwrite_python = false;
    m_regex = false;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_synth_add_options);
  }

  // Instance variables to hold the values for command options.

  bool m_cascade;
  bool m_skip_references;
  bool m_skip_pointers;
  std::string m_class_name;
  bool m_input_python;
  std::string m_category;
  bool is_class_based;
  bool handwrite_python;
  bool m_regex;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

bool Execute_HandwritePython(Args &command, CommandReturnObject &result);

bool Execute_PythonClass(Args &command, CommandReturnObject &result);

401protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  WarnOnPotentialUnquotedUnsignedType(command, result);

  if (m_options.handwrite_python)
    return Execute_HandwritePython(command, result);
  else if (m_options.is_class_based)
    return Execute_PythonClass(command, result);
  else {
    result.AppendError("must either provide a children list, a Python class "
                       "name, or use -P and type a Python class "
                       "line-by-line");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
}

void IOHandlerActivated(IOHandler &io_handler) override {
  StreamFileSP output_sp(io_handler.GetOutputStreamFile());
  if (output_sp) {
    output_sp->PutCString(g_synth_addreader_instructions);
    output_sp->Flush();
  }
}

void IOHandlerInputComplete(IOHandler &io_handler,
                            std::string &data) override {
  StreamFileSP error_sp = io_handler.GetErrorStreamFile();

430#ifndef LLDB_DISABLE_PYTHON
  ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
  if (interpreter) {
    StringList lines;
    lines.SplitIntoLines(data);
    if (lines.GetSize() > 0) {
      SynthAddOptions *options_ptr =
          ((SynthAddOptions *)io_handler.GetUserData());
      if (options_ptr) {
        SynthAddOptions::SharedPointer options(
            options_ptr); // this will ensure that we get rid of the pointer
                          // when going out of scope

        ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
        if (interpreter) {
          std::string class_name_str;
          if (interpreter->GenerateTypeSynthClass(lines, class_name_str)) {
            if (class_name_str.empty()) {
              error_sp->Printf(
                  "error: unable to obtain a proper name for the class.\n");
              error_sp->Flush();
            } else {
              // everything should be fine now, let's add the synth provider
              // class

              SyntheticChildrenSP synth_provider;
              synth_provider.reset(new ScriptedSyntheticChildren(
                  SyntheticChildren::Flags()
                      .SetCascades(options->m_cascade)
                      .SetSkipPointers(options->m_skip_pointers)
                      .SetSkipReferences(options->m_skip_references),
                  class_name_str.c_str()));

              lldb::TypeCategoryImplSP category;
              DataVisualization::Categories::GetCategory(
                  ConstString(options->m_category.c_str()), category);

              Status error;

              for (size_t i = 0; i < options->m_target_types.GetSize(); i++) {
                const char *type_name =
                    options->m_target_types.GetStringAtIndex(i);
                ConstString const_type_name(type_name);
                if (const_type_name) {
                  if (!CommandObjectTypeSynthAdd::AddSynth(
                          const_type_name, synth_provider,
                          options->m_regex
                              ? CommandObjectTypeSynthAdd::eRegexSynth
                              : CommandObjectTypeSynthAdd::eRegularSynth,
                          options->m_category, &error)) {
                    error_sp->Printf("error: %s\n", error.AsCString());
                    error_sp->Flush();
                    break;
                  }
                } else {
                  error_sp->Printf("error: invalid type name.\n");
                  error_sp->Flush();
                  break;
                }
              }
            }
          } else {
            error_sp->Printf("error: unable to generate a class.\n");
            error_sp->Flush();
          }
        } else {
          error_sp->Printf("error: no script interpreter.\n");
          error_sp->Flush();
        }
      } else {
        error_sp->Printf("error: internal synchronization data missing.\n");
        error_sp->Flush();
      }
    } else {
      error_sp->Printf("error: empty function, didn't add python command.\n");
      error_sp->Flush();
    }
  } else {
    error_sp->Printf(
        "error: script interpreter missing, didn't add python command.\n");
    error_sp->Flush();
  }

513#endif // LLDB_DISABLE_PYTHON
  io_handler.SetIsDone(true);
}

517public:
enum SynthFormatType { eRegularSynth, eRegexSynth };

CommandObjectTypeSynthAdd(CommandInterpreter &interpreter);

~CommandObjectTypeSynthAdd() override = default;

static bool AddSynth(ConstString type_name, lldb::SyntheticChildrenSP entry,
                     SynthFormatType type, std::string category_name,
                     Status *error);
527};

529//-------------------------------------------------------------------------
530// CommandObjectTypeFormatAdd
531//-------------------------------------------------------------------------

533static OptionDefinition g_type_format_add_options[] = {
  // clang-format off
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,    "Add this to the given category instead of the default one." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, cascade through typedef chains." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,    "Don't use this format for pointers-to-type objects." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,    "Don't use this format for references-to-type objects." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,    "Type names are actually regular expressions." },
{ LLDB_OPT_SET_2(1U << 1),   false, "type",            't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,    "Format variables as if they were of this type." }
  // clang-format on
542};

544class CommandObjectTypeFormatAdd : public CommandObjectParsed {
545private:
class CommandOptions : public OptionGroup {
public:
  CommandOptions() : OptionGroup() {}

  ~CommandOptions() override = default;

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_format_add_options);
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_cascade = true;
    m_skip_pointers = false;
    m_skip_references = false;
    m_regex = false;
    m_category.assign("default");
    m_custom_type_name.clear();
  }

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option =
        g_type_format_add_options[option_idx].short_option;
    bool success;

    switch (short_option) {
    case 'C':
      m_cascade = Args::StringToBoolean(option_value, true, &success);
      if (!success)
        error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                       option_value.str().c_str());
      break;
    case 'p':
      m_skip_pointers = true;
      break;
    case 'w':
      m_category.assign(option_value);
      break;
    case 'r':
      m_skip_references = true;
      break;
    case 'x':
      m_regex = true;
      break;
    case 't':
      m_custom_type_name.assign(option_value);
      break;
    default:
      error.SetErrorStringWithFormat("unrecognized option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  // Instance variables to hold the values for command options.

  bool m_cascade;
  bool m_skip_references;
  bool m_skip_pointers;
  bool m_regex;
  std::string m_category;
  std::string m_custom_type_name;
};

OptionGroupOptions m_option_group;
OptionGroupFormat m_format_options;
CommandOptions m_command_options;

Options *GetOptions() override { return &m_option_group; }

619public:
CommandObjectTypeFormatAdd(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type format add",
                          "Add a new formatting style for a type.", nullptr),
      m_option_group(), m_format_options(eFormatInvalid),
      m_command_options() {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);

  SetHelpLong(
      R"(
637The following examples of 'type format add' refer to this code snippet for context:

  typedef int Aint;
  typedef float Afloat;
  typedef Aint Bint;
  typedef Afloat Bfloat;

  Aint ix = 5;
  Bint iy = 5;

  Afloat fx = 3.14;
  BFloat fy = 3.14;

650Adding default formatting:

652(lldb) type format add -f hex AInt
653(lldb) frame variable iy

655)"
      "    Produces hexadecimal display of iy, because no formatter is available for Bint and \
657the one for Aint is used instead."
      R"(

660To prevent this use the cascade option '-C no' to prevent evaluation of typedef chains:


663(lldb) type format add -f hex -C no AInt

665Similar reasoning applies to this:

667(lldb) type format add -f hex -C no float -p

669)"
      "    All float values and float references are now formatted as hexadecimal, but not \
671pointers to floats.  Nor will it change the default display for Afloat and Bfloat objects.");

  // Add the "--format" to all options groups
  m_option_group.Append(&m_format_options,
                        OptionGroupFormat::OPTION_GROUP_FORMAT,
                        LLDB_OPT_SET_1(1U << 0));
  m_option_group.Append(&m_command_options);
  m_option_group.Finalize();
}

~CommandObjectTypeFormatAdd() override = default;

683protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1) {
1
Assuming 'argc' is >= 1→
2
←
Taking false branch→
    result.AppendErrorWithFormat("%s takes one or more args.\n",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  const Format format = m_format_options.GetFormat();
  if (format == eFormatInvalid &&
3
←
Assuming 'format' is not equal to eFormatInvalid→
      m_command_options.m_custom_type_name.empty()) {
    result.AppendErrorWithFormat("%s needs a valid format.\n",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  TypeFormatImplSP entry;

  if (m_command_options.m_custom_type_name.empty())
4
←
Assuming the condition is false→
5
←
Taking false branch→
    entry.reset(new TypeFormatImpl_Format(
        format, TypeFormatImpl::Flags()
                    .SetCascades(m_command_options.m_cascade)
                    .SetSkipPointers(m_command_options.m_skip_pointers)
                    .SetSkipReferences(m_command_options.m_skip_references)));
  else
    entry.reset(new TypeFormatImpl_EnumType(
        ConstString(m_command_options.m_custom_type_name.c_str()),
        TypeFormatImpl::Flags()
            .SetCascades(m_command_options.m_cascade)
            .SetSkipPointers(m_command_options.m_skip_pointers)
            .SetSkipReferences(m_command_options.m_skip_references)));

  // now I have a valid format, let's add it to every type

  TypeCategoryImplSP category_sp;
  DataVisualization::Categories::GetCategory(
      ConstString(m_command_options.m_category), category_sp);
  if (!category_sp)
6
←
Taking false branch→
    return false;

  WarnOnPotentialUnquotedUnsignedType(command, result);

  for (auto &arg_entry : command.entries()) {
7
←
Assuming '__begin1' is not equal to '__end1'→
    if (arg_entry.ref.empty()) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
12
←
Assuming the condition is false→
13
←
Taking false branch→
15
←
Assuming the condition is false→
16
←
Taking false branch→
46
←
Assuming the condition is false→
47
←
Taking false branch→
      result.AppendError("empty typenames not allowed");
      result.SetStatus(eReturnStatusFailed);
      return false;
    }

    ConstString typeCS(arg_entry.ref);
    if (m_command_options.m_regex) {
10
←
Assuming the condition is false→
11
←
Taking false branch→
14
←
Taking false branch→
17
←
Taking false branch→
48
←
Taking false branch→
      RegularExpressionSP typeRX(new RegularExpression());
      if (!typeRX->Compile(arg_entry.ref)) {
        result.AppendError(
            "regex format error (maybe this is not really a regex?)");
        result.SetStatus(eReturnStatusFailed);
        return false;
      }
      category_sp->GetRegexTypeSummariesContainer()->Delete(typeCS);
      category_sp->GetRegexTypeFormatsContainer()->Add(typeRX, entry);
    } else
      category_sp->GetTypeFormatsContainer()->Add(typeCS, entry);
18
←
Calling 'FormattersContainer::Add'→
45
←
Returning; memory was released→
49
←
Calling 'FormattersContainer::Add'→
  }

  result.SetStatus(eReturnStatusSuccessFinishNoResult);
  return result.Succeeded();
}
754};

756static OptionDefinition g_type_formatter_delete_options[] = {
  // clang-format off
{ LLDB_OPT_SET_1(1U << 0), false, "all",      'a', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Delete from every category." },
{ LLDB_OPT_SET_2(1U << 1), false, "category", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,     "Delete from given category." },
{ LLDB_OPT_SET_3(1U << 2), false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Delete from given language's category." }
  // clang-format on
762};

764class CommandObjectTypeFormatterDelete : public CommandObjectParsed {
765protected:
class CommandOptions : public Options {
public:
  CommandOptions() : Options() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'a':
      m_delete_all = true;
      break;
    case 'w':
      m_category = std::string(option_arg);
      break;
    case 'l':
      m_language = Language::GetLanguageTypeFromString(option_arg);
      break;
    default:
      error.SetErrorStringWithFormat("unrecognized option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_delete_all = false;
    m_category = "default";
    m_language = lldb::eLanguageTypeUnknown;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_formatter_delete_options);
  }

  // Instance variables to hold the values for command options.

  bool m_delete_all;
  std::string m_category;
  lldb::LanguageType m_language;
};

CommandOptions m_options;
uint32_t m_formatter_kind_mask;

Options *GetOptions() override { return &m_options; }

818public:
CommandObjectTypeFormatterDelete(CommandInterpreter &interpreter,
                                 uint32_t formatter_kind_mask,
                                 const char *name, const char *help)
    : CommandObjectParsed(interpreter, name, help, nullptr), m_options(),
      m_formatter_kind_mask(formatter_kind_mask) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlain;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeFormatterDelete() override = default;

837protected:
virtual bool FormatterSpecificDeletion(ConstString typeCS) { return false; }

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc != 1) {
    result.AppendErrorWithFormat("%s takes 1 arg.\n", m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  const char *typeA = command.GetArgumentAtIndex(0);
  ConstString typeCS(typeA);

  if (!typeCS) {
    result.AppendError("empty typenames not allowed");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  if (m_options.m_delete_all) {
    DataVisualization::Categories::ForEach(
        [this, typeCS](const lldb::TypeCategoryImplSP &category_sp) -> bool {
          category_sp->Delete(typeCS, m_formatter_kind_mask);
          return true;
        });
    result.SetStatus(eReturnStatusSuccessFinishNoResult);
    return result.Succeeded();
  }

  bool delete_category = false;
  bool extra_deletion = false;

  if (m_options.m_language != lldb::eLanguageTypeUnknown) {
    lldb::TypeCategoryImplSP category;
    DataVisualization::Categories::GetCategory(m_options.m_language,
                                               category);
    if (category)
      delete_category = category->Delete(typeCS, m_formatter_kind_mask);
    extra_deletion = FormatterSpecificDeletion(typeCS);
  } else {
    lldb::TypeCategoryImplSP category;
    DataVisualization::Categories::GetCategory(
        ConstString(m_options.m_category.c_str()), category);
    if (category)
      delete_category = category->Delete(typeCS, m_formatter_kind_mask);
    extra_deletion = FormatterSpecificDeletion(typeCS);
  }

  if (delete_category || extra_deletion) {
    result.SetStatus(eReturnStatusSuccessFinishNoResult);
    return result.Succeeded();
  } else {
    result.AppendErrorWithFormat("no custom formatter for %s.\n", typeA);
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
}
896};

898static OptionDefinition g_type_formatter_clear_options[] = {
  // clang-format off
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "all", 'a', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Clear every category." }
  // clang-format on
902};

904class CommandObjectTypeFormatterClear : public CommandObjectParsed {
905private:
class CommandOptions : public Options {
public:
  CommandOptions() : Options() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'a':
      m_delete_all = true;
      break;
    default:
      error.SetErrorStringWithFormat("unrecognized option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_delete_all = false;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_formatter_clear_options);
  }

  // Instance variables to hold the values for command options.
  bool m_delete_all;
};

CommandOptions m_options;
uint32_t m_formatter_kind_mask;

Options *GetOptions() override { return &m_options; }

947public:
CommandObjectTypeFormatterClear(CommandInterpreter &interpreter,
                                uint32_t formatter_kind_mask,
                                const char *name, const char *help)
    : CommandObjectParsed(interpreter, name, help, nullptr), m_options(),
      m_formatter_kind_mask(formatter_kind_mask) {}

~CommandObjectTypeFormatterClear() override = default;

956protected:
virtual void FormatterSpecificDeletion() {}

bool DoExecute(Args &command, CommandReturnObject &result) override {
  if (m_options.m_delete_all) {
    DataVisualization::Categories::ForEach(
        [this](const TypeCategoryImplSP &category_sp) -> bool {
          category_sp->Clear(m_formatter_kind_mask);
          return true;
        });
  } else {
    lldb::TypeCategoryImplSP category;
    if (command.GetArgumentCount() > 0) {
      const char *cat_name = command.GetArgumentAtIndex(0);
      ConstString cat_nameCS(cat_name);
      DataVisualization::Categories::GetCategory(cat_nameCS, category);
    } else {
      DataVisualization::Categories::GetCategory(ConstString(nullptr),
                                                 category);
    }
    category->Clear(m_formatter_kind_mask);
  }

  FormatterSpecificDeletion();

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
984};

986//-------------------------------------------------------------------------
987// CommandObjectTypeFormatDelete
988//-------------------------------------------------------------------------

990class CommandObjectTypeFormatDelete : public CommandObjectTypeFormatterDelete {
991public:
CommandObjectTypeFormatDelete(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterDelete(
          interpreter,
          eFormatCategoryItemValue | eFormatCategoryItemRegexValue,
          "type format delete",
          "Delete an existing formatting style for a type.") {}

~CommandObjectTypeFormatDelete() override = default;
1000};

1002//-------------------------------------------------------------------------
1003// CommandObjectTypeFormatClear
1004//-------------------------------------------------------------------------

1006class CommandObjectTypeFormatClear : public CommandObjectTypeFormatterClear {
1007public:
CommandObjectTypeFormatClear(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterClear(
          interpreter,
          eFormatCategoryItemValue | eFormatCategoryItemRegexValue,
          "type format clear", "Delete all existing format styles.") {}
1013};

1015template <typename FormatterType>
1016class CommandObjectTypeFormatterList : public CommandObjectParsed {
typedef typename FormatterType::SharedPointer FormatterSharedPointer;

class CommandOptions : public Options {
public:
  CommandOptions()
      : Options(), m_category_regex("", ""),
        m_category_language(lldb::eLanguageTypeUnknown,
                            lldb::eLanguageTypeUnknown) {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;
    switch (short_option) {
    case 'w':
      m_category_regex.SetCurrentValue(option_arg);
      m_category_regex.SetOptionWasSet();
      break;
    case 'l':
      error = m_category_language.SetValueFromString(option_arg);
      if (error.Success())
        m_category_language.SetOptionWasSet();
      break;
    default:
      error.SetErrorStringWithFormat("unrecognized option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_category_regex.Clear();
    m_category_language.Clear();
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    static OptionDefinition g_option_table[] = {
        // clang-format off
          {LLDB_OPT_SET_1(1U << 0), false, "category-regex", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,     "Only show categories matching this filter."},
          {LLDB_OPT_SET_2(1U << 1), false, "language",       'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Only show the category for a specific language."}
        // clang-format on
    };
    return llvm::ArrayRef<OptionDefinition>(g_option_table);
  }

  // Instance variables to hold the values for command options.

  OptionValueString m_category_regex;
  OptionValueLanguage m_category_language;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

1076public:
CommandObjectTypeFormatterList(CommandInterpreter &interpreter,
                               const char *name, const char *help)
    : CommandObjectParsed(interpreter, name, help, nullptr), m_options() {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatOptional;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeFormatterList() override = default;

1093protected:
virtual bool FormatterSpecificList(CommandReturnObject &result) {
  return false;
}

bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  std::unique_ptr<RegularExpression> category_regex;
  std::unique_ptr<RegularExpression> formatter_regex;

  if (m_options.m_category_regex.OptionWasSet()) {
    category_regex.reset(new RegularExpression());
    if (!category_regex->Compile(
            m_options.m_category_regex.GetCurrentValueAsRef())) {
      result.AppendErrorWithFormat(
          "syntax error in category regular expression '%s'",
          m_options.m_category_regex.GetCurrentValueAsRef().str().c_str());
      result.SetStatus(eReturnStatusFailed);
      return false;
    }
  }

  if (argc == 1) {
    const char *arg = command.GetArgumentAtIndex(0);
    formatter_regex.reset(new RegularExpression());
    if (!formatter_regex->Compile(llvm::StringRef::withNullAsEmpty(arg))) {
      result.AppendErrorWithFormat("syntax error in regular expression '%s'",
                                   arg);
      result.SetStatus(eReturnStatusFailed);
      return false;
    }
  }

  bool any_printed = false;

  auto category_closure = [&result, &formatter_regex, &any_printed](
      const lldb::TypeCategoryImplSP &category) -> void {
    result.GetOutputStream().Printf(
        "-----------------------\nCategory: %s%s\n-----------------------\n",
        category->GetName(), category->IsEnabled() ? "" : " (disabled)");

    TypeCategoryImpl::ForEachCallbacks<FormatterType> foreach;
    foreach
      .SetExact([&result, &formatter_regex, &any_printed](
                    ConstString name,
                    const FormatterSharedPointer &format_sp) -> bool {
        if (formatter_regex) {
          bool escape = true;
          if (name.GetStringRef() == formatter_regex->GetText()) {
            escape = false;
          } else if (formatter_regex->Execute(name.GetStringRef())) {
            escape = false;
          }

          if (escape)
            return true;
        }

        any_printed = true;
        result.GetOutputStream().Printf("%s: %s\n", name.AsCString(),
                                        format_sp->GetDescription().c_str());
        return true;
      });

    foreach
      .SetWithRegex([&result, &formatter_regex, &any_printed](
                        RegularExpressionSP regex_sp,
                        const FormatterSharedPointer &format_sp) -> bool {
        if (formatter_regex) {
          bool escape = true;
          if (regex_sp->GetText() == formatter_regex->GetText()) {
            escape = false;
          } else if (formatter_regex->Execute(regex_sp->GetText())) {
            escape = false;
          }

          if (escape)
            return true;
        }

        any_printed = true;
        result.GetOutputStream().Printf("%s: %s\n",
                                        regex_sp->GetText().str().c_str(),
                                        format_sp->GetDescription().c_str());
        return true;
      });

    category->ForEach(foreach);
  };

  if (m_options.m_category_language.OptionWasSet()) {
    lldb::TypeCategoryImplSP category_sp;
    DataVisualization::Categories::GetCategory(
        m_options.m_category_language.GetCurrentValue(), category_sp);
    if (category_sp)
      category_closure(category_sp);
  } else {
    DataVisualization::Categories::ForEach(
        [&category_regex, &category_closure](
            const lldb::TypeCategoryImplSP &category) -> bool {
          if (category_regex) {
            bool escape = true;
            if (category->GetName() == category_regex->GetText()) {
              escape = false;
            } else if (category_regex->Execute(
                           llvm::StringRef::withNullAsEmpty(
                               category->GetName()))) {
              escape = false;
            }

            if (escape)
              return true;
          }

          category_closure(category);

          return true;
        });

    any_printed = FormatterSpecificList(result) | any_printed;
  }

  if (any_printed)
    result.SetStatus(eReturnStatusSuccessFinishResult);
  else {
    result.GetOutputStream().PutCString("no matching results found.\n");
    result.SetStatus(eReturnStatusSuccessFinishNoResult);
  }
  return result.Succeeded();
}
1224};

1226//-------------------------------------------------------------------------
1227// CommandObjectTypeFormatList
1228//-------------------------------------------------------------------------

1230class CommandObjectTypeFormatList
  : public CommandObjectTypeFormatterList<TypeFormatImpl> {
1232public:
CommandObjectTypeFormatList(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterList(interpreter, "type format list",
                                     "Show a list of current formats.") {}
1236};

1238#ifndef LLDB_DISABLE_PYTHON

1240//-------------------------------------------------------------------------
1241// CommandObjectTypeSummaryAdd
1242//-------------------------------------------------------------------------

1244#endif // LLDB_DISABLE_PYTHON

1246Status CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue(
  uint32_t option_idx, llvm::StringRef option_arg,
  ExecutionContext *execution_context) {
Status error;
const int short_option = m_getopt_table[option_idx].val;
bool success;

switch (short_option) {
case 'C':
  m_flags.SetCascades(Args::StringToBoolean(option_arg, true, &success));
  if (!success)
    error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                   option_arg.str().c_str());
  break;
case 'e':
  m_flags.SetDontShowChildren(false);
  break;
case 'h':
  m_flags.SetHideEmptyAggregates(true);
  break;
case 'v':
  m_flags.SetDontShowValue(true);
  break;
case 'c':
  m_flags.SetShowMembersOneLiner(true);
  break;
case 's':
  m_format_string = std::string(option_arg);
  break;
case 'p':
  m_flags.SetSkipPointers(true);
  break;
case 'r':
  m_flags.SetSkipReferences(true);
  break;
case 'x':
  m_regex = true;
  break;
case 'n':
  m_name.SetString(option_arg);
  break;
case 'o':
  m_python_script = option_arg;
  m_is_add_script = true;
  break;
case 'F':
  m_python_function = option_arg;
  m_is_add_script = true;
  break;
case 'P':
  m_is_add_script = true;
  break;
case 'w':
  m_category = std::string(option_arg);
  break;
case 'O':
  m_flags.SetHideItemNames(true);
  break;
default:
  error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
  break;
}

return error;
1310}

1312void CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting(
  ExecutionContext *execution_context) {
m_flags.Clear().SetCascades().SetDontShowChildren().SetDontShowValue(false);
m_flags.SetShowMembersOneLiner(false)
    .SetSkipPointers(false)
    .SetSkipReferences(false)
    .SetHideItemNames(false);

m_regex = false;
m_name.Clear();
m_python_script = "";
m_python_function = "";
m_format_string = "";
m_is_add_script = false;
m_category = "default";
1327}

1329#ifndef LLDB_DISABLE_PYTHON

1331bool CommandObjectTypeSummaryAdd::Execute_ScriptSummary(
  Args &command, CommandReturnObject &result) {
const size_t argc = command.GetArgumentCount();

if (argc < 1 && !m_options.m_name) {
  result.AppendErrorWithFormat("%s takes one or more args.\n",
                               m_cmd_name.c_str());
  result.SetStatus(eReturnStatusFailed);
  return false;
}

TypeSummaryImplSP script_format;

if (!m_options.m_python_function
         .empty()) // we have a Python function ready to use
{
  const char *funct_name = m_options.m_python_function.c_str();
  if (!funct_name || !funct_name[0]) {
    result.AppendError("function name empty.\n");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  std::string code =
      ("    " + m_options.m_python_function + "(valobj,internal_dict)");

  script_format.reset(
      new ScriptSummaryFormat(m_options.m_flags, funct_name, code.c_str()));

  ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();

  if (interpreter && !interpreter->CheckObjectExists(funct_name))
    result.AppendWarningWithFormat(
        "The provided function \"%s\" does not exist - "
        "please define it before attempting to use this summary.\n",
        funct_name);
} else if (!m_options.m_python_script
                .empty()) // we have a quick 1-line script, just use it
{
  ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
  if (!interpreter) {
    result.AppendError("script interpreter missing - unable to generate "
                       "function wrapper.\n");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
  StringList funct_sl;
  funct_sl << m_options.m_python_script.c_str();
  std::string funct_name_str;
  if (!interpreter->GenerateTypeScriptFunction(funct_sl, funct_name_str)) {
    result.AppendError("unable to generate function wrapper.\n");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
  if (funct_name_str.empty()) {
    result.AppendError(
        "script interpreter failed to generate a valid function name.\n");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  std::string code = "    " + m_options.m_python_script;

  script_format.reset(new ScriptSummaryFormat(
      m_options.m_flags, funct_name_str.c_str(), code.c_str()));
} else {
  // Use an IOHandler to grab Python code from the user
  ScriptAddOptions *options =
      new ScriptAddOptions(m_options.m_flags, m_options.m_regex,
                           m_options.m_name, m_options.m_category);

  for (auto &entry : command.entries()) {
    if (entry.ref.empty()) {
      result.AppendError("empty typenames not allowed");
      result.SetStatus(eReturnStatusFailed);
      return false;
    }

    options->m_target_types << entry.ref;
  }

  m_interpreter.GetPythonCommandsFromIOHandler(
      "    ",   // Prompt
      *this,    // IOHandlerDelegate
      true,     // Run IOHandler in async mode
      options); // Baton for the "io_handler" that will be passed back into
                // our IOHandlerDelegate functions
  result.SetStatus(eReturnStatusSuccessFinishNoResult);

  return result.Succeeded();
}

// if I am here, script_format must point to something good, so I can add that
// as a script summary to all interested parties

Status error;

for (auto &entry : command.entries()) {
  CommandObjectTypeSummaryAdd::AddSummary(
      ConstString(entry.ref), script_format,
      (m_options.m_regex ? eRegexSummary : eRegularSummary),
      m_options.m_category, &error);
  if (error.Fail()) {
    result.AppendError(error.AsCString());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
}

if (m_options.m_name) {
  AddSummary(m_options.m_name, script_format, eNamedSummary,
             m_options.m_category, &error);
  if (error.Fail()) {
    result.AppendError(error.AsCString());
    result.AppendError("added to types, but not given a name");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
}

return result.Succeeded();
1452}

1454#endif // LLDB_DISABLE_PYTHON

1456bool CommandObjectTypeSummaryAdd::Execute_StringSummary(
  Args &command, CommandReturnObject &result) {
const size_t argc = command.GetArgumentCount();

if (argc < 1 && !m_options.m_name) {
  result.AppendErrorWithFormat("%s takes one or more args.\n",
                               m_cmd_name.c_str());
  result.SetStatus(eReturnStatusFailed);
  return false;
}

if (!m_options.m_flags.GetShowMembersOneLiner() &&
    m_options.m_format_string.empty()) {
  result.AppendError("empty summary strings not allowed");
  result.SetStatus(eReturnStatusFailed);
  return false;
}

const char *format_cstr = (m_options.m_flags.GetShowMembersOneLiner()
                               ? ""
                               : m_options.m_format_string.c_str());

// ${var%S} is an endless recursion, prevent it
if (strcmp(format_cstr, "${var%S}") == 0) {
  result.AppendError("recursive summary not allowed");
  result.SetStatus(eReturnStatusFailed);
  return false;
}

std::unique_ptr<StringSummaryFormat> string_format(
    new StringSummaryFormat(m_options.m_flags, format_cstr));
if (!string_format) {
  result.AppendError("summary creation failed");
  result.SetStatus(eReturnStatusFailed);
  return false;
}
if (string_format->m_error.Fail()) {
  result.AppendErrorWithFormat("syntax error: %s",
                               string_format->m_error.AsCString("<unknown>"));
  result.SetStatus(eReturnStatusFailed);
  return false;
}
lldb::TypeSummaryImplSP entry(string_format.release());

// now I have a valid format, let's add it to every type
Status error;
for (auto &arg_entry : command.entries()) {
  if (arg_entry.ref.empty()) {
    result.AppendError("empty typenames not allowed");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
  ConstString typeCS(arg_entry.ref);

  AddSummary(typeCS, entry,
             (m_options.m_regex ? eRegexSummary : eRegularSummary),
             m_options.m_category, &error);

  if (error.Fail()) {
    result.AppendError(error.AsCString());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
}

if (m_options.m_name) {
  AddSummary(m_options.m_name, entry, eNamedSummary, m_options.m_category,
             &error);
  if (error.Fail()) {
    result.AppendError(error.AsCString());
    result.AppendError("added to types, but not given a name");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
}

result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
1534}

1536CommandObjectTypeSummaryAdd::CommandObjectTypeSummaryAdd(
  CommandInterpreter &interpreter)
  : CommandObjectParsed(interpreter, "type summary add",
                        "Add a new summary style for a type.", nullptr),
    IOHandlerDelegateMultiline("DONE"), m_options(interpreter) {
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;

type_style_arg.arg_type = eArgTypeName;
type_style_arg.arg_repetition = eArgRepeatPlus;

type_arg.push_back(type_style_arg);

m_arguments.push_back(type_arg);

SetHelpLong(
    R"(
1553The following examples of 'type summary add' refer to this code snippet for context:

  struct JustADemo
  {
      int* ptr;
      float value;
      JustADemo(int p = 1, float v = 0.1) : ptr(new int(p)), value(v) {}
  };
  JustADemo demo_instance(42, 3.14);

  typedef JustADemo NewDemo;
  NewDemo new_demo_instance(42, 3.14);

1566(lldb) type summary add --summary-string "the answer is ${*var.ptr}" JustADemo

  Subsequently displaying demo_instance with 'frame variable' or 'expression' will display "the answer is 42"

1570(lldb) type summary add --summary-string "the answer is ${*var.ptr}, and the question is ${var.value}" JustADemo

  Subsequently displaying demo_instance with 'frame variable' or 'expression' will display "the answer is 42 and the question is 3.14"

1574)"
    "Alternatively, you could define formatting for all pointers to integers and \
1576rely on that when formatting JustADemo to obtain the same result:"
    R"(

1579(lldb) type summary add --summary-string "${var%V} -> ${*var}" "int *"
1580(lldb) type summary add --summary-string "the answer is ${var.ptr}, and the question is ${var.value}" JustADemo

1582)"
    "Type summaries are automatically applied to derived typedefs, so the examples \
1584above apply to both JustADemo and NewDemo.  The cascade option can be used to \
1585suppress this behavior:"
    R"(

1588(lldb) type summary add --summary-string "${var.ptr}, ${var.value},{${var.byte}}" JustADemo -C no

  The summary will now be used for values of JustADemo but not NewDemo.

1592)"
    "By default summaries are shown for pointers and references to values of the \
1594specified type.  To suppress formatting for pointers use the -p option, or apply \
1595the corresponding -r option to suppress formatting for references:"
    R"(

1598(lldb) type summary add -p -r --summary-string "${var.ptr}, ${var.value},{${var.byte}}" JustADemo

1600)"
    "One-line summaries including all fields in a type can be inferred without supplying an \
1602explicit summary string by passing the -c option:"
    R"(

1605(lldb) type summary add -c JustADemo
1606(lldb) frame variable demo_instance
1607(ptr=<address>, value=3.14)

1609)"
    "Type summaries normally suppress the nested display of individual fields.  To \
1611supply a summary to supplement the default structure add the -e option:"
    R"(

1614(lldb) type summary add -e --summary-string "*ptr = ${*var.ptr}" JustADemo

1616)"
    "Now when displaying JustADemo values the int* is displayed, followed by the \
1618standard LLDB sequence of children, one per line:"
    R"(

1621*ptr = 42 {
ptr = <address>
value = 3.14
1624}

1626)"
    "You can also add summaries written in Python.  These scripts use lldb public API to \
1628gather information from your variables and produce a meaningful summary.  To start a \
1629multi-line script use the -P option.  The function declaration will be displayed along with \
1630a comment describing the two arguments.  End your script with the  word 'DONE' on a line by \
1631itself:"
    R"(

1634(lldb) type summary add JustADemo -P
1635def function (valobj,internal_dict):
1636"""valobj: an SBValue which you want to provide a summary for
1637internal_dict: an LLDB support object not to be used"""
  value = valobj.GetChildMemberWithName('value');
  return 'My value is ' + value.GetValue();
  DONE

1642Alternatively, the -o option can be used when providing a simple one-line Python script:

1644(lldb) type summary add JustADemo -o "value = valobj.GetChildMemberWithName('value'); return 'My value is ' + value.GetValue();")");
1645}

1647bool CommandObjectTypeSummaryAdd::DoExecute(Args &command,
                                          CommandReturnObject &result) {
WarnOnPotentialUnquotedUnsignedType(command, result);

if (m_options.m_is_add_script) {
1652#ifndef LLDB_DISABLE_PYTHON
  return Execute_ScriptSummary(command, result);
1654#else
  result.AppendError("python is disabled");
  result.SetStatus(eReturnStatusFailed);
  return false;
1658#endif // LLDB_DISABLE_PYTHON
}

return Execute_StringSummary(command, result);
1662}

1664static bool FixArrayTypeNameWithRegex(ConstString &type_name) {
llvm::StringRef type_name_ref(type_name.GetStringRef());

if (type_name_ref.endswith("[]")) {
  std::string type_name_str(type_name.GetCString());
  type_name_str.resize(type_name_str.length() - 2);
  if (type_name_str.back() != ' ')
    type_name_str.append(" \\[[0-9]+\\]");
  else
    type_name_str.append("\\[[0-9]+\\]");
  type_name.SetCString(type_name_str.c_str());
  return true;
}
return false;
1678}

1680bool CommandObjectTypeSummaryAdd::AddSummary(ConstString type_name,
                                           TypeSummaryImplSP entry,
                                           SummaryFormatType type,
                                           std::string category_name,
                                           Status *error) {
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()),
                                           category);

if (type == eRegularSummary) {
  if (FixArrayTypeNameWithRegex(type_name))
    type = eRegexSummary;
}

if (type == eRegexSummary) {
  RegularExpressionSP typeRX(new RegularExpression());
  if (!typeRX->Compile(type_name.GetStringRef())) {
    if (error)
      error->SetErrorString(
          "regex format error (maybe this is not really a regex?)");
    return false;
  }

  category->GetRegexTypeSummariesContainer()->Delete(type_name);
  category->GetRegexTypeSummariesContainer()->Add(typeRX, entry);

  return true;
} else if (type == eNamedSummary) {
  // system named summaries do not exist (yet?)
  DataVisualization::NamedSummaryFormats::Add(type_name, entry);
  return true;
} else {
  category->GetTypeSummariesContainer()->Add(type_name, entry);
  return true;
}
1715}

1717//-------------------------------------------------------------------------
1718// CommandObjectTypeSummaryDelete
1719//-------------------------------------------------------------------------

1721class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete {
1722public:
CommandObjectTypeSummaryDelete(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterDelete(
          interpreter,
          eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary,
          "type summary delete", "Delete an existing summary for a type.") {}

~CommandObjectTypeSummaryDelete() override = default;

1731protected:
bool FormatterSpecificDeletion(ConstString typeCS) override {
  if (m_options.m_language != lldb::eLanguageTypeUnknown)
    return false;
  return DataVisualization::NamedSummaryFormats::Delete(typeCS);
}
1737};

1739class CommandObjectTypeSummaryClear : public CommandObjectTypeFormatterClear {
1740public:
CommandObjectTypeSummaryClear(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterClear(
          interpreter,
          eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary,
          "type summary clear", "Delete all existing summaries.") {}

1747protected:
void FormatterSpecificDeletion() override {
  DataVisualization::NamedSummaryFormats::Clear();
}
1751};

1753//-------------------------------------------------------------------------
1754// CommandObjectTypeSummaryList
1755//-------------------------------------------------------------------------

1757class CommandObjectTypeSummaryList
  : public CommandObjectTypeFormatterList<TypeSummaryImpl> {
1759public:
CommandObjectTypeSummaryList(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterList(interpreter, "type summary list",
                                     "Show a list of current summaries.") {}

1764protected:
bool FormatterSpecificList(CommandReturnObject &result) override {
  if (DataVisualization::NamedSummaryFormats::GetCount() > 0) {
    result.GetOutputStream().Printf("Named summaries:\n");
    DataVisualization::NamedSummaryFormats::ForEach(
        [&result](ConstString name,
                  const TypeSummaryImplSP &summary_sp) -> bool {
          result.GetOutputStream().Printf(
              "%s: %s\n", name.AsCString(),
              summary_sp->GetDescription().c_str());
          return true;
        });
    return true;
  }
  return false;
}
1780};

1782//-------------------------------------------------------------------------
1783// CommandObjectTypeCategoryDefine
1784//-------------------------------------------------------------------------

1786static OptionDefinition g_type_category_define_options[] = {
  // clang-format off
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "enabled",  'e', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "If specified, this category will be created enabled." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Specify the language that this category is supported for." }
  // clang-format on
1791};

1793class CommandObjectTypeCategoryDefine : public CommandObjectParsed {
class CommandOptions : public Options {
public:
  CommandOptions()
      : Options(), m_define_enabled(false, false),
        m_cate_language(eLanguageTypeUnknown, eLanguageTypeUnknown) {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'e':
      m_define_enabled.SetValueFromString(llvm::StringRef("true"));
      break;
    case 'l':
      error = m_cate_language.SetValueFromString(option_arg);
      break;
    default:
      error.SetErrorStringWithFormat("unrecognized option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_define_enabled.Clear();
    m_cate_language.Clear();
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_category_define_options);
  }

  // Instance variables to hold the values for command options.

  OptionValueBoolean m_define_enabled;
  OptionValueLanguage m_cate_language;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

1842public:
CommandObjectTypeCategoryDefine(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category define",
                          "Define a new category as a source of formatters.",
                          nullptr),
      m_options() {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryDefine() override = default;

1861protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1) {
    result.AppendErrorWithFormat("%s takes 1 or more args.\n",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  for (auto &entry : command.entries()) {
    TypeCategoryImplSP category_sp;
    if (DataVisualization::Categories::GetCategory(ConstString(entry.ref),
                                                   category_sp) &&
        category_sp) {
      category_sp->AddLanguage(m_options.m_cate_language.GetCurrentValue());
      if (m_options.m_define_enabled.GetCurrentValue())
        DataVisualization::Categories::Enable(category_sp,
                                              TypeCategoryMap::Default);
    }
  }

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
1887};

1889//-------------------------------------------------------------------------
1890// CommandObjectTypeCategoryEnable
1891//-------------------------------------------------------------------------

1893static OptionDefinition g_type_category_enable_options[] = {
  // clang-format off
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Enable the category for this language." },
  // clang-format on
1897};

1899class CommandObjectTypeCategoryEnable : public CommandObjectParsed {
class CommandOptions : public Options {
public:
  CommandOptions() : Options() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'l':
      if (!option_arg.empty()) {
        m_language = Language::GetLanguageTypeFromString(option_arg);
        if (m_language == lldb::eLanguageTypeUnknown)
          error.SetErrorStringWithFormat("unrecognized language '%s'",
                                         option_arg.str().c_str());
      }
      break;
    default:
      error.SetErrorStringWithFormat("unrecognized option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_language = lldb::eLanguageTypeUnknown;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_category_enable_options);
  }

  // Instance variables to hold the values for command options.

  lldb::LanguageType m_language;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

1946public:
CommandObjectTypeCategoryEnable(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category enable",
                          "Enable a category as a source of formatters.",
                          nullptr),
      m_options() {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryEnable() override = default;

1965protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1 && m_options.m_language == lldb::eLanguageTypeUnknown) {
    result.AppendErrorWithFormat("%s takes arguments and/or a language",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  if (argc == 1 && strcmp(command.GetArgumentAtIndex(0), "*") == 0) {
    DataVisualization::Categories::EnableStar();
  } else if (argc > 0) {
    for (int i = argc - 1; i >= 0; i--) {
      const char *typeA = command.GetArgumentAtIndex(i);
      ConstString typeCS(typeA);

      if (!typeCS) {
        result.AppendError("empty category name not allowed");
        result.SetStatus(eReturnStatusFailed);
        return false;
      }
      DataVisualization::Categories::Enable(typeCS);
      lldb::TypeCategoryImplSP cate;
      if (DataVisualization::Categories::GetCategory(typeCS, cate) && cate) {
        if (cate->GetCount() == 0) {
          result.AppendWarning("empty category enabled (typo?)");
        }
      }
    }
  }

  if (m_options.m_language != lldb::eLanguageTypeUnknown)
    DataVisualization::Categories::Enable(m_options.m_language);

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
2004};

2006//-------------------------------------------------------------------------
2007// CommandObjectTypeCategoryDelete
2008//-------------------------------------------------------------------------

2010class CommandObjectTypeCategoryDelete : public CommandObjectParsed {
2011public:
CommandObjectTypeCategoryDelete(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category delete",
                          "Delete a category and all associated formatters.",
                          nullptr) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryDelete() override = default;

2029protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1) {
    result.AppendErrorWithFormat("%s takes 1 or more arg.\n",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  bool success = true;

  // the order is not relevant here
  for (int i = argc - 1; i >= 0; i--) {
    const char *typeA = command.GetArgumentAtIndex(i);
    ConstString typeCS(typeA);

    if (!typeCS) {
      result.AppendError("empty category name not allowed");
      result.SetStatus(eReturnStatusFailed);
      return false;
    }
    if (!DataVisualization::Categories::Delete(typeCS))
      success = false; // keep deleting even if we hit an error
  }
  if (success) {
    result.SetStatus(eReturnStatusSuccessFinishResult);
    return result.Succeeded();
  } else {
    result.AppendError("cannot delete one or more categories\n");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
}
2064};

2066//-------------------------------------------------------------------------
2067// CommandObjectTypeCategoryDisable
2068//-------------------------------------------------------------------------

2070OptionDefinition g_type_category_disable_options[] = {
  // clang-format off
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Enable the category for this language." }
  // clang-format on
2074};

2076class CommandObjectTypeCategoryDisable : public CommandObjectParsed {
class CommandOptions : public Options {
public:
  CommandOptions() : Options() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;

    switch (short_option) {
    case 'l':
      if (!option_arg.empty()) {
        m_language = Language::GetLanguageTypeFromString(option_arg);
        if (m_language == lldb::eLanguageTypeUnknown)
          error.SetErrorStringWithFormat("unrecognized language '%s'",
                                         option_arg.str().c_str());
      }
      break;
    default:
      error.SetErrorStringWithFormat("unrecognized option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_language = lldb::eLanguageTypeUnknown;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_category_disable_options);
  }

  // Instance variables to hold the values for command options.

  lldb::LanguageType m_language;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

2123public:
CommandObjectTypeCategoryDisable(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category disable",
                          "Disable a category as a source of formatters.",
                          nullptr),
      m_options() {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryDisable() override = default;

2142protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1 && m_options.m_language == lldb::eLanguageTypeUnknown) {
    result.AppendErrorWithFormat("%s takes arguments and/or a language",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  if (argc == 1 && strcmp(command.GetArgumentAtIndex(0), "*") == 0) {
    DataVisualization::Categories::DisableStar();
  } else if (argc > 0) {
    // the order is not relevant here
    for (int i = argc - 1; i >= 0; i--) {
      const char *typeA = command.GetArgumentAtIndex(i);
      ConstString typeCS(typeA);

      if (!typeCS) {
        result.AppendError("empty category name not allowed");
        result.SetStatus(eReturnStatusFailed);
        return false;
      }
      DataVisualization::Categories::Disable(typeCS);
    }
  }

  if (m_options.m_language != lldb::eLanguageTypeUnknown)
    DataVisualization::Categories::Disable(m_options.m_language);

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
2176};

2178//-------------------------------------------------------------------------
2179// CommandObjectTypeCategoryList
2180//-------------------------------------------------------------------------

2182class CommandObjectTypeCategoryList : public CommandObjectParsed {
2183public:
CommandObjectTypeCategoryList(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type category list",
                          "Provide a list of all existing categories.",
                          nullptr) {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatOptional;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);
}

~CommandObjectTypeCategoryList() override = default;

2201protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  std::unique_ptr<RegularExpression> regex;

  if (argc == 1) {
    regex.reset(new RegularExpression());
    const char *arg = command.GetArgumentAtIndex(0);
    if (!regex->Compile(llvm::StringRef::withNullAsEmpty(arg))) {
      result.AppendErrorWithFormat(
          "syntax error in category regular expression '%s'", arg);
      result.SetStatus(eReturnStatusFailed);
      return false;
    }
  } else if (argc != 0) {
    result.AppendErrorWithFormat("%s takes 0 or one arg.\n",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  DataVisualization::Categories::ForEach(
      [&regex, &result](const lldb::TypeCategoryImplSP &category_sp) -> bool {
        if (regex) {
          bool escape = true;
          if (regex->GetText() == category_sp->GetName()) {
            escape = false;
          } else if (regex->Execute(llvm::StringRef::withNullAsEmpty(
                         category_sp->GetName()))) {
            escape = false;
          }

          if (escape)
            return true;
        }

        result.GetOutputStream().Printf(
            "Category: %s\n", category_sp->GetDescription().c_str());

        return true;
      });

  result.SetStatus(eReturnStatusSuccessFinishResult);
  return result.Succeeded();
}
2247};

2249//-------------------------------------------------------------------------
2250// CommandObjectTypeFilterList
2251//-------------------------------------------------------------------------

2253class CommandObjectTypeFilterList
  : public CommandObjectTypeFormatterList<TypeFilterImpl> {
2255public:
CommandObjectTypeFilterList(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterList(interpreter, "type filter list",
                                     "Show a list of current filters.") {}
2259};

2261#ifndef LLDB_DISABLE_PYTHON

2263//-------------------------------------------------------------------------
2264// CommandObjectTypeSynthList
2265//-------------------------------------------------------------------------

2267class CommandObjectTypeSynthList
  : public CommandObjectTypeFormatterList<SyntheticChildren> {
2269public:
CommandObjectTypeSynthList(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterList(
          interpreter, "type synthetic list",
          "Show a list of current synthetic providers.") {}
2274};

2276#endif // LLDB_DISABLE_PYTHON

2278//-------------------------------------------------------------------------
2279// CommandObjectTypeFilterDelete
2280//-------------------------------------------------------------------------

2282class CommandObjectTypeFilterDelete : public CommandObjectTypeFormatterDelete {
2283public:
CommandObjectTypeFilterDelete(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterDelete(
          interpreter,
          eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
          "type filter delete", "Delete an existing filter for a type.") {}

~CommandObjectTypeFilterDelete() override = default;
2291};

2293#ifndef LLDB_DISABLE_PYTHON

2295//-------------------------------------------------------------------------
2296// CommandObjectTypeSynthDelete
2297//-------------------------------------------------------------------------

2299class CommandObjectTypeSynthDelete : public CommandObjectTypeFormatterDelete {
2300public:
CommandObjectTypeSynthDelete(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterDelete(
          interpreter,
          eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
          "type synthetic delete",
          "Delete an existing synthetic provider for a type.") {}

~CommandObjectTypeSynthDelete() override = default;
2309};

2311#endif // LLDB_DISABLE_PYTHON

2313//-------------------------------------------------------------------------
2314// CommandObjectTypeFilterClear
2315//-------------------------------------------------------------------------

2317class CommandObjectTypeFilterClear : public CommandObjectTypeFormatterClear {
2318public:
CommandObjectTypeFilterClear(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterClear(
          interpreter,
          eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
          "type filter clear", "Delete all existing filter.") {}
2324};

2326#ifndef LLDB_DISABLE_PYTHON
2327//-------------------------------------------------------------------------
2328// CommandObjectTypeSynthClear
2329//-------------------------------------------------------------------------

2331class CommandObjectTypeSynthClear : public CommandObjectTypeFormatterClear {
2332public:
CommandObjectTypeSynthClear(CommandInterpreter &interpreter)
    : CommandObjectTypeFormatterClear(
          interpreter,
          eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
          "type synthetic clear",
          "Delete all existing synthetic providers.") {}
2339};

2341bool CommandObjectTypeSynthAdd::Execute_HandwritePython(
  Args &command, CommandReturnObject &result) {
SynthAddOptions *options = new SynthAddOptions(
    m_options.m_skip_pointers, m_options.m_skip_references,
    m_options.m_cascade, m_options.m_regex, m_options.m_category);

for (auto &entry : command.entries()) {
  if (entry.ref.empty()) {
    result.AppendError("empty typenames not allowed");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  options->m_target_types << entry.ref;
}

m_interpreter.GetPythonCommandsFromIOHandler(
    "    ",   // Prompt
    *this,    // IOHandlerDelegate
    true,     // Run IOHandler in async mode
    options); // Baton for the "io_handler" that will be passed back into our
              // IOHandlerDelegate functions
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
2365}

2367bool CommandObjectTypeSynthAdd::Execute_PythonClass(
  Args &command, CommandReturnObject &result) {
const size_t argc = command.GetArgumentCount();

if (argc < 1) {
  result.AppendErrorWithFormat("%s takes one or more args.\n",
                               m_cmd_name.c_str());
  result.SetStatus(eReturnStatusFailed);
  return false;
}

if (m_options.m_class_name.empty() && !m_options.m_input_python) {
  result.AppendErrorWithFormat("%s needs either a Python class name or -P to "
                               "directly input Python code.\n",
                               m_cmd_name.c_str());
  result.SetStatus(eReturnStatusFailed);
  return false;
}

SyntheticChildrenSP entry;

ScriptedSyntheticChildren *impl = new ScriptedSyntheticChildren(
    SyntheticChildren::Flags()
        .SetCascades(m_options.m_cascade)
        .SetSkipPointers(m_options.m_skip_pointers)
        .SetSkipReferences(m_options.m_skip_references),
    m_options.m_class_name.c_str());

entry.reset(impl);

ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();

if (interpreter &&
    !interpreter->CheckObjectExists(impl->GetPythonClassName()))
  result.AppendWarning("The provided class does not exist - please define it "
                       "before attempting to use this synthetic provider");

// now I have a valid provider, let's add it to every type

lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(
    ConstString(m_options.m_category.c_str()), category);

Status error;

for (auto &arg_entry : command.entries()) {
  if (arg_entry.ref.empty()) {
    result.AppendError("empty typenames not allowed");
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  ConstString typeCS(arg_entry.ref);
  if (!AddSynth(typeCS, entry,
                m_options.m_regex ? eRegexSynth : eRegularSynth,
                m_options.m_category, &error)) {
    result.AppendError(error.AsCString());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }
}

result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
2431}

2433CommandObjectTypeSynthAdd::CommandObjectTypeSynthAdd(
  CommandInterpreter &interpreter)
  : CommandObjectParsed(interpreter, "type synthetic add",
                        "Add a new synthetic provider for a type.", nullptr),
    IOHandlerDelegateMultiline("DONE"), m_options() {
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;

type_style_arg.arg_type = eArgTypeName;
type_style_arg.arg_repetition = eArgRepeatPlus;

type_arg.push_back(type_style_arg);

m_arguments.push_back(type_arg);
2447}

2449bool CommandObjectTypeSynthAdd::AddSynth(ConstString type_name,
                                       SyntheticChildrenSP entry,
                                       SynthFormatType type,
                                       std::string category_name,
                                       Status *error) {
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()),
                                           category);

if (type == eRegularSynth) {
  if (FixArrayTypeNameWithRegex(type_name))
    type = eRegexSynth;
}

if (category->AnyMatches(type_name, eFormatCategoryItemFilter |
                                        eFormatCategoryItemRegexFilter,
                         false)) {
  if (error)
    error->SetErrorStringWithFormat("cannot add synthetic for type %s when "
                                    "filter is defined in same category!",
                                    type_name.AsCString());
  return false;
}

if (type == eRegexSynth) {
  RegularExpressionSP typeRX(new RegularExpression());
  if (!typeRX->Compile(type_name.GetStringRef())) {
    if (error)
      error->SetErrorString(
          "regex format error (maybe this is not really a regex?)");
    return false;
  }

  category->GetRegexTypeSyntheticsContainer()->Delete(type_name);
  category->GetRegexTypeSyntheticsContainer()->Add(typeRX, entry);

  return true;
} else {
  category->GetTypeSyntheticsContainer()->Add(type_name, entry);
  return true;
}
2490}

2492#endif // LLDB_DISABLE_PYTHON

2494static OptionDefinition g_type_filter_add_options[] = {
  // clang-format off
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,        "If true, cascade through typedef chains." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for pointers-to-type objects." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for references-to-type objects." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,           "Add this to the given category instead of the default one." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "child",           'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeExpressionPath, "Include this expression path in the synthetic view." },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Type names are actually regular expressions." }
  // clang-format on
2503};

2505class CommandObjectTypeFilterAdd : public CommandObjectParsed {
2506private:
class CommandOptions : public Options {
  typedef std::vector<std::string> option_vector;

public:
  CommandOptions() : Options() {}

  ~CommandOptions() override = default;

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                        ExecutionContext *execution_context) override {
    Status error;
    const int short_option = m_getopt_table[option_idx].val;
    bool success;

    switch (short_option) {
    case 'C':
      m_cascade = Args::StringToBoolean(option_arg, true, &success);
      if (!success)
        error.SetErrorStringWithFormat("invalid value for cascade: %s",
                                       option_arg.str().c_str());
      break;
    case 'c':
      m_expr_paths.push_back(option_arg);
      has_child_list = true;
      break;
    case 'p':
      m_skip_pointers = true;
      break;
    case 'r':
      m_skip_references = true;
      break;
    case 'w':
      m_category = std::string(option_arg);
      break;
    case 'x':
      m_regex = true;
      break;
    default:
      error.SetErrorStringWithFormat("unrecognized option '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_cascade = true;
    m_skip_pointers = false;
    m_skip_references = false;
    m_category = "default";
    m_expr_paths.clear();
    has_child_list = false;
    m_regex = false;
  }

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_filter_add_options);
  }

  // Instance variables to hold the values for command options.

  bool m_cascade;
  bool m_skip_references;
  bool m_skip_pointers;
  bool m_input_python;
  option_vector m_expr_paths;
  std::string m_category;
  bool has_child_list;
  bool m_regex;

  typedef option_vector::iterator ExpressionPathsIterator;
};

CommandOptions m_options;

Options *GetOptions() override { return &m_options; }

enum FilterFormatType { eRegularFilter, eRegexFilter };

bool AddFilter(ConstString type_name, TypeFilterImplSP entry,
               FilterFormatType type, std::string category_name,
               Status *error) {
  lldb::TypeCategoryImplSP category;
  DataVisualization::Categories::GetCategory(
      ConstString(category_name.c_str()), category);

  if (type == eRegularFilter) {
    if (FixArrayTypeNameWithRegex(type_name))
      type = eRegexFilter;
  }

  if (category->AnyMatches(type_name, eFormatCategoryItemSynth |
                                          eFormatCategoryItemRegexSynth,
                           false)) {
    if (error)
      error->SetErrorStringWithFormat("cannot add filter for type %s when "
                                      "synthetic is defined in same "
                                      "category!",
                                      type_name.AsCString());
    return false;
  }

  if (type == eRegexFilter) {
    RegularExpressionSP typeRX(new RegularExpression());
    if (!typeRX->Compile(type_name.GetStringRef())) {
      if (error)
        error->SetErrorString(
            "regex format error (maybe this is not really a regex?)");
      return false;
    }

    category->GetRegexTypeFiltersContainer()->Delete(type_name);
    category->GetRegexTypeFiltersContainer()->Add(typeRX, entry);

    return true;
  } else {
    category->GetTypeFiltersContainer()->Add(type_name, entry);
    return true;
  }
}

2629public:
CommandObjectTypeFilterAdd(CommandInterpreter &interpreter)
    : CommandObjectParsed(interpreter, "type filter add",
                          "Add a new filter for a type.", nullptr),
      m_options() {
  CommandArgumentEntry type_arg;
  CommandArgumentData type_style_arg;

  type_style_arg.arg_type = eArgTypeName;
  type_style_arg.arg_repetition = eArgRepeatPlus;

  type_arg.push_back(type_style_arg);

  m_arguments.push_back(type_arg);

  SetHelpLong(
      R"(
2646The following examples of 'type filter add' refer to this code snippet for context:

  class Foo {
      int a;
      int b;
      int c;
      int d;
      int e;
      int f;
      int g;
      int h;
      int i;
  }
  Foo my_foo;

2661Adding a simple filter:

2663(lldb) type filter add --child a --child g Foo
2664(lldb) frame variable my_foo

2666)"
      "Produces output where only a and g are displayed.  Other children of my_foo \
2668(b, c, d, e, f, h and i) are available by asking for them explicitly:"
      R"(

2671(lldb) frame variable my_foo.b my_foo.c my_foo.i

2673)"
      "The formatting option --raw on frame variable bypasses the filter, showing \
2675all children of my_foo as if no filter was defined:"
      R"(

2678(lldb) frame variable my_foo --raw)");
}

~CommandObjectTypeFilterAdd() override = default;

2683protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
  const size_t argc = command.GetArgumentCount();

  if (argc < 1) {
    result.AppendErrorWithFormat("%s takes one or more args.\n",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  if (m_options.m_expr_paths.empty()) {
    result.AppendErrorWithFormat("%s needs one or more children.\n",
                                 m_cmd_name.c_str());
    result.SetStatus(eReturnStatusFailed);
    return false;
  }

  TypeFilterImplSP entry(new TypeFilterImpl(
      SyntheticChildren::Flags()
          .SetCascades(m_options.m_cascade)
          .SetSkipPointers(m_options.m_skip_pointers)
          .SetSkipReferences(m_options.m_skip_references)));

  // go through the expression paths
  CommandOptions::ExpressionPathsIterator begin,
      end = m_options.m_expr_paths.end();

  for (begin = m_options.m_expr_paths.begin(); begin != end; begin++)
    entry->AddExpressionPath(*begin);

  // now I have a valid provider, let's add it to every type

  lldb::TypeCategoryImplSP category;
  DataVisualization::Categories::GetCategory(
      ConstString(m_options.m_category.c_str()), category);

  Status error;

  WarnOnPotentialUnquotedUnsignedType(command, result);

  for (auto &arg_entry : command.entries()) {
    if (arg_entry.ref.empty()) {
      result.AppendError("empty typenames not allowed");
      result.SetStatus(eReturnStatusFailed);
      return false;
    }

    ConstString typeCS(arg_entry.ref);
    if (!AddFilter(typeCS, entry,
                   m_options.m_regex ? eRegexFilter : eRegularFilter,
                   m_options.m_category, &error)) {
      result.AppendError(error.AsCString());
      result.SetStatus(eReturnStatusFailed);
      return false;
    }
  }

  result.SetStatus(eReturnStatusSuccessFinishNoResult);
  return result.Succeeded();
}
2744};

2746//----------------------------------------------------------------------
2747// "type lookup"
2748//----------------------------------------------------------------------
2749static OptionDefinition g_type_lookup_options[] = {
  // clang-format off
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "show-help", 'h', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Display available help for types" },
{ LLDB_OPT_SET_ALL0xFFFFFFFFU, false, "language",  'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Which language's types should the search scope be" }
  // clang-format on
2754};

2756class CommandObjectTypeLookup : public CommandObjectRaw {
2757protected:
// this function is allowed to do a more aggressive job at guessing languages
// than the expression parser
// is comfortable with - so leave the original call alone and add one that is
// specific to type lookup
lldb::LanguageType GuessLanguage(StackFrame *frame) {
  lldb::LanguageType lang_type = lldb::eLanguageTypeUnknown;

  if (!frame)
    return lang_type;

  lang_type = frame->GuessLanguage();
  if (lang_type != lldb::eLanguageTypeUnknown)
    return lang_type;

  Symbol *s = frame->GetSymbolContext(eSymbolContextSymbol).symbol;
  if (s)
    lang_type = s->GetMangled().GuessLanguage();

  return lang_type;
}

class CommandOptions : public OptionGroup {
public:
  CommandOptions()
      : OptionGroup(), m_show_help(false), m_language(eLanguageTypeUnknown) {}

  ~CommandOptions() override = default;

  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
    return llvm::makeArrayRef(g_type_lookup_options);
  }

  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override {
    Status error;

    const int short_option = g_type_lookup_options[option_idx].short_option;

    switch (short_option) {
    case 'h':
      m_show_help = true;
      break;

    case 'l':
      m_language = Language::GetLanguageTypeFromString(option_value);
      break;

    default:
      error.SetErrorStringWithFormat("invalid short option character '%c'",
                                     short_option);
      break;
    }

    return error;
  }

  void OptionParsingStarting(ExecutionContext *execution_context) override {
    m_show_help = false;
    m_language = eLanguageTypeUnknown;
  }

  // Options table: Required for subclasses of Options.

  bool m_show_help;
  lldb::LanguageType m_language;
};

OptionGroupOptions m_option_group;
CommandOptions m_command_options;

2828public:
CommandObjectTypeLookup(CommandInterpreter &interpreter)
    : CommandObjectRaw(interpreter, "type lookup",
                       "Lookup types and declarations in the current target, "
                       "following language-specific naming conventions.",
                       "type lookup <type-specifier>",
                       eCommandRequiresTarget),
      m_option_group(), m_command_options() {
  m_option_group.Append(&m_command_options);
  m_option_group.Finalize();
}

~CommandObjectTypeLookup() override = default;

Options *GetOptions() override { return &m_option_group; }

llvm::StringRef GetHelpLong() override {
  if (!m_cmd_help_long.empty())
    return m_cmd_help_long;

  StreamString stream;
  // FIXME: hardcoding languages is not good
  lldb::LanguageType languages[] = {eLanguageTypeObjC,
                                    eLanguageTypeC_plus_plus};

  for (const auto lang_type : languages) {
    if (auto language = Language::FindPlugin(lang_type)) {
      if (const char *help = language->GetLanguageSpecificTypeLookupHelp()) {
        stream.Printf("%s\n", help);
      }
    }
  }

  m_cmd_help_long = stream.GetString();
  return m_cmd_help_long;
}

bool DoExecute(const char *raw_command_line,
               CommandReturnObject &result) override {
  if (!raw_command_line || !raw_command_line[0]) {
    result.SetError(
        "type lookup cannot be invoked without a type name as argument");
    return false;
  }

  auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
  m_option_group.NotifyOptionParsingStarting(&exe_ctx);

  const char *name_of_type = nullptr;

  if (raw_command_line[0] == '-') {
    // We have some options and these options MUST end with --.
    const char *end_options = nullptr;
    const char *s = raw_command_line;
    while (s && s[0]) {
      end_options = ::strstr(s, "--");
      if (end_options) {
        end_options += 2; // Get past the "--"
        if (::isspace(end_options[0])) {
          name_of_type = end_options;
          while (::isspace(*name_of_type))
            ++name_of_type;
          break;
        }
      }
      s = end_options;
    }

    if (end_options) {
      Args args(
          llvm::StringRef(raw_command_line, end_options - raw_command_line));
      if (!ParseOptions(args, result))
        return false;

      Status error(m_option_group.NotifyOptionParsingFinished(&exe_ctx));
      if (error.Fail()) {
        result.AppendError(error.AsCString());
        result.SetStatus(eReturnStatusFailed);
        return false;
      }
    }
  }
  if (nullptr == name_of_type)
    name_of_type = raw_command_line;

  // TargetSP
  // target_sp(GetCommandInterpreter().GetDebugger().GetSelectedTarget());
  // const bool fill_all_in = true;
  // ExecutionContext exe_ctx(target_sp.get(), fill_all_in);
  ExecutionContextScope *best_scope = exe_ctx.GetBestExecutionContextScope();

  bool any_found = false;

  std::vector<Language *> languages;

  bool is_global_search = false;
  LanguageType guessed_language = lldb::eLanguageTypeUnknown;

  if ((is_global_search =
           (m_command_options.m_language == eLanguageTypeUnknown))) {
    // FIXME: hardcoding languages is not good
    languages.push_back(Language::FindPlugin(eLanguageTypeObjC));
    languages.push_back(Language::FindPlugin(eLanguageTypeC_plus_plus));
  } else {
    languages.push_back(Language::FindPlugin(m_command_options.m_language));
  }

  // This is not the most efficient way to do this, but we support very few
  // languages
  // so the cost of the sort is going to be dwarfed by the actual lookup
  // anyway
  if (StackFrame *frame = m_exe_ctx.GetFramePtr()) {
    guessed_language = GuessLanguage(frame);
    if (guessed_language != eLanguageTypeUnknown) {
      std::sort(
          languages.begin(), languages.end(),
          [guessed_language](Language *lang1, Language *lang2) -> bool {
            if (!lang1 || !lang2)
              return false;
            LanguageType lt1 = lang1->GetLanguageType();
            LanguageType lt2 = lang2->GetLanguageType();
            if (lt1 == guessed_language)
              return true; // make the selected frame's language come first
            if (lt2 == guessed_language)
              return false; // make the selected frame's language come first
            return (lt1 < lt2); // normal comparison otherwise
          });
    }
  }

  bool is_first_language = true;

  for (Language *language : languages) {
    if (!language)
      continue;

    if (auto scavenger = language->GetTypeScavenger()) {
      Language::TypeScavenger::ResultSet search_results;
      if (scavenger->Find(best_scope, name_of_type, search_results) > 0) {
        for (const auto &search_result : search_results) {
          if (search_result && search_result->IsValid()) {
            any_found = true;
            search_result->DumpToStream(result.GetOutputStream(),
                                        this->m_command_options.m_show_help);
          }
        }
      }
    }
    // this is "type lookup SomeName" and we did find a match, so get out
    if (any_found && is_global_search)
      break;
    else if (is_first_language && is_global_search &&
             guessed_language != lldb::eLanguageTypeUnknown) {
      is_first_language = false;
      result.GetOutputStream().Printf(
          "no type was found in the current language %s matching '%s'; "
          "performing a global search across all languages\n",
          Language::GetNameForLanguageType(guessed_language), name_of_type);
    }
  }

  if (!any_found)
    result.AppendMessageWithFormat("no type was found matching '%s'\n",
                                   name_of_type);

  result.SetStatus(any_found ? lldb::eReturnStatusSuccessFinishResult
                             : lldb::eReturnStatusSuccessFinishNoResult);
  return true;
}
2997};

2999template <typename FormatterType>
3000class CommandObjectFormatterInfo : public CommandObjectRaw {
3001public:
typedef std::function<typename FormatterType::SharedPointer(ValueObject &)>
    DiscoveryFunction;
CommandObjectFormatterInfo(CommandInterpreter &interpreter,
                           const char *formatter_name,
                           DiscoveryFunction discovery_func)
    : CommandObjectRaw(interpreter, "", "", "",
                       eCommandRequiresFrame),
      m_formatter_name(formatter_name ? formatter_name : ""),
      m_discovery_function(discovery_func) {
  StreamString name;
  name.Printf("type %s info", formatter_name);
  SetCommandName(name.GetString());
  StreamString help;
  help.Printf("This command evaluates the provided expression and shows "
              "which %s is applied to the resulting value (if any).",
              formatter_name);
  SetHelp(help.GetString());
  StreamString syntax;
  syntax.Printf("type %s info <expr>", formatter_name);
  SetSyntax(syntax.GetString());
}

~CommandObjectFormatterInfo() override = default;

3026protected:
bool DoExecute(const char *command, CommandReturnObject &result) override {
  TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
  Thread *thread = GetDefaultThread();
  if (!thread) {
    result.AppendError("no default thread");
    result.SetStatus(lldb::eReturnStatusFailed);
    return false;
  }

  StackFrameSP frame_sp = thread->GetSelectedFrame();
  ValueObjectSP result_valobj_sp;
  EvaluateExpressionOptions options;
  lldb::ExpressionResults expr_result = target_sp->EvaluateExpression(
      command, frame_sp.get(), result_valobj_sp, options);
  if (expr_result == eExpressionCompleted && result_valobj_sp) {
    result_valobj_sp =
        result_valobj_sp->GetQualifiedRepresentationIfAvailable(
            target_sp->GetPreferDynamicValue(),
            target_sp->GetEnableSyntheticValue());
    typename FormatterType::SharedPointer formatter_sp =
        m_discovery_function(*result_valobj_sp);
    if (formatter_sp) {
      std::string description(formatter_sp->GetDescription());
      result.AppendMessageWithFormat(
          "%s applied to (%s) %s is: %s\n", m_formatter_name.c_str(),
          result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>"),
          command, description.c_str());
      result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
    } else {
      result.AppendMessageWithFormat(
          "no %s applies to (%s) %s\n", m_formatter_name.c_str(),
          result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>"),
          command);
      result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
    }
    return true;
  } else {
    result.AppendError("failed to evaluate expression");
    result.SetStatus(lldb::eReturnStatusFailed);
    return false;
  }
}

3070private:
std::string m_formatter_name;
DiscoveryFunction m_discovery_function;
3073};

3075class CommandObjectTypeFormat : public CommandObjectMultiword {
3076public:
CommandObjectTypeFormat(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "type format",
          "Commands for customizing value display formats.",
          "type format [<sub-command-options>] ") {
  LoadSubCommand(
      "add", CommandObjectSP(new CommandObjectTypeFormatAdd(interpreter)));
  LoadSubCommand("clear", CommandObjectSP(
                              new CommandObjectTypeFormatClear(interpreter)));
  LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeFormatDelete(
                               interpreter)));
  LoadSubCommand(
      "list", CommandObjectSP(new CommandObjectTypeFormatList(interpreter)));
  LoadSubCommand(
      "info", CommandObjectSP(new CommandObjectFormatterInfo<TypeFormatImpl>(
                  interpreter, "format",
                  [](ValueObject &valobj) -> TypeFormatImpl::SharedPointer {
                    return valobj.GetValueFormat();
                  })));
}

~CommandObjectTypeFormat() override = default;
3099};

3101#ifndef LLDB_DISABLE_PYTHON

3103class CommandObjectTypeSynth : public CommandObjectMultiword {
3104public:
CommandObjectTypeSynth(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "type synthetic",
          "Commands for operating on synthetic type representations.",
          "type synthetic [<sub-command-options>] ") {
  LoadSubCommand("add",
                 CommandObjectSP(new CommandObjectTypeSynthAdd(interpreter)));
  LoadSubCommand(
      "clear", CommandObjectSP(new CommandObjectTypeSynthClear(interpreter)));
  LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeSynthDelete(
                               interpreter)));
  LoadSubCommand(
      "list", CommandObjectSP(new CommandObjectTypeSynthList(interpreter)));
  LoadSubCommand(
      "info",
      CommandObjectSP(new CommandObjectFormatterInfo<SyntheticChildren>(
          interpreter, "synthetic",
          [](ValueObject &valobj) -> SyntheticChildren::SharedPointer {
            return valobj.GetSyntheticChildren();
          })));
}

~CommandObjectTypeSynth() override = default;
3128};

3130#endif // LLDB_DISABLE_PYTHON

3132class CommandObjectTypeFilter : public CommandObjectMultiword {
3133public:
CommandObjectTypeFilter(CommandInterpreter &interpreter)
    : CommandObjectMultiword(interpreter, "type filter",
                             "Commands for operating on type filters.",
                             "type synthetic [<sub-command-options>] ") {
  LoadSubCommand(
      "add", CommandObjectSP(new CommandObjectTypeFilterAdd(interpreter)));
  LoadSubCommand("clear", CommandObjectSP(
                              new CommandObjectTypeFilterClear(interpreter)));
  LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeFilterDelete(
                               interpreter)));
  LoadSubCommand(
      "list", CommandObjectSP(new CommandObjectTypeFilterList(interpreter)));
}

~CommandObjectTypeFilter() override = default;
3149};

3151class CommandObjectTypeCategory : public CommandObjectMultiword {
3152public:
CommandObjectTypeCategory(CommandInterpreter &interpreter)
    : CommandObjectMultiword(interpreter, "type category",
                             "Commands for operating on type categories.",
                             "type category [<sub-command-options>] ") {
  LoadSubCommand(
      "define",
      CommandObjectSP(new CommandObjectTypeCategoryDefine(interpreter)));
  LoadSubCommand(
      "enable",
      CommandObjectSP(new CommandObjectTypeCategoryEnable(interpreter)));
  LoadSubCommand(
      "disable",
      CommandObjectSP(new CommandObjectTypeCategoryDisable(interpreter)));
  LoadSubCommand(
      "delete",
      CommandObjectSP(new CommandObjectTypeCategoryDelete(interpreter)));
  LoadSubCommand("list", CommandObjectSP(
                             new CommandObjectTypeCategoryList(interpreter)));
}

~CommandObjectTypeCategory() override = default;
3174};

3176class CommandObjectTypeSummary : public CommandObjectMultiword {
3177public:
CommandObjectTypeSummary(CommandInterpreter &interpreter)
    : CommandObjectMultiword(
          interpreter, "type summary",
          "Commands for editing variable summary display options.",
          "type summary [<sub-command-options>] ") {
  LoadSubCommand(
      "add", CommandObjectSP(new CommandObjectTypeSummaryAdd(interpreter)));
  LoadSubCommand("clear", CommandObjectSP(new CommandObjectTypeSummaryClear(
                              interpreter)));
  LoadSubCommand("delete", CommandObjectSP(new CommandObjectTypeSummaryDelete(
                               interpreter)));
  LoadSubCommand(
      "list", CommandObjectSP(new CommandObjectTypeSummaryList(interpreter)));
  LoadSubCommand(
      "info", CommandObjectSP(new CommandObjectFormatterInfo<TypeSummaryImpl>(
                  interpreter, "summary",
                  [](ValueObject &valobj) -> TypeSummaryImpl::SharedPointer {
                    return valobj.GetSummaryFormat();
                  })));
}

~CommandObjectTypeSummary() override = default;
3200};

3202//-------------------------------------------------------------------------
3203// CommandObjectType
3204//-------------------------------------------------------------------------

3206CommandObjectType::CommandObjectType(CommandInterpreter &interpreter)
  : CommandObjectMultiword(interpreter, "type",
                           "Commands for operating on the type system.",
                           "type [<sub-command-options>]") {
LoadSubCommand("category",
               CommandObjectSP(new CommandObjectTypeCategory(interpreter)));
LoadSubCommand("filter",
               CommandObjectSP(new CommandObjectTypeFilter(interpreter)));
LoadSubCommand("format",
               CommandObjectSP(new CommandObjectTypeFormat(interpreter)));
LoadSubCommand("summary",
               CommandObjectSP(new CommandObjectTypeSummary(interpreter)));
3218#ifndef LLDB_DISABLE_PYTHON
LoadSubCommand("synthetic",
               CommandObjectSP(new CommandObjectTypeSynth(interpreter)));
3221#endif // LLDB_DISABLE_PYTHON
LoadSubCommand("lookup",
               CommandObjectSP(new CommandObjectTypeLookup(interpreter)));
3224}

3226CommandObjectType::~CommandObjectType() = default;

←

/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/include/lldb/DataFormatters/FormattersContainer.h

→

1//===-- FormattersContainer.h -----------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#ifndef lldb_FormattersContainer_h_
11#define lldb_FormattersContainer_h_

13// C Includes
14// C++ Includes
15#include <functional>
16#include <map>
17#include <memory>
18#include <mutex>
19#include <string>

21// Other libraries and framework includes
22// Project includes
23#include "lldb/lldb-public.h"

25#include "lldb/Core/ValueObject.h"
26#include "lldb/DataFormatters/FormatClasses.h"
27#include "lldb/DataFormatters/TypeFormat.h"
28#include "lldb/DataFormatters/TypeSummary.h"
29#include "lldb/DataFormatters/TypeSynthetic.h"
30#include "lldb/DataFormatters/TypeValidator.h"
31#include "lldb/Symbol/CompilerType.h"
32#include "lldb/Utility/RegularExpression.h"
33#include "lldb/Utility/StringLexer.h"

35namespace lldb_private {

37class IFormatChangeListener {
38public:
virtual ~IFormatChangeListener() = default;

virtual void Changed() = 0;

virtual uint32_t GetCurrentRevision() = 0;
44};

46// if the user tries to add formatters for, say, "struct Foo"
47// those will not match any type because of the way we strip qualifiers from
48// typenames
49// this method looks for the case where the user is adding a
50// "class","struct","enum" or "union" Foo
51// and strips the unnecessary qualifier
52static inline ConstString GetValidTypeName_Impl(const ConstString &type) {
if (type.IsEmpty())
  return type;

std::string type_cstr(type.AsCString());
lldb_utility::StringLexer type_lexer(type_cstr);

type_lexer.AdvanceIf("class ");
type_lexer.AdvanceIf("enum ");
type_lexer.AdvanceIf("struct ");
type_lexer.AdvanceIf("union ");

while (type_lexer.NextIf({' ', '\t', '\v', '\f'}).first)
  ;

return ConstString(type_lexer.GetUnlexed());
68}

70template <typename KeyType, typename ValueType> class FormattersContainer;

72template <typename KeyType, typename ValueType> class FormatMap {
73public:
typedef typename ValueType::SharedPointer ValueSP;
typedef std::map<KeyType, ValueSP> MapType;
typedef typename MapType::iterator MapIterator;
typedef std::function<bool(KeyType, const ValueSP &)> ForEachCallback;

FormatMap(IFormatChangeListener *lst)
    : m_map(), m_map_mutex(), listener(lst) {}

void Add(KeyType name, const ValueSP &entry) {
  if (listener)
21
←
Assuming the condition is false→
22
←
Taking false branch→
52
←
Assuming the condition is false→
53
←
Taking false branch→
    entry->GetRevision() = listener->GetCurrentRevision();
  else
    entry->GetRevision() = 0;

  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
  m_map[name] = entry;
23
←
Calling defaulted copy assignment operator for 'shared_ptr'→
40
←
Returning; memory was released→
54
←
Calling defaulted copy assignment operator for 'shared_ptr'→
  if (listener)
41
←
Assuming the condition is false→
42
←
Taking false branch→
    listener->Changed();
}

bool Delete(KeyType name) {
  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
  MapIterator iter = m_map.find(name);
  if (iter == m_map.end())
    return false;
  m_map.erase(name);
  if (listener)
    listener->Changed();
  return true;
}

void Clear() {
  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
  m_map.clear();
  if (listener)
    listener->Changed();
}

bool Get(KeyType name, ValueSP &entry) {
  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
  MapIterator iter = m_map.find(name);
  if (iter == m_map.end())
    return false;
  entry = iter->second;
  return true;
}

void ForEach(ForEachCallback callback) {
  if (callback) {
    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
    MapIterator pos, end = m_map.end();
    for (pos = m_map.begin(); pos != end; pos++) {
      KeyType type = pos->first;
      if (!callback(type, pos->second))
        break;
    }
  }
}

uint32_t GetCount() { return m_map.size(); }

ValueSP GetValueAtIndex(size_t index) {
  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
  MapIterator iter = m_map.begin();
  MapIterator end = m_map.end();
  while (index > 0) {
    iter++;
    index--;
    if (end == iter)
      return ValueSP();
  }
  return iter->second;
}

KeyType GetKeyAtIndex(size_t index) {
  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
  MapIterator iter = m_map.begin();
  MapIterator end = m_map.end();
  while (index > 0) {
    iter++;
    index--;
    if (end == iter)
      return KeyType();
  }
  return iter->first;
}

161protected:
MapType m_map;
std::recursive_mutex m_map_mutex;
IFormatChangeListener *listener;

MapType &map() { return m_map; }

std::recursive_mutex &mutex() { return m_map_mutex; }

friend class FormattersContainer<KeyType, ValueType>;
friend class FormatManager;
172};

174template <typename KeyType, typename ValueType> class FormattersContainer {
175protected:
typedef FormatMap<KeyType, ValueType> BackEndType;

178public:
typedef typename BackEndType::MapType MapType;
typedef typename MapType::iterator MapIterator;
typedef typename MapType::key_type MapKeyType;
typedef typename MapType::mapped_type MapValueType;
typedef typename BackEndType::ForEachCallback ForEachCallback;
typedef typename std::shared_ptr<FormattersContainer<KeyType, ValueType>>
    SharedPointer;

friend class TypeCategoryImpl;

FormattersContainer(std::string name, IFormatChangeListener *lst)
    : m_format_map(lst), m_name(name) {}

void Add(const MapKeyType &type, const MapValueType &entry) {
  Add_Impl(type, entry, static_cast<KeyType *>(nullptr));
19
←
Calling 'FormattersContainer::Add_Impl'→
44
←
Returning; memory was released→
50
←
Calling 'FormattersContainer::Add_Impl'→
}

bool Delete(ConstString type) {
  return Delete_Impl(type, static_cast<KeyType *>(nullptr));
}

bool Get(ValueObject &valobj, MapValueType &entry,
         lldb::DynamicValueType use_dynamic, uint32_t *why = nullptr) {
  uint32_t value = lldb_private::eFormatterChoiceCriterionDirectChoice;
  CompilerType ast_type(valobj.GetCompilerType());
  bool ret = Get(valobj, ast_type, entry, use_dynamic, value);
  if (ret)
    entry = MapValueType(entry);
  else
    entry = MapValueType();
  if (why)
    *why = value;
  return ret;
}

bool Get(ConstString type, MapValueType &entry) {
  return Get_Impl(type, entry, static_cast<KeyType *>(nullptr));
}

bool GetExact(ConstString type, MapValueType &entry) {
  return GetExact_Impl(type, entry, static_cast<KeyType *>(nullptr));
}

MapValueType GetAtIndex(size_t index) {
  return m_format_map.GetValueAtIndex(index);
}

lldb::TypeNameSpecifierImplSP GetTypeNameSpecifierAtIndex(size_t index) {
  return GetTypeNameSpecifierAtIndex_Impl(index,
                                          static_cast<KeyType *>(nullptr));
}

void Clear() { m_format_map.Clear(); }

void ForEach(ForEachCallback callback) { m_format_map.ForEach(callback); }

uint32_t GetCount() { return m_format_map.GetCount(); }

237protected:
BackEndType m_format_map;
std::string m_name;

DISALLOW_COPY_AND_ASSIGN(FormattersContainer)FormattersContainer(const FormattersContainer &) = delete
; const FormattersContainer &operator=(const FormattersContainer
 &) = delete;

void Add_Impl(const MapKeyType &type, const MapValueType &entry,
              lldb::RegularExpressionSP *dummy) {
  m_format_map.Add(type, entry);
}

void Add_Impl(const ConstString &type, const MapValueType &entry,
              ConstString *dummy) {
  m_format_map.Add(GetValidTypeName_Impl(type), entry);
20
←
Calling 'FormatMap::Add'→
43
←
Returning; memory was released→
51
←
Calling 'FormatMap::Add'→
}

bool Delete_Impl(ConstString type, ConstString *dummy) {
  return m_format_map.Delete(type);
}

bool Delete_Impl(ConstString type, lldb::RegularExpressionSP *dummy) {
  std::lock_guard<std::recursive_mutex> guard(m_format_map.mutex());
  MapIterator pos, end = m_format_map.map().end();
  for (pos = m_format_map.map().begin(); pos != end; pos++) {
    lldb::RegularExpressionSP regex = pos->first;
    if (type.GetStringRef() == regex->GetText()) {
      m_format_map.map().erase(pos);
      if (m_format_map.listener)
        m_format_map.listener->Changed();
      return true;
    }
  }
  return false;
}

bool Get_Impl(ConstString type, MapValueType &entry, ConstString *dummy) {
  return m_format_map.Get(type, entry);
}

bool GetExact_Impl(ConstString type, MapValueType &entry,
                   ConstString *dummy) {
  return Get_Impl(type, entry, static_cast<KeyType *>(nullptr));
}

lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierAtIndex_Impl(size_t index, ConstString *dummy) {
  ConstString key = m_format_map.GetKeyAtIndex(index);
  if (key)
    return lldb::TypeNameSpecifierImplSP(
        new TypeNameSpecifierImpl(key.AsCString(), false));
  else
    return lldb::TypeNameSpecifierImplSP();
}

lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierAtIndex_Impl(size_t index,
                                 lldb::RegularExpressionSP *dummy) {
  lldb::RegularExpressionSP regex = m_format_map.GetKeyAtIndex(index);
  if (regex.get() == nullptr)
    return lldb::TypeNameSpecifierImplSP();
  return lldb::TypeNameSpecifierImplSP(
      new TypeNameSpecifierImpl(regex->GetText().str().c_str(), true));
}

bool Get_Impl(ConstString key, MapValueType &value,
              lldb::RegularExpressionSP *dummy) {
  llvm::StringRef key_str = key.GetStringRef();
  std::lock_guard<std::recursive_mutex> guard(m_format_map.mutex());
  MapIterator pos, end = m_format_map.map().end();
  for (pos = m_format_map.map().begin(); pos != end; pos++) {
    lldb::RegularExpressionSP regex = pos->first;
    if (regex->Execute(key_str)) {
      value = pos->second;
      return true;
    }
  }
  return false;
}

bool GetExact_Impl(ConstString key, MapValueType &value,
                   lldb::RegularExpressionSP *dummy) {
  std::lock_guard<std::recursive_mutex> guard(m_format_map.mutex());
  MapIterator pos, end = m_format_map.map().end();
  for (pos = m_format_map.map().begin(); pos != end; pos++) {
    lldb::RegularExpressionSP regex = pos->first;
    if (regex->GetText() == key.GetStringRef()) {
      value = pos->second;
      return true;
    }
  }
  return false;
}

bool Get(const FormattersMatchVector &candidates, MapValueType &entry,
         uint32_t *reason) {
  for (const FormattersMatchCandidate &candidate : candidates) {
    if (Get(candidate.GetTypeName(), entry)) {
      if (candidate.IsMatch(entry) == false) {
        entry.reset();
        continue;
      } else {
        if (reason)
          *reason = candidate.GetReason();
        return true;
      }
    }
  }
  return false;
}
346};

348} // namespace lldb_private

350#endif // lldb_FormattersContainer_h_

←

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

→

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

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

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

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

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

25// 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
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;
  }

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


/**
 *  @brief  A smart pointer with reference-counted copy semantics.
 *
 *  The object pointed to is deleted when the last shared_ptr pointing to
 *  it is destroyed or reset.
*/
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:

    using element_type = typename __shared_ptr<_Tp>::element_type;

109#if __cplusplus201103L > 201402L
110# define __cpp_lib_shared_ptr_weak_type 201606
    using weak_type = weak_ptr<_Tp>;
112#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;

    /**
     *  @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 @a __p
     *          and shares ownership with @a __r.
     *  @param  __r  A %shared_ptr.
     *  @param  __p  A pointer that will remain valid while @a *__r is valid.
     *  @post   get() == __p && use_count() == __r.use_count()
     *
     *  This can be used to construct a @c shared_ptr to a sub-object
     *  of an object managed by an existing @c shared_ptr.
     *
     * @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) { }

    /**
     *  @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) { }

268#if _GLIBCXX_USE_DEPRECATED1
    template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
shared_ptr(auto_ptr<_Yp>&& __r);
271#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)) { }

280#if __cplusplus201103L <= 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()) { }
288#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;
24
←
Calling defaulted copy assignment operator for '__shared_ptr'→
39
←
Returning; memory was released→
55
←
Calling defaulted copy assignment operator for '__shared_ptr'→

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

306#if _GLIBCXX_USE_DEPRECATED1
    template<typename _Yp>
_Assignable<auto_ptr<_Yp>>
operator=(auto_ptr<_Yp>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}
314#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_make_shared_tag __tag, const _Alloc& __a,
   _Args&&... __args)
: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
{ }

    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>;
  };

358#if __cpp_deduction_guides >= 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>;
363#endif

// 20.7.2.2.7 shared_ptr comparisons
template<typename _Tp, typename _Up>
  inline bool
  operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() == __b.get(); }

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

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

template<typename _Tp, typename _Up>
  inline bool
  operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() != __b.get(); }

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

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

template<typename _Tp, typename _Up>
  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());
  }

template<typename _Tp>
  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);
  }

template<typename _Tp>
  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());
  }

template<typename _Tp, typename _Up>
  inline bool
  operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__b < __a); }

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

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

template<typename _Tp, typename _Up>
  inline bool
  operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return (__b < __a); }

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

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

template<typename _Tp, typename _Up>
  inline bool
  operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__a < __b); }

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

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

template<typename _Tp>
  struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
  { };

// 20.7.2.2.8 shared_ptr specialized algorithms.
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.
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()));
  }

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()));
  }

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();
  }

504#if __cplusplus201103L > 201402L
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()));
  }
512#endif

/**
 *  @brief  A smart pointer with weak semantics.
 *
 *  With forwarding constructors and assignment operators.
 */
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); }
  };

587#if __cpp_deduction_guides >= 201606
template<typename _Tp>
  weak_ptr(shared_ptr<_Tp>) ->  weak_ptr<_Tp>;
590#endif

// 20.7.2.3.6 weak_ptr specialized algorithms.
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
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); }

646#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
647#define __cpp_lib_enable_shared_from_this 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; }
655#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;
  };

/**
 *  @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_make_shared_tag(), __a,
	     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_const<_Tp>::type _Tp_nc;
    return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
		       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());
    }
  };

// @} group pointer_abstractions

724_GLIBCXX_END_NAMESPACE_VERSION
725} // namespace

727#endif // _SHARED_PTR_H

←

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

→

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

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

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

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

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

25// 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#if __cpp_rtti199711
53# include <typeinfo>
54#endif
55#include <bits/allocated_ptr.h>
56#include <bits/refwrap.h>
57#include <bits/stl_function.h>
58#include <ext/aligned_buffer.h>

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

64#if _GLIBCXX_USE_DEPRECATED1
template<typename> class auto_ptr;
66#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; }
35
←
Memory is released→

    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)
31
←
Taking true branch→
61
←
Calling '__exchange_and_add_dispatch'→
 {
          _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)
32
←
Taking false branch→
     {
__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,
33
←
Taking true branch→
				       -1) == 1)
            {
              _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
       _M_destroy();
34
←
Calling '_Sp_counted_base::_M_destroy'→
36
←
Returning; memory was released→
            }
 }
    }

    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
    {
483#if __cpp_rtti199711
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2400. shared_ptr's get_deleter() should use addressof()
      return __ti == typeid(_Deleter)
 ? std::__addressof(_M_impl._M_del())
 : nullptr;
489#else
      return nullptr;
491#endif
    }

  private:
    _Impl _M_impl;
  };

// helpers for make_shared / allocate_shared

struct _Sp_make_shared_tag { };

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>;

    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();
    }

    // Sneaky trick so __shared_ptr can get the managed pointer
    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept
    {
551#if __cpp_rtti199711
if (__ti == typeid(_Sp_make_shared_tag))
 return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
554#endif
return nullptr;
    }

  private:
    _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
  {
  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>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter, typename _Alloc>
__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(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
       _Args&&... __args)
: _M_pi(0)
{
 typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
 typename _Sp_cp_type::__allocator_type __a2(__a);
 auto __guard = std::__allocate_guarded(__a2);
 _Sp_cp_type* __mem = __guard.get();
 ::new (__mem) _Sp_cp_type(std::move(__a),
		    std::forward<_Args>(__args)...);
 _M_pi = __mem;
 __guard = nullptr;
}

643#if _GLIBCXX_USE_DEPRECATED1
    // Special case for auto_ptr<_Tp> to provide the strong guarantee.
    template<typename _Tp>
      explicit
__shared_count(std::auto_ptr<_Tp>&& __r);
648#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)
26
←
Taking true branch→
57
←
Taking true branch→
 {
   if (__tmp != 0)
27
←
Assuming '__tmp' is equal to null→
28
←
Taking false branch→
58
←
Taking false branch→
     __tmp->_M_add_ref_copy();
   if (_M_pi != 0)
29
←
Taking true branch→
59
←
Taking true branch→
     _M_pi->_M_release();
30
←
Calling '_Sp_counted_base::_M_release'→
37
←
Returning; memory was released→
60
←
Calling '_Sp_counted_base::_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;
  }

869#define __cpp_lib_shared_ptr_arrays201603 201603

// 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;

1001#if __cplusplus201103L <= 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();
    }
1017#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:

1068#if __cplusplus201103L > 201402L
    using weak_type = __weak_ptr<_Tp, _Lp>;
1070#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))
{ }

    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
{ }

    __shared_ptr(const __shared_ptr&) noexcept = default;
    __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
25
←
Calling copy assignment operator for '__shared_count'→
38
←
Returning; memory was released→
56
←
Calling copy assignment operator for '__shared_count'→
    ~__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 = _S_raw_ptr(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}

1165#if __cplusplus201103L <= 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 = _S_raw_ptr(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}
  public:
1181#endif

1183#if _GLIBCXX_USE_DEPRECATED1
    // Postcondition: use_count() == 1 and __r.get() == 0
    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(auto_ptr<_Yp>&& __r);
1187#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;
}

1200#if _GLIBCXX_USE_DEPRECATED1
    template<typename _Yp>
_Assignable<_Yp>
operator=(auto_ptr<_Yp>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}
1208#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); }

    element_type*
    get() const noexcept
    { return _M_ptr; }

    explicit operator bool() const // never throws
    { return _M_ptr == 0 ? false : true; }

    bool
    unique() const noexcept
    { return _M_refcount._M_unique(); }

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

    void
    swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
    {
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
    }

    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); }

1288#if __cpp_rtti199711
  protected:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
     _Args&&... __args)
: _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
		std::forward<_Args>(__args)...)
{
 // _M_ptr needs to point to the newly constructed object.
 // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
 void* __p = _M_refcount._M_get_deleter(typeid(__tag));
 _M_ptr = static_cast<_Tp*>(__p);
 _M_enable_shared_from_this_with(_M_ptr);
}
1303#else
    template<typename _Alloc>
      struct _Deleter
      {
        void operator()(typename _Alloc::value_type* __ptr)
        {
   __allocated_ptr<_Alloc> __guard{ _M_alloc, __ptr };
   allocator_traits<_Alloc>::destroy(_M_alloc, __guard.get());
        }
        _Alloc _M_alloc;
      };

    template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
     _Args&&... __args)
: _M_ptr(), _M_refcount()
{
 typedef typename allocator_traits<_Alloc>::template
   rebind_traits<typename std::remove_cv<_Tp>::type> __traits;
 _Deleter<typename __traits::allocator_type> __del = { __a };
 auto __guard = std::__allocate_guarded(__del._M_alloc);
 auto __ptr = __guard.get();
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2070. allocate_shared should use allocator_traits<A>::construct
 __traits::construct(__del._M_alloc, __ptr,
	      std::forward<_Args>(__args)...);
 __guard = nullptr;
 __shared_count<_Lp> __count(__ptr, __del, __del._M_alloc);
 _M_refcount._M_swap(__count);
 _M_ptr = __ptr;
 _M_enable_shared_from_this_with(_M_ptr);
}
1335#endif

    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>
static _Tp1*
_S_raw_ptr(_Tp1* __ptr)
{ return __ptr; }

    template<typename _Tp1>
static auto
_S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr))
{ return std::__addressof(*__ptr); }

    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;

    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; }

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); }

template<typename _Sp>
  struct _Sp_less : public binary_function<_Sp, _Sp, bool>
  {
    bool
    operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
    {
typedef typename _Sp::element_type element_type;
return std::less<element_type*>()(__lhs.get(), __rhs.get());
    }
  };

template<typename _Tp, _Lock_policy _Lp>
  struct less<__shared_ptr<_Tp, _Lp>>
  : public _Sp_less<__shared_ptr<_Tp, _Lp>>
  { };

// 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();
  }

1579#if __cplusplus201103L > 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()));
  }
1587#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); }

1806#if __cplusplus201103L > 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; }
1814#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, typename _Alloc, typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
		    std::forward<_Args>(__args)...);
  }

template<typename _Tp, _Lock_policy _Lp, 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());
    }
  };

1863_GLIBCXX_END_NAMESPACE_VERSION
1864} // namespace

1866#endif // _SHARED_PTR_BASE_H

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/ext/atomicity.h

1// Support for atomic operations -*- C++ -*-
2 
3// Copyright (C) 2004-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
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/atomicity.h
26 *  This file is a GNU extension to the Standard C++ Library.
27 */
28 
29#ifndef _GLIBCXX_ATOMICITY_H1
30#define _GLIBCXX_ATOMICITY_H1	1
31 
32#pragma GCC system_header
33 
34#include <bits/c++config.h>
35#include <bits/gthr.h>
36#include <bits/atomic_word.h>
37 
38namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
39{
40_GLIBCXX_BEGIN_NAMESPACE_VERSION
41 
42  // Functions for portable atomic access.
43  // To abstract locking primitives across all thread policies, use:
44  // __exchange_and_add_dispatch
45  // __atomic_add_dispatch
46#ifdef _GLIBCXX_ATOMIC_BUILTINS1
47  static inline _Atomic_word 
48  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
49  { return __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL4); }
50 
51  static inline void
52  __atomic_add(volatile _Atomic_word* __mem, int __val)
53  { __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL4); }
54#else
55  _Atomic_word
56  __attribute__ ((__unused__))
57  __exchange_and_add(volatile _Atomic_word*, int) throw ();
58 
59  void
60  __attribute__ ((__unused__))
61  __atomic_add(volatile _Atomic_word*, int) throw ();
62#endif
63 
64  static inline _Atomic_word
65  __exchange_and_add_single(_Atomic_word* __mem, int __val)
66  {
67    _Atomic_word __result = *__mem;
65
←
Use of memory after it is freed
68    *__mem += __val;
69    return __result;
70  }
71 
72  static inline void
73  __atomic_add_single(_Atomic_word* __mem, int __val)
74  { *__mem += __val; }
75 
76  static inline _Atomic_word
77  __attribute__ ((__unused__))
78  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
79  {
80#ifdef __GTHREADS1
81    if (__gthread_active_p())
62
←
Assuming the condition is false→
63
←
Taking false branch→
82      return __exchange_and_add(__mem, __val);
83    else
84      return __exchange_and_add_single(__mem, __val);
64
←
Calling '__exchange_and_add_single'→
85#else
86    return __exchange_and_add_single(__mem, __val);
87#endif
88  }
89 
90  static inline void
91  __attribute__ ((__unused__))
92  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
93  {
94#ifdef __GTHREADS1
95    if (__gthread_active_p())
96      __atomic_add(__mem, __val);
97    else
98      __atomic_add_single(__mem, __val);
99#else
100    __atomic_add_single(__mem, __val);
101#endif
102  }
103 
104_GLIBCXX_END_NAMESPACE_VERSION
105} // namespace
106 
107// Even if the CPU doesn't need a memory barrier, we need to ensure
108// that the compiler doesn't reorder memory accesses across the
109// barriers.
110#ifndef _GLIBCXX_READ_MEM_BARRIER__atomic_thread_fence (2)
111#define _GLIBCXX_READ_MEM_BARRIER__atomic_thread_fence (2) __atomic_thread_fence (__ATOMIC_ACQUIRE2)
112#endif
113#ifndef _GLIBCXX_WRITE_MEM_BARRIER__atomic_thread_fence (3)
114#define _GLIBCXX_WRITE_MEM_BARRIER__atomic_thread_fence (3) __atomic_thread_fence (__ATOMIC_RELEASE3)
115#endif
116 
117#endif 