Index: vendor/lldb/dist/include/lldb/API/SBAttachInfo.h =================================================================== --- vendor/lldb/dist/include/lldb/API/SBAttachInfo.h (revision 321699) +++ vendor/lldb/dist/include/lldb/API/SBAttachInfo.h (revision 321700) @@ -1,190 +1,190 @@ //===-- SBAttachInfo.h ------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef LLDB_SBAttachInfo_h_ #define LLDB_SBAttachInfo_h_ #include "lldb/API/SBDefines.h" namespace lldb { class SBTarget; class LLDB_API SBAttachInfo { public: SBAttachInfo(); SBAttachInfo(lldb::pid_t pid); //------------------------------------------------------------------ /// Attach to a process by name. /// /// This function implies that a future call to SBTarget::Attach(...) /// will be synchronous. /// /// @param[in] path /// A full or partial name for the process to attach to. /// /// @param[in] wait_for /// If \b false, attach to an existing process whose name matches. /// If \b true, then wait for the next process whose name matches. //------------------------------------------------------------------ SBAttachInfo(const char *path, bool wait_for); //------------------------------------------------------------------ /// Attach to a process by name. /// /// Future calls to SBTarget::Attach(...) will be synchronous or /// asynchronous depending on the \a async argument. /// /// @param[in] path /// A full or partial name for the process to attach to. /// /// @param[in] wait_for /// If \b false, attach to an existing process whose name matches. /// If \b true, then wait for the next process whose name matches. /// /// @param[in] async /// If \b false, then the SBTarget::Attach(...) call will be a /// synchronous call with no way to cancel the attach in /// progress. /// If \b true, then the SBTarget::Attach(...) function will /// return immediately and clients are expected to wait for a /// process eStateStopped event if a suitable process is /// eventually found. If the client wants to cancel the event, /// SBProcess::Stop() can be called and an eStateExited process /// event will be delivered. //------------------------------------------------------------------ SBAttachInfo(const char *path, bool wait_for, bool async); SBAttachInfo(const SBAttachInfo &rhs); ~SBAttachInfo(); SBAttachInfo &operator=(const SBAttachInfo &rhs); lldb::pid_t GetProcessID(); void SetProcessID(lldb::pid_t pid); void SetExecutable(const char *path); void SetExecutable(lldb::SBFileSpec exe_file); bool GetWaitForLaunch(); //------------------------------------------------------------------ /// Set attach by process name settings. /// /// Designed to be used after a call to SBAttachInfo::SetExecutable(). /// This function implies that a call to SBTarget::Attach(...) will /// be synchronous. /// /// @param[in] b /// If \b false, attach to an existing process whose name matches. /// If \b true, then wait for the next process whose name matches. //------------------------------------------------------------------ void SetWaitForLaunch(bool b); //------------------------------------------------------------------ /// Set attach by process name settings. /// /// Designed to be used after a call to SBAttachInfo::SetExecutable(). /// Future calls to SBTarget::Attach(...) will be synchronous or /// asynchronous depending on the \a async argument. /// /// @param[in] b /// If \b false, attach to an existing process whose name matches. /// If \b true, then wait for the next process whose name matches. /// /// @param[in] async /// If \b false, then the SBTarget::Attach(...) call will be a /// synchronous call with no way to cancel the attach in /// progress. /// If \b true, then the SBTarget::Attach(...) function will /// return immediately and clients are expected to wait for a /// process eStateStopped event if a suitable process is /// eventually found. If the client wants to cancel the event, /// SBProcess::Stop() can be called and an eStateExited process /// event will be delivered. //------------------------------------------------------------------ void SetWaitForLaunch(bool b, bool async); bool GetIgnoreExisting(); void SetIgnoreExisting(bool b); uint32_t GetResumeCount(); void SetResumeCount(uint32_t c); const char *GetProcessPluginName(); void SetProcessPluginName(const char *plugin_name); uint32_t GetUserID(); uint32_t GetGroupID(); bool UserIDIsValid(); bool GroupIDIsValid(); void SetUserID(uint32_t uid); void SetGroupID(uint32_t gid); uint32_t GetEffectiveUserID(); uint32_t GetEffectiveGroupID(); bool EffectiveUserIDIsValid(); bool EffectiveGroupIDIsValid(); void SetEffectiveUserID(uint32_t uid); void SetEffectiveGroupID(uint32_t gid); lldb::pid_t GetParentProcessID(); void SetParentProcessID(lldb::pid_t pid); bool ParentProcessIDIsValid(); //---------------------------------------------------------------------- /// Get the listener that will be used to receive process events. /// /// If no listener has been set via a call to - /// SBLaunchInfo::SetListener(), then an invalid SBListener will be + /// SBAttachInfo::SetListener(), then an invalid SBListener will be /// returned (SBListener::IsValid() will return false). If a listener /// has been set, then the valid listener object will be returned. //---------------------------------------------------------------------- SBListener GetListener(); //---------------------------------------------------------------------- /// Set the listener that will be used to receive process events. /// /// By default the SBDebugger, which has a listener, that the SBTarget /// belongs to will listen for the process events. Calling this function /// allows a different listener to be used to listen for process events. //---------------------------------------------------------------------- void SetListener(SBListener &listener); protected: friend class SBTarget; lldb_private::ProcessAttachInfo &ref(); ProcessAttachInfoSP m_opaque_sp; }; } // namespace lldb #endif // LLDB_SBAttachInfo_h_ Index: vendor/lldb/dist/include/lldb/API/SBBreakpoint.h =================================================================== --- vendor/lldb/dist/include/lldb/API/SBBreakpoint.h (revision 321699) +++ vendor/lldb/dist/include/lldb/API/SBBreakpoint.h (revision 321700) @@ -1,176 +1,176 @@ //===-- SBBreakpoint.h ------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef LLDB_SBBreakpoint_h_ #define LLDB_SBBreakpoint_h_ #include "lldb/API/SBDefines.h" class SBBreakpointListImpl; namespace lldb { class LLDB_API SBBreakpoint { public: typedef bool (*BreakpointHitCallback)(void *baton, SBProcess &process, SBThread &thread, lldb::SBBreakpointLocation &location); SBBreakpoint(); SBBreakpoint(const lldb::SBBreakpoint &rhs); ~SBBreakpoint(); const lldb::SBBreakpoint &operator=(const lldb::SBBreakpoint &rhs); // Tests to see if the opaque breakpoint object in this object matches the // opaque breakpoint object in "rhs". bool operator==(const lldb::SBBreakpoint &rhs); bool operator!=(const lldb::SBBreakpoint &rhs); break_id_t GetID() const; bool IsValid() const; void ClearAllBreakpointSites(); lldb::SBBreakpointLocation FindLocationByAddress(lldb::addr_t vm_addr); lldb::break_id_t FindLocationIDByAddress(lldb::addr_t vm_addr); lldb::SBBreakpointLocation FindLocationByID(lldb::break_id_t bp_loc_id); lldb::SBBreakpointLocation GetLocationAtIndex(uint32_t index); void SetEnabled(bool enable); bool IsEnabled(); void SetOneShot(bool one_shot); bool IsOneShot() const; bool IsInternal(); uint32_t GetHitCount() const; void SetIgnoreCount(uint32_t count); uint32_t GetIgnoreCount() const; void SetCondition(const char *condition); const char *GetCondition(); void SetThreadID(lldb::tid_t sb_thread_id); lldb::tid_t GetThreadID(); void SetThreadIndex(uint32_t index); uint32_t GetThreadIndex() const; void SetThreadName(const char *thread_name); const char *GetThreadName() const; void SetQueueName(const char *queue_name); const char *GetQueueName() const; void SetCallback(BreakpointHitCallback callback, void *baton); void SetScriptCallbackFunction(const char *callback_function_name); void SetCommandLineCommands(SBStringList &commands); bool GetCommandLineCommands(SBStringList &commands); SBError SetScriptCallbackBody(const char *script_body_text); bool AddName(const char *new_name); void RemoveName(const char *name_to_remove); bool MatchesName(const char *name); void GetNames(SBStringList &names); size_t GetNumResolvedLocations() const; size_t GetNumLocations() const; bool GetDescription(lldb::SBStream &description); bool GetDescription(lldb::SBStream &description, bool include_locations); static bool EventIsBreakpointEvent(const lldb::SBEvent &event); static lldb::BreakpointEventType GetBreakpointEventTypeFromEvent(const lldb::SBEvent &event); static lldb::SBBreakpoint GetBreakpointFromEvent(const lldb::SBEvent &event); static lldb::SBBreakpointLocation GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event, uint32_t loc_idx); static uint32_t GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event_sp); private: friend class SBBreakpointList; friend class SBBreakpointLocation; friend class SBTarget; SBBreakpoint(const lldb::BreakpointSP &bp_sp); static bool PrivateBreakpointHitCallback( void *baton, lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id); lldb::BreakpointSP GetSP() const; lldb::BreakpointWP m_opaque_wp; }; class LLDB_API SBBreakpointList { public: SBBreakpointList(SBTarget &target); ~SBBreakpointList(); size_t GetSize() const; SBBreakpoint GetBreakpointAtIndex(size_t idx); SBBreakpoint FindBreakpointByID(lldb::break_id_t); - void Append(const SBBreakpoint &sb_file); + void Append(const SBBreakpoint &sb_bkpt); - bool AppendIfUnique(const SBBreakpoint &sb_file); + bool AppendIfUnique(const SBBreakpoint &sb_bkpt); void AppendByID(lldb::break_id_t id); void Clear(); protected: friend class SBTarget; void CopyToBreakpointIDList(lldb_private::BreakpointIDList &bp_id_list); private: std::shared_ptr m_opaque_sp; }; } // namespace lldb #endif // LLDB_SBBreakpoint_h_ Index: vendor/lldb/dist/include/lldb/API/SBProcess.h =================================================================== --- vendor/lldb/dist/include/lldb/API/SBProcess.h (revision 321699) +++ vendor/lldb/dist/include/lldb/API/SBProcess.h (revision 321700) @@ -1,406 +1,406 @@ //===-- SBProcess.h ---------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef LLDB_SBProcess_h_ #define LLDB_SBProcess_h_ #include "lldb/API/SBDefines.h" #include "lldb/API/SBError.h" #include "lldb/API/SBQueue.h" #include "lldb/API/SBTarget.h" #include namespace lldb { class SBEvent; class LLDB_API SBProcess { public: //------------------------------------------------------------------ /// Broadcaster event bits definitions. //------------------------------------------------------------------ FLAGS_ANONYMOUS_ENUM(){eBroadcastBitStateChanged = (1 << 0), eBroadcastBitInterrupt = (1 << 1), eBroadcastBitSTDOUT = (1 << 2), eBroadcastBitSTDERR = (1 << 3), eBroadcastBitProfileData = (1 << 4), eBroadcastBitStructuredData = (1 << 5)}; SBProcess(); SBProcess(const lldb::SBProcess &rhs); const lldb::SBProcess &operator=(const lldb::SBProcess &rhs); SBProcess(const lldb::ProcessSP &process_sp); ~SBProcess(); static const char *GetBroadcasterClassName(); const char *GetPluginName(); // DEPRECATED: use GetPluginName() const char *GetShortPluginName(); void Clear(); bool IsValid() const; lldb::SBTarget GetTarget() const; lldb::ByteOrder GetByteOrder() const; size_t PutSTDIN(const char *src, size_t src_len); size_t GetSTDOUT(char *dst, size_t dst_len) const; size_t GetSTDERR(char *dst, size_t dst_len) const; size_t GetAsyncProfileData(char *dst, size_t dst_len) const; void ReportEventState(const lldb::SBEvent &event, FILE *out) const; void AppendEventStateReport(const lldb::SBEvent &event, lldb::SBCommandReturnObject &result); //------------------------------------------------------------------ /// Remote connection related functions. These will fail if the /// process is not in eStateConnected. They are intended for use /// when connecting to an externally managed debugserver instance. //------------------------------------------------------------------ bool RemoteAttachToProcessWithID(lldb::pid_t pid, lldb::SBError &error); bool RemoteLaunch(char const **argv, char const **envp, const char *stdin_path, const char *stdout_path, const char *stderr_path, const char *working_directory, uint32_t launch_flags, bool stop_at_entry, lldb::SBError &error); //------------------------------------------------------------------ // Thread related functions //------------------------------------------------------------------ uint32_t GetNumThreads(); lldb::SBThread GetThreadAtIndex(size_t index); lldb::SBThread GetThreadByID(lldb::tid_t sb_thread_id); lldb::SBThread GetThreadByIndexID(uint32_t index_id); lldb::SBThread GetSelectedThread() const; //------------------------------------------------------------------ // Function for lazily creating a thread using the current OS // plug-in. This function will be removed in the future when there // are APIs to create SBThread objects through the interface and add // them to the process through the SBProcess API. //------------------------------------------------------------------ lldb::SBThread CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context); bool SetSelectedThread(const lldb::SBThread &thread); bool SetSelectedThreadByID(lldb::tid_t tid); bool SetSelectedThreadByIndexID(uint32_t index_id); //------------------------------------------------------------------ // Queue related functions //------------------------------------------------------------------ uint32_t GetNumQueues(); lldb::SBQueue GetQueueAtIndex(size_t index); //------------------------------------------------------------------ // Stepping related functions //------------------------------------------------------------------ lldb::StateType GetState(); int GetExitStatus(); const char *GetExitDescription(); //------------------------------------------------------------------ /// Gets the process ID /// /// Returns the process identifier for the process as it is known /// on the system on which the process is running. For unix systems /// this is typically the same as if you called "getpid()" in the /// process. /// /// @return /// Returns LLDB_INVALID_PROCESS_ID if this object does not /// contain a valid process object, or if the process has not /// been launched. Returns a valid process ID if the process is /// valid. //------------------------------------------------------------------ lldb::pid_t GetProcessID(); //------------------------------------------------------------------ /// Gets the unique ID associated with this process object /// /// Unique IDs start at 1 and increment up with each new process /// instance. Since starting a process on a system might always /// create a process with the same process ID, there needs to be a /// way to tell two process instances apart. /// /// @return /// Returns a non-zero integer ID if this object contains a /// valid process object, zero if this object does not contain /// a valid process object. //------------------------------------------------------------------ uint32_t GetUniqueID(); uint32_t GetAddressByteSize() const; lldb::SBError Destroy(); lldb::SBError Continue(); lldb::SBError Stop(); lldb::SBError Kill(); lldb::SBError Detach(); lldb::SBError Detach(bool keep_stopped); lldb::SBError Signal(int signal); lldb::SBUnixSignals GetUnixSignals(); void SendAsyncInterrupt(); uint32_t GetStopID(bool include_expression_stops = false); //------------------------------------------------------------------ /// Gets the stop event corresponding to stop ID. // /// Note that it wasn't fully implemented and tracks only the stop /// event for the last natural stop ID. /// /// @param [in] stop_id /// The ID of the stop event to return. /// /// @return /// The stop event corresponding to stop ID. //------------------------------------------------------------------ lldb::SBEvent GetStopEventForStopID(uint32_t stop_id); size_t ReadMemory(addr_t addr, void *buf, size_t size, lldb::SBError &error); size_t WriteMemory(addr_t addr, const void *buf, size_t size, lldb::SBError &error); size_t ReadCStringFromMemory(addr_t addr, void *buf, size_t size, lldb::SBError &error); uint64_t ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size, lldb::SBError &error); lldb::addr_t ReadPointerFromMemory(addr_t addr, lldb::SBError &error); // Events static lldb::StateType GetStateFromEvent(const lldb::SBEvent &event); static bool GetRestartedFromEvent(const lldb::SBEvent &event); static size_t GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event); static const char * GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event, size_t idx); static lldb::SBProcess GetProcessFromEvent(const lldb::SBEvent &event); static bool GetInterruptedFromEvent(const lldb::SBEvent &event); static lldb::SBStructuredData GetStructuredDataFromEvent(const lldb::SBEvent &event); static bool EventIsProcessEvent(const lldb::SBEvent &event); static bool EventIsStructuredDataEvent(const lldb::SBEvent &event); lldb::SBBroadcaster GetBroadcaster() const; static const char *GetBroadcasterClass(); bool GetDescription(lldb::SBStream &description); //------------------------------------------------------------------ /// Start Tracing with the given SBTraceOptions. /// /// @param[in] options /// Class containing trace options like trace buffer size, meta /// data buffer size, TraceType and any custom parameters /// {formatted as a JSON Dictionary}. In case of errors in /// formatting, an error would be reported. /// It must be noted that tracing options such as buffer sizes /// or other custom parameters passed maybe invalid for some /// trace technologies. In such cases the trace implementations /// could choose to either throw an error or could round off to /// the nearest valid options to start tracing if the passed /// value is not supported. To obtain the actual used trace /// options please use the GetTraceConfig API. For the custom /// parameters, only the parameters recognized by the target /// would be used and others would be ignored. /// /// @param[out] error /// An error explaining what went wrong. /// /// @return /// A SBTrace instance, which should be used /// to get the trace data or other trace related operations. //------------------------------------------------------------------ lldb::SBTrace StartTrace(SBTraceOptions &options, lldb::SBError &error); uint32_t GetNumSupportedHardwareWatchpoints(lldb::SBError &error) const; //------------------------------------------------------------------ /// Load a shared library into this process. /// /// @param[in] remote_image_spec /// The path for the shared library on the target what you want /// to load. /// /// @param[out] error /// An error object that gets filled in with any errors that /// might occur when trying to load the shared library. /// /// @return /// A token that represents the shared library that can be /// later used to unload the shared library. A value of /// LLDB_INVALID_IMAGE_TOKEN will be returned if the shared /// library can't be opened. //------------------------------------------------------------------ uint32_t LoadImage(lldb::SBFileSpec &remote_image_spec, lldb::SBError &error); //------------------------------------------------------------------ /// Load a shared library into this process. /// /// @param[in] local_image_spec /// The file spec that points to the shared library that you /// want to load if the library is located on the host. The /// library will be copied over to the location specified by /// remote_image_spec or into the current working directory with /// the same filename if the remote_image_spec isn't specified. /// /// @param[in] remote_image_spec /// If local_image_spec is specified then the location where the /// library should be copied over from the host. If /// local_image_spec isn't specified, then the path for the /// shared library on the target what you want to load. /// /// @param[out] error /// An error object that gets filled in with any errors that /// might occur when trying to load the shared library. /// /// @return /// A token that represents the shared library that can be /// later used to unload the shared library. A value of /// LLDB_INVALID_IMAGE_TOKEN will be returned if the shared /// library can't be opened. //------------------------------------------------------------------ uint32_t LoadImage(const lldb::SBFileSpec &local_image_spec, const lldb::SBFileSpec &remote_image_spec, lldb::SBError &error); lldb::SBError UnloadImage(uint32_t image_token); lldb::SBError SendEventData(const char *data); //------------------------------------------------------------------ /// Return the number of different thread-origin extended backtraces /// this process can support. /// /// When the process is stopped and you have an SBThread, lldb may be /// able to show a backtrace of when that thread was originally created, /// or the work item was enqueued to it (in the case of a libdispatch /// queue). /// /// @return /// The number of thread-origin extended backtrace types that may be /// available. //------------------------------------------------------------------ uint32_t GetNumExtendedBacktraceTypes(); //------------------------------------------------------------------ /// Return the name of one of the thread-origin extended backtrace /// methods. /// /// @param [in] idx /// The index of the name to return. They will be returned in /// the order that the user will most likely want to see them. /// e.g. if the type at index 0 is not available for a thread, /// see if the type at index 1 provides an extended backtrace. /// /// @return /// The name at that index. //------------------------------------------------------------------ const char *GetExtendedBacktraceTypeAtIndex(uint32_t idx); lldb::SBThreadCollection GetHistoryThreads(addr_t addr); bool IsInstrumentationRuntimePresent(InstrumentationRuntimeType type); - // Save the state of the process in a core file (or mini dump on Windows). + /// Save the state of the process in a core file (or mini dump on Windows). lldb::SBError SaveCore(const char *file_name); //------------------------------------------------------------------ /// Query the address load_addr and store the details of the memory /// region that contains it in the supplied SBMemoryRegionInfo object. /// To iterate over all memory regions use GetMemoryRegionList. /// /// @param[in] load_addr /// The address to be queried. /// /// @param[out] region_info /// A reference to an SBMemoryRegionInfo object that will contain /// the details of the memory region containing load_addr. /// /// @return /// An error object describes any errors that occurred while /// querying load_addr. //------------------------------------------------------------------ lldb::SBError GetMemoryRegionInfo(lldb::addr_t load_addr, lldb::SBMemoryRegionInfo ®ion_info); //------------------------------------------------------------------ /// Return the list of memory regions within the process. /// /// @return /// A list of all witin the process memory regions. //------------------------------------------------------------------ lldb::SBMemoryRegionInfoList GetMemoryRegions(); protected: friend class SBAddress; friend class SBBreakpoint; friend class SBBreakpointLocation; friend class SBCommandInterpreter; friend class SBDebugger; friend class SBExecutionContext; friend class SBFunction; friend class SBModule; friend class SBTarget; friend class SBThread; friend class SBValue; friend class lldb_private::QueueImpl; lldb::ProcessSP GetSP() const; void SetSP(const lldb::ProcessSP &process_sp); lldb::ProcessWP m_opaque_wp; }; } // namespace lldb #endif // LLDB_SBProcess_h_ Index: vendor/lldb/dist/scripts/interface/SBBreakpoint.i =================================================================== --- vendor/lldb/dist/scripts/interface/SBBreakpoint.i (revision 321699) +++ vendor/lldb/dist/scripts/interface/SBBreakpoint.i (revision 321700) @@ -1,301 +1,301 @@ //===-- SWIG Interface for SBBreakpoint -------------------------*- 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 a logical breakpoint and its associated settings. For example (from test/functionalities/breakpoint/breakpoint_ignore_count/ TestBreakpointIgnoreCount.py), def breakpoint_ignore_count_python(self): '''Use Python APIs to set breakpoint ignore count.''' exe = os.path.join(os.getcwd(), 'a.out') # Create a target by the debugger. target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # Now create a breakpoint on main.c by name 'c'. breakpoint = target.BreakpointCreateByName('c', 'a.out') self.assertTrue(breakpoint and breakpoint.GetNumLocations() == 1, VALID_BREAKPOINT) # Get the breakpoint location from breakpoint after we verified that, # indeed, it has one location. location = breakpoint.GetLocationAtIndex(0) self.assertTrue(location and location.IsEnabled(), VALID_BREAKPOINT_LOCATION) # Set the ignore count on the breakpoint location. location.SetIgnoreCount(2) self.assertTrue(location.GetIgnoreCount() == 2, 'SetIgnoreCount() works correctly') # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, os.getcwd()) self.assertTrue(process, PROCESS_IS_VALID) # Frame#0 should be on main.c:37, frame#1 should be on main.c:25, and # frame#2 should be on main.c:48. #lldbutil.print_stacktraces(process) from lldbutil import get_stopped_thread thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint) self.assertTrue(thread != None, 'There should be a thread stopped due to breakpoint') frame0 = thread.GetFrameAtIndex(0) frame1 = thread.GetFrameAtIndex(1) frame2 = thread.GetFrameAtIndex(2) self.assertTrue(frame0.GetLineEntry().GetLine() == self.line1 and frame1.GetLineEntry().GetLine() == self.line3 and frame2.GetLineEntry().GetLine() == self.line4, STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT) # The hit count for the breakpoint should be 3. self.assertTrue(breakpoint.GetHitCount() == 3) process.Continue() SBBreakpoint supports breakpoint location iteration, for example, for bl in breakpoint: print('breakpoint location load addr: %s' % hex(bl.GetLoadAddress())) print('breakpoint location condition: %s' % hex(bl.GetCondition())) -and rich comparion methods which allow the API program to use, +and rich comparison methods which allow the API program to use, if aBreakpoint == bBreakpoint: ... to compare two breakpoints for equality." ) SBBreakpoint; class SBBreakpoint { public: typedef bool (*BreakpointHitCallback) (void *baton, SBProcess &process, SBThread &thread, lldb::SBBreakpointLocation &location); SBBreakpoint (); SBBreakpoint (const lldb::SBBreakpoint& rhs); ~SBBreakpoint(); break_id_t GetID () const; bool IsValid() const; void ClearAllBreakpointSites (); lldb::SBBreakpointLocation FindLocationByAddress (lldb::addr_t vm_addr); lldb::break_id_t FindLocationIDByAddress (lldb::addr_t vm_addr); lldb::SBBreakpointLocation FindLocationByID (lldb::break_id_t bp_loc_id); lldb::SBBreakpointLocation GetLocationAtIndex (uint32_t index); void SetEnabled (bool enable); bool IsEnabled (); void SetOneShot (bool one_shot); bool IsOneShot (); bool IsInternal (); uint32_t GetHitCount () const; void SetIgnoreCount (uint32_t count); uint32_t GetIgnoreCount () const; %feature("docstring", " //-------------------------------------------------------------------------- /// The breakpoint stops only if the condition expression evaluates to true. //-------------------------------------------------------------------------- ") SetCondition; void SetCondition (const char *condition); %feature("docstring", " //------------------------------------------------------------------ /// Get the condition expression for the breakpoint. //------------------------------------------------------------------ ") GetCondition; const char * GetCondition (); void SetThreadID (lldb::tid_t sb_thread_id); lldb::tid_t GetThreadID (); void SetThreadIndex (uint32_t index); uint32_t GetThreadIndex() const; void SetThreadName (const char *thread_name); const char * GetThreadName () const; void SetQueueName (const char *queue_name); const char * GetQueueName () const; %feature("docstring", " //------------------------------------------------------------------ /// Set the name of the script function to be called when the breakpoint is hit. //------------------------------------------------------------------ ") SetScriptCallbackFunction; void SetScriptCallbackFunction (const char *callback_function_name); %feature("docstring", " //------------------------------------------------------------------ /// Provide the body for the script function to be called when the breakpoint is hit. /// The body will be wrapped in a function, which be passed two arguments: /// 'frame' - which holds the bottom-most SBFrame of the thread that hit the breakpoint /// 'bpno' - which is the SBBreakpointLocation to which the callback was attached. /// /// The error parameter is currently ignored, but will at some point hold the Python /// compilation diagnostics. /// Returns true if the body compiles successfully, false if not. //------------------------------------------------------------------ ") SetScriptCallbackBody; SBError SetScriptCallbackBody (const char *script_body_text); void SetCommandLineCommands(SBStringList &commands); bool GetCommandLineCommands(SBStringList &commands); bool AddName (const char *new_name); void RemoveName (const char *name_to_remove); bool MatchesName (const char *name); void GetNames (SBStringList &names); size_t GetNumResolvedLocations() const; size_t GetNumLocations() const; bool GetDescription (lldb::SBStream &description); bool GetDescription(lldb::SBStream &description, bool include_locations); bool operator == (const lldb::SBBreakpoint& rhs); bool operator != (const lldb::SBBreakpoint& rhs); static bool EventIsBreakpointEvent (const lldb::SBEvent &event); static lldb::BreakpointEventType GetBreakpointEventTypeFromEvent (const lldb::SBEvent& event); static lldb::SBBreakpoint GetBreakpointFromEvent (const lldb::SBEvent& event); static lldb::SBBreakpointLocation GetBreakpointLocationAtIndexFromEvent (const lldb::SBEvent& event, uint32_t loc_idx); static uint32_t GetNumBreakpointLocationsFromEvent (const lldb::SBEvent &event_sp); %pythoncode %{ __swig_getmethods__["id"] = GetID if _newclass: id = property(GetID, None, doc='''A read only property that returns the ID of this breakpoint.''') __swig_getmethods__["enabled"] = IsEnabled __swig_setmethods__["enabled"] = SetEnabled if _newclass: enabled = property(IsEnabled, SetEnabled, doc='''A read/write property that configures whether this breakpoint is enabled or not.''') __swig_getmethods__["one_shot"] = IsOneShot __swig_setmethods__["one_shot"] = SetOneShot if _newclass: one_shot = property(IsOneShot, SetOneShot, doc='''A read/write property that configures whether this breakpoint is one-shot (deleted when hit) or not.''') __swig_getmethods__["num_locations"] = GetNumLocations if _newclass: num_locations = property(GetNumLocations, None, doc='''A read only property that returns the count of locations of this breakpoint.''') %} }; class SBBreakpointListImpl; class LLDB_API SBBreakpointList { public: SBBreakpointList(SBTarget &target); ~SBBreakpointList(); size_t GetSize() const; SBBreakpoint GetBreakpointAtIndex(size_t idx); SBBreakpoint FindBreakpointByID(lldb::break_id_t); void Append(const SBBreakpoint &sb_bkpt); bool AppendIfUnique(const SBBreakpoint &sb_bkpt); void AppendByID (lldb::break_id_t id); void Clear(); private: std::shared_ptr m_opaque_sp; }; } // namespace lldb Index: vendor/lldb/dist/scripts/interface/SBModule.i =================================================================== --- vendor/lldb/dist/scripts/interface/SBModule.i (revision 321699) +++ vendor/lldb/dist/scripts/interface/SBModule.i (revision 321700) @@ -1,530 +1,530 @@ //===-- SWIG Interface for SBModule -----------------------------*- 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 an executable image and its associated object and symbol files. The module is designed to be able to select a single slice of an executable image as it would appear on disk and during program execution. You can retrieve SBModule from SBSymbolContext, which in turn is available from SBFrame. SBModule supports symbol iteration, for example, for symbol in module: name = symbol.GetName() saddr = symbol.GetStartAddress() eaddr = symbol.GetEndAddress() -and rich comparion methods which allow the API program to use, +and rich comparison methods which allow the API program to use, if thisModule == thatModule: print('This module is the same as that module') to test module equality. A module also contains object file sections, namely SBSection. SBModule supports section iteration through section_iter(), for example, print('Number of sections: %d' % module.GetNumSections()) for sec in module.section_iter(): print(sec) And to iterate the symbols within a SBSection, use symbol_in_section_iter(), # Iterates the text section and prints each symbols within each sub-section. for subsec in text_sec: print(INDENT + repr(subsec)) for sym in exe_module.symbol_in_section_iter(subsec): print(INDENT2 + repr(sym)) print(INDENT2 + 'symbol type: %s' % symbol_type_to_str(sym.GetType())) produces this following output: [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text id = {0x00000004}, name = 'mask_access(MaskAction, unsigned int)', range = [0x00000001000017c0-0x0000000100001870) symbol type: code id = {0x00000008}, name = 'thread_func(void*)', range = [0x0000000100001870-0x00000001000019b0) symbol type: code id = {0x0000000c}, name = 'main', range = [0x00000001000019b0-0x0000000100001d5c) symbol type: code id = {0x00000023}, name = 'start', address = 0x0000000100001780 symbol type: code [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs id = {0x00000024}, name = '__stack_chk_fail', range = [0x0000000100001d5c-0x0000000100001d62) symbol type: trampoline id = {0x00000028}, name = 'exit', range = [0x0000000100001d62-0x0000000100001d68) symbol type: trampoline id = {0x00000029}, name = 'fflush', range = [0x0000000100001d68-0x0000000100001d6e) symbol type: trampoline id = {0x0000002a}, name = 'fgets', range = [0x0000000100001d6e-0x0000000100001d74) symbol type: trampoline id = {0x0000002b}, name = 'printf', range = [0x0000000100001d74-0x0000000100001d7a) symbol type: trampoline id = {0x0000002c}, name = 'pthread_create', range = [0x0000000100001d7a-0x0000000100001d80) symbol type: trampoline id = {0x0000002d}, name = 'pthread_join', range = [0x0000000100001d80-0x0000000100001d86) symbol type: trampoline id = {0x0000002e}, name = 'pthread_mutex_lock', range = [0x0000000100001d86-0x0000000100001d8c) symbol type: trampoline id = {0x0000002f}, name = 'pthread_mutex_unlock', range = [0x0000000100001d8c-0x0000000100001d92) symbol type: trampoline id = {0x00000030}, name = 'rand', range = [0x0000000100001d92-0x0000000100001d98) symbol type: trampoline id = {0x00000031}, name = 'strtoul', range = [0x0000000100001d98-0x0000000100001d9e) symbol type: trampoline id = {0x00000032}, name = 'usleep', range = [0x0000000100001d9e-0x0000000100001da4) symbol type: trampoline [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame " ) SBModule; class SBModule { public: SBModule (); SBModule (const lldb::SBModule &rhs); SBModule (const lldb::SBModuleSpec &module_spec); SBModule (lldb::SBProcess &process, lldb::addr_t header_addr); ~SBModule (); bool IsValid () const; void Clear(); %feature("docstring", " //------------------------------------------------------------------ /// Get const accessor for the module file specification. /// /// This function returns the file for the module on the host system /// that is running LLDB. This can differ from the path on the /// platform since we might be doing remote debugging. /// /// @return /// A const reference to the file specification object. //------------------------------------------------------------------ ") GetFileSpec; lldb::SBFileSpec GetFileSpec () const; %feature("docstring", " //------------------------------------------------------------------ /// Get accessor for the module platform file specification. /// /// Platform file refers to the path of the module as it is known on /// the remote system on which it is being debugged. For local /// debugging this is always the same as Module::GetFileSpec(). But /// remote debugging might mention a file '/usr/lib/liba.dylib' /// which might be locally downloaded and cached. In this case the /// platform file could be something like: /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib' /// The file could also be cached in a local developer kit directory. /// /// @return /// A const reference to the file specification object. //------------------------------------------------------------------ ") GetPlatformFileSpec; lldb::SBFileSpec GetPlatformFileSpec () const; bool SetPlatformFileSpec (const lldb::SBFileSpec &platform_file); lldb::SBFileSpec GetRemoteInstallFileSpec (); bool SetRemoteInstallFileSpec (lldb::SBFileSpec &file); %feature("docstring", "Returns the UUID of the module as a Python string." ) GetUUIDString; const char * GetUUIDString () const; lldb::SBSection FindSection (const char *sect_name); lldb::SBAddress ResolveFileAddress (lldb::addr_t vm_addr); lldb::SBSymbolContext ResolveSymbolContextForAddress (const lldb::SBAddress& addr, uint32_t resolve_scope); bool GetDescription (lldb::SBStream &description); uint32_t GetNumCompileUnits(); lldb::SBCompileUnit GetCompileUnitAtIndex (uint32_t); size_t GetNumSymbols (); lldb::SBSymbol GetSymbolAtIndex (size_t idx); lldb::SBSymbol FindSymbol (const char *name, lldb::SymbolType type = eSymbolTypeAny); lldb::SBSymbolContextList FindSymbols (const char *name, lldb::SymbolType type = eSymbolTypeAny); size_t GetNumSections (); lldb::SBSection GetSectionAtIndex (size_t idx); %feature("docstring", " //------------------------------------------------------------------ /// Find functions by name. /// /// @param[in] name /// The name of the function we are looking for. /// /// @param[in] name_type_mask /// A logical OR of one or more FunctionNameType enum bits that /// indicate what kind of names should be used when doing the /// lookup. Bits include fully qualified names, base names, /// C++ methods, or ObjC selectors. /// See FunctionNameType for more details. /// /// @return /// A symbol context list that gets filled in with all of the /// matches. //------------------------------------------------------------------ ") FindFunctions; lldb::SBSymbolContextList FindFunctions (const char *name, uint32_t name_type_mask = lldb::eFunctionNameTypeAny); lldb::SBType FindFirstType (const char* name); lldb::SBTypeList FindTypes (const char* type); lldb::SBType GetTypeByID (lldb::user_id_t uid); lldb::SBType GetBasicType(lldb::BasicType type); %feature("docstring", " //------------------------------------------------------------------ /// Get all types matching \a type_mask from debug info in this /// module. /// /// @param[in] type_mask /// A bitfield that consists of one or more bits logically OR'ed /// together from the lldb::TypeClass enumeration. This allows /// you to request only structure types, or only class, struct /// and union types. Passing in lldb::eTypeClassAny will return /// all types found in the debug information for this module. /// /// @return /// A list of types in this module that match \a type_mask //------------------------------------------------------------------ ") GetTypes; lldb::SBTypeList GetTypes (uint32_t type_mask = lldb::eTypeClassAny); %feature("docstring", " //------------------------------------------------------------------ /// Find global and static variables by name. /// /// @param[in] target /// A valid SBTarget instance representing the debuggee. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @param[in] max_matches /// Allow the number of matches to be limited to \a max_matches. /// /// @return /// A list of matched variables in an SBValueList. //------------------------------------------------------------------ ") FindGlobalVariables; lldb::SBValueList FindGlobalVariables (lldb::SBTarget &target, const char *name, uint32_t max_matches); %feature("docstring", " //------------------------------------------------------------------ /// Find the first global (or static) variable by name. /// /// @param[in] target /// A valid SBTarget instance representing the debuggee. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @return /// An SBValue that gets filled in with the found variable (if any). //------------------------------------------------------------------ ") FindFirstGlobalVariable; lldb::SBValue FindFirstGlobalVariable (lldb::SBTarget &target, const char *name); lldb::ByteOrder GetByteOrder (); uint32_t GetAddressByteSize(); const char * GetTriple (); uint32_t GetVersion (uint32_t *versions, uint32_t num_versions); lldb::SBFileSpec GetSymbolFileSpec() const; lldb::SBAddress GetObjectFileHeaderAddress() const; bool operator == (const lldb::SBModule &rhs) const; bool operator != (const lldb::SBModule &rhs) const; %pythoncode %{ class symbols_access(object): re_compile_type = type(re.compile('.')) '''A helper object that will lazily hand out lldb.SBSymbol objects for a module when supplied an index, name, or regular expression.''' def __init__(self, sbmodule): self.sbmodule = sbmodule def __len__(self): if self.sbmodule: return int(self.sbmodule.GetNumSymbols()) return 0 def __getitem__(self, key): count = len(self) if type(key) is int: if key < count: return self.sbmodule.GetSymbolAtIndex(key) elif type(key) is str: matches = [] sc_list = self.sbmodule.FindSymbols(key) for sc in sc_list: symbol = sc.symbol if symbol: matches.append(symbol) return matches elif isinstance(key, self.re_compile_type): matches = [] for idx in range(count): symbol = self.sbmodule.GetSymbolAtIndex(idx) added = False name = symbol.name if name: re_match = key.search(name) if re_match: matches.append(symbol) added = True if not added: mangled = symbol.mangled if mangled: re_match = key.search(mangled) if re_match: matches.append(symbol) return matches else: print("error: unsupported item type: %s" % type(key)) return None def get_symbols_access_object(self): '''An accessor function that returns a symbols_access() object which allows lazy symbol access from a lldb.SBModule object.''' return self.symbols_access (self) def get_compile_units_access_object (self): '''An accessor function that returns a compile_units_access() object which allows lazy compile unit access from a lldb.SBModule object.''' return self.compile_units_access (self) def get_symbols_array(self): '''An accessor function that returns a list() that contains all symbols in a lldb.SBModule object.''' symbols = [] for idx in range(self.num_symbols): symbols.append(self.GetSymbolAtIndex(idx)) return symbols class sections_access(object): re_compile_type = type(re.compile('.')) '''A helper object that will lazily hand out lldb.SBSection objects for a module when supplied an index, name, or regular expression.''' def __init__(self, sbmodule): self.sbmodule = sbmodule def __len__(self): if self.sbmodule: return int(self.sbmodule.GetNumSections()) return 0 def __getitem__(self, key): count = len(self) if type(key) is int: if key < count: return self.sbmodule.GetSectionAtIndex(key) elif type(key) is str: for idx in range(count): section = self.sbmodule.GetSectionAtIndex(idx) if section.name == key: return section elif isinstance(key, self.re_compile_type): matches = [] for idx in range(count): section = self.sbmodule.GetSectionAtIndex(idx) name = section.name if name: re_match = key.search(name) if re_match: matches.append(section) return matches else: print("error: unsupported item type: %s" % type(key)) return None class compile_units_access(object): re_compile_type = type(re.compile('.')) '''A helper object that will lazily hand out lldb.SBCompileUnit objects for a module when supplied an index, full or partial path, or regular expression.''' def __init__(self, sbmodule): self.sbmodule = sbmodule def __len__(self): if self.sbmodule: return int(self.sbmodule.GetNumCompileUnits()) return 0 def __getitem__(self, key): count = len(self) if type(key) is int: if key < count: return self.sbmodule.GetCompileUnitAtIndex(key) elif type(key) is str: is_full_path = key[0] == '/' for idx in range(count): comp_unit = self.sbmodule.GetCompileUnitAtIndex(idx) if is_full_path: if comp_unit.file.fullpath == key: return comp_unit else: if comp_unit.file.basename == key: return comp_unit elif isinstance(key, self.re_compile_type): matches = [] for idx in range(count): comp_unit = self.sbmodule.GetCompileUnitAtIndex(idx) fullpath = comp_unit.file.fullpath if fullpath: re_match = key.search(fullpath) if re_match: matches.append(comp_unit) return matches else: print("error: unsupported item type: %s" % type(key)) return None def get_sections_access_object(self): '''An accessor function that returns a sections_access() object which allows lazy section array access.''' return self.sections_access (self) def get_sections_array(self): '''An accessor function that returns an array object that contains all sections in this module object.''' if not hasattr(self, 'sections_array'): self.sections_array = [] for idx in range(self.num_sections): self.sections_array.append(self.GetSectionAtIndex(idx)) return self.sections_array def get_compile_units_array(self): '''An accessor function that returns an array object that contains all compile_units in this module object.''' if not hasattr(self, 'compile_units_array'): self.compile_units_array = [] for idx in range(self.GetNumCompileUnits()): self.compile_units_array.append(self.GetCompileUnitAtIndex(idx)) return self.compile_units_array __swig_getmethods__["symbols"] = get_symbols_array if _newclass: symbols = property(get_symbols_array, None, doc='''A read only property that returns a list() of lldb.SBSymbol objects contained in this module.''') __swig_getmethods__["symbol"] = get_symbols_access_object if _newclass: symbol = property(get_symbols_access_object, None, doc='''A read only property that can be used to access symbols by index ("symbol = module.symbol[0]"), name ("symbols = module.symbol['main']"), or using a regular expression ("symbols = module.symbol[re.compile(...)]"). The return value is a single lldb.SBSymbol object for array access, and a list() of lldb.SBSymbol objects for name and regular expression access''') __swig_getmethods__["sections"] = get_sections_array if _newclass: sections = property(get_sections_array, None, doc='''A read only property that returns a list() of lldb.SBSection objects contained in this module.''') __swig_getmethods__["compile_units"] = get_compile_units_array if _newclass: compile_units = property(get_compile_units_array, None, doc='''A read only property that returns a list() of lldb.SBCompileUnit objects contained in this module.''') __swig_getmethods__["section"] = get_sections_access_object if _newclass: section = property(get_sections_access_object, None, doc='''A read only property that can be used to access symbols by index ("section = module.section[0]"), name ("sections = module.section[\'main\']"), or using a regular expression ("sections = module.section[re.compile(...)]"). The return value is a single lldb.SBSection object for array access, and a list() of lldb.SBSection objects for name and regular expression access''') __swig_getmethods__["compile_unit"] = get_compile_units_access_object if _newclass: section = property(get_sections_access_object, None, doc='''A read only property that can be used to access compile units by index ("compile_unit = module.compile_unit[0]"), name ("compile_unit = module.compile_unit[\'main.cpp\']"), or using a regular expression ("compile_unit = module.compile_unit[re.compile(...)]"). The return value is a single lldb.SBCompileUnit object for array access or by full or partial path, and a list() of lldb.SBCompileUnit objects regular expressions.''') def get_uuid(self): return uuid.UUID (self.GetUUIDString()) __swig_getmethods__["uuid"] = get_uuid if _newclass: uuid = property(get_uuid, None, doc='''A read only property that returns a standard python uuid.UUID object that represents the UUID of this module.''') __swig_getmethods__["file"] = GetFileSpec if _newclass: file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented where it is being debugged.''') __swig_getmethods__["platform_file"] = GetPlatformFileSpec if _newclass: platform_file = property(GetPlatformFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented on the current host system.''') __swig_getmethods__["byte_order"] = GetByteOrder if _newclass: byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this module.''') __swig_getmethods__["addr_size"] = GetAddressByteSize if _newclass: addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this module.''') __swig_getmethods__["triple"] = GetTriple if _newclass: triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this module.''') __swig_getmethods__["num_symbols"] = GetNumSymbols if _newclass: num_symbols = property(GetNumSymbols, None, doc='''A read only property that returns number of symbols in the module symbol table as an integer.''') __swig_getmethods__["num_sections"] = GetNumSections if _newclass: num_sections = property(GetNumSections, None, doc='''A read only property that returns number of sections in the module as an integer.''') %} }; } // namespace lldb Index: vendor/lldb/dist/scripts/interface/SBSymbol.i =================================================================== --- vendor/lldb/dist/scripts/interface/SBSymbol.i (revision 321699) +++ vendor/lldb/dist/scripts/interface/SBSymbol.i (revision 321700) @@ -1,110 +1,110 @@ //===-- SWIG Interface for SBSymbol -----------------------------*- 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 symbol possibly associated with a stack frame. -SBModule contains SBSymbol(s). SBSymbol can also be retrived from SBFrame. +SBModule contains SBSymbol(s). SBSymbol can also be retrieved from SBFrame. See also SBModule and SBFrame." ) SBSymbol; class SBSymbol { public: SBSymbol (); ~SBSymbol (); SBSymbol (const lldb::SBSymbol &rhs); bool IsValid () const; const char * GetName() const; const char * GetDisplayName() const; const char * GetMangledName () const; lldb::SBInstructionList GetInstructions (lldb::SBTarget target); lldb::SBInstructionList GetInstructions (lldb::SBTarget target, const char *flavor_string); SBAddress GetStartAddress (); SBAddress GetEndAddress (); uint32_t GetPrologueByteSize (); SymbolType GetType (); bool GetDescription (lldb::SBStream &description); bool IsExternal(); bool IsSynthetic(); bool operator == (const lldb::SBSymbol &rhs) const; bool operator != (const lldb::SBSymbol &rhs) const; %pythoncode %{ def get_instructions_from_current_target (self): return self.GetInstructions (target) __swig_getmethods__["name"] = GetName if _newclass: name = property(GetName, None, doc='''A read only property that returns the name for this symbol as a string.''') __swig_getmethods__["mangled"] = GetMangledName if _newclass: mangled = property(GetMangledName, None, doc='''A read only property that returns the mangled (linkage) name for this symbol as a string.''') __swig_getmethods__["type"] = GetType if _newclass: type = property(GetType, None, doc='''A read only property that returns an lldb enumeration value (see enumerations that start with "lldb.eSymbolType") that represents the type of this symbol.''') __swig_getmethods__["addr"] = GetStartAddress if _newclass: addr = property(GetStartAddress, None, doc='''A read only property that returns an lldb object that represents the start address (lldb.SBAddress) for this symbol.''') __swig_getmethods__["end_addr"] = GetEndAddress if _newclass: end_addr = property(GetEndAddress, None, doc='''A read only property that returns an lldb object that represents the end address (lldb.SBAddress) for this symbol.''') __swig_getmethods__["prologue_size"] = GetPrologueByteSize if _newclass: prologue_size = property(GetPrologueByteSize, None, doc='''A read only property that returns the size in bytes of the prologue instructions as an unsigned integer.''') __swig_getmethods__["instructions"] = get_instructions_from_current_target if _newclass: instructions = property(get_instructions_from_current_target, None, doc='''A read only property that returns an lldb object that represents the instructions (lldb.SBInstructionList) for this symbol.''') __swig_getmethods__["external"] = IsExternal if _newclass: external = property(IsExternal, None, doc='''A read only property that returns a boolean value that indicates if this symbol is externally visiable (exported) from the module that contains it.''') __swig_getmethods__["synthetic"] = IsSynthetic if _newclass: synthetic = property(IsSynthetic, None, doc='''A read only property that returns a boolean value that indicates if this symbol was synthetically created from information in module that contains it.''') %} }; } // namespace lldb