SBValue.cpp | Explore in Territory

//===-- SBValue.cpp -------------------------------------------------------===//
//
// 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 "lldb/Utility/Instrumentation.h"

#include "lldb/API/SBDeclaration.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeFilter.h"
#include "lldb/API/SBTypeFormat.h"
#include "lldb/API/SBTypeSummary.h"
#include "lldb/API/SBTypeSynthetic.h"

#include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Core/Declaration.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/Section.h"
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/DumpValueObjectOptions.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Scalar.h"
#include "lldb/Utility/Stream.h"

#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBExpressionOptions.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBTarget.h"
#include "lldb/API/SBThread.h"

#include <memory>

usingnamespacelldb;
usingnamespacelldb_private;

class ValueImpl { … };

class ValueLocker { … };

SBValue::SBValue() { … }

SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { … }

SBValue::SBValue(const SBValue &rhs) { … }

SBValue &SBValue::operator=(const SBValue &rhs) { … }

SBValue::~SBValue() = default;

bool SBValue::IsValid() { … }
operator bool()

void SBValue::Clear() { … }

SBError SBValue::GetError() { … }

user_id_t SBValue::GetID() { … }

const char *SBValue::GetName() { … }

const char *SBValue::GetTypeName() { … }

const char *SBValue::GetDisplayTypeName() { … }

size_t SBValue::GetByteSize() { … }

bool SBValue::IsInScope() { … }

const char *SBValue::GetValue() { … }

ValueType SBValue::GetValueType() { … }

const char *SBValue::GetObjectDescription() { … }

SBType SBValue::GetType() { … }

bool SBValue::GetValueDidChange() { … }

const char *SBValue::GetSummary() { … }

const char *SBValue::GetSummary(lldb::SBStream &stream,
                                lldb::SBTypeSummaryOptions &options) { … }

const char *SBValue::GetLocation() { … }

// Deprecated - use the one that takes an lldb::SBError
bool SBValue::SetValueFromCString(const char *value_str) { … }

bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) { … }

lldb::SBTypeFormat SBValue::GetTypeFormat() { … }

lldb::SBTypeSummary SBValue::GetTypeSummary() { … }

lldb::SBTypeFilter SBValue::GetTypeFilter() { … }

lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() { … }

lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
                                           SBType type) { … }

lldb::SBValue SBValue::Cast(SBType type) { … }

lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
                                                 const char *expression) { … }

lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
                                                 const char *expression,
                                                 SBExpressionOptions &options) { … }

lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
                                              lldb::addr_t address,
                                              SBType sb_type) { … }

lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
                                           SBType sb_type) { … }

SBValue SBValue::GetChildAtIndex(uint32_t idx) { … }

SBValue SBValue::GetChildAtIndex(uint32_t idx,
                                 lldb::DynamicValueType use_dynamic,
                                 bool can_create_synthetic) { … }

uint32_t SBValue::GetIndexOfChildWithName(const char *name) { … }

SBValue SBValue::GetChildMemberWithName(const char *name) { … }

SBValue
SBValue::GetChildMemberWithName(const char *name,
                                lldb::DynamicValueType use_dynamic_value) { … }

lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) { … }

lldb::SBValue SBValue::GetStaticValue() { … }

lldb::SBValue SBValue::GetNonSyntheticValue() { … }

lldb::SBValue SBValue::GetSyntheticValue() { … }

lldb::DynamicValueType SBValue::GetPreferDynamicValue() { … }

void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) { … }

bool SBValue::GetPreferSyntheticValue() { … }

void SBValue::SetPreferSyntheticValue(bool use_synthetic) { … }

bool SBValue::IsDynamic() { … }

bool SBValue::IsSynthetic() { … }

bool SBValue::IsSyntheticChildrenGenerated() { … }

void SBValue::SetSyntheticChildrenGenerated(bool is) { … }

lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) { … }

int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) { … }

uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) { … }

int64_t SBValue::GetValueAsSigned(int64_t fail_value) { … }

uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) { … }

lldb::addr_t SBValue::GetValueAsAddress() { … }

bool SBValue::MightHaveChildren() { … }

bool SBValue::IsRuntimeSupportValue() { … }

uint32_t SBValue::GetNumChildren() { … }

uint32_t SBValue::GetNumChildren(uint32_t max) { … }

SBValue SBValue::Dereference() { … }

// Deprecated - please use GetType().IsPointerType() instead.
bool SBValue::TypeIsPointerType() { … }

void *SBValue::GetOpaqueType() { … }

lldb::SBTarget SBValue::GetTarget() { … }

lldb::SBProcess SBValue::GetProcess() { … }

lldb::SBThread SBValue::GetThread() { … }

lldb::SBFrame SBValue::GetFrame() { … }

lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const { … }

lldb::ValueObjectSP SBValue::GetSP() const { … }

void SBValue::SetSP(ValueImplSP impl_sp) { … }

void SBValue::SetSP(const lldb::ValueObjectSP &sp) { … }

void SBValue::SetSP(const lldb::ValueObjectSP &sp,
                    lldb::DynamicValueType use_dynamic) { … }

void SBValue::SetSP(const lldb::ValueObjectSP &sp, bool use_synthetic) { … }

void SBValue::SetSP(const lldb::ValueObjectSP &sp,
                    lldb::DynamicValueType use_dynamic, bool use_synthetic) { … }

void SBValue::SetSP(const lldb::ValueObjectSP &sp,
                    lldb::DynamicValueType use_dynamic, bool use_synthetic,
                    const char *name) { … }

bool SBValue::GetExpressionPath(SBStream &description) { … }

bool SBValue::GetExpressionPath(SBStream &description,
                                bool qualify_cxx_base_classes) { … }

lldb::SBValue SBValue::EvaluateExpression(const char *expr) const { … }

lldb::SBValue
SBValue::EvaluateExpression(const char *expr,
                            const SBExpressionOptions &options) const { … }

lldb::SBValue SBValue::EvaluateExpression(const char *expr,
                                          const SBExpressionOptions &options,
                                          const char *name) const { … }

bool SBValue::GetDescription(SBStream &description) { … }

lldb::Format SBValue::GetFormat() { … }

void SBValue::SetFormat(lldb::Format format) { … }

lldb::SBValue SBValue::AddressOf() { … }

lldb::addr_t SBValue::GetLoadAddress() { … }

lldb::SBAddress SBValue::GetAddress() { … }

lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) { … }

lldb::SBData SBValue::GetData() { … }

bool SBValue::SetData(lldb::SBData &data, SBError &error) { … }

lldb::SBValue SBValue::Clone(const char *new_name) { … }

lldb::SBDeclaration SBValue::GetDeclaration() { … }

lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
                                  SBError &error) { … }

// FIXME: Remove this method impl (as well as the decl in .h) once it is no
// longer needed.
// Backward compatibility fix in the interim.
lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
                                  bool write) { … }

lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
                                         bool write, SBError &error) { … }

lldb::SBValue SBValue::Persist() { … }

lldb::SBValue SBValue::GetVTable() { … }
llvm/lldb/source/API/SBValue.cpp
