mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-27 20:26:06 +00:00
e3e91517ff
Given our implementation of ValueObjects we could have a scenario where a ValueObject has a dynamic type of Foo* at one point, and then its dynamic type changes to Bar* If Bar* has synthetic children enabled, by the time we figure that out, our public API is already vending SBValues wrapping a DynamicVO, instead of a SyntheticVO and there was no trivial way for us to change the SP inside an SBValue on the fly This checkin reimplements SBValue in terms of a wrapper, ValueImpl, that allows this substitutions on-the-fly by overriding GetSP() to do The Right Thing (TM) As an additional bonus, GetNonSyntheticValue() now works, and we can get rid of the ForceDisableSyntheticChildren idiom in ScriptInterpreterPython Lastly, this checkin makes sure the synthetic VOs get the correct m_value and m_data from their parents (prevented summaries from working in some cases) llvm-svn: 166426
499 lines
18 KiB
C++
499 lines
18 KiB
C++
//===-- SWIG Interface for SBValue ------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace lldb {
|
|
|
|
%feature("docstring",
|
|
"Represents the value of a variable, a register, or an expression.
|
|
|
|
SBValue supports iteration through its child, which in turn is represented
|
|
as an SBValue. For example, we can get the general purpose registers of a
|
|
frame as an SBValue, and iterate through all the registers,
|
|
|
|
registerSet = frame.GetRegisters() # Returns an SBValueList.
|
|
for regs in registerSet:
|
|
if 'general purpose registers' in regs.getName().lower():
|
|
GPRs = regs
|
|
break
|
|
|
|
print '%s (number of children = %d):' % (GPRs.GetName(), GPRs.GetNumChildren())
|
|
for reg in GPRs:
|
|
print 'Name: ', reg.GetName(), ' Value: ', reg.GetValue()
|
|
|
|
produces the output:
|
|
|
|
General Purpose Registers (number of children = 21):
|
|
Name: rax Value: 0x0000000100000c5c
|
|
Name: rbx Value: 0x0000000000000000
|
|
Name: rcx Value: 0x00007fff5fbffec0
|
|
Name: rdx Value: 0x00007fff5fbffeb8
|
|
Name: rdi Value: 0x0000000000000001
|
|
Name: rsi Value: 0x00007fff5fbffea8
|
|
Name: rbp Value: 0x00007fff5fbffe80
|
|
Name: rsp Value: 0x00007fff5fbffe60
|
|
Name: r8 Value: 0x0000000008668682
|
|
Name: r9 Value: 0x0000000000000000
|
|
Name: r10 Value: 0x0000000000001200
|
|
Name: r11 Value: 0x0000000000000206
|
|
Name: r12 Value: 0x0000000000000000
|
|
Name: r13 Value: 0x0000000000000000
|
|
Name: r14 Value: 0x0000000000000000
|
|
Name: r15 Value: 0x0000000000000000
|
|
Name: rip Value: 0x0000000100000dae
|
|
Name: rflags Value: 0x0000000000000206
|
|
Name: cs Value: 0x0000000000000027
|
|
Name: fs Value: 0x0000000000000010
|
|
Name: gs Value: 0x0000000000000048
|
|
|
|
See also linked_list_iter() for another perspective on how to iterate through an
|
|
SBValue instance which interprets the value object as representing the head of a
|
|
linked list."
|
|
) SBValue;
|
|
class SBValue
|
|
{
|
|
public:
|
|
SBValue ();
|
|
|
|
SBValue (const SBValue &rhs);
|
|
|
|
~SBValue ();
|
|
|
|
bool
|
|
IsValid();
|
|
|
|
void
|
|
Clear();
|
|
|
|
SBError
|
|
GetError();
|
|
|
|
lldb::user_id_t
|
|
GetID ();
|
|
|
|
const char *
|
|
GetName();
|
|
|
|
const char *
|
|
GetTypeName ();
|
|
|
|
size_t
|
|
GetByteSize ();
|
|
|
|
bool
|
|
IsInScope ();
|
|
|
|
lldb::Format
|
|
GetFormat ();
|
|
|
|
void
|
|
SetFormat (lldb::Format format);
|
|
|
|
const char *
|
|
GetValue ();
|
|
|
|
int64_t
|
|
GetValueAsSigned(SBError& error, int64_t fail_value=0);
|
|
|
|
uint64_t
|
|
GetValueAsUnsigned(SBError& error, uint64_t fail_value=0);
|
|
|
|
int64_t
|
|
GetValueAsSigned(int64_t fail_value=0);
|
|
|
|
uint64_t
|
|
GetValueAsUnsigned(uint64_t fail_value=0);
|
|
|
|
ValueType
|
|
GetValueType ();
|
|
|
|
bool
|
|
GetValueDidChange ();
|
|
|
|
const char *
|
|
GetSummary ();
|
|
|
|
const char *
|
|
GetObjectDescription ();
|
|
|
|
lldb::SBValue
|
|
GetDynamicValue (lldb::DynamicValueType use_dynamic);
|
|
|
|
lldb::SBValue
|
|
GetStaticValue ();
|
|
|
|
lldb::SBValue
|
|
GetNonSyntheticValue ();
|
|
|
|
lldb::DynamicValueType
|
|
GetPreferDynamicValue ();
|
|
|
|
void
|
|
SetPreferDynamicValue (lldb::DynamicValueType use_dynamic);
|
|
|
|
bool
|
|
GetPreferSyntheticValue ();
|
|
|
|
void
|
|
SetPreferSyntheticValue (bool use_synthetic);
|
|
|
|
bool
|
|
IsDynamic();
|
|
|
|
bool
|
|
IsSynthetic ();
|
|
|
|
const char *
|
|
GetLocation ();
|
|
|
|
bool
|
|
SetValueFromCString (const char *value_str);
|
|
|
|
bool
|
|
SetValueFromCString (const char *value_str, lldb::SBError& error);
|
|
|
|
lldb::SBTypeFormat
|
|
GetTypeFormat ();
|
|
|
|
lldb::SBTypeSummary
|
|
GetTypeSummary ();
|
|
|
|
lldb::SBTypeFilter
|
|
GetTypeFilter ();
|
|
|
|
lldb::SBTypeSynthetic
|
|
GetTypeSynthetic ();
|
|
|
|
lldb::SBValue
|
|
GetChildAtIndex (uint32_t idx);
|
|
|
|
%feature("docstring", "
|
|
//------------------------------------------------------------------
|
|
/// Get a child value by index from a value.
|
|
///
|
|
/// Structs, unions, classes, arrays and and pointers have child
|
|
/// values that can be access by index.
|
|
///
|
|
/// Structs and unions access child members using a zero based index
|
|
/// for each child member. For
|
|
///
|
|
/// Classes reserve the first indexes for base classes that have
|
|
/// members (empty base classes are omitted), and all members of the
|
|
/// current class will then follow the base classes.
|
|
///
|
|
/// Pointers differ depending on what they point to. If the pointer
|
|
/// points to a simple type, the child at index zero
|
|
/// is the only child value available, unless \a synthetic_allowed
|
|
/// is \b true, in which case the pointer will be used as an array
|
|
/// and can create 'synthetic' child values using positive or
|
|
/// negative indexes. If the pointer points to an aggregate type
|
|
/// (an array, class, union, struct), then the pointee is
|
|
/// transparently skipped and any children are going to be the indexes
|
|
/// of the child values within the aggregate type. For example if
|
|
/// we have a 'Point' type and we have a SBValue that contains a
|
|
/// pointer to a 'Point' type, then the child at index zero will be
|
|
/// the 'x' member, and the child at index 1 will be the 'y' member
|
|
/// (the child at index zero won't be a 'Point' instance).
|
|
///
|
|
/// Arrays have a preset number of children that can be accessed by
|
|
/// index and will returns invalid child values for indexes that are
|
|
/// out of bounds unless the \a synthetic_allowed is \b true. In this
|
|
/// case the array can create 'synthetic' child values for indexes
|
|
/// that aren't in the array bounds using positive or negative
|
|
/// indexes.
|
|
///
|
|
/// @param[in] idx
|
|
/// The index of the child value to get
|
|
///
|
|
/// @param[in] use_dynamic
|
|
/// An enumeration that specifies wether to get dynamic values,
|
|
/// and also if the target can be run to figure out the dynamic
|
|
/// type of the child value.
|
|
///
|
|
/// @param[in] synthetic_allowed
|
|
/// If \b true, then allow child values to be created by index
|
|
/// for pointers and arrays for indexes that normally wouldn't
|
|
/// be allowed.
|
|
///
|
|
/// @return
|
|
/// A new SBValue object that represents the child member value.
|
|
//------------------------------------------------------------------
|
|
") GetChildAtIndex;
|
|
lldb::SBValue
|
|
GetChildAtIndex (uint32_t idx,
|
|
lldb::DynamicValueType use_dynamic,
|
|
bool can_create_synthetic);
|
|
|
|
lldb::SBValue
|
|
CreateChildAtOffset (const char *name, uint32_t offset, lldb::SBType type);
|
|
|
|
lldb::SBValue
|
|
SBValue::Cast (lldb::SBType type);
|
|
|
|
lldb::SBValue
|
|
CreateValueFromExpression (const char *name, const char* expression);
|
|
|
|
lldb::SBValue
|
|
CreateValueFromExpression (const char *name, const char* expression, SBExpressionOptions &options);
|
|
|
|
lldb::SBValue
|
|
CreateValueFromAddress(const char* name, lldb::addr_t address, lldb::SBType type);
|
|
|
|
lldb::SBValue
|
|
CreateValueFromData (const char* name,
|
|
lldb::SBData data,
|
|
lldb::SBType type);
|
|
|
|
lldb::SBType
|
|
GetType();
|
|
|
|
%feature("docstring", "
|
|
//------------------------------------------------------------------
|
|
/// Returns the child member index.
|
|
///
|
|
/// Matches children of this object only and will match base classes and
|
|
/// member names if this is a clang typed object.
|
|
///
|
|
/// @param[in] name
|
|
/// The name of the child value to get
|
|
///
|
|
/// @return
|
|
/// An index to the child member value.
|
|
//------------------------------------------------------------------
|
|
") GetIndexOfChildWithName;
|
|
uint32_t
|
|
GetIndexOfChildWithName (const char *name);
|
|
|
|
lldb::SBValue
|
|
GetChildMemberWithName (const char *name);
|
|
|
|
%feature("docstring", "
|
|
//------------------------------------------------------------------
|
|
/// Returns the child member value.
|
|
///
|
|
/// Matches child members of this object and child members of any base
|
|
/// classes.
|
|
///
|
|
/// @param[in] name
|
|
/// The name of the child value to get
|
|
///
|
|
/// @param[in] use_dynamic
|
|
/// An enumeration that specifies wether to get dynamic values,
|
|
/// and also if the target can be run to figure out the dynamic
|
|
/// type of the child value.
|
|
///
|
|
/// @return
|
|
/// A new SBValue object that represents the child member value.
|
|
//------------------------------------------------------------------
|
|
") GetChildMemberWithName;
|
|
lldb::SBValue
|
|
GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic);
|
|
|
|
%feature("docstring", "Expands nested expressions like .a->b[0].c[1]->d."
|
|
) GetValueForExpressionPath;
|
|
lldb::SBValue
|
|
GetValueForExpressionPath(const char* expr_path);
|
|
|
|
lldb::SBDeclaration
|
|
GetDeclaration ();
|
|
|
|
uint32_t
|
|
GetNumChildren ();
|
|
|
|
void *
|
|
GetOpaqueType();
|
|
|
|
lldb::SBValue
|
|
Dereference ();
|
|
|
|
lldb::SBValue
|
|
AddressOf();
|
|
|
|
bool
|
|
TypeIsPointerType ();
|
|
|
|
lldb::SBTarget
|
|
GetTarget();
|
|
|
|
lldb::SBProcess
|
|
GetProcess();
|
|
|
|
lldb::SBThread
|
|
GetThread();
|
|
|
|
lldb::SBFrame
|
|
GetFrame();
|
|
|
|
%feature("docstring", "
|
|
/// Find and watch a variable.
|
|
/// It returns an SBWatchpoint, which may be invalid.
|
|
") Watch;
|
|
lldb::SBWatchpoint
|
|
Watch (bool resolve_location, bool read, bool write, SBError &error);
|
|
|
|
%feature("docstring", "
|
|
/// Find and watch the location pointed to by a variable.
|
|
/// It returns an SBWatchpoint, which may be invalid.
|
|
") WatchPointee;
|
|
lldb::SBWatchpoint
|
|
WatchPointee (bool resolve_location, bool read, bool write, SBError &error);
|
|
|
|
bool
|
|
GetDescription (lldb::SBStream &description);
|
|
|
|
bool
|
|
GetExpressionPath (lldb::SBStream &description);
|
|
|
|
%feature("docstring", "
|
|
//------------------------------------------------------------------
|
|
/// Get an SBData wrapping what this SBValue points to.
|
|
///
|
|
/// This method will dereference the current SBValue, if its
|
|
/// data type is a T* or T[], and extract item_count elements
|
|
/// of type T from it, copying their contents in an SBData.
|
|
///
|
|
/// @param[in] item_idx
|
|
/// The index of the first item to retrieve. For an array
|
|
/// this is equivalent to array[item_idx], for a pointer
|
|
/// to *(pointer + item_idx). In either case, the measurement
|
|
/// unit for item_idx is the sizeof(T) rather than the byte
|
|
///
|
|
/// @param[in] item_count
|
|
/// How many items should be copied into the output. By default
|
|
/// only one item is copied, but more can be asked for.
|
|
///
|
|
/// @return
|
|
/// An SBData with the contents of the copied items, on success.
|
|
/// An empty SBData otherwise.
|
|
//------------------------------------------------------------------
|
|
") GetPointeeData;
|
|
lldb::SBData
|
|
GetPointeeData (uint32_t item_idx = 0,
|
|
uint32_t item_count = 1);
|
|
|
|
%feature("docstring", "
|
|
//------------------------------------------------------------------
|
|
/// Get an SBData wrapping the contents of this SBValue.
|
|
///
|
|
/// This method will read the contents of this object in memory
|
|
/// and copy them into an SBData for future use.
|
|
///
|
|
/// @return
|
|
/// An SBData with the contents of this SBValue, on success.
|
|
/// An empty SBData otherwise.
|
|
//------------------------------------------------------------------
|
|
") GetData;
|
|
lldb::SBData
|
|
GetData ();
|
|
|
|
lldb::addr_t
|
|
GetLoadAddress();
|
|
|
|
lldb::SBAddress
|
|
GetAddress();
|
|
|
|
%feature("docstring", "Returns an expression path for this value."
|
|
) GetExpressionPath;
|
|
bool
|
|
GetExpressionPath (lldb::SBStream &description, bool qualify_cxx_base_classes);
|
|
|
|
%pythoncode %{
|
|
def __get_dynamic__ (self):
|
|
'''Helper function for the "SBValue.dynamic" property.'''
|
|
return self.GetDynamicValue (eDynamicCanRunTarget)
|
|
|
|
__swig_getmethods__["name"] = GetName
|
|
if _newclass: name = property(GetName, None, doc='''A read only property that returns the name of this value as a string.''')
|
|
|
|
__swig_getmethods__["type"] = GetType
|
|
if _newclass: type = property(GetType, None, doc='''A read only property that returns a lldb.SBType object that represents the type for this value.''')
|
|
|
|
__swig_getmethods__["size"] = GetByteSize
|
|
if _newclass: size = property(GetByteSize, None, doc='''A read only property that returns the size in bytes of this value.''')
|
|
|
|
__swig_getmethods__["is_in_scope"] = IsInScope
|
|
if _newclass: is_in_scope = property(IsInScope, None, doc='''A read only property that returns a boolean value that indicates whether this value is currently lexically in scope.''')
|
|
|
|
__swig_getmethods__["format"] = GetFormat
|
|
__swig_setmethods__["format"] = SetFormat
|
|
if _newclass: format = property(GetName, SetFormat, doc='''A read/write property that gets/sets the format used for lldb.SBValue().GetValue() for this value. See enumerations that start with "lldb.eFormat".''')
|
|
|
|
__swig_getmethods__["value"] = GetValue
|
|
__swig_setmethods__["value"] = SetValueFromCString
|
|
if _newclass: value = property(GetValue, SetValueFromCString, doc='''A read/write property that gets/sets value from a string.''')
|
|
|
|
__swig_getmethods__["value_type"] = GetValueType
|
|
if _newclass: value_type = property(GetValueType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eValueType") that represents the type of this value (local, argument, global, register, etc.).''')
|
|
|
|
__swig_getmethods__["changed"] = GetValueDidChange
|
|
if _newclass: changed = property(GetValueDidChange, None, doc='''A read only property that returns a boolean value that indicates if this value has changed since it was last updated.''')
|
|
|
|
__swig_getmethods__["data"] = GetData
|
|
if _newclass: data = property(GetData, None, doc='''A read only property that returns an lldb object (lldb.SBData) that represents the bytes that make up the value for this object.''')
|
|
|
|
__swig_getmethods__["load_addr"] = GetLoadAddress
|
|
if _newclass: load_addr = property(GetLoadAddress, None, doc='''A read only property that returns the load address of this value as an integer.''')
|
|
|
|
__swig_getmethods__["addr"] = GetAddress
|
|
if _newclass: addr = property(GetAddress, None, doc='''A read only property that returns an lldb.SBAddress that represents the address of this value if it is in memory.''')
|
|
|
|
__swig_getmethods__["deref"] = Dereference
|
|
if _newclass: deref = property(Dereference, None, doc='''A read only property that returns an lldb.SBValue that is created by dereferencing this value.''')
|
|
|
|
__swig_getmethods__["address_of"] = AddressOf
|
|
if _newclass: address_of = property(AddressOf, None, doc='''A read only property that returns an lldb.SBValue that represents the address-of this value.''')
|
|
|
|
__swig_getmethods__["error"] = GetError
|
|
if _newclass: error = property(GetError, None, doc='''A read only property that returns the lldb.SBError that represents the error from the last time the variable value was calculated.''')
|
|
|
|
__swig_getmethods__["summary"] = GetSummary
|
|
if _newclass: summary = property(GetSummary, None, doc='''A read only property that returns the summary for this value as a string''')
|
|
|
|
__swig_getmethods__["description"] = GetObjectDescription
|
|
if _newclass: description = property(GetObjectDescription, None, doc='''A read only property that returns the language-specific description of this value as a string''')
|
|
|
|
__swig_getmethods__["dynamic"] = __get_dynamic__
|
|
if _newclass: dynamic = property(__get_dynamic__, None, doc='''A read only property that returns an lldb.SBValue that is created by finding the dynamic type of this value.''')
|
|
|
|
__swig_getmethods__["location"] = GetLocation
|
|
if _newclass: location = property(GetLocation, None, doc='''A read only property that returns the location of this value as a string.''')
|
|
|
|
__swig_getmethods__["target"] = GetTarget
|
|
if _newclass: target = property(GetTarget, None, doc='''A read only property that returns the lldb.SBTarget that this value is associated with.''')
|
|
|
|
__swig_getmethods__["process"] = GetProcess
|
|
if _newclass: process = property(GetProcess, None, doc='''A read only property that returns the lldb.SBProcess that this value is associated with, the returned value might be invalid and should be tested.''')
|
|
|
|
__swig_getmethods__["thread"] = GetThread
|
|
if _newclass: thread = property(GetThread, None, doc='''A read only property that returns the lldb.SBThread that this value is associated with, the returned value might be invalid and should be tested.''')
|
|
|
|
__swig_getmethods__["frame"] = GetFrame
|
|
if _newclass: frame = property(GetFrame, None, doc='''A read only property that returns the lldb.SBFrame that this value is associated with, the returned value might be invalid and should be tested.''')
|
|
|
|
__swig_getmethods__["num_children"] = GetNumChildren
|
|
if _newclass: num_children = property(GetNumChildren, None, doc='''A read only property that returns the number of child lldb.SBValues that this value has.''')
|
|
|
|
__swig_getmethods__["unsigned"] = GetValueAsUnsigned
|
|
if _newclass: unsigned = property(GetValueAsUnsigned, None, doc='''A read only property that returns the value of this SBValue as an usigned integer.''')
|
|
|
|
__swig_getmethods__["signed"] = GetValueAsSigned
|
|
if _newclass: signed = property(GetValueAsSigned, None, doc='''A read only property that returns the value of this SBValue as a signed integer.''')
|
|
|
|
def get_expr_path(self):
|
|
s = SBStream()
|
|
self.GetExpressionPath (s)
|
|
return s.GetData()
|
|
|
|
__swig_getmethods__["path"] = get_expr_path
|
|
if _newclass: path = property(get_expr_path, None, doc='''A read only property that returns the expression path that one can use to reach this value in an expression.''')
|
|
%}
|
|
|
|
};
|
|
|
|
} // namespace lldb
|