intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-17 23:45:25 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
eee554d86ed2407623421d3aa3bac1f8e0d9e2ae
llvm/lldb/source/Expression/REPL.cpp
Jason Molenda 62e0681afb Add -Wimplicit-fallthrough command line option to clang in 
the xcode project file to catch switch statements that have a
case that falls through unintentionally.

Define LLVM_FALLTHROUGH to indicate instances where a case has code
and intends to fall through.  This should be in llvm/Support/Compiler.h;
Peter Collingbourne originally checked in there (r237766), then
reverted (r237941) because he didn't have time to mark up all the
'case' statements that were intended to fall through.  I put together
a patch to get this back in llvm http://reviews.llvm.org/D17063 but
it hasn't been approved in the past week.  I added a new
lldb-private-defines.h to hold the definition for now.

Every place in lldb where there is a comment that the fall-through
is intentional, I added LLVM_FALLTHROUGH to silence the warning.
I haven't tried to identify whether the fallthrough is a bug or
not in the other places.

I haven't tried to add this to the cmake option build flags.
This warning will only work for clang.

This build cleanly (with some new warnings) on macosx with clang
under xcodebuild, but if this causes problems for people on other
configurations, I'll back it out.

llvm-svn: 260930
2016-02-16 04:14:33 +00:00

650 lines
25 KiB
C++
Raw Blame History

//===-- REPL.cpp ------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Debugger.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Expression/REPL.h"
#include "lldb/Expression/UserExpression.h"
#include "lldb/Host/HostInfo.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/AnsiTerminal.h"
using namespace lldb_private;
REPL::REPL(LLVMCastKind kind, Target &target) :
m_target(target),
m_kind(kind)
{
// Make sure all option values have sane defaults
Debugger &debugger = m_target.GetDebugger();
CommandInterpreter &ci = debugger.GetCommandInterpreter();
m_format_options.OptionParsingStarting(ci);
m_varobj_options.OptionParsingStarting(ci);
m_command_options.OptionParsingStarting(ci);
// Default certain settings for REPL regardless of the global settings.
m_command_options.unwind_on_error = false;
m_command_options.ignore_breakpoints = false;
m_command_options.debug = false;
}
REPL::~REPL() = default;
lldb::REPLSP
REPL::Create(Error &err, lldb::LanguageType language, Debugger *debugger, Target *target, const char *repl_options)
{
uint32_t idx = 0;
lldb::REPLSP ret;
while (REPLCreateInstance create_instance = PluginManager::GetREPLCreateCallbackAtIndex(idx++))
{
ret = (*create_instance)(err, language, debugger, target, repl_options);
if (ret)
{
break;
}
}
return ret;
}
std::string
REPL::GetSourcePath()
{
ConstString file_basename = GetSourceFileBasename();
FileSpec tmpdir_file_spec;
if (HostInfo::GetLLDBPath (lldb::ePathTypeLLDBTempSystemDir, tmpdir_file_spec))
{
tmpdir_file_spec.GetFilename().SetCString(file_basename.AsCString());
m_repl_source_path = tmpdir_file_spec.GetPath();
}
else
{
tmpdir_file_spec = FileSpec("/tmp", false);
tmpdir_file_spec.AppendPathComponent(file_basename.AsCString());
}
return tmpdir_file_spec.GetPath();
}
lldb::IOHandlerSP
REPL::GetIOHandler()
{
if (!m_io_handler_sp)
{
Debugger &debugger = m_target.GetDebugger();
m_io_handler_sp.reset (new IOHandlerEditline (debugger,
IOHandler::Type::REPL,
"lldb-repl", // Name of input reader for history
"> ", // prompt
". ", // Continuation prompt
true, // Multi-line
true, // The REPL prompt is always colored
1, // Line number
*this));
// Don't exit if CTRL+C is pressed
static_cast<IOHandlerEditline *>(m_io_handler_sp.get())->SetInterruptExits(false);
if (m_io_handler_sp->GetIsInteractive() && m_io_handler_sp->GetIsRealTerminal())
{
m_indent_str.assign (debugger.GetTabSize(), ' ');
m_enable_auto_indent = debugger.GetAutoIndent();
}
else
{
m_indent_str.clear();
m_enable_auto_indent = false;
}
}
return m_io_handler_sp;
}
void
REPL::IOHandlerActivated (IOHandler &io_handler)
{
lldb::ProcessSP process_sp = m_target.GetProcessSP();
if (process_sp && process_sp->IsAlive())
return;
lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFile());
error_sp->Printf("REPL requires a running target process.\n");
io_handler.SetIsDone(true);
}
bool
REPL::IOHandlerInterrupt (IOHandler &io_handler)
{
return false;
}
void
REPL::IOHandlerInputInterrupted (IOHandler &io_handler,
std::string &line)
{
}
const char *
REPL::IOHandlerGetFixIndentationCharacters()
{
return (m_enable_auto_indent ? GetAutoIndentCharacters() : nullptr);
}
ConstString
REPL::IOHandlerGetControlSequence (char ch)
{
if (ch == 'd')
return ConstString(":quit\n");
return ConstString();
}
const char *
REPL::IOHandlerGetCommandPrefix ()
{
return ":";
}
const char *
REPL::IOHandlerGetHelpPrologue ()
{
return "\nThe REPL (Read-Eval-Print-Loop) acts like an interpreter. "
"Valid statements, expressions, and declarations are immediately compiled and executed.\n\n"
"The complete set of LLDB debugging commands are also available as described below. Commands "
"must be prefixed with a colon at the REPL prompt (:quit for example.) Typing just a colon "
"followed by return will switch to the LLDB prompt.\n\n";
}
bool
REPL::IOHandlerIsInputComplete (IOHandler &io_handler,
StringList &lines)
{
// Check for meta command
const size_t num_lines = lines.GetSize();
if (num_lines == 1)
{
const char *first_line = lines.GetStringAtIndex(0);
if (first_line[0] == ':')
return true; // Meta command is a single line where that starts with ':'
}
// Check if REPL input is done
std::string source_string (lines.CopyList());
return SourceIsComplete(source_string);
}
int
REPL::CalculateActualIndentation (const StringList &lines)
{
std::string last_line = lines[lines.GetSize() - 1];
int actual_indent = 0;
for (char &ch : last_line)
{
if (ch != ' ') break;
++actual_indent;
}
return actual_indent;
}
int
REPL::IOHandlerFixIndentation (IOHandler &io_handler,
const StringList &lines,
int cursor_position)
{
if (!m_enable_auto_indent) return 0;
if (!lines.GetSize())
{
return 0;
}
int tab_size = io_handler.GetDebugger().GetTabSize();
lldb::offset_t desired_indent = GetDesiredIndentation(lines,
cursor_position,
tab_size);
int actual_indent = REPL::CalculateActualIndentation(lines);
if (desired_indent == LLDB_INVALID_OFFSET)
return 0;
return (int)desired_indent - actual_indent;
}
void
REPL::IOHandlerInputComplete (IOHandler &io_handler, std::string &code)
{
lldb::StreamFileSP output_sp(io_handler.GetOutputStreamFile());
lldb::StreamFileSP error_sp(io_handler.GetErrorStreamFile());
bool extra_line = false;
bool did_quit = false;
if (code.empty())
{
m_code.AppendString("");
static_cast<IOHandlerEditline &>(io_handler).SetBaseLineNumber(m_code.GetSize()+1);
}
else
{
Debugger &debugger = m_target.GetDebugger();
CommandInterpreter &ci = debugger.GetCommandInterpreter();
extra_line = ci.GetSpaceReplPrompts();
ExecutionContext exe_ctx (m_target.GetProcessSP()->GetThreadList().GetSelectedThread()->GetSelectedFrame().get());
lldb::ProcessSP process_sp(exe_ctx.GetProcessSP());
if (code[0] == ':')
{
// Meta command
// Strip the ':'
code.erase(0, 1);
if (Args::StripSpaces (code))
{
// "lldb" was followed by arguments, so just execute the command dump the results
// Turn off prompt on quit in case the user types ":quit"
const bool saved_prompt_on_quit = ci.GetPromptOnQuit();
if (saved_prompt_on_quit)
ci.SetPromptOnQuit(false);
// Execute the command
CommandReturnObject result;
result.SetImmediateOutputStream(output_sp);
result.SetImmediateErrorStream(error_sp);
ci.HandleCommand(code.c_str(), eLazyBoolNo, result);
if (saved_prompt_on_quit)
ci.SetPromptOnQuit(true);
if (result.GetStatus() == lldb::eReturnStatusQuit)
{
did_quit = true;
io_handler.SetIsDone(true);
if (debugger.CheckTopIOHandlerTypes(IOHandler::Type::REPL, IOHandler::Type::CommandInterpreter))
{
// We typed "quit" or an alias to quit so we need to check if the
// command interpreter is above us and tell it that it is done as well
// so we don't drop back into the command interpreter if we have already
// quit
lldb::IOHandlerSP io_handler_sp (ci.GetIOHandler());
if (io_handler_sp)
io_handler_sp->SetIsDone(true);
}
}
}
else
{
// ":" was followed by no arguments, so push the LLDB command prompt
if (debugger.CheckTopIOHandlerTypes(IOHandler::Type::REPL, IOHandler::Type::CommandInterpreter))
{
// If the user wants to get back to the command interpreter and the
// command interpreter is what launched the REPL, then just let the
// REPL exit and fall back to the command interpreter.
io_handler.SetIsDone(true);
}
else
{
// The REPL wasn't launched the by the command interpreter, it is the
// base IOHandler, so we need to get the command interpreter and
lldb::IOHandlerSP io_handler_sp (ci.GetIOHandler());
if (io_handler_sp)
{
io_handler_sp->SetIsDone(false);
debugger.PushIOHandler(ci.GetIOHandler());
}
}
}
}
else
{
// Unwind any expression we might have been running in case our REPL
// expression crashed and the user was looking around
if (m_dedicated_repl_mode)
{
Thread *thread = exe_ctx.GetThreadPtr();
if (thread && thread->UnwindInnermostExpression().Success())
{
thread->SetSelectedFrameByIndex(0, false);
exe_ctx.SetFrameSP(thread->GetSelectedFrame());
}
}
const bool colorize_err = error_sp->GetFile().GetIsTerminalWithColors();
EvaluateExpressionOptions expr_options;
expr_options.SetCoerceToId(m_varobj_options.use_objc);
expr_options.SetUnwindOnError(m_command_options.unwind_on_error);
expr_options.SetIgnoreBreakpoints (m_command_options.ignore_breakpoints);
expr_options.SetKeepInMemory(true);
expr_options.SetUseDynamic(m_varobj_options.use_dynamic);
expr_options.SetTryAllThreads(m_command_options.try_all_threads);
expr_options.SetGenerateDebugInfo(true);
expr_options.SetREPLEnabled (true);
expr_options.SetColorizeErrors(colorize_err);
expr_options.SetPoundLine(m_repl_source_path.c_str(), m_code.GetSize() + 1);
if (m_command_options.timeout > 0)
expr_options.SetTimeoutUsec(m_command_options.timeout);
else
expr_options.SetTimeoutUsec(0);
expr_options.SetLanguage(GetLanguage());
PersistentExpressionState *persistent_state = m_target.GetPersistentExpressionStateForLanguage(GetLanguage());
const size_t var_count_before = persistent_state->GetSize();
const char *expr_prefix = nullptr;
lldb::ValueObjectSP result_valobj_sp;
Error error;
lldb::ModuleSP jit_module_sp;
lldb::ExpressionResults execution_results = UserExpression::Evaluate (exe_ctx,
expr_options,
code.c_str(),
expr_prefix,
result_valobj_sp,
error,
0, // Line offset
&jit_module_sp);
//CommandInterpreter &ci = debugger.GetCommandInterpreter();
if (process_sp && process_sp->IsAlive())
{
bool add_to_code = true;
bool handled = false;
if (result_valobj_sp)
{
lldb::Format format = m_format_options.GetFormat();
if (result_valobj_sp->GetError().Success())
{
handled |= PrintOneVariable(debugger, output_sp, result_valobj_sp);
}
else if (result_valobj_sp->GetError().GetError() == UserExpression::kNoResult)
{
if (format != lldb::eFormatVoid && debugger.GetNotifyVoid())
{
error_sp->PutCString("(void)\n");
handled = true;
}
}
}
if (debugger.GetPrintDecls())
{
for (size_t vi = var_count_before, ve = persistent_state->GetSize();
vi != ve;
++vi)
{
lldb::ExpressionVariableSP persistent_var_sp = persistent_state->GetVariableAtIndex(vi);
lldb::ValueObjectSP valobj_sp = persistent_var_sp->GetValueObject();
PrintOneVariable(debugger, output_sp, valobj_sp, persistent_var_sp.get());
}
}
if (!handled)
{
bool useColors = error_sp->GetFile().GetIsTerminalWithColors();
switch (execution_results)
{
case lldb::eExpressionSetupError:
case lldb::eExpressionParseError:
add_to_code = false;
LLVM_FALLTHROUGH;
case lldb::eExpressionDiscarded:
error_sp->Printf("%s\n", error.AsCString());
break;
case lldb::eExpressionCompleted:
break;
case lldb::eExpressionInterrupted:
if (useColors) {
error_sp->Printf(ANSI_ESCAPE1(ANSI_FG_COLOR_RED));
error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_BOLD));
}
error_sp->Printf("Execution interrupted. ");
if (useColors) error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_NORMAL));
error_sp->Printf("Enter code to recover and continue.\nEnter LLDB commands to investigate (type :help for assistance.)\n");
break;
case lldb::eExpressionHitBreakpoint:
// Breakpoint was hit, drop into LLDB command interpreter
if (useColors) {
error_sp->Printf(ANSI_ESCAPE1(ANSI_FG_COLOR_RED));
error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_BOLD));
}
output_sp->Printf("Execution stopped at breakpoint. ");
if (useColors) error_sp->Printf(ANSI_ESCAPE1(ANSI_CTRL_NORMAL));
output_sp->Printf("Enter LLDB commands to investigate (type help for assistance.)\n");
{
lldb::IOHandlerSP io_handler_sp (ci.GetIOHandler());
if (io_handler_sp)
{
io_handler_sp->SetIsDone(false);
debugger.PushIOHandler(ci.GetIOHandler());
}
}
break;
case lldb::eExpressionTimedOut:
error_sp->Printf("error: timeout\n");
if (error.AsCString())
error_sp->Printf("error: %s\n", error.AsCString());
break;
case lldb::eExpressionResultUnavailable:
// Shoulnd't happen???
error_sp->Printf("error: could not fetch result -- %s\n", error.AsCString());
break;
case lldb::eExpressionStoppedForDebug:
// Shoulnd't happen???
error_sp->Printf("error: stopped for debug -- %s\n", error.AsCString());
break;
}
}
if (add_to_code)
{
const uint32_t new_default_line = m_code.GetSize() + 1;
m_code.SplitIntoLines(code);
// Update our code on disk
if (!m_repl_source_path.empty())
{
lldb_private::File file (m_repl_source_path.c_str(),
File::eOpenOptionWrite | File::eOpenOptionTruncate | File::eOpenOptionCanCreate,
lldb::eFilePermissionsFileDefault);
std::string code (m_code.CopyList());
code.append(1, '\n');
size_t bytes_written = code.size();
file.Write(code.c_str(), bytes_written);
file.Close();
// Now set the default file and line to the REPL source file
m_target.GetSourceManager().SetDefaultFileAndLine(FileSpec(m_repl_source_path.c_str(), false), new_default_line);
}
static_cast<IOHandlerEditline &>(io_handler).SetBaseLineNumber(m_code.GetSize()+1);
}
if (extra_line)
{
fprintf(output_sp->GetFile().GetStream(), "\n");
}
}
}
// Don't complain about the REPL process going away if we are in the process of quitting.
if (!did_quit && (!process_sp || !process_sp->IsAlive()))
{
error_sp->Printf("error: REPL process is no longer alive, exiting REPL\n");
io_handler.SetIsDone(true);
}
}
}
int
REPL::IOHandlerComplete (IOHandler &io_handler,
const char *current_line,
const char *cursor,
const char *last_char,
int skip_first_n_matches,
int max_matches,
StringList &matches)
{
matches.Clear();
llvm::StringRef line (current_line, cursor - current_line);
// Complete an LLDB command if the first character is a colon...
if (!line.empty() && line[0] == ':')
{
Debugger &debugger = m_target.GetDebugger();
// auto complete LLDB commands
const char *lldb_current_line = line.substr(1).data();
return debugger.GetCommandInterpreter().HandleCompletion (lldb_current_line,
cursor,
last_char,
skip_first_n_matches,
max_matches,
matches);
}
// Strip spaces from the line and see if we had only spaces
line = line.ltrim();
if (line.empty())
{
// Only spaces on this line, so just indent
matches.AppendString(m_indent_str);
return 1;
}
std::string current_code;
current_code.append(m_code.CopyList());
IOHandlerEditline &editline = static_cast<IOHandlerEditline &>(io_handler);
const StringList *current_lines = editline.GetCurrentLines();
if (current_lines)
{
const uint32_t current_line_idx = editline.GetCurrentLineIndex();
if (current_line_idx < current_lines->GetSize())
{
for (uint32_t i=0; i<current_line_idx; ++i)
{
const char *line_cstr = current_lines->GetStringAtIndex(i);
if (line_cstr)
{
current_code.append("\n");
current_code.append (line_cstr);
}
}
}
}
if (cursor > current_line)
{
current_code.append("\n");
current_code.append(current_line, cursor - current_line);
}
return CompleteCode(current_code, matches);
}
bool
QuitCommandOverrideCallback(void *baton, const char **argv)
{
Target *target = (Target *)baton;
lldb::ProcessSP process_sp (target->GetProcessSP());
if (process_sp)
{
process_sp->Destroy(false);
process_sp->GetTarget().GetDebugger().ClearIOHandlers();
}
return false;
}
Error
REPL::RunLoop ()
{
Error error;
error = DoInitialization();
m_repl_source_path = GetSourcePath();
if (!error.Success())
return error;
Debugger &debugger = m_target.GetDebugger();
lldb::IOHandlerSP io_handler_sp (GetIOHandler());
FileSpec save_default_file;
uint32_t save_default_line = 0;
if (!m_repl_source_path.empty())
{
// Save the current default file and line
m_target.GetSourceManager().GetDefaultFileAndLine(save_default_file, save_default_line);
}
debugger.PushIOHandler(io_handler_sp);
// Check if we are in dedicated REPL mode where LLDB was start with the "--repl" option
// from the command line. Currently we know this by checking if the debugger already
// has a IOHandler thread.
if (!debugger.HasIOHandlerThread())
{
// The debugger doesn't have an existing IOHandler thread, so this must be
// dedicated REPL mode...
m_dedicated_repl_mode = true;
debugger.StartIOHandlerThread();
std::string command_name_str ("quit");
CommandObject *cmd_obj = debugger.GetCommandInterpreter().GetCommandObjectForCommand(command_name_str);
if (cmd_obj)
{
assert(command_name_str.empty());
cmd_obj->SetOverrideCallback (QuitCommandOverrideCallback, &m_target);
}
}
// Wait for the REPL command interpreter to get popped
io_handler_sp->WaitForPop();
if (m_dedicated_repl_mode)
{
// If we were in dedicated REPL mode we would have started the
// IOHandler thread, and we should kill our process
lldb::ProcessSP process_sp = m_target.GetProcessSP();
if (process_sp && process_sp->IsAlive())
process_sp->Destroy(false);
// Wait for the IO handler thread to exit (TODO: don't do this if the IO handler thread already exists...)
debugger.JoinIOHandlerThread();
}
// Restore the default file and line
if (save_default_file && save_default_line != 0)
m_target.GetSourceManager().SetDefaultFileAndLine(save_default_file, save_default_line);
return error;
}
Reference in New Issue View Git Blame Copy Permalink