From 5569e64ea7853aa6ef08dbfbe847647e35ee94fa Mon Sep 17 00:00:00 2001 From: Greg Clayton Date: Mon, 6 Feb 2012 01:44:54 +0000 Subject: Removed all of the "#ifndef SWIG" from the SB header files since we are using interface (.i) files for each class. Changed the FindFunction class from: uint32_t SBTarget::FindFunctions (const char *name, uint32_t name_type_mask, bool append, lldb::SBSymbolContextList& sc_list) uint32_t SBModule::FindFunctions (const char *name, uint32_t name_type_mask, bool append, lldb::SBSymbolContextList& sc_list) To: lldb::SBSymbolContextList SBTarget::FindFunctions (const char *name, uint32_t name_type_mask = lldb::eFunctionNameTypeAny); lldb::SBSymbolContextList SBModule::FindFunctions (const char *name, uint32_t name_type_mask = lldb::eFunctionNameTypeAny); This makes the API easier to use from python. Also added the ability to append a SBSymbolContext or a SBSymbolContextList to a SBSymbolContextList. Exposed properties for lldb.SBSymbolContextList in python: lldb.SBSymbolContextList.modules => list() or all lldb.SBModule objects in the list lldb.SBSymbolContextList.compile_units => list() or all lldb.SBCompileUnits objects in the list lldb.SBSymbolContextList.functions => list() or all lldb.SBFunction objects in the list lldb.SBSymbolContextList.blocks => list() or all lldb.SBBlock objects in the list lldb.SBSymbolContextList.line_entries => list() or all lldb.SBLineEntry objects in the list lldb.SBSymbolContextList.symbols => list() or all lldb.SBSymbol objects in the list This allows a call to the SBTarget::FindFunctions(...) and SBModule::FindFunctions(...) and then the result can be used to extract the desired information: sc_list = lldb.target.FindFunctions("erase") for function in sc_list.functions: print function for symbol in sc_list.symbols: print symbol Exposed properties for the lldb.SBSymbolContext objects in python: lldb.SBSymbolContext.module => lldb.SBModule lldb.SBSymbolContext.compile_unit => lldb.SBCompileUnit lldb.SBSymbolContext.function => lldb.SBFunction lldb.SBSymbolContext.block => lldb.SBBlock lldb.SBSymbolContext.line_entry => lldb.SBLineEntry lldb.SBSymbolContext.symbol => lldb.SBSymbol Exposed properties for the lldb.SBBlock objects in python: lldb.SBBlock.parent => lldb.SBBlock for the parent block that contains lldb.SBBlock.sibling => lldb.SBBlock for the sibling block to the current block lldb.SBBlock.first_child => lldb.SBBlock for the first child block to the current block lldb.SBBlock.call_site => for inline functions, return a lldb.declaration object that gives the call site file, line and column lldb.SBBlock.name => for inline functions this is the name of the inline function that this block represents lldb.SBBlock.inlined_block => returns the inlined function block that contains this block (might return itself if the current block is an inlined block) lldb.SBBlock.range[int] => access the address ranges for a block by index, a list() with start and end address is returned lldb.SBBlock.ranges => an array or all address ranges for this block lldb.SBBlock.num_ranges => the number of address ranges for this blcok SBFunction objects can now get the SBType and the SBBlock that represents the top scope of the function. SBBlock objects can now get the variable list from the current block. The value list returned allows varaibles to be viewed prior with no process if code wants to check the variables in a function. There are two ways to get a variable list from a SBBlock: lldb::SBValueList SBBlock::GetVariables (lldb::SBFrame& frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic); lldb::SBValueList SBBlock::GetVariables (lldb::SBTarget& target, bool arguments, bool locals, bool statics); When a SBFrame is used, the values returned will be locked down to the frame and the values will be evaluated in the context of that frame. When a SBTarget is used, global an static variables can be viewed without a running process. llvm-svn: 149853 --- lldb/scripts/Python/interface/SBBlock.i | 81 +++++++++++++++++++++ lldb/scripts/Python/interface/SBFunction.i | 35 ++++++--- lldb/scripts/Python/interface/SBModule.i | 15 +--- lldb/scripts/Python/interface/SBSymbolContext.i | 28 +++++++ .../scripts/Python/interface/SBSymbolContextList.i | 85 ++++++++++++++++++++++ lldb/scripts/Python/interface/SBTarget.i | 17 +---- 6 files changed, 224 insertions(+), 37 deletions(-) (limited to 'lldb/scripts/Python/interface') diff --git a/lldb/scripts/Python/interface/SBBlock.i b/lldb/scripts/Python/interface/SBBlock.i index 83895edcc06..cdaf62cbeca 100644 --- a/lldb/scripts/Python/interface/SBBlock.i +++ b/lldb/scripts/Python/interface/SBBlock.i @@ -89,6 +89,87 @@ public: bool GetDescription (lldb::SBStream &description); + + lldb::SBValueList + GetVariables (lldb::SBFrame& frame, + bool arguments, + bool locals, + bool statics, + lldb::DynamicValueType use_dynamic); + + lldb::SBValueList + GetVariables (lldb::SBTarget& target, + bool arguments, + bool locals, + bool statics); + + %pythoncode %{ + def get_range_at_index(self, idx): + if idx < self.GetNumRanges(): + return [self.sbblock.GetRangeStartAddress(key), self.sbblock.GetRangeEndAddress(key)] + return [] + + class ranges_access(object): + '''A helper object that will lazily hand out an array of lldb.SBAddress that represent address ranges for a block.''' + def __init__(self, sbblock): + self.sbblock = sbblock + + def __len__(self): + if self.sbblock: + return self.sbblock.GetNumRanges() + return 0 + + def __getitem__(self, key): + count = len(self) + if type(key) is int: + return self.sbblock.get_range_at_index (key); + else: + print "error: unsupported item type: %s" % type(key) + return None + + def get_ranges_access_object(self): + '''An accessor function that returns a ranges_access() object which allows lazy block address ranges access.''' + return self.ranges_access (self) + + def get_ranges_array(self): + '''An accessor function that returns an array object that contains all ranges in this block object.''' + if not hasattr(self, 'ranges'): + self.ranges = [] + for idx in range(self.num_ranges): + self.ranges.append (self.get_range_at_index (idx)) + return self.ranges + + def get_call_site(self): + return declaration(self.GetInlinedCallSiteFile(), self.GetInlinedCallSiteLine(), self.GetInlinedCallSiteColumn()) + + __swig_getmethods__["parent"] = GetParent + if _newclass: x = property(GetParent, None) + + __swig_getmethods__["first_child"] = GetFirstChild + if _newclass: x = property(GetFirstChild, None) + + __swig_getmethods__["call_site"] = get_call_site + if _newclass: x = property(get_call_site, None) + + __swig_getmethods__["sibling"] = GetSibling + if _newclass: x = property(GetSibling, None) + + __swig_getmethods__["name"] = GetInlinedName + if _newclass: x = property(GetInlinedName, None) + + __swig_getmethods__["inlined_block"] = GetContainingInlinedBlock + if _newclass: x = property(GetContainingInlinedBlock, None) + + __swig_getmethods__["range"] = get_ranges_access_object + if _newclass: x = property(get_ranges_access_object, None) + + __swig_getmethods__["ranges"] = get_ranges_array + if _newclass: x = property(get_ranges_array, None) + + __swig_getmethods__["num_ranges"] = GetNumRanges + if _newclass: x = property(GetNumRanges, None) + %} + }; } // namespace lldb diff --git a/lldb/scripts/Python/interface/SBFunction.i b/lldb/scripts/Python/interface/SBFunction.i index 37b957fd5cf..e259490310b 100644 --- a/lldb/scripts/Python/interface/SBFunction.i +++ b/lldb/scripts/Python/interface/SBFunction.i @@ -65,15 +65,21 @@ public: lldb::SBInstructionList GetInstructions (lldb::SBTarget target); - SBAddress + lldb::SBAddress GetStartAddress (); - SBAddress + lldb::SBAddress GetEndAddress (); uint32_t GetPrologueByteSize (); + lldb::SBType + GetType (); + + lldb::SBBlock + GetBlock (); + bool GetDescription (lldb::SBStream &description); @@ -81,24 +87,29 @@ public: def get_instructions_from_current_target (self): return self.GetInstructions (target) - __swig_getmethods__["name"] = GetName - if _newclass: x = property(GetName, None) - - __swig_getmethods__["mangled"] = GetMangledName - if _newclass: x = property(GetMangledName, None) - __swig_getmethods__["addr"] = GetStartAddress if _newclass: x = property(GetStartAddress, None) - + + __swig_getmethods__["block"] = GetBlock + if _newclass: x = property(GetBlock, None) + __swig_getmethods__["end_addr"] = GetEndAddress if _newclass: x = property(GetEndAddress, None) - __swig_getmethods__["prologue_size"] = GetPrologueByteSize - if _newclass: x = property(GetPrologueByteSize, None) - __swig_getmethods__["instructions"] = get_instructions_from_current_target if _newclass: x = property(get_instructions_from_current_target, None) + __swig_getmethods__["mangled"] = GetMangledName + if _newclass: x = property(GetMangledName, None) + + __swig_getmethods__["name"] = GetName + if _newclass: x = property(GetName, None) + + __swig_getmethods__["prologue_size"] = GetPrologueByteSize + if _newclass: x = property(GetPrologueByteSize, None) + + __swig_getmethods__["type"] = GetType + if _newclass: x = property(GetType, None) %} }; diff --git a/lldb/scripts/Python/interface/SBModule.i b/lldb/scripts/Python/interface/SBModule.i index dc8f674722b..44d3a86d667 100644 --- a/lldb/scripts/Python/interface/SBModule.i +++ b/lldb/scripts/Python/interface/SBModule.i @@ -192,23 +192,14 @@ public: /// C++ methods, or ObjC selectors. /// See FunctionNameType for more details. /// - /// @param[in] append - /// If true, any matches will be appended to \a sc_list, else - /// matches replace the contents of \a sc_list. - /// - /// @param[out] sc_list + /// @return /// A symbol context list that gets filled in with all of the /// matches. - /// - /// @return - /// The number of matches added to \a sc_list. //------------------------------------------------------------------ ") FindFunctions; - uint32_t + lldb::SBSymbolContextList FindFunctions (const char *name, - uint32_t name_type_mask, // Logical OR one or more FunctionNameType enum bits - bool append, - lldb::SBSymbolContextList& sc_list); + uint32_t name_type_mask = lldb::eFunctionNameTypeAny); lldb::SBType FindFirstType (const char* name); diff --git a/lldb/scripts/Python/interface/SBSymbolContext.i b/lldb/scripts/Python/interface/SBSymbolContext.i index 5f29e8e2c3b..4bf7fe34788 100644 --- a/lldb/scripts/Python/interface/SBSymbolContext.i +++ b/lldb/scripts/Python/interface/SBSymbolContext.i @@ -79,6 +79,34 @@ public: bool GetDescription (lldb::SBStream &description); + + + %pythoncode %{ + __swig_getmethods__["module"] = GetModule + __swig_setmethods__["module"] = SetModule + if _newclass: x = property(GetModule, SetModule) + + __swig_getmethods__["compile_unit"] = GetCompileUnit + __swig_setmethods__["compile_unit"] = SetCompileUnit + if _newclass: x = property(GetCompileUnit, SetCompileUnit) + + __swig_getmethods__["function"] = GetFunction + __swig_setmethods__["function"] = SetFunction + if _newclass: x = property(GetFunction, SetFunction) + + __swig_getmethods__["block"] = GetBlock + __swig_setmethods__["block"] = SetBlock + if _newclass: x = property(GetBlock, SetBlock) + + __swig_getmethods__["symbol"] = GetSymbol + __swig_setmethods__["symbol"] = SetSymbol + if _newclass: x = property(GetSymbol, SetSymbol) + + __swig_getmethods__["line_entry"] = GetLineEntry + __swig_setmethods__["line_entry"] = SetLineEntry + if _newclass: x = property(GetLineEntry, SetLineEntry) + %} + }; } // namespace lldb diff --git a/lldb/scripts/Python/interface/SBSymbolContextList.i b/lldb/scripts/Python/interface/SBSymbolContextList.i index 6ea5978baed..0a03a22d4ab 100644 --- a/lldb/scripts/Python/interface/SBSymbolContextList.i +++ b/lldb/scripts/Python/interface/SBSymbolContextList.i @@ -48,8 +48,93 @@ public: SBSymbolContext GetContextAtIndex (uint32_t idx); + void + Append (lldb::SBSymbolContext &sc); + + void + Append (lldb::SBSymbolContextList &sc_list); + + bool + GetDescription (lldb::SBStream &description); + void Clear(); + + %pythoncode %{ + def __len__(self): + return self.GetSize() + + def __getitem__(self, key): + count = len(self) + if type(key) is int: + if key < count: + return self.GetContextAtIndex(key) + else: + raise IndexError + raise TypeError + + def get_module_array(self): + a = [] + for i in range(len(self)): + obj = self.GetContextAtIndex(i).module + if obj: + a.append(obj) + return a + + def get_compile_unit_array(self): + a = [] + for i in range(len(self)): + obj = self.GetContextAtIndex(i).compile_unit + if obj: + a.append(obj) + return a + def get_function_array(self): + a = [] + for i in range(len(self)): + obj = self.GetContextAtIndex(i).function + if obj: + a.append(obj) + return a + def get_block_array(self): + a = [] + for i in range(len(self)): + obj = self.GetContextAtIndex(i).block + if obj: + a.append(obj) + return a + def get_symbol_array(self): + a = [] + for i in range(len(self)): + obj = self.GetContextAtIndex(i).symbol + if obj: + a.append(obj) + return a + def get_line_entry_array(self): + a = [] + for i in range(len(self)): + obj = self.GetContextAtIndex(i).line_entry + if obj: + a.append(obj) + return a + __swig_getmethods__["modules"] = get_module_array + if _newclass: x = property(get_module_array, None) + + __swig_getmethods__["compile_units"] = get_compile_unit_array + if _newclass: x = property(get_compile_unit_array, None) + + __swig_getmethods__["functions"] = get_function_array + if _newclass: x = property(get_function_array, None) + + __swig_getmethods__["blocks"] = get_block_array + if _newclass: x = property(get_block_array, None) + + __swig_getmethods__["line_entries"] = get_line_entry_array + if _newclass: x = property(get_line_entry_array, None) + + __swig_getmethods__["symbols"] = get_symbol_array + if _newclass: x = property(get_symbol_array, None) + %} + }; } // namespace lldb diff --git a/lldb/scripts/Python/interface/SBTarget.i b/lldb/scripts/Python/interface/SBTarget.i index d917530ad0d..58a546b54c7 100644 --- a/lldb/scripts/Python/interface/SBTarget.i +++ b/lldb/scripts/Python/interface/SBTarget.i @@ -348,23 +348,14 @@ public: /// C++ methods, or ObjC selectors. /// See FunctionNameType for more details. /// - /// @param[in] append - /// If true, any matches will be appended to \a sc_list, else - /// matches replace the contents of \a sc_list. - /// - /// @param[out] sc_list - /// A symbol context list that gets filled in with all of the - /// matches. - /// /// @return - /// The number of matches added to \a sc_list. + /// A lldb::SBSymbolContextList that gets filled in with all of + /// the symbol contexts for all the matches. //------------------------------------------------------------------ ") FindFunctions; - uint32_t + lldb::SBSymbolContextList FindFunctions (const char *name, - uint32_t name_type_mask, // Logical OR one or more FunctionNameType enum bits - bool append, - lldb::SBSymbolContextList& sc_list); + uint32_t name_type_mask = lldb::eFunctionNameTypeAny); lldb::SBType FindFirstType (const char* type); -- cgit v1.2.3