diff options
Diffstat (limited to 'source/API/SBValue.cpp')
| -rw-r--r-- | source/API/SBValue.cpp | 897 |
1 files changed, 495 insertions, 402 deletions
diff --git a/source/API/SBValue.cpp b/source/API/SBValue.cpp index a61a2a19a6216..8383007635229 100644 --- a/source/API/SBValue.cpp +++ b/source/API/SBValue.cpp @@ -1,13 +1,13 @@ //===-- SBValue.cpp ---------------------------------------------*- C++ -*-===// // -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #include "lldb/API/SBValue.h" +#include "SBReproducerPrivate.h" #include "lldb/API/SBDeclaration.h" #include "lldb/API/SBStream.h" @@ -36,7 +36,6 @@ #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" #include "lldb/Utility/DataExtractor.h" -#include "lldb/Utility/Log.h" #include "lldb/Utility/Scalar.h" #include "lldb/Utility/Stream.h" @@ -47,6 +46,8 @@ #include "lldb/API/SBTarget.h" #include "lldb/API/SBThread.h" +#include <memory> + using namespace lldb; using namespace lldb_private; @@ -56,7 +57,7 @@ public: ValueImpl(lldb::ValueObjectSP in_valobj_sp, lldb::DynamicValueType use_dynamic, bool use_synthetic, - const char *name = NULL) + const char *name = nullptr) : m_valobj_sp(), m_use_dynamic(use_dynamic), m_use_synthetic(use_synthetic), m_name(name) { if (in_valobj_sp) { @@ -83,7 +84,7 @@ public: } bool IsValid() { - if (m_valobj_sp.get() == NULL) + if (m_valobj_sp.get() == nullptr) return false; else { // FIXME: This check is necessary but not sufficient. We for sure don't @@ -107,7 +108,6 @@ public: lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker, std::unique_lock<std::recursive_mutex> &lock, Status &error) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (!m_valobj_sp) { error.SetErrorString("invalid value object"); return m_valobj_sp; @@ -126,9 +126,6 @@ public: // 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(); } @@ -218,32 +215,55 @@ private: Status m_lock_error; }; -SBValue::SBValue() : m_opaque_sp() {} +SBValue::SBValue() : m_opaque_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValue); } + +SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { + LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &), value_sp); -SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { SetSP(value_sp); } + SetSP(value_sp); +} + +SBValue::SBValue(const SBValue &rhs) { + LLDB_RECORD_CONSTRUCTOR(SBValue, (const lldb::SBValue &), rhs); -SBValue::SBValue(const SBValue &rhs) { SetSP(rhs.m_opaque_sp); } + SetSP(rhs.m_opaque_sp); +} SBValue &SBValue::operator=(const SBValue &rhs) { + LLDB_RECORD_METHOD(lldb::SBValue &, + SBValue, operator=,(const lldb::SBValue &), rhs); + if (this != &rhs) { SetSP(rhs.m_opaque_sp); } - return *this; + return LLDB_RECORD_RESULT(*this); } SBValue::~SBValue() {} bool SBValue::IsValid() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid); + return this->operator bool(); +} +SBValue::operator bool() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValue, operator bool); + // 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 && m_opaque_sp->IsValid() && - m_opaque_sp->GetRootSP().get() != NULL; + return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid() && + m_opaque_sp->GetRootSP().get() != nullptr; } -void SBValue::Clear() { m_opaque_sp.reset(); } +void SBValue::Clear() { + LLDB_RECORD_METHOD_NO_ARGS(void, SBValue, Clear); + + m_opaque_sp.reset(); +} SBError SBValue::GetError() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBValue, GetError); + SBError sb_error; ValueLocker locker; @@ -254,10 +274,12 @@ SBError SBValue::GetError() { sb_error.SetErrorStringWithFormat("error: %s", locker.GetError().AsCString()); - return sb_error; + return LLDB_RECORD_RESULT(sb_error); } user_id_t SBValue::GetID() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBValue, GetID); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -266,69 +288,46 @@ user_id_t SBValue::GetID() { } const char *SBValue::GetName() { - const char *name = NULL; + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetName); + + const char *name = nullptr; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) name = value_sp->GetName().GetCString(); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - 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; } const char *SBValue::GetTypeName() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - const char *name = NULL; + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeName); + + const char *name = nullptr; 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; } const char *SBValue::GetDisplayTypeName() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - const char *name = NULL; + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetDisplayTypeName); + + const char *name = nullptr; 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; } size_t SBValue::GetByteSize() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteSize); + size_t result = 0; ValueLocker locker; @@ -337,15 +336,12 @@ size_t SBValue::GetByteSize() { result = value_sp->GetByteSize(); } - if (log) - log->Printf("SBValue(%p)::GetByteSize () => %" PRIu64, - static_cast<void *>(value_sp.get()), - static_cast<uint64_t>(result)); - return result; } bool SBValue::IsInScope() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope); + bool result = false; ValueLocker locker; @@ -354,109 +350,51 @@ bool SBValue::IsInScope() { result = value_sp->IsInScope(); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBValue(%p)::IsInScope () => %i", - static_cast<void *>(value_sp.get()), result); - return result; } const char *SBValue::GetValue() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetValue); - const char *cstr = NULL; + const char *cstr = nullptr; 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; } ValueType SBValue::GetValueType() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::ValueType, 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)); - 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; } const char *SBValue::GetObjectDescription() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - const char *cstr = NULL; + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetObjectDescription); + + const char *cstr = nullptr; 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; } const char *SBValue::GetTypeValidatorResult() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - const char *cstr = NULL; + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeValidatorResult); + + const char *cstr = nullptr; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -468,41 +406,28 @@ const char *SBValue::GetTypeValidatorResult() { cstr = validation.second.c_str(); } } - if (log) { - if (cstr) - log->Printf("SBValue(%p)::GetTypeValidatorResult() => \"%s\"", - static_cast<void *>(value_sp.get()), cstr); - else - log->Printf("SBValue(%p)::GetTypeValidatorResult() => NULL", - static_cast<void *>(value_sp.get())); - } + return cstr; } SBType SBValue::GetType() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType); + 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())); + type_sp = std::make_shared<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; + + return LLDB_RECORD_RESULT(sb_type); } bool SBValue::GetValueDidChange() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetValueDidChange); + bool result = false; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -510,35 +435,29 @@ bool SBValue::GetValueDidChange() { 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; } const char *SBValue::GetSummary() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - const char *cstr = NULL; + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetSummary); + + const char *cstr = nullptr; 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; } const char *SBValue::GetSummary(lldb::SBStream &stream, lldb::SBTypeSummaryOptions &options) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(const char *, SBValue, GetSummary, + (lldb::SBStream &, lldb::SBTypeSummaryOptions &), stream, + options); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -547,61 +466,49 @@ const char *SBValue::GetSummary(lldb::SBStream &stream, 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; } const char *SBValue::GetLocation() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - const char *cstr = NULL; + LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetLocation); + + const char *cstr = nullptr; 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; } // Deprecated - use the one that takes an lldb::SBError bool SBValue::SetValueFromCString(const char *value_str) { + LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, (const char *), + value_str); + lldb::SBError dummy; return SetValueFromCString(value_str, dummy); } bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) { + LLDB_RECORD_METHOD(bool, SBValue, SetValueFromCString, + (const char *, lldb::SBError &), value_str, error); + bool success = false; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 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; } lldb::SBTypeFormat SBValue::GetTypeFormat() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFormat, SBValue, GetTypeFormat); + lldb::SBTypeFormat format; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -612,10 +519,12 @@ lldb::SBTypeFormat SBValue::GetTypeFormat() { format.SetSP(format_sp); } } - return format; + return LLDB_RECORD_RESULT(format); } lldb::SBTypeSummary SBValue::GetTypeSummary() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSummary, SBValue, GetTypeSummary); + lldb::SBTypeSummary summary; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -626,10 +535,12 @@ lldb::SBTypeSummary SBValue::GetTypeSummary() { summary.SetSP(summary_sp); } } - return summary; + return LLDB_RECORD_RESULT(summary); } lldb::SBTypeFilter SBValue::GetTypeFilter() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeFilter, SBValue, GetTypeFilter); + lldb::SBTypeFilter filter; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -644,11 +555,12 @@ lldb::SBTypeFilter SBValue::GetTypeFilter() { } } } - return filter; + return LLDB_RECORD_RESULT(filter); } -#ifndef LLDB_DISABLE_PYTHON lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic); + lldb::SBTypeSynthetic synthetic; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -663,12 +575,15 @@ lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() { } } } - return synthetic; + return LLDB_RECORD_RESULT(synthetic); } -#endif lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset, SBType type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset, + (const char *, uint32_t, lldb::SBType), name, offset, + type); + lldb::SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -681,20 +596,12 @@ lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset, GetPreferDynamicValue(), GetPreferSyntheticValue(), name); } } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - 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; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::Cast(SBType type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType), type); + lldb::SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -702,20 +609,27 @@ lldb::SBValue SBValue::Cast(SBType type) { if (value_sp && type_sp) sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)), GetPreferDynamicValue(), GetPreferSyntheticValue()); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::CreateValueFromExpression(const char *name, const char *expression) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *), name, expression); + SBExpressionOptions options; options.ref().SetKeepInMemory(true); - return CreateValueFromExpression(name, expression, options); + return LLDB_RECORD_RESULT( + CreateValueFromExpression(name, expression, options)); } lldb::SBValue SBValue::CreateValueFromExpression(const char *name, const char *expression, SBExpressionOptions &options) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *, lldb::SBExpressionOptions &), + name, expression, options); + lldb::SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -728,23 +642,16 @@ lldb::SBValue SBValue::CreateValueFromExpression(const char *name, 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; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::CreateValueFromAddress(const char *name, lldb::addr_t address, SBType sb_type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress, + (const char *, lldb::addr_t, lldb::SBType), name, address, + sb_type); + lldb::SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -757,21 +664,15 @@ lldb::SBValue SBValue::CreateValueFromAddress(const char *name, exe_ctx, ast_type); } sb_value.SetSP(new_value_sp); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - 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; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data, SBType sb_type) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType), name, data, + sb_type); + lldb::SBValue sb_value; lldb::ValueObjectSP new_value_sp; ValueLocker locker; @@ -784,20 +685,12 @@ lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data, new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad); } sb_value.SetSP(new_value_sp); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - 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; + return LLDB_RECORD_RESULT(sb_value); } SBValue SBValue::GetChildAtIndex(uint32_t idx) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t), idx); + const bool can_create_synthetic = false; lldb::DynamicValueType use_dynamic = eNoDynamicValues; TargetSP target_sp; @@ -807,14 +700,18 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx) { if (target_sp) use_dynamic = target_sp->GetPreferDynamicValue(); - return GetChildAtIndex(idx, use_dynamic, can_create_synthetic); + return LLDB_RECORD_RESULT( + GetChildAtIndex(idx, use_dynamic, can_create_synthetic)); } SBValue SBValue::GetChildAtIndex(uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, + (uint32_t, lldb::DynamicValueType, bool), idx, use_dynamic, + can_create_synthetic); + lldb::ValueObjectSP child_sp; - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -828,35 +725,27 @@ SBValue SBValue::GetChildAtIndex(uint32_t idx, 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; + return LLDB_RECORD_RESULT(sb_value); } uint32_t SBValue::GetIndexOfChildWithName(const char *name) { + LLDB_RECORD_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, (const char *), + name); + uint32_t idx = UINT32_MAX; 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)); - if (log) { - if (idx == UINT32_MAX) - 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; } SBValue SBValue::GetChildMemberWithName(const char *name) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *), name); + lldb::DynamicValueType use_dynamic_value = eNoDynamicValues; TargetSP target_sp; if (m_opaque_sp) @@ -864,17 +753,19 @@ SBValue SBValue::GetChildMemberWithName(const char *name) { if (target_sp) use_dynamic_value = target_sp->GetPreferDynamicValue(); - return GetChildMemberWithName(name, use_dynamic_value); + return LLDB_RECORD_RESULT(GetChildMemberWithName(name, use_dynamic_value)); } SBValue SBValue::GetChildMemberWithName(const char *name, lldb::DynamicValueType use_dynamic_value) { + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *, lldb::DynamicValueType), name, + use_dynamic_value); + lldb::ValueObjectSP child_sp; const ConstString str_name(name); - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -884,26 +775,25 @@ SBValue::GetChildMemberWithName(const char *name, 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; + return LLDB_RECORD_RESULT(sb_value); } lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) { + LLDB_RECORD_METHOD(lldb::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; + return LLDB_RECORD_RESULT(value_sb); } lldb::SBValue SBValue::GetStaticValue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, GetStaticValue); + SBValue value_sb; if (IsValid()) { ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), @@ -911,42 +801,57 @@ lldb::SBValue SBValue::GetStaticValue() { m_opaque_sp->GetUseSynthetic())); value_sb.SetSP(proxy_sp); } - return value_sb; + return LLDB_RECORD_RESULT(value_sb); } lldb::SBValue SBValue::GetNonSyntheticValue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::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; + return LLDB_RECORD_RESULT(value_sb); } lldb::DynamicValueType SBValue::GetPreferDynamicValue() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::DynamicValueType, SBValue, + GetPreferDynamicValue); + if (!IsValid()) return eNoDynamicValues; return m_opaque_sp->GetUseDynamic(); } void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) { + LLDB_RECORD_METHOD(void, SBValue, SetPreferDynamicValue, + (lldb::DynamicValueType), use_dynamic); + if (IsValid()) return m_opaque_sp->SetUseDynamic(use_dynamic); } bool SBValue::GetPreferSyntheticValue() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, GetPreferSyntheticValue); + if (!IsValid()) return false; return m_opaque_sp->GetUseSynthetic(); } void SBValue::SetPreferSyntheticValue(bool use_synthetic) { + LLDB_RECORD_METHOD(void, SBValue, SetPreferSyntheticValue, (bool), + use_synthetic); + if (IsValid()) return m_opaque_sp->SetUseSynthetic(use_synthetic); } bool SBValue::IsDynamic() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsDynamic); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -955,6 +860,8 @@ bool SBValue::IsDynamic() { } bool SBValue::IsSynthetic() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSynthetic); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -963,6 +870,8 @@ bool SBValue::IsSynthetic() { } bool SBValue::IsSyntheticChildrenGenerated() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsSyntheticChildrenGenerated); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -971,6 +880,8 @@ bool SBValue::IsSyntheticChildrenGenerated() { } void SBValue::SetSyntheticChildrenGenerated(bool is) { + LLDB_RECORD_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool), is); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -978,7 +889,9 @@ void SBValue::SetSyntheticChildrenGenerated(bool is) { } lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath, + (const char *), expr_path); + lldb::ValueObjectSP child_sp; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -990,16 +903,13 @@ lldb::SBValue SBValue::GetValueForExpressionPath(const char *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; + return LLDB_RECORD_RESULT(sb_value); } int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) { + LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, + (lldb::SBError &, int64_t), error, fail_value); + error.Clear(); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1018,6 +928,9 @@ int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) { } uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) { + LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, + (lldb::SBError &, uint64_t), error, fail_value); + error.Clear(); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1036,6 +949,8 @@ uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) { } int64_t SBValue::GetValueAsSigned(int64_t fail_value) { + LLDB_RECORD_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t), fail_value); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -1045,6 +960,9 @@ int64_t SBValue::GetValueAsSigned(int64_t fail_value) { } uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) { + LLDB_RECORD_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t), + fail_value); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -1054,52 +972,51 @@ uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) { } bool SBValue::MightHaveChildren() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, MightHaveChildren); + 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; } bool SBValue::IsRuntimeSupportValue() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsRuntimeSupportValue); + 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; } -uint32_t SBValue::GetNumChildren() { return GetNumChildren(UINT32_MAX); } +uint32_t SBValue::GetNumChildren() { + LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBValue, GetNumChildren); + + return GetNumChildren(UINT32_MAX); +} uint32_t SBValue::GetNumChildren(uint32_t max) { + LLDB_RECORD_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t), max); + uint32_t num_children = 0; - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 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; } SBValue SBValue::Dereference() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, Dereference); + SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1107,104 +1024,77 @@ SBValue SBValue::Dereference() { Status error; sb_value = value_sp->Dereference(error); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBValue(%p)::Dereference () => SBValue(%p)", - static_cast<void *>(value_sp.get()), - static_cast<void *>(value_sp.get())); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } // Deprecated - please use GetType().IsPointerType() instead. -bool SBValue::TypeIsPointerType() { return GetType().IsPointerType(); } +bool SBValue::TypeIsPointerType() { + LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, TypeIsPointerType); + + return GetType().IsPointerType(); +} void *SBValue::GetOpaqueType() { + LLDB_RECORD_METHOD_NO_ARGS(void *, SBValue, GetOpaqueType); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) return value_sp->GetCompilerType().GetOpaqueQualType(); - return NULL; + return nullptr; } lldb::SBTarget SBValue::GetTarget() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::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)); - if (log) { - if (target_sp.get() == 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; + + return LLDB_RECORD_RESULT(sb_target); } lldb::SBProcess SBValue::GetProcess() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::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)); - if (log) { - if (process_sp.get() == 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; + + return LLDB_RECORD_RESULT(sb_process); } lldb::SBThread SBValue::GetThread() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::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)); - if (log) { - if (thread_sp.get() == 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; + + return LLDB_RECORD_RESULT(sb_thread); } lldb::SBFrame SBValue::GetFrame() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::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)); - if (log) { - if (frame_sp.get() == 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; + + return LLDB_RECORD_RESULT(sb_frame); } lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const { @@ -1216,8 +1106,10 @@ lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const { } lldb::ValueObjectSP SBValue::GetSP() const { + LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ValueObjectSP, SBValue, GetSP); + ValueLocker locker; - return GetSP(locker); + return LLDB_RECORD_RESULT(GetSP(locker)); } void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; } @@ -1275,6 +1167,9 @@ void SBValue::SetSP(const lldb::ValueObjectSP &sp, } bool SBValue::GetExpressionPath(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &), + description); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -1286,6 +1181,9 @@ bool SBValue::GetExpressionPath(SBStream &description) { bool SBValue::GetExpressionPath(SBStream &description, bool qualify_cxx_base_classes) { + LLDB_RECORD_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &, bool), + description, qualify_cxx_base_classes); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { @@ -1295,7 +1193,86 @@ bool SBValue::GetExpressionPath(SBStream &description, return false; } +lldb::SBValue SBValue::EvaluateExpression(const char *expr) const { + LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, + (const char *), expr); + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (!value_sp) + return LLDB_RECORD_RESULT(SBValue()); + + lldb::TargetSP target_sp = value_sp->GetTargetSP(); + if (!target_sp) + return LLDB_RECORD_RESULT(SBValue()); + + lldb::SBExpressionOptions options; + options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue()); + options.SetUnwindOnError(true); + options.SetIgnoreBreakpoints(true); + + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr)); +} + +lldb::SBValue +SBValue::EvaluateExpression(const char *expr, + const SBExpressionOptions &options) const { + LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &), + expr, options); + + return LLDB_RECORD_RESULT(EvaluateExpression(expr, options, nullptr)); +} + +lldb::SBValue SBValue::EvaluateExpression(const char *expr, + const SBExpressionOptions &options, + const char *name) const { + LLDB_RECORD_METHOD_CONST( + lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &, const char *), expr, + options, name); + + + if (!expr || expr[0] == '\0') { + return LLDB_RECORD_RESULT(SBValue()); + } + + + ValueLocker locker; + lldb::ValueObjectSP value_sp(GetSP(locker)); + if (!value_sp) { + return LLDB_RECORD_RESULT(SBValue()); + } + + lldb::TargetSP target_sp = value_sp->GetTargetSP(); + if (!target_sp) { + return LLDB_RECORD_RESULT(SBValue()); + } + + std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); + ExecutionContext exe_ctx(target_sp.get()); + + StackFrame *frame = exe_ctx.GetFramePtr(); + if (!frame) { + return LLDB_RECORD_RESULT(SBValue()); + } + + ValueObjectSP res_val_sp; + target_sp->EvaluateExpression(expr, frame, res_val_sp, options.ref(), nullptr, + value_sp.get()); + + if (name) + res_val_sp->SetName(ConstString(name)); + + SBValue result; + result.SetSP(res_val_sp, options.GetFetchDynamicValue()); + return LLDB_RECORD_RESULT(result); +} + bool SBValue::GetDescription(SBStream &description) { + LLDB_RECORD_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &), + description); + Stream &strm = description.ref(); ValueLocker locker; @@ -1309,6 +1286,8 @@ bool SBValue::GetDescription(SBStream &description) { } lldb::Format SBValue::GetFormat() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBValue, GetFormat); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -1317,6 +1296,8 @@ lldb::Format SBValue::GetFormat() { } void SBValue::SetFormat(lldb::Format format) { + LLDB_RECORD_METHOD(void, SBValue, SetFormat, (lldb::Format), format); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) @@ -1324,6 +1305,8 @@ void SBValue::SetFormat(lldb::Format format) { } lldb::SBValue SBValue::AddressOf() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValue, SBValue, AddressOf); + SBValue sb_value; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1332,16 +1315,13 @@ lldb::SBValue SBValue::AddressOf() { sb_value.SetSP(value_sp->AddressOf(error), GetPreferDynamicValue(), GetPreferSyntheticValue()); } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBValue(%p)::AddressOf () => SBValue(%p)", - static_cast<void *>(value_sp.get()), - static_cast<void *>(value_sp.get())); - return sb_value; + return LLDB_RECORD_RESULT(sb_value); } lldb::addr_t SBValue::GetLoadAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBValue, GetLoadAddress); + lldb::addr_t value = LLDB_INVALID_ADDRESS; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1365,15 +1345,13 @@ lldb::addr_t SBValue::GetLoadAddress() { value = LLDB_INVALID_ADDRESS; } } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")", - static_cast<void *>(value_sp.get()), value); return value; } lldb::SBAddress SBValue::GetAddress() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBValue, GetAddress); + Address addr; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1396,18 +1374,14 @@ lldb::SBAddress SBValue::GetAddress() { } } } - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (log) - log->Printf("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")", - static_cast<void *>(value_sp.get()), - (addr.GetSection() ? addr.GetSection()->GetName().GetCString() - : "NULL"), - addr.GetOffset()); - return SBAddress(new Address(addr)); + + return LLDB_RECORD_RESULT(SBAddress(new Address(addr))); } lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(lldb::SBData, SBValue, GetPointeeData, + (uint32_t, uint32_t), item_idx, item_count); + lldb::SBData sb_data; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1420,16 +1394,13 @@ lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) { *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; + return LLDB_RECORD_RESULT(sb_data); } lldb::SBData SBValue::GetData() { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBData, SBValue, GetData); + lldb::SBData sb_data; ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); @@ -1440,16 +1411,14 @@ lldb::SBData SBValue::GetData() { 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; + return LLDB_RECORD_RESULT(sb_data); } bool SBValue::SetData(lldb::SBData &data, SBError &error) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + LLDB_RECORD_METHOD(bool, SBValue, SetData, (lldb::SBData &, lldb::SBError &), + data, error); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); bool ret = true; @@ -1458,10 +1427,6 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) { 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 { @@ -1482,14 +1447,12 @@ bool SBValue::SetData(lldb::SBData &data, SBError &error) { 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; } lldb::SBDeclaration SBValue::GetDeclaration() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration); + ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); SBDeclaration decl_sb; @@ -1498,11 +1461,15 @@ lldb::SBDeclaration SBValue::GetDeclaration() { if (value_sp->GetDeclaration(decl)) decl_sb.SetDeclaration(decl); } - return decl_sb; + return LLDB_RECORD_RESULT(decl_sb); } lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, + (bool, bool, bool, lldb::SBError &), resolve_location, + read, write, error); + SBWatchpoint sb_watchpoint; // If the SBValue is not valid, there's no point in even trying to watch it. @@ -1512,18 +1479,18 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, if (value_sp && target_sp) { // Read and Write cannot both be false. if (!read && !write) - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); // If the value is not in scope, don't try and watch and invalid value if (!IsInScope()) - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); addr_t addr = GetLoadAddress(); if (addr == LLDB_INVALID_ADDRESS) - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); size_t byte_size = GetByteSize(); if (byte_size == 0) - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); uint32_t watch_type = 0; if (read) @@ -1550,23 +1517,13 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, } } } else if (target_sp) { - Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - 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)); - 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; + return LLDB_RECORD_RESULT(sb_watchpoint); } // FIXME: Remove this method impl (as well as the decl in .h) once it is no @@ -1574,24 +1531,160 @@ lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write, // Backward compatibility fix in the interim. lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, Watch, (bool, bool, bool), + resolve_location, read, write); + SBError error; - return Watch(resolve_location, read, write, error); + return LLDB_RECORD_RESULT(Watch(resolve_location, read, write, error)); } lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read, bool write, SBError &error) { + LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee, + (bool, bool, bool, lldb::SBError &), resolve_location, + read, write, error); + SBWatchpoint sb_watchpoint; if (IsInScope() && GetType().IsPointerType()) sb_watchpoint = Dereference().Watch(resolve_location, read, write, error); - return sb_watchpoint; + return LLDB_RECORD_RESULT(sb_watchpoint); } lldb::SBValue SBValue::Persist() { + LLDB_RECORD_METHOD_NO_ARGS(lldb::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; + return LLDB_RECORD_RESULT(persisted_sb); +} + +namespace lldb_private { +namespace repro { + +template <> +void RegisterMethods<SBValue>(Registry &R) { + LLDB_REGISTER_CONSTRUCTOR(SBValue, ()); + LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &)); + LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &)); + LLDB_REGISTER_METHOD(lldb::SBValue &, + SBValue, operator=,(const lldb::SBValue &)); + LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ()); + LLDB_REGISTER_METHOD_CONST(bool, SBValue, operator bool, ()); + LLDB_REGISTER_METHOD(void, SBValue, Clear, ()); + LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ()); + LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ()); + LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ()); + LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeValidatorResult, ()); + LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ()); + LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ()); + LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, + (lldb::SBStream &, lldb::SBTypeSummaryOptions &)); + LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ()); + LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *)); + LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, + (const char *, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBValue, GetTypeFormat, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBValue, GetTypeSummary, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBValue, GetTypeFilter, ()); + LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBValue, GetTypeSynthetic, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateChildAtOffset, + (const char *, uint32_t, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Cast, (lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *)); + LLDB_REGISTER_METHOD( + lldb::SBValue, SBValue, CreateValueFromExpression, + (const char *, const char *, lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromAddress, + (const char *, lldb::addr_t, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, CreateValueFromData, + (const char *, lldb::SBData, lldb::SBType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildAtIndex, + (uint32_t, lldb::DynamicValueType, bool)); + LLDB_REGISTER_METHOD(uint32_t, SBValue, GetIndexOfChildWithName, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetChildMemberWithName, + (const char *, lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetDynamicValue, + (lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetStaticValue, ()); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetNonSyntheticValue, ()); + LLDB_REGISTER_METHOD(lldb::DynamicValueType, SBValue, GetPreferDynamicValue, + ()); + LLDB_REGISTER_METHOD(void, SBValue, SetPreferDynamicValue, + (lldb::DynamicValueType)); + LLDB_REGISTER_METHOD(bool, SBValue, GetPreferSyntheticValue, ()); + LLDB_REGISTER_METHOD(void, SBValue, SetPreferSyntheticValue, (bool)); + LLDB_REGISTER_METHOD(bool, SBValue, IsDynamic, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsSynthetic, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsSyntheticChildrenGenerated, ()); + LLDB_REGISTER_METHOD(void, SBValue, SetSyntheticChildrenGenerated, (bool)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, GetValueForExpressionPath, + (const char *)); + LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, + (lldb::SBError &, int64_t)); + LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, + (lldb::SBError &, uint64_t)); + LLDB_REGISTER_METHOD(int64_t, SBValue, GetValueAsSigned, (int64_t)); + LLDB_REGISTER_METHOD(uint64_t, SBValue, GetValueAsUnsigned, (uint64_t)); + LLDB_REGISTER_METHOD(bool, SBValue, MightHaveChildren, ()); + LLDB_REGISTER_METHOD(bool, SBValue, IsRuntimeSupportValue, ()); + LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, ()); + LLDB_REGISTER_METHOD(uint32_t, SBValue, GetNumChildren, (uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Dereference, ()); + LLDB_REGISTER_METHOD(bool, SBValue, TypeIsPointerType, ()); + LLDB_REGISTER_METHOD(void *, SBValue, GetOpaqueType, ()); + LLDB_REGISTER_METHOD(lldb::SBTarget, SBValue, GetTarget, ()); + LLDB_REGISTER_METHOD(lldb::SBProcess, SBValue, GetProcess, ()); + LLDB_REGISTER_METHOD(lldb::SBThread, SBValue, GetThread, ()); + LLDB_REGISTER_METHOD(lldb::SBFrame, SBValue, GetFrame, ()); + LLDB_REGISTER_METHOD_CONST(lldb::ValueObjectSP, SBValue, GetSP, ()); + LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(bool, SBValue, GetExpressionPath, + (lldb::SBStream &, bool)); + LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValue, EvaluateExpression, + (const char *)); + LLDB_REGISTER_METHOD_CONST( + lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &)); + LLDB_REGISTER_METHOD_CONST( + lldb::SBValue, SBValue, EvaluateExpression, + (const char *, const lldb::SBExpressionOptions &, const char *)); + LLDB_REGISTER_METHOD(bool, SBValue, GetDescription, (lldb::SBStream &)); + LLDB_REGISTER_METHOD(lldb::Format, SBValue, GetFormat, ()); + LLDB_REGISTER_METHOD(void, SBValue, SetFormat, (lldb::Format)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ()); + LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ()); + LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData, + (uint32_t, uint32_t)); + LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ()); + LLDB_REGISTER_METHOD(bool, SBValue, SetData, + (lldb::SBData &, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ()); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch, + (bool, bool, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch, + (bool, bool, bool)); + LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee, + (bool, bool, bool, lldb::SBError &)); + LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ()); +} + +} } |