/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/API/SBValue.cpp

Bug Summary

File:	tools/lldb/source/API/SBValue.cpp
Warning:	line 476, column 7 Inner pointer of container used after re/deallocation

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 SBValue.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -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-8/lib/clang/8.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/source/API -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/API -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.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-8~svn345461/build-llvm/tools/lldb/source/API -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/API/SBValue.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/API/SBValue.cpp

→

1//===-- SBValue.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 "lldb/API/SBValue.h"

12#include "lldb/API/SBDeclaration.h"
13#include "lldb/API/SBStream.h"
14#include "lldb/API/SBTypeFilter.h"
15#include "lldb/API/SBTypeFormat.h"
16#include "lldb/API/SBTypeSummary.h"
17#include "lldb/API/SBTypeSynthetic.h"

19#include "lldb/Breakpoint/Watchpoint.h"
20#include "lldb/Core/Module.h"
21#include "lldb/Core/Section.h"
22#include "lldb/Core/StreamFile.h"
23#include "lldb/Core/Value.h"
24#include "lldb/Core/ValueObject.h"
25#include "lldb/Core/ValueObjectConstResult.h"
26#include "lldb/DataFormatters/DataVisualization.h"
27#include "lldb/Symbol/Block.h"
28#include "lldb/Symbol/Declaration.h"
29#include "lldb/Symbol/ObjectFile.h"
30#include "lldb/Symbol/Type.h"
31#include "lldb/Symbol/Variable.h"
32#include "lldb/Symbol/VariableList.h"
33#include "lldb/Target/ExecutionContext.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/Utility/DataExtractor.h"
39#include "lldb/Utility/Log.h"
40#include "lldb/Utility/Scalar.h"
41#include "lldb/Utility/Stream.h"

43#include "lldb/API/SBDebugger.h"
44#include "lldb/API/SBExpressionOptions.h"
45#include "lldb/API/SBFrame.h"
46#include "lldb/API/SBProcess.h"
47#include "lldb/API/SBTarget.h"
48#include "lldb/API/SBThread.h"

50using namespace lldb;
51using namespace lldb_private;

53class ValueImpl {
54public:
ValueImpl() {}

ValueImpl(lldb::ValueObjectSP in_valobj_sp,
          lldb::DynamicValueType use_dynamic, bool use_synthetic,
          const char *name = NULL__null)
    : m_valobj_sp(), m_use_dynamic(use_dynamic),
      m_use_synthetic(use_synthetic), m_name(name) {
  if (in_valobj_sp) {
    if ((m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(
             lldb::eNoDynamicValues, false))) {
      if (!m_name.IsEmpty())
        m_valobj_sp->SetName(m_name);
    }
  }
}

ValueImpl(const ValueImpl &rhs)
    : m_valobj_sp(rhs.m_valobj_sp), m_use_dynamic(rhs.m_use_dynamic),
      m_use_synthetic(rhs.m_use_synthetic), m_name(rhs.m_name) {}

ValueImpl &operator=(const ValueImpl &rhs) {
  if (this != &rhs) {
    m_valobj_sp = rhs.m_valobj_sp;
    m_use_dynamic = rhs.m_use_dynamic;
    m_use_synthetic = rhs.m_use_synthetic;
    m_name = rhs.m_name;
  }
  return *this;
}

bool IsValid() {
  if (m_valobj_sp.get() == NULL__null)
    return false;
  else {
    // FIXME: This check is necessary but not sufficient.  We for sure don't
    // want to touch SBValues whose owning
    // targets have gone away.  This check is a little weak in that it
    // enforces that restriction when you call IsValid, but since IsValid
    // doesn't lock the target, you have no guarantee that the SBValue won't
    // go invalid after you call this... Also, an SBValue could depend on
    // data from one of the modules in the target, and those could go away
    // independently of the target, for instance if a module is unloaded.
    // But right now, neither SBValues nor ValueObjects know which modules
    // they depend on.  So I have no good way to make that check without
    // tracking that in all the ValueObject subclasses.
    TargetSP target_sp = m_valobj_sp->GetTargetSP();
    if (target_sp && target_sp->IsValid())
      return true;
    else
      return false;
  }
}

lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; }

lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker,
                          std::unique_lock<std::recursive_mutex> &lock,
                          Status &error) {
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
  if (!m_valobj_sp) {
    error.SetErrorString("invalid value object");
    return m_valobj_sp;
  }

  lldb::ValueObjectSP value_sp = m_valobj_sp;

  Target *target = value_sp->GetTargetSP().get();
  if (!target)
    return ValueObjectSP();

  lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex());

  ProcessSP process_sp(value_sp->GetProcessSP());
  if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) {
    // We don't allow people to play around with ValueObject if the process
    // is running. If you want to look at values, pause the process, then
    // look.
    if (log)
      log->Printf("SBValue(%p)::GetSP() => error: process is running",
                  static_cast<void *>(value_sp.get()));
    error.SetErrorString("process must be stopped.");
    return ValueObjectSP();
  }

  if (m_use_dynamic != eNoDynamicValues) {
    ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic);
    if (dynamic_sp)
      value_sp = dynamic_sp;
  }

  if (m_use_synthetic) {
    ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue(m_use_synthetic);
    if (synthetic_sp)
      value_sp = synthetic_sp;
  }

  if (!value_sp)
    error.SetErrorString("invalid value object");
  if (!m_name.IsEmpty())
    value_sp->SetName(m_name);

  return value_sp;
}

void SetUseDynamic(lldb::DynamicValueType use_dynamic) {
  m_use_dynamic = use_dynamic;
}

void SetUseSynthetic(bool use_synthetic) { m_use_synthetic = use_synthetic; }

lldb::DynamicValueType GetUseDynamic() { return m_use_dynamic; }

bool GetUseSynthetic() { return m_use_synthetic; }

// All the derived values that we would make from the m_valobj_sp will share
// the ExecutionContext with m_valobj_sp, so we don't need to do the
// calculations in GetSP to return the Target, Process, Thread or Frame.  It
// is convenient to provide simple accessors for these, which I do here.
TargetSP GetTargetSP() {
  if (m_valobj_sp)
    return m_valobj_sp->GetTargetSP();
  else
    return TargetSP();
}

ProcessSP GetProcessSP() {
  if (m_valobj_sp)
    return m_valobj_sp->GetProcessSP();
  else
    return ProcessSP();
}

ThreadSP GetThreadSP() {
  if (m_valobj_sp)
    return m_valobj_sp->GetThreadSP();
  else
    return ThreadSP();
}

StackFrameSP GetFrameSP() {
  if (m_valobj_sp)
    return m_valobj_sp->GetFrameSP();
  else
    return StackFrameSP();
}

201private:
lldb::ValueObjectSP m_valobj_sp;
lldb::DynamicValueType m_use_dynamic;
bool m_use_synthetic;
ConstString m_name;
206};

208class ValueLocker {
209public:
ValueLocker() {}

ValueObjectSP GetLockedSP(ValueImpl &in_value) {
  return in_value.GetSP(m_stop_locker, m_lock, m_lock_error);
}

Status &GetError() { return m_lock_error; }

218private:
Process::StopLocker m_stop_locker;
std::unique_lock<std::recursive_mutex> m_lock;
Status m_lock_error;
222};

224SBValue::SBValue() : m_opaque_sp() {}

226SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { SetSP(value_sp); }

228SBValue::SBValue(const SBValue &rhs) { SetSP(rhs.m_opaque_sp); }

230SBValue &SBValue::operator=(const SBValue &rhs) {
if (this != &rhs) {
  SetSP(rhs.m_opaque_sp);
}
return *this;
235}

237SBValue::~SBValue() {}

239bool SBValue::IsValid() {
// If this function ever changes to anything that does more than just check
// if the opaque shared pointer is non NULL, then we need to update all "if
// (m_opaque_sp)" code in this file.
return m_opaque_sp.get() != NULL__null && m_opaque_sp->IsValid() &&
       m_opaque_sp->GetRootSP().get() != NULL__null;
245}

247void SBValue::Clear() { m_opaque_sp.reset(); }

249SBError SBValue::GetError() {
SBError sb_error;

ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  sb_error.SetError(value_sp->GetError());
else
  sb_error.SetErrorStringWithFormat("error: %s",
                                    locker.GetError().AsCString());

return sb_error;
261}

263user_id_t SBValue::GetID() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  return value_sp->GetID();
return LLDB_INVALID_UID(18446744073709551615UL);
269}

271const char *SBValue::GetName() {
const char *name = NULL__null;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  name = value_sp->GetName().GetCString();

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  if (name)
    log->Printf("SBValue(%p)::GetName () => \"%s\"",
                static_cast<void *>(value_sp.get()), name);
  else
    log->Printf("SBValue(%p)::GetName () => NULL",
                static_cast<void *>(value_sp.get()));
}

return name;
289}

291const char *SBValue::GetTypeName() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
const char *name = NULL__null;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  name = value_sp->GetQualifiedTypeName().GetCString();
}

if (log) {
  if (name)
    log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
                static_cast<void *>(value_sp.get()), name);
  else
    log->Printf("SBValue(%p)::GetTypeName () => NULL",
                static_cast<void *>(value_sp.get()));
}

return name;
310}

312const char *SBValue::GetDisplayTypeName() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
const char *name = NULL__null;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  name = value_sp->GetDisplayTypeName().GetCString();
}

if (log) {
  if (name)
    log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
                static_cast<void *>(value_sp.get()), name);
  else
    log->Printf("SBValue(%p)::GetTypeName () => NULL",
                static_cast<void *>(value_sp.get()));
}

return name;
331}

333size_t SBValue::GetByteSize() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
size_t result = 0;

ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  result = value_sp->GetByteSize();
}

if (log)
  log->Printf("SBValue(%p)::GetByteSize () => %" PRIu64"l" "u",
              static_cast<void *>(value_sp.get()),
              static_cast<uint64_t>(result));

return result;
349}

351bool SBValue::IsInScope() {
bool result = false;

ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  result = value_sp->IsInScope();
}

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log)
  log->Printf("SBValue(%p)::IsInScope () => %i",
              static_cast<void *>(value_sp.get()), result);

return result;
366}

368const char *SBValue::GetValue() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));

const char *cstr = NULL__null;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  cstr = value_sp->GetValueAsCString();
}
if (log) {
  if (cstr)
    log->Printf("SBValue(%p)::GetValue() => \"%s\"",
                static_cast<void *>(value_sp.get()), cstr);
  else
    log->Printf("SBValue(%p)::GetValue() => NULL",
                static_cast<void *>(value_sp.get()));
}

return cstr;
387}

389ValueType SBValue::GetValueType() {
ValueType result = eValueTypeInvalid;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  result = value_sp->GetValueType();

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  switch (result) {
  case eValueTypeInvalid:
    log->Printf("SBValue(%p)::GetValueType () => eValueTypeInvalid",
                static_cast<void *>(value_sp.get()));
    break;
  case eValueTypeVariableGlobal:
    log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal",
                static_cast<void *>(value_sp.get()));
    break;
  case eValueTypeVariableStatic:
    log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableStatic",
                static_cast<void *>(value_sp.get()));
    break;
  case eValueTypeVariableArgument:
    log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableArgument",
                static_cast<void *>(value_sp.get()));
    break;
  case eValueTypeVariableLocal:
    log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableLocal",
                static_cast<void *>(value_sp.get()));
    break;
  case eValueTypeRegister:
    log->Printf("SBValue(%p)::GetValueType () => eValueTypeRegister",
                static_cast<void *>(value_sp.get()));
    break;
  case eValueTypeRegisterSet:
    log->Printf("SBValue(%p)::GetValueType () => eValueTypeRegisterSet",
                static_cast<void *>(value_sp.get()));
    break;
  case eValueTypeConstResult:
    log->Printf("SBValue(%p)::GetValueType () => eValueTypeConstResult",
                static_cast<void *>(value_sp.get()));
    break;
  case eValueTypeVariableThreadLocal:
    log->Printf(
        "SBValue(%p)::GetValueType () => eValueTypeVariableThreadLocal",
        static_cast<void *>(value_sp.get()));
    break;
  }
}
return result;
439}

441const char *SBValue::GetObjectDescription() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
const char *cstr = NULL__null;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  cstr = value_sp->GetObjectDescription();
}
if (log) {
  if (cstr)
    log->Printf("SBValue(%p)::GetObjectDescription() => \"%s\"",
                static_cast<void *>(value_sp.get()), cstr);
  else
    log->Printf("SBValue(%p)::GetObjectDescription() => NULL",
                static_cast<void *>(value_sp.get()));
}
return cstr;
458}

460const char *SBValue::GetTypeValidatorResult() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
const char *cstr = NULL__null;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
1
Assuming the condition is true→
2
←
Taking true branch→
  const auto &validation(value_sp->GetValidationStatus());
  if (TypeValidatorResult::Failure == validation.first) {
3
←
Assuming the condition is true→
4
←
Taking true branch→
    if (validation.second.empty())
5
←
Assuming the condition is false→
6
←
Taking false branch→
      cstr = "unknown error";
    else
      cstr = validation.second.c_str();
7
←
Pointer to inner buffer of 'class std::__cxx11::basic_string<char>' obtained here→
  }
}
8
←
Calling implicit destructor for 'pair<lldb_private::TypeValidatorResult, std::__cxx11::basic_string<char>>'→
10
←
Returning from destructor for 'pair<lldb_private::TypeValidatorResult, std::__cxx11::basic_string<char>>'→
if (log) {
11
←
Assuming 'log' is non-null→
12
←
Taking true branch→
  if (cstr)
13
←
Assuming 'cstr' is non-null→
14
←
Taking true branch→
    log->Printf("SBValue(%p)::GetTypeValidatorResult() => \"%s\"",
15
←
Inner pointer of container used after re/deallocation
                static_cast<void *>(value_sp.get()), cstr);
  else
    log->Printf("SBValue(%p)::GetTypeValidatorResult() => NULL",
                static_cast<void *>(value_sp.get()));
}
return cstr;
483}

485SBType SBValue::GetType() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
SBType sb_type;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
TypeImplSP type_sp;
if (value_sp) {
  type_sp.reset(new TypeImpl(value_sp->GetTypeImpl()));
  sb_type.SetSP(type_sp);
}
if (log) {
  if (type_sp)
    log->Printf("SBValue(%p)::GetType => SBType(%p)",
                static_cast<void *>(value_sp.get()),
                static_cast<void *>(type_sp.get()));
  else
    log->Printf("SBValue(%p)::GetType => NULL",
                static_cast<void *>(value_sp.get()));
}
return sb_type;
505}

507bool SBValue::GetValueDidChange() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
bool result = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  if (value_sp->UpdateValueIfNeeded(false))
    result = value_sp->GetValueDidChange();
}
if (log)
  log->Printf("SBValue(%p)::GetValueDidChange() => %i",
              static_cast<void *>(value_sp.get()), result);

return result;
521}

523const char *SBValue::GetSummary() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
const char *cstr = NULL__null;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  cstr = value_sp->GetSummaryAsCString();
}
if (log) {
  if (cstr)
    log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
                static_cast<void *>(value_sp.get()), cstr);
  else
    log->Printf("SBValue(%p)::GetSummary() => NULL",
                static_cast<void *>(value_sp.get()));
}
return cstr;
540}

542const char *SBValue::GetSummary(lldb::SBStream &stream,
                              lldb::SBTypeSummaryOptions &options) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  std::string buffer;
  if (value_sp->GetSummaryAsCString(buffer, options.ref()) && !buffer.empty())
    stream.Printf("%s", buffer.c_str());
}
const char *cstr = stream.GetData();
if (log) {
  if (cstr)
    log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
                static_cast<void *>(value_sp.get()), cstr);
  else
    log->Printf("SBValue(%p)::GetSummary() => NULL",
                static_cast<void *>(value_sp.get()));
}
return cstr;
562}

564const char *SBValue::GetLocation() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
const char *cstr = NULL__null;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  cstr = value_sp->GetLocationAsCString();
}
if (log) {
  if (cstr)
    log->Printf("SBValue(%p)::GetLocation() => \"%s\"",
                static_cast<void *>(value_sp.get()), cstr);
  else
    log->Printf("SBValue(%p)::GetLocation() => NULL",
                static_cast<void *>(value_sp.get()));
}
return cstr;
581}

583// Deprecated - use the one that takes an lldb::SBError
584bool SBValue::SetValueFromCString(const char *value_str) {
lldb::SBError dummy;
return SetValueFromCString(value_str, dummy);
587}

589bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
bool success = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (value_sp) {
  success = value_sp->SetValueFromCString(value_str, error.ref());
} else
  error.SetErrorStringWithFormat("Could not get value: %s",
                                 locker.GetError().AsCString());

if (log)
  log->Printf("SBValue(%p)::SetValueFromCString(\"%s\") => %i",
              static_cast<void *>(value_sp.get()), value_str, success);

return success;
605}

607lldb::SBTypeFormat SBValue::GetTypeFormat() {
lldb::SBTypeFormat format;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  if (value_sp->UpdateValueIfNeeded(true)) {
    lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat();
    if (format_sp)
      format.SetSP(format_sp);
  }
}
return format;
619}

621lldb::SBTypeSummary SBValue::GetTypeSummary() {
lldb::SBTypeSummary summary;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  if (value_sp->UpdateValueIfNeeded(true)) {
    lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat();
    if (summary_sp)
      summary.SetSP(summary_sp);
  }
}
return summary;
633}

635lldb::SBTypeFilter SBValue::GetTypeFilter() {
lldb::SBTypeFilter filter;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  if (value_sp->UpdateValueIfNeeded(true)) {
    lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren();

    if (synthetic_sp && !synthetic_sp->IsScripted()) {
      TypeFilterImplSP filter_sp =
          std::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
      filter.SetSP(filter_sp);
    }
  }
}
return filter;
651}

653#ifndef LLDB_DISABLE_PYTHON
654lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
lldb::SBTypeSynthetic synthetic;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  if (value_sp->UpdateValueIfNeeded(true)) {
    lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren();

    if (children_sp && children_sp->IsScripted()) {
      ScriptedSyntheticChildrenSP synth_sp =
          std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
      synthetic.SetSP(synth_sp);
    }
  }
}
return synthetic;
670}
671#endif

673lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
                                         SBType type) {
lldb::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
lldb::ValueObjectSP new_value_sp;
if (value_sp) {
  TypeImplSP type_sp(type.GetSP());
  if (type.IsValid()) {
    sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(
                       offset, type_sp->GetCompilerType(false), true),
                   GetPreferDynamicValue(), GetPreferSyntheticValue(), name);
  }
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  if (new_value_sp)
    log->Printf("SBValue(%p)::CreateChildAtOffset => \"%s\"",
                static_cast<void *>(value_sp.get()),
                new_value_sp->GetName().AsCString());
  else
    log->Printf("SBValue(%p)::CreateChildAtOffset => NULL",
                static_cast<void *>(value_sp.get()));
}
return sb_value;
698}

700lldb::SBValue SBValue::Cast(SBType type) {
lldb::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
TypeImplSP type_sp(type.GetSP());
if (value_sp && type_sp)
  sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),
                 GetPreferDynamicValue(), GetPreferSyntheticValue());
return sb_value;
709}

711lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
                                               const char *expression) {
SBExpressionOptions options;
options.ref().SetKeepInMemory(true);
return CreateValueFromExpression(name, expression, options);
716}

718lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
                                               const char *expression,
                                               SBExpressionOptions &options) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
lldb::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
lldb::ValueObjectSP new_value_sp;
if (value_sp) {
  ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
  new_value_sp = ValueObject::CreateValueObjectFromExpression(
      name, expression, exe_ctx, options.ref());
  if (new_value_sp)
    new_value_sp->SetName(ConstString(name));
}
sb_value.SetSP(new_value_sp);
if (log) {
  if (new_value_sp)
    log->Printf("SBValue(%p)::CreateValueFromExpression(name=\"%s\", "
                "expression=\"%s\") => SBValue (%p)",
                static_cast<void *>(value_sp.get()), name, expression,
                static_cast<void *>(new_value_sp.get()));
  else
    log->Printf("SBValue(%p)::CreateValueFromExpression(name=\"%s\", "
                "expression=\"%s\") => NULL",
                static_cast<void *>(value_sp.get()), name, expression);
}
return sb_value;
746}

748lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
                                            lldb::addr_t address,
                                            SBType sb_type) {
lldb::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
lldb::ValueObjectSP new_value_sp;
lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
if (value_sp && type_impl_sp) {
  CompilerType ast_type(type_impl_sp->GetCompilerType(true));
  ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
  new_value_sp = ValueObject::CreateValueObjectFromAddress(name, address,
                                                           exe_ctx, ast_type);
}
sb_value.SetSP(new_value_sp);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  if (new_value_sp)
    log->Printf("SBValue(%p)::CreateValueFromAddress => \"%s\"",
                static_cast<void *>(value_sp.get()),
                new_value_sp->GetName().AsCString());
  else
    log->Printf("SBValue(%p)::CreateValueFromAddress => NULL",
                static_cast<void *>(value_sp.get()));
}
return sb_value;
774}

776lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
                                         SBType sb_type) {
lldb::SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
if (value_sp && type_impl_sp) {
  ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
  new_value_sp = ValueObject::CreateValueObjectFromData(
      name, **data, exe_ctx, type_impl_sp->GetCompilerType(true));
  new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
}
sb_value.SetSP(new_value_sp);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  if (new_value_sp)
    log->Printf("SBValue(%p)::CreateValueFromData => \"%s\"",
                static_cast<void *>(value_sp.get()),
                new_value_sp->GetName().AsCString());
  else
    log->Printf("SBValue(%p)::CreateValueFromData => NULL",
                static_cast<void *>(value_sp.get()));
}
return sb_value;
801}

803SBValue SBValue::GetChildAtIndex(uint32_t idx) {
const bool can_create_synthetic = false;
lldb::DynamicValueType use_dynamic = eNoDynamicValues;
TargetSP target_sp;
if (m_opaque_sp)
  target_sp = m_opaque_sp->GetTargetSP();

if (target_sp)
  use_dynamic = target_sp->GetPreferDynamicValue();

return GetChildAtIndex(idx, use_dynamic, can_create_synthetic);
814}

816SBValue SBValue::GetChildAtIndex(uint32_t idx,
                               lldb::DynamicValueType use_dynamic,
                               bool can_create_synthetic) {
lldb::ValueObjectSP child_sp;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));

ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  const bool can_create = true;
  child_sp = value_sp->GetChildAtIndex(idx, can_create);
  if (can_create_synthetic && !child_sp) {
    child_sp = value_sp->GetSyntheticArrayMember(idx, can_create);
  }
}

SBValue sb_value;
sb_value.SetSP(child_sp, use_dynamic, GetPreferSyntheticValue());
if (log)
  log->Printf("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)",
              static_cast<void *>(value_sp.get()), idx,
              static_cast<void *>(value_sp.get()));

return sb_value;
840}

842uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
uint32_t idx = UINT32_MAX(4294967295U);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  idx = value_sp->GetIndexOfChildWithName(ConstString(name));
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  if (idx == UINT32_MAX(4294967295U))
    log->Printf(
        "SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND",
        static_cast<void *>(value_sp.get()), name);
  else
    log->Printf("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u",
                static_cast<void *>(value_sp.get()), name, idx);
}
return idx;
860}

862SBValue SBValue::GetChildMemberWithName(const char *name) {
lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
TargetSP target_sp;
if (m_opaque_sp)
  target_sp = m_opaque_sp->GetTargetSP();

if (target_sp)
  use_dynamic_value = target_sp->GetPreferDynamicValue();
return GetChildMemberWithName(name, use_dynamic_value);
871}

873SBValue
874SBValue::GetChildMemberWithName(const char *name,
                              lldb::DynamicValueType use_dynamic_value) {
lldb::ValueObjectSP child_sp;
const ConstString str_name(name);

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));

ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  child_sp = value_sp->GetChildMemberWithName(str_name, true);
}

SBValue sb_value;
sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());

if (log)
  log->Printf(
      "SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)",
      static_cast<void *>(value_sp.get()), name,
      static_cast<void *>(value_sp.get()));

return sb_value;
897}

899lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
SBValue value_sb;
if (IsValid()) {
  ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), use_dynamic,
                                     m_opaque_sp->GetUseSynthetic()));
  value_sb.SetSP(proxy_sp);
}
return value_sb;
907}

909lldb::SBValue SBValue::GetStaticValue() {
SBValue value_sb;
if (IsValid()) {
  ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
                                     eNoDynamicValues,
                                     m_opaque_sp->GetUseSynthetic()));
  value_sb.SetSP(proxy_sp);
}
return value_sb;
918}

920lldb::SBValue SBValue::GetNonSyntheticValue() {
SBValue value_sb;
if (IsValid()) {
  ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
                                     m_opaque_sp->GetUseDynamic(), false));
  value_sb.SetSP(proxy_sp);
}
return value_sb;
928}

930lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
if (!IsValid())
  return eNoDynamicValues;
return m_opaque_sp->GetUseDynamic();
934}

936void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
if (IsValid())
  return m_opaque_sp->SetUseDynamic(use_dynamic);
939}

941bool SBValue::GetPreferSyntheticValue() {
if (!IsValid())
  return false;
return m_opaque_sp->GetUseSynthetic();
945}

947void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
if (IsValid())
  return m_opaque_sp->SetUseSynthetic(use_synthetic);
950}

952bool SBValue::IsDynamic() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  return value_sp->IsDynamic();
return false;
958}

960bool SBValue::IsSynthetic() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  return value_sp->IsSynthetic();
return false;
966}

968bool SBValue::IsSyntheticChildrenGenerated() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  return value_sp->IsSyntheticChildrenGenerated();
return false;
974}

976void SBValue::SetSyntheticChildrenGenerated(bool is) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  return value_sp->SetSyntheticChildrenGenerated(is);
981}

983lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
lldb::ValueObjectSP child_sp;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  // using default values for all the fancy options, just do it if you can
  child_sp = value_sp->GetValueForExpressionPath(expr_path);
}

SBValue sb_value;
sb_value.SetSP(child_sp, GetPreferDynamicValue(), GetPreferSyntheticValue());

if (log)
  log->Printf("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => "
              "SBValue(%p)",
              static_cast<void *>(value_sp.get()), expr_path,
              static_cast<void *>(value_sp.get()));

return sb_value;
1003}

1005int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
error.Clear();
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  bool success = true;
  uint64_t ret_val = fail_value;
  ret_val = value_sp->GetValueAsSigned(fail_value, &success);
  if (!success)
    error.SetErrorString("could not resolve value");
  return ret_val;
} else
  error.SetErrorStringWithFormat("could not get SBValue: %s",
                                 locker.GetError().AsCString());

return fail_value;
1021}

1023uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
error.Clear();
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  bool success = true;
  uint64_t ret_val = fail_value;
  ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
  if (!success)
    error.SetErrorString("could not resolve value");
  return ret_val;
} else
  error.SetErrorStringWithFormat("could not get SBValue: %s",
                                 locker.GetError().AsCString());

return fail_value;
1039}

1041int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  return value_sp->GetValueAsSigned(fail_value);
}
return fail_value;
1048}

1050uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  return value_sp->GetValueAsUnsigned(fail_value);
}
return fail_value;
1057}

1059bool SBValue::MightHaveChildren() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
bool has_children = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  has_children = value_sp->MightHaveChildren();

if (log)
  log->Printf("SBValue(%p)::MightHaveChildren() => %i",
              static_cast<void *>(value_sp.get()), has_children);
return has_children;
1071}

1073bool SBValue::IsRuntimeSupportValue() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
bool is_support = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  is_support = value_sp->IsRuntimeSupportValue();

if (log)
  log->Printf("SBValue(%p)::IsRuntimeSupportValue() => %i",
              static_cast<void *>(value_sp.get()), is_support);
return is_support;
1085}

1087uint32_t SBValue::GetNumChildren() { return GetNumChildren(UINT32_MAX(4294967295U)); }

1089uint32_t SBValue::GetNumChildren(uint32_t max) {
uint32_t num_children = 0;

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  num_children = value_sp->GetNumChildren(max);

if (log)
  log->Printf("SBValue(%p)::GetNumChildren (%u) => %u",
              static_cast<void *>(value_sp.get()), max, num_children);

return num_children;
1103}

1105SBValue SBValue::Dereference() {
SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  Status error;
  sb_value = value_sp->Dereference(error);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log)
  log->Printf("SBValue(%p)::Dereference () => SBValue(%p)",
              static_cast<void *>(value_sp.get()),
              static_cast<void *>(value_sp.get()));

return sb_value;
1120}

1122// Deprecated - please use GetType().IsPointerType() instead.
1123bool SBValue::TypeIsPointerType() { return GetType().IsPointerType(); }

1125void *SBValue::GetOpaqueType() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  return value_sp->GetCompilerType().GetOpaqueQualType();
return NULL__null;
1131}

1133lldb::SBTarget SBValue::GetTarget() {
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp) {
  target_sp = m_opaque_sp->GetTargetSP();
  sb_target.SetSP(target_sp);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  if (target_sp.get() == NULL__null)
    log->Printf("SBValue(%p)::GetTarget () => NULL",
                static_cast<void *>(m_opaque_sp.get()));
  else
    log->Printf("SBValue(%p)::GetTarget () => %p",
                static_cast<void *>(m_opaque_sp.get()),
                static_cast<void *>(target_sp.get()));
}
return sb_target;
1151}

1153lldb::SBProcess SBValue::GetProcess() {
SBProcess sb_process;
ProcessSP process_sp;
if (m_opaque_sp) {
  process_sp = m_opaque_sp->GetProcessSP();
  sb_process.SetSP(process_sp);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  if (process_sp.get() == NULL__null)
    log->Printf("SBValue(%p)::GetProcess () => NULL",
                static_cast<void *>(m_opaque_sp.get()));
  else
    log->Printf("SBValue(%p)::GetProcess () => %p",
                static_cast<void *>(m_opaque_sp.get()),
                static_cast<void *>(process_sp.get()));
}
return sb_process;
1171}

1173lldb::SBThread SBValue::GetThread() {
SBThread sb_thread;
ThreadSP thread_sp;
if (m_opaque_sp) {
  thread_sp = m_opaque_sp->GetThreadSP();
  sb_thread.SetThread(thread_sp);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  if (thread_sp.get() == NULL__null)
    log->Printf("SBValue(%p)::GetThread () => NULL",
                static_cast<void *>(m_opaque_sp.get()));
  else
    log->Printf("SBValue(%p)::GetThread () => %p",
                static_cast<void *>(m_opaque_sp.get()),
                static_cast<void *>(thread_sp.get()));
}
return sb_thread;
1191}

1193lldb::SBFrame SBValue::GetFrame() {
SBFrame sb_frame;
StackFrameSP frame_sp;
if (m_opaque_sp) {
  frame_sp = m_opaque_sp->GetFrameSP();
  sb_frame.SetFrameSP(frame_sp);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log) {
  if (frame_sp.get() == NULL__null)
    log->Printf("SBValue(%p)::GetFrame () => NULL",
                static_cast<void *>(m_opaque_sp.get()));
  else
    log->Printf("SBValue(%p)::GetFrame () => %p",
                static_cast<void *>(m_opaque_sp.get()),
                static_cast<void *>(frame_sp.get()));
}
return sb_frame;
1211}

1213lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
if (!m_opaque_sp || !m_opaque_sp->IsValid()) {
  locker.GetError().SetErrorString("No value");
  return ValueObjectSP();
}
return locker.GetLockedSP(*m_opaque_sp.get());
1219}

1221lldb::ValueObjectSP SBValue::GetSP() const {
ValueLocker locker;
return GetSP(locker);
1224}

1226void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; }

1228void SBValue::SetSP(const lldb::ValueObjectSP &sp) {
if (sp) {
  lldb::TargetSP target_sp(sp->GetTargetSP());
  if (target_sp) {
    lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
    bool use_synthetic =
        target_sp->TargetProperties::GetEnableSyntheticValue();
    m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
  } else
    m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, true));
} else
  m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, false));
1240}

1242void SBValue::SetSP(const lldb::ValueObjectSP &sp,
                  lldb::DynamicValueType use_dynamic) {
if (sp) {
  lldb::TargetSP target_sp(sp->GetTargetSP());
  if (target_sp) {
    bool use_synthetic =
        target_sp->TargetProperties::GetEnableSyntheticValue();
    SetSP(sp, use_dynamic, use_synthetic);
  } else
    SetSP(sp, use_dynamic, true);
} else
  SetSP(sp, use_dynamic, false);
1254}

1256void SBValue::SetSP(const lldb::ValueObjectSP &sp, bool use_synthetic) {
if (sp) {
  lldb::TargetSP target_sp(sp->GetTargetSP());
  if (target_sp) {
    lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
    SetSP(sp, use_dynamic, use_synthetic);
  } else
    SetSP(sp, eNoDynamicValues, use_synthetic);
} else
  SetSP(sp, eNoDynamicValues, use_synthetic);
1266}

1268void SBValue::SetSP(const lldb::ValueObjectSP &sp,
                  lldb::DynamicValueType use_dynamic, bool use_synthetic) {
m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
1271}

1273void SBValue::SetSP(const lldb::ValueObjectSP &sp,
                  lldb::DynamicValueType use_dynamic, bool use_synthetic,
                  const char *name) {
m_opaque_sp =
    ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic, name));
1278}

1280bool SBValue::GetExpressionPath(SBStream &description) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  value_sp->GetExpressionPath(description.ref(), false);
  return true;
}
return false;
1288}

1290bool SBValue::GetExpressionPath(SBStream &description,
                              bool qualify_cxx_base_classes) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  value_sp->GetExpressionPath(description.ref(), qualify_cxx_base_classes);
  return true;
}
return false;
1299}

1301bool SBValue::GetDescription(SBStream &description) {
Stream &strm = description.ref();

ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  value_sp->Dump(strm);
else
  strm.PutCString("No value");

return true;
1312}

1314lldb::Format SBValue::GetFormat() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  return value_sp->GetFormat();
return eFormatDefault;
1320}

1322void SBValue::SetFormat(lldb::Format format) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
  value_sp->SetFormat(format);
1327}

1329lldb::SBValue SBValue::AddressOf() {
SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  Status error;
  sb_value.SetSP(value_sp->AddressOf(error), GetPreferDynamicValue(),
                 GetPreferSyntheticValue());
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log)
  log->Printf("SBValue(%p)::AddressOf () => SBValue(%p)",
              static_cast<void *>(value_sp.get()),
              static_cast<void *>(value_sp.get()));

return sb_value;
1345}

1347lldb::addr_t SBValue::GetLoadAddress() {
lldb::addr_t value = LLDB_INVALID_ADDRESS(18446744073709551615UL);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  TargetSP target_sp(value_sp->GetTargetSP());
  if (target_sp) {
    const bool scalar_is_load_address = true;
    AddressType addr_type;
    value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
    if (addr_type == eAddressTypeFile) {
      ModuleSP module_sp(value_sp->GetModule());
      if (!module_sp)
        value = LLDB_INVALID_ADDRESS(18446744073709551615UL);
      else {
        Address addr;
        module_sp->ResolveFileAddress(value, addr);
        value = addr.GetLoadAddress(target_sp.get());
      }
    } else if (addr_type == eAddressTypeHost ||
               addr_type == eAddressTypeInvalid)
      value = LLDB_INVALID_ADDRESS(18446744073709551615UL);
  }
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log)
  log->Printf("SBValue(%p)::GetLoadAddress () => (%" PRIu64"l" "u" ")",
              static_cast<void *>(value_sp.get()), value);

return value;
1377}

1379lldb::SBAddress SBValue::GetAddress() {
Address addr;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  TargetSP target_sp(value_sp->GetTargetSP());
  if (target_sp) {
    lldb::addr_t value = LLDB_INVALID_ADDRESS(18446744073709551615UL);
    const bool scalar_is_load_address = true;
    AddressType addr_type;
    value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
    if (addr_type == eAddressTypeFile) {
      ModuleSP module_sp(value_sp->GetModule());
      if (module_sp)
        module_sp->ResolveFileAddress(value, addr);
    } else if (addr_type == eAddressTypeLoad) {
      // no need to check the return value on this.. if it can actually do
      // the resolve addr will be in the form (section,offset), otherwise it
      // will simply be returned as (NULL, value)
      addr.SetLoadAddress(value, target_sp.get());
    }
  }
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
if (log)
  log->Printf("SBValue(%p)::GetAddress () => (%s,%" PRIu64"l" "u" ")",
              static_cast<void *>(value_sp.get()),
              (addr.GetSection() ? addr.GetSection()->GetName().GetCString()
                                 : "NULL"),
              addr.GetOffset());
return SBAddress(new Address(addr));
1410}

1412lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
lldb::SBData sb_data;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  TargetSP target_sp(value_sp->GetTargetSP());
  if (target_sp) {
    DataExtractorSP data_sp(new DataExtractor());
    value_sp->GetPointeeData(*data_sp, item_idx, item_count);
    if (data_sp->GetByteSize() > 0)
      *sb_data = data_sp;
  }
}
if (log)
  log->Printf("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
              static_cast<void *>(value_sp.get()), item_idx, item_count,
              static_cast<void *>(sb_data.get()));

return sb_data;
1432}

1434lldb::SBData SBValue::GetData() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
lldb::SBData sb_data;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
  DataExtractorSP data_sp(new DataExtractor());
  Status error;
  value_sp->GetData(*data_sp, error);
  if (error.Success())
    *sb_data = data_sp;
}
if (log)
  log->Printf("SBValue(%p)::GetData () => SBData(%p)",
              static_cast<void *>(value_sp.get()),
              static_cast<void *>(sb_data.get()));

return sb_data;
1452}

1454bool SBValue::SetData(lldb::SBData &data, SBError &error) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
bool ret = true;

if (value_sp) {
  DataExtractor *data_extractor = data.get();

  if (!data_extractor) {
    if (log)
      log->Printf("SBValue(%p)::SetData() => error: no data to set",
                  static_cast<void *>(value_sp.get()));

    error.SetErrorString("No data to set");
    ret = false;
  } else {
    Status set_error;

    value_sp->SetData(*data_extractor, set_error);

    if (!set_error.Success()) {
      error.SetErrorStringWithFormat("Couldn't set data: %s",
                                     set_error.AsCString());
      ret = false;
    }
  }
} else {
  error.SetErrorStringWithFormat(
      "Couldn't set data: could not get SBValue: %s",
      locker.GetError().AsCString());
  ret = false;
}

if (log)
  log->Printf("SBValue(%p)::SetData (%p) => %s",
              static_cast<void *>(value_sp.get()),
              static_cast<void *>(data.get()), ret ? "true" : "false");
return ret;
1493}

1495lldb::SBDeclaration SBValue::GetDeclaration() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
SBDeclaration decl_sb;
if (value_sp) {
  Declaration decl;
  if (value_sp->GetDeclaration(decl))
    decl_sb.SetDeclaration(decl);
}
return decl_sb;
1505}

1507lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
                                SBError &error) {
SBWatchpoint sb_watchpoint;

// If the SBValue is not valid, there's no point in even trying to watch it.
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
TargetSP target_sp(GetTarget().GetSP());
if (value_sp && target_sp) {
  // Read and Write cannot both be false.
  if (!read && !write)
    return sb_watchpoint;

  // If the value is not in scope, don't try and watch and invalid value
  if (!IsInScope())
    return sb_watchpoint;

  addr_t addr = GetLoadAddress();
  if (addr == LLDB_INVALID_ADDRESS(18446744073709551615UL))
    return sb_watchpoint;
  size_t byte_size = GetByteSize();
  if (byte_size == 0)
    return sb_watchpoint;

  uint32_t watch_type = 0;
  if (read)
    watch_type |= LLDB_WATCH_TYPE_READ(1u << 0);
  if (write)
    watch_type |= LLDB_WATCH_TYPE_WRITE(1u << 1);

  Status rc;
  CompilerType type(value_sp->GetCompilerType());
  WatchpointSP watchpoint_sp =
      target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc);
  error.SetError(rc);

  if (watchpoint_sp) {
    sb_watchpoint.SetSP(watchpoint_sp);
    Declaration decl;
    if (value_sp->GetDeclaration(decl)) {
      if (decl.GetFile()) {
        StreamString ss;
        // True to show fullpath for declaration file.
        decl.DumpStopContext(&ss, true);
        watchpoint_sp->SetDeclInfo(ss.GetString());
      }
    }
  }
} else if (target_sp) {
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
  if (log)
    log->Printf("SBValue(%p)::Watch() => error getting SBValue: %s",
                static_cast<void *>(value_sp.get()),
                locker.GetError().AsCString());

  error.SetErrorStringWithFormat("could not get SBValue: %s",
                                 locker.GetError().AsCString());
} else {
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API(1u << 16)));
  if (log)
    log->Printf("SBValue(%p)::Watch() => error getting SBValue: no target",
                static_cast<void *>(value_sp.get()));
  error.SetErrorString("could not set watchpoint, a target is required");
}

return sb_watchpoint;
1573}

1575// FIXME: Remove this method impl (as well as the decl in .h) once it is no
1576// longer needed.
1577// Backward compatibility fix in the interim.
1578lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
                                bool write) {
SBError error;
return Watch(resolve_location, read, write, error);
1582}

1584lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
                                       bool write, SBError &error) {
SBWatchpoint sb_watchpoint;
if (IsInScope() && GetType().IsPointerType())
  sb_watchpoint = Dereference().Watch(resolve_location, read, write, error);
return sb_watchpoint;
1590}

1592lldb::SBValue SBValue::Persist() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
SBValue persisted_sb;
if (value_sp) {
  persisted_sb.SetSP(value_sp->Persist());
}
return persisted_sb;
1600}

←

/usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/bits/stl_pair.h

1// Pair implementation -*- C++ -*-

3// Copyright (C) 2001-2016 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/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

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

56#ifndef _STL_PAIR_H1
57#define _STL_PAIR_H1 1

59#include <bits/move.h> // for std::move / std::forward, and std::swap

61#if __cplusplus201103L >= 201103L
62#include <type_traits> // for std::__decay_and_strip too
63#endif

65namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
66{
67_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 *  @addtogroup utilities
 *  @{
 */

74#if __cplusplus201103L >= 201103L
/// piecewise_construct_t
struct piecewise_construct_t { explicit piecewise_construct_t() = default; };

/// piecewise_construct
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();

// Forward declarations.
template<typename...>
  class tuple;

template<std::size_t...>
  struct _Index_tuple;

// Concept utility functions, reused in conditionally-explicit
// constructors.
// See PR 70437, don't look at is_constructible or
// is_convertible if the types are the same to
// avoid querying those properties for incomplete types.
template <bool, typename _T1, typename _T2>
  struct _PCC
  {
    template <typename _U1, typename _U2>
    static constexpr bool _ConstructiblePair()
    {
return __and_<is_constructible<_T1, const _U1&>,
      is_constructible<_T2, const _U2&>>::value;
    }

    template <typename _U1, typename _U2>
    static constexpr bool _ImplicitlyConvertiblePair()
    {
return __and_<is_convertible<const _U1&, _T1>,
      is_convertible<const _U2&, _T2>>::value;
    }

    template <typename _U1, typename _U2>
    static constexpr bool _MoveConstructiblePair()
    {
return __and_<is_constructible<_T1, _U1&&>,
      is_constructible<_T2, _U2&&>>::value;
    }

    template <typename _U1, typename _U2>
    static constexpr bool _ImplicitlyMoveConvertiblePair()
    {
return __and_<is_convertible<_U1&&, _T1>,
      is_convertible<_U2&&, _T2>>::value;
    }

    template <bool __implicit, typename _U1, typename _U2>
    static constexpr bool _CopyMovePair()
    {
using __do_converts = __and_<is_convertible<const _U1&, _T1>,
		  is_convertible<_U2&&, _T2>>;
using __converts = typename conditional<__implicit,
		       __do_converts,
		       __not_<__do_converts>>::type;
return __and_<is_constructible<_T1, const _U1&>,
      is_constructible<_T2, _U2&&>,
      __converts
      >::value;
    }

    template <bool __implicit, typename _U1, typename _U2>
    static constexpr bool _MoveCopyPair()
    {
using __do_converts = __and_<is_convertible<_U1&&, _T1>,
		  is_convertible<const _U2&, _T2>>;
using __converts = typename conditional<__implicit,
		       __do_converts,
		       __not_<__do_converts>>::type;
return __and_<is_constructible<_T1, _U1&&>,
      is_constructible<_T2, const _U2&&>,
      __converts
      >::value;
    }
};

template <typename _T1, typename _T2>
  struct _PCC<false, _T1, _T2>
  {
    template <typename _U1, typename _U2>
    static constexpr bool _ConstructiblePair()
    {
return false;
    }

    template <typename _U1, typename _U2>
    static constexpr bool _ImplicitlyConvertiblePair()
    {
return false;
    }

    template <typename _U1, typename _U2>
    static constexpr bool _MoveConstructiblePair()
    {
return false;
    }

    template <typename _U1, typename _U2>
    static constexpr bool _ImplicitlyMoveConvertiblePair()
    {
return false;
    }
};

struct __wrap_nonesuch : std::__nonesuch {
  explicit __wrap_nonesuch(const __nonesuch&) = delete;
};

185#endif

/**
 *  @brief Struct holding two objects of arbitrary type.
 *
 *  @tparam _T1  Type of first object.
 *  @tparam _T2  Type of second object.
 */
template<typename _T1, typename _T2>
  struct pair
9
←
Inner buffer of 'class std::__cxx11::basic_string<char>' deallocated by call to destructor→
  {
    typedef _T1 first_type;    /// @c first_type is the first bound type
    typedef _T2 second_type;   /// @c second_type is the second bound type

    _T1 first;                 /// @c first is a copy of the first object
    _T2 second;                /// @c second is a copy of the second object

    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 265.  std::pair::pair() effects overly restrictive
    /** The default constructor creates @c first and @c second using their
     *  respective default constructors.  */
206#if __cplusplus201103L >= 201103L
    template <typename _U1 = _T1,
              typename _U2 = _T2,
              typename enable_if<__and_<
                                   __is_implicitly_default_constructible<_U1>,
                                   __is_implicitly_default_constructible<_U2>>
                                 ::value, bool>::type = true>
213#endif
    _GLIBCXX_CONSTEXPRconstexpr pair()
    : first(), second() { }

217#if __cplusplus201103L >= 201103L
    template <typename _U1 = _T1,
              typename _U2 = _T2,
              typename enable_if<__and_<
                     is_default_constructible<_U1>,
                     is_default_constructible<_U2>,
                     __not_<
                       __and_<__is_implicitly_default_constructible<_U1>,
                              __is_implicitly_default_constructible<_U2>>>>
                                 ::value, bool>::type = false>
    explicit constexpr pair()
    : first(), second() { }
229#endif

    /** Two objects may be passed to a @c pair constructor to be copied.  */
232#if __cplusplus201103L < 201103L
    pair(const _T1& __a, const _T2& __b)
    : first(__a), second(__b) { }
235#else
    // Shortcut for constraining the templates that don't take pairs.
    using _PCCP = _PCC<true, _T1, _T2>;

    template<typename _U1 = _T1, typename _U2=_T2, typename
      enable_if<_PCCP::template
	   _ConstructiblePair<_U1, _U2>()
                && _PCCP::template
	   _ImplicitlyConvertiblePair<_U1, _U2>(),
                       bool>::type=true>
    constexpr pair(const _T1& __a, const _T2& __b)
    : first(__a), second(__b) { }

     template<typename _U1 = _T1, typename _U2=_T2, typename
enable_if<_PCCP::template
	    _ConstructiblePair<_U1, _U2>()
                 && !_PCCP::template
	    _ImplicitlyConvertiblePair<_U1, _U2>(),
                       bool>::type=false>
    explicit constexpr pair(const _T1& __a, const _T2& __b)
    : first(__a), second(__b) { }
256#endif

    /** There is also a templated copy ctor for the @c pair class itself.  */
259#if __cplusplus201103L < 201103L
    template<typename _U1, typename _U2>
pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
263#else
    // Shortcut for constraining the templates that take pairs.
    template <typename _U1, typename _U2>
      using _PCCFP = _PCC<!is_same<_T1, _U1>::value
	    || !is_same<_T2, _U2>::value,
	    _T1, _T2>;

    template<typename _U1, typename _U2, typename
      enable_if<_PCCFP<_U1, _U2>::template
	   _ConstructiblePair<_U1, _U2>()
                && _PCCFP<_U1, _U2>::template
	   _ImplicitlyConvertiblePair<_U1, _U2>(),
	  bool>::type=true>
      constexpr pair(const pair<_U1, _U2>& __p)
      : first(__p.first), second(__p.second) { }

    template<typename _U1, typename _U2, typename
      enable_if<_PCCFP<_U1, _U2>::template
	   _ConstructiblePair<_U1, _U2>()
	 && !_PCCFP<_U1, _U2>::template
	   _ImplicitlyConvertiblePair<_U1, _U2>(),
                       bool>::type=false>
explicit constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }

    constexpr pair(const pair&) = default;
    constexpr pair(pair&&) = default;

    // DR 811.
    template<typename _U1, typename
      enable_if<_PCCP::template
	   _MoveCopyPair<true, _U1, _T2>(),
                       bool>::type=true>
     constexpr pair(_U1&& __x, const _T2& __y)
     : first(std::forward<_U1>(__x)), second(__y) { }

    template<typename _U1, typename
      enable_if<_PCCP::template
	   _MoveCopyPair<false, _U1, _T2>(),
                       bool>::type=false>
     explicit constexpr pair(_U1&& __x, const _T2& __y)
     : first(std::forward<_U1>(__x)), second(__y) { }

    template<typename _U2, typename
      enable_if<_PCCP::template
	   _CopyMovePair<true, _T1, _U2>(),
                       bool>::type=true>
     constexpr pair(const _T1& __x, _U2&& __y)
     : first(__x), second(std::forward<_U2>(__y)) { }

    template<typename _U2, typename
      enable_if<_PCCP::template
	   _CopyMovePair<false, _T1, _U2>(),
                       bool>::type=false>
     explicit pair(const _T1& __x, _U2&& __y)
     : first(__x), second(std::forward<_U2>(__y)) { }

    template<typename _U1, typename _U2, typename
      enable_if<_PCCP::template
	   _MoveConstructiblePair<_U1, _U2>()
	  && _PCCP::template
	   _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
                       bool>::type=true>
constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }

    template<typename _U1, typename _U2, typename
      enable_if<_PCCP::template
	   _MoveConstructiblePair<_U1, _U2>()
	  && !_PCCP::template
	   _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
                       bool>::type=false>
explicit constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }


    template<typename _U1, typename _U2, typename
      enable_if<_PCCFP<_U1, _U2>::template
	   _MoveConstructiblePair<_U1, _U2>()
	  && _PCCFP<_U1, _U2>::template
	   _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
                       bool>::type=true>
constexpr pair(pair<_U1, _U2>&& __p)
: first(std::forward<_U1>(__p.first)),
 second(std::forward<_U2>(__p.second)) { }

    template<typename _U1, typename _U2, typename
      enable_if<_PCCFP<_U1, _U2>::template
	   _MoveConstructiblePair<_U1, _U2>()
	  && !_PCCFP<_U1, _U2>::template
	   _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
                       bool>::type=false>
explicit constexpr pair(pair<_U1, _U2>&& __p)
: first(std::forward<_U1>(__p.first)),
 second(std::forward<_U2>(__p.second)) { }

    template<typename... _Args1, typename... _Args2>
      pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);

    pair&
    operator=(typename conditional<
__and_<is_copy_assignable<_T1>,
       is_copy_assignable<_T2>>::value,
const pair&, const __wrap_nonesuch&>::type __p)
    {
first = __p.first;
second = __p.second;
return *this;
    }

    pair&
    operator=(typename conditional<
__not_<__and_<is_copy_assignable<_T1>,
              is_copy_assignable<_T2>>>::value,
const pair&, const __wrap_nonesuch&>::type __p) = delete;

    pair&
    operator=(typename conditional<
__and_<is_move_assignable<_T1>,
       is_move_assignable<_T2>>::value,
pair&&, __wrap_nonesuch&&>::type __p)
    noexcept(__and_<is_nothrow_move_assignable<_T1>,
             is_nothrow_move_assignable<_T2>>::value)
    {
first = std::forward<first_type>(__p.first);
second = std::forward<second_type>(__p.second);
return *this;
    }

    template<typename _U1, typename _U2>
    typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
		is_assignable<_T2&, const _U2&>>::value,
	 pair&>::type
operator=(const pair<_U1, _U2>& __p)
{
 first = __p.first;
 second = __p.second;
 return *this;
}

    template<typename _U1, typename _U2>
    typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
		is_assignable<_T2&, _U2&&>>::value,
	 pair&>::type
operator=(pair<_U1, _U2>&& __p)
{
 first = std::forward<_U1>(__p.first);
 second = std::forward<_U2>(__p.second);
 return *this;
}

    void
    swap(pair& __p)
    noexcept(__is_nothrow_swappable<_T1>::value
             && __is_nothrow_swappable<_T2>::value)
    {
using std::swap;
swap(first, __p.first);
swap(second, __p.second);
    }

  private:
    template<typename... _Args1, std::size_t... _Indexes1,
             typename... _Args2, std::size_t... _Indexes2>
      pair(tuple<_Args1...>&, tuple<_Args2...>&,
           _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
429#endif
  };

/// Two pairs of the same type are equal iff their members are equal.
template<typename _T1, typename _T2>
  inline _GLIBCXX_CONSTEXPRconstexpr bool
  operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  { return __x.first == __y.first && __x.second == __y.second; }

/// <http://gcc.gnu.org/onlinedocs/libstdc++/manual/utilities.html>
template<typename _T1, typename _T2>
  inline _GLIBCXX_CONSTEXPRconstexpr bool
  operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  { return __x.first < __y.first
    || (!(__y.first < __x.first) && __x.second < __y.second); }

/// Uses @c operator== to find the result.
template<typename _T1, typename _T2>
  inline _GLIBCXX_CONSTEXPRconstexpr bool
  operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  { return !(__x == __y); }

/// Uses @c operator< to find the result.
template<typename _T1, typename _T2>
  inline _GLIBCXX_CONSTEXPRconstexpr bool
  operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  { return __y < __x; }

/// Uses @c operator< to find the result.
template<typename _T1, typename _T2>
  inline _GLIBCXX_CONSTEXPRconstexpr bool
  operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  { return !(__y < __x); }

/// Uses @c operator< to find the result.
template<typename _T1, typename _T2>
  inline _GLIBCXX_CONSTEXPRconstexpr bool
  operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  { return !(__x < __y); }

469#if __cplusplus201103L >= 201103L
/// See std::pair::swap().
// Note:  no std::swap overloads in C++03 mode, this has performance
//        implications, see, eg, libstdc++/38466.
template<typename _T1, typename _T2>
  inline void
  swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
  noexcept(noexcept(__x.swap(__y)))
  { __x.swap(__y); }
478#endif

/**
 *  @brief A convenience wrapper for creating a pair from two objects.
 *  @param  __x  The first object.
 *  @param  __y  The second object.
 *  @return   A newly-constructed pair<> object of the appropriate type.
 *
 *  The standard requires that the objects be passed by reference-to-const,
 *  but LWG issue #181 says they should be passed by const value.  We follow
 *  the LWG by default.
 */
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 181.  make_pair() unintended behavior
492#if __cplusplus201103L >= 201103L
// NB: DR 706.
template<typename _T1, typename _T2>
  constexpr pair<typename __decay_and_strip<_T1>::__type,
                 typename __decay_and_strip<_T2>::__type>
  make_pair(_T1&& __x, _T2&& __y)
  {
    typedef typename __decay_and_strip<_T1>::__type __ds_type1;
    typedef typename __decay_and_strip<_T2>::__type __ds_type2;
    typedef pair<__ds_type1, __ds_type2> 	      __pair_type;
    return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
  }
504#else
template<typename _T1, typename _T2>
  inline pair<_T1, _T2>
  make_pair(_T1 __x, _T2 __y)
  { return pair<_T1, _T2>(__x, __y); }
509#endif

/// @}

513_GLIBCXX_END_NAMESPACE_VERSION
514} // namespace std

516#endif /* _STL_PAIR_H */