2010-06-09 00:52:24 +08:00
//===-- CommandObjectExpression.cpp -----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
# include "CommandObjectExpression.h"
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
2010-07-23 08:16:21 +08:00
# include "lldb/Interpreter/Args.h"
2010-06-09 00:52:24 +08:00
# include "lldb/Core/Value.h"
# include "lldb/Core/InputReader.h"
2010-09-30 08:54:27 +08:00
# include "lldb/Core/ValueObjectVariable.h"
2010-06-09 00:52:24 +08:00
# include "lldb/Expression/ClangExpressionVariable.h"
This is a major refactoring of the expression parser.
The goal is to separate the parser's data from the data
belonging to the parser's clients. This allows clients
to use the parser to obtain (for example) a JIT compiled
function or some DWARF code, and then discard the parser
state.
Previously, parser state was held in ClangExpression and
used liberally by ClangFunction, which inherited from
ClangExpression. The main effects of this refactoring
are:
- reducing ClangExpression to an abstract class that
declares methods that any client must expose to the
expression parser,
- moving the code specific to implementing the "expr"
command from ClangExpression and
CommandObjectExpression into ClangUserExpression,
a new class,
- moving the common parser interaction code from
ClangExpression into ClangExpressionParser, a new
class, and
- making ClangFunction rely only on
ClangExpressionParser and not depend on the
internal implementation of ClangExpression.
Side effects include:
- the compiler interaction code has been factored
out of ClangFunction and is now in an AST pass
(ASTStructExtractor),
- the header file for ClangFunction is now fully
documented,
- several bugs that only popped up when Clang was
deallocated (which never happened, since the
lifetime of the compiler was essentially infinite)
are now fixed, and
- the developer-only "call" command has been
disabled.
I have tested the expr command and the Objective-C
step-into code, which use ClangUserExpression and
ClangFunction, respectively, and verified that they
work. Please let me know if you encounter bugs or
poor documentation.
llvm-svn: 112249
2010-08-27 09:01:44 +08:00
# include "lldb/Expression/ClangUserExpression.h"
2010-07-24 05:47:22 +08:00
# include "lldb/Expression/ClangFunction.h"
2010-06-09 00:52:24 +08:00
# include "lldb/Expression/DWARFExpression.h"
# include "lldb/Host/Host.h"
2010-07-23 08:16:21 +08:00
# include "lldb/Core/Debugger.h"
2010-06-23 09:19:29 +08:00
# include "lldb/Interpreter/CommandInterpreter.h"
2010-06-09 00:52:24 +08:00
# include "lldb/Interpreter/CommandReturnObject.h"
2010-09-30 08:54:27 +08:00
# include "lldb/Target/ObjCLanguageRuntime.h"
2010-06-09 00:52:24 +08:00
# include "lldb/Symbol/ObjectFile.h"
# include "lldb/Symbol/Variable.h"
# include "lldb/Target/Process.h"
# include "lldb/Target/StackFrame.h"
# include "lldb/Target/Target.h"
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
# include "lldb/Target/Thread.h"
2010-07-23 08:16:21 +08:00
# include "llvm/ADT/StringRef.h"
2010-06-09 00:52:24 +08:00
using namespace lldb ;
using namespace lldb_private ;
2011-10-25 14:44:01 +08:00
CommandObjectExpression : : CommandOptions : : CommandOptions ( ) :
OptionGroup ( )
2010-06-09 00:52:24 +08:00
{
}
CommandObjectExpression : : CommandOptions : : ~ CommandOptions ( )
{
}
2011-10-25 14:44:01 +08:00
OptionDefinition
CommandObjectExpression : : CommandOptions : : g_option_table [ ] =
{
{ LLDB_OPT_SET_1 | LLDB_OPT_SET_2 , false , " dynamic-value " , ' d ' , required_argument , NULL , 0 , eArgTypeBoolean , " Upcast the value resulting from the expression to its dynamic type if available. " } ,
{ LLDB_OPT_SET_1 | LLDB_OPT_SET_2 , false , " unwind-on-error " , ' u ' , required_argument , NULL , 0 , eArgTypeBoolean , " Clean up program state if the expression causes a crash, breakpoint hit or signal. " } ,
{ LLDB_OPT_SET_2 , false , " object-description " , ' o ' , no_argument , NULL , 0 , eArgTypeNone , " Print the object description of the value resulting from the expression. " } ,
} ;
uint32_t
CommandObjectExpression : : CommandOptions : : GetNumDefinitions ( )
{
return sizeof ( g_option_table ) / sizeof ( OptionDefinition ) ;
}
2010-06-09 00:52:24 +08:00
Error
2011-10-25 14:44:01 +08:00
CommandObjectExpression : : CommandOptions : : SetOptionValue ( CommandInterpreter & interpreter ,
uint32_t option_idx ,
const char * option_arg )
2010-06-09 00:52:24 +08:00
{
Error error ;
2011-10-25 14:44:01 +08:00
const char short_option = ( char ) g_option_table [ option_idx ] . short_option ;
2010-06-09 00:52:24 +08:00
switch ( short_option )
{
2010-09-08 06:38:08 +08:00
//case 'l':
//if (language.SetLanguageFromCString (option_arg) == false)
//{
2011-10-26 08:56:27 +08:00
// error.SetErrorStringWithFormat("invalid language option argument '%s'", option_arg);
2010-09-08 06:38:08 +08:00
//}
//break;
2010-06-09 00:52:24 +08:00
2010-09-30 08:54:27 +08:00
case ' o ' :
print_object = true ;
break ;
2010-11-06 03:25:48 +08:00
2011-04-16 08:01:13 +08:00
case ' d ' :
{
bool success ;
bool result ;
result = Args : : StringToBoolean ( option_arg , true , & success ) ;
if ( ! success )
2011-10-26 08:56:27 +08:00
error . SetErrorStringWithFormat ( " invalid dynamic value setting: \" %s \" " , option_arg ) ;
2011-04-16 08:01:13 +08:00
else
{
if ( result )
2011-05-30 08:49:24 +08:00
use_dynamic = eLazyBoolYes ;
2011-04-16 08:01:13 +08:00
else
use_dynamic = eLazyBoolNo ;
}
}
break ;
2010-11-06 03:25:48 +08:00
case ' u ' :
This patch modifies the expression parser to allow it
to execute expressions even in the absence of a process.
This allows expressions to run in situations where the
target cannot run -- e.g., to perform calculations based
on type information, or to inspect a binary's static
data.
This modification touches the following files:
lldb-private-enumerations.h
Introduce a new enum specifying the policy for
processing an expression. Some expressions should
always be JITted, for example if they are functions
that will be used over and over again. Some
expressions should always be interpreted, for
example if the target is unsafe to run. For most,
it is acceptable to JIT them, but interpretation
is preferable when possible.
Target.[h,cpp]
Have EvaluateExpression now accept the new enum.
ClangExpressionDeclMap.[cpp,h]
Add support for the IR interpreter and also make
the ClangExpressionDeclMap more robust in the
absence of a process.
ClangFunction.[cpp,h]
Add support for the new enum.
IRInterpreter.[cpp,h]
New implementation.
ClangUserExpression.[cpp,h]
Add support for the new enum, and for running
expressions in the absence of a process.
ClangExpression.h
Remove references to the old DWARF-based method
of evaluating expressions, because it has been
superseded for now.
ClangUtilityFunction.[cpp,h]
Add support for the new enum.
ClangExpressionParser.[cpp,h]
Add support for the new enum, remove references
to DWARF, and add support for checking whether
the expression could be evaluated statically.
IRForTarget.[h,cpp]
Add support for the new enum, and add utility
functions to support the interpreter.
IRToDWARF.cpp
Removed
CommandObjectExpression.cpp
Remove references to the obsolete -i option.
Process.cpp
Modify calls to ClangUserExpression::Evaluate
to pass the correct enum (for dlopen/dlclose)
SBValue.cpp
Add support for the new enum.
SBFrame.cpp
Add support for he new enum.
BreakpointOptions.cpp
Add support for the new enum.
llvm-svn: 139772
2011-09-15 10:13:07 +08:00
{
bool success ;
unwind_on_error = Args : : StringToBoolean ( option_arg , true , & success ) ;
if ( ! success )
2011-10-26 08:56:27 +08:00
error . SetErrorStringWithFormat ( " could not convert \" %s \" to a boolean value. " , option_arg ) ;
This patch modifies the expression parser to allow it
to execute expressions even in the absence of a process.
This allows expressions to run in situations where the
target cannot run -- e.g., to perform calculations based
on type information, or to inspect a binary's static
data.
This modification touches the following files:
lldb-private-enumerations.h
Introduce a new enum specifying the policy for
processing an expression. Some expressions should
always be JITted, for example if they are functions
that will be used over and over again. Some
expressions should always be interpreted, for
example if the target is unsafe to run. For most,
it is acceptable to JIT them, but interpretation
is preferable when possible.
Target.[h,cpp]
Have EvaluateExpression now accept the new enum.
ClangExpressionDeclMap.[cpp,h]
Add support for the IR interpreter and also make
the ClangExpressionDeclMap more robust in the
absence of a process.
ClangFunction.[cpp,h]
Add support for the new enum.
IRInterpreter.[cpp,h]
New implementation.
ClangUserExpression.[cpp,h]
Add support for the new enum, and for running
expressions in the absence of a process.
ClangExpression.h
Remove references to the old DWARF-based method
of evaluating expressions, because it has been
superseded for now.
ClangUtilityFunction.[cpp,h]
Add support for the new enum.
ClangExpressionParser.[cpp,h]
Add support for the new enum, remove references
to DWARF, and add support for checking whether
the expression could be evaluated statically.
IRForTarget.[h,cpp]
Add support for the new enum, and add utility
functions to support the interpreter.
IRToDWARF.cpp
Removed
CommandObjectExpression.cpp
Remove references to the obsolete -i option.
Process.cpp
Modify calls to ClangUserExpression::Evaluate
to pass the correct enum (for dlopen/dlclose)
SBValue.cpp
Add support for the new enum.
SBFrame.cpp
Add support for he new enum.
BreakpointOptions.cpp
Add support for the new enum.
llvm-svn: 139772
2011-09-15 10:13:07 +08:00
break ;
}
2010-06-09 00:52:24 +08:00
default :
2011-10-26 08:56:27 +08:00
error . SetErrorStringWithFormat ( " invalid short option character '%c' " , short_option ) ;
2010-06-09 00:52:24 +08:00
break ;
}
return error ;
}
void
2011-10-25 14:44:01 +08:00
CommandObjectExpression : : CommandOptions : : OptionParsingStarting ( CommandInterpreter & interpreter )
2010-06-09 00:52:24 +08:00
{
2011-04-16 08:01:13 +08:00
use_dynamic = eLazyBoolCalculate ;
2011-10-25 14:44:01 +08:00
print_object = false ;
2010-11-06 03:25:48 +08:00
unwind_on_error = true ;
2010-06-09 00:52:24 +08:00
show_types = true ;
show_summary = true ;
}
2011-03-25 05:19:54 +08:00
const OptionDefinition *
2010-06-09 00:52:24 +08:00
CommandObjectExpression : : CommandOptions : : GetDefinitions ( )
{
return g_option_table ;
}
2010-09-18 09:14:36 +08:00
CommandObjectExpression : : CommandObjectExpression ( CommandInterpreter & interpreter ) :
CommandObject ( interpreter ,
" expression " ,
2010-10-01 02:16:58 +08:00
" Evaluate a C/ObjC/C++ expression in the current program context, using variables currently in scope. " ,
2010-10-05 06:28:36 +08:00
NULL ) ,
2011-10-25 14:44:01 +08:00
m_option_group ( interpreter ) ,
m_format_options ( eFormatDefault ) ,
m_command_options ( ) ,
2010-10-01 02:30:25 +08:00
m_expr_line_count ( 0 ) ,
2010-06-09 00:52:24 +08:00
m_expr_lines ( )
{
SetHelpLong (
" Examples: \n \
\ n \
expr my_struct - > a = my_array [ 3 ] \ n \
expr - f bin - - ( index * 8 ) + 5 \ n \
expr char c [ ] = \ " foo \" ; c[0] \n " ) ;
2010-10-05 06:28:36 +08:00
CommandArgumentEntry arg ;
CommandArgumentData expression_arg ;
// Define the first (and only) variant of this arg.
expression_arg . arg_type = eArgTypeExpression ;
expression_arg . arg_repetition = eArgRepeatPlain ;
// There is only one variant this argument could be; put it into the argument entry.
arg . push_back ( expression_arg ) ;
// Push the data for the first argument into the m_arguments vector.
m_arguments . push_back ( arg ) ;
2011-10-25 14:44:01 +08:00
// Add the "--format" and "--count" options to group 1 and 3
m_option_group . Append ( & m_format_options , OptionGroupFormat : : OPTION_GROUP_FORMAT , LLDB_OPT_SET_1 ) ;
m_option_group . Append ( & m_command_options ) ;
m_option_group . Finalize ( ) ;
2010-06-09 00:52:24 +08:00
}
CommandObjectExpression : : ~ CommandObjectExpression ( )
{
}
Options *
CommandObjectExpression : : GetOptions ( )
{
2011-10-25 14:44:01 +08:00
return & m_option_group ;
2010-06-09 00:52:24 +08:00
}
bool
CommandObjectExpression : : Execute
(
Args & command ,
CommandReturnObject & result
)
{
return false ;
}
size_t
CommandObjectExpression : : MultiLineExpressionCallback
(
void * baton ,
2010-06-23 09:19:29 +08:00
InputReader & reader ,
2010-06-09 00:52:24 +08:00
lldb : : InputReaderAction notification ,
const char * bytes ,
size_t bytes_len
)
{
CommandObjectExpression * cmd_object_expr = ( CommandObjectExpression * ) baton ;
2011-06-17 00:27:19 +08:00
bool batch_mode = reader . GetDebugger ( ) . GetCommandInterpreter ( ) . GetBatchCommandMode ( ) ;
2010-06-09 00:52:24 +08:00
switch ( notification )
{
case eInputReaderActivate :
2011-06-17 00:27:19 +08:00
if ( ! batch_mode )
2011-06-16 03:35:17 +08:00
{
2011-07-20 11:41:06 +08:00
StreamSP async_strm_sp ( reader . GetDebugger ( ) . GetAsyncOutputStream ( ) ) ;
if ( async_strm_sp )
{
async_strm_sp - > PutCString ( " Enter expressions, then terminate with an empty line to evaluate: \n " ) ;
async_strm_sp - > Flush ( ) ;
}
2011-06-16 03:35:17 +08:00
}
2010-06-09 00:52:24 +08:00
// Fall through
case eInputReaderReactivate :
break ;
case eInputReaderDeactivate :
break ;
This patch captures and serializes all output being written by the
command line driver, including the lldb prompt being output by
editline, the asynchronous process output & error messages, and
asynchronous messages written by target stop-hooks.
As part of this it introduces a new Stream class,
StreamAsynchronousIO. A StreamAsynchronousIO object is created with a
broadcaster, who will eventually broadcast the stream's data for a
listener to handle, and an event type indicating what type of event
the broadcaster will broadcast. When the Write method is called on a
StreamAsynchronousIO object, the data is appended to an internal
string. When the Flush method is called on a StreamAsynchronousIO
object, it broadcasts it's data string and clears the string.
Anything in lldb-core that needs to generate asynchronous output for
the end-user should use the StreamAsynchronousIO objects.
I have also added a new notification type for InputReaders, to let
them know that a asynchronous output has been written. This is to
allow the input readers to, for example, refresh their prompts and
lines, if desired. I added the case statements to all the input
readers to catch this notification, but I haven't added any code for
handling them yet (except to the IOChannel input reader).
llvm-svn: 130721
2011-05-03 04:41:46 +08:00
case eInputReaderAsynchronousOutputWritten :
break ;
2010-06-09 00:52:24 +08:00
case eInputReaderGotToken :
+ + cmd_object_expr - > m_expr_line_count ;
if ( bytes & & bytes_len )
{
cmd_object_expr - > m_expr_lines . append ( bytes , bytes_len + 1 ) ;
}
if ( bytes_len = = 0 )
2010-06-23 09:19:29 +08:00
reader . SetIsDone ( true ) ;
2010-06-09 00:52:24 +08:00
break ;
2010-11-20 04:47:54 +08:00
case eInputReaderInterrupt :
cmd_object_expr - > m_expr_lines . clear ( ) ;
reader . SetIsDone ( true ) ;
2011-06-17 00:27:19 +08:00
if ( ! batch_mode )
2011-06-16 03:35:17 +08:00
{
2011-07-20 11:41:06 +08:00
StreamSP async_strm_sp ( reader . GetDebugger ( ) . GetAsyncOutputStream ( ) ) ;
if ( async_strm_sp )
{
async_strm_sp - > PutCString ( " Expression evaluation cancelled. \n " ) ;
async_strm_sp - > Flush ( ) ;
}
2011-06-16 03:35:17 +08:00
}
2010-11-20 04:47:54 +08:00
break ;
case eInputReaderEndOfFile :
reader . SetIsDone ( true ) ;
break ;
2010-06-09 00:52:24 +08:00
case eInputReaderDone :
2010-11-20 04:47:54 +08:00
if ( cmd_object_expr - > m_expr_lines . size ( ) > 0 )
2010-06-09 00:52:24 +08:00
{
2011-06-14 04:20:29 +08:00
StreamSP output_stream = reader . GetDebugger ( ) . GetAsyncOutputStream ( ) ;
StreamSP error_stream = reader . GetDebugger ( ) . GetAsyncErrorStream ( ) ;
2010-06-09 00:52:24 +08:00
cmd_object_expr - > EvaluateExpression ( cmd_object_expr - > m_expr_lines . c_str ( ) ,
2011-06-14 04:20:29 +08:00
output_stream . get ( ) ,
error_stream . get ( ) ) ;
output_stream - > Flush ( ) ;
error_stream - > Flush ( ) ;
2010-06-09 00:52:24 +08:00
}
break ;
}
return bytes_len ;
}
bool
2010-10-05 08:00:42 +08:00
CommandObjectExpression : : EvaluateExpression
(
const char * expr ,
2011-06-14 04:20:29 +08:00
Stream * output_stream ,
Stream * error_stream ,
2010-10-05 08:00:42 +08:00
CommandReturnObject * result
)
2010-06-09 00:52:24 +08:00
{
2011-09-22 12:58:26 +08:00
Target * target = m_exe_ctx . GetTargetPtr ( ) ;
if ( target )
2010-07-23 08:16:21 +08:00
{
2010-12-14 10:59:59 +08:00
lldb : : ValueObjectSP result_valobj_sp ;
2011-03-25 05:19:54 +08:00
ExecutionResults exe_results ;
2011-01-13 16:53:35 +08:00
bool keep_in_memory = true ;
2011-05-04 11:43:18 +08:00
lldb : : DynamicValueType use_dynamic ;
2011-04-16 08:01:13 +08:00
// If use dynamic is not set, get it from the target:
2011-10-25 14:44:01 +08:00
switch ( m_command_options . use_dynamic )
2011-04-16 08:01:13 +08:00
{
case eLazyBoolCalculate :
2011-09-22 12:58:26 +08:00
use_dynamic = target - > GetPreferDynamicValue ( ) ;
2011-04-16 08:01:13 +08:00
break ;
case eLazyBoolYes :
2011-05-04 11:43:18 +08:00
use_dynamic = lldb : : eDynamicCanRunTarget ;
2011-04-16 08:01:13 +08:00
break ;
case eLazyBoolNo :
2011-05-04 11:43:18 +08:00
use_dynamic = lldb : : eNoDynamicValues ;
2011-04-16 08:01:13 +08:00
break ;
}
2011-01-13 16:53:35 +08:00
2011-09-22 12:58:26 +08:00
exe_results = target - > EvaluateExpression ( expr ,
m_exe_ctx . GetFramePtr ( ) ,
eExecutionPolicyOnlyWhenNeeded ,
2011-10-25 14:44:01 +08:00
m_command_options . unwind_on_error ,
2011-09-22 12:58:26 +08:00
keep_in_memory ,
use_dynamic ,
result_valobj_sp ) ;
2010-12-14 10:59:59 +08:00
2011-10-25 14:44:01 +08:00
if ( exe_results = = eExecutionInterrupted & & ! m_command_options . unwind_on_error )
2010-11-30 10:22:11 +08:00
{
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
uint32_t start_frame = 0 ;
uint32_t num_frames = 1 ;
uint32_t num_frames_with_source = 0 ;
2011-09-22 12:58:26 +08:00
Thread * thread = m_exe_ctx . GetThreadPtr ( ) ;
if ( thread )
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
{
2011-09-22 12:58:26 +08:00
thread - > GetStatus ( result - > GetOutputStream ( ) ,
start_frame ,
num_frames ,
num_frames_with_source ) ;
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
}
2011-09-22 12:58:26 +08:00
else
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
{
2011-09-22 12:58:26 +08:00
Process * process = m_exe_ctx . GetProcessPtr ( ) ;
if ( process )
{
bool only_threads_with_stop_reason = true ;
process - > GetThreadStatus ( result - > GetOutputStream ( ) ,
only_threads_with_stop_reason ,
start_frame ,
num_frames ,
num_frames_with_source ) ;
}
Centralized a lot of the status information for processes,
threads, and stack frame down in the lldb_private::Process,
lldb_private::Thread, lldb_private::StackFrameList and the
lldb_private::StackFrame classes. We had some command line
commands that had duplicate versions of the process status
output ("thread list" and "process status" for example).
Removed the "file" command and placed it where it should
have been: "target create". Made an alias for "file" to
"target create" so we stay compatible with GDB commands.
We can now have multple usable targets in lldb at the
same time. This is nice for comparing two runs of a program
or debugging more than one binary at the same time. The
new command is "target select <target-idx>" and also to see
a list of the current targets you can use the new "target list"
command. The flow in a debug session can be:
(lldb) target create /path/to/exe/a.out
(lldb) breakpoint set --name main
(lldb) run
... hit breakpoint
(lldb) target create /bin/ls
(lldb) run /tmp
Process 36001 exited with status = 0 (0x00000000)
(lldb) target list
Current targets:
target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
* target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) target select 0
Current targets:
* target #0: /tmp/args/a.out ( arch=x86_64-apple-darwin, platform=localhost, pid=35999, state=stopped )
target #1: /bin/ls ( arch=x86_64-apple-darwin, platform=localhost, pid=36001, state=exited )
(lldb) bt
* thread #1: tid = 0x2d03, 0x0000000100000b9a a.out`main + 42 at main.c:16, stop reason = breakpoint 1.1
frame #0: 0x0000000100000b9a a.out`main + 42 at main.c:16
frame #1: 0x0000000100000b64 a.out`start + 52
Above we created a target for "a.out" and ran and hit a
breakpoint at "main". Then we created a new target for /bin/ls
and ran it. Then we listed the targest and selected our original
"a.out" program, so we showed two concurent debug sessions
going on at the same time.
llvm-svn: 129695
2011-04-18 16:33:37 +08:00
}
2010-12-14 10:59:59 +08:00
}
if ( result_valobj_sp )
{
if ( result_valobj_sp - > GetError ( ) . Success ( ) )
{
2011-10-25 14:44:01 +08:00
Format format = m_format_options . GetFormat ( ) ;
if ( format ! = eFormatDefault )
result_valobj_sp - > SetFormat ( format ) ;
2010-12-14 10:59:59 +08:00
2011-06-14 04:20:29 +08:00
ValueObject : : DumpValueObject ( * ( output_stream ) ,
2010-12-14 10:59:59 +08:00
result_valobj_sp . get ( ) , // Variable object to dump
result_valobj_sp - > GetName ( ) . GetCString ( ) , // Root object name
0 , // Pointer depth to traverse (zero means stop at pointers)
0 , // Current depth, this is the top most, so zero...
UINT32_MAX , // Max depth to go when dumping concrete types, dump everything...
2011-10-25 14:44:01 +08:00
m_command_options . show_types , // Show types when dumping?
2010-12-14 10:59:59 +08:00
false , // Show locations of variables, no since this is a host address which we don't care to see
2011-10-25 14:44:01 +08:00
m_command_options . print_object , // Print the objective C object?
2011-04-16 08:01:13 +08:00
use_dynamic ,
2011-07-22 08:16:08 +08:00
true , // Use synthetic children if available
2010-12-14 10:59:59 +08:00
true , // Scope is already checked. Const results are always in scope.
2011-07-16 09:22:04 +08:00
false , // Don't flatten output
2011-08-12 10:00:06 +08:00
0 , // Always use summaries (you might want an option --no-summary like there is for frame variable)
false ) ; // Do not show more children than settings allow
2010-12-14 10:59:59 +08:00
if ( result )
result - > SetStatus ( eReturnStatusSuccessFinishResult ) ;
}
else
{
2011-08-24 05:20:51 +08:00
if ( result_valobj_sp - > GetError ( ) . GetError ( ) = = ClangUserExpression : : kNoResult )
2011-06-25 06:31:10 +08:00
{
2011-08-24 05:20:51 +08:00
error_stream - > PutCString ( " <no result> \n " ) ;
if ( result )
result - > SetStatus ( eReturnStatusSuccessFinishResult ) ;
2011-06-25 06:31:10 +08:00
}
else
{
2011-08-24 05:20:51 +08:00
const char * error_cstr = result_valobj_sp - > GetError ( ) . AsCString ( ) ;
if ( error_cstr & & error_cstr [ 0 ] )
{
int error_cstr_len = strlen ( error_cstr ) ;
const bool ends_with_newline = error_cstr [ error_cstr_len - 1 ] = = ' \n ' ;
if ( strstr ( error_cstr , " error: " ) ! = error_cstr )
error_stream - > PutCString ( " error: " ) ;
error_stream - > Write ( error_cstr , error_cstr_len ) ;
if ( ! ends_with_newline )
error_stream - > EOL ( ) ;
}
else
{
error_stream - > PutCString ( " error: unknown error \n " ) ;
}
if ( result )
result - > SetStatus ( eReturnStatusFailed ) ;
2011-06-25 06:31:10 +08:00
}
2010-11-30 10:22:11 +08:00
}
}
2010-12-14 10:59:59 +08:00
}
else
{
2011-06-14 04:20:29 +08:00
error_stream - > Printf ( " error: invalid execution context for expression \n " ) ;
2010-12-14 10:59:59 +08:00
return false ;
2010-07-23 08:16:21 +08:00
}
2010-08-12 09:56:52 +08:00
2010-07-23 08:16:21 +08:00
return true ;
2010-06-09 00:52:24 +08:00
}
bool
CommandObjectExpression : : ExecuteRawCommandString
(
const char * command ,
CommandReturnObject & result
)
{
2011-04-12 13:54:46 +08:00
m_exe_ctx = m_interpreter . GetExecutionContext ( ) ;
2010-06-09 00:52:24 +08:00
2011-10-25 14:44:01 +08:00
m_option_group . NotifyOptionParsingStarting ( ) ;
2010-06-09 00:52:24 +08:00
const char * expr = NULL ;
if ( command [ 0 ] = = ' \0 ' )
{
m_expr_lines . clear ( ) ;
m_expr_line_count = 0 ;
2010-09-18 09:14:36 +08:00
InputReaderSP reader_sp ( new InputReader ( m_interpreter . GetDebugger ( ) ) ) ;
2010-06-09 00:52:24 +08:00
if ( reader_sp )
{
Error err ( reader_sp - > Initialize ( CommandObjectExpression : : MultiLineExpressionCallback ,
this , // baton
eInputReaderGranularityLine , // token size, to pass to callback function
2010-06-23 09:19:29 +08:00
NULL , // end token
2010-06-09 00:52:24 +08:00
NULL , // prompt
true ) ) ; // echo input
if ( err . Success ( ) )
{
2010-09-18 09:14:36 +08:00
m_interpreter . GetDebugger ( ) . PushInputReader ( reader_sp ) ;
2010-06-09 00:52:24 +08:00
result . SetStatus ( eReturnStatusSuccessFinishNoResult ) ;
}
else
{
result . AppendError ( err . AsCString ( ) ) ;
result . SetStatus ( eReturnStatusFailed ) ;
}
}
else
{
result . AppendError ( " out of memory " ) ;
result . SetStatus ( eReturnStatusFailed ) ;
}
return result . Succeeded ( ) ;
}
if ( command [ 0 ] = = ' - ' )
{
// We have some options and these options MUST end with --.
const char * end_options = NULL ;
const char * s = command ;
while ( s & & s [ 0 ] )
{
end_options = : : strstr ( s , " -- " ) ;
if ( end_options )
{
end_options + = 2 ; // Get past the "--"
if ( : : isspace ( end_options [ 0 ] ) )
{
expr = end_options ;
while ( : : isspace ( * expr ) )
+ + expr ;
break ;
}
}
s = end_options ;
}
if ( end_options )
{
2010-06-23 09:19:29 +08:00
Args args ( command , end_options - command ) ;
2010-09-18 09:14:36 +08:00
if ( ! ParseOptions ( args , result ) )
2010-06-09 00:52:24 +08:00
return false ;
2011-04-13 08:18:08 +08:00
2011-10-25 14:44:01 +08:00
Error error ( m_option_group . NotifyOptionParsingFinished ( ) ) ;
2011-04-13 08:18:08 +08:00
if ( error . Fail ( ) )
{
result . AppendError ( error . AsCString ( ) ) ;
result . SetStatus ( eReturnStatusFailed ) ;
return false ;
}
2010-06-09 00:52:24 +08:00
}
}
if ( expr = = NULL )
expr = command ;
2010-06-24 08:16:27 +08:00
2011-06-14 04:20:29 +08:00
if ( EvaluateExpression ( expr , & ( result . GetOutputStream ( ) ) , & ( result . GetErrorStream ( ) ) , & result ) )
2010-08-13 08:42:30 +08:00
return true ;
result . SetStatus ( eReturnStatusFailed ) ;
return false ;
2010-06-09 00:52:24 +08:00
}
