mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-29 16:29:00 -04:00
061858ce61
New public API for handling formatters: creating, deleting, modifying categories, and formatters, and managing type/formatter association. This provides SB classes for each of the main object types involved in providing formatter support: SBTypeCategory SBTypeFilter SBTypeFormat SBTypeSummary SBTypeSynthetic plus, an SBTypeNameSpecifier class that is used on the public API layer to abstract the notion that formatters can be applied to plain type-names as well as to regular expressions For naming consistency, this patch also renames a lot of formatters-related classes. Plus, the changes in how flags are handled that started with summaries is now extended to other classes as well. A new enum (lldb::eTypeOption) is meant to support this on the public side. The patch also adds several new calls to the formatter infrastructure that are used to implement by-index accessing and several other design changes required to accommodate the new API layer. An architectural change is introduced in that backing objects for formatters now become writable. On the public API layer, CoW is implemented to prevent unwanted propagation of changes. Lastly, there are some modifications in how the "default" category is constructed and managed in relation to other categories. llvm-svn: 150558
358 lines
9.5 KiB
C++
358 lines
9.5 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(frame)
|
|
|
|
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()
|
|
") SBDebugger;
|
|
class SBDebugger
|
|
{
|
|
public:
|
|
|
|
static void
|
|
Initialize();
|
|
|
|
static void
|
|
Terminate();
|
|
|
|
static lldb::SBDebugger
|
|
Create();
|
|
|
|
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",
|
|
"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);
|
|
|
|
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::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 ();
|
|
|
|
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);
|
|
|
|
void
|
|
DispatchInput (void *baton, const void *data, size_t data_len);
|
|
|
|
void
|
|
DispatchInputInterrupt ();
|
|
|
|
void
|
|
DispatchInputEndOfFile ();
|
|
|
|
void
|
|
PushInputReader (lldb::SBInputReader &reader);
|
|
|
|
void
|
|
NotifyTopInputReader (lldb::InputReaderAction notification);
|
|
|
|
bool
|
|
InputReaderIsTopReader (const lldb::SBInputReader &reader);
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
}; // class SBDebugger
|
|
|
|
} // namespace lldb
|