replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added a 'jump' command, similar to GDBs. 

This allows the PC to be directly changed to a different line.
It's similar to the example python script in examples/python/jump.py, except implemented as a builtin.

Also this version will track the current function correctly even if the target line resolves to multiple addresses. (e.g. debugging a templated function)

llvm-svn: 190572
This commit is contained in:
Richard Mitton 2013-09-12 02:20:34 +00:00
parent 50c003b577
commit f86248d9ba
19 changed files with 579 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lldb/include/lldb/API/SBThread.h
View File

@ -117,6 +117,9 @@ public:
lldb::SBFileSpec &file_spec,
uint32_t line);
SBError
JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line);
void
RunToAddress (lldb::addr_t addr);

2
lldb/include/lldb/Core/Error.h
View File

@ -68,7 +68,7 @@ public:
Error (ValueType err, lldb::ErrorType type = lldb::eErrorTypeGeneric);
explicit
Error (const char* err_str);
Error (const char *format, ...) __attribute__ ((format (printf, 2, 3)));
Error (const Error &rhs);
//------------------------------------------------------------------

26
lldb/include/lldb/Core/Module.h
View File

@ -346,6 +346,32 @@ public:
bool append,
SymbolContextList& sc_list);
//------------------------------------------------------------------
/// Find addresses by file/line
///
/// @param[in] target_sp
/// The target the addresses are desired for.
///
/// @param[in] file
/// Source file to locate.
///
/// @param[in] line
/// Source line to locate.
///
/// @param[in] function
/// Optional filter function. Addresses within this function will be
/// added to the 'local' list. All others will be added to the 'extern' list.
///
/// @param[out] output_local
/// All matching addresses within 'function'
///
/// @param[out] output_extern
/// All matching addresses not within 'function'
void FindAddressesForLine (const lldb::TargetSP target_sp,
const FileSpec &file, uint32_t line,
Function *function,
std::vector<Address> &output_local, std::vector<Address> &output_extern);
//------------------------------------------------------------------
/// Find global and static variables by name.
///

30
lldb/include/lldb/Core/ModuleList.h
View File

@ -439,7 +439,35 @@ public:
bool
FindSourceFile (const FileSpec &orig_spec, FileSpec &new_spec) const;
//------------------------------------------------------------------
/// Find addresses by file/line
///
/// @param[in] target_sp
/// The target the addresses are desired for.
///
/// @param[in] file
/// Source file to locate.
///
/// @param[in] line
/// Source line to locate.
///
/// @param[in] function
/// Optional filter function. Addresses within this function will be
/// added to the 'local' list. All others will be added to the 'extern' list.
///
/// @param[out] output_local
/// All matching addresses within 'function'
///
/// @param[out] output_extern
/// All matching addresses not within 'function'
void FindAddressesForLine (const lldb::TargetSP target_sp,
const FileSpec &file, uint32_t line,
Function *function,
std::vector<Address> &output_local, std::vector<Address> &output_extern);
bool
Remove (const lldb::ModuleSP &module_sp);

2
lldb/include/lldb/Target/RegisterContext.h
View File

@ -129,6 +129,8 @@ public:
bool
SetPC (uint64_t pc);
bool SetPC (Address addr);
uint64_t
GetSP (uint64_t fail_value = LLDB_INVALID_ADDRESS);

5
lldb/include/lldb/Target/Thread.h
View File

@ -377,7 +377,10 @@ public:
Error
ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return_value_sp, bool broadcast = false);
Error
JumpToLine (const FileSpec &file, uint32_t line, bool can_leave_function, std::string *warnings = NULL);
virtual lldb::StackFrameSP
GetFrameWithStackID (const StackID &stack_id)
{

7
lldb/scripts/Python/interface/SBThread.i
View File

@ -136,10 +136,13 @@ public:
StepInstruction(bool step_over);
SBError
StepOverUntil (lldb::SBFrame &frame,
lldb::SBFileSpec &file_spec,
StepOverUntil (lldb::SBFrame &frame,
lldb::SBFileSpec &file_spec,
uint32_t line);
SBError
JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line);
void
RunToAddress (lldb::addr_t addr);

25
lldb/source/API/SBThread.cpp
View File

@ -909,6 +909,31 @@ SBThread::StepOverUntil (lldb::SBFrame &sb_frame,
return sb_error;
}
SBError
SBThread::JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
SBError sb_error;
Mutex::Locker api_locker;
ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
if (log)
log->Printf ("SBThread(%p)::JumpToLine (file+line = %s:%u)", exe_ctx.GetThreadPtr(), file_spec->GetPath().c_str(), line);
if (!exe_ctx.HasThreadScope())
{
sb_error.SetErrorString("this SBThread object is invalid");
return sb_error;
}
Thread *thread = exe_ctx.GetThreadPtr();
Error err = thread->JumpToLine (file_spec.get(), line, true);
sb_error.SetError (err);
return sb_error;
}
SBError
SBThread::ReturnFromFrame (SBFrame &frame, SBValue &return_value)
{

203
lldb/source/Commands/CommandObjectThread.cpp
View File

@ -1462,6 +1462,208 @@ CommandObjectThreadReturn::CommandOptions::g_option_table[] =
{ 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
};
//-------------------------------------------------------------------------
// CommandObjectThreadJump
//-------------------------------------------------------------------------
class CommandObjectThreadJump : public CommandObjectParsed
{
public:
class CommandOptions : public Options
{
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter)
{
OptionParsingStarting ();
}
void
OptionParsingStarting ()
{
m_filenames.Clear();
m_line_num = 0;
m_line_offset = 0;
m_load_addr = LLDB_INVALID_ADDRESS;
m_force = false;
}
virtual
~CommandOptions ()
{
}
virtual Error
SetOptionValue (uint32_t option_idx, const char *option_arg)
{
bool success;
const int short_option = m_getopt_table[option_idx].val;
Error error;
switch (short_option)
{
case 'f':
m_filenames.AppendIfUnique (FileSpec(option_arg, false));
if (m_filenames.GetSize() > 1)
return Error("only one source file expected.");
break;
case 'l':
m_line_num = Args::StringToUInt32 (option_arg, 0, 0, &success);
if (!success || m_line_num == 0)
return Error("invalid line number: '%s'.", option_arg);
break;
case 'b':
m_line_offset = Args::StringToSInt32 (option_arg, 0, 0, &success);
if (!success)
return Error("invalid line offset: '%s'.", option_arg);
break;
case 'a':
{
ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
m_load_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
}
break;
case 'r':
m_force = true;
break;
default:
return Error("invalid short option character '%c'", short_option);
}
return error;
}
const OptionDefinition*
GetDefinitions ()
{
return g_option_table;
}
FileSpecList m_filenames;
uint32_t m_line_num;
int32_t m_line_offset;
lldb::addr_t m_load_addr;
bool m_force;
static OptionDefinition g_option_table[];
};
virtual
Options *
GetOptions ()
{
return &m_options;
}
CommandObjectThreadJump (CommandInterpreter &interpreter) :
CommandObjectParsed (interpreter,
"thread jump",
"Sets the program counter to a new address.",
"thread jump",
eFlagRequiresFrame |
eFlagTryTargetAPILock |
eFlagProcessMustBeLaunched |
eFlagProcessMustBePaused ),
m_options (interpreter)
{
}
~CommandObjectThreadJump()
{
}
protected:
bool DoExecute (Args& args, CommandReturnObject &result)
{
RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
StackFrame *frame = m_exe_ctx.GetFramePtr();
Thread *thread = m_exe_ctx.GetThreadPtr();
Target *target = m_exe_ctx.GetTargetPtr();
const SymbolContext &sym_ctx = frame->GetSymbolContext (eSymbolContextLineEntry);
if (m_options.m_load_addr != LLDB_INVALID_ADDRESS)
{
// Use this address directly.
Address dest = Address(m_options.m_load_addr);
lldb::addr_t callAddr = dest.GetCallableLoadAddress (target);
if (callAddr == LLDB_INVALID_ADDRESS)
{
result.AppendErrorWithFormat ("Invalid destination address.");
result.SetStatus (eReturnStatusFailed);
return false;
}
if (!reg_ctx->SetPC (callAddr))
{
result.AppendErrorWithFormat ("Error changing PC value for thread %d.", thread->GetIndexID());
result.SetStatus (eReturnStatusFailed);
return false;
}
}
else
{
// Pick either the absolute line, or work out a relative one.
int32_t line = (int32_t)m_options.m_line_num;
if (line == 0)
line = sym_ctx.line_entry.line + m_options.m_line_offset;
// Try the current file, but override if asked.
FileSpec file = sym_ctx.line_entry.file;
if (m_options.m_filenames.GetSize() == 1)
file = m_options.m_filenames.GetFileSpecAtIndex(0);
if (!file)
{
result.AppendErrorWithFormat ("No source file available for the current location.");
result.SetStatus (eReturnStatusFailed);
return false;
}
std::string warnings;
Error err = thread->JumpToLine (file, line, m_options.m_force, &warnings);
if (err.Fail())
{
result.SetError (err);
return false;
}
if (!warnings.empty())
result.AppendWarning (warnings.c_str());
}
result.SetStatus (eReturnStatusSuccessFinishResult);
return true;
}
CommandOptions m_options;
};
OptionDefinition
CommandObjectThreadJump::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, NULL, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,
"Specifies the source file to jump to."},
{ LLDB_OPT_SET_1, true, "line", 'l', OptionParser::eRequiredArgument, NULL, 0, eArgTypeLineNum,
"Specifies the line number to jump to."},
{ LLDB_OPT_SET_2, true, "by", 'b', OptionParser::eRequiredArgument, NULL, 0, eArgTypeOffset,
"Jumps by a relative line offset from the current line."},
{ LLDB_OPT_SET_3, true, "address", 'a', OptionParser::eRequiredArgument, NULL, 0, eArgTypeAddressOrExpression,
"Jumps to a specific address."},
{ LLDB_OPT_SET_1|
LLDB_OPT_SET_2|
LLDB_OPT_SET_3, false, "force",'r', OptionParser::eNoArgument, NULL, 0, eArgTypeNone,"Allows the PC to leave the current function."},
{ 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
};
//-------------------------------------------------------------------------
// CommandObjectMultiwordThread
//-------------------------------------------------------------------------
@ -1476,6 +1678,7 @@ CommandObjectMultiwordThread::CommandObjectMultiwordThread (CommandInterpreter &
LoadSubCommand ("continue", CommandObjectSP (new CommandObjectThreadContinue (interpreter)));
LoadSubCommand ("list", CommandObjectSP (new CommandObjectThreadList (interpreter)));
LoadSubCommand ("return", CommandObjectSP (new CommandObjectThreadReturn (interpreter)));
LoadSubCommand ("jump", CommandObjectSP (new CommandObjectThreadJump (interpreter)));
LoadSubCommand ("select", CommandObjectSP (new CommandObjectThreadSelect (interpreter)));
LoadSubCommand ("until", CommandObjectSP (new CommandObjectThreadUntil (interpreter)));
LoadSubCommand ("step-in", CommandObjectSP (new CommandObjectThreadStepWithTypeAndScope (

8
lldb/source/Core/Error.cpp
View File

@ -52,12 +52,16 @@ Error::Error (const Error &rhs) :
{
}
Error::Error (const char* err_str):
Error::Error (const char* format, ...):
m_code (0),
m_type (eErrorTypeInvalid),
m_string ()
{
SetErrorString(err_str);
va_list args;
va_start (args, format);
SetErrorToGenericError ();
SetErrorStringWithVarArg (format, args);
va_end (args);
}
//----------------------------------------------------------------------

24
lldb/source/Core/Module.cpp
View File

@ -9,6 +9,7 @@
#include "lldb/lldb-python.h"
#include "lldb/Core/AddressResolverFileLine.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/DataBuffer.h"
@ -752,6 +753,27 @@ Module::FindFunctions (const RegularExpression& regex,
return sc_list.GetSize() - start_size;
}
void
Module::FindAddressesForLine (const lldb::TargetSP target_sp,
const FileSpec &file, uint32_t line,
Function *function,
std::vector<Address> &output_local, std::vector<Address> &output_extern)
{
SearchFilterByModule filter(target_sp, m_file);
AddressResolverFileLine resolver(file, line, true);
resolver.ResolveAddress (filter);
for (size_t n=0;n<resolver.GetNumberOfAddresses();n++)
{
Address addr = resolver.GetAddressRangeAtIndex(n).GetBaseAddress();
Function *f = addr.CalculateSymbolContextFunction();
if (f && f == function)
output_local.push_back (addr);
else
output_extern.push_back (addr);
}
}
size_t
Module::FindTypes_Impl (const SymbolContext& sc,
const ConstString &name,
@ -1606,4 +1628,4 @@ Module::PrepareForFunctionNameLookup (const ConstString &name,
lookup_name = name;
match_name_after_lookup = false;
}
}
}

14
lldb/source/Core/ModuleList.cpp
View File

@ -663,7 +663,19 @@ ModuleList::FindSourceFile (const FileSpec &orig_spec, FileSpec &new_spec) const
return false;
}
void
ModuleList::FindAddressesForLine (const lldb::TargetSP target_sp,
const FileSpec &file, uint32_t line,
Function *function,
std::vector<Address> &output_local, std::vector<Address> &output_extern)
{
Mutex::Locker locker(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos)
{
(*pos)->FindAddressesForLine(target_sp, file, line, function, output_local, output_extern);
}
}
ModuleSP
ModuleList::FindFirstModule (const ModuleSpec &module_spec) const

27
lldb/source/Interpreter/CommandInterpreter.cpp
View File

@ -228,6 +228,13 @@ CommandInterpreter::Initialize ()
AddAlias ("t", cmd_obj_sp);
}
cmd_obj_sp = GetCommandSPExact ("_regexp-jump",false);
if (cmd_obj_sp)
{
AddAlias ("j", cmd_obj_sp);
AddAlias ("jump", cmd_obj_sp);
}
cmd_obj_sp = GetCommandSPExact ("_regexp-list", false);
if (cmd_obj_sp)
{
@ -618,6 +625,26 @@ CommandInterpreter::LoadCommandDictionary ()
}
}
std::unique_ptr<CommandObjectRegexCommand>
jump_regex_cmd_ap(new CommandObjectRegexCommand (*this,
"_regexp-jump",
"Sets the program counter to a new address.",
"_regexp-jump [<line>]\n"
"_regexp-jump [<+-lineoffset>]\n"
"_regexp-jump [<file>:<line>]\n"
"_regexp-jump [*<addr>]\n", 2));
if (jump_regex_cmd_ap.get())
{
if (jump_regex_cmd_ap->AddRegexCommand("^\\*(.*)$", "thread jump --addr %1") &&
jump_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "thread jump --line %1") &&
jump_regex_cmd_ap->AddRegexCommand("^([^:]+):([0-9]+)$", "thread jump --file %1 --line %2") &&
jump_regex_cmd_ap->AddRegexCommand("^([+\\-][0-9]+)$", "thread jump --by %1"))
{
CommandObjectSP jump_regex_cmd_sp(jump_regex_cmd_ap.release());
m_command_dict[jump_regex_cmd_sp->GetCommandName ()] = jump_regex_cmd_sp;
}
}
}
int

13
lldb/source/Target/RegisterContext.cpp
View File

@ -113,6 +113,19 @@ RegisterContext::SetPC(uint64_t pc)
return success;
}
bool
RegisterContext::SetPC(Address addr)
{
TargetSP target_sp = m_thread.CalculateTarget();
Target *target = target_sp.get();
lldb::addr_t callAddr = addr.GetCallableLoadAddress (target);
if (callAddr == LLDB_INVALID_ADDRESS)
return false;
return SetPC (callAddr);
}
uint64_t
RegisterContext::GetSP(uint64_t fail_value)
{

73
lldb/source/Target/Thread.cpp
View File

@ -1745,6 +1745,79 @@ Thread::ReturnFromFrame (lldb::StackFrameSP frame_sp, lldb::ValueObjectSP return
return return_error;
}
static void DumpAddressList (Stream &s, const std::vector<Address> &list, ExecutionContextScope *exe_scope)
{
for (size_t n=0;n<list.size();n++)
{
s << "\t";
list[n].Dump (&s, exe_scope, Address::DumpStyleResolvedDescription, Address::DumpStyleSectionNameOffset);
s << "\n";
}
}
Error
Thread::JumpToLine (const FileSpec &file, uint32_t line, bool can_leave_function, std::string *warnings)
{
ExecutionContext exe_ctx (GetStackFrameAtIndex(0));
Target *target = exe_ctx.GetTargetPtr();
TargetSP target_sp = exe_ctx.GetTargetSP();
RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
StackFrame *frame = exe_ctx.GetFramePtr();
const SymbolContext &sc = frame->GetSymbolContext(eSymbolContextFunction);
// Find candidate locations.
std::vector<Address> candidates, within_function, outside_function;
target->GetImages().FindAddressesForLine (target_sp, file, line, sc.function, within_function, outside_function);
// If possible, we try and stay within the current function.
// Within a function, we accept multiple locations (optimized code may do this,
// there's no solution here so we do the best we can).
// However if we're trying to leave the function, we don't know how to pick the
// right location, so if there's more than one then we bail.
if (!within_function.empty())
candidates = within_function;
else if (outside_function.size() == 1 && can_leave_function)
candidates = outside_function;
// Check if we got anything.
if (candidates.empty())
{
if (outside_function.empty())
{
return Error("Cannot locate an address for %s:%i.",
file.GetFilename().AsCString(), line);
}
else if (outside_function.size() == 1)
{
return Error("%s:%i is outside the current function.",
file.GetFilename().AsCString(), line);
}
else
{
StreamString sstr;
DumpAddressList(sstr, outside_function, target);
return Error("%s:%i has multiple candidate locations:\n%s",
file.GetFilename().AsCString(), line, sstr.GetString().c_str());
}
}
// Accept the first location, warn about any others.
Address dest = candidates[0];
if (warnings && candidates.size() > 1)
{
StreamString sstr;
sstr.Printf("%s:%i appears multiple times in this function, selecting the first location:\n",
file.GetFilename().AsCString(), line);
DumpAddressList(sstr, candidates, target);
*warnings = sstr.GetString();
}
if (!reg_ctx->SetPC (dest))
return Error("Cannot change PC to target address.");
return Error();
}
void
Thread::DumpUsingSettingsFormat (Stream &strm, uint32_t frame_idx)
{

4
lldb/test/functionalities/thread/jump/Makefile Normal file
View File

@ -0,0 +1,4 @@
LEVEL = ../../../make
CXX_SOURCES := main.cpp other.cpp
include $(LEVEL)/Makefile.rules

75
lldb/test/functionalities/thread/jump/TestThreadJump.py Normal file
View File

@ -0,0 +1,75 @@
"""
Test jumping to different places.
"""
import os, time
import unittest2
import lldb
from lldbtest import *
import lldbutil
class ThreadJumpTestCase(TestBase):
mydir = os.path.join("functionalities", "thread", "jump")
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
@dsym_test
def test_with_dsym(self):
"""Test thread jump handling."""
self.buildDsym(dictionary=self.getBuildFlags())
self.thread_jump_test()
@dwarf_test
def test_with_dwarf(self):
"""Test thread jump handling."""
self.buildDwarf(dictionary=self.getBuildFlags())
self.thread_jump_test()
def do_min_test(self, start, jump, var, value):
self.runCmd("j %i" % start) # jump to the start marker
self.runCmd("thread step-in") # step into the min fn
self.runCmd("j %i" % jump) # jump to the branch we're interested in
self.runCmd("thread step-out") # return out
self.runCmd("thread step-over") # assign to the global
self.expect("expr %s" % var, substrs = [value]) # check it
def thread_jump_test(self):
"""Test thread exit handling."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Find the line numbers for our breakpoints.
self.mark1 = line_number('main.cpp', '// 1st marker')
self.mark2 = line_number('main.cpp', '// 2nd marker')
self.mark3 = line_number('main.cpp', '// 3rd marker')
self.mark4 = line_number('main.cpp', '// 4th marker')
self.mark5 = line_number('other.cpp', '// other marker')
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.mark3, num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint 1.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT + " 1",
substrs = ['stopped',
'* thread #1',
'stop reason = breakpoint 1'])
self.do_min_test(self.mark3, self.mark1, "i", "4"); # Try the int path, force it to return 'a'
self.do_min_test(self.mark3, self.mark2, "i", "5"); # Try the int path, force it to return 'b'
self.do_min_test(self.mark4, self.mark1, "j", "7"); # Try the double path, force it to return 'a'
self.do_min_test(self.mark4, self.mark2, "j", "8"); # Try the double path, force it to return 'b'
# Try jumping to another function in a different file.
self.runCmd("thread jump --file other.cpp --line %i --force" % self.mark5)
self.expect("process status",
substrs = ["at other.cpp:%i" % self.mark5])
# Try jumping to another function (without forcing)
self.expect("j main.cpp:%i" % self.mark1, COMMAND_FAILED_AS_EXPECTED, error = True,
substrs = ["error"])
if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()

34
lldb/test/functionalities/thread/jump/main.cpp Normal file
View File

@ -0,0 +1,34 @@
//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// This test verifies the correct handling of program counter jumps.
int otherfn();
template<typename T>
T min(T a, T b)
{
if (a < b)
{
return a; // 1st marker
} else {
return b; // 2nd marker
}
}
int main ()
{
int i;
double j;
i = min(4, 5); // 3rd marker
j = min(7.0, 8.0); // 4th marker
return 0;
}

13
lldb/test/functionalities/thread/jump/other.cpp Normal file
View File

@ -0,0 +1,13 @@
//===-- other.cpp -----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int otherfn()
{
return 4; // other marker
}