b842f2ecf0
When introduced, breakpoint names were just tags that you could apply to breakpoints that would allow you to refer to a breakpoint when you couldn't capture the ID, or to refer to a collection of breakpoints. This change makes the names independent holders of breakpoint options that you can then apply to breakpoints when you add the name to the breakpoint. It adds the "breakpoint name configure" command to set up or reconfigure breakpoint names. There is also full support for then in the SB API, including a new SBBreakpointName class. The connection between the name and the breakpoints sharing the name remains live, so if you reconfigure the name, all the breakpoint options all change as well. This allows a quick way to share complex breakpoint behavior among a bunch of breakpoints, and a convenient way to iterate on the set. You can also create a name from a breakpoint, allowing a quick way to copy options from one breakpoint to another. I also added the ability to make hidden and delete/disable protected names. When applied to a breakpoint, you will only be able to list, delete or disable that breakpoint if you refer to it explicitly by ID. This feature will allow GUI's that need to use breakpoints for their own purposes to keep their breakpoints from getting accidentally disabled or deleted. <rdar://problem/22094452> llvm-svn: 313292
432 lines
12 KiB
C++
432 lines
12 KiB
C++
//===-- SWIG Interface for SBDebugger ---------------------------*- 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",
|
|
"SBDebugger is the primordial object that creates SBTargets and provides
|
|
access to them. It also manages the overall debugging experiences.
|
|
|
|
For example (from example/disasm.py),
|
|
|
|
import lldb
|
|
import os
|
|
import sys
|
|
|
|
def disassemble_instructions (insts):
|
|
for i in insts:
|
|
print i
|
|
|
|
...
|
|
|
|
# Create a new debugger instance
|
|
debugger = lldb.SBDebugger.Create()
|
|
|
|
# When we step or continue, don't return from the function until the process
|
|
# stops. We do this by setting the async mode to false.
|
|
debugger.SetAsync (False)
|
|
|
|
# Create a target from a file and arch
|
|
print('Creating a target for \'%s\'' % exe)
|
|
|
|
target = debugger.CreateTargetWithFileAndArch (exe, lldb.LLDB_ARCH_DEFAULT)
|
|
|
|
if target:
|
|
# If the target is valid set a breakpoint at main
|
|
main_bp = target.BreakpointCreateByName (fname, target.GetExecutable().GetFilename());
|
|
|
|
print main_bp
|
|
|
|
# Launch the process. Since we specified synchronous mode, we won't return
|
|
# from this function until we hit the breakpoint at main
|
|
process = target.LaunchSimple (None, None, os.getcwd())
|
|
|
|
# Make sure the launch went ok
|
|
if process:
|
|
# Print some simple process info
|
|
state = process.GetState ()
|
|
print process
|
|
if state == lldb.eStateStopped:
|
|
# Get the first thread
|
|
thread = process.GetThreadAtIndex (0)
|
|
if thread:
|
|
# Print some simple thread info
|
|
print thread
|
|
# Get the first frame
|
|
frame = thread.GetFrameAtIndex (0)
|
|
if frame:
|
|
# Print some simple frame info
|
|
print frame
|
|
function = frame.GetFunction()
|
|
# See if we have debug info (a function)
|
|
if function:
|
|
# We do have a function, print some info for the function
|
|
print function
|
|
# Now get all instructions for this function and print them
|
|
insts = function.GetInstructions(target)
|
|
disassemble_instructions (insts)
|
|
else:
|
|
# See if we have a symbol in the symbol table for where we stopped
|
|
symbol = frame.GetSymbol();
|
|
if symbol:
|
|
# We do have a symbol, print some info for the symbol
|
|
print symbol
|
|
# Now get all instructions for this symbol and print them
|
|
insts = symbol.GetInstructions(target)
|
|
disassemble_instructions (insts)
|
|
|
|
registerList = frame.GetRegisters()
|
|
print('Frame registers (size of register set = %d):' % registerList.GetSize())
|
|
for value in registerList:
|
|
#print value
|
|
print('%s (number of children = %d):' % (value.GetName(), value.GetNumChildren()))
|
|
for child in value:
|
|
print('Name: ', child.GetName(), ' Value: ', child.GetValue())
|
|
|
|
print('Hit the breakpoint at main, enter to continue and wait for program to exit or \'Ctrl-D\'/\'quit\' to terminate the program')
|
|
next = sys.stdin.readline()
|
|
if not next or next.rstrip('\n') == 'quit':
|
|
print('Terminating the inferior process...')
|
|
process.Kill()
|
|
else:
|
|
# Now continue to the program exit
|
|
process.Continue()
|
|
# When we return from the above function we will hopefully be at the
|
|
# program exit. Print out some process info
|
|
print process
|
|
elif state == lldb.eStateExited:
|
|
print('Didn\'t hit the breakpoint at main, program has exited...')
|
|
else:
|
|
print('Unexpected process state: %s, killing process...' % debugger.StateAsCString (state))
|
|
process.Kill()
|
|
|
|
Sometimes you need to create an empty target that will get filled in later. The most common use for this
|
|
is to attach to a process by name or pid where you don't know the executable up front. The most convenient way
|
|
to do this is:
|
|
|
|
target = debugger.CreateTarget('')
|
|
error = lldb.SBError()
|
|
process = target.AttachToProcessWithName(debugger.GetListener(), 'PROCESS_NAME', False, error)
|
|
|
|
or the equivalent arguments for AttachToProcessWithID.
|
|
") SBDebugger;
|
|
class SBDebugger
|
|
{
|
|
public:
|
|
|
|
static void
|
|
Initialize();
|
|
|
|
static void
|
|
Terminate();
|
|
|
|
static lldb::SBDebugger
|
|
Create();
|
|
|
|
static lldb::SBDebugger
|
|
Create(bool source_init_files);
|
|
|
|
static lldb::SBDebugger
|
|
Create(bool source_init_files, lldb::LogOutputCallback log_callback, void *baton);
|
|
|
|
static void
|
|
Destroy (lldb::SBDebugger &debugger);
|
|
|
|
static void
|
|
MemoryPressureDetected();
|
|
|
|
SBDebugger();
|
|
|
|
SBDebugger(const lldb::SBDebugger &rhs);
|
|
|
|
~SBDebugger();
|
|
|
|
bool
|
|
IsValid() const;
|
|
|
|
void
|
|
Clear ();
|
|
|
|
void
|
|
SetAsync (bool b);
|
|
|
|
bool
|
|
GetAsync ();
|
|
|
|
void
|
|
SkipLLDBInitFiles (bool b);
|
|
|
|
void
|
|
SetInputFileHandle (FILE *f, bool transfer_ownership);
|
|
|
|
void
|
|
SetOutputFileHandle (FILE *f, bool transfer_ownership);
|
|
|
|
void
|
|
SetErrorFileHandle (FILE *f, bool transfer_ownership);
|
|
|
|
FILE *
|
|
GetInputFileHandle ();
|
|
|
|
FILE *
|
|
GetOutputFileHandle ();
|
|
|
|
FILE *
|
|
GetErrorFileHandle ();
|
|
|
|
lldb::SBCommandInterpreter
|
|
GetCommandInterpreter ();
|
|
|
|
void
|
|
HandleCommand (const char *command);
|
|
|
|
lldb::SBListener
|
|
GetListener ();
|
|
|
|
void
|
|
HandleProcessEvent (const lldb::SBProcess &process,
|
|
const lldb::SBEvent &event,
|
|
FILE *out,
|
|
FILE *err);
|
|
|
|
lldb::SBTarget
|
|
CreateTarget (const char *filename,
|
|
const char *target_triple,
|
|
const char *platform_name,
|
|
bool add_dependent_modules,
|
|
lldb::SBError& sb_error);
|
|
|
|
lldb::SBTarget
|
|
CreateTargetWithFileAndTargetTriple (const char *filename,
|
|
const char *target_triple);
|
|
|
|
lldb::SBTarget
|
|
CreateTargetWithFileAndArch (const char *filename,
|
|
const char *archname);
|
|
|
|
lldb::SBTarget
|
|
CreateTarget (const char *filename);
|
|
|
|
%feature("docstring",
|
|
"The dummy target holds breakpoints and breakpoint names that will prime newly created targets."
|
|
) GetDummyTarget;
|
|
lldb::SBTarget GetDummyTarget();
|
|
|
|
%feature("docstring",
|
|
"Return true if target is deleted from the target list of the debugger."
|
|
) DeleteTarget;
|
|
bool
|
|
DeleteTarget (lldb::SBTarget &target);
|
|
|
|
lldb::SBTarget
|
|
GetTargetAtIndex (uint32_t idx);
|
|
|
|
uint32_t
|
|
GetIndexOfTarget (lldb::SBTarget target);
|
|
|
|
lldb::SBTarget
|
|
FindTargetWithProcessID (pid_t pid);
|
|
|
|
lldb::SBTarget
|
|
FindTargetWithFileAndArch (const char *filename,
|
|
const char *arch);
|
|
|
|
uint32_t
|
|
GetNumTargets ();
|
|
|
|
lldb::SBTarget
|
|
GetSelectedTarget ();
|
|
|
|
void
|
|
SetSelectedTarget (lldb::SBTarget &target);
|
|
|
|
lldb::SBPlatform
|
|
GetSelectedPlatform();
|
|
|
|
void
|
|
SetSelectedPlatform(lldb::SBPlatform &platform);
|
|
|
|
%feature("docstring",
|
|
"Get the number of currently active platforms."
|
|
) GetNumPlatforms;
|
|
uint32_t
|
|
GetNumPlatforms ();
|
|
|
|
%feature("docstring",
|
|
"Get one of the currently active platforms."
|
|
) GetPlatformAtIndex;
|
|
lldb::SBPlatform
|
|
GetPlatformAtIndex (uint32_t idx);
|
|
|
|
%feature("docstring",
|
|
"Get the number of available platforms."
|
|
) GetNumAvailablePlatforms;
|
|
uint32_t
|
|
GetNumAvailablePlatforms ();
|
|
|
|
%feature("docstring", "
|
|
Get the name and description of one of the available platforms.
|
|
|
|
@param idx Zero-based index of the platform for which info should be
|
|
retrieved, must be less than the value returned by
|
|
GetNumAvailablePlatforms().
|
|
") GetAvailablePlatformInfoAtIndex;
|
|
lldb::SBStructuredData
|
|
GetAvailablePlatformInfoAtIndex (uint32_t idx);
|
|
|
|
lldb::SBSourceManager
|
|
GetSourceManager ();
|
|
|
|
// REMOVE: just for a quick fix, need to expose platforms through
|
|
// SBPlatform from this class.
|
|
lldb::SBError
|
|
SetCurrentPlatform (const char *platform_name);
|
|
|
|
bool
|
|
SetCurrentPlatformSDKRoot (const char *sysroot);
|
|
|
|
// FIXME: Once we get the set show stuff in place, the driver won't need
|
|
// an interface to the Set/Get UseExternalEditor.
|
|
bool
|
|
SetUseExternalEditor (bool input);
|
|
|
|
bool
|
|
GetUseExternalEditor ();
|
|
|
|
bool
|
|
SetUseColor (bool use_color);
|
|
|
|
bool
|
|
GetUseColor () const;
|
|
|
|
static bool
|
|
GetDefaultArchitecture (char *arch_name, size_t arch_name_len);
|
|
|
|
static bool
|
|
SetDefaultArchitecture (const char *arch_name);
|
|
|
|
lldb::ScriptLanguage
|
|
GetScriptingLanguage (const char *script_language_name);
|
|
|
|
static const char *
|
|
GetVersionString ();
|
|
|
|
static const char *
|
|
StateAsCString (lldb::StateType state);
|
|
|
|
static bool
|
|
StateIsRunningState (lldb::StateType state);
|
|
|
|
static bool
|
|
StateIsStoppedState (lldb::StateType state);
|
|
|
|
bool
|
|
EnableLog (const char *channel, const char ** types);
|
|
|
|
void
|
|
SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton);
|
|
|
|
void
|
|
DispatchInput (const void *data, size_t data_len);
|
|
|
|
void
|
|
DispatchInputInterrupt ();
|
|
|
|
void
|
|
DispatchInputEndOfFile ();
|
|
|
|
const char *
|
|
GetInstanceName ();
|
|
|
|
static SBDebugger
|
|
FindDebuggerWithID (int id);
|
|
|
|
static lldb::SBError
|
|
SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name);
|
|
|
|
static lldb::SBStringList
|
|
GetInternalVariableValue (const char *var_name, const char *debugger_instance_name);
|
|
|
|
bool
|
|
GetDescription (lldb::SBStream &description);
|
|
|
|
uint32_t
|
|
GetTerminalWidth () const;
|
|
|
|
void
|
|
SetTerminalWidth (uint32_t term_width);
|
|
|
|
lldb::user_id_t
|
|
GetID ();
|
|
|
|
const char *
|
|
GetPrompt() const;
|
|
|
|
void
|
|
SetPrompt (const char *prompt);
|
|
|
|
lldb::ScriptLanguage
|
|
GetScriptLanguage() const;
|
|
|
|
void
|
|
SetScriptLanguage (lldb::ScriptLanguage script_lang);
|
|
|
|
bool
|
|
GetCloseInputOnEOF () const;
|
|
|
|
void
|
|
SetCloseInputOnEOF (bool b);
|
|
|
|
lldb::SBTypeCategory
|
|
GetCategory (const char* category_name);
|
|
|
|
SBTypeCategory
|
|
GetCategory (lldb::LanguageType lang_type);
|
|
|
|
lldb::SBTypeCategory
|
|
CreateCategory (const char* category_name);
|
|
|
|
bool
|
|
DeleteCategory (const char* category_name);
|
|
|
|
uint32_t
|
|
GetNumCategories ();
|
|
|
|
lldb::SBTypeCategory
|
|
GetCategoryAtIndex (uint32_t);
|
|
|
|
lldb::SBTypeCategory
|
|
GetDefaultCategory();
|
|
|
|
lldb::SBTypeFormat
|
|
GetFormatForType (lldb::SBTypeNameSpecifier);
|
|
|
|
lldb::SBTypeSummary
|
|
GetSummaryForType (lldb::SBTypeNameSpecifier);
|
|
|
|
lldb::SBTypeFilter
|
|
GetFilterForType (lldb::SBTypeNameSpecifier);
|
|
|
|
lldb::SBTypeSynthetic
|
|
GetSyntheticForType (lldb::SBTypeNameSpecifier);
|
|
|
|
void
|
|
RunCommandInterpreter (bool auto_handle_events,
|
|
bool spawn_thread,
|
|
SBCommandInterpreterRunOptions &options,
|
|
int &num_errors,
|
|
bool &quit_requested,
|
|
bool &stopped_for_crash);
|
|
|
|
lldb::SBError
|
|
RunREPL (lldb::LanguageType language, const char *repl_options);
|
|
}; // class SBDebugger
|
|
|
|
} // namespace lldb
|